From dedd12c66a861fc1988d7ffb8c5e630bd76d655a Mon Sep 17 00:00:00 2001 From: Nick Thomas Date: Sat, 10 Apr 2021 14:25:19 +0100 Subject: [PATCH] Vendor in a purple-sys wrapper This code comes from https://github.com/Flared/purple-icq/tree/master/src/purple It is GPL-3 licensed --- src/purple/LICENSE | 674 +++++++++++++++++++++++++ src/purple/account/mod.rs | 243 +++++++++ src/purple/account/settings.rs | 353 +++++++++++++ src/purple/blist.rs | 45 ++ src/purple/chat.rs | 72 +++ src/purple/command.rs | 0 src/purple/connection/connections.rs | 45 ++ src/purple/connection/mod.rs | 100 ++++ src/purple/connection/protocol_data.rs | 51 ++ src/purple/conversation.rs | 193 +++++++ src/purple/ffi.rs | 106 ++++ src/purple/group.rs | 40 ++ src/purple/handlers/entrypoints.rs | 297 +++++++++++ src/purple/handlers/mod.rs | 2 + src/purple/handlers/traits.rs | 116 +++++ src/purple/hashtable.rs | 71 +++ src/purple/loader.rs | 138 +++++ src/purple/mod.rs | 150 ++++++ src/purple/plugin.rs | 11 + src/purple/prpl.rs | 50 ++ src/purple/status_type.rs | 31 ++ 21 files changed, 2788 insertions(+) create mode 100644 src/purple/LICENSE create mode 100644 src/purple/account/mod.rs create mode 100644 src/purple/account/settings.rs create mode 100644 src/purple/blist.rs create mode 100644 src/purple/chat.rs create mode 100644 src/purple/command.rs create mode 100644 src/purple/connection/connections.rs create mode 100644 src/purple/connection/mod.rs create mode 100644 src/purple/connection/protocol_data.rs create mode 100644 src/purple/conversation.rs create mode 100644 src/purple/ffi.rs create mode 100644 src/purple/group.rs create mode 100644 src/purple/handlers/entrypoints.rs create mode 100644 src/purple/handlers/mod.rs create mode 100644 src/purple/handlers/traits.rs create mode 100644 src/purple/hashtable.rs create mode 100644 src/purple/loader.rs create mode 100644 src/purple/mod.rs create mode 100644 src/purple/plugin.rs create mode 100644 src/purple/prpl.rs create mode 100644 src/purple/status_type.rs diff --git a/src/purple/LICENSE b/src/purple/LICENSE new file mode 100644 index 0000000..f288702 --- /dev/null +++ b/src/purple/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. + + + Copyright (C) + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . + +Also add information on how to contact you by electronic and paper mail. + + If the program does terminal interaction, make it output a short +notice like this when it starts in an interactive mode: + + Copyright (C) + This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'. + This is free software, and you are welcome to redistribute it + under certain conditions; type `show c' for details. + +The hypothetical commands `show w' and `show c' should show the appropriate +parts of the General Public License. Of course, your program's commands +might be different; for a GUI interface, you would use an "about box". + + You should also get your employer (if you work as a programmer) or school, +if any, to sign a "copyright disclaimer" for the program, if necessary. +For more information on this, and how to apply and follow the GNU GPL, see +. + + The GNU General Public License does not permit incorporating your program +into proprietary programs. If your program is a subroutine library, you +may consider it more useful to permit linking proprietary applications with +the library. If this is what you want to do, use the GNU Lesser General +Public License instead of this License. But first, please read +. diff --git a/src/purple/account/mod.rs b/src/purple/account/mod.rs new file mode 100644 index 0000000..49ee60f --- /dev/null +++ b/src/purple/account/mod.rs @@ -0,0 +1,243 @@ +use super::ffi::{AsMutPtr, AsPtr}; +use super::{Connection, Conversation, PurpleConversationType}; +use std::borrow::Cow; +use std::ffi::CStr; +use std::ffi::CString; +use std::os::raw::{c_char, c_void}; +use std::panic::catch_unwind; + +pub mod settings; + +impl AsMutPtr for Account { + type PtrType = purple_sys::PurpleAccount; + fn as_mut_ptr(&mut self) -> *mut purple_sys::PurpleAccount { + self.0 + } +} + +#[derive(Clone)] +pub struct Account(*mut purple_sys::PurpleAccount); + +impl Account { + pub unsafe fn from_raw(ptr: *mut purple_sys::PurpleAccount) -> Self { + Account(ptr) + } + + pub fn get_connection(&self) -> Option { + let connection_ptr = unsafe { purple_sys::purple_account_get_connection(self.0) }; + if connection_ptr.is_null() { + None + } else { + unsafe { Connection::from_raw(connection_ptr) } + } + } + + pub fn get_username(&self) -> Option> { + let username_ptr = unsafe { purple_sys::purple_account_get_username(self.0) }; + if username_ptr.is_null() { + None + } else { + Some(unsafe { CStr::from_ptr(username_ptr) }.to_string_lossy()) + } + } + + pub fn is_disconnected(&self) -> bool { + let is_disconnected = unsafe { purple_sys::purple_account_is_disconnected(self.0) }; + is_disconnected != 0 + } + + #[allow(dead_code)] + pub fn get_bool(&self, key: &str, default_value: bool) -> bool { + let c_key = CString::new(key).unwrap(); + unsafe { + purple_sys::purple_account_get_bool(self.0, c_key.as_ptr(), default_value as i32) != 0 + } + } + pub fn get_int(&self, key: &str, default_value: i32) -> i32 { + let c_key = CString::new(key).unwrap(); + unsafe { purple_sys::purple_account_get_int(self.0, c_key.as_ptr(), default_value) } + } + pub fn get_string(&self, key: &str, default_value: &str) -> String { + let c_key = CString::new(key).unwrap(); + let c_default_value = CString::new(default_value).unwrap(); + let c_value = unsafe { + purple_sys::purple_account_get_string(self.0, c_key.as_ptr(), c_default_value.as_ptr()) + }; + unsafe { CStr::from_ptr(c_value).to_string_lossy().into_owned() } + } + + pub fn set_bool(&self, key: &str, value: bool) { + log::info!("Set setting: {} = {}", key, value); + let c_key = CString::new(key).unwrap(); + unsafe { purple_sys::purple_account_set_bool(self.0, c_key.as_ptr(), value as i32) }; + } + pub fn set_int(&self, key: &str, value: i32) { + log::info!("Set setting: {} = {}", key, value); + let c_key = CString::new(key).unwrap(); + unsafe { purple_sys::purple_account_set_int(self.0, c_key.as_ptr(), value) }; + } + pub fn set_string(&self, key: &str, value: &str) { + log::info!("Set setting: {} = {}", key, value); + let c_key = CString::new(key).unwrap(); + let c_value = CString::new(value).unwrap(); + unsafe { purple_sys::purple_account_set_string(self.0, c_key.as_ptr(), c_value.as_ptr()) }; + } + + pub fn remove_setting(&self, key: &str) { + log::info!("Delete setting: {}", key); + let c_key = CString::new(key).unwrap(); + unsafe { purple_sys::purple_account_remove_setting(self.0, c_key.as_ptr()) }; + } + + pub fn set_settings(&self, settings: &T) -> settings::Result<()> { + settings::to_account(&self, settings) + } + + pub fn find_chat_conversation(&mut self, name: &str) -> Option { + let c_name = CString::new(name).unwrap(); + unsafe { + Conversation::from_ptr(purple_sys::purple_find_conversation_with_account( + PurpleConversationType::PURPLE_CONV_TYPE_CHAT, + c_name.as_ptr(), + self.0, + )) + } + } + + #[allow(clippy::too_many_arguments)] + pub fn request_input( + &self, + title: Option<&str>, + primary: Option<&str>, + secondary: Option<&str>, + default_value: Option<&str>, + multiline: bool, + masked: bool, + hint: Option<&str>, + ok_text: &str, + cancel_text: &str, + callback: F, + who: Option<&str>, + ) where + F: FnOnce(Option>) + 'static, + { + let title = title.map(|v| CString::new(v).unwrap().into_raw()); + let primary = primary.map(|v| CString::new(v).unwrap().into_raw()); + let secondary = secondary.map(|v| CString::new(v).unwrap().into_raw()); + let default_value = default_value.map(|v| CString::new(v).unwrap().into_raw()); + let mut hint = hint.map(|v| CString::new(v).unwrap().into_raw()); + let who = who.map(|v| CString::new(v).unwrap().into_raw()); + let ok_text = CString::new(ok_text).unwrap().into_raw(); + let cancel_text = CString::new(cancel_text).unwrap().into_raw(); + + let mut connection = self.get_connection().map(|c| c.as_ptr()); + + let callback_closure = move |value: Option>| { + // Regain ownership over strings to free them. + // Safe since all of those pointer where generated from into_raw() + unsafe { + title.map(|p| CString::from_raw(p)); + primary.map(|p| CString::from_raw(p)); + secondary.map(|p| CString::from_raw(p)); + default_value.map(|p| CString::from_raw(p)); + hint.map(|p| CString::from_raw(p)); + who.map(|p| CString::from_raw(p)); + CString::from_raw(ok_text); + CString::from_raw(cancel_text); + who.map(|p| CString::from_raw(p)); + } + + callback(value); + }; + + unsafe { + purple_request_input_with_callback( + connection.as_mut_ptr() as *mut c_void, + title.as_ptr(), + primary.as_ptr(), + secondary.as_ptr(), + default_value.as_ptr(), + multiline as i32, + masked as i32, + hint.as_mut_ptr(), + ok_text, + cancel_text, + callback_closure, + self.0, + who.as_ptr(), + std::ptr::null_mut(), + ); + } + } +} + +#[allow(clippy::too_many_arguments)] +unsafe fn purple_request_input_with_callback( + connection: *mut c_void, + title: *const c_char, + primary: *const c_char, + secondary: *const c_char, + default_value: *const c_char, + multiline: i32, + masked: i32, + hint: *mut c_char, + ok_text: *const c_char, + cancel_text: *const c_char, + callback: F, + account: *mut purple_sys::PurpleAccount, + who: *const c_char, + conv: *mut purple_sys::PurpleConversation, +) where + F: FnOnce(Option>) + 'static, +{ + let user_data = Box::into_raw(Box::new(callback)) as *mut c_void; + let ok_cb_ptr: unsafe extern "C" fn(*mut c_void, *const c_char) = + request_input_ok_trampoline::; + let cancel_cb_ptr: unsafe extern "C" fn(*mut c_void) = request_input_cancel_trampoline::; + + purple_sys::purple_request_input( + connection, + title, + primary, + secondary, + default_value, + multiline, + masked, + hint, + ok_text, + Some(std::mem::transmute(ok_cb_ptr)), + cancel_text, + Some(std::mem::transmute(cancel_cb_ptr)), + account, + who, + conv, + user_data, + ); +} + +unsafe extern "C" fn request_input_ok_trampoline(user_data: *mut c_void, value: *const c_char) +where + F: FnOnce(Option>), +{ + log::debug!("request_input_ok_trampoline"); + if let Err(error) = catch_unwind(|| { + let value = CStr::from_ptr(value); + let closure = Box::from_raw(user_data as *mut F); + closure(Some(value.to_string_lossy())); + }) { + log::error!("Error in request_input callback: {:?}", error); + } +} + +unsafe extern "C" fn request_input_cancel_trampoline(user_data: *mut c_void) +where + F: FnOnce(Option>), +{ + log::debug!("request_input_cancel_trampoline"); + if let Err(error) = catch_unwind(|| { + let closure = Box::from_raw(user_data as *mut F); + closure(None); + }) { + log::error!("Error in request_input callback: {:?}", error); + } +} diff --git a/src/purple/account/settings.rs b/src/purple/account/settings.rs new file mode 100644 index 0000000..d1ec3d1 --- /dev/null +++ b/src/purple/account/settings.rs @@ -0,0 +1,353 @@ +use super::Account; +use serde::{de, ser, Serialize}; +pub type Result = std::result::Result; + +#[derive(Clone, Debug, PartialEq)] +pub enum Error { + Message(String), + UnsupportedType(&'static str), + MissingKey, + PurpleFailed, +} +impl std::error::Error for Error {} + +impl ser::Error for Error { + fn custom(msg: T) -> Self { + Error::Message(msg.to_string()) + } +} + +impl de::Error for Error { + fn custom(msg: T) -> Self { + Error::Message(msg.to_string()) + } +} + +impl std::fmt::Display for Error { + fn fmt(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result { + match self { + Error::Message(msg) => formatter.write_str(msg), + Error::PurpleFailed => formatter.write_str("libpurple call failed"), + Error::MissingKey => formatter.write_str("Key unset for value"), + Error::UnsupportedType(t) => write!(formatter, "type '{}' is not supported", t), + } + } +} + +pub struct Serializer<'a> { + current_key: Result<&'a str>, + account: &'a Account, +} + +pub fn to_account(account: &Account, value: &T) -> Result<()> +where + T: Serialize, +{ + let mut serializer = Serializer { + account, + current_key: Err(Error::MissingKey), + }; + value.serialize(&mut serializer) +} + +impl<'a> Serializer<'a> { + fn serialize_int(&self, v: i32) -> Result<()> { + match &self.current_key { + Ok(k) => { + self.account.set_int(k, v); + Ok(()) + } + Err(e) => Err(e.clone()), + } + } + fn serialize_string(&self, v: &str) -> Result<()> { + match &self.current_key { + Ok(k) => { + self.account.set_string(k, v); + Ok(()) + } + Err(e) => Err(e.clone()), + } + } + fn remove_settings(&self) -> Result<()> { + match &self.current_key { + Ok(k) => { + self.account.remove_setting(k); + Ok(()) + } + Err(e) => Err(e.clone()), + } + } +} + +impl<'a, 'b> ser::Serializer for &'a mut Serializer<'b> { + type Ok = (); + type Error = Error; + type SerializeSeq = Self; + type SerializeTuple = Self; + type SerializeTupleStruct = Self; + type SerializeTupleVariant = Self; + type SerializeMap = Self; + type SerializeStruct = Self; + type SerializeStructVariant = Self; + + fn serialize_bool(self, v: bool) -> Result { + match &self.current_key { + Ok(k) => { + self.account.set_bool(k, v); + Ok(()) + } + Err(e) => Err(e.clone()), + } + } + + fn serialize_i8(self, v: i8) -> Result { + self.serialize_int(v as i32) + } + + fn serialize_i16(self, v: i16) -> Result { + self.serialize_int(v as i32) + } + + fn serialize_i32(self, v: i32) -> Result { + self.serialize_int(v) + } + + fn serialize_i64(self, _v: i64) -> Result { + Err(Error::UnsupportedType("i64")) + } + + fn serialize_u8(self, v: u8) -> Result { + self.serialize_int(v as i32) + } + + fn serialize_u16(self, v: u16) -> Result { + self.serialize_int(v as i32) + } + + fn serialize_u32(self, v: u32) -> Result { + self.serialize_int(v as i32) + } + + fn serialize_u64(self, _v: u64) -> Result { + Err(Error::UnsupportedType("u64")) + } + + fn serialize_f32(self, _v: f32) -> Result { + Err(Error::UnsupportedType("f32")) + } + + fn serialize_f64(self, _v: f64) -> Result { + Err(Error::UnsupportedType("f64")) + } + + fn serialize_char(self, v: char) -> Result { + self.serialize_string(&v.to_string()) + } + + fn serialize_str(self, v: &str) -> Result { + self.serialize_string(v) + } + + fn serialize_bytes(self, _v: &[u8]) -> Result { + Err(Error::UnsupportedType("bytes")) + } + + fn serialize_none(self) -> Result { + self.remove_settings() + } + + fn serialize_some(self, value: &T) -> Result { + value.serialize(self) + } + + fn serialize_unit(self) -> Result { + Err(Error::UnsupportedType("unit")) + } + + fn serialize_unit_struct(self, _name: &'static str) -> Result { + Err(Error::UnsupportedType("unit_struct")) + } + + fn serialize_unit_variant( + self, + _name: &'static str, + _variant_index: u32, + variant: &'static str, + ) -> Result { + self.serialize_str(variant) + } + + fn serialize_newtype_struct( + self, + _name: &'static str, + value: &T, + ) -> Result { + value.serialize(self) + } + + fn serialize_newtype_variant( + self, + _name: &'static str, + _variant_index: u32, + _variant: &'static str, + value: &T, + ) -> Result { + value.serialize(self) + } + + fn serialize_seq(self, _len: Option) -> Result { + Err(Error::UnsupportedType("seq")) + } + + fn serialize_tuple(self, _len: usize) -> Result { + Err(Error::UnsupportedType("tuple")) + } + + fn serialize_tuple_struct( + self, + _name: &'static str, + _len: usize, + ) -> Result { + Err(Error::UnsupportedType("tuple_struct")) + } + + fn serialize_tuple_variant( + self, + _name: &'static str, + _variant_index: u32, + _variant: &'static str, + _len: usize, + ) -> Result { + Err(Error::UnsupportedType("tuple_variant")) + } + + fn serialize_map(self, _len: Option) -> Result { + Err(Error::UnsupportedType("map")) + } + + fn serialize_struct(self, _name: &'static str, _len: usize) -> Result { + Ok(self) + } + + fn serialize_struct_variant( + self, + _name: &'static str, + _variant_index: u32, + _variant: &'static str, + _len: usize, + ) -> Result { + Err(Error::UnsupportedType("struct_variant")) + } +} + +impl<'a, 'b> ser::SerializeSeq for &'a mut Serializer<'b> { + type Ok = (); + type Error = Error; + + fn serialize_element(&mut self, _value: &T) -> Result<()> { + unreachable!() + } + + fn end(self) -> Result { + unreachable!() + } +} + +impl<'a, 'b> ser::SerializeTuple for &'a mut Serializer<'b> { + type Ok = (); + type Error = Error; + + fn serialize_element(&mut self, _value: &T) -> Result<()> { + unreachable!() + } + + fn end(self) -> Result { + unreachable!() + } +} + +impl<'a, 'b> ser::SerializeTupleStruct for &'a mut Serializer<'b> { + type Ok = (); + type Error = Error; + + fn serialize_field(&mut self, _value: &T) -> Result<()> { + unreachable!() + } + + fn end(self) -> Result { + unreachable!() + } +} + +impl<'a, 'b> ser::SerializeTupleVariant for &'a mut Serializer<'b> { + type Ok = (); + type Error = Error; + + fn serialize_field(&mut self, _value: &T) -> Result<()> { + unreachable!() + } + + fn end(self) -> Result { + unreachable!() + } +} + +impl<'a, 'b> ser::SerializeMap for &'a mut Serializer<'b> { + type Ok = (); + type Error = Error; + + fn serialize_key(&mut self, _key: &T) -> Result<()> { + unreachable!() + } + + fn serialize_value(&mut self, _value: &T) -> Result<()> { + unreachable!() + } + + fn end(self) -> Result { + unreachable!() + } +} + +impl<'a, 'b> ser::SerializeStruct for &'a mut Serializer<'b> { + type Ok = (); + type Error = Error; + + fn serialize_field( + &mut self, + key: &'static str, + value: &T, + ) -> Result<()> { + // Shouldn't happen. + if self.current_key.is_ok() { + return Err(Error::Message("Key already set".into())); + } + + self.current_key = Ok(key); + let value = value.serialize(&mut **self); + self.current_key = Err(Error::MissingKey); + value + } + + fn end(self) -> Result { + Ok(()) + } +} + +impl<'a, 'b> ser::SerializeStructVariant for &'a mut Serializer<'b> { + type Ok = (); + type Error = Error; + + fn serialize_field( + &mut self, + _key: &'static str, + _value: &T, + ) -> Result<()> { + unreachable!() + } + + fn end(self) -> Result { + unreachable!() + } +} diff --git a/src/purple/blist.rs b/src/purple/blist.rs new file mode 100644 index 0000000..052dd49 --- /dev/null +++ b/src/purple/blist.rs @@ -0,0 +1,45 @@ +use super::ffi::AsPtr; +use libc::c_char; +use std::ffi::CStr; +use std::ffi::CString; +use std::ptr::NonNull; + +pub struct BlistNode(NonNull); + +impl BlistNode { + pub unsafe fn from_ptr(ptr: *mut purple_sys::PurpleBlistNode) -> Option { + NonNull::new(ptr).map(Self) + } + + pub fn get_string(&mut self, key: &str) -> Option<&str> { + let c_key = CString::new(key).unwrap(); + + unsafe { + let c_value = purple_sys::purple_blist_node_get_string(self.0.as_ptr(), c_key.as_ptr()); + NonNull::new(c_value as *mut c_char).map(|p| { + CStr::from_ptr(p.as_ptr() as *const c_char) + .to_str() + .unwrap() + }) + } + } + + pub fn set_string(&mut self, key: &str, value: &str) { + let c_key = CString::new(key).unwrap(); + let c_value = CString::new(value).unwrap(); + unsafe { + purple_sys::purple_blist_node_set_string( + self.0.as_ptr(), + c_key.as_ptr(), + c_value.as_ptr(), + ); + } + } +} + +impl AsPtr for BlistNode { + type PtrType = purple_sys::PurpleBlistNode; + fn as_ptr(&self) -> *const Self::PtrType { + self.0.as_ptr() + } +} diff --git a/src/purple/chat.rs b/src/purple/chat.rs new file mode 100644 index 0000000..96859ab --- /dev/null +++ b/src/purple/chat.rs @@ -0,0 +1,72 @@ +use super::blist::BlistNode; +use super::ffi::{AsMutPtr, AsPtr, IntoGlibPtr}; +use crate::purple; +use std::ffi::CString; +use std::ptr::{null_mut, NonNull}; + +pub struct Chat(NonNull); + +impl Chat { + pub fn new( + account: &mut purple::Account, + alias: &str, + components: purple::StrHashTable, + ) -> Self { + let c_alias = CString::new(alias).unwrap(); + unsafe { + Self::from_ptr(purple_sys::purple_chat_new( + account.as_mut_ptr(), + c_alias.as_ptr(), + components.into_glib_full(), + )) + .unwrap() + } + } + + pub unsafe fn from_ptr(ptr: *mut purple_sys::PurpleChat) -> Option { + NonNull::new(ptr).map(Self) + } + + pub fn find(account: &mut purple::Account, name: &str) -> Option { + let c_name = CString::new(name).unwrap(); + unsafe { + Self::from_ptr(purple_sys::purple_blist_find_chat( + account.as_mut_ptr(), + c_name.as_ptr(), + )) + } + } + + pub fn as_blist_node(&mut self) -> BlistNode { + unsafe { BlistNode::from_ptr(self.0.as_ptr() as *mut purple_sys::PurpleBlistNode).unwrap() } + } + + pub fn set_alias(&mut self, new_alias: &str) { + let c_alias = CString::new(new_alias).unwrap(); + unsafe { + purple_sys::purple_blist_alias_chat(self.as_mut_ptr(), c_alias.as_ptr()); + } + } + + pub fn get_group(&mut self) -> Option { + let c_group = unsafe { purple_sys::purple_chat_get_group(self.as_mut_ptr()) }; + if c_group.is_null() { + None + } else { + unsafe { purple::Group::from_ptr(c_group) } + } + } + + pub fn add_to_blist(&mut self, group: &mut purple::Group, _node: Option<()>) { + unsafe { + purple_sys::purple_blist_add_chat(self.as_mut_ptr(), group.as_mut_ptr(), null_mut()) + } + } +} + +impl AsPtr for Chat { + type PtrType = purple_sys::PurpleChat; + fn as_ptr(&self) -> *const Self::PtrType { + self.0.as_ptr() + } +} diff --git a/src/purple/command.rs b/src/purple/command.rs new file mode 100644 index 0000000..e69de29 diff --git a/src/purple/connection/connections.rs b/src/purple/connection/connections.rs new file mode 100644 index 0000000..66a84d0 --- /dev/null +++ b/src/purple/connection/connections.rs @@ -0,0 +1,45 @@ +use super::protocol_data::ProtocolData; +use crate::purple::ffi::AsMutPtr; +use crate::purple::Connection; +use std::os::raw::c_void; + +pub struct Connections { + protocol_datas: std::collections::HashSet<*mut ProtocolData>, +} + +impl Connections { + pub fn new() -> Self { + Self { + protocol_datas: Default::default(), + } + } + + pub unsafe fn add(&mut self, connection: Connection, data: T) { + let account = connection.get_account(); + let data_ptr = Box::new(ProtocolData:: { + account, + connection, + data, + }); + let data_raw_ptr = Box::into_raw(data_ptr); + connection.set_protocol_data(data_raw_ptr as *mut c_void); + self.protocol_datas.insert(data_raw_ptr); + } + + pub fn remove(&mut self, connection: Connection) { + let protocol_data_ptr = connection.get_protocol_data() as *mut ProtocolData; + self.protocol_datas.remove(&protocol_data_ptr); + // Retake ownership of the protocol data to drop its data. + unsafe { Box::from_raw(protocol_data_ptr) }; + } + + pub fn get<'b, P>(&mut self, mut ptr: P) -> Option<&'b mut ProtocolData> + where + P: AsMutPtr>, + { + self.protocol_datas + .get(&ptr.as_mut_ptr()) + .cloned() + .map(|p| unsafe { &mut *p }) + } +} diff --git a/src/purple/connection/mod.rs b/src/purple/connection/mod.rs new file mode 100644 index 0000000..c9ca335 --- /dev/null +++ b/src/purple/connection/mod.rs @@ -0,0 +1,100 @@ +use super::ffi::AsPtr; +use super::{Conversation, Plugin}; +use crate::purple; +use crate::purple::PurpleMessageFlags; +use crate::MsgInfo; +use std::ffi::CString; +use std::os::raw::c_void; +use std::ptr::NonNull; + +pub mod connections; +pub mod protocol_data; + +pub use self::connections::Connections; +pub use self::protocol_data::Handle; + +#[derive(Clone, Copy)] +pub struct Connection(NonNull); + +impl Connection { + pub unsafe fn from_raw(ptr: *mut purple_sys::PurpleConnection) -> Option { + NonNull::new(ptr).map(Self) + } + + pub fn get_protocol_plugin(self) -> Option { + let plugin_ptr = unsafe { purple_sys::purple_connection_get_prpl(self.0.as_ptr()) }; + if plugin_ptr.is_null() { + None + } else { + Some(unsafe { Plugin::from_raw(plugin_ptr) }) + } + } + + pub fn set_protocol_data(self, data: *mut c_void) { + unsafe { purple_sys::purple_connection_set_protocol_data(self.0.as_ptr(), data) }; + } + + pub fn get_protocol_data(self) -> *mut c_void { + unsafe { purple_sys::purple_connection_get_protocol_data(self.0.as_ptr()) } + } + + pub fn get_account(self) -> purple::Account { + unsafe { + purple::Account::from_raw(purple_sys::purple_connection_get_account(self.0.as_ptr())) + } + } + + pub fn set_state(self, state: purple::PurpleConnectionState) { + log::info!("Connection state: {:?}", state); + unsafe { purple_sys::purple_connection_set_state(self.0.as_ptr(), state) }; + } + + pub fn error_reason(self, reason: purple::PurpleConnectionError, description: &str) { + let c_description = CString::new(description).unwrap(); + unsafe { + purple_sys::purple_connection_error_reason( + self.0.as_ptr(), + reason, + c_description.as_ptr(), + ); + } + } + + pub fn serv_got_chat_in(self, chat_input: MsgInfo) { + unsafe { + let c_sn = CString::new(chat_input.chat_sn).unwrap(); + let sn_hash = glib_sys::g_str_hash(c_sn.as_ptr() as *mut c_void); + let c_sender = CString::new(chat_input.author_sn).unwrap(); + let c_text = CString::new(chat_input.text).unwrap(); + + purple_sys::serv_got_chat_in( + self.0.as_ptr(), + sn_hash as i32, + c_sender.as_ptr(), + PurpleMessageFlags::PURPLE_MESSAGE_RECV, + c_text.as_ptr(), + chat_input.time as i64, + ) + } + } + + pub fn serv_got_joined_chat(self, name: &str) -> Option { + unsafe { + let c_name = CString::new(name).unwrap(); + let name_hash = glib_sys::g_str_hash(c_name.as_ptr() as *mut c_void); + let conv = purple_sys::serv_got_joined_chat( + self.0.as_ptr(), + name_hash as i32, + c_name.as_ptr(), + ); + Conversation::from_ptr(conv) + } + } +} + +impl AsPtr for Connection { + type PtrType = purple_sys::PurpleConnection; + fn as_ptr(&self) -> *const purple_sys::PurpleConnection { + self.0.as_ptr() + } +} diff --git a/src/purple/connection/protocol_data.rs b/src/purple/connection/protocol_data.rs new file mode 100644 index 0000000..945e672 --- /dev/null +++ b/src/purple/connection/protocol_data.rs @@ -0,0 +1,51 @@ +use crate::purple::ffi::AsPtr; +use crate::purple::{Account, Connection}; + +pub struct Handle(*mut ProtocolData); + +impl std::fmt::Debug for Handle { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(f, "Handle({:?})", self.0) + } +} + +impl From<&mut Connection> for Handle { + fn from(connection: &mut Connection) -> Handle { + Handle(connection.get_protocol_data() as *mut ProtocolData) + } +} + +impl From<&mut Account> for Handle { + fn from(account: &mut Account) -> Handle { + Handle(account.get_connection().unwrap().get_protocol_data() as *mut ProtocolData) + } +} + +impl Clone for Handle { + fn clone(&self) -> Self { + Self(self.0) + } +} + +unsafe impl Send for Handle {} +unsafe impl Sync for Handle {} + +impl AsPtr for Handle { + type PtrType = ProtocolData; + fn as_ptr(&self) -> *const ProtocolData { + self.0 + } +} + +impl AsPtr for &Handle { + type PtrType = ProtocolData; + fn as_ptr(&self) -> *const ProtocolData { + self.0 + } +} + +pub struct ProtocolData { + pub account: Account, + pub connection: Connection, + pub data: T, +} diff --git a/src/purple/conversation.rs b/src/purple/conversation.rs new file mode 100644 index 0000000..ed11bb0 --- /dev/null +++ b/src/purple/conversation.rs @@ -0,0 +1,193 @@ +use super::ffi::{AsMutPtr, AsPtr}; +use super::{Connection, PurpleConvChatBuddyFlags}; +use glib::translate::{FromGlib, ToGlib}; +use std::ffi::{CStr, CString}; +use std::os::raw::{c_char, c_void}; +use std::ptr::{null_mut, NonNull}; + +pub struct ChatConversation(NonNull); +pub struct Conversation(NonNull); + +impl Conversation { + pub unsafe fn from_ptr(ptr: *mut purple_sys::PurpleConversation) -> Option { + NonNull::new(ptr).map(Self) + } + + pub fn find(connection: &mut Connection, id: i32) -> Option { + unsafe { Self::from_ptr(purple_sys::purple_find_chat(connection.as_mut_ptr(), id)) } + } + + pub fn find_by_name(connection: &mut Connection, name: &str) -> Option { + let c_name = CString::new(name).unwrap(); + let sn_hash = unsafe { glib_sys::g_str_hash(c_name.as_ptr() as *mut c_void) }; + Self::find(connection, sn_hash as i32) + } + + pub fn set_title(&mut self, title: &str) { + unsafe { + let c_title = CString::new(title).unwrap(); + purple_sys::purple_conversation_set_title(self.as_mut_ptr(), c_title.as_ptr()); + } + } + + pub fn get_title(&mut self) -> Option<&str> { + unsafe { + let c_value = purple_sys::purple_conversation_get_title(self.as_mut_ptr()); + NonNull::new(c_value as *mut c_char).map(|p| { + CStr::from_ptr(p.as_ptr() as *const c_char) + .to_str() + .unwrap() + }) + } + } + + pub fn get_name(&mut self) -> Option<&str> { + unsafe { + let c_value = purple_sys::purple_conversation_get_name(self.as_mut_ptr()); + NonNull::new(c_value as *mut c_char).map(|p| { + CStr::from_ptr(p.as_ptr() as *const c_char) + .to_str() + .unwrap() + }) + } + } + + pub fn get_connection(&mut self) -> Connection { + unsafe { + let c_connection = purple_sys::purple_conversation_get_gc(self.as_mut_ptr()); + Connection::from_raw(c_connection).unwrap() + } + } + + pub fn present(&mut self) { + unsafe { purple_sys::purple_conversation_present(self.as_mut_ptr()) } + } + + // Unsafe since set_data check for an existing value and frees it as `T` type, while + // being unable to ensure the freed data is really ot `T` type. + pub unsafe fn set_data(&mut self, key: &str, data: T) { + let c_key = CString::new(key).unwrap(); + let existing_ptr = + purple_sys::purple_conversation_get_data(self.as_mut_ptr(), c_key.as_ptr()); + if !existing_ptr.is_null() { + Box::::from_raw(existing_ptr as *mut T); + } + + let data_ptr = Box::into_raw(Box::new(data)); + purple_sys::purple_conversation_set_data( + self.as_mut_ptr(), + c_key.as_ptr(), + data_ptr as *mut c_void, + ); + } + + // Unsafe since get_data doesn't validate the data stored at `key` is really of `T` + // type. + pub unsafe fn get_data<'a, T>(&'a mut self, key: &'_ str) -> Option<&'a mut T> { + let c_key = CString::new(key).unwrap(); + NonNull::new(purple_sys::purple_conversation_get_data( + self.as_mut_ptr(), + c_key.as_ptr(), + )) + .map(|p| &mut *(p.as_ptr() as *mut T)) + } + + // Unsafe since it doesn't validate the data stored at `key` is really of `T` + // type. + pub unsafe fn remove_data(&mut self, key: &str) { + let c_key = CString::new(key).unwrap(); + let existing_ptr = + purple_sys::purple_conversation_get_data(self.as_mut_ptr(), c_key.as_ptr()); + if !existing_ptr.is_null() { + Box::::from_raw(existing_ptr as *mut T); + purple_sys::purple_conversation_set_data(self.as_mut_ptr(), c_key.as_ptr(), null_mut()); + } + } + + pub fn get_chat_data(&mut self) -> Option { + unsafe { + ChatConversation::from_ptr(purple_sys::purple_conversation_get_chat_data( + self.as_mut_ptr(), + )) + } + } +} + +impl ChatConversation { + pub unsafe fn from_ptr(ptr: *mut purple_sys::PurpleConvChat) -> Option { + NonNull::new(ptr).map(Self) + } + + pub fn has_left(&mut self) -> bool { + FromGlib::from_glib(unsafe { purple_sys::purple_conv_chat_has_left(self.0.as_ptr()) }) + } + + pub fn add_user( + &mut self, + user: &str, + extra_msg: &str, + flags: PurpleConvChatBuddyFlags, + new_arrival: bool, + ) { + let c_user = CString::new(user).unwrap(); + let c_extra_msg = CString::new(extra_msg).unwrap(); + log::info!( + "{:?}, {:?}, {:?}, {:?}, {:?}, {:?}, {:?}", + self.as_mut_ptr(), + c_user, + c_user.as_ptr(), + c_extra_msg, + c_extra_msg.as_ptr(), + flags, + new_arrival.to_glib() + ); + unsafe { + purple_sys::purple_conv_chat_add_user( + self.as_mut_ptr(), + c_user.as_ptr(), + c_extra_msg.as_ptr(), + flags, + new_arrival.to_glib(), + ) + } + log::info!("Added user"); + } + + pub fn clear_users(&mut self) { + unsafe { purple_sys::purple_conv_chat_clear_users(self.as_mut_ptr()) } + } + + pub fn set_topic(&mut self, who: &str, topic: &str) { + let c_topic = CString::new(topic).unwrap(); + let c_who = CString::new(who).unwrap(); + unsafe { + purple_sys::purple_conv_chat_set_topic( + self.as_mut_ptr(), + c_who.as_ptr(), + c_topic.as_ptr(), + ); + } + } + + pub fn get_conversation(&mut self) -> Conversation { + unsafe { + Conversation::from_ptr(purple_sys::purple_conv_chat_get_conversation( + self.as_mut_ptr(), + )) + .unwrap() + } + } +} + +impl AsPtr for Conversation { + type PtrType = purple_sys::PurpleConversation; + fn as_ptr(&self) -> *const Self::PtrType { + self.0.as_ptr() + } +} +impl AsPtr for ChatConversation { + type PtrType = purple_sys::PurpleConvChat; + fn as_ptr(&self) -> *const Self::PtrType { + self.0.as_ptr() + } +} diff --git a/src/purple/ffi.rs b/src/purple/ffi.rs new file mode 100644 index 0000000..8783bb2 --- /dev/null +++ b/src/purple/ffi.rs @@ -0,0 +1,106 @@ +use glib::translate::{Ptr, ToGlibPtr}; +use std::ffi::CStr; +use std::os::raw::c_char; +use std::ptr::{null, null_mut, NonNull}; + +pub fn mut_override(ptr: *const T) -> *mut T { + ptr as *mut T +} +pub trait IntoGlibPtr

{ + fn into_glib_full(self) -> *mut P; +} + +impl IntoGlibPtr for P { + fn into_glib_full(mut self) -> *mut P::PtrType { + let ptr = self.as_mut_ptr(); + std::mem::forget(self); + ptr + } +} + +pub trait ToGlibContainerFromIterator

+where + Self: Sized, +{ + fn into_glib_full_from_iter>(iter: I) -> P; +} + +impl ToGlibContainerFromIterator<*mut glib_sys::GList> for T +where + T: AsPtr, + T: IntoGlibPtr

, + P: 'static, +{ + fn into_glib_full_from_iter(iter: I) -> *mut glib_sys::GList + where + I: IntoIterator, + { + let mut list: *mut glib_sys::GList = std::ptr::null_mut(); + unsafe { + for ptr in iter.into_iter().map(|v| v.into_glib_full()) { + list = glib_sys::g_list_prepend(list, Ptr::to(ptr)); + } + glib_sys::g_list_reverse(list) + } + } +} + +impl ToGlibContainerFromIterator<*mut glib_sys::GHashTable> for (&'static CStr, String) { + fn into_glib_full_from_iter(iter: I) -> *mut glib_sys::GHashTable + where + I: IntoIterator, + { + unsafe { + let ptr = glib_sys::g_hash_table_new_full( + Some(glib_sys::g_str_hash), + Some(glib_sys::g_str_equal), + None, + Some(glib_sys::g_free), + ); + for (k, v) in iter { + let k: *const c_char = k.as_ptr(); + let v: *mut c_char = v.to_glib_full(); + glib_sys::g_hash_table_insert(ptr, k as *mut _, v as *mut _); + } + ptr + } + } +} + +pub trait AsPtr { + type PtrType; + fn as_ptr(&self) -> *const Self::PtrType; +} + +pub trait AsMutPtr { + type PtrType; + fn as_mut_ptr(&mut self) -> *mut Self::PtrType; +} + +impl AsMutPtr for T { + type PtrType = T::PtrType; + fn as_mut_ptr(&mut self) -> *mut Self::PtrType { + self.as_ptr() as *mut Self::PtrType + } +} + +impl AsPtr for Option> { + type PtrType = T; + fn as_ptr(&self) -> *const Self::PtrType { + self.map_or_else(null, |x| x.as_ptr()) + } +} + +impl AsPtr for Option<*const T> { + type PtrType = T; + fn as_ptr(&self) -> *const T { + self.unwrap_or_else(null) + } +} + +impl AsPtr for Option<*mut T> { + type PtrType = T; + fn as_ptr(&self) -> *const T { + self.unwrap_or_else(null_mut) + } +} diff --git a/src/purple/group.rs b/src/purple/group.rs new file mode 100644 index 0000000..e4f0a39 --- /dev/null +++ b/src/purple/group.rs @@ -0,0 +1,40 @@ +use super::ffi::{AsMutPtr, AsPtr}; +use std::ffi::CStr; +use std::ffi::CString; +use std::ptr::{null_mut, NonNull}; + +pub struct Group(NonNull); + +impl Group { + pub unsafe fn from_ptr(ptr: *mut purple_sys::PurpleGroup) -> Option { + NonNull::new(ptr).map(Self) + } + + pub fn find(name: &str) -> Option { + let c_name = CString::new(name).unwrap(); + unsafe { Group::from_ptr(purple_sys::purple_find_group(c_name.as_ptr())) } + } + + pub fn new(name: &str) -> Group { + let c_name = CString::new(name).unwrap(); + unsafe { Group::from_ptr(purple_sys::purple_group_new(c_name.as_ptr())).unwrap() } + } + + pub fn add_to_blist(&mut self, _node: Option<()>) { + unsafe { purple_sys::purple_blist_add_group(self.as_mut_ptr(), null_mut()) } + } + + pub fn get_name(&mut self) -> String { + unsafe { + let name_ptr = purple_sys::purple_group_get_name(self.as_mut_ptr()); + CStr::from_ptr(name_ptr).to_str().unwrap().to_string() + } + } +} + +impl AsPtr for Group { + type PtrType = purple_sys::PurpleGroup; + fn as_ptr(&self) -> *const Self::PtrType { + self.0.as_ptr() + } +} diff --git a/src/purple/handlers/entrypoints.rs b/src/purple/handlers/entrypoints.rs new file mode 100644 index 0000000..4663ded --- /dev/null +++ b/src/purple/handlers/entrypoints.rs @@ -0,0 +1,297 @@ +use super::super::{prpl, Account, Connection, Plugin, PurpleMessageFlags, StrHashTable}; +use super::traits; +use crate::purple::ffi::{IntoGlibPtr, ToGlibContainerFromIterator}; +use glib::translate::{ToGlibContainerFromSlice, ToGlibPtr}; +use log::{debug, error}; +use std::ffi::CStr; +use std::os::raw::{c_char, c_void}; +use std::panic::catch_unwind; +use std::ptr::NonNull; + +pub extern "C" fn actions( + _: *mut purple_sys::PurplePlugin, + _: *mut c_void, +) -> *mut glib_sys::GList { + std::ptr::null_mut() +} + +pub extern "C" fn load(plugin_ptr: *mut purple_sys::PurplePlugin) -> i32 { + match catch_unwind(|| { + debug!("load"); + let mut plugin = unsafe { Plugin::from_raw(plugin_ptr) }; + let prpl_plugin = unsafe { plugin.extra::

() }; + prpl_plugin.load(&plugin) as i32 + }) { + Ok(r) => r, + Err(_) => 0, + } +} + +pub extern "C" fn login(account_ptr: *mut purple_sys::PurpleAccount) { + if let Err(error) = catch_unwind(|| { + debug!("login"); + let mut account = unsafe { Account::from_raw(account_ptr) }; + let mut plugin = account + .get_connection() + .expect("No connection found for account") + .get_protocol_plugin() + .expect("No plugin found for connection"); + let prpl_plugin = unsafe { plugin.extra::

() }; + prpl_plugin.login(&mut account); + }) { + error!("Failure in login: {:?}", error) + }; +} + +pub extern "C" fn get_cb_alias( + connection_ptr: *mut purple_sys::PurpleConnection, + id: i32, + c_who: *const c_char, +) -> *mut c_char { + match catch_unwind(|| { + debug!("get_cb_alias"); + let mut connection = unsafe { Connection::from_raw(connection_ptr).unwrap() }; + let mut plugin = connection + .get_protocol_plugin() + .expect("No plugin found for connection"); + let prpl_plugin = unsafe { plugin.extra::

() }; + let who = unsafe { CStr::from_ptr(c_who).to_str().unwrap() }; + prpl_plugin + .get_cb_alias(&mut connection, id, who) + .as_ref() + .map(ToGlibPtr::to_glib_full) + .unwrap_or_else(std::ptr::null_mut) + }) { + Ok(r) => r, + Err(error) => { + error!("Failure in get_cb_alias: {:?}", error); + std::ptr::null_mut() + } + } +} + +pub extern "C" fn chat_info( + connection_ptr: *mut purple_sys::PurpleConnection, +) -> *mut glib_sys::GList { + match catch_unwind(|| { + debug!("chat_info"); + let mut connection = unsafe { Connection::from_raw(connection_ptr).unwrap() }; + let mut plugin = connection + .get_protocol_plugin() + .expect("No plugin found for connection"); + let prpl_plugin = unsafe { plugin.extra::

() }; + ToGlibContainerFromSlice::to_glib_full_from_slice( + &prpl_plugin + .chat_info(&mut connection) + .into_iter() + .map(|x| x.into()) + .collect::>(), + ) + }) { + Ok(r) => r, + Err(error) => { + error!("Failure in chat_info: {:?}", error); + std::ptr::null_mut() + } + } +} + +pub extern "C" fn close( + connection_ptr: *mut purple_sys::PurpleConnection, +) { + if let Err(error) = catch_unwind(|| { + debug!("close"); + let mut connection = unsafe { Connection::from_raw(connection_ptr).unwrap() }; + let mut plugin = connection + .get_protocol_plugin() + .expect("No plugin found for connection"); + let prpl_plugin = unsafe { plugin.extra::

() }; + prpl_plugin.close(&mut connection) + }) { + error!("Failure in close: {:?}", error) + } +} + +pub extern "C" fn list_icon( + account_ptr: *mut purple_sys::PurpleAccount, + _: *mut purple_sys::PurpleBuddy, +) -> *const c_char { + match catch_unwind(|| { + debug!("list_icon"); + let mut account = unsafe { Account::from_raw(account_ptr) }; + P::list_icon(&mut account).as_ptr() + }) { + Ok(r) => r, + Err(error) => { + error!("Failure in list_icon: {:?}", error); + std::ptr::null_mut() + } + } +} + +pub extern "C" fn status_types( + account_ptr: *mut purple_sys::PurpleAccount, +) -> *mut glib_sys::GList { + match catch_unwind(|| { + debug!("status_types"); + let mut account = unsafe { Account::from_raw(account_ptr) }; + ToGlibContainerFromIterator::into_glib_full_from_iter(P::status_types(&mut account)) + }) { + Ok(r) => r, + Err(error) => { + error!("Failure in status_types: {:?}", error); + std::ptr::null_mut() + } + } +} + +pub extern "C" fn join_chat( + connection_ptr: *mut purple_sys::PurpleConnection, + components: *mut glib_sys::GHashTable, +) { + if let Err(error) = catch_unwind(|| { + debug!("join_chat"); + let mut connection = unsafe { Connection::from_raw(connection_ptr).unwrap() }; + let mut plugin = connection + .get_protocol_plugin() + .expect("No plugin found for connection"); + let prpl_plugin = unsafe { plugin.extra::

() }; + let mut data = unsafe { StrHashTable::from_ptr(components) }; + prpl_plugin.join_chat(&mut connection, data.as_mut()) + }) { + error!("Failure in join_chat: {:?}", error) + } +} + +pub extern "C" fn chat_leave( + connection_ptr: *mut purple_sys::PurpleConnection, + id: i32, +) { + if let Err(error) = catch_unwind(|| { + debug!("chat_leave"); + let mut connection = unsafe { Connection::from_raw(connection_ptr).unwrap() }; + let mut plugin = connection + .get_protocol_plugin() + .expect("No plugin found for connection"); + let prpl_plugin = unsafe { plugin.extra::

() }; + prpl_plugin.chat_leave(&mut connection, id) + }) { + error!("Failure in chat_leave: {:?}", error) + } +} + +pub extern "C" fn convo_closed( + connection_ptr: *mut purple_sys::PurpleConnection, + c_who: *const c_char, +) { + if let Err(error) = catch_unwind(|| { + debug!("convo_closed"); + let mut connection = unsafe { Connection::from_raw(connection_ptr).unwrap() }; + let mut plugin = connection + .get_protocol_plugin() + .expect("No plugin found for connection"); + let prpl_plugin = unsafe { plugin.extra::

() }; + let who = NonNull::new(c_who as *mut _) + .map(|p| unsafe { CStr::from_ptr(p.as_ptr()).to_str().unwrap() }); + prpl_plugin.convo_closed(&mut connection, who) + }) { + error!("Failure in convo_closed: {:?}", error) + } +} + +pub extern "C" fn get_chat_name( + data: *mut glib_sys::GHashTable, +) -> *mut c_char { + match catch_unwind(|| { + debug!("get_chat_name"); + let mut data = unsafe { StrHashTable::from_ptr(data) }; + let name = P::get_chat_name(data.as_mut()); + name.to_glib_full() + }) { + Ok(r) => r, + Err(error) => { + error!("Failure in get_chat_name: {:?}", error); + std::ptr::null_mut() + } + } +} + +pub extern "C" fn chat_info_defaults( + connection_ptr: *mut purple_sys::PurpleConnection, + c_chat_name: *const c_char, +) -> *mut glib_sys::GHashTable { + match catch_unwind(|| { + debug!("chat_info_defaults_handler"); + let mut connection = unsafe { Connection::from_raw(connection_ptr).unwrap() }; + let mut plugin = connection + .get_protocol_plugin() + .expect("No plugin found for connection"); + let prpl_plugin = unsafe { plugin.extra::

() }; + + let chat_name = NonNull::new(c_chat_name as *mut _) + .map(|p| unsafe { CStr::from_ptr(p.as_ptr()).to_string_lossy() }); + prpl_plugin + .chat_info_defaults(&mut connection, chat_name.as_deref()) + .into_glib_full() + }) { + Ok(r) => r, + Err(error) => { + error!("Failure in chat_info_defaults: {:?}", error); + std::ptr::null_mut() + } + } +} +pub extern "C" fn roomlist_get_list_handler( + _: *mut purple_sys::PurpleConnection, +) -> *mut purple_sys::PurpleRoomlist { + println!("roomlist_get_list_handler"); + std::ptr::null_mut() +} + +pub extern "C" fn chat_send( + connection_ptr: *mut purple_sys::PurpleConnection, + id: i32, + c_message: *const c_char, + flags: PurpleMessageFlags, +) -> i32 { + match catch_unwind(|| { + debug!("convo_closed"); + let mut connection = unsafe { Connection::from_raw(connection_ptr).unwrap() }; + let mut plugin = connection + .get_protocol_plugin() + .expect("No plugin found for connection"); + let prpl_plugin = unsafe { plugin.extra::

() }; + let message = unsafe { CStr::from_ptr(c_message).to_str().unwrap() }; + prpl_plugin.chat_send(&mut connection, id, message, flags) + }) { + Ok(r) => r, + Err(error) => { + error!("Failure in convo_closed: {:?}", error); + -1 + } + } +} +pub extern "C" fn send_im( + connection_ptr: *mut purple_sys::PurpleConnection, + c_who: *const c_char, + c_message: *const c_char, + flags: PurpleMessageFlags, +) -> i32 { + match catch_unwind(|| { + debug!("convo_closed"); + let mut connection = unsafe { Connection::from_raw(connection_ptr).unwrap() }; + let mut plugin = connection + .get_protocol_plugin() + .expect("No plugin found for connection"); + let prpl_plugin = unsafe { plugin.extra::

() }; + let who = unsafe { CStr::from_ptr(c_who).to_str().unwrap() }; + let message = unsafe { CStr::from_ptr(c_message).to_str().unwrap() }; + prpl_plugin.send_im(&mut connection, who, message, flags) + }) { + Ok(r) => r, + Err(error) => { + error!("Failure in convo_closed: {:?}", error); + -1 + } + } +} diff --git a/src/purple/handlers/mod.rs b/src/purple/handlers/mod.rs new file mode 100644 index 0000000..d77d3f0 --- /dev/null +++ b/src/purple/handlers/mod.rs @@ -0,0 +1,2 @@ +pub mod entrypoints; +pub mod traits; diff --git a/src/purple/handlers/traits.rs b/src/purple/handlers/traits.rs new file mode 100644 index 0000000..c6cecf5 --- /dev/null +++ b/src/purple/handlers/traits.rs @@ -0,0 +1,116 @@ +use super::super::{ + prpl, Account, Connection, Conversation, Plugin, PurpleMessageFlags, StatusType, StrHashTable, +}; +use std::ffi::CStr; + +pub trait LoadHandler { + fn load(&mut self, plugin: &Plugin) -> bool; +} + +pub trait LoginHandler { + fn login(&mut self, account: &mut Account); +} + +pub trait CloseHandler { + fn close(&mut self, connection: &mut Connection); +} + +pub trait StatusTypeHandler { + fn status_types(account: &mut Account) -> Vec; +} + +pub trait ListIconHandler { + fn list_icon(account: &mut Account) -> &'static CStr; +} + +pub trait ChatInfoHandler { + fn chat_info(&mut self, connection: &mut Connection) -> Vec; +} + +pub trait ChatInfoDefaultsHandler { + fn chat_info_defaults( + &mut self, + connection: &mut Connection, + chat_name: Option<&str>, + ) -> StrHashTable; +} + +pub trait JoinChatHandler { + fn join_chat(&mut self, connection: &mut Connection, data: Option<&mut StrHashTable>); +} + +pub trait ChatLeaveHandler { + fn chat_leave(&mut self, connection: &mut Connection, id: i32); +} + +pub trait ConvoClosedHandler { + fn convo_closed(&mut self, connection: &mut Connection, who: Option<&str>); +} + +pub trait GetChatBuddyAlias { + fn get_cb_alias(&mut self, connection: &mut Connection, id: i32, who: &str) -> Option; +} + +pub trait GetChatNameHandler { + fn get_chat_name(data: Option<&mut StrHashTable>) -> Option; +} + +pub trait SendIMHandler { + fn send_im( + &mut self, + connection: &mut Connection, + who: &str, + message: &str, + flags: PurpleMessageFlags, + ) -> i32; +} + +pub trait ChatSendHandler { + fn chat_send( + &mut self, + connection: &mut Connection, + id: i32, + message: &str, + flags: PurpleMessageFlags, + ) -> i32; +} + +pub trait InputHandler { + fn input(&mut self, fd: i32, cond: crate::purple::PurpleInputCondition); + fn enable_input(&mut self, fd: i32, cond: crate::purple::PurpleInputCondition) -> u32 + where + Self: 'static, + { + let self_ptr: *mut Self = self; + crate::purple::input_add(fd, cond, move |fd, cond| { + let this = unsafe { &mut *self_ptr }; + this.input(fd, cond); + }) + } + + fn disable_input(&self, input_handle: u32) -> bool { + unsafe { purple_sys::purple_input_remove(input_handle) != 0 } + } +} + +pub trait CommandHandler { + fn command( + &mut self, + conversation: &mut Conversation, + command: &str, + args: &[&str], + ) -> purple_sys::PurpleCmdRet; + fn enable_command(&mut self, cmd: &str, args: &str, help_text: &str) -> purple_sys::PurpleCmdId + where + Self: 'static, + { + let self_ptr: *mut Self = self; + crate::purple::register_cmd(cmd, args, help_text, move |conversation, cmd, args| { + let this = unsafe { &mut *self_ptr }; + this.command(conversation, cmd, args) + }) + } + fn disable_command(&self, command_id: purple_sys::PurpleCmdId) { + unsafe { purple_sys::purple_cmd_unregister(command_id) } + } +} diff --git a/src/purple/hashtable.rs b/src/purple/hashtable.rs new file mode 100644 index 0000000..c39e5a3 --- /dev/null +++ b/src/purple/hashtable.rs @@ -0,0 +1,71 @@ +use super::ffi::{mut_override, AsPtr}; +use glib::translate::{FromGlib, FromGlibPtrContainer, ToGlibPtr}; +use std::ffi::CStr; +use std::os::raw::{c_char, c_void}; +use std::ptr::NonNull; + +pub type StrHashTable<'a> = HashTable<&'static CStr, &'a str>; + +pub struct HashTable( + NonNull, + std::marker::PhantomData<(K, V)>, +); + +impl Default for HashTable<&'static CStr, &str> { + fn default() -> Self { + Self( + NonNull::new(unsafe { + glib_sys::g_hash_table_new_full( + Some(glib_sys::g_str_hash), + Some(glib_sys::g_str_equal), + None, + Some(glib_sys::g_free), + ) + }) + .unwrap(), + std::marker::PhantomData, + ) + } +} + +impl HashTable<&'static CStr, &str> { + pub unsafe fn from_ptr(ptr: *mut glib_sys::GHashTable) -> Option { + NonNull::new(ptr).map(|p| Self(p, std::marker::PhantomData)) + } + + pub fn insert(&mut self, key: &'static CStr, value: &str) -> bool { + FromGlib::from_glib(unsafe { + glib_sys::g_hash_table_insert( + self.0.as_ptr(), + key.as_ptr() as *mut c_void, + ToGlibPtr::<*mut c_char>::to_glib_full(value) as *mut c_void, + ) + }) + } + + pub fn lookup(&self, key: &'static CStr) -> Option<&str> { + unsafe { + NonNull::new(glib_sys::g_hash_table_lookup( + mut_override(self.as_ptr()), + key.as_ptr() as *const c_void, + ) as *mut c_char) + .map(|p| CStr::from_ptr(p.as_ptr()).to_str().unwrap()) + } + } +} + +impl std::fmt::Debug for HashTable { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + use std::collections::HashMap; + let hashmap: HashMap = + unsafe { FromGlibPtrContainer::from_glib_none(self.0.as_ptr()) }; + write!(f, "HashTable({:?})", hashmap) + } +} + +impl AsPtr for HashTable { + type PtrType = glib_sys::GHashTable; + fn as_ptr(&self) -> *const Self::PtrType { + self.0.as_ptr() + } +} diff --git a/src/purple/loader.rs b/src/purple/loader.rs new file mode 100644 index 0000000..f577522 --- /dev/null +++ b/src/purple/loader.rs @@ -0,0 +1,138 @@ +use super::handlers::entrypoints; +use crate::purple::PrplPlugin; +use log::info; +use std::ffi::CString; +use std::marker::PhantomData; +use std::os::raw::c_void; + +#[derive(Default)] +pub struct RegisterContext

{ + info: Box, + extra_info: Box, + _phantom_marker: PhantomData

, +} + +impl

RegisterContext

{ + pub fn new() -> Self { + RegisterContext { + info: Box::new(purple_sys::PurplePluginInfo::default()), + extra_info: Box::new(purple_sys::PurplePluginProtocolInfo::default()), + _phantom_marker: PhantomData, + } + } + pub fn into_raw(mut self) -> *mut purple_sys::PurplePluginInfo { + self.extra_info.roomlist_get_list = Some(entrypoints::roomlist_get_list_handler); + + self.info.extra_info = Box::into_raw(self.extra_info) as *mut c_void; + + Box::into_raw(self.info) + } + + pub fn with_info(mut self, info: PrplInfo) -> Self { + self.info.id = CString::new(info.id).unwrap().into_raw(); + self.info.name = CString::new(info.name).unwrap().into_raw(); + self.info.version = CString::new(info.version).unwrap().into_raw(); + self.info.summary = CString::new(info.summary).unwrap().into_raw(); + self.info.description = CString::new(info.description).unwrap().into_raw(); + self.info.author = CString::new(info.author).unwrap().into_raw(); + self.info.homepage = CString::new(info.homepage).unwrap().into_raw(); + self.info.actions = Some(entrypoints::actions); + self + } +} + +pub struct PrplPluginLoader(*mut purple_sys::PurplePlugin, PhantomData

); + +impl PrplPluginLoader

{ + pub unsafe fn from_raw(ptr: *mut purple_sys::PurplePlugin) -> Self { + Self(ptr, PhantomData) + } + + pub fn init(&self) -> i32 { + let prpl_plugin = Box::new(P::new()); + let register_context: RegisterContext = RegisterContext::new(); + let register_context = prpl_plugin.register(register_context); + + // Unsafe required to dereference the pointers and call + // purple_plugin_register. Safe otherwise. + unsafe { + (*self.0).info = register_context.into_raw(); + (*self.0).extra = Box::into_raw(prpl_plugin) as *mut c_void; + + info!("Registering"); + purple_sys::purple_plugin_register(self.0) + } + } +} + +pub struct PrplInfo { + pub id: String, + pub name: String, + pub version: String, + pub summary: String, + pub description: String, + pub author: String, + pub homepage: String, +} + +impl Default for PrplInfo { + fn default() -> Self { + PrplInfo { + id: "".into(), + name: "".into(), + version: "".into(), + summary: "".into(), + description: "".into(), + author: "".into(), + homepage: "".into(), + } + } +} + +macro_rules! impl_handler_builder { + ($($f:ident => $t:ident)*) => ($( + paste::item! { + impl]> RegisterContext { + #[allow(dead_code)] + pub fn [](mut self) -> Self { + self.info.[<$f>] = Some(crate::purple::handlers::entrypoints::[<$f>]::); + self + } + } + } + )*) +} + +macro_rules! impl_extra_handler_builder { + ($($f:ident => $t:ident)*) => ($( + paste::item! { + impl]> RegisterContext { + #[allow(dead_code)] + pub fn [](mut self) -> Self { + self.extra_info.[<$f>] = Some(crate::purple::handlers::entrypoints::[<$f>]::); + self + } + } + } + )*) +} + +impl_handler_builder! { + load => LoadHandler +} + +impl_extra_handler_builder! { + login => LoginHandler + chat_info => ChatInfoHandler + chat_info_defaults => ChatInfoDefaultsHandler + close => CloseHandler + status_types => StatusTypeHandler + list_icon => ListIconHandler + join_chat => JoinChatHandler + chat_leave => ChatLeaveHandler + convo_closed => ConvoClosedHandler + get_chat_name => GetChatNameHandler + send_im => SendIMHandler + chat_send => ChatSendHandler + get_cb_alias => GetChatBuddyAlias +} diff --git a/src/purple/mod.rs b/src/purple/mod.rs new file mode 100644 index 0000000..10dd319 --- /dev/null +++ b/src/purple/mod.rs @@ -0,0 +1,150 @@ +pub use self::account::Account; +pub use self::blist::BlistNode; +pub use self::chat::Chat; +pub use self::connection::protocol_data::ProtocolData; +pub use self::connection::{Connection, Connections, Handle}; +pub use self::conversation::Conversation; +pub use self::group::Group; +pub use self::handlers::traits::*; +pub use self::hashtable::StrHashTable; +pub use self::loader::{PrplInfo, PrplPluginLoader, RegisterContext}; +pub use self::plugin::Plugin; +pub use self::status_type::{PurpleStatusPrimitive, StatusType}; +use glib::translate::FromGlibPtrContainer; +pub use purple_sys; +pub use purple_sys::{ + PurpleCmdId, PurpleCmdRet, PurpleConnectionError, PurpleConnectionState, + PurpleConvChatBuddyFlags, PurpleConversationType, PurpleDebugLevel, PurpleInputCondition, + PurpleMessageFlags, +}; +use std::ffi::{CStr, CString}; +use std::os::raw::{c_char, c_void}; +use std::panic::catch_unwind; +use std::ptr; + +lazy_static::lazy_static! { + static ref STR_FORMAT: CString = CString::new("%s").unwrap(); +} + +pub mod account; +mod blist; +mod chat; +mod connection; +mod conversation; +pub mod ffi; +mod group; +mod handlers; +mod hashtable; +mod loader; +mod plugin; +pub mod prpl; +mod status_type; + +pub trait PrplPlugin { + type Plugin; + fn new() -> Self; + fn register(&self, context: RegisterContext) -> RegisterContext; +} + +macro_rules! purple_prpl_plugin { + ($plugin:ty) => { + /// # Safety + /// This function is the plugin entrypoints and should not be called manually. + #[no_mangle] + pub unsafe extern "C" fn purple_init_plugin( + plugin_ptr: *mut purple_sys::PurplePlugin, + ) -> i32 { + // Safe as long as called from libpurple. Should be the + // case since this function is called by libpurple. + let plugin = purple::PrplPluginLoader::<$plugin>::from_raw(plugin_ptr); + plugin.init() + } + }; +} + +pub fn input_add(fd: i32, cond: PurpleInputCondition, callback: F) -> u32 +where + F: Fn(i32, PurpleInputCondition) + 'static, +{ + let user_data = Box::into_raw(Box::new(callback)) as *mut c_void; + unsafe { purple_sys::purple_input_add(fd, cond, Some(trampoline::), user_data) } +} + +unsafe extern "C" fn trampoline(user_data: *mut c_void, df: i32, cond: PurpleInputCondition) +where + F: Fn(i32, PurpleInputCondition), +{ + if let Err(error) = catch_unwind(|| { + let closure = &*(user_data as *mut F); + closure(df, cond); + }) { + log::error!("Failure in input handler: {:?}", error); + } +} + +pub fn register_cmd( + cmd: &str, + args: &str, + help_text: &str, + callback: F, +) -> purple_sys::PurpleCmdId +where + F: Fn(&mut Conversation, &str, &[&str]) -> purple_sys::PurpleCmdRet + 'static, +{ + let user_data = Box::into_raw(Box::new(callback)) as *mut c_void; + let c_cmd = CString::new(cmd).unwrap(); + let c_args = CString::new(args).unwrap(); + let c_help = CString::new(help_text).unwrap(); + + unsafe { + purple_sys::purple_cmd_register( + c_cmd.as_ptr(), + c_args.as_ptr(), + purple_sys::PurpleCmdPriority::PURPLE_CMD_P_DEFAULT, + purple_sys::PurpleCmdFlag::PURPLE_CMD_FLAG_CHAT, + ptr::null(), + Some(trampoline_cmd::), + c_help.as_ptr(), + user_data, + ) + } +} + +unsafe extern "C" fn trampoline_cmd( + conversation_ptr: *mut purple_sys::PurpleConversation, + c_cmd: *const c_char, + c_args: *mut *mut c_char, + _c_error: *mut *mut c_char, + user_data: *mut c_void, +) -> purple_sys::PurpleCmdRet +where + F: Fn(&mut Conversation, &str, &[&str]) -> purple_sys::PurpleCmdRet, +{ + let closure = &*(user_data as *mut F); + + let cmd = CStr::from_ptr(c_cmd).to_str().unwrap(); + let args: Vec = FromGlibPtrContainer::from_glib_none(c_args); + let mut conversation = Conversation::from_ptr(conversation_ptr).unwrap(); + + closure( + &mut conversation, + cmd, + args.iter() + .map(std::ops::Deref::deref) + .collect::>() + .as_slice(), + ) +} + +pub fn debug(level: PurpleDebugLevel, target: &str, message: &str) { + let c_target = CString::new(target).unwrap(); + let c_message = CString::new(message).unwrap(); + unsafe { + purple_sys::purple_debug( + level, + c_target.as_ptr(), + STR_FORMAT.as_ptr(), + c_message.as_ptr(), + ) + } +} diff --git a/src/purple/plugin.rs b/src/purple/plugin.rs new file mode 100644 index 0000000..d6a3cd4 --- /dev/null +++ b/src/purple/plugin.rs @@ -0,0 +1,11 @@ +pub struct Plugin(*mut purple_sys::PurplePlugin); + +impl Plugin { + pub unsafe fn from_raw(ptr: *mut purple_sys::PurplePlugin) -> Self { + Plugin(ptr) + } + + pub unsafe fn extra<'a, T>(&mut self) -> &'a mut T { + &mut *((*self.0).extra as *mut T) + } +} diff --git a/src/purple/prpl.rs b/src/purple/prpl.rs new file mode 100644 index 0000000..3f6885e --- /dev/null +++ b/src/purple/prpl.rs @@ -0,0 +1,50 @@ +use glib::translate::{GlibPtrDefault, Stash, ToGlib, ToGlibPtr}; +use std::ffi::CStr; + +pub struct ChatEntry { + pub label: &'static CStr, + pub identifier: &'static CStr, + pub required: bool, + pub is_int: bool, + pub min: i32, + pub max: i32, + pub secret: bool, +} + +pub struct ProtoChatEntry(purple_sys::proto_chat_entry); + +impl Into for ChatEntry { + fn into(self) -> ProtoChatEntry { + ProtoChatEntry(purple_sys::proto_chat_entry { + label: self.label.as_ptr(), + identifier: self.identifier.as_ptr(), + required: self.required.to_glib(), + is_int: self.is_int.to_glib(), + min: self.min, + max: self.max, + secret: self.secret.to_glib(), + }) + } +} + +impl GlibPtrDefault for ProtoChatEntry { + type GlibType = *const purple_sys::proto_chat_entry; +} + +impl<'a> ToGlibPtr<'a, *const purple_sys::proto_chat_entry> for ProtoChatEntry { + type Storage = &'a ProtoChatEntry; + + fn to_glib_none(&'a self) -> Stash<'a, *const purple_sys::proto_chat_entry, Self> { + Stash(&self.0 as *const purple_sys::proto_chat_entry, self) + } + + fn to_glib_full(&self) -> *const purple_sys::proto_chat_entry { + unsafe { + let res = glib_sys::g_malloc(std::mem::size_of::()) + as *mut purple_sys::proto_chat_entry; + + *res = self.0; + res + } + } +} diff --git a/src/purple/status_type.rs b/src/purple/status_type.rs new file mode 100644 index 0000000..112afef --- /dev/null +++ b/src/purple/status_type.rs @@ -0,0 +1,31 @@ +use super::ffi::{mut_override, AsPtr}; +use glib::translate::ToGlib; +pub use purple_sys::PurpleStatusPrimitive; +use std::ffi::CStr; + +pub struct StatusType(*mut purple_sys::PurpleStatusType); + +impl StatusType { + pub fn new( + primitive: PurpleStatusPrimitive, + id: Option<&'static CStr>, + name: Option<&'static CStr>, + user_settable: bool, + ) -> Self { + unsafe { + Self(purple_sys::purple_status_type_new( + primitive, + id.map_or_else(std::ptr::null_mut, |s| mut_override(s.as_ptr())), + name.map_or_else(std::ptr::null_mut, |s| mut_override(s.as_ptr())), + user_settable.to_glib(), + )) + } + } +} + +impl AsPtr for StatusType { + type PtrType = purple_sys::PurpleStatusType; + fn as_ptr(&self) -> *const Self::PtrType { + self.0 + } +}