pax_global_header00006660000000000000000000000064144526547610014530gustar00rootroot0000000000000052 comment=8274be77a0b01f3e29bd1137be77d82077c038a3 catgirl-2.2/000077500000000000000000000000001445265476100130205ustar00rootroot00000000000000catgirl-2.2/.gitignore000066400000000000000000000000701445265476100150050ustar00rootroot00000000000000*.o *.t catgirl chroot.tar config.mk root/ sandman tags catgirl-2.2/LICENSE000066400000000000000000001045151445265476100140330ustar00rootroot00000000000000 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 . catgirl-2.2/Makefile000066400000000000000000000032431445265476100144620ustar00rootroot00000000000000PREFIX ?= /usr/local BINDIR ?= ${PREFIX}/bin MANDIR ?= ${PREFIX}/man CEXTS = gnu-case-range gnu-conditional-omitted-operand CFLAGS += -std=c11 -Wall -Wextra -Wpedantic -Wmissing-prototypes CFLAGS += ${CEXTS:%=-Wno-%} LDADD.libtls = -ltls LDADD.ncursesw = -lncursesw BINS = catgirl MANS = ${BINS:=.1} -include config.mk LDLIBS = ${LDADD.libtls} ${LDADD.ncursesw} LDLIBS.sandman = -framework Cocoa OBJS += buffer.o OBJS += chat.o OBJS += command.o OBJS += complete.o OBJS += config.o OBJS += edit.o OBJS += filter.o OBJS += handle.o OBJS += input.o OBJS += irc.o OBJS += log.o OBJS += ui.o OBJS += url.o OBJS += window.o OBJS += xdg.o OBJS.sandman = sandman.o TESTS += edit.t dev: tags all check all: ${BINS} catgirl: ${OBJS} ${CC} ${LDFLAGS} ${OBJS} ${LDLIBS} -o $@ ${OBJS}: chat.h edit.o edit.t input.o: edit.h sandman: ${OBJS.sandman} ${CC} ${LDFLAGS} ${OBJS.$@} ${LDLIBS.$@} -o $@ check: ${TESTS} .SUFFIXES: .t .c.t: ${CC} ${CFLAGS} -DTEST ${LDFLAGS} $< ${LDLIBS} -o $@ ./$@ || rm $@ tags: *.[ch] ctags -w *.[ch] clean: rm -f ${BINS} ${OBJS} ${OBJS.sandman} ${TESTS} tags install: ${BINS} ${MANS} install -d ${DESTDIR}${BINDIR} ${DESTDIR}${MANDIR}/man1 install ${BINS} ${DESTDIR}${BINDIR} install -m 644 ${MANS} ${DESTDIR}${MANDIR}/man1 uninstall: rm -f ${BINS:%=${DESTDIR}${BINDIR}/%} rm -f ${MANS:%=${DESTDIR}${MANDIR}/man1/%} CHROOT_USER = chat CHROOT_GROUP = ${CHROOT_USER} chroot.tar: catgirl catgirl.1 scripts/chroot-prompt.sh scripts/chroot-man.sh chroot.tar: scripts/build-chroot.sh sh scripts/build-chroot.sh ${CHROOT_USER} ${CHROOT_GROUP} install-chroot: chroot.tar tar -px -f chroot.tar -C /home/${CHROOT_USER} clean-chroot: rm -fr chroot.tar root catgirl-2.2/README.7000066400000000000000000000113361445265476100140510ustar00rootroot00000000000000.\" To view this file: $ man ./README.7 .Dd July 9, 2023 .Dt README 7 .Os "Causal Agency" . .Sh NAME .Nm catgirl .Nd IRC client . .Sh DESCRIPTION .Xr catgirl 1 is a terminal IRC client. . .Pp Screenshot: imagine, if you will, text on a screen, next to names in a selection of colours. . .Ss Notable Features .Bl -bullet .It Tab complete: most recently seen or mentioned nicks are completed first. Commas are inserted between multiple nicks. .It Prompt: the prompt clearly shows whether input will be interpreted as a command or sent as a message. .It Split scroll: keeps the latest messages in view while scrolling. .It URL detection: recent URLs from a particular user or matching a substring can be opened or copied. .It Nick coloring: color generation based on usernames remains stable across nick changes. Mentions of users in messages are colored. .It Topic diffing: the modified portion of a channel topic change is highlighted. .It Ignore: visibility of filtered messages can be toggled. .It Security: on .Fx and .Ox , the .Cm restrict option enables tight sandboxing. Sandboxing is always used on .Ox . .El . .Ss Non-features .Bl -bullet .It Dynamic configuration: all configuration happens in a simple text file or on the command line. .It Multi-network: a terminal multiplexer such as .Xr screen 1 or .Xr tmux 1 (or just your regular terminal emulator tabs) can be used to connect .Nm to multiple networks. .It Reconnection: when the connection to the server is lost, .Nm exits. It can be run in a loop or connected to a bouncer, such as .Lk https://git.causal.agency/pounce "pounce" . .It CTCP: apart from .Sy ACTION , this protocol is useless at best and enables abuse at worst. .It Protocol coverage: IRCv3 extensions are implemented only where they contribute to the intended user experience. .It Cleartext IRC: TLS is now ubiquitous and certificates are easy to obtain. .El . .Sh INSTALLING .Nm requires ncurses and .Sy libtls , provided by either .Lk https://git.causal.agency/libretls/about LibreTLS (for OpenSSL) or by LibreSSL. It targets .Fx , .Ox , macOS and Linux. .Nm and .Sy libtls may be packaged for your system. Check the Repology pages for .Lk https://repology.org/project/catgirl/versions catgirl and .Lk https://repology.org/project/libretls/versions libretls . . .Bd -literal -offset indent $ ./configure $ make all # make install .Ed . .Pp Packagers are encouraged to patch in their own text macros in .Pa input.c . . .Pp If installing .Sy libtls manually to .Pa /usr/local , for example, make sure .Pa /usr/local/lib appears in .Pa /etc/ld.so.conf or .Pa /etc/ld.so.conf.d/* and be sure to run .Xr ldconfig 8 once the library is installed. Set .Ev PKG_CONFIG_PATH for .Nm ./configure to find it. .Bd -literal -offset indent $ PKG_CONFIG_PATH=/usr/local/lib/pkgconfig ./configure .Ed . .Pp The .Nm sandman wrapper is provided for macOS to stop and start .Nm on system sleep and wake. To enable it, configure with: .Bd -literal -offset indent $ ./configure --enable-sandman .Ed . .Sh FILES .Bl -tag -width "command.c" -compact .It Pa chat.h global state and declarations .It Pa chat.c startup and event loop .It Pa irc.c IRC connection and parsing .It Pa ui.c curses interface .It Pa window.c window management .It Pa input.c input handling .It Pa handle.c IRC message handling .It Pa command.c command handling .It Pa buffer.c line wrapping .It Pa edit.c line editing .It Pa complete.c tab complete .It Pa url.c URL detection .It Pa filter.c message filtering .It Pa log.c chat logging .It Pa config.c configuration parsing .It Pa xdg.c XDG base directories .It Pa sandman.m sleep/wake wrapper for macOS .El . .Pp .Bl -tag -width "scripts/notify-send.scpt" -compact .It Pa scripts/chat.tmux.conf example .Xr tmux 1 configuration for multiple networks and automatic reconnects .It Pa scripts/notify-send.scpt .Xr notify-send 1 in AppleScript .It Pa scripts/build-chroot.sh chroot builder for .Ox and .Fx .It Pa scripts/chroot-prompt.sh name prompt wrapper for chroot .It Pa scripts/chroot-man.sh .Xr man 1 implementation for chroot .It Pa scripts/sshd_config .Xr sshd 8 configuration for public chroot .El . .Sh CONTRIBUTING The upstream URL of this project is .Aq Lk https://git.causal.agency/catgirl . Contributions in any form can be sent to .Aq Mt list+catgirl@causal.agency . For sending patches by email, see .Aq Lk https://git-send-email.io . Mailing list archives are available at .Aq Lk https://causal.agency/list/catgirl.html . . .Pp Monetary contributions can be .Lk https://liberapay.com/june/donate "donated via Liberapay" . . .Sh SEE ALSO .Xr catgirl 1 , .Xr sandman 1 . .Pp IRC bouncer: .Lk https://git.causal.agency/pounce "pounce" . .Rs .%A June McEnroe .%T IRC Suite .%U https://text.causal.agency/010-irc-suite.txt .%D June 19, 2020 .Re . .\" To view this file: $ man ./README.7 catgirl-2.2/buffer.c000066400000000000000000000142001445265476100144320ustar00rootroot00000000000000/* Copyright (C) 2020 June McEnroe * * 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 . * * Additional permission under GNU GPL version 3 section 7: * * If you modify this Program, or any covered work, by linking or * combining it with OpenSSL (or a modified version of that library), * containing parts covered by the terms of the OpenSSL License and the * original SSLeay license, the licensors of this Program grant you * additional permission to convey the resulting work. Corresponding * Source for a non-source form of such a combination shall include the * source code for the parts of OpenSSL used as well as that of the * covered work. */ #include #include #include #include #include #include #include #include #include #include "chat.h" struct Lines { size_t len; struct Line lines[BufferCap]; }; _Static_assert(!(BufferCap & (BufferCap - 1)), "BufferCap is power of two"); struct Buffer { struct Lines soft; struct Lines hard; }; struct Buffer *bufferAlloc(void) { struct Buffer *buffer = calloc(1, sizeof(*buffer)); if (!buffer) err(EX_OSERR, "calloc"); return buffer; } void bufferFree(struct Buffer *buffer) { for (size_t i = 0; i < BufferCap; ++i) { free(buffer->soft.lines[i].str); free(buffer->hard.lines[i].str); } free(buffer); } static const struct Line *linesLine(const struct Lines *lines, size_t i) { const struct Line *line = &lines->lines[(lines->len + i) % BufferCap]; return (line->str ? line : NULL); } static struct Line *linesNext(struct Lines *lines) { struct Line *line = &lines->lines[lines->len++ % BufferCap]; free(line->str); return line; } const struct Line *bufferSoft(const struct Buffer *buffer, size_t i) { return linesLine(&buffer->soft, i); } const struct Line *bufferHard(const struct Buffer *buffer, size_t i) { return linesLine(&buffer->hard, i); } enum { StyleCap = 10 }; static char *styleCopy(char *ptr, char *end, struct Style style) { ptr = seprintf( ptr, end, "%s%s%s%s", (style.attr & Bold ? (const char []) { B, '\0' } : ""), (style.attr & Reverse ? (const char []) { R, '\0' } : ""), (style.attr & Italic ? (const char []) { I, '\0' } : ""), (style.attr & Underline ? (const char []) { U, '\0' } : "") ); if (style.fg != Default || style.bg != Default) { ptr = seprintf(ptr, end, "\3%02d,%02d", style.fg, style.bg); } return ptr; } static const wchar_t ZWS = L'\u200B'; static const wchar_t ZWNJ = L'\u200C'; static int flow(struct Lines *hard, int cols, const struct Line *soft) { int flowed = 1; struct Line *line = linesNext(hard); line->num = soft->num; line->heat = soft->heat; line->time = soft->time; line->str = strdup(soft->str); if (!line->str) err(EX_OSERR, "strdup"); int width = 0; int align = 0; char *wrap = NULL; struct Style style = StyleDefault; struct Style wrapStyle = StyleDefault; for (char *str = line->str; *str;) { size_t len = styleParse(&style, (const char **)&str); if (!len) continue; bool tab = (*str == '\t' && !align); if (tab) *str = ' '; wchar_t wc = L'\0'; int n = mbtowc(&wc, str, len); if (n < 0) { n = 1; // ncurses will render these as "~A". width += (*str & '\200' ? 2 : 1); } else if (wc == ZWS || wc == ZWNJ) { // ncurses likes to render these as spaces when they should be // zero-width, so just remove them entirely. memmove(str, &str[n], strlen(&str[n]) + 1); continue; } else if (wc == L'\t') { // Assuming TABSIZE = 8. width += 8 - (width % 8); } else if (wc < L' ' || wc == L'\177') { // ncurses will render these as "^A". width += 2; } else if (wcwidth(wc) > 0) { width += wcwidth(wc); } if (tab && width < cols) { align = width; wrap = NULL; } if (iswspace(wc) && !tab) { wrap = str; wrapStyle = style; } if (wc == L'-' && width <= cols) { wrap = &str[n]; wrapStyle = style; } if (width <= cols) { str += n; continue; } else if (!wrap) { wrap = str; wrapStyle = style; } n = 0; len = strlen(wrap); for (int m; wrap[n] && (m = mbtowc(&wc, &wrap[n], len - n)); n += m) { if (m < 0) { m = 1; } else if (!iswspace(wc)) { break; } } if (!wrap[n]) { *wrap = '\0'; break; } flowed++; line = linesNext(hard); line->num = soft->num; line->heat = soft->heat; line->time = 0; size_t cap = StyleCap + align + strlen(&wrap[n]) + 1; line->str = malloc(cap); if (!line->str) err(EX_OSERR, "malloc"); char *end = &line->str[cap]; str = seprintf(line->str, end, "%*s", (width = align), ""); str = styleCopy(str, end, wrapStyle); style = wrapStyle; seprintf(str, end, "%s", &wrap[n]); *wrap = '\0'; wrap = NULL; } return flowed; } int bufferPush( struct Buffer *buffer, int cols, enum Heat thresh, enum Heat heat, time_t time, const char *str ) { struct Line *soft = linesNext(&buffer->soft); soft->num = buffer->soft.len; soft->heat = heat; soft->time = time; soft->str = strdup(str); if (!soft->str) err(EX_OSERR, "strdup"); if (heat < thresh) return 0; return flow(&buffer->hard, cols, soft); } int bufferReflow(struct Buffer *buffer, int cols, enum Heat thresh, size_t tail) { buffer->hard.len = 0; for (size_t i = 0; i < BufferCap; ++i) { free(buffer->hard.lines[i].str); buffer->hard.lines[i].str = NULL; } int flowed = 0; for (size_t i = 0; i < BufferCap; ++i) { const struct Line *soft = bufferSoft(buffer, i); if (!soft) continue; if (soft->heat < thresh) continue; int n = flow(&buffer->hard, cols, soft); if (i >= BufferCap - tail) flowed += n; } return flowed; } catgirl-2.2/catgirl.1000066400000000000000000000533411445265476100145350ustar00rootroot00000000000000.Dd May 29, 2022 .Dt CATGIRL 1 .Os . .Sh NAME .Nm catgirl .Nd IRC client . .Sh SYNOPSIS .Nm .Op Fl KRelqv .Op Fl C Ar copy .Op Fl H Ar hash .Op Fl I Ar highlight .Op Fl N Ar notify .Op Fl O Ar open .Op Fl S Ar bind .Op Fl T Ns Op Ar timestamp .Op Fl a Ar plain .Op Fl c Ar cert .Op Fl h Ar host .Op Fl i Ar ignore .Op Fl j Ar join .Op Fl k Ar priv .Op Fl m Ar mode .Op Fl n Ar nick .Op Fl p Ar port .Op Fl r Ar real .Op Fl s Ar save .Op Fl t Ar trust .Op Fl u Ar user .Op Fl w Ar pass .Op Ar config ... . .Nm .Fl o .Op Fl S Ar bind .Op Fl h Ar host .Op Fl p Ar port .Op Ar config ... . .Nm .Fl g Ar cert . .Sh DESCRIPTION The .Nm IRC client provides a curses interface for TLS-only Internet Relay Chat. The only required option is .Fl h , the host name to connect to. See .Sx EXAMPLES for managing further configuration. Type .Ic /help in .Nm to view the list of .Sx COMMANDS and .Sx KEY BINDINGS . . .Pp Options can be loaded from files listed on the command line. Files are searched for in .Pa $XDG_CONFIG_DIRS/catgirl .Po usually .Pa ~/.config/catgirl .Pc unless the path starts with .Ql / , .Ql \&./ or .Ql \&../ . Files and flags listed later on the command line take precedence over those listed earlier. . .Pp Each option is placed on a line, and lines beginning with .Ql # are ignored. The options are listed below following their corresponding flags. . .Bl -tag -width Ds .It Fl C Ar util | Cm copy No = Ar util Set the utility used by .Ic /copy . Subsequent .Cm copy options append arguments to .Ar util . The URL to copy is provided to .Ar util on standard input. The default is the first available of .Xr pbcopy 1 , .Xr wl-copy 1 , .Xr xclip 1 , .Xr xsel 1 . . .It Fl H Ar seed,bound | Cm hash No = Ar seed,bound Set the initial seed of the nick and channel color hash function and the maximum IRC color value produced by the function. The default is 0,75. To use only colors from the 16-color terminal set, use 0,15. To disable nick and channel colors, use 0,0. . .It Fl I Ar pattern | Cm highlight No = Ar pattern Add a case-insensitive message highlight pattern, which may contain .Ql * , .Ql \&? and .Ql [] wildcards as in .Xr glob 7 . The format of the pattern is as follows: .Bd -ragged -offset indent .Ar nick Ns Op Ar !user@host Op Ar command Op Ar channel Op Ar message .Ed .Pp The commands which can be matched are: .Sy INVITE , .Sy JOIN , .Sy NICK , .Sy NOTICE , .Sy PART , .Sy PRIVMSG , .Sy QUIT , .Sy SETNAME . . .It Fl K | Cm kiosk Disable the .Ic /copy , .Ic /debug , .Ic /exec , .Ic /join , .Ic /list , .Ic /msg , .Ic /open , .Ic /part , .Ic /query , .Ic /quote commands. Replace the username with a hash of its original value. . .It Fl N Ar util | Cm notify No = Ar util Send notifications using a utility. Subsequent .Cm notify options append arguments to .Ar util . The window name and message are provided to .Ar util as two additional arguments, appropriate for .Xr notify-send 1 . . .It Fl O Ar util | Cm open No = Ar util Set the utility used by .Ic /open . Subsequent .Cm open options append arguments to .Ar util . The URL to open is provided to .Ar util as an argument. The default is the first available of .Xr open 1 , .Xr xdg-open 1 . . .It Fl R | Cm restrict Disable the .Ic /copy , .Ic /exec and .Ic /open commands, the .Cm notify option, and viewing this manual with .Ic /help . . .It Fl S Ar host | Cm bind No = Ar host Bind to source address .Ar host when connecting to the server. To connect from any address over IPv4 only, use 0.0.0.0. To connect from any address over IPv6 only, use ::. . .It Fl T Ns Oo Ar format Oc | Cm timestamp Op = Ar format Show timestamps by default, in the specified .Xr strftime 3 .Ar format . The format string may contain raw IRC formatting codes. The default format is .Qq \&%X . . .It Fl a Ar user : Ns Ar pass | Cm sasl-plain No = Ar user : Ns Ar pass Authenticate as .Ar user with .Ar pass using SASL PLAIN. Leave .Ar pass blank to prompt for the password. . .It Fl c Ar path | Cm cert No = Ar path Load the TLS client certificate from .Ar path . The .Ar path is searched for in the same manner as configuration files. If the private key is in a separate file, it is loaded with .Cm priv . With .Cm sasl-external , authenticate using SASL EXTERNAL. Certificates can be generated with .Fl g . . .It Fl e | Cm sasl-external Authenticate using SASL EXTERNAL, also known as CertFP. The TLS client certificate is loaded with .Cm cert . See .Sx Configuring CertFP . . .It Fl g Ar path Generate a TLS client certificate using .Xr openssl 1 and write it to .Ar path . . .It Fl h Ar host | Cm host No = Ar host Connect to .Ar host . . .It Fl i Ar pattern | Cm ignore No = Ar pattern Add a case-insensitive message ignore pattern, which may contain .Ql * , .Ql \&? and .Ql [] wildcards as in .Xr glob 7 . The format of the pattern is as follows: .Bd -ragged -offset indent .Ar nick Ns Op Ar !user@host Op Ar command Op Ar channel Op Ar message .Ed .Pp The commands which can be matched are: .Sy INVITE , .Sy JOIN , .Sy NICK , .Sy NOTICE , .Sy PART , .Sy PRIVMSG , .Sy QUIT , .Sy SETNAME . . .It Fl j Ar channels Oo Ar keys Oc | Cm join No = Ar channels Oo Ar keys Oc Join the comma-separated list of .Ar channels with the optional comma-separated list of channel .Ar keys . . .It Fl k Ar path | Cm priv No = Ar priv Load the TLS client private key from .Ar path . The .Ar path is searched for in the same manner as configuration files. . .It Fl l | Cm log Log chat events to files in paths .Pa $XDG_DATA_HOME/catgirl/log/network/channel/YYYY-MM-DD.log . . .It Fl m Ar mode | Cm mode No = Ar mode Set the user .Ar mode . . .It Fl n Ar nick Oo Ar ... Oc | Cm nick No = Ar nick Oo Ar ... Oc Set nickname to .Ar nick . The default nickname is the value of the environment variable .Ev USER . Additional space-separated nicks will be tried in order if the first is not available, and all nicks are treated as highlight words. . .It Fl o Print the server certificate chain to standard output in PEM format and exit. . .It Fl p Ar port | Cm port No = Ar port Connect to .Ar port . The default port is 6697. . .It Fl q | Cm quiet Raise the default message visibility threshold for new windows, hiding general events (joins, quits, etc.). . .It Fl r Ar real | Cm real No = Ar real Set realname to .Ar real . The default realname is the same as the nickname. . .It Fl s Ar name | Cm save No = Ar name Save and load the contents of windows from .Ar name in .Pa $XDG_DATA_DIRS/catgirl , or an absolute or relative path if .Ar name starts with .Ql / , .Ql \&./ , or .Ql \&../ . . .It Fl t Ar path | Cm trust No = Ar path Trust the self-signed certificate loaded from .Ar path and disable server name verification. The .Ar path is searched for in the same manner as configuration files. See .Sx Connecting to Servers with Self-signed Certificates . . .It Fl u Ar user | Cm user No = Ar user Set username to .Ar user . The default username is the same as the nickname. . .It Fl v | Cm debug Log raw IRC messages to the .Sy window as well as standard error if it is not a terminal. . .It Fl w Ar pass | Cm pass No = Ar pass Log in with the server password .Ar pass . Leave .Ar pass blank to prompt for the password. .El . .Ss Configuring CertFP .Bl -enum .It Generate a new TLS client certificate: .Bd -literal -offset indent $ catgirl -g ~/.config/catgirl/example.pem .Ed .It Connect to the server using the certificate: .Bd -literal -offset indent cert = example.pem # or: $ catgirl -c example.pem .Ed .It Identify with services or use .Cm sasl-plain , then add the certificate fingerprint to your account: .Bd -literal -offset indent /ns CERT ADD .Ed .It Enable SASL EXTERNAL to require successful authentication when connecting (not possible on all networks): .Bd -literal -offset indent cert = example.pem sasl-external # or: $ catgirl -e -c example.pem .Ed .El . .Ss Connecting to Servers with Self-signed Certificates .Bl -enum .It Connect to the server and write its certificate to a file: .Bd -literal -offset indent $ catgirl -o -h irc.example.org > ~/.config/catgirl/example.pem .Ed .It Configure .Nm to trust the certificate: .Bd -literal -offset indent trust = example.pem # or: $ catgirl -t example.pem .Ed .El . .Sh INTERFACE The .Nm interface is split into three areas. . .Ss Status Line The top line of the terminal shows window statuses. Only the currently active window and windows with activity are listed. The status line for a window might look like this: .Bd -literal -offset indent 1+ #ascii.town +3 ~7 @ .Ed .Pp The number on the left is the window number. Following it may be one of .Ql - , .Ql + , .Ql ++ , as well as .Ql = . These indicate the message visibility threshold and mute status of the window. .Pp On the right side, the number following .Ql + indicates the number of unread messages. The number following .Ql ~ indicates how many lines are below the scroll position. An .Ql @ indicates that there is unsent input in the window's .Sx Input Line . .Pp .Nm will also set the terminal title, if possible, to the name of the network and active window, followed by the unread count for that window, and the unread count for all other windows in parentheses. . .Ss Chat Area The chat area shows messages and events. Regular messages are shown with the nick between .Ql <> angle brackets. Actions are shown with the nick preceded by .Ql * . Notices are shown with the nick between .Ql - hyphens. .Pp Blank lines are inserted into the chat as unread markers. .Pp While scrolling, the most recent 5 lines of chat are kept visible below a marker line. . .Ss Input Line The bottom line of the terminal is where messages and commands are entered. When entering a message, action or notice, your nick appears on the left, as it would in the .Sx Chat Area . When entering a command, no nick is shown. .Pp Formatting codes are shown in the input line as reverse-video uppercase letters. These will not appear in the sent message. .Pp Input that is too long to send as a single message will have a red background starting at the point where it will be split into a second message. . .Sh COMMANDS Any unique prefix can be used to abbreviate a command. For example, .Ic /join can be typed .Ic /j . . .Ss Chat Commands .Bl -tag -width Ds .It Ic /away Op Ar message Set or clear your away status. .It Ic /cs Ar command Send a command to ChanServ. .It Ic /invite Ar nick Invite a user to the channel. .It Ic /join Op Ar channel Op Ar key Join the named channel, the current channel, or the channel you've been invited to. .It Ic /list Op Ar channel List channels. .It Ic /me Op Ar action Send an action message. .It Ic /msg Ar nick message Send a private message. .It Ic /names List users in the channel. .It Ic /nick Ar nick Change nicknames. .It Ic /notice Ar message Send a notice. .It Ic /ns Ar command Send a command to NickServ. .It Ic /ops List channel operators. .It Ic /part Op Ar message Leave the channel. .It Ic /query Ar nick Start a private conversation. .It Ic /quit Op Ar message Quit IRC. .It Ic /quote Ar command Send a raw IRC command. Use .Ic M-- to show unknown replies. .It Ic /say Ar message Send a regular message. .It Ic /setname Ar name Update realname if supported by the server. .It Ic /topic Op Ar topic Show or set the topic of the channel. Press .Ic Tab twice to copy the current topic. .It Ic /whois Op Ar nick Query information about a user or yourself. .It Ic /whowas Ar nick Query past information about a user. .El . .Ss UI Commands .Bl -tag -width Ds .It Ic /close Op Ar name | num Close the named, numbered or current window. .It Ic /copy Op Ar nick | substring Copy the most recent URL from .Ar nick or matching .Ar substring . .It Ic /debug Toggle logging in the .Sy window. .It Ic /exec Ar command Run .Ar command with .Ev SHELL and interpret its output as input to the current window, including as commands. .It Ic /help View this manual. Type .Ic q to return to .Nm . .It Ic /help Ar topic List the server help for a topic. Try .Ic /help index for a list of topics. .It Ic /highlight Op Ar pattern List message highlight patterns or temporarily add a pattern. To permanently add a pattern, use the .Cm highlight option. .It Ic /ignore Op Ar pattern List message ignore patterns or temporarily add a pattern. To permanently add a pattern, use the .Cm ignore option. .It Ic /move Oo Ar name Oc Ar num Move the named or current window to number. .It Ic /open Op Ar count Open each of .Ar count most recent URLs. .It Ic /open Ar nick | substring Open the most recent URL from .Ar nick or matching .Ar substring . .It Ic /unhighlight Ar pattern Temporarily remove a message highlight pattern. .It Ic /unignore Ar pattern Temporarily remove a message ignore pattern. .It Ic /window List all windows. .It Ic /window Ar name | substring Switch to window by name or matching substring. .It Ic /window Ar num | Ic / Ns Ar num Switch to window by number. .El . .Ss Operator Commands .Bl -tag -width Ds .It Ic /ban Op Ar mask ... List or ban masks from the channel. .It Ic /deop Op Ar nick ... Revoke channel operator status from users or yourself. .It Ic /devoice Op Ar nick ... Revoke voice from users or yourself in the channel. .It Ic /except Op Ar mask ... List or add masks to the channel ban exception list. .It Ic /invex Op Ar mask ... List or add masks to the channel invite list. .It Ic /kick Ar nick Op Ar message Kick a user from the channel. .It Ic /mode Oo Ar modes Oc Op Ar param ... Show or set channel modes. In the .Sy window, show or set user modes. .It Ic /op Op Ar nick ... Grant users or yourself channel operator status. .It Ic /unban Ar mask ... Unban masks from the channel. .It Ic /unexcept Ar mask ... Remove masks from the channel ban exception list. .It Ic /uninvex Ar mask ... Remove masks from the channel invite list. .It Ic /voice Op Ar nick ... Grant users or yourself voice in the channel. .El . .Sh KEY BINDINGS The .Nm interface provides .Xr emacs 1 Ns -like line editing as well as keys for IRC formatting. The prefixes .Ic C- and .Ic M- represent the control and meta (alt) modifiers, respectively. . .Ss Line Editing .Bl -tag -width Ds -compact .It Ic C-a Move to beginning of line. .It Ic C-b Move left. .It Ic C-d Delete next character. .It Ic C-e Move to end of line. .It Ic C-f Move right. .It Ic C-k Delete to end of line. .It Ic C-t Transpose characters. .It Ic C-u Delete to beginning of line. .It Ic C-w Delete previous word. .It Ic C-x Expand a text macro beginning with .Ql \e . .It Ic C-y Paste previously deleted text. .It Ic M-Enter Insert a newline without sending a command. .It Ic M-b Move to previous word. .It Ic M-d Delete next word. .It Ic M-f Move to next word. .It Ic M-q Collapse all whitespace. .It Ic Tab Complete nick, channel, command or macro. .El .Pp Arrow and navigation keys also work as expected. . .Ss Window Keys .Bl -tag -width Ds -compact .It Ic C-l Redraw the UI. .It Ic C-n Switch to next window. .It Ic C-p Switch to previous window. .It Ic C-r Scroll to previous line matching input. .It Ic C-s Scroll to next line matching input. .It Ic C-v Scroll down a page. .It Ic M-+ Raise message visibility threshold, hiding ignored messages, general events (joins, quits, etc.), or non-highlighted messages. .It Ic M-- Lower message visibility threshold, showing ignored messages and unknown replies. .It Ic M-= Toggle mute. Muted windows do not appear in the status line unless you are mentioned. .It Ic M-/ Switch to previously selected window. .It Ic M-< Scroll to top. .It Ic M-> Scroll to bottom. .It Ic M- Ns Ar n Switch to window by number 0\(en9. .It Ic M-a Cycle through unread windows. .It Ic M-l List the contents of the window without word-wrapping and with timestamps. Press .Ic Enter to return to .Nm . .It Ic M-m Insert a blank line in the window. .It Ic M-n Scroll to next highlight. .It Ic M-p Scroll to previous highlight. .It Ic M-s Reveal spoiler text. .It Ic M-t Toggle timestamps. .It Ic M-u Scroll to first unread line. .It Ic M-v Scroll up a page. .El . .Ss IRC Formatting .Bl -tag -width "C-z C-v" -compact .It Ic C-z C-v Insert the next input character literally. .It Ic C-z b Toggle bold. .It Ic C-z c Set or reset color. .It Ic C-z i Toggle italics. .It Ic C-z o Reset formatting. .It Ic C-z p Manually toggle paste mode. .It Ic C-z r Toggle reverse color. .It Ic C-z s Set spoiler text (black on black). .It Ic C-z u Toggle underline. .El . .Pp Some color codes can be inserted with the following: .Bl -column "C-z A" "magenta" "C-z N" "orange (dark yellow)" .It Ic C-z A Ta gray Ta Ic C-z N Ta brown (dark red) .It Ic C-z B Ta blue Ta Ic C-z O Ta orange (dark yellow) .It Ic C-z C Ta cyan Ta Ic C-z P Ta pink (light magenta) .It Ic C-z G Ta green Ta Ic C-z R Ta red .It Ic C-z K Ta black Ta Ic C-z W Ta white .It Ic C-z M Ta magenta Ta Ic C-z Y Ta yellow .El . .Pp To set other colors, follow .Ic C-z c by one or two digits for the foreground color, optionally followed by a comma and one or two digits for the background color. To reset color, follow .Ic C-z c by a non-digit. . .Pp The color numbers are as follows: .Bl -column "99" "orange (dark yellow)" "15" "pink (light magenta)" .It \ 0 Ta white Ta \ 8 Ta yellow .It \ 1 Ta black Ta \ 9 Ta light green .It \ 2 Ta blue Ta 10 Ta cyan .It \ 3 Ta green Ta 11 Ta light cyan .It \ 4 Ta red Ta 12 Ta light blue .It \ 5 Ta brown (dark red) Ta 13 Ta pink (light magenta) .It \ 6 Ta magenta Ta 14 Ta gray .It \ 7 Ta orange (dark yellow) Ta 15 Ta light gray .It 99 Ta default Ta Ta .El . .Sh ENVIRONMENT .Bl -tag -width Ds .It Ev SHELL The shell used by .Ic /exec . The default is .Pa /bin/sh . .It Ev USER The default nickname. .El . .Sh FILES .Bl -tag -width Ds .It Pa $XDG_CONFIG_DIRS/catgirl Configuration files are searched for first in .Ev $XDG_CONFIG_HOME , usually .Pa ~/.config , followed by the colon-separated list of paths .Ev $XDG_CONFIG_DIRS , usually .Pa /etc/xdg . .It Pa ~/.config/catgirl The most likely location of configuration files. . .It Pa $XDG_DATA_DIRS/catgirl Save files are searched for first in .Ev $XDG_DATA_HOME , usually .Pa ~/.local/share , followed by the colon-separated list of paths .Ev $XDG_DATA_DIRS , usually .Pa /usr/local/share:/usr/share . .It Pa ~/.local/share/catgirl The most likely location of save files. .El . .Sh EXIT STATUS The .Nm client exits 0 if requested by the user, .Dv EX_UNAVAILABLE (69) if the connection is lost, and >0 if any other error occurs. . .Sh EXAMPLES Join .Li #ascii.town from the command line: .Bd -literal -offset indent $ catgirl -h irc.tilde.chat -j '#ascii.town' .Ed .Pp Create a configuration file in .Pa ~/.config/catgirl/tilde : .Bd -literal -offset indent host = irc.tilde.chat join = #ascii.town .Ed .Pp Load the configuration file: .Bd -literal -offset indent $ catgirl tilde .Ed . .Sh STANDARDS .Bl -item .It .Rs .%A Adam .%A Attila Molnar .%T invite-notify Extension .%I IRCv3 Working Group .%U https://ircv3.net/specs/extensions/invite-notify .Re .It .Rs .%A Jack Allnutt .%A Val Lorentz .%A Daniel Oaks .%T Modern IRC Client Protocol .%I ircdocs .%U https://modern.ircdocs.horse/index.html .Re .It .Rs .%A Kiyoshi Aman .%A Kyle Fuller .%A St\('ephan Kochen .%A Alexey Sokolov .%A James Wheare .%T Message Tags .%I IRCv3 Working Group .%U https://ircv3.net/specs/extensions/message-tags .Re .It .Rs .%A Kiyoshi Aman .%T extended-join Extension .%I IRCv3 Working Group .%U https://ircv3.net/specs/extensions/extended-join .Re .It .Rs .%A Waldo Bastian .%A Ryan Lortie .%A Lennart Poettering .%T XDG Base Directory Specification .%U https://specifications.freedesktop.org/basedir-spec/basedir-spec-latest.html .%D November 24, 2010 .Re .It .Rs .%A Christine Dodrill .%A Ryan .%A James Wheare .%T chghost Extension .%I IRCv3 Working Group .%U https://ircv3.net/specs/extensions/chghost .Re .It .Rs .%A Kyle Fuller .%A St\('ephan Kochen .%A Alexey Sokolov .%A James Wheare .%T server-time Extension .%I IRCv3 Working Group .%U https://ircv3.net/specs/extensions/server-time .Re .It .Rs .%A Lee Hardy .%A Perry Lorier .%A Kevin L. Mitchell .%A Attila Molnar .%A Daniel Oakley .%A William Pitcock .%A James Wheare .%T Client Capability Negotiation .%I IRCv3 Working Group .%U https://ircv3.net/specs/core/capability-negotiation .Re .It .Rs .%A S. Josefsson .%T The Base16, Base32, and Base64 Data Encodings .%I IETF .%R RFC 4648 .%U https://tools.ietf.org/html/rfc4648 .%D October 2006 .Re .It .Rs .%A C. Kalt .%T Internet Relay Chat: Client Protocol .%I IETF .%R RFC 2812 .%U https://tools.ietf.org/html/rfc2812 .%D April 2000 .Re .It .Rs .%A Janne Mareike Koschinski .%T setname Extension .%I IRCv3 Working Group .%U https://ircv3.net/specs/extensions/setname .Re .It .Rs .%A Mantas Mikul\[u0117]nas .%T userhost-in-names Extension .%I IRCv3 Working Group .%U https://ircv3.net/specs/extensions/userhost-in-names .Re .It .Rs .%A Daniel Oaks .%T IRC Formatting .%I ircdocs .%U https://modern.ircdocs.horse/formatting.html .Re .It .Rs .%A Daniel Oaks .%T Standard Replies Extension .%I IRCv3 Working Group .%U https://ircv3.net/specs/extensions/standard-replies .Re .It .Rs .%A J. Oikarinen .%A D. Reed .%T Internet Relay Chat Protocol .%I IETF .%R RFC 1459 .%U https://tools.ietf.org/html/rfc1459 .%D May 1993 .Re .It .Rs .%A William Pitcock .%A Jilles Tjoelker .%T IRCv3.1 SASL Authentication .%I IRCv3 Working Group .%U https://ircv3.net/specs/extensions/sasl-3.1 .Re .It .Rs .%A William Pitcock .%T multi-prefix Extension .%I IRCv3 Working Group .%U https://ircv3.net/specs/extensions/multi-prefix .Re .It .Rs .%A James Wheare .%T Message IDs .%I IRCv3 Working Group .%U https://ircv3.net/specs/extensions/message-ids .Re .It .Rs .%A James Wheare .%T reply Client Tag .%I IRCv3 Working Group .%U https://ircv3.net/specs/client-tags/reply .Re .It .Rs .%A K. Zeilenga, Ed. .%T The PLAIN Simple Authentication and Security Layer (SASL) Mechanism .%I IETF .%R RFC 4616 .%U https://tools.ietf.org/html/rfc4616 .%D August 2006 .Re .El . .Ss Extensions The .Nm client implements the .Sy causal.agency/consumer vendor-specific IRCv3 capability offered by .Xr pounce 1 . The consumer position is stored in the .Cm save file. . .Sh AUTHORS .An June McEnroe Aq Mt june@causal.agency . .Sh BUGS Send mail to .Aq Mt list+catgirl@causal.agency or join .Li #ascii.town on .Li irc.tilde.chat . catgirl-2.2/chat.c000066400000000000000000000334561445265476100141160ustar00rootroot00000000000000/* Copyright (C) 2020 June McEnroe * * 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 . * * Additional permission under GNU GPL version 3 section 7: * * If you modify this Program, or any covered work, by linking or * combining it with OpenSSL (or a modified version of that library), * containing parts covered by the terms of the OpenSSL License and the * original SSLeay license, the licensors of this Program grant you * additional permission to convey the resulting work. Corresponding * Source for a non-source form of such a combination shall include the * source code for the parts of OpenSSL used as well as that of the * covered work. */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #ifdef __FreeBSD__ #include #endif char *readpassphrase(const char *prompt, char *buf, size_t bufsiz, int flags); #include "chat.h" #ifndef OPENSSL_BIN #define OPENSSL_BIN "openssl" #endif static void genCert(const char *path) { const char *name = strrchr(path, '/'); name = (name ? &name[1] : path); char subj[4 + NAME_MAX]; snprintf(subj, sizeof(subj), "/CN=%.*s", (int)strcspn(name, "."), name); umask(0066); execlp( OPENSSL_BIN, "openssl", "req", "-x509", "-new", "-newkey", "rsa:4096", "-sha256", "-days", "3650", "-nodes", "-subj", subj, "-out", path, "-keyout", path, NULL ); err(EX_UNAVAILABLE, "openssl"); } char *idNames[IDCap] = { [None] = "", [Debug] = "", [Network] = "", }; enum Color idColors[IDCap] = { [None] = Black, [Debug] = Green, [Network] = Gray, }; uint idNext = Network + 1; struct Network network = { .userLen = 9, .hostLen = 63 }; struct Self self = { .color = Default }; static const char *save; static void exitSave(void) { int error = uiSave(); if (error) { warn("%s", save); _exit(EX_IOERR); } } uint execID; int execPipe[2] = { -1, -1 }; int utilPipe[2] = { -1, -1 }; static void execRead(void) { char buf[1024]; ssize_t len = read(execPipe[0], buf, sizeof(buf) - 1); if (len < 0) err(EX_IOERR, "read"); if (!len) return; buf[len] = '\0'; for (char *ptr = buf; ptr;) { char *line = strsep(&ptr, "\r\n"); if (line[0]) command(execID, line); } } static void utilRead(void) { char buf[1024]; ssize_t len = read(utilPipe[0], buf, sizeof(buf) - 1); if (len < 0) err(EX_IOERR, "read"); if (!len) return; buf[len] = '\0'; for (char *ptr = buf; ptr;) { char *line = strsep(&ptr, "\r\n"); if (line[0]) uiFormat(Network, Warm, NULL, "%s", line); } } uint32_t hashInit; uint32_t hashBound = 75; static void parseHash(char *str) { hashInit = strtoul(str, &str, 0); if (*str) hashBound = strtoul(&str[1], NULL, 0); } static void parsePlain(char *str) { self.plainUser = strsep(&str, ":"); if (!str) errx(EX_USAGE, "SASL PLAIN missing colon"); self.plainPass = str; } static volatile sig_atomic_t signals[NSIG]; static void signalHandler(int signal) { signals[signal] = 1; } static void sandboxEarly(bool log); static void sandboxLate(int irc); #if defined __OpenBSD__ static char *promisesInitial; static char promises[64] = "stdio tty"; static void sandboxEarly(bool log) { char *ptr = &promises[strlen(promises)]; char *end = &promises[sizeof(promises)]; if (log) { char buf[PATH_MAX]; int error = unveil(dataPath(buf, sizeof(buf), "log", 0), "wc"); if (error) err(EX_OSERR, "unveil"); ptr = seprintf(ptr, end, " wpath cpath"); } if (!self.restricted) { int error = unveil("/", "x"); if (error) err(EX_OSERR, "unveil"); ptr = seprintf(ptr, end, " proc exec"); } promisesInitial = ptr; ptr = seprintf(ptr, end, " inet dns"); int error = pledge(promises, NULL); if (error) err(EX_OSERR, "pledge"); } static void sandboxLate(int irc) { (void)irc; *promisesInitial = '\0'; int error = pledge(promises, NULL); if (error) err(EX_OSERR, "pledge"); } #elif defined __FreeBSD__ static void sandboxEarly(bool log) { (void)log; } static void sandboxLate(int irc) { if (!self.restricted) return; // Rights are also limited in uiLoad() and logOpen(). cap_rights_t rights; int error = 0 || caph_limit_stdin() || caph_rights_limit( STDOUT_FILENO, cap_rights_init(&rights, CAP_WRITE, CAP_IOCTL) ) || caph_limit_stderr() || caph_rights_limit( irc, cap_rights_init(&rights, CAP_SEND, CAP_RECV, CAP_EVENT) ); if (error) err(EX_OSERR, "cap_rights_limit"); // caph_cache_tzdata(3) doesn't load UTC info, which we need for // certificate verification. gmtime(3) does. caph_cache_tzdata(); gmtime(&(time_t) { time(NULL) }); error = cap_enter(); if (error) err(EX_OSERR, "cap_enter"); } #else static void sandboxEarly(bool log) { (void)log; } static void sandboxLate(int irc) { (void)irc; } #endif int main(int argc, char *argv[]) { setlocale(LC_CTYPE, ""); bool insecure = false; bool printCert = false; const char *bind = NULL; const char *host = NULL; const char *port = "6697"; const char *trust = NULL; const char *cert = NULL; const char *priv = NULL; bool log = false; bool sasl = false; char *pass = NULL; const char *user = NULL; const char *real = NULL; struct option options[] = { { .val = '!', .name = "insecure", no_argument }, { .val = 'C', .name = "copy", required_argument }, { .val = 'H', .name = "hash", required_argument }, { .val = 'I', .name = "highlight", required_argument }, { .val = 'K', .name = "kiosk", no_argument }, { .val = 'N', .name = "notify", required_argument }, { .val = 'O', .name = "open", required_argument }, { .val = 'R', .name = "restrict", no_argument }, { .val = 'S', .name = "bind", required_argument }, { .val = 'T', .name = "timestamp", optional_argument }, { .val = 'a', .name = "sasl-plain", required_argument }, { .val = 'c', .name = "cert", required_argument }, { .val = 'e', .name = "sasl-external", no_argument }, { .val = 'g', .name = "generate", required_argument }, { .val = 'h', .name = "host", required_argument }, { .val = 'i', .name = "ignore", required_argument }, { .val = 'j', .name = "join", required_argument }, { .val = 'k', .name = "priv", required_argument }, { .val = 'l', .name = "log", no_argument }, { .val = 'm', .name = "mode", required_argument }, { .val = 'n', .name = "nick", required_argument }, { .val = 'o', .name = "print-chain", no_argument }, { .val = 'p', .name = "port", required_argument }, { .val = 'q', .name = "quiet", no_argument }, { .val = 'r', .name = "real", required_argument }, { .val = 's', .name = "save", required_argument }, { .val = 't', .name = "trust", required_argument }, { .val = 'u', .name = "user", required_argument }, { .val = 'v', .name = "debug", no_argument }, { .val = 'w', .name = "pass", required_argument }, {0}, }; char opts[3 * ARRAY_LEN(options)]; for (size_t i = 0, j = 0; i < ARRAY_LEN(options); ++i) { opts[j++] = options[i].val; if (options[i].has_arg != no_argument) opts[j++] = ':'; if (options[i].has_arg == optional_argument) opts[j++] = ':'; } for (int opt; 0 < (opt = getopt_config(argc, argv, opts, options, NULL));) { switch (opt) { break; case '!': insecure = true; break; case 'C': utilPush(&urlCopyUtil, optarg); break; case 'H': parseHash(optarg); break; case 'I': filterAdd(Hot, optarg); break; case 'K': self.kiosk = true; break; case 'N': utilPush(&uiNotifyUtil, optarg); break; case 'O': utilPush(&urlOpenUtil, optarg); break; case 'R': self.restricted = true; break; case 'S': bind = optarg; break; case 'T': { windowTime.enable = true; if (optarg) windowTime.format = optarg; } break; case 'a': sasl = true; parsePlain(optarg); break; case 'c': cert = optarg; break; case 'e': sasl = true; break; case 'g': genCert(optarg); break; case 'h': host = optarg; break; case 'i': filterAdd(Ice, optarg); break; case 'j': self.join = optarg; break; case 'k': priv = optarg; break; case 'l': log = true; logOpen(); break; case 'm': self.mode = optarg; break; case 'n': { for (uint i = 0; i < ARRAY_LEN(self.nicks); ++i) { self.nicks[i] = strsep(&optarg, " "); } } break; case 'o': printCert = true; break; case 'p': port = optarg; break; case 'q': windowThreshold = Warm; break; case 'r': real = optarg; break; case 's': save = optarg; break; case 't': trust = optarg; break; case 'u': user = optarg; break; case 'v': self.debug = true; break; case 'w': pass = optarg; break; default: return EX_USAGE; } } if (!host) errx(EX_USAGE, "host required"); if (printCert) { #ifdef __OpenBSD__ int error = pledge("stdio inet dns", NULL); if (error) err(EX_OSERR, "pledge"); #endif ircConfig(true, NULL, NULL, NULL); ircConnect(bind, host, port); ircPrintCert(); ircClose(); return EX_OK; } if (!self.nicks[0]) self.nicks[0] = getenv("USER"); if (!self.nicks[0]) errx(EX_CONFIG, "USER unset"); if (!user) user = self.nicks[0]; if (!real) real = self.nicks[0]; if (self.kiosk) { char *hash; int n = asprintf(&hash, "%08" PRIx32, _hash(user)); if (n < 0) err(EX_OSERR, "asprintf"); user = hash; } if (pass && !pass[0]) { char *buf = malloc(512); if (!buf) err(EX_OSERR, "malloc"); pass = readpassphrase("Server password: ", buf, 512, 0); if (!pass) errx(EX_IOERR, "unable to read passphrase"); } if (self.plainPass && !self.plainPass[0]) { char *buf = malloc(512); if (!buf) err(EX_OSERR, "malloc"); self.plainPass = readpassphrase("Account password: ", buf, 512, 0); if (!self.plainPass) errx(EX_IOERR, "unable to read passphrase"); } // Modes defined in RFC 1459: set(&network.chanTypes, "#&"); set(&network.prefixes, "@+"); set(&network.prefixModes, "ov"); set(&network.listModes, "b"); set(&network.paramModes, "k"); set(&network.setParamModes, "l"); set(&network.channelModes, "imnpst"); set(&network.name, host); set(&self.nick, "*"); inputCompletion(); ircConfig(insecure, trust, cert, priv); uiInit(); sig_t cursesWinch = signal(SIGWINCH, signalHandler); if (save) { uiLoad(save); atexit(exitSave); } windowShow(windowFor(Network)); uiFormat( Network, Cold, NULL, "\3%dcatgirl\3\tis GPLv3 fwee softwawe ^w^ " "code is avaiwable fwom https://git.causal.agency/catgirl", Pink ); uiFormat(Network, Cold, NULL, "Traveling..."); uiDraw(); sandboxEarly(log); int irc = ircConnect(bind, host, port); sandboxLate(irc); ircHandshake(); if (pass) { ircFormat("PASS :"); ircSend(pass, strlen(pass)); ircFormat("\r\n"); explicit_bzero(pass, strlen(pass)); } if (sasl) ircFormat("CAP REQ :sasl\r\n"); ircFormat("CAP LS\r\n"); ircFormat("NICK %s\r\n", self.nicks[0]); ircFormat("USER %s 0 * :%s\r\n", user, real); // Avoid disabling VINTR until main loop. inputInit(); signal(SIGHUP, signalHandler); signal(SIGINT, signalHandler); signal(SIGALRM, signalHandler); signal(SIGTERM, signalHandler); signal(SIGCHLD, signalHandler); bool pipes = !self.kiosk && !self.restricted; if (pipes) { int error = pipe(utilPipe) || pipe(execPipe); if (error) err(EX_OSERR, "pipe"); fcntl(utilPipe[0], F_SETFD, FD_CLOEXEC); fcntl(utilPipe[1], F_SETFD, FD_CLOEXEC); fcntl(execPipe[0], F_SETFD, FD_CLOEXEC); fcntl(execPipe[1], F_SETFD, FD_CLOEXEC); } bool ping = false; struct pollfd fds[] = { { .events = POLLIN, .fd = STDIN_FILENO }, { .events = POLLIN, .fd = irc }, { .events = POLLIN, .fd = utilPipe[0] }, { .events = POLLIN, .fd = execPipe[0] }, }; while (!self.quit) { int nfds = poll(fds, (pipes ? ARRAY_LEN(fds) : 2), -1); if (nfds < 0 && errno != EINTR) err(EX_IOERR, "poll"); if (nfds > 0) { if (fds[0].revents) inputRead(); if (fds[1].revents) ircRecv(); if (fds[2].revents) utilRead(); if (fds[3].revents) execRead(); } if (signals[SIGHUP]) self.quit = "zzz"; if (signals[SIGINT] || signals[SIGTERM]) break; if (nfds > 0 && fds[1].revents) { ping = false; struct itimerval timer = { .it_value.tv_sec = 2 * 60, .it_interval.tv_sec = 30, }; int error = setitimer(ITIMER_REAL, &timer, NULL); if (error) err(EX_OSERR, "setitimer"); } if (signals[SIGALRM]) { signals[SIGALRM] = 0; if (ping) { errx(EX_UNAVAILABLE, "ping timeout"); } else { ircFormat("PING nyaa\r\n"); ping = true; } } if (signals[SIGCHLD]) { signals[SIGCHLD] = 0; for (int status; 0 < waitpid(-1, &status, WNOHANG);) { if (WIFEXITED(status) && WEXITSTATUS(status)) { uiFormat( Network, Warm, NULL, "Process exits with status %d", WEXITSTATUS(status) ); } else if (WIFSIGNALED(status)) { uiFormat( Network, Warm, NULL, "Process terminates from %s", strsignal(WTERMSIG(status)) ); } } uiShow(); } if (signals[SIGWINCH]) { signals[SIGWINCH] = 0; cursesWinch(SIGWINCH); // doupdate(3) needs to be called for KEY_RESIZE to be picked up. uiDraw(); inputRead(); } uiDraw(); } if (self.quit) { ircFormat("QUIT :%s\r\n", self.quit); } else { ircFormat("QUIT\r\n"); } struct Message msg = { .nick = self.nick, .user = self.user, .cmd = "QUIT", .params[0] = self.quit, }; handle(&msg); ircClose(); logClose(); uiHide(); } catgirl-2.2/chat.h000066400000000000000000000273731445265476100141240ustar00rootroot00000000000000/* Copyright (C) 2020 June McEnroe * * 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 . * * Additional permission under GNU GPL version 3 section 7: * * If you modify this Program, or any covered work, by linking or * combining it with OpenSSL (or a modified version of that library), * containing parts covered by the terms of the OpenSSL License and the * original SSLeay license, the licensors of this Program grant you * additional permission to convey the resulting work. Corresponding * Source for a non-source form of such a combination shall include the * source code for the parts of OpenSSL used as well as that of the * covered work. */ #include #include #include #include #include #include #include #include #include #include #include #include #include #define ARRAY_LEN(a) (sizeof(a) / sizeof(a[0])) #define BIT(x) x##Bit, x = 1 << x##Bit, x##Bit_ = x##Bit typedef unsigned uint; typedef unsigned char byte; static inline char *seprintf(char *ptr, char *end, const char *fmt, ...) __attribute__((format(printf, 3, 4))); static inline char *seprintf(char *ptr, char *end, const char *fmt, ...) { va_list ap; va_start(ap, fmt); int n = vsnprintf(ptr, end - ptr, fmt, ap); va_end(ap); if (n < 0) return NULL; if (n > end - ptr) return end; return ptr + n; } enum Attr { BIT(Bold), BIT(Reverse), BIT(Italic), BIT(Underline), }; enum Color { White, Black, Blue, Green, Red, Brown, Magenta, Orange, Yellow, LightGreen, Cyan, LightCyan, LightBlue, Pink, Gray, LightGray, Default = 99, ColorCap, }; struct Style { enum Attr attr; enum Color fg, bg; }; static const struct Style StyleDefault = { 0, Default, Default }; enum { B = '\2', C = '\3', O = '\17', R = '\26', I = '\35', U = '\37' }; static inline size_t styleParse(struct Style *style, const char **str) { switch (**str) { break; case B: (*str)++; style->attr ^= Bold; break; case O: (*str)++; *style = StyleDefault; break; case R: (*str)++; style->attr ^= Reverse; break; case I: (*str)++; style->attr ^= Italic; break; case U: (*str)++; style->attr ^= Underline; break; case C: { (*str)++; if (!isdigit(**str)) { style->fg = Default; style->bg = Default; break; } style->fg = *(*str)++ - '0'; if (isdigit(**str)) style->fg = style->fg * 10 + *(*str)++ - '0'; if ((*str)[0] != ',' || !isdigit((*str)[1])) break; (*str)++; style->bg = *(*str)++ - '0'; if (isdigit(**str)) style->bg = style->bg * 10 + *(*str)++ - '0'; } } return strcspn(*str, (const char[]) { B, C, O, R, I, U, '\0' }); } static inline void styleStrip(char *buf, size_t cap, const char *str) { *buf = '\0'; char *ptr = buf, *end = &buf[cap]; struct Style style = StyleDefault; while (*str) { size_t len = styleParse(&style, &str); ptr = seprintf(ptr, end, "%.*s", (int)len, str); str += len; } } enum { None, Debug, Network, IDCap = 256 }; extern char *idNames[IDCap]; extern enum Color idColors[IDCap]; extern uint idNext; static inline uint idFind(const char *name) { for (uint id = 0; id < idNext; ++id) { if (!strcasecmp(idNames[id], name)) return id; } return None; } static inline uint idFor(const char *name) { uint id = idFind(name); if (id) return id; if (idNext == IDCap) return Network; idNames[idNext] = strdup(name); idColors[idNext] = Default; if (!idNames[idNext]) err(EX_OSERR, "strdup"); return idNext++; } extern uint32_t hashInit; extern uint32_t hashBound; static inline uint32_t _hash(const char *str) { if (*str == '~') str++; uint32_t hash = hashInit; for (; *str; ++str) { hash = (hash << 5) | (hash >> 27); hash ^= *str; hash *= 0x27220A95; } return hash; } static inline enum Color hash(const char *str) { if (hashBound < Blue) return Default; return Blue + _hash(str) % (hashBound + 1 - Blue); } extern struct Network { char *name; uint userLen; uint hostLen; char *chanTypes; char *statusmsg; char *prefixes; char *prefixModes; char *listModes; char *paramModes; char *setParamModes; char *channelModes; char excepts; char invex; } network; static inline uint prefixBit(char p) { char *s = strchr(network.prefixes, p); if (!s) return 0; return 1 << (s - network.prefixes); } static inline char bitPrefix(uint p) { for (uint i = 0; network.prefixes[i]; ++i) { if (p & (1 << i)) return network.prefixes[i]; } return '\0'; } #define ENUM_CAP \ X("causal.agency/consumer", CapConsumer) \ X("chghost", CapChghost) \ X("extended-join", CapExtendedJoin) \ X("invite-notify", CapInviteNotify) \ X("message-tags", CapMessageTags) \ X("multi-prefix", CapMultiPrefix) \ X("sasl", CapSASL) \ X("server-time", CapServerTime) \ X("setname", CapSetname) \ X("userhost-in-names", CapUserhostInNames) \ X("znc.in/self-message", CapSelfMessage) enum Cap { #define X(name, id) BIT(id), ENUM_CAP #undef X }; extern struct Self { bool debug; bool kiosk; bool restricted; size_t pos; enum Cap caps; const char *plainUser; char *plainPass; const char *nicks[8]; const char *mode; const char *join; char *nick; char *user; char *host; enum Color color; char *invited; char *quit; } self; static inline void set(char **field, const char *value) { free(*field); *field = strdup(value); if (!*field) err(EX_OSERR, "strdup"); } #define ENUM_TAG \ X("+draft/reply", TagReply) \ X("causal.agency/pos", TagPos) \ X("msgid", TagMsgID) \ X("time", TagTime) enum Tag { #define X(name, id) id, ENUM_TAG #undef X TagCap, }; enum { ParamCap = 254 }; struct Message { char *tags[TagCap]; char *nick; char *user; char *host; char *cmd; char *params[ParamCap]; }; void ircConfig( bool insecure, const char *trust, const char *cert, const char *priv ); int ircConnect(const char *bind, const char *host, const char *port); void ircHandshake(void); void ircPrintCert(void); void ircRecv(void); void ircSend(const char *ptr, size_t len); void ircFormat(const char *format, ...) __attribute__((format(printf, 1, 2))); void ircClose(void); extern uint execID; extern int execPipe[2]; extern int utilPipe[2]; enum { UtilCap = 16 }; struct Util { uint argc; const char *argv[UtilCap]; }; static inline void utilPush(struct Util *util, const char *arg) { if (1 + util->argc < UtilCap) { util->argv[util->argc++] = arg; } else { errx(EX_CONFIG, "too many utility arguments"); } } enum Reply { ReplyAway = 1, ReplyBan, ReplyExcepts, ReplyHelp, ReplyInvex, ReplyJoin, ReplyList, ReplyMode, ReplyNames, ReplyNamesAuto, ReplyTopic, ReplyTopicAuto, ReplyWhois, ReplyWhowas, ReplyCap, }; extern uint replies[ReplyCap]; void handle(struct Message *msg); void command(uint id, char *input); const char *commandIsPrivmsg(uint id, const char *input); const char *commandIsNotice(uint id, const char *input); const char *commandIsAction(uint id, const char *input); size_t commandWillSplit(uint id, const char *input); void commandCompletion(void); enum Heat { Ice, Cold, Warm, Hot, }; enum { TitleCap = 256, StatusLines = 1, MarkerLines = 1, SplitLines = 5, InputLines = 1, InputCols = 1024, }; extern char uiTitle[TitleCap]; extern struct _win_st *uiStatus; extern struct _win_st *uiMain; extern struct _win_st *uiInput; extern bool uiSpoilerReveal; extern struct Util uiNotifyUtil; void uiInit(void); uint uiAttr(struct Style style); short uiPair(struct Style style); void uiShow(void); void uiHide(void); void uiDraw(void); void uiResize(void); void uiWrite(uint id, enum Heat heat, const time_t *time, const char *str); void uiFormat( uint id, enum Heat heat, const time_t *time, const char *format, ... ) __attribute__((format(printf, 4, 5))); void uiLoad(const char *name); int uiSave(void); void inputInit(void); void inputWait(void); void inputUpdate(void); bool inputPending(uint id); void inputRead(void); void inputCompletion(void); int inputSave(FILE *file); void inputLoad(FILE *file, size_t version); enum Scroll { ScrollOne, ScrollPage, ScrollAll, ScrollUnread, ScrollHot, }; extern struct Time { bool enable; const char *format; int width; } windowTime; extern enum Heat windowThreshold; void windowInit(void); void windowUpdate(void); void windowResize(void); bool windowWrite(uint id, enum Heat heat, const time_t *time, const char *str); void windowBare(void); uint windowID(void); uint windowNum(void); uint windowFor(uint id); void windowShow(uint num); void windowAuto(void); void windowSwap(void); void windowMove(uint from, uint to); void windowClose(uint num); void windowList(void); void windowMark(void); void windowUnmark(void); void windowToggleMute(void); void windowToggleTime(void); void windowToggleThresh(int n); bool windowTimeEnable(void); void windowScroll(enum Scroll by, int n); void windowSearch(const char *str, int dir); int windowSave(FILE *file); void windowLoad(FILE *file, size_t version); enum { BufferCap = 1024 }; struct Buffer; struct Line { uint num; enum Heat heat; time_t time; char *str; }; struct Buffer *bufferAlloc(void); void bufferFree(struct Buffer *buffer); const struct Line *bufferSoft(const struct Buffer *buffer, size_t i); const struct Line *bufferHard(const struct Buffer *buffer, size_t i); int bufferPush( struct Buffer *buffer, int cols, enum Heat thresh, enum Heat heat, time_t time, const char *str ); int bufferReflow( struct Buffer *buffer, int cols, enum Heat thresh, size_t tail ); struct Cursor { uint gen; struct Node *node; }; void completePush(uint id, const char *str, enum Color color); void completePull(uint id, const char *str, enum Color color); void completeReplace(const char *old, const char *new); void completeRemove(uint id, const char *str); enum Color completeColor(uint id, const char *str); uint *completeBits(uint id, const char *str); const char *completePrefix(struct Cursor *curs, uint id, const char *prefix); const char *completeSubstr(struct Cursor *curs, uint id, const char *substr); const char *completeEach(struct Cursor *curs, uint id); uint completeEachID(struct Cursor *curs, const char *str); void completeAccept(struct Cursor *curs); void completeReject(struct Cursor *curs); extern struct Util urlOpenUtil; extern struct Util urlCopyUtil; void urlScan(uint id, const char *nick, const char *mesg); void urlOpenCount(uint id, uint count); void urlOpenMatch(uint id, const char *str); void urlCopyMatch(uint id, const char *str); int urlSave(FILE *file); void urlLoad(FILE *file, size_t version); enum { FilterCap = 64 }; extern struct Filter { enum Heat heat; char *mask; char *cmd; char *chan; char *mesg; } filters[FilterCap]; struct Filter filterParse(enum Heat heat, char *pattern); struct Filter filterAdd(enum Heat heat, const char *pattern); bool filterRemove(struct Filter filter); enum Heat filterCheck(enum Heat heat, uint id, const struct Message *msg); void logOpen(void); void logFormat(uint id, const time_t *time, const char *format, ...) __attribute__((format(printf, 3, 4))); void logClose(void); char *configPath(char *buf, size_t cap, const char *path, int i); char *dataPath(char *buf, size_t cap, const char *path, int i); FILE *configOpen(const char *path, const char *mode); FILE *dataOpen(const char *path, const char *mode); int getopt_config( int argc, char *const *argv, const char *optstring, const struct option *longopts, int *longindex ); catgirl-2.2/command.c000066400000000000000000000451711445265476100146120ustar00rootroot00000000000000/* Copyright (C) 2020 June McEnroe * * 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 . * * Additional permission under GNU GPL version 3 section 7: * * If you modify this Program, or any covered work, by linking or * combining it with OpenSSL (or a modified version of that library), * containing parts covered by the terms of the OpenSSL License and the * original SSLeay license, the licensors of this Program grant you * additional permission to convey the resulting work. Corresponding * Source for a non-source form of such a combination shall include the * source code for the parts of OpenSSL used as well as that of the * covered work. */ #include #include #include #include #include #include #include "chat.h" typedef void Command(uint id, char *params); static void commandDebug(uint id, char *params) { (void)id; (void)params; self.debug ^= true; uiFormat( Debug, Warm, NULL, "\3%dDebug is %s", Gray, (self.debug ? "on" : "off") ); } static void commandQuote(uint id, char *params) { (void)id; if (params) ircFormat("%s\r\n", params); } static void echoMessage(char *cmd, uint id, char *params) { if (!params) return; ircFormat("%s %s :%s\r\n", cmd, idNames[id], params); struct Message msg = { .nick = self.nick, .user = self.user, .cmd = cmd, .params[0] = idNames[id], .params[1] = params, }; handle(&msg); } static int splitChunk(const char *cmd, uint id) { int overhead = snprintf( NULL, 0, ":%s!%*s@%*s %s %s :\r\n", self.nick, (self.user ? 0 : network.userLen), (self.user ?: "*"), (self.host ? 0 : network.hostLen), (self.host ?: "*"), cmd, idNames[id] ); assert(overhead > 0 && overhead < 512); return 512 - overhead; } static int splitLen(int chunk, const char *params) { int len = 0; size_t cap = 1 + strlen(params); for (int n = 0; params[len] != '\n' && len + n <= chunk; len += n) { n = mblen(¶ms[len], cap - len); if (n < 0) { n = 1; mblen(NULL, 0); } if (!n) break; } return len; } static void splitMessage(char *cmd, uint id, char *params) { if (!params) return; int chunk = splitChunk(cmd, id); if (strlen(params) <= (size_t)chunk && !strchr(params, '\n')) { echoMessage(cmd, id, params); return; } while (*params) { int len = splitLen(chunk, params); char ch = params[len]; params[len] = '\0'; echoMessage(cmd, id, params); params[len] = ch; params += len; if (ch == '\n') params++; } } static void commandPrivmsg(uint id, char *params) { splitMessage("PRIVMSG", id, params); } static void commandNotice(uint id, char *params) { splitMessage("NOTICE", id, params); } static void commandMe(uint id, char *params) { char buf[512]; if (!params) params = ""; int chunk = splitChunk("PRIVMSG \1ACTION\1", id); if (strlen(params) <= (size_t)chunk && !strchr(params, '\n')) { snprintf(buf, sizeof(buf), "\1ACTION %s\1", params); echoMessage("PRIVMSG", id, buf); return; } while (*params) { int len = splitLen(chunk, params); snprintf(buf, sizeof(buf), "\1ACTION %.*s\1", len, params); echoMessage("PRIVMSG", id, buf); params += len; if (*params == '\n') params++; } } static void commandMsg(uint id, char *params) { if (!params) return; char *nick = strsep(¶ms, " "); uint msg = idFor(nick); if (idColors[msg] == Default) { idColors[msg] = completeColor(id, nick); } if (params) { splitMessage("PRIVMSG", msg, params); } else { windowShow(windowFor(msg)); } } static void commandJoin(uint id, char *params) { if (!params && id == Network) params = self.invited; if (!params) params = idNames[id]; uint count = 1; for (char *ch = params; *ch && *ch != ' '; ++ch) { if (*ch == ',') count++; } ircFormat("JOIN %s\r\n", params); replies[ReplyJoin] += count; replies[ReplyTopic] += count; replies[ReplyNames] += count; } static void commandPart(uint id, char *params) { if (params) { ircFormat("PART %s :%s\r\n", idNames[id], params); } else { ircFormat("PART %s\r\n", idNames[id]); } } static void commandQuit(uint id, char *params) { (void)id; set(&self.quit, (params ?: "nyaa~")); } static void commandNick(uint id, char *params) { (void)id; if (params) { ircFormat("NICK :%s\r\n", params); } else { uiFormat( Network, Warm, NULL, "You are \3%02d%s", self.color, self.nick ); } } static void commandAway(uint id, char *params) { (void)id; if (params) { ircFormat("AWAY :%s\r\n", params); } else { ircFormat("AWAY\r\n"); } replies[ReplyAway]++; } static void commandSetname(uint id, char *params) { (void)id; if (!params) return; ircFormat("SETNAME :%s\r\n", params); } static void commandTopic(uint id, char *params) { if (params) { ircFormat("TOPIC %s :%s\r\n", idNames[id], params); } else { ircFormat("TOPIC %s\r\n", idNames[id]); replies[ReplyTopic]++; } } static void commandNames(uint id, char *params) { (void)params; ircFormat("NAMES %s\r\n", idNames[id]); replies[ReplyNames]++; } static void commandOps(uint id, char *params) { (void)params; char buf[1024]; char *ptr = buf, *end = &buf[sizeof(buf)]; ptr = seprintf( ptr, end, "The council of \3%02d%s\3 are ", idColors[id], idNames[id] ); bool first = true; struct Cursor curs = {0}; for (const char *nick; (nick = completeEach(&curs, id));) { char prefix = bitPrefix(*completeBits(id, nick)); if (!prefix || prefix == '+') continue; ptr = seprintf( ptr, end, "%s\3%02d%c%s\3", (first ? "" : ", "), completeColor(id, nick), prefix, nick ); first = false; } if (first) { uiFormat( id, Warm, NULL, "\3%02d%s\3 is a lawless wasteland", idColors[id], idNames[id] ); } else { uiWrite(id, Warm, NULL, buf); } } static void commandInvite(uint id, char *params) { if (!params) return; char *nick = strsep(¶ms, " "); ircFormat("INVITE %s %s\r\n", nick, idNames[id]); } static void commandKick(uint id, char *params) { if (!params) return; char *nick = strsep(¶ms, " "); if (params) { ircFormat("KICK %s %s :%s\r\n", idNames[id], nick, params); } else { ircFormat("KICK %s %s\r\n", idNames[id], nick); } } static void commandMode(uint id, char *params) { if (id == Network) { if (params) { ircFormat("MODE %s %s\r\n", self.nick, params); } else { ircFormat("MODE %s\r\n", self.nick); replies[ReplyMode]++; } } else { if (params) { if (!params[1] || (params[0] == '+' && !params[2])) { char m = (params[0] == '+' ? params[1] : params[0]); if (m == 'b') replies[ReplyBan]++; if (m == network.excepts) replies[ReplyExcepts]++; if (m == network.invex) replies[ReplyInvex]++; } ircFormat("MODE %s %s\r\n", idNames[id], params); } else { ircFormat("MODE %s\r\n", idNames[id]); replies[ReplyMode]++; } } } static void channelListMode(uint id, char pm, char l, const char *params) { int count = 1; for (const char *ch = params; *ch; ++ch) { if (*ch == ' ') count++; } char modes[13 + 1] = { l, l, l, l, l, l, l, l, l, l, l, l, l, '\0' }; ircFormat("MODE %s %c%.*s %s\r\n", idNames[id], pm, count, modes, params); } static void commandOp(uint id, char *params) { if (params) { channelListMode(id, '+', 'o', params); } else { ircFormat("CS OP %s\r\n", idNames[id]); } } static void commandDeop(uint id, char *params) { channelListMode(id, '-', 'o', (params ?: self.nick)); } static void commandVoice(uint id, char *params) { if (params) { channelListMode(id, '+', 'v', params); } else { ircFormat("CS VOICE %s\r\n", idNames[id]); } } static void commandDevoice(uint id, char *params) { channelListMode(id, '-', 'v', (params ?: self.nick)); } static void commandBan(uint id, char *params) { if (params) { channelListMode(id, '+', 'b', params); } else { ircFormat("MODE %s b\r\n", idNames[id]); replies[ReplyBan]++; } } static void commandUnban(uint id, char *params) { if (!params) return; channelListMode(id, '-', 'b', params); } static void commandExcept(uint id, char *params) { if (params) { channelListMode(id, '+', network.excepts, params); } else { ircFormat("MODE %s %c\r\n", idNames[id], network.excepts); replies[ReplyExcepts]++; } } static void commandUnexcept(uint id, char *params) { if (!params) return; channelListMode(id, '-', network.excepts, params); } static void commandInvex(uint id, char *params) { if (params) { channelListMode(id, '+', network.invex, params); } else { ircFormat("MODE %s %c\r\n", idNames[id], network.invex); replies[ReplyInvex]++; } } static void commandUninvex(uint id, char *params) { if (!params) return; channelListMode(id, '-', network.invex, params); } static void commandList(uint id, char *params) { (void)id; if (params) { ircFormat("LIST :%s\r\n", params); } else { ircFormat("LIST\r\n"); } replies[ReplyList]++; } static void commandWhois(uint id, char *params) { (void)id; if (!params) params = self.nick; uint count = 1; for (char *ch = params; *ch; ++ch) { if (*ch == ',') count++; } ircFormat("WHOIS %s\r\n", params); replies[ReplyWhois] += count; } static void commandWhowas(uint id, char *params) { (void)id; if (!params) return; ircFormat("WHOWAS %s\r\n", params); replies[ReplyWhowas]++; } static void commandNS(uint id, char *params) { (void)id; ircFormat("NS %s\r\n", (params ?: "HELP")); } static void commandCS(uint id, char *params) { (void)id; ircFormat("CS %s\r\n", (params ?: "HELP")); } static void commandQuery(uint id, char *params) { if (!params) return; uint query = idFor(params); if (idColors[query] == Default) { idColors[query] = completeColor(id, params); } windowShow(windowFor(query)); } static void commandWindow(uint id, char *params) { if (!params) { windowList(); } else if (isdigit(params[0])) { windowShow(strtoul(params, NULL, 10)); } else { id = idFind(params); if (id) { windowShow(windowFor(id)); return; } struct Cursor curs = {0}; for (const char *str; (str = completeSubstr(&curs, None, params));) { id = idFind(str); if (!id) continue; completeAccept(&curs); windowShow(windowFor(id)); break; } } } static void commandMove(uint id, char *params) { if (!params) return; char *name = strsep(¶ms, " "); if (params) { id = idFind(name); if (id) windowMove(windowFor(id), strtoul(params, NULL, 10)); } else { windowMove(windowFor(id), strtoul(name, NULL, 10)); } } static void commandClose(uint id, char *params) { if (!params) { windowClose(windowFor(id)); } else if (isdigit(params[0])) { windowClose(strtoul(params, NULL, 10)); } else { id = idFind(params); if (id) windowClose(windowFor(id)); } } static void commandOpen(uint id, char *params) { if (!params) { urlOpenCount(id, 1); } else if (isdigit(params[0]) && !params[1]) { urlOpenCount(id, params[0] - '0'); } else { urlOpenMatch(id, params); } } static void commandCopy(uint id, char *params) { urlCopyMatch(id, params); } static void commandFilter(enum Heat heat, uint id, char *params) { if (params) { struct Filter filter = filterAdd(heat, params); uiFormat( id, Cold, NULL, "%sing \3%02d%s %s %s %s", (heat == Hot ? "Highlight" : "Ignor"), Brown, filter.mask, (filter.cmd ?: ""), (filter.chan ?: ""), (filter.mesg ?: "") ); } else { for (size_t i = 0; i < FilterCap && filters[i].mask; ++i) { if (filters[i].heat != heat) continue; uiFormat( Network, Warm, NULL, "%sing \3%02d%s %s %s %s", (heat == Hot ? "Highlight" : "Ignor"), Brown, filters[i].mask, (filters[i].cmd ?: ""), (filters[i].chan ?: ""), (filters[i].mesg ?: "") ); } } } static void commandUnfilter(enum Heat heat, uint id, char *params) { if (!params) return; struct Filter filter = filterParse(heat, params); bool found = filterRemove(filter); uiFormat( id, Cold, NULL, "%s %sing \3%02d%s %s %s %s", (found ? "No longer" : "Not"), (heat == Hot ? "highlight" : "ignor"), Brown, filter.mask, (filter.cmd ?: ""), (filter.chan ?: ""), (filter.mesg ?: "") ); } static void commandHighlight(uint id, char *params) { commandFilter(Hot, id, params); } static void commandIgnore(uint id, char *params) { commandFilter(Ice, id, params); } static void commandUnhighlight(uint id, char *params) { commandUnfilter(Hot, id, params); } static void commandUnignore(uint id, char *params) { commandUnfilter(Ice, id, params); } static void commandExec(uint id, char *params) { execID = id; pid_t pid = fork(); if (pid < 0) err(EX_OSERR, "fork"); if (pid) return; setsid(); close(STDIN_FILENO); dup2(execPipe[1], STDOUT_FILENO); dup2(utilPipe[1], STDERR_FILENO); const char *shell = getenv("SHELL") ?: "/bin/sh"; execl(shell, shell, "-c", params, NULL); warn("%s", shell); _exit(EX_UNAVAILABLE); } static void commandHelp(uint id, char *params) { (void)id; if (params) { ircFormat("HELP :%s\r\n", params); replies[ReplyHelp]++; return; } if (self.restricted) { uiFormat(id, Warm, NULL, "See catgirl(1) or /help index"); return; } uiHide(); pid_t pid = fork(); if (pid < 0) err(EX_OSERR, "fork"); if (pid) return; char buf[256]; snprintf(buf, sizeof(buf), "%sp^COMMANDS$", (getenv("LESS") ?: "")); setenv("LESS", buf, 1); execlp("man", "man", "1", "catgirl", NULL); dup2(utilPipe[1], STDERR_FILENO); warn("man"); _exit(EX_UNAVAILABLE); } enum Flag { BIT(Multiline), BIT(Restrict), BIT(Kiosk), }; static const struct Handler { const char *cmd; Command *fn; enum Flag flags; enum Cap caps; } Commands[] = { { "/away", commandAway, 0, 0 }, { "/ban", commandBan, 0, 0 }, { "/close", commandClose, 0, 0 }, { "/copy", commandCopy, Restrict | Kiosk, 0 }, { "/cs", commandCS, 0, 0 }, { "/debug", commandDebug, Kiosk, 0 }, { "/deop", commandDeop, 0, 0 }, { "/devoice", commandDevoice, 0, 0 }, { "/except", commandExcept, 0, 0 }, { "/exec", commandExec, Multiline | Restrict | Kiosk, 0 }, { "/help", commandHelp, 0, 0 }, // Restrict special case. { "/highlight", commandHighlight, 0, 0 }, { "/ignore", commandIgnore, 0, 0 }, { "/invex", commandInvex, 0, 0 }, { "/invite", commandInvite, 0, 0 }, { "/join", commandJoin, Kiosk, 0 }, { "/kick", commandKick, 0, 0 }, { "/list", commandList, Kiosk, 0 }, { "/me", commandMe, Multiline, 0 }, { "/mode", commandMode, 0, 0 }, { "/move", commandMove, 0, 0 }, { "/msg", commandMsg, Multiline | Kiosk, 0 }, { "/names", commandNames, 0, 0 }, { "/nick", commandNick, 0, 0 }, { "/notice", commandNotice, Multiline, 0 }, { "/ns", commandNS, 0, 0 }, { "/o", commandOpen, Restrict | Kiosk, 0 }, { "/op", commandOp, 0, 0 }, { "/open", commandOpen, Restrict | Kiosk, 0 }, { "/ops", commandOps, 0, 0 }, { "/part", commandPart, Kiosk, 0 }, { "/query", commandQuery, Kiosk, 0 }, { "/quit", commandQuit, 0, 0 }, { "/quote", commandQuote, Multiline | Kiosk, 0 }, { "/say", commandPrivmsg, Multiline, 0 }, { "/setname", commandSetname, 0, CapSetname }, { "/topic", commandTopic, 0, 0 }, { "/unban", commandUnban, 0, 0 }, { "/unexcept", commandUnexcept, 0, 0 }, { "/unhighlight", commandUnhighlight, 0, 0 }, { "/unignore", commandUnignore, 0, 0 }, { "/uninvex", commandUninvex, 0, 0 }, { "/voice", commandVoice, 0, 0 }, { "/whois", commandWhois, 0, 0 }, { "/whowas", commandWhowas, 0, 0 }, { "/window", commandWindow, 0, 0 }, }; static int compar(const void *cmd, const void *_handler) { const struct Handler *handler = _handler; return strcmp(cmd, handler->cmd); } const char *commandIsPrivmsg(uint id, const char *input) { if (id == Network || id == Debug) return NULL; if (input[0] != '/') return input; const char *space = strchr(&input[1], ' '); const char *slash = strchr(&input[1], '/'); if (slash && (!space || slash < space)) return input; return NULL; } const char *commandIsNotice(uint id, const char *input) { if (id == Network || id == Debug) return NULL; if (strncmp(input, "/notice ", 8)) return NULL; return &input[8]; } const char *commandIsAction(uint id, const char *input) { if (id == Network || id == Debug) return NULL; if (strncmp(input, "/me ", 4)) return NULL; return &input[4]; } size_t commandWillSplit(uint id, const char *input) { int chunk; const char *params; if (NULL != (params = commandIsPrivmsg(id, input))) { chunk = splitChunk("PRIVMSG", id); } else if (NULL != (params = commandIsNotice(id, input))) { chunk = splitChunk("NOTICE", id); } else if (NULL != (params = commandIsAction(id, input))) { chunk = splitChunk("PRIVMSG \1ACTION\1", id); } else if (id != Network && id != Debug && !strncmp(input, "/say ", 5)) { params = &input[5]; chunk = splitChunk("PRIVMSG", id); } else { return 0; } if (strlen(params) <= (size_t)chunk) return 0; for ( int split; params[(split = splitLen(chunk, params))]; params = ¶ms[split + 1] ) { if (params[split] == '\n') continue; return (params - input) + split; } return 0; } static bool commandAvailable(const struct Handler *handler) { if (handler->flags & Restrict && self.restricted) return false; if (handler->flags & Kiosk && self.kiosk) return false; if (handler->caps && (handler->caps & self.caps) != handler->caps) { return false; } return true; } void command(uint id, char *input) { if (id == Debug && input[0] != '/' && !self.restricted) { commandQuote(id, input); return; } else if (!input[0]) { return; } else if (commandIsPrivmsg(id, input)) { commandPrivmsg(id, input); return; } else if (input[0] == '/' && isdigit(input[1])) { commandWindow(id, &input[1]); return; } struct Cursor curs = {0}; const char *cmd = strsep(&input, " "); const char *unique = completePrefix(&curs, None, cmd); if (unique && !completePrefix(&curs, None, cmd)) { cmd = unique; } const struct Handler *handler = bsearch( cmd, Commands, ARRAY_LEN(Commands), sizeof(*handler), compar ); if (!handler) { uiFormat(id, Warm, NULL, "No such command %s", cmd); return; } if (!commandAvailable(handler)) { uiFormat(id, Warm, NULL, "Command %s is unavailable", cmd); return; } if (input) { if (!(handler->flags & Multiline)) { input[strcspn(input, "\n")] = '\0'; } input += strspn(input, " "); size_t len = strlen(input); while (input[len - 1] == ' ') input[--len] = '\0'; if (!input[0]) input = NULL; } handler->fn(id, input); } void commandCompletion(void) { for (size_t i = 0; i < ARRAY_LEN(Commands); ++i) { if (!commandAvailable(&Commands[i])) continue; completePush(None, Commands[i].cmd, Default); } } catgirl-2.2/compat_readpassphrase.c000066400000000000000000000134771445265476100175500ustar00rootroot00000000000000/* * Original: readpassphrase.c in OpenSSH portable */ /* * Copyright (c) 2000-2002, 2007, 2010 * Todd C. Miller * * Permission to use, copy, modify, and distribute this software for any * purpose with or without fee is hereby granted, provided that the above * copyright notice and this permission notice appear in all copies. * * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. * * Sponsored in part by the Defense Advanced Research Projects * Agency (DARPA) and Air Force Research Laboratory, Air Force * Materiel Command, USAF, under agreement number F39502-99-1-0512. */ #include #include #include #include #include #include #include #include #include /* * Macros and function required for readpassphrase(3). */ #define RPP_ECHO_OFF 0x00 #define RPP_ECHO_ON 0x01 #define RPP_REQUIRE_TTY 0x02 #define RPP_FORCELOWER 0x04 #define RPP_FORCEUPPER 0x08 #define RPP_SEVENBIT 0x10 #define RPP_STDIN 0x20 char *readpassphrase(const char *, char *, size_t, int); #if !defined(_NSIG) && defined(NSIG) # define _NSIG NSIG #endif static volatile sig_atomic_t readpassphrase_signo[_NSIG]; static void readpassphrase_handler(int s) { readpassphrase_signo[s] = 1; } char * readpassphrase(const char *prompt, char *buf, size_t bufsiz, int flags) { ssize_t nr; int input, output, save_errno, i, need_restart; char ch, *p, *end; struct termios term, oterm; struct sigaction sa, savealrm, saveint, savehup, savequit, saveterm; struct sigaction savetstp, savettin, savettou, savepipe; /* If we don't have TCSASOFT define it so that ORing it it below is a no-op. */ #ifndef TCSASOFT const int tcasoft = 0; #else const int tcasoft = TCSASOFT; #endif /* I suppose we could alloc on demand in this case (XXX). */ if (bufsiz == 0) { errno = EINVAL; return(NULL); } restart: for (i = 0; i < _NSIG; i++) readpassphrase_signo[i] = 0; nr = -1; save_errno = 0; need_restart = 0; /* * Read and write to /dev/tty if available. If not, read from * stdin and write to stderr unless a tty is required. */ if ((flags & RPP_STDIN) || (input = output = open(_PATH_TTY, O_RDWR)) == -1) { if (flags & RPP_REQUIRE_TTY) { errno = ENOTTY; return(NULL); } input = STDIN_FILENO; output = STDERR_FILENO; } /* * Turn off echo if possible. * If we are using a tty but are not the foreground pgrp this will * generate SIGTTOU, so do it *before* installing the signal handlers. */ if (input != STDIN_FILENO && tcgetattr(input, &oterm) == 0) { memcpy(&term, &oterm, sizeof(term)); if (!(flags & RPP_ECHO_ON)) term.c_lflag &= ~(ECHO | ECHONL); #ifdef VSTATUS if (term.c_cc[VSTATUS] != _POSIX_VDISABLE) term.c_cc[VSTATUS] = _POSIX_VDISABLE; #endif (void)tcsetattr(input, TCSAFLUSH|tcasoft, &term); } else { memset(&term, 0, sizeof(term)); term.c_lflag |= ECHO; memset(&oterm, 0, sizeof(oterm)); oterm.c_lflag |= ECHO; } /* * Catch signals that would otherwise cause the user to end * up with echo turned off in the shell. Don't worry about * things like SIGXCPU and SIGVTALRM for now. */ sigemptyset(&sa.sa_mask); sa.sa_flags = 0; /* don't restart system calls */ sa.sa_handler = readpassphrase_handler; (void)sigaction(SIGALRM, &sa, &savealrm); (void)sigaction(SIGHUP, &sa, &savehup); (void)sigaction(SIGINT, &sa, &saveint); (void)sigaction(SIGPIPE, &sa, &savepipe); (void)sigaction(SIGQUIT, &sa, &savequit); (void)sigaction(SIGTERM, &sa, &saveterm); (void)sigaction(SIGTSTP, &sa, &savetstp); (void)sigaction(SIGTTIN, &sa, &savettin); (void)sigaction(SIGTTOU, &sa, &savettou); if (!(flags & RPP_STDIN)) (void)write(output, prompt, strlen(prompt)); end = buf + bufsiz - 1; p = buf; while ((nr = read(input, &ch, 1)) == 1 && ch != '\n' && ch != '\r') { if (p < end) { if ((flags & RPP_SEVENBIT)) ch &= 0x7f; if (isalpha((unsigned char)ch)) { if ((flags & RPP_FORCELOWER)) ch = (char)tolower((unsigned char)ch); if ((flags & RPP_FORCEUPPER)) ch = (char)toupper((unsigned char)ch); } *p++ = ch; } } *p = '\0'; save_errno = errno; if (!(term.c_lflag & ECHO)) (void)write(output, "\n", 1); /* Restore old terminal settings and signals. */ if (memcmp(&term, &oterm, sizeof(term)) != 0) { const int sigttou = readpassphrase_signo[SIGTTOU]; /* Ignore SIGTTOU generated when we are not the fg pgrp. */ while (tcsetattr(input, TCSAFLUSH|tcasoft, &oterm) == -1 && errno == EINTR && !readpassphrase_signo[SIGTTOU]) continue; readpassphrase_signo[SIGTTOU] = sigttou; } (void)sigaction(SIGALRM, &savealrm, NULL); (void)sigaction(SIGHUP, &savehup, NULL); (void)sigaction(SIGINT, &saveint, NULL); (void)sigaction(SIGQUIT, &savequit, NULL); (void)sigaction(SIGPIPE, &savepipe, NULL); (void)sigaction(SIGTERM, &saveterm, NULL); (void)sigaction(SIGTSTP, &savetstp, NULL); (void)sigaction(SIGTTIN, &savettin, NULL); (void)sigaction(SIGTTOU, &savettou, NULL); if (input != STDIN_FILENO) (void)close(input); /* * If we were interrupted by a signal, resend it to ourselves * now that we have restored the signal handlers. */ for (i = 0; i < _NSIG; i++) { if (readpassphrase_signo[i]) { kill(getpid(), i); switch (i) { case SIGTSTP: case SIGTTIN: case SIGTTOU: need_restart = 1; } } } if (need_restart) goto restart; if (save_errno) errno = save_errno; return(nr == -1 ? NULL : buf); } catgirl-2.2/complete.c000066400000000000000000000130351445265476100147760ustar00rootroot00000000000000/* Copyright (C) 2020, 2022 June McEnroe * * 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 . * * Additional permission under GNU GPL version 3 section 7: * * If you modify this Program, or any covered work, by linking or * combining it with OpenSSL (or a modified version of that library), * containing parts covered by the terms of the OpenSSL License and the * original SSLeay license, the licensors of this Program grant you * additional permission to convey the resulting work. Corresponding * Source for a non-source form of such a combination shall include the * source code for the parts of OpenSSL used as well as that of the * covered work. */ #include #include #include #include #include "chat.h" struct Node { uint id; char *str; enum Color color; uint bits; struct Node *prev; struct Node *next; }; static uint gen; static struct Node *head; static struct Node *tail; static struct Node *alloc(uint id, const char *str, enum Color color) { struct Node *node = calloc(1, sizeof(*node)); if (!node) err(EX_OSERR, "calloc"); node->id = id; node->str = strdup(str); if (!node->str) err(EX_OSERR, "strdup"); node->color = color; node->bits = 0; return node; } static struct Node *detach(struct Node *node) { if (node->prev) node->prev->next = node->next; if (node->next) node->next->prev = node->prev; if (head == node) head = node->next; if (tail == node) tail = node->prev; node->prev = NULL; node->next = NULL; return node; } static struct Node *prepend(struct Node *node) { node->prev = NULL; node->next = head; if (head) head->prev = node; head = node; tail = (tail ?: node); return node; } static struct Node *append(struct Node *node) { node->next = NULL; node->prev = tail; if (tail) tail->next = node; tail = node; head = (head ?: node); return node; } static struct Node *find(uint id, const char *str) { for (struct Node *node = head; node; node = node->next) { if (node->id == id && !strcmp(node->str, str)) return node; } return NULL; } void completePush(uint id, const char *str, enum Color color) { struct Node *node = find(id, str); if (node) { if (color != Default) node->color = color; } else { append(alloc(id, str, color)); } } void completePull(uint id, const char *str, enum Color color) { struct Node *node = find(id, str); if (node) { if (color != Default) node->color = color; prepend(detach(node)); } else { prepend(alloc(id, str, color)); } } void completeReplace(const char *old, const char *new) { struct Node *next = NULL; for (struct Node *node = head; node; node = next) { next = node->next; if (strcmp(node->str, old)) continue; free(node->str); node->str = strdup(new); if (!node->str) err(EX_OSERR, "strdup"); prepend(detach(node)); } } void completeRemove(uint id, const char *str) { struct Node *next = NULL; for (struct Node *node = head; node; node = next) { next = node->next; if (id && node->id != id) continue; if (str && strcmp(node->str, str)) continue; detach(node); free(node->str); free(node); } gen++; } enum Color completeColor(uint id, const char *str) { struct Node *node = find(id, str); return (node ? node->color : Default); } uint *completeBits(uint id, const char *str) { struct Node *node = find(id, str); return (node ? &node->bits : NULL); } const char *completePrefix(struct Cursor *curs, uint id, const char *prefix) { size_t len = strlen(prefix); if (curs->gen != gen) curs->node = NULL; for ( curs->gen = gen, curs->node = (curs->node ? curs->node->next : head); curs->node; curs->node = curs->node->next ) { if (curs->node->id && curs->node->id != id) continue; if (!strncasecmp(curs->node->str, prefix, len)) return curs->node->str; } return NULL; } const char *completeSubstr(struct Cursor *curs, uint id, const char *substr) { if (curs->gen != gen) curs->node = NULL; for ( curs->gen = gen, curs->node = (curs->node ? curs->node->next : head); curs->node; curs->node = curs->node->next ) { if (curs->node->id && curs->node->id != id) continue; if (strstr(curs->node->str, substr)) return curs->node->str; } return NULL; } const char *completeEach(struct Cursor *curs, uint id) { if (curs->gen != gen) curs->node = NULL; for ( curs->gen = gen, curs->node = (curs->node ? curs->node->next : head); curs->node; curs->node = curs->node->next ) { if (curs->node->id == id) return curs->node->str; } return NULL; } uint completeEachID(struct Cursor *curs, const char *str) { if (curs->gen != gen) curs->node = NULL; for ( curs->gen = gen, curs->node = (curs->node ? curs->node->next : head); curs->node; curs->node = curs->node->next ) { if (!curs->node->id) continue; if (!strcmp(curs->node->str, str)) return curs->node->id; } return None; } void completeAccept(struct Cursor *curs) { if (curs->gen == gen && curs->node) { prepend(detach(curs->node)); } curs->node = NULL; } void completeReject(struct Cursor *curs) { curs->node = NULL; } catgirl-2.2/config.c000066400000000000000000000073311445265476100144350ustar00rootroot00000000000000/* Copyright (C) 2019 June McEnroe * * 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 . * * Additional permission under GNU GPL version 3 section 7: * * If you modify this Program, or any covered work, by linking or * combining it with OpenSSL (or a modified version of that library), * containing parts covered by the terms of the OpenSSL License and the * original SSLeay license, the licensors of this Program grant you * additional permission to convey the resulting work. Corresponding * Source for a non-source form of such a combination shall include the * source code for the parts of OpenSSL used as well as that of the * covered work. */ #include #include #include #include #include #include #include #include "chat.h" #define WS "\t " static const char *path; static FILE *file; static size_t num; static char *line; static size_t cap; static int clean(int opt) { if (file) fclose(file); free(line); line = NULL; cap = 0; return opt; } int getopt_config( int argc, char *const *argv, const char *optstring, const struct option *longopts, int *longindex ) { static int opt; for (;;) { if (!file) { if (optind == argc) return clean(-1); if (opt >= 0 && argv[optind][0] == '-') { opt = getopt_long(argc, argv, optstring, longopts, longindex); if (opt >= 0 || optind == argc) return clean(opt); } num = 0; path = argv[optind++]; file = configOpen(path, "r"); if (!file) return clean('?'); } for (;;) { ssize_t llen = getline(&line, &cap, file); if (ferror(file)) { warn("%s", path); return clean('?'); } if (llen <= 0) break; if (line[llen - 1] == '\n') line[llen - 1] = '\0'; num++; char *name = line + strspn(line, WS); size_t len = strcspn(name, WS "="); if (!name[0] || name[0] == '#') continue; const struct option *option; for (option = longopts; option->name; ++option) { if (strlen(option->name) != len) continue; if (!strncmp(option->name, name, len)) break; } if (!option->name) { warnx( "%s:%zu: unrecognized option `%.*s'", path, num, (int)len, name ); return clean('?'); } char *equal = &name[len] + strspn(&name[len], WS); if (*equal && *equal != '=') { warnx( "%s:%zu: option `%s' missing equals sign", path, num, option->name ); return clean('?'); } if (option->has_arg == no_argument && *equal) { warnx( "%s:%zu: option `%s' doesn't allow an argument", path, num, option->name ); return clean('?'); } if (option->has_arg == required_argument && !*equal) { warnx( "%s:%zu: option `%s' requires an argument", path, num, option->name ); return clean(':'); } optarg = NULL; if (*equal) { char *arg = &equal[1] + strspn(&equal[1], WS); optarg = strdup(arg); if (!optarg) { warn("getopt_config"); return clean('?'); } } if (longindex) *longindex = option - longopts; if (option->flag) { *option->flag = option->val; return 0; } else { return option->val; } } fclose(file); file = NULL; } } catgirl-2.2/configure000077500000000000000000000023751445265476100147360ustar00rootroot00000000000000#!/bin/sh set -eu : ${PKG_CONFIG:=pkg-config} cflags() { echo "CFLAGS += $*" } defstr() { cflags "-D'$1=\"$2\"'" } defvar() { defstr "$1" "$(${PKG_CONFIG} --variable=$3 $2)${4:-}" } ldadd() { lib=$1; shift echo "LDADD.${lib} = $*" } config() { ${PKG_CONFIG} --print-errors "$@" cflags $(${PKG_CONFIG} --cflags "$@") for lib; do ldadd $lib $(${PKG_CONFIG} --libs $lib); done } exec >config.mk for opt; do case "${opt}" in (--prefix=*) echo "PREFIX = ${opt#*=}" ;; (--bindir=*) echo "BINDIR = ${opt#*=}" ;; (--mandir=*) echo "MANDIR = ${opt#*=}" ;; (--enable-sandman) echo 'BINS += sandman' ;; (*) echo "warning: unsupported option ${opt}" >&2 ;; esac done case "$(uname)" in (FreeBSD) config libtls defstr OPENSSL_BIN /usr/bin/openssl ;; (OpenBSD) defstr OPENSSL_BIN /usr/bin/openssl ;; (Linux) cflags -Wno-pedantic -D_GNU_SOURCE config libtls ncursesw defvar OPENSSL_BIN openssl exec_prefix /bin/openssl echo 'OBJS += compat_readpassphrase.o' ;; (Darwin) cflags -D__STDC_WANT_LIB_EXT1__=1 cflags "-D'explicit_bzero(b,l)=memset_s((b),(l),0,(l))'" config libtls ncursesw defvar OPENSSL_BIN openssl exec_prefix /bin/openssl ;; (*) config libtls ncursesw defvar OPENSSL_BIN openssl exec_prefix /bin/openssl ;; esac catgirl-2.2/edit.c000066400000000000000000000202541445265476100141140ustar00rootroot00000000000000/* Copyright (C) 2020, 2022 June McEnroe * * 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 . * * Additional permission under GNU GPL version 3 section 7: * * If you modify this Program, or any covered work, by linking or * combining it with OpenSSL (or a modified version of that library), * containing parts covered by the terms of the OpenSSL License and the * original SSLeay license, the licensors of this Program grant you * additional permission to convey the resulting work. Corresponding * Source for a non-source form of such a combination shall include the * source code for the parts of OpenSSL used as well as that of the * covered work. */ #include #include #include #include #include #include #include "edit.h" static bool isword(wchar_t ch) { return !iswspace(ch) && !iswpunct(ch); } char *editString(const struct Edit *e, char **buf, size_t *cap, size_t *pos) { size_t req = e->len * MB_CUR_MAX + 1; if (req > *cap) { char *new = realloc(*buf, req); if (!new) return NULL; *buf = new; *cap = req; } const wchar_t *ptr = e->buf; size_t len = wcsnrtombs(*buf, &ptr, e->pos, *cap-1, NULL); if (len == (size_t)-1) return NULL; if (pos) *pos = len; ptr = &e->buf[e->pos]; size_t n = wcsnrtombs( *buf + len, &ptr, e->len - e->pos, *cap-1 - len, NULL ); if (n == (size_t)-1) return NULL; len += n; (*buf)[len] = '\0'; return *buf; } int editReserve(struct Edit *e, size_t index, size_t count) { if (index > e->len) { errno = EINVAL; return -1; } if (e->len + count > e->cap) { size_t cap = (e->cap ?: 256); while (cap < e->len + count) cap *= 2; wchar_t *buf = realloc(e->buf, sizeof(*buf) * cap); if (!buf) return -1; e->buf = buf; e->cap = cap; } wmemmove(&e->buf[index + count], &e->buf[index], e->len - index); e->len += count; return 0; } int editCopy(struct Edit *e, size_t index, size_t count) { if (index + count > e->len) { errno = EINVAL; return -1; } if (!e->cut) return 0; e->cut->len = 0; if (editReserve(e->cut, 0, count) < 0) return -1; wmemcpy(e->cut->buf, &e->buf[index], count); return 0; } int editDelete(struct Edit *e, bool cut, size_t index, size_t count) { if (index + count > e->len) { errno = EINVAL; return -1; } if (cut && editCopy(e, index, count) < 0) return -1; wmemmove(&e->buf[index], &e->buf[index + count], e->len - index - count); e->len -= count; if (e->pos > e->len) e->pos = e->len; return 0; } static size_t prevSpacing(const struct Edit *e, size_t pos) { if (!pos) return 0; do { pos--; } while (pos && !wcwidth(e->buf[pos])); return pos; } static size_t nextSpacing(const struct Edit *e, size_t pos) { if (pos == e->len) return e->len; do { pos++; } while (pos < e->len && !wcwidth(e->buf[pos])); return pos; } int editFn(struct Edit *e, enum EditFn fn) { int ret = 0; switch (fn) { break; case EditHead: e->pos = 0; break; case EditTail: e->pos = e->len; break; case EditPrev: e->pos = prevSpacing(e, e->pos); break; case EditNext: e->pos = nextSpacing(e, e->pos); break; case EditPrevWord: { while (e->pos && !isword(e->buf[e->pos-1])) e->pos--; while (e->pos && isword(e->buf[e->pos-1])) e->pos--; } break; case EditNextWord: { while (e->pos < e->len && isword(e->buf[e->pos])) e->pos++; while (e->pos < e->len && !isword(e->buf[e->pos])) e->pos++; } break; case EditDeleteHead: { ret = editDelete(e, true, 0, e->pos); e->pos = 0; } break; case EditDeleteTail: { ret = editDelete(e, true, e->pos, e->len - e->pos); } break; case EditDeletePrev: { size_t prev = prevSpacing(e, e->pos); editDelete(e, false, prev, e->pos - prev); e->pos = prev; } break; case EditDeleteNext: { editDelete(e, false, e->pos, nextSpacing(e, e->pos) - e->pos); } break; case EditDeletePrevWord: { if (!e->pos) break; size_t word = e->pos; while (word && !isword(e->buf[word-1])) word--; while (word && isword(e->buf[word-1])) word--; ret = editDelete(e, true, word, e->pos - word); e->pos = word; } break; case EditDeleteNextWord: { if (e->pos == e->len) break; size_t word = e->pos; while (word < e->len && !isword(e->buf[word])) word++; while (word < e->len && isword(e->buf[word])) word++; ret = editDelete(e, true, e->pos, word - e->pos); } break; case EditPaste: { if (!e->cut) break; ret = editReserve(e, e->pos, e->cut->len); if (ret == 0) { wmemcpy(&e->buf[e->pos], e->cut->buf, e->cut->len); e->pos += e->cut->len; } } break; case EditTranspose: { if (e->len < 2) break; if (!e->pos) e->pos++; if (e->pos == e->len) e->pos--; wchar_t x = e->buf[e->pos-1]; e->buf[e->pos-1] = e->buf[e->pos]; e->buf[e->pos++] = x; } break; case EditCollapse: { size_t ws; for (e->pos = 0; e->pos < e->len;) { for (; e->pos < e->len && !iswspace(e->buf[e->pos]); ++e->pos); for (ws = e->pos; ws < e->len && iswspace(e->buf[ws]); ++ws); if (e->pos && ws < e->len) { editDelete(e, false, e->pos, ws - e->pos - 1); e->buf[e->pos++] = L' '; } else { editDelete(e, false, e->pos, ws - e->pos); } } } break; case EditClear: e->len = e->pos = 0; } return ret; } int editInsert(struct Edit *e, wchar_t ch) { char mb[MB_LEN_MAX]; if (wctomb(mb, ch) < 0) return -1; if (editReserve(e, e->pos, 1) < 0) return -1; e->buf[e->pos++] = ch; return 0; } #ifdef TEST #undef NDEBUG #include #include static void fix(struct Edit *e, const char *str) { assert(0 == editFn(e, EditClear)); for (const char *ch = str; *ch; ++ch) { assert(0 == editInsert(e, (wchar_t)*ch)); } } static bool eq(struct Edit *e, const char *str1) { size_t pos; static size_t cap; static char *buf; assert(NULL != editString(e, &buf, &cap, &pos)); const char *str2 = &str1[strlen(str1) + 1]; return pos == strlen(str1) && !strncmp(buf, str1, pos) && !strcmp(&buf[pos], str2); } #define editFn(...) assert(0 == editFn(__VA_ARGS__)) int main(void) { struct Edit cut = {0}; struct Edit e = { .cut = &cut }; fix(&e, "foo bar"); editFn(&e, EditHead); assert(eq(&e, "\0foo bar")); editFn(&e, EditTail); assert(eq(&e, "foo bar\0")); editFn(&e, EditPrev); assert(eq(&e, "foo ba\0r")); editFn(&e, EditNext); assert(eq(&e, "foo bar\0")); fix(&e, "foo, bar"); editFn(&e, EditPrevWord); assert(eq(&e, "foo, \0bar")); editFn(&e, EditPrevWord); assert(eq(&e, "\0foo, bar")); editFn(&e, EditNextWord); assert(eq(&e, "foo, \0bar")); editFn(&e, EditNextWord); assert(eq(&e, "foo, bar\0")); fix(&e, "foo bar"); editFn(&e, EditPrevWord); editFn(&e, EditDeleteHead); assert(eq(&e, "\0bar")); fix(&e, "foo bar"); editFn(&e, EditPrevWord); editFn(&e, EditDeleteTail); assert(eq(&e, "foo \0")); fix(&e, "foo bar"); editFn(&e, EditDeletePrev); assert(eq(&e, "foo ba\0")); editFn(&e, EditHead); editFn(&e, EditDeleteNext); assert(eq(&e, "\0oo ba")); fix(&e, "foo, bar"); editFn(&e, EditDeletePrevWord); assert(eq(&e, "foo, \0")); editFn(&e, EditDeletePrevWord); assert(eq(&e, "\0")); fix(&e, "foo, bar"); editFn(&e, EditHead); editFn(&e, EditDeleteNextWord); assert(eq(&e, "\0, bar")); editFn(&e, EditDeleteNextWord); assert(eq(&e, "\0")); fix(&e, "foo bar"); editFn(&e, EditDeletePrevWord); editFn(&e, EditPaste); assert(eq(&e, "foo bar\0")); editFn(&e, EditPaste); assert(eq(&e, "foo barbar\0")); fix(&e, "bar"); editFn(&e, EditTranspose); assert(eq(&e, "bra\0")); editFn(&e, EditHead); editFn(&e, EditTranspose); assert(eq(&e, "rb\0a")); editFn(&e, EditTranspose); assert(eq(&e, "rab\0")); fix(&e, " foo bar "); editFn(&e, EditCollapse); assert(eq(&e, "foo bar\0")); } #endif /* TEST */ catgirl-2.2/edit.h000066400000000000000000000043731445265476100141250ustar00rootroot00000000000000/* Copyright (C) 2022 June McEnroe * * 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 . * * Additional permission under GNU GPL version 3 section 7: * * If you modify this Program, or any covered work, by linking or * combining it with OpenSSL (or a modified version of that library), * containing parts covered by the terms of the OpenSSL License and the * original SSLeay license, the licensors of this Program grant you * additional permission to convey the resulting work. Corresponding * Source for a non-source form of such a combination shall include the * source code for the parts of OpenSSL used as well as that of the * covered work. */ #include #include struct Edit { wchar_t *buf; size_t pos; size_t len; size_t cap; struct Edit *cut; }; enum EditFn { EditHead, EditTail, EditPrev, EditNext, EditPrevWord, EditNextWord, EditDeleteHead, EditDeleteTail, EditDeletePrev, EditDeleteNext, EditDeletePrevWord, EditDeleteNextWord, EditPaste, EditTranspose, EditCollapse, EditClear, }; // Perform an editing function. int editFn(struct Edit *e, enum EditFn fn); // Insert a character at the cursor. int editInsert(struct Edit *e, wchar_t ch); // Convert the buffer to a multi-byte string. char *editString(const struct Edit *e, char **buf, size_t *cap, size_t *pos); // Reserve a range in the buffer. int editReserve(struct Edit *e, size_t index, size_t count); // Copy a range of the buffer into e->cut. int editCopy(struct Edit *e, size_t index, size_t count); // Delete a range from the buffer. If cut is true, copy the deleted portion. int editDelete(struct Edit *e, bool cut, size_t index, size_t count); catgirl-2.2/filter.c000066400000000000000000000103721445265476100144540ustar00rootroot00000000000000/* Copyright (C) 2020 June McEnroe * * 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 . * * Additional permission under GNU GPL version 3 section 7: * * If you modify this Program, or any covered work, by linking or * combining it with OpenSSL (or a modified version of that library), * containing parts covered by the terms of the OpenSSL License and the * original SSLeay license, the licensors of this Program grant you * additional permission to convey the resulting work. Corresponding * Source for a non-source form of such a combination shall include the * source code for the parts of OpenSSL used as well as that of the * covered work. */ #include #include #include #include #include #include #include #include "chat.h" struct Filter filters[FilterCap]; static size_t len; struct Filter filterParse(enum Heat heat, char *pattern) { struct Filter filter = { .heat = heat }; filter.mask = strsep(&pattern, " "); filter.cmd = strsep(&pattern, " "); filter.chan = strsep(&pattern, " "); filter.mesg = pattern; return filter; } struct Filter filterAdd(enum Heat heat, const char *pattern) { if (len == FilterCap) errx(EX_CONFIG, "filter limit exceeded"); char *own; if (!strchr(pattern, '!') && !strchr(pattern, ' ')) { int n = asprintf(&own, "%s!*@*", pattern); if (n < 0) err(EX_OSERR, "asprintf"); } else { own = strdup(pattern); if (!own) err(EX_OSERR, "strdup"); } struct Filter filter = filterParse(heat, own); filters[len++] = filter; return filter; } bool filterRemove(struct Filter filter) { bool found = false; for (size_t i = len - 1; i < len; --i) { if (filters[i].heat != filter.heat) continue; if (!filters[i].cmd != !filter.cmd) continue; if (!filters[i].chan != !filter.chan) continue; if (!filters[i].mesg != !filter.mesg) continue; if (strcasecmp(filters[i].mask, filter.mask)) continue; if (filter.cmd && strcasecmp(filters[i].cmd, filter.cmd)) continue; if (filter.chan && strcasecmp(filters[i].chan, filter.chan)) continue; if (filter.mesg && strcasecmp(filters[i].mesg, filter.mesg)) continue; free(filters[i].mask); memmove(&filters[i], &filters[i + 1], sizeof(*filters) * --len); filters[len] = (struct Filter) {0}; found = true; } return found; } static bool filterTest( struct Filter filter, const char *mask, uint id, const struct Message *msg ) { if (fnmatch(filter.mask, mask, FNM_CASEFOLD)) return false; if (!filter.cmd) return true; if (fnmatch(filter.cmd, msg->cmd, FNM_CASEFOLD)) return false; if (!filter.chan) return true; if (fnmatch(filter.chan, idNames[id], FNM_CASEFOLD)) return false; if (!filter.mesg) return true; if (!msg->params[1]) return false; return !fnmatch(filter.mesg, msg->params[1], FNM_CASEFOLD); } enum { IcedCap = 8 }; static struct { size_t len; char *msgIDs[IcedCap]; } iced; static void icedPush(const char *msgID) { if (!msgID) return; size_t i = iced.len % IcedCap; free(iced.msgIDs[i]); iced.msgIDs[i] = strdup(msgID); if (!iced.msgIDs[i]) err(EX_OSERR, "strdup"); iced.len++; } enum Heat filterCheck(enum Heat heat, uint id, const struct Message *msg) { if (!len) return heat; if (msg->tags[TagReply]) { for (size_t i = 0; i < IcedCap; ++i) { if (!iced.msgIDs[i]) continue; if (strcmp(msg->tags[TagReply], iced.msgIDs[i])) continue; icedPush(msg->tags[TagMsgID]); return Ice; } } char mask[512]; snprintf(mask, sizeof(mask), "%s!%s@%s", msg->nick, msg->user, msg->host); for (size_t i = 0; i < len; ++i) { if (!filterTest(filters[i], mask, id, msg)) continue; if (filters[i].heat == Ice) icedPush(msg->tags[TagMsgID]); return filters[i].heat; } return heat; } catgirl-2.2/handle.c000066400000000000000000001200431445265476100144170ustar00rootroot00000000000000/* Copyright (C) 2020 June McEnroe * * 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 . * * Additional permission under GNU GPL version 3 section 7: * * If you modify this Program, or any covered work, by linking or * combining it with OpenSSL (or a modified version of that library), * containing parts covered by the terms of the OpenSSL License and the * original SSLeay license, the licensors of this Program grant you * additional permission to convey the resulting work. Corresponding * Source for a non-source form of such a combination shall include the * source code for the parts of OpenSSL used as well as that of the * covered work. */ #include #include #include #include #include #include #include #include #include #include "chat.h" uint replies[ReplyCap]; static const char *CapNames[] = { #define X(name, id) [id##Bit] = name, ENUM_CAP #undef X }; static enum Cap capParse(const char *list) { enum Cap caps = 0; while (*list) { enum Cap cap = 0; size_t len = strcspn(list, " "); for (size_t i = 0; i < ARRAY_LEN(CapNames); ++i) { if (len != strlen(CapNames[i])) continue; if (strncmp(list, CapNames[i], len)) continue; cap = 1 << i; break; } caps |= cap; list += len; if (*list) list++; } return caps; } static void capList(char *buf, size_t cap, enum Cap caps) { *buf = '\0'; char *ptr = buf, *end = &buf[cap]; for (size_t i = 0; i < ARRAY_LEN(CapNames); ++i) { if (caps & (1 << i)) { ptr = seprintf( ptr, end, "%s%s", (ptr > buf ? " " : ""), CapNames[i] ); } } } static void require(struct Message *msg, bool origin, uint len) { if (origin) { if (!msg->nick) msg->nick = "*.*"; if (!msg->user) msg->user = msg->nick; if (!msg->host) msg->host = msg->user; } for (uint i = 0; i < len; ++i) { if (msg->params[i]) continue; errx(EX_PROTOCOL, "%s missing parameter %u", msg->cmd, 1 + i); } } static const time_t *tagTime(const struct Message *msg) { static time_t time; struct tm tm; if (!msg->tags[TagTime]) return NULL; if (!strptime(msg->tags[TagTime], "%Y-%m-%dT%T", &tm)) return NULL; time = timegm(&tm); return &time; } typedef void Handler(struct Message *msg); static void handleStandardReply(struct Message *msg) { require(msg, false, 3); for (uint i = 2; i < ParamCap - 1; ++i) { if (msg->params[i + 1]) continue; uiFormat( Network, Warm, tagTime(msg), "%s", msg->params[i] ); break; } } static void handleErrorGeneric(struct Message *msg) { require(msg, false, 2); if (msg->params[2]) { size_t len = strlen(msg->params[2]); if (msg->params[2][len - 1] == '.') msg->params[2][len - 1] = '\0'; uiFormat( Network, Warm, tagTime(msg), "%s: %s", msg->params[2], msg->params[1] ); } else { uiFormat( Network, Warm, tagTime(msg), "%s", msg->params[1] ); } } static void handleReplyGeneric(struct Message *msg) { uint first = 1; uint id = Network; if (msg->params[1] && strchr(network.chanTypes, msg->params[1][0])) { id = idFor(msg->params[1]); first++; } char buf[1024]; char *ptr = buf, *end = &buf[sizeof(buf)]; ptr = seprintf(ptr, end, "\3%d(%s)\3\t", Gray, msg->cmd); for (uint i = first; i < ParamCap && msg->params[i]; ++i) { ptr = seprintf( ptr, end, "%s%s", (i > first ? " " : ""), msg->params[i] ); } uiWrite(id, Ice, tagTime(msg), buf); } static void handleErrorNicknameInUse(struct Message *msg) { require(msg, false, 2); if (!strcmp(self.nick, "*")) { static uint i = 1; if (i < ARRAY_LEN(self.nicks) && self.nicks[i]) { ircFormat("NICK %s\r\n", self.nicks[i++]); } else { ircFormat("NICK %s_\r\n", msg->params[1]); } } else { handleErrorGeneric(msg); } } static void handleErrorErroneousNickname(struct Message *msg) { require(msg, false, 3); if (!strcmp(self.nick, "*")) { errx(EX_CONFIG, "%s: %s", msg->params[1], msg->params[2]); } else { handleErrorGeneric(msg); } } static void handleCap(struct Message *msg) { require(msg, false, 3); enum Cap caps = capParse(msg->params[2]); if (!strcmp(msg->params[1], "LS")) { caps &= ~CapSASL; if (caps & CapConsumer && self.pos) { ircFormat("CAP REQ %s=%zu\r\n", CapNames[CapConsumerBit], self.pos); caps &= ~CapConsumer; } if (caps) { char buf[512]; capList(buf, sizeof(buf), caps); ircFormat("CAP REQ :%s\r\n", buf); } else { if (!(self.caps & CapSASL)) ircFormat("CAP END\r\n"); } } else if (!strcmp(msg->params[1], "ACK")) { self.caps |= caps; if (caps & CapSASL) { ircFormat( "AUTHENTICATE %s\r\n", (self.plainUser ? "PLAIN" : "EXTERNAL") ); } if (!(self.caps & CapSASL)) ircFormat("CAP END\r\n"); } else if (!strcmp(msg->params[1], "NAK")) { errx(EX_CONFIG, "server does not support %s", msg->params[2]); } } #define BASE64_SIZE(len) (1 + ((len) + 2) / 3 * 4) static void base64(char *dst, const byte *src, size_t len) { static const char Base64[64] = { "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/" }; size_t i = 0; while (len > 2) { dst[i++] = Base64[0x3F & (src[0] >> 2)]; dst[i++] = Base64[0x3F & (src[0] << 4 | src[1] >> 4)]; dst[i++] = Base64[0x3F & (src[1] << 2 | src[2] >> 6)]; dst[i++] = Base64[0x3F & src[2]]; src += 3; len -= 3; } if (len) { dst[i++] = Base64[0x3F & (src[0] >> 2)]; if (len > 1) { dst[i++] = Base64[0x3F & (src[0] << 4 | src[1] >> 4)]; dst[i++] = Base64[0x3F & (src[1] << 2)]; } else { dst[i++] = Base64[0x3F & (src[0] << 4)]; dst[i++] = '='; } dst[i++] = '='; } dst[i] = '\0'; } static void handleAuthenticate(struct Message *msg) { (void)msg; if (!self.plainUser) { ircFormat("AUTHENTICATE +\r\n"); return; } byte buf[299] = {0}; size_t userLen = strlen(self.plainUser); size_t passLen = strlen(self.plainPass); size_t len = 1 + userLen + 1 + passLen; if (sizeof(buf) < len) errx(EX_USAGE, "SASL PLAIN is too long"); memcpy(&buf[1], self.plainUser, userLen); memcpy(&buf[1 + userLen + 1], self.plainPass, passLen); char b64[BASE64_SIZE(sizeof(buf))]; base64(b64, buf, len); ircFormat("AUTHENTICATE "); ircSend(b64, BASE64_SIZE(len) - 1); ircFormat("\r\n"); explicit_bzero(b64, sizeof(b64)); explicit_bzero(buf, sizeof(buf)); explicit_bzero(self.plainPass, strlen(self.plainPass)); } static void handleReplyLoggedIn(struct Message *msg) { (void)msg; ircFormat("CAP END\r\n"); handleReplyGeneric(msg); } static void handleErrorSASLFail(struct Message *msg) { require(msg, false, 2); errx(EX_CONFIG, "%s", msg->params[1]); } static void handleReplyWelcome(struct Message *msg) { require(msg, false, 1); set(&self.nick, msg->params[0]); completePull(Network, self.nick, Default); if (self.mode) ircFormat("MODE %s %s\r\n", self.nick, self.mode); if (self.join) { uint count = 1; for (const char *ch = self.join; *ch && *ch != ' '; ++ch) { if (*ch == ',') count++; } ircFormat("JOIN %s\r\n", self.join); if (count == 1) replies[ReplyJoin]++; replies[ReplyTopicAuto] += count; replies[ReplyNamesAuto] += count; } commandCompletion(); handleReplyGeneric(msg); } static void handleReplyISupport(struct Message *msg) { handleReplyGeneric(msg); for (uint i = 1; i < ParamCap; ++i) { if (!msg->params[i]) break; char *key = strsep(&msg->params[i], "="); if (!strcmp(key, "NETWORK")) { if (!msg->params[i]) continue; set(&network.name, msg->params[i]); static bool arrived; if (!arrived) { uiFormat( Network, Cold, tagTime(msg), "You arrive in %s", msg->params[i] ); arrived = true; } } else if (!strcmp(key, "USERLEN")) { if (!msg->params[i]) continue; network.userLen = strtoul(msg->params[i], NULL, 10); } else if (!strcmp(key, "HOSTLEN")) { if (!msg->params[i]) continue; network.hostLen = strtoul(msg->params[i], NULL, 10); } else if (!strcmp(key, "CHANTYPES")) { if (!msg->params[i]) continue; set(&network.chanTypes, msg->params[i]); } else if (!strcmp(key, "STATUSMSG")) { if (!msg->params[i]) continue; set(&network.statusmsg, msg->params[i]); } else if (!strcmp(key, "PREFIX")) { strsep(&msg->params[i], "("); char *modes = strsep(&msg->params[i], ")"); char *prefixes = msg->params[i]; if (!modes || !prefixes || strlen(modes) != strlen(prefixes)) { errx(EX_PROTOCOL, "invalid PREFIX value"); } set(&network.prefixModes, modes); set(&network.prefixes, prefixes); } else if (!strcmp(key, "CHANMODES")) { char *list = strsep(&msg->params[i], ","); char *param = strsep(&msg->params[i], ","); char *setParam = strsep(&msg->params[i], ","); char *channel = strsep(&msg->params[i], ","); if (!list || !param || !setParam || !channel) { errx(EX_PROTOCOL, "invalid CHANMODES value"); } set(&network.listModes, list); set(&network.paramModes, param); set(&network.setParamModes, setParam); set(&network.channelModes, channel); } else if (!strcmp(key, "EXCEPTS")) { network.excepts = (msg->params[i] ?: "e")[0]; } else if (!strcmp(key, "INVEX")) { network.invex = (msg->params[i] ?: "I")[0]; } } } static void handleReplyMOTD(struct Message *msg) { require(msg, false, 2); char *line = msg->params[1]; urlScan(Network, NULL, line); if (!strncmp(line, "- ", 2)) { uiFormat(Network, Cold, tagTime(msg), "\3%d-\3\t%s", Gray, &line[2]); } else { uiFormat(Network, Cold, tagTime(msg), "%s", line); } } static void handleErrorNoMOTD(struct Message *msg) { (void)msg; } static void handleReplyHelp(struct Message *msg) { require(msg, false, 3); urlScan(Network, NULL, msg->params[2]); uiWrite(Network, Warm, tagTime(msg), msg->params[2]); } static void handleJoin(struct Message *msg) { require(msg, true, 1); uint id = idFor(msg->params[0]); if (!strcmp(msg->nick, self.nick)) { if (!self.user || strcmp(self.user, msg->user)) { set(&self.user, msg->user); self.color = hash(msg->user); } if (!self.host || strcmp(self.host, msg->host)) { set(&self.host, msg->host); } idColors[id] = hash(msg->params[0]); completePull(None, msg->params[0], idColors[id]); if (replies[ReplyJoin]) { windowShow(windowFor(id)); replies[ReplyJoin]--; } } completePull(id, msg->nick, hash(msg->user)); if (msg->params[2] && !strcasecmp(msg->params[2], msg->nick)) { msg->params[2] = NULL; } uiFormat( id, filterCheck(Cold, id, msg), tagTime(msg), "\3%02d%s\3\t%s%s%sarrives in \3%02d%s\3", hash(msg->user), msg->nick, (msg->params[2] ? "(" : ""), (msg->params[2] ?: ""), (msg->params[2] ? "\17) " : ""), hash(msg->params[0]), msg->params[0] ); logFormat(id, tagTime(msg), "%s arrives in %s", msg->nick, msg->params[0]); } static void handleChghost(struct Message *msg) { require(msg, true, 2); if (strcmp(msg->nick, self.nick)) return; if (!self.user || strcmp(self.user, msg->params[0])) { set(&self.user, msg->params[0]); self.color = hash(msg->params[0]); } if (!self.host || strcmp(self.host, msg->params[1])) { set(&self.host, msg->params[1]); } } static void handlePart(struct Message *msg) { require(msg, true, 1); uint id = idFor(msg->params[0]); if (!strcmp(msg->nick, self.nick)) { completeRemove(id, NULL); } completeRemove(id, msg->nick); enum Heat heat = filterCheck(Cold, id, msg); if (heat > Ice) urlScan(id, msg->nick, msg->params[1]); uiFormat( id, heat, tagTime(msg), "\3%02d%s\3\tleaves \3%02d%s\3%s%s", hash(msg->user), msg->nick, hash(msg->params[0]), msg->params[0], (msg->params[1] ? ": " : ""), (msg->params[1] ?: "") ); logFormat( id, tagTime(msg), "%s leaves %s%s%s", msg->nick, msg->params[0], (msg->params[1] ? ": " : ""), (msg->params[1] ?: "") ); } static void handleKick(struct Message *msg) { require(msg, true, 2); uint id = idFor(msg->params[0]); bool kicked = !strcmp(msg->params[1], self.nick); completePull(id, msg->nick, hash(msg->user)); urlScan(id, msg->nick, msg->params[2]); uiFormat( id, (kicked ? Hot : Cold), tagTime(msg), "%s\3%02d%s\17\tkicks \3%02d%s\3 out of \3%02d%s\3%s%s", (kicked ? "\26" : ""), hash(msg->user), msg->nick, completeColor(id, msg->params[1]), msg->params[1], hash(msg->params[0]), msg->params[0], (msg->params[2] ? ": " : ""), (msg->params[2] ?: "") ); logFormat( id, tagTime(msg), "%s kicks %s out of %s%s%s", msg->nick, msg->params[1], msg->params[0], (msg->params[2] ? ": " : ""), (msg->params[2] ?: "") ); completeRemove(id, msg->params[1]); if (kicked) completeRemove(id, NULL); } static void handleNick(struct Message *msg) { require(msg, true, 1); if (!strcmp(msg->nick, self.nick)) { set(&self.nick, msg->params[0]); inputUpdate(); } struct Cursor curs = {0}; for (uint id; (id = completeEachID(&curs, msg->nick));) { if (!strcmp(idNames[id], msg->nick)) { set(&idNames[id], msg->params[0]); } uiFormat( id, filterCheck(Cold, id, msg), tagTime(msg), "\3%02d%s\3\tis now known as \3%02d%s\3", hash(msg->user), msg->nick, hash(msg->user), msg->params[0] ); if (id == Network) continue; logFormat( id, tagTime(msg), "%s is now known as %s", msg->nick, msg->params[0] ); } completeReplace(msg->nick, msg->params[0]); } static void handleSetname(struct Message *msg) { require(msg, true, 1); struct Cursor curs = {0}; for (uint id; (id = completeEachID(&curs, msg->nick));) { uiFormat( id, filterCheck(Cold, id, msg), tagTime(msg), "\3%02d%s\3\tis now known as \3%02d%s\3 (%s\17)", hash(msg->user), msg->nick, hash(msg->user), msg->nick, msg->params[0] ); } } static void handleQuit(struct Message *msg) { require(msg, true, 0); struct Cursor curs = {0}; for (uint id; (id = completeEachID(&curs, msg->nick));) { enum Heat heat = filterCheck(Cold, id, msg); if (heat > Ice) urlScan(id, msg->nick, msg->params[0]); uiFormat( id, heat, tagTime(msg), "\3%02d%s\3\tleaves%s%s", hash(msg->user), msg->nick, (msg->params[0] ? ": " : ""), (msg->params[0] ?: "") ); if (id == Network) continue; logFormat( id, tagTime(msg), "%s leaves%s%s", msg->nick, (msg->params[0] ? ": " : ""), (msg->params[0] ?: "") ); } completeRemove(None, msg->nick); } static void handleInvite(struct Message *msg) { require(msg, true, 2); if (!strcmp(msg->params[0], self.nick)) { set(&self.invited, msg->params[1]); uiFormat( Network, filterCheck(Hot, Network, msg), tagTime(msg), "\3%02d%s\3\tinvites you to \3%02d%s\3", hash(msg->user), msg->nick, hash(msg->params[1]), msg->params[1] ); } else { uint id = idFor(msg->params[1]); uiFormat( id, Cold, tagTime(msg), "\3%02d%s\3\tinvites %s to \3%02d%s\3", hash(msg->user), msg->nick, msg->params[0], hash(msg->params[1]), msg->params[1] ); logFormat( id, tagTime(msg), "%s invites %s to %s", msg->nick, msg->params[0], msg->params[1] ); } } static void handleReplyInviting(struct Message *msg) { require(msg, false, 3); struct Message invite = { .nick = self.nick, .user = self.user, .cmd = "INVITE", .params[0] = msg->params[1], .params[1] = msg->params[2], }; handleInvite(&invite); } static void handleErrorUserOnChannel(struct Message *msg) { require(msg, false, 3); uint id = idFor(msg->params[2]); uiFormat( id, Warm, tagTime(msg), "\3%02d%s\3 is already in \3%02d%s\3", completeColor(id, msg->params[1]), msg->params[1], hash(msg->params[2]), msg->params[2] ); } static void handleReplyNames(struct Message *msg) { require(msg, false, 4); uint id = idFor(msg->params[2]); char buf[1024]; char *ptr = buf, *end = &buf[sizeof(buf)]; while (msg->params[3]) { char *name = strsep(&msg->params[3], " "); char *prefixes = strsep(&name, "!"); char *nick = &prefixes[strspn(prefixes, network.prefixes)]; char *user = strsep(&name, "@"); enum Color color = (user ? hash(user) : Default); uint bits = 0; for (char *p = prefixes; p < nick; ++p) { bits |= prefixBit(*p); } completePush(id, nick, color); *completeBits(id, nick) = bits; if (!replies[ReplyNames] && !replies[ReplyNamesAuto]) continue; ptr = seprintf( ptr, end, "%s\3%02d%s\3", (ptr > buf ? ", " : ""), color, prefixes ); } if (ptr == buf) return; uiFormat( id, (replies[ReplyNamesAuto] ? Cold : Warm), tagTime(msg), "In \3%02d%s\3 are %s", hash(msg->params[2]), msg->params[2], buf ); } static void handleReplyEndOfNames(struct Message *msg) { (void)msg; if (replies[ReplyNamesAuto]) { replies[ReplyNamesAuto]--; } else if (replies[ReplyNames]) { replies[ReplyNames]--; } } static void handleReplyNoTopic(struct Message *msg) { require(msg, false, 2); uiFormat( idFor(msg->params[1]), Warm, tagTime(msg), "There is no sign in \3%02d%s\3", hash(msg->params[1]), msg->params[1] ); } static void topicComplete(uint id, const char *topic) { char buf[512]; struct Cursor curs = {0}; const char *prev = completePrefix(&curs, id, "/topic "); if (prev) { snprintf(buf, sizeof(buf), "%s", prev); completeRemove(id, buf); } if (topic) { snprintf(buf, sizeof(buf), "/topic %s", topic); completePush(id, buf, Default); } } static void handleReplyTopic(struct Message *msg) { require(msg, false, 3); uint id = idFor(msg->params[1]); topicComplete(id, msg->params[2]); if (!replies[ReplyTopic] && !replies[ReplyTopicAuto]) return; urlScan(id, NULL, msg->params[2]); uiFormat( id, (replies[ReplyTopicAuto] ? Cold : Warm), tagTime(msg), "The sign in \3%02d%s\3 reads: %s", hash(msg->params[1]), msg->params[1], msg->params[2] ); logFormat( id, tagTime(msg), "The sign in %s reads: %s", msg->params[1], msg->params[2] ); if (replies[ReplyTopicAuto]) { replies[ReplyTopicAuto]--; } else { replies[ReplyTopic]--; } } static void swap(wchar_t *a, wchar_t *b) { wchar_t x = *a; *a = *b; *b = x; } static char *highlightMiddle( char *ptr, char *end, enum Color color, wchar_t *str, size_t pre, size_t suf ) { wchar_t nul = L'\0'; swap(&str[pre], &nul); ptr = seprintf(ptr, end, "%ls", str); swap(&str[pre], &nul); swap(&str[suf], &nul); if (hashBound) { ptr = seprintf( ptr, end, "\3%02d,%02d%ls\3%02d,%02d", Default, color, &str[pre], Default, Default ); } else { ptr = seprintf(ptr, end, "\26%ls\26", &str[pre]); } swap(&str[suf], &nul); ptr = seprintf(ptr, end, "%ls", &str[suf]); return ptr; } static void handleTopic(struct Message *msg) { require(msg, true, 2); uint id = idFor(msg->params[0]); if (!msg->params[1][0]) { topicComplete(id, NULL); uiFormat( id, Warm, tagTime(msg), "\3%02d%s\3\tremoves the sign in \3%02d%s\3", hash(msg->user), msg->nick, hash(msg->params[0]), msg->params[0] ); logFormat( id, tagTime(msg), "%s removes the sign in %s", msg->nick, msg->params[0] ); return; } struct Cursor curs = {0}; const char *prev = completePrefix(&curs, id, "/topic "); if (prev) { prev += 7; } else { goto plain; } wchar_t old[512]; wchar_t new[512]; if (swprintf(old, ARRAY_LEN(old), L"%s", prev) < 0) goto plain; if (swprintf(new, ARRAY_LEN(new), L"%s", msg->params[1]) < 0) goto plain; size_t pre; for (pre = 0; old[pre] && new[pre] && old[pre] == new[pre]; ++pre); size_t osuf = wcslen(old); size_t nsuf = wcslen(new); while (osuf > pre && nsuf > pre && old[osuf-1] == new[nsuf-1]) { osuf--; nsuf--; } char buf[1024]; char *ptr = buf, *end = &buf[sizeof(buf)]; ptr = seprintf( ptr, end, "\3%02d%s\3\ttakes down the sign in \3%02d%s\3: ", hash(msg->user), msg->nick, hash(msg->params[0]), msg->params[0] ); ptr = highlightMiddle(ptr, end, Brown, old, pre, osuf); if (osuf != pre) uiWrite(id, Cold, tagTime(msg), buf); ptr = buf; ptr = seprintf( ptr, end, "\3%02d%s\3\tplaces a new sign in \3%02d%s\3: ", hash(msg->user), msg->nick, hash(msg->params[0]), msg->params[0] ); ptr = highlightMiddle(ptr, end, Green, new, pre, nsuf); uiWrite(id, Warm, tagTime(msg), buf); goto log; plain: uiFormat( id, Warm, tagTime(msg), "\3%02d%s\3\tplaces a new sign in \3%02d%s\3: %s", hash(msg->user), msg->nick, hash(msg->params[0]), msg->params[0], msg->params[1] ); log: logFormat( id, tagTime(msg), "%s places a new sign in %s: %s", msg->nick, msg->params[0], msg->params[1] ); topicComplete(id, msg->params[1]); urlScan(id, msg->nick, msg->params[1]); } static const char *UserModes[256] = { ['O'] = "local oper", ['i'] = "invisible", ['o'] = "oper", ['r'] = "registered", ['w'] = "wallops", }; static void handleReplyUserModeIs(struct Message *msg) { require(msg, false, 2); char buf[1024]; char *ptr = buf, *end = &buf[sizeof(buf)]; for (char *ch = msg->params[1]; *ch; ++ch) { if (*ch == '+') continue; const char *name = UserModes[(byte)*ch]; ptr = seprintf( ptr, end, ", +%c%s%s", *ch, (name ? " " : ""), (name ?: "") ); } uiFormat( Network, Warm, tagTime(msg), "\3%02d%s\3\tis %s", self.color, self.nick, (ptr > buf ? &buf[2] : "modeless") ); } static const char *ChanModes[256] = { ['a'] = "protected", ['h'] = "halfop", ['i'] = "invite-only", ['k'] = "key", ['l'] = "client limit", ['m'] = "moderated", ['n'] = "no external messages", ['o'] = "operator", ['q'] = "founder", ['s'] = "secret", ['t'] = "protected topic", ['v'] = "voice", }; static void handleReplyChannelModeIs(struct Message *msg) { require(msg, false, 3); uint param = 3; char buf[1024]; char *ptr = buf, *end = &buf[sizeof(buf)]; for (char *ch = msg->params[2]; *ch; ++ch) { if (*ch == '+') continue; const char *name = ChanModes[(byte)*ch]; if ( strchr(network.paramModes, *ch) || strchr(network.setParamModes, *ch) ) { assert(param < ParamCap); ptr = seprintf( ptr, end, ", +%c%s%s %s", *ch, (name ? " " : ""), (name ?: ""), msg->params[param++] ); } else { ptr = seprintf( ptr, end, ", +%c%s%s", *ch, (name ? " " : ""), (name ?: "") ); } } uiFormat( idFor(msg->params[1]), Warm, tagTime(msg), "\3%02d%s\3\tis %s", hash(msg->params[1]), msg->params[1], (ptr > buf ? &buf[2] : "modeless") ); } static void handleMode(struct Message *msg) { require(msg, true, 2); if (!strchr(network.chanTypes, msg->params[0][0])) { bool set = true; for (char *ch = msg->params[1]; *ch; ++ch) { if (*ch == '+') { set = true; continue; } if (*ch == '-') { set = false; continue; } const char *name = UserModes[(byte)*ch]; uiFormat( Network, Warm, tagTime(msg), "\3%02d%s\3\t%ssets \3%02d%s\3 %c%c%s%s", hash(msg->user), msg->nick, (set ? "" : "un"), self.color, msg->params[0], set["-+"], *ch, (name ? " " : ""), (name ?: "") ); } return; } uint id = idFor(msg->params[0]); bool set = true; uint i = 2; for (char *ch = msg->params[1]; *ch; ++ch) { if (*ch == '+') { set = true; continue; } if (*ch == '-') { set = false; continue; } const char *verb = (set ? "sets" : "unsets"); const char *name = ChanModes[(byte)*ch]; if (*ch == network.excepts) name = "except"; if (*ch == network.invex) name = "invite"; const char *mode = (const char[]) { set["-+"], *ch, (name ? ' ' : '\0'), '\0' }; if (!name) name = ""; if (strchr(network.prefixModes, *ch)) { if (i >= ParamCap || !msg->params[i]) { errx(EX_PROTOCOL, "MODE missing %s parameter", mode); } char *nick = msg->params[i++]; char prefix = network.prefixes[ strchr(network.prefixModes, *ch) - network.prefixModes ]; completePush(id, nick, Default); if (set) { *completeBits(id, nick) |= prefixBit(prefix); } else { *completeBits(id, nick) &= ~prefixBit(prefix); } uiFormat( id, Cold, tagTime(msg), "\3%02d%s\3\t%s \3%02d%c%s\3 %s%s in \3%02d%s\3", hash(msg->user), msg->nick, verb, completeColor(id, nick), prefix, nick, mode, name, hash(msg->params[0]), msg->params[0] ); logFormat( id, tagTime(msg), "%s %s %c%s %s%s in %s", msg->nick, verb, prefix, nick, mode, name, msg->params[0] ); } if (strchr(network.listModes, *ch)) { if (i >= ParamCap || !msg->params[i]) { errx(EX_PROTOCOL, "MODE missing %s parameter", mode); } char *mask = msg->params[i++]; if (*ch == 'b') { verb = (set ? "bans" : "unbans"); uiFormat( id, Cold, tagTime(msg), "\3%02d%s\3\t%s %c%c %s from \3%02d%s\3", hash(msg->user), msg->nick, verb, set["-+"], *ch, mask, hash(msg->params[0]), msg->params[0] ); logFormat( id, tagTime(msg), "%s %s %c%c %s from %s", msg->nick, verb, set["-+"], *ch, mask, msg->params[0] ); } else { verb = (set ? "adds" : "removes"); const char *to = (set ? "to" : "from"); uiFormat( id, Cold, tagTime(msg), "\3%02d%s\3\t%s %s %s the \3%02d%s\3 %s%s list", hash(msg->user), msg->nick, verb, mask, to, hash(msg->params[0]), msg->params[0], mode, name ); logFormat( id, tagTime(msg), "%s %s %s %s the %s %s%s list", msg->nick, verb, mask, to, msg->params[0], mode, name ); } } if (strchr(network.paramModes, *ch)) { if (i >= ParamCap || !msg->params[i]) { errx(EX_PROTOCOL, "MODE missing %s parameter", mode); } char *param = msg->params[i++]; uiFormat( id, Cold, tagTime(msg), "\3%02d%s\3\t%s \3%02d%s\3 %s%s %s", hash(msg->user), msg->nick, verb, hash(msg->params[0]), msg->params[0], mode, name, param ); logFormat( id, tagTime(msg), "%s %s %s %s%s %s", msg->nick, verb, msg->params[0], mode, name, param ); } if (strchr(network.setParamModes, *ch) && set) { if (i >= ParamCap || !msg->params[i]) { errx(EX_PROTOCOL, "MODE missing %s parameter", mode); } char *param = msg->params[i++]; uiFormat( id, Cold, tagTime(msg), "\3%02d%s\3\t%s \3%02d%s\3 %s%s %s", hash(msg->user), msg->nick, verb, hash(msg->params[0]), msg->params[0], mode, name, param ); logFormat( id, tagTime(msg), "%s %s %s %s%s %s", msg->nick, verb, msg->params[0], mode, name, param ); } else if (strchr(network.setParamModes, *ch)) { uiFormat( id, Cold, tagTime(msg), "\3%02d%s\3\t%s \3%02d%s\3 %s%s", hash(msg->user), msg->nick, verb, hash(msg->params[0]), msg->params[0], mode, name ); logFormat( id, tagTime(msg), "%s %s %s %s%s", msg->nick, verb, msg->params[0], mode, name ); } if (strchr(network.channelModes, *ch)) { uiFormat( id, Cold, tagTime(msg), "\3%02d%s\3\t%s \3%02d%s\3 %s%s", hash(msg->user), msg->nick, verb, hash(msg->params[0]), msg->params[0], mode, name ); logFormat( id, tagTime(msg), "%s %s %s %s%s", msg->nick, verb, msg->params[0], mode, name ); } } } static void handleErrorChanopPrivsNeeded(struct Message *msg) { require(msg, false, 3); uiFormat( idFor(msg->params[1]), Warm, tagTime(msg), "%s", msg->params[2] ); } static void handleErrorUserNotInChannel(struct Message *msg) { require(msg, false, 4); uiFormat( idFor(msg->params[2]), Warm, tagTime(msg), "%s\tis not in \3%02d%s\3", msg->params[1], hash(msg->params[2]), msg->params[2] ); } static void handleErrorBanListFull(struct Message *msg) { require(msg, false, 4); uiFormat( idFor(msg->params[1]), Warm, tagTime(msg), "%s", (msg->params[4] ?: msg->params[3]) ); } static void handleReplyBanList(struct Message *msg) { require(msg, false, 3); uint id = idFor(msg->params[1]); if (msg->params[3] && msg->params[4]) { char since[sizeof("0000-00-00 00:00:00")]; time_t time = strtol(msg->params[4], NULL, 10); strftime(since, sizeof(since), "%F %T", localtime(&time)); uiFormat( id, Warm, tagTime(msg), "Banned from \3%02d%s\3 since %s by \3%02d%s\3: %s", hash(msg->params[1]), msg->params[1], since, completeColor(id, msg->params[3]), msg->params[3], msg->params[2] ); } else { uiFormat( id, Warm, tagTime(msg), "Banned from \3%02d%s\3: %s", hash(msg->params[1]), msg->params[1], msg->params[2] ); } } static void onList(const char *list, struct Message *msg) { require(msg, false, 3); uint id = idFor(msg->params[1]); if (msg->params[3] && msg->params[4]) { char since[sizeof("0000-00-00 00:00:00")]; time_t time = strtol(msg->params[4], NULL, 10); strftime(since, sizeof(since), "%F %T", localtime(&time)); uiFormat( id, Warm, tagTime(msg), "On the \3%02d%s\3 %s list since %s by \3%02d%s\3: %s", hash(msg->params[1]), msg->params[1], list, since, completeColor(id, msg->params[3]), msg->params[3], msg->params[2] ); } else { uiFormat( id, Warm, tagTime(msg), "On the \3%02d%s\3 %s list: %s", hash(msg->params[1]), msg->params[1], list, msg->params[2] ); } } static void handleReplyExceptList(struct Message *msg) { onList("except", msg); } static void handleReplyInviteList(struct Message *msg) { onList("invite", msg); } static void handleReplyList(struct Message *msg) { require(msg, false, 3); uiFormat( Network, Warm, tagTime(msg), "In \3%02d%s\3 are %ld under the banner: %s", hash(msg->params[1]), msg->params[1], strtol(msg->params[2], NULL, 10), (msg->params[3] ?: "") ); } static void handleReplyWhoisUser(struct Message *msg) { require(msg, false, 6); completePull(Network, msg->params[1], hash(msg->params[2])); uiFormat( Network, Warm, tagTime(msg), "\3%02d%s\3\tis %s!%s@%s (%s\17)", hash(msg->params[2]), msg->params[1], msg->params[1], msg->params[2], msg->params[3], msg->params[5] ); } static void handleReplyWhoisServer(struct Message *msg) { if (!replies[ReplyWhois] && !replies[ReplyWhowas]) return; require(msg, false, 4); uiFormat( Network, Warm, tagTime(msg), "\3%02d%s\3\t%s connected to %s (%s)", completeColor(Network, msg->params[1]), msg->params[1], (replies[ReplyWhowas] ? "was" : "is"), msg->params[2], msg->params[3] ); } static void handleReplyWhoisIdle(struct Message *msg) { require(msg, false, 3); unsigned long idle = strtoul(msg->params[2], NULL, 10); const char *unit = "second"; if (idle / 60) { idle /= 60; unit = "minute"; if (idle / 60) { idle /= 60; unit = "hour"; if (idle / 24) { idle /= 24; unit = "day"; } } } char signon[sizeof("0000-00-00 00:00:00")]; time_t time = strtol((msg->params[3] ?: ""), NULL, 10); strftime(signon, sizeof(signon), "%F %T", localtime(&time)); uiFormat( Network, Warm, tagTime(msg), "\3%02d%s\3\tis idle for %lu %s%s%s%s", completeColor(Network, msg->params[1]), msg->params[1], idle, unit, (idle != 1 ? "s" : ""), (msg->params[3] ? ", signed on " : ""), (msg->params[3] ? signon : "") ); } static void handleReplyWhoisChannels(struct Message *msg) { require(msg, false, 3); char buf[1024]; char *ptr = buf, *end = &buf[sizeof(buf)]; while (msg->params[2]) { char *channel = strsep(&msg->params[2], " "); if (!channel[0]) break; char *name = &channel[strspn(channel, network.prefixes)]; ptr = seprintf( ptr, end, "%s\3%02d%s\3", (ptr > buf ? ", " : ""), hash(name), channel ); } uiFormat( Network, Warm, tagTime(msg), "\3%02d%s\3\tis in %s", completeColor(Network, msg->params[1]), msg->params[1], buf ); } static void handleReplyWhoisGeneric(struct Message *msg) { require(msg, false, 3); if (msg->params[3]) { msg->params[0] = msg->params[2]; msg->params[2] = msg->params[3]; msg->params[3] = msg->params[0]; } uiFormat( Network, Warm, tagTime(msg), "\3%02d%s\3\t%s%s%s", completeColor(Network, msg->params[1]), msg->params[1], msg->params[2], (msg->params[3] ? " " : ""), (msg->params[3] ?: "") ); } static void handleReplyEndOfWhois(struct Message *msg) { require(msg, false, 2); if (strcmp(msg->params[1], self.nick)) { completeRemove(Network, msg->params[1]); } } static void handleReplyWhowasUser(struct Message *msg) { require(msg, false, 6); completePull(Network, msg->params[1], hash(msg->params[2])); uiFormat( Network, Warm, tagTime(msg), "\3%02d%s\3\twas %s!%s@%s (%s)", hash(msg->params[2]), msg->params[1], msg->params[1], msg->params[2], msg->params[3], msg->params[5] ); } static void handleReplyEndOfWhowas(struct Message *msg) { require(msg, false, 2); if (strcmp(msg->params[1], self.nick)) { completeRemove(Network, msg->params[1]); } } static void handleReplyAway(struct Message *msg) { require(msg, false, 3); // Might be part of a WHOIS response. uint id = (replies[ReplyWhois] ? Network : idFor(msg->params[1])); uiFormat( id, (id == Network ? Warm : Cold), tagTime(msg), "\3%02d%s\3\tis away: %s", completeColor(id, msg->params[1]), msg->params[1], msg->params[2] ); logFormat( id, tagTime(msg), "%s is away: %s", msg->params[1], msg->params[2] ); } static void handleReplyNowAway(struct Message *msg) { require(msg, false, 2); uiFormat(Network, Warm, tagTime(msg), "%s", msg->params[1]); } static bool isAction(struct Message *msg) { if (strncmp(msg->params[1], "\1ACTION", 7)) return false; if (msg->params[1][7] == ' ') { msg->params[1] += 8; } else if (msg->params[1][7] == '\1') { msg->params[1] += 7; } else { return false; } size_t len = strlen(msg->params[1]); if (msg->params[1][len - 1] == '\1') { msg->params[1][len - 1] = '\0'; } return true; } static bool matchWord(const char *str, const char *word) { size_t len = strlen(word); const char *match = str; while (NULL != (match = strstr(match, word))) { char a = (match > str ? match[-1] : ' '); char b = (match[len] ?: ' '); if ((isspace(a) || ispunct(a)) && (isspace(b) || ispunct(b))) { return true; } match = &match[len]; } return false; } static bool isMention(const struct Message *msg) { if (matchWord(msg->params[1], self.nick)) return true; for (uint i = 0; i < ARRAY_LEN(self.nicks) && self.nicks[i]; ++i) { if (matchWord(msg->params[1], self.nicks[i])) return true; } return false; } static char *colorMentions(char *ptr, char *end, uint id, const char *msg) { // Consider words before a colon, or only the first two. const char *split = strstr(msg, ": "); if (!split) { split = strchr(msg, ' '); if (split) split = strchr(&split[1], ' '); } if (!split) split = &msg[strlen(msg)]; // Bail if there is existing formatting. for (const char *ch = msg; ch < split; ++ch) { if (iscntrl(*ch)) goto rest; } while (msg < split) { size_t skip = strspn(msg, ",:<> "); ptr = seprintf(ptr, end, "%.*s", (int)skip, msg); msg += skip; size_t len = strcspn(msg, ",:<> "); char *p = seprintf(ptr, end, "%.*s", (int)len, msg); enum Color color = completeColor(id, ptr); if (color != Default) { ptr = seprintf(ptr, end, "\3%02d%.*s\3", color, (int)len, msg); } else { ptr = p; } msg += len; } rest: return seprintf(ptr, end, "%s", msg); } static void handlePrivmsg(struct Message *msg) { require(msg, true, 2); char statusmsg = '\0'; if (network.statusmsg && strchr(network.statusmsg, msg->params[0][0])) { statusmsg = msg->params[0][0]; msg->params[0]++; } bool query = !strchr(network.chanTypes, msg->params[0][0]); bool server = strchr(msg->nick, '.'); bool mine = !strcmp(msg->nick, self.nick); uint id; if (query && server) { id = Network; } else if (query && !mine) { id = idFor(msg->nick); idColors[id] = hash(msg->user); } else { id = idFor(msg->params[0]); } bool notice = (msg->cmd[0] == 'N'); bool action = !notice && isAction(msg); bool highlight = !mine && isMention(msg); enum Heat heat = (!notice && (highlight || query) ? Hot : Warm); heat = filterCheck(heat, id, msg); if (heat > Warm && !mine && !query) highlight = true; if (!notice && !mine && heat > Ice) { completePull(id, msg->nick, hash(msg->user)); } if (heat > Ice) urlScan(id, msg->nick, msg->params[1]); char buf[1024]; char *ptr = buf, *end = &buf[sizeof(buf)]; if (statusmsg) { ptr = seprintf( ptr, end, "\3%d[%c]\3 ", hash(msg->params[0]), statusmsg ); } if (notice) { if (id != Network) { logFormat(id, tagTime(msg), "-%s- %s", msg->nick, msg->params[1]); } ptr = seprintf( ptr, end, "\3%d-%s-\3%d\t", hash(msg->user), msg->nick, LightGray ); } else if (action) { logFormat(id, tagTime(msg), "* %s %s", msg->nick, msg->params[1]); ptr = seprintf( ptr, end, "%s\35\3%d* %s\17\35\t", (highlight ? "\26" : ""), hash(msg->user), msg->nick ); } else { logFormat(id, tagTime(msg), "<%s> %s", msg->nick, msg->params[1]); ptr = seprintf( ptr, end, "%s\3%d<%s>\17\t", (highlight ? "\26" : ""), hash(msg->user), msg->nick ); } if (notice) { ptr = seprintf(ptr, end, "%s", msg->params[1]); } else { ptr = colorMentions(ptr, end, id, msg->params[1]); } uiWrite(id, heat, tagTime(msg), buf); } static void handlePing(struct Message *msg) { require(msg, false, 1); ircFormat("PONG :%s\r\n", msg->params[0]); } static void handleError(struct Message *msg) { require(msg, false, 1); errx(EX_UNAVAILABLE, "%s", msg->params[0]); } static const struct Handler { const char *cmd; int reply; Handler *fn; } Handlers[] = { { "001", 0, handleReplyWelcome }, { "005", 0, handleReplyISupport }, { "221", -ReplyMode, handleReplyUserModeIs }, { "276", +ReplyWhois, handleReplyWhoisGeneric }, { "301", 0, handleReplyAway }, { "305", -ReplyAway, handleReplyNowAway }, { "306", -ReplyAway, handleReplyNowAway }, { "307", +ReplyWhois, handleReplyWhoisGeneric }, { "311", +ReplyWhois, handleReplyWhoisUser }, { "312", 0, handleReplyWhoisServer }, { "313", +ReplyWhois, handleReplyWhoisGeneric }, { "314", +ReplyWhowas, handleReplyWhowasUser }, { "317", +ReplyWhois, handleReplyWhoisIdle }, { "318", -ReplyWhois, handleReplyEndOfWhois }, { "319", +ReplyWhois, handleReplyWhoisChannels }, { "320", +ReplyWhois, handleReplyWhoisGeneric }, { "322", +ReplyList, handleReplyList }, { "323", -ReplyList, NULL }, { "324", -ReplyMode, handleReplyChannelModeIs }, { "330", +ReplyWhois, handleReplyWhoisGeneric }, { "331", -ReplyTopic, handleReplyNoTopic }, { "332", 0, handleReplyTopic }, { "335", +ReplyWhois, handleReplyWhoisGeneric }, { "338", +ReplyWhois, handleReplyWhoisGeneric }, { "341", 0, handleReplyInviting }, { "346", +ReplyInvex, handleReplyInviteList }, { "347", -ReplyInvex, NULL }, { "348", +ReplyExcepts, handleReplyExceptList }, { "349", -ReplyExcepts, NULL }, { "353", 0, handleReplyNames }, { "366", 0, handleReplyEndOfNames }, { "367", +ReplyBan, handleReplyBanList }, { "368", -ReplyBan, NULL }, { "369", -ReplyWhowas, handleReplyEndOfWhowas }, { "372", 0, handleReplyMOTD }, { "378", +ReplyWhois, handleReplyWhoisGeneric }, { "379", +ReplyWhois, handleReplyWhoisGeneric }, { "422", 0, handleErrorNoMOTD }, { "432", 0, handleErrorErroneousNickname }, { "433", 0, handleErrorNicknameInUse }, { "437", 0, handleErrorNicknameInUse }, { "441", 0, handleErrorUserNotInChannel }, { "443", 0, handleErrorUserOnChannel }, { "478", 0, handleErrorBanListFull }, { "482", 0, handleErrorChanopPrivsNeeded }, { "671", +ReplyWhois, handleReplyWhoisGeneric }, { "704", +ReplyHelp, handleReplyHelp }, { "705", +ReplyHelp, handleReplyHelp }, { "706", -ReplyHelp, NULL }, { "900", 0, handleReplyLoggedIn }, { "904", 0, handleErrorSASLFail }, { "905", 0, handleErrorSASLFail }, { "906", 0, handleErrorSASLFail }, { "AUTHENTICATE", 0, handleAuthenticate }, { "CAP", 0, handleCap }, { "CHGHOST", 0, handleChghost }, { "ERROR", 0, handleError }, { "FAIL", 0, handleStandardReply }, { "INVITE", 0, handleInvite }, { "JOIN", 0, handleJoin }, { "KICK", 0, handleKick }, { "MODE", 0, handleMode }, { "NICK", 0, handleNick }, { "NOTE", 0, handleStandardReply }, { "NOTICE", 0, handlePrivmsg }, { "PART", 0, handlePart }, { "PING", 0, handlePing }, { "PRIVMSG", 0, handlePrivmsg }, { "QUIT", 0, handleQuit }, { "SETNAME", 0, handleSetname }, { "TOPIC", 0, handleTopic }, { "WARN", 0, handleStandardReply }, }; static int compar(const void *cmd, const void *_handler) { const struct Handler *handler = _handler; return strcmp(cmd, handler->cmd); } void handle(struct Message *msg) { if (!msg->cmd) return; if (msg->tags[TagPos]) { self.pos = strtoull(msg->tags[TagPos], NULL, 10); } const struct Handler *handler = bsearch( msg->cmd, Handlers, ARRAY_LEN(Handlers), sizeof(*handler), compar ); if (handler) { if (handler->reply && !replies[abs(handler->reply)]) return; if (handler->fn) handler->fn(msg); if (handler->reply < 0) replies[abs(handler->reply)]--; } else if (strcmp(msg->cmd, "400") >= 0 && strcmp(msg->cmd, "599") <= 0) { handleErrorGeneric(msg); } else if (isdigit(msg->cmd[0])) { handleReplyGeneric(msg); } } catgirl-2.2/input.c000066400000000000000000000425611445265476100143330ustar00rootroot00000000000000/* Copyright (C) 2020 June McEnroe * * 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 . * * Additional permission under GNU GPL version 3 section 7: * * If you modify this Program, or any covered work, by linking or * combining it with OpenSSL (or a modified version of that library), * containing parts covered by the terms of the OpenSSL License and the * original SSLeay license, the licensors of this Program grant you * additional permission to convey the resulting work. Corresponding * Source for a non-source form of such a combination shall include the * source code for the parts of OpenSSL used as well as that of the * covered work. */ #define _XOPEN_SOURCE_EXTENDED #include #include #include #include #include #include #include #include #include #include #include #include #include #include "chat.h" #include "edit.h" #define ENUM_KEY \ X(KeyCtrlLeft, "\33[1;5D", NULL) \ X(KeyCtrlRight, "\33[1;5C", NULL) \ X(KeyMeta0, "\0330", "\33)") \ X(KeyMeta1, "\0331", "\33!") \ X(KeyMeta2, "\0332", "\33@") \ X(KeyMeta3, "\0333", "\33#") \ X(KeyMeta4, "\0334", "\33$") \ X(KeyMeta5, "\0335", "\33%") \ X(KeyMeta6, "\0336", "\33^") \ X(KeyMeta7, "\0337", "\33&") \ X(KeyMeta8, "\0338", "\33*") \ X(KeyMeta9, "\0339", "\33(") \ X(KeyMetaA, "\33a", NULL) \ X(KeyMetaB, "\33b", NULL) \ X(KeyMetaD, "\33d", NULL) \ X(KeyMetaF, "\33f", NULL) \ X(KeyMetaL, "\33l", NULL) \ X(KeyMetaM, "\33m", NULL) \ X(KeyMetaN, "\33n", NULL) \ X(KeyMetaP, "\33p", NULL) \ X(KeyMetaQ, "\33q", NULL) \ X(KeyMetaS, "\33s", NULL) \ X(KeyMetaT, "\33t", NULL) \ X(KeyMetaU, "\33u", NULL) \ X(KeyMetaV, "\33v", NULL) \ X(KeyMetaEnter, "\33\r", "\33\n") \ X(KeyMetaGt, "\33>", "\33.") \ X(KeyMetaLt, "\33<", "\33,") \ X(KeyMetaEqual, "\33=", NULL) \ X(KeyMetaMinus, "\33-", "\33_") \ X(KeyMetaPlus, "\33+", NULL) \ X(KeyMetaSlash, "\33/", "\33?") \ X(KeyFocusIn, "\33[I", NULL) \ X(KeyFocusOut, "\33[O", NULL) \ X(KeyPasteOn, "\33[200~", NULL) \ X(KeyPasteOff, "\33[201~", NULL) \ X(KeyPasteManual, "\32p", "\32\20") enum { KeyMax = KEY_MAX, #define X(id, seq, alt) id, ENUM_KEY #undef X }; static struct Edit cut; static struct Edit edits[IDCap]; void inputInit(void) { for (size_t i = 0; i < ARRAY_LEN(edits); ++i) { edits[i].cut = &cut; } struct termios term; int error = tcgetattr(STDOUT_FILENO, &term); if (error) err(EX_OSERR, "tcgetattr"); // Gain use of C-q, C-s, C-c, C-z, C-y, C-v, C-o. term.c_iflag &= ~IXON; term.c_cc[VINTR] = _POSIX_VDISABLE; term.c_cc[VSUSP] = _POSIX_VDISABLE; #ifdef VDSUSP term.c_cc[VDSUSP] = _POSIX_VDISABLE; #endif term.c_cc[VLNEXT] = _POSIX_VDISABLE; term.c_cc[VDISCARD] = _POSIX_VDISABLE; error = tcsetattr(STDOUT_FILENO, TCSANOW, &term); if (error) err(EX_OSERR, "tcsetattr"); def_prog_mode(); #define X(id, seq, alt) define_key(seq, id); if (alt) define_key(alt, id); ENUM_KEY #undef X keypad(uiInput, true); nodelay(uiInput, true); } static void inputAdd(struct Style reset, struct Style *style, const char *str) { while (*str) { const char *code = str; size_t len = styleParse(style, &str); wattr_set(uiInput, A_BOLD | A_REVERSE, 0, NULL); switch (*code) { break; case B: waddch(uiInput, 'B'); break; case C: waddch(uiInput, 'C'); break; case O: waddch(uiInput, 'O'); break; case R: waddch(uiInput, 'R'); break; case I: waddch(uiInput, 'I'); break; case U: waddch(uiInput, 'U'); break; case '\n': waddch(uiInput, 'N'); } if (str - code > 1) waddnstr(uiInput, &code[1], str - &code[1]); if (str[0] == '\n') { *style = reset; str++; len--; } size_t nl = strcspn(str, "\n"); if (nl < len) len = nl; wattr_set(uiInput, uiAttr(*style), uiPair(*style), NULL); waddnstr(uiInput, str, len); str += len; } } static char *inputStop( struct Style reset, struct Style *style, const char *str, char *stop ) { char ch = *stop; *stop = '\0'; inputAdd(reset, style, str); *stop = ch; return stop; } static size_t cap; static char *buf; void inputUpdate(void) { uint id = windowID(); size_t pos = 0; const char *ptr = editString(&edits[id], &buf, &cap, &pos); if (!ptr) err(EX_OSERR, "editString"); const char *prefix = ""; const char *prompt = self.nick; const char *suffix = ""; const char *skip = buf; struct Style stylePrompt = { .fg = self.color, .bg = Default }; struct Style styleInput = StyleDefault; size_t split = commandWillSplit(id, buf); const char *privmsg = commandIsPrivmsg(id, buf); const char *notice = commandIsNotice(id, buf); const char *action = commandIsAction(id, buf); if (privmsg) { prefix = "<"; suffix = "> "; skip = privmsg; } else if (notice) { prefix = "-"; suffix = "- "; styleInput.fg = LightGray; skip = notice; } else if (action) { prefix = "* "; suffix = " "; stylePrompt.attr |= Italic; styleInput.attr |= Italic; skip = action; } else if (id == Debug && buf[0] != '/') { prompt = "<< "; stylePrompt.fg = Gray; } else { prompt = ""; } if (skip > &buf[pos]) { prefix = prompt = suffix = ""; skip = buf; } int y, x; wmove(uiInput, 0, 0); if (windowTimeEnable() && id != Network) { whline(uiInput, ' ', windowTime.width); wmove(uiInput, 0, windowTime.width); } wattr_set(uiInput, uiAttr(stylePrompt), uiPair(stylePrompt), NULL); waddstr(uiInput, prefix); waddstr(uiInput, prompt); waddstr(uiInput, suffix); getyx(uiInput, y, x); int posx; struct Style style = styleInput; inputStop(styleInput, &style, skip, &buf[pos]); getyx(uiInput, y, posx); wmove(uiInput, y, x); ptr = skip; style = styleInput; if (split) { ptr = inputStop(styleInput, &style, ptr, &buf[split]); style = styleInput; style.bg = Red; } inputAdd(styleInput, &style, ptr); wclrtoeol(uiInput); wmove(uiInput, y, posx); } bool inputPending(uint id) { return edits[id].len; } static const struct { const wchar_t *name; const wchar_t *string; } Macros[] = { { L"\\banhammer", L"▬▬▬▬▬▬▬▋ Ò╭╮Ó" }, { L"\\bear", L"ʕっ•ᴥ•ʔっ" }, { L"\\blush", L"（˶′◡‵˶）" }, { L"\\com", L"\0038,4\2 ☭ " }, { L"\\cool", L"(⌐■_■)" }, { L"\\flip", L"(╯°□°）╯︵ ┻━┻" }, { L"\\gary", L"ᕕ( ᐛ )ᕗ" }, { L"\\hug", L"（っ・∀・）っ" }, { L"\\lenny", L"( ͡° ͜ʖ ͡°)" }, { L"\\look", L"ಠ_ಠ" }, { L"\\shrug", L"¯\\_(ツ)_/¯" }, { L"\\unflip", L"┬─┬ノ(º_ºノ)" }, { L"\\wave", L"ヾ(＾∇＾)" }, }; void inputCompletion(void) { char mbs[256]; for (size_t i = 0; i < ARRAY_LEN(Macros); ++i) { size_t n = wcstombs(mbs, Macros[i].name, sizeof(mbs)); assert(n != (size_t)-1); completePush(None, mbs, Default); } } static int macroExpand(struct Edit *e) { size_t macro = e->pos; while (macro && e->buf[macro] != L'\\') macro--; if (macro == e->pos) return 0; for (size_t i = 0; i < ARRAY_LEN(Macros); ++i) { if (wcslen(Macros[i].name) != e->pos - macro) continue; if (wcsncmp(Macros[i].name, &e->buf[macro], e->pos - macro)) continue; if (wcstombs(NULL, Macros[i].string, 0) == (size_t)-1) continue; size_t expand = wcslen(Macros[i].string); int error = 0 || editDelete(e, false, macro, e->pos - macro) || editReserve(e, macro, expand); if (error) return error; wcsncpy(&e->buf[macro], Macros[i].string, expand); e->pos = macro + expand; break; } return 0; } static struct { uint id; char *pre; size_t pos; size_t len; bool suffix; struct Cursor curs; } tab; static void tabAccept(void) { completeAccept(&tab.curs); tab.len = 0; } static void tabReject(void) { completeReject(&tab.curs); tab.len = 0; } static int tabComplete(struct Edit *e, uint id) { if (tab.len && id != tab.id) { tabAccept(); } if (!tab.len) { tab.id = id; tab.pos = e->pos; while (tab.pos && !iswspace(e->buf[tab.pos-1])) tab.pos--; tab.len = e->pos - tab.pos; if (!tab.len) return 0; size_t cap = tab.len * MB_CUR_MAX + 1; char *buf = realloc(tab.pre, cap); if (!buf) return -1; tab.pre = buf; const wchar_t *ptr = &e->buf[tab.pos]; size_t n = wcsnrtombs(tab.pre, &ptr, tab.len, cap-1, NULL); if (n == (size_t)-1) return -1; tab.pre[n] = '\0'; tab.suffix = true; } const char *comp = completePrefix(&tab.curs, id, tab.pre); if (!comp) { comp = completePrefix(&tab.curs, id, tab.pre); tab.suffix ^= true; } if (!comp) { tab.len = 0; return 0; } size_t cap = strlen(comp) + 1; wchar_t *wcs = malloc(sizeof(*wcs) * cap); if (!wcs) return -1; size_t n = mbstowcs(wcs, comp, cap); assert(n != (size_t)-1); bool colon = (tab.len >= 2 && e->buf[tab.pos + tab.len - 2] == L':'); int error = editDelete(e, false, tab.pos, tab.len); if (error) goto fail; tab.len = n; if (wcs[0] == L'\\' || wcschr(wcs, L' ')) { error = editReserve(e, tab.pos, tab.len); if (error) goto fail; } else if (wcs[0] != L'/' && tab.suffix && (!tab.pos || colon)) { tab.len += 2; error = editReserve(e, tab.pos, tab.len); if (error) goto fail; e->buf[tab.pos + n + 0] = L':'; e->buf[tab.pos + n + 1] = L' '; } else if (tab.suffix && tab.pos >= 2 && e->buf[tab.pos - 2] == L':') { tab.len += 2; error = editReserve(e, tab.pos, tab.len); if (error) goto fail; e->buf[tab.pos - 2] = L','; e->buf[tab.pos + n + 0] = L':'; e->buf[tab.pos + n + 1] = L' '; } else { tab.len++; error = editReserve(e, tab.pos, tab.len); if (error) goto fail; if (!tab.suffix && tab.pos >= 2 && e->buf[tab.pos - 2] == L',') { e->buf[tab.pos - 2] = L':'; } e->buf[tab.pos + n] = L' '; } wmemcpy(&e->buf[tab.pos], wcs, n); e->pos = tab.pos + tab.len; free(wcs); return 0; fail: free(wcs); return -1; } static void inputEnter(void) { uint id = windowID(); char *cmd = editString(&edits[id], &buf, &cap, NULL); if (!cmd) err(EX_OSERR, "editString"); tabAccept(); editFn(&edits[id], EditClear); command(id, cmd); } static void keyCode(int code) { int error = 0; struct Edit *edit = &edits[windowID()]; switch (code) { break; case KEY_RESIZE: uiResize(); break; case KeyFocusIn: windowUnmark(); break; case KeyFocusOut: windowMark(); break; case KeyMetaEnter: error = editInsert(edit, L'\n'); break; case KeyMetaEqual: windowToggleMute(); break; case KeyMetaMinus: windowToggleThresh(-1); break; case KeyMetaPlus: windowToggleThresh(+1); break; case KeyMetaSlash: windowSwap(); break; case KeyMetaGt: windowScroll(ScrollAll, -1); break; case KeyMetaLt: windowScroll(ScrollAll, +1); break; case KeyMeta0 ... KeyMeta9: windowShow(code - KeyMeta0); break; case KeyMetaA: windowAuto(); break; case KeyMetaB: error = editFn(edit, EditPrevWord); break; case KeyMetaD: error = editFn(edit, EditDeleteNextWord); break; case KeyMetaF: error = editFn(edit, EditNextWord); break; case KeyMetaL: windowBare(); break; case KeyMetaM: uiWrite(windowID(), Warm, NULL, ""); break; case KeyMetaN: windowScroll(ScrollHot, +1); break; case KeyMetaP: windowScroll(ScrollHot, -1); break; case KeyMetaQ: error = editFn(edit, EditCollapse); break; case KeyMetaS: uiSpoilerReveal ^= true; windowUpdate(); break; case KeyMetaT: windowToggleTime(); break; case KeyMetaU: windowScroll(ScrollUnread, 0); break; case KeyMetaV: windowScroll(ScrollPage, +1); break; case KeyCtrlLeft: error = editFn(edit, EditPrevWord); break; case KeyCtrlRight: error = editFn(edit, EditNextWord); break; case KEY_BACKSPACE: error = editFn(edit, EditDeletePrev); break; case KEY_DC: error = editFn(edit, EditDeleteNext); break; case KEY_DOWN: windowScroll(ScrollOne, -1); break; case KEY_END: error = editFn(edit, EditTail); break; case KEY_ENTER: inputEnter(); break; case KEY_HOME: error = editFn(edit, EditHead); break; case KEY_LEFT: error = editFn(edit, EditPrev); break; case KEY_NPAGE: windowScroll(ScrollPage, -1); break; case KEY_PPAGE: windowScroll(ScrollPage, +1); break; case KEY_RIGHT: error = editFn(edit, EditNext); break; case KEY_SEND: windowScroll(ScrollAll, -1); break; case KEY_SHOME: windowScroll(ScrollAll, +1); break; case KEY_UP: windowScroll(ScrollOne, +1); } if (error) err(EX_OSERR, "editFn"); } static void keyCtrl(wchar_t ch) { int error = 0; struct Edit *edit = &edits[windowID()]; switch (ch ^ L'@') { break; case L'?': error = editFn(edit, EditDeletePrev); break; case L'A': error = editFn(edit, EditHead); break; case L'B': error = editFn(edit, EditPrev); break; case L'C': raise(SIGINT); break; case L'D': error = editFn(edit, EditDeleteNext); break; case L'E': error = editFn(edit, EditTail); break; case L'F': error = editFn(edit, EditNext); break; case L'H': error = editFn(edit, EditDeletePrev); break; case L'I': error = tabComplete(edit, windowID()); break; case L'J': inputEnter(); break; case L'K': error = editFn(edit, EditDeleteTail); break; case L'L': clearok(curscr, true); wrefresh(curscr); break; case L'N': windowShow(windowNum() + 1); break; case L'P': windowShow(windowNum() - 1); break; case L'R': windowSearch(editString(edit, &buf, &cap, NULL), -1); break; case L'S': windowSearch(editString(edit, &buf, &cap, NULL), +1); break; case L'T': error = editFn(edit, EditTranspose); break; case L'U': error = editFn(edit, EditDeleteHead); break; case L'V': windowScroll(ScrollPage, -1); break; case L'W': error = editFn(edit, EditDeletePrevWord); break; case L'X': error = macroExpand(edit); tabAccept(); break; case L'Y': error = editFn(edit, EditPaste); } if (error) err(EX_OSERR, "editFn"); } static void keyStyle(wchar_t ch) { if (iswcntrl(ch)) ch = towlower(ch ^ L'@'); char buf[8] = {0}; enum Color color = Default; switch (ch) { break; case L'A': color = Gray; break; case L'B': color = Blue; break; case L'C': color = Cyan; break; case L'G': color = Green; break; case L'K': color = Black; break; case L'M': color = Magenta; break; case L'N': color = Brown; break; case L'O': color = Orange; break; case L'P': color = Pink; break; case L'R': color = Red; break; case L'W': color = White; break; case L'Y': color = Yellow; break; case L'b': buf[0] = B; break; case L'c': buf[0] = C; break; case L'i': buf[0] = I; break; case L'o': buf[0] = O; break; case L'r': buf[0] = R; break; case L's': { snprintf(buf, sizeof(buf), "%c%02d,%02d", C, Black, Black); } break; case L'u': buf[0] = U; } if (color != Default) { snprintf(buf, sizeof(buf), "%c%02d", C, color); } struct Edit *edit = &edits[windowID()]; for (char *ch = buf; *ch; ++ch) { int error = editInsert(edit, *ch); if (error) err(EX_OSERR, "editInsert"); } } static bool waiting; void inputWait(void) { waiting = true; } void inputRead(void) { if (isendwin()) { if (waiting) { uiShow(); flushinp(); waiting = false; } else { return; } } wint_t ch; static bool paste, style, literal; for (int ret; ERR != (ret = wget_wch(uiInput, &ch));) { bool tabbing = false; size_t pos = edits[tab.id].pos; bool spr = uiSpoilerReveal; if (ret == KEY_CODE_YES && ch == KeyPasteOn) { paste = true; } else if (ret == KEY_CODE_YES && ch == KeyPasteOff) { paste = false; } else if (ret == KEY_CODE_YES && ch == KeyPasteManual) { paste ^= true; } else if (paste || literal) { int error = editInsert(&edits[windowID()], ch); if (error) err(EX_OSERR, "editInsert"); } else if (ret == KEY_CODE_YES) { keyCode(ch); } else if (ch == (L'Z' ^ L'@')) { style = true; continue; } else if (style && ch == (L'V' ^ L'@')) { literal = true; continue; } else if (style) { keyStyle(ch); } else if (iswcntrl(ch)) { tabbing = (ch == (L'I' ^ L'@')); keyCtrl(ch); } else { int error = editInsert(&edits[windowID()], ch); if (error) err(EX_OSERR, "editInsert"); } style = false; literal = false; if (!tabbing) { if (edits[tab.id].pos > pos) { tabAccept(); } else if (edits[tab.id].pos < pos) { tabReject(); } } if (spr) { uiSpoilerReveal = false; windowUpdate(); } } inputUpdate(); } static int writeString(FILE *file, const char *str) { return (fwrite(str, strlen(str) + 1, 1, file) ? 0 : -1); } int inputSave(FILE *file) { int error; for (uint id = 0; id < IDCap; ++id) { if (!edits[id].len) continue; char *ptr = editString(&edits[id], &buf, &cap, NULL); if (!ptr) return -1; error = 0 || writeString(file, idNames[id]) || writeString(file, ptr); if (error) return error; } return writeString(file, ""); } static ssize_t readString(FILE *file, char **buf, size_t *cap) { ssize_t len = getdelim(buf, cap, '\0', file); if (len < 0 && !feof(file)) err(EX_IOERR, "getdelim"); return len; } void inputLoad(FILE *file, size_t version) { if (version < 8) return; while (0 < readString(file, &buf, &cap) && buf[0]) { uint id = idFor(buf); readString(file, &buf, &cap); size_t max = strlen(buf); int error = editReserve(&edits[id], 0, max); if (error) err(EX_OSERR, "editReserve"); size_t len = mbstowcs(edits[id].buf, buf, max); assert(len != (size_t)-1); edits[id].len = len; edits[id].pos = len; } } catgirl-2.2/irc.c000066400000000000000000000200261445265476100137410ustar00rootroot00000000000000/* Copyright (C) 2020 June McEnroe * * 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 . * * Additional permission under GNU GPL version 3 section 7: * * If you modify this Program, or any covered work, by linking or * combining it with OpenSSL (or a modified version of that library), * containing parts covered by the terms of the OpenSSL License and the * original SSLeay license, the licensors of this Program grant you * additional permission to convey the resulting work. Corresponding * Source for a non-source form of such a combination shall include the * source code for the parts of OpenSSL used as well as that of the * covered work. */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "chat.h" static struct tls *client; static struct tls_config *config; void ircConfig( bool insecure, const char *trust, const char *cert, const char *priv ) { int error = 0; char buf[PATH_MAX]; config = tls_config_new(); if (!config) errx(EX_SOFTWARE, "tls_config_new"); if (insecure) { tls_config_insecure_noverifycert(config); tls_config_insecure_noverifyname(config); } if (trust) { tls_config_insecure_noverifyname(config); for (int i = 0; configPath(buf, sizeof(buf), trust, i); ++i) { error = tls_config_set_ca_file(config, buf); if (!error) break; } if (error) errx(EX_NOINPUT, "%s: %s", trust, tls_config_error(config)); } // Explicitly load the default CA cert file on OpenBSD now so it doesn't // need to be unveiled. Other systems might use a CA directory, so avoid // changing the default behavior. #ifdef __OpenBSD__ if (!insecure && !trust) { const char *ca = tls_default_ca_cert_file(); error = tls_config_set_ca_file(config, ca); if (error) errx(EX_OSFILE, "%s: %s", ca, tls_config_error(config)); } #endif if (cert) { for (int i = 0; configPath(buf, sizeof(buf), cert, i); ++i) { if (priv) { error = tls_config_set_cert_file(config, buf); } else { error = tls_config_set_keypair_file(config, buf, buf); } if (!error) break; } if (error) errx(EX_NOINPUT, "%s: %s", cert, tls_config_error(config)); } if (priv) { for (int i = 0; configPath(buf, sizeof(buf), priv, i); ++i) { error = tls_config_set_key_file(config, buf); if (!error) break; } if (error) errx(EX_NOINPUT, "%s: %s", priv, tls_config_error(config)); } client = tls_client(); if (!client) errx(EX_SOFTWARE, "tls_client"); error = tls_configure(client, config); if (error) errx(EX_SOFTWARE, "tls_configure: %s", tls_error(client)); } int ircConnect(const char *bindHost, const char *host, const char *port) { assert(client); int error; int sock = -1; struct addrinfo *head; struct addrinfo hints = { .ai_family = AF_UNSPEC, .ai_socktype = SOCK_STREAM, .ai_protocol = IPPROTO_TCP, }; if (bindHost) { error = getaddrinfo(bindHost, NULL, &hints, &head); if (error) errx(EX_NOHOST, "%s: %s", bindHost, gai_strerror(error)); for (struct addrinfo *ai = head; ai; ai = ai->ai_next) { sock = socket(ai->ai_family, ai->ai_socktype, ai->ai_protocol); if (sock < 0) err(EX_OSERR, "socket"); error = bind(sock, ai->ai_addr, ai->ai_addrlen); if (!error) { hints.ai_family = ai->ai_family; break; } close(sock); sock = -1; } if (sock < 0) err(EX_UNAVAILABLE, "%s", bindHost); freeaddrinfo(head); } error = getaddrinfo(host, port, &hints, &head); if (error) errx(EX_NOHOST, "%s:%s: %s", host, port, gai_strerror(error)); for (struct addrinfo *ai = head; ai; ai = ai->ai_next) { if (sock < 0) { sock = socket(ai->ai_family, ai->ai_socktype, ai->ai_protocol); if (sock < 0) err(EX_OSERR, "socket"); } error = connect(sock, ai->ai_addr, ai->ai_addrlen); if (!error) break; if (error && errno == EINTR) break; // connect continues asynchronously close(sock); sock = -1; } if (sock < 0) err(EX_UNAVAILABLE, "%s:%s", host, port); freeaddrinfo(head); fcntl(sock, F_SETFD, FD_CLOEXEC); error = tls_connect_socket(client, sock, host); if (error) errx(EX_PROTOCOL, "tls_connect: %s", tls_error(client)); return sock; } void ircHandshake(void) { int error; do { error = tls_handshake(client); } while (error == TLS_WANT_POLLIN || error == TLS_WANT_POLLOUT); if (error) errx(EX_PROTOCOL, "tls_handshake: %s", tls_error(client)); tls_config_clear_keys(config); } void ircPrintCert(void) { size_t len; ircHandshake(); const byte *pem = tls_peer_cert_chain_pem(client, &len); printf("subject= %s\n", tls_peer_cert_subject(client)); fwrite(pem, len, 1, stdout); } enum { MessageCap = 8191 + 512 }; static void debug(const char *pre, const char *line) { if (!self.debug) return; size_t len = strcspn(line, "\r\n"); uiFormat( Debug, Cold, NULL, "\3%02d%s\3\t%.*s", Gray, pre, (int)len, line ); if (!isatty(STDERR_FILENO)) { fprintf(stderr, "%s %.*s\n", pre, (int)len, line); } } void ircSend(const char *ptr, size_t len) { assert(client); while (len) { ssize_t ret = tls_write(client, ptr, len); if (ret == TLS_WANT_POLLIN || ret == TLS_WANT_POLLOUT) continue; if (ret < 0) errx(EX_IOERR, "tls_write: %s", tls_error(client)); ptr += ret; len -= ret; } } void ircFormat(const char *format, ...) { char buf[MessageCap]; va_list ap; va_start(ap, format); int len = vsnprintf(buf, sizeof(buf), format, ap); va_end(ap); assert((size_t)len < sizeof(buf)); debug("<<", buf); ircSend(buf, len); } static const char *TagNames[TagCap] = { #define X(name, id) [id] = name, ENUM_TAG #undef X }; static void unescape(char *tag) { for (;;) { tag = strchr(tag, '\\'); if (!tag) break; switch (tag[1]) { break; case ':': tag[1] = ';'; break; case 's': tag[1] = ' '; break; case 'r': tag[1] = '\r'; break; case 'n': tag[1] = '\n'; } memmove(tag, &tag[1], strlen(&tag[1]) + 1); if (tag[0]) tag = &tag[1]; } } static struct Message parse(char *line) { struct Message msg = { .cmd = NULL }; if (line[0] == '@') { char *tags = 1 + strsep(&line, " "); while (tags) { char *tag = strsep(&tags, ";"); char *key = strsep(&tag, "="); for (uint i = 0; i < TagCap; ++i) { if (strcmp(key, TagNames[i])) continue; if (tag) { unescape(tag); msg.tags[i] = tag; } else { msg.tags[i] = ""; } break; } } } if (line[0] == ':') { char *origin = 1 + strsep(&line, " "); msg.nick = strsep(&origin, "!"); msg.user = strsep(&origin, "@"); msg.host = origin; } msg.cmd = strsep(&line, " "); for (uint i = 0; line && i < ParamCap; ++i) { if (line[0] == ':') { msg.params[i] = &line[1]; break; } msg.params[i] = strsep(&line, " "); } return msg; } void ircRecv(void) { static char buf[MessageCap]; static size_t len = 0; assert(client); ssize_t ret = tls_read(client, &buf[len], sizeof(buf) - len); if (ret == TLS_WANT_POLLIN || ret == TLS_WANT_POLLOUT) return; if (ret < 0) errx(EX_IOERR, "tls_read: %s", tls_error(client)); if (!ret) errx(EX_PROTOCOL, "server closed connection"); len += ret; char *crlf; char *line = buf; for (;;) { crlf = memmem(line, &buf[len] - line, "\r\n", 2); if (!crlf) break; *crlf = '\0'; debug(">>", line); struct Message msg = parse(line); handle(&msg); line = crlf + 2; } len -= line - buf; memmove(buf, line, len); } void ircClose(void) { tls_close(client); tls_free(client); } catgirl-2.2/log.c000066400000000000000000000107521445265476100137520ustar00rootroot00000000000000/* Copyright (C) 2020 June McEnroe * * 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 . * * Additional permission under GNU GPL version 3 section 7: * * If you modify this Program, or any covered work, by linking or * combining it with OpenSSL (or a modified version of that library), * containing parts covered by the terms of the OpenSSL License and the * original SSLeay license, the licensors of this Program grant you * additional permission to convey the resulting work. Corresponding * Source for a non-source form of such a combination shall include the * source code for the parts of OpenSSL used as well as that of the * covered work. */ #include #include #include #include #include #include #include #include #include #include #include #include #ifdef __FreeBSD__ #include #endif #include "chat.h" static int logDir = -1; void logOpen(void) { char buf[PATH_MAX]; int error = mkdir(dataPath(buf, sizeof(buf), "", 0), S_IRWXU); if (error && errno != EEXIST) err(EX_CANTCREAT, "%s", buf); error = mkdir(dataPath(buf, sizeof(buf), "log", 0), S_IRWXU); if (error && errno != EEXIST) err(EX_CANTCREAT, "%s", buf); logDir = open(buf, O_RDONLY | O_CLOEXEC); if (logDir < 0) err(EX_CANTCREAT, "%s", buf); #ifdef __FreeBSD__ cap_rights_t rights; cap_rights_init( &rights, CAP_MKDIRAT, CAP_CREATE, CAP_WRITE, /* for fdopen(3) */ CAP_FCNTL, CAP_FSTAT ); error = caph_rights_limit(logDir, &rights); if (error) err(EX_OSERR, "cap_rights_limit"); #endif } static void logMkdir(const char *path) { int error = mkdirat(logDir, path, S_IRWXU); if (error && errno != EEXIST) err(EX_CANTCREAT, "log/%s", path); } static void sanitize(char *ptr, char *end) { for (char *ch = ptr; ch < end && *ch == '.'; ++ch) { *ch = '_'; } for (char *ch = ptr; ch < end; ++ch) { if (*ch == '/') *ch = '_'; } } static struct { int year; int month; int day; FILE *file; } logs[IDCap]; static FILE *logFile(uint id, const struct tm *tm) { if ( logs[id].file && logs[id].year == tm->tm_year && logs[id].month == tm->tm_mon && logs[id].day == tm->tm_mday ) return logs[id].file; if (logs[id].file) { int error = fclose(logs[id].file); if (error) err(EX_IOERR, "%s", idNames[id]); } logs[id].year = tm->tm_year; logs[id].month = tm->tm_mon; logs[id].day = tm->tm_mday; char path[PATH_MAX]; char *ptr = path, *end = &path[sizeof(path)]; ptr = seprintf(ptr, end, "%s", network.name); sanitize(path, ptr); logMkdir(path); char *name = ptr; ptr = seprintf(ptr, end, "/%s", idNames[id]); sanitize(&name[1], ptr); logMkdir(path); size_t len = strftime(ptr, end - ptr, "/%F.log", tm); if (!len) errx(EX_CANTCREAT, "log path too long"); int fd = openat( logDir, path, O_WRONLY | O_APPEND | O_CREAT | O_CLOEXEC, S_IRUSR | S_IWUSR ); if (fd < 0) err(EX_CANTCREAT, "log/%s", path); logs[id].file = fdopen(fd, "a"); if (!logs[id].file) err(EX_OSERR, "fdopen"); setlinebuf(logs[id].file); return logs[id].file; } void logClose(void) { if (logDir < 0) return; for (uint id = 0; id < IDCap; ++id) { if (!logs[id].file) continue; int error = fclose(logs[id].file); if (error) err(EX_IOERR, "%s", idNames[id]); } close(logDir); } void logFormat(uint id, const time_t *src, const char *format, ...) { if (logDir < 0) return; time_t ts = (src ? *src : time(NULL)); struct tm *tm = localtime(&ts); if (!tm) err(EX_OSERR, "localtime"); FILE *file = logFile(id, tm); char buf[sizeof("0000-00-00T00:00:00+0000")]; strftime(buf, sizeof(buf), "%FT%T%z", tm); int n = fprintf(file, "[%s] ", buf); if (n < 0) err(EX_IOERR, "%s", idNames[id]); va_list ap; va_start(ap, format); n = vfprintf(file, format, ap); va_end(ap); if (n < 0) err(EX_IOERR, "%s", idNames[id]); n = fprintf(file, "\n"); if (n < 0) err(EX_IOERR, "%s", idNames[id]); } catgirl-2.2/sandman.1000066400000000000000000000007521445265476100145270ustar00rootroot00000000000000.Dd February 12, 2020 .Dt SANDMAN 1 .Os . .Sh NAME .Nm sandman .Nd sleep wrapper . .Sh SYNOPSIS .Nm .Op Fl t Ar secs .Ar command ... . .Sh DESCRIPTION The .Nm utility wraps a .Ar command , sending it .Dv SIGHUP when the system goes to sleep, and restarting it when the system wakes. . .Pp The arguments are as follows: .Bl -tag -width Ds .It Fl t Ar secs Wait for .Ar secs before restarting the process. The default is 8 seconds. .El . .Sh AUTHORS .An June McEnroe Aq Mt june@causal.agency catgirl-2.2/sandman.m000066400000000000000000000045031445265476100146210ustar00rootroot00000000000000/* Copyright (C) 2019, 2020 June McEnroe * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see . */ #import #import #import #import #import #import #import typedef unsigned uint; static pid_t pid; static void spawn(char *argv[]) { pid = fork(); if (pid < 0) err(EX_OSERR, "fork"); if (pid) return; execvp(argv[0], argv); err(EX_CONFIG, "%s", argv[0]); } static void handler(int signal) { (void)signal; int status; pid_t pid = wait(&status); if (pid < 0) _exit(EX_OSERR); _exit(status); } int main(int argc, char *argv[]) { uint delay = 8; for (int opt; 0 < (opt = getopt(argc, argv, "t:"));) { switch (opt) { break; case 't': delay = strtoul(optarg, NULL, 10); break; default: return EX_USAGE; } } argc -= optind; argv += optind; if (!argc) errx(EX_USAGE, "command required"); NSWorkspace *workspace = [NSWorkspace sharedWorkspace]; NSNotificationCenter *notifCenter = [workspace notificationCenter]; [notifCenter addObserverForName:NSWorkspaceWillSleepNotification object:nil queue:nil usingBlock:^(NSNotification *notif) { (void)notif; signal(SIGCHLD, SIG_IGN); int error = kill(pid, SIGHUP); if (error) err(EX_UNAVAILABLE, "kill"); int status; wait(&status); }]; [notifCenter addObserverForName:NSWorkspaceDidWakeNotification object:nil queue:nil usingBlock:^(NSNotification *notif) { (void)notif; warnx("waiting %u seconds...", delay); sleep(delay); signal(SIGCHLD, handler); spawn(argv); }]; signal(SIGCHLD, handler); spawn(argv); [[NSApplication sharedApplication] run]; } catgirl-2.2/scripts/000077500000000000000000000000001445265476100145075ustar00rootroot00000000000000catgirl-2.2/scripts/build-chroot.sh000066400000000000000000000042211445265476100174350ustar00rootroot00000000000000#!/bin/sh set -eux CHROOT_USER=$1 CHROOT_GROUP=$2 if [ "$(uname)" = 'OpenBSD' ]; then install -d -o root -g wheel \ root \ root/bin \ root/etc/ssl \ root/home \ root/usr/bin \ root/usr/lib \ root/usr/libexec \ root/usr/share/man install -d -o ${CHROOT_USER} -g ${CHROOT_GROUP} \ root/home/${CHROOT_USER} \ root/home/${CHROOT_USER}/.local/share cp -fp /bin/sh root/bin cp -fp /usr/libexec/ld.so root/usr/libexec export LD_TRACE_LOADED_OBJECTS_FMT1='%p\n' export LD_TRACE_LOADED_OBJECTS_FMT2='' for bin in ./catgirl /usr/bin/mandoc /usr/bin/less; do LD_TRACE_LOADED_OBJECTS=1 $bin | xargs -t -J % cp -fp % root/usr/lib done cp -fp /usr/bin/printf /usr/bin/mandoc /usr/bin/less root/usr/bin make install DESTDIR=root PREFIX=/usr MANDIR=/usr/share/man install scripts/chroot-prompt.sh root/usr/bin/catgirl-prompt install scripts/chroot-man.sh root/usr/bin/man cp -fp /etc/hosts /etc/resolv.conf root/etc cp -fp /etc/ssl/cert.pem root/etc/ssl cp -af /usr/share/locale /usr/share/terminfo root/usr/share tar -c -f chroot.tar -C root bin etc home usr elif [ "$(uname)" = 'FreeBSD' ]; then install -d -o root -g wheel \ root \ root/bin \ root/etc \ root/home \ root/lib \ root/libexec \ root/usr/bin \ root/usr/local/etc/ssl \ root/usr/share/man \ root/usr/share/misc install -d -o ${CHROOT_USER} -g ${CHROOT_GROUP} \ root/home/${CHROOT_USER} \ root/home/${CHROOT_USER}/.local/share cp -fp /libexec/ld-elf.so.1 root/libexec ldd -f '%p\n' catgirl /usr/bin/mandoc /usr/bin/less \ | sort -u | xargs -t -J % cp -fp % root/lib chflags noschg root/libexec/* root/lib/* cp -fp /rescue/sh /usr/bin/mandoc /usr/bin/less root/bin make install DESTDIR=root PREFIX=/usr MANDIR=/usr/share/man install scripts/chroot-prompt.sh root/usr/bin/catgirl-prompt install scripts/chroot-man.sh root/usr/bin/man cp -fp /etc/hosts /etc/resolv.conf root/etc cp -fp /usr/local/etc/ssl/cert.pem root/usr/local/etc/ssl cp -af /usr/share/locale root/usr/share cp -fp /usr/share/misc/termcap.db root/usr/share/misc tar -c -f chroot.tar -C root bin etc home lib libexec usr else echo "Don't know how to build chroot on $(uname)" >&2 exit 1 fi catgirl-2.2/scripts/chat.tmux.conf000066400000000000000000000037741445265476100173040ustar00rootroot00000000000000# use `tmux -L chat -f ./chat.tmux.conf attach-session' (without any other # options or parameters) to access this session group in its own tmux server, # not interfering with existing servers/sessions/configurations new-session -t chat # catgirl(1) puts windows at the top set-option -g -- status-position top # intuitive navigation set-option -g -- mode-keys vi set-option -g -- mouse on # indicate new messages set-option -g -- monitor-activity on set-option -g -- monitor-bell on # hardcode names during window creation set-option -g -- automatic-rename off set-option -g -- allow-rename off set-option -g -- set-titles off set-option -g -- renumber-windows on # for the F1 binding, make hotkeys match window numbers set-option -g -- base-index 1 # clients exit on network errors, restart them automatically # (use `kill-pane'/`C-b x' to destroy windows) set-option -g -- remain-on-exit on set-hook -g -- pane-died respawn-pane # disarm ^C to avoid accidentially losing logs bind-key -n -N 'confirm INTR key' -- C-c \ confirm-before -p 'Send ^C? (y/N)' -- 'send-keys -- C-c' # one-click version of default `C-b w' (shows preview windows) bind-key -n -N 'pick chat network' -- F1 choose-tree -Z # catgirl(1) might run in `-R'/`restrict'ed mode, i.e. `/help' is disabled bind-key -n -N 'read catgirl help' -- F2 \ new-window -S -n help -- man -s 1 -- catgirl # intuitive refresh, just don't spam it ;-) bind-key -n -N 'reconnect network' -- F5 \ confirm-before -p 'reconnect network? (y/N)' -- 'respawn-pane -k' # immersive mode ;-) bind-key -n -N 'toggle fullscreen' -- F11 set status # this configuration is idempotent, i.e. reloading it only changes settings # and never duplicates already existing windows bind-key -N 'reload configuration' -- R { source-file -F -- '#{source_files}' display-message -- 'configuration reloaded' } ## do not double-quote commands to avoid running through "sh -c" # IRC new-window -d -S -n hackint -- catgirl -- defaults hackint new-window -d -S -n efnet -- catgirl -- defaults efnet catgirl-2.2/scripts/chroot-man.sh000066400000000000000000000001101445265476100171020ustar00rootroot00000000000000#!/bin/sh exec mandoc /usr/share/man/man1/catgirl.1 | LESSSECURE=1 less catgirl-2.2/scripts/chroot-prompt.sh000066400000000000000000000002601445265476100176560ustar00rootroot00000000000000#!/bin/sh set -eu printf 'Name: ' read -r nick rest printf '%s %s\n' "$nick" "$SSH_CLIENT" >>nicks.log exec catgirl -K -n "$nick" -s "${nick##*/}" -u "${SSH_CLIENT%% *}" "$@" catgirl-2.2/scripts/notify-send.scpt000066400000000000000000000003001445265476100176320ustar00rootroot00000000000000#!/usr/bin/osascript on run argv if count of argv is 2 then display notification (item 2 of argv) with title (item 1 of argv) else display notification (item 1 of argv) end if end run catgirl-2.2/scripts/sshd_config000066400000000000000000000002601445265476100167160ustar00rootroot00000000000000UsePAM no Match User chat PasswordAuthentication yes PermitEmptyPasswords yes ChrootDirectory /home/chat ForceCommand catgirl-prompt DisableForwarding yes MaxSessions 1 catgirl-2.2/ui.c000066400000000000000000000216551445265476100136120ustar00rootroot00000000000000/* Copyright (C) 2020 June McEnroe * * 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 . * * Additional permission under GNU GPL version 3 section 7: * * If you modify this Program, or any covered work, by linking or * combining it with OpenSSL (or a modified version of that library), * containing parts covered by the terms of the OpenSSL License and the * original SSLeay license, the licensors of this Program grant you * additional permission to convey the resulting work. Corresponding * Source for a non-source form of such a combination shall include the * source code for the parts of OpenSSL used as well as that of the * covered work. */ #define _XOPEN_SOURCE_EXTENDED #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #ifdef __FreeBSD__ #include #endif #include "chat.h" #define BOTTOM (LINES - 1) #define RIGHT (COLS - 1) #define MAIN_LINES (LINES - StatusLines - InputLines) WINDOW *uiStatus; WINDOW *uiMain; WINDOW *uiInput; static short colorPairs; static void colorInit(void) { start_color(); use_default_colors(); if (!COLORS) return; for (short pair = 0; pair < 16; ++pair) { init_pair(1 + pair, pair % COLORS, -1); } colorPairs = 17; } static attr_t colorAttr(short fg) { if (!COLORS) return (fg > 0 ? A_BOLD : A_NORMAL); if (fg != COLOR_BLACK && fg % COLORS == COLOR_BLACK) return A_BOLD; if (COLORS > 8) return A_NORMAL; return (fg / COLORS & 1 ? A_BOLD : A_NORMAL); } static short colorPair(short fg, short bg) { if (!COLORS) return 0; fg %= COLORS; bg %= COLORS; if (bg == -1 && fg < 16) return 1 + fg; for (short pair = 17; pair < colorPairs; ++pair) { short f, b; pair_content(pair, &f, &b); if (f == fg && b == bg) return pair; } init_pair(colorPairs, fg, bg); return colorPairs++; } // XXX: Assuming terminals will be fine with these even if they're unsupported, // since they're "private" modes. static const char *FocusMode[2] = { "\33[?1004l", "\33[?1004h" }; static const char *PasteMode[2] = { "\33[?2004l", "\33[?2004h" }; static void errExit(void) { putp(FocusMode[false]); putp(PasteMode[false]); reset_shell_mode(); } void uiInit(void) { initscr(); cbreak(); noecho(); colorInit(); atexit(errExit); #ifndef A_ITALIC #define A_ITALIC A_BLINK // Force ncurses to use individual enter_attr_mode strings: set_attributes = NULL; enter_blink_mode = enter_italics_mode; #endif if (!to_status_line && !strncmp(termname(), "xterm", 5)) { to_status_line = "\33]2;"; from_status_line = "\7"; } uiStatus = newwin(StatusLines, COLS, 0, 0); if (!uiStatus) err(EX_OSERR, "newwin"); uiMain = newwin(MAIN_LINES, COLS, StatusLines, 0); if (!uiMain) err(EX_OSERR, "newwin"); uiInput = newpad(InputLines, InputCols); if (!uiInput) err(EX_OSERR, "newpad"); windowInit(); uiShow(); } static bool hidden = true; char uiTitle[TitleCap]; static char prevTitle[TitleCap]; void uiDraw(void) { if (hidden) return; wnoutrefresh(uiStatus); wnoutrefresh(uiMain); int y, x; getyx(uiInput, y, x); pnoutrefresh( uiInput, 0, (x + 1 > RIGHT ? x + 1 - RIGHT : 0), LINES - InputLines, 0, BOTTOM, RIGHT ); (void)y; doupdate(); if (!to_status_line) return; if (!strcmp(uiTitle, prevTitle)) return; strcpy(prevTitle, uiTitle); putp(tparm(to_status_line, 0)); putp(uiTitle); putp(from_status_line); fflush(stdout); } static const short Colors[ColorCap] = { [Default] = -1, [White] = 8 + COLOR_WHITE, [Black] = 0 + COLOR_BLACK, [Blue] = 0 + COLOR_BLUE, [Green] = 0 + COLOR_GREEN, [Red] = 8 + COLOR_RED, [Brown] = 0 + COLOR_RED, [Magenta] = 0 + COLOR_MAGENTA, [Orange] = 0 + COLOR_YELLOW, [Yellow] = 8 + COLOR_YELLOW, [LightGreen] = 8 + COLOR_GREEN, [Cyan] = 0 + COLOR_CYAN, [LightCyan] = 8 + COLOR_CYAN, [LightBlue] = 8 + COLOR_BLUE, [Pink] = 8 + COLOR_MAGENTA, [Gray] = 8 + COLOR_BLACK, [LightGray] = 0 + COLOR_WHITE, 52, 94, 100, 58, 22, 29, 23, 24, 17, 54, 53, 89, 88, 130, 142, 64, 28, 35, 30, 25, 18, 91, 90, 125, 124, 166, 184, 106, 34, 49, 37, 33, 19, 129, 127, 161, 196, 208, 226, 154, 46, 86, 51, 75, 21, 171, 201, 198, 203, 215, 227, 191, 83, 122, 87, 111, 63, 177, 207, 205, 217, 223, 229, 193, 157, 158, 159, 153, 147, 183, 219, 212, 16, 233, 235, 237, 239, 241, 244, 247, 250, 254, 231, }; uint uiAttr(struct Style style) { attr_t attr = A_NORMAL; if (style.attr & Bold) attr |= A_BOLD; if (style.attr & Reverse) attr |= A_REVERSE; if (style.attr & Italic) attr |= A_ITALIC; if (style.attr & Underline) attr |= A_UNDERLINE; return attr | colorAttr(Colors[style.fg]); } bool uiSpoilerReveal; short uiPair(struct Style style) { if (uiSpoilerReveal && style.fg == style.bg) { return colorPair(Colors[Default], Colors[style.bg]); } return colorPair(Colors[style.fg], Colors[style.bg]); } void uiShow(void) { if (!hidden) return; prevTitle[0] = '\0'; putp(FocusMode[true]); putp(PasteMode[true]); fflush(stdout); hidden = false; windowUnmark(); } void uiHide(void) { if (hidden) return; windowMark(); hidden = true; putp(FocusMode[false]); putp(PasteMode[false]); endwin(); } struct Util uiNotifyUtil; static void notify(uint id, const char *str) { if (self.restricted) return; if (!uiNotifyUtil.argc) return; char buf[1024]; styleStrip(buf, sizeof(buf), str); struct Util util = uiNotifyUtil; utilPush(&util, idNames[id]); utilPush(&util, buf); pid_t pid = fork(); if (pid < 0) err(EX_OSERR, "fork"); if (pid) return; setsid(); close(STDIN_FILENO); dup2(utilPipe[1], STDOUT_FILENO); dup2(utilPipe[1], STDERR_FILENO); execvp(util.argv[0], (char *const *)util.argv); warn("%s", util.argv[0]); _exit(EX_CONFIG); } void uiWrite(uint id, enum Heat heat, const time_t *src, const char *str) { bool note = windowWrite(id, heat, src, str); if (note) { beep(); notify(id, str); } } void uiFormat( uint id, enum Heat heat, const time_t *time, const char *format, ... ) { char buf[1024]; va_list ap; va_start(ap, format); int len = vsnprintf(buf, sizeof(buf), format, ap); va_end(ap); assert((size_t)len < sizeof(buf)); uiWrite(id, heat, time, buf); } void uiResize(void) { wclear(uiMain); wresize(uiMain, MAIN_LINES, COLS); windowResize(); } static FILE *saveFile; static const uint64_t Signatures[] = { 0x6C72696774616301, // no heat, unread, unreadWarm 0x6C72696774616302, // no self.pos 0x6C72696774616303, // no buffer line heat 0x6C72696774616304, // no mute 0x6C72696774616305, // no URLs 0x6C72696774616306, // no thresh 0x6C72696774616307, // no window time 0x6C72696774616308, // no input 0x6C72696774616309, }; static size_t signatureVersion(uint64_t signature) { for (size_t i = 0; i < ARRAY_LEN(Signatures); ++i) { if (signature == Signatures[i]) return i; } errx(EX_DATAERR, "unknown file signature %" PRIX64, signature); } static int writeUint64(FILE *file, uint64_t u) { return (fwrite(&u, sizeof(u), 1, file) ? 0 : -1); } int uiSave(void) { return 0 || ftruncate(fileno(saveFile), 0) || writeUint64(saveFile, Signatures[8]) || writeUint64(saveFile, self.pos) || windowSave(saveFile) || inputSave(saveFile) || urlSave(saveFile) || fclose(saveFile); } static uint64_t readUint64(FILE *file) { uint64_t u; fread(&u, sizeof(u), 1, file); if (ferror(file)) err(EX_IOERR, "fread"); if (feof(file)) errx(EX_DATAERR, "unexpected eof"); return u; } void uiLoad(const char *name) { int error; saveFile = dataOpen(name, "a+e"); if (!saveFile) exit(EX_CANTCREAT); rewind(saveFile); #ifdef __FreeBSD__ cap_rights_t rights; cap_rights_init(&rights, CAP_READ, CAP_WRITE, CAP_FLOCK, CAP_FTRUNCATE); error = caph_rights_limit(fileno(saveFile), &rights); if (error) err(EX_OSERR, "cap_rights_limit"); #endif error = flock(fileno(saveFile), LOCK_EX | LOCK_NB); if (error && errno == EWOULDBLOCK) { errx(EX_CANTCREAT, "%s: save file in use", name); } time_t signature; fread(&signature, sizeof(signature), 1, saveFile); if (ferror(saveFile)) err(EX_IOERR, "fread"); if (feof(saveFile)) { return; } size_t version = signatureVersion(signature); if (version > 1) { self.pos = readUint64(saveFile); } windowLoad(saveFile, version); inputLoad(saveFile, version); urlLoad(saveFile, version); } catgirl-2.2/url.c000066400000000000000000000154601445265476100137740ustar00rootroot00000000000000/* Copyright (C) 2020 June McEnroe * * 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 . * * Additional permission under GNU GPL version 3 section 7: * * If you modify this Program, or any covered work, by linking or * combining it with OpenSSL (or a modified version of that library), * containing parts covered by the terms of the OpenSSL License and the * original SSLeay license, the licensors of this Program grant you * additional permission to convey the resulting work. Corresponding * Source for a non-source form of such a combination shall include the * source code for the parts of OpenSSL used as well as that of the * covered work. */ #include #include #include #include #include #include #include #include #include #include "chat.h" static const char *Pattern = { "(" "cvs|" "ftp|" "gemini|" "git|" "gopher|" "http|" "https|" "irc|" "ircs|" "magnet|" "sftp|" "ssh|" "svn|" "telnet|" "vnc" ")" ":([^[:space:]>\"()]|[(][^)]*[)])+" }; static regex_t Regex; static void compile(void) { static bool compiled; if (compiled) return; compiled = true; int error = regcomp(&Regex, Pattern, REG_EXTENDED); if (!error) return; char buf[256]; regerror(error, &Regex, buf, sizeof(buf)); errx(EX_SOFTWARE, "regcomp: %s: %s", buf, Pattern); } struct URL { uint id; char *nick; char *url; }; enum { Cap = 64 }; static struct { struct URL urls[Cap]; size_t len; } ring; _Static_assert(!(Cap & (Cap - 1)), "Cap is power of two"); static void push(uint id, const char *nick, const char *str, size_t len) { struct URL *url = &ring.urls[ring.len++ % Cap]; free(url->nick); free(url->url); url->id = id; url->nick = NULL; if (nick) { url->nick = strdup(nick); if (!url->nick) err(EX_OSERR, "strdup"); } url->url = malloc(len + 1); if (!url->url) err(EX_OSERR, "malloc"); char buf[1024]; snprintf(buf, sizeof(buf), "%.*s", (int)len, str); styleStrip(url->url, len + 1, buf); } void urlScan(uint id, const char *nick, const char *mesg) { if (!mesg) return; compile(); regmatch_t match = {0}; for (const char *ptr = mesg; *ptr; ptr += match.rm_eo) { if (regexec(&Regex, ptr, 1, &match, 0)) break; push(id, nick, &ptr[match.rm_so], match.rm_eo - match.rm_so); } } struct Util urlOpenUtil; static const struct Util OpenUtils[] = { { 1, { "open" } }, { 1, { "xdg-open" } }, }; static void urlOpen(const char *url) { pid_t pid = fork(); if (pid < 0) err(EX_OSERR, "fork"); if (pid) return; setsid(); close(STDIN_FILENO); dup2(utilPipe[1], STDOUT_FILENO); dup2(utilPipe[1], STDERR_FILENO); if (urlOpenUtil.argc) { struct Util util = urlOpenUtil; utilPush(&util, url); execvp(util.argv[0], (char *const *)util.argv); warn("%s", util.argv[0]); _exit(EX_CONFIG); } for (size_t i = 0; i < ARRAY_LEN(OpenUtils); ++i) { struct Util util = OpenUtils[i]; utilPush(&util, url); execvp(util.argv[0], (char *const *)util.argv); if (errno != ENOENT) { warn("%s", util.argv[0]); _exit(EX_CONFIG); } } warnx("no open utility found"); _exit(EX_CONFIG); } struct Util urlCopyUtil; static const struct Util CopyUtils[] = { { 1, { "pbcopy" } }, { 1, { "wl-copy" } }, { 3, { "xclip", "-selection", "clipboard" } }, { 3, { "xsel", "-i", "-b" } }, }; static void urlCopy(const char *url) { int rw[2]; int error = pipe(rw); if (error) err(EX_OSERR, "pipe"); size_t len = strlen(url); if (len > PIPE_BUF) len = PIPE_BUF; ssize_t n = write(rw[1], url, len); if (n < 0) err(EX_IOERR, "write"); error = close(rw[1]); if (error) err(EX_IOERR, "close"); pid_t pid = fork(); if (pid < 0) err(EX_OSERR, "fork"); if (pid) { close(rw[0]); return; } setsid(); dup2(rw[0], STDIN_FILENO); dup2(utilPipe[1], STDOUT_FILENO); dup2(utilPipe[1], STDERR_FILENO); close(rw[0]); if (urlCopyUtil.argc) { execvp(urlCopyUtil.argv[0], (char *const *)urlCopyUtil.argv); warn("%s", urlCopyUtil.argv[0]); _exit(EX_CONFIG); } for (size_t i = 0; i < ARRAY_LEN(CopyUtils); ++i) { execvp(CopyUtils[i].argv[0], (char *const *)CopyUtils[i].argv); if (errno != ENOENT) { warn("%s", CopyUtils[i].argv[0]); _exit(EX_CONFIG); } } warnx("no copy utility found"); _exit(EX_CONFIG); } void urlOpenCount(uint id, uint count) { for (uint i = 1; i <= Cap; ++i) { const struct URL *url = &ring.urls[(ring.len - i) % Cap]; if (!url->url) break; if (url->id != id) continue; urlOpen(url->url); if (!--count) break; } } void urlOpenMatch(uint id, const char *str) { for (uint i = 1; i <= Cap; ++i) { const struct URL *url = &ring.urls[(ring.len - i) % Cap]; if (!url->url) break; if (url->id != id) continue; if ((url->nick && !strcmp(url->nick, str)) || strstr(url->url, str)) { urlOpen(url->url); break; } } } void urlCopyMatch(uint id, const char *str) { for (uint i = 1; i <= Cap; ++i) { const struct URL *url = &ring.urls[(ring.len - i) % Cap]; if (!url->url) break; if (url->id != id) continue; if ( !str || (url->nick && !strcmp(url->nick, str)) || strstr(url->url, str) ) { urlCopy(url->url); break; } } } static int writeString(FILE *file, const char *str) { return (fwrite(str, strlen(str) + 1, 1, file) ? 0 : -1); } static ssize_t readString(FILE *file, char **buf, size_t *cap) { ssize_t len = getdelim(buf, cap, '\0', file); if (len < 0 && !feof(file)) err(EX_IOERR, "getdelim"); return len; } int urlSave(FILE *file) { for (size_t i = 0; i < Cap; ++i) { const struct URL *url = &ring.urls[(ring.len + i) % Cap]; if (!url->url) continue; int error = 0 || writeString(file, idNames[url->id]) || writeString(file, (url->nick ?: "")) || writeString(file, url->url); if (error) return error; } return writeString(file, ""); } void urlLoad(FILE *file, size_t version) { if (version < 5) return; size_t cap = 0; char *buf = NULL; while (0 < readString(file, &buf, &cap) && buf[0]) { struct URL *url = &ring.urls[ring.len++ % Cap]; free(url->nick); free(url->url); url->id = idFor(buf); url->nick = NULL; readString(file, &buf, &cap); if (buf[0]) { url->nick = strdup(buf); if (!url->nick) err(EX_OSERR, "strdup"); } readString(file, &buf, &cap); url->url = strdup(buf); if (!url->url) err(EX_OSERR, "strdup"); } free(buf); } catgirl-2.2/window.c000066400000000000000000000400631445265476100144760ustar00rootroot00000000000000/* Copyright (C) 2020 June McEnroe * * 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 . * * Additional permission under GNU GPL version 3 section 7: * * If you modify this Program, or any covered work, by linking or * combining it with OpenSSL (or a modified version of that library), * containing parts covered by the terms of the OpenSSL License and the * original SSLeay license, the licensors of this Program grant you * additional permission to convey the resulting work. Corresponding * Source for a non-source form of such a combination shall include the * source code for the parts of OpenSSL used as well as that of the * covered work. */ #define _XOPEN_SOURCE_EXTENDED #include #include #include #include #include #include #include #include #include #include #include "chat.h" #define MAIN_LINES (LINES - StatusLines - InputLines) static struct Window { uint id; int scroll; bool mark; bool mute; bool time; enum Heat thresh; enum Heat heat; uint unreadSoft; uint unreadHard; uint unreadWarm; struct Buffer *buffer; } *windows[IDCap]; static uint count; static uint show; static uint swap; static uint user; static uint windowPush(struct Window *window) { assert(count < IDCap); windows[count] = window; return count++; } static uint windowInsert(uint num, struct Window *window) { assert(count < IDCap); assert(num <= count); memmove( &windows[num + 1], &windows[num], sizeof(*windows) * (count - num) ); windows[num] = window; count++; return num; } static struct Window *windowRemove(uint num) { assert(num < count); struct Window *window = windows[num]; count--; memmove( &windows[num], &windows[num + 1], sizeof(*windows) * (count - num) ); return window; } static void windowFree(struct Window *window) { completeRemove(None, idNames[window->id]); bufferFree(window->buffer); free(window); } enum Heat windowThreshold = Cold; struct Time windowTime = { .format = "%X" }; uint windowFor(uint id) { for (uint num = 0; num < count; ++num) { if (windows[num]->id == id) return num; } struct Window *window = calloc(1, sizeof(*window)); if (!window) err(EX_OSERR, "malloc"); window->id = id; window->mark = true; window->time = windowTime.enable; if (id == Network || id == Debug) { window->thresh = Cold; } else { window->thresh = windowThreshold; } window->buffer = bufferAlloc(); completePush(None, idNames[id], idColors[id]); return windowPush(window); } enum { TimeCap = 64 }; void windowInit(void) { char fmt[TimeCap]; char buf[TimeCap]; styleStrip(fmt, sizeof(fmt), windowTime.format); struct tm *time = localtime(&(time_t) { -22100400 }); size_t len = strftime(buf, sizeof(buf), fmt, time); if (!len) errx(EX_CONFIG, "invalid timestamp format: %s", fmt); int y; waddstr(uiMain, buf); waddch(uiMain, ' '); getyx(uiMain, y, windowTime.width); (void)y; windowFor(Network); } static int styleAdd(WINDOW *win, struct Style init, const char *str) { struct Style style = init; while (*str) { size_t len = styleParse(&style, &str); wattr_set(win, uiAttr(style), uiPair(style), NULL); if (waddnstr(win, str, len) == ERR) return -1; str += len; } return 0; } static void statusUpdate(void) { struct { uint unread; enum Heat heat; } others = { 0, Cold }; wmove(uiStatus, 0, 0); for (uint num = 0; num < count; ++num) { const struct Window *window = windows[num]; if (num != show && !window->scroll && !inputPending(window->id)) { if (window->heat < Warm) continue; if (window->mute && window->heat < Hot) continue; } if (num != show) { others.unread += window->unreadWarm; if (window->heat > others.heat) others.heat = window->heat; } char buf[256], *end = &buf[sizeof(buf)]; char *ptr = seprintf( buf, end, "\3%d%s %u%s%s %s ", idColors[window->id], (num == show ? "\26" : ""), num, window->thresh[(const char *[]) { "-", "", "+", "++" }], &"="[!window->mute], idNames[window->id] ); if (window->mark && window->unreadWarm) { ptr = seprintf( ptr, end, "\3%d+%d\3%d ", (window->heat > Warm ? White : idColors[window->id]), window->unreadWarm, idColors[window->id] ); } if (window->scroll) { ptr = seprintf(ptr, end, "~%d ", window->scroll); } if (num != show && inputPending(window->id)) { ptr = seprintf(ptr, end, "@ "); } if (styleAdd(uiStatus, StyleDefault, buf) < 0) break; } wclrtoeol(uiStatus); const struct Window *window = windows[show]; char *end = &uiTitle[sizeof(uiTitle)]; char *ptr = seprintf( uiTitle, end, "%s %s", network.name, idNames[window->id] ); if (window->mark && window->unreadWarm) { ptr = seprintf( ptr, end, " +%d%s", window->unreadWarm, &"!"[window->heat < Hot] ); } if (others.unread) { ptr = seprintf( ptr, end, " (+%d%s)", others.unread, &"!"[others.heat < Hot] ); } } static size_t windowTop(const struct Window *window) { size_t top = BufferCap - MAIN_LINES - window->scroll; if (window->scroll) top += MarkerLines; return top; } static size_t windowBottom(const struct Window *window) { size_t bottom = BufferCap - (window->scroll ?: 1); if (window->scroll) bottom -= SplitLines + MarkerLines; return bottom; } static void mainAdd(int y, bool time, const struct Line *line) { int ny, nx; wmove(uiMain, y, 0); if (!line || !line->str[0]) { wclrtoeol(uiMain); return; } if (time && line->time) { char buf[TimeCap]; strftime(buf, sizeof(buf), windowTime.format, localtime(&line->time)); struct Style init = { .fg = Gray, .bg = Default }; styleAdd(uiMain, init, buf); waddch(uiMain, ' '); } else if (time) { whline(uiMain, ' ', windowTime.width); wmove(uiMain, y, windowTime.width); } styleAdd(uiMain, StyleDefault, line->str); getyx(uiMain, ny, nx); if (ny != y) return; wclrtoeol(uiMain); (void)nx; } static void mainUpdate(void) { const struct Window *window = windows[show]; int y = 0; int marker = MAIN_LINES - SplitLines - MarkerLines; for (size_t i = windowTop(window); i < BufferCap; ++i) { mainAdd(y++, window->time, bufferHard(window->buffer, i)); if (window->scroll && y == marker) break; } if (!window->scroll) return; y = MAIN_LINES - SplitLines; for (size_t i = BufferCap - SplitLines; i < BufferCap; ++i) { mainAdd(y++, window->time, bufferHard(window->buffer, i)); } wattr_set(uiMain, A_NORMAL, 0, NULL); mvwhline(uiMain, marker, 0, ACS_BULLET, COLS); } void windowUpdate(void) { statusUpdate(); mainUpdate(); } void windowBare(void) { uiHide(); inputWait(); const struct Window *window = windows[show]; const struct Line *line = bufferHard(window->buffer, windowBottom(window)); uint num = 0; if (line) num = line->num; for (size_t i = 0; i < BufferCap; ++i) { line = bufferSoft(window->buffer, i); if (!line) continue; if (line->num > num) break; if (!line->str[0]) { printf("\n"); continue; } char buf[TimeCap]; struct Style style = { .fg = Gray, .bg = Default }; strftime(buf, sizeof(buf), windowTime.format, localtime(&line->time)); vid_attr(uiAttr(style), uiPair(style), NULL); printf("%s ", buf); bool align = false; style = StyleDefault; for (const char *str = line->str; *str;) { if (*str == '\t') { printf("%c", (align ? '\t' : ' ')); align = true; str++; } size_t len = styleParse(&style, &str); size_t tab = strcspn(str, "\t"); if (tab < len) len = tab; vid_attr(uiAttr(style), uiPair(style), NULL); printf("%.*s", (int)len, str); str += len; } printf("\n"); } } static void mark(struct Window *window) { if (window->scroll) return; window->mark = true; window->unreadSoft = 0; window->unreadWarm = 0; } static void unmark(struct Window *window) { if (!window->scroll) { window->mark = false; window->heat = Cold; } statusUpdate(); } static void scrollN(struct Window *window, int n) { mark(window); window->scroll += n; if (window->scroll > BufferCap - MAIN_LINES) { window->scroll = BufferCap - MAIN_LINES; } if (window->scroll < 0) window->scroll = 0; unmark(window); if (window == windows[show]) mainUpdate(); } static void scrollTo(struct Window *window, int top) { window->scroll = 0; scrollN(window, top - MAIN_LINES + MarkerLines); } static int windowCols(const struct Window *window) { return COLS - (window->time ? windowTime.width : 0); } bool windowWrite(uint id, enum Heat heat, const time_t *src, const char *str) { struct Window *window = windows[windowFor(id)]; time_t ts = (src ? *src : time(NULL)); if (heat >= window->thresh) { if (!window->unreadSoft++) window->unreadHard = 0; } if (window->mark && heat > Cold) { if (!window->unreadWarm++) { int lines = bufferPush( window->buffer, windowCols(window), window->thresh, Warm, ts, "" ); if (window->scroll) scrollN(window, lines); if (window->unreadSoft > 1) { window->unreadSoft++; window->unreadHard += lines; } } if (heat > window->heat) window->heat = heat; statusUpdate(); } int lines = bufferPush( window->buffer, windowCols(window), window->thresh, heat, ts, str ); window->unreadHard += lines; if (window->scroll) scrollN(window, lines); if (window == windows[show]) mainUpdate(); return window->mark && heat > Warm; } static void reflow(struct Window *window) { uint num = 0; const struct Line *line = bufferHard(window->buffer, windowTop(window)); if (line) num = line->num; window->unreadHard = bufferReflow( window->buffer, windowCols(window), window->thresh, window->unreadSoft ); if (!window->scroll || !num) return; for (size_t i = 0; i < BufferCap; ++i) { line = bufferHard(window->buffer, i); if (!line || line->num != num) continue; scrollTo(window, BufferCap - i); break; } } void windowResize(void) { for (uint num = 0; num < count; ++num) { reflow(windows[num]); } windowUpdate(); } uint windowID(void) { return windows[show]->id; } uint windowNum(void) { return show; } void windowShow(uint num) { if (num >= count) return; if (num != show) { swap = show; mark(windows[swap]); } show = num; user = num; unmark(windows[show]); mainUpdate(); inputUpdate(); } void windowAuto(void) { uint minHot = UINT_MAX, numHot = 0; uint minWarm = UINT_MAX, numWarm = 0; for (uint num = 0; num < count; ++num) { struct Window *window = windows[num]; if (window->heat >= Hot) { if (window->unreadWarm >= minHot) continue; minHot = window->unreadWarm; numHot = num; } if (window->heat >= Warm && !window->mute) { if (window->unreadWarm >= minWarm) continue; minWarm = window->unreadWarm; numWarm = num; } } uint oldUser = user; if (minHot < UINT_MAX) { windowShow(numHot); user = oldUser; } else if (minWarm < UINT_MAX) { windowShow(numWarm); user = oldUser; } else if (user != show) { windowShow(user); } } void windowSwap(void) { windowShow(swap); } void windowMove(uint from, uint to) { if (from >= count) return; struct Window *window = windowRemove(from); if (to < count) { windowShow(windowInsert(to, window)); } else { windowShow(windowPush(window)); } } void windowClose(uint num) { if (num >= count) return; if (windows[num]->id == Network) return; struct Window *window = windowRemove(num); completeRemove(window->id, NULL); windowFree(window); if (swap >= num) swap--; if (show == num) { windowShow(swap); swap = show; } else if (show > num) { show--; mainUpdate(); } statusUpdate(); } void windowList(void) { for (uint num = 0; num < count; ++num) { const struct Window *window = windows[num]; uiFormat( Network, Warm, NULL, "\3%02d%u %s", idColors[window->id], num, idNames[window->id] ); } } void windowMark(void) { mark(windows[show]); } void windowUnmark(void) { unmark(windows[show]); } void windowToggleMute(void) { windows[show]->mute ^= true; statusUpdate(); } void windowToggleTime(void) { windows[show]->time ^= true; reflow(windows[show]); windowUpdate(); inputUpdate(); } void windowToggleThresh(int n) { struct Window *window = windows[show]; if (n > 0 && window->thresh == Hot) return; if (n < 0 && window->thresh == Ice) { window->thresh = Cold; } else { window->thresh += n; } reflow(window); windowUpdate(); } bool windowTimeEnable(void) { return windows[show]->time; } void windowScroll(enum Scroll by, int n) { struct Window *window = windows[show]; switch (by) { break; case ScrollOne: { scrollN(window, n); } break; case ScrollPage: { scrollN(window, n * (MAIN_LINES - SplitLines - MarkerLines - 1)); } break; case ScrollAll: { if (n < 0) { scrollTo(window, 0); break; } for (size_t i = 0; i < BufferCap; ++i) { if (!bufferHard(window->buffer, i)) continue; scrollTo(window, BufferCap - i); break; } } break; case ScrollUnread: { scrollTo(window, window->unreadHard); } break; case ScrollHot: { for (size_t i = windowTop(window) + n; i < BufferCap; i += n) { const struct Line *line = bufferHard(window->buffer, i); const struct Line *prev = bufferHard(window->buffer, i - 1); if (!line || line->heat < Hot) continue; if (prev && prev->heat > Warm) continue; scrollTo(window, BufferCap - i); break; } } } } void windowSearch(const char *str, int dir) { struct Window *window = windows[show]; for (size_t i = windowTop(window) + dir; i < BufferCap; i += dir) { const struct Line *line = bufferHard(window->buffer, i); if (!line || !strcasestr(line->str, str)) continue; scrollTo(window, BufferCap - i); break; } } static int writeTime(FILE *file, time_t time) { return (fwrite(&time, sizeof(time), 1, file) ? 0 : -1); } static int writeString(FILE *file, const char *str) { return (fwrite(str, strlen(str) + 1, 1, file) ? 0 : -1); } int windowSave(FILE *file) { int error; for (uint num = 0; num < count; ++num) { const struct Window *window = windows[num]; error = 0 || writeString(file, idNames[window->id]) || writeTime(file, window->mute) || writeTime(file, window->time) || writeTime(file, window->thresh) || writeTime(file, window->heat) || writeTime(file, window->unreadSoft) || writeTime(file, window->unreadWarm); if (error) return error; for (size_t i = 0; i < BufferCap; ++i) { const struct Line *line = bufferSoft(window->buffer, i); if (!line) continue; error = 0 || writeTime(file, line->time) || writeTime(file, line->heat) || writeString(file, line->str); if (error) return error; } error = writeTime(file, 0); if (error) return error; } return writeString(file, ""); } static time_t readTime(FILE *file) { time_t time; fread(&time, sizeof(time), 1, file); if (ferror(file)) err(EX_IOERR, "fread"); if (feof(file)) errx(EX_DATAERR, "unexpected eof"); return time; } static ssize_t readString(FILE *file, char **buf, size_t *cap) { ssize_t len = getdelim(buf, cap, '\0', file); if (len < 0 && !feof(file)) err(EX_IOERR, "getdelim"); return len; } void windowLoad(FILE *file, size_t version) { size_t cap = 0; char *buf = NULL; while (0 < readString(file, &buf, &cap) && buf[0]) { struct Window *window = windows[windowFor(idFor(buf))]; if (version > 3) window->mute = readTime(file); if (version > 6) window->time = readTime(file); if (version > 5) window->thresh = readTime(file); if (version > 0) { window->heat = readTime(file); window->unreadSoft = readTime(file); window->unreadWarm = readTime(file); } for (;;) { time_t time = readTime(file); if (!time) break; enum Heat heat = (version > 2 ? readTime(file) : Cold); readString(file, &buf, &cap); bufferPush(window->buffer, COLS, window->thresh, heat, time, buf); } reflow(window); } free(buf); } catgirl-2.2/xdg.c000066400000000000000000000072641445265476100137570ustar00rootroot00000000000000/* Copyright (C) 2019, 2020 June McEnroe * * 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 . * * Additional permission under GNU GPL version 3 section 7: * * If you modify this Program, or any covered work, by linking or * combining it with OpenSSL (or a modified version of that library), * containing parts covered by the terms of the OpenSSL License and the * original SSLeay license, the licensors of this Program grant you * additional permission to convey the resulting work. Corresponding * Source for a non-source form of such a combination shall include the * source code for the parts of OpenSSL used as well as that of the * covered work. */ #include #include #include #include #include #include #include #include #include "chat.h" #define SUBDIR "catgirl" struct Base { const char *envHome; const char *envDirs; const char *defHome; const char *defDirs; }; static const struct Base Config = { .envHome = "XDG_CONFIG_HOME", .envDirs = "XDG_CONFIG_DIRS", .defHome = ".config", .defDirs = "/etc/xdg", }; static const struct Base Data = { .envHome = "XDG_DATA_HOME", .envDirs = "XDG_DATA_DIRS", .defHome = ".local/share", .defDirs = "/usr/local/share:/usr/share", }; static char *basePath( struct Base base, char *buf, size_t cap, const char *path, int i ) { if (path[strspn(path, ".")] == '/') { if (i > 0) return NULL; snprintf(buf, cap, "%s", path); return buf; } if (i > 0) { const char *dirs = getenv(base.envDirs); if (!dirs) dirs = base.defDirs; for (; i > 1; --i) { dirs += strcspn(dirs, ":"); dirs += (*dirs == ':'); } if (!*dirs) return NULL; snprintf( buf, cap, "%.*s/" SUBDIR "/%s", (int)strcspn(dirs, ":"), dirs, path ); return buf; } const char *home = getenv("HOME"); const char *baseHome = getenv(base.envHome); if (baseHome) { snprintf(buf, cap, "%s/" SUBDIR "/%s", baseHome, path); } else if (home) { snprintf(buf, cap, "%s/%s/" SUBDIR "/%s", home, base.defHome, path); } else { errx(EX_USAGE, "HOME unset"); } return buf; } char *configPath(char *buf, size_t cap, const char *path, int i) { return basePath(Config, buf, cap, path, i); } char *dataPath(char *buf, size_t cap, const char *path, int i) { return basePath(Data, buf, cap, path, i); } FILE *configOpen(const char *path, const char *mode) { char buf[PATH_MAX]; for (int i = 0; configPath(buf, sizeof(buf), path, i); ++i) { FILE *file = fopen(buf, mode); if (file) return file; if (errno != ENOENT) warn("%s", buf); } warn("%s", configPath(buf, sizeof(buf), path, 0)); return NULL; } FILE *dataOpen(const char *path, const char *mode) { char buf[PATH_MAX]; for (int i = 0; dataPath(buf, sizeof(buf), path, i); ++i) { FILE *file = fopen(buf, mode); if (file) return file; if (errno != ENOENT) warn("%s", buf); } if (mode[0] != 'r') { int error = mkdir(dataPath(buf, sizeof(buf), "", 0), S_IRWXU); if (error && errno != EEXIST) warn("%s", buf); } FILE *file = fopen(dataPath(buf, sizeof(buf), path, 0), mode); if (!file) warn("%s", buf); return file; }