pax_global_header00006660000000000000000000000064130252653660014522gustar00rootroot0000000000000052 comment=985ce44e73a0f1e6542fe959036f3bba65bc7a16 scanmem-0.16/000077500000000000000000000000001302526536600130735ustar00rootroot00000000000000scanmem-0.16/.gitignore000066400000000000000000000013271302526536600150660ustar00rootroot00000000000000# Compiled program /scanmem # Auto-generated files *.o *.lo *.la .deps .libs m4 autom4te.cache config.h* configure Makefile Makefile.in aclocal.m4 compile config.guess config.log config.status config.sub depcomp install-sh libtool ltmain.sh missing py-compile stamp-h1 tags # GameConqueror gui/GameConqueror.appdata.xml gui/GameConqueror.desktop gui/consts.py gui/*.pyc gui/*.pyo gui/__pycache__ gui/gameconqueror gui/org.freedesktop.gameconqueror.policy gui/org.freedesktop.gameconqueror.policy.in # Translations po/.intltool-merge-cache po/GameConqueror.pot po/Makefile.in.in po/POTFILES po/ja.gmo po/ru.gmo po/stamp-it # Android builds # libreadline and ncurses downloads and links readline-* ncurses-* readline ncurses scanmem-0.16/COPYING000066400000000000000000001045131302526536600141320ustar00rootroot00000000000000 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 . scanmem-0.16/ChangeLog000066400000000000000000000172751302526536600146610ustar00rootroot000000000000002016-04-28 Sebastian Parschauer * See https://github.com/scanmem/scanmem/releases for new releases 2012-03-26 WANG Lu * Fix for '!=' as 'not equal to' * Typo * Option 'dump_with_ascii' added (Thanks to sec) 2011-12-16 WANG Lu * Support wildcards when writing bytearrays [Thanks to Incarus6] * Delete an item upon DELETE key is pressed * Copy address & cheatlist reorderable 2011-08-16 WANG Lu * Fix freeze after switching the target process 2011-08-15 WANG Lu * Improve the process selection dialog * Make tooltip for the 'Value' label more obvious 2011-08-02 WANG Lu * Fix memory browser 2011-07-08 WANG Lu * Fix manpage * Fix process list displaying (Issue 26) 2011-03-14 WANG Lu * Ignore empty input at cheatlist * Process list dialog is resizable 2011-01-13 WANG Lu * Run as root * Skip when readlink on /proc/pid/exe fails * Added a script for building packages for PPA 2011-01-12 WANG Lu * Using pager when showing help messages 2011-01-11 WANG Lu * Check version of scanmem right after GameConqueror starts 2010-09-19 WANG Lu * Fixed memory leak * Set monospace font to the lists * Fixed value parsing for strings 2010-05-22 Wang Lu * Fixed `set' command 2010-05-16 Wang Lu * Fixed build on FreeBSD * Bug fixed: freezing when scanning multiple variables 2010-04-28 Wang Lu * Bug fixed: dump_to_file [Thanks to Bryan Cain] * Manually add a cheat entry * Update values in the lists 2010-01-19 WANG Lu * Bug fixed: read /proc//mem on 32bit machines * Bug fixed: scan for double variables on 32bit machines * a little improvement on peekbuf * Better communication, replace readline with printf when running as backend * `scan for address` supported 2010-01-16 WANG Lu * Memory Editor * Fix copyright strings (again) * new 'dump' command 2010-01-12 WANG Lu * Bugs fixed * Better DEFAULT_LONGDOC * Better GUI * Better communication between GUI & backend * Progress bar in GUI * Several other UI improvement 2010-01-10 WANG Lu * STRING supported * Fixed a bug relacted to match_flag, now match_flags seems to be `dangerous` since I made it a union now. * Fixed a memory bug in target_memory_info_array.c 2010-01-09 WANG Lu * BYTEARRAY supported, oh yeah 2010-01-07 WANG Lu * Added uservalue_t and clean up some value_t, this make it more flexible, and make it possible to support more data types and even user-specific scan routine * in scan routines old_value and user_value are both provided * clean up MATCHES_AND_VALUES stuff, since currently we don't use MATCHES or VALUES * removed snapshot and use MATCHANY instead, such that this can be used to filter out data types * now user can provide float numbers * INCREASEDBY and DECREASEDBY support 2010-01-06 WANG Lu * Fixed detection of reverse change, but it's now working partially, see comments in `help option` * MATCHANY can be used to filter out types now * GREATERTHAN & LESSTHAN supported 2010-01-03 WANG Lu * better GUI * support scanning for a speicific type of data * autotools-ized gui * added an option to determine which regions to be searched 2009-12-20 WANG Lu * basic float/double support * fixed a peek buffer bug, that the buffer is not shifted correctly * change format of some commands for the front-end * added a new 'write' command * fixed a data overwritten issue (Issue 1) xxxx-xx-xx Tavis Ormandy * fixed infinite loop if a command was just leading whitespace. * add message to configure script about `libreadline-dev` package. * correct some typos reported by debian. 2007-06-07 Tavis Ormandy * make license clearer, added gpl notice to all source files, and added a show command. - eg, show copying, show warranty, etc. * handle unspecified value in set properly, eg set /4 * autotooled the build process. * fixed bug where unaligned variables might be missed at end of region. * begin testsuite using dejagnu, to help prevent any regressions in future. * use /proc/pid/mem if available. 2007-04-08 Tavis Ormandy * corrected lots of lint errors. * include copy of GPL in COPYING file. * use more EXPECT(). * fixed two memory leaks (very small). * much more scalable commandline parsing, simple switch/case was getting too unwieldy. * deprecated cont command, and re-wrote set to make it much more powerful. - use set x/y instead of cont, cont will print a warning if you try to use it. * preliminary support for float type (WARNING: experimental) * implemented simple custom completer for readline, so tab completion now works for commands. - arguments will work with completion in next version. * massive improvements to online help, each command can register its own documentation. - example : `help set` will now print detailed usage information. * added quick shell escape support (shell command). * added interrupt support to commands that continue until stopped. * changed the format of list output, which now has a set of flags that represent the possible formats that this variable could be, eg 'CSi' means could be a char or a short, but cant be an int. * new command `watch` that monitors how a variable changes. * updated manual 2007-03-04 Tavis Ormandy * buffered overlapping peeks to improve scan performance. * automatically support chars, shorts and ints. - removed width command * pid command can change target. * = command, to accompany < and > to indicate variable has not changed. * snapshot command to enhance <, > and =. WARNING: experimental, very inefficient. - snapshot will use a more efficient format next version, right now it should not be used on large programs, or will eat all your free memory. 2007-01-11 Tavis Ormandy * cleaned up some lintian errors * used __builtin_expect() to try to improve performance in some areas * minor UI tweaks, give region counts during scan. * start using readline(), should implement completion at some point. * fixed memory leak. 2006-11-16 Tavis Ormandy * Made buffer management more intelligent. * Add commands to list and delete regions (lregions, dregion). * Add commands to indicate variable has increased or decreased (<, >). * Improved usability of set, cont, list, etc. * Add progress meter, large programs can take a long time for initial scan. * Testing support for variable width targets, signedness not currenlty handled. * delete command to eliminate matches. * list command now shows where a variable is located. * General code cleanup. * Eliminate useless command line options, use interactive versions instead. * Improved documentation. 2006-11-14 Tavis Ormandy * Applied patch from Brian Lewis * Install signal handler to detach from target on sigint/sighup/sigquit. * Improved Makefile * Added initial man page 2006-11-13 Tavis Ormandy * Initial version scanmem-0.16/Makefile.am000066400000000000000000000017101302526536600151260ustar00rootroot00000000000000ACLOCAL_AMFLAGS = -I m4 SUBDIRS = po if ENABLE_GUI SUBDIRS += gui endif AM_CFLAGS = -O2 -g -Wall lib_LTLIBRARIES = libscanmem.la libscanmem_la_includedir = $(includedir)/scanmem libscanmem_la_include_HEADERS = commands.h \ list.h \ maps.h \ scanmem.h \ scanroutines.h \ show_message.h \ targetmem.h \ value.h libscanmem_la_SOURCES = commands.c \ ptrace.c \ menu.c \ handlers.h \ handlers.c \ interrupt.h \ list.c \ licence.h \ maps.c \ scanmem.c \ scanroutines.c \ show_message.c \ targetmem.c \ value.c if !HAVE_GETLINE libscanmem_la_SOURCES += getline.h \ getline.c endif if !WITH_READLINE libscanmem_la_SOURCES += readline.h \ readline.c endif libscanmem_la_LDFLAGS = -version-info 1:0:0 bin_PROGRAMS = scanmem scanmem_SOURCES = main.c scanmem_LDADD = libscanmem.la dist_man_MANS = scanmem.1 dist_doc_DATA = README EXTRA_DIST = gpl-3.0.txt lgpl-3.0.txt scanmem-0.16/NEWS000066400000000000000000000000721302526536600135710ustar00rootroot00000000000000See https://github.com/scanmem/scanmem/releases for news. scanmem-0.16/README000066400000000000000000000041341302526536600137550ustar00rootroot00000000000000# ![](https://raw.githubusercontent.com/scanmem/scanmem/master/gui/GameConqueror_72x72.png)scanmem & GameConqueror scanmem is a debugging utility designed to isolate the address of an arbitrary variable in an executing process. scanmem simply needs to be told the pid of the process and the value of the variable at several different times. After several scans of the process, scanmem isolates the position of the variable and allows you to modify its value. ## GUI GameConqueror is a GUI front-end for scanmem, providing more features, such as: * Flexible syntax for searching * Easier and multiple variable locking * Better process finder * Memory browser/editor See [gui/README](gui/README) for more details. ## Requirements scanmem requires libreadline to read commands interactively, and `/proc` must be mounted. GameConqueror requirements are documented in [gui/README](gui/README). ## Documentation To read documentation: * `man scanmem` * `man gameconqueror` * `scanmem --help` * enter `help` at the scanmem prompt * use the interactive help of GameConqueror ## Build Requirements The build requires autotools-dev (autoconf, automake, etc.), libtool, libreadline-dev, intltool and python. ## Build and Install To generate files required for the build: ./autogen.sh To build with GUI: ./configure --prefix=/usr --enable-gui && make sudo make install To build without GUI: ./configure --prefix=/usr && make sudo make install If you want to specify a prefix other than `/usr`, make sure that `/lib` and `/lib64` are in an ld.so config file (`.conf`) in `/etc/ld.so.conf.d/`. See `man ld.so`. Run `sudo ldconfig` after the first install to update the ld.so cache. Otherwise, libscanmem can't be found. Run `./configure --help` for more details. ## Android Build You need a [standalone toolchain of Android NDK] (https://developer.android.com/ndk/guides/standalone_toolchain.html#itc) (Advanced method) to build interactive capabilities for Android. For more information, run: ./build_for_android.sh help ## License: GPLv3, LGPLv3 for libscanmem scanmem-0.16/README.md000077700000000000000000000000001302526536600152252READMEustar00rootroot00000000000000scanmem-0.16/TODO000066400000000000000000000010241302526536600135600ustar00rootroot00000000000000Current ======= * option: whether to search in readonly regions * bytearray flag check (truncval_to_flags, checkmatches, update command for bytearray&string) * see: https://github.com/scanmem/scanmem/issues for further TODOs Future ====== * use PT_IO on freebsd, instead of PT_READ/WRITE_D * add working freebsd support * in target_memory_info_array.c, need check return value of allocate_enough_to_reach everywhere * search for values in files? (eg saved state) * macro support * automatically support zero and one based values. scanmem-0.16/autogen.sh000077500000000000000000000016011302526536600150720ustar00rootroot00000000000000#!/bin/sh LIBTOOLIZE=libtoolize if [ "$(uname -s)" = "Darwin" ]; then LIBTOOLIZE=glibtoolize # install via brew fi echo "+ running $LIBTOOLIZE ..." $LIBTOOLIZE -c || { echo echo "$LIBTOOLIZE failed - check that it is present on system" exit 1 } echo "+ running aclocal ..." aclocal -I m4 || { echo echo "aclocal failed - check that all needed development files"\ "are present on system" exit 1 } echo "+ running autoheader ... " autoheader || { echo echo "autoheader failed" exit 1 } echo "+ running autoconf ... " autoconf || { echo echo "autoconf failed" exit 1 } echo "+ running intltoolize ..." intltoolize -f -c --automake || { echo echo "intltoolize failed - check that it is present on system" exit 1 } echo "+ running automake ... " automake -c --add-missing || { echo echo "automake failed" exit 1 } scanmem-0.16/build_for_android.sh000077500000000000000000000124401302526536600171000ustar00rootroot00000000000000#!/bin/sh if [ "x$1" = "x--help" ] || [ "x$1" = "xhelp" ] || [ "x$1" = "x-h" ]; then echo " ## Before building: # Run autogen.sh if \"./configure\" does not exist. # From scanmem source directory ./autogen.sh ## For libreadline support: # HOST is the compiler architecture for your toolchain and Android # device. (e.g. arm-linux-androideabi) # NDK_STANDALONE_TOOLCHAIN is the directory of your NDK standalone # toolchain. # Install libreadline to your NDK sysroot. # From libreadline source directory, execute: export PATH=\"\$NDK_STANDALONE_TOOLCHAIN/bin:\$PATH\" bash_cv_wcwidth_broken=false ./configure --host=\"\$HOST\" \\ --disable-shared --enable-static \\ --prefix=\"\$NDK_STANDALONE_TOOLCHAIN/sysroot/usr\" make make install # Install ncurses to your NDK sysgen. # From ncurses source directory, execute: export PATH=\"\$NDK_STANDALONE_TOOLCHAIN/bin:\$PATH\" ac_cv_header_locale_h=no ./configure --host=\"\$HOST\" \\ --disable-shared --enable-static \\ --prefix=\"\$NDK_STANDALONE_TOOLCHAIN/sysroot/usr\" make make install ## Building for Android 5.0 and above requires exporting PIE flags, such as: export CFLAGS="-fPIE" LDFLAGS="-pie" ## To build with standalone toolchain: export NDK_STANDALONE_TOOLCHAIN=\"/your/toolchain/path\" export HOST=\"your-androideabi\" # Default arm-linux-androideabi ./build_for_android.sh ## Advanced features and Environment variables that may be set... NDK_STANDALONE_TOOLCHAIN - A standalone toolchain is required to build full capabilities. HOST - Compiler architecture that will be used for cross-compiling, default is arm-linux-androideabi SCANMEM_HOME - Path which has scanmem sources, and will be used to build scanmem. Default current directory LIBREADLINE_DIR - Path which has libreadline sources to build automatically. Default is to download sources NCURSES_DIR - Path which has ncurses sources to build automatically. Default is to download sources " exit 0 fi # Resolve ndk toolchain or other if [ "x${NDK_STANDALONE_TOOLCHAIN}" = "x" ]; then echo "NDK_STANDALONE_TOOLCHAIN was not found. Please enter the toolchain path:" read NDK_STANDALONE_TOOLCHAIN # Nothing entered if [ "x${NDK_STANDALONE_TOOLCHAIN}" = "x" ]; then echo "Error: Please set \$NDK_STANDALONE_TOOLCHAIN env variable." 1>&2 exit 1 fi fi export SYSROOT="${NDK_STANDALONE_TOOLCHAIN}/sysroot" export PATH="${NDK_STANDALONE_TOOLCHAIN}/bin:${PATH}" # Host architecture if [ "x${HOST}" = "x" ]; then HOST=arm-linux-androideabi echo "Env variable \$HOST, host architecture, is not specified. Defaulting to ${HOST}" fi # Build and return directory if [ "x${SCANMEM_HOME}" = "x" ]; then export SCANMEM_HOME="$(pwd)" else cd "${SCANMEM_HOME}" fi # Processor count for make instructions procnum="$(getconf _NPROCESSORS_ONLN)" if [ "x${procnum}" = "x" ] || [ $procnum -eq 0 ]; then procnum=1 fi # Do not fail for source downloads, workarounds may be found for broken links if [ ! -f "${SYSROOT}/usr/lib/libreadline.a" ]; then # Build libreadline for android if [ "x${LIBREADLINE_DIR}" = "x" ]; then echo "LIBREADLINE_DIR was not found. Please enter the path where libreadline source is located, or press enter to try a source download:" read LIBREADLINE_DIR if [ "x${LIBREADLINE_DIR}" = "x" ]; then echo "Downloading libreadline..." if [ ! -f readline-6.3.tar.gz ]; then wget -c ftp://ftp.gnu.org/gnu/readline/readline-6.3.tar.gz fi tar xvf readline-6.3.tar.gz export LIBREADLINE_DIR="$(pwd)/readline-6.3" fi fi cd "${LIBREADLINE_DIR}" bash_cv_wcwidth_broken=false ./configure --host="${HOST}" \ --disable-shared --enable-static --prefix="${SYSROOT}/usr" make -j ${procnum} make install cd "${SCANMEM_HOME}" # To make sure headers can be found if [ ! -f readline ]; then ln -s "${LIBREADLINE_DIR}" readline fi fi # ncurses, same logic as libreadline if [ ! -f "${SYSROOT}/usr/lib/libncurses.a" ]; then # Build libncurses for android (needed by libreadline) if [ "x${NCURSES_DIR}" = "x" ]; then echo "NCURSES_DIR was not found. Please enter the path where ncurses source is located, or press enter to try a source download:" read NCURSES_DIR if [ "x${NCURSES_DIR}" = "x" ]; then echo "Downloading ncurses..." if [ ! -f ncurses-6.0.tar.gz ]; then wget -c http://invisible-mirror.net/archives/ncurses/ncurses-6.0.tar.gz fi tar xvf ncurses-6.0.tar.gz export NCURSES_DIR="$(pwd)/ncurses-6.0" fi fi cd "${NCURSES_DIR}" ac_cv_header_locale_h=no ./configure --host="${HOST}" \ --disable-shared --enable-static --prefix="${SYSROOT}/usr" make -j ${procnum} make install cd "${SCANMEM_HOME}" # To make sure headers can be found if [ ! -f ncurses ]; then ln -s "${NCURSES_DIR}" ncurses fi fi # Build scanmem for android if [ "$(uname -s)" = "Darwin" ]; then PATH=/usr/local/opt/gettext/bin:${PATH} # brew install gettext fi LIBS="-lncurses -lm" ./configure --host="${HOST}" --prefix="${SYSROOT}/usr" \ --enable-static --disable-shared [ "$?" != "0" ] && exit 1 make -j ${procnum} && make install scanmem-0.16/commands.c000066400000000000000000000105471302526536600150470ustar00rootroot00000000000000/* Registration and general execution of commands. Copyright (C) 2006,2007,2009 Tavis Ormandy Copyright (C) 2009 Eli Dupree Copyright (C) 2009,2010 WANG Lu This file is part of libscanmem. This library is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this library. If not, see . */ #ifndef _GNU_SOURCE # define _GNU_SOURCE #endif #include "config.h" #include #include #include #include #include #include #include #include #include "commands.h" #include "show_message.h" /* * sm_registercommand - add the command and a pointer to its handler to the commands list. * * so that free(data) works when destroying the list, I just concatenate the string * with the command structure. I could have used a static vector of commands, but this * way I can add aliases and macros at runtime (planned in future). * */ bool sm_registercommand(const char *command, void *handler, list_t *commands, char *shortdoc, char *longdoc) { command_t *data; assert(commands != NULL); if (command != NULL) { if ((data = malloc(sizeof(command_t) + strlen(command) + 1)) == NULL) { show_error("sorry, there was a memory allocation problem.\n"); return false; } data->command = (char *) data + sizeof(*data); /* command points to the extra space allocated after data */ strcpy(data->command, command); } else { if ((data = malloc(sizeof(command_t))) == NULL) { show_error("sorry, there was a memory allocation problem.\n"); return false; } data->command = NULL; } data->handler = handler; data->shortdoc = shortdoc; data->longdoc = longdoc; /* add new command to list */ if (l_append(commands, NULL, data) == -1) { free(data); return false; } return true; } bool sm_execcommand(globals_t *vars, const char *commandline) { unsigned argc; char *str = NULL, *tok = NULL; char **argv = NULL; command_t *err = NULL; bool ret = false; list_t *commands = vars->commands; element_t *np = NULL; assert(commandline != NULL); assert(commands != NULL); vars->current_cmdline = commandline; np = commands->head; str = tok = strdupa(commandline); /* tokenize command line into an argument vector */ for (argc = 0; tok; argc++, str = NULL) { /* make enough size for another pointer (+1 for NULL at end) */ if ((argv = realloc(argv, (argc + 1) * sizeof(char *))) == NULL) { show_error("sorry there was a memory allocation error.\n"); return false; } /* insert next token */ argv[argc] = tok = strtok(str, " \t"); } assert(argc >= 1); assert(argv != NULL); /* just leading whitespace? */ if (argv[0] == NULL) { free(argv); /* legal i guess, just dont do anything */ return true; } /* search commands list for appropriate handler */ while (np) { command_t *command = np->data; /* check if this command matches */ if (command->command == NULL) { /* the default handler has a NULL command */ err = command; } else if (strcasecmp(argv[0], command->command) == 0) { /* match found, execute handler */ ret = command->handler(vars, argv, argc - 1); free(argv); return ret; } np = np->next; } /* no match, if there was a default handler found, run it now */ if (err != NULL) { ret = err->handler(vars, argv, argc - 1); } free(argv); return ret; } scanmem-0.16/commands.h000066400000000000000000000023211302526536600150430ustar00rootroot00000000000000/* Registration and general execution of commands. This file is part of libscanmem. This library is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this library. If not, see . */ #ifndef COMMANDS_H #define COMMANDS_H #include #include "scanmem.h" typedef struct { bool (*handler)(globals_t *vars, char **argv, unsigned argc); char *command; char *shortdoc; char *longdoc; } command_t; bool sm_registercommand(const char *command, void *handler, list_t *commands, char *shortdoc, char *longdoc); bool sm_execcommand(globals_t *vars, const char *commandline); #endif /* COMMANDS_H */ scanmem-0.16/configure.ac000066400000000000000000000107501302526536600153640ustar00rootroot00000000000000AC_INIT([scanmem],[0.16],[https://github.com/scanmem/scanmem]) AC_CONFIG_MACRO_DIR([m4]) AM_INIT_AUTOMAKE([-Wall -Werror -Wno-extra-portability foreign]) AC_CONFIG_SRCDIR([main.c]) AC_CONFIG_HEADER([config.h]) AC_USE_SYSTEM_EXTENSIONS AC_HEADER_STDBOOL LT_INIT IT_PROG_INTLTOOL AC_CHECK_FUNCS(memset strcasecmp strchr strdup strerror strtoul getline) if test "x$ac_cv_func_getline" = "xno"; then AC_CHECK_FUNCS(fgetln) if test "x$ac_cv_func_fgetln" = "xno"; then AC_MSG_ERROR([Cannot build without working getline().]) else AC_MSG_NOTICE([Using the fgetln()-based getline() replacement.]) fi fi AM_CONDITIONAL([HAVE_GETLINE], [test "x$ac_cv_func_getline" != "xno"]) AC_CHECK_HEADERS(fcntl.h limits.h stddef.h sys/time.h) AC_FUNC_ALLOCA AC_FUNC_STRTOD AC_TYPE_INT8_T AC_TYPE_INT16_T AC_TYPE_INT32_T AC_TYPE_INT64_T AC_TYPE_UINT8_T AC_TYPE_UINT16_T AC_TYPE_UINT32_T AC_TYPE_UINT64_T AC_TYPE_OFF_T AC_TYPE_PID_T AC_TYPE_SIZE_T AC_TYPE_SSIZE_T AC_C_BIGENDIAN # Detect the host OS android="no" AC_CANONICAL_HOST case "$host_os" in *android*) android="yes" AC_MSG_NOTICE([Android detected]) ;; linux*) AC_MSG_NOTICE([Linux detected]) ;; *) AC_MSG_NOTICE([Your platform is not currently supported]) ;; esac AS_IF([test "x$android" = "xno"], [ # also need to check if the file is zero'ed (some hardened systems) AC_CHECK_FILE([/proc/self/maps], [], [ echo "This system does not seem to have /proc/pid/maps files." exit 1 ]) # also need to check this file works AC_CHECK_FILE([/proc/self/mem], [ # LARGEFILE support required for this to work AC_SYS_LARGEFILE AC_DEFINE(HAVE_PROCMEM, [1], [Enable /proc/pid/mem support]) ],[ # This will hurt performance. echo "This system does not seem to have /proc/pid/mem files." echo "Falling back to ptrace() only support." AC_DEFINE(HAVE_PROCMEM, [0], [Enable /proc/pid/mem support]) ]) # malloc optimizations without Android AC_FUNC_MALLOC AC_FUNC_REALLOC ], [ # supported on Android AC_SYS_LARGEFILE # /proc/pid/mem is there but reading interesting data fails AC_DEFINE(HAVE_PROCMEM, [0], [Enable /proc/pid/mem support]) ]) # copied from ubuntu-tweak dnl AS_AC_EXPAND(VAR, CONFIGURE_VAR) dnl dnl example dnl AS_AC_EXPAND(SYSCONFDIR, $sysconfdir) dnl will set SYSCONFDIR to /usr/local/etc if prefix=/usr/local AC_DEFUN([AS_AC_EXPAND], [ EXP_VAR=[$1] FROM_VAR=[$2] dnl first expand prefix and exec_prefix if necessary prefix_save=$prefix exec_prefix_save=$exec_prefix dnl if no prefix given, then use /usr/local, the default prefix if test "x$prefix" = "xNONE"; then prefix=$ac_default_prefix fi dnl if no exec_prefix given, then use prefix if test "x$exec_prefix" = "xNONE"; then exec_prefix=$prefix fi full_var="$FROM_VAR" dnl loop until it doesn't change anymore while true; do new_full_var="`eval echo $full_var`" if test "x$new_full_var" = "x$full_var"; then break; fi full_var=$new_full_var done dnl clean up full_var=$new_full_var AC_SUBST([$1], "$full_var") dnl restore prefix and exec_prefix prefix=$prefix_save exec_prefix=$exec_prefix_save ]) # end copy AS_AC_EXPAND(PKGDATADIR, $datadir/gameconqueror) AS_AC_EXPAND(LIBDIR, $libdir) GETTEXT_PACKAGE=GameConqueror AC_SUBST(GETTEXT_PACKAGE) AC_DEFINE_UNQUOTED([GETTEXT_PACKAGE], ["$GETTEXT_PACKAGE"], [The domain to use with gettext]) AS_AC_EXPAND(LOCALEDIR, $localedir) AC_CONFIG_FILES([ Makefile po/Makefile.in ]) AC_ARG_ENABLE(gui, [AS_HELP_STRING([--enable-gui], [enable gameconqueror, the gui front-end of scanmem])]) AM_CONDITIONAL([ENABLE_GUI], [test "x$enable_gui" = "xyes"]) AS_IF([test "x$enable_gui" = "xyes"], [ AM_PATH_PYTHON([2.7]) AC_CONFIG_FILES([ gui/Makefile gui/icons/Makefile gui/consts.py gui/gameconqueror gui/org.freedesktop.gameconqueror.policy.in ]) ]) # Check for termcap and readline or bypass checking for the libraries. AC_ARG_WITH([readline], [AS_HELP_STRING([--without-readline], [build without readline])]) AM_CONDITIONAL([WITH_READLINE], [test "x$with_readline" != "xno"]) AS_IF([test "x$with_readline" != "xno"], [ # termcap is sometimes required by readline AC_CHECK_LIB([termcap], [tgetent], [], []) AC_CHECK_LIB([readline], [readline], [], [ echo "libreadline could not be found, which is required to continue." echo "The libreadline-dev package may be required." exit 1 ]) ]) AC_OUTPUT scanmem-0.16/endianness.h000066400000000000000000000053451302526536600154020ustar00rootroot00000000000000/* Endianness conversion. Copyright (C) 2014 Hraban Luyat Copyright (C) 2015 Sebastian Parschauer This file is part of libscanmem. This library is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this library. If not, see . */ #ifndef ENDIANNESS_H #define ENDIANNESS_H #include #include #include #include #include "scanmem.h" #include "value.h" #include "config.h" /* True if host is big endian */ #ifdef WORDS_BIGENDIAN static const bool big_endian = true; #else static const bool big_endian = false; #endif static inline uint16_t swap_bytes16(uint16_t i) { uint16_t res = i & 0xff; res <<= 8; res |= i >> 8; return res; } static inline uint32_t swap_bytes32(uint32_t i) { uint32_t res = swap_bytes16(i); res <<= 16; res |= swap_bytes16(i >> 16); return res; } static inline uint64_t swap_bytes64(uint64_t i) { uint64_t res = swap_bytes32(i); res <<= 32; res |= swap_bytes32(i >> 32); return res; } // swap endianness of 2, 4 or 8 byte word in-place. static inline void swap_bytes_var(void *p, size_t num) { switch (num) { case sizeof(uint16_t): ; // empty statement to cheat the compiler uint16_t i16 = swap_bytes16(*((uint16_t *)p)); memcpy(p, &i16, sizeof(uint16_t)); return; case sizeof(uint32_t): ; uint32_t i32 = swap_bytes32(*((uint32_t *)p)); memcpy(p, &i32, sizeof(uint32_t)); return; case sizeof(uint64_t): ; uint64_t i64 = swap_bytes64(*((uint64_t *)p)); memcpy(p, &i64, sizeof(uint64_t)); return; } assert(false); return; } static inline void fix_endianness(globals_t *vars, value_t *data_value) { if (!vars->options.reverse_endianness) { return; } if (data_value->flags.u64b) { data_value->uint64_value = swap_bytes64(data_value->uint64_value); } else if (data_value->flags.u32b) { data_value->uint32_value = swap_bytes32(data_value->uint32_value); } else if (data_value->flags.u16b) { data_value->uint16_value = swap_bytes16(data_value->uint16_value); } return; } #endif /* ENDIANNESS_H */ scanmem-0.16/getline.c000066400000000000000000000042551302526536600146740ustar00rootroot00000000000000/* Replace getline() with BSD specific fgetln(). Copyright (C) 2015 JianXiong Zhou Copyright (C) 2015 Jonathan Pelletier This file is part of libscanmem. This library is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this library. If not, see . */ #include "getline.h" #if !defined(HAVE_GETLINE) && defined(HAVE_FGETLN) #include #include #include /* * Avoid frequent malloc()/free() calls * (determined by getline() test on Linux) */ #define BUF_MIN 120 ssize_t getline(char **lineptr, size_t *n, FILE *stream) { char *lptr; size_t len = 0; /* Check for invalid arguments */ if (lineptr == NULL || n == NULL) { errno = EINVAL; return -1; } lptr = fgetln(stream, &len); if (lptr == NULL) { /* Invalid stream */ errno = EINVAL; return -1; } /* * getline() returns a null byte ('\0') terminated C string * but fgetln() returns characters without '\0' termination */ if (*lineptr == NULL) { *n = BUF_MIN; goto alloc_buf; } /* Realloc the original pointer */ if (*n < len + 1) { free(*lineptr); *n = len + 1; alloc_buf: *lineptr = malloc(*n); if (*lineptr == NULL) { *n = 0; return -1; } } /* Copy over the string */ memcpy(*lineptr, lptr, len); (*lineptr)[len] = '\0'; /* * getline() and fgetln() both return len including the * delimiter but without the null byte at the end */ return len; } #endif scanmem-0.16/getline.h000066400000000000000000000021011302526536600146650ustar00rootroot00000000000000/* Replace getline() with BSD specific fgetln(). Copyright (C) 2015 JianXiong Zhou Copyright (C) 2015 Jonathan Pelletier This file is part of libscanmem. This library is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this library. If not, see . */ #ifndef GETLINE_H #define GETLINE_H #include "config.h" #ifndef HAVE_GETLINE #include ssize_t getline(char **lineptr, size_t *n, FILE *stream); #endif #endif /* GETLINE_H */ scanmem-0.16/gpl-3.0.txt000066400000000000000000001045131302526536600147200ustar00rootroot00000000000000 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 . scanmem-0.16/gui/000077500000000000000000000000001302526536600136575ustar00rootroot00000000000000scanmem-0.16/gui/COPYING000066400000000000000000001045131302526536600147160ustar00rootroot00000000000000 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 . scanmem-0.16/gui/GameConqueror.appdata.xml.in000066400000000000000000000024151302526536600211700ustar00rootroot00000000000000 GameConqueror.desktop CC0-1.0 GPL-3.0+ <_name>Game Conqueror <_summary>Game hacking tool. GUI front-end for scanmem. <_p> scanmem is a simple interactive debugging utility, used to locate the address of a variable in an executing process. This can be used for the analysis or modification of a hostile process on a compromised machine, reverse engineering, or as a "pokefinder" to cheat at video games. GameConqueror aims to provide a CheatEngine-alike interface for scanmem, it's user-friendly and easy to use. <_p>Features:
    <_li>Locking on multiple variables <_li>Memory Viewer/Editor <_li>... many to be done
https://raw.githubusercontent.com/scanmem/scanmem/master/gui/screenshot.png https://github.com/scanmem/scanmem i.gnatenko.brain@gmail.com scanmem-0.16/gui/GameConqueror.desktop.in000066400000000000000000000003311302526536600204230ustar00rootroot00000000000000[Desktop Entry] _Name=Game Conqueror _Comment=A game hacking tool. A GUI front-end for scanmem. Exec=gameconqueror Terminal=false Type=Application Icon=GameConqueror Categories=Development;Utility; StartupNotify=true scanmem-0.16/gui/GameConqueror.py000066400000000000000000001400371302526536600170050ustar00rootroot00000000000000#!/usr/bin/env python """ Game Conqueror: a graphical game cheating tool, using scanmem as its backend Copyright (C) 2009-2011,2013 Wang Lu Copyright (C) 2010 Bryan Cain Copyright (C) 2013 Mattias Muenster Copyright (C) 2014-2016 Sebastian Parschauer Copyright (C) 2016 Andrea Stacchiotti 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 . """ import sys import os import argparse import struct import tempfile import platform import threading import json import gi gi.require_version('Gtk', '3.0') from gi.repository import Gtk from gi.repository import Gdk from gi.repository import GObject from consts import * from hexview import HexView from backend import GameConquerorBackend import misc import locale import gettext # In some locale, ',' is used in float numbers locale.setlocale(locale.LC_NUMERIC, 'C') locale.bindtextdomain(GETTEXT_PACKAGE, LOCALEDIR); gettext.install(GETTEXT_PACKAGE, LOCALEDIR, names=('_')); CLIPBOARD = Gtk.Clipboard.get(Gdk.SELECTION_CLIPBOARD) WORK_DIR = os.path.dirname(sys.argv[0]) PROGRESS_INTERVAL = 100 # for scan progress updates DATA_WORKER_INTERVAL = 500 # for read(update)/write(lock) SCAN_RESULT_LIST_LIMIT = 1000 # maximal number of entries that can be displayed SCAN_VALUE_TYPES = ['int', 'int8', 'int16', 'int32', 'int64', 'float', 'float32', 'float64', 'number', 'bytearray', 'string'] LOCK_FLAG_TYPES = misc.build_simple_str_liststore(['=', '+', '-']) MEMORY_TYPES = ['int8', 'uint8', 'int16', 'uint16', 'int32', 'uint32', 'int64', 'uint64', 'float32', 'float64', 'bytearray', 'string'] SEARCH_SCOPE_NAMES = ['Basic', 'Normal', 'Full'] # convert type names used by scanmem into ours TYPENAMES_S2G = {'I64':'int64' ,'I64s':'int64' ,'I64u':'uint64' ,'I32':'int32' ,'I32s':'int32' ,'I32u':'uint32' ,'I16':'int16' ,'I16s':'int16' ,'I16u':'uint16' ,'I8':'int8' ,'I8s':'int8' ,'I8u':'uint8' ,'F32':'float32' ,'F64':'float64' ,'bytearray':'bytearray' ,'string':'string' } # convert our typenames into struct format characters TYPENAMES_G2STRUCT = {'int8':'b' ,'uint8':'B' ,'int16':'h' ,'uint16':'H' ,'int32':'i' ,'uint32':'I' ,'int64':'q' ,'uint64':'Q' ,'float32':'f' ,'float64':'d' } # sizes in bytes of integer and float types TYPESIZES = {'int8':1 ,'uint8':1 ,'int16':2 ,'uint16':2 ,'int32':4 ,'uint32':4 ,'int64':8 ,'uint64':8 ,'float32':4 ,'float64':8 } class GameConqueror(): def __init__(self): ################################## # init GUI self.builder = Gtk.Builder() self.builder.set_translation_domain(GETTEXT_PACKAGE) self.builder.add_from_file(os.path.join(WORK_DIR, 'GameConqueror.xml')) self.main_window = self.builder.get_object('MainWindow') self.main_window.set_title('GameConqueror %s' % (VERSION,)) self.about_dialog = self.builder.get_object('AboutDialog') # set version self.about_dialog.set_version(VERSION) self.process_list_dialog = self.builder.get_object('ProcessListDialog') self.addcheat_dialog = self.builder.get_object('AddCheatDialog') # init memory editor self.memoryeditor_window = self.builder.get_object('MemoryEditor_Window') self.memoryeditor_hexview = HexView() self.memoryeditor_window.get_child().pack_start(self.memoryeditor_hexview, True, True, 0) self.memoryeditor_hexview.show_all() self.memoryeditor_address_entry = self.builder.get_object('MemoryEditor_Address_Entry') self.memoryeditor_hexview.connect('char-changed', self.memoryeditor_hexview_char_changed_cb) self.found_count_label = self.builder.get_object('FoundCount_Label') self.process_label = self.builder.get_object('Process_Label') self.value_input = self.builder.get_object('Value_Input') self.scanoption_frame = self.builder.get_object('ScanOption_Frame') self.scanprogress_progressbar = self.builder.get_object('ScanProgress_ProgressBar') self.input_box = self.builder.get_object('Value_Input') self.scan_button = self.builder.get_object('Scan_Button') self.reset_button = self.builder.get_object('Reset_Button') self.is_first_scan = True ### # Set scan data type self.scan_data_type_combobox = self.builder.get_object('ScanDataType_ComboBoxText') for entry in SCAN_VALUE_TYPES: self.scan_data_type_combobox.append_text(entry) # apply setting misc.combobox_set_active_item(self.scan_data_type_combobox, SETTINGS['scan_data_type']) ### # set search scope self.search_scope_scale = self.builder.get_object('SearchScope_Scale') # apply setting self.search_scope_scale.set_value(SETTINGS['search_scope']) # init scanresult treeview # we may need a cell data func here # create model self.scanresult_tv = self.builder.get_object('ScanResult_TreeView') # liststore contents: addr, value, type, valid, offset, region type, match_id self.scanresult_liststore = Gtk.ListStore(GObject.TYPE_UINT64, str, str, bool, GObject.TYPE_UINT64, str, int) self.scanresult_tv.set_model(self.scanresult_liststore) self.scanresult_last_clicked = 0 # init columns misc.treeview_append_column(self.scanresult_tv, _('Address'), 0, hex_col=0, attributes=(('text',0),), properties = (('family', 'monospace'),) ) misc.treeview_append_column(self.scanresult_tv, _('Value'), 1, attributes=(('text',1),), properties = (('family', 'monospace'),) ) misc.treeview_append_column(self.scanresult_tv, _('Offset'), 4, hex_col=4, attributes=(('text',4),), properties = (('family', 'monospace'),) ) misc.treeview_append_column(self.scanresult_tv, _('Region Type'), 5, attributes=(('text',5),), properties = (('family', 'monospace'),) ) # init CheatList TreeView self.cheatlist_tv = self.builder.get_object('CheatList_TreeView') # cheatlist contents: lockflag, locked, description, addr, type, value, valid self.cheatlist_liststore = Gtk.ListStore(str, bool, str, GObject.TYPE_UINT64, str, str, bool) self.cheatlist_tv.set_model(self.cheatlist_liststore) self.cheatlist_last_clicked = 0 self.cheatlist_editing = False # Lock Flag misc.treeview_append_column(self.cheatlist_tv, '', 0 ,renderer_class = Gtk.CellRendererCombo ,attributes = (('text',0),) ,properties = (('editable', True) ,('has-entry', False) ,('model', LOCK_FLAG_TYPES) ,('text-column', 0) ) ,signals = (('edited', self.cheatlist_toggle_lock_flag_cb), ('editing-started', self.cheatlist_edit_start), ('editing-canceled', self.cheatlist_edit_cancel),) ) # Lock misc.treeview_append_column(self.cheatlist_tv, _('Lock'), 1 ,renderer_class = Gtk.CellRendererToggle ,attributes = (('active',1),) ,properties = (('activatable', True) ,('radio', False) ,('inconsistent', False)) ,signals = (('toggled', self.cheatlist_toggle_lock_cb),) ) # Description misc.treeview_append_column(self.cheatlist_tv, _('Description'), 2 ,attributes = (('text',2),) ,properties = (('editable', True),) ,signals = (('edited', self.cheatlist_edit_description_cb), ('editing-started', self.cheatlist_edit_start), ('editing-canceled', self.cheatlist_edit_cancel),) ) # Address misc.treeview_append_column(self.cheatlist_tv, _('Address'), 3, hex_col=3 ,attributes = (('text',3),) ,properties = (('family', 'monospace'),) ) # Type misc.treeview_append_column(self.cheatlist_tv, _('Type'), 4 ,renderer_class = Gtk.CellRendererCombo ,attributes = (('text',4),) ,properties = (('editable', True) ,('has-entry', False) ,('model', misc.build_simple_str_liststore(MEMORY_TYPES)) ,('text-column', 0)) ,signals = (('edited', self.cheatlist_edit_type_cb), ('editing-started', self.cheatlist_edit_start), ('editing-canceled', self.cheatlist_edit_cancel),) ) # Value misc.treeview_append_column(self.cheatlist_tv, _('Value'), 5 ,attributes = (('text',5),) ,properties = (('editable', True) ,('family', 'monospace')) ,signals = (('edited', self.cheatlist_edit_value_cb), ('editing-started', self.cheatlist_edit_start), ('editing-canceled', self.cheatlist_edit_cancel),) ) # init ProcessList self.processfilter_input = self.builder.get_object('ProcessFilter_Input') self.userfilter_input = self.builder.get_object('UserFilter_Input') # init ProcessList_TreeView self.processlist_tv = self.builder.get_object('ProcessList_TreeView') self.processlist_liststore = Gtk.ListStore(int, str, str) self.processlist_filter = self.processlist_liststore.filter_new(root=None) self.processlist_filter.set_visible_func(self.processlist_filter_func, data=None) self.processlist_tv.set_model(Gtk.TreeModelSort(self.processlist_filter)) self.processlist_tv.set_search_column(1) # first col misc.treeview_append_column(self.processlist_tv, 'PID', 0 ,attributes = (('text',0),) ) # second col misc.treeview_append_column(self.processlist_tv, _('User'), 1 ,attributes = (('text',1),) ) # third col misc.treeview_append_column(self.processlist_tv, _('Process'), 2 ,attributes = (('text',2),) ) # get list of things to be disabled during scan self.disablelist = [] self.disablelist.append(self.cheatlist_tv) self.disablelist.append(self.scanresult_tv) self.disablelist.append(self.builder.get_object('processGrid')) self.disablelist.append(self.builder.get_object('searchGrid')) self.disablelist.append(self.builder.get_object('buttonGrid')) self.disablelist.append(self.memoryeditor_window) # init AddCheatDialog self.addcheat_address_input = self.builder.get_object('Address_Input') self.addcheat_address_input.override_font(gi.repository.Pango.FontDescription("Monospace")) self.addcheat_description_input = self.builder.get_object('Description_Input') self.addcheat_length_spinbutton = self.builder.get_object('Length_SpinButton') self.addcheat_type_combobox = self.builder.get_object('Type_ComboBoxText') for entry in MEMORY_TYPES: self.addcheat_type_combobox.append_text(entry) misc.combobox_set_active_item(self.addcheat_type_combobox, SETTINGS['lock_data_type']) self.Type_ComboBoxText_changed_cb(self.addcheat_type_combobox) # init popup menu for scanresult self.scanresult_popup = Gtk.Menu() misc.menu_append_item(self.scanresult_popup, _('Add to cheat list'), self.scanresult_popup_cb, 'add_to_cheat_list') misc.menu_append_item(self.scanresult_popup, _('Browse this address'), self.scanresult_popup_cb, 'browse_this_address') misc.menu_append_item(self.scanresult_popup, _('Scan for this address'), self.scanresult_popup_cb, 'scan_for_this_address') misc.menu_append_item(self.scanresult_popup, _('Remove this match'), self.scanresult_delete_selected_matches) self.scanresult_popup.show_all() # init popup menu for cheatlist self.cheatlist_popup = Gtk.Menu() misc.menu_append_item(self.cheatlist_popup, _('Browse this address'), self.cheatlist_popup_cb, 'browse_this_address') misc.menu_append_item(self.cheatlist_popup, _('Copy address'), self.cheatlist_popup_cb, 'copy_address') misc.menu_append_item(self.cheatlist_popup, _('Remove this entry'), self.cheatlist_popup_cb, 'remove_entry') self.cheatlist_popup.show_all() self.builder.connect_signals(self) self.main_window.connect('destroy', self.exit) ########################### # init others (backend, flag...) self.pid = 0 # target pid self.maps = [] self.last_hexedit_address = (0,0) # used for hexview self.is_scanning = False self.exit_flag = False # currently for data_worker only, other 'threads' may also use this flag self.is_data_worker_working = False self.backend = GameConquerorBackend(os.path.join(LIBDIR, 'libscanmem.so.1')) self.check_backend_version() self.search_count = 0 GObject.timeout_add(DATA_WORKER_INTERVAL, self.data_worker) self.command_lock = threading.RLock() ########################### # GUI callbacks # Memory editor def MemoryEditor_Button_clicked_cb(self, button, data=None): if self.pid == 0: self.show_error(_('Please select a process')) return self.browse_memory() return True def MemoryEditor_Address_Entry_activate_cb(self, entry, data=None): txt = self.memoryeditor_address_entry.get_text() if txt == '': return try: addr = int(txt, 16) self.browse_memory(addr) except: self.show_error(_('Invalid address')) def MemoryEditor_JumpTo_Button_clicked_cb(self, button, data=None): txt = self.memoryeditor_address_entry.get_text() if txt == '': return try: addr = int(txt, 16) self.browse_memory(addr) except: self.show_error(_('Invalid address')) # Manually add cheat def ConfirmAddCheat_Button_clicked_cb(self, button, data=None): addr = self.addcheat_address_input.get_text() try: addr = int(addr, 16) except ValueError: self.show_error(_('Please enter a valid address.')) return False description = self.addcheat_description_input.get_text() if not description: description = _('No Description') typestr = self.addcheat_type_combobox.get_active_text() length = self.addcheat_length_spinbutton.get_value_as_int() if 'int' in typestr: value = 0 elif 'float' in typestr: value = 0.0 elif typestr == 'string': value = ' ' * length elif typestr == 'bytearray': value = '00 ' * length else: value = None self.add_to_cheat_list(addr, value, typestr, description) self.addcheat_dialog.hide() return True def CloseAddCheat_Button_clicked_cb(self, button, data=None): self.addcheat_dialog.hide() return True # Main window def ManuallyAddCheat_Button_clicked_cb(self, button, data=None): self.addcheat_dialog.show() return True def RemoveAllCheat_Button_clicked_cb(self, button, data=None): self.cheatlist_liststore.clear() return True def LoadCheat_Button_clicked_cb(self, button, data=None): dialog = Gtk.FileChooserDialog(_("Open.."), self.main_window, Gtk.FileChooserAction.OPEN, (Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL, Gtk.STOCK_OPEN, Gtk.ResponseType.OK)) dialog.set_default_response(Gtk.ResponseType.OK) response = dialog.run() if response == Gtk.ResponseType.OK: try: with open(dialog.get_filename(), 'r') as f: obj = json.load(f) for row in obj['cheat_list']: self.add_to_cheat_list(row[3],row[5],row[4],row[2],True) except: pass dialog.destroy() return True def SaveCheat_Button_clicked_cb(self, button, data=None): dialog = Gtk.FileChooserDialog(_("Save.."), self.main_window, Gtk.FileChooserAction.SAVE, (Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL, Gtk.STOCK_OPEN, Gtk.ResponseType.OK)) dialog.set_default_response(Gtk.ResponseType.OK) dialog.set_do_overwrite_confirmation(True) response = dialog.run() if response == Gtk.ResponseType.OK: try: with open(dialog.get_filename(), 'w') as f: obj = {'cheat_list' : [list(i) for i in self.cheatlist_liststore]} json.dump(obj, f); except: pass dialog.destroy() return True def SearchScope_Scale_format_value_cb(self, scale, value, Data=None): return SEARCH_SCOPE_NAMES[int(value)] def Value_Input_activate_cb(self, entry, data=None): self.do_scan() return True def ScanResult_TreeView_popup_menu_cb(self, widget, data=None): pathlist = self.scanresult_tv.get_selection().get_selected_rows()[1] if len(pathlist): self.scanresult_popup.popup(None, None, None, None, 0, 0) return True return False def ScanResult_TreeView_button_press_event_cb(self, widget, event, data=None): # add to cheat list (model, pathlist) = self.scanresult_tv.get_selection().get_selected_rows() if event.button == 1 and event.get_click_count()[1] > 1: # left double click for path in pathlist: (addr, value, typestr) = model.get(model.get_iter(path), 0, 1, 2) self.add_to_cheat_list(addr, value, typestr) elif event.button == 3: # right click path = self.scanresult_tv.get_path_at_pos(int(event.x),int(event.y)) if path is not None: self.scanresult_popup.popup(None, None, None, None, event.button, event.get_time()) self.scanresult_last_clicked = path[0] return path[0] in pathlist return False def CheatList_TreeView_button_press_event_cb(self, widget, event, data=None): if event.button == 3: # right click pathlist = self.cheatlist_tv.get_selection().get_selected_rows()[1] path = self.cheatlist_tv.get_path_at_pos(int(event.x),int(event.y)) if path is not None: self.cheatlist_popup.popup(None, None, None, None, event.button, event.get_time()) self.cheatlist_last_clicked = path[0] return path[0] in pathlist return False def CheatList_TreeView_popup_menu_cb(self, widget, data=None): pathlist = self.cheatlist_tv.get_selection().get_selected_rows()[1] if len(pathlist): self.cheatlist_popup.popup(None, None, None, None, 0, 0) return True return False def Scan_Button_clicked_cb(self, button, data=None): self.do_scan() return True def Reset_Button_clicked_cb(self, button, data=None): self.reset_scan() return True def Logo_EventBox_button_release_event_cb(self, widget, data=None): self.about_dialog.run() self.about_dialog.hide() return True # Process list def ProcessFilter_Input_changed_cb(self, widget, data=None): self.processlist_filter.refilter() def UserFilter_Input_changed_cb(self, widget, data=None): self.processlist_filter.refilter() def ProcessList_TreeView_row_activated_cb(self, treeview, path, view_column, data=None): (model, iter) = self.processlist_tv.get_selection().get_selected() if iter is not None: (pid, user, process) = model.get(iter, 0, 1, 2) self.select_process(pid, process) self.process_list_dialog.response(Gtk.ResponseType.CANCEL) return True return False def SelectProcess_Button_clicked_cb(self, button, data=None): self.processlist_liststore.clear() pl = self.get_process_list() for p in pl: # self.processlist_liststore.append([p[0], (p[1][:50] if len(p) > 1 else '')]) # limit the length here, otherwise it may crash (why?) self.processlist_liststore.append([p[0], (p[1] if len(p) > 1 else ''),(p[2] if len(p) > 2 else '')]) self.process_list_dialog.show() while True: res = self.process_list_dialog.run() if res == Gtk.ResponseType.OK: # -5 (model, iter) = self.processlist_tv.get_selection().get_selected() if iter is None: self.show_error(_('Please select a process')) continue else: (pid, process) = model.get(iter, 0, 1) self.select_process(pid, process) break else: # for None and Cancel break self.process_list_dialog.hide() return True ####################### # customed callbacks # (i.e. not standard event names are used) # Callback to hide window when 'X' button is pressed def hide_window_on_delete_event_cb(self, widget, event, data=None): widget.hide() return True # Memory editor def memoryeditor_hexview_char_changed_cb(self, hexview, offset, charval): addr = hexview.base_addr + offset self.write_value(addr, 'int8', charval) # return False such that the byte the default handler will be called, and will be displayed correctly return False # Manually add cheat def focus_on_next_widget_cb(self, widget, data=None): widget.get_toplevel().child_focus(Gtk.DirectionType.TAB_FORWARD) return True def Type_ComboBoxText_changed_cb(self, combo_box): data_type = combo_box.get_active_text() if data_type in TYPESIZES: self.addcheat_length_spinbutton.set_value(TYPESIZES[data_type]) self.addcheat_length_spinbutton.set_sensitive(False) else: self.addcheat_length_spinbutton.set_sensitive(True) # Main window def cheatlist_edit_start(self, a, b, c): self.cheatlist_editing = True def cheatlist_edit_cancel(self, a): self.cheatlist_editing = False def scanresult_delete_selected_matches(self, menuitem, data=None): (model, pathlist) = self.scanresult_tv.get_selection().get_selected_rows() match_id_list = [ model.get_value(model.get_iter(path), 6) for path in pathlist ] self.command_lock.acquire() for mid in sorted(match_id_list, reverse=True): # Start from the largest, so no match id gets invalidated self.backend.send_command('delete %d' %(mid,)) self.update_scan_result() self.command_lock.release() def scanresult_popup_cb(self, menuitem, data=None): (model, pathlist) = self.scanresult_tv.get_selection().get_selected_rows() if data == 'add_to_cheat_list': for path in reversed(pathlist): (addr, value, typestr) = model.get(model.get_iter(path), 0, 1, 2) self.add_to_cheat_list(addr, value, typestr) return True addr = model.get_value(model.get_iter(self.scanresult_last_clicked), 0) if data == 'browse_this_address': self.browse_memory(addr) return True elif data == 'scan_for_this_address': self.scan_for_addr(addr) return True return False def ScanResult_TreeView_key_press_event_cb(self, scanresult_tv, event, data=None): keycode = event.keyval pressedkey = Gdk.keyval_name(keycode) if pressedkey == 'Return': (model, pathlist) = self.scanresult_tv.get_selection().get_selected_rows() for path in reversed(pathlist): (addr, value, typestr) = model.get(model.get_iter(path), 0, 1, 2) self.add_to_cheat_list(addr, value, typestr) elif pressedkey in {'Delete', 'BackSpace'}: self.scanresult_delete_selected_matches(None) def CheatList_TreeView_key_press_event_cb(self, cheatlist_tv, event, data=None): keycode = event.keyval pressedkey = Gdk.keyval_name(keycode) if pressedkey in {'Delete', 'BackSpace'}: (model, pathlist) = self.cheatlist_tv.get_selection().get_selected_rows() for path in reversed(pathlist): self.cheatlist_liststore.remove(model.get_iter(path)) def cheatlist_popup_cb(self, menuitem, data=None): self.cheatlist_editing = False (model, pathlist) = self.cheatlist_tv.get_selection().get_selected_rows() if data == 'remove_entry': for path in reversed(pathlist): self.cheatlist_liststore.remove(model.get_iter(path)) return True addr = model.get_value(model.get_iter(self.cheatlist_last_clicked), 3) if data == 'browse_this_address': self.browse_memory(addr) return True elif data == 'copy_address': addr = '%x' %(addr,) CLIPBOARD.set_text(addr, len(addr)) return True return False def cheatlist_toggle_lock(self, row): if self.cheatlist_liststore[row][6]: # valid locked = self.cheatlist_liststore[row][1] locked = not locked self.cheatlist_liststore[row][1] = locked if locked: #TODO: check value(valid number & not overflow), if failed, unlock it and do nothing pass else: #TODO: update its value? pass return True def cheatlist_toggle_lock_cb(self, cellrenderertoggle, row_str, data=None): pathlist = self.cheatlist_tv.get_selection().get_selected_rows()[1] if not row_str: return True cur_row = int(row_str) # check if the current row is part of the selection found = False for path in pathlist: row = path[0] if row == cur_row: found = True break if not found: self.cheatlist_toggle_lock(cur_row) return True # the current row is part of the selection for path in pathlist: row = path[0] self.cheatlist_toggle_lock(row) return True def cheatlist_toggle_lock_flag_cb(self, cell, path, new_text, data=None): self.cheatlist_editing = False # currently only one lock flag is supported return True row = int(path) self.cheatlist_liststore[row][0] = new_text # data_worker will handle this later return True def cheatlist_edit_description_cb(self, cell, path, new_text, data=None): self.cheatlist_editing = False pathlist = self.cheatlist_tv.get_selection().get_selected_rows()[1] for path in pathlist: row = path[0] self.cheatlist_liststore[row][2] = new_text return True def cheatlist_edit_value_cb(self, cell, path, new_text, data=None): self.cheatlist_editing = False # ignore empty value if new_text == '': return True pathlist = self.cheatlist_tv.get_selection().get_selected_rows()[1] for path in pathlist: row = path[0] if not self.cheatlist_liststore[row][6]: #not valid continue self.cheatlist_liststore[row][5] = new_text if self.cheatlist_liststore[row][1]: # locked # data_worker will handle this pass else: (addr, typestr, value) = self.cheatlist_liststore[row][3:6] self.write_value(addr, typestr, value) return True def cheatlist_edit_type_cb(self, cell, path, new_text, data=None): self.cheatlist_editing = False pathlist = self.cheatlist_tv.get_selection().get_selected_rows()[1] for path in pathlist: row = path[0] (addr, typestr, value) = self.cheatlist_liststore[row][3:6] if new_text == typestr: continue if new_text in {'bytearray', 'string'}: self.cheatlist_liststore[row][5] = self.bytes2value(new_text, self.read_memory(addr, self.get_type_size(typestr, value))) self.cheatlist_liststore[row][4] = new_text self.cheatlist_liststore[row][1] = False # unlock return True # Process list def processlist_filter_func(self, model, iter, data=None): (pid, user, process) = model.get(iter, 0, 1, 2) return process is not None and \ process.find(self.processfilter_input.get_text()) != -1 and \ user is not None and \ user.find(self.userfilter_input.get_text()) != -1 ############################ # core functions def show_error(self, msg): dialog = Gtk.MessageDialog(self.main_window ,Gtk.DialogFlags.MODAL ,Gtk.MessageType.ERROR ,Gtk.ButtonsType.OK ,msg) dialog.run() dialog.destroy() # return None if unknown def get_pointer_width(self): bits = platform.architecture()[0] if not bits.endswith('bit'): return None try: bitn = int(bits[:-len('bit')]) if bitn not in {8,16,32,64}: return None else: return bitn except: return None # return the size in bytes of the value in memory def get_type_size(self, typename, value): if typename in TYPESIZES: # int or float type; fixed length return TYPESIZES[typename] elif typename == 'bytearray': return (len(value.strip())+1)/3 elif typename == 'string': return len(misc.encode(value)) return None # parse bytes dumped by scanmem into number, string, etc. def bytes2value(self, typename, databytes): if databytes is None: return None if typename in TYPENAMES_G2STRUCT: return struct.unpack(TYPENAMES_G2STRUCT[typename], databytes)[0] elif typename == 'string': return misc.decode(databytes, 'replace') elif typename == 'bytearray': databytes = misc.str2bytes(databytes) return ' '.join(['%02x' %(i,) for i in databytes]) else: return databytes def scan_for_addr(self, addr): bits = self.get_pointer_width() if bits is None: self.show_error(_('Unknown architecture, you may report to developers')) return self.reset_scan() self.value_input.set_text('%#x'%(addr,)) misc.combobox_set_active_item(self.scan_data_type_combobox, 'int%d'%(bits,)) self.do_scan() def browse_memory(self, addr=None): # select a region contains addr try: self.read_maps() except: self.show_error(_('Cannot retrieve memory maps of that process, maybe it has ' 'exited (crashed), or you don\'t have enough privileges')) return selected_region = None if addr: for m in self.maps: if m['start_addr'] <= addr and addr < m['end_addr']: selected_region = m break if selected_region: if selected_region['flags'][0] != 'r': # not readable self.show_error(_('Address %x is not readable') % (addr,)) return else: self.show_error(_('Address %x is not valid') % (addr,)) return else: # just select the first readable region for m in self.maps: if m['flags'][0] == 'r': selected_region = m break if selected_region is None: self.show_error(_('Cannot find a readable region')) return addr = selected_region['start_addr'] # read region if necessary start_addr = max(addr - 1024, selected_region['start_addr']) end_addr = min(addr + 1024, selected_region['end_addr']) if self.last_hexedit_address[0] != start_addr or \ self.last_hexedit_address[1] != end_addr: data = self.read_memory(start_addr, end_addr - start_addr) if data is None: self.show_error(_('Cannot read memory')) return self.last_hexedit_address = (start_addr, end_addr) self.memoryeditor_hexview.payload = misc.str2bytes(data) self.memoryeditor_hexview.base_addr = start_addr # set editable flag self.memoryeditor_hexview.editable = (selected_region['flags'][1] == 'w') if addr: self.memoryeditor_hexview.show_addr(addr) self.memoryeditor_window.show() # this callback will be called from other thread def progress_watcher(self): Gdk.threads_enter() self.scanprogress_progressbar.set_fraction(self.backend.get_scan_progress()) Gdk.flush() Gdk.threads_leave() return True def add_to_cheat_list(self, addr, value, typestr, description=_('No Description'), at_end=False): # determine longest possible type types = typestr.split() vt = typestr for t in types: if t in TYPENAMES_S2G: vt = TYPENAMES_S2G[t] break if at_end: self.cheatlist_liststore.append(['=', False, description, addr, vt, str(value), True]) else: self.cheatlist_liststore.prepend(['=', False, description, addr, vt, str(value), True]) def get_process_list(self): plist = [] for proc in os.popen('ps -wweo pid=,user:16=,command= --sort=-pid').readlines(): (pid, user, pname) = [tok.strip() for tok in proc.split(None, 2)] plist.append((int(pid), user, pname)) return plist def select_process(self, pid, process_name): # ask backend for attaching the target process # update 'current process' # reset flags # for debug/log self.pid = pid try: self.read_maps() except: self.pid = 0 self.process_label.set_text(_('No process selected')) self.process_label.set_property('tooltip-text', _('Select a process')) self.show_error(_('Cannot retrieve memory maps of that process, maybe it has ' 'exited (crashed), or you don\'t have enough privileges')) else: self.process_label.set_text('%d - %s' % (pid, process_name)) self.process_label.set_property('tooltip-text', process_name) self.command_lock.acquire() self.backend.send_command('pid %d' % (pid,)) self.reset_scan() self.command_lock.release() # unlock all entries in cheat list for i in range(len(self.cheatlist_liststore)): self.cheatlist_liststore[i][1] = False def read_maps(self): lines = open('/proc/%d/maps' % (self.pid,)).readlines() self.maps = [] for l in lines: item = {} info = l.split(' ', 5) addr = info[0] idx = addr.index('-') item['start_addr'] = int(addr[:idx],16) item['end_addr'] = int(addr[idx+1:],16) item['size'] = item['end_addr'] - item['start_addr'] item['flags'] = info[1] item['offset'] = info[2] item['dev'] = info[3] item['inode'] = int(info[4]) if len(info) < 6: item['pathname'] = '' else: item['pathname'] = info[5].lstrip() # don't use strip self.maps.append(item) def reset_scan(self): self.search_count = 0 # reset search type and value type self.scanresult_liststore.clear() self.command_lock.acquire() self.backend.send_command('reset') self.update_scan_result() self.command_lock.release() self.scanprogress_progressbar.set_fraction(0.0) self.scanoption_frame.set_sensitive(True) self.is_first_scan = True def apply_scan_settings (self): # scan data type assert(self.scan_data_type_combobox.get_active() >= 0) datatype = self.scan_data_type_combobox.get_active_text() # Tell the scanresult sort function if a numeric cast is needed isnumeric = ('int' in datatype or 'float' in datatype or 'number' in datatype) self.scanresult_liststore.set_sort_func(1, misc.value_compare, (1, isnumeric)) self.command_lock.acquire() self.backend.send_command('option scan_data_type %s' % (datatype,)) # search scope self.backend.send_command('option region_scan_level %d' %(1 + int(self.search_scope_scale.get_value()),)) # TODO: ugly, reset to make region_scan_level taking effect self.backend.send_command('reset') self.command_lock.release() # perform scanning through backend # set GUI if needed def do_scan(self): if self.pid == 0: self.show_error(_('Please select a process')) return assert(self.scan_data_type_combobox.get_active() >= 0) data_type = self.scan_data_type_combobox.get_active_text() cmd = self.value_input.get_text() try: cmd = misc.check_scan_command(data_type, cmd, self.is_first_scan) except Exception as e: # this is not quite good self.show_error(e.args[0]) return # disable the window before perform scanning, such that if result come so fast, we won't mess it up self.search_count +=1 self.scanoption_frame.set_sensitive(False) # no need to check search_count here # disable set of widgets interfering with the scan for wid in self.disablelist: wid.set_sensitive(False) self.is_scanning = True # set scan options only when first scan, since this will reset backend if self.search_count == 1: self.apply_scan_settings() self.backend.reset_scan_progress() self.progress_watcher_id = GObject.timeout_add(PROGRESS_INTERVAL, self.progress_watcher, priority=GObject.PRIORITY_DEFAULT_IDLE) threading.Thread(target=self.scan_thread_func, args=(cmd,)).start() def scan_thread_func(self, cmd): self.command_lock.acquire() self.backend.send_command(cmd) GObject.source_remove(self.progress_watcher_id) Gdk.threads_enter() self.scanprogress_progressbar.set_fraction(1.0) # enable set of widgets interfering with the scan for wid in self.disablelist: wid.set_sensitive(True) self.is_scanning = False self.update_scan_result() self.is_first_scan = False Gdk.flush() Gdk.threads_leave() self.command_lock.release() def update_scan_result(self): match_count = self.backend.get_match_count() self.found_count_label.set_text(_('Found: %d') % (match_count,)) if (match_count > SCAN_RESULT_LIST_LIMIT): self.scanresult_liststore.clear() else: self.command_lock.acquire() lines = self.backend.send_command('list', get_output = True) self.command_lock.release() self.scanresult_tv.set_model(None) # temporarily disable model for scanresult_liststore for the sake of performance self.scanresult_liststore.clear() for line in lines: line = misc.decode(line) (mid, line) = line.split(']', 1) mid = int(mid.strip(' []')) (addr, off, rt, val, t) = list(map(str.strip, line.split(',')[:5])) addr = int(addr, 16) off = int(off.split('+')[1], 16) t = t.strip(' []') if t == 'unknown': continue self.scanresult_liststore.append([addr, val, t, True, off, rt, mid]) self.scanresult_tv.set_model(self.scanresult_liststore) # return range(r1, r2) where all rows between r1 and r2 (EXCLUSIVE) are visible # return range(0, 0) if no row visible def get_visible_rows(self, treeview): _range = treeview.get_visible_range() try: r1 = _range[0][0] r2 = _range[1][0] + 1 except: r1 = r2 = 0 return range(r1, r2) # read/write data periodically def data_worker(self): if (not self.is_scanning) and (self.pid != 0) and self.command_lock.acquire(0): # non-blocking Gdk.threads_enter() self.is_data_worker_working = True # Write to memory locked values in cheat list for i in self.cheatlist_liststore: if i[1] and i[6]: # locked and valid self.write_value(i[3], i[4], i[5]) # addr, typestr, value # Update visible (and unlocked) cheat list rows rows = self.get_visible_rows(self.cheatlist_tv) for i in rows: lockflag, locked, desc, addr, typestr, value, valid = self.cheatlist_liststore[i] if valid and not locked: newvalue = self.read_value(addr, typestr, value) if newvalue is None: self.cheatlist_liststore[i] = (lockflag, False, desc, addr, typestr, '??', False) elif newvalue != value and not self.cheatlist_editing: self.cheatlist_liststore[i] = (lockflag, locked, desc, addr, typestr, str(newvalue), valid) # Update visible scanresult rows rows = self.get_visible_rows(self.scanresult_tv) for i in rows: row = self.scanresult_liststore[i] addr, cur_value, scanmem_type, valid = row[:4] if valid: new_value = self.read_value(addr, TYPENAMES_S2G[scanmem_type.split(' ', 1)[0]], cur_value) if new_value is not None: row[1] = str(new_value) else: row[1] = '??' row[3] = False self.is_data_worker_working = False Gdk.flush() Gdk.threads_leave() self.command_lock.release() return not self.exit_flag def read_value(self, addr, typestr, prev_value): return self.bytes2value(typestr, self.read_memory(addr, self.get_type_size(typestr, prev_value))) # addr could be int or str def read_memory(self, addr, length): if not isinstance(addr,str): addr = '%x'%(addr,) f = tempfile.NamedTemporaryFile() self.command_lock.acquire() self.backend.send_command('dump %s %d %s' % (addr, length, f.name)) self.command_lock.release() data = f.read() # lines = self.backend.send_command('dump %s %d' % (addr, length)) # data = '' # for line in lines: # bytes = line.strip().split() # for byte in bytes: data += chr(int(byte, 16)) # TODO raise Exception here isn't good if len(data) != length: # self.show_error('Cannot access target memory') data = None return data # addr could be int or str def write_value(self, addr, typestr, value): if not isinstance(addr,str): addr = '%x'%(addr,) self.command_lock.acquire() self.backend.send_command('write %s %s %s'%(typestr, addr, value)) self.command_lock.release() def exit(self, object, data=None): self.exit_flag = True Gtk.main_quit() def main(self): Gtk.main() def check_backend_version(self): if self.backend.get_version() != VERSION: self.show_error(_('Version of scanmem mismatched, you may encounter problems. Please make sure you are using the same version of GameConqueror as scanmem.')) if __name__ == '__main__': # Parse cmdline arguments parser = argparse.ArgumentParser(prog='GameConqueror', description=_("A GUI for scanmem, a game hacking tool"), epilog=_('Report bugs to ' + PACKAGE_BUGREPORT + '.')) parser.add_argument('-s', '--search', metavar='val', dest='search_value', help=_('prefill the search box')) parser.add_argument('-v', '--version', action='version', version='%(prog)s ' + VERSION) parser.add_argument("pid", nargs='?', type=int, help=_("PID of the process")) args = parser.parse_args() # Init application GObject.threads_init() Gdk.threads_init() gc_instance = GameConqueror() # Attach to given pid (if any) if (args.pid is not None) : process_name = os.popen('ps -p ' + str(args.pid) + ' -o command=').read().strip() gc_instance.select_process(args.pid, process_name) # Prefill the search box (if asked) if (args.search_value is not None) : gc_instance.input_box.set_text(args.search_value) # Start gc_instance.main() scanmem-0.16/gui/GameConqueror.xml000066400000000000000000001514401302526536600171550ustar00rootroot00000000000000 1 1024 1 10 2 1 10 True False list-add True False edit-delete True False gtk-edit True False edit-find True False gtk-jump-to 280 False GameConqueror - Memory Editor False GameConqueror_128x128.png utility True False 5 vertical True False True False 5 5 Address: False True 0 True True 5 False True 1 28 28 True True True jumpto_image False True 2 True False True True 3 False False 0 True False document-open True False view-refresh True False document-save True False computer True False GameConqueror center 550 550 GameConqueror_128x128.png True True vertical True False 200 True 200 True False vertical True False start 5 2 2 Found: 0 False False 0 True True True True True multiple True True 1 True False True False 5 5 True False True False Syntax: For numeric types: <span font_family="monospace"> <b>N</b> Exactly this number <b>N..M</b> Range between two numbers <b>?</b> Unknown initial value <b>&gt; or +</b> Increased values <b>&lt; or -</b> Decreased values <b>=</b> Unchanged values <b>!=</b> Changed values <b>&gt; N</b> Greater than N <b>&lt; N</b> Less than N <b>+ N</b> Increased by N <b>- N</b> Decreased by N <b>!= N</b> Other than N </span> where N could be a number of a simple math expression embraced by (), e.g. <span font_family="monospace"> 12 0x34 5.67 (- 8 * 9)</span> For bytearray: use 2-char hexadecimal notation for each byte, separated by spaces e.g. <span font_family="monospace">FE DC BA 98 76 54 32 10</span> <span font_family="monospace">??</span> can be used as a wildcard value For string: enter the string directly Value: <span color="blue"><u>?</u></span> True True 0 0 True True 5 5 True Insert value to search for 1 0 32 32 True True True Scan 1 find_image 2 0 32 32 True True True Reset 1 refresh_image 3 0 0 1 True False 5 72 72 True False About False 72 72 True False GameConqueror_72x72.png 1 0 2 True False start 5 True True 0 1 True False 5 32 32 True True True Select a process system_image 0 0 True False Select a process No process selected end 1 0 0 0 0 0 True False 0 out True False 10 10 5 True False 5 True False 1 0 True False Specify type of target data start Data Type: 0 0 True False True 2 0 2 True False <b>Basic:</b> Fastest but may miss some values <b>Normal:</b> Works for most cases <b>Full:</b> Never miss values but slowest start Search Scope: 0 1 120 True True SearchScope_Scale_Adjustment 0 bottom 1 1 True False 0 2 True False 2 32 32 True True True Memory Editor edit_image 5 0 32 32 True True True Save address list to file save_image 3 0 32 32 True True True Load address list from file load_image 2 0 32 32 True True True Remove all entries delete_image 1 0 32 32 True True True Manually add an entry add_image 0 0 True False True 4 0 0 3 True False False False True True 50 True True True multiple True False False 5 dialog MainWindow GameConqueror Copyright (C) 2009-2014 WANG Lu <coolwanglu@gmail.com> Copyright (C) 2010 Bryan Cain Copyright (C) 2015-2016 Sebastian Parschauer <s.parschauer@gmx.de> Copyright (C) 2016 Andrea Stacchiotti <andreastacchiotti(a)gmail.com> Special thanks: Igor Gnatenko, Mattias Muenster, Zhang Zhe A graphical frontend of scanmem https://github.com/scanmem/scanmem Homepage Wang Lu <coolwanglu(a)gmail.com> GameConqueror_128x128.png gpl-3-0 True False 2 True False end False True end 0 False 5 Manually add an entry False True GameConqueror_128x128.png dialog MainWindow True False vertical 5 True False end _Close True True True True False False 0 _Add True True True True False False 1 False True end 0 True False 2 5 True False Memory address of the value start Address: 0 0 True False Give a brief description of the value start Description: 0 1 True False Specify type of target data start Type: 0 2 True True 1 0 True True 1 1 True False 1 2 True False Specify data length (string/bytearray only) start Length: 0 3 True True Length_SpinButton_Adjustment 1 3 True True 0 CloseAddCheat_Button ConfirmAddCheat_Button False 5 Type to search for a process True 400 500 GameConqueror_128x128.png dialog MainWindow True False vertical 5 True False end _OK True True True True False False 0 _Cancel True True True True False False 1 False True end 2 True False 0 in True False 10 True False 5 5 True True 1 0 True True 1 1 True False start User: 0 1 True False start Process: 0 0 True False Filter True False True 0 True True True True True True 1 ProcessListDialog_OK_Button ProcessListDialog_Cancel_Button scanmem-0.16/gui/GameConqueror_128x128.png000066400000000000000000002006351302526536600201570ustar00rootroot00000000000000‰PNG  IHDR€€Ã>aËgAMA± üabKGDÿÿÿ ½§“ pHYs  šœtIMEÙ   íòtEXtCommentCreated with GIMPW IDATx@€¿2+ êÛÓñf^þüû%ö* ýüûùóíæûìäÙýñëâ åýüú¸ýûù´½ù* †ÿÿþF'9Nÿ/C] "/þýüêàÔáÔÃüÚÉ´óíäÚ¸ûøõ»û „h7Pn1Fa õðêÚʶþѼ¢òñêáÿ›üúøšÝ4 ° .?Ec‰ íåÜѼ¡øÔÁ©þÆúøô|ÉZœGgŽ(9OüúøÔÀ¨ýĪ‰ùþþý½ûøõqÝU’Ô- IDATz ‹Y± +;#01Hcÿþþ!çÜÏfÿÿêÿΙ XV}¬ ìäÙ­‡Zõ÷óî˜ýüút"V[ƒµ  +?VØÆ°.ú÷ôùÿÇŒ!eY° ïçÞ¢yEõüúø#éu fX~®  ÷ôïàÑÀçÜÎÿú÷ó÷)$2 "(8þàÒÀX‘[ €W~­  öòîÇ­ŒúÓÀ¨ Èù÷ó»þüûê # 7ú÷ô/ý.A[ (:O (7 àÒÀ:»Z‚´ )Ü̹·–nù£ùöò{êC düúøM"2E:Sr(³’hôÚȳ~ÓMp›"0BÿÿÿƬ‹ýͶ›ïûùöMÈlv+:>Y| &ú÷ô—i/øüúø+Þ ¸3Ie/D]ÿÿÿ»wùÓ¿¦àûùö2ÚùÿþýÃþýü’òíæùÓ¿¦6óíå'6þþý´“jöñêâ±þýüœu&VKm• §„úÕÁªÝûøõ7ïûÿþýÄþýü˜ïèÞζ›' %éÞÒ²dõèÜÏÑüú÷Tû. Ç_‰½ л þç‡äúøô1î2 „ú÷ôHüòþýü‹ÿþýú ×FdŠ)U ØDZÿ²üú÷÷vwQ--|BB +B$$#ôÚìì.Èýûù-.?ÔÀ§ôøõðš ¡; –QQ #2Úìì-È«[r. IDATD%2öðéáòìæÁ (%! ($ÿýýýýûýûù  _£WW L**/ ¯ÔÔ)ùýýG$3GÝ͹ ·üú÷ý68 >0ûùö õ$ÿ'    —i/ Ì9!©[[  ! (ù÷÷D(8Ýλõ÷óîª+N Pûú÷/ö+<&4 *$Z9Ò{BB v@@ýûù*þýüæÛÍÀ_ c%5J#3F (8 ZI¼¬]] K)) üþþ8)õéßÓ éýûùí8 ÿþý?(:Qþ,@W %4ZW ¬ºdd 8 ûþþ 7+< æÛÍÃ/ • /9Ss ,>V ZV ŸÂii 0ÿÿÿÉââÈââØëëü÷ûûø B$$! þþþ 9".éÞÑù÷òíÀ‰iZ ¨T..m;;·ØØ=––÷ñ÷÷^eŸÞps¦åúßÒÀüÿþý9Ûúùüü‰‡¿¿ô»ÛÛ Ê ÿöñëèÿþþ{">›SS ±ÕÕT££ôôúúBp¥äªõñëúöóÙüþþ™µ××ÿÈááýþþ~ººôñøø—÷óîèííäÙóíæϹŸ«…VöŽ\B w·bb ³ÖÖZ¦¦óöûû?s¦åÇãÕÅÊþñúýý^D››øÒççûýý_©©øãððÑ¥ ÷ôïëÿÿÿ¥Ñ¼£fCa…÷óîÙȳӿ§óîæÛ ¹÷óîfÛ®^^ ÉââZ¦¦ôöûûCs¦åÍßÑÀöú÷ó°°÷ûûc2 C%%õ9 Ýííý´ÖÖÿüþþÆõúúRÿþýýýüúúýûùŠÓÀ§_"2E!/@ëâ×ʲ•ùÛ˶ »øôïš¹üúøú ¹c55 C%%ÜììHõôúúOg•ÎÊÞλþºþÿÿ¦¸ºÚÚNºÚÚ&ìÂÌüúøøåýûùN±a·3Kg-@X çÜÏË´—öãÕÅüŒýûù”ýûùïd :‰JJïöö@™™÷÷ûûm(8² êàÔýüùóØî ÆO^ IDATÀ?€þýüýÂýüú.ϸ†Î·›Güúø áûùö•ÿÿ•ö °__ ýþþR¢¢öòøø¡ i0F_ ØDZûþýý¦ÿþýÿþýÝûùöWûøõ  {CC*|¹¹üÏææÓóùùmõ$4HÿÿÿÔÁ©ùýüú¤þýüúýW2v??¶××”ÅÅòñøøM Ÿ2GbåÙÊüúøëÐñùöòý  –¡WW èóóZ§§÷ôúúN þýüU2IeÌ´—ôûøõîõñìú Q,,: ÿÿÿY¦¦õúýý’Å ·6Mj ôïéàÓ¢êôîèÿ #eLL ”ÆÆÿÏååá÷ûû}C?3Jf̵˜÷¢ðáôïçûùö ‡r>> ßîîy··øõúúP  ¥Ed‰ öòíл¡ýûù†ãùõò üúø (Lt>>f­­öˆÛ §$4I$3Gȯø¤ãý âìäÙ!-û9 …yAA ®ÓÓÉââìôúú‡ z @Dc‡ñêâÒ¾¥ýûùö}ÊêàÔ!/A  P$Gl::øûûj¯¯÷óùù^Q~Sw¤  ¸™róþýü†éú÷ó¾ßоó&7MýüúRoj99 ’ÅÅþúýýÆ¢V|« ×ůÿéßÒêÿþý‹½ãÖÆÿÿÿ#1` al:: òøø„½½ùòüþØ šX°*ôïè»wöûøõ[ûÝþþýîéÞÑ=Xy ŠY: ü†¾¾þüó"a^ˆ» )þþý²dôýûúŽÉÿþþ5"1D üú÷ìâ×Hýûù£û œ‹KK!'ÿÿÿšÉÊ}½¿(=TNpš ¦„øßÑ¿Ñýûø_ÿ Ùj™Ó þþý¹™rúÛË·êûøõNÏ Öð þþþ´××z¾Áï Ad‹"/Õ«ý»wìýûù-ëñ=  %2%5I âÓÃ_ =üûøíßÿ`U..AT..þþþËããŽÆÇ]ª¬ºêò(Oq@_„ âÕĶ•löýûù@ß6,¶8 IDAT1 Äg”Í  ùöó×Ä­Ò¾¥óíåÚ ÙþýüÐù÷óØÿÿëyb55 ÛðóÒéêÖæã5K)=U%äØÉ­ˆZôüúøFÇ «.B[LA^÷ôïêßÓïèßñëãÿ÷óîùþýýþÿþý   %( àÒÁ±Žcõüú÷O½ÚSx§(6×Æ°ýºšsõüúøIÆK ª_‰½ þþýÂ¥ƒùѽ£îüúøEÕÛÿÿþÚʵ6);R òí嬇YóàÓÁÎüù÷?áÿþþÃüúøÖì2$4G ÿÿÿÒ¾¤þ±Œaöóîç‰ýûùdõÿþý¼üûøðÓ¿§@"&äØʯŠ]òÚȳÛûùöIÿÿ¬ÿ9 ª&4Ca† !ãÖÇÄ©ˆóêâÕöüù÷x¢þ tv-?5Mi %4õðêØÆ°þιžõ÷òíñûùö‚¡úf k%6J!/B%3 ÷óîèÞÒæ×ÆÚË·üðëãû³üú÷–Âÿ.J Küù÷1ø   ýöñü÷óùôíôìäìéâüûú- ýËãã³ôúúRü%K5EB$$   ˆ¿¿ƒ¼¼öûûqèè B$$GˆJJ÷üüùþÿÿüþúýýû íãððú'+Ö0þž IDATÜÛììþ,ôùù&ÓÛìì ÿÿÿ  þ9 oÏÛ ®<÷rY11  óùùÍääùýý±S ÀF%%E‚FFh88&(ÆááYýÿÿ· µ˜RRJ[22ãðð%‰‰øùýýî œ M©[[ \22ÞîîýÝííúýý¶2 ÄO++3ºee $ J((—ÇÇ@þÿÿ’ù®¿ÜÜïöö‰JJa2z ÄšTT¤YY &>ýþþ­ÓÓÿÁÿõúúnl¯¯õöúú£XXe66/ ×<8 ¿ ¼”PP(Çll &~ººûøüüÓÊÞ6óùù!F&&F&&+ ¹ÚÚZ;øüüÛå%c ¥ j}DD%¦YY3ººúŒÁÁð÷ûûBóÚÆkk 2õúúšÈÈþˆÀÀøøûûõÁñøøÉþÿÿøú ! 1õúú2N**`33>""ùüü_©©ô´××âõúúCèV Ùuu  ÿÿÿÓèèÈááÔééýð÷÷ù#2%âïïGôâïï¾öûûZõ‹-gÁhh ·ØØÿX¥¥÷øüüúýýÿ ¬6G¸cc öúúr³³ö¢ÎÎô÷ûûTà ¶: 8³`` ¾ÜÜ[§§õôùù¶ôúúfðëñ,Ë IDAT ©&C´bb  âïïr´´óµ××øøüü_·† m«\\ B$$îöö„½½ø™ÈÈýûþþ“ûýý…ôF §V.. ‹KK  ÞííÃÃ÷œÊʨ÷ûûzç …ÿal::r>> óøø³×וÆÆïÎååš÷üü‘ã! xûýý]9û]22E%%úüüÏææÆááý®ÓÓòËãã Èòùù›®÷ M Yüþþ?'÷$ èôôúïööûáððþÝííéóó âøüü¾øüü¼¹ð*ðïåáÚùûè<•IDAT€ÿÏcesüQøIEND®B`‚scanmem-0.16/gui/GameConqueror_48x48.png000066400000000000000000000052671302526536600200250ustar00rootroot00000000000000‰PNG  IHDR00Wù‡bKGDÿÿÿ ½§“ pHYs  šœtIMEà;u†ƒÔtEXtCommentCreated with GIMPW IDAThÞíYkpTå~¾sö~Ín.› ¹lÈÝ"A.‘@EA¡Pµ:íТ£bU@Ǫe:*¥V¼´"µJa¤fP‘@’IH 7rÙÍf³¹l6ÙM²—sÎ×¹ˆiA–Àž™ócçû¾÷¼Ï|ïûž÷}¸Û¸.°7Èn(þF Át:&%g…Ñ”ù+Ñ+–Ê%n§½ßÝm;ßc«ßç´5|ívÚÛp·"Ü9«_~/)g™Y¡ a¾¿XóÃ;؇nk}Ï…SûOWŸØý €ïn¡Ñ“ófÜÿÌžäœe*.à6J˜1ë”R€R0¬‚À£¾¤À[Z°ãGSå¿nz†]ºè‰m{Ìw.T <Â0ø¬Š`«/uy=.™T¦‚T©Às¥‹"±’Eå‡÷è½^¢ŸzP1û¡M;ÍÓ)8¿„ôÚ›é™Û¿¨þvïëZD§.I³ò¡„;æ™TúH†¥Z @~3o@qÇ‚u™÷¬§‚Â0pu¶âø?6o©/)ø-€6ì§ýDÓÙ£w¶T_ò LwwÛTUÇ?Ýêr´ì÷`X1>@â3澓·þ_ËT! |Ž~øÜ‚5"©Bà|ƒW22ò´hÃcÑ×eÁ¸†À™‘½ü©ÕrM(žƒÀs(>°½¨®¤à1ÿËypçùÀWüP0/1ñÉG¦MËu¾Íå6ÜÿRjî¿Th€‚IÑ\ùMcgóù ãÑ ù==ýt”±XFa"¯°7rEzú£f8e(¥øË©ÂB‹.qbÚìS†! ºÛêqîðÎwxƃ€Ð×m­óz\ÄR9ԡƹ—·ãçšLÏ<œ™©¥!8XSíÞVVU´`íQé"‡K¬À¡òëKú»­·n´¥ò›ÃÎöF†€I—6{1€¬C‡~óâñéÓW¨T*€tyÜx³¼Úyßïvl0$¤+©ÀäLi}é¡'Æs&nUé +£“²ÃŠÐ fV­7.²Õ•Ù¹€·?Ã1sÃÝ3Ÿàý>ö`]Þï•Á°tcˆÑt‡xxnfÑq©Çv¾ð‚³½q+–‚ ×/Ú]õLe¾óyëÿú‘6"Ž¡Tðp4ŸG[mIÏ ÛYCz£Í†„^E8B&eÃ= 8PJÁ0,ºÛêùc=ÿGKÍéÍ7K™“%åäš»îõårµTàG, AÆ3B” #¿k‹Ê¿üà){Ãwï[+½Y…ë¶Ötu4Ç…F›“dJ-Ë0,@˜GGœ'Ïùàê´Îþ°üØG/<èqÚ?ŸµæeÚZu⦋»â°Ø¤»£³Ö'eÍÓEÄidšP‘ ~߆úºà¶Ö¶– ûö¦÷:Ï~½åÔi=€°¢ÜW.zkZ”Qr ××wl¼_\ܶ«¼ü±J»ýÈxüÁñ£W*Qa·Ÿàðx*¯õä•g’b0dÏ6™6ÏOLœŸf4ŠCd2€¸½^X\.µ´4–µµí©loÿ´Éé¬ Dkµhëë»%\³ˆaÒ3£¢âA.8Ö¿¿@Åx|©oã6þþnÛO[Ìñ€0IEND®B`‚scanmem-0.16/gui/GameConqueror_72x72.png000066400000000000000000000123531302526536600200110ustar00rootroot00000000000000‰PNG  IHDRHHUí³GgAMA± üabKGDùC» pHYs  šœ vpAgHHÎyðßIDATxÚíœytUսǿ{ŸéŽ¹¹7óH „B"SPpª`E±N8´µêóU;<ûÖ{öµ®Õjë{Õö9–×ZëÓg}UZ««€TBH $!óœ;äÞÜùža¿?àR©!$êã·Ö]w­{ÏÙgŸÏÙ¿ßoÿöï·pQ.ÊE¹(³'Ül\” Êq¡ „ŒNÇbl¶ÙÌŽPÊ!aÎ`ìá$X @>nÉ—îÇ‹ „ÎvwAfòb…+ÐÓ¸/AgŠ]2oÉƘ„ôù1qi±¼¨#A_pÔÙç xíöî¦]£öžjÇó—_n­ú T%üÅD(Ó4QgŠ]7gáêoÍ+»jeêü%“5 „òãG1hª‚€ÇWÿ e¨³¾¿ïxÕÇö¼ÎþÝ7<ü¿ý|ü60Mýb¢œM•-qé¹,Zs˃ù—|9ÁdKC´³;D¡P•ün;ú[;ëvéªßýÛQGïVŽGT%2c€.¸‘fLKLž»ø‘Šßþváª,:£Œ1ìÎ3Þ¢ÁŒøŒ¯€ ¬ÚôóÒ«¾ž-êŒ8is!ð¹‡qèçêv¿~oÁòë?´w7iªƒ¦ÊPä8^Ô$CŒËëèÝÛßZ½ËÑs<ufŽ ´K{Þ¨é¨ýà9ì¯Å'Yùi”évó¦9‹V?¿fó#·'d.˜ rЇCÛ¶tyÿ·ßHÎ]²££fç93ÄÄ#0êä°èZûÕÇ»?øí¿Ì›éd²&߾ꖇŸ/\µÉmwÓÐðáï]û·>ñ=ßÈàK´¿·MN6>g"š"Ï`4儌쒵÷甬3EÿNEOÓÇjý‡¯ý·odðµOTyæ&…“Þ×4µÃÅ&gÝ’W±a©ÞlÅÉÑC…ÇÞƒ£;_þ` õð„Ðà¬Þíl"”æä,¾ìŽ´Ü¥|´j©JÇö¿Ùßհ秶Ôùý“…Ÿu™£qi¹›æ.¹"WÐÁ´1„Pô6W©ÍûßúUÈçþ(äsÏö½Ní榡ôô‚KnHÌZ$œ=„ èÁñýoUÛ»›^0³!øg %qκ¬E« %ƒùT E@ÐÓ¸/ØÓ¸ï=3yCÀ<› ÓŽ#çç¨Ï!ÆÄ9…צÌ+Õ6̯íG>8äê|gºèx1’„úï|çÔoŒ1üâÚk¡ã80@rƒ›*srž(IKû‘ÊXqQrò”¯w^6ˆR˜^PQ¡‰‹ŠÀ ÛŽ†{ü=€áé“c³¡Ýå¢!EÉÖ›¿ñå—³/™3'£”+ÏÌ Ûýþሪö¥˜Íß_»öÁuóçǺƒA<µwïª76èžq@qi¹«’²‹8Ž‡¦©”H={Û=C]ïb áÇ‹àDT9 UÃf0ÀH}OÙªìì[Wfe­,NMŸÙ%‰#U4MóF"ê€ÇYÓø›Š‹‰$Š!¸Õï¿dGKKeHQ^™i@†øŒü+âÒs©6î¾ %ðØ»0Ø~t'cZß'L9„r Io†¨7ÃÕßÊ«JD§* @Ȥ/ÏÊúêÆ›¾TP<×fƒ$Šg5‡“æbÜ‹BÓJ‘c³ñóâãóÝݦà,¦ ˆ¤y ™s%CÌiõb ŽÞ– £·y7€IcB(xI9ä§Pƒ*‡Ó%½y"‡2Ss—¦Z3³ 1 Y¡Àh¨·êí_YXø¥»ËË—•¦§~|í„s c°êõ˜—{ »[ð©'ªS$êŒ â3ò3(Çšû¨ª‚¡¶£í‘ ¯æÌã)'à¶oÃ+_Ç4mIrÎâ•q鹫-I™)ñiy©&[ŠIgŠ…¤7ƒâ8ööSûï\Syï]ee© &Ó˜è•ÆɼÓ$¹4£(¢ӥ˜Q@ÔlKÍ5Ç¥‰§â]Bò¹á±÷tªrx‚zmxp Þyú¾9~æ¾¼`Õ3 W”$dX,‰™ôæ±¥WBA„C{ù]ï^yë’•6½ L f4€Ë`*cŒRJ-:lÃYÀt‚ã̘¢Çž* }|F^©Ñ°Ó3gŸk@ó Vc¢z »^þá E—mþîüeW/N™·DÐcBÇ"tÆÆc7 ‘Hh°áõGÜa-¿¥´Ì*òüY£¢ÓéÄö–f{­W ;TÚêqÛ½œßéM6›çÜXT´ìªü|1š„@)(!"¦¸r1U@’Î;W2Æ"zþãwkÎÞ–&Dy/½9îš’+¿ö‹âuw$ëÍV0m›h/5Ué­ãñ¿"º.½¹´Ü*rÜi8„ ,ËxïX“÷å–®£êÒYÊ•—æY#¡²–·ž9QWsàë€ÖÓãvÿ"Ûf»µ )‰ ª_=S4Õ‰¢YÔ›uÚ›0¦!ä÷(r$h~)óJï*\}c²Þd·UG¡„rýGÞzzëÚHGùæ¥Kã%>깂ÑP¿üxÿðSvº7áΧCóWݸÂh¶%6íy=p¢êÝŸÚÏÛ÷uvny¯¹yX‹2â!YFP–}˜b¸3%@”ôf›m'5UE$èõRŽ÷G*êñ:cì„$áXÁÂXrÐ=Ô¥µV¿ß’×ýÑòoT\’i’¤ #Ç âÙ½õl3,¾íÑåfkÒ:¦1ŒÂÑÛr40êØ @ ) BŠRý§††·õŒE7ŒìëêÒõôlà?çM"SR1Q2Z$£eBfi*"¡€OSäèŽ(^×@³¯uEʼÅãê¥aÔуÁöº`_ó¡ŽÞ–y‘¡œ¯¹zi¢Ù<Ž?ƯìÝe-9\´áJJ©…1B9x†»µQGïL´w¡=ÿÛ{ïY®ÊÏ¿$¢ªlGKËîÃ}}[ð7¦¡G)wÖ¹šªÈª‰îˆ6ÐzøW5ïýfÙ¢Ko^¦3Æ’¾æC®Îºw ´Õ¾éÚ7×{Ó7¿|Ýæ‚ädmUÅ«55Î_· 7\úà-•¥V5ßrõŸÙ»÷ãìÙzûÎ'îÞÕÖ–§ Ûf½ øƒòÔ–j§1/Æ0îÒ&tXS•†ãûÞ¼k¨ýÈFÊ ¯kðÃ׵ןæ³êõ+î([vÿºÜ\ý™®|gkkèÉÝ»·Å®ºm•Þd±Fÿ-‡è?QÓ¤DB “õD Ô«„j ¢(+Ê”ïjJ€˜¦(šzæU åxB(wæÊ¡>&î¸-mþOÉB8ÈA¼Ž>놂‚ïn.)Éœ0×!ƒƒìÙ½{ß,}‹­NåEÝ„…¸‘Ám¨ýèý“õOÖ4Èáé)—™ 9ôEB¾ ¹qB)DÑÄ‹’QOœ°úÝCh­zwÂoYVëõ·/Yrev|<‰†ãðBUÕÑmÍͯ—m¸ÿ‘äœb‰iQMEOÓ~§½«éø” €©È”¼˜ªDœÁQW$Z—(å!êÍMUcþŽ&2®ÊË»çòÜ\#‰Ò1¼ÙØèÙZwô¹´üò5¹åëˆzN')ÜÃݬãÈ®÷åp öBÙ2 #!¿; FNcB)Œ–xAcË<×Éy ¯+,,‰ÕG9BBÐ48È~WSó¦“èŒ +oÞœ”]DYÔœFÓ´×ìîlx @à³ (èw7¼ÎSu„LÓ›4‡KÈ\p)>YuSVçäÜ´<+Kˆ6Ì!YÆïéÚÛ;Ð[zÅ]ßÊ«Xo!ôt÷¥îh`Íÿüz`Ô±&àœ ÐPGÝA¯£ Ó`ŽO'ÉsK* ¡E’Ñ2é‰ FcåÕyy¥f.ªÕÝÝÚï[ü¥ëï¿kñåwåõ£òkÁQ'êþújÍPGÝs˜BT>Ó€˜ß=\5Øvd0ºfãäU¬ÏÊ.Yûðߓ•Wq-ÄñÅ°qÒʬ¬ë—edèÆ*¦TMEmOž?Þ…œkÌ-[oºÞt:Æ9„Æ=oØ[«¶=¦Êá時œGu‡¦*NŽ—¥å-+Ð-ŸÁ`‰Glbf®ª(e­Õ,à±»U%B \¿pá·Wçd[^/ö à•ænü!l~åí$»ä2ŽãÅ ëÛLSÐ|àÏÃyá'^gߢÏ-ç•Ñc7¬ºù__.Z»9vB£„Œ`¶T†:놂£®Î€ÏÕ­ø,ê-äTm´ßã@[Íõ¶-ïÖÿõµ‡ÂÏÛ¦H}FPÎ92оÇÞ}Ìç÷Ø3yA²ˆ:å/Œ«=‚ J90¦Aá±÷ ­f»çèÎWöÕíúŸŸµýNZ? Õ ÓVaÆ‹z(‘ `AâœÂëâ2òW$e/*6Å&ÅêÌV’Aày‘ƒª@øö¹¡x°wÖ{;»[þ82ص5èuÈ-_ïh¯ýJä³QJ4í[ –Üñï;±å¾b+€ ÊñÉæ¸Ô½(®¾fþ¼ÛJSR$3Ä‹,’ˆWkjž?p`}Z~y×@k 4ufKìÎ%Ó^'ðرå¾bŽáxaD”Œu +oBç{Ï{®I¯Ø´±¨@@)dYÆöÖV úŽœm3è¤0U¢*PÂAì{ãgˆ7ÃAEŒ Ú±ì(!&Q´BŒl6ÐB`Õëa®@Úy¶;c;Ö\@߀×;a‹çy$›ÍqzžO?ßö)!`ŒqÞP¨„rGH–WiŒIçÛîŒmÉd)JN¾©2''§ž _Û×çìv»w`ŠÅá96\Á`Ò¢ä亷¢â'__¶lsAbâúÞÑQÑá÷Ÿ™Èül š%iQeNN©5*Ek0·;qOGÇžX½~0ô)Ö)!`ñE"˯_¸ðç¯]{çæÒÒ¸ÉÉ\yf¦‰0VúQggUDUÛ>€”@$b,MK»ª )éTÆ‘ç8$™LÖv—ËÖ08ø¡Y’õ“s|"Ç!ÙlÆh8›ŸpÏ=ååoÍšeK32N•ÜqRé@W׉þÑÑÝŸ@«ªÓ(Š—Væä¤ë„ÓÛâM&$¹##–Nç¡Î/«*t‚EÓ P ³$AÑ4EAYdU½äÊÜÜǾ[Yù_++KœSBplhHûC}ýŸ\@ÕTû|Á¼Ød"«êàö––w´´m*.>¥gÀºÜ\r÷³û÷§ìhm}Jcì`P–CŒ1F'âÄRB–¬Îξöª¼¼ë6¥Íkä 8=##x½®®ñ„ÃqîM!Ÿ 3ºëy\b¯ÉÏáÉ nÈKL<«zã„Ó‰wú¸«ëÈ°ÏW7; ‚`ˆ7çÇs+23ç—gfZsÀG8DÁ©ëïgOïÝ[µµ¾þŸ=¡ÐžÏ ‰çV”âû**^øÁºuKS-–³ž>c ®@££)Š&PJ­M&èx~lur0aEÁŽ––È3ûöýa{KË+srŽín?¿‰³1‚ÀƒÍ`X{ç’%Ï<´fMAÚ™ÆoxÂ÷™fg×éráµÚÚžßÕÖniú/£(:ý‘óß3+€N^Ûª×_vâE?y`ÅŠeE))“Œ¿yöX×í>v¶¶úߨ«Û¹½¥å?ý‘È^‘ã”sy¿WfåÝ'å©k¯íøÑÎûÛœN³¬iÙ F£d’$Ž›8‚(=0¢ªhs8°íØ1ï³ûöíþMUÕcU==O̵َ;MÆ÷~ÌæÄpøý&›Á°nUvöæåsæ,]œšš‘d6S³(Bà8Èš†@$ÂF‚AÒ922r¸§§³ixøÐÇ]]où"‘_]ºÔõRuõÙ£9ë€Nvbqj*jûûu! lÔ˜˜Œ´˜˜ƒ(š²ìöù†û<žþ,w¹C¡Fƒ™‹Ú?: åÿÛbnì¥zA€e,©H0Vº+Ó$“ &QGΈç.ÊE¹(å )ÿÞ.ÆÎTzctEXtCommentCreated with GIMPW%tEXtcreate-date2009-12-12T20:08:57+08:00‡Å£Õ%tEXtmodify-date2009-12-12T19:30:08+08:00¢ªIEND®B`‚scanmem-0.16/gui/Makefile.am000066400000000000000000000020351302526536600157130ustar00rootroot00000000000000SUBDIRS = icons gameconquerordir=$(datadir)/gameconqueror python_PYTHON = backend.py consts.py misc.py hexview.py GameConqueror.py pythondir = $(gameconquerordir) dist_bin_SCRIPTS = gameconqueror dist_gameconqueror_DATA = GameConqueror.xml GameConqueror_128x128.png \ GameConqueror_72x72.png GameConqueror_48x48.png dist_desktop_in_files = GameConqueror.desktop.in dist_desktop_DATA = $(dist_desktop_in_files:.desktop.in=.desktop) @INTLTOOL_DESKTOP_RULE@ dist_polkit_in_files = org.freedesktop.gameconqueror.policy.in dist_polkit_DATA = $(dist_polkit_in_files:.policy.in=.policy) @INTLTOOL_POLICY_RULE@ dist_appdata_in_files = GameConqueror.appdata.xml.in dist_appdata_DATA = $(dist_appdata_in_files:.xml.in=.xml) @INTLTOOL_XML_RULE@ dist_man_MANS = gameconqueror.1 dist_doc_DATA = README TODO COPYING EXTRA_DIST = gameconqueror.in consts.py.in desktopdir=$(datadir)/applications polkitdir=$(datadir)/polkit-1/actions appdatadir=$(datadir)/appdata install-data-hook: chmod +x $(DESTDIR)$(gameconquerordir)/GameConqueror.py scanmem-0.16/gui/README000066400000000000000000000015111302526536600145350ustar00rootroot00000000000000Game Conqueror ============== Game Conqueror is a graphical game cheating tool under Linux, as a frontend of scanmem. Requirements ============ libscanmem (latest version) Python (2.x / 3.x) PyGObject GTK+ 3 policykit Usage ===== You are supposed to be familiar with cheating tools like CheatEngine - Search for a value in the Value entry, then press Enter or the scan buttons * Check supported syntax via the '?' mark * You scan enable/disable searching for integer/float using the checkboxes. * Pay attention to 'Found: XX' at topleft * Results will be displayed in the left list if there are not too many - Add a candidate address to the list below by double-click on it or use the context-menu - There you can edit description, value, and lock it. Author ====== WANG Lu License ======= GPLv3 scanmem-0.16/gui/TODO000066400000000000000000000007441302526536600143540ustar00rootroot00000000000000TODOs ===== - show error messages - different color for different addresses (heap, stack, module etc) - limit size of bytes read for memory editor - processlist sortable - popup in memory editor -- like `add entry for this address` - manually add cheat - icon in processlist - custom address region scan - different types of locking ('+' & '-') - plugin-like system to support different datatypes (or actually representations) - different representation (dec, hex ...) for cheatlist scanmem-0.16/gui/backend.py000066400000000000000000000052211302526536600156200ustar00rootroot00000000000000""" GameConquerorBackend: communication with scanmem Copyright (C) 2010,2011,2013 Wang Lu 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 . """ import sys import os import ctypes import tempfile import misc class GameConquerorBackend(): BACKEND_FUNCS = { 'sm_init' : (ctypes.c_bool, ), 'sm_set_backend' : (None, ), 'sm_backend_exec_cmd' : (None, ctypes.c_char_p), 'sm_get_num_matches' : (ctypes.c_long, ), 'sm_get_version' : (ctypes.c_char_p, ), 'sm_get_scan_progress' : (ctypes.c_double, ), 'sm_reset_scan_progress' : (None,) } def __init__(self, libpath='libscanmem.so'): self.lib = ctypes.CDLL(libpath) self.init_lib_functions() self.lib.sm_set_backend() self.lib.sm_init() self.send_command('reset') self.version = '' def init_lib_functions(self): for k,v in GameConquerorBackend.BACKEND_FUNCS.items(): f = getattr(self.lib, k) f.restype = v[0] f.argtypes = v[1:] # for scan command, we don't want get_output immediately def send_command(self, cmd, get_output = False): if get_output: with tempfile.TemporaryFile() as directed_file: backup_stdout_fileno = os.dup(sys.stdout.fileno()) os.dup2(directed_file.fileno(), sys.stdout.fileno()) self.lib.sm_backend_exec_cmd(ctypes.c_char_p(misc.encode(cmd))) os.dup2(backup_stdout_fileno, sys.stdout.fileno()) os.close(backup_stdout_fileno) directed_file.seek(0) return directed_file.readlines() else: self.lib.sm_backend_exec_cmd(ctypes.c_char_p(misc.encode(cmd))) def get_match_count(self): return self.lib.sm_get_num_matches() def get_version(self): return misc.decode(self.lib.sm_get_version()) def get_scan_progress(self): return self.lib.sm_get_scan_progress() def reset_scan_progress(self): self.lib.sm_reset_scan_progress() scanmem-0.16/gui/consts.py.in000066400000000000000000000005111302526536600161440ustar00rootroot00000000000000# constants # should be defined by autotools VERSION = '@VERSION@' LIBDIR = '@LIBDIR@' LOCALEDIR = '@LOCALEDIR@' GETTEXT_PACKAGE = '@GETTEXT_PACKAGE@' PACKAGE_BUGREPORT = '@PACKAGE_BUGREPORT@' SETTINGS = {'scan_data_type':'int32' ,'lock_data_type':'int32' ,'search_scope' : 1 # normal } scanmem-0.16/gui/gameconqueror.1000066400000000000000000000022411302526536600166070ustar00rootroot00000000000000.TH gameconqueror 1 "2016-07-27" "gameconqueror-0.16" .SH NAME gameconqueror \- A GUI for scanmem, a game hacking tool. .SH SYNOPSIS .B gameconqueror .RB [options] .IR [target-program-pid] .SH DESCRIPTION .PP Scanmem is a simple interactive debugging utility for Linux, used to locate the address of a variable in a running process. This can be used for the analysis or modification of a hostile process on a compromised machine, for reverse engineering, or as a "pokefinder" to cheat at video games. .PP GameConqueror is a GUI for scanmem, aims to provide more features than scanmem, and CheatEngine-alike user-friendly interface. .PP .SH OPTIONS .B "\-v, \-\-version" Print version and exit. .B "\-h, \-\-help" Print a short description of command line options and exit. .BI "\-s, \-\-search=" value Fill the search box with the given .IR value "." .SH HOMEPAGE https://github.com/scanmem/scanmem .SH AUTHOR gameconqueror has been written by WANG Lu . See copyright file for full list of authors. .PP This manual page has been written by Kartik Mistry , for the Debian project (but may be used by others). .SH SEE ALSO scanmem(1) scanmem-0.16/gui/gameconqueror.in000066400000000000000000000002541302526536600170570ustar00rootroot00000000000000#!/bin/bash DATADIR=@PKGDATADIR@ PKEXEC=$(command -v "pkexec") if [ -n "$PKEXEC" ]; then $PKEXEC $DATADIR/GameConqueror.py "$@" else echo "install policykit!" fi scanmem-0.16/gui/hexview.py000066400000000000000000000560141302526536600157160ustar00rootroot00000000000000""" HexView: memory editor with hex and ascii output Extended by Wang Lu and Sebastian Parschauer * Added editing and cursor moving stuff * Port to GTK 3 Copyright (C) 2010,2011,2013 WANG Lu Copyright (C) 2015 Sebastian Parschauer First version Copyright (C) 2008, 2009 Adriano Monteiro Marques Author: Francesco Piccinno 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 . """ from gi.repository import Gtk from gi.repository import Gdk from gi.repository import Pango from gi.repository import GObject class BaseText(Gtk.TextView): __gtype_name__ = 'BaseText' def __init__(self, parent): super(BaseText, self).__init__() self.buffer = self.get_buffer() self._parent = parent self.modify_font(Pango.FontDescription(parent.font)) self.set_editable(False) self.texttag = self.buffer.create_tag(None) GObject.type_register(BaseText) class OffsetText(BaseText): __gtype_name__ = 'OffsetText' def __init__(self, parent): super(OffsetText, self).__init__(parent) self.off_len = 1 self.connect('button-press-event', self.__on_button_press) self.connect('realize', self.__on_realize) self.set_cursor_visible(False) self.texttag.set_property('weight', Pango.Weight.BOLD) def __on_button_press(self, widget, evt): return True def __on_realize(self, widget): """ TODO self.modify_base(Gtk.StateType.NORMAL, self.get_style().dark[Gtk.StateType.NORMAL]) """ return True def render(self, txt): self.buffer.set_text('') base_addr = self._parent.base_addr bpl = self._parent.bpl tot_lines = int(len(txt) / bpl) if len(txt) % bpl != 0: tot_lines += 1 self.off_len = len('%x'%(base_addr+len(txt),)) output = [] for i in range(tot_lines): output.append(("%0" + str(self.off_len) + "x") % (base_addr + i*bpl)) if output: self.buffer.insert_with_tags( self.buffer.get_end_iter(), "\n".join(output), self.texttag ) def do_get_preferred_width(self): ctx = self.get_pango_context() font = ctx.load_font(Pango.FontDescription(self._parent.font)) metric = font.get_metrics(ctx.get_language()) w = metric.get_approximate_char_width() / Pango.SCALE * (self.off_len + 1) w += 2 return w,w def do_get_preferred_height(self): return 0,0 class AsciiText(BaseText): __gtype_name__ = 'AsciiText' _printable = \ "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ!\"#$%" \ "&'()*+,-./:;<=>?@[\]^_`{|}~ " def __init__(self, parent): super(AsciiText, self).__init__(parent) self.connect('key-press-event', self.__on_key_press) self.connect('button-release-event', self.__on_button_release) self.connect_after('move-cursor', self.__on_move_cursor) self.prev_start = None self.prev_end = None """ TODO self.texttag.set_property( 'background-gdk', self.get_style().text_aa[Gtk.StateType.NORMAL] ) """ def __on_move_cursor(self, textview, step_size, count, extend_selection, data=None): buffer = self.get_buffer() insert_mark = buffer.get_insert() insert_iter = buffer.get_iter_at_mark(insert_mark) insert_off = insert_iter.get_offset() if not extend_selection: if count > 0: # try to move forward if insert_iter.is_end() or \ step_size != Gtk.MovementStep.VISUAL_POSITIONS: # at end or line down: stay insert_iter.backward_char() else: # move forward if (insert_off+1) % (self._parent.bpl+1) == 0: insert_iter.forward_char() elif count < 0: # try to move backward if not insert_iter.is_start() and \ step_size == Gtk.MovementStep.VISUAL_POSITIONS: # move backward (at start or line up: stay) if (insert_off+1) % (self._parent.bpl+1) == 1: insert_iter.backward_char() insert_iter.backward_char() # set end always to one char in front of start end_iter = insert_iter.copy() end_iter.forward_char() # select one char buffer.select_range(insert_iter, end_iter) return True def __on_key_press(self, widget, evt, data=None): if not self._parent.editable: return False c = evt.keyval if c < 256 and (chr(c) in AsciiText._printable): buffer = self.get_buffer() bounds = buffer.get_selection_bounds() if bounds and (bounds[1].get_offset() - bounds[0].get_offset() > 1): self.select_a_char() else: iter = buffer.get_iter_at_mark(buffer.get_insert()) off = iter.get_offset() org_off = off - int(off / (self._parent.bpl + 1)) self._parent.emit('char-changed', org_off, c) self.select_a_char(buffer.get_iter_at_offset(off+1)) return True return False def __on_button_release(self, widget, event, data=None): buffer = self.get_buffer() bounds = buffer.get_selection_bounds() if (not bounds) or (bounds[1].get_offset() - bounds[0].get_offset() == 1): self.select_a_char() # return False in order to let other handler handle it return False # we want at least one char is selected all the time def select_a_char(self, insert_iter = None): buffer = self.get_buffer() if insert_iter is None: insert_iter = buffer.get_iter_at_mark(buffer.get_insert()) insert_off = insert_iter.get_offset() if (insert_off+1) % (self._parent.bpl+1) == 0: if insert_iter.is_end(): end_iter = insert_iter.copy() insert_iter.backward_char() else: insert_iter.forward_char() end_iter = insert_iter.copy() end_iter.forward_char() else: end_iter = insert_iter.copy() end_iter.forward_char() buffer.select_range(insert_iter, end_iter) self.scroll_to_iter(insert_iter, 0, False, 0, 0) def render(self, txt): self.buffer.set_text('') bpl = self._parent.bpl tot_lines = int(len(txt) / bpl) if len(txt) % bpl != 0: tot_lines += 1 output = [] convert = lambda i: "".join( [chr(x) if (chr(x) in AsciiText._printable) else ('.') for x in list(i)]) for i in range(tot_lines): if i * bpl + bpl > len(txt): output.append( convert(txt[i * bpl:]) ) else: output.append( convert(txt[i * bpl:(i * bpl) + bpl]) ) if output: self.buffer.insert_with_tags( self.buffer.get_end_iter(), "\n".join(output), self.texttag ) def do_get_preferred_width(self): ctx = self.get_pango_context() font = ctx.load_font(Pango.FontDescription(self._parent.font)) metric = font.get_metrics(ctx.get_language()) w = metric.get_approximate_char_width() / Pango.SCALE * self._parent.bpl w += 2 return w,w def do_get_preferred_height(self): return 0,0 # start and end are offset to the original text def select_blocks(self, start=None, end=None): if not start and not end: # deselect if self.prev_start and self.prev_end and \ self.prev_start != self.prev_end: self.buffer.remove_tag(self.texttag, self.buffer.get_iter_at_mark(self.prev_start), self.buffer.get_iter_at_mark(self.prev_end)) self.buffer.delete_mark(self.prev_start) self.prev_start = None self.buffer.delete_mark(self.prev_end) self.prev_end = None return bpl = self._parent.bpl start += start/bpl end += end/bpl if self.prev_start and self.prev_end: if self.buffer.get_iter_at_mark(self.prev_start).get_offset() == start \ and self.buffer.get_iter_at_mark(self.prev_end).get_offset() == end: # nothing to do return else: # remove old selection self.buffer.remove_tag(self.texttag, self.buffer.get_iter_at_mark(self.prev_start), self.buffer.get_iter_at_mark(self.prev_end)) # apply new selection start_iter = self.buffer.get_iter_at_offset(start) end_iter = self.buffer.get_iter_at_offset(end) self.buffer.apply_tag(self.texttag, start_iter, end_iter) if self.prev_start: self.buffer.move_mark(self.prev_start, start_iter) else: self.prev_start = self.buffer.create_mark(None, start_iter, True) if self.prev_end: self.buffer.move_mark(self.prev_end, end_iter) else: self.prev_end = self.buffer.create_mark(None, end_iter, False) class HexText(BaseText): __gtype_name__ = 'HexText' _hexdigits = '0123456789abcdefABCDEF' def __init__(self, parent): super(HexText, self).__init__(parent) self.connect('realize', self.__on_realize) self.connect('button-release-event', self.__on_button_release) self.connect('key-press-event', self.__on_key_press) self.connect_after('move-cursor', self.__on_move_cursor) self.prev_start = None self.prev_end = None """ TODO self.texttag.set_property( 'background-gdk', self.get_style().mid[Gtk.StateType.NORMAL] ) """ def __on_key_press(self, widget, evt, data=None): if not self._parent.editable: return False char = evt.keyval if char < 256 and (chr(char) in HexText._hexdigits): buffer = self.get_buffer() bounds = buffer.get_selection_bounds() if bounds and (bounds[1].get_offset() - bounds[0].get_offset() > 1): self.select_a_char() else: c = chr(char).upper() iter = buffer.get_iter_at_mark(buffer.get_insert()) off = iter.get_offset() pos = off % 3 org_off = int(off / 3) txt = buffer.get_text( buffer.get_iter_at_offset(org_off*3), buffer.get_iter_at_offset(org_off*3+2), True) if pos < 2: l = list(txt) l[pos] = c self._parent.emit('char-changed', org_off, int(''.join(l),16)) self.select_a_char(buffer.get_iter_at_offset(off+1)) return True return False def __on_button_release(self, widget, event, data=None): buffer = self.get_buffer() bounds = buffer.get_selection_bounds() if (not bounds) or (bounds[1].get_offset() - bounds[0].get_offset() == 1): self.select_a_char() # return False in order to let other handler handle it return False # we want at least one char is selected all the time def select_a_char(self, insert_iter = None): buffer = self.get_buffer() if insert_iter is None: insert_iter = buffer.get_iter_at_mark(buffer.get_insert()) insert_off = insert_iter.get_offset() if insert_off % 3 == 2: if insert_iter.is_end(): end_iter = insert_iter.copy() insert_iter.backward_char() else: insert_iter.forward_char() end_iter = insert_iter.copy() end_iter.forward_char() else: end_iter = insert_iter.copy() end_iter.forward_char() buffer.select_range(insert_iter, end_iter) self.scroll_to_iter(insert_iter, 0, False, 0, 0) def __on_move_cursor(self, textview, step_size, count, extend_selection, data=None): buffer = self.get_buffer() insert_mark = buffer.get_insert() insert_iter = buffer.get_iter_at_mark(insert_mark) insert_off = insert_iter.get_offset() if not extend_selection: if count > 0: # try to move forward if insert_iter.is_end() or \ step_size != Gtk.MovementStep.VISUAL_POSITIONS: # at end or line down: stay insert_iter.backward_char() else: # move forward if insert_off % 3 == 2: insert_iter.forward_char() elif count < 0: # try to move backward if not insert_iter.is_start() and \ step_size == Gtk.MovementStep.VISUAL_POSITIONS: # move backward (at start or line up: stay) if insert_off % 3 == 0: insert_iter.backward_char() insert_iter.backward_char() # set end always to one char in front of start end_iter = insert_iter.copy() end_iter.forward_char() # select one char buffer.select_range(insert_iter, end_iter) return True def __on_realize(self, widget): """ TODO self.modify_base(Gtk.StateType.NORMAL, self.get_style().mid[Gtk.StateType.NORMAL]) """ return True def render(self, txt): self.buffer.set_text('') bpl = self._parent.bpl tot_lines = int(len(txt) / bpl) if len(txt) % bpl != 0: tot_lines += 1 output = [] convert = lambda x: '%02X'%(x,) for i in range(tot_lines): if i * bpl + bpl > len(txt): output.append( " ".join(map(convert, txt[i * bpl:])) ) else: output.append( " ".join(map(convert, txt[i * bpl:(i * bpl) + bpl])) ) if output: self.buffer.insert_with_tags( self.buffer.get_end_iter(), "\n".join(output).upper(), self.texttag ) def do_get_preferred_width(self): ctx = self.get_pango_context() font = ctx.load_font(Pango.FontDescription(self._parent.font)) metric = font.get_metrics(ctx.get_language()) w = metric.get_approximate_char_width() / Pango.SCALE * \ (self._parent.bpl * 3 - 1) w += 2 return w,w def do_get_preferred_height(self): return 0,0 # start and end are offset to the original text def select_blocks(self, start=None, end=None): if not start and not end: # deselect if self.prev_start and self.prev_end and \ self.prev_start != self.prev_end: self.buffer.remove_tag(self.texttag, self.buffer.get_iter_at_mark(self.prev_start), self.buffer.get_iter_at_mark(self.prev_end)) self.buffer.delete_mark(self.prev_start) self.prev_start = None self.buffer.delete_mark(self.prev_end) self.prev_end = None return start *= 3 end = end * 3 -1 if self.prev_start and self.prev_end: if self.buffer.get_iter_at_mark(self.prev_start).get_offset() == start \ and self.buffer.get_iter_at_mark(self.prev_end).get_offset() == end: return else: # remove old selection self.buffer.remove_tag(self.texttag, self.buffer.get_iter_at_mark(self.prev_start), self.buffer.get_iter_at_mark(self.prev_end)) start_iter = self.buffer.get_iter_at_offset(start) end_iter = self.buffer.get_iter_at_offset(end) self.buffer.apply_tag(self.texttag, start_iter, end_iter) if self.prev_start: self.buffer.move_mark(self.prev_start, start_iter) else: self.prev_start = self.buffer.create_mark(None, start_iter, True) if self.prev_end: self.buffer.move_mark(self.prev_end, end_iter) else: self.prev_end = self.buffer.create_mark(None, end_iter, False) class HexView(Gtk.Box): __gtype_name__ = 'HexView' __gsignals__ = { 'char-changed' : (GObject.SignalFlags.RUN_LAST, GObject.TYPE_BOOLEAN, (int,int)) } def __init__(self): super(HexView, self).__init__(False, 4) self.set_border_width(4) self._bpl = 16 self._font = "Monospace 10" self._payload = "" self._base_addr = 0; self.scroll_mark = None self.editable = False self.vadj = Gtk.Adjustment() self.vscroll = Gtk.Scrollbar.new(Gtk.Orientation.VERTICAL, self.vadj) self.offset_text = OffsetText(self) self.hex_text = HexText(self) self.ascii_text = AsciiText(self) self.offset_text.set_vadjustment(self.vadj) self.hex_text.set_vadjustment(self.vadj) self.ascii_text.set_vadjustment(self.vadj) self.hex_text.buffer.connect('mark-set', self.__on_hex_change) self.ascii_text.buffer.connect('mark-set', self.__on_ascii_change) def scroll(widget): widget.set_size_request(-1, 128) frame = Gtk.ScrolledWindow.new(None, self.vadj) # frame.set_shadow_type(Gtk.ShadowType.IN) frame.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.NEVER) frame.add(widget) frame.connect('scroll-event', self.__on_scroll_event) return frame self.pack_start(scroll(self.offset_text), expand=False, fill=False, padding=0) self.pack_start(scroll(self.hex_text), expand=False, fill=False, padding=0) self.pack_start(scroll(self.ascii_text), expand=False, fill=False, padding=0) self.pack_end(self.vscroll, False, False, 0) # self.connect('char-changed', self.do_char_changed) def __on_scroll_event(self, widget, event, data=None): self.vscroll.emit('scroll-event', event.copy()) return True # scroll to the addr # select the byte at addr # set focus def show_addr(self, addr): GObject.idle_add(self.show_addr_helper, addr) def show_addr_helper(self, addr): off = addr - self._base_addr off *= 3 buf = self.hex_text.get_buffer() off_iter = buf.get_iter_at_offset(off) if self.scroll_mark is None: self.scroll_mark = buf.create_mark(None, off_iter) else: buf.move_mark(self.scroll_mark, off_iter) self.hex_text.scroll_to_mark(self.scroll_mark, 0, True, 0, 0) iter2 = off_iter.copy() iter2.forward_char() buf.select_range(off_iter, iter2) self.hex_text.grab_focus() def do_realize(self): Gtk.Box.do_realize(self) # set font self.modify_font(self._font) def __on_hex_change(self, buffer, iter, mark): return True def __on_ascii_change(self, buffer, iter, mark): return True def do_char_changed(self, offset, charval): hex_buffer = self.hex_text.get_buffer() ascii_buffer = self.ascii_text.get_buffer() # set text # set hex iter1 = hex_buffer.get_iter_at_offset(offset * 3) iter2 = hex_buffer.get_iter_at_offset(offset * 3 + 2) hex_buffer.delete(iter1, iter2) hex_buffer.insert(iter1, '%02X'%(charval,)) # set ascii iter1 = ascii_buffer.get_iter_at_offset(offset + offset / self._bpl) iter2 = ascii_buffer.get_iter_at_offset(offset + offset / self._bpl + 1) ascii_buffer.delete(iter1, iter2) char = chr(charval) ascii_buffer.insert(iter1, (char in AsciiText._printable and char or '.')) return True def get_payload(self): return self._payload def set_payload(self, val): self._payload = val for view in {self.offset_text, self.hex_text, self.ascii_text}: # Invalidate previous iters if hasattr(view, 'prev_start'): view.prev_start = None if hasattr(view, 'prev_end'): view.prev_end = None view.render(self._payload) def get_font(self): return self._font def modify_font(self, val): try: desc = Pango.FontDescription(val) self._font = val for view in {self.offset_text, self.hex_text, self.ascii_text}: view.modify_font(desc) except Exception: pass def get_bpl(self): return self._bpl def set_bpl(self, val): self._bpl = val # Redraw! self.payload = self.payload def get_base_addr(self): return self._base_addr def set_base_addr(self, val): self._base_addr = val view = self.offset_text # Invalidate previous iters if hasattr(view, 'prev_start'): view.prev_start = None if hasattr(view, 'prev_end'): view.prev_end = None view.render(self._payload) payload = property(get_payload, set_payload) font = property(get_font, modify_font) bpl = property(get_bpl, set_bpl) base_addr = property(get_base_addr, set_base_addr) GObject.type_register(HexView) if __name__ == "__main__": def char_changed_handler(hexview, offset, charval): #print 'handler:','%X' % (offset,), chr(charval), '%02X' % (charval,) return False w = Gtk.Window() w.resize(500,500) view = HexView() view.payload = "Woo welcome this is a simple read/only HexView widget for PacketManipulator"*16 view.base_addr = 0x6fff000000000000; # view.connect('char-changed', char_changed_handler) view.editable = True w.add(view) w.show_all() w.connect('delete-event', lambda *w: Gtk.main_quit()) Gtk.main() scanmem-0.16/gui/icons/000077500000000000000000000000001302526536600147725ustar00rootroot00000000000000scanmem-0.16/gui/icons/128x128/000077500000000000000000000000001302526536600157275ustar00rootroot00000000000000scanmem-0.16/gui/icons/128x128/GameConqueror.png000077700000000000000000000000001302526536600261172../../GameConqueror_128x128.pngustar00rootroot00000000000000scanmem-0.16/gui/icons/48x48/000077500000000000000000000000001302526536600155715ustar00rootroot00000000000000scanmem-0.16/gui/icons/48x48/GameConqueror.png000077700000000000000000000000001302526536600256232../../GameConqueror_48x48.pngustar00rootroot00000000000000scanmem-0.16/gui/icons/72x72/000077500000000000000000000000001302526536600155635ustar00rootroot00000000000000scanmem-0.16/gui/icons/72x72/GameConqueror.png000077700000000000000000000000001302526536600256072../../GameConqueror_72x72.pngustar00rootroot00000000000000scanmem-0.16/gui/icons/Makefile.am000066400000000000000000000006611302526536600170310ustar00rootroot00000000000000dist_icon48_DATA = 48x48/GameConqueror.png dist_icon72_DATA = 72x72/GameConqueror.png dist_icon128_DATA = 128x128/GameConqueror.png EXTRA_DIST = $(icons48_DATA) $(icons72_DATA) $(icons128_DATA) icon48dir = $(datadir)/icons/hicolor/48x48/apps icon72dir = $(datadir)/icons/hicolor/72x72/apps icon128dir = $(datadir)/icons/hicolor/128x128/apps install-data-hook: @echo "Remember to run gtk-update-icon-cache if icons don't show up." scanmem-0.16/gui/misc.py000066400000000000000000000163231302526536600151710ustar00rootroot00000000000000""" Misc funtions for Game Conqueror Copyright (C) 2010,2011,2013 Wang Lu Copyright (C) 2013 Mattias Copyright (C) 2016 Andrea Stacchiotti 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 . """ import sys from gi.repository import Gtk PY3K = sys.version_info >= (3, 0) # check syntax, data range etc. # translate if neccesary # return (success, msg) # if success == True, msg is converted command # else msg is error message def check_scan_command (data_type, cmd, is_first_scan): if cmd == '': raise ValueError(_('No value provided')) if data_type == 'string': return '" ' + cmd elif data_type == 'bytearray': cmd = cmd.strip() bytes = cmd.split(' ') for byte in bytes: if byte.strip() == '': continue if len(byte) != 2: raise ValueError(_('Bad value: %s') % (byte, )) if byte == '??': continue try: _tmp = int(byte,16) except: raise ValueError(_('Bad value: %s') % (byte, )) return cmd else: # for numbers cmd = cmd.strip() # hack for snapshot if cmd == '?': if is_first_scan: return 'snapshot' else: return '' is_operator_cmd = cmd in {'=', '!=', '>', '<', '+', '-'} if not is_first_scan and is_operator_cmd: return cmd if is_first_scan and (is_operator_cmd or cmd[:2] in {'+ ', '- '}): raise ValueError(_('Command \"%s\" is not valid for the first scan') % (cmd[:2],)) # evaluating the command range_nums = cmd.split("..") if len(range_nums) == 2: # range detected num_1 = eval_operand(range_nums[0]) num_2 = eval_operand(range_nums[1]) cmd = str(num_1) + ".." + str(num_2) check_int(data_type, num_1) check_int(data_type, num_2) else: # regular command processing if cmd[:2] in {'+ ', '- ', '> ', '< '}: num = cmd[2:] cmd = cmd[:2] elif cmd[:3] == '!= ': num = cmd[3:] cmd = cmd[:3] else: num = cmd cmd = '' num = eval_operand(num) cmd += str(num) check_int(data_type, num) # finally return cmd # evaluate the expression def eval_operand(s): try: v = eval(s) py2_long = not PY3K and isinstance(v, long) if isinstance(v, int) or isinstance(v, float) or py2_long: return v except: pass raise ValueError(_('Bad value: %s') % (s,)) # check if a number is a valid integer # raise an exception if not def check_int (data_type, num): if data_type.startswith('int'): py2_long = not PY3K and isinstance(num, long) if not (isinstance(num, int) or py2_long): raise ValueError(_('%s is not an integer') % (num,)) if data_type == 'int': width = 64 else: width = int(data_type[len('int'):]) if num > ((1< val2: return 1 if val1 == val2: return 0 return -1 # format number in base16 (callback for TreeView) def format16(col, cell, model, iter, hex_col): cell.set_property("text", "%x" % model.get_value(iter, hex_col)) # append a column to `treeview`, with given `title` # keyword parameters # renderer_class -- default: Gtk.CellRendererText # attributes -- if not None, will be applied to renderer # properties -- if not None, will be applied to renderer # signals -- if not None, will be connected to renderer # the latter two should be a list of tuples, i.e. ((name1, value1), (name2, value2)) def treeview_append_column(treeview, title, sort_id=None, resizable=True, hex_col=None, **kwargs): renderer_class = kwargs.get('renderer_class', Gtk.CellRendererText) attributes = kwargs.get('attributes') properties = kwargs.get('properties') signals = kwargs.get('signals') column = Gtk.TreeViewColumn(title) treeview.append_column(column) if sort_id is not None: column.set_sort_column_id(sort_id) column.set_resizable(resizable) renderer = renderer_class() column.pack_start(renderer, True) if hex_col is not None: column.set_cell_data_func(renderer, format16, hex_col) if attributes: for k,v in attributes: column.add_attribute(renderer, k, v) if properties: for k,v in properties: renderer.set_property(k,v) if signals: for k,v in signals: renderer.connect(k,v) # data is optional data to callback def menu_append_item(menu, name, callback, data=None): item = Gtk.MenuItem(name) menu.append(item) item.connect('activate', callback, data) # Interface for bytes<>string conversion for py2/3 # Usage is the same you'd do in py3, call `decode` on external raw data # and `encode` to work with the memory representation def decode(raw_bytes, errors='strict'): if PY3K: return raw_bytes.decode(errors=errors) else: return str(raw_bytes) def encode(unicode_string, errors='strict'): if PY3K: return unicode_string.encode(errors=errors) else: return unicode_string # Convert codepoints to integers byte by byte def str2bytes(string): if PY3K: return bytes(string) else: return map(ord, string) scanmem-0.16/gui/org.freedesktop.gameconqueror.policy.in.in000066400000000000000000000016101302526536600240570ustar00rootroot00000000000000 Scanmem https://github.com/scanmem/scanmem <_description>Run Game Conqueror <_message>Authentication is required to run Game Conqueror GameConqueror auth_admin_keep auth_admin_keep auth_admin_keep @PKGDATADIR@/GameConqueror.py true scanmem-0.16/gui/screenshot.png000066400000000000000000001445631302526536600165570ustar00rootroot00000000000000‰PNG  IHDRsÉî ¿€sBIT|dˆtEXtSoftwaregnome-screenshotï¿> IDATxœìÝwXçÚÀáßl§wbETì-Öh,i'Õ˜nÚI¾”“rÒ‹'=GSL=1&&1&šf¢)ÆĽwEé °°eæûX]¥ ˆbžûº¼dgÞy癆gß6 •vîÜiÚ»wï­eee“Ž@B!„â\qTÓ´ä°°°™þþþ÷îÝÛ ¬Zµ*255uAÇŽ{víÚ//¯³ªB!„8EII ›6mâÈ‘#›bcc/NLLLW8`Y³fÍÚ‘#G&Ÿí…B!DÒÒÒø믿¶ôéÓ§¿~èС÷&$$Üغuk4M;Û± !„Bˆ:øúúRXXØêàÁƒ¹º²²²ëbcc%‘B!„hAzöì‰ÕjhâIæ„B!Z€.:ÀK9!„BˆÉÇ­r’Ð !„B´<:.V!„Bˆ–JZæ„B!Z0i™B!„hÁ\-sB!„¢å‘–9!„BˆLw¶B!„ 'ݬBœgœN'( zݹõYMÓ4ì&£ñl‡rÎ*.)Ål6a4ê}ŒÃá`wr N§“NÚáY±ˆhõ'§ ²U!AŽYqö¹’9EQÎv,BˆRU•Ÿ–,ç÷«HÏÊF¯ÓL¯„xÆ\0ˆ°à³—¦iü¾r5®YÏ¡ôtJ­eøúxÓ=®3WŽCDXèY‰ë\¢ª*KW¯åÛŸ‘“NG\tn¸âR:¶mSãqÅ¥¥,þó/~^ú'…E¼òøCµóñÜoY±n·\ýÆÚ´#„8+di!Z¸R«•ßþ€¤-. &£‘ô¬lÒ/¡¼¼œÛ&^Õìq•Ûl¼ôöìNN ÀÏ—À@2srY½i 7_u¹Üw€9óòÃo@iY;÷%óä«oðü#÷Ý®mµÇ­Ú°™9ó¢×ë1 ØE©ñ=ݲk+‘j-+„h:%V+oü9÷Þz^•­ç%V+¯¾;xôîÛ]ÛBºY…há>ýf>IÝ®-ÿ¼q¢ë©ÕÊêM[HìÚå”cš²5¾¦ºf÷#»“Sˆn×–Ý~3Qá­€ŠnàŒì|}¼O¹÷œÍ^‚êÎ]xìk7o£o÷n¨šF~AQá­°˜Íµ[ßãö¥à‡ßþÀd2ò܃÷ÒµS ªª2û»ùöçE¼9ó3Þšòdµ]æôëƒÝá`ä <3õ-¤®ñÚÊÊË™1ga¡¤geŸöû#„h8»ÃAIi)¯¾;ƒGï¹€WßÍnC×Cb¤eNˆ¬ °ˆ¥«ÖâéaáéîÆÓb¡¬¬ ½NÇ}{£ª*š¦¡ª*S?ü˜¤)))%$(!}{sùE£H9t˜§þû&Cû÷åHf&‡3² 䢡Cؾwûö§¢j*Ãöãê cQ…‚¢c|2ï;¶íÞƒ—§'ƒz'rÕø1 ŠKJY´|%&“‘Çî¹_o/W\!¨ª @ѱb¾˜¿€­»öPVn£cÛÖL¼tÑíÚtà Oý÷M† èKzV6ié™ø3aÔ0†è@vn_þð[víÁÃl¦{×ά\·‘ £†Ó¾¯¾7ƒ½zrÿäxéíغ{/Sº—Î;ÔzÙ¹ù|ôå×|ÿëbòŽÐ6*’מx¸Ö¸k;îD«6n`¨áÄ´këz&^:ž•ë7’•“KòT:uhÊ÷Þd4pñ¨ác$+Õt/Ÿ·àròòÜ·~~¤/^"÷}!š‰—‡·^{%ïΚÍnãå·ÿ‡8t:÷Ü|=^ú}”–9!Z°”ÊÖ˜˜öíñ0›QU•™_}ÃŽ½I®2³™—{ ØŸšFçŽ0›LìJJæëŸ~Ål6Ñ%&€5›¶Ð6*’V¡Á¤¦áÃ9ó0™Œ´‹Šâàá#|÷ËbbÚ·#¾S SÞx‡ŒìºuîÄÑÂ"æ/úR«•É×^IÊ¡4¢Û¶Å×Û«Ú8¨èŠ}öõ·IÏÊ&¶c{|½½Ù¸}'ÏL}‹—{Ðõ‰uõÆ-´Š ]ëHö$§ð¿Ùs‰íÐ?^˜þ>Y¹yD¶ #0ÀŸÛvb³ÛÑét®ãOüä{â6›Í^ëuTµ¶ÙlvF_0£Ñ€Ãá¨3;YnþQÚEFº’[¨h½ìЦ5Y9¹dç­6™ª­ód)‡ÒøiÉr¼½<¹õš+ùöçEu#„h:š¦Õ*Œ{n¾ž·?þŒCéhT´’ßsóõDµ sûýo×”)Iè„hy̦Š™¡¥ÖR×Í  è˜[7šgå'>˜õÆ+ä- =3‹Ðà ¾ýy;ö&Ý€ÎјòÐ}hšÆíÿ~ŠÜü£¼û³„òãoðñÜoÙ“œB᱊sôëÙëÿq ªªòø+¯óûÊÕ\ù%n1Öv“Z¹~#éYÙ êÈÃwMà·?ÿâýÏæðí/¿qÉ…#Ýâxÿó/Y´l»“SÐé²róЫÿþgE×Å¿ýÁ¬yßî÷µêÊ¿6nªõ:ªŽéж5wÝp­ëØ_—ýY¯¸O>Îf³¹Å`¨œµZV^~J|å•eM&ãiÝŸO,ët:ùßì¹hšÆ-×\—‡¥Æ²Bˆ3Çétâïëƒhh høûú¸µ®7”´Ì Ñ‚µŒDQRæHf6‘­ByüÿîD¯×c³Û¹òŽ{]eËm6^{ÿ#6ïÜíVGYy¹ëkMÓ\]}þ¾>äæ¥ðØ1|¼<ññöÀZVÆ‘Œ,ÖnÞÊÚÍ[ÝêËÎË£}›( ¢U¨ èþ¾>ÕÆŸ‘ @L‡v”WÆѱmëŠ}Y9ÕÇåããŠûhå,ÎØŽ\ÇŸÎ'ܺ®ãÄ󟘈NÜ''p'jÎ*`oÊ.è×ÛµÝf³“r°¢u3²3~W¬ßHêá#|8{.3¾˜‡Ýnà³oàË~â©ûþIt»šgÀ !¯ÔjåÕ÷? 4(xåÝyôŸ·Õº¤P}Ș9!Z0/OÆ ̯ËV0íùsÒ5têÐ8Þ²¿ã¿.[Á滹 _.»èB ‹Š˜òÆ;®ý'–=ÙÉ÷ˆªõɆôë;½ÝÊ`1›6 /ËV¯ãõŸpç¤k\ËØgdÒ¾uQáaìÝ€ÑC¢( {÷ *"¼Î¸ÂC+–\I9x¨Úý³ €£…EÕî¯ë:W&{'Ÿ¿±qW¹ ¾ÿu1KþZCL»¶ îÛ kYŸ~=Ÿ‚¢"âb:ZïûóÉß'›Í~Ê E§UE_Ù ­ÓɬV!ΤR«•×>˜‰ÍnG¯Óqßãwß5»ÝΫïÄ¿ïšÜ¨„NZæ„hÁ4Mcâ¥Øw •”ƒi<ûúÛøúxàçG^åx¬ªñ[UcÅ2²³Ù¸u;ûjðyõIäë…¿²aë :=Aþ+FQ:wªèÖ»ú ’S±/%•‡ž• ¼<=8’™ÓéäÅ?À Þ‰üøÛVoÜLN^>>^žlݽƒÁÀUã/¢¤´´Ö8÷éÍw¿,æϵÈÌÉ%Èߟ½)\û;¶mƒÅlfç¾$ž™6½^ÏÁÃéõ¾Ž¯¿‘qW ôóåöIWóÎ'³ù`öW̘3geË¢§‡÷Ýz#š¦±dÕfÌùš@?Þ}á6ïÜÍüE¿¸ºÕßÿüK,f3}{$0~ÄPÆÊ¥cF¹ó£/¿fÁâ%Üxåe\|áÊÊÊ=^GQ3EQШ˜”vÏÍ×À=7_Ï»³f£:žÅ/-sB´p&£WŸx„/ç/dÑò•+¦èX1z½ž^ ñ®±_c‡_À®¤ýlÙ¹›¤iß&ꔥ2 ú±e'ß#<-ž{è>Þ5›¥«×º¶÷îïJ LF¯?ó8óþŠuÈÊÉ%ïh&£‘^ݺ¢ª:Eá¥Gä³oç³eçn2²sèÞ¥37]y9­B‚HN=äÇÉÿ z^}âf}ý;ö&‘•“‡Gå¸0MÓÐëtœNç)qÜÚtòyOžæt:O¹–ÕvÕ¿¡qצ®¤/,8È5v®j9»ÝÞ d¬¦˜…gNMyVS qnV!Î3uý.7õïúé Îon ]Òã\ãt:›dù!Äù©ñÏBˆsHxX(Cúö¦MdÄÙE!š…´Ì !Î+ÝãbéÃá1aBˆ¿3'„8¯8Žz=æJ!ÎÒ2'„BÑ‚é@Zæ„B!Z*i™B!„hÁ¤eN!„¢3xxxHB'„BÑÉ:sB!„-˜,M"„BÑ‚IËœB!D &ÉœB!D &ÉœB!D &ÉœB!D &ÉœB!D &ÉœB!D f8Û!„Bœ«œN'G%''»ÝŽ‡‡ÁÁÁøúú¢×ëÏvx€$sB!„§ÈÍÍeÝú ¬Þ’D^±L¾ 3¢8ËÑìEû˜éA×Î1têÔ “ÉtÖb•dN!„¢’ÍfcÅÊU,Xº‘bK[‚Û%" EW•2i¨N¥…¹,?´Ÿß·­&Äôý{Äзw"­Zµjö˜%™B!„ŠŠŠ˜=÷[6¤: ïv%aáhšzB)½Á„op$~!­q:l”ä°`Û­ú’!=ÚpÑè‘øûû7[ÜõJ殺îzróòNÙ>õ•—èÕ³g“U—5k×ñäsSøß;Ó‰îرÎò—]u …EEÕî{úñÇ1lhS‡(„Bˆ$77—Ÿ~EŠ­5@o0”ĹÓ4 Ms¢èôx…ãõØQþس’íû>æί¤M›6Í{½[æ{ô`ü؋ܶµo×®©ã©MÓPÕšßà“=ôÀ}Øí·mó¾ýŽ©©ôèžÐÔá !„¢9zô(ïÍœC¦)Žö‰CÅí¹õŠN‡¦ªhšŠ¢((ºŠ‰ZU.¢ihš†‡·?zO #y|ú Þ7??¿3½“¹ÈȈ3Þ‚¥ª*¹yy`0œZAAÖ²24´jŽ®ÙAƒÜ^çååóÊÔiŒ¿h ŠY!„-×±cǘñéWd™:Óºë•I\Ež¡( N‡œÔ=”fïGï,AUŒ(žÁø·Á/´ “¥â˜Ê„ <ºÉ™ûض}CªåìM£IÆÌ3ã“Y¬]·žRk)q±¹ëöÉ´o׎œÜ\®½á&þýà¿sá(æ/XÈÛï½Ï_ÏÅZVÆÕ“n`øС¬^»–²²2<==yòÑGØ¿?GÒÓyuÚëlß±³"蓽'ßNQQó¿ž[¯xç~ó ªªríÕW5Åå !„¢²ÙlÌžûÉÖV´KâÞ§è(>šIÆÖ_èÒ ú ïJpP¥V+i‡ÓÙ¼’ý{Ë1Gt'´]&‹÷ñnYEÁ`ñ¢¬¬¼Y®£ÞÉÜ‚Ÿ~fÁO?»^·kÛ–O>üUUyüégÉÍËã¶[nÆÛË‹oçÏçÿxY}T´¸ØšV]7©ÝnãÙ'',,”ioNçéï0°ìv;OOy£ÑÀûÓß$À?€ß—.å£Of¹ŽíØ¡Å%ÅõºŽÂÂB~üégFIXhh}/_!„çMÓøuñ¬;¨ÑqÀ(*ž£PÕ"§£ û ùÛæsø¾ <È­!©Wb"ãívÒÒÒømÉJ6®ÞŠGë~„¶‹Ç`²P”{­`?qû7˵4xÌœ——'Û¶ï`Ç®]¼öâ ôéÝ €nñ]¹bâ$~X°K/žP¯ú @ÿ~}Ø¿3>™Eii)û’’9šÊôiSé @‡“Æê=ûäãõ½ ¾ù~>v»I×^Sïc„Bq~Ù»w/?­ÜCë>×UNv8ÞµZ\Eþö¹óšôîÕ«ÚãF#:tàÎöíIJJâÇ_—²kÅ&œoŠ–µ™Ë'ŒF¯×ŸÝ H’9!„Bœ÷V¯ÝˆæÙÓÇÕ½ª ¹w Ã;ÙÈÞÆr88ÎFÕÑlݬB!„gCii)ëw¤w•ÛâÀ¥Çò°”`ÄÐIÍ“ÍfcÉâŤïÙF#}GŒ >>¾AuI2'„BˆóÚž={ÈsúÑÁ7ÈÕ* y·3°K$Á\ÇödªªrðàAR ?3[q1š¦¡70ûøàÈžíÛi•’ÂÅ‘‘ñÓÌ™<ô‘ XlX’9!„Bœ×¶ìØ‹GH'ôzªê¶2ì9»¹àÊË]8h,›ÍƖ͛ټt)–œ¢48¼FMái;dÒÖáàš„Ì&( ¹»v±aÝ:Iæ„B!NdµZÙžœA`¨•O{Pt …9‰³~Úu:ÊËË)++Ãf³a6›IOOgõ¯¿â}ð —FDбS§ŠD­&•³iQUÐéhïïϾôtœNçiOÄdN!„ç­P¦ó%ØÓ÷x«¦Q˜¹Ÿ=ÛÕ¹ö­ªªX­VÒÓÓÙŸrôÌ, Š­ä;((q‚j£S°‚>5•1$vïŽA§«8—ªÖZ·‹¦àá3?»ÝÞ°d®êI gš¦5Y3«8¿äçç7Y]š¦‘™IfV&¥ÖÒ&«·6žž´ kE«ÐVò3.„øÛIJNAóŠ@§×»Ö–s:è‹ÓµË%5—ŸŸÏ¶íÛÙ¾;…¤#”+ž(^á½;`ñöÇâC„Å€nÿ¯„ìßÈÕ11„x{W$q®qy@u÷Ý÷Wò2™pa³ÙNû Ò2WIUÕ»¾Œh92³3±Ùm ì?‹¹ySV^ÆÞ¤½dfgvúÝ BÑR©ªÊ‘Ì<<ü€Ê¤JQ(+.ÀÇä ¼U«SŽIKKcÉŸ«Ø°ûeæH¼B»Ø³‡ŠNŠ0heX·|I÷Œ]\‡ÑXmWd-%¿ÔŠSÓÐ) ~ žžî'Õ4,F#ªÍ†ZßÖ¼H2WI’9Ѳ²³Ðwzžòòòf9§^§'6:–ÕëVK2'„ø[)++#-§¯˜`ÐŽ?ñ¡äh&¢‚ݺXív;¿,ZÌÏ+w£„v#´×,^¾ èÐ44­rY“RNÙÖyôÉÜÍ•q]0 §´¶¥æå±<#Ýe †ÐV¨š O53“¾&£££Ýû5êt¨ÇñOƒ$s•’ qº¬V+f³›ÍÖlçTU³ÙŒÕjm¶s !Ĺ ¼¼œÜcå´ñòw[_ÎZ˜MT\€ÛГ%K—óíÊTÚö½Ÿ4µ2yÓÜôõ6:±ïZHü‘\Ñ¥ &½þx"§(”Ûí,NÙÏJÕ€Úujh7Š­V26~˽“FÁ—o¿MÛœâBC/`¬(hª*É\cTÍpâLÓ\Ÿîš÷œBñwS\\Œ¦3¡7˜€Šû ¦©Ø¬E´v•s8ü¶r ‘=®ÄÃ;À5¶îDŠN‡·YÁ;k%†=«¸ªKWÌ'¶È) EeeÌÙ½‹¤Ö „÷½Œl‡?8Uü9+ÇN§£ß¸q,ûâ bƒƒÑU&”ev;šÑØ ^ByœW%i™Í©*¡k®€L~Büíäåçcôðu›ƒ :è5ž^ÇÇ­©ªJi¹‹—E—j%EÑ¡(:œ…Ù)MÛ@Ù_ ™ƒ·Ùì–ÈZ­ÌÚ½‹Ô®#0ö¸ž,›ªS£¼´ˆ@‹qcÇ ÓU¤]Ý{ô /,ŒõiihŠÂªC‡ðêÔ Ï“ÇÓÕC-s9¹9|üÉ t:wßu/^^^µ–_·~ K—-aÐÀ! 4ä´÷Ÿ-ªóÔdîãY‘““ÍèQcèÙ³—Û¾ `×î\0dú¬±Þôô#|þŧtìÍ•W\Ýäq‹–EQ4MköÒ2'„ø;*..ƒ‡Û6Mu¢×xzßn0hÓÊŸÌ#I„G÷¨ìbU)ÊM#ïД¢ƒ´2á8¸‡„‡êãã–È•”—3')‰Œø‘è¢Çbs* i(:=E9iÄ´vŸg6›7iógÌ`óŽØU•<®¼âŠ:—J©NÉܶm[€Š¬uÇÎíôëÛÿ´OÒT×ÍšÐ-?–üÎÎÝ;Ý’9§ÓIòþ$ºvéÚl1ŠóCmݬ[·maé²?°Z­šVçÿ‹£F\Hbb¯jë•dNñwäTUàÔnKƒáx ¤Óé¸lìpÞüøÒl%˜=ý)LÛF¨ñ(ã:Ò«çå,ýågb<-Ä……¹Mvp8|³okôÞ†öÅP™È iËN¡Ë 6§ôŽ´k׎Ûœäädt:ÑÑÑ j•ƒ:’9‡ÃÁŽ;Ðét¨ªÊÖm[š4™+))a_Ò^bb:¡iÇŽ#$8¤AYicU×RÒ%.ž¥Ë–päÈa ðóó 5õ6›ÖQmðõõkîPE W[2÷Ûâ_¹ä’K‰Äl6c2™1›ÌFl¶rÊmåÿ—Ÿøµ¬¬L~þu!={&ÖxγÝͪª*ÇŠ‹ñõñiT,MUâïJC§œ:ô$®sg¾ÝÀ’?WQ\º‡‹Gt¡oï+ðòòbãúõhÛw0">þ”åGþ8p€ÍF#ºPM>n»í奘Ê2è;¨ÚH¼½½éÑ£G£¯¨Ödn_Ò^Êʬôì‘HFF:™Y™¤¥¢uë6®2Å%Åü¹bYef© ×»WYÛþÂÂ~[ü+kÖ¬¢èX¡¡aÜrÓdJJJøýß8p ‹‡…¸Î]<è×ÀÀõÖ±uëf ðòô"<<‚Ë.ýGûjR]2çééItÇö%íe×î è_ñÍØ»o]»Æ(¿›ÿ éé锕Yñóó£K\<œúÍÛ¿?™o¾›G\ç.\rñeÌûæ+HaÒĈŠj]絋–«êæQS2gµZ $zô¿kIT4ô•ã.4MéjüùÙ}­yMØg·ÛY¹jó,dÛöŒ»h üë˯\µš§§ü“ÉÄ¢?¸¶'%ïgÖç³Ù°i“k1Ì‹ÇåÎÛ&»~¦ës®úÔÓXó,äí÷Þç‹O>aÒ-·pçä[¹úÊ+N)WZZʼo¿cðÀDwìØäõ7Tyy9?þ—]|1#‡k²z…h© zý)³QAÁ©)8'o‡˜˜hbb¢Ý¶°j©ÊÀ IDATþ|nhÓÆ}-9EagVku:<"ÚâcèŠÁdqMžPY©´µÐªšõìšR­Éܶm[ˆëÜ??2³2Ù²m‹+™³ÙlÌ;‡Ü¼\BBBññö&+;Ëu|]û]åìvº'ô@¯×£ª*‡ƒ9_ÍæèÑ|Ú´nKII1kÖ®¦Üfcô¨1ìOIfÉÒß±X<ˆŒˆ¢ÔZÊ‘ôõî«MMc˜ºug_Ò^vîªHæTU%)yz½žÎ±Š?¨éD„G`49|8¿V­Àd2ÙºÚzkR×µ‹–¯¶–9§Ó‰S­¸Á„Ç AU5ü½-D{³÷PÅV;]ÚâƒÃ©b³;øé‡oÐ):œNgõ6$É+))aÚ[oÓ;±'þþµ–-µZyëwkØ«a±˜yøûñññ!)9™YŸÏ&$8˜«®øÇiœ«îzkÙŸ’Ð-??_TU¥¦w­¤´”OgA«Va§•ÌÕ·þ†RU;w1x`Íãx…ø;ñô°€Zæ¶MÑéPVkY G¹[¶x1Ýl6Ú¹%r¥¥,ÌÉ¡Í°aü¼îá}ÐÔã¿Õšê¤ðà&®½¤§kâÙRc2WPp”ƒ‡Rñöò&*ª5¾¾¾,[¾„½{wsáÈÑX,öíÛKn^.±:»Z¾ª&8uî¯ÆEcƹ^oß¾üü½ùé—_INI9­sÕ§žÆ(((dûŽÜ{÷ñókšFn^š¦äzC‚ƒYºè—SêPU•Ü¼<Nù]=ú«8Š‹Kðööªöw¿¼¼£ÑX튲²2Ò32 ÆÛÛûôÞ !Îþþþ8J¹}pÒé Ø1sìر:?rä«Vñèh”¦±0%… ~}Ù‘tsT_LÞ'µÊ £˜nññM}Y§¨13غ½¢U®¸¤˜×¦¾ìÚît:Ùµk‰‰½ÉÉÍ 22²Ú:êÚ_“œÜ’’÷‘”¼Ïm_AÁQ:ÇÆQXXȆë˜÷ÍWFºuëÎð¡#jÝW["TS2§ÓéˆïÚµëÖ°k×ìv;p¼‹*È|Ïþ”ýnÇV•mÊk9í:Ź¥Î–¹Ê¦‹Å‚N§Ãdö  ¸œ Bü=°ÚUì'å6å6:Eiò–9S=ƯîKJæûpçä[q85–s:ääæ²à§ŸÉÊÎføœö¹êSOC­Xµ MÓ¸`Ðñá}2‹ÿ}4€¶mZóèC×9–œÜ\®½á&þýà¿HìÙƒ«'ÝÀð¡CY½v-eeexzzòä£0°ÿÕð¯?ʶí;PÕŠÚ—NÏ=w݉¢(,þã>ùl6™™˜Íf.7–{îºÓUï bæ¬O±ÛíF~à~FÙ$ï“-‰¿¿?ŠZ†ÓVŽÞh*>üzø’‘Sçñ«–,¡Å‚¿‡‡[«Ü®ÌLRýý1[í¤”Ò¾k7·µéTÕAnÒJnÛjo:Õf7ªª²cû6 b–\Õ‡E§Ó‰Ífc˶-$&öÆß?€Ì¬S»N:÷×ÄÏϨèÞëÜÅmŸ/%%%tOèA¿¾ýÉÎÎbÉÒ?Ø´i¡!¡tì]ã¾î 52¬m©ˆnñ ¬]·†»v i‹ÚïZÙ¸iûSöÓ%®+}úô£´´„¯¿™ëVGU×™ÉTñÃT\RÜ k-_íÉœêJæ||½1 `0àçoÁdÔ£:5N6M‡MÕ(wTýÜž™d®.ªª2í­·èЮW\~s¿þ¦Æ²¯O›Ÿ]À…#FЯoŸ³¾õpðPšÛ¶N11xxTÿLÜ?W¬ [|W]Ý/cGæÚ«¯¤¼ÜÆÿ>šÉÏ>˧ͨì&=þ¾Úí6ž}âqÂÂB™öætÞ˜þŽ[2w:õûúøØ£—]|1a¡!¬Y·žOgAî „· ç¥×¦rÕÿ`üE‘—ŸGr²ûɶmÚðïÿEDD8¯O›7ßy‡‘Çɸ[ñ·ãááAx ¥Çòð ŠDÓT4UÅ7¤ ;ö-æ2‡£Æ†ž¬¬,r·lẎÝ&=”Ùíü’~„â6íÙ¼¿”Ö}®ªxfkÕšž:ÙÉÛˆ(§WbÏf¹Îj¯ %e?Å%ÅD„GpÃõ7»¶———ñþï’““MFf]ºteÍšUìÚµƒ¢ÂÉÍ=žéÖµ¿&q»²ò¯•ìOIÆ`4àëãKii)( 11ؾc+,ù|¼}ÈËË (0ˆ={wÕ¸¯6µ%sAAÁDDD’ž~€ž=«½)-8ÊÁƒ©dd¦»¶UM3>|8o¿ûšž=1M¤¥âó/>E¯Ó“•Yïk-_}[ævýõCµeª£(œ•dîû”¼Ÿ÷Þz£ÎDáÒ èÒ¹3›¶lañ’%„„†pû-7Ÿö9ë[ÏÖí;xî…ݶÍxïjǸ±iËVî¹ó·íQQ‘DFDðȃpÕu׳bå_ôíÓû”: @ÿ~}Ø¿3>™Eii)žžž§]ÿø±qÃuŠñ„:žOgÁþ”DEF¢( ÙÙÙ”——Ó³{wOš ×=¡ÝºUÆÒŸ5kב›—GXhhï«ç#³ÙLûp?6æÁ78 ´Š'@xGq`·Ž]»v‘Pí±Ö®%^§ÃÇb9žÌétlHKã·´ <½»Ðºïe˜,^',ήÃZ”‡õàŸ\uûåX,ÕxljÕ&s[+×–8p°Ûv³ÙB¯^½Yµú/¶nÝÌEcÆ1iÒ,[¶„´´CääæÒºuk׸³É\ëþšxzzrÍÕùåןØ^ÙB@«V´iÝ–ìœ,rrs ¢_ßþDEµE©y_-êzœWB·î®d®k÷þï^‰½9”vÔÔdd¤†©²9×ß?€^‰½Ù¾}Ù9YŒ.»ì –/_BNN6ÄÄtbçÎõºvÑò©ªZí‡EQÐëõdee²ö«G0M&ŒF#z½½^¢TÎ`u:q8Øvìv‡Æ 7¸Ū±ygr‘âœÜ\fΚE׸8Ž-`õšµLKÃét²zÍZüýý]]†b¢éÍø±ÈWó¾fҵ׸-ÜYõ­gèÁÕŽk«ÎªÕkPU•!ƒ«_> (0£ÑÈ‘ôôËTñ¨üWõ¾7¤þ?–.ãÍ$'7×um‡ƒvmÛòÚK/òÑ'³¸óÿî¥}»vÜ~ËÍ è߯Úz-æŠ{‘¬5(þŽE!>.–¿~ÜŠÖéø‡0½Þˆô`>ýö7î÷÷§M›6nÇÙl6Ò6nä¦ðpªº'NÛŽáý=1t¹˜ö/Ãhö<áwKÁa/ã𦟸zxÂiMŽj¬j“¹+þqU <”!ƒ‡º^ûúøº–بN]û}ä‰j·· kÅ-7M¦¼¼Œâ’¼½¼\¢"£˜xí¤j«m_mêúc×=¡GÝ´&“‰k®šˆÕZ (§ô9šQ#G»mkßn²Ûë ã.q}]Ûµ‹–¯¦–9MÓ7vç¶ï‰gŸ£Oï^¼öâ Õáš¹ÞMUÏò+éGHppe²sr°Ûí„„œþ¸ÕÓ­?)9™^y•Þ~—]z &£‘1_ê*Û;±'½{²?åo¾óÏ<ÿ_}öiƒâ|ß•ÀŸ–s,/ßਊ®VM%(*–̲^ý`#út¢O¯øúúVNð܇)7à ÒòrÙ_ÀʬBvZ"ðó/º´‰CQtn‰œ¦:HÝô+¢-Œ1¼Y¯ñœŸi6[š%‘©îq^§Ëãio¤Íuí¢ùÔ5›µOï¾ôéÝ×õ:9eÀátQÙ—žžŽAo mÛöDwpïzoÊnÖ¬¬lö쫘„SRRBFf&ËW¬D§S2h£GŽdÄ°anÇÌ÷5Ÿù ¿ÿ–ªÔqñàpªt댟¯/»vïáÓÙ³éß_Ÿz«¾õ4ıcÅlܼ™;n½å”}{öî#å@*¥ÖRfΪH–†]0䴒džԿ/©â 3²jõׄª½ûö‘’z˜èŽ˜ŒF¢;td÷ž½ 2NˆêX,FìÎÜ•+ñ :ᱚšFxt"%Á­Y¼o3?¯û?‹‚¿‰ÌÇ!ßFò®,r J` ÞiÖ£ÉRñüÖž{ít8HݼˆîÁǘtÍÄføÁ9ŸÌ5—ººY…h*µ%s'›1cïL‡Ãv|cO0LÜýwqëä›QP0M…âëSýI’ÌmÛ±—^›êz“›Ëæ-[]‹ët:L'-‰QѬ¸ÍLݸy ‹ÿXâÖúߥ‹Û2#u«¾õ4Äêµkq8ÕvæÍç¶Þ¦iDFDðò¦àïONnî­¿O¯^Œ5’—^û/±:À±â>øpE•Ë*xzzòà}÷âççWïu³„ø»2x ë¶~LFò&":õvÍ<Õ4 /ÿ¼Ç :ì”—Ãj³â¦¢ètèŒÚxú¢7Q´ªû÷ñ{¢Óa³spãÏôŠtpó¤kÏJ ¹2gÎmâĉÍ~âsÍÞ¤½ÄÆÄÖ]Püíäçç7Y]ë7­§o¯¾X­Öj÷-8ÊÏ¿,ÀZn#¼U‡dîú?#3 Õ©a0èãhþQF_8^ONN&±1Õ?+ØÃÃõ›ÖÓ»ç©÷›CaQ‡¥QXTD«°P:vèРnߦªçDO=7…ÜÜ<>xgzµûËÊÊ(·ÙðómØlòÆÔŸô(šªàvªªRPXXÑ-|Æ$â|pèÐ!ÞœñZëQ„¶‹¯˜~ÒÝŠß³ï)Õø®ú}<š™JÞîE\˜Åå—ŒÇl6ŸÁ+¨Þ¢E‹$™«²{ïnâbãÎvâÔ”É܆ÍèÕ£eeÕ· ,ûs)f:E¡¬¼ÜµÝd2a³ÙhÞ £ÁHii)yyyèuzòrsˆíK€a!áÕÖk±XظeãYKæÎeùùùŒÆFuÕžÍú…õ·ÿ~>œ=Ÿ"¯x"âT>~Kƒz=E©œ ¡PR˜CÖ¾5øÛS¹züôéÓ°¥–šÂ¢E‹*ºYwîÞyÖ‚8—Èû ªV}‚ÔPµu³.]º„)Ïý‡ÀÀÀzÕ•—ŸÇ³Ï>Äq—¡ÓéštÌÜßE}ßësµ~!DýuìØ‘‡ï¾‘¯¿ÿ‰+?Ã+*‘€ðŽ˜<}ÐL U­©QÕB§( ªÓ½¼”⣙ÚŠ§-1‰5|2þu<î°9ºÆUß5#„hÚ–¹º&@”••qç]wT»¯&þþþ8ÎZ»ÏÄlV!„h‰BBB¸sò ìÝ»—å­'yÛz œÞ(f?ÌÞèèôFp:pÚJ(/.Àq,—â¬$b:†qÍ >ôìq!AAµ¯_Ûœd„ÍLUk~†êK/¼Òàzkk};ëÌ !DK¥×ëéÒ¥ ]ºt¡  €#GŽ““C~Á16o^s_2 ÁÁøè!ؤÇÏlâw/+—Þ2‘Ö­Oï™ëÍA’9!šÙéÌfmÊs !„8•¿¿¿[W©¿§ Sù1.éÔ©¢·U§Ãn·³Éf«¹’³L’9!š‘¢Tåq õ%+M ÑŒ¼<½\ÍôU-tgúTÌ’õòô:›—.„-‚¯¯/Z«V¤AÕðM#6$]j*;vìhP½š¦±~ýz¾š:•„ôtî‰g|çÎü³G<·ogÝÚµ Ž¹Ù’¹î}ú5y+þZŸK/§Gßþ5ÖŸŸ”cÆ6Éù׬[Çu7Þ\c]kÖ­ã¾fðˆQ :Œ‰7ÞÄ‚Ÿ~v+³yËV{êi†^8†C‡3ñÆ›øaáBéû›hÖŠü‚ü >ÊËËÉ;šG«°VÍvN!„h©, QññlËÉqÛn6βyóÈ=GúòÍìÙìøüsnfTÇŽ˜ôzÐ4Œ}ÃÃ9¼woƒcnÑݬ¯M›ÆÓO½klò|ù¿S?n,ŸÍþ¢Ñç›1ó¼ÿ>&ßõÏj÷ßyϽôNLdú´©tíÇ‘ô ^:ŒŒ î¸m2o½û.W]ñ¼ÿ>üýI;|˜×^ƒÃ‡pÏ]w6:Fqn  2²2š-¡³X,„‡…ˆÓél–s !DKÖ«_?¾Yº”aV+~ýÒ4☜Ì7}Ä•·ÝFppp­õØív¶lÞÌÚ ˆ·Z¹¡KÑ´šrÑ`£ÑˆÁ`h¶çiªªŠÃáÀn·7Ëù„¢¥Ó4ïçÎ%pÃþÑ¥‹[òåÔ4–¤¤ðÐgÂz&&b6›]ûN'………ìܾÝkÖà™–ÆØÖ­‰©.ñSÒ ˜™’ÂE÷ÝG§NN;V×ã¼ê²|Å >žõ;wïÆËË‹¡ƒóð¿À×÷ø³—,[ÎŒ?&y AAÜuÛm\vÉÅnõÌ_°3?&3+‹Èˆn½ù&.»x‚[™úÔsb7g¾ý]_Ÿ˜`óÂ+¯ðì“O6x@áézðþûNÙf1›q:ên ±;g"$q²Ûí’X !Ä9LQFŽËgÛ·Ó5;›ØÐPWB§W.ìØ‘öyy,™;—?ü€TF//T»âìllyy´×é¸$8˜NÝ»c¨ìR=é$lËÈ`~Ný¯¿¾A‰\•z%s³¿üŠ»ïºƒ X­V>œù1Ï¿ü ÿ}ùE "Ù{mÚë<ûätOH +;‹OgqJöñ¬OyqÊsÄvŠ!)y?OOùA <è´ê©JÚjkí›öÖtzvïÁAOïibsæÎã¢Ñ£«Ýçp8H9ÊÔ7ÞdüØ‹š92!„BÔÄÏÏá'òõGq«ÙL„ŸŸ[BLÇ  òKKÉ(*¢ìèQŒŠB€§'¡¡¡X †Š •]´.ŠB¹ÃÁ))l0›}÷ÝJä žÉÜŒ÷Þu}m6›¹ç®;¹püñkæ'ŸòèÃ1 E‹Yûvíxî©'O©ç±‡¢G÷ºÅóØÃñÁG¹’¹úÖS—õ6òû’%|?oîiÛ”–.ÿ“…?ÿÂœÏf²ïÄÖÅα±zõìYçɺŻ½îß•”N»žºLyñ%î»ûn‚ÏâCp—ý¹‚ç_z™÷ß™Ž¿Ÿß)û·®_‹ÝngJ ¯M{ƒéï½Ï£=x"B!DM ªlpúæ. &!<üx‹TŸ¸¨2_Ê).féÁƒì1›é=q"½ûôÁ`hšy¨uÖòÔsSð÷óãí7^'22³ÉDi©•C‡5I:¥é§>Ì ¯¼Ê ¯¼ê¶ýLL¨΢ŋy鵩¼7ýMbcbj,g4éËË/ü‡«&N’dN!„8Ç(ŠÂÀÁƒ áǯ¾bËöíŒhÓ†__tz}E¡jZàPUlN'©ùùlÈÎf¿ÑH»!C¸~Ø0·gÁ6…:“¹ 7²háøøŸì°n÷2;ubãæÍ zA­umݾA¸^oß¹‹Ž:œv=u©.ak®DîÛùó™öÆ[|ðÎÛt‹«×1U³ …BqnŠ%êá‡Y½r%Ÿ¬\IPZ1f3¡ÞÞø˜LõzìªJ©ÝÎÑÒRŽ”—sÐူ0:ŽÏu‰‰œ‘ØêLæ:ÇÆòùœ/¹áºŠåKÖ®ßÀÓßv+3ù–›xùµ©XÌfº'$“›Ãçs¾ä©Çu+÷êÔ×ùϳOSÙ½8‡¸ÿ´ë9W}üég¼óþ¼ùß×NéR®rÇÝÿÇÄk®¦WÏž˜-fRR0õÍ7™0n\3G+„BˆÓáååŨ1c2lûöî%%)‰Ýyy8ŽC³ÙЙLèñhßž°ˆ&têDhh(úª¼3¤Îdî¥ç§ðÚ´7wÙå”—ÛˆëË Ï=ËÍ·ßá*3tÈœN'o½ûnÅ’"Üuûm§ÔuÛ-7óä3Ϲ–&™|ËM 8ð´ë9[Nœ´Põõ‰­}o½S1QäÞ:åØå‹áïïÏ]·ßƬÏgóÔsSp:DEFpéÅsÝ5WŸáè…BÑÌf3Ýè–€¦inËM5ç:¢UšmÑ`!Zª¦^4X!„h*‹-j¾g³ !„Bˆ¦'ÉœB!D &ÉœB!D &ÉœB!D &ÉœB!D Ö4Ï‘BÔKa©ÿþšÎŽ ;yVù,%„gB‡J¿¶Fñl‡sÆI2'D3zä›Ãõ:Fõj×du–Xíu: ^M{ã“øGâk‰¯qZr|ŽdóÎïGxò’vMzÎs‘$sB4£ÝÙb|ÙžZ@f¡­Ñõ9jDUÁ`hú–B‰¯q$¾Æ‘ø§%Çg6êð1[Ø•UÜäç=I2'D3 õÖ¡ÙK(,UhìTMôJ“Ä è´º ‰¯q$¾Æ‘ø§åǧaÂJ°ßùßÅ ’Ì Ñ¬^ùG}—NvqÓ}âBq*s žG.Š8Ûa4 Iæ„hF1¡&~ø¿hôz=ŠÒtŸz…B§iN§‡Ãq¶Ci’Ì ÑÌÇßæ#„âÌ“µ„B!Z0Iæ„B!Z°:»Y»÷éÇÖõkë,SºŽ«Îšuë˜þÎ{ìܽ»Æãë*³yËVæ~ó «×®Ãn³Ñ¶m®½ú*.?¾Qã”ê:ïšuë˜óÕ<6mÙ‚Óé ]Û¶\wÍ5\<~ÜM!„OMÖ2·uýÚSþ5ÄŒ™Ÿðàý÷5ªÌ[ï¾ËÁƒøzÎl–ÿþ/NyŽ_ýÆ{ÿû°A1Õ÷¼wÞs/%%%LŸ6•e¿-âÅ)SXøó/|øÑÌ3›B!þž”9sæh'N¬±@}[æš¼5×y³sr¸jâ$–ÿþÛ‹íõ·¦ó¯ûîukaËÌÊbâ7±tѯÍ›hzùùùg;!„¢Z‹-ª_ËÜü Ù?è5`—\qó,lÐ —¯XÁµ7ÜHŸAC¸èâKùúÛïTOCÙÏð Âï¿ï”®R‹ÙŒÓá¬óØ3›B!ÎOõZšäãYŸòâ”çˆíCRò~žžò‚2x«Ìȱã),,$$8˜.q¹í–[ˆëëÚÿ×êÕ<ùìžyâ1 @ê¡C<þÔ3DEE1 _ߦ¿²J‡ƒ”©L}ãMƽ茧&sæÎã¢Ñ£«Ýw¶cB!DËW¯d¢G÷ºÅóØÃñÁG¹’¹‘Çsó ×Ó9¶ÅÅ%¬]¿žûz˜ÇÿýÇ^À‡3?æž;ï`ô¨Qt‹ã‘=Àç_Ì9cÉ܉3:ÇÆòà}÷ž‘óÔdéò?Yøó/ÌùlÖ)ûÎvlB!„8?Ô«›5¡[¼Ûënñ]I9pÀõúõ×^!¡[<&“‰ÀÀÆŽÍž}šéï¾ç*³{Ï^FŽîVO÷„’’“­¶®_ˆU+™;û3¼<=™þÞûgì\'[öç žéeÞ˜úþ~~çTlB!„84x6«N©ýЄøn¤>ì¶íÂqèÞ§Ÿëß‘£ÈÍËkhõb4éËË/ü‡Ÿ~þ匞«Ê¢Å‹yöùxûÍ׉‰9§bB!Äù¥^ݬ[·ogЀ®×Ûwî¢c‡µ³/9‰ðV­\¯»v‰cÚ+¯ÐÀPGUÕfy„Ò·óç3í·øà·éW¯cš+6!„BœêÕ2÷êÔ×Ù²mV«•;wòÚ´iÜzó®ýwß÷«V¯¡¤¤„’ÒRÖ¬[Ç3SžgòÍ7¹ÊÜyÛd{êivìÜIYYÇŽcɲåÜöÏ»›ü¢î¸ûÿXºüOŠŠŽQn³±{Ï^žzn Æ«ûàFøøÓÏxñ•×xå…çOéš>Û± !„âüT¯uæžöþ÷ÑL2³²ˆŒˆ`ò-7qé} ™ IDAT„ ®2‹ÿXÂg_|ÁÞ}I˜Í&:vèÀä›nr›í °nýþ7s&»vïFU5z$$pãõ×¹µúU÷4‰“×t««Ì¦Í[˜õùl6nÞŒÓé$*2‚K/¾˜ë®¹½^_÷»RË{QÛykzÀòÅ‹ð÷÷?c±‰3GÖ™Bq®Z´hQÝÉœw’Ì !„8WÕ{Ñ`!„Bqnª×!„Bˆæ¦i™Ù™dfeRj-möó{zxÒ*ìÿÙ»ïð¨Ê´Ã¿™If&“Þ; %’Ð;¢¨XuUTDEÅÕUW\ÛZQ¢à ¨¬²‹ëîú­m±P•J¡CÞûd2õû#2dL›„$乯+™sÞóžçLÈÉ3o;a„…4LèìîXŸÿ×O˜jL’9!„BôHEMFÆŽ‹V£íöóê 9v„‚¢€n¥ñùÃCÃ[,'Éœ¢Û¹úÓ¶¢çh­õ©°¨1#Ç Rª¨¯¯ïöØTJñýâÙ–º  Ûci|~Iæ„=JAQÅ%Å„…`µX]ŽÂ…Lf…E…M–ºº:4 F£Ñ¡aµZÑh4ÔÕÕt{,¿>K$™Bt»Â¢BBCðööF£Ñ¸:!„ Ùl64% ‹ ›m}²ÙlØl6Dvöü®ŒÅ™óI2'„èvuuu£V«e}E!.p6›ˆˆNçžnµŒ+) { ®ˆ¥µÉ ÉœÂE´Zm›7(!ÄoŸB¡ÀÝݽÅ}=¥eîL,Vk÷ ‘–9!D¥TÊ2—Bˆ³Zûpçl2W[oaí¦\ÒŽWr$·€øH/†ôóå–‰‘xjέ'ÀÙÄÒjµrêôINŸ>Å©Ó'±Z­xê<ñöñ!%i0nîîlÚ´µZÃÈ£ kyrƒ$sBˆI¡PH«œÂ)Î&P»Ž–1oõ~…3*:”›Súáãã†Áläh~·¼´•çg$0¼@»Ï߸…°­X ß}ÿ?‚ƒƒ>lW^q5J¥³ÙDuu5?¬ÿŽ¼Ü\n¸a¥%%lÝþ3¿»îÆ6ÏßIæ„BÑ#9Ûµ¹ëh)Ï­HcJ|*Ê ø늿“Ÿ} ³©Žˆ^}ùÓƒwòþCcytùf¿9‘áýŽ¡q7kã×Í©¬¬àëo¿âòË&Ó§w_êë èõ5X­V”J%:Ži7ÞJnnÑѽðñöæû¿;çndIæ„RQ¡ 3S…ÉññüýÛw3’–9!Dc-ÝÚj «5˜ynÅ.Šì˶ԭ=¸›Ñc¢¸ýÆëðññäçǘûâ\:i2O̸–¹+7±ö…ËñÔ:—µg6ë–Ÿ7síÔë £ªª‚´ô4²²2©®©ÁËÓ“„„A ˆ@ppp‹çhíü-‘dN³Ùl̸ë”J%[µÂá†f³Ù¸ãž{ ä­Å¯¶XGqI 7ϸƒæü…‰ÆwyÌ?ÿìÎ7zc25¼V«á‘Gêxê©:œÉÑ$‘B8«­êÓu Vi()*âdæ1ºwÉIèß?Ž  `®»¦Š þŠ×ßÙÌ Ó'œO¿;Äï§rúü[åZŠ%;ç4jww"Â#(++åÛuß`µÚ1b f“‰»¶³yË&2OçÊÉW¡Õz ãëÚJ椛UˆN¡Ppù¥“XýéŽϤ\?û¾£Ç“›—Çô›§¹0¦FŒ0ñùçÕ$'›ÉÏW²v­†×^óà²ËL nvªŽsMè¬V+5µµx{yµX—Õj¥º¦ooI …893›u×Á‚Ôþ:tÑ£#HØ^ÑѸ»»c±XP«Õ$ìÇøñüû›ÍÜzãµütà ÷^“èT ζÌíß¿+¯¸ƒÁÀƒû±Ùàê+¯A©TòÕ7ÿeòeWЧwß&Ç™Íæ®o™K1Š½;w´YQMM ËW¬äÇõ(.)!:*Š‡|€IO´—Ù¼å'ÞZú.Ù99ôŠŽæÑÙdüرçjNãó§¥ïeí石mG*&£‘˜˜^Üzó4®2Å~³v¦LGlOMeÉÒ÷8pèP³ïÉöÔTÖüã3ö¤§c±˜‰‰á¶[naꔫÛ¿¸ðL¾ìRVº† ›69$s6nB­V;´¶™ÍfjjjñòòÄÍíÜ?éõzÜÝÝ[\ 9j5ŒßÐ,çãcá®» ¼ý¶–¬,%Ç·}|Kÿ×M&›¶lá__üé{÷1uÊÕ<ûç'Êìܽ›þö ¤ÞhÄËË‹;o›Îí·M·×{äè1V|ø©»va4ñððàú©×ðÐî—uí„è¡:ÚÍzðx.{…`6˜éåE``ÞÞÞ(•JôúZ¬+žž:úÅx±'­µBÃÁãyNSs6™«©©ÁÃC‡ÉTϡÇ?v‚=­««£²²‚òòÒ&Ç™L¦žÑÍZo4rÏý0$%™–½KhHY'O±tÙr{2wìx&Ï/XÀÂù/2dð`ö¤¥óìܹ¬\¾Œ>½{Ûëj+q|ûÝw™vã <öÈlüýüÈÎÉáÕ7Þ$''—‡þp¿Óe:⃕òØ#³™õ‡šÝÿC3|èP–¼¾˜Ä„äæåóÊâ×ÉÏÏç¾{guilâüAâÀlØ´™ûf݃B¡Àjµ²aÓfÆŽ…——þù)öeìÇjµâææÆu×LiöÿMqI ·Þ1“??ö(W\~_|ùï¼·ŒÿûçZ¼¼¼ÈÍËcá«‹9xø0J¥’K/¹˜Gþ#Zmäïœõ{ªªªøâŸk[ÝfƒU«´¨T0b„s­rÐü[¯×³hñŒ1œÿfg½šMf¾¾\?õ”JZžyò |}}9|ä+>üˆà`¦ßr³Ó1 !\¯­dÎjªÇh2¢rÓàî®F­V£P*€†{‡B©@­V£vWãªº«¹¾Ó“¹Z}-Jeý[¯¯Å××Ï^vÂø‰¬ûî[ÊÊJiØtvf¬ÍÖCÆÌ­ýìŸôëÓ‡g}‚î×%o,¶¿þÇgŸq÷w0zäHÆŒÉ3f°fígÌyú)§ÏõÑuxݧwo^œûӦϰÿQs¦LG¬|Y«ûgÞ>ƒGg?lÿãÓ§w,óæÎaú3íÉ\WÅ&Γ/»”7ßYÊÁÇI8ƒ‡ST\Ì#|Ð^fèàÁ\?u*¡!ÁlOÝÉÇŸ|Êà”dâû÷oRŸÕjņãMèÌŒ0‹ÅÂÓsæ·]Nm­žgŸ¿­ù;¿¿çnúöéCMmM«1ÛlðÔSž¬Z¥áµ×j‰=·Å4ýüüøæÿþƒF­fúw5[fì˜ÑŒ3Úþúâ‹.bçîÝlØ´ÉžÌõ‹cþósíeƌɿúšc™™çŸ¢ûµ•Ìõö¥´ªµ‡™§˜Íf¬+Ê_á­+f³™c§êðôõåT^!ý£|:œÌ57³¶áï¾C½¥Ò __?JKK@¡PÌŒéwØ[ê?Qâ̇÷_ïkÏ"ÅN­ÚùÅ—_1åú6f×Þ8/¾üÊaÿë7póM-¯‘°'=qcÇ8l?v,»÷¤9B›Læ¶[œ)s.{dv“V­FƒÅlióØ®ŽMô|O¼wwwÖoÜÀú›ðõõed£~Ë;n›ÎÄ ã‰ŽŠbì膄&óDV»Ïµ7#ƒœÜ\.½äb õõ¨ÜTÄõíö©ö2Ïÿå^{ù¥Vëùä +WjX²¤–»ï®oW gZÝ~ý¥ÕhZäZ*wæËf³QYU…¿¯_“}V«•‚ÂB–°‚‚ÂB.»ä’6ë“/ù’/×|µ¤ñúnÍ} Kˆ¤°º_/qçTv1µúZ,+‹•Z}-§²‹Ø¿ßFLd4Gs3–Ñf½Í­+wf²Â¯¿¬V+ááœWÇ&zooFÉÆÍ[xà÷÷²ió&]<Ña\Ü6òþŠ•—” óh˜ eîÀܼ|¾¶Øa»¿Ÿ_»êùïÕ$%Y¸í¶ö%ràüˆ¶Ê­Yû%%¥Ütãïš”]´øuþûÕ×\5y2ãÆŽqú¼B×S(ÚžqÛÕÃùçÿvh B«ÓðÖòžÇf?Ü$ngÊt¥ ›6óÕ7ß²fõGMö¹:6Ñ3]qùelùùg>ùû?(+/çŠË.µï;vü8 ½Â¿¿—믻µ»;WL½Îáø_/nÙø÷«±àÀ†3ÿ¶jQ‘‘ŽwÎœ:ÜÝ]÷ÌÄÖo`é²å̼ãv’5]fàÆë¯')1‘»wóíwßÂC÷ßç‚H…miéƒV[Éœ§‡šLåϯ}A_Ÿ8Ô^v§™ØµëtÃX73AA~(•¶gmç†Q~¼óÆ+„2zÌØëm|~gb‰íMúÞ4¶ü´…‹&\Ä﮿‘“'³øiëfòòò‰‰‰áúk¯'&&–ššÜÜÜ1m&k–Ì%'9Þ$“%r"ël׎Z­æ™'Ÿ 1!€¸~}™óÌÓ<ù̳ödN£Ñ`4Ñjµ|òá*êêêÐj5özÞxu‘ýû€5W]1?^YüF“dnïΘL&2OœàÕ×ßdÉ{ËxêñÇÚ]¦«lܼ…ù//dÙÒ%øùú6ÙïÊØDÏ5rø0|}|øø“O‰ŽŠ¢\œ}_Yy9þþþTVV²uÛvL¿,ô¦Ñ4üíÝ—‡‡–A ‰è<<øyÛ6F JAa!»÷ì±×•’œLXh(/,x‰ûgÍ"<<Œüü Ç `Á¢W¨­­eáü[ŒwÙ2-V^~Yß®ël«[Å™rÛw¤òüü\zÉ%ž… ^äëo¾íp™Î¶îûïy~þÞyë âý1î ±‰žÍÝÝÝ>|òe—:ü6ŒÉ—]Ê˯¾ÆÍ3îàÛï¾'"¼ááÌ>ÞÞLºx"_|ù%/¾´“ÉÄŸ~ˆ}û¹ýîY<;÷‡óxxhY´àE<==yjÎsÜqϽ¼ôÊ«ì?xÐ^æè±ã:|¤Õx7ntcûöî_®ò§Ÿ·òØSO3rø0^xî/öá­‰ŠŠÂjµv¨[Zá»YÛú‘ÿ޼—«'÷C¤ç`Å~”ïÃ= Šk®èÇ£7ô§úÔnv¥ï§ ¤‚k®º”GzЩºÏ|°liÌÜ™/­VËï®»°lù2víNåxæ1 ò8yò6®çýþJ~A>·ßv'*•ªÍs;3©»ðÞŒ Æ9;y!ãÀA‡ä-%9‰Ì'ì-s§Ngj=$e0[·mw8nËÏ[6tH«ç>züáa­'|ÎÜ »ë&þ¯/¾àõ7ßfùÒwH8ЩcäŒhlöC2û¡›lW*•<óäÜï,lVþÉÞœ§Ÿâ¿¿?__ÜÝݹüÒK™0n%¥¥„†„4YG.¦W/Þ^üF£½¾__‡úV¯ü ÍX®èðu6÷I³  ‡ k6ååç³~ã&”J—LlHr7mù‰§þ2΃+¯˜ÌÏ[· Q«?®¡ËäÛuë0™-$JÄÏ×—ŒýXñᇠNIn¶¥\áz-µ>µõ„„Æ<=ÔÜ{ãXî½±ùîÓèÈpæÎù ˜Qa¡¼¢¼Íº'Sδúúúqã ÓÈ:™Å®]©TUUSU]…»»;}ûôcô¨1ôíÓמ¨¶¥ÓºY_Yü/>ÿñqq¿t ¾ÎãzľÿÖi71á"æ<ýqýúq:;‡ qýµSíe¦ßr3÷=ôýûÇ1$%…=éé¬þôSV.?»Üǃ³ÿÄíÓo%%9  2öïçåW^cÖ]3íeî{ðL¿åf† ‚F«áĉ,¿õ×\}u»Êt…U¯fé²å¼õÚ«Mº¦]›øíð÷ov»B¡ 8(Èa›V«msLœZ­¶gí.-Ý´Óö¦óܼùö×EÅÅìܵµZÍÖëøÏÿ‹Ùl¦ªªšç^8ÛÄ·ÿý€;wñÍÿÖ9Ü„S’’xùÅy]q9Bˆ.äLå¬ÑcƲô½å<öèlŠ pzÌš3“1‹‰%6&¶ÍzÛâL7«bÍš5¶éÓ§·X eÄ(æ??—÷W¬¤ °aFꬻgrÝ5×8”[¿qï.ŸÓÙÙ„sÝÔk˜u×L‡ÕÖ7où‰7ßYjÄc<ìðˆï\ÏêO?åÈÑch4júöéì™3í-ö¤¥óÑß>awZ‹…¨È®›:•Ûn¹Ù~.gÊtDsO¨h¼ÈqKO°Øôý:üüüº,6ÑuÊÊÊ\BÐâ¾ÒҶ߯]i»˜4qRg†ÔDEe%'Ož¢¼¢‚Ȉpâúõ“™¬Bô`ë7­gøÇGÈìNßMÊ  ƒ‹¢jøP¼wÿ^’“©¯oÿìýs¡ÑhØw`ÃkvÿºuëÚN愸ÐI2×ùv§ïæ’‹.quBˆdÃæ M–Ýé»IJHêöª1FCÆÁ —Äræü­%sÝ?rY!p~9!Ä…­3»Y;z~h¸gY,§&$t&‹ÅÒ9‹ !„Bt·Æ3H]åÌ£¶À5‰e·=›U!ÚÃÙuæ„ŽŽ.ÜÕ\yngI2'„p Iæ„çO'z½77·nKð ƒOg«å$™B!D䊪±ÆÉTXh…E…øxùØŸºÓÕêë멪©jó ’Ì !º§Î“ÊÊJüüü\Š¢(//o¶õÉ Tc“©ÿ°A~a~·-•¢Õj  'À?‹ÅÒb9Iæ„Ý.,4ŒÌ¬Lúöî+ ¸ŠŠ 2³2›m}rEÕد“©   ÂÂÂœz„`g8ó„¨3Ïán‰$sBˆnwæ}ððA—.*„p½ÖZŸ\‘@5öëdÊd2µ™X¹‚$sBˆnçê´¢çh«õ©§&P=‰$sB—´BtùH,„Bq“dN!„â<&ÉœB!ÄyL’9!„BˆóX› RFŒbïÎmVTSSÃò+ùqýŠKJˆŽŠâá`ÒÅíe¶§¦²dé{8t¨Å:7où‰·–¾KvN½¢£ytö?vl³eËÊʹiúm”–•9Ô—–¾—µŸζ©˜ŒFbbzqëÍÓ¸vÊ”sz„P[ñoOMeÍ?>cOz:‹™Ø˜n»å¦N¹ºËcB!Ä…©SZæêFî¹ÿLF#,{—m›6ðÊK øâ¿_:”û`å‡<öÈìë9v<“ç,àÏ?ÊO~ä‰GÿÄsó^äDVV³å¾¶˜)W_ÕdûÛï¾Ë„ñãøçšOØôÃw¼4ï¾]÷ï½ÿ×sºÎ¶â¿ÿ¡‡©­­eÉë‹ÙøÝ:^š7¯¾ù–¿®XÙå± !„â¤X³fmúôé-p¦enõ'ŸrøÈQ^ž?Ï©“¶Tçü—Ó«wÞ>þíÃÕ#7/9O?åPvãæ-,Z¼˜ÿ¬ý£/º¸Í‹Š‹™6}›~øΩ;ÿo/áÑÙ;´°2ýΙlX÷¿n‰Mt¾²²²N«ë»õò3BÑ>“'Mnqߺuëœ[gî‹/¿âƒ•«((,$2"‚{îšÉõS¯±ïÿaý†V[¬œµ'=Ûn½ÅaÛø±cùó³qØVSSÂE‹xþ/ÁÃÃÃéúMfó9ÇØšæÞ­FƒÅÜòóÔÎèêØDÏ1õª)®A!ÄyâËo¿n³ŒSÉܪ>æ¥y/ß?ŽcÇ3ynÞ‹úû3aü82³²(+/ã¦é·qút6áááÜtÃï˜që-íZÝ=¿ !Y˜9ë÷(” –-y›‚‡r¯¿½„!)ƒ™0®ù±t™ÍfNddñ›o1åª+Ž¥³¬YûWNn>£vulB!„8ÿ9•Ì=ýÄã NI 9iO?ñ8ËW¬°'sz½žU¯fî³ÏÒ?®Ù9¹Ìy! …‚Û§ßêt0õõõ¨Õj,V *Th4 †z{™»vóÃúõüç³µmÖ—2b”ýûññ<6ûa§cé 6mæ«o¾eÍêšìsulB!„ømpªÙ,9iÃë¤A‰“Ôj5Ï<ùÉIƒÐjµÄõëËœgžæŸÿúw»‚Ñh4F>ùp¯ü€úúz´Z½Ì¼—^föƒØf}{wî`×ÖŸXûÉj½{·ë¢þðû{ùèoŸ0ç…yX,¢"#¸nêÔv'…¿ÖVüo/}€‡{¼É±›¾_‡ŸŸ_—Å&„Bˆ S›‹ q¡ëìEƒe9!„ÎúòÛ¯;gÑ`!„¸ÐY­Vò óÉÉÍ£V_ëêp.Hž:O¢"# oצBüÖI2'„ÊÊK(.)"À?ˆà W‡#\ ¿0ŸÂ¢"âãâðóõsu8¤ŠÊ NœlX+2<ÒÅÑÑsÈG!œ`lØ\†p¡Ü¼|úÆö‘DÎ…ü|ýèۇܼ|W‡"D"-sB8!Ð?ˆ@ÿ W‡!\H¯×ãÛÌà¢{ùúú¢×ë]†=Š´Ì !„BœÇ$™Bq^Q(®AˆE’9!œPo¬§²ªC½ÁÕ¡‘BÑSI2'„**ËÉ:•Iyy©«CB!È!œàçëV£E£Ñº:á"Ò2×sÈÏBG’Ì áZƒF­qÙùØø#C½ýµZ­ÆÏÇ—Þ±½ êžY¶_~ûu«ûG IHpp·Ä"„â,Iæ„8Ølà@¯èh°Ñh$¿°€í;w80>±m?¿øÈñ£ÔT×2lÈÅ0lðÙãNž>MuM5I ‰öm>>ÞªWœe6›9q2‹Ð|}d”–HËœŽ$™â<áíåETÄÙUï{ÇƲgo:"$8/O/ á±S&³ w7w‡GÕÔÔR]SÝlÝ-ÓXDx„ýûâÒêêôÛ:“ÙlF©Tö¨G6Kál"m2›8rì(Zßl2g2™œ*çîîÞÅ‘ñÛ!ÉœNè‰óR( ìO^~9y¹ ˆ‹gëŽí”•—a³ÙP*•ÄôêÅ ‰¬ß¼‘Úچ牞é.½tâ%ètºi¯´½é””•rÙÅ“ì‰OaQ©»w2iâŨT*~Þ¾ €@ ‹‹0›Í‘”8­¶a,¢^¯'m_:eåå( "#"HJHÂÍMÀúÍ1M\qÙåñv ‹ÅŠR©pHþZK¤ÏgÁCëÁÔ«¦4Ùg³Ù0 h4šf\‹Å€J¥:Çè»^Nn.ûhµLRâ b{ÅtSDBœÿ$™ =õq^:µZMuu AôŽ‰A«õ ¸¤˜#ÇŽÈà¤d9BAOrb2ê_ƶtLXhX»béMN^.%¥¥öq|Óøø, IDAT9¹¹øûã©ó¤ÎP‡^¯ÇèíMrâ õõdfe²}g*ÆŽC©T²}W*ž:—L˜ˆÉl&u÷NŽŸ8΀þñøzûb2;ëíëT9y¹9v½¾•JILt ‰ZL¤J?lXOl¯X Š 0 Œ=†m;¶“’”LP` ?lXODxEÅ…˜ÍÜÜÜ’2˜°PêëëÙ»…EE( |}|¨¨¬äâ áíÕ3»½{ÇÆ´˜ÐI"'Dûµ™Ì¥ŒÅÞ;Ú¬¨¦¦†å+Vòãú —”ÅÃ>À¤‹'°=5•5ÿøŒ=ééX,fbcb¸í–[˜:åj‡s5§ñùÓÒ÷²öóÏÙ¶#“ÑHLL/n½y×N™bÿ$ìL™ŽØžšÊ’¥ïqàСfßg®±«b]«'?ÎK¡Ppæ¿Nÿ~q@C7¥B¡àȱ£TVU×­V‹Édj2I¡¥cÚ›Ìø Óy›MpP&³‰‚¢%8¶ò……„Ùëöõñå§m?SRZŠJ¥¤¶¶–þ}ã0[,ö䤠°ÐžÌut¼_W«ª®"mo:}z÷&&ºƒÊª*€é3IiMm ýûÅáææ†ÚÝ›ÍFãÏ 6«•¡)CÑé<Ø·?ƒŒû Åf³±sÏ.l6ãÇŒÅÍÍìœ**+»ýúÛ«¥„N9!:¦SZæêFî¹ÿ†¤$óÁ²w !ëä)–.[nOæîèa†Ê’ד˜0ܼ|^Yü:ùùùÜwï,{]m%Žo¿û.Ón¼Ç™¿ŸÙ99¼úÆ›äääòÐîwºLG|°òC{d6³þð@³û¹Æ®ŠM\˜ õõõxzz›ŸÇ¡Ã‡©3ÔÙ»ÜÚjQìÈ1ÍQ(DGFsüD&‹…ܼ¼†®ÒVÆÕùúøPUU…Z­ m_ºCÆu³ˆuæƒX]³ÙBP`A É€@³‰´ÉÜðoTD$ÑQQ ÇêšÔJhHC×~hp(‡ŽÆl6SYUIyEÆŽÇï—gÆúûûCV—]f§úuBמDN>ø á¨S’¹µŸý“~}úðÌŸŸ´oë×%o,¶¿žyû ý°ý—°OïXæÍÃô;g:$smù胿:¼îÓ»7/Î}ŽiÓgØ“!gÊtÄÊ÷—µºß™kìªØÄ…éhæq !!¨¬ªdOz Û+•JÅ×ë¾u(oµY^;sL{DGFsäØQòòóÉÍË%4$7·–o3CÃ5<=u¨T å&]t±=9íIZK ¼½¼=b‡fËÖŸðöòf`ü{ÖYμ—6lT×4t­{hÏßµ{ÇÆb±6Œ÷“9!:Ωdî‹/¿âƒ•«((,$2"‚{îšÉõS¯±ïÿaý{dv«u4·_«Ñ`1[ÚróLfs§”9çr]›87õÆz †:4-Z-\S[K~Aþ/ñ)**¢°¸ˆqñx{yST\ 4¬‰g4)Ê-Âj=›¼yêt›ƒR¡$$$˜úzc«Ç´—‡‡–à  ;‚Á``ôˆ¸&eôuzL&&“™Œxxh A¡P Óy°+m  óС¯Ó û¼=éi˜ÍfFÑá»JpPÁA㩪®bßþýìJÛÍ¥/±Oîøu"}®<´TTVvzÒØúõéëê„8ï9•Ì­úèc^š÷ñýã8v<“çæ½H ¿?Æ 3+‹²ò2nš~§OgÎM7üŽ·ÞÒêÒkÖ~Æ•“';l»ôª)TVVDÂÀÜ{÷Ý ßìñf³™Y'Yüæ[L¹êÊ—éJÍ]㮎M8¯¢²œü‚\BƒÃ‹lû€.PRZBIi аlƒ¯/#† ·† "*2ÒÞMéç닧îl Wï˜XJËÊÈ8§Î‹À€€6éˆ^ÑÑìNKC«ÕÚ»;–yœ£ÇàãíÃÈa#ì-N£†dïþ ¶ïL@í®¦wl¬=™«¨ªÄdtni‹ÎÖZË\Ee%ÕÕÕøúú T*ñõñ¥¢²Â~ÿk.‘>WÁAAöqtƒ““Ñyè(¯(?çzÏÒÍ*„#§’¹§ŸxœÁ) w““ñô³|Å {2§×ëYõñjæ>û,ýãú‘“Ëü—¢P(¸}ú­ÍÖ¹aÓf¾úæ[Ö¬þȾíÒK.á®;ng@|jjjÙ±s'<þÏüùI.™x‘Ãñ'K ˆç±Ù79‡3eºRs×x†«cíãçãÚÇy]~É¥m–Q( ILBü@l6›½Eè FøÑcš×Ú1-I”Üâ¾Ðà0 Q‘ÍþÑM”DP@ …‡}^^^Œ=‹Å‚ÙbnòÔI]ìT|ÝÍd2qàðAûjnnn$'&ÙÇ6—HŸ+¥RɘcHÛ—Æö©( —µ !\Ë©d.9iÃë¤A‰œÈ:;ÊV­VóÌ“O˜@\¿¾Ìyæiž|æÙf“¹›·0ÿå…,[ºÄ>pàWÙ¿PsÕ“ñ÷÷ã•Åo4IæöîÜÉd"óÄ ^}ýM–¼·Œ§¬ÝeºJK×Øbí§Ñh΋øб ym%e%Øl6¢#£šÝ¯@N§kµ•Ju^¬™vFpPW\z9F£«Õ†V«qHd[J¤½¦Ü¯×™ûõþؘbcÎŽ-Óé<7z,&³ ¥BIaQ!»ÓÓP)Û«NIËœŽ:¼¼ºRqöÐÐúöéã°?¦W4ùMŽ[÷ý÷³îši/s߃dæÍTUUSo4rèðæ¼0k®¾º]eº‚3×èªØĹ)+/áèñC””¹:”ÍÍÍ‹'\Dtdt“}gºÏ×D¯'&H••U=~Œ-[âØñãôŽe`¼s"Ïg=ñg!„+)Ö¬Yc›>}z‹RFŒbþósyÅJûÒ$³îžÉu×\ãPnýÆM¼»ü}NggÌuS¯aÖ]3íã^ZzºÀ¦ï×áççÇ÷?®gõ§Ÿräè145}ûôaÖÌ™ö‰{ÒÒùèoŸ°;- ‹ÅBTd×MÊm·Ül?—3e:¢¹kh¼È±3×ØU±‰®SVVÖðlÖÒ"ýƒ ìø2ß­ÿ®ÙgoŠžo[êÆŒlùwÜ•¬Vk«+üÖô䟅íËo¿fò¤æWÅX·n]ÛÉœº²²²N«K’¹ó—$=‡ü,Ä…Ä™dîÂù('„çÀSçIuuµ«Ã¸àUWWŸóZˆBüÖH2'„Nˆ';7G:ª®®&;7‡ˆðpW‡"DòÛ^ŒH!:I`@ ¥ee¤íÛ‹Ù"³Ï]ÁMåFhH(®EˆE’9!„pB^A.µúZR’’ñõñqu8¤ŠÊ NœÌ"¯ —Èp×Ïæ@nF³ì2#oýPÀ5)~B«<ÔJ®Jòåó]eçTÏÓŸg“‘Óòcdœ¹Æ?ÿ3› ‡«(­1c¶Ø8]fä­ï ˜’, ­+)-aמ=ìNKãèñcôíÝ—A¿ŒC++/£¬¼œäÄ$"#" aøa€S§O;}ŽÐPBCBðöò&48ƒÁ€Ùl¦¼¢œêšj&àïç‡ÎÃïŽ?£4À?΃ìÜl ¡U± ¨€¨HÇJa!a„…†Û+†¡)C©®©¦¤´”Ò²Rjkk‰ Äl± P(ðõñ¡ °Ð~ì°!C=bT‡c]«wl,ƒžGÙžDNÆ/ áÈ©–¹Ë|¸ud AÞnVšøç®2¾?x¶ëp\?oVþTÜj+·4Ý_o¶ñë‰x£úx2mxq!ZôF+©Yµ|°¹˜šzK»Ê46%Éݧj)¬rnàmG9{ÍQ)åæ$ZÛ+†¤ÄAää³+mž:O{WgMm-^^^öònnnhµÔvð9–nn · -çr v …‚èÈhŽŸÈÄb±›—×ÐUÚʸº3¸¯ªªB­V¶/Ý¡ŒF£é”øZŠYt®Þ±±X¬ ÷mi‘¢ãœJæ¦ àõï 8Q\Ol šG'‡QQgagVà >:@¯‡ŠwgÄ᯦¨ÊÄ·•ü_z9-LvàÚ?6­vØvÝ`>ÙVÊÁü:´îJnÀ/ aÑ7ùí*s†»JÁuCü˜óŸg.µÓ5wg¸)D¨¹÷¢`6îü±ƒâ·)<,œÈˆöÈ Àß^LèÃ#wìzößg“.£ÙÂ'ÛJùxVŸv—9ãò_Ž8UÚýcgZºFpœ¤‘Y\ϪŸd¼œp^R JË6“¶o/cFŽ"0 ??2d0 <*77Nž:‰R¡"¦W/4j *•Š‚ÂBB‚BÐ×é).m½5½± À@t:2`PBZ–Ò²sëêá¡%8(ˆÃÇŽ`0="®I}“É„Éd&ã@FÃúzÁ!( t:v¥í!aÀt:ôuz@aƒ·'= ³ÙÌÈá#Î)Î3¤e®‘…œJæŽÔ9¾.4Ð+Pmm´ØX¾±ˆ£… ŸœO–Ô³t}!O_Þl27ª_ÊœÿäPm8Û5ê¥Q1ct #{{àå†ZÕðÛ¸qÏ™2g(pÃ0^û_Ó»®ÖÒ5ž1åí£¸©Ä¨¹ob3Çñþ¦¢nSœŸÜÝÝœ”Âö;8q2‹¾½û0rø9ÌÇ°X,øû3~ìX´š†VµäAIìÍØÇ›6 T*Ûµh¯J¥bÔ°‘¤íKg[êüýüÏ9ÁéÍî´4´Z-AAMöË<ÎÑã 3Ð}¼}9l„½õnÔ°‘ìÝŸÁö©¨ÝÕôŽµ'sU•˜Œ];´B!z‚ÏfmÜ}ZRmâTi½ÃþÜ #!ÞM}¼¨¿7\ÂÜÿË%«Äñ˜Ç&‡Qm°ðÂs)¬4a´ØðpWòùƒýÚUæŒ ý½)ª2q¤ÀÐÑËìÖ®±1³ÅFfq=¯ý/Ÿ¥3b$™-ºü’K›l  bêUSì¯ÕîjR%·XGTD$a!aÔ×ðððpXZÄÝÍÝ¡.€Ø˜bcÎŽcòòòbÂØñ˜Í ]µ­u‰6ÖZL¡Áa( ¢""›M “%øËS/»w½¼¼7z ‹³ÅŒFí8^nÒE;Ÿ³¤e®çŸ…ŽœšÍ: Ìñ&Ú?TëÐmy¸À@L ã4ÒOMqµã§â+ù2ûÒPæý·aéŽ_KŽò௛‹È.3b´4d‹ÉѺv—9cÚð>Ûyn3XÛ«­klŽBÑ0~Nˆ®ææ¦ÂÓÓóœÖˆssss:‘kKIY 6›Í¾öݯ)P ÓéZx¡R©š$rBq!qêŽ~ÿÄ`†{ uWÒ?LËýCøg£e>¾Ú[Á'…Ò?L‹ÚMAl†?N å»F3^oÀƒ—„ðêÿò9ÜBKYfq=¿â§F‰§Fɸ~^ÜwQp»ËŒèí‰Él#=»c3ù:™k|é†(F÷ñÂK£B­RÐ7DÃã“ÃX/ Ä(;'?__‡Y¸B´EZæ„päÔÇëµ;ËxâŠ0ûÒ$Ÿí*c×ÉZûþ£…þžZÊŸ. %ÂOMi™ïVòŸ=gÇËÝ=®aËó×F6©ú_3©ª³°x]>÷]ª»{£V)9^dàï xuZ´½¬3enÀg縮ܯ5ž´pæûÆ ;skv”rãЛ†J •&¾?XÅ—{+:5V!zºúúz ”àêPœ" „¢§R¬Y³ÆöIÑ0WÇ!Dõ·;šÌï¨ïÖ×dlÚ…Êb±Pg¨ÃCëJÕyÏ–í*ÛRw0f¤,BÜÈÏB\H¾üök&OšÜâþuëÖuÎ „¢½T*^ž^çE"à©ó¤ººù5#E÷©®®ÆS'k ј$sBᄈðp²ss$¡s¡êêj²ssˆwu(Bô(3%M!~ゃ‚Q  ëÔ)êêêÚ>@t:"Ã# Âf³º:!z Iæ„ 6›•`ÂÃÃe2„‹Øl6,3KóÏáâB%ÉœB8Éb±H"!„èqdÌœB!ÄyL’9!„Bˆó˜8.†+„pTVÖ½„B!ÚCZæ„B!Îc’Ì !„BœÇ$™B!„8I2'„Bq“dNˆóˆÙl¦¶¶³ùü\ëì|_!z"Y4Xˆó@mm-{÷gPZVjßDrâ <=»÷¡ã‹•m©ÛéKdx„SÇô¤ø/4z½žìÜ**+¨¨¬ÀÏ×?_?¢#£Ðét.ŽPq®ÚLæRFŒbïÎmVTSSÃò+ùqýŠKJˆŽŠâá`ÒÅ›”-++ç¦é·QZVæPwʈQÍÖ­V«ÙùóûëÍ[~⭥C¯èhýGÆÛîzÚk{j*K–¾ÇC‡š}O¶§¦²æŸ±'=‹ÅLlL ·Ýr S§\m/“–¾—µŸζ©˜ŒFbbzqëÍÓ¸vÊyDhQêž]ج6F ŽÎÃÚÚZòò Ðh4.ˆÆFyE9á†0§èYñ_l6Y§Nr<ó8Q‘QDGF“”0€ŠÊJ**+øiÛÏôëÛÞ1±rÿâ<Ö)-sõF#÷ÜÿCR’ù`Ù»„†„uòK—-o6™[øÚb¦\}«?ùÔa{s ÒÒeËíŸ&ŽÏäù X8ÿE† Ìž´tž;—•Ë—ѧwo§ëéˆV~ÈcÌfÖhvÿý=Ìð¡CYòúb’›—Ï+‹_'??ŸûîÀÛï¾Ë´oà±GfãïçGvN¯¾ñ&99¹<ô‡ûÏ)>ñÛT__OMM ‰ ÀÇÛ‡ð°ðfË›Íf”J%JeÓQV«“Ù„»›{³û¡á‘U*•Êá³ÙŒZ­næ\ôuµxxxàîæÞ)ñ·v¾sÕÚ{ó[b³Ùرk'V«…qcÆáù«Ö7NGDx81½bØ›±—¢âbF ! ç©NIæÖ~öOúõéÃ3~Ò¾­\?–¼±¸IÙ›·q`?/ÎÓ$™ûµZ½žþû?¬ùøCû¶|öwßq£GŽ`̨‘Ü9ckÖ~Æœ§ŸrºžŽXùþ²V÷ϼ}Î~Ø~CìÓ;–ysç0ýΙödî£þêpLŸÞ½yqîsL›>C’9Ñ,µZV£åtv6Aøxû4[N¯×“¶/²òr ‘$%$áæÖ˜mݱ²ò2l6J¥’˜^½40‘:C?lXOl¯X Š 0 L;­FCÆý•cµZÑétŒ: O]C·è©Ó§8|ôV«¥RIÊ d¢"#;¿Á`hö|>Þ>˜Ì&9Baq!f³?? ÄÛËC½Ÿ·o#( Ââ"Ìf3ÁA$%B«Õ:õެ߼“ÑÄ—]~Î?¯ž ëÔI¬V cFŽn5AóÔé3r4ÛR·“uê$}b{wc”BˆÎâÔÇÓ/¾üŠ)×ßÀ°1ã¸öÆi|ñåWûX¿›oº±ÍzjjjX°hyê)<<<Ú,ÿÙçÿbÜèÑDFœ—³'=qcÇ8”?v,»÷¤µ«ž®ðØ#³›Ü8µ '{›Ìæ® Kœç Æ Áh2²é§-ü¼}ùùØl6{›ÍÆö]©¸¹¹qÉ„‰Œ=–¢âbŽŸ8n/È°ÁC?fq}û‘uò$…öý5µ5ôïÇÐÁCÐj4ìܳ‹:ƒ‘Æsñ„‹Hˆ€—§—½¼——£GŒä²K&ľ1µ7þ–Îg³ÙHݵ“¢’"öÈäÁØl6¶lý™:C6› ½^Ñd$9q RUSÅö©X,§Þ_o_|}›O2Ï7z½žã™ÇIIJqª¥M¡P’”ÂñÌãèõúnˆPÑÙœj™[õÑǼ4ïâûÇqìx&ÏÍ{‘@&Œ@fVeåeÜ4ý6NŸÎ&<<œ›nø3n½Å¡;ãõ·—0$e0ÆméTvF£‘Oþþþúî;Ûó íIÙÌY¿G¡T°lÉÛ”œ©§»¬YûWNžÜì>³Ù̉¬“,~ó-¦\ue7G&Î'þ\vñ$ Š 8yê4»Òöàá¡eÄÐøúøPZVJmm-ýûÆa¶XP(øúøPPXÈ€þñôï4ü¿S(9v”ʪ*|}}ˆŠˆ$:* €²ò2**+™0v<~¿ì÷öòºa  48”¢" †z<<´íŽ¿¼¢¼Åó•–•RV^Îè#  þåÜ|·þ{N>ML¯^„…„Ú0ŽÏ×Ç—Ÿ¶ýLIi)*•²Í÷fØ!ö³rµìÜ¢"£št­¶ÆS§#*2ŠìÜâãäñŽBœoœJæž~âq§$œ4ˆ§Ÿxœå+VØ“9½^ϪW3÷Ùgé×ìœ\濼…BÁíÓo`ç®Ýü°~=ÿùl­Sýß—_‘”˜@ß>}¶×××ÛÇÒX¬T¨Ðh4 õíª§;lØ´™¯¾ù–5«?j²¯ñ$ññ<6ûánŒLœ”J%aD„EP^QÁö;8pè cG¦¶¶¡E%m_ºÃ1'äæçqèðaê uö1q6š¶¤T×Ô s¢@õKwes-sÎÄßÚùjjk†–À3ÜÜÜÐj=¨m¡%Éק¡•­ªªÊ~¿hí½qFYyEEE”•÷ìgõÖÖÕ‘8 ¡£¢Í IDATÝÇùùúqàðAJKKº ªÎà@Dx8>>¾®Eˆéd.9iÃë¤A‰œÈʲ¿V«Õ<óä$&4Ü@âúõeÎ3Oóä3ÏÚ“¹y/½Ìì$(0°ÍóY­V>þäSαÉ>FƒÑhD«Õòɇ«¨««C«mzcn­ž®¶qó濼eK—Ø[Û»s&“‰Ì'xõõ7YòÞ2žzü±nSœŸüýüðòôÄd2ØdžMºèâf—ú¨¬ªdOz Û+•JÅ×ë¾m±þ3õÕêk»d"BKñ7w¾3-L55µxh’=³ÙŒÁP×âÒ(ƒ¡áXO*UÃm®¥÷ÆYY'³?€ñ:\GwX÷ã÷ÍÞsÚâçë‹Õjeìè¶{N\©V_Kvv¶$sB4Òá)]JÅÙCCCBš´|ÅôŠ&¿àl×gvN ½BʈQö/h~‘ußÿ@xxIƒ›ì  %7/Ïa[n^ž½{ÅÙzºÒºï¿çùù xç­7ˆ‹k±œ»»;âãY¸àE¾þ¦å?¬âÂVWWÇdwzY§Nrêô)v§§QQYIl¯ a<œNçÁ®´=—S[[KqI1Å% ­,õõF4j F“‘S§OaµZ[t(á¡ Ë{¨T*F ÉÞýlß™ €Ú]MïØX‚ƒ‚ "*2ÒÞÕèçëkŸ•Ú77#‡`oÆ>{}:ŽQÃGØ[Ç:3þÖÎçåéÅÈá#8tä0Âb±àïÏø±cÑj´Ôê8–yœ£Ç KŸŒ67·†[\kï @EU%&£©ÕëgÏž=˜-=ûwU©TRQYÙîÅ€+*+Q*•lݾµ‹"ën*7bcc]†=Êÿ³wßáQTëÇ¿[²›é½Ð! 5ô"‚( "êõÚ½êÅ.ˆõ^õÚËÏ®¨¨\ ‚ìWņ¨t¤÷š„ôÞ“Ýdwg~,Yˆ)›²Y²ø~ž‡GÜ9{æ9ÃäÍ9gδ(™{îÅ—yâчéקÏñaÁ—¸çιŽíW^v)O>ó,ÝÿoúôîMzF&O=ó,_8½Õ­Y»ƒÁȨ#Ý>ãŠË¹éöÛéÛ·Ƀ³mÇ>øøcÞ[ðV«êé Àü·0ï…ç M×¹é¶Ù̸âr†%'cô6’’’Ê‹óæqÁùç7Z^ˆ®]º2zÄ(TU¥¦¦//¯zëÀÕñ÷÷gÜè1Øl6¬6+FÉ^$FCò !$õKDUUÇ°féçMkP_ÿ.œ1fV«›b«WߟËÇFÇÝpY’ÖÄßÜþ ^ÔIJ4` ¡Á!h4šOË7wnÀ>ëL\lq±qNËj¢´¬”è¨Æ×ñkJiY)ñ±qò„¨EÉÜ ×_ÇyŒÜ<û“¤³®¿¶Þú'%qÓ¬Y<úäÓ¤gdÆEÓ/àÚ«g¶: w-bÖu×6¹½Oï^<þÐC<ûÂKŽ7@<ùè#Žƒ[ZO[œ<$\÷÷“{_ÿsÁw[±œÀÀ@n¹ñ}ø=ö86›Ø˜h.š>«®¸Ü¥±ŠÓF£i„5F§Ó5š,Aë'ýƒýa½ –¤liümÝŸÓÞ¨æÎÍé".&–µÖÑ-¾[‹Ÿh­ª®&3+“3ÆŒëàè„A³dÉuÆŒ§:!:­âb×=½øóªŸímW·èñƒK«üÕ¥¤¥’›—ëtÑ`°?¼aóF"#"eÑ`!:¡e?~Ï”I/q°|ùò¶?!„¢sêÑ­;Z­Ž ›76¹| Ø{ä6lÞˆV«£G·îî PáR.y—Bœ*>Þ>ÒÛù'†QÃGz,uÖK`@ cÉ’Ò²2JËJÉÌʤw¯ÞôèÖ]ÞË*„“dN!NC†žÝ{AFV&YìÞ·°?ÍÈcƵú©W!Dç#ÉœBœÆ|}}å U!Ns2gN!„ƒI2'„BáÁ$™B!„ð`’Ì !„Bx0Iæ„B!<˜$sB!„L’9!„B&ÉœB!„“dN!„ƒI2'„ЊÕ+ùî§(-+k°í·µkøcÛ–SUC&³‰e?~ONnΩEˆ¿,Iæ„¢“RU•í;w`³ÙNu(BˆNL’9!„褂©ª®âàáC.«óω¡ÕjÅl6;þ_UUªM&TUmð]EQ¨©­AQ—Å#„h?ý©@!DãºÎÁLjŒˆ 8(¸Ñr«…’W‡Õj#(0¤„DºøwÁd6ñËêUtïNn~.f³™±£Ç°~ã"Ã#È+ÈGUU‚ƒ !%-›Í†··7£† k—®¬ß´‘â’bTUE«ÕÒ->ž‰ýÝy:„Mž9!„èÄúôêM`@Ûwílt¸UUU6oùƒüÂ|û&’TUW·x:Ž“gÉéõ:Nþ +'›ý`2›Ðét¨4œW'„p?Iæ„ÂôèÞœ¼\vìÞ…Fà€Ÿ¯/••UøxÛ?³?Ô`"&*Ú%û.+/cÛŽí$%$Ò=¾:Žï—ÿè’º…í'ìBá4 Ƀc±ÔR]}b.\HpAìÞ»›ìœlò òÙºcZŽnññ.ÙwMM-Fƒ‘ZK-ÇÒ9žhÕëì}…EÅäÈ2*Bœ’Ì !„‡ðõõ%±_b½Ï4 #‡ $$„½ö³}ç4 gŒ‹·ÑÛ%û %6&†í»vðËêU¤gfàç뀗—ÑQѤ¥§±eûV¬6«Kö)„h9Í’%KÔ3fœê8„è´Š‹‹]V×Ï«~fúyÓ\VŸîTSSƒªªx{7LMfFƒ­Vú„p¥e?~Ï”ISšÜ¾|ùr™3'„¢eŒFc“Ûêæë !ÜO~…B!„ð`’Ì !„Bx0Iæ„B!<˜$sB!„L’9!„B&ÉœB!„“dN!„ƒI2'„BáÁ$™B!„ð`’Ì !„Bx0Iæ„B!<˜$sB!„L’9!„B&ÉœB!„“dN!„ƒI2'„BáÁ$™B!„ð`’Ì !„Bx0Iæ„B!<˜$sB!„L’9!„B&ÉœB!„“dN!„ƒI2'„BáÁ$™B!„ð`’Ì !„Bx0Iæ„B!<˜$sB!„L’9!„B¦?ÕñW³ìÇïOuB!N#’Ì áFS&M9Õ!!„8ÍÈ0«B!„“dN!„ƒI2'„BáÁ$™B!„ð`’Ì !„Bx0Iæ„B!<˜,M"„©ªJn~.¹y¹T›ªÝ²O__"#"‰ D£ÑH<Âý<á> Éœn”›ŸK­¥–±£ÇâmôvË>Í5f>Hn~.QQÇ#„p?O¸H2'„ååç1fätZ555nÙ§N«£_ï~lؼ¡ÁMAâñ¬x„îç ÷™3'„™L&ŒF#Š¢¸mŸŠ¢`41™L‡Ç#„p?O¸HÏœn¦ª*ªªº}ŸÍm“x<'!„ûuöû€$sBœ§â‡us“h%ÏŠGá~ù> Éœn¤ÑhPUÕ­ÝõÐôMHâñ¬x„îç ÷Iæ„p³ÎÖ]ßšxÔ¬,”~À¶e –={Pm¿~h‡ÇpÁèºwwk<®âêxldÑ–ûðöêƒ"!|¬ËâB¸Ÿ³ûÀƒûÙ°q]³sÜ‚ƒ˜:å<‚ƒCZ¼Ï–’dN7;UÉJSÝõ-Gùì3xû¿Ø¢"PÃBÐ_t¨*JvÖ_WRõÎÛøÌžƒï¬Yàdh =ñXkk°Ùjë}æeôE«Õ9=†Žˆ§1ÿÝx;罊µÙ°tçã¾íŽQ’9!ܬ-==®8Ä]WŽÄfSxíó-\5©W«÷ÙÖx¬K—b;|z÷BÙ¹}l<~ÿ¾ýÀöí»wS½ð}¬;wã“”@ÅŽT¼ý6þ7Ýäòx¶®þ„‘Sþa/£(ö›¤Í†ÕRÃúïÞ&8²ñ‰MÖíêx\Q¿+Ê !:VKîuIŸF£E‹‚¢Õ¢U´hµP\RL¬¡ ï—1ò¶»8ºü6ýëzƼöI“ûl)Iæ„p£º‰´­ýamµ)X¬6ö§—`µ)mJë®w’‘éå—ñæÀ!|.» ï¹w¢Õëõé"#ñšt6Õó_ÇüÁøöêIéóÏcœ<}sèÚÍjC±YÉ8²«Þç]ÈOÁ—oܪ(h°÷ØÕÑê½qö5 ;{¦Kãi)Wµ—ÂýZsÐh49r”‚ÂÛ2¬EÙ¿ŸAÿ¹žÌŸ·AzÅ;6¡¾Úx½2Ì*D'Ö–ä@UUÊ«j(,©Âj±¸´§§¹xj—-Cßµ šòJ´Ý{`¼c.¯¼ö V«;æÌEQ^xñ9‚‚ƒ™}ûl,›6£ÉÍÁJÅ’%>ð€KãQTsu…ãÿ(Í©Àf+>þI·zåõ:}â‚éedãO‹:é*—ÆÓRÒ3'„gké}@«ÑÒ¯__úö탢ØñVT…´í˜ÙϨà U3H/ÙLvv‰ïÎk²^院kÉMáã•Gøø—ÃX¬6TU%ÀßHi…™ÂÒj Z˜0çsTUE§ÕpÍÔD®?¿¿Ó}¶%žÚ1¼°•–b¼çÐj(*.&--•ÇŸxEUÉÌÌdÀ€ ïfQ~ï½è¼}0­_ߦ›T³=sŠ‚©ªÜñÿG²ËYúñ'MN$VU…3¯ Ox–f’`W$seûX°ùŒz¿Ûîýq8þ†f zŒ¾¡£Ö%ÉœK‹{æ´Zí?HA~ã3sÑ”ôï=b!µû9p`/‡{˜¨LœÉ¹\-Éœž¨%7…–ïgÊèÞ¼ô(Š‚ͦ²/µˆ‚ÒjF ê†Ñ CQT*«kxÙN®;/Éé>Ûe÷nŒÝ㡸mÿþ¨ªÊ½wßÇSO?AzF111ÜvËlTUE;`TV¡‹‰¢fçn×'s6…²’"¬ûÓ¬Š¢ ÑhY±êÇFËOžtŠ¢RUYy|"rÇ%s‹¶ÝËÔqÃßÌŠí'†FôÉYƒ/áXé.¾Þû"÷ñ¹Óº$™¢siyÏœ†ÄÄDú¡(*…é;Ù±ã;FF¨õ {÷îdã.yø7Þûä[§÷ž–’dN7SÅéâ“V‹…’Š¶<hÐj5hµZ´Z ;Ž:þ®ª VK­ÓúšÛÞ\Ÿ¹³ç€FëXø¾{þ¨T¿µËöí¨!!˜ÊʽôR—ÏQ‹‰‰§K@Z­½g.>ZCvúbÆ£ÑéQÕþV UAUíuEª V«…=¿/í°9s¡!a<üàÜkž‹ªª¼ ètz,ÖZ,},Xέ¥öŽZj-víÚÞæä[qj´&™4hŸ/ø½º°xo¾ÁݸüɯñØ>¹ÞæöÙR’Ì áfmIæ¼ô:l èuZ¼ôº6%smFÔvïŽÿ]wQößôê‰yÑ",›7ã}Ã,tÇ ¶íÙƒiá"¬;w Š¤<%¿9sÐõìéúaVEeÈ™—àåe@QEÅfµPR˜éX²¥îAUUQV‹ÞèCYyE‡ ³îܵ“ØØnTUU`³Úˆï€ÁËHeE%iÇR G§Ó“››‡:°íÃâB÷kÍ}»¦ºŒƒ)tÔ«ï]@h÷!Ž·Ahµ ªrbšˆ ³ á4cí¡Ö¸ö‚A¼ñÞ2Çß[ûý¦&Ò¶$ŸnÀüË/”§¤à×£¶ì,*ï¹µªÚþ:/?_´]»@D8e©ÇÐÄwÃï–[š­³­ñ”•—cª,ÃŒ‚¢Ø£¬N«AQA£ª¨6P4*ªÆ^®¢¤’’â’f†oÛ~~Ò3Ò±Z-(ŠBIi `ÿ}˜Íf¼¼ Lœ0ƒÁ@^^žÓúä!:Öß·U–|óz£ï‰µæ´ UT´ ?‘ĵå>ÙIæ„p³¶ôÌ]{^®=ïÄZrîf­¸t)Uï¾KÉË/ãŽÖß}LÀZZFmI)¦Â"|g϶'r ´qø ¹xJJJ©¨,'84À±¾œª ZÇ·6› E±¡ØìÉ\iieee6Ìš—›Á`Ä`0D½=zl“ee˜UÏâì>àííCYY}Ÿ×M Ñ¡«WWQq!F£ ³ á‰\õz¨Öjª»¾5ñøÞpÆÉ“1ö¦±mÝØŸx5L›@àßÿŽ¾W/û‚m|ºÖY<£§\ɪo?rkƒý£'_ÙêaÖ–žŸ¼¼ Éœnd³Ù %22Ò±2xGS«ÕŠÅb‘x<<!„ûyÂ}@’9!ÜÌb±tªÔOó:[QŸ´—ÝépN‡cBˆÎ¤ÃæÌ)ŠÒQU»DgOÔ'íew:œ‡Óá„¢3‘dNxi/»Óá<œÇ „‰$sÂ#H{Ùçát8!„èL$™AQ¥½àô8§Ã1!DgÒqÉ\'¿awöøD}’|ÛçA±yþ1!DgÒaK“4õCgÞk/QSSóïÄÇÇuë9eggñáÇ‹éÖ­;W^~U»ã«ãããKhh(I‰ý4p°Û^²ûg­=>°¿XUUt:ãéÁ¶ÔÓ8K Xøþ;hµZn»e~~~Í–ßüÇFVÿºŠqcÇsƸñ­Þ~ª4v^ž÷B³ï ìlmÝØ¿½…‹Þ¥  Ÿ)çL%9yX½m˾û†}û÷ræø‰Œ=¶Ézë®í^={séß/wyÜBÑYÉ0k /&S5é,ÿùG>ùt V«ÕM¶ß?}ÏK¯<Ï‘#‡Ou(íæ¬'u×®örŠÂž½»ÝÒ)ÑØy0Ž?u¿lèõzÇg^^^î³YàƒØ»o½Ïm6GŽÚ¯ßþIý;>8!„ð@nï™ë,œÅwËM·áããKmm-iÇRùeåÏdd¦³eËfF7Ó;Ð^UUU:|>}ú¢ª*„…†ÿï{°Ýõ»ªwk®½¬V+{öîA«Õ¢( ;wí`ÔÈÑ.ÛwSmr*’¤ÆÎÃí·Þáøû?}Ï®Ý;9çì) 4Ä¡µXcÇ”8€Õ¿®"++“²²RHKK¥¶¶–¸Øxºv pw¨Bá:]2W]]ů¿­&5-…ÚÚZ¢"£™pæD¢¢¢Olÿ}5i©©˜Ì&‚ƒHHH¢{·îõꩪªâÃQVVÆ„3Ïbô¨1mŠÏ`0зO?Œ#Ÿ|¶„?¶žH檪ªøeåϤ¦¦àíãMbBgŒ;NÀ[6³sçvJËJñóõ#**š‹/ºÄéqü¼â'6n\OyE9ááL|n½áѺ!¥Ä„$ò ò)//#<,œqcÇÓ£GOÞ_ü.ùùöwR~õõDFD2ùœ© †Y›;çuû8`ÅÅEеKWFŽÍÀã½)îÐ\{:|³ÙDò¡ääd“›—KFF:qqñŽ2•U•ü¾æWŽ9‚V«A§«é7·½¬¬´Ñ6¹þÚYíºšÛÖ–óЫÕÊ› æc2UsåWÑ-¾;yùy,ZüÁAÁL;z³×8¿Þ[ª±cðõõ¥w¯>:|}û÷2fô8:@ÿþû‚Ã_}ýÙÙÙ˜Í&HJÀØ1ãÔyôè¾øê3’¸púÅ|öÅ'¤¦¦0sÆ5ÄÆƹ옄âTêTì‹…—~Äî=»èÚ5€¸¸xÒ3ŽñÑ’ÈÏÏ;±}÷.¼}|èÕ³7Š¢PZVÒ ž/¿úŒ²²2’‡ mȵ%¾ØØ8´Z-ÕÕÕ˜LÕX­V–|ò 22 /½7m`åê_8šr„U«¡ªºš˜èX F#YÙ™õ³™ã¨µXÿòSÒŽ¥Ò³goì=q±ñ$%  gÏ^­>çuÜ¢ª„‡…ST\Ä?}GqIq«Îa{4×^»ví 1!‰„„$vv¨­­åÓO—°{÷.üýý‰Àf³¶x»£ÜŸÚ¤=×@sÛÚzš¢×ëš<´Þ¹Ø·Ï>¤9xp²ã³¦®'gÇÚMàƒØ{<.EQ8|ä:Ž„~ €=™ËÉÉ&:*š~}°Z¬¬[¿†-[7·:W“BœJªgnßþ½ѯ__SXÝÖ IDAThï¡Ø¾c?¯ø‰õÖÑ£GOŠ‹‹èÓ§/—\|i½ïfgg **˾ÿ†œÜz÷êÃ9gOqI|UUðò2°ÿ>{,½û2aÂY(6/ý;¶1iâÙÔÖÖÆèQcˆC¯××;ÎæŽ#""‚s§žßàó?‹ŠŠæª+¯®w®¶mÛÊ%»”òòrÊÊÊ1|$}úôm´gç|äˆQ€}x¶®'oùÏ?²cçv22Ò rý«àÓT{•––p,= ?bcãèÚµ+¿þ¶Šƒ÷3ùì)x{{sèÐA ‹ é×7ÁÑóU÷€àt{?·ÉîÝ»Ú| 4·­-çÁ™ä!Ãظi`²y*F£‘ýö¢ÓéÐ ¥¥ö_$šºž*Ê+š=Ö–Äîìzô艟ŸEE…äåçaª®Æl6Ó¯oF£7Z­–Ù·Í¥²²’ââ"ظiii©ÄÆ4|ßjsœýnÍ1 !Ä©Ô©’¹ââ"b¢cŸÅDÇ:¶èijú¦]YUI^^.úlòéÓÖÆwôèTU%<<½^OAa`ïÉ8|äP½²¥¥%$ôK¤¬¬Œ-[7óÙŸàååÅÀƒ9kÂ$Çq6wmQW_]ý-áìœ7ÆÏÏ€šs›âl‹¦Úkçn{OSeU%Ï¿øŒãs›Íƾ}{:t8…öá昘˜Fëp¶½)í¹šÛÖ\ÑÖdÎÏÏþIص{'ûöï%,,ŒŠŠ ’ðõõu$s';ùzrv¬¡¡a-Ž¥©cÐjµ è?M›7²oßǺuC¬`O‚¿]ö?Ž¦­÷ÝæžæmŠ+I!N¥N•Ì‡íø,;ÇÞ“êØžž‘Έá£­£K—.L:ël¾øò3~øé;BBC ms|µµµ¤¤å§å?0b˜}¿]ûÐ^âñ¡½1t¥ªªŠÁƒ†0jähòóóXµz%Û¶m!<,¼EÇÑyyöaÑà{ýuï2·X›þAçìœwµ—¢(ìÙ½ ooÇñÚl6jkkÙ±kC‡'00€Ü¼¼uN·7¥=×@¯ž½›ÜÖ܃ íy°hÄð‘ìÚ½“]»v}­W‡M±öù®`OôãÊcBˆSé”%so¿»À±ö€¿Ÿ?×\}›7oäÀÁý”T†)©)èt:ÆŽG``›6oäȑü¿ø]B‚C),*$:*Ú1ß WÏÞœ9~"¿¯ù•/¿úœ\}>>>­ŽÏjµÖ[ŠdØÐá 0€Ä„þ¬]·–£)GÐ{ééÚ¥+ÕÕÕ ÑЧO_vïÙÉÊU¿Ð¥Kºøw¡¨ÈÞËBDDd‹Ž£%rr²ùò«ÏÑh4¤¤Ú{+F²? lOÆVü²œ;w`µY9û¬sê}?)±³ç¼-=¡±öJI9JeU%ÑQÑ\sõuŽÏkj̼µà òÉÉÍ!)©?7®gß¾=”—•Láñ^Àéö¦´ç8pp_“ÛZ{Z*44Œž=z’’šBQqAAAÄÇw«W¦©ë)0 °ÙcmæŽ!$$”èèÇt€ä!C}¡¤´„cÇÒÈÉ=ñKˆ¯¯}ÝÊÌÌ ¾üês’‡ Åàe ##?^ŒN«#/?×QÞYû !„§8e@˜ÍfL&“ãÙlÆËË‹™W]ÃÀƒ¨¨¨ 3+‹îݺsÍÕ×nß>ã’’PYYÉÁCPl6üý»4¨Ìè±ôë—@ii _ûU›âÓétÓ§w_®¼âªzóï|}}¹âò±{÷.Ö­_ËöÛ¨8þ´cdd4ñqÝ°X,Ä…Ó/&66®UÇáŒ^ïEQq!ééLjŽŠaæŒkL$FRb4 EÅ…øøø`³Ùê}ßÙ9ï,[›lçñ‡ÆŽ=£ÞçF£7Æ ·—Ù¹£ÁÈÌ™ÿ 1!‰ÒÒR>„Ÿ¿¿ã— gÛ›Òžk ¹m­=­1âøH«ÕÊàA {嚺žœkk8;†“¡éŸ4 Þ¶aC‡Ó½{rr²ùõ·U”–”`ð²÷À1lèp´-ùyè½ô\|ñ߉   ŸÚÚšzIš+I!N%Í’%KÔ3f¸¼âÔc©ôèÖÃåõžLUU§?p›âÊøjjÌTVUáïç瘨Ým9O}“C[¥¦¥Ò£{Ç^OíÑÞk ¥Ú{ÝÖÔÖðÚë¯Ô{SFk®§ö«+ÚÒdª4 zÜÛÊ]í'„®¶téÒÎ5g®µÚšÈkã3½Ûõ =ÇñWÑÙ¡nï5ÐRí}¯éž=»Q…„~‰N_yÖ”ö«+ÚÒ•¯÷µŸBt„NµÎœ;uöøD}í^<]´ç<¨ªÊÖm[<øÔ½BÚR!\Ë£{æÚ£³Ç猉 I™å<½½\¥=ç!5-•’’bo¨ãÎëIÚR!\K’9ìxEÑ_§·—«´ç.ÞiY½^O||74 Û¶oeêäsÝ¡è¬ÅÎ?69-WYYÉ‚wßcåªÕËœÛneÒÄ lܼ™%Ÿ|ƶ;°Ù¬tïÖ«®¸‚éÓÎï˜c0øcÝ—ïÏ“lܼ™×æ¿ÉÞýûm×–´Óö;ùô‹/Ø°i3–ÚZºu‹çÊË/ãÂiÓ¼C!‡áC‡òÚK/Ò?)‘¬ìž{ñ%rrr¸é†Y.§±$eþ[ (-+sé~<Ñ;ï½ÏÝsï`Ö-·6º½%íôêopÙß/áî¹wHFf&Ï¿ü ™™YÜ~ËÍî<!„èXK–,Q;‹wÞû¯ZUU©šLÕ-þS]]¥¾ýî—ÇrÎyÓÔ!#G«{öík°í²3Õ¹÷ÜÛ溧^p¡:dähÇŸISÏSoŸ{§º~ã¦ö„Üf•••ê›ÿ}[=pðà)­£= é´Ìâ?Rxè‘f˼4ïUUQ”zŸåä檧LmW|-QYU¥žyÎ53+«Ã÷Õl§¸-OÖT»¶µòòóÕ3Ïžì²ø„âT[²d‰Ú©žfµÙl(ŠE±µêÍfëxEá¡G£¦¶Ö¥õÚl6† Mæ©Çá‰Gæºk®¦ªºš[fÏáÃ%K]º¯–¨¬ªbÁ;ïràС•ó¿osßÿiWáëeß1íâK6fþý2¾^ö]½í¿¬ZÍå—þ½Ù:îž{Gƒ!8o£›µþ5öÛš5\;ëF†=ƒ “§òÈãOR^^Ñê2'ûì‹/7z41ÑÑ-9ÜVk¬ÝÓÚÒ™–¶Sc,Í^€„~ý¸ûŽ9n‰I!ÜÅi2wÑôé$Òè¶ø¸8—cµv®d`Öu×òëo¿óðãOðÙÇáëëSo»¢(̾ónò ¸ãöÛèâïÏÇŸ|Â?þyÿûüS"ÂÃ[¼¯¸ØXIIMÃf³qûÜ»ˆ‰á«O—RYYÅœ»ïá…ïsÇí·qèð|ä1®™y—\t…>>„†† ( **6E!#3“Þ½zòà¿ï£¤¤”…‹?à–9wðáÂ÷xô?2ÿ­dçäððƒ÷ByE…£g礎ÅRË ÿ÷4QQ‘<ñô3<õÌsíJæ PïÿèOJjªãÿ Üw/ý“’èÓ»=p?÷=ð`£Éܯ¿¯áÉÿ{†·æ¿F`@€ãóòò Þzç~_³–‚‚Ç0üÉ×mKÊÔQ…Å}Ì3O>Ñæcš½&šk7húz¨ÓT[)ŠÂwß‹ªª,z÷mºøûóõ²ïØ»o_»Ž¥5šj§:;ÿØ„ÅbáhJ Ï¿ô ¯½ùÿ¾çn·Å'„Íi2—”˜@Rb‚;bé”ÉœN§ã©Ç㊫¯aÞëóyðßõ{"·nÛÎŽ]»xëµW;f4ÉCsöyÓøì‹/™s[ãOã5E¯Ó¡ª*[¶mãXz:7þózLf3:½ŽÄ~}ùmÍZî¸ý6t:-†ÜÜ\Ìf3#‡gÔˆìܵ›½ûö±dñûŽÄåÏ=$ÓÎ?×1Œ–—Ÿß Ž³&Nàì³Îì=”W_ÿO¶lÝÊ™ãÏ 44”Ò²2Æã(_—´äœÔÍ[›8áLG¯ÙÄ3ÇóêoRUU…ŸŸ_«ÎYs´š3 "ÂÃô|u‹#'7·Á÷–¯XÁÿ=ÿ"o¾6~}úÔÛöÐcÀ민LLL4Fƒêjc&LlU™ûú…¨¨Hèß®cmîšš<¤Ùvsv=4ÕVûdÏÞ½õ®µäÁƒùà£Ûu,-Õ\;ÌËË‹„~ýxæ©'¸lÆLI愧•N5ÌjµZÐh4¨ªê¼ðq X­-_ʤ-zöèηÝÊ‹ó^eÒYêmKÏÌ W¯I‚¿¿?ááddfµj?…Ó½{7ÇwzìñzeB‚ƒíûëÙ“·^×ß|‹ÿ¸–Þ½z1÷öÛ8sü¤¤Ù{£\5‘>¡__>Ì™ãÏpZ¾-çÄÇ× UËÒüÙÎÝ»ë%*»÷î«—¼ 4£))Ž¤àXz‘õêùòë¯yé•WY0ÿuú'&6ØÏ–­[YþÝ·téÒÅñÙæ-[Z]¦ÎÂÅ‹¹÷®;[x”Mkîšp¥“Ûªnè6âOçÐœµSc:rŽ­Bœ*N“¹éÓÎo0|U§[¼óÅ}[CUAQUôZm‹~¨k4Zl6MË“¿¶š9ãJVýö>ñZí‰Þž¸˜XRRÓCªUUUäåç3uò9-®_UUÞ^¸€içN%'ÇÞ[ôí—Ÿ7yžÇŒɘQ#9tøO?÷wýëßüôí7„‡ÙãHKOgH``ëöOrróû00Øèæž vÕ9i­ç^|™'}˜~}úR{‰{îœëØ~åe—òä3ÏòÐýÿ¦OïÞ¤gdòÔ3Ïrñ…'æ±-\üóßZÀ¼žoòºOè×—,åš«f°é-¼òÚë­.°fí: ££­½šº&ÂÂB¶[[Ôµïþý=wîÐ’vºé¶Ù̸âr†%'cô6’’’Ê‹óæqÁù®_Z!N%§ÉÜ€þýп}Ã?-D~~ÑÑq F§åm6+9¹9ï­êHZ­–'y˜Ë®º“ÉD¿¾ö!áÆ2 žzæYæÜv+~~~,ýô3¼¼¼¸¢™e023³X±rªªRVVÆokÖ°fÝzfßz ½{õ":*šè¨(î½ÿîš3‡˜˜h²²²Ñh4Œ=Š½ûöqøh ‰ ý0xyѯO_vïÙ‹——žáC“‰ŽŠâ‰§ŸáÞ;çÒ«WORÓÒ1lX‹73+›òò **+xæ…ˆŠŒdü¸±ÄÆÄ°rõ¯|ûÝ÷èô:ÎWÿ‡¸³sbkGï[sn¸þ:þóÈcäæåͬë¯åŒ±cÛû'%qÓ¬Y<úäÓ¤gdÆEÓ/àÚ«g:ʼ:ßþÐÂœ»ïiPÿo+–Èÿ=ù8Ï¿ô ç_ü7jjjILèÇS=Êu7Þä(Û’2ï.ZĬë\óks×8o·¶=j$1ÑÑ<öôÿñä#ÅÎ]»Ú]ïÉ-ÔýýäE–[ÒN·Üx‹>üˆ‡{›ÍFlL4MŸÎUW\Þîø„¢3éTo€8{Ò9¬X±œ3Ï:Îùª)6Eá÷_gÒ¤ÉnˆÎÞ3uÏÜ;xêÙçŸiµZÞxõæ½>Ÿ—潊¹ÆÌàAƒøpỄ††6Y×Æ͛ٸy3]»’Я¯½ü¢ã__Þxõž|æYn›{'ªªÀ•—_Ƙѣ(¯¨äåy¯RV^€ŸŸ?p?Ç{âæÏ{™GŸ|Š[ï˜ëˆýõW^Â÷ø™3ï.|Ÿ·ß}€~}úðú+/;æ²Í¸âr¶nßÎÓÏ=O\l #‡ ¯÷]g礱9YíU÷ƒþ ¦5[nÒÄ Ž·=4WOs"#"xùù†KŒœüÝ–”Xüî;N÷×Rή gíÖ^^^¼»àMîÿÏÃÜ6÷N4 aÍ\÷-å¬ZÒNC“‡04¹ñ‡·„ât¢Y²d‰:cÆŒS‡Ãþûùþ‡e4;ÔªÕj cÊäs4p#t¿ššªªª ¬÷pˆ¢(—”`±Xˆ¯7ü[§²²’ÚZ ÁÁA-ÚWݲ!?üÆ&ãååEDx¸¼ËÒC´äšè(ètzÖ¬[Ë¿|ˆ¾ù_‡-€,„ÂnéÒ¥«g 1!‘Ä„–Mfþ«0 ‡µZ-¡!!Í~×ßß¿MûÔh5Ž9rÂs´äšè(u{8x½^ßàÁ!„£Ó%sBϲ~ÃFJËÊèÞ­ûöïçãO>岿_‚N§;Õ¡ !Ä_‚$sBˆv9pð ß~ÿ©ii„††2sÆ•Ü<럧:,!„øËdNÔS÷^N!ZêŸ×]Ë?¯»‹Å‚——שG!þrÜ7;ZqZ“DN!N Iæ„B!<˜$sB!„L’9!„B¦˜öê¡S‡B!„h¥«Ã¥gN!„£I2'„BáÁ$™B!„ð`’Ì !„Bx0Iæ„B!8/·³ãx[mO¯æÛJ˜>$ˆ7VåÕ+;ª§?ý"½™·âXƒdî_Ÿ×ßOzq-óVäòÆÌn§4Ùè mé¬ ¾ÚVÂÂ5Ž¶ŒâZæý’˼+»9’¹Îz~…ÂÕ:ÕÓ¬V«Uµ±'µkþo—?þ¿lMGUm¨ª•[Óyõë=\uþJ«,l¼ýîLNª?‡r\ï.ü°»¬ÝûéíÃÖcõ‡T·«b@ŒO½ÏüŒZfO çÍUù˜-Í÷6ŸL§uíõV§±vkLghKgÞ;)‘«ScUѵàŽÖQçW!N•NÕ3g³ÙP…W¿ÜIDt8£#yíëíÔX¬øûèyñó]\5m(•5 köæŸÇÓ{’wt{,®ç`®™ÞáF®Ê{k \ZwV‰…ÕNÌïùz{ ÿ:7ŠYãÃØ’VEfɉá:_ƒ‹MÅbk|¦Q¯¡Ö¦¢6²Y¯ÕàgÔRf²5ú]ƒ–ÂJk«ÞÏd >¸þúÖÖQG«=%U6¬Jûf2]6<˜—~Î%¥ †î!îšI©ÉÆ©öÄ+.Ø@€Ž7fv#:È@~¹…w—ñÍŽ’FÏ]SºèÉ-³_p/^‡¢Â#_gÖ¥þ?§Yg„±7ÛÄMÌ¥;™^«!.ØÀ g†Õ».Úª±k¢±vû³æ®gmåcЂ ¦V$®®táà@~?TÑè6WŸ_!„èLœ&s·N ç‚Á/ýñÝÎÒzCVíeµZQ…Z‹…ŒÂ*bŠª¹î¡¼óÝvj-V®™>”r“•õ{òÈÎÈå¶ó»qÆÀ(>=huY 'K)¨asj%W eãÑJöf›-çgÔrݸ0Ft÷ÃÇ á`®™÷Ör¬¨åCTª ¬/ä̾]˜”Е6àŽS£è墨üz°‚7WŸèå9+¡+׌ !¢«5V•Ÿv—òöïö¤3ØOÏìI ëî‹^«!»ÔÂÓßgSi¶±xVO¾ÛYʘ^þ„øëyú‡|8/œy+rÙž^Íó—ű;³š=üðÖkÙ•ibþª<Š«¬ü÷݉ 2ö‡n\œJ­UåýödÞŠ\Vî/oöœ„úëY<«'¿ª`d?¼½´T×*¼¸<‡M)Ο¦,ø­€}ÇÛè@®™ÿþšÏŒQ!ŽdÎ× å²áÁ¼¾2Ô¢ Ì™ |³½¤Åû1êµÔO¬µ  RcUðÖŸèë˸>þÜòÁ1§õÕG€£5,\Ûö!À¦®‰æÚ­áõPÀç…1oE.;3ª¶U ¯Ž;ωdx?TŽä›éáÍíkÕ¿öÝÓŸI‰]™»4½Á6Wž_!„茜&s+ö•7™Äd—º¶;¬.™»jB/üï(h´è´‘Ì<¦+f«Ê†ýùdeæpã”8& ŽÂ×׫Նªë˜çÓ>ßRÂèžþÜ5%’9kÐë ÕÀãÅì§gѺªj.ÄK—ÇqˇiV¶<ÑÌ)³Pn²l@§ÕðøE1ä–[¸íÃ4| Z½0†+F³x}!=BÜ;5’ÿm+aùÞ2BüôŽa1ž^«áño³)ª´l «¤–±Á>ÞT„Ù¢PPnC«±O«¨/Žéxsu>>:.ÌS‹ážO3xmeÿJDW/^_iŸV\eÃߨ­WGs礎—Nó?æ_n厳#¸ý¬6¥¤´¹­æÖ¿N晉18þ¿Ö¦²à×|Ÿ™VXÃüUyÜ~T«’¹«‚A§¡Æªr÷§öäÁÛK‹Ùzâڸ㜯+¢¤ÚyûO{õz†nÁnšεcCùïo­ÿ%©¹kýYë½IDAT¢¹vƒ?]VG[Öiª­4xtz hà¾Ï2¨®µqNR}#¼[[êéÏœ³#xè™T˜ö@»êü !Dgåt†É‘|3¿ªhôÏ‘|³³¯·J]2721’û.îNQ^>÷å’Ul¦Æªð뮲ҳ¹yj,“’£ðóóCQl6+µÖ€MQyéç\Býõ\Fhƒíb|IŒòaþª|~=XÁ©U<óC6Z­†óµ~1c›ª¢ÑÀÀb‚ üv°£—›jïUÕÓEUQ±ùõZvfTóÕ6{B’åCßo^_™Ç¶cU+ªaíáŠzô«”³|O¿¬ ¤ªá˜ŽV²þH%?î.ã¹sèbd`¬{³LWY©®UØz¬Š­ÇªÌké9Ù˜RÉ©öø6¦Tâ¯Ç×àÚiœ'3VXôe•ÖÞÅ«UuTX‰ ¨ÿˆ®^TœHÜ¢¼¸}R8ßÏíëøõ{‰Nfµ©-¨á…Ÿr8+¡mó?›»&œµ[½ë¡²á/iMµÕ€_úFzóÖê|öç˜8VTëèu‡3ûváÎs"xìÛ,R ›îtÅùBˆÎªS ³ÚlöߪF##£¹K…W¾Mc“ª¢×ëÈÉÌãÚ‰ÑL¿¿?ªª¢ÑhP[3á© 2ŠkY¼¾Ƈ±þ¤%,¢í?ÔÓOJªj +,D´.IöÓè«'³¤Ö‘,Ü=%²^™Òjû9:VTËÃÿËäcCyuF<ÇŠjX´®Í©UÄÛ{£rË]Ószôø=ÂŒlNu> Ú–sR—XhÚ17=!²þƒ }#¼9Vt"Q=k¦[ˆÑÑ3h  ¢uçio¶‰¡ÝüêÕ=¢»{²N$1Í9kÉZx}~W[4wM¸ÒÉmdoÏ“Yw9w@7Œã¡ÿe6xâ¼)í9¿BÑY9MæV(ç@nã7ʬR×®ï¦(êñ6 F£‘á ‘Ì¶Úxeeµ WŸÉäaÑøùù99lŠ •Ž½A³½„1=ý¹óœH”“’Çœãáã‚ Ž!U_ƒ–Ð.^¬9\Ùh]ÑWŽ `õ »ڛæ¦ÒÈ*iüý£˜{§FÚEO^™…϶×{+á<3K7qç9D(ª´²b_ÿÛV¾ÜÉC¡u?¹G-­°†WÉåæ‰áDx‘Ujᕹ.Üœ%›ŠøûÐ`N ¹eVì+gÙΦ¯›æ4wM€óvk‹íéÕä•[¸ãì^Y‘G~¹…Ä(ç_tÂY\?Î>åáÑ c|wÆÛG)7Ù\~~…¢³êTK“¤j°ò×ß™xæX´'u!(Š*X*Ì”Tžô¹ÊÚu›8æÕß-ñå”YxoM!·O ?ƒ |“Å?Ïå†ña½4ìÏ6s÷§éŽÞÆ ‰÷eH¼/fG ì‹×Ö=!h²(<öM³'EðÄÅ1hŽ—[¶³”méÕøµÌFo{[]«0U>åÇ— yüÛ,æžÉ“Ç8b웬¯wvňfŒ ì ë>ömÕµöï.ÛQÊ€nŸANiíÿ·w­MƒqÇI³¦[esà”1AdóâI&¾z_€'_„âÕwà+ð"ÍaxðäÅ»((c7e[a¢Ý†¶Î-Íãa´m›4¦´Ïúý\[ÂCžòKòäÿ×ûOñBÇIçäÜ™ü—]çBÿg;§^^üëö0èXƒ¼Ýiýúòïãn×j»^ïóïá%­‰¤yË"l=z^Óƒ[Ëz|wEÆhàºO+iÒÌQÞç&•S©T̳/×Ç=Ž®³‡´ÒªÊ&wuý}ž[Wc¶÷¦òÓ¢è9š+º:hµcßy¸Ž´0ëÉ+œ¼îêµu°ì»š)8ݽvI:eCž¼ÚÕV­¥02úú=¤—¥%Ò¬‰Q)û®¢Hºq¹¬‡·—uÿéŽvsÚ· èíÞùÍÉz2'Iû¥5í—Öäšc9®DFRäûþ~š…FGá¿a,2J,}Ñü•­€kdLwïì‘fMŒJg­­.ù'7C”åd7qa®#rf4âoä`ýRYó%Wµ½c]¹àëεE½Ü:Pû?;zÒ™Ø0À«K¾n^×ÅÅ¢ÍP/Þí)xómÜÀ©A˜CLÖ«˜^Õ†6ª yGaŸþÁ€Ñɹê€iE€ñ ÌXŒ0`1€Å<)Þ:v‚MžÌØŒ0`1€Ås#ÌXŒ0`1€Ås#ÌXŒ0`1€ŠCopyright (C) 2009 Eli Dupree Copyright (C) 2009,2010 WANG Lu Copyright (C) 2014-2016 Sebastian Parschauer This file is part of libscanmem. This library is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this library. If not, see . */ #ifndef _GNU_SOURCE # define _GNU_SOURCE #endif #include "config.h" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include /* to determine the word width */ #include #include #include #include "commands.h" #include "endianness.h" #include "handlers.h" #include "interrupt.h" #include "show_message.h" #define USEPARAMS() ((void) vars, (void) argv, (void) argc) /* macro to hide gcc unused warnings */ /* * This file defines all the command handlers used, each one is registered using * registercommand(), and when a matching command is entered, the commandline is * tokenized and parsed into an argv/argc. * * argv[0] will contain the command entered, so one handler can handle multiple * commands by checking whats in there, but you still need seperate documentation * for each command when you register it. * * Most commands will also need some documentation, see handlers.h for the format. * * Commands are allowed to read and modify settings in the vars structure. * */ #define calloca(x,y) (memset(alloca((x) * (y)), 0x00, (x) * (y))) /* try to determine the size of a pointer */ #ifndef ULONG_MAX #warning ULONG_MAX is not defined! #endif #if ULONG_MAX == 4294967295UL #define POINTER_FMT "%8lx" #elif ULONG_MAX == 18446744073709551615UL #define POINTER_FMT "%12lx" #else #define POINTER_FMT "%12lx" #endif bool handler__set(globals_t * vars, char **argv, unsigned argc) { unsigned block, seconds = 1; char *delay = NULL; char *end; bool cont = false; struct setting { char *matchids; char *value; unsigned seconds; } *settings = NULL; assert(argc != 0); assert(argv != NULL); assert(vars != NULL); if (argc < 2) { show_error("expected an argument, type `help set` for details.\n"); return false; } /* supporting `set` for bytearray will cause annoying syntax problems... */ if ((vars->options.scan_data_type == BYTEARRAY) ||(vars->options.scan_data_type == STRING)) { show_error("`set` is not supported for bytearray or string, use `write` instead.\n"); return false; } /* check if there are any matches */ if (vars->num_matches == 0) { show_error("no matches are known.\n"); return false; } /* --- parse arguments into settings structs --- */ settings = calloca(argc - 1, sizeof(struct setting)); /* parse every block into a settings struct */ for (block = 0; block < argc - 1; block++) { /* first seperate the block into matches and value, which are separated by '=' */ if ((settings[block].value = strchr(argv[block + 1], '=')) == NULL) { /* no '=' found, whole string must be the value */ settings[block].value = argv[block + 1]; } else { /* there is a '=', value+1 points to value string. */ /* use strndupa() to copy the matchids into a new buffer */ settings[block].matchids = strndupa(argv[block + 1], (size_t) (settings[block].value++ - argv[block + 1])); } /* value points to the value string, possibly with a delay suffix */ /* matchids points to the match-ids (possibly multiple) or NULL */ /* now check for a delay suffix (meaning continuous mode), eg 0xff/10 */ if ((delay = strchr(settings[block].value, '/')) != NULL) { char *end = NULL; /* parse delay count */ settings[block].seconds = strtoul(delay + 1, &end, 10); if (*(delay + 1) == '\0') { /* empty delay count, eg: 12=32/ */ show_error("you specified an empty delay count, `%s`, see `help set`.\n", settings[block].value); return false; } else if (*end != '\0') { /* parse failed before end, probably trailing garbage, eg 34=9/16foo */ show_error("trailing garbage after delay count, `%s`.\n", settings[block].value); return false; } else if (settings[block].seconds == 0) { /* 10=24/0 disables continous mode */ show_info("you specified a zero delay, disabling continuous mode.\n"); } else { /* valid delay count seen and understood */ show_info("setting %s every %u seconds until interrupted...\n", settings[block].matchids ? settings[block]. matchids : "all", settings[block].seconds); /* continuous mode on */ cont = true; } /* remove any delay suffix from the value */ settings[block].value = strndupa(settings[block].value, (size_t) (delay - settings[block].value)); } /* if (strchr('/')) */ } /* for(block...) */ /* --- setup a longjmp to handle interrupt --- */ if (INTERRUPTABLE()) { /* control returns here when interrupted */ // settings is allocated with alloca, do not free it // free(settings); sm_detach(vars->target); ENDINTERRUPTABLE(); return true; } /* --- execute the parsed setting structs --- */ while (true) { uservalue_t userval; /* for every settings struct */ for (block = 0; block < argc - 1; block++) { /* check if this block has anything to do this iteration */ if (seconds != 1) { /* not the first iteration (all blocks get executed first iteration) */ /* if settings.seconds is zero, then this block is only executed once */ /* if seconds % settings.seconds is zero, then this block must be executed */ if (settings[block].seconds == 0 || (seconds % settings[block].seconds) != 0) continue; } /* convert value */ if (!parse_uservalue_number(settings[block].value, &userval)) { show_error("bad number `%s` provided\n", settings[block].value); goto fail; } /* check if specific match(s) were specified */ if (settings[block].matchids != NULL) { char *id, *lmatches = NULL; unsigned num = 0; /* create local copy of the matchids for strtok() to modify */ lmatches = strdupa(settings[block].matchids); /* now seperate each match, spearated by commas */ while ((id = strtok(lmatches, ",")) != NULL) { match_location loc; /* set to NULL for strtok() */ lmatches = NULL; /* parse this id */ num = strtoul(id, &end, 0x00); /* check that succeeded */ if (*id == '\0' || *end != '\0') { show_error("could not parse match id `%s`\n", id); goto fail; } /* check this is a valid match-id */ loc = nth_match(vars->matches, num); if (loc.swath) { value_t v; value_t old; void *address = remote_address_of_nth_element(loc.swath, loc.index /* ,MATCHES_AND_VALUES */); /* copy val onto v */ /* XXX: valcmp? make sure the sizes match */ old = data_to_val(loc.swath, loc.index /* ,MATCHES_AND_VALUES */); zero_value(&v); v.flags = old.flags = loc.swath->data[loc.index].match_info; uservalue2value(&v, &userval); show_info("setting *%p to %#"PRIx64"...\n", address, v.int64_value); /* set the value specified */ fix_endianness(vars, &v); if (sm_setaddr(vars->target, address, &v) == false) { show_error("failed to set a value.\n"); goto fail; } } else { /* match-id > than number of matches */ show_error("found an invalid match-id `%s`\n", id); goto fail; } } } else { matches_and_old_values_swath *reading_swath_index = (matches_and_old_values_swath *)vars->matches->swaths; int reading_iterator = 0; /* user wants to set all matches */ while (reading_swath_index->first_byte_in_child) { /* Only actual matches are considered */ if (flags_to_max_width_in_bytes(reading_swath_index->data[reading_iterator].match_info) > 0) { void *address = remote_address_of_nth_element(reading_swath_index, reading_iterator /* ,MATCHES_AND_VALUES */); /* XXX: as above : make sure the sizes match */ value_t old = data_to_val(reading_swath_index, reading_iterator /* ,MATCHES_AND_VALUES */); value_t v; zero_value(&v); v.flags = old.flags = reading_swath_index->data[reading_iterator].match_info; uservalue2value(&v, &userval); show_info("setting *%p to %#"PRIx64"...\n", address, v.int64_value); fix_endianness(vars, &v); if (sm_setaddr(vars->target, address, &v) == false) { show_error("failed to set a value.\n"); goto fail; } } /* Go on to the next one... */ ++reading_iterator; if (reading_iterator >= reading_swath_index->number_of_bytes) { reading_swath_index = local_address_beyond_last_element(reading_swath_index /* ,MATCHES_AND_VALUES */); reading_iterator = 0; } } } /* if (matchid != NULL) else ... */ } /* for(block) */ if (cont) { sleep(1); } else { break; } seconds++; } /* while(true) */ ENDINTERRUPTABLE(); return true; fail: ENDINTERRUPTABLE(); return false; } /* XXX: add yesno command to check if matches > 099999 */ /* FORMAT (don't change, front-end depends on this): * [#no] addr, value, [possible types (separated by space)] */ bool handler__list(globals_t *vars, char **argv, unsigned argc) { unsigned i = 0; int buf_len = 128; /* will be realloc later if necessary */ element_t *np = NULL; char *v = malloc(buf_len); if (v == NULL) { show_error("memory allocation failed.\n"); return false; } char *bytearray_suffix = ", [bytearray]"; char *string_suffix = ", [string]"; USEPARAMS(); if (!vars->matches) goto out_free; if (vars->regions) np = vars->regions->head; matches_and_old_values_swath *reading_swath_index = (matches_and_old_values_swath *)vars->matches->swaths; int reading_iterator = 0; /* list all known matches */ while (reading_swath_index->first_byte_in_child) { match_flags flags = reading_swath_index->data[reading_iterator].match_info; /* Only actual matches are considered */ if (flags_to_max_width_in_bytes(flags) > 0) { switch(vars->options.scan_data_type) { case BYTEARRAY: ; /* cheat gcc */ buf_len = flags.bytearray_length * 3 + 32; v = realloc(v, buf_len); /* for each byte and the suffix', this should be enough */ if (v == NULL) { show_error("memory allocation failed.\n"); return false; } data_to_bytearray_text(v, buf_len, reading_swath_index, reading_iterator, flags.bytearray_length); assert(strlen(v) + strlen(bytearray_suffix) + 1 <= buf_len); /* or maybe realloc is better? */ strcat(v, bytearray_suffix); break; case STRING: ; /* cheat gcc */ buf_len = flags.string_length + strlen(string_suffix) + 32; /* for the string and suffix, this should be enough */ v = realloc(v, buf_len); if (v == NULL) { show_error("memory allocation failed.\n"); return false; } data_to_printable_string(v, buf_len, reading_swath_index, reading_iterator, flags.string_length); assert(strlen(v) + strlen(string_suffix) + 1 <= buf_len); /* or maybe realloc is better? */ strcat(v, string_suffix); break; default: /* numbers */ ; /* cheat gcc */ value_t val = data_to_val(reading_swath_index, reading_iterator /* ,MATCHES_AND_VALUES */); truncval_to_flags(&val, flags); valtostr(&val, v, buf_len); break; } void *address = remote_address_of_nth_element(reading_swath_index, reading_iterator /* ,MATCHES_AND_VALUES */); unsigned long address_ul = (unsigned long)address; int region_id = 99; unsigned long match_off = 0; const char *region_type = "??"; /* get region info belonging to the match - * note: we assume the regions list and matches to be sorted */ while (np) { region_t *region = np->data; unsigned long region_start = (unsigned long)region->start; if (address_ul < region_start + region->size && address_ul >= region_start) { region_id = region->id; match_off = address_ul - region->load_addr; region_type = region_type_names[region->type]; break; } np = np->next; } fprintf(stdout, "[%2u] "POINTER_FMT", %2u + "POINTER_FMT", %5s, %s\n", i++, address_ul, region_id, match_off, region_type, v); } /* Go on to the next one... */ ++reading_iterator; if (reading_iterator >= reading_swath_index->number_of_bytes) { reading_swath_index = local_address_beyond_last_element( reading_swath_index /* ,MATCHES_AND_VALUES */); reading_iterator = 0; } } out_free: free(v); return true; } /* XXX: handle multiple deletes, eg delete !1 2 3 4 5 6 */ bool handler__delete(globals_t * vars, char **argv, unsigned argc) { unsigned id; char *end = NULL; match_location loc; if (argc != 2) { show_error("was expecting one argument, see `help delete`.\n"); return false; } /* parse argument */ id = strtoul(argv[1], &end, 0x00); /* check that strtoul() worked */ if (argv[1][0] == '\0' || *end != '\0') { show_error("sorry, couldnt parse `%s`, try `help delete`\n", argv[1]); return false; } loc = nth_match(vars->matches, id); if (loc.swath) { /* It is not convenient to check whether anything else relies on this, so just mark it as not a REAL match */ zero_match_flags(&loc.swath->data[loc.index].match_info); vars->num_matches--; return true; } else { /* I guess this is not a valid match-id */ show_warn("you specified a non-existant match `%u`.\n", id); show_info("use \"list\" to list matches, or \"help\" for other commands.\n"); return false; } } bool handler__reset(globals_t * vars, char **argv, unsigned argc) { USEPARAMS(); if (vars->matches) { free(vars->matches); vars->matches = NULL; vars->num_matches = 0; } /* refresh list of regions */ l_destroy(vars->regions); /* create a new linked list of regions */ if ((vars->regions = l_init()) == NULL) { show_error("sorry, there was a problem allocating memory.\n"); return false; } /* read in maps if a pid is known */ if (vars->target && sm_readmaps(vars->target, vars->regions) != true) { show_error("sorry, there was a problem getting a list of regions to search.\n"); show_warn("the pid may be invalid, or you don't have permission.\n"); vars->target = 0; return false; } return true; } bool handler__pid(globals_t * vars, char **argv, unsigned argc) { char *resetargv[] = { "reset", NULL }; char *end = NULL; if (argc == 2) { vars->target = (pid_t) strtoul(argv[1], &end, 0x00); if (vars->target == 0) { show_error("`%s` does not look like a valid pid.\n", argv[1]); return false; } } else if (vars->target) { /* print the pid of the target program */ show_info("target pid is %u.\n", vars->target); return true; } else { show_info("no target is currently set.\n"); return false; } return handler__reset(vars, resetargv, 1); } bool handler__snapshot(globals_t *vars, char **argv, unsigned argc) { USEPARAMS(); /* check that a pid has been specified */ if (vars->target == 0) { show_error("no target set, type `help pid`.\n"); return false; } /* remove any existing matches */ if (vars->matches) { free(vars->matches); vars->matches = NULL; vars->num_matches = 0; } if (sm_searchregions(vars, MATCHANY, NULL) != true) { show_error("failed to save target address space.\n"); return false; } return true; } /* dregion [!][x][,x,...] */ bool handler__dregion(globals_t *vars, char **argv, unsigned argc) { unsigned id; bool invert = false; char *end = NULL, *idstr = NULL, *block = NULL; element_t *np, *pp; list_t *keep = NULL; region_t *save; /* need an argument */ if (argc < 2) { show_error("expected an argument, see `help dregion`.\n"); return false; } /* check that there is a process known */ if (vars->target == 0) { show_error("no target specified, see `help pid`\n"); return false; } /* check for an inverted match */ if (*argv[1] == '!') { invert = true; /* create a copy of the argument for strtok(), +1 to skip '!' */ block = strdupa(argv[1] + 1); /* check for lone '!' */ if (*block == '\0') { show_error("inverting an empty set, maybe try `reset` instead?\n"); return false; } /* create a list to keep the specified regions */ if ((keep = l_init()) == NULL) { show_error("memory allocation error.\n"); return false; } } else { invert = false; block = strdupa(argv[1]); } /* loop for every number specified, eg "1,2,3,4,5" */ while ((idstr = strtok(block, ",")) != NULL) { region_t *r = NULL; /* set block to NULL for strtok() */ block = NULL; /* attempt to parse as a regionid */ id = strtoul(idstr, &end, 0x00); /* check that worked, "1,abc,4,,5,6foo" */ if (*end != '\0' || *idstr == '\0') { show_error("could not parse argument %s.\n", idstr); if (invert) { if (l_concat(vars->regions, &keep) == -1) { show_error("there was a problem restoring saved regions.\n"); l_destroy(vars->regions); l_destroy(keep); return false; } } assert(keep == NULL); return false; } /* initialise list pointers */ np = vars->regions->head; pp = NULL; /* find the correct region node */ while (np) { r = np->data; /* compare the node id to the id the user specified */ if (r->id == id) break; pp = np; /* keep track of prev for l_remove() */ np = np->next; } /* check if a match was found */ if (np == NULL) { show_error("no region matching %u, or already moved.\n", id); if (invert) { if (l_concat(vars->regions, &keep) == -1) { show_error("there was a problem restoring saved regions.\n"); l_destroy(vars->regions); l_destroy(keep); return false; } } if (keep) l_destroy(keep); return false; } np = pp; /* save this region if the match is inverted */ if (invert) { assert(keep != NULL); l_remove(vars->regions, np, (void *) &save); if (l_append(keep, keep->tail, save) == -1) { show_error("sorry, there was an internal memory error.\n"); free(save); l_destroy(keep); return false; } continue; } /* check for any affected matches before removing it */ if(vars->num_matches > 0) { region_t *s; /* determine the correct pointer we're supposed to be checking */ if (np) { assert(np->next); s = np->next->data; } else { /* head of list */ s = vars->regions->head->data; } if (!(vars->matches = delete_by_region(vars->matches, &vars->num_matches, s, false))) { show_error("memory allocation error while deleting matches\n"); } } l_remove(vars->regions, np, NULL); } if (invert) { region_t *s = keep->head->data; if (vars->num_matches > 0) { if (!(vars->matches = delete_by_region(vars->matches, &vars->num_matches, s, true))) { show_error("memory allocation error while deleting matches\n"); } } /* okay, done with the regions list */ l_destroy(vars->regions); /* and switch to the keep list */ vars->regions = keep; } return true; } bool handler__lregions(globals_t * vars, char **argv, unsigned argc) { element_t *np = vars->regions->head; USEPARAMS(); if (vars->target == 0) { show_error("no target has been specified, see `help pid`.\n"); return false; } if (vars->regions->size == 0) { show_info("no regions are known.\n"); } /* print a list of regions that are searched */ while (np) { region_t *region = np->data; fprintf(stderr, "[%2u] "POINTER_FMT", %7lu bytes, %5s, "POINTER_FMT", %c%c%c, %s\n", region->id, (unsigned long)region->start, region->size, region_type_names[region->type], region->load_addr, region->flags.read ? 'r' : '-', region->flags.write ? 'w' : '-', region->flags.exec ? 'x' : '-', region->filename[0] ? region->filename : "unassociated"); np = np->next; } return true; } /* the name of the function is for history reason, now GREATERTHAN & LESSTHAN are also handled by this function */ bool handler__decinc(globals_t * vars, char **argv, unsigned argc) { uservalue_t val; scan_match_type_t m; USEPARAMS(); if (argc == 1) { zero_uservalue(&val); } else if (argc > 2) { show_error("too many values specified, see `help %s`", argv[0]); return false; } else { if (!parse_uservalue_number(argv[1], &val)) { show_error("bad value specified, see `help %s`", argv[0]); return false; } } if (strcmp(argv[0], "=") == 0) { m = (argc == 1) ? MATCHNOTCHANGED : MATCHEQUALTO; } else if (strcmp(argv[0], "!=") == 0) { m = (argc == 1) ? MATCHCHANGED : MATCHNOTEQUALTO; } else if (strcmp(argv[0], "<") == 0) { m = (argc == 1) ? MATCHDECREASED : MATCHLESSTHAN; } else if (strcmp(argv[0], ">") == 0) { m = (argc == 1) ? MATCHINCREASED : MATCHGREATERTHAN; } else if (strcmp(argv[0], "+") == 0) { m = (argc == 1) ? MATCHINCREASED : MATCHINCREASEDBY; } else if (strcmp(argv[0], "-") == 0) { m = (argc == 1) ? MATCHDECREASED : MATCHDECREASEDBY; } else { show_error("unrecognized match type seen at decinc handler.\n"); return false; } if (vars->matches) { if (sm_checkmatches(vars, m, &val) == false) { show_error("failed to search target address space.\n"); return false; } } else { /* Cannot be used on first scan: * =, !=, <, >, +, + N, -, - N * Can be used on first scan: * = N, != N, < N, > N */ if (m == MATCHNOTCHANGED || m == MATCHCHANGED || m == MATCHDECREASED || m == MATCHINCREASED || m == MATCHDECREASEDBY || m == MATCHINCREASEDBY ) { show_error("cannot use that search without matches\n"); return false; } else { if (sm_searchregions(vars, m, &val) != true) { show_error("failed to search target address space.\n"); return false; } } } if (vars->num_matches == 1) { show_info("match identified, use \"set\" to modify value.\n"); show_info("enter \"help\" for other commands.\n"); } return true; } bool handler__version(globals_t *vars, char **argv, unsigned argc) { USEPARAMS(); vars->printversion(stderr); return true; } bool handler__string(globals_t * vars, char **argv, unsigned argc) { /* test scan_data_type */ if (vars->options.scan_data_type != STRING) { show_error("scan_data_type is not string, see `help option`.\n"); return false; } /* test the length */ int i; for(i = 0; (i < 3) && vars->current_cmdline[i]; ++i) {} if (i != 3) /* cmdline too short */ { show_error("please specify a string\n"); return false; } /* the string being scanned */ uservalue_t val; val.string_value = vars->current_cmdline+2; val.flags.string_length = strlen(val.string_value); /* need a pid for the rest of this to work */ if (vars->target == 0) { return false; } /* user has specified an exact value of the variable to find */ if (vars->matches) { /* already know some matches */ if (sm_checkmatches(vars, MATCHEQUALTO, &val) != true) { show_error("failed to search target address space.\n"); return false; } } else { /* initial search */ if (sm_searchregions(vars, MATCHEQUALTO, &val) != true) { show_error("failed to search target address space.\n"); return false; } } /* check if we now know the only possible candidate */ if (vars->num_matches == 1) { show_info("match identified, use \"set\" to modify value.\n"); show_info("enter \"help\" for other commands.\n"); } return true; } static inline bool parse_uservalue_default(char *str, uservalue_t *val) { bool ret = true; if (!parse_uservalue_number(str, val)) { show_error("unable to parse number `%s`\n", str); ret = false; } return ret; } bool handler__default(globals_t * vars, char **argv, unsigned argc) { uservalue_t vals[2]; uservalue_t *val = &vals[0]; bytearray_element_t *array = NULL; scan_match_type_t m = MATCHEQUALTO; char *ustr = argv[0]; char *pos; bool ret = false; USEPARAMS(); switch(vars->options.scan_data_type) { case ANYNUMBER: case ANYINTEGER: case ANYFLOAT: case INTEGER8: case INTEGER16: case INTEGER32: case INTEGER64: case FLOAT32: case FLOAT64: /* attempt to parse command as a number */ if (argc != 1) { show_error("unknown command\n"); goto retl; } /* detect a range */ pos = strstr(ustr, ".."); if (pos) { *pos = '\0'; if (!parse_uservalue_default(ustr, &vals[0])) goto retl; ustr = pos + 2; if (!parse_uservalue_default(ustr, &vals[1])) goto retl; m = MATCHRANGE; } else { if (!parse_uservalue_default(ustr, val)) goto retl; } break; case BYTEARRAY: /* attempt to parse command as a bytearray */ array = calloc(argc, sizeof(bytearray_element_t)); if (array == NULL) { show_error("there's a memory allocation error.\n"); goto retl; } if (!parse_uservalue_bytearray(argv, argc, array, val)) { show_error("unable to parse command `%s`\n", ustr); goto retl; } break; case STRING: show_error("unable to parse command `%s`\nIf you want to scan" " for a string, use command `\"`.\n", ustr); goto retl; break; default: assert(false); break; } /* need a pid for the rest of this to work */ if (vars->target == 0) { goto retl; } /* user has specified an exact value of the variable to find */ if (vars->matches) { /* already know some matches */ if (sm_checkmatches(vars, m, val) != true) { show_error("failed to search target address space.\n"); goto retl; } } else { /* initial search */ if (sm_searchregions(vars, m, val) != true) { show_error("failed to search target address space.\n"); goto retl; } } /* check if we now know the only possible candidate */ if (vars->num_matches == 1) { show_info("match identified, use \"set\" to modify value.\n"); show_info("enter \"help\" for other commands.\n"); } ret = true; retl: if (array) free(array); return ret; } bool handler__update(globals_t *vars, char **argv, unsigned argc) { USEPARAMS(); if (vars->matches) { if (sm_checkmatches(vars, MATCHANY, NULL) == false) { show_error("failed to scan target address space.\n"); return false; } } else { show_error("cannot use that command without matches\n"); return false; } return true; } bool handler__exit(globals_t *vars, char **argv, unsigned argc) { USEPARAMS(); vars->exit = 1; return true; } #define DOC_COLUMN 11 /* which column descriptions start on with help command */ bool handler__help(globals_t *vars, char **argv, unsigned argc) { bool ret = false; list_t *commands = vars->commands; element_t *np = NULL; command_t *def = NULL; assert(commands != NULL); assert(argc >= 1); np = commands->head; /* pager support, dirty ugly hardcoded */ FILE *outfd = popen("more", "w"); if (outfd == NULL) { show_warn("Cannot execute pager, fall back to normal output\n"); outfd = stderr; } /* print version information for generic help */ if (argv[1] == NULL) { vars->printversion(outfd); fprintf(outfd, "\n"); } /* traverse the commands list, printing out the relevant documentation */ while (np) { command_t *command = np->data; /* remember the default command */ if (command->command == NULL) def = command; /* just `help` with no argument */ if (argv[1] == NULL) { /* NULL shortdoc means dont print in help listing */ if (command->shortdoc == NULL) { np = np->next; continue; } /* print out command name */ fprintf(outfd, "%-*s%s\n", DOC_COLUMN, command->command ? command->command : "default", command->shortdoc); /* detailed information requested about specific command */ } else if (command->command && strcasecmp(argv[1], command->command) == 0) { fprintf(outfd, "%s\n", command->longdoc ? command-> longdoc : "missing documentation"); ret = true; goto retl; } np = np->next; } if (argc > 1) { show_error("unknown command `%s`\n", argv[1]); ret = false; } else if (def) { fprintf(outfd, "\n%s\n", def->longdoc ? def->longdoc : ""); ret = true; } ret = true; retl: if (outfd != stderr) pclose(outfd); return ret; } bool handler__eof(globals_t * vars, char **argv, unsigned argc) { show_user("exit\n"); return handler__exit(vars, argv, argc); } /* XXX: handle !ls style escapes */ bool handler__shell(globals_t * vars, char **argv, unsigned argc) { size_t len = argc; unsigned i; char *command; USEPARAMS(); if (argc < 2) { show_error("shell command requires an argument, see `help shell`.\n"); return false; } /* convert arg vector into single string, first calculate length */ for (i = 1; i < argc; i++) len += strlen(argv[i]); /* allocate space */ command = calloca(len, 1); /* concatenate strings */ for (i = 1; i < argc; i++) { strcat(command, argv[i]); strcat(command, " "); } /* finally execute command */ if (system(command) == -1) { // command is allocated with alloca, do not free it // free(command); show_error("system() failed, command was not executed.\n"); return false; } // command is allocated with alloca, do not free it // free(command); return true; } bool handler__watch(globals_t * vars, char **argv, unsigned argc) { value_t o, n; unsigned id; char *end = NULL, buf[128], timestamp[64]; time_t t; match_location loc; value_t old_val; void *address; scan_data_type_t data_type = vars->options.scan_data_type; if (argc != 2) { show_error("was expecting one argument, see `help watch`.\n"); return false; } if ((data_type == BYTEARRAY) || (data_type == STRING)) { show_error("`watch` is not supported for bytearray or string.\n"); return false; } /* parse argument */ id = strtoul(argv[1], &end, 0x00); /* check that strtoul() worked */ if (argv[1][0] == '\0' || *end != '\0') { show_error("sorry, couldn't parse `%s`, try `help watch`\n", argv[1]); return false; } loc = nth_match(vars->matches, id); /* check this is a valid match-id */ if (!loc.swath) { show_error("you specified a non-existent match `%u`.\n", id); show_info("use \"list\" to list matches, or \"help\" for other commands.\n"); return false; } address = remote_address_of_nth_element(loc.swath, loc.index /* ,MATCHES_AND_VALUES */); old_val = data_to_val(loc.swath, loc.index /* ,MATCHES_AND_VALUES */); old_val.flags = loc.swath->data[loc.index].match_info; valcpy(&o, &old_val); valcpy(&n, &o); valtostr(&o, buf, sizeof(buf)); if (INTERRUPTABLE()) { (void) sm_detach(vars->target); ENDINTERRUPTABLE(); return true; } /* every entry is timestamped */ t = time(NULL); strftime(timestamp, sizeof(timestamp), "[%T]", localtime(&t)); show_info("%s monitoring %10p for changes until interrupted...\n", timestamp, address); while (true) { if (sm_attach(vars->target) == false) return false; if (sm_peekdata(vars->target, address, &n) == false) return false; truncval(&n, &old_val); /* check if the new value is different */ match_flags tmpflags; zero_match_flags(&tmpflags); scan_routine_t valuecmp_routine = (sm_get_scanroutine(ANYNUMBER, MATCHCHANGED)); if (valuecmp_routine(&o, &n, NULL, &tmpflags, address)) { valcpy(&o, &n); truncval(&o, &old_val); valtostr(&o, buf, sizeof(buf)); /* fetch new timestamp */ t = time(NULL); strftime(timestamp, sizeof(timestamp), "[%T]", localtime(&t)); show_info("%s %10p -> %s\n", timestamp, address, buf); } /* detach after valuecmp_routine, since it may read more data (e.g. bytearray) */ sm_detach(vars->target); (void) sleep(1); } } #include "licence.h" bool handler__show(globals_t * vars, char **argv, unsigned argc) { USEPARAMS(); if (argv[1] == NULL) { show_error("expecting an argument.\n"); return false; } if (strcmp(argv[1], "copying") == 0) show_user(SM_COPYING); else if (strcmp(argv[1], "warranty") == 0) show_user(SM_WARRANTY); else if (strcmp(argv[1], "version") == 0) vars->printversion(stderr); else { show_error("unrecognized show command `%s`\n", argv[1]); return false; } return true; } bool handler__dump(globals_t * vars, char **argv, unsigned argc) { void *addr; char *endptr; char *buf = NULL; int len; bool dump_to_file = false; FILE *dump_f = NULL; if (argc < 3 || argc > 4) { show_error("bad argument, see `help dump`.\n"); return false; } /* check address */ errno = 0; addr = (void *)(strtoll(argv[1], &endptr, 16)); if ((errno != 0) || (*endptr != '\0')) { show_error("bad address, see `help dump`.\n"); return false; } /* check length */ errno = 0; len = strtoll(argv[2], &endptr, 0); if ((errno != 0) || (*endptr != '\0')) { show_error("bad length, see `help dump`.\n"); return false; } /* check filename */ if (argc == 4) { if((dump_f = fopen(argv[3], "wb")) == NULL) { show_error("failed to open file\n"); return false; } dump_to_file = true; } buf = malloc(len + sizeof(long)); if (buf == NULL) { if (dump_f) fclose(dump_f); show_error("memory allocation failed.\n"); return false; } if (!sm_read_array(vars->target, addr, buf, len)) { if (dump_f) fclose(dump_f); show_error("read memory failed.\n"); free(buf); return false; } if(dump_to_file) { size_t s = fwrite(buf,1,len,dump_f); fclose(dump_f); if (s != len) { show_error("write to file failed.\n"); free(buf); return false; } } else { /* print it out */ int i,j; int buf_idx = 0; for (i = 0; i + 16 < len; i += 16) { if (vars->options.backend == 0) printf("%p: ", addr+i); for (j = 0; j < 16; ++j) { printf("%02X ", (unsigned char)(buf[buf_idx++])); } if(vars->options.dump_with_ascii == 1) { for (j = 0; j < 16; ++j) { char c = buf[i+j]; printf("%c", isprint(c) ? c : '.'); } } printf("\n"); } if (i < len) { if (vars->options.backend == 0) printf("%p: ", addr+i); for (j = i; j < len; ++j) { printf("%02X ", (unsigned char)(buf[buf_idx++])); } if(vars->options.dump_with_ascii == 1) { while(j%16 !=0) // skip "empty" numbers { printf(" "); ++j; } for (j = 0; i+j < len; ++j) { char c = buf[i+j]; printf("%c", isprint(c) ? c : '.'); } } printf("\n"); } } free(buf); return true; } bool handler__write(globals_t * vars, char **argv, unsigned argc) { int data_width = 0; const char *fmt = NULL; void *addr; char *buf = NULL; char *endptr; int datatype; /* 0 for numbers, 1 for bytearray, 2 for string */ bool ret; const char *string_parameter = NULL; /* used by string type */ if (argc < 4) { show_error("bad arguments, see `help write`.\n"); ret = false; goto retl; } /* try int first */ if ((strcasecmp(argv[1], "i8") == 0) ||(strcasecmp(argv[1], "int8") == 0)) { data_width = 1; datatype = 0; fmt = "%"PRId8; } else if ((strcasecmp(argv[1], "i16") == 0) ||(strcasecmp(argv[1], "int16") == 0)) { data_width = 2; datatype = 0; fmt = "%"PRId16; } else if ((strcasecmp(argv[1], "i32") == 0) ||(strcasecmp(argv[1], "int32") == 0)) { data_width = 4; datatype = 0; fmt = "%"PRId32; } else if ((strcasecmp(argv[1], "i64") == 0) ||(strcasecmp(argv[1], "int64") == 0)) { data_width = 8; datatype = 0; fmt = "%"PRId64; } else if ((strcasecmp(argv[1], "f32") == 0) ||(strcasecmp(argv[1], "float32") == 0)) { data_width = 4; datatype = 0; fmt = "%f"; } else if ((strcasecmp(argv[1], "f64") == 0) ||(strcasecmp(argv[1], "float64") == 0)) { data_width = 8; datatype = 0; fmt = "%lf"; } else if (strcasecmp(argv[1], "bytearray") == 0) { data_width = argc - 3; datatype = 1; } else if (strcasecmp(argv[1], "string") == 0) { /* locate the string parameter, say locate the beginning of the 4th parameter (2 characters after the end of the 3rd paramter)*/ int i; string_parameter = vars->current_cmdline; for(i = 0; i < 3; ++i) { while(((*string_parameter) == ' ') ||(*string_parameter) == '\t') ++ string_parameter; while(((*string_parameter) != ' ') &&(*string_parameter) != '\t') ++ string_parameter; } ++ string_parameter; data_width = strlen(string_parameter); datatype = 2; } /* may support more types here */ else { show_error("bad data_type, see `help write`.\n"); ret = false; goto retl; } /* check argc again */ if ((datatype == 0) && (argc != 4)) { show_error("bad arguments, see `help write`.\n"); ret = false; goto retl; } /* check address */ errno = 0; addr = (void *)strtoll(argv[2], &endptr, 16); if ((errno != 0) || (*endptr != '\0')) { show_error("bad address, see `help write`.\n"); ret = false; goto retl; } buf = malloc(data_width + 8); /* allocate a little bit more, just in case */ if (buf == NULL) { show_error("memory allocation failed.\n"); ret = false; goto retl; } /* load value into buffer */ switch(datatype) { case 0: // numbers if(sscanf(argv[3], fmt, buf) < 1) /* should be OK even for max uint64 */ { show_error("bad value, see `help write`.\n"); ret = false; goto retl; } if (1 < data_width && vars->options.reverse_endianness) { swap_bytes_var(buf, data_width); } break; case 1: // bytearray ; /* cheat gcc */ /* call parse_uservalue_bytearray */ bytearray_element_t *array = calloc(data_width, sizeof(bytearray_element_t)); uservalue_t val_buf; if (array == NULL) { show_error("memory allocation failed.\n"); ret = false; goto retl; } if(!parse_uservalue_bytearray(argv+3, argc-3, array, &val_buf)) { show_error("bad byte array speicified.\n"); free(array); ret = false; goto retl; } int i; { // if wildcard is provided in the bytearray, we need the original data. bool wildcard_used = false; for(i = 0; i < data_width; ++i) { if(array[i].is_wildcard == 1) { wildcard_used = true; break; } } if (wildcard_used) { if(!sm_read_array(vars->target, addr, buf, data_width)) { show_error("read memory failed.\n"); free(array); ret = false; goto retl; } } } for(i = 0; i < data_width; ++i) { bytearray_element_t *cur_element = array+i; if(cur_element->is_wildcard == 0) { buf[i] = cur_element->byte; } } free(array); break; case 2: //string strncpy(buf, string_parameter, data_width); break; default: assert(false); } /* write into memory */ ret = sm_write_array(vars->target, addr, buf, data_width); retl: if(buf) free(buf); return ret; } bool handler__option(globals_t * vars, char **argv, unsigned argc) { /* this might need to change */ if (argc != 3) { show_error("bad arguments, see `help option`.\n"); return false; } if (strcasecmp(argv[1], "scan_data_type") == 0) { if (strcasecmp(argv[2], "number") == 0) { vars->options.scan_data_type = ANYNUMBER; } else if (strcasecmp(argv[2], "int") == 0) { vars->options.scan_data_type = ANYINTEGER; } else if (strcasecmp(argv[2], "int8") == 0) { vars->options.scan_data_type = INTEGER8; } else if (strcasecmp(argv[2], "int16") == 0) { vars->options.scan_data_type = INTEGER16; } else if (strcasecmp(argv[2], "int32") == 0) { vars->options.scan_data_type = INTEGER32; } else if (strcasecmp(argv[2], "int64") == 0) { vars->options.scan_data_type = INTEGER64; } else if (strcasecmp(argv[2], "float") == 0) { vars->options.scan_data_type = ANYFLOAT; } else if (strcasecmp(argv[2], "float32") == 0) { vars->options.scan_data_type = FLOAT32; } else if (strcasecmp(argv[2], "float64") == 0) { vars->options.scan_data_type = FLOAT64; } else if (strcasecmp(argv[2], "bytearray") == 0) { vars->options.scan_data_type = BYTEARRAY; } else if (strcasecmp(argv[2], "string") == 0) { vars->options.scan_data_type = STRING; } else { show_error("bad value for scan_data_type, see `help option`.\n"); return false; } } else if (strcasecmp(argv[1], "region_scan_level") == 0) { if (strcmp(argv[2], "1") == 0) {vars->options.region_scan_level = REGION_HEAP_STACK_EXECUTABLE; } else if (strcmp(argv[2], "2") == 0) {vars->options.region_scan_level = REGION_HEAP_STACK_EXECUTABLE_BSS; } else if (strcmp(argv[2], "3") == 0) {vars->options.region_scan_level = REGION_ALL; } else { show_error("bad value for region_scan_level, see `help option`.\n"); return false; } } else if (strcasecmp(argv[1], "detect_reverse_change") == 0) { if (strcmp(argv[2], "0") == 0) {vars->options.detect_reverse_change = 0; } else if (strcmp(argv[2], "1") == 0) {vars->options.detect_reverse_change = 1; } else { show_error("bad value for detect_reverse_change, see `help option`.\n"); return false; } } else if (strcasecmp(argv[1], "dump_with_ascii") == 0) { if (strcmp(argv[2], "0") == 0) {vars->options.dump_with_ascii = 0; } else if (strcmp(argv[2], "1") == 0) {vars->options.dump_with_ascii = 1; } else { show_error("bad value for dump_with_ascii, see `help option`.\n"); return false; } } else if (strcasecmp(argv[1], "endianness") == 0) { // data is host endian: don't swap if (strcmp(argv[2], "0") == 0) {vars->options.reverse_endianness = 0; } // data is little endian: swap if host is big endian else if (strcmp(argv[2], "1") == 0) {vars->options.reverse_endianness = big_endian; } // data is big endian: swap if host is little endian else if (strcmp(argv[2], "2") == 0) {vars->options.reverse_endianness = !big_endian; } else { show_error("bad value for endianness, see `help option`.\n"); return false; } } else { show_error("unknown option specified, see `help option`.\n"); return false; } return true; } scanmem-0.16/handlers.h000066400000000000000000000436021302526536600150510ustar00rootroot00000000000000/* Specific command handling with help texts. Copyright (C) 2006,2007,2009 Tavis Ormandy Copyright (C) 2009 Eli Dupree Copyright (C) 2009,2010 WANG Lu Copyright (C) 2014-2016 Sebastian Parschauer This file is part of libscanmem. This library is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this library. If not, see . */ #ifndef HANDLERS_H #define HANDLERS_H /* * SHRTDOC's are one line descriptions of the supported command (shown with `help`). * LONGDOC's are detailed descriptions (shown with `help command`) (wrap them before column 80). * * The DOC's are passed to the registercommand() routine, and are read by the help * command. You can define SHRTDOC to NULL and help will not print it. * However, a NULL longdoc will print "missing documentation" if specific help is requested, * if you really dont want it to print anything, use "". * * Each handler is passed an argv and argc, argv[0] is the command called, along with * a pointer to the global settings structure, which contains various settings and lists * that handlers are allowed to change. One handler can handle multiple commands, but * you need register each command with its own documentation. */ #define SET_SHRTDOC "change known matches to specified value" #define SET_LONGDOC "usage: set [match-id[,match-id,...]=]n[/d] [...]\n" \ "Inject the value `n` into the match numbers `match-id`, or if just `n` is\n" \ "specified, all known matches. `n` can be specified in standard C language\n" \ "notation, a leading 0x for hexadecimal, leading 0 for octal, and everything\n" \ "else is assumed to be decimal. All known matches, along with their match-ids\n" \ "can be displayed with the `list` command. Multiple match-ids can be specified,\n" \ "separated with commas and terminated with an '=' sign.\n" \ "To set a value continually, for example to prevent a counter from decreasing,\n" \ "suffix the command with '/', followed by the number of seconds to wait between\n" \ "sets. Interrupt scanmem with ^C to stop the setting.\n\n" \ "Note that this command cannot work for bytearray or string.\n\n" \ "Examples:\n" \ "\tset 10 - set all known matches to 10\n" \ "\tset 0=0x03 - set match 0 to 0x03.\n" \ "\tset 0,1,2,7=0x32 - set matches 0,1,2 and 7 to 0x32\n" \ "\tset 0,3=42/8 - set matches 0 and 3 to 42 every 8 seconds\n" \ "\tset 12,13,14=0x23/2 23,19=0/8 6=4 0 - complex example, can be combined" \ bool handler__set(globals_t *vars, char **argv, unsigned argc); #define LIST_SHRTDOC "list all currently known matches" #define LIST_LONGDOC "usage: list\n" \ "Print all the currently known matches, along with details about the\n" \ "match, such as its type, location, and last known value. The number in\n" \ "the left column is the `match-id`, this can be passed to other commands\n" \ "such as `set`, `delete`, etc.\n" \ "The flags displayed indicate the possible types of the variable.\n" \ "Also the region id, an offset and the region type belonging to a match\n" \ "are displayed. The offset is used from the code load address or region start.\n" \ "This helps bypassing address space layout randomization (ASLR).\n" bool handler__list(globals_t *vars, char **argv, unsigned argc); #define DELETE_SHRTDOC "delete a known match by match-id" #define DELETE_LONGDOC "usage: delete match-id\n" \ "Remove the match `match-id` from the match list. The `match-id` can\n" \ "be found using the `list` command. To delete all matches, see\n" \ "the `reset` command.\n" \ "To delete all matches associated with a particular library, see the\n" \ "`dregion` command, which will also remove any associated matches.\n" \ "Example:\n" \ "\tdelete 0 - delete match 0\n" \ "NOTE: match-ids may be recalculated after matches are removed or added." bool handler__delete(globals_t *vars, char **argv, unsigned argc); #define RESET_SHRTDOC "forget all matches, and reinitialise regions" #define RESET_LONGDOC "usage: reset\n" \ "Forget all matches and regions, and reread regions from the relevant\n" \ "maps file. Useful if you have made an error, or want to find a new\n" \ "variable.\n" bool handler__reset(globals_t *vars, char **argv, unsigned argc); #define PID_SHRTDOC "print current pid, or attach to a new process" #define PID_LONGDOC "usage: pid [pid]\n" \ "If `pid` is specified, reset current session and then attach to new\n" \ "process `pid`. If `pid` is not specified, print information about\n" \ "current process." bool handler__pid(globals_t *vars, char **argv, unsigned argc); #define SNAPSHOT_SHRTDOC "take a snapshot of the current process state" #define SNAPSHOT_LONGDOC "usage: snapshot\n" \ "Take a snapshot of the entire process in its current state. This is useful\n" \ "if you don't know the exact value of the variable you are searching for, but\n" \ "can describe it in terms of higher, lower or equal (see commands `>`,`<` and\n" \ "`=`).\n\n" \ "NOTE: This can use a lot of memory with large processes." bool handler__snapshot(globals_t *vars, char **argv, unsigned argc); #define DREGION_SHRTDOC "delete a known region by region-id" #define DREGION_LONGDOC "usage: dregion [!]region-id[,region-id[,...]]\n" \ "Remove the region `region-id` from the regions list, along with any matches\n" \ "affected from the match list. The `region-id` can be found using the `lregions`\n" \ "command. A leading `!` indicates the list should be inverted.\n" bool handler__dregion(globals_t *vars, char **argv, unsigned argc); #define LREGIONS_SHRTDOC "list all known regions" #define LREGIONS_LONGDOC "usage: lregions\n" \ "Print all the currently known regions, along with details such as the\n" \ "start address, size, region type, load address, permissions and associated\n" \ "filename. The number in the left column is the `region-id`, this can be\n" \ "passed to other commands that process regions, such as `dregion`.\n" \ "The load address is the start of the .text region for the executable\n" \ "or libraries. Otherwise, it is the region start.\n" bool handler__lregions(globals_t *vars, char **argv, unsigned argc); #define GREATERTHAN_SHRTDOC "match values that have increased or greater than some number" #define LESSTHAN_SHRTDOC "match values that have decreased or less than some number" #define NOTCHANGED_SHRTDOC "match values that have not changed or equal to some number" #define CHANGED_SHRTDOC "match values that have changed or different from some number" #define INCREASED_SHRTDOC "match values that have increased at all or by some number" #define DECREASED_SHRTDOC "match values that have decreased at all or by some number" #define GREATERTHAN_LONGDOC "usage: > [n]\n" \ "If n is given, match values that are greater than n.\n" \ "Otherwise match all values that have increased. (same as `+`)\n" \ "You can use this in conjunction with `snapshot` if you never know its value." #define LESSTHAN_LONGDOC "usage: < [n]\n" \ "If n is given, match values that are less than n.\n" \ "Otherwise match all values that have decreased. (same as `-`)\n" \ "You can use this in conjunction with `snapshot` if you never know its value." #define NOTCHANGED_LONGDOC "usage: = [n]\n" \ "If n is given, match values that are equal to n. (same as `n`)\n" \ "Otherwise match all values that have not changed since the last scan.\n" \ "You can use this in conjunction with `snapshot` if you never know its value." #define CHANGED_LONGDOC "usage: != [n]\n" \ "If n is given, match values that are different from n.\n" \ "Otherwise match all values that have changed since the last scan.\n" \ "You can use this in conjunction with `snapshot` if you never know its value." #define INCREASED_LONGDOC "usage: + [n]\n" \ "If n is given, match values that have been increased by n\n" \ "Otherwise match all values that have increased. (same as `>`)\n" \ "You can use this in conjunction with `snapshot` if you never know its value." #define DECREASED_LONGDOC "usage: - [n]\n" \ "If n is given, match values that have been decreased by n\n" \ "Otherwise match all values that have decreased. (same as `<`)\n" \ "You can use this in conjunction with `snapshot` if you never know its value." bool handler__decinc(globals_t *vars, char **argv, unsigned argc); #define VERSION_SHRTDOC "print current version" #define VERSION_LONGDOC "usage: version\n" \ "Display the current version of scanmem in use." bool handler__version(globals_t *vars, char **argv, unsigned argc); #define EXIT_SHRTDOC "exit the program immediately" #define EXIT_LONGDOC "usage: exit\n" \ "Exit scanmem immediately, zero will be returned." bool handler__exit(globals_t *vars, char **argv, unsigned argc); #define HELP_SHRTDOC "access online documentation, use `help command` for specific help" #define HELP_LONGDOC "usage: help [command]\n" \ "If `command` is specified, print detailed information about command `command`\n" \ "including options and usage summary. If `command` is not specified, print a\n" \ "one line description of each command supported." bool handler__help(globals_t *vars, char **argv, unsigned argc); #define DEFAULT_SHRTDOC NULL #define DEFAULT_LONGDOC "When searching for a number, use any notation in standard C language (leading 0x for\n" \ "hexadecimal, leading 0 for octal, everything else is assumed to be decimal).\n" \ "Float numbers are also acceptable, but will be rounded if scanning integers.\n" \ "Use \'..\' for a range, e.g. \'1..3\' searches between 1 and 3 inclusive.\n" \ "\n" \ "When searching for an array of byte, use 2-byte hexadecimal notation, \n" \ "separated by spaces, wildcard '?\?' is also supported. E.g. FF ?\? EE ?\? 02 01\n" \ "\n" \ "When searching for strings, use the \" command\n" \ "\n" \ "Scan the current process for variables with given value.\n" \ "By entering the value of the variable as it changes multiple times, scanmem can\n" \ "eliminate matches, eventually identifying where the variable is located.\n" \ "Once the variable is found, use `set` to change its value.\n" bool handler__default(globals_t *vars, char **argv, unsigned argc); #define STRING_SHRTDOC "match a given string" #define STRING_LONGDOC "usage \" \n" \ " is counted since the 2nd character following the leading \"\n" \ "This can only be used when scan_data_type is set to be string\n" \ "Example:\n" \ "\t\" Scan for string, spaces and ' \" are all acceptable.\n" bool handler__string(globals_t *vars, char **argv, unsigned argc); #define UPDATE_SHRTDOC "update match values without culling list" #define UPDATE_LONGDOC "usage: update\n" \ "Scans the current process, getting the current values of all matches.\n" \ "These values can be viewed with `list`, and are also the old values that\n" \ "scanmem compares to when using `>`, `<`, or `=`. This command is equivalent\n" \ "to a search command that all current results match.\n" bool handler__update(globals_t *vars, char **argv, unsigned argc); bool handler__eof(globals_t *vars, char **argv, unsigned argc); #define SHELL_SHRTDOC "execute a shell command without leaving scanmem" #define SHELL_LONGDOC "usage: shell [shell-command]\n" \ "Execute `shell-command` using /bin/sh then return, useful for reading man\n" \ "pages, checking top, or making notes with an external editor.\n" \ "Examples:\n" \ "\tshell vi notes.txt\n" \ "\tshell man scanmem\n" \ "\tshell cat > notes.txt\n" bool handler__shell(globals_t *vars, char **argv, unsigned argc); #define WATCH_SHRTDOC "monitor the value of a memory location as it changes" #define WATCH_LONGDOC "usage: watch [match-id]\n" \ "Monitors the match `match-id`, by testing its value every second. When the\n" \ "value changes, its new value is printed along with an timestamp. Interrupt\n" \ "with ^C to stop monitoring.\n" \ "Examples:\n" \ "\twatch 12 - watch match 12 for any changes.\n" bool handler__watch(globals_t *vars, char **argv, unsigned argc); /*XXX: improve this */ #define SHOW_SHRTDOC "display information about scanmem." #define SHOW_LONGDOC "usage: show \n" \ "Display information relating to .\n" \ "Possible values: `copying`, `warranty` or `version`\n" bool handler__show(globals_t *vars, char **argv, unsigned argc); #define DUMP_SHRTDOC "dump a memory region to screen or a file" #define DUMP_LONGDOC "usage: dump
[]\n" \ "\n" \ "If is given, save the region of memory to the file \n" \ "Otherwise display it in a human-readable format.\n" bool handler__dump(globals_t *vars, char **argv, unsigned argc); #define WRITE_SHRTDOC "change the value of a specific memory location" #define WRITE_LONGDOC "usage: write
\n" \ "\n" \ "Write into
\n" \ " should be one of:\n" \ "\tint{8|16|32|64} (or i{8|16|32|64} for short)\n" \ "\tfloat{32|64} (or f{32|64} for short)\n" \ "\tbytearray\n" \ "\n" \ "Example:\n" \ "\twrite i16 60103e 0\n" \ "\twrite float32 60103e 0\n" \ "\twrite bytearray 60103e ff 01 32\n" bool handler__write(globals_t *vars, char **argv, unsigned argc); #define OPTION_SHRTDOC "set runtime options of scanmem, see `help option`" #define OPTION_LONGDOC "usage: option \n" \ "\n" \ "Here are all options and their possible values\n" \ "\n" \ "scan_data_type\t\tspecify what type of data should be considered\n" \ "\t\t\tDefault:int\n" \ "\tMOST OF TIME YOU MUST EXECUTE `reset' IMMEDIATELY AFTER CHANGING scan_data_type\n" \ "\n" \ "\tPossible Values:\n" \ "\tnumber:\t\t\tinteger or float\n" \ "\tint:\t\t\tinteger of any width\n" \ "\tfloat:\t\t\tfloat of any width\n" \ "\tint{8|16|32|64}:\tinteger of given width\n" \ "\tfloat{32|64}:\t\tfloat of given width\n" \ "\tbytearray:\t\tan array of bytes\n" \ "\tstring:\t\t\tstring\n" \ "\n" \ "region_scan_level\tspecify which regions should be scanned\n" \ "\t\t\tDefault:2\n" \ "\n" \ "\tPossible Values:\n" \ "\t1:\theap, stack and executable only\n" \ "\t2:\theap, stack executable and bss only\n" \ "\t3:\teverything(e.g. other libs)\n" \ "\n" \ "detect_reverse_change\twhether to (also) search for values that changes oppositely as given order\n" \ "\t\t\tDefault:0\n" \ "\tIf you want to use this feature, you can only search for INCREASED or DECREASED after initial search\n" \ "\n" \ "\tpossible values:\n" \ "\t0:\tdisabled\n" \ "\t1:\tenabled\n" \ "\n" \ "dump_with_ascii\twhether to print ascii characters with a memory dump\n" \ "\t\t\tDefault:1\n" \ "\n" \ "\tpossible values:\n" \ "\t0:\tdisabled\n" \ "\t1:\tenabled\n" \ "\n" \ "endianness\tendianness of data (used by: set, write and comparisons)\n" \ "\t\t\tDefault:0\n" \ "\n" \ "\tpossible values:\n" \ "\t0:\thost endian\n" \ "\t1:\tlittle endian\n" \ "\t2:\tbig endian\n" \ "\n" \ "Example:\n" \ "\toption scan_data_type int32\n" bool handler__option(globals_t *vars, char **argv, unsigned argc); #endif /* HANDLERS_H */ scanmem-0.16/interrupt.h000066400000000000000000000026071302526536600153050ustar00rootroot00000000000000/* Interrupt handling to stop watching or locking variables. This file is part of libscanmem. This library is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this library. If not, see . */ #ifndef INTERRUPT_H #define INTERRUPT_H /* small header file to manage interrupted commands */ static sigjmp_buf jmpbuf; /* used when aborting a command due to interrupt */ static sighandler_t oldsig; /* reinstalled before longjmp */ static unsigned intused; /* signal handler to handle interrupt during a commands */ static void interrupted(int n) { (void) n; siglongjmp(jmpbuf, 1); } #define INTERRUPTABLE() ((oldsig = signal(SIGINT, interrupted)), intused = 1, sigsetjmp(jmpbuf, 1)) #define ENDINTERRUPTABLE() (intused ? ((void) signal(SIGINT, oldsig), intused = 0) : (intused = 0)) #endif /* INTERRUPT_H */ scanmem-0.16/lgpl-3.0.txt000066400000000000000000000167431302526536600151030ustar00rootroot00000000000000 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. scanmem-0.16/licence.h000066400000000000000000000060661302526536600146560ustar00rootroot00000000000000/* Just some license texts. This file is part of libscanmem. This library is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this library. If not, see . */ #ifndef LICENCE_H #define LICENCE_H #define SM_WARRANTY \ "15. Disclaimer of Warranty.\n\n" \ "THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY\n" \ "APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT\n" \ "HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM \"AS IS\" WITHOUT WARRANTY\n" \ "OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,\n" \ "THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR\n" \ "PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM\n" \ "IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF\n" \ "ALL NECESSARY SERVICING, REPAIR OR CORRECTION.\n" \ "\n" \ "16. Limitation of Liability.\n\n" \ "IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING\n" \ "WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS\n" \ "THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY\n" \ "GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE\n" \ "USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF\n" \ "DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD\n" \ "PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),\n" \ "EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF\n" \ "SUCH DAMAGES.\n" #define SM_COPYING \ "This program is free software; you can redistribute it and/or modify\n" \ "it under the terms of the GNU General Public License as published by\n" \ "the Free Software Foundation; either version 3 of the License, or\n" \ "(at your option) any later version.\n" \ "\n" \ "This program is distributed in the hope that it will be useful,\n" \ "but WITHOUT ANY WARRANTY; without even the implied warranty of\n" \ "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n" \ "GNU General Public License for more details.\n" \ "\n" \ "You should have received a copy of the GNU General Public License\n" \ "along with this program; if not, see .\n" #endif /* LICENCE_H */ scanmem-0.16/list.c000066400000000000000000000062531302526536600142200ustar00rootroot00000000000000/* A simple linked list implementation. Copyright (C) 2006,2007,2009 Tavis Ormandy This file is part of libscanmem. This library is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this library. If not, see . */ #include "config.h" #include #include "list.h" /* create a new list */ list_t *l_init(void) { return calloc(1, sizeof(list_t)); } /* destroy the whole list */ void l_destroy(list_t * list) { void *data; if (list == NULL) return; /* remove every element */ while (list->size) { l_remove(list, NULL, &data); free(data); } free(list); } /* add a new element to the list */ int l_append(list_t * list, element_t * element, void *data) { element_t *n = calloc(1, sizeof(element_t)); if (n == NULL) return -1; n->data = data; /* insert at head or tail */ if (element == NULL) { if (list->size == 0) { list->tail = n; } n->next = list->head; list->head = n; } else { /* insertion in the middle of a list */ if (element->next == NULL) { list->tail = n; } n->next = element->next; element->next = n; } list->size++; return 0; } /* concatenate list src with list dst */ int l_concat(list_t *dst, list_t **src) { void *data; element_t *n; n = (*src)->head; while (n) { l_remove(*src, NULL, &data); if (l_append(dst, NULL, data) == -1) return -1; n = (*src)->head; } l_destroy(*src); *src = NULL; return 0; } /* remove the element at element->next */ void l_remove(list_t * list, element_t * element, void **data) { element_t *o; /* remove from head */ if (element == NULL) { if (data) { *data = list->head->data; } o = list->head; list->head = o->next; if (list->size == 1) { list->tail = NULL; } } else { if (data) { *data = element->next->data; } o = element->next; if ((element->next = element->next->next) == NULL) { list->tail = element; } } if (data == NULL) free(o->data); free(o); list->size--; return; } /* remove the nth element */ void l_remove_nth(list_t * list, unsigned n, void **data) { element_t *np = list->head; /* traverse to correct element */ while (n--) { if ((np = np->next) == NULL) /* return */ abort(); } l_remove(list, np, data); } scanmem-0.16/list.h000066400000000000000000000027301302526536600142210ustar00rootroot00000000000000/* A very simple linked list implementation. This file is part of libscanmem. This library is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this library. If not, see . */ #ifndef LIST_H #define LIST_H typedef struct element { void *data; struct element *next; } element_t; typedef struct { unsigned size; element_t *head; element_t *tail; } list_t; /* create a new list */ list_t *l_init(void); /* destroy the whole list */ void l_destroy(list_t * list); /* add a new element to the list */ int l_append(list_t * list, element_t * element, void *data); /* remove the element at element->next */ void l_remove(list_t * list, element_t * element, void **data); /* remove the nth element from head */ void l_remove_nth(list_t * list, unsigned n, void **data); /* remove all elements from *src, and append to dst */ int l_concat(list_t *dst, list_t **src); #endif /* LIST_H */ scanmem-0.16/main.c000066400000000000000000000145401302526536600141670ustar00rootroot00000000000000/* Scanmem main function, option parsing and help text. Copyright (C) 2006,2007,2009 Tavis Ormandy Copyright (C) 2009 Eli Dupree Copyright (C) 2009-2013 WANG Lu Copyright (C) 2016 Sebastian Parschauer This file is part of scanmem. 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 . */ #ifndef _GNU_SOURCE #define _GNU_SOURCE #endif #include "config.h" #include #include #include #include #include #include #include "scanmem.h" #include "commands.h" #include "show_message.h" static const char copy_text[] = "Copyright (C) 2006-2009 Tavis Ormandy\n" "Copyright (C) 2009,2010 Tavis Ormandy, Eli Dupree, WANG Lu\n" "Copyright (C) 2011-2015 WANG Lu\n" "Copyright (C) 2015-2016 Sebastian Parschauer\n" "scanmem comes with ABSOLUTELY NO WARRANTY; for details type `show warranty'.\n" "This is free software, and you are welcome to redistribute it\n" "under certain conditions; type `show copying' for details.\n\n"; /* print scanmem and libscanmem version */ static void printversion(FILE *outfd) { fprintf(outfd, "scanmem version %s\n", PACKAGE_VERSION); sm_printversion(outfd); } /* print scanmem version and copyright info */ static void printcopyright(FILE *outfd) { printversion(outfd); fprintf(outfd, "\n%s", copy_text); } static const char help_text[] = "Usage: scanmem [OPTION]... [PID]\n" "Interactively locate and modify variables in an executing process.\n" "\n" "-p, --pid=pid\t\tset the target process pid\n" "-h, --help\t\tprint this message\n" "-v, --version\t\tprint version information\n" "\n" "scanmem is an interactive debugging utility, enter `help` at the prompt\n" "for further assistance.\n" "\n" "Report bugs to <" PACKAGE_BUGREPORT ">.\n"; /* print quick usage message to stderr */ static void printhelp(void) { printcopyright(stderr); show_user("%s", help_text); return; } static void parse_parameter(int argc, char **argv) { struct option longopts[] = { {"pid", 1, NULL, 'p'}, /* target pid */ {"version", 0, NULL, 'v'}, /* print version */ {"help", 0, NULL, 'h'}, /* print help summary */ {"debug", 0, NULL, 'd'}, /* enable debug mode */ {NULL, 0, NULL, 0}, }; char *end; int optindex; bool done = false; globals_t *vars = &sm_globals; /* process command line */ while (!done) { switch (getopt_long(argc, argv, "vhdp:", longopts, &optindex)) { case 'p': vars->target = (pid_t) strtoul(optarg, &end, 0); /* check if that parsed correctly */ if (*end != '\0' || *optarg == '\0' || vars->target == 0) { show_error("invalid pid specified.\n"); exit(EXIT_FAILURE); } break; case 'v': printversion(stderr); exit(EXIT_FAILURE); case 'h': printhelp(); exit(EXIT_FAILURE); case 'd': vars->options.debug = 1; break; case -1: done = true; break; default: printhelp(); exit(EXIT_FAILURE); } } /* parse any pid specified after arguments */ if (optind <= argc && argv[optind]) { vars->target = (pid_t) strtoul(argv[optind], &end, 0); /* check if that parsed correctly */ if (*end != '\0' || argv[optind][0] == '\0' || vars->target == 0) { show_error("invalid pid specified.\n"); exit(EXIT_FAILURE); } } } int main(int argc, char **argv) { parse_parameter(argc, argv); int ret = EXIT_SUCCESS; globals_t *vars = &sm_globals; printcopyright(stderr); vars->printversion = printversion; if (!sm_init()) { show_error("Initialization failed.\n"); ret = EXIT_FAILURE; goto end; } if (getuid() != 0) { show_warn("Run scanmem as root if memory regions are missing. " "See scanmem man page.\n\n"); } /* this will initialize matches and regions */ if (sm_execcommand(vars, "reset") == false) { vars->target = 0; } /* check if there is a target already specified */ if (vars->target == 0) { show_user("Enter the pid of the process to search using the \"pid\" command.\n"); show_user("Enter \"help\" for other commands.\n"); } else { show_user("Please enter current value, or \"help\" for other commands.\n"); } /* main loop, read input and process commands */ while (!vars->exit) { char *line; /* reads in a commandline from the user and returns a pointer to it in *line */ if (sm_getcommand(vars, &line) == false) { show_error("failed to read in a command.\n"); ret = EXIT_FAILURE; break; } /* sm_execcommand() returning failure is not fatal, just the command could not complete. */ if (sm_execcommand(vars, line) == false) { if (vars->target == 0) { show_user("Enter the pid of the process to search using the \"pid\" command.\n"); show_user("Enter \"help\" for other commands.\n"); } else { show_user("Please enter current value or \"help\" for other commands.\n"); } } free(line); fflush(stdout); fflush(stderr); } end: /* now free any allocated memory used */ l_destroy(vars->regions); l_destroy(vars->commands); /* attempt to detach just in case */ (void) sm_detach(vars->target); return ret; } scanmem-0.16/maps.c000066400000000000000000000252161302526536600142050ustar00rootroot00000000000000/* Reading the data from /proc/pid/maps into a regions list. Copyright (C) 2006,2007,2009 Tavis Ormandy Copyright (C) 2009 Eli Dupree Copyright (C) 2009,2010 WANG Lu Copyright (C) 2014-2016 Sebastian Parschauer This file is part of libscanmem. This library is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this library. If not, see . */ #ifndef _GNU_SOURCE # define _GNU_SOURCE #endif #include "config.h" #include #include #include #include #include #include #include #include #include "list.h" #include "maps.h" #include "getline.h" #include "scanmem.h" #include "show_message.h" const char *region_type_names[] = REGION_TYPE_NAMES; bool sm_readmaps(pid_t target, list_t *regions) { FILE *maps; char name[128], *line = NULL; char exelink[128]; size_t len = 0; unsigned int code_regions = 0, exe_regions = 0; unsigned long prev_end = 0, load_addr = 0, exe_load = 0; bool is_exe = false; #define MAX_LINKBUF_SIZE 256 char linkbuf[MAX_LINKBUF_SIZE], *exename = linkbuf; int linkbuf_size; char binname[MAX_LINKBUF_SIZE]; /* check if target is valid */ if (target == 0) return false; /* construct the maps filename */ snprintf(name, sizeof(name), "/proc/%u/maps", target); /* attempt to open the maps file */ if ((maps = fopen(name, "r")) == NULL) { show_error("failed to open maps file %s.\n", name); return false; } show_info("maps file located at %s opened.\n", name); /* get executable name */ snprintf(exelink, sizeof(exelink), "/proc/%u/exe", target); linkbuf_size = readlink(exelink, exename, MAX_LINKBUF_SIZE - 1); if (linkbuf_size > 0) { exename[linkbuf_size] = 0; } else { /* readlink may fail for special processes, just treat as empty in order not to miss those regions */ exename[0] = 0; } /* read every line of the maps file */ while (getline(&line, &len, maps) != -1) { unsigned long start, end; region_t *map = NULL; char read, write, exec, cow, *filename; int offset, dev_major, dev_minor, inode; region_type_t type = REGION_TYPE_MISC; /* slight overallocation */ if ((filename = alloca(len)) == NULL) { show_error("failed to allocate %lu bytes for filename.\n", (unsigned long)len); goto error; } /* initialise to zero */ memset(filename, '\0', len); /* parse each line */ if (sscanf(line, "%lx-%lx %c%c%c%c %x %x:%x %u %[^\n]", &start, &end, &read, &write, &exec, &cow, &offset, &dev_major, &dev_minor, &inode, filename) >= 6) { /* * get the load address for regions of the same ELF file * * When the ELF loader loads an executable or a library into * memory, there is one region per ELF segment created: * .text (r-x), .rodata (r--), .data (rw-) and .bss (rw-). The * 'x' permission of .text is used to detect the load address * (region start) and the end of the ELF file in memory. All * these regions have the same filename. The only exception * is the .bss region. Its filename is empty and it is * consecutive with the .data region. But the regions .bss and * .rodata may not be present with some ELF files. This is why * we can't rely on other regions to be consecutive in memory. * There should never be more than these four regions. * The data regions use their variables relative to the load * address. So determining it makes sense as we can get the * variable address used within the ELF file with it. * But for the executable there is the special case that there * is a gap between .text and .rodata. Other regions might be * loaded via mmap() to it. So we have to count the number of * regions belonging to the exe separately to handle that. * References: * http://en.wikipedia.org/wiki/Executable_and_Linkable_Format * http://wiki.osdev.org/ELF * http://lwn.net/Articles/531148/ */ /* detect further regions of the same ELF file and its end */ if (code_regions > 0) { if (exec == 'x' || (strncmp(filename, binname, MAX_LINKBUF_SIZE) != 0 && (filename[0] != '\0' || start != prev_end)) || code_regions >= 4) { code_regions = 0; is_exe = false; /* exe with .text and without .data is impossible */ if (exe_regions > 1) exe_regions = 0; } else { code_regions++; if (is_exe) exe_regions++; } } if (code_regions == 0) { /* detect the first region belonging to an ELF file */ if (exec == 'x' && filename[0] != '\0') { code_regions++; if (strncmp(filename, exename, MAX_LINKBUF_SIZE) == 0) { exe_regions = 1; exe_load = start; is_exe = true; } strncpy(binname, filename, MAX_LINKBUF_SIZE); binname[MAX_LINKBUF_SIZE - 1] = '\0'; /* just to be sure */ /* detect the second region of the exe after skipping regions */ } else if (exe_regions == 1 && filename[0] != '\0' && strncmp(filename, exename, MAX_LINKBUF_SIZE) == 0) { code_regions = ++exe_regions; load_addr = exe_load; is_exe = true; strncpy(binname, filename, MAX_LINKBUF_SIZE); binname[MAX_LINKBUF_SIZE - 1] = '\0'; /* just to be sure */ } if (exe_regions < 2) load_addr = start; } prev_end = end; /* must have permissions to read and write, and be non-zero size */ if ((write == 'w') && (read == 'r') && ((end - start) > 0)) { bool useful = false; /* determine region type */ if (is_exe) type = REGION_TYPE_EXE; else if (code_regions > 0) type = REGION_TYPE_CODE; else if (!strcmp(filename, "[heap]")) type = REGION_TYPE_HEAP; else if (!strcmp(filename, "[stack]")) type = REGION_TYPE_STACK; /* determine if this region is useful */ switch (sm_globals.options.region_scan_level) { case REGION_ALL: useful = true; break; case REGION_HEAP_STACK_EXECUTABLE_BSS: if (filename[0] == '\0') { useful = true; break; } /* fall through */ case REGION_HEAP_STACK_EXECUTABLE: if (type == REGION_TYPE_HEAP || type == REGION_TYPE_STACK) { useful = true; break; } /* test if the region is mapped to the executable */ if (type == REGION_TYPE_EXE || strncmp(filename, exename, MAX_LINKBUF_SIZE) == 0) useful = true; break; } if (!useful) continue; /* allocate a new region structure */ if ((map = calloc(1, sizeof(region_t) + strlen(filename))) == NULL) { show_error("failed to allocate memory for region.\n"); goto error; } /* initialise this region */ map->flags.read = true; map->flags.write = true; map->start = (void *) start; map->size = (unsigned long) (end - start); map->type = type; map->load_addr = load_addr; /* setup other permissions */ map->flags.exec = (exec == 'x'); map->flags.shared = (cow == 's'); map->flags.private = (cow == 'p'); /* save pathname */ if (strlen(filename) != 0) { /* the pathname is concatenated with the structure */ strcpy(map->filename, filename); } /* add a unique identifier */ map->id = regions->size; /* okay, add this guy to our list */ if (l_append(regions, regions->tail, map) == -1) { show_error("failed to save region.\n"); goto error; } } } } show_info("%d suitable regions found.\n", regions->size); /* release memory allocated */ free(line); fclose(maps); return true; error: free(line); fclose(maps); return false; } scanmem-0.16/maps.h000066400000000000000000000045671302526536600142200ustar00rootroot00000000000000/* Reading the data from /proc/pid/maps into a regions list. Copyright (C) 2006,2007,2009 Tavis Ormandy Copyright (C) 2009 Eli Dupree Copyright (C) 2009,2010 WANG Lu Copyright (C) 2014-2016 Sebastian Parschauer This file is part of libscanmem. This library is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this library. If not, see . */ #ifndef MAPS_H #define MAPS_H #include "list.h" /* determine what regions we need */ typedef enum { REGION_ALL, /* each of them */ REGION_HEAP_STACK_EXECUTABLE, /* heap, stack, executable */ REGION_HEAP_STACK_EXECUTABLE_BSS /* heap, stack, executable, bss */ } region_scan_level_t; typedef enum { REGION_TYPE_MISC, REGION_TYPE_CODE, REGION_TYPE_EXE, REGION_TYPE_HEAP, REGION_TYPE_STACK } region_type_t; #define REGION_TYPE_NAMES { "misc", "code", "exe", "heap", "stack" } extern const char *region_type_names[]; /* a region obtained from /proc/pid/maps, these are searched for matches */ typedef struct { void *start; /* start address. Hack: If HAVE_PROCMEM, this is actually an (unsigned long) offset into /proc/{pid}/mem */ unsigned long size; /* size */ region_type_t type; unsigned long load_addr; /* e.g. load address of the executable */ struct __attribute__((packed)) { unsigned read:1; unsigned write:1; unsigned exec:1; unsigned shared:1; unsigned private:1; } flags; unsigned id; /* unique identifier */ char filename[1]; /* associated file, must be last */ } region_t; bool sm_readmaps(pid_t target, list_t *regions); #endif /* MAPS_H */ scanmem-0.16/menu.c000066400000000000000000000106421302526536600142060ustar00rootroot00000000000000/* Prompt, command completion and version information. Copyright (C) 2006,2007,2009 Tavis Ormandy Copyright (C) 2010,2011 Lu Wang This file is part of libscanmem. This library is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this library. If not, see . */ #ifndef _GNU_SOURCE # define _GNU_SOURCE #endif #include "config.h" #include #include #include #include #include #include #if HAVE_LIBREADLINE #include #include #else #include "readline.h" #endif #include "getline.h" #include "scanmem.h" #include "commands.h" #include "show_message.h" /* command generator for readline completion */ static char *commandgenerator(const char *text, int state) { static unsigned index = 0; unsigned i; size_t len; element_t *np; globals_t *vars = &sm_globals; /* reset generator if state == 0, otherwise continue from last time */ index = state ? index : 0; np = vars->commands ? vars->commands->head : NULL; len = strlen(text); /* skip to the last node checked */ for (i = 0; np && i < index; i++) np = np->next; /* traverse the commands list, checking for matches */ while (np) { command_t *command = np->data; np = np->next; /* record progress */ index++; /* if shortdoc is NULL, this is not supposed to be user visible */ if (command == NULL || command->command == NULL || command->shortdoc == NULL) continue; /* check if we have a match */ if (strncmp(text, command->command, len) == 0) { return strdup(command->command); } } return NULL; } /* custom completor program for readline */ static char **commandcompletion(const char *text, int start, int end) { (void) end; /* never use default completer (filenames), even if I dont generate any matches */ rl_attempted_completion_over = 1; /* only complete on the first word, the command */ return start ? NULL : rl_completion_matches(text, commandgenerator); } /* * sm_getcommand() reads in a command using readline, and places a pointer to * the read string into *line, _which must be free'd by caller_. * returns true on success, or false on error. */ bool sm_getcommand(globals_t *vars, char **line) { char prompt[64]; bool success = true; assert(vars != NULL); snprintf(prompt, sizeof(prompt), "%ld> ", vars->num_matches); rl_readline_name = "scanmem"; rl_attempted_completion_function = commandcompletion; while (true) { if (vars->options.backend == 0) { /* for normal user, read in the next command using readline library */ success = ((*line = readline(prompt)) != NULL); } else { /* disable readline for front-end, since readline may produce ansi escape codes, which is terrible for front-end */ printf("%s\n", prompt); /* add a newline for front-end */ fflush(stdout); /* otherwise front-end may not receive this */ *line = NULL; /* let getline malloc it */ size_t n; ssize_t bytes_read = getline(line, &n, stdin); success = (bytes_read > 0); if (success) (*line)[bytes_read-1] = '\0'; /* remove the trialing newline */ } if (!success) { /* EOF */ if ((*line = strdup("__eof")) == NULL) { fprintf(stderr, "error: sorry, there was a memory allocation error.\n"); return false; } } if (strlen(*line)) { break; } free(*line); } /* record this line to readline history */ add_history(*line); return true; } scanmem-0.16/po/000077500000000000000000000000001302526536600135115ustar00rootroot00000000000000scanmem-0.16/po/LINGUAS000066400000000000000000000000061302526536600145320ustar00rootroot00000000000000ja ru scanmem-0.16/po/POTFILES.in000066400000000000000000000002711302526536600152660ustar00rootroot00000000000000[type: gettext/glade]gui/GameConqueror.xml gui/GameConqueror.py gui/misc.py gui/GameConqueror.desktop.in gui/org.freedesktop.gameconqueror.policy.in.in gui/GameConqueror.appdata.xml.in scanmem-0.16/po/POTFILES.skip000066400000000000000000000000541302526536600156250ustar00rootroot00000000000000gui/org.freedesktop.gameconqueror.policy.in scanmem-0.16/po/ja.po000066400000000000000000000311421302526536600144440ustar00rootroot00000000000000# Japanese translations for Game Conqueror. # Copyright (C) 2009-2013 Wang Lu # This file is distributed under the same license as Game Conqueror. # Kuina , 2013. # msgid "" msgstr "" "Project-Id-Version: scanmem 0.14\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2016-07-27 23:22+0200\n" "PO-Revision-Date: 2013-10-30 02:13+0900\n" "Last-Translator: Kuina \n" "Language-Team: Japanese\n" "Language: ja\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=UTF-8\n" "Content-Transfer-Encoding: 8bit\n" "Plural-Forms: nplurals=1; plural=0;\n" #: ../gui/GameConqueror.xml.h:1 msgid "GameConqueror - Memory Editor" msgstr "GameConqueror - メモリエディタ" #: ../gui/GameConqueror.xml.h:2 msgid "Address:" msgstr "アドレス:" #: ../gui/GameConqueror.xml.h:3 msgid "GameConqueror" msgstr "" #: ../gui/GameConqueror.xml.h:4 msgid "Found: 0" msgstr "0 件見ã¤ã‹ã‚Šã¾ã—ãŸ" #: ../gui/GameConqueror.xml.h:5 msgid "" "Syntax:\n" "\n" " For numeric types:\n" "\n" " N Exactly this number\n" " N..M Range between two numbers\n" " ? Unknown initial value\n" " > or + Increased values\n" " < or - Decreased values\n" " = Unchanged values\n" " != Changed values\n" " > N Greater than N\n" " < N Less than N\n" " + N Increased by N\n" " - N Decreased by N\n" " != N Other than N\n" "\n" " where N could be a number of a simple math expression embraced by (), e.g.\n" " 12\n" " 0x34\n" " 5.67\n" " (- 8 * 9)\n" "\n" " For bytearray: use 2-byte hexadecimal notation for each byte, separated by " "spaces\n" " e.g. FE DC BA 98 76 54 32 10\n" "\n" " For string: enter the string directly" msgstr "" "Syntax:\n" "\n" " 数値を検索ã™ã‚‹å ´åˆ: \n" "\n" " N N ã¨ç­‰ã—ã„\n" " N..M 二ã¤ã®æ•°å€¤ã®é–“ã®ç¯„囲\n" " ? å…¨ã¦ã®å€¤\n" " > or + å‰å›žã‚¹ã‚­ãƒ£ãƒ³æ™‚より増加ã—ãŸ\n" " < or - å‰å›žã‚¹ã‚­ãƒ£ãƒ³æ™‚より減少ã—ãŸ\n" " = å‰å›žã‚¹ã‚­ãƒ£ãƒ³æ™‚より変化ã—ã¦ã„ãªã„\n" " != å‰å›žã‚¹ã‚­ãƒ£ãƒ³æ™‚より変化ã—ãŸ\n" " > N N より大ãã„\n" " < N N よりå°ã•ã„\n" " + N å‰å›žã‚¹ã‚­ãƒ£ãƒ³æ™‚より N 増加ã—ãŸ\n" " - N å‰å›žã‚¹ã‚­ãƒ£ãƒ³æ™‚より N 減少ã—ãŸ\n" " != N N ã¨ç•°ãªã‚‹\n" "\n" " 数値ã®ä»£ã‚ã‚Šã«ã€()ã§å›²ã£ãŸç°¡å˜ãªæ•°å¼ã‚’入力ã™ã‚‹ã“ã¨ã‚‚ã§ãã¾ã™ã€‚例:\n" " 12\n" " 0x34\n" " 5.67\n" " (- 8 * 9)\n" "\n" " ãƒã‚¤ãƒˆåˆ—を検索ã™ã‚‹å ´åˆ: 16進表記を用ã„ã€1ãƒã‚¤ãƒˆãšã¤åŠè§’スペースã§åŒºåˆ‡ã£ã¦ã" "ã ã•ã„\n" " 例: FE DC BA 98 76 54 32 10\n" "\n" " 文字列を検索ã™ã‚‹å ´åˆ: 検索ã—ãŸã„文字列をãã®ã¾ã¾å…¥åŠ›ã—ã¦ãã ã•ã„" #: ../gui/GameConqueror.xml.h:32 msgid "Value: ?" msgstr "値: ?" #: ../gui/GameConqueror.xml.h:33 msgid "Insert value to search for" msgstr "" #: ../gui/GameConqueror.xml.h:34 msgid "Scan" msgstr "スキャン" #: ../gui/GameConqueror.xml.h:35 msgid "Reset" msgstr "リセット" #: ../gui/GameConqueror.xml.h:36 ../gui/GameConqueror.py:830 msgid "Select a process" msgstr "プロセスをé¸æŠžã—ã¦ãã ã•ã„" #: ../gui/GameConqueror.xml.h:37 ../gui/GameConqueror.py:829 msgid "No process selected" msgstr "プロセスãŒé¸æŠžã•ã‚Œã¦ã„ã¾ã›ã‚“" #: ../gui/GameConqueror.xml.h:38 msgid "About" msgstr "" #: ../gui/GameConqueror.xml.h:39 msgid "Specify type of target data" msgstr "データ型を指定ã—ã¾ã™" #: ../gui/GameConqueror.xml.h:40 msgid "Data Type:" msgstr "データ型:" #: ../gui/GameConqueror.xml.h:41 msgid "" "Basic: Fastest but may miss some values\n" "Normal: Works for most cases\n" "Full: Never miss values but slowest" msgstr "" "Basic: 高速ã§ã™ãŒã€å€¤ãŒå­˜åœ¨ã™ã‚‹ã«ã‚‚ã‹ã‹ã‚らãšã€ã‚¢ãƒ‰ãƒ¬ã‚¹ã‚’å–å¾—ã§ã" "ãªã„å ´åˆãŒã‚ã‚Šã¾ã™\n" "Normal: 通常ã¯ã“ã‚Œã§å……分ã§ã™\n" "Full: 値ãŒå­˜åœ¨ã™ã‚Œã°å¿…ãšãã®ã‚¢ãƒ‰ãƒ¬ã‚¹ã‚’å–å¾—ã§ãã¾ã™ãŒã€é…ã„ã§ã™" #: ../gui/GameConqueror.xml.h:44 msgid "Search Scope:" msgstr "検索範囲:" #: ../gui/GameConqueror.xml.h:45 msgid "Memory Editor" msgstr "メモリエディタ" #: ../gui/GameConqueror.xml.h:46 msgid "Save address list to file" msgstr "アドレス一覧をファイルã¸ä¿å­˜" #: ../gui/GameConqueror.xml.h:47 msgid "Load address list from file" msgstr "アドレス一覧をファイルã‹ã‚‰èª­ã¿è¾¼ã¿" #: ../gui/GameConqueror.xml.h:48 msgid "Remove all entries" msgstr "å…¨ã¦ã®é …目を削除" #: ../gui/GameConqueror.xml.h:49 msgid "Manually add an entry" msgstr "手動入力" #: ../gui/GameConqueror.xml.h:50 msgid "" "Copyright (C) 2009-2014 WANG Lu \n" "Copyright (C) 2010 Bryan Cain\n" "Copyright (C) 2015-2016 Sebastian Parschauer \n" "\n" "Special thanks: Igor Gnatenko, Andrea Stacchiotti, Mattias Muenster, Zhang " "Zhe" msgstr "" #: ../gui/GameConqueror.xml.h:55 msgid "A graphical frontend of scanmem" msgstr "scanmem GUI フロントエンド" #: ../gui/GameConqueror.xml.h:56 msgid "Homepage" msgstr "ホームページ" #: ../gui/GameConqueror.xml.h:57 msgid "_Close" msgstr "é–‰ã˜ã‚‹(_C)" #: ../gui/GameConqueror.xml.h:58 msgid "_Add" msgstr "追加(_A)" #: ../gui/GameConqueror.xml.h:59 msgid "Memory address of the value" msgstr "メモリアドレスを入力ã—ã¾ã™" #: ../gui/GameConqueror.xml.h:60 msgid "Give a brief description of the value" msgstr "変数ã®ç°¡å˜ãªèª¬æ˜Žã‚’入力ã—ã¾ã™" #: ../gui/GameConqueror.xml.h:61 msgid "Description:" msgstr "概è¦:" #: ../gui/GameConqueror.xml.h:62 msgid "Type:" msgstr "データ型:" #: ../gui/GameConqueror.xml.h:63 msgid "Press Ctrl+F to search for a process" msgstr "Ctrl+Fキーã§ãƒ—ロセスを検索ã§ãã¾ã™" #: ../gui/GameConqueror.xml.h:64 msgid "_OK" msgstr "OK(_O)" #: ../gui/GameConqueror.xml.h:65 msgid "_Cancel" msgstr "キャンセル(_C)" #: ../gui/GameConqueror.xml.h:66 msgid "User:" msgstr "ユーザー:" #: ../gui/GameConqueror.xml.h:67 msgid "Process:" msgstr "プロセス:" #: ../gui/GameConqueror.xml.h:68 msgid "Filter" msgstr "フィルタ" #. init columns #. Address #: ../gui/GameConqueror.py:169 ../gui/GameConqueror.py:214 msgid "Address" msgstr "アドレス" #. Value #: ../gui/GameConqueror.py:170 ../gui/GameConqueror.py:231 msgid "Value" msgstr "値" #: ../gui/GameConqueror.py:171 msgid "Offset" msgstr "オフセット" #: ../gui/GameConqueror.py:172 msgid "Region Type" msgstr "地域ã®ã‚¿ã‚¤ãƒ—" #. Lock #: ../gui/GameConqueror.py:197 msgid "Lock" msgstr "ロック" #. Description #: ../gui/GameConqueror.py:206 msgid "Description" msgstr "概è¦" #. Type #: ../gui/GameConqueror.py:219 msgid "Type" msgstr "åž‹" #. second col #: ../gui/GameConqueror.py:257 msgid "User" msgstr "ユーザー" #. third col #: ../gui/GameConqueror.py:262 msgid "Process" msgstr "プロセス" #: ../gui/GameConqueror.py:288 msgid "Add to cheat list" msgstr "ãƒãƒ¼ãƒˆãƒªã‚¹ãƒˆã«è¿½åŠ " #: ../gui/GameConqueror.py:289 ../gui/GameConqueror.py:296 msgid "Browse this address" msgstr "ã“ã®ã‚¢ãƒ‰ãƒ¬ã‚¹ã®ãƒ¡ãƒ¢ãƒªå†…容を表示" #: ../gui/GameConqueror.py:290 msgid "Scan for this address" msgstr "ã“ã®ã‚¢ãƒ‰ãƒ¬ã‚¹ã‚’指ã™ãƒã‚¤ãƒ³ã‚¿ã‚’スキャン" #: ../gui/GameConqueror.py:297 msgid "Copy address" msgstr "アドレスをコピー" #: ../gui/GameConqueror.py:298 msgid "Remove this entry" msgstr "ã“ã®é …目を削除" #: ../gui/GameConqueror.py:330 ../gui/GameConqueror.py:479 #: ../gui/GameConqueror.py:900 msgid "Please select a process" msgstr "プロセスをé¸æŠžã—ã¦ãã ã•ã„" #: ../gui/GameConqueror.py:343 ../gui/GameConqueror.py:353 msgid "Invalid address" msgstr "無効ãªã‚¢ãƒ‰ãƒ¬ã‚¹ã§ã™" #: ../gui/GameConqueror.py:364 msgid "Open.." msgstr "é–‹ã.." #: ../gui/GameConqueror.py:384 msgid "Save.." msgstr "ä¿å­˜.." #: ../gui/GameConqueror.py:495 msgid "Please enter a valid address." msgstr "有効ãªãƒ¡ãƒ¢ãƒªã‚¢ãƒ‰ãƒ¬ã‚¹ã‚’入力ã—ã¦ãã ã•ã„." #: ../gui/GameConqueror.py:499 ../gui/GameConqueror.py:803 msgid "No Description" msgstr "説明ãªã—" #: ../gui/GameConqueror.py:736 msgid "Unknown architecture, you may report to developers" msgstr "未知ã®ã‚¢ãƒ¼ã‚­ãƒ†ã‚¯ãƒãƒ£ã§ã™ã€‚å¿…è¦ã§ã‚ã‚Œã°é–‹ç™ºè€…ã«å ±å‘Šã—ã¦ãã ã•ã„。" #: ../gui/GameConqueror.py:748 ../gui/GameConqueror.py:831 msgid "" "Cannot retrieve memory maps of that process, maybe it has exited (crashed), " "or you don't have enough privileges" msgstr "" "指定ã•ã‚ŒãŸãƒ—ロセスã®ãƒ¡ãƒ¢ãƒªãƒžãƒƒãƒ—を読ã¿è¾¼ã‚ã¾ã›ã‚“。既ã«çµ‚了ã‚ã‚‹ã„ã¯ã‚¯ãƒ©ãƒƒã‚·ãƒ¥" "ã—ãŸã‹ã€ã“ã®æ“作ã«å¿…è¦ãªæ¨©é™ãŒãªã„å¯èƒ½æ€§ãŒã‚ã‚Šã¾ã™ã€‚" #. not readable #: ../gui/GameConqueror.py:759 #, python-format msgid "Address %x is not readable" msgstr "アドレス %x を読ã¿è¾¼ã‚ã¾ã›ã‚“" #: ../gui/GameConqueror.py:762 #, python-format msgid "Address %x is not valid" msgstr "アドレス %x ã¯ç„¡åŠ¹ã§ã™" #: ../gui/GameConqueror.py:771 msgid "Cannot find a readable region" msgstr "読ã¿è¾¼ã¿å¯èƒ½ãªãƒ¡ãƒ¢ãƒªç¯„囲ãŒè¦‹ã¤ã‹ã‚Šã¾ã›ã‚“" #: ../gui/GameConqueror.py:782 msgid "Cannot read memory" msgstr "メモリを読ã¿è¾¼ã‚ã¾ã›ã‚“" #: ../gui/GameConqueror.py:954 #, python-format msgid "Found: %d" msgstr "%d 件見ã¤ã‹ã‚Šã¾ã—ãŸ" #: ../gui/GameConqueror.py:1069 msgid "" "Version of scanmem mismatched, you may encounter problems. Please make sure " "you are using the same version of GameConqueror as scanmem." msgstr "" "scanmem ã®ãƒãƒ¼ã‚¸ãƒ§ãƒ³ãŒé•ã„ã¾ã™ã€‚何らã‹ã®å•é¡ŒãŒç™ºç”Ÿã—ã¦ã„ã‚‹å¯èƒ½æ€§ãŒã‚ã‚Šã¾ã™ã€‚" "scanmem 本体ã¨åŒã˜ãƒãƒ¼ã‚¸ãƒ§ãƒ³ã® Game Conqueror を使用ã—ã¦ã„ã‚‹ã‹ç¢ºèªã—ã¦ãã ã•" "ã„。" #: ../gui/GameConqueror.py:1075 msgid "A GUI for scanmem, a game hacking tool" msgstr "" #: ../gui/GameConqueror.py:1076 msgid "Report bugs to " msgstr "" #: ../gui/GameConqueror.py:1078 msgid "prefill the search box" msgstr "" #: ../gui/GameConqueror.py:1080 msgid "PID of the process" msgstr "" #: ../gui/misc.py:35 msgid "No value provided" msgstr "値ãŒå…¥åŠ›ã•ã‚Œã¦ã„ã¾ã›ã‚“" #: ../gui/misc.py:45 ../gui/misc.py:51 ../gui/misc.py:103 #, python-format msgid "Bad value: %s" msgstr "無効ãªå€¤: %s" #: ../gui/misc.py:64 #, python-format msgid "Command \"%s\" is not valid for the first scan" msgstr "æ¼”ç®—å­ \"%s\" ã¯åˆå›žã‚¹ã‚­ãƒ£ãƒ³æ™‚ã«ã¯åˆ©ç”¨ã§ãã¾ã›ã‚“" #: ../gui/misc.py:111 #, python-format msgid "%s is not an integer" msgstr "%s ã¯æ•´æ•°ã§ã¯ã‚ã‚Šã¾ã›ã‚“" #: ../gui/misc.py:117 #, python-format msgid "%s is too bulky for %s" msgstr "%s 㯠%s ã§è¡¨ç¾ã§ãる範囲を超ãˆã¦ã„ã¾ã™" #: ../gui/misc.py:144 #, python-format msgid "Cannot locate item: %s" msgstr "%s ã¨ã„ã†é …ç›®ã¯è¦‹ã¤ã‹ã‚Šã¾ã›ã‚“" #: ../gui/GameConqueror.desktop.in.h:1 ../gui/GameConqueror.appdata.xml.in.h:1 msgid "Game Conqueror" msgstr "" #: ../gui/GameConqueror.desktop.in.h:2 msgid "A game hacking tool. A GUI front-end for scanmem." msgstr "ゲームå‘ã‘プロセスメモリエディタ(scanmem GUI フロントエンド)" #: ../gui/org.freedesktop.gameconqueror.policy.in.in.h:1 msgid "Run Game Conqueror" msgstr "" #: ../gui/org.freedesktop.gameconqueror.policy.in.in.h:2 msgid "Authentication is required to run Game Conqueror" msgstr "" #: ../gui/GameConqueror.appdata.xml.in.h:2 msgid "Game hacking tool. GUI front-end for scanmem." msgstr "ゲームå‘ã‘プロセスメモリエディタ(scanmem GUI フロントエンド)" #: ../gui/GameConqueror.appdata.xml.in.h:3 msgid "" "scanmem is a simple interactive debugging utility, used to locate the " "address of a variable in an executing process. This can be used for the " "analysis or modification of a hostile process on a compromised machine, " "reverse engineering, or as a \"pokefinder\" to cheat at video games. " "GameConqueror aims to provide a CheatEngine-alike interface for scanmem, " "it's user-friendly and easy to use." msgstr "" #: ../gui/GameConqueror.appdata.xml.in.h:4 msgid "Features:" msgstr "" #: ../gui/GameConqueror.appdata.xml.in.h:5 msgid "Locking on multiple variables" msgstr "" #: ../gui/GameConqueror.appdata.xml.in.h:6 msgid "Memory Viewer/Editor" msgstr "メモリエディタ" #: ../gui/GameConqueror.appdata.xml.in.h:7 msgid "... many to be done" msgstr "" scanmem-0.16/po/ru.po000066400000000000000000000331031302526536600144770ustar00rootroot00000000000000# Russian translations for Game Conqueror. # Copyright (C) 2009-2014 Wang Lu # This file is distributed under the same license as Game Conqueror. # Igor Gnatenko , 2014. # msgid "" msgstr "" "Project-Id-Version: scanmem 0.14\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2016-07-27 23:22+0200\n" "PO-Revision-Date: 2014-01-26 13:38+0400\n" "Last-Translator: Igor Gnatenko \n" "Language-Team: Russian Fedora\n" "Language: ru\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=UTF-8\n" "Content-Transfer-Encoding: 8bit\n" "Plural-Forms: nplurals=1; plural=0;\n" #: ../gui/GameConqueror.xml.h:1 msgid "GameConqueror - Memory Editor" msgstr "GameConqueror - Редактор ПамÑти" #: ../gui/GameConqueror.xml.h:2 msgid "Address:" msgstr "ÐдреÑ:" #: ../gui/GameConqueror.xml.h:3 msgid "GameConqueror" msgstr "" #: ../gui/GameConqueror.xml.h:4 msgid "Found: 0" msgstr "Ðайдено: 0" #: ../gui/GameConqueror.xml.h:5 msgid "" "Syntax:\n" "\n" " For numeric types:\n" "\n" " N Exactly this number\n" " N..M Range between two numbers\n" " ? Unknown initial value\n" " > or + Increased values\n" " < or - Decreased values\n" " = Unchanged values\n" " != Changed values\n" " > N Greater than N\n" " < N Less than N\n" " + N Increased by N\n" " - N Decreased by N\n" " != N Other than N\n" "\n" " where N could be a number of a simple math expression embraced by (), e.g.\n" " 12\n" " 0x34\n" " 5.67\n" " (- 8 * 9)\n" "\n" " For bytearray: use 2-byte hexadecimal notation for each byte, separated by " "spaces\n" " e.g. FE DC BA 98 76 54 32 10\n" "\n" " For string: enter the string directly" msgstr "" "СинтакÑиÑ:\n" "\n" " Ð”Ð»Ñ Ñ‡Ð¸Ñленных типов: \n" "\n" " N Равные N\n" " N..M Диапазон между Ð´Ð²ÑƒÐ¼Ñ Ñ‡Ð¸Ñлами\n" " ? ÐеизвеÑтное начальное значение\n" " > или + УвеличившиеÑÑ Ð·Ð½Ð°Ñ‡ÐµÐ½Ð¸Ñ\n" " < или - УменьшившиеÑÑ Ð·Ð½Ð°Ñ‡ÐµÐ½Ð¸Ñ\n" " = Ðе изменившиеÑÑ Ð·Ð½Ð°Ñ‡ÐµÐ½Ð¸Ñ\n" " != ИзменившиеÑÑ Ð·Ð½Ð°Ñ‡ÐµÐ½Ð¸Ñ\n" " > N Больше чем N\n" " < N Меньше чем N\n" " + N УвеличилиÑÑŒ на N\n" " - N УменьшилиÑÑŒ by N\n" " != N Отличные от N\n" "\n" " где N может быть чиÑло или проÑтое математичеÑкое выражение, выделенное в " "(), напр.\n" " 12\n" " 0x34\n" " 5.67\n" " (- 8 * 9)\n" "\n" " Ð”Ð»Ñ Ð¼Ð°ÑÑива байтов: иÑпользуйте 2-разрÑдный шеÑтнадцатеричный формат Ð´Ð»Ñ " "каждого байта, разделённые пробелами\n" " напр. FE DC BA 98 76 54 32 10\n" "\n" " Ð”Ð»Ñ Ñтрок: вводите иÑкомую Ñтроку" #: ../gui/GameConqueror.xml.h:32 msgid "Value: ?" msgstr "Значение: ?" #: ../gui/GameConqueror.xml.h:33 msgid "Insert value to search for" msgstr "" #: ../gui/GameConqueror.xml.h:34 msgid "Scan" msgstr "Сканировать" #: ../gui/GameConqueror.xml.h:35 msgid "Reset" msgstr "СброÑ" #: ../gui/GameConqueror.xml.h:36 ../gui/GameConqueror.py:830 msgid "Select a process" msgstr "Выбрать процеÑÑ" #: ../gui/GameConqueror.xml.h:37 ../gui/GameConqueror.py:829 msgid "No process selected" msgstr "ПроцеÑÑ Ð½Ðµ выбран" #: ../gui/GameConqueror.xml.h:38 msgid "About" msgstr "" #: ../gui/GameConqueror.xml.h:39 msgid "Specify type of target data" msgstr "Укажите тип целевых данных" #: ../gui/GameConqueror.xml.h:40 msgid "Data Type:" msgstr "Тип данных:" #: ../gui/GameConqueror.xml.h:41 msgid "" "Basic: Fastest but may miss some values\n" "Normal: Works for most cases\n" "Full: Never miss values but slowest" msgstr "" "БыÑтрый: БыÑтрый, но может не Ñодержать некоторых значений\n" "Обычный: Работает в большинÑтве Ñлучаев\n" "Полный: Медленный, но Ñодержит вÑе значениÑ" #: ../gui/GameConqueror.xml.h:44 msgid "Search Scope:" msgstr "ОблаÑÑ‚ÑŒ ПоиÑка:" #: ../gui/GameConqueror.xml.h:45 msgid "Memory Editor" msgstr "Редактор ПамÑти" #: ../gui/GameConqueror.xml.h:46 msgid "Save address list to file" msgstr "Сохранить ÑпиÑок адреÑов в файл" #: ../gui/GameConqueror.xml.h:47 msgid "Load address list from file" msgstr "Загрузить ÑпиÑок адреÑов из файла" #: ../gui/GameConqueror.xml.h:48 msgid "Remove all entries" msgstr "Удалить вÑе Ñлементы" #: ../gui/GameConqueror.xml.h:49 msgid "Manually add an entry" msgstr "Добавить Ñлемент вручную" #: ../gui/GameConqueror.xml.h:50 msgid "" "Copyright (C) 2009-2014 WANG Lu \n" "Copyright (C) 2010 Bryan Cain\n" "Copyright (C) 2015-2016 Sebastian Parschauer \n" "\n" "Special thanks: Igor Gnatenko, Andrea Stacchiotti, Mattias Muenster, Zhang " "Zhe" msgstr "" #: ../gui/GameConqueror.xml.h:55 msgid "A graphical frontend of scanmem" msgstr "ГрафичеÑкий Ð¸Ð½Ñ‚ÐµÑ€Ñ„ÐµÐ¹Ñ Ðº scanmem" #: ../gui/GameConqueror.xml.h:56 msgid "Homepage" msgstr "ДомашнÑÑ Ñтраница" #: ../gui/GameConqueror.xml.h:57 msgid "_Close" msgstr "_Закрыть" #: ../gui/GameConqueror.xml.h:58 msgid "_Add" msgstr "_Добавить" #: ../gui/GameConqueror.xml.h:59 msgid "Memory address of the value" msgstr "ÐÐ´Ñ€ÐµÑ Ð·Ð½Ð°Ñ‡ÐµÐ½Ð¸Ñ Ð² памÑти" #: ../gui/GameConqueror.xml.h:60 msgid "Give a brief description of the value" msgstr "Дайте краткое опиÑание значениÑ" #: ../gui/GameConqueror.xml.h:61 msgid "Description:" msgstr "ОпиÑание:" #: ../gui/GameConqueror.xml.h:62 msgid "Type:" msgstr "Тип:" #: ../gui/GameConqueror.xml.h:63 msgid "Press Ctrl+F to search for a process" msgstr "Ðажмите Ctrl+F, чтобы найти процеÑÑ" #: ../gui/GameConqueror.xml.h:64 msgid "_OK" msgstr "_OK" #: ../gui/GameConqueror.xml.h:65 msgid "_Cancel" msgstr "О_тменить" #: ../gui/GameConqueror.xml.h:66 msgid "User:" msgstr "Пользователь:" #: ../gui/GameConqueror.xml.h:67 msgid "Process:" msgstr "ПроцеÑÑ:" #: ../gui/GameConqueror.xml.h:68 msgid "Filter" msgstr "Фильтр" #. init columns #. Address #: ../gui/GameConqueror.py:169 ../gui/GameConqueror.py:214 msgid "Address" msgstr "ÐдреÑ" #. Value #: ../gui/GameConqueror.py:170 ../gui/GameConqueror.py:231 msgid "Value" msgstr "Значение" #: ../gui/GameConqueror.py:171 msgid "Offset" msgstr "офÑет" #: ../gui/GameConqueror.py:172 msgid "Region Type" msgstr "Тип Регион" #. Lock #: ../gui/GameConqueror.py:197 msgid "Lock" msgstr "Заблокировать" #. Description #: ../gui/GameConqueror.py:206 msgid "Description" msgstr "ОпиÑание" #. Type #: ../gui/GameConqueror.py:219 msgid "Type" msgstr "Тип" #. second col #: ../gui/GameConqueror.py:257 msgid "User" msgstr "Пользователь" #. third col #: ../gui/GameConqueror.py:262 msgid "Process" msgstr "ПроцеÑÑ" #: ../gui/GameConqueror.py:288 msgid "Add to cheat list" msgstr "Добавить в чит-лиÑÑ‚" #: ../gui/GameConqueror.py:289 ../gui/GameConqueror.py:296 msgid "Browse this address" msgstr "ПроÑмотреть Ñтот адреÑ" #: ../gui/GameConqueror.py:290 msgid "Scan for this address" msgstr "ИÑкать по Ñтому адреÑу" #: ../gui/GameConqueror.py:297 msgid "Copy address" msgstr "Копировать адреÑ" #: ../gui/GameConqueror.py:298 msgid "Remove this entry" msgstr "Удалить Ñтот Ñлемент" #: ../gui/GameConqueror.py:330 ../gui/GameConqueror.py:479 #: ../gui/GameConqueror.py:900 msgid "Please select a process" msgstr "ПожалуйÑта выберите процеÑÑ" #: ../gui/GameConqueror.py:343 ../gui/GameConqueror.py:353 msgid "Invalid address" msgstr "Ðекорректный адреÑ" #: ../gui/GameConqueror.py:364 msgid "Open.." msgstr "Открыть.." #: ../gui/GameConqueror.py:384 msgid "Save.." msgstr "Сохранить.." #: ../gui/GameConqueror.py:495 msgid "Please enter a valid address." msgstr "ПожалуйÑта введите корректный адреÑ." #: ../gui/GameConqueror.py:499 ../gui/GameConqueror.py:803 msgid "No Description" msgstr "Ðет ОпиÑаниÑ" #: ../gui/GameConqueror.py:736 msgid "Unknown architecture, you may report to developers" msgstr "ÐеизвеÑÑ‚Ð½Ð°Ñ Ð°Ñ€Ñ…Ð¸Ñ‚ÐµÐºÑ‚ÑƒÑ€Ð°, Ñообщите разработчикам" #: ../gui/GameConqueror.py:748 ../gui/GameConqueror.py:831 msgid "" "Cannot retrieve memory maps of that process, maybe it has exited (crashed), " "or you don't have enough privileges" msgstr "" "Ðевозможно получить маппинги памÑти Ð´Ð»Ñ Ñтого процеÑÑа, возможно он больше " "не ÑущеÑтвует или у Ð²Ð°Ñ Ð½Ðµ хватает прав" #. not readable #: ../gui/GameConqueror.py:759 #, python-format msgid "Address %x is not readable" msgstr "ÐÐ´Ñ€ÐµÑ %x не доÑтупен Ð´Ð»Ñ Ñ‡Ñ‚ÐµÐ½Ð¸Ñ" #: ../gui/GameConqueror.py:762 #, python-format msgid "Address %x is not valid" msgstr "ÐÐ´Ñ€ÐµÑ %x не корректен" #: ../gui/GameConqueror.py:771 msgid "Cannot find a readable region" msgstr "Ðевозможно найти облаÑÑ‚ÑŒ Ð´Ð»Ñ Ñ‡Ñ‚ÐµÐ½Ð¸Ñ" #: ../gui/GameConqueror.py:782 msgid "Cannot read memory" msgstr "Ðевозможно прочитать памÑÑ‚ÑŒ" #: ../gui/GameConqueror.py:954 #, python-format msgid "Found: %d" msgstr "Ðайдено: %d" #: ../gui/GameConqueror.py:1069 msgid "" "Version of scanmem mismatched, you may encounter problems. Please make sure " "you are using the same version of GameConqueror as scanmem." msgstr "" "ИÑÐ¿Ð¾Ð»ÑŒÐ·ÑƒÐµÐ¼Ð°Ñ Ð²ÐµÑ€ÑÐ¸Ñ scanmem неÑовмеÑтима, могут быть проблемы. УбедитеÑÑŒ, " "что вы иÑпользуете одинаковые верÑии GameConqueror и scanmem." #: ../gui/GameConqueror.py:1075 msgid "A GUI for scanmem, a game hacking tool" msgstr "" #: ../gui/GameConqueror.py:1076 msgid "Report bugs to " msgstr "" #: ../gui/GameConqueror.py:1078 msgid "prefill the search box" msgstr "" #: ../gui/GameConqueror.py:1080 msgid "PID of the process" msgstr "" #: ../gui/misc.py:35 msgid "No value provided" msgstr "Значение не предоÑтавлено" #: ../gui/misc.py:45 ../gui/misc.py:51 ../gui/misc.py:103 #, python-format msgid "Bad value: %s" msgstr "Плохое значение: %s" #: ../gui/misc.py:64 #, python-format msgid "Command \"%s\" is not valid for the first scan" msgstr "Комманда \"%s\" некорректна Ð´Ð»Ñ Ð¿ÐµÑ€Ð²Ð¾Ð³Ð¾ поиÑка" #: ../gui/misc.py:111 #, python-format msgid "%s is not an integer" msgstr "%s не целочиÑленное" #: ../gui/misc.py:117 #, python-format msgid "%s is too bulky for %s" msgstr "%s Ñлишком большой Ð´Ð»Ñ %s" #: ../gui/misc.py:144 #, python-format msgid "Cannot locate item: %s" msgstr "Ðевозможно найти запиÑÑŒ: %s" #: ../gui/GameConqueror.desktop.in.h:1 ../gui/GameConqueror.appdata.xml.in.h:1 msgid "Game Conqueror" msgstr "" #: ../gui/GameConqueror.desktop.in.h:2 msgid "A game hacking tool. A GUI front-end for scanmem." msgstr "ИнÑтрумент Ð´Ð»Ñ Ð²Ð·Ð»Ð¾Ð¼Ð° игр (графичеÑкий Ð¸Ð½Ñ‚ÐµÑ€Ñ„ÐµÐ¹Ñ Ðº scanmem)" #: ../gui/org.freedesktop.gameconqueror.policy.in.in.h:1 msgid "Run Game Conqueror" msgstr "ЗапуÑк Game Conqueror" #: ../gui/org.freedesktop.gameconqueror.policy.in.in.h:2 msgid "Authentication is required to run Game Conqueror" msgstr "" "Ð”Ð»Ñ Ð·Ð°Ð¿ÑƒÑка Game Conqueror требуетÑÑ Ð¿Ð¾Ð´Ñ‚Ð²ÐµÑ€Ð¶Ð´ÐµÐ½Ð¸Ðµ подлинноÑти пользователÑ" #: ../gui/GameConqueror.appdata.xml.in.h:2 msgid "Game hacking tool. GUI front-end for scanmem." msgstr "ИнÑтрумент Ð´Ð»Ñ Ð²Ð·Ð»Ð¾Ð¼Ð° игр (графичеÑкий Ð¸Ð½Ñ‚ÐµÑ€Ñ„ÐµÐ¹Ñ Ðº scanmem)" #: ../gui/GameConqueror.appdata.xml.in.h:3 msgid "" "scanmem is a simple interactive debugging utility, used to locate the " "address of a variable in an executing process. This can be used for the " "analysis or modification of a hostile process on a compromised machine, " "reverse engineering, or as a \"pokefinder\" to cheat at video games. " "GameConqueror aims to provide a CheatEngine-alike interface for scanmem, " "it's user-friendly and easy to use." msgstr "" #: ../gui/GameConqueror.appdata.xml.in.h:4 msgid "Features:" msgstr "ВозможноÑти:" #: ../gui/GameConqueror.appdata.xml.in.h:5 msgid "Locking on multiple variables" msgstr "Замораживание мнножеÑтва переменных" #: ../gui/GameConqueror.appdata.xml.in.h:6 msgid "Memory Viewer/Editor" msgstr "Редактор/ПроÑмотрщик ПамÑти" #: ../gui/GameConqueror.appdata.xml.in.h:7 msgid "... many to be done" msgstr "" scanmem-0.16/ptrace.c000066400000000000000000000675021302526536600145270ustar00rootroot00000000000000/* Functions to access the memory of the target process. Copyright (C) 2006,2007,2009 Tavis Ormandy Copyright (C) 2009 Eli Dupree Copyright (C) 2009,2010 WANG Lu Copyright (C) 2015 Sebastian Parschauer This file is part of libscanmem. This library is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this library. If not, see . */ #include "config.h" /* for pread */ # ifdef _XOPEN_SOURCE # undef _XOPEN_SOURCE # endif # define _XOPEN_SOURCE 500 #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #ifdef __GNUC__ # define EXPECT(x,y) __builtin_expect(x, y) #else # define EXPECT(x,y) x #endif // Dirty hack for FreeBSD #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__) #define PTRACE_ATTACH PT_ATTACH #define PTRACE_DETACH PT_DETACH #define PTRACE_PEEKDATA PT_READ_D #define PTRACE_POKEDATA PT_WRITE_D #endif #include "value.h" #include "endianness.h" #include "scanroutines.h" #include "scanmem.h" #include "show_message.h" /* Progress handling */ #define NUM_DOTS (10) #define NUM_SAMPLES (100) #define MAX_PROGRESS (1.0) /* 100% */ #if (!NUM_DOTS || !NUM_SAMPLES || NUM_SAMPLES % NUM_DOTS != 0) #error Invalid NUM_DOTS to NUM_SAMPLES proportion! #endif #define SAMPLES_PER_DOT (NUM_SAMPLES / NUM_DOTS) #define PROGRESS_PER_SAMPLE (MAX_PROGRESS / NUM_SAMPLES) /* ptrace peek buffer, used by peekdata() */ /* make it larger in order to reduce shift */ /* #define MAX_PEEKBUF_SIZE (4*sizeof(int64_t)) */ #define MAX_PEEKBUF_SIZE (1024) static struct { uint8_t cache[MAX_PEEKBUF_SIZE]; /* read from ptrace() */ unsigned size; /* number of entries (in bytes) */ char *base; /* base address of cached region */ pid_t pid; /* what pid this applies to */ } peekbuf; bool sm_attach(pid_t target) { int status; /* attach, to the target application, which should cause a SIGSTOP */ if (ptrace(PTRACE_ATTACH, target, NULL, NULL) == -1L) { show_error("failed to attach to %d, %s\n", target, strerror(errno)); return false; } /* wait for the SIGSTOP to take place. */ if (waitpid(target, &status, 0) == -1 || !WIFSTOPPED(status)) { show_error("there was an error waiting for the target to stop.\n"); show_info("%s\n", strerror(errno)); return false; } /* flush the peek buffer */ memset(&peekbuf, 0x00, sizeof(peekbuf)); /* everything looks okay */ return true; } bool sm_detach(pid_t target) { // addr is ignore under Linux, but should be 1 under FreeBSD in order to let the child process continue at what it had been interrupted return ptrace(PTRACE_DETACH, target, 1, 0) == 0; } /* * sm_peekdata - caches overlapping ptrace reads to improve performance. * * This routine could just call ptrace(PEEKDATA), but using a cache reduces * the number of peeks required by 70% when reading large chunks of * consecutive addresses. */ bool sm_peekdata(pid_t pid, void *addr, value_t * result) { char *reqaddr = addr; int i, j; int shift_size1 = 0, shift_size2 = 0; char *last_address_gathered = 0; assert(peekbuf.size <= MAX_PEEKBUF_SIZE); assert(result != NULL); /* initialise result */ zero_value(result); valnowidth(result); /* check if we have a cache hit */ if (pid == peekbuf.pid && reqaddr >= peekbuf.base && (unsigned long) (reqaddr + sizeof(int64_t) - peekbuf.base) <= peekbuf.size) { memcpy(&result->int64_value, &peekbuf.cache[reqaddr - peekbuf.base], sizeof(result->int64_value)); return true; } else if (pid == peekbuf.pid && reqaddr >= peekbuf.base && (unsigned long) (reqaddr - peekbuf.base) < peekbuf.size) { assert(peekbuf.size != 0); /* partial hit, we have some of the data but not all, so remove old entries - shift the frame by as far as is necessary */ /* tail shift, round up to nearest long size, for ptrace efficiency */ shift_size1 = (reqaddr + sizeof(int64_t)) - (peekbuf.base + peekbuf.size); shift_size1 = sizeof(long) * (1 + (shift_size1-1) / sizeof(long)); /* head shift if necessary*/ if (peekbuf.size + shift_size1 > MAX_PEEKBUF_SIZE) { shift_size2 = reqaddr-peekbuf.base; shift_size2 = sizeof(long) * (shift_size2 / sizeof(long)); for (i = shift_size2; i < peekbuf.size; ++i) { peekbuf.cache[i - shift_size2] = peekbuf.cache[i]; } peekbuf.size -= shift_size2; peekbuf.base += shift_size2; } } else { /* cache miss, invalidate cache */ shift_size1 = shift_size2 = sizeof(int64_t); peekbuf.pid = pid; peekbuf.size = 0; peekbuf.base = addr; } /* we need a ptrace() to complete request */ errno = 0; for (i = 0; i < shift_size1; i += sizeof(long)) { char *ptrace_address = peekbuf.base + peekbuf.size; long ptraced_long = ptrace(PTRACE_PEEKDATA, pid, ptrace_address, NULL); /* check if ptrace() succeeded */ if (EXPECT(ptraced_long == -1L && errno != 0, false)) { /* its possible i'm trying to read partially oob */ if (errno == EIO || errno == EFAULT) { /* read backwards until we get a good read, then shift out the right value */ for (j = 1, errno = 0; j < sizeof(long); j++, errno = 0) { /* Try for a shifted ptrace - 'continue' (i.e. try an increased shift) if it fails */ if ((ptraced_long = ptrace(PTRACE_PEEKDATA, pid, ptrace_address - j, NULL)) == -1L && (errno == EIO || errno == EFAULT)) continue; /* Cache it with the appropriate offset */ if(peekbuf.size >= j) { memcpy(&peekbuf.cache[peekbuf.size - j], &ptraced_long, sizeof(long)); } else { memcpy(&peekbuf.cache[0], &ptraced_long, sizeof(long)); peekbuf.base -= j; } peekbuf.size += sizeof(long) - j; last_address_gathered = ptrace_address + sizeof(long) - j; /* Interrupt the gathering process */ goto doublebreak; } } /* i wont print a message here, would be very noisy if a region is unmapped */ return false; } /* Otherwise, ptrace() worked - cache the data, increase the size */ memcpy(&peekbuf.cache[peekbuf.size], &ptraced_long, sizeof(long)); peekbuf.size += sizeof(long); last_address_gathered = ptrace_address + sizeof(long); } doublebreak: /* Return result to caller */ if (reqaddr + sizeof(int64_t) <= last_address_gathered) { /* The values are fine - read away */ memcpy(&result->int64_value, &peekbuf.cache[reqaddr - peekbuf.base], sizeof(result->int64_value)); } else { int successful_gathering = last_address_gathered - reqaddr; /* We didn't get enough - add zeroes at the end */ for (i = 0; i < sizeof(int64_t); ++i) { uint8_t val = (i < successful_gathering) ? peekbuf.cache[reqaddr - peekbuf.base + i] : 0; *(((uint8_t *)&result->int64_value) + i) = val; } /* Mark which values this can't be */ if (successful_gathering < sizeof(int64_t)) result->flags.u64b = result->flags.s64b = result->flags.f64b = 0; if (successful_gathering < sizeof(int32_t)) result->flags.u32b = result->flags.s32b = result->flags.f32b = 0; if (successful_gathering < sizeof(int16_t)) result->flags.u16b = result->flags.s16b = 0; if (successful_gathering < sizeof(int8_t)) result->flags.u8b = result->flags.s8b = 0; } /* success */ return true; } static inline void print_a_dot(void) { fprintf(stderr, "."); fflush(stderr); } /* This is the function that handles when you enter a value (or >, <, =) for the second or later time (i.e. when there's already a list of matches); it reduces the list to those that still match. It returns false on failure to attach, detach, or reallocate memory, otherwise true. "value" is what to compare to. It is meaningless when the match type is not MATCHEXACT. */ bool sm_checkmatches(globals_t *vars, scan_match_type_t match_type, const uservalue_t *uservalue) { matches_and_old_values_swath *reading_swath_index = (matches_and_old_values_swath *)vars->matches->swaths; matches_and_old_values_swath reading_swath = *reading_swath_index; long bytes_scanned = 0; long total_scan_bytes = 0; matches_and_old_values_swath *tmp_swath_index = reading_swath_index; int samples_remaining = NUM_SAMPLES; int samples_to_dot = SAMPLES_PER_DOT; size_t bytes_at_next_sample; size_t bytes_per_sample; while(tmp_swath_index->number_of_bytes) { total_scan_bytes += tmp_swath_index->number_of_bytes; tmp_swath_index = (matches_and_old_values_swath *)(&tmp_swath_index->data[tmp_swath_index->number_of_bytes]); } bytes_per_sample = total_scan_bytes / NUM_SAMPLES; bytes_at_next_sample = bytes_per_sample; /* for user, just print the first dot */ print_a_dot(); int reading_iterator = 0; matches_and_old_values_swath *writing_swath_index = (matches_and_old_values_swath *)vars->matches->swaths; writing_swath_index->first_byte_in_child = NULL; writing_swath_index->number_of_bytes = 0; /* used to fill in non-match regions */ match_flags zero_flag; zero_match_flags(&zero_flag); int required_extra_bytes_to_record = 0; vars->num_matches = 0; vars->scan_progress = 0.0; if (sm_choose_scanroutine(vars->options.scan_data_type, match_type) == false) { show_error("unsupported scan for current data type.\n"); return false; } assert(sm_scan_routine); /* stop and attach to the target */ if (sm_attach(vars->target) == false) return false; while (reading_swath.first_byte_in_child) { int match_length = 0; value_t data_value; match_flags checkflags; void *address = reading_swath.first_byte_in_child + reading_iterator; /* Read value from this address */ if (EXPECT(sm_peekdata(vars->target, address, &data_value) == false, false)) { /* Uhh, what? We couldn't look at the data there? I guess this doesn't count as a match then */ } else { value_t old_val = data_to_val_aux(reading_swath_index, reading_iterator, reading_swath.number_of_bytes /* ,MATCHES_AND_VALUES */); match_flags flags = reading_swath_index->data[reading_iterator].match_info; /* these are not harmful for bytearray routine, since it will ignore flags of new_value & old_value */ truncval_to_flags(&old_val, flags); truncval_to_flags(&data_value, flags); fix_endianness(vars, &data_value); zero_match_flags(&checkflags); match_length = (*sm_scan_routine)(&data_value, &old_val, uservalue, &checkflags, address); } if (match_length > 0) { /* Still a candidate. Write data. (We can get away with overwriting in the same array because it is guaranteed to take up the same number of bytes or fewer, and because we copied out the reading swath metadata already.) (We can get away with assuming that the pointers will stay valid, because as we never add more data to the array than there was before, it will not reallocate.) */ old_value_and_match_info new_value = { get_u8b(&data_value), checkflags }; writing_swath_index = add_element((&vars->matches), writing_swath_index, address, &new_value /* ,MATCHES_AND_VALUES */); ++vars->num_matches; required_extra_bytes_to_record = match_length - 1; } else if (required_extra_bytes_to_record) { old_value_and_match_info new_value = { get_u8b(&data_value), zero_flag }; writing_swath_index = add_element(&vars->matches, writing_swath_index, address, &new_value /* ,MATCHES_AND_VALUES */); --required_extra_bytes_to_record; } if (EXPECT(bytes_scanned >= bytes_at_next_sample, false)) { bytes_at_next_sample += bytes_per_sample; /* handle rounding */ if (EXPECT(--samples_remaining > 0, true)) { /* for front-end, update percentage */ vars->scan_progress += PROGRESS_PER_SAMPLE; if (EXPECT(--samples_to_dot == 0, false)) { samples_to_dot = SAMPLES_PER_DOT; /* for user, just print a dot */ print_a_dot(); } } } ++bytes_scanned; /* Go on to the next one... */ ++reading_iterator; if (reading_iterator >= reading_swath.number_of_bytes) { reading_swath_index = (matches_and_old_values_swath *) (&reading_swath_index->data[reading_swath.number_of_bytes]); reading_swath = *reading_swath_index; reading_iterator = 0; required_extra_bytes_to_record = 0; /* just in case */ } } if (!(vars->matches = null_terminate(vars->matches, writing_swath_index /* ,MATCHES_AND_VALUES */))) { show_error("memory allocation error while reducing matches-array size\n"); return false; } /* tell front-end we've done */ vars->scan_progress = MAX_PROGRESS; show_info("we currently have %ld matches.\n", vars->num_matches); /* okay, detach */ return sm_detach(vars->target); } /* read region using /proc/pid/mem */ ssize_t readregion(pid_t target, void *buf, size_t count, unsigned long offset) { char mem[32]; int fd; ssize_t len; /* print the path to mem file */ snprintf(mem, sizeof(mem), "/proc/%d/mem", target); /* attempt to open the file */ if ((fd = open(mem, O_RDONLY)) == -1) { show_error("unable to open %s.\n", mem); return -1; } /* try to honour the request */ len = pread(fd, buf, count, offset); /* clean up */ close(fd); return len; } /* sm_searchregions() performs an initial search of the process for values matching value */ bool sm_searchregions(globals_t *vars, scan_match_type_t match_type, const uservalue_t *uservalue) { matches_and_old_values_swath *writing_swath_index; int required_extra_bytes_to_record = 0; unsigned long total_size = 0; unsigned regnum = 0; element_t *n = vars->regions->head; region_t *r; unsigned long total_scan_bytes = 0; void *address = NULL; #if HAVE_PROCMEM unsigned char *data = NULL; ssize_t len = 0; #endif /* used to fill in non-match regions */ match_flags zero_flag; zero_match_flags(&zero_flag); if (sm_choose_scanroutine(vars->options.scan_data_type, match_type) == false) { show_error("unsupported scan for current data type.\n"); return false; } assert(sm_scan_routine); /* stop and attach to the target */ if (sm_attach(vars->target) == false) return false; /* make sure we have some regions to search */ if (vars->regions->size == 0) { show_warn("no regions defined, perhaps you deleted them all?\n"); show_info("use the \"reset\" command to refresh regions.\n"); return sm_detach(vars->target); } total_size = sizeof(matches_and_old_values_array); while (n) { total_size += ((region_t *)(n->data))->size * sizeof(old_value_and_match_info) + sizeof(matches_and_old_values_swath); n = n->next; } total_size += sizeof(matches_and_old_values_swath); /* for null terminate */ show_debug("allocate array, max size %ld\n", total_size); if (!(vars->matches = allocate_array(vars->matches, total_size))) { show_error("could not allocate match array\n"); return false; } writing_swath_index = (matches_and_old_values_swath *)vars->matches->swaths; writing_swath_index->first_byte_in_child = NULL; writing_swath_index->number_of_bytes = 0; /* get total byte */ for(n = vars->regions->head; n; n = n->next) total_scan_bytes += ((region_t *)n->data)->size; vars->scan_progress = 0.0; n = vars->regions->head; /* check every memory region */ while (n) { unsigned offset, nread = 0; int dots_remaining = NUM_DOTS; size_t bytes_at_next_dot; size_t bytes_per_dot; double progress_per_dot; /* load the next region */ r = n->data; bytes_per_dot = r->size / NUM_DOTS; bytes_at_next_dot = bytes_per_dot; progress_per_dot = (double)bytes_per_dot / total_scan_bytes; #if HAVE_PROCMEM /* over allocate by enough bytes set to zero that the last bytes can be read as 64-bit ints */ if ((data = calloc(r->size + sizeof(int64_t) - 1, 1)) == NULL) { show_error("sorry, there was a memory allocation error.\n"); return false; } /* keep reading until completed */ while (nread < r->size) { if ((len = readregion(vars->target, data+nread, r->size-nread, (unsigned long)(r->start+nread))) == -1) { /* no, continue with whatever data was read */ break; } else { /* some data was read */ nread += len; } } #else /* cannot use /proc/pid/mem */ nread = r->size; #endif /* print a progress meter so user knows we havent crashed */ /* cannot use show_info here because it'll append a '\n' */ show_user("%02u/%02u searching %#10lx - %#10lx.", ++regnum, vars->regions->size, (unsigned long)r->start, (unsigned long)r->start + r->size); fflush(stderr); /* for every offset, check if we have a match */ for (offset = 0; offset < nread; offset++) { match_flags checkflags; value_t data_value; /* initialise data_value */ zero_value(&data_value); valnowidth(&data_value); address = r->start + offset; #if HAVE_PROCMEM /* Don't dereference as this causes an alignment issue e.g. on ARM. GCC replaces memcpy() with dereferencing where possible. */ memcpy(&data_value.int64_value, &data[offset], sizeof(int64_t)); /* Mark which values this can't be */ if (EXPECT((nread - offset < sizeof(int64_t)), false)) { data_value.flags.u64b = data_value.flags.s64b = data_value.flags.f64b = 0; if (nread - offset < sizeof(int32_t)) { data_value.flags.u32b = data_value.flags.s32b = data_value.flags.f32b = 0; if (nread - offset < sizeof(int16_t)) { data_value.flags.u16b = data_value.flags.s16b = 0; if (nread - offset < sizeof(int8_t)) { data_value.flags.u8b = data_value.flags.s8b = 0; } } } } #else if (EXPECT(peekdata(vars->target, address, &data_value) == false, false)) { break; } #endif fix_endianness(vars, &data_value); /* initialise checkflags */ zero_match_flags(&checkflags); int match_length; /* check if we have a match */ if (EXPECT(((match_length = (*sm_scan_routine)(&data_value, NULL, uservalue, &checkflags, address)) > 0), false)) { /* only set these flags for numbers */ if ((vars->options.scan_data_type != BYTEARRAY) && (vars->options.scan_data_type != STRING)) { checkflags.ineq_forwards = checkflags.ineq_reverse = 1; } old_value_and_match_info new_value = { get_u8b(&data_value), checkflags }; writing_swath_index = add_element((&vars->matches), writing_swath_index, r->start + offset, &new_value); ++vars->num_matches; required_extra_bytes_to_record = match_length - 1; } else if (required_extra_bytes_to_record) { old_value_and_match_info new_value = { get_u8b(&data_value), zero_flag }; writing_swath_index = add_element((&vars->matches), writing_swath_index, r->start + offset, &new_value); --required_extra_bytes_to_record; } /* print a simple progress meter. */ if (EXPECT(offset >= bytes_at_next_dot, false)) { bytes_at_next_dot += bytes_per_dot; /* handle rounding */ if (EXPECT(--dots_remaining > 0, true)) { /* for user, just print a dot */ print_a_dot(); /* for front-end, update percentage */ vars->scan_progress += progress_per_dot; } } } vars->scan_progress += progress_per_dot; n = n->next; show_user("ok\n"); #if HAVE_PROCMEM free(data); #endif } /* tell front-end we've done */ vars->scan_progress = MAX_PROGRESS; if (!(vars->matches = null_terminate(vars->matches, writing_swath_index /* ,MATCHES_AND_VALUES */))) { show_error("memory allocation error while reducing matches-array size\n"); return false; } show_info("we currently have %ld matches.\n", vars->num_matches); /* okay, detach */ return sm_detach(vars->target); } bool sm_setaddr(pid_t target, void *addr, const value_t *to) { value_t saved; int i; if (sm_attach(target) == false) { return false; } if (sm_peekdata(target, addr, &saved) == false) { show_error("couldnt access the target address %10p\n", addr); return false; } /* Basically, overwrite as much of the data as makes sense, and no more. */ /* about float/double: now value_t is a union, we can use the following way instead of the commented way, in order to avoid compiler warning */ if (saved.flags.u64b && to->flags.u64b) { set_u64b(&saved, get_u64b(to)); } else if (saved.flags.s64b && to->flags.s64b) { set_s64b(&saved, get_s64b(to)); } else if (saved.flags.f64b && to->flags.f64b) { set_s64b(&saved, get_s64b(to)); } /* *((int64_t *)&(to->float64_value))); } */ else if (saved.flags.u32b && to->flags.u32b) { set_u32b(&saved, get_u32b(to)); } else if (saved.flags.s32b && to->flags.s32b) { set_s32b(&saved, get_s32b(to)); } else if (saved.flags.f32b && to->flags.f32b) { set_s32b(&saved, get_s32b(to)); } /* *((int32_t *)&(to->float32_value))); } */ else if (saved.flags.u16b && to->flags.u16b) { set_u16b(&saved, get_u16b(to)); } else if (saved.flags.s16b && to->flags.s16b) { set_s16b(&saved, get_s16b(to)); } else if (saved.flags.u8b && to->flags.u8b ) { set_u8b(&saved, get_u8b(to)); } else if (saved.flags.s8b && to->flags.s8b ) { set_s8b(&saved, get_s8b(to)); } else { show_error("could not determine type to poke.\n"); return false; } /* TODO: may use /proc//mem here */ /* assume that sizeof(save.int64_value) (int64_t) is multiple of sizeof(long) */ for (i = 0; i < sizeof(saved.int64_value); i += sizeof(long)) { if (ptrace(PTRACE_POKEDATA, target, addr + i, *(long *)(((int8_t *)&saved.int64_value) + i)) == -1L) { return false; } } return sm_detach(target); } bool sm_read_array(pid_t target, void *addr, char *buf, int len) { if (sm_attach(target) == false) { return false; } #if HAVE_PROCMEM unsigned nread=0; ssize_t tmpl; while (nread < len) { if ((tmpl = readregion(target, buf+nread, len-nread, (unsigned long)(addr+nread))) == -1) { /* no, continue with whatever data was read */ break; } else { /* some data was read */ nread += tmpl; } } if (nread < len) { sm_detach(target); return false; } return sm_detach(target); #else int i; /* here we just read long by long, this should be ok for most of time */ /* partial hit is not handled */ for(i = 0; i < len; i += sizeof(long)) { errno = 0; *((long *)(buf+i)) = ptrace(PTRACE_PEEKDATA, target, addr+i, NULL); if (EXPECT((*((long *)(buf+i)) == -1L) && (errno != 0), false)) { sm_detach(target); return false; } } return sm_detach(target); #endif } /* TODO: may use /proc//mem here */ bool sm_write_array(pid_t target, void *addr, const void *data, int len) { int i,j; long peek_value; if (sm_attach(target) == false) { return false; } for (i = 0; i + sizeof(long) < len; i += sizeof(long)) { if (ptrace(PTRACE_POKEDATA, target, addr + i, *(long *)(data + i)) == -1L) { return false; } } if (len - i > 0) /* something left (shorter than a long) */ { if (len > sizeof(long)) /* rewrite last sizeof(long) bytes of the buffer */ { if (ptrace(PTRACE_POKEDATA, target, addr + len - sizeof(long), *(long *)(data + len - sizeof(long))) == -1L) { return false; } } else /* we have to play with bits... */ { /* try all possible shifting read & write */ for(j = 0; j <= sizeof(long) - (len - i); ++j) { errno = 0; if(((peek_value = ptrace(PTRACE_PEEKDATA, target, addr - j, NULL)) == -1L) && (errno != 0)) { if (errno == EIO || errno == EFAULT) /* may try next shift */ continue; else { show_error("%s failed.\n", __func__); return false; } } else /* peek success */ { /* write back */ memcpy(((int8_t*)&peek_value)+j, data+i, len-i); if (ptrace(PTRACE_POKEDATA, target, addr - j, peek_value) == -1L) { show_error("%s failed.\n", __func__); return false; } break; } } } } return sm_detach(target); } scanmem-0.16/readline.c000066400000000000000000000032141302526536600150220ustar00rootroot00000000000000/* Replace libreadline. Copyright (C) 2015 Jonathan Pelletier This file is part of libscanmem. This library is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this library. If not, see . */ #include #include "readline.h" #include "getline.h" int rl_attempted_completion_over = 0; const char *rl_readline_name = "scanmem"; rl_completion_func_t *rl_attempted_completion_function = NULL; /* always return NULL to show that there are no completions */ char **rl_completion_matches(const char *text, rl_compentry_func_t *entry_function) { return NULL; } /* show the prompt, then allocate, read and return a line with getline() */ char *readline(const char *prompt) { char *line = NULL; size_t n = 0; ssize_t bytes_read; printf("%s", prompt); fflush(stdout); bytes_read = getline(&line, &n, stdin); if (bytes_read > 0) line[bytes_read - 1] = '\0'; /* remove the trailing newline */ return line; } /* don't maintain a history */ void add_history(const char *line) { } scanmem-0.16/readline.h000066400000000000000000000024471302526536600150360ustar00rootroot00000000000000/* Replace libreadline. Copyright (C) 2015 Jonathan Pelletier This file is part of libscanmem. This library is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this library. If not, see . */ #ifndef READLINE_H #define READLINE_H typedef char *rl_compentry_func_t(const char *, int); typedef char **rl_completion_func_t(const char *, int, int); extern int rl_attempted_completion_over; extern const char *rl_readline_name; extern rl_completion_func_t *rl_attempted_completion_function; char **rl_completion_matches(const char *text, rl_compentry_func_t *entry_function); char *readline(const char *prompt); void add_history(const char *line); #endif /* READLINE_H */ scanmem-0.16/scanmem.1000066400000000000000000000367061302526536600146140ustar00rootroot00000000000000.TH scanmem 1 "2016-12-17" "scanmem-0.16" .SH NAME scanmem - locate and modify a variable in an executing process. .SH SYNOPSIS .B scanmem .RB [options] .IR [target-program-pid] .SH DESCRIPTION .B scanmem is an interactive debugging utility that can be used to isolate the address of a variable in an executing process by successively scanning the process' address space looking for matching values. By informing .B scanmem how the value of the variable changes over time, it can determine the actual location (or locations) of the variable by successively eliminating non-matches. .B scanmem determines where to look by searching for mappings with .I read / .I write permission, these are referred to as regions. Users can eliminate regions they believe are likely unrelated to the target variable (for example, located in a shared library unrelated to the variable in question), this will improve the speed of the scan, which can initially be quite slow in large programs. Once a variable has been found, .B scanmem can monitor the variable, or change it to a user specified value, either once, or continually over a period of time. .B scanmem .RI "works similarly to the \(dq" pokefinders "\(dq once commonly used to cheat at video games," this function is a good demonstration of how to use .BR scanmem ", and is used in the documentation." .SH USAGE .B scanmem should be invoked with the process id of the program you wish to debug as an argument. Once started, .B scanmem accepts interactive commands. These are described below, however entering .IR help at the .B > prompt will allow you to access .BR scanmem "'s" online documentation. The .IR target-program-pid can be specified in decimal, hexadecimal, or octal using the standard C language notation (leading 0x for hexadecimal, leading 0 for octal, anything else is assumed to be decimal). .BI "\-p, \-\-pid=" pid Set the .IR "target-program-pid". .B "\-v, \-\-version" Print version and exit. .B "\-h, \-\-help" Print a short description of command line options then exit. .B "\-d, \-\-debug" Run in debug mode, more information will be outputted. .SH COMMANDS While in interactive mode, .BR scanmem " prints a decimal number followed by " > ", the number is the current number of" possible candidates for the target variable that are known. 0 indicates that no possible variables have been eliminated yet. The default scan data type is "int". .RB "It can be changed with the " option " command." .B n Where .B n represents any number in decimal, octal or hexadecimal, this command tells .B scanmem that the current value of the target variable is exactly .BR n "." .B scanmem will begin a search of the entire address space, or the existing known matches (if any), eliminating any variable that does not have this value. .B n..m This is like the .B n command but .B scanmem searches for a range of numbers between .B n and .B m inclusive instead. .BR ">", " <", " =", " !=" ", ..." The following commands are extremely useful for locating a variable where we cannot see its exact value but we can see for example how it changes over time like with a health bar. These commands usually cannot be used for the first scan but there are some exceptions: .BR "> " n, " < " n, " = " "n and" " != " n. .BI "> " [n] .RI "If " n " is given, match values that are greater than " n "." .RB "Otherwise match all values that have increased." .BI "< " [n] .RI "If " n " is given, match values that are less than " n "." .RB "Otherwise match all values that have decreased." .BI "+ " [n] .RI "If " n " is given, match values that have been increased by " n "." .RB "Otherwise match all values that have increased (same as " > ")." .BI "- " [n] .RI "If " n " is given, match values that have been decreased by " n "." .RB "Otherwise match all values that have decreased (same as " < ")." .BI "= " [n] .RI "If " n " is given, match values that are equal to " n " (same as " n ")." .RB "Otherwise match all values that have not changed." .BI "!= " [n] .RI "If " n " is given, match values that are different from " n "." .RB "Otherwise match all values that have changed." .B snapshot Match any value. This is useful when an initial value or range is not known for subsequent scans with .BR > ", " < ", " + ", " - ", " = ", and " != "." .BI "\(dq " text Search for the provided .I text in memory if the scan data type is set to "string". .B update Scans the current process, getting the current values of all matches. These values can be viewed with .BR list ", and are also the old values that " scanmem " compares to when using" .BR > ", " < ", or " = "." This command is equivalent to a search command that all current results match. .B list List all the possible candidates currently known, including their address, region id, match offset, region type, last known value and possible value types. The value in the first column is the match id, and can be used in conjunction with the .B delete command to eliminate matches. For experts: The match offset is determined by subtracting the load address of the associated ELF file or region from the address. It can be used to bypass Address Space Layout Randomization (ASLR). .B delete .I match-id Delete match .IR match-id ", which can be found from the output of the" .B list command. To delete all matches, see the .B reset command, or to delete all matches associated with a particular library, see the .B dregion command, which also removes any associated matches. Please note that match-ids may be recalculated after matches are removed or added. .B watch .I match-id Monitor the value of .IR match-id ", and print its value as it changes. Every change is printed along with a timestamp," you can interrupt this command with ^C to stop monitoring. .B set .I [match-id][,match-id,...]=]value[/delay] [...] Set the value .IR value " into the match numbers " match-id ", or if just " .IR value " is specified, all known matches." .I value can be specified in standard C language notation. All known matches, along with their match-id's can be displayed using the .B list command. Multiple .IR match-id's " can be specified, separated with commas and terminated with an " .IR = " sign. To set a value continually, suffix the command with " / followed by the number of seconds to wait between sets. You can interrupt the set command with ^C to return to the .B scanmem prompt. This can be used to sustain the value of a variable which decreases overtime, for example a timer that is decremented every second can be set to 100 every 10 seconds to prevent some property from ever changing. This command is used to change the value of the variable(s) once found by elimination. Please note, some applications will store values in multiple locations. .B write .I value_type address value Manually set the value of the variable at the specified address. Names of .I value_type are subject to change in different versions of .BR scanmem "," see more info using the `help write` command. .B dump .I address length [filename] Dump the memory region starting from .I address of length .I length in a human-readable format. If .I filename is given, data will be saved into the file, otherwise data will be displayed on stdout. .B pid .I [new-pid] Print out the process id of the current target program, or change the target to .IR new-pid ", which will reset existing regions and matches." .B reset Forget all known regions and matches and start again. .B lregions List all the known regions, this can be used in combination with the .B dregion command to eliminate regions that the user believes are not related to the variable in question, thus reducing the address space required to search in. The value in the first column is the .I region-id which must be passed to the .B dregion command. Besides the start address, the size and path (if applicable) are also printed. This can be used to eliminate regions located in shared libraries that are unlikely to be relevant to the variable required. For experts: Also the region type and the load address are displayed. The types are "exe" (executable) "code" (library), "heap", "stack" or "misc" (everything else). The load address is the memory location where an ELF file (exe/lib) has been loaded to. This helps to convert between the addresses in memory and in the associated ELF file. If the region does not belong to an ELF file, then it is the same as the start address. .B dregion .I [!]region-id[,region-id][,...] Delete the region .IR region-id ", along with any matches from the match list. The" .I region-id can be found in the output of the .B lregions command. A leading .I ! indicates the list should be inverted. .B option .I name value Change options at runtime. E.g. the scan data type can be changed. See `help option` for all possible names/values. .B shell .I shell-command Execute .I shell-command using /bin/sh, then return. .B show .I info Display information relating to .I info - see `help show` for details. .B version Print the version of .B scanmem in use. .B help Print a short summary of available commands. .BR exit Detach from the target program and exit immediately. .SH EXAMPLES Cheat at nethack, on systems where nethack is not installed sgid. .B ATTENTION: scanmem usually requires root privileges. See .B BUGS for details. .nf $ sudo scanmem `pgrep nethack` info: maps file located at /proc/14658/maps opened. info: 9 suitable regions found. Please enter current value, or "help" for other commands. 0> .fi The 0 in the .B scanmem prompt indicates we currently have no candidates, so I enter how much gold I currently have (58 pieces) and let .B scanmem find the potential candidates. .nf 0> 58 01/09 searching 0x79f000 - 0x7b0000..........ok 02/09 searching 0x7b0000 - 0x7cc000..........ok 03/09 searching 0x24d2000 - 0x24f3000..........ok 04/09 searching 0x7fcc04baa000 - 0x7fcc04bae000..........ok 05/09 searching 0x7fcc04de1000 - 0x7fcc04de2000..........ok 06/09 searching 0x7fcc051f7000 - 0x7fcc051fb000..........ok 07/09 searching 0x7fcc05227000 - 0x7fcc0522a000..........ok 08/09 searching 0x7fcc0522c000 - 0x7fcc0522d000..........ok 09/09 searching 0x7ffc8c113000 - 0x7ffc8c134000..........ok info: we currently have 16 matches. 16> list [ 0] 7b09e0, 1 + 3b09e0, exe, 58, [I64 I32 I16 I8 ] [ 1] 7b907a, 1 + 3b907a, exe, 58, [I8 ] [ 2] 24d4b6c, 2 + 2b6c, heap, 58, [I16 I8 ] [ 3] 24d567e, 2 + 367e, heap, 58, [I16 I8 ] [ 4] 24d5740, 2 + 3740, heap, 58, [I8 ] [ 5] 7fcc05229951, 6 + 2951, misc, 58, [I8 ] [ 6] 7ffc8c12ee28, 8 + 1be28, stack, 58, [I16 I8 ] [ 7] 7ffc8c132381, 8 + 1f381, stack, 58, [I8 ] [ 8] 7ffc8c132389, 8 + 1f389, stack, 58, [I8 ] [ 9] 7ffc8c132391, 8 + 1f391, stack, 58, [I8 ] [10] 7ffc8c132399, 8 + 1f399, stack, 58, [I8 ] [11] 7ffc8c1323a1, 8 + 1f3a1, stack, 58, [I8 ] [12] 7ffc8c1323a9, 8 + 1f3a9, stack, 58, [I8 ] [13] 7ffc8c1331a3, 8 + 201a3, stack, 58, [I8 ] [14] 7ffc8c13325f, 8 + 2025f, stack, 58, [I8 ] [15] 7ffc8c133264, 8 + 20264, stack, 58, [I8 ] 16> .fi 16 potential matches were found, many of them are quite unrelated, as they are part of the stack, belong to libraries or miscellaneous memory-mapped files. Even the heap is unlikely for a very old command line game. We could make .B scanmem eliminate these manually using the .B delete command, however just waiting until the amount of gold changes and telling .B scanmem the new value should be enough. I find some more gold, and tell .B scanmem the new value, 83. .nf 16> 83 ..........info: we currently have 1 matches. info: match identified, use "set" to modify value. info: enter "help" for other commands. 1> list [ 0] 7b09e0, 1 + 3b09e0, exe, 83, [I64 I32 I16 I8 ] .fi Only one of the 16 original candidates now has the value 83, so this must be where the amount of gold is stored. I'll try setting it to 10,000 pieces. .nf 1> set 10000 info: setting *0x7b09e0 to 0x2710... 1> .fi The resulting nethack status: .nf Dlvl:1 $:10000 HP:15(15) Pw:2(2) AC:7 Exp:1 .fi Conclusion: We've found and modified the gold value as I32 in static memory of the executable at virtual memory address 0x7b09e0. This address belongs to the region with id 1. Now it is important to know if this is a position-independent executable (PIE). We list the regions for this and check the load address of the executable. .nf 1> lregions [ 0] 79f000, 69632 bytes, exe, 400000, rw-, /usr/lib/nethack/nethack.tty [ 1] 7b0000, 114688 bytes, exe, 400000, rw-, unassociated [ 2] 24d2000, 135168 bytes, heap, 24d2000, rw-, [heap] [ 3] 7fcc04baa000, 16384 bytes, misc, 7fcc04baa000, rw-, unassociated [ 4] 7fcc04de1000, 4096 bytes, misc, 7fcc04de1000, rw-, unassociated [ 5] 7fcc051f7000, 16384 bytes, misc, 7fcc051f7000, rw-, unassociated [ 6] 7fcc05227000, 12288 bytes, misc, 7fcc05227000, rw-, unassociated [ 7] 7fcc0522c000, 4096 bytes, misc, 7fcc0522c000, rw-, unassociated [ 8] 7ffc8c113000, 135168 bytes, stack, 7ffc8c113000, rw-, [stack] .fi We are on x86_64 and 0x400000 is the static load adress for executables there. This means that this is not a PIE and the gold is always stored at 0x7b09e0. This makes it easy to use a game trainer like GameConqueror which refills the gold value periodically. With a PIE we have to use the match offset (0x3b09e0 here) instead and an advanced game trainer with PIE support has to determine and add the current load address to it to get the current memory address of the gold value of the current game run. .SH NOTES .B scanmem has been tested on multiple large programs, including the 3d shoot-em-up quake3 linux. .B scanmem is also tested on ARM platforms and comes with Android support since version 0.16. Obviously, .B scanmem can crash your program if used incorrectly. Some programs store values in multiple locations, this is why .B set will change all known matches. Address Space Layout Randomization (ASLR) together with position-independent executables (PIE), position-independent code (PIC) or dynamic memory on the heap causes variables to be loaded to different memory addresses at every game start. Advanced game trainers like ugtrain are required to periodically refill variables is such memory regions. .SH BUGS .B scanmem usually requires root privileges for .BR ptrace (2) because security modules control ptrace() capabilities. On x86 and x86_64 there is usually the .B Yama security module providing the file .IR /proc/sys/kernel/yama/ptrace_scope "." It is available since Linux 3.4. If this file contains "1", then only parents may ptrace() their children without root privileges. This means that .B scanmem would have to run the game. This is not possible as this would require major design changes. So we run .B scanmem as root. The first scan can be very slow on large programs, this is not a problem for subsequent scans as huge portions of the address space are usually eliminated. This could be improved in future, perhaps by assuming all integers are aligned by default. Suggestions welcome. The .B snapshot command uses memory inefficiently, and should probably not be used on large programs. In future this will use a more intelligent format. .SH HOMEPAGE https://github.com/scanmem/scanmem .SH AUTHORS Tavis Ormandy http://taviso.decsystem.org/ .br Eli Dupree .br WANG Lu .br Sebastian Parschauer All bug reports, suggestions or feedback welcome. .SH SEE ALSO gameconqueror(1) gdb(1) ptrace(2) nethack(6) pidof(8) scanmem-0.16/scanmem.c000066400000000000000000000177771302526536600147050ustar00rootroot00000000000000/* Provide interfaces for front-ends. Copyright (C) 2006,2007,2009 Tavis Ormandy Copyright (C) 2009 Eli Dupree Copyright (C) 2009-2013 WANG Lu Copyright (C) 2016 Sebastian Parschauer This file is part of libscanmem. This library is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this library. If not, see . */ #ifndef _GNU_SOURCE #define _GNU_SOURCE #endif #include "config.h" #include #include #include #include #include #include #include "scanmem.h" #include "commands.h" #include "handlers.h" #include "show_message.h" void sm_printversion(FILE *outfd) { fprintf(outfd, "libscanmem version %s\n", PACKAGE_VERSION); } /* global settings */ globals_t sm_globals = { 0, /* exit flag */ 0, /* pid target */ NULL, /* matches */ 0, /* match count */ 0, /* scan progress */ NULL, /* regions */ NULL, /* commands */ NULL, /* current_cmdline */ sm_printversion, /* printversion() pointer */ /* options */ { 1, /* alignment */ 0, /* debug */ 0, /* backend */ ANYINTEGER, /* scan_data_type */ REGION_HEAP_STACK_EXECUTABLE_BSS, /* region_detail_level */ 0, /* detect_reverse_change */ 1, /* dump_with_ascii */ 0, /* reverse_endianness */ } }; /* signal handler - Use async-signal-safe functions ONLY! */ static void sighandler(int n) { const char err_msg[] = "error: \nKilled by signal "; const char msg_end[] = ".\n"; char num_str[4] = {0}; ssize_t num_size; ssize_t wbytes; wbytes = write(STDERR_FILENO, err_msg, sizeof(err_msg) - 1); if (wbytes != sizeof(err_msg) - 1) goto out; /* manual int to str conversion */ if (n < 10) { num_str[0] = (char) (0x30 + n); num_size = 1; } else if (n >= 100) { goto out; } else { num_str[0] = (char) (0x30 + n / 10); num_str[1] = (char) (0x30 + n % 10); num_size = 2; } wbytes = write(STDERR_FILENO, num_str, num_size); if (wbytes != num_size) goto out; wbytes = write(STDERR_FILENO, msg_end, sizeof(msg_end) - 1); if (wbytes != sizeof(msg_end) - 1) goto out; out: _exit(EXIT_FAILURE); /* also detaches from tracee */ } bool sm_init(void) { globals_t *vars = &sm_globals; /* before attaching to target, install signal handler to detach on error */ if (vars->options.debug == 0) /* in debug mode, let it crash and see the core dump */ { (void) signal(SIGHUP, sighandler); (void) signal(SIGINT, sighandler); (void) signal(SIGSEGV, sighandler); (void) signal(SIGABRT, sighandler); (void) signal(SIGILL, sighandler); (void) signal(SIGFPE, sighandler); (void) signal(SIGTERM, sighandler); } /* linked list of commands, and function pointers to their handlers */ if ((vars->commands = l_init()) == NULL) { show_error("sorry, there was a memory allocation error.\n"); return false; } /* NULL shortdoc means dont display this command in `help` listing */ sm_registercommand("set", handler__set, vars->commands, SET_SHRTDOC, SET_LONGDOC); sm_registercommand("list", handler__list, vars->commands, LIST_SHRTDOC, LIST_LONGDOC); sm_registercommand("delete", handler__delete, vars->commands, DELETE_SHRTDOC, DELETE_LONGDOC); sm_registercommand("reset", handler__reset, vars->commands, RESET_SHRTDOC, RESET_LONGDOC); sm_registercommand("pid", handler__pid, vars->commands, PID_SHRTDOC, PID_LONGDOC); sm_registercommand("snapshot", handler__snapshot, vars->commands, SNAPSHOT_SHRTDOC, SNAPSHOT_LONGDOC); sm_registercommand("dregion", handler__dregion, vars->commands, DREGION_SHRTDOC, DREGION_LONGDOC); sm_registercommand("dregions", handler__dregion, vars->commands, NULL, DREGION_LONGDOC); sm_registercommand("lregions", handler__lregions, vars->commands, LREGIONS_SHRTDOC, LREGIONS_LONGDOC); sm_registercommand("version", handler__version, vars->commands, VERSION_SHRTDOC, VERSION_LONGDOC); sm_registercommand("=", handler__decinc, vars->commands, NOTCHANGED_SHRTDOC, NOTCHANGED_LONGDOC); sm_registercommand("!=", handler__decinc, vars->commands, CHANGED_SHRTDOC, CHANGED_LONGDOC); sm_registercommand("<", handler__decinc, vars->commands, LESSTHAN_SHRTDOC, LESSTHAN_LONGDOC); sm_registercommand(">", handler__decinc, vars->commands, GREATERTHAN_SHRTDOC, GREATERTHAN_LONGDOC); sm_registercommand("+", handler__decinc, vars->commands, INCREASED_SHRTDOC, INCREASED_LONGDOC); sm_registercommand("-", handler__decinc, vars->commands, DECREASED_SHRTDOC, DECREASED_LONGDOC); sm_registercommand("\"", handler__string, vars->commands, STRING_SHRTDOC, STRING_LONGDOC); sm_registercommand("update", handler__update, vars->commands, UPDATE_SHRTDOC, UPDATE_LONGDOC); sm_registercommand("exit", handler__exit, vars->commands, EXIT_SHRTDOC, EXIT_LONGDOC); sm_registercommand("quit", handler__exit, vars->commands, NULL, EXIT_LONGDOC); sm_registercommand("q", handler__exit, vars->commands, NULL, EXIT_LONGDOC); sm_registercommand("help", handler__help, vars->commands, HELP_SHRTDOC, HELP_LONGDOC); sm_registercommand("shell", handler__shell, vars->commands, SHELL_SHRTDOC, SHELL_LONGDOC); sm_registercommand("watch", handler__watch, vars->commands, WATCH_SHRTDOC, WATCH_LONGDOC); sm_registercommand("show", handler__show, vars->commands, SHOW_SHRTDOC, SHOW_LONGDOC); sm_registercommand("dump", handler__dump, vars->commands, DUMP_SHRTDOC, DUMP_LONGDOC); sm_registercommand("write", handler__write, vars->commands, WRITE_SHRTDOC, WRITE_LONGDOC); sm_registercommand("option", handler__option, vars->commands, OPTION_SHRTDOC, OPTION_LONGDOC); /* commands beginning with __ have special meaning */ sm_registercommand("__eof", handler__eof, vars->commands, NULL, NULL); /* special value NULL means no other matches */ sm_registercommand(NULL, handler__default, vars->commands, DEFAULT_SHRTDOC, DEFAULT_LONGDOC); return true; } /* for front-ends */ void sm_set_backend(void) { sm_globals.options.backend = 1; } void sm_backend_exec_cmd(const char *commandline) { sm_execcommand(&sm_globals, commandline); fflush(stdout); fflush(stderr); } long sm_get_num_matches(void) { return sm_globals.num_matches; } const char *sm_get_version(void) { return PACKAGE_VERSION; } double sm_get_scan_progress(void) { return sm_globals.scan_progress; } void sm_reset_scan_progress(void) { sm_globals.scan_progress = 0; } scanmem-0.16/scanmem.h000066400000000000000000000104651302526536600146750ustar00rootroot00000000000000/* Provide interfaces for front-ends. Copyright (C) 2006,2007,2009 Tavis Ormandy Copyright (C) 2009 Eli Dupree Copyright (C) 2009-2013 WANG Lu Copyright (C) 2016 Sebastian Parschauer This file is part of libscanmem. This library is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this library. If not, see . */ #ifndef SCANMEM_H #define SCANMEM_H #include #include #include #include #include "scanroutines.h" #include "list.h" #include "value.h" #include "targetmem.h" #ifndef PACKAGE_VERSION #define PACKAGE_VERSION "(unknown)" #endif /* from string.h in glibc for Android/BSD */ #ifndef strdupa #define strdupa(s) \ ({ \ const char *__old = (s); \ size_t __len = strlen(__old) + 1; \ char *__new = (char *) alloca(__len); \ (char *) memcpy(__new, __old, __len); \ }) #endif #ifndef strndupa #define strndupa(s, n) \ ({ \ const char *__old = (s); \ size_t __len = strnlen(__old, (n)); \ char *__new = (char *) alloca(__len + 1); \ __new[__len] = '\0'; \ (char *) memcpy(__new, __old, __len); \ }) #endif #ifndef MIN #define MIN(a,b) ((a) < (b) ? (a) : (b)) #endif /* global settings */ typedef struct { unsigned exit:1; pid_t target; matches_and_old_values_array *matches; long num_matches; double scan_progress; list_t *regions; list_t *commands; /* command handlers */ const char *current_cmdline; /* the command being executed */ void (*printversion)(FILE *outfd); struct { unsigned short alignment; unsigned short debug; unsigned short backend; /* if 1, scanmem will work as a backend and output would be more machine-readable */ /* options that can be changed during runtime */ scan_data_type_t scan_data_type; region_scan_level_t region_scan_level; unsigned short detect_reverse_change; unsigned short dump_with_ascii; unsigned short reverse_endianness; } options; } globals_t; /* global settings */ extern globals_t sm_globals; bool sm_init(void); void sm_printversion(FILE *outfd); void sm_set_backend(void); void sm_backend_exec_cmd(const char *commandline); long sm_get_num_matches(void); const char *sm_get_version(void); double sm_get_scan_progress(void); void sm_reset_scan_progress(void); /* ptrace.c */ bool sm_detach(pid_t target); bool sm_setaddr(pid_t target, void *addr, const value_t *to); bool sm_checkmatches(globals_t *vars, scan_match_type_t match_type, const uservalue_t *uservalue); bool sm_searchregions(globals_t *vars, scan_match_type_t match_type, const uservalue_t *uservalue); bool sm_peekdata(pid_t pid, void *addr, value_t *result); bool sm_attach(pid_t target); bool sm_read_array(pid_t target, void *addr, char *buf, int len); bool sm_write_array(pid_t target, void *addr, const void *data, int len); /* menu.c */ bool sm_getcommand(globals_t *vars, char **line); #endif /* SCANMEM_H */ scanmem-0.16/scanroutines.c000066400000000000000000000475551302526536600157740ustar00rootroot00000000000000/* Routines of scanning for different data types. Copyright (C) 2009,2010 WANG Lu This file is part of libscanmem. This library is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this library. If not, see . */ #include "config.h" #include #include "scanroutines.h" #include "value.h" #include "scanmem.h" /* for convenience */ #define SCAN_ROUTINE_ARGUMENTS (const value_t *new_value, const value_t *old_value, const uservalue_t *user_value, match_flags *saveflags, void *address) int (*sm_scan_routine) SCAN_ROUTINE_ARGUMENTS; #define VALUE_COMP(a,b,field,op) (((a)->flags.field && (b)->flags.field) && (get_##field(a) op get_##field(b))) #define VALUE_COPY(a,b,field) ((set_##field(a, get_##field(b))), ((a)->flags.field = 1)) #define SET_FLAG(f, field) ((f)->field = 1) /********************/ /* Integer specific */ /********************/ /* for MATCHANY */ #define DEFINE_INTEGER_MATCHANY_ROUTINE(DATATYPENAME, DATAWIDTH) \ int scan_routine_##DATATYPENAME##_ANY SCAN_ROUTINE_ARGUMENTS \ { \ int ret = 0; \ if ((new_value)->flags.s##DATAWIDTH##b) { ret = (DATAWIDTH)/8; SET_FLAG(saveflags, s##DATAWIDTH##b); } \ if ((new_value)->flags.u##DATAWIDTH##b) { ret = (DATAWIDTH)/8; SET_FLAG(saveflags, u##DATAWIDTH##b); } \ return ret; \ } DEFINE_INTEGER_MATCHANY_ROUTINE(INTEGER8, 8) DEFINE_INTEGER_MATCHANY_ROUTINE(INTEGER16, 16) DEFINE_INTEGER_MATCHANY_ROUTINE(INTEGER32, 32) DEFINE_INTEGER_MATCHANY_ROUTINE(INTEGER64, 64) #define DEFINE_INTEGER_ROUTINE(DATATYPENAME, DATAWIDTH, MATCHTYPENAME, MATCHTYPE, VALUE_TO_COMPARE_WITH) \ int scan_routine_##DATATYPENAME##_##MATCHTYPENAME SCAN_ROUTINE_ARGUMENTS \ { \ assert(VALUE_TO_COMPARE_WITH); \ int ret = 0; \ if(VALUE_COMP(new_value, VALUE_TO_COMPARE_WITH, s##DATAWIDTH##b, MATCHTYPE)) { \ SET_FLAG(saveflags, s##DATAWIDTH##b); \ ret = (DATAWIDTH)/8; \ } \ if(VALUE_COMP(new_value, VALUE_TO_COMPARE_WITH, u##DATAWIDTH##b, MATCHTYPE)) { \ SET_FLAG(saveflags, u##DATAWIDTH##b); \ ret = (DATAWIDTH)/8; \ } \ return ret; \ } #define DEFINE_INTEGER_ROUTINE_FOR_ALL_INTEGER_TYPE(MATCHTYPENAME, MATCHTYPE, VALUE_TO_COMPARE_WITH) \ DEFINE_INTEGER_ROUTINE(INTEGER8, 8, MATCHTYPENAME, MATCHTYPE, VALUE_TO_COMPARE_WITH) \ DEFINE_INTEGER_ROUTINE(INTEGER16, 16, MATCHTYPENAME, MATCHTYPE, VALUE_TO_COMPARE_WITH) \ DEFINE_INTEGER_ROUTINE(INTEGER32, 32, MATCHTYPENAME, MATCHTYPE, VALUE_TO_COMPARE_WITH) \ DEFINE_INTEGER_ROUTINE(INTEGER64, 64, MATCHTYPENAME, MATCHTYPE, VALUE_TO_COMPARE_WITH) DEFINE_INTEGER_ROUTINE_FOR_ALL_INTEGER_TYPE(EQUALTO, ==, user_value) DEFINE_INTEGER_ROUTINE_FOR_ALL_INTEGER_TYPE(NOTEQUALTO, !=, user_value) DEFINE_INTEGER_ROUTINE_FOR_ALL_INTEGER_TYPE(GREATERTHAN, >, user_value) DEFINE_INTEGER_ROUTINE_FOR_ALL_INTEGER_TYPE(LESSTHAN, <, user_value) DEFINE_INTEGER_ROUTINE_FOR_ALL_INTEGER_TYPE(NOTCHANGED, ==, old_value) DEFINE_INTEGER_ROUTINE_FOR_ALL_INTEGER_TYPE(CHANGED, !=, old_value) DEFINE_INTEGER_ROUTINE_FOR_ALL_INTEGER_TYPE(INCREASED, >, old_value) DEFINE_INTEGER_ROUTINE_FOR_ALL_INTEGER_TYPE(DECREASED, <, old_value) /******************/ /* Float specific */ /******************/ /* for MATCHANY */ #define DEFINE_FLOAT_MATCHANY_ROUTINE(DATATYPENAME, DATAWIDTH) \ int scan_routine_##DATATYPENAME##_ANY SCAN_ROUTINE_ARGUMENTS \ { \ int ret = 0; \ if ((new_value)->flags.f##DATAWIDTH##b) { ret = (DATAWIDTH)/8; SET_FLAG(saveflags, f##DATAWIDTH##b); } \ return ret; \ } DEFINE_FLOAT_MATCHANY_ROUTINE(FLOAT32, 32) DEFINE_FLOAT_MATCHANY_ROUTINE(FLOAT64, 64) #define DEFINE_FLOAT_ROUTINE(DATATYPENAME, DATAWIDTH, MATCHTYPENAME, MATCHTYPE, VALUE_TO_COMPARE_WITH) \ int scan_routine_##DATATYPENAME##_##MATCHTYPENAME SCAN_ROUTINE_ARGUMENTS \ { \ assert(VALUE_TO_COMPARE_WITH); \ int ret = 0; \ if(VALUE_COMP(new_value, VALUE_TO_COMPARE_WITH, f##DATAWIDTH##b, MATCHTYPE)) { \ SET_FLAG(saveflags, f##DATAWIDTH##b); \ ret = (DATAWIDTH)/8; \ } \ return ret; \ } \ #define DEFINE_FLOAT_ROUTINE_FOR_ALL_FLOAT_TYPE(MATCHTYPENAME, MATCHTYPE, VALUE_TO_COMPARE_WITH) \ DEFINE_FLOAT_ROUTINE(FLOAT32, 32, MATCHTYPENAME, MATCHTYPE, VALUE_TO_COMPARE_WITH) \ DEFINE_FLOAT_ROUTINE(FLOAT64, 64, MATCHTYPENAME, MATCHTYPE, VALUE_TO_COMPARE_WITH) DEFINE_FLOAT_ROUTINE_FOR_ALL_FLOAT_TYPE(NOTEQUALTO, !=, user_value) /* TODO: this should be consistent with !EQUALTO */ DEFINE_FLOAT_ROUTINE_FOR_ALL_FLOAT_TYPE(NOTCHANGED, ==, old_value) /* this is bad */ DEFINE_FLOAT_ROUTINE_FOR_ALL_FLOAT_TYPE(CHANGED, !=, old_value) /* this is bad, but better than above */ DEFINE_FLOAT_ROUTINE_FOR_ALL_FLOAT_TYPE(INCREASED, >, old_value) DEFINE_FLOAT_ROUTINE_FOR_ALL_FLOAT_TYPE(DECREASED, <, old_value) DEFINE_FLOAT_ROUTINE_FOR_ALL_FLOAT_TYPE(GREATERTHAN, >, user_value) DEFINE_FLOAT_ROUTINE_FOR_ALL_FLOAT_TYPE(LESSTHAN, <, user_value) /********************/ /* Special routines */ /********************/ /*-----------------------------------*/ /* special EQUALTO for float numbers */ /*-----------------------------------*/ #define DEFINE_FLOAT_EQUALTO_ROUTINE(FLOATTYPENAME, WIDTH) \ int scan_routine_##FLOATTYPENAME##_EQUALTO SCAN_ROUTINE_ARGUMENTS \ { \ int ret = 0; \ if ((new_value->flags.f##WIDTH##b) && (user_value->flags.f##WIDTH##b) \ && (get_f##WIDTH##b(new_value) == get_f##WIDTH##b(user_value))) \ { \ SET_FLAG(saveflags, f##WIDTH##b); \ ret = (WIDTH)/8; \ } \ return ret; \ } DEFINE_FLOAT_EQUALTO_ROUTINE(FLOAT32, 32) DEFINE_FLOAT_EQUALTO_ROUTINE(FLOAT64, 64) /*-----------------------------*/ /* for reverse changing detect */ /*-----------------------------*/ #define DEFINE_ROUTINE_WITH_REVERSE_DETECT(DATATYPENAME, DATAWIDTH, MATCHTYPENAME, REVERSEMATCHTYPENAME) \ int scan_routine_##DATATYPENAME##_##MATCHTYPENAME##_WITH_REVERSE SCAN_ROUTINE_ARGUMENTS \ { \ int ret = 0; \ if ((new_value->flags.ineq_forwards) && scan_routine_##DATATYPENAME##_##MATCHTYPENAME (new_value, old_value, user_value, saveflags, address)) { ret = (DATAWIDTH)/8; SET_FLAG(saveflags, ineq_forwards); } \ if ((new_value->flags.ineq_reverse) && scan_routine_##DATATYPENAME##_##REVERSEMATCHTYPENAME (new_value, old_value, user_value, saveflags, address)) { ret = (DATAWIDTH)/8; SET_FLAG(saveflags, ineq_reverse); } \ return ret; \ } #define DEFINE_ROUTINE_WITH_REVERSE_DETECT_FOR_DATATYPE(DATATYPENAME, DATAWIDTH) \ DEFINE_ROUTINE_WITH_REVERSE_DETECT(DATATYPENAME, DATAWIDTH, INCREASED, DECREASED) \ DEFINE_ROUTINE_WITH_REVERSE_DETECT(DATATYPENAME, DATAWIDTH, DECREASED, INCREASED) DEFINE_ROUTINE_WITH_REVERSE_DETECT_FOR_DATATYPE(INTEGER8, 8) DEFINE_ROUTINE_WITH_REVERSE_DETECT_FOR_DATATYPE(INTEGER16, 16) DEFINE_ROUTINE_WITH_REVERSE_DETECT_FOR_DATATYPE(INTEGER32, 32) DEFINE_ROUTINE_WITH_REVERSE_DETECT_FOR_DATATYPE(INTEGER64, 64) DEFINE_ROUTINE_WITH_REVERSE_DETECT_FOR_DATATYPE(FLOAT32, 32) DEFINE_ROUTINE_WITH_REVERSE_DETECT_FOR_DATATYPE(FLOAT64, 64) /*---------------------------------*/ /* for INCREASEDBY and DECREASEDBY */ /*---------------------------------*/ #define DEFINE_INTEGER_INCREASEDBY_DECREASEDBY_ROUTINE(DATATYPENAME, DATAWIDTH) \ int scan_routine_##DATATYPENAME##_INCREASEDBY SCAN_ROUTINE_ARGUMENTS \ { \ int ret = 0; \ if ((new_value->flags.s##DATAWIDTH##b) && (old_value->flags.s##DATAWIDTH##b) && (user_value->flags.s##DATAWIDTH##b) \ && (get_s##DATAWIDTH##b(new_value) == get_s##DATAWIDTH##b(old_value) + get_s##DATAWIDTH##b(user_value))) \ { ret = (DATAWIDTH)/8; SET_FLAG(saveflags, s##DATAWIDTH##b); } \ if ((new_value->flags.u##DATAWIDTH##b) && (old_value->flags.u##DATAWIDTH##b) && (user_value->flags.u##DATAWIDTH##b) \ && (get_u##DATAWIDTH##b(new_value) == get_u##DATAWIDTH##b(old_value) + get_u##DATAWIDTH##b(user_value))) \ { ret = (DATAWIDTH)/8; SET_FLAG(saveflags, u##DATAWIDTH##b); } \ return ret; \ } \ int scan_routine_##DATATYPENAME##_DECREASEDBY SCAN_ROUTINE_ARGUMENTS \ { \ int ret = 0; \ if ((new_value->flags.s##DATAWIDTH##b) && (old_value->flags.s##DATAWIDTH##b) && (user_value->flags.s##DATAWIDTH##b) \ && (get_s##DATAWIDTH##b(new_value) == get_s##DATAWIDTH##b(old_value) - get_s##DATAWIDTH##b(user_value))) \ { ret = (DATAWIDTH)/8; SET_FLAG(saveflags, s##DATAWIDTH##b); } \ if ((new_value->flags.u##DATAWIDTH##b) && (old_value->flags.u##DATAWIDTH##b) && (user_value->flags.u##DATAWIDTH##b) \ && (get_u##DATAWIDTH##b(new_value) == get_u##DATAWIDTH##b(old_value) - get_u##DATAWIDTH##b(user_value))) \ { ret = (DATAWIDTH)/8; SET_FLAG(saveflags, u##DATAWIDTH##b); } \ return ret; \ } DEFINE_INTEGER_INCREASEDBY_DECREASEDBY_ROUTINE(INTEGER8, 8) DEFINE_INTEGER_INCREASEDBY_DECREASEDBY_ROUTINE(INTEGER16, 16) DEFINE_INTEGER_INCREASEDBY_DECREASEDBY_ROUTINE(INTEGER32, 32) DEFINE_INTEGER_INCREASEDBY_DECREASEDBY_ROUTINE(INTEGER64, 64) #define DEFINE_FLOAT_INCREASEDBY_DECREASEDBY_ROUTINE(DATATYPENAME, DATAWIDTH) \ int scan_routine_##DATATYPENAME##_INCREASEDBY SCAN_ROUTINE_ARGUMENTS \ { \ int ret = 0; \ if ((new_value->flags.f##DATAWIDTH##b) && (old_value->flags.f##DATAWIDTH##b) && (user_value->flags.f##DATAWIDTH##b) \ && (get_f##DATAWIDTH##b(new_value) == get_f##DATAWIDTH##b(old_value) + get_f##DATAWIDTH##b(user_value))) \ { ret = (DATAWIDTH)/8; SET_FLAG(saveflags, f##DATAWIDTH##b); } \ return ret; \ } \ int scan_routine_##DATATYPENAME##_DECREASEDBY SCAN_ROUTINE_ARGUMENTS \ { \ int ret = 0; \ if ((new_value->flags.f##DATAWIDTH##b) && (old_value->flags.f##DATAWIDTH##b) && (user_value->flags.f##DATAWIDTH##b) \ && (get_f##DATAWIDTH##b(new_value) == get_f##DATAWIDTH##b(old_value) - get_f##DATAWIDTH##b(user_value))) \ { ret = (DATAWIDTH)/8; SET_FLAG(saveflags, f##DATAWIDTH##b); } \ return ret; \ } DEFINE_FLOAT_INCREASEDBY_DECREASEDBY_ROUTINE(FLOAT32, 32) DEFINE_FLOAT_INCREASEDBY_DECREASEDBY_ROUTINE(FLOAT64, 64) /*-----------*/ /* for RANGE */ /*-----------*/ #define DEFINE_INTEGER_RANGE_ROUTINE(DATATYPENAME, DATAWIDTH) \ int scan_routine_##DATATYPENAME##_RANGE SCAN_ROUTINE_ARGUMENTS \ { \ int ret = 0; \ if ((new_value->flags.s##DATAWIDTH##b) \ && (user_value[0].flags.s##DATAWIDTH##b) && (user_value[1].flags.s##DATAWIDTH##b) \ && (get_s##DATAWIDTH##b(new_value) >= get_s##DATAWIDTH##b(&user_value[0])) \ && (get_s##DATAWIDTH##b(new_value) <= get_s##DATAWIDTH##b(&user_value[1]))) \ { ret = (DATAWIDTH)/8; SET_FLAG(saveflags, s##DATAWIDTH##b); } \ if ((new_value->flags.u##DATAWIDTH##b) \ && (user_value[0].flags.u##DATAWIDTH##b) && (user_value[1].flags.u##DATAWIDTH##b) \ && (get_u##DATAWIDTH##b(new_value) >= get_u##DATAWIDTH##b(&user_value[0])) \ && (get_u##DATAWIDTH##b(new_value) <= get_u##DATAWIDTH##b(&user_value[1]))) \ { ret = (DATAWIDTH)/8; SET_FLAG(saveflags, u##DATAWIDTH##b); } \ return ret; \ } DEFINE_INTEGER_RANGE_ROUTINE(INTEGER8, 8) DEFINE_INTEGER_RANGE_ROUTINE(INTEGER16, 16) DEFINE_INTEGER_RANGE_ROUTINE(INTEGER32, 32) DEFINE_INTEGER_RANGE_ROUTINE(INTEGER64, 64) #define DEFINE_FLOAT_RANGE_ROUTINE(DATATYPENAME, DATAWIDTH) \ int scan_routine_##DATATYPENAME##_RANGE SCAN_ROUTINE_ARGUMENTS \ { \ int ret = 0; \ if ((new_value->flags.f##DATAWIDTH##b) \ && (user_value[0].flags.f##DATAWIDTH##b) && (user_value[1].flags.f##DATAWIDTH##b) \ && (get_f##DATAWIDTH##b(new_value) >= get_f##DATAWIDTH##b(&user_value[0])) \ && (get_f##DATAWIDTH##b(new_value) <= get_f##DATAWIDTH##b(&user_value[1]))) \ { ret = (DATAWIDTH)/8; SET_FLAG(saveflags, f##DATAWIDTH##b); } \ return ret; \ } DEFINE_FLOAT_RANGE_ROUTINE(FLOAT32, 32) DEFINE_FLOAT_RANGE_ROUTINE(FLOAT64, 64) /*---------------*/ /* for BYTEARRAY */ /*---------------*/ int scan_routine_BYTEARRAY_ANY SCAN_ROUTINE_ARGUMENTS { return saveflags->bytearray_length = ((old_value)->flags.bytearray_length); } int scan_routine_BYTEARRAY_EQUALTO SCAN_ROUTINE_ARGUMENTS { bytearray_element_t *array = user_value->bytearray_value; int length = user_value->flags.bytearray_length; int cur_idx = 0; int i, j; value_t val_buf = *new_value; for(i = 0; i + sizeof(int64_t) < length; i += sizeof(int64_t)) { /* match current block */ for(j = 0; j < sizeof(int64_t); ++j) { if( (array[cur_idx].is_wildcard == 1) || (array[cur_idx].byte == val_buf.bytes[j])) { /* pass */ } else { /* not matched */ return 0; } ++ cur_idx; } /* read next block */ if (!sm_peekdata(sm_globals.target, address+i+sizeof(int64_t), &val_buf)) { /* cannot read */ return 0; } } /* match bytes left */ for(j = 0; j < length - i; ++j) { if( (array[cur_idx].is_wildcard == 1) || (array[cur_idx].byte == val_buf.bytes[j])) { /* pass */ } else { /* not matched */ return 0; } ++ cur_idx; } /* matched */ saveflags->bytearray_length = length; return length; } /*------------*/ /* for STRING */ /*------------*/ int scan_routine_STRING_ANY SCAN_ROUTINE_ARGUMENTS { return saveflags->string_length = ((old_value)->flags.string_length); } int scan_routine_STRING_EQUALTO SCAN_ROUTINE_ARGUMENTS { const char *scan_string = user_value->string_value; int length = user_value->flags.string_length; int i, j; value_t val_buf = *new_value; for(i = 0; i + sizeof(int64_t) < length; i += sizeof(int64_t)) { if(val_buf.int64_value != *((int64_t*)(scan_string+i))) { /* not matched */ return 0; } /* read next block */ if (!sm_peekdata(sm_globals.target, address + i + sizeof(int64_t), &val_buf)) { /* cannot read */ return 0; } } /* match bytes left */ for(j = 0; j < length - i; ++j) { if(val_buf.bytes[j] != *(scan_string+i+j)) { /* not matched */ return 0; } } /* matched */ saveflags->string_length = length; return length; } /*-------------------------*/ /* Any-xxx types specifiec */ /*-------------------------*/ /* this is for anynumber, anyinteger, anyfloat */ #define DEFINE_ANYTYPE_ROUTINE(MATCHTYPENAME) \ int scan_routine_ANYINTEGER_##MATCHTYPENAME SCAN_ROUTINE_ARGUMENTS \ { \ int ret = 0, tmp_ret;\ if ((tmp_ret = scan_routine_INTEGER8_##MATCHTYPENAME (new_value, old_value, user_value, saveflags, address)) > ret) { ret = tmp_ret; } \ if ((tmp_ret = scan_routine_INTEGER16_##MATCHTYPENAME (new_value, old_value, user_value, saveflags, address)) > ret) { ret = tmp_ret; } \ if ((tmp_ret = scan_routine_INTEGER32_##MATCHTYPENAME (new_value, old_value, user_value, saveflags, address)) > ret) { ret = tmp_ret; } \ if ((tmp_ret = scan_routine_INTEGER64_##MATCHTYPENAME (new_value, old_value, user_value, saveflags, address)) > ret) { ret = tmp_ret; } \ return ret; \ } \ int scan_routine_ANYFLOAT_##MATCHTYPENAME SCAN_ROUTINE_ARGUMENTS \ { \ int ret = 0, tmp_ret; \ if ((tmp_ret = scan_routine_FLOAT32_##MATCHTYPENAME (new_value, old_value, user_value, saveflags, address)) > ret) { ret = tmp_ret; } \ if ((tmp_ret = scan_routine_FLOAT64_##MATCHTYPENAME (new_value, old_value, user_value, saveflags, address)) > ret) { ret = tmp_ret; } \ return ret; \ } \ int scan_routine_ANYNUMBER_##MATCHTYPENAME SCAN_ROUTINE_ARGUMENTS \ { \ int ret1 = scan_routine_ANYINTEGER_##MATCHTYPENAME (new_value, old_value, user_value, saveflags, address); \ int ret2 = scan_routine_ANYFLOAT_##MATCHTYPENAME (new_value, old_value, user_value, saveflags, address); \ return (ret1 > ret2 ? ret1 : ret2); \ } \ DEFINE_ANYTYPE_ROUTINE(ANY) DEFINE_ANYTYPE_ROUTINE(EQUALTO) DEFINE_ANYTYPE_ROUTINE(NOTEQUALTO) DEFINE_ANYTYPE_ROUTINE(CHANGED) DEFINE_ANYTYPE_ROUTINE(NOTCHANGED) DEFINE_ANYTYPE_ROUTINE(INCREASED) DEFINE_ANYTYPE_ROUTINE(DECREASED) DEFINE_ANYTYPE_ROUTINE(GREATERTHAN) DEFINE_ANYTYPE_ROUTINE(LESSTHAN) DEFINE_ANYTYPE_ROUTINE(INCREASED_WITH_REVERSE) DEFINE_ANYTYPE_ROUTINE(DECREASED_WITH_REVERSE) DEFINE_ANYTYPE_ROUTINE(INCREASEDBY) DEFINE_ANYTYPE_ROUTINE(DECREASEDBY) DEFINE_ANYTYPE_ROUTINE(RANGE) /***************************************************************/ /* choose a routine according to scan_data_type and match_type */ /***************************************************************/ #define CHOOSE_ROUTINE(SCANDATATYPE, ROUTINEDATATYPENAME, SCANMATCHTYPE, ROUTINEMATCHTYPENAME) \ if ((dt == SCANDATATYPE) && (mt == SCANMATCHTYPE)) \ { \ return &scan_routine_##ROUTINEDATATYPENAME##_##ROUTINEMATCHTYPENAME; \ } #define CHOOSE_ROUTINE_FOR_ALL_NUMBER_TYPES(SCANMATCHTYPE, ROUTINEMATCHTYPENAME) \ CHOOSE_ROUTINE(INTEGER8, INTEGER8, SCANMATCHTYPE, ROUTINEMATCHTYPENAME) \ CHOOSE_ROUTINE(INTEGER16, INTEGER16, SCANMATCHTYPE, ROUTINEMATCHTYPENAME) \ CHOOSE_ROUTINE(INTEGER32, INTEGER32, SCANMATCHTYPE, ROUTINEMATCHTYPENAME) \ CHOOSE_ROUTINE(INTEGER64, INTEGER64, SCANMATCHTYPE, ROUTINEMATCHTYPENAME) \ CHOOSE_ROUTINE(FLOAT32, FLOAT32, SCANMATCHTYPE, ROUTINEMATCHTYPENAME) \ CHOOSE_ROUTINE(FLOAT64, FLOAT64, SCANMATCHTYPE, ROUTINEMATCHTYPENAME) \ CHOOSE_ROUTINE(ANYINTEGER, ANYINTEGER, SCANMATCHTYPE, ROUTINEMATCHTYPENAME) \ CHOOSE_ROUTINE(ANYFLOAT, ANYFLOAT, SCANMATCHTYPE, ROUTINEMATCHTYPENAME) \ CHOOSE_ROUTINE(ANYNUMBER, ANYNUMBER, SCANMATCHTYPE, ROUTINEMATCHTYPENAME) \ bool sm_choose_scanroutine(scan_data_type_t dt, scan_match_type_t mt) { return (sm_scan_routine = sm_get_scanroutine(dt, mt)) != NULL; } scan_routine_t sm_get_scanroutine(scan_data_type_t dt, scan_match_type_t mt) { if (sm_globals.options.detect_reverse_change) { CHOOSE_ROUTINE_FOR_ALL_NUMBER_TYPES(MATCHINCREASED, INCREASED_WITH_REVERSE) CHOOSE_ROUTINE_FOR_ALL_NUMBER_TYPES(MATCHDECREASED, DECREASED_WITH_REVERSE) } CHOOSE_ROUTINE_FOR_ALL_NUMBER_TYPES(MATCHANY, ANY) CHOOSE_ROUTINE_FOR_ALL_NUMBER_TYPES(MATCHEQUALTO, EQUALTO) CHOOSE_ROUTINE_FOR_ALL_NUMBER_TYPES(MATCHNOTEQUALTO, NOTEQUALTO) CHOOSE_ROUTINE_FOR_ALL_NUMBER_TYPES(MATCHCHANGED, CHANGED) CHOOSE_ROUTINE_FOR_ALL_NUMBER_TYPES(MATCHNOTCHANGED, NOTCHANGED) CHOOSE_ROUTINE_FOR_ALL_NUMBER_TYPES(MATCHINCREASED, INCREASED) CHOOSE_ROUTINE_FOR_ALL_NUMBER_TYPES(MATCHDECREASED, DECREASED) CHOOSE_ROUTINE_FOR_ALL_NUMBER_TYPES(MATCHINCREASEDBY, INCREASEDBY) CHOOSE_ROUTINE_FOR_ALL_NUMBER_TYPES(MATCHDECREASEDBY, DECREASEDBY) CHOOSE_ROUTINE_FOR_ALL_NUMBER_TYPES(MATCHGREATERTHAN, GREATERTHAN) CHOOSE_ROUTINE_FOR_ALL_NUMBER_TYPES(MATCHLESSTHAN, LESSTHAN) CHOOSE_ROUTINE_FOR_ALL_NUMBER_TYPES(MATCHRANGE, RANGE) CHOOSE_ROUTINE(BYTEARRAY, BYTEARRAY, MATCHEQUALTO, EQUALTO) CHOOSE_ROUTINE(STRING, STRING, MATCHEQUALTO, EQUALTO) return NULL; } scanmem-0.16/scanroutines.h000066400000000000000000000052661302526536600157720ustar00rootroot00000000000000/* Definition of routines of scanning for different data types. Copyright (C) 2009,2010 WANG Lu Copyright (C) 2015 Vyacheslav Shegai This file is part of libscanmem. This library is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this library. If not, see . */ #ifndef SCANROUTINES_H #define SCANROUTINES_H #include #include "value.h" typedef enum { ANYNUMBER, /* ANYINTEGER or ANYFLOAT */ ANYINTEGER, /* INTEGER of whatever width */ ANYFLOAT, /* FLOAT of whatever width */ INTEGER8, INTEGER16, INTEGER32, INTEGER64, FLOAT32, FLOAT64, BYTEARRAY, STRING } scan_data_type_t; typedef enum { MATCHANY, /* to update */ /* following: compare with a given value */ MATCHEQUALTO, MATCHNOTEQUALTO, MATCHGREATERTHAN, MATCHLESSTHAN, MATCHRANGE, /* following: compare with the old value */ MATCHNOTCHANGED, MATCHCHANGED, MATCHINCREASED, MATCHDECREASED, /* folowing: compare with both given value and old value */ MATCHINCREASEDBY, MATCHDECREASEDBY } scan_match_type_t; /* match old_value against new_value or user_value (or both, depending on the matching type, store the result into save */ /* NOTE: saveflag must be set to 0, since only useful bits are set, but extra bits are not cleared! */ /* address is pointing to new_value in TARGET PROCESS MEMORY SPACE, used when searching for a byte array */ /* return the number of bytes needed to store old_value, 0 for not matched */ typedef int (*scan_routine_t)(const value_t *new_value, const value_t *old_value, const uservalue_t *user_value, match_flags *saveflag, void *address); extern scan_routine_t sm_scan_routine; /* * choose the global scanroutine according to the given parameters, g_scan_routine will be set * return whether a proper routine has been found */ bool sm_choose_scanroutine(scan_data_type_t dt, scan_match_type_t mt); scan_routine_t sm_get_scanroutine(scan_data_type_t dt, scan_match_type_t mt); #endif /* SCANROUTINES_H */ scanmem-0.16/show_message.c000066400000000000000000000036571302526536600157360ustar00rootroot00000000000000/* Message printing helper functions. Copyright (C) 2010 WANG Lu This file is part of libscanmem. This library is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this library. If not, see . */ #include "config.h" #include #include #include "show_message.h" #include "scanmem.h" void show_info(const char *fmt, ...) { va_list args; va_start (args, fmt); fprintf(stderr, "info: "); vfprintf(stderr, fmt, args); va_end (args); } void show_error(const char *fmt, ...) { va_list args; va_start (args, fmt); fprintf(stderr, "error: "); vfprintf(stderr, fmt, args); va_end (args); } void show_warn(const char *fmt, ...) { va_list args; va_start (args, fmt); fprintf(stderr, "warn: "); vfprintf(stderr, fmt, args); va_end (args); } void show_user(const char *fmt, ...) { va_list args; va_start (args, fmt); if (!(sm_globals.options.backend)) { vfprintf(stderr, fmt, args); } va_end (args); } void show_debug(const char *fmt, ...) { va_list args; va_start (args, fmt); if (sm_globals.options.debug) { fprintf(stderr, "debug: "); vfprintf(stderr, fmt, args); } va_end (args); } void show_scan_progress(unsigned long cur, unsigned long total) { fprintf(stderr, "."); fflush(stderr); } scanmem-0.16/show_message.h000066400000000000000000000040421302526536600157300ustar00rootroot00000000000000/* Message printing helper functions. Copyright (C) 2010 WANG Lu This file is part of libscanmem. This library is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this library. If not, see . */ /* * This file declares all types of output functions, in order to provide well-formatted messages that a front-end can understand * * Basically, all data go through stdout, and all message (to user or to front-end) go through stderr * * In stderr: * all messages prefixed with 'error:' will be considered fatal error, front-end may notify user to re-start backend * all messages prefixed with 'warn:' will be considered nonfatal error * all messages prefixed with 'info:' will be ignored (by the front-end) * * To display message to user only, use show_user, nothing will be prepended, and the message will be ignore if scanmem is running as a backend */ #ifndef SHOW_MESSAGE_H #define SHOW_MESSAGE_H /* prepend 'info: ', output to stderr */ void show_info(const char *fmt, ...); /* prepend 'error: ', output to stderr */ void show_error(const char *fmt, ...); /* prepend 'warn: ', output to stderr */ void show_warn(const char *fmt, ...); /* display message only when in debug mode */ void show_debug(const char *fmt, ...); /* display message only when not running as a backend */ void show_user(const char *fmt, ...); /* display progress of scan */ void show_scan_progress(unsigned long cur, unsigned long total); #endif /* SHOW_MESSAGE_H */ scanmem-0.16/targetmem.c000066400000000000000000000167511302526536600152360ustar00rootroot00000000000000/* The target memory information array (storage of matches). Copyright (C) 2009 Eli Dupree Copyright (C) 2010 WANG Lu This file is part of libscanmem. This library is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this library. If not, see . */ #include "config.h" #include #include #include #include #include #include #include "targetmem.h" #include "show_message.h" matches_and_old_values_array * allocate_array (matches_and_old_values_array *array, unsigned long max_bytes) { /* Make enough space for the array header and a null first swath. */ unsigned long bytes_to_allocate = sizeof(matches_and_old_values_array) + sizeof(matches_and_old_values_swath); if (!(array = realloc(array, bytes_to_allocate))) return NULL; array->bytes_allocated = bytes_to_allocate; array->max_needed_bytes = max_bytes; return array; } matches_and_old_values_array * null_terminate (matches_and_old_values_array *array, matches_and_old_values_swath *swath) { unsigned long bytes_needed; if (swath->number_of_bytes == 0) { assert(swath->first_byte_in_child == NULL); } else { swath = local_address_beyond_last_element(swath ); array = allocate_enough_to_reach(array, ((void *)swath) + sizeof(matches_and_old_values_swath), &swath); swath->first_byte_in_child = NULL; swath->number_of_bytes = 0; } bytes_needed = ((void *)swath + sizeof(matches_and_old_values_swath) - (void *)array); if (bytes_needed < array->bytes_allocated) { /* Reduce array to its final size */ if (!(array = realloc(array, bytes_needed))) return NULL; array->bytes_allocated = bytes_needed; } return array; } void data_to_printable_string (char *buf, int buf_length, matches_and_old_values_swath *swath, long index, int string_length) { long swath_length = swath->number_of_bytes - index; /* TODO: what if length is too large ? */ long max_length = (swath_length >= string_length) ? string_length : swath_length; int i; for (i = 0; i < max_length; ++i) { uint8_t byte; byte = ((matches_and_old_values_swath *)swath)->data[index+i].old_value; buf[i] = isprint(byte) ? byte : '.'; } buf[i] = 0; /* null-terminate */ } void data_to_bytearray_text (char *buf, int buf_length, matches_and_old_values_swath *swath, long index, int bytearray_length) { int i; int bytes_used = 0; long swath_length = swath->number_of_bytes - index; /* TODO: what if length is too large ? */ long max_length = (swath_length >= bytearray_length) ? bytearray_length : swath_length; for (i = 0; i < max_length; ++i) { uint8_t byte; byte = ((matches_and_old_values_swath *)swath)->data[index+i].old_value; /* TODO: check error here */ snprintf(buf+bytes_used, buf_length-bytes_used, (iswaths; int reading_iterator = 0; if (!matches) return (match_location){NULL, 0}; while (reading_swath_index->first_byte_in_child) { /* Only actual matches are considered */ if (flags_to_max_width_in_bytes( reading_swath_index->data[reading_iterator].match_info) > 0) { if (i == n) return (match_location){reading_swath_index, reading_iterator}; ++i; } /* Go on to the next one... */ ++reading_iterator; if (reading_iterator >= reading_swath_index->number_of_bytes) { reading_swath_index = local_address_beyond_last_element( (matches_and_old_values_swath *)reading_swath_index); reading_iterator = 0; } } /* I guess this is not a valid match-id */ return (match_location){ NULL, 0 }; } matches_and_old_values_array * delete_by_region (matches_and_old_values_array *matches, long *num_matches, region_t *which, bool invert) { int reading_iterator = 0; matches_and_old_values_swath *reading_swath_index = (matches_and_old_values_swath *)matches->swaths; matches_and_old_values_swath reading_swath = *reading_swath_index; matches_and_old_values_swath *writing_swath_index = (matches_and_old_values_swath *)matches->swaths; writing_swath_index->first_byte_in_child = NULL; writing_swath_index->number_of_bytes = 0; *num_matches = 0; while (reading_swath.first_byte_in_child) { void *address = reading_swath.first_byte_in_child + reading_iterator; bool in_region = (address >= which->start && address < which->start + which->size); if ((in_region && invert) || (!in_region && !invert)) { match_flags flags; flags = reading_swath_index->data[reading_iterator].match_info; /* Still a candidate. Write data. (We can get away with overwriting in the same array because it is guaranteed to take up the same number of bytes or fewer, and because we copied out the reading swath metadata already.) (We can get away with assuming that the pointers will stay valid, because as we never add more data to the array than there was before, it will not reallocate.) */ writing_swath_index = add_element((matches_and_old_values_array **) (&matches), (matches_and_old_values_swath *) writing_swath_index, address, &reading_swath_index->data[reading_iterator]); /* Actual matches are recorded */ if (flags_to_max_width_in_bytes(flags) > 0) ++(*num_matches); } /* Go on to the next one... */ ++reading_iterator; if (reading_iterator >= reading_swath.number_of_bytes) { reading_swath_index = (matches_and_old_values_swath *) (&reading_swath_index->data[reading_swath.number_of_bytes]); reading_swath = *reading_swath_index; reading_iterator = 0; } } matches = null_terminate((matches_and_old_values_array *)matches, (matches_and_old_values_swath *)writing_swath_index); if (!matches) return NULL; return matches; } scanmem-0.16/targetmem.h000066400000000000000000000246061302526536600152410ustar00rootroot00000000000000/* The target memory information array (storage of matches). Copyright (C) 2009 Eli Dupree Copyright (C) 2010 WANG Lu Copyright (C) 2015 Sebastian Parschauer This file is part of libscanmem. This library is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this library. If not, see . */ #ifndef TARGETMEM_H #define TARGETMEM_H #include #include #include #include #include "value.h" #include "maps.h" #include "show_message.h" /* public structs */ typedef struct { uint8_t old_value; match_flags match_info; } old_value_and_match_info; /* These three structs are not used; pointers to them are used to refer to arrays containing copied_data_swaths / matches_swaths, in the following format: - the array begins with the first_byte_in_child pointer; immediately after that is the number_of_bytes, and then the struct's data describing that many bytes. (Note that the number refers to the number of bytes in the child process's memory that are covered, not the number of bytes the struct takes up.) - in the first position after each such block is another such block (first byte pointer and number of bytes), or a null pointer and a 0 number of bytes to terminate the data. (The first_byte_in_child pointers refer to locations in the child - they cannot be followed except using ptrace()) */ /* typedef struct { void *first_byte_in_child; unsigned long number_of_bytes; } unknown_type_of_swath; typedef struct { void *first_byte_in_child; unsigned long number_of_bytes; uint8_t copied_bytes[0]; } copied_data_swath; typedef struct { void *first_byte_in_child; unsigned long number_of_bytes; match_flags match_info[0]; } matches_swath; */ typedef struct { void *first_byte_in_child; unsigned long number_of_bytes; old_value_and_match_info data[0]; } matches_and_old_values_swath; /* typedef struct { unsigned long bytes_allocated; unsigned long max_needed_bytes; } unknown_type_of_array; typedef struct { unsigned long bytes_allocated; unsigned long max_needed_bytes; copied_data_swath swaths[0]; } copied_data_array; typedef struct { unsigned long bytes_allocated; unsigned long max_needed_bytes; matches_swath swaths[0]; } matches_array; */ typedef struct { unsigned long bytes_allocated; unsigned long max_needed_bytes; matches_and_old_values_swath swaths[0]; } matches_and_old_values_array; typedef struct { matches_and_old_values_swath *swath; long index; } match_location; /* public functions */ matches_and_old_values_array *allocate_array (matches_and_old_values_array *array, unsigned long max_bytes); matches_and_old_values_array *null_terminate (matches_and_old_values_array *array, matches_and_old_values_swath *swath); /* for printable text representation */ void data_to_printable_string (char *buf, int buf_length, matches_and_old_values_swath *swath, long index, int string_length); /* for bytearray representation */ void data_to_bytearray_text (char *buf, int buf_length, matches_and_old_values_swath *swath, long index, int bytearray_length); match_location nth_match (matches_and_old_values_array *matches, unsigned n); matches_and_old_values_array *delete_by_region (matches_and_old_values_array *array, long *num_matches, region_t *which, bool invert); static inline long index_of_last_element (matches_and_old_values_swath *swath) { return swath->number_of_bytes - 1; } static inline void * remote_address_of_nth_element (matches_and_old_values_swath *swath, long n) { return swath->first_byte_in_child + n; } static inline void * remote_address_of_last_element (matches_and_old_values_swath *swath) { return (remote_address_of_nth_element(swath, index_of_last_element(swath))); } static inline void * local_address_beyond_nth_element (matches_and_old_values_swath *swath, long n) { return &((matches_and_old_values_swath *)swath)->data[n + 1]; } static inline void * local_address_beyond_last_element (matches_and_old_values_swath *swath) { return (local_address_beyond_nth_element(swath, index_of_last_element(swath))); } static inline matches_and_old_values_array * allocate_enough_to_reach (matches_and_old_values_array *array, void *last_byte_to_reach_plus_one, matches_and_old_values_swath **swath_pointer_to_correct) { unsigned long bytes_needed = (last_byte_to_reach_plus_one - (void *)array); if (bytes_needed <= array->bytes_allocated) { return array; } else { matches_and_old_values_array *original_location = array; /* Allocate twice as much each time, so we don't have to do it too often */ unsigned long bytes_to_allocate = array->bytes_allocated; while (bytes_to_allocate < bytes_needed) bytes_to_allocate *= 2; show_debug("to_allocate %ld, max %ld\n", bytes_to_allocate, array->max_needed_bytes); /* Sometimes we know an absolute max that we will need */ if (array->max_needed_bytes < bytes_to_allocate) { assert(array->max_needed_bytes >= bytes_needed); bytes_to_allocate = array->max_needed_bytes; } if (!(array = realloc(array, bytes_to_allocate))) return NULL; array->bytes_allocated = bytes_to_allocate; /* Put the swath pointer back where it should be, if needed. We cast everything to void pointers in this line to make sure the math works out. */ if (swath_pointer_to_correct) { (*swath_pointer_to_correct) = (matches_and_old_values_swath *) (((void *)(*swath_pointer_to_correct)) + ((void *)array - (void *)original_location)); } return array; } } /* Returns a pointer to the swath to which the element was added - i.e. the last swath in the array after the operation */ static inline matches_and_old_values_swath * add_element (matches_and_old_values_array **array, matches_and_old_values_swath *swath, void *remote_address, void *new_element) { if (swath->number_of_bytes == 0) { assert(swath->first_byte_in_child == NULL); /* We have to overwrite this as a new swath */ *array = allocate_enough_to_reach(*array, (void *)swath + sizeof(matches_and_old_values_swath) + sizeof(old_value_and_match_info), &swath); swath->first_byte_in_child = remote_address; } else { unsigned long local_index_excess = remote_address - remote_address_of_last_element(swath); unsigned long local_address_excess = local_index_excess * sizeof(old_value_and_match_info); size_t needed_size = sizeof(matches_and_old_values_swath) + sizeof(old_value_and_match_info); if (local_address_excess >= needed_size) { /* It is most memory-efficient to start a new swath */ *array = allocate_enough_to_reach(*array, local_address_beyond_last_element(swath) + sizeof(matches_and_old_values_swath) + sizeof(old_value_and_match_info), &swath); swath = local_address_beyond_last_element(swath); swath->first_byte_in_child = remote_address; swath->number_of_bytes = 0; } else { /* It is most memory-efficient to write over the intervening space with null values */ *array = allocate_enough_to_reach(*array, local_address_beyond_last_element(swath) + local_address_excess, &swath); switch (local_address_excess) { case 4: memset(local_address_beyond_last_element(swath), 0, 4); break; case 8: memset(local_address_beyond_last_element(swath), 0, 8); break; default: /* slow due to unknown size to be zeroed */ memset(local_address_beyond_last_element(swath), 0, local_address_excess); break; } swath->number_of_bytes += local_index_excess - 1; } } /* Add me */ *(old_value_and_match_info *)local_address_beyond_last_element(swath) = *(old_value_and_match_info *)new_element; ++swath->number_of_bytes; return swath; } /* only at most sizeof(int64_t) bytes will be read, if more bytes are needed (e.g. bytearray), read them separatedly (for performance) */ static inline value_t data_to_val_aux (matches_and_old_values_swath *swath, long index, long swath_length) { int i; value_t val; int max_bytes = swath_length - index; zero_value(&val); if (max_bytes > 8) max_bytes = 8; if (max_bytes >= 8) val.flags.u64b = val.flags.s64b = val.flags.f64b = 1; if (max_bytes >= 4) val.flags.u32b = val.flags.s32b = val.flags.f32b = 1; if (max_bytes >= 2) val.flags.u16b = val.flags.s16b = 1; if (max_bytes >= 1) val.flags.u8b = val.flags.s8b = 1; for (i = 0; i < max_bytes; ++i) { uint8_t byte; byte = ((matches_and_old_values_swath *)swath)->data[index + i].old_value; *((uint8_t *)(&val.int64_value) + i) = byte; } return val; } static inline value_t data_to_val (matches_and_old_values_swath *swath, long index) { return data_to_val_aux(swath, index, swath->number_of_bytes); } #endif /* TARGETMEM_H */ scanmem-0.16/value.c000066400000000000000000000254331302526536600143620ustar00rootroot00000000000000/* Simple routines for working with the value_t data structure. Copyright (C) 2006,2007,2009 Tavis Ormandy Copyright (C) 2009 Eli Dupree Copyright (C) 2009,2010 WANG Lu Copyright (C) 2015 Sebastian Parschauer This file is part of libscanmem. This library is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this library. If not, see . */ #include "config.h" #include #include #include #include #include #include #include #include #include #include "value.h" #include "scanroutines.h" #include "scanmem.h" void valtostr(const value_t *val, char *str, size_t n) { char buf[128]; int np = 0; int max_bytes = 0; bool print_as_unsigned = false; #define FLAG_MACRO(bytes, string) (val->flags.u##bytes##b && val->flags.s##bytes##b) ? (string " ") : (val->flags.u##bytes##b) ? (string "u ") : (val->flags.s##bytes##b) ? (string "s ") : "" /* set the flags */ np = snprintf(buf, sizeof(buf), "[%s%s%s%s%s%s%s]", FLAG_MACRO(64, "I64"), FLAG_MACRO(32, "I32"), FLAG_MACRO(16, "I16"), FLAG_MACRO(8, "I8"), val->flags.f64b ? "F64 " : "", val->flags.f32b ? "F32 " : "", (val->flags.ineq_reverse && !val->flags.ineq_forwards) ? "(reversed inequality) " : ""); /* handle having no type at all */ if (np <= 2) goto err; if (val->flags.u64b) { max_bytes = 8; print_as_unsigned = true; } else if (val->flags.s64b) { max_bytes = 8; print_as_unsigned = false; } else if (val->flags.u32b) { max_bytes = 4; print_as_unsigned = true; } else if (val->flags.s32b) { max_bytes = 4; print_as_unsigned = false; } else if (val->flags.u16b) { max_bytes = 2; print_as_unsigned = true; } else if (val->flags.s16b) { max_bytes = 2; print_as_unsigned = false; } else if (val->flags.u8b ) { max_bytes = 1; print_as_unsigned = true; } else if (val->flags.s8b ) { max_bytes = 1; print_as_unsigned = false; } /* find the right format, considering different integer size implementations */ if (max_bytes == sizeof(long long)) np = snprintf(str, n, print_as_unsigned ? "%llu, %s" : "%lld, %s", print_as_unsigned ? get_ulonglong(val) : get_slonglong(val), buf); else if (max_bytes == sizeof(long)) np = snprintf(str, n, print_as_unsigned ? "%lu, %s" : "%ld, %s" , print_as_unsigned ? get_ulong(val) : get_slong(val), buf); else if (max_bytes == sizeof(int)) np = snprintf(str, n, print_as_unsigned ? "%u, %s" : "%d, %s" , print_as_unsigned ? get_uint(val) : get_sint(val), buf); else if (max_bytes == sizeof(short)) np = snprintf(str, n, print_as_unsigned ? "%hu, %s" : "%hd, %s" , print_as_unsigned ? get_ushort(val) : get_sshort(val), buf); else if (max_bytes == sizeof(char)) np = snprintf(str, n, print_as_unsigned ? "%hhu, %s" : "%hhd, %s", print_as_unsigned ? get_uchar(val) : get_schar(val), buf); else if (val->flags.f64b) np = snprintf(str, n, "%lf, %s", get_f64b(val), buf); else if (val->flags.f32b) np = snprintf(str, n, "%f, %s", get_f32b(val), buf); else goto err; if (np <= 0 || np >= (n - 1)) goto err; return; err: /* always print a value and a type for not crashing the GUI */ strncpy(str, "unknown, [unknown]", n); } void valcpy(value_t * dst, const value_t * src) { memcpy(dst, src, sizeof(value_t)); return; } /* dst.flags must be set beforehand */ void uservalue2value(value_t *dst, const uservalue_t *src) { if(dst->flags.u8b) set_u8b(dst, get_u8b(src)); if(dst->flags.s8b) set_s8b(dst, get_s8b(src)); if(dst->flags.u16b) set_u16b(dst, get_u16b(src)); if(dst->flags.s16b) set_s16b(dst, get_s16b(src)); if(dst->flags.u32b) set_u32b(dst, get_u32b(src)); if(dst->flags.s32b) set_s32b(dst, get_s32b(src)); if(dst->flags.u64b) set_u64b(dst, get_u64b(src)); if(dst->flags.s64b) set_s64b(dst, get_s64b(src)); /* I guess integer and float cannot be matched together */ if(dst->flags.f32b) set_f32b(dst, get_f32b(src)); if(dst->flags.f64b) set_f64b(dst, get_f64b(src)); } /* array must have been allocated, of size at least argc */ bool parse_uservalue_bytearray(char **argv, unsigned argc, bytearray_element_t *array, uservalue_t *val) { int i,j; const char *cur_str; char cur_char; char *endptr; bytearray_element_t *cur_element; for(i = 0; i < argc; ++i) { /* get current string */ cur_str = argv[i]; /* test its length */ for(j = 0; (j < 3) && (cur_str[j]); ++j) {} if (j != 2) /* length is not 2 */ return false; cur_element = array + i; if (strcmp(cur_str, "??") == 0) { cur_element->is_wildcard = 1; continue; } else { /* parse as hex integer */ cur_char = (char)strtol(cur_str, &endptr, 16); if (*endptr != '\0') return false; cur_element->is_wildcard = 0; cur_element->byte = cur_char; } } /* everything is ok */ val->bytearray_value = array; val->flags.bytearray_length = argc; return true; } bool parse_uservalue_number(const char *nptr, uservalue_t * val) { /* TODO multiple rounding method */ if (parse_uservalue_int(nptr, val)) { val->flags.f32b = val->flags.f64b = 1; val->float32_value = (float) val->int64_value; val->float64_value = (double) val->int64_value; return true; } else if(parse_uservalue_float(nptr, val)) { double num = val->float64_value; if (num >= (double)(0) && num < (double)(1LL<< 8)) { val->flags.u8b = 1; set_u8b(val, (uint8_t)num); } if (num >= (double)-(1LL<< 7) && num < (double)(1LL<< 7)) { val->flags.s8b = 1; set_s8b(val, (int8_t)num); } if (num >= (double)(0) && num < (double)(1LL<<16)) { val->flags.u16b = 1; set_u16b(val, (uint16_t)num); } if (num >= (double)-(1LL<<15) && num < (double)(1LL<<15)) { val->flags.s16b = 1; set_s16b(val, (int16_t)num); } if (num >= (double)(0) && num < (double)(1LL<<32)) { val->flags.u32b = 1; set_u32b(val, (uint32_t)num); } if (num >= (double)-(1LL<<31) && num < (double)(1LL<<31)) { val->flags.s32b = 1; set_s32b(val, (int32_t)num); } if ( (double)(true) && (double)(true)) { val->flags.u64b = 1; set_u64b(val, (uint64_t)num); } if ( (double)(true) && (double)(true)) { val->flags.s64b = 1; set_s64b(val, (int64_t)num); } return true; } return false; } bool parse_uservalue_int(const char *nptr, uservalue_t * val) { int64_t num; char *endptr; assert(nptr != NULL); assert(val != NULL); zero_uservalue(val); /* skip past any whitespace */ while (isspace(*nptr)) ++nptr; /* now parse it using strtoul */ errno = 0; num = strtoll(nptr, &endptr, 0); if ((errno != 0) || (*endptr != '\0')) return false; /* determine correct flags */ if (num >= (0) && num < (1LL<< 8)) { val->flags.u8b = 1; set_u8b(val, (uint8_t)num); } if (num >= -(1LL<< 7) && num < (1LL<< 7)) { val->flags.s8b = 1; set_s8b(val, (int8_t)num); } if (num >= (0) && num < (1LL<<16)) { val->flags.u16b = 1; set_u16b(val, (uint16_t)num); } if (num >= -(1LL<<15) && num < (1LL<<15)) { val->flags.s16b = 1; set_s16b(val, (int16_t)num); } if (num >= (0) && num < (1LL<<32)) { val->flags.u32b = 1; set_u32b(val, (uint32_t)num); } if (num >= -(1LL<<31) && num < (1LL<<31)) { val->flags.s32b = 1; set_s32b(val, (int32_t)num); } if ( (true) && (true)) { val->flags.u64b = 1; set_u64b(val, (uint64_t)num); } if ( (true) && (true)) { val->flags.s64b = 1; set_s64b(val, (int64_t)num); } return true; } bool parse_uservalue_float(const char *nptr, uservalue_t * val) { double num; char *endptr; assert(nptr); assert(val); zero_uservalue(val); while (isspace(*nptr)) ++nptr; errno = 0; num = strtod(nptr, &endptr); if ((errno != 0) || (*endptr != '\0')) return false; /* I'm not sure how to distinguish float & double, but I guess it's not necessary here */ val->flags.f32b = val->flags.f64b = 1; val->float32_value = (float) num; val->float64_value = num; return true; } int flags_to_max_width_in_bytes(match_flags flags) { switch(sm_globals.options.scan_data_type) { case BYTEARRAY: return flags.bytearray_length; break; case STRING: return flags.string_length; break; default: /* numbers */ if (flags.u64b || flags.s64b || flags.f64b) return 8; else if (flags.u32b || flags.s32b || flags.f32b) return 4; else if (flags.u16b || flags.s16b ) return 2; else if (flags.u8b || flags.s8b ) return 1; else /* It can't be a variable of any size */ return 0; break; } } int val_max_width_in_bytes(value_t *val) { return flags_to_max_width_in_bytes(val->flags); } #define DEFINE_GET_BY_SYSTEM_DEPENDENT_TYPE_FUNCTION(type, typename, signedness_letter) \ type get_##signedness_letter##typename (const value_t const* val) \ { \ if (sizeof(type) <= 1) return (type)get_##signedness_letter##8b(val); \ else if (sizeof(type) <= 2) return (type)get_##signedness_letter##16b(val); \ else if (sizeof(type) <= 4) return (type)get_##signedness_letter##32b(val); \ else if (sizeof(type) <= 8) return (type)get_##signedness_letter##64b(val); \ else assert(false); \ } #define DEFINE_GET_BY_SYSTEM_DEPENDENT_TYPE_FUNCTIONS(type, typename) \ DEFINE_GET_BY_SYSTEM_DEPENDENT_TYPE_FUNCTION(unsigned type, typename, u) \ DEFINE_GET_BY_SYSTEM_DEPENDENT_TYPE_FUNCTION(signed type, typename, s) DEFINE_GET_BY_SYSTEM_DEPENDENT_TYPE_FUNCTIONS(char, char) DEFINE_GET_BY_SYSTEM_DEPENDENT_TYPE_FUNCTIONS(short, short) DEFINE_GET_BY_SYSTEM_DEPENDENT_TYPE_FUNCTIONS(int, int) DEFINE_GET_BY_SYSTEM_DEPENDENT_TYPE_FUNCTIONS(long, long) DEFINE_GET_BY_SYSTEM_DEPENDENT_TYPE_FUNCTIONS(long long, longlong) scanmem-0.16/value.h000066400000000000000000000173311302526536600143650ustar00rootroot00000000000000/* Simple routines for working with the value_t data structure. Copyright (C) 2006,2007,2009 Tavis Ormandy Copyright (C) 2009 Eli Dupree Copyright (C) 2009,2010 WANG Lu Copyright (C) 2015 Sebastian Parschauer This file is part of libscanmem. This library is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this library. If not, see . */ #ifndef VALUE_H #define VALUE_H #include #include #include #include /* some routines for working with value_t structures */ /* this is memory-efficient but DANGEROUS */ /* always keep in mind that don't mess up with bytearray_length or string_length when scanning for BYTEARRAY of STRING */ typedef union { struct __attribute__ ((packed)) { unsigned u8b:1; /* could be an unsigned 8-bit variable (e.g. unsigned char) */ unsigned u16b:1; /* could be an unsigned 16-bit variable (e.g. unsigned short) */ unsigned u32b:1; /* could be an unsigned 32-bit variable (e.g. unsigned int) */ unsigned u64b:1; /* could be an unsigned 64-bit variable (e.g. unsigned long long) */ unsigned s8b:1; /* could be a signed 8-bit variable (e.g. signed char) */ unsigned s16b:1; /* could be a signed 16-bit variable (e.g. short) */ unsigned s32b:1; /* could be a signed 32-bit variable (e.g. int) */ unsigned s64b:1; /* could be a signed 64-bit variable (e.g. long long) */ unsigned f32b:1; /* could be a 32-bit floating point variable (i.e. float) */ unsigned f64b:1; /* could be a 64-bit floating point variable (i.e. double) */ unsigned ineq_forwards:1; /* Whether this value has matched inequalities used the normal way */ unsigned ineq_reverse:1; /* Whether this value has matched inequalities in reverse */ }; uint16_t bytearray_length; /* used when search for an array of bytes or text, I guess uint16_t is enough */ uint16_t string_length; /* used when search for a string */ } match_flags; /* this struct describing values retrieved from target memory */ typedef struct { union { int8_t int8_value; uint8_t uint8_value; int16_t int16_value; uint16_t uint16_value; int32_t int32_value; uint32_t uint32_value; int64_t int64_value; uint64_t uint64_value; float float32_value; double float64_value; int8_t bytes[sizeof(int64_t)]; }; match_flags flags; } value_t; typedef struct{ int8_t byte; int8_t is_wildcard; } bytearray_element_t; /* this struct describing values provided by users */ typedef struct { int8_t int8_value; uint8_t uint8_value; int16_t int16_value; uint16_t uint16_value; int32_t int32_value; uint32_t uint32_value; int64_t int64_value; uint64_t uint64_value; float float32_value; double float64_value; bytearray_element_t *bytearray_value; const char *string_value; match_flags flags; } uservalue_t; /* used when output values to user */ /* only work for numbers */ void valtostr(const value_t *val, char *str, size_t n); bool parse_uservalue_bytearray(char **argv, unsigned argc, bytearray_element_t *array, uservalue_t * val); /* parse bytearray, the parameter array should be allocated beforehand */ bool parse_uservalue_number(const char *nptr, uservalue_t * val); /* parse int or float */ bool parse_uservalue_int(const char *nptr, uservalue_t * val); bool parse_uservalue_float(const char *nptr, uservalue_t * val); void valcpy(value_t * dst, const value_t * src); void uservalue2value(value_t * dst, const uservalue_t * src); /* dst.flags must be set beforehand */ int flags_to_max_width_in_bytes(match_flags flags); int val_max_width_in_bytes(value_t *val); #define get_s8b(val) ((val)->int8_value) #define get_u8b(val) ((val)->uint8_value) #define get_s16b(val) ((val)->int16_value) #define get_u16b(val) ((val)->uint16_value) #define get_s32b(val) ((val)->int32_value) #define get_u32b(val) ((val)->uint32_value) #define get_s64b(val) ((val)->int64_value) #define get_u64b(val) ((val)->uint64_value) #define get_f32b(val) ((val)->float32_value) #define get_f64b(val) ((val)->float64_value) #define set_s8b(val, v) (((val)->int8_value) = v) #define set_u8b(val, v) (((val)->uint8_value) = v) #define set_s16b(val, v) (((val)->int16_value) = v) #define set_u16b(val, v) (((val)->uint16_value) = v) #define set_s32b(val, v) (((val)->int32_value) = v) #define set_u32b(val, v) (((val)->uint32_value) = v) #define set_s64b(val, v) (((val)->int64_value) = v) #define set_u64b(val, v) (((val)->uint64_value) = v) #define set_f32b(val, v) (((val)->float32_value) = v) #define set_f64b(val, v) (((val)->float64_value) = v) #define DECLARE_GET_BY_SYSTEM_DEPENDENT_TYPE_FUNCTIONS(type, typename) \ unsigned type get_u##typename (const value_t const *val); \ signed type get_s##typename (const value_t const *val); DECLARE_GET_BY_SYSTEM_DEPENDENT_TYPE_FUNCTIONS(char, char); DECLARE_GET_BY_SYSTEM_DEPENDENT_TYPE_FUNCTIONS(short, short); DECLARE_GET_BY_SYSTEM_DEPENDENT_TYPE_FUNCTIONS(int, int); DECLARE_GET_BY_SYSTEM_DEPENDENT_TYPE_FUNCTIONS(long, long); DECLARE_GET_BY_SYSTEM_DEPENDENT_TYPE_FUNCTIONS(long long, longlong); static inline void zero_match_flags(match_flags *flags) { memset(flags, 0, sizeof(*flags)); } static inline void zero_value(value_t *val) { /* zero components separately - 10 bytes memset() is too slow */ val->int64_value = 0; /* zero the whole union */ zero_match_flags(&val->flags); } static inline void zero_uservalue(uservalue_t *val) { memset(val, 0, sizeof(*val)); } static inline void truncval_to_flags(value_t *dst, match_flags flags) { assert(dst != NULL); dst->flags.u64b &= flags.u64b; dst->flags.s64b &= flags.s64b; dst->flags.f64b &= flags.f64b; dst->flags.u32b &= flags.u32b; dst->flags.s32b &= flags.s32b; dst->flags.f32b &= flags.f32b; dst->flags.u16b &= flags.u16b; dst->flags.s16b &= flags.s16b; dst->flags.u8b &= flags.u8b; dst->flags.s8b &= flags.s8b; /* Hack - simply overwrite the inequality flags (this should have no effect except to make them display properly) */ dst->flags.ineq_forwards = flags.ineq_forwards; dst->flags.ineq_reverse = flags.ineq_reverse; } static inline void truncval(value_t *dst, const value_t *src) { assert(src != NULL); truncval_to_flags(dst, src->flags); } /* set all possible width flags, if nothing is known about val */ static inline void valnowidth(value_t *val) { assert(val); val->flags.u64b = 1; val->flags.s64b = 1; val->flags.u32b = 1; val->flags.s32b = 1; val->flags.u16b = 1; val->flags.s16b = 1; val->flags.u8b = 1; val->flags.s8b = 1; val->flags.f64b = 1; val->flags.f32b = 1; val->flags.ineq_forwards = 1; val->flags.ineq_reverse = 1; /* don't bother with bytearray_length and string_length */ return; } #endif /* VALUE_H */