From e85b7bc326a924594292c7661c31e9f6630c1917 Mon Sep 17 00:00:00 2001 From: Nikolai Rinas Date: Fri, 29 Jul 2016 20:49:49 -0700 Subject: [PATCH] init --- LICENSE | 674 ++++++++++++++++++++++++++++++++ Makefile | 16 + README.md | 24 +- bin/jslisten | Bin 0 -> 71948 bytes src/axbtnmap.c | 89 +++++ src/axbtnmap.h | 65 ++++ src/jslisten.c | 534 +++++++++++++++++++++++++ src/minGlue.h | 31 ++ src/minIni.c | 877 ++++++++++++++++++++++++++++++++++++++++++ src/minIni.h | 152 ++++++++ utils/jslisten-init | 60 +++ utils/modeSwitcher.sh | 77 ++++ 12 files changed, 2598 insertions(+), 1 deletion(-) create mode 100644 LICENSE create mode 100644 Makefile create mode 100755 bin/jslisten create mode 100644 src/axbtnmap.c create mode 100644 src/axbtnmap.h create mode 100644 src/jslisten.c create mode 100644 src/minGlue.h create mode 100644 src/minIni.c create mode 100644 src/minIni.h create mode 100755 utils/jslisten-init create mode 100755 utils/modeSwitcher.sh diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..c65825e --- /dev/null +++ b/LICENSE @@ -0,0 +1,674 @@ + 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. + + {one line to give the program's name and a brief idea of what it does.} + Copyright (C) {year} {name of author} + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 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: + + {project} Copyright (C) {year} {fullname} + 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 +. diff --git a/Makefile b/Makefile new file mode 100644 index 0000000..0654937 --- /dev/null +++ b/Makefile @@ -0,0 +1,16 @@ +CFLAGS ?= -g -O2 -Wall + +PROGRAMS = jslisten + + +compile: $(PROGRAMS) + +jslisten.o: src/jslisten.c src/axbtnmap.h src/minIni.h + +jslisten: src/jslisten.o src/axbtnmap.o src/minIni.o + $(CC) $(CFLAGS) $(CPPFLAGS) $(LDFLAGS) $^ -ludev -o bin/$@ + +clean: + $(RM) src/*.o src/*.swp bin/$(PROGRAMS) src/*.orig src/*.rej map *~ + +.PHONY: compile clean diff --git a/README.md b/README.md index 63d9c08..419d372 100644 --- a/README.md +++ b/README.md @@ -1,2 +1,24 @@ # jslisten -listen to gamepad inputs and trigger a command + +## Index + 1. [Overview](#overview) + 2. [Requirements](#requirements) + 3. [Installation](##installation) + +## Overview + +This program listen in the background for gamepad inputs. If a special button combination is getting pressed +the provided command line will be invoked. + +It's basically a copy of jstest and udev example implementations. + +## + +Main purpose for this development is a switcher between Kodi and Retropie with the PS3 controller. +## Requirements + +If you have many different /dev/inputs, you might adjust this program to search for special one. + +## Installation + * Use the precompiled binary in /bin or run "# make" to get the binary + * df diff --git a/bin/jslisten b/bin/jslisten new file mode 100755 index 0000000000000000000000000000000000000000..26767e6f1baeae620952249215911aa94a139ee5 GIT binary patch literal 71948 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 or6{43+ + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along + * with this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + */ + +#include +#include + +#include +#include + +#include +#include + +#include "axbtnmap.h" + +/* The following values come from include/joystick.h in the kernel source. */ +#define JSIOCSBTNMAP_LARGE _IOW('j', 0x33, __u16[KEY_MAX_LARGE - BTN_MISC + 1]) +#define JSIOCSBTNMAP_SMALL _IOW('j', 0x33, __u16[KEY_MAX_SMALL - BTN_MISC + 1]) +#define JSIOCGBTNMAP_LARGE _IOR('j', 0x34, __u16[KEY_MAX_LARGE - BTN_MISC + 1]) +#define JSIOCGBTNMAP_SMALL _IOR('j', 0x34, __u16[KEY_MAX_SMALL - BTN_MISC + 1]) + +int determine_ioctl(int fd, int *ioctls, int *ioctl_used, void *argp) +{ + int i, retval = 0; + + /* Try each ioctl in turn. */ + for (i = 0; ioctls[i]; i++) { + if ((retval = ioctl(fd, ioctls[i], argp)) >= 0) { + /* The ioctl did something. */ + *ioctl_used = ioctls[i]; + return retval; + } else if (errno != -EINVAL) { + /* Some other error occurred. */ + return retval; + } + } + return retval; +} + +int getbtnmap(int fd, uint16_t *btnmap) +{ + static int jsiocgbtnmap = 0; + int ioctls[] = { JSIOCGBTNMAP, JSIOCGBTNMAP_LARGE, JSIOCGBTNMAP_SMALL, 0 }; + + if (jsiocgbtnmap != 0) { + /* We already know which ioctl to use. */ + return ioctl(fd, jsiocgbtnmap, btnmap); + } else { + return determine_ioctl(fd, ioctls, &jsiocgbtnmap, btnmap); + } +} + +int setbtnmap(int fd, uint16_t *btnmap) +{ + static int jsiocsbtnmap = 0; + int ioctls[] = { JSIOCSBTNMAP, JSIOCSBTNMAP_LARGE, JSIOCSBTNMAP_SMALL, 0 }; + + if (jsiocsbtnmap != 0) { + /* We already know which ioctl to use. */ + return ioctl(fd, jsiocsbtnmap, btnmap); + } else { + return determine_ioctl(fd, ioctls, &jsiocsbtnmap, btnmap); + } +} + +int getaxmap(int fd, uint8_t *axmap) +{ + return ioctl(fd, JSIOCGAXMAP, axmap); +} + +int setaxmap(int fd, uint8_t *axmap) +{ + return ioctl(fd, JSIOCSAXMAP, axmap); +} diff --git a/src/axbtnmap.h b/src/axbtnmap.h new file mode 100644 index 0000000..37a6e98 --- /dev/null +++ b/src/axbtnmap.h @@ -0,0 +1,65 @@ +/* + * Axis and button map support functions. + * Copyright © 2009 Stephen Kitt + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along + * with this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + */ + +#ifndef __AXBTNMAP_H__ +#define __AXBTNMAP_H__ + +#include +#include + +/* The following values come from include/input.h in the kernel + source; the small variant is used up to version 2.6.27, the large + one from 2.6.28 onwards. We need to handle both values because the + kernel doesn't; it only expects one of the values, and we need to + determine which one at run-time. */ +#define KEY_MAX_LARGE 0x2FF +#define KEY_MAX_SMALL 0x1FF + +/* Axis map size. */ +#define AXMAP_SIZE (ABS_MAX + 1) + +/* Button map size. */ +#define BTNMAP_SIZE (KEY_MAX_LARGE - BTN_MISC + 1) + +/* Retrieves the current axis map in the given array, which must + contain at least AXMAP_SIZE elements. Returns the result of the + ioctl(): negative in case of an error, 0 otherwise for kernels up + to 2.6.30, the length of the array actually copied for later + kernels. */ +int getaxmap(int fd, uint8_t *axmap); + +/* Uses the given array as the axis map. The array must contain at + least AXMAP_SIZE elements. Returns the result of the ioctl(): + negative in case of an error, 0 otherwise. */ +int setaxmap(int fd, uint8_t *axmap); + +/* Retrieves the current button map in the given array, which must + contain at least BTNMAP_SIZE elements. Returns the result of the + ioctl(): negative in case of an error, 0 otherwise for kernels up + to 2.6.30, the length of the array actually copied for later + kernels. */ +int getbtnmap(int fd, uint16_t *btnmap); + +/* Uses the given array as the button map. The array must contain at + least BTNMAP_SIZE elements. Returns the result of the ioctl(): + negative in case of an error, 0 otherwise. */ +int setbtnmap(int fd, uint16_t *btnmap); + +#endif + diff --git a/src/jslisten.c b/src/jslisten.c new file mode 100644 index 0000000..e5d80b7 --- /dev/null +++ b/src/jslisten.c @@ -0,0 +1,534 @@ +/* + * jslisten + * + * Created by Nikolai Rinas on 27.03.15. + * Copyright (c) 2015 Nikolai Rinas. All rights reserved. + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program. If not, see + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include + +#include +#include "minIni.h" + +#include "axbtnmap.h" + +//--------------------------------- +// Some static stuff +//--------------------------------- +#define sizearray(a) (sizeof(a) / sizeof((a)[0])) +#define BUTTON_DEFINED_RANGE -2147483647 // sizeof(long) +#define true 0 +#define false 1 + +#define NAME_LENGTH 128 +#define MYPROGNAME "jslisten" +#define myConfFile "/.jslisten" +#define myGlConfFile "/etc/jslisten.cfg" +#define MY_LOG_LEVEL LOG_NOTICE //LOG_DEBUG //LOG_NOTICE + +#define INI_BUFFERSIZE 512 + + +//--------------------------------- +// Global definitions +//--------------------------------- +char iniFile[512]; +int joyFD; +long button1 = BUTTON_DEFINED_RANGE; // Default unassigned +long button2 = BUTTON_DEFINED_RANGE; // Default unassigned +long button3 = BUTTON_DEFINED_RANGE; // Default unassigned +long button4 = BUTTON_DEFINED_RANGE; // Default unassigned +int buttonActive = 0; +char swFilename[100]; + + +//--------------------------------- +// Check if the button was assigned +//--------------------------------- +int buttonDefined(int val) { + if ( val > BUTTON_DEFINED_RANGE ) { + return true; + }else{ + return false; + } +} + +//--------------------------------- +// get the configuration file +//--------------------------------- +int getConfigFile() { + int rc=1; // Default nothing found + // Determine home dir + strcat(strcpy(iniFile, getenv("HOME")), myConfFile); + + // Look for personal file + if( access( iniFile, R_OK ) != -1 ) { + // file exists + rc = 0; + syslog(LOG_INFO, "reading config %s\n", iniFile); + }else{ + // file doesn't exist, check global + if( access( myGlConfFile, R_OK ) != -1 ) { + strcpy(iniFile, myGlConfFile); + rc = 0; + syslog(LOG_INFO, "reading config %s\n", iniFile); + }else{ + // Write a default file to the home dir + FILE *f = fopen(iniFile, "w"); + if (f == NULL) { + syslog(LOG_ERR, "err: failed write config file %s\n", myConfFile); + }else{ + const char *defaultConfig = "[Generic]\nprogram=\nbutton1=\nbutton2=\nbutton3=\nbutton4=\n"; + fprintf(f, "%s\n", defaultConfig); + syslog(LOG_ERR, "err: no config found. Please maintain all required values in %s\n", iniFile); + } + } + } + return rc; +} + +//--------------------------------------- +// Get configuration items from the file +//--------------------------------------- +void readConfig(void) { + char str[100]; + int s, k; + char section[50]; + long l; + int n; + + /* section/key enumeration */ + for (s = 0; ini_getsection(s, section, sizearray(section), iniFile) > 0; s++) { + for (k = 0; ini_getkey(section, k, str, sizearray(str), iniFile) > 0; k++) { + if ( strncmp("program", str, 7) == 0 ) { // Key found + n = ini_gets(section, str, "dummy", swFilename, sizearray(swFilename), iniFile); + if ( n > 5 && strncmp("dummy", swFilename, 5) != 0 ) { // Value is not empty + syslog(LOG_INFO, "Filename: %s\n", swFilename); + } + } + if ( strncmp("button1", str, 7) == 0 ) { // Key found + l = ini_getl(section, str, BUTTON_DEFINED_RANGE, iniFile); + if ( buttonDefined(l) == true ) { // Value is not empty + syslog(LOG_INFO, "button1: %ld\n", l); + button1 = l; + buttonActive++; + } + } + if ( strncmp("button2", str, 7) == 0 ) { // Key found + l = ini_getl(section, str, BUTTON_DEFINED_RANGE, iniFile); + if ( buttonDefined(l) == true ) { // Value is not empty + syslog(LOG_INFO, "button2: %ld\n", l); + button2 = l; + buttonActive++; + } + } + if ( strncmp("button3", str, 7) == 0 ) { // Key found + l = ini_getl(section, str, BUTTON_DEFINED_RANGE, iniFile); + if ( buttonDefined(l) == true ) { // Value is not empty + syslog(LOG_INFO, "button3: %ld\n", l); + button3 = l; + buttonActive++; + } + } + if ( strncmp("button4", str, 7) == 0 ) { // Key found + l = ini_getl(section, str, BUTTON_DEFINED_RANGE, iniFile); + if ( buttonDefined(l) == true ){ // Value is not empty + syslog(LOG_INFO, "button4: %ld\n", l); + button4 = l; + buttonActive++; + } + } + } /* for */ + } /* for */ +} + +//--------------------------------------------- +// Validity check of the provided config items +//--------------------------------------------- +int checkConfig(void) { + int rc=0; + if ( sizearray(swFilename) < 3 ) { // no program make no sense + syslog(LOG_ERR, "err: no valid filename provided. Please check ini file\n"); + rc = 1; + } + if ( buttonDefined(button1) == false ) { // we need at least one button for tracking + syslog(LOG_ERR, "err: button assignment missing. Please set at least button1 in the ini file!\n"); + rc = 1; + } + syslog(LOG_INFO, "Active assigned buttons: %d\n", buttonActive); + + return rc; +} + +//--------------------------------------------- +// Get the input device +//--------------------------------------------- +void listenJoy (void) { + /* Listen to the input devices and try to recognize connected joystick */ + /* This function is basically a copy of a udev example */ + struct udev *udev; + struct udev_device *dev; + struct udev_device *mydev; + struct udev_monitor *mon; + int fd; + struct udev_enumerate *enumerate; + struct udev_list_entry *devices, *dev_list_entry; + + joyFD = -1; // Clear previous joystick + + /* Create the udev object */ + udev = udev_new(); + if (!udev) { + syslog (LOG_ERR, "Can't create udev\n"); + exit(1); + } + + // Check if a joypad is connected already ... + + /* Create a list of the devices in the 'hidraw' subsystem. */ + enumerate = udev_enumerate_new(udev); + udev_enumerate_add_match_subsystem(enumerate, "input"); + udev_enumerate_scan_devices(enumerate); + devices = udev_enumerate_get_list_entry(enumerate); + + udev_list_entry_foreach(dev_list_entry, devices) { + const char* name; + const char* sysPath; + const char* devPath; + + name = udev_list_entry_get_name(dev_list_entry); + mydev = udev_device_new_from_syspath(udev, name); + sysPath = udev_device_get_syspath(mydev); + devPath = udev_device_get_devnode(mydev); + + if (sysPath != NULL && devPath != NULL && strstr(sysPath, "/js") != 0) { + syslog (LOG_NOTICE, "Found Device: %s\n", devPath); + if ((joyFD = open(devPath, O_RDONLY)) < 0) { // Open the file descriptor + syslog (LOG_INFO, "error: failed to open fd\n"); + } + } + + udev_device_unref(mydev); + } + /* cleanup */ + udev_enumerate_unref(enumerate); + + if ( joyFD < 0 ) { // Still no joystick found + + /* Set up a monitor to monitor input devices */ + mon = udev_monitor_new_from_netlink(udev, "udev"); + udev_monitor_filter_add_match_subsystem_devtype(mon, "input", NULL); + udev_monitor_enable_receiving(mon); + /* Get the file descriptor (fd) for the monitor. + This fd will get passed to select() */ + fd = udev_monitor_get_fd(mon); + + + /* This section will run continuously, calling usleep() at + the end of each pass. This is to demonstrate how to use + a udev_monitor in a non-blocking way. */ + while (joyFD<0) { + /* Set up the call to select(). In this case, select() will + only operate on a single file descriptor, the one + associated with our udev_monitor. Note that the timeval + object is set to 0, which will cause select() to not + block. */ + fd_set fds; + struct timeval tv; + int ret; + + FD_ZERO(&fds); + FD_SET(fd, &fds); + tv.tv_sec = 0; + tv.tv_usec = 0; + + ret = select(fd+1, &fds, NULL, NULL, &tv); + + /* Check if our file descriptor has received data. */ + if (ret > 0 && FD_ISSET(fd, &fds)) { + syslog(LOG_DEBUG,"\nselect() says there should be data\n"); + + /* Make the call to receive the device. + select() ensured that this will not block. */ + dev = udev_monitor_receive_device(mon); + if (dev) { + syslog(LOG_DEBUG, "Got Device\n"); + syslog(LOG_DEBUG, " Node: %s\n", udev_device_get_devnode(dev)); + syslog(LOG_DEBUG, " Subsystem: %s\n", udev_device_get_subsystem(dev)); + syslog(LOG_DEBUG, " Devtype: %s\n", udev_device_get_devtype(dev)); + syslog(LOG_DEBUG, " Action: %s\n",udev_device_get_action(dev)); + + if ( strncmp(udev_device_get_action(dev), "add", 3) == 0 ) { // Device added + /* enumerate joypad devices */ + /* Create a list of the devices in the 'input' subsystem. */ + enumerate = udev_enumerate_new(udev); + udev_enumerate_add_match_subsystem(enumerate, "input"); + udev_enumerate_scan_devices(enumerate); + devices = udev_enumerate_get_list_entry(enumerate); + + udev_list_entry_foreach(dev_list_entry, devices) { + const char* name; + const char* sysPath; + const char* devPath; + + name = udev_list_entry_get_name(dev_list_entry); + mydev = udev_device_new_from_syspath(udev, name); + sysPath = udev_device_get_syspath(mydev); + devPath = udev_device_get_devnode(mydev); + + if (sysPath != NULL && devPath != NULL && strstr(sysPath, "/js") != 0) { + syslog(LOG_NOTICE, "Found Device: %s\n", devPath); + if ((joyFD = open(devPath, O_RDONLY)) < 0) { // Open the file descriptor + syslog(LOG_INFO, "error: failed to open fd\n"); + } + } + + udev_device_unref(mydev); + } + /* cleanup */ + udev_enumerate_unref(enumerate); + }else{ + if ( strncmp(udev_device_get_action(dev), "remove", 6) == 0 ) { // Device remove + if ( joyFD >= 0 ) { + close(joyFD); + } + joyFD = -1; // Reset + } + } + }else{ + syslog(LOG_WARNING, "No Device from receive_device(). An error occured.\n"); + } + udev_device_unref(dev); + } + usleep(250*1000); + syslog(LOG_DEBUG, "."); + fflush(stdout); + } + } + + udev_unref(udev); + +} + +//--------------------------------------------- +// Listen on the input and call the program +//--------------------------------------------- +int bindJoy(void) { + + char *axis_names[ABS_MAX + 1] = { "X", "Y", "Z", "Rx", "Ry", "Rz", "Throttle", "Rudder", + "Wheel", "Gas", "Brake", "?", "?", "?", "?", "?", + "Hat0X", "Hat0Y", "Hat1X", "Hat1Y", "Hat2X", "Hat2Y", "Hat3X", "Hat3Y", + "?", "?", "?", "?", "?", "?", "?", + }; + + char *button_names[KEY_MAX - BTN_MISC + 1] = { + "Btn0", "Btn1", "Btn2", "Btn3", "Btn4", "Btn5", "Btn6", "Btn7", "Btn8", "Btn9", "?", "?", "?", "?", "?", "?", + "LeftBtn", "RightBtn", "MiddleBtn", "SideBtn", "ExtraBtn", "ForwardBtn", "BackBtn", "TaskBtn", "?", "?", "?", "?", "?", "?", "?", "?", + "Trigger", "ThumbBtn", "ThumbBtn2", "TopBtn", "TopBtn2", "PinkieBtn", "BaseBtn", "BaseBtn2", "BaseBtn3", "BaseBtn4", "BaseBtn5", "BaseBtn6", "BtnDead", + "BtnA", "BtnB", "BtnC", "BtnX", "BtnY", "BtnZ", "BtnTL", "BtnTR", "BtnTL2", "BtnTR2", "BtnSelect", "BtnStart", "BtnMode", "BtnThumbL", "BtnThumbR", "?", + "?", "?", "?", "?", "?", "?", "?", "?", "?", "?", "?", "?", "?", "?", "?", "?", + "WheelBtn", "Gear up", + }; + + unsigned char axes = 2; + unsigned char buttons = 2; + int version = 0x000800; + char name[NAME_LENGTH] = "Unknown"; + uint16_t btnmap[BTNMAP_SIZE]; + uint8_t axmap[AXMAP_SIZE]; + int btnmapok = 1; + int i; + + int button1State=0; + int button2State=0; + int button3State=0; + int button4State=0; + + ioctl(joyFD, JSIOCGVERSION, &version); + ioctl(joyFD, JSIOCGAXES, &axes); + ioctl(joyFD, JSIOCGBUTTONS, &buttons); + ioctl(joyFD, JSIOCGNAME(NAME_LENGTH), name); + + getaxmap(joyFD, axmap); + getbtnmap(joyFD, btnmap); + + syslog(LOG_INFO, "Driver version is %d.%d.%d.\n", + version >> 16, (version >> 8) & 0xff, version & 0xff); + + /* Determine whether the button map is usable. */ + for (i = 0; btnmapok && i < buttons; i++) { + if (btnmap[i] < BTN_MISC || btnmap[i] > KEY_MAX) { + btnmapok = 0; + break; + } + } + if (!btnmapok) { + /* btnmap out of range for names. Don't print any. */ + syslog(LOG_WARNING, "jslisten is not fully compatible with your kernel. Unable to retrieve button map!\n"); + syslog(LOG_INFO, "Joystick (%s) has %d axes ", name, axes); + syslog(LOG_INFO, "and %d buttons.\n", buttons); + } else { + syslog(LOG_INFO, "Joystick (%s) has %d axes (", name, axes); + for (i = 0; i < axes; i++) { + syslog(LOG_INFO, "%s%s", i > 0 ? ", " : "", axis_names[axmap[i]]); + } + syslog(LOG_INFO, ")\n"); + + syslog(LOG_INFO, "and %d buttons (", buttons); + for (i = 0; i < buttons; i++) { + syslog(LOG_INFO, "%s%s", i > 0 ? ", " : "", button_names[btnmap[i] - BTN_MISC]); + } + syslog(LOG_INFO, ").\n"); + } + + // Non-blocking reading + struct js_event js; + int needTrigger; + fcntl(joyFD, F_SETFL, O_NONBLOCK); + + while (1) { + while (read(joyFD, &js, sizeof(struct js_event)) == sizeof(struct js_event)) { + syslog(LOG_DEBUG, "Event: type %d, time %d, number %d, value %d\n", + js.type, js.time, js.number, js.value); + if ( js.number == button1 ) { + button1State = js.value; + } + if ( js.number == button2 ) { + button2State = js.value; + } + if ( js.number == button3 ) { + button3State = js.value; + } + if ( js.number == button4 ) { + button4State = js.value; + } + needTrigger = 0; + switch (buttonActive) { + case 1: + if ( button1State == 1 ) { needTrigger = 1; } + break; + case 2: + if ( button1State == 1 && button2State == 1 ) { needTrigger = 1; } + break; + case 3: + if ( button1State == 1 && button2State == 1 && button3State == 1 ) { needTrigger = 1; } + break; + case 4: + if ( button1State == 1 && button2State == 1 && button3State == 1 && button4State == 1) { + needTrigger = 1; + } + break; + } + if ( needTrigger == 1 ) { + syslog(LOG_INFO, "Swtching mode. ...\n"); + // reset state, so we call only once + button1State = 0; + button2State = 0; + button3State = 0; + button4State = 0; + int rc = system(swFilename); + if ( rc == 0 ) { + syslog(LOG_INFO, "Call succesfull\n"); + }else{ + syslog(LOG_INFO, "Call failed\n"); + } + } + } + + if (errno != EAGAIN) { + syslog(LOG_DEBUG, "\njslistent: error reading"); // Regular exit if the joystick disconnect + return 1; + } + + usleep(10000); + } + return 0; +} + +//--------------------------------------------- +// Exit function +//--------------------------------------------- +void signal_callback_handler(int signum) { + syslog(LOG_NOTICE, "Exit. Caught signal %d\n",signum); + // Cleanup and close up stuff here + + closelog(); + + // Terminate program + exit(0); +} + + +//--------------------------------------------- +// main function +//--------------------------------------------- +int main(void) { + int rc; + // Register signal and signal handler + signal(SIGINT, signal_callback_handler); + signal(SIGKILL, signal_callback_handler); + signal(SIGTERM, signal_callback_handler); + signal(SIGHUP, signal_callback_handler); + + // Open Syslog + setlogmask (LOG_UPTO (MY_LOG_LEVEL)); + openlog (MYPROGNAME, LOG_CONS | LOG_PID | LOG_NDELAY, LOG_LOCAL1); + syslog(LOG_NOTICE, "Listen to joystick inputs ...\n"); + + // Get the configuration file + rc = getConfigFile(); + if ( rc > 0 ) { + return rc; + } + + // Read the configuration + readConfig(); + + // Check if we have everything + rc = checkConfig(); + if ( rc > 0 ) { + return rc; + } + + // If everything is set up, run ... + if ( rc == 0 ) { + // Main endless loop + while (1) { + listenJoy(); // Find our joystick + if ( joyFD > 0 ) { + bindJoy(); // If found, use it and listen to the keys + } + } + } + return 0; +} diff --git a/src/minGlue.h b/src/minGlue.h new file mode 100644 index 0000000..2d47d90 --- /dev/null +++ b/src/minGlue.h @@ -0,0 +1,31 @@ +/* Glue functions for the minIni library, based on the C/C++ stdio library + * + * Or better said: this file contains macros that maps the function interface + * used by minIni to the standard C/C++ file I/O functions. + * + * By CompuPhase, 2008-2014 + * This "glue file" is in the public domain. It is distributed without + * warranties or conditions of any kind, either express or implied. + */ + +/* map required file I/O types and functions to the standard C library */ +#include + +#define INI_FILETYPE FILE* +#define ini_openread(filename,file) ((*(file) = fopen((filename),"rb")) != NULL) +#define ini_openwrite(filename,file) ((*(file) = fopen((filename),"wb")) != NULL) +#define ini_openrewrite(filename,file) ((*(file) = fopen((filename),"r+b")) != NULL) +#define ini_close(file) (fclose(*(file)) == 0) +#define ini_read(buffer,size,file) (fgets((buffer),(size),*(file)) != NULL) +#define ini_write(buffer,file) (fputs((buffer),*(file)) >= 0) +#define ini_rename(source,dest) (rename((source), (dest)) == 0) +#define ini_remove(filename) (remove(filename) == 0) + +#define INI_FILEPOS long int +#define ini_tell(file,pos) (*(pos) = ftell(*(file))) +#define ini_seek(file,pos) (fseek(*(file), *(pos), SEEK_SET) == 0) + +/* for floating-point support, define additional types and functions */ +#define INI_REAL float +#define ini_ftoa(string,value) sprintf((string),"%f",(value)) +#define ini_atof(string) (INI_REAL)strtod((string),NULL) diff --git a/src/minIni.c b/src/minIni.c new file mode 100644 index 0000000..245a813 --- /dev/null +++ b/src/minIni.c @@ -0,0 +1,877 @@ +/* minIni - Multi-Platform INI file parser, suitable for embedded systems + * + * These routines are in part based on the article "Multiplatform .INI Files" + * by Joseph J. Graf in the March 1994 issue of Dr. Dobb's Journal. + * + * Copyright (c) CompuPhase, 2008-2015 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not + * use this file except in compliance with the License. You may obtain a copy + * of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations + * under the License. + * + * Version: $Id: minIni.c 53 2015-01-18 13:35:11Z thiadmer.riemersma@gmail.com $ + */ + +#if (defined _UNICODE || defined __UNICODE__ || defined UNICODE) && !defined INI_ANSIONLY +# if !defined UNICODE /* for Windows */ +# define UNICODE +# endif +# if !defined _UNICODE /* for C library */ +# define _UNICODE +# endif +#endif + +#define MININI_IMPLEMENTATION +#include "minIni.h" +#if defined NDEBUG + #define assert(e) +#else + #include +#endif + +#if !defined __T || defined INI_ANSIONLY + #include + #include + #include + #define TCHAR char + #define __T(s) s + #define _tcscat strcat + #define _tcschr strchr + #define _tcscmp strcmp + #define _tcscpy strcpy + #define _tcsicmp stricmp + #define _tcslen strlen + #define _tcsncmp strncmp + #define _tcsnicmp strnicmp + #define _tcsrchr strrchr + #define _tcstol strtol + #define _tcstod strtod + #define _totupper toupper + #define _stprintf sprintf + #define _tfgets fgets + #define _tfputs fputs + #define _tfopen fopen + #define _tremove remove + #define _trename rename +#endif + +#if defined __linux || defined __linux__ + #define __LINUX__ +#elif defined FREEBSD && !defined __FreeBSD__ + #define __FreeBSD__ +#elif defined(_MSC_VER) + #pragma warning(disable: 4996) /* for Microsoft Visual C/C++ */ +#endif +#if !defined strnicmp && !defined PORTABLE_STRNICMP + #if defined __LINUX__ || defined __FreeBSD__ || defined __OpenBSD__ || defined __APPLE__ + #define strnicmp strncasecmp + #endif +#endif +#if !defined _totupper + #define _totupper toupper +#endif + +#if !defined INI_LINETERM + #if defined __LINUX__ || defined __FreeBSD__ || defined __OpenBSD__ || defined __APPLE__ + #define INI_LINETERM __T("\n") + #else + #define INI_LINETERM __T("\r\n") + #endif +#endif +#if !defined INI_FILETYPE + #error Missing definition for INI_FILETYPE. +#endif + +#if !defined sizearray + #define sizearray(a) (sizeof(a) / sizeof((a)[0])) +#endif + +enum quote_option { + QUOTE_NONE, + QUOTE_ENQUOTE, + QUOTE_DEQUOTE, +}; + +#if defined PORTABLE_STRNICMP +int strnicmp(const TCHAR *s1, const TCHAR *s2, size_t n) +{ + register int c1, c2; + + while (n-- != 0 && (*s1 || *s2)) { + c1 = *s1++; + if ('a' <= c1 && c1 <= 'z') + c1 += ('A' - 'a'); + c2 = *s2++; + if ('a' <= c2 && c2 <= 'z') + c2 += ('A' - 'a'); + if (c1 != c2) + return c1 - c2; + } /* while */ + return 0; +} +#endif /* PORTABLE_STRNICMP */ + +static TCHAR *skipleading(const TCHAR *str) +{ + assert(str != NULL); + while ('\0' < *str && *str <= ' ') + str++; + return (TCHAR *)str; +} + +static TCHAR *skiptrailing(const TCHAR *str, const TCHAR *base) +{ + assert(str != NULL); + assert(base != NULL); + while (str > base && '\0' < *(str-1) && *(str-1) <= ' ') + str--; + return (TCHAR *)str; +} + +static TCHAR *striptrailing(TCHAR *str) +{ + TCHAR *ptr = skiptrailing(_tcschr(str, '\0'), str); + assert(ptr != NULL); + *ptr = '\0'; + return str; +} + +static TCHAR *save_strncpy(TCHAR *dest, const TCHAR *source, size_t maxlen, enum quote_option option) +{ + size_t d, s; + + assert(maxlen>0); + assert(dest <= source || dest >= source + maxlen); + if (option == QUOTE_ENQUOTE && maxlen < 3) + option = QUOTE_NONE; /* cannot store two quotes and a terminating zero in less than 3 characters */ + + switch (option) { + case QUOTE_NONE: + for (d = 0; d < maxlen - 1 && source[d] != '\0'; d++) + dest[d] = source[d]; + assert(d < maxlen); + dest[d] = '\0'; + break; + case QUOTE_ENQUOTE: + d = 0; + dest[d++] = '"'; + for (s = 0; source[s] != '\0' && d < maxlen - 2; s++, d++) { + if (source[s] == '"') { + if (d >= maxlen - 3) + break; /* no space to store the escape character plus the one that follows it */ + dest[d++] = '\\'; + } /* if */ + dest[d] = source[s]; + } /* for */ + dest[d++] = '"'; + dest[d] = '\0'; + break; + case QUOTE_DEQUOTE: + for (d = s = 0; source[s] != '\0' && d < maxlen - 1; s++, d++) { + if ((source[s] == '"' || source[s] == '\\') && source[s + 1] == '"') + s++; + dest[d] = source[s]; + } /* for */ + dest[d] = '\0'; + break; + default: + assert(0); + } /* switch */ + + return dest; +} + +static TCHAR *cleanstring(TCHAR *string, enum quote_option *quotes) +{ + int isstring; + TCHAR *ep; + + assert(string != NULL); + assert(quotes != NULL); + + /* Remove a trailing comment */ + isstring = 0; + for (ep = string; *ep != '\0' && ((*ep != ';' && *ep != '#') || isstring); ep++) { + if (*ep == '"') { + if (*(ep + 1) == '"') + ep++; /* skip "" (both quotes) */ + else + isstring = !isstring; /* single quote, toggle isstring */ + } else if (*ep == '\\' && *(ep + 1) == '"') { + ep++; /* skip \" (both quotes */ + } /* if */ + } /* for */ + assert(ep != NULL && (*ep == '\0' || *ep == ';' || *ep == '#')); + *ep = '\0'; /* terminate at a comment */ + striptrailing(string); + /* Remove double quotes surrounding a value */ + *quotes = QUOTE_NONE; + if (*string == '"' && (ep = _tcschr(string, '\0')) != NULL && *(ep - 1) == '"') { + string++; + *--ep = '\0'; + *quotes = QUOTE_DEQUOTE; /* this is a string, so remove escaped characters */ + } /* if */ + return string; +} + +static int getkeystring(INI_FILETYPE *fp, const TCHAR *Section, const TCHAR *Key, + int idxSection, int idxKey, TCHAR *Buffer, int BufferSize, + INI_FILEPOS *mark) +{ + TCHAR *sp, *ep; + int len, idx; + enum quote_option quotes; + TCHAR LocalBuffer[INI_BUFFERSIZE]; + + assert(fp != NULL); + /* Move through file 1 line at a time until a section is matched or EOF. If + * parameter Section is NULL, only look at keys above the first section. If + * idxSection is positive, copy the relevant section name. + */ + len = (Section != NULL) ? (int)_tcslen(Section) : 0; + if (len > 0 || idxSection >= 0) { + idx = -1; + do { + if (!ini_read(LocalBuffer, INI_BUFFERSIZE, fp)) + return 0; + sp = skipleading(LocalBuffer); + ep = _tcschr(sp, ']'); + } while (*sp != '[' || ep == NULL || (((int)(ep-sp-1) != len || _tcsnicmp(sp+1,Section,len) != 0) && ++idx != idxSection)); + if (idxSection >= 0) { + if (idx == idxSection) { + assert(ep != NULL); + assert(*ep == ']'); + *ep = '\0'; + save_strncpy(Buffer, sp + 1, BufferSize, QUOTE_NONE); + return 1; + } /* if */ + return 0; /* no more section found */ + } /* if */ + } /* if */ + + /* Now that the section has been found, find the entry. + * Stop searching upon leaving the section's area. + */ + assert(Key != NULL || idxKey >= 0); + len = (Key != NULL) ? (int)_tcslen(Key) : 0; + idx = -1; + do { + if (mark != NULL) + ini_tell(fp, mark); /* optionally keep the mark to the start of the line */ + if (!ini_read(LocalBuffer,INI_BUFFERSIZE,fp) || *(sp = skipleading(LocalBuffer)) == '[') + return 0; + sp = skipleading(LocalBuffer); + ep = _tcschr(sp, '='); /* Parse out the equal sign */ + if (ep == NULL) + ep = _tcschr(sp, ':'); + } while (*sp == ';' || *sp == '#' || ep == NULL + || ((len == 0 || (int)(skiptrailing(ep,sp)-sp) != len || _tcsnicmp(sp,Key,len) != 0) && ++idx != idxKey)); + if (idxKey >= 0) { + if (idx == idxKey) { + assert(ep != NULL); + assert(*ep == '=' || *ep == ':'); + *ep = '\0'; + striptrailing(sp); + save_strncpy(Buffer, sp, BufferSize, QUOTE_NONE); + return 1; + } /* if */ + return 0; /* no more key found (in this section) */ + } /* if */ + + /* Copy up to BufferSize chars to buffer */ + assert(ep != NULL); + assert(*ep == '=' || *ep == ':'); + sp = skipleading(ep + 1); + sp = cleanstring(sp, "es); /* Remove a trailing comment */ + save_strncpy(Buffer, sp, BufferSize, quotes); + return 1; +} + +/** ini_gets() + * \param Section the name of the section to search for + * \param Key the name of the entry to find the value of + * \param DefValue default string in the event of a failed read + * \param Buffer a pointer to the buffer to copy into + * \param BufferSize the maximum number of characters to copy + * \param Filename the name and full path of the .ini file to read from + * + * \return the number of characters copied into the supplied buffer + */ +int ini_gets(const TCHAR *Section, const TCHAR *Key, const TCHAR *DefValue, + TCHAR *Buffer, int BufferSize, const TCHAR *Filename) +{ + INI_FILETYPE fp; + int ok = 0; + + if (Buffer == NULL || BufferSize <= 0 || Key == NULL) + return 0; + if (ini_openread(Filename, &fp)) { + ok = getkeystring(&fp, Section, Key, -1, -1, Buffer, BufferSize, NULL); + (void)ini_close(&fp); + } /* if */ + if (!ok) + save_strncpy(Buffer, (DefValue != NULL) ? DefValue : __T(""), BufferSize, QUOTE_NONE); + return (int)_tcslen(Buffer); +} + +/** ini_getl() + * \param Section the name of the section to search for + * \param Key the name of the entry to find the value of + * \param DefValue the default value in the event of a failed read + * \param Filename the name of the .ini file to read from + * + * \return the value located at Key + */ +long ini_getl(const TCHAR *Section, const TCHAR *Key, long DefValue, const TCHAR *Filename) +{ + TCHAR LocalBuffer[64]; + int len = ini_gets(Section, Key, __T(""), LocalBuffer, sizearray(LocalBuffer), Filename); + return (len == 0) ? DefValue + : ((len >= 2 && _totupper((int)LocalBuffer[1]) == 'X') ? _tcstol(LocalBuffer, NULL, 16) + : _tcstol(LocalBuffer, NULL, 10)); +} + +#if defined INI_REAL +/** ini_getf() + * \param Section the name of the section to search for + * \param Key the name of the entry to find the value of + * \param DefValue the default value in the event of a failed read + * \param Filename the name of the .ini file to read from + * + * \return the value located at Key + */ +INI_REAL ini_getf(const TCHAR *Section, const TCHAR *Key, INI_REAL DefValue, const TCHAR *Filename) +{ + TCHAR LocalBuffer[64]; + int len = ini_gets(Section, Key, __T(""), LocalBuffer, sizearray(LocalBuffer), Filename); + return (len == 0) ? DefValue : ini_atof(LocalBuffer); +} +#endif + +/** ini_getbool() + * \param Section the name of the section to search for + * \param Key the name of the entry to find the value of + * \param DefValue default value in the event of a failed read; it should + * zero (0) or one (1). + * \param Buffer a pointer to the buffer to copy into + * \param BufferSize the maximum number of characters to copy + * \param Filename the name and full path of the .ini file to read from + * + * A true boolean is found if one of the following is matched: + * - A string starting with 'y' or 'Y' + * - A string starting with 't' or 'T' + * - A string starting with '1' + * + * A false boolean is found if one of the following is matched: + * - A string starting with 'n' or 'N' + * - A string starting with 'f' or 'F' + * - A string starting with '0' + * + * \return the true/false flag as interpreted at Key + */ +int ini_getbool(const TCHAR *Section, const TCHAR *Key, int DefValue, const TCHAR *Filename) +{ + TCHAR LocalBuffer[2] = __T(""); + int ret; + + ini_gets(Section, Key, __T(""), LocalBuffer, sizearray(LocalBuffer), Filename); + LocalBuffer[0] = (TCHAR)_totupper((int)LocalBuffer[0]); + if (LocalBuffer[0] == 'Y' || LocalBuffer[0] == '1' || LocalBuffer[0] == 'T') + ret = 1; + else if (LocalBuffer[0] == 'N' || LocalBuffer[0] == '0' || LocalBuffer[0] == 'F') + ret = 0; + else + ret = DefValue; + + return(ret); +} + +/** ini_getsection() + * \param idx the zero-based sequence number of the section to return + * \param Buffer a pointer to the buffer to copy into + * \param BufferSize the maximum number of characters to copy + * \param Filename the name and full path of the .ini file to read from + * + * \return the number of characters copied into the supplied buffer + */ +int ini_getsection(int idx, TCHAR *Buffer, int BufferSize, const TCHAR *Filename) +{ + INI_FILETYPE fp; + int ok = 0; + + if (Buffer == NULL || BufferSize <= 0 || idx < 0) + return 0; + if (ini_openread(Filename, &fp)) { + ok = getkeystring(&fp, NULL, NULL, idx, -1, Buffer, BufferSize, NULL); + (void)ini_close(&fp); + } /* if */ + if (!ok) + *Buffer = '\0'; + return (int)_tcslen(Buffer); +} + +/** ini_getkey() + * \param Section the name of the section to browse through, or NULL to + * browse through the keys outside any section + * \param idx the zero-based sequence number of the key to return + * \param Buffer a pointer to the buffer to copy into + * \param BufferSize the maximum number of characters to copy + * \param Filename the name and full path of the .ini file to read from + * + * \return the number of characters copied into the supplied buffer + */ +int ini_getkey(const TCHAR *Section, int idx, TCHAR *Buffer, int BufferSize, const TCHAR *Filename) +{ + INI_FILETYPE fp; + int ok = 0; + + if (Buffer == NULL || BufferSize <= 0 || idx < 0) + return 0; + if (ini_openread(Filename, &fp)) { + ok = getkeystring(&fp, Section, NULL, -1, idx, Buffer, BufferSize, NULL); + (void)ini_close(&fp); + } /* if */ + if (!ok) + *Buffer = '\0'; + return (int)_tcslen(Buffer); +} + + +#if !defined INI_NOBROWSE +/** ini_browse() + * \param Callback a pointer to a function that will be called for every + * setting in the INI file. + * \param UserData arbitrary data, which the function passes on the + * \c Callback function + * \param Filename the name and full path of the .ini file to read from + * + * \return 1 on success, 0 on failure (INI file not found) + * + * \note The \c Callback function must return 1 to continue + * browsing through the INI file, or 0 to stop. Even when the + * callback stops the browsing, this function will return 1 + * (for success). + */ +int ini_browse(INI_CALLBACK Callback, const void *UserData, const TCHAR *Filename) +{ + TCHAR LocalBuffer[INI_BUFFERSIZE]; + int lenSec, lenKey; + enum quote_option quotes; + INI_FILETYPE fp; + + if (Callback == NULL) + return 0; + if (!ini_openread(Filename, &fp)) + return 0; + + LocalBuffer[0] = '\0'; /* copy an empty section in the buffer */ + lenSec = (int)_tcslen(LocalBuffer) + 1; + for ( ;; ) { + TCHAR *sp, *ep; + if (!ini_read(LocalBuffer + lenSec, INI_BUFFERSIZE - lenSec, &fp)) + break; + sp = skipleading(LocalBuffer + lenSec); + /* ignore empty strings and comments */ + if (*sp == '\0' || *sp == ';' || *sp == '#') + continue; + /* see whether we reached a new section */ + ep = _tcschr(sp, ']'); + if (*sp == '[' && ep != NULL) { + *ep = '\0'; + save_strncpy(LocalBuffer, sp + 1, INI_BUFFERSIZE, QUOTE_NONE); + lenSec = (int)_tcslen(LocalBuffer) + 1; + continue; + } /* if */ + /* not a new section, test for a key/value pair */ + ep = _tcschr(sp, '='); /* test for the equal sign or colon */ + if (ep == NULL) + ep = _tcschr(sp, ':'); + if (ep == NULL) + continue; /* invalid line, ignore */ + *ep++ = '\0'; /* split the key from the value */ + striptrailing(sp); + save_strncpy(LocalBuffer + lenSec, sp, INI_BUFFERSIZE - lenSec, QUOTE_NONE); + lenKey = (int)_tcslen(LocalBuffer + lenSec) + 1; + /* clean up the value */ + sp = skipleading(ep); + sp = cleanstring(sp, "es); /* Remove a trailing comment */ + save_strncpy(LocalBuffer + lenSec + lenKey, sp, INI_BUFFERSIZE - lenSec - lenKey, quotes); + /* call the callback */ + if (!Callback(LocalBuffer, LocalBuffer + lenSec, LocalBuffer + lenSec + lenKey, UserData)) + break; + } /* for */ + + (void)ini_close(&fp); + return 1; +} +#endif /* INI_NOBROWSE */ + +#if ! defined INI_READONLY +static void ini_tempname(TCHAR *dest, const TCHAR *source, int maxlength) +{ + TCHAR *p; + + save_strncpy(dest, source, maxlength, QUOTE_NONE); + p = _tcsrchr(dest, '\0'); + assert(p != NULL); + *(p - 1) = '~'; +} + +static enum quote_option check_enquote(const TCHAR *Value) +{ + const TCHAR *p; + + /* run through the value, if it has trailing spaces, or '"', ';' or '#' + * characters, enquote it + */ + assert(Value != NULL); + for (p = Value; *p != '\0' && *p != '"' && *p != ';' && *p != '#'; p++) + /* nothing */; + return (*p != '\0' || (p > Value && *(p - 1) == ' ')) ? QUOTE_ENQUOTE : QUOTE_NONE; +} + +static void writesection(TCHAR *LocalBuffer, const TCHAR *Section, INI_FILETYPE *fp) +{ + if (Section != NULL && _tcslen(Section) > 0) { + TCHAR *p; + LocalBuffer[0] = '['; + save_strncpy(LocalBuffer + 1, Section, INI_BUFFERSIZE - 4, QUOTE_NONE); /* -1 for '[', -1 for ']', -2 for '\r\n' */ + p = _tcsrchr(LocalBuffer, '\0'); + assert(p != NULL); + *p++ = ']'; + _tcscpy(p, INI_LINETERM); /* copy line terminator (typically "\n") */ + if (fp != NULL) + (void)ini_write(LocalBuffer, fp); + } /* if */ +} + +static void writekey(TCHAR *LocalBuffer, const TCHAR *Key, const TCHAR *Value, INI_FILETYPE *fp) +{ + TCHAR *p; + enum quote_option option = check_enquote(Value); + save_strncpy(LocalBuffer, Key, INI_BUFFERSIZE - 3, QUOTE_NONE); /* -1 for '=', -2 for '\r\n' */ + p = _tcsrchr(LocalBuffer, '\0'); + assert(p != NULL); + *p++ = '='; + save_strncpy(p, Value, INI_BUFFERSIZE - (p - LocalBuffer) - 2, option); /* -2 for '\r\n' */ + p = _tcsrchr(LocalBuffer, '\0'); + assert(p != NULL); + _tcscpy(p, INI_LINETERM); /* copy line terminator (typically "\n") */ + if (fp != NULL) + (void)ini_write(LocalBuffer, fp); +} + +static int cache_accum(const TCHAR *string, int *size, int max) +{ + int len = (int)_tcslen(string); + if (*size + len >= max) + return 0; + *size += len; + return 1; +} + +static int cache_flush(TCHAR *buffer, int *size, + INI_FILETYPE *rfp, INI_FILETYPE *wfp, INI_FILEPOS *mark) +{ + int terminator_len = (int)_tcslen(INI_LINETERM); + int pos = 0; + + (void)ini_seek(rfp, mark); + assert(buffer != NULL); + buffer[0] = '\0'; + assert(size != NULL); + assert(*size <= INI_BUFFERSIZE); + while (pos < *size) { + (void)ini_read(buffer + pos, INI_BUFFERSIZE - pos, rfp); + while (pos < *size && buffer[pos] != '\0') + pos++; /* cannot use _tcslen() because buffer may not be zero-terminated */ + } /* while */ + if (buffer[0] != '\0') { + assert(pos > 0 && pos <= INI_BUFFERSIZE); + if (pos == INI_BUFFERSIZE) + pos--; + buffer[pos] = '\0'; /* force zero-termination (may be left unterminated in the above while loop) */ + (void)ini_write(buffer, wfp); + } + ini_tell(rfp, mark); /* update mark */ + *size = 0; + /* return whether the buffer ended with a line termination */ + return (pos > terminator_len) && (_tcscmp(buffer + pos - terminator_len, INI_LINETERM) == 0); +} + +static int close_rename(INI_FILETYPE *rfp, INI_FILETYPE *wfp, const TCHAR *filename, TCHAR *buffer) +{ + (void)ini_close(rfp); + (void)ini_close(wfp); + (void)ini_remove(filename); + (void)ini_tempname(buffer, filename, INI_BUFFERSIZE); + (void)ini_rename(buffer, filename); + return 1; +} + +/** ini_puts() + * \param Section the name of the section to write the string in + * \param Key the name of the entry to write, or NULL to erase all keys in the section + * \param Value a pointer to the buffer the string, or NULL to erase the key + * \param Filename the name and full path of the .ini file to write to + * + * \return 1 if successful, otherwise 0 + */ +int ini_puts(const TCHAR *Section, const TCHAR *Key, const TCHAR *Value, const TCHAR *Filename) +{ + INI_FILETYPE rfp; + INI_FILETYPE wfp; + INI_FILEPOS mark; + INI_FILEPOS head, tail; + TCHAR *sp, *ep; + TCHAR LocalBuffer[INI_BUFFERSIZE]; + int len, match, flag, cachelen; + + assert(Filename != NULL); + if (!ini_openread(Filename, &rfp)) { + /* If the .ini file doesn't exist, make a new file */ + if (Key != NULL && Value != NULL) { + if (!ini_openwrite(Filename, &wfp)) + return 0; + writesection(LocalBuffer, Section, &wfp); + writekey(LocalBuffer, Key, Value, &wfp); + (void)ini_close(&wfp); + } /* if */ + return 1; + } /* if */ + + /* If parameters Key and Value are valid (so this is not an "erase" request) + * and the setting already exists, there are two short-cuts to avoid rewriting + * the INI file. + */ + if (Key != NULL && Value != NULL) { + ini_tell(&rfp, &mark); + match = getkeystring(&rfp, Section, Key, -1, -1, LocalBuffer, sizearray(LocalBuffer), &head); + if (match) { + /* if the current setting is identical to the one to write, there is + * nothing to do. + */ + if (_tcscmp(LocalBuffer,Value) == 0) { + (void)ini_close(&rfp); + return 1; + } /* if */ + /* if the new setting has the same length as the current setting, and the + * glue file permits file read/write access, we can modify in place. + */ + #if defined ini_openrewrite + /* we already have the start of the (raw) line, get the end too */ + ini_tell(&rfp, &tail); + /* create new buffer (without writing it to file) */ + writekey(LocalBuffer, Key, Value, NULL); + if (_tcslen(LocalBuffer) == (size_t)(tail - head)) { + /* length matches, close the file & re-open for read/write, then + * write at the correct position + */ + (void)ini_close(&rfp); + if (!ini_openrewrite(Filename, &wfp)) + return 0; + (void)ini_seek(&wfp, &head); + (void)ini_write(LocalBuffer, &wfp); + (void)ini_close(&wfp); + return 1; + } /* if */ + #endif + } /* if */ + /* key not found, or different value & length -> proceed (but rewind the + * input file first) + */ + (void)ini_seek(&rfp, &mark); + } /* if */ + + /* Get a temporary file name to copy to. Use the existing name, but with + * the last character set to a '~'. + */ + ini_tempname(LocalBuffer, Filename, INI_BUFFERSIZE); + if (!ini_openwrite(LocalBuffer, &wfp)) { + (void)ini_close(&rfp); + return 0; + } /* if */ + ini_tell(&rfp, &mark); + cachelen = 0; + + /* Move through the file one line at a time until a section is + * matched or until EOF. Copy to temp file as it is read. + */ + len = (Section != NULL) ? (int)_tcslen(Section) : 0; + if (len > 0) { + do { + if (!ini_read(LocalBuffer, INI_BUFFERSIZE, &rfp)) { + /* Failed to find section, so add one to the end */ + flag = cache_flush(LocalBuffer, &cachelen, &rfp, &wfp, &mark); + if (Key!=NULL && Value!=NULL) { + if (!flag) + (void)ini_write(INI_LINETERM, &wfp); /* force a new line behind the last line of the INI file */ + writesection(LocalBuffer, Section, &wfp); + writekey(LocalBuffer, Key, Value, &wfp); + } /* if */ + return close_rename(&rfp, &wfp, Filename, LocalBuffer); /* clean up and rename */ + } /* if */ + /* Copy the line from source to dest, but not if this is the section that + * we are looking for and this section must be removed + */ + sp = skipleading(LocalBuffer); + ep = _tcschr(sp, ']'); + match = (*sp == '[' && ep != NULL && (int)(ep-sp-1) == len && _tcsnicmp(sp + 1,Section,len) == 0); + if (!match || Key != NULL) { + if (!cache_accum(LocalBuffer, &cachelen, INI_BUFFERSIZE)) { + cache_flush(LocalBuffer, &cachelen, &rfp, &wfp, &mark); + (void)ini_read(LocalBuffer, INI_BUFFERSIZE, &rfp); + cache_accum(LocalBuffer, &cachelen, INI_BUFFERSIZE); + } /* if */ + } /* if */ + } while (!match); + } /* if */ + cache_flush(LocalBuffer, &cachelen, &rfp, &wfp, &mark); + /* when deleting a section, the section head that was just found has not been + * copied to the output file, but because this line was not "accumulated" in + * the cache, the position in the input file was reset to the point just + * before the section; this must now be skipped (again) + */ + if (Key == NULL) { + (void)ini_read(LocalBuffer, INI_BUFFERSIZE, &rfp); + ini_tell(&rfp, &mark); + } /* if */ + + /* Now that the section has been found, find the entry. Stop searching + * upon leaving the section's area. Copy the file as it is read + * and create an entry if one is not found. + */ + len = (Key != NULL) ? (int)_tcslen(Key) : 0; + for( ;; ) { + if (!ini_read(LocalBuffer, INI_BUFFERSIZE, &rfp)) { + /* EOF without an entry so make one */ + flag = cache_flush(LocalBuffer, &cachelen, &rfp, &wfp, &mark); + if (Key!=NULL && Value!=NULL) { + if (!flag) + (void)ini_write(INI_LINETERM, &wfp); /* force a new line behind the last line of the INI file */ + writekey(LocalBuffer, Key, Value, &wfp); + } /* if */ + return close_rename(&rfp, &wfp, Filename, LocalBuffer); /* clean up and rename */ + } /* if */ + sp = skipleading(LocalBuffer); + ep = _tcschr(sp, '='); /* Parse out the equal sign */ + if (ep == NULL) + ep = _tcschr(sp, ':'); + match = (ep != NULL && len > 0 && (int)(skiptrailing(ep,sp)-sp) == len && _tcsnicmp(sp,Key,len) == 0); + if ((Key != NULL && match) || *sp == '[') + break; /* found the key, or found a new section */ + /* copy other keys in the section */ + if (Key == NULL) { + ini_tell(&rfp, &mark); /* we are deleting the entire section, so update the read position */ + } else { + if (!cache_accum(LocalBuffer, &cachelen, INI_BUFFERSIZE)) { + cache_flush(LocalBuffer, &cachelen, &rfp, &wfp, &mark); + (void)ini_read(LocalBuffer, INI_BUFFERSIZE, &rfp); + cache_accum(LocalBuffer, &cachelen, INI_BUFFERSIZE); + } /* if */ + } /* if */ + } /* for */ + /* the key was found, or we just dropped on the next section (meaning that it + * wasn't found); in both cases we need to write the key, but in the latter + * case, we also need to write the line starting the new section after writing + * the key + */ + flag = (*sp == '['); + cache_flush(LocalBuffer, &cachelen, &rfp, &wfp, &mark); + if (Key != NULL && Value != NULL) + writekey(LocalBuffer, Key, Value, &wfp); + /* cache_flush() reset the "read pointer" to the start of the line with the + * previous key or the new section; read it again (because writekey() destroyed + * the buffer) + */ + (void)ini_read(LocalBuffer, INI_BUFFERSIZE, &rfp); + if (flag) { + /* the new section heading needs to be copied to the output file */ + cache_accum(LocalBuffer, &cachelen, INI_BUFFERSIZE); + } else { + /* forget the old key line */ + ini_tell(&rfp, &mark); + } /* if */ + /* Copy the rest of the INI file */ + while (ini_read(LocalBuffer, INI_BUFFERSIZE, &rfp)) { + if (!cache_accum(LocalBuffer, &cachelen, INI_BUFFERSIZE)) { + cache_flush(LocalBuffer, &cachelen, &rfp, &wfp, &mark); + (void)ini_read(LocalBuffer, INI_BUFFERSIZE, &rfp); + cache_accum(LocalBuffer, &cachelen, INI_BUFFERSIZE); + } /* if */ + } /* while */ + cache_flush(LocalBuffer, &cachelen, &rfp, &wfp, &mark); + return close_rename(&rfp, &wfp, Filename, LocalBuffer); /* clean up and rename */ +} + +/* Ansi C "itoa" based on Kernighan & Ritchie's "Ansi C" book. */ +#define ABS(v) ((v) < 0 ? -(v) : (v)) + +static void strreverse(TCHAR *str) +{ + int i, j; + for (i = 0, j = (int)_tcslen(str) - 1; i < j; i++, j--) { + TCHAR t = str[i]; + str[i] = str[j]; + str[j] = t; + } /* for */ +} + +static void long2str(long value, TCHAR *str) +{ + int i = 0; + long sign = value; + int n; + + /* generate digits in reverse order */ + do { + n = (int)(value % 10); /* get next lowest digit */ + str[i++] = (TCHAR)(ABS(n) + '0'); /* handle case of negative digit */ + } while (value /= 10); /* delete the lowest digit */ + if (sign < 0) + str[i++] = '-'; + str[i] = '\0'; + + strreverse(str); +} + +/** ini_putl() + * \param Section the name of the section to write the value in + * \param Key the name of the entry to write + * \param Value the value to write + * \param Filename the name and full path of the .ini file to write to + * + * \return 1 if successful, otherwise 0 + */ +int ini_putl(const TCHAR *Section, const TCHAR *Key, long Value, const TCHAR *Filename) +{ + TCHAR LocalBuffer[32]; + long2str(Value, LocalBuffer); + return ini_puts(Section, Key, LocalBuffer, Filename); +} + +#if defined INI_REAL +/** ini_putf() + * \param Section the name of the section to write the value in + * \param Key the name of the entry to write + * \param Value the value to write + * \param Filename the name and full path of the .ini file to write to + * + * \return 1 if successful, otherwise 0 + */ +int ini_putf(const TCHAR *Section, const TCHAR *Key, INI_REAL Value, const TCHAR *Filename) +{ + TCHAR LocalBuffer[64]; + ini_ftoa(LocalBuffer, Value); + return ini_puts(Section, Key, LocalBuffer, Filename); +} +#endif /* INI_REAL */ +#endif /* !INI_READONLY */ diff --git a/src/minIni.h b/src/minIni.h new file mode 100644 index 0000000..c20a421 --- /dev/null +++ b/src/minIni.h @@ -0,0 +1,152 @@ +/* minIni - Multi-Platform INI file parser, suitable for embedded systems + * + * Copyright (c) CompuPhase, 2008-2015 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not + * use this file except in compliance with the License. You may obtain a copy + * of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the + * License for the specific language governing permissions and limitations + * under the License. + * + * Version: $Id: minIni.h 53 2015-01-18 13:35:11Z thiadmer.riemersma@gmail.com $ + */ +#ifndef MININI_H +#define MININI_H + +#include "minGlue.h" + +#if (defined _UNICODE || defined __UNICODE__ || defined UNICODE) && !defined INI_ANSIONLY + #include + #define mTCHAR TCHAR +#else + /* force TCHAR to be "char", but only for minIni */ + #define mTCHAR char +#endif + +#if !defined INI_BUFFERSIZE + #define INI_BUFFERSIZE 512 +#endif + +#if defined __cplusplus + extern "C" { +#endif + +int ini_getbool(const mTCHAR *Section, const mTCHAR *Key, int DefValue, const mTCHAR *Filename); +long ini_getl(const mTCHAR *Section, const mTCHAR *Key, long DefValue, const mTCHAR *Filename); +int ini_gets(const mTCHAR *Section, const mTCHAR *Key, const mTCHAR *DefValue, mTCHAR *Buffer, int BufferSize, const mTCHAR *Filename); +int ini_getsection(int idx, mTCHAR *Buffer, int BufferSize, const mTCHAR *Filename); +int ini_getkey(const mTCHAR *Section, int idx, mTCHAR *Buffer, int BufferSize, const mTCHAR *Filename); + +#if defined INI_REAL +INI_REAL ini_getf(const mTCHAR *Section, const mTCHAR *Key, INI_REAL DefValue, const mTCHAR *Filename); +#endif + +#if !defined INI_READONLY +int ini_putl(const mTCHAR *Section, const mTCHAR *Key, long Value, const mTCHAR *Filename); +int ini_puts(const mTCHAR *Section, const mTCHAR *Key, const mTCHAR *Value, const mTCHAR *Filename); +#if defined INI_REAL +int ini_putf(const mTCHAR *Section, const mTCHAR *Key, INI_REAL Value, const mTCHAR *Filename); +#endif +#endif /* INI_READONLY */ + +#if !defined INI_NOBROWSE +typedef int (*INI_CALLBACK)(const mTCHAR *Section, const mTCHAR *Key, const mTCHAR *Value, const void *UserData); +int ini_browse(INI_CALLBACK Callback, const void *UserData, const mTCHAR *Filename); +#endif /* INI_NOBROWSE */ + +#if defined __cplusplus + } +#endif + + +#if defined __cplusplus + +#if defined __WXWINDOWS__ + #include "wxMinIni.h" +#else + #include + + /* The C++ class in minIni.h was contributed by Steven Van Ingelgem. */ + class minIni + { + public: + minIni(const std::string& filename) : iniFilename(filename) + { } + + bool getbool(const std::string& Section, const std::string& Key, bool DefValue=false) const + { return ini_getbool(Section.c_str(), Key.c_str(), int(DefValue), iniFilename.c_str()) != 0; } + + long getl(const std::string& Section, const std::string& Key, long DefValue=0) const + { return ini_getl(Section.c_str(), Key.c_str(), DefValue, iniFilename.c_str()); } + + int geti(const std::string& Section, const std::string& Key, int DefValue=0) const + { return static_cast(this->getl(Section, Key, long(DefValue))); } + + std::string gets(const std::string& Section, const std::string& Key, const std::string& DefValue="") const + { + char buffer[INI_BUFFERSIZE]; + ini_gets(Section.c_str(), Key.c_str(), DefValue.c_str(), buffer, INI_BUFFERSIZE, iniFilename.c_str()); + return buffer; + } + + std::string getsection(int idx) const + { + char buffer[INI_BUFFERSIZE]; + ini_getsection(idx, buffer, INI_BUFFERSIZE, iniFilename.c_str()); + return buffer; + } + + std::string getkey(const std::string& Section, int idx) const + { + char buffer[INI_BUFFERSIZE]; + ini_getkey(Section.c_str(), idx, buffer, INI_BUFFERSIZE, iniFilename.c_str()); + return buffer; + } + +#if defined INI_REAL + INI_REAL getf(const std::string& Section, const std::string& Key, INI_REAL DefValue=0) const + { return ini_getf(Section.c_str(), Key.c_str(), DefValue, iniFilename.c_str()); } +#endif + +#if ! defined INI_READONLY + bool put(const std::string& Section, const std::string& Key, long Value) const + { return ini_putl(Section.c_str(), Key.c_str(), Value, iniFilename.c_str()) != 0; } + + bool put(const std::string& Section, const std::string& Key, int Value) const + { return ini_putl(Section.c_str(), Key.c_str(), (long)Value, iniFilename.c_str()) != 0; } + + bool put(const std::string& Section, const std::string& Key, bool Value) const + { return ini_putl(Section.c_str(), Key.c_str(), (long)Value, iniFilename.c_str()) != 0; } + + bool put(const std::string& Section, const std::string& Key, const std::string& Value) const + { return ini_puts(Section.c_str(), Key.c_str(), Value.c_str(), iniFilename.c_str()) != 0; } + + bool put(const std::string& Section, const std::string& Key, const char* Value) const + { return ini_puts(Section.c_str(), Key.c_str(), Value, iniFilename.c_str()) != 0; } + +#if defined INI_REAL + bool put(const std::string& Section, const std::string& Key, INI_REAL Value) const + { return ini_putf(Section.c_str(), Key.c_str(), Value, iniFilename.c_str()) != 0; } +#endif + + bool del(const std::string& Section, const std::string& Key) const + { return ini_puts(Section.c_str(), Key.c_str(), 0, iniFilename.c_str()) != 0; } + + bool del(const std::string& Section) const + { return ini_puts(Section.c_str(), 0, 0, iniFilename.c_str()) != 0; } +#endif + + private: + std::string iniFilename; + }; + +#endif /* __WXWINDOWS__ */ +#endif /* __cplusplus */ + +#endif /* MININI_H */ diff --git a/utils/jslisten-init b/utils/jslisten-init new file mode 100755 index 0000000..e549057 --- /dev/null +++ b/utils/jslisten-init @@ -0,0 +1,60 @@ +#!/bin/sh +# kFreeBSD do not accept scripts as interpreters, using #!/bin/sh and sourcing. +if [ true != "$INIT_D_SCRIPT_SOURCED" ] ; then + set "$0" "$@"; INIT_D_SCRIPT_SOURCED=true . /lib/init/init-d-script +fi +### BEGIN INIT INFO +# Provides: jslisten +# Required-Start: $remote_fs $syslog +# Required-Stop: $remote_fs $syslog +# Default-Start: 2 3 4 5 +# Default-Stop: 0 1 6 +# Short-Description: Listen to the joystick input and run a script on key combination +# Description: This file should be used to construct scripts to be +# placed in /etc/init.d. This example start a +# single forking daemon capable of writing a pid +# file. To get other behavoirs, implemend +# do_start(), do_stop() or other functions to +# override the defaults in /lib/init/init-d-script. +### END INIT INFO + +# Author: Nikolai Rinas +# + +DESC="jslisten daemon" +NAME="jslisten" +PIDFILE="/var/run/${NAME}.pid" +DAEMON="/opt/bin/$NAME" + +do_start_cmd() { + start-stop-daemon --start --background --make-pidfile --quiet ${PIDFILE:+--pidfile ${PIDFILE}} \ + $START_ARGS \ + --startas $DAEMON --name $NAME --exec $DAEMON --test > /dev/null \ + || return 1 + start-stop-daemon --start --background --make-pidfile --quiet ${PIDFILE:+--pidfile ${PIDFILE}} \ + $START_ARGS \ + --startas $DAEMON --name $NAME --exec $DAEMON -- $DAEMON_ARGS \ + || return 2 +} + +do_stop_cmd_123() { + start-stop-daemon --stop --quiet --retry=TERM/30/INT/5 \ + $STOP_ARGS \ + ${PIDFILE:+--pidfile ${PIDFILE}} --name $NAME --exec $DAEMON + RETVAL="$?" + [ "$RETVAL" = 2 ] && return 2 + # Wait for children to finish too if this is a daemon that forks + # and if the daemon is only ever run from this initscript. + # If the above conditions are not satisfied then add some other code + # that waits for the process to drop all resources that could be + # needed by services started subsequently. A last resort is to + # sleep for some time. + start-stop-daemon --stop --quiet --oknodo --retry=0/30/INT/5 \ + $STOP_ARGS \ + --exec $DAEMON + [ "$?" = 2 ] && return 2 + # Many daemons don't delete their pidfiles when they exit. + rm -f $PIDFILE + return $RETVAL +} + diff --git a/utils/modeSwitcher.sh b/utils/modeSwitcher.sh new file mode 100755 index 0000000..3fd1595 --- /dev/null +++ b/utils/modeSwitcher.sh @@ -0,0 +1,77 @@ +#!/bin/bash +# +# Switch between Kodi and Retropie +# + +KODISERVICE="/usr/bin/kodi" +KODIINIT="/etc/init.d/kodi" +X11SERVICE="/usr/sbin/lightdm" +X11INIT="/etc/init.d/lightdm" +RETROSERVICE="emulationstation" +RETROINIT="/etc/init.d/retropie" + +KODIRUN="FALSE" +X11RUN="FALSE" +RETRORUN="FALSE" + +check_kodi() { + if ps ax | grep -v grep | grep $KODISERVICE > /dev/null ; then + KODIRUN="TRUE" + else + KODIRUN="FALSE" + fi +} + +check_lightdm() { + if ps ax | grep -v grep | grep $X11SERVICE > /dev/null ; then + X11RUN="TRUE" + else + X11RUN="FALSE" + fi +} + +check_retropie() { + if ps ax | grep -v grep | grep $RETROSERVICE > /dev/null ; then + RETRORUN="TRUE" + else + RETRORUN="FALSE" + fi +} + +check_kodi +check_lightdm +check_retropie + +# Switch to Kodi +if [ $RETRORUN == "TRUE" ];then + # Stop Retropie service + $RETROINIT stop + # Only if the service was shut down properly + if [ $? == 0 ]; then + # Start lightdm + #$X11INIT start + # Start kodi + chmod g-rw /dev/input/* + $KODIINIT start + fi + exit 0 +else + # Shut down lightdm if running + if [ $X11RUN == "TRUE" ]; then + $X11INIT stop + check_lightdm + fi + # Shut down kodi if running + if [ $KODIRUN == "TRUE" ]; then + $KODIINIT stop + check_kodi + fi + # If nothing else is running, start Retropie + if [ $X11RUN == "FALSE" ] && [ $KODIRUN == "FALSE" ]; then + chmod g+rw /dev/input/* + $RETROINIT start + fi + exit 0 +fi + +