From ff08838a19ba70cad3a4d0b2a24654a0ac42efa0 Mon Sep 17 00:00:00 2001 From: Max Lv Date: Sat, 6 Apr 2013 18:00:46 +0800 Subject: [PATCH] add debian package description --- .gitignore | 1 + COPYING | 686 +-- LICENSE | 674 +++ debian/README.Debian | 6 + debian/README.source | 9 + debian/changelog | 5 + debian/compat | 1 + debian/control | 15 + debian/copyright | 23 + debian/docs | 1 + debian/files | 1 + debian/patches/debian-changes-1.0-1 | 7045 +++++++++++++++++++++++++ debian/patches/series | 1 + debian/rules | 21 + debian/shadowsocks.postinst.debhelper | 5 + debian/shadowsocks.postrm.debhelper | 5 + debian/shadowsocks.substvars | 2 + debian/source/format | 1 + libasyncns/Makefile.am | 1 + libev/Makefile.am | 2 +- 20 files changed, 7830 insertions(+), 675 deletions(-) create mode 100644 LICENSE create mode 100644 debian/README.Debian create mode 100644 debian/README.source create mode 100644 debian/changelog create mode 100644 debian/compat create mode 100644 debian/control create mode 100644 debian/copyright create mode 100644 debian/docs create mode 100644 debian/files create mode 100644 debian/patches/debian-changes-1.0-1 create mode 100644 debian/patches/series create mode 100755 debian/rules create mode 100644 debian/shadowsocks.postinst.debhelper create mode 100644 debian/shadowsocks.postrm.debhelper create mode 100644 debian/shadowsocks.substvars create mode 100644 debian/source/format diff --git a/.gitignore b/.gitignore index 795ed968..f5dfff70 100644 --- a/.gitignore +++ b/.gitignore @@ -10,6 +10,7 @@ pid ss* stamp-h1 .libs +.pc *.json # Do not edit the following section diff --git a/COPYING b/COPYING index 94a9ed02..7660015d 100644 --- a/COPYING +++ b/COPYING @@ -1,674 +1,12 @@ - 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 -. +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 . diff --git a/LICENSE b/LICENSE new file mode 100644 index 00000000..94a9ed02 --- /dev/null +++ b/LICENSE @@ -0,0 +1,674 @@ + GNU GENERAL PUBLIC LICENSE + Version 3, 29 June 2007 + + Copyright (C) 2007 Free Software Foundation, Inc. + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + Preamble + + The GNU General Public License is a free, copyleft license for +software and other kinds of works. + + The licenses for most software and other practical works are designed +to take away your freedom to share and change the works. By contrast, +the GNU General Public License is intended to guarantee your freedom to +share and change all versions of a program--to make sure it remains free +software for all its users. We, the Free Software Foundation, use the +GNU General Public License for most of our software; it applies also to +any other work released this way by its authors. You can apply it to +your programs, too. + + When we speak of free software, we are referring to freedom, not +price. Our General Public Licenses are designed to make sure that you +have the freedom to distribute copies of free software (and charge for +them if you wish), that you receive source code or can get it if you +want it, that you can change the software or use pieces of it in new +free programs, and that you know you can do these things. + + To protect your rights, we need to prevent others from denying you +these rights or asking you to surrender the rights. Therefore, you have +certain responsibilities if you distribute copies of the software, or if +you modify it: responsibilities to respect the freedom of others. + + For example, if you distribute copies of such a program, whether +gratis or for a fee, you must pass on to the recipients the same +freedoms that you received. You must make sure that they, too, receive +or can get the source code. And you must show them these terms so they +know their rights. + + Developers that use the GNU GPL protect your rights with two steps: +(1) assert copyright on the software, and (2) offer you this License +giving you legal permission to copy, distribute and/or modify it. + + For the developers' and authors' protection, the GPL clearly explains +that there is no warranty for this free software. For both users' and +authors' sake, the GPL requires that modified versions be marked as +changed, so that their problems will not be attributed erroneously to +authors of previous versions. + + Some devices are designed to deny users access to install or run +modified versions of the software inside them, although the manufacturer +can do so. This is fundamentally incompatible with the aim of +protecting users' freedom to change the software. The systematic +pattern of such abuse occurs in the area of products for individuals to +use, which is precisely where it is most unacceptable. Therefore, we +have designed this version of the GPL to prohibit the practice for those +products. If such problems arise substantially in other domains, we +stand ready to extend this provision to those domains in future versions +of the GPL, as needed to protect the freedom of users. + + Finally, every program is threatened constantly by software patents. +States should not allow patents to restrict development and use of +software on general-purpose computers, but in those that do, we wish to +avoid the special danger that patents applied to a free program could +make it effectively proprietary. To prevent this, the GPL assures that +patents cannot be used to render the program non-free. + + The precise terms and conditions for copying, distribution and +modification follow. + + TERMS AND CONDITIONS + + 0. Definitions. + + "This License" refers to version 3 of the GNU General Public License. + + "Copyright" also means copyright-like laws that apply to other kinds of +works, such as semiconductor masks. + + "The Program" refers to any copyrightable work licensed under this +License. Each licensee is addressed as "you". "Licensees" and +"recipients" may be individuals or organizations. + + To "modify" a work means to copy from or adapt all or part of the work +in a fashion requiring copyright permission, other than the making of an +exact copy. The resulting work is called a "modified version" of the +earlier work or a work "based on" the earlier work. + + A "covered work" means either the unmodified Program or a work based +on the Program. + + To "propagate" a work means to do anything with it that, without +permission, would make you directly or secondarily liable for +infringement under applicable copyright law, except executing it on a +computer or modifying a private copy. Propagation includes copying, +distribution (with or without modification), making available to the +public, and in some countries other activities as well. + + To "convey" a work means any kind of propagation that enables other +parties to make or receive copies. Mere interaction with a user through +a computer network, with no transfer of a copy, is not conveying. + + An interactive user interface displays "Appropriate Legal Notices" +to the extent that it includes a convenient and prominently visible +feature that (1) displays an appropriate copyright notice, and (2) +tells the user that there is no warranty for the work (except to the +extent that warranties are provided), that licensees may convey the +work under this License, and how to view a copy of this License. If +the interface presents a list of user commands or options, such as a +menu, a prominent item in the list meets this criterion. + + 1. Source Code. + + The "source code" for a work means the preferred form of the work +for making modifications to it. "Object code" means any non-source +form of a work. + + A "Standard Interface" means an interface that either is an official +standard defined by a recognized standards body, or, in the case of +interfaces specified for a particular programming language, one that +is widely used among developers working in that language. + + The "System Libraries" of an executable work include anything, other +than the work as a whole, that (a) is included in the normal form of +packaging a Major Component, but which is not part of that Major +Component, and (b) serves only to enable use of the work with that +Major Component, or to implement a Standard Interface for which an +implementation is available to the public in source code form. A +"Major Component", in this context, means a major essential component +(kernel, window system, and so on) of the specific operating system +(if any) on which the executable work runs, or a compiler used to +produce the work, or an object code interpreter used to run it. + + The "Corresponding Source" for a work in object code form means all +the source code needed to generate, install, and (for an executable +work) run the object code and to modify the work, including scripts to +control those activities. However, it does not include the work's +System Libraries, or general-purpose tools or generally available free +programs which are used unmodified in performing those activities but +which are not part of the work. For example, Corresponding Source +includes interface definition files associated with source files for +the work, and the source code for shared libraries and dynamically +linked subprograms that the work is specifically designed to require, +such as by intimate data communication or control flow between those +subprograms and other parts of the work. + + The Corresponding Source need not include anything that users +can regenerate automatically from other parts of the Corresponding +Source. + + The Corresponding Source for a work in source code form is that +same work. + + 2. Basic Permissions. + + All rights granted under this License are granted for the term of +copyright on the Program, and are irrevocable provided the stated +conditions are met. This License explicitly affirms your unlimited +permission to run the unmodified Program. The output from running a +covered work is covered by this License only if the output, given its +content, constitutes a covered work. This License acknowledges your +rights of fair use or other equivalent, as provided by copyright law. + + You may make, run and propagate covered works that you do not +convey, without conditions so long as your license otherwise remains +in force. You may convey covered works to others for the sole purpose +of having them make modifications exclusively for you, or provide you +with facilities for running those works, provided that you comply with +the terms of this License in conveying all material for which you do +not control copyright. Those thus making or running the covered works +for you must do so exclusively on your behalf, under your direction +and control, on terms that prohibit them from making any copies of +your copyrighted material outside their relationship with you. + + Conveying under any other circumstances is permitted solely under +the conditions stated below. Sublicensing is not allowed; section 10 +makes it unnecessary. + + 3. Protecting Users' Legal Rights From Anti-Circumvention Law. + + No covered work shall be deemed part of an effective technological +measure under any applicable law fulfilling obligations under article +11 of the WIPO copyright treaty adopted on 20 December 1996, or +similar laws prohibiting or restricting circumvention of such +measures. + + When you convey a covered work, you waive any legal power to forbid +circumvention of technological measures to the extent such circumvention +is effected by exercising rights under this License with respect to +the covered work, and you disclaim any intention to limit operation or +modification of the work as a means of enforcing, against the work's +users, your or third parties' legal rights to forbid circumvention of +technological measures. + + 4. Conveying Verbatim Copies. + + You may convey verbatim copies of the Program's source code as you +receive it, in any medium, provided that you conspicuously and +appropriately publish on each copy an appropriate copyright notice; +keep intact all notices stating that this License and any +non-permissive terms added in accord with section 7 apply to the code; +keep intact all notices of the absence of any warranty; and give all +recipients a copy of this License along with the Program. + + You may charge any price or no price for each copy that you convey, +and you may offer support or warranty protection for a fee. + + 5. Conveying Modified Source Versions. + + You may convey a work based on the Program, or the modifications to +produce it from the Program, in the form of source code under the +terms of section 4, provided that you also meet all of these conditions: + + a) The work must carry prominent notices stating that you modified + it, and giving a relevant date. + + b) The work must carry prominent notices stating that it is + released under this License and any conditions added under section + 7. This requirement modifies the requirement in section 4 to + "keep intact all notices". + + c) You must license the entire work, as a whole, under this + License to anyone who comes into possession of a copy. This + License will therefore apply, along with any applicable section 7 + additional terms, to the whole of the work, and all its parts, + regardless of how they are packaged. This License gives no + permission to license the work in any other way, but it does not + invalidate such permission if you have separately received it. + + d) If the work has interactive user interfaces, each must display + Appropriate Legal Notices; however, if the Program has interactive + interfaces that do not display Appropriate Legal Notices, your + work need not make them do so. + + A compilation of a covered work with other separate and independent +works, which are not by their nature extensions of the covered work, +and which are not combined with it such as to form a larger program, +in or on a volume of a storage or distribution medium, is called an +"aggregate" if the compilation and its resulting copyright are not +used to limit the access or legal rights of the compilation's users +beyond what the individual works permit. Inclusion of a covered work +in an aggregate does not cause this License to apply to the other +parts of the aggregate. + + 6. Conveying Non-Source Forms. + + You may convey a covered work in object code form under the terms +of sections 4 and 5, provided that you also convey the +machine-readable Corresponding Source under the terms of this License, +in one of these ways: + + a) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by the + Corresponding Source fixed on a durable physical medium + customarily used for software interchange. + + b) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by a + written offer, valid for at least three years and valid for as + long as you offer spare parts or customer support for that product + model, to give anyone who possesses the object code either (1) a + copy of the Corresponding Source for all the software in the + product that is covered by this License, on a durable physical + medium customarily used for software interchange, for a price no + more than your reasonable cost of physically performing this + conveying of source, or (2) access to copy the + Corresponding Source from a network server at no charge. + + c) Convey individual copies of the object code with a copy of the + written offer to provide the Corresponding Source. This + alternative is allowed only occasionally and noncommercially, and + only if you received the object code with such an offer, in accord + with subsection 6b. + + d) Convey the object code by offering access from a designated + place (gratis or for a charge), and offer equivalent access to the + Corresponding Source in the same way through the same place at no + further charge. You need not require recipients to copy the + Corresponding Source along with the object code. If the place to + copy the object code is a network server, the Corresponding Source + may be on a different server (operated by you or a third party) + that supports equivalent copying facilities, provided you maintain + clear directions next to the object code saying where to find the + Corresponding Source. Regardless of what server hosts the + Corresponding Source, you remain obligated to ensure that it is + available for as long as needed to satisfy these requirements. + + e) Convey the object code using peer-to-peer transmission, provided + you inform other peers where the object code and Corresponding + Source of the work are being offered to the general public at no + charge under subsection 6d. + + A separable portion of the object code, whose source code is excluded +from the Corresponding Source as a System Library, need not be +included in conveying the object code work. + + A "User Product" is either (1) a "consumer product", which means any +tangible personal property which is normally used for personal, family, +or household purposes, or (2) anything designed or sold for incorporation +into a dwelling. In determining whether a product is a consumer product, +doubtful cases shall be resolved in favor of coverage. For a particular +product received by a particular user, "normally used" refers to a +typical or common use of that class of product, regardless of the status +of the particular user or of the way in which the particular user +actually uses, or expects or is expected to use, the product. A product +is a consumer product regardless of whether the product has substantial +commercial, industrial or non-consumer uses, unless such uses represent +the only significant mode of use of the product. + + "Installation Information" for a User Product means any methods, +procedures, authorization keys, or other information required to install +and execute modified versions of a covered work in that User Product from +a modified version of its Corresponding Source. The information must +suffice to ensure that the continued functioning of the modified object +code is in no case prevented or interfered with solely because +modification has been made. + + If you convey an object code work under this section in, or with, or +specifically for use in, a User Product, and the conveying occurs as +part of a transaction in which the right of possession and use of the +User Product is transferred to the recipient in perpetuity or for a +fixed term (regardless of how the transaction is characterized), the +Corresponding Source conveyed under this section must be accompanied +by the Installation Information. But this requirement does not apply +if neither you nor any third party retains the ability to install +modified object code on the User Product (for example, the work has +been installed in ROM). + + The requirement to provide Installation Information does not include a +requirement to continue to provide support service, warranty, or updates +for a work that has been modified or installed by the recipient, or for +the User Product in which it has been modified or installed. Access to a +network may be denied when the modification itself materially and +adversely affects the operation of the network or violates the rules and +protocols for communication across the network. + + Corresponding Source conveyed, and Installation Information provided, +in accord with this section must be in a format that is publicly +documented (and with an implementation available to the public in +source code form), and must require no special password or key for +unpacking, reading or copying. + + 7. Additional Terms. + + "Additional permissions" are terms that supplement the terms of this +License by making exceptions from one or more of its conditions. +Additional permissions that are applicable to the entire Program shall +be treated as though they were included in this License, to the extent +that they are valid under applicable law. If additional permissions +apply only to part of the Program, that part may be used separately +under those permissions, but the entire Program remains governed by +this License without regard to the additional permissions. + + When you convey a copy of a covered work, you may at your option +remove any additional permissions from that copy, or from any part of +it. (Additional permissions may be written to require their own +removal in certain cases when you modify the work.) You may place +additional permissions on material, added by you to a covered work, +for which you have or can give appropriate copyright permission. + + Notwithstanding any other provision of this License, for material you +add to a covered work, you may (if authorized by the copyright holders of +that material) supplement the terms of this License with terms: + + a) Disclaiming warranty or limiting liability differently from the + terms of sections 15 and 16 of this License; or + + b) Requiring preservation of specified reasonable legal notices or + author attributions in that material or in the Appropriate Legal + Notices displayed by works containing it; or + + c) Prohibiting misrepresentation of the origin of that material, or + requiring that modified versions of such material be marked in + reasonable ways as different from the original version; or + + d) Limiting the use for publicity purposes of names of licensors or + authors of the material; or + + e) Declining to grant rights under trademark law for use of some + trade names, trademarks, or service marks; or + + f) Requiring indemnification of licensors and authors of that + material by anyone who conveys the material (or modified versions of + it) with contractual assumptions of liability to the recipient, for + any liability that these contractual assumptions directly impose on + those licensors and authors. + + All other non-permissive additional terms are considered "further +restrictions" within the meaning of section 10. If the Program as you +received it, or any part of it, contains a notice stating that it is +governed by this License along with a term that is a further +restriction, you may remove that term. If a license document contains +a further restriction but permits relicensing or conveying under this +License, you may add to a covered work material governed by the terms +of that license document, provided that the further restriction does +not survive such relicensing or conveying. + + If you add terms to a covered work in accord with this section, you +must place, in the relevant source files, a statement of the +additional terms that apply to those files, or a notice indicating +where to find the applicable terms. + + Additional terms, permissive or non-permissive, may be stated in the +form of a separately written license, or stated as exceptions; +the above requirements apply either way. + + 8. Termination. + + You may not propagate or modify a covered work except as expressly +provided under this License. Any attempt otherwise to propagate or +modify it is void, and will automatically terminate your rights under +this License (including any patent licenses granted under the third +paragraph of section 11). + + However, if you cease all violation of this License, then your +license from a particular copyright holder is reinstated (a) +provisionally, unless and until the copyright holder explicitly and +finally terminates your license, and (b) permanently, if the copyright +holder fails to notify you of the violation by some reasonable means +prior to 60 days after the cessation. + + Moreover, your license from a particular copyright holder is +reinstated permanently if the copyright holder notifies you of the +violation by some reasonable means, this is the first time you have +received notice of violation of this License (for any work) from that +copyright holder, and you cure the violation prior to 30 days after +your receipt of the notice. + + Termination of your rights under this section does not terminate the +licenses of parties who have received copies or rights from you under +this License. If your rights have been terminated and not permanently +reinstated, you do not qualify to receive new licenses for the same +material under section 10. + + 9. Acceptance Not Required for Having Copies. + + You are not required to accept this License in order to receive or +run a copy of the Program. Ancillary propagation of a covered work +occurring solely as a consequence of using peer-to-peer transmission +to receive a copy likewise does not require acceptance. However, +nothing other than this License grants you permission to propagate or +modify any covered work. These actions infringe copyright if you do +not accept this License. Therefore, by modifying or propagating a +covered work, you indicate your acceptance of this License to do so. + + 10. Automatic Licensing of Downstream Recipients. + + Each time you convey a covered work, the recipient automatically +receives a license from the original licensors, to run, modify and +propagate that work, subject to this License. You are not responsible +for enforcing compliance by third parties with this License. + + An "entity transaction" is a transaction transferring control of an +organization, or substantially all assets of one, or subdividing an +organization, or merging organizations. If propagation of a covered +work results from an entity transaction, each party to that +transaction who receives a copy of the work also receives whatever +licenses to the work the party's predecessor in interest had or could +give under the previous paragraph, plus a right to possession of the +Corresponding Source of the work from the predecessor in interest, if +the predecessor has it or can get it with reasonable efforts. + + You may not impose any further restrictions on the exercise of the +rights granted or affirmed under this License. For example, you may +not impose a license fee, royalty, or other charge for exercise of +rights granted under this License, and you may not initiate litigation +(including a cross-claim or counterclaim in a lawsuit) alleging that +any patent claim is infringed by making, using, selling, offering for +sale, or importing the Program or any portion of it. + + 11. Patents. + + A "contributor" is a copyright holder who authorizes use under this +License of the Program or a work on which the Program is based. The +work thus licensed is called the contributor's "contributor version". + + A contributor's "essential patent claims" are all patent claims +owned or controlled by the contributor, whether already acquired or +hereafter acquired, that would be infringed by some manner, permitted +by this License, of making, using, or selling its contributor version, +but do not include claims that would be infringed only as a +consequence of further modification of the contributor version. For +purposes of this definition, "control" includes the right to grant +patent sublicenses in a manner consistent with the requirements of +this License. + + Each contributor grants you a non-exclusive, worldwide, royalty-free +patent license under the contributor's essential patent claims, to +make, use, sell, offer for sale, import and otherwise run, modify and +propagate the contents of its contributor version. + + In the following three paragraphs, a "patent license" is any express +agreement or commitment, however denominated, not to enforce a patent +(such as an express permission to practice a patent or covenant not to +sue for patent infringement). To "grant" such a patent license to a +party means to make such an agreement or commitment not to enforce a +patent against the party. + + If you convey a covered work, knowingly relying on a patent license, +and the Corresponding Source of the work is not available for anyone +to copy, free of charge and under the terms of this License, through a +publicly available network server or other readily accessible means, +then you must either (1) cause the Corresponding Source to be so +available, or (2) arrange to deprive yourself of the benefit of the +patent license for this particular work, or (3) arrange, in a manner +consistent with the requirements of this License, to extend the patent +license to downstream recipients. "Knowingly relying" means you have +actual knowledge that, but for the patent license, your conveying the +covered work in a country, or your recipient's use of the covered work +in a country, would infringe one or more identifiable patents in that +country that you have reason to believe are valid. + + If, pursuant to or in connection with a single transaction or +arrangement, you convey, or propagate by procuring conveyance of, a +covered work, and grant a patent license to some of the parties +receiving the covered work authorizing them to use, propagate, modify +or convey a specific copy of the covered work, then the patent license +you grant is automatically extended to all recipients of the covered +work and works based on it. + + A patent license is "discriminatory" if it does not include within +the scope of its coverage, prohibits the exercise of, or is +conditioned on the non-exercise of one or more of the rights that are +specifically granted under this License. You may not convey a covered +work if you are a party to an arrangement with a third party that is +in the business of distributing software, under which you make payment +to the third party based on the extent of your activity of conveying +the work, and under which the third party grants, to any of the +parties who would receive the covered work from you, a discriminatory +patent license (a) in connection with copies of the covered work +conveyed by you (or copies made from those copies), or (b) primarily +for and in connection with specific products or compilations that +contain the covered work, unless you entered into that arrangement, +or that patent license was granted, prior to 28 March 2007. + + Nothing in this License shall be construed as excluding or limiting +any implied license or other defenses to infringement that may +otherwise be available to you under applicable patent law. + + 12. No Surrender of Others' Freedom. + + If conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot convey a +covered work so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you may +not convey it at all. For example, if you agree to terms that obligate you +to collect a royalty for further conveying from those to whom you convey +the Program, the only way you could satisfy both those terms and this +License would be to refrain entirely from conveying the Program. + + 13. Use with the GNU Affero General Public License. + + Notwithstanding any other provision of this License, you have +permission to link or combine any covered work with a work licensed +under version 3 of the GNU Affero General Public License into a single +combined work, and to convey the resulting work. The terms of this +License will continue to apply to the part which is the covered work, +but the special requirements of the GNU Affero General Public License, +section 13, concerning interaction through a network will apply to the +combination as such. + + 14. Revised Versions of this License. + + The Free Software Foundation may publish revised and/or new versions of +the GNU General Public License from time to time. Such new versions will +be similar in spirit to the present version, but may differ in detail to +address new problems or concerns. + + Each version is given a distinguishing version number. If the +Program specifies that a certain numbered version of the GNU General +Public License "or any later version" applies to it, you have the +option of following the terms and conditions either of that numbered +version or of any later version published by the Free Software +Foundation. If the Program does not specify a version number of the +GNU General Public License, you may choose any version ever published +by the Free Software Foundation. + + If the Program specifies that a proxy can decide which future +versions of the GNU General Public License can be used, that proxy's +public statement of acceptance of a version permanently authorizes you +to choose that version for the Program. + + Later license versions may give you additional or different +permissions. However, no additional obligations are imposed on any +author or copyright holder as a result of your choosing to follow a +later version. + + 15. Disclaimer of Warranty. + + THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY +APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT +HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY +OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, +THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM +IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF +ALL NECESSARY SERVICING, REPAIR OR CORRECTION. + + 16. Limitation of Liability. + + IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING +WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS +THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY +GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE +USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF +DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD +PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), +EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF +SUCH DAMAGES. + + 17. Interpretation of Sections 15 and 16. + + If the disclaimer of warranty and limitation of liability provided +above cannot be given local legal effect according to their terms, +reviewing courts shall apply local law that most closely approximates +an absolute waiver of all civil liability in connection with the +Program, unless a warranty or assumption of liability accompanies a +copy of the Program in return for a fee. + + END OF TERMS AND CONDITIONS + + How to Apply These Terms to Your New Programs + + If you develop a new program, and you want it to be of the greatest +possible use to the public, the best way to achieve this is to make it +free software which everyone can redistribute and change under these terms. + + To do so, attach the following notices to the program. It is safest +to attach them to the start of each source file to most effectively +state the exclusion of warranty; and each file should have at least +the "copyright" line and a pointer to where the full notice is found. + + + Copyright (C) + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . + +Also add information on how to contact you by electronic and paper mail. + + If the program does terminal interaction, make it output a short +notice like this when it starts in an interactive mode: + + Copyright (C) + This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'. + This is free software, and you are welcome to redistribute it + under certain conditions; type `show c' for details. + +The hypothetical commands `show w' and `show c' should show the appropriate +parts of the General Public License. Of course, your program's commands +might be different; for a GUI interface, you would use an "about box". + + You should also get your employer (if you work as a programmer) or school, +if any, to sign a "copyright disclaimer" for the program, if necessary. +For more information on this, and how to apply and follow the GNU GPL, see +. + + The GNU General Public License does not permit incorporating your program +into proprietary programs. If your program is a subroutine library, you +may consider it more useful to permit linking proprietary applications with +the library. If this is what you want to do, use the GNU Lesser General +Public License instead of this License. But first, please read +. diff --git a/debian/README.Debian b/debian/README.Debian new file mode 100644 index 00000000..ae2da2ef --- /dev/null +++ b/debian/README.Debian @@ -0,0 +1,6 @@ +shadowsocks for Debian +---------------------- + + + + -- Max Lv Sat, 06 Apr 2013 16:59:15 +0800 diff --git a/debian/README.source b/debian/README.source new file mode 100644 index 00000000..50cd37dc --- /dev/null +++ b/debian/README.source @@ -0,0 +1,9 @@ +shadowsocks for Debian +---------------------- + + + + + + diff --git a/debian/changelog b/debian/changelog new file mode 100644 index 00000000..1a755d67 --- /dev/null +++ b/debian/changelog @@ -0,0 +1,5 @@ +shadowsocks (1.0-1) unstable; urgency=low + + * Initial release + + -- Max Lv Sat, 06 Apr 2013 16:59:15 +0800 diff --git a/debian/compat b/debian/compat new file mode 100644 index 00000000..7f8f011e --- /dev/null +++ b/debian/compat @@ -0,0 +1 @@ +7 diff --git a/debian/control b/debian/control new file mode 100644 index 00000000..ea6c0b9e --- /dev/null +++ b/debian/control @@ -0,0 +1,15 @@ +Source: shadowsocks +Section: net +Priority: extra +Maintainer: Max Lv +Build-Depends: debhelper (>= 7.0.50~), autotools-dev, mime-support, gawk +Standards-Version: 3.8.4 +Homepage: http://www.shadowsocks.org +#Vcs-Git: git://git.debian.org/collab-maint/shadowsocks.git +#Vcs-Browser: http://git.debian.org/?p=collab-maint/shadowsocks.git;a=summary + +Package: shadowsocks +Architecture: any +Depends: ${shlibs:Depends}, ${misc:Depends} +Description: A lightweight secured scoks5 proxy. + Shadowsocks-libev is a lightweight secured scoks5 proxy for embedded devices and low end boxes. diff --git a/debian/copyright b/debian/copyright new file mode 100644 index 00000000..b7ed35e2 --- /dev/null +++ b/debian/copyright @@ -0,0 +1,23 @@ +This work was packaged for Debian by: + + Max Lv on Sat, 06 Apr 2013 16:59:15 +0800 + +It was downloaded from: + + https://github.com/madeye/shadowsocks-libev + +Upstream Author(s): + + clowwindy + +Copyright: + + Copyright (C) 2013 Max Lv + +License: + + GPLv3 + +The Debian packaging is: + + Copyright (C) 2013 Max Lv diff --git a/debian/docs b/debian/docs new file mode 100644 index 00000000..b43bf86b --- /dev/null +++ b/debian/docs @@ -0,0 +1 @@ +README.md diff --git a/debian/files b/debian/files new file mode 100644 index 00000000..1ee2010f --- /dev/null +++ b/debian/files @@ -0,0 +1 @@ +shadowsocks_1.0-1_i386.deb net extra diff --git a/debian/patches/debian-changes-1.0-1 b/debian/patches/debian-changes-1.0-1 new file mode 100644 index 00000000..4d06d8e8 --- /dev/null +++ b/debian/patches/debian-changes-1.0-1 @@ -0,0 +1,7045 @@ +Description: Upstream changes introduced in version 1.0-1 + This patch has been created by dpkg-source during the package build. + Here's the last changelog entry, hopefully it gives details on why + those changes were made: + . + shadowsocks (1.0-1) unstable; urgency=low + . + * Initial release + . + The person named in the Author field signed this changelog entry. +Author: Max Lv + +--- +The information above should follow the Patch Tagging Guidelines, please +checkout http://dep.debian.net/deps/dep3/ to learn about the format. Here +are templates for supplementary fields that you might want to add: + +Origin: , +Bug: +Bug-Debian: http://bugs.debian.org/ +Bug-Ubuntu: https://launchpad.net/bugs/ +Forwarded: +Reviewed-By: +Last-Update: + +--- /dev/null ++++ shadowsocks-1.0/pid +@@ -0,0 +1 @@ ++25044 +\ No newline at end of file +--- /dev/null ++++ shadowsocks-1.0/LICENSE +@@ -0,0 +1,674 @@ ++ GNU GENERAL PUBLIC LICENSE ++ Version 3, 29 June 2007 ++ ++ Copyright (C) 2007 Free Software Foundation, Inc. ++ Everyone is permitted to copy and distribute verbatim copies ++ of this license document, but changing it is not allowed. ++ ++ Preamble ++ ++ The GNU General Public License is a free, copyleft license for ++software and other kinds of works. ++ ++ The licenses for most software and other practical works are designed ++to take away your freedom to share and change the works. By contrast, ++the GNU General Public License is intended to guarantee your freedom to ++share and change all versions of a program--to make sure it remains free ++software for all its users. We, the Free Software Foundation, use the ++GNU General Public License for most of our software; it applies also to ++any other work released this way by its authors. You can apply it to ++your programs, too. ++ ++ When we speak of free software, we are referring to freedom, not ++price. Our General Public Licenses are designed to make sure that you ++have the freedom to distribute copies of free software (and charge for ++them if you wish), that you receive source code or can get it if you ++want it, that you can change the software or use pieces of it in new ++free programs, and that you know you can do these things. ++ ++ To protect your rights, we need to prevent others from denying you ++these rights or asking you to surrender the rights. Therefore, you have ++certain responsibilities if you distribute copies of the software, or if ++you modify it: responsibilities to respect the freedom of others. ++ ++ For example, if you distribute copies of such a program, whether ++gratis or for a fee, you must pass on to the recipients the same ++freedoms that you received. You must make sure that they, too, receive ++or can get the source code. And you must show them these terms so they ++know their rights. ++ ++ Developers that use the GNU GPL protect your rights with two steps: ++(1) assert copyright on the software, and (2) offer you this License ++giving you legal permission to copy, distribute and/or modify it. ++ ++ For the developers' and authors' protection, the GPL clearly explains ++that there is no warranty for this free software. For both users' and ++authors' sake, the GPL requires that modified versions be marked as ++changed, so that their problems will not be attributed erroneously to ++authors of previous versions. ++ ++ Some devices are designed to deny users access to install or run ++modified versions of the software inside them, although the manufacturer ++can do so. This is fundamentally incompatible with the aim of ++protecting users' freedom to change the software. The systematic ++pattern of such abuse occurs in the area of products for individuals to ++use, which is precisely where it is most unacceptable. Therefore, we ++have designed this version of the GPL to prohibit the practice for those ++products. If such problems arise substantially in other domains, we ++stand ready to extend this provision to those domains in future versions ++of the GPL, as needed to protect the freedom of users. ++ ++ Finally, every program is threatened constantly by software patents. ++States should not allow patents to restrict development and use of ++software on general-purpose computers, but in those that do, we wish to ++avoid the special danger that patents applied to a free program could ++make it effectively proprietary. To prevent this, the GPL assures that ++patents cannot be used to render the program non-free. ++ ++ The precise terms and conditions for copying, distribution and ++modification follow. ++ ++ TERMS AND CONDITIONS ++ ++ 0. Definitions. ++ ++ "This License" refers to version 3 of the GNU General Public License. ++ ++ "Copyright" also means copyright-like laws that apply to other kinds of ++works, such as semiconductor masks. ++ ++ "The Program" refers to any copyrightable work licensed under this ++License. Each licensee is addressed as "you". "Licensees" and ++"recipients" may be individuals or organizations. ++ ++ To "modify" a work means to copy from or adapt all or part of the work ++in a fashion requiring copyright permission, other than the making of an ++exact copy. The resulting work is called a "modified version" of the ++earlier work or a work "based on" the earlier work. ++ ++ A "covered work" means either the unmodified Program or a work based ++on the Program. ++ ++ To "propagate" a work means to do anything with it that, without ++permission, would make you directly or secondarily liable for ++infringement under applicable copyright law, except executing it on a ++computer or modifying a private copy. Propagation includes copying, ++distribution (with or without modification), making available to the ++public, and in some countries other activities as well. ++ ++ To "convey" a work means any kind of propagation that enables other ++parties to make or receive copies. Mere interaction with a user through ++a computer network, with no transfer of a copy, is not conveying. ++ ++ An interactive user interface displays "Appropriate Legal Notices" ++to the extent that it includes a convenient and prominently visible ++feature that (1) displays an appropriate copyright notice, and (2) ++tells the user that there is no warranty for the work (except to the ++extent that warranties are provided), that licensees may convey the ++work under this License, and how to view a copy of this License. If ++the interface presents a list of user commands or options, such as a ++menu, a prominent item in the list meets this criterion. ++ ++ 1. Source Code. ++ ++ The "source code" for a work means the preferred form of the work ++for making modifications to it. "Object code" means any non-source ++form of a work. ++ ++ A "Standard Interface" means an interface that either is an official ++standard defined by a recognized standards body, or, in the case of ++interfaces specified for a particular programming language, one that ++is widely used among developers working in that language. ++ ++ The "System Libraries" of an executable work include anything, other ++than the work as a whole, that (a) is included in the normal form of ++packaging a Major Component, but which is not part of that Major ++Component, and (b) serves only to enable use of the work with that ++Major Component, or to implement a Standard Interface for which an ++implementation is available to the public in source code form. A ++"Major Component", in this context, means a major essential component ++(kernel, window system, and so on) of the specific operating system ++(if any) on which the executable work runs, or a compiler used to ++produce the work, or an object code interpreter used to run it. ++ ++ The "Corresponding Source" for a work in object code form means all ++the source code needed to generate, install, and (for an executable ++work) run the object code and to modify the work, including scripts to ++control those activities. However, it does not include the work's ++System Libraries, or general-purpose tools or generally available free ++programs which are used unmodified in performing those activities but ++which are not part of the work. For example, Corresponding Source ++includes interface definition files associated with source files for ++the work, and the source code for shared libraries and dynamically ++linked subprograms that the work is specifically designed to require, ++such as by intimate data communication or control flow between those ++subprograms and other parts of the work. ++ ++ The Corresponding Source need not include anything that users ++can regenerate automatically from other parts of the Corresponding ++Source. ++ ++ The Corresponding Source for a work in source code form is that ++same work. ++ ++ 2. Basic Permissions. ++ ++ All rights granted under this License are granted for the term of ++copyright on the Program, and are irrevocable provided the stated ++conditions are met. This License explicitly affirms your unlimited ++permission to run the unmodified Program. The output from running a ++covered work is covered by this License only if the output, given its ++content, constitutes a covered work. This License acknowledges your ++rights of fair use or other equivalent, as provided by copyright law. ++ ++ You may make, run and propagate covered works that you do not ++convey, without conditions so long as your license otherwise remains ++in force. You may convey covered works to others for the sole purpose ++of having them make modifications exclusively for you, or provide you ++with facilities for running those works, provided that you comply with ++the terms of this License in conveying all material for which you do ++not control copyright. Those thus making or running the covered works ++for you must do so exclusively on your behalf, under your direction ++and control, on terms that prohibit them from making any copies of ++your copyrighted material outside their relationship with you. ++ ++ Conveying under any other circumstances is permitted solely under ++the conditions stated below. Sublicensing is not allowed; section 10 ++makes it unnecessary. ++ ++ 3. Protecting Users' Legal Rights From Anti-Circumvention Law. ++ ++ No covered work shall be deemed part of an effective technological ++measure under any applicable law fulfilling obligations under article ++11 of the WIPO copyright treaty adopted on 20 December 1996, or ++similar laws prohibiting or restricting circumvention of such ++measures. ++ ++ When you convey a covered work, you waive any legal power to forbid ++circumvention of technological measures to the extent such circumvention ++is effected by exercising rights under this License with respect to ++the covered work, and you disclaim any intention to limit operation or ++modification of the work as a means of enforcing, against the work's ++users, your or third parties' legal rights to forbid circumvention of ++technological measures. ++ ++ 4. Conveying Verbatim Copies. ++ ++ You may convey verbatim copies of the Program's source code as you ++receive it, in any medium, provided that you conspicuously and ++appropriately publish on each copy an appropriate copyright notice; ++keep intact all notices stating that this License and any ++non-permissive terms added in accord with section 7 apply to the code; ++keep intact all notices of the absence of any warranty; and give all ++recipients a copy of this License along with the Program. ++ ++ You may charge any price or no price for each copy that you convey, ++and you may offer support or warranty protection for a fee. ++ ++ 5. Conveying Modified Source Versions. ++ ++ You may convey a work based on the Program, or the modifications to ++produce it from the Program, in the form of source code under the ++terms of section 4, provided that you also meet all of these conditions: ++ ++ a) The work must carry prominent notices stating that you modified ++ it, and giving a relevant date. ++ ++ b) The work must carry prominent notices stating that it is ++ released under this License and any conditions added under section ++ 7. This requirement modifies the requirement in section 4 to ++ "keep intact all notices". ++ ++ c) You must license the entire work, as a whole, under this ++ License to anyone who comes into possession of a copy. This ++ License will therefore apply, along with any applicable section 7 ++ additional terms, to the whole of the work, and all its parts, ++ regardless of how they are packaged. This License gives no ++ permission to license the work in any other way, but it does not ++ invalidate such permission if you have separately received it. ++ ++ d) If the work has interactive user interfaces, each must display ++ Appropriate Legal Notices; however, if the Program has interactive ++ interfaces that do not display Appropriate Legal Notices, your ++ work need not make them do so. ++ ++ A compilation of a covered work with other separate and independent ++works, which are not by their nature extensions of the covered work, ++and which are not combined with it such as to form a larger program, ++in or on a volume of a storage or distribution medium, is called an ++"aggregate" if the compilation and its resulting copyright are not ++used to limit the access or legal rights of the compilation's users ++beyond what the individual works permit. Inclusion of a covered work ++in an aggregate does not cause this License to apply to the other ++parts of the aggregate. ++ ++ 6. Conveying Non-Source Forms. ++ ++ You may convey a covered work in object code form under the terms ++of sections 4 and 5, provided that you also convey the ++machine-readable Corresponding Source under the terms of this License, ++in one of these ways: ++ ++ a) Convey the object code in, or embodied in, a physical product ++ (including a physical distribution medium), accompanied by the ++ Corresponding Source fixed on a durable physical medium ++ customarily used for software interchange. ++ ++ b) Convey the object code in, or embodied in, a physical product ++ (including a physical distribution medium), accompanied by a ++ written offer, valid for at least three years and valid for as ++ long as you offer spare parts or customer support for that product ++ model, to give anyone who possesses the object code either (1) a ++ copy of the Corresponding Source for all the software in the ++ product that is covered by this License, on a durable physical ++ medium customarily used for software interchange, for a price no ++ more than your reasonable cost of physically performing this ++ conveying of source, or (2) access to copy the ++ Corresponding Source from a network server at no charge. ++ ++ c) Convey individual copies of the object code with a copy of the ++ written offer to provide the Corresponding Source. This ++ alternative is allowed only occasionally and noncommercially, and ++ only if you received the object code with such an offer, in accord ++ with subsection 6b. ++ ++ d) Convey the object code by offering access from a designated ++ place (gratis or for a charge), and offer equivalent access to the ++ Corresponding Source in the same way through the same place at no ++ further charge. You need not require recipients to copy the ++ Corresponding Source along with the object code. If the place to ++ copy the object code is a network server, the Corresponding Source ++ may be on a different server (operated by you or a third party) ++ that supports equivalent copying facilities, provided you maintain ++ clear directions next to the object code saying where to find the ++ Corresponding Source. Regardless of what server hosts the ++ Corresponding Source, you remain obligated to ensure that it is ++ available for as long as needed to satisfy these requirements. ++ ++ e) Convey the object code using peer-to-peer transmission, provided ++ you inform other peers where the object code and Corresponding ++ Source of the work are being offered to the general public at no ++ charge under subsection 6d. ++ ++ A separable portion of the object code, whose source code is excluded ++from the Corresponding Source as a System Library, need not be ++included in conveying the object code work. ++ ++ A "User Product" is either (1) a "consumer product", which means any ++tangible personal property which is normally used for personal, family, ++or household purposes, or (2) anything designed or sold for incorporation ++into a dwelling. In determining whether a product is a consumer product, ++doubtful cases shall be resolved in favor of coverage. For a particular ++product received by a particular user, "normally used" refers to a ++typical or common use of that class of product, regardless of the status ++of the particular user or of the way in which the particular user ++actually uses, or expects or is expected to use, the product. A product ++is a consumer product regardless of whether the product has substantial ++commercial, industrial or non-consumer uses, unless such uses represent ++the only significant mode of use of the product. ++ ++ "Installation Information" for a User Product means any methods, ++procedures, authorization keys, or other information required to install ++and execute modified versions of a covered work in that User Product from ++a modified version of its Corresponding Source. The information must ++suffice to ensure that the continued functioning of the modified object ++code is in no case prevented or interfered with solely because ++modification has been made. ++ ++ If you convey an object code work under this section in, or with, or ++specifically for use in, a User Product, and the conveying occurs as ++part of a transaction in which the right of possession and use of the ++User Product is transferred to the recipient in perpetuity or for a ++fixed term (regardless of how the transaction is characterized), the ++Corresponding Source conveyed under this section must be accompanied ++by the Installation Information. But this requirement does not apply ++if neither you nor any third party retains the ability to install ++modified object code on the User Product (for example, the work has ++been installed in ROM). ++ ++ The requirement to provide Installation Information does not include a ++requirement to continue to provide support service, warranty, or updates ++for a work that has been modified or installed by the recipient, or for ++the User Product in which it has been modified or installed. Access to a ++network may be denied when the modification itself materially and ++adversely affects the operation of the network or violates the rules and ++protocols for communication across the network. ++ ++ Corresponding Source conveyed, and Installation Information provided, ++in accord with this section must be in a format that is publicly ++documented (and with an implementation available to the public in ++source code form), and must require no special password or key for ++unpacking, reading or copying. ++ ++ 7. Additional Terms. ++ ++ "Additional permissions" are terms that supplement the terms of this ++License by making exceptions from one or more of its conditions. ++Additional permissions that are applicable to the entire Program shall ++be treated as though they were included in this License, to the extent ++that they are valid under applicable law. If additional permissions ++apply only to part of the Program, that part may be used separately ++under those permissions, but the entire Program remains governed by ++this License without regard to the additional permissions. ++ ++ When you convey a copy of a covered work, you may at your option ++remove any additional permissions from that copy, or from any part of ++it. (Additional permissions may be written to require their own ++removal in certain cases when you modify the work.) You may place ++additional permissions on material, added by you to a covered work, ++for which you have or can give appropriate copyright permission. ++ ++ Notwithstanding any other provision of this License, for material you ++add to a covered work, you may (if authorized by the copyright holders of ++that material) supplement the terms of this License with terms: ++ ++ a) Disclaiming warranty or limiting liability differently from the ++ terms of sections 15 and 16 of this License; or ++ ++ b) Requiring preservation of specified reasonable legal notices or ++ author attributions in that material or in the Appropriate Legal ++ Notices displayed by works containing it; or ++ ++ c) Prohibiting misrepresentation of the origin of that material, or ++ requiring that modified versions of such material be marked in ++ reasonable ways as different from the original version; or ++ ++ d) Limiting the use for publicity purposes of names of licensors or ++ authors of the material; or ++ ++ e) Declining to grant rights under trademark law for use of some ++ trade names, trademarks, or service marks; or ++ ++ f) Requiring indemnification of licensors and authors of that ++ material by anyone who conveys the material (or modified versions of ++ it) with contractual assumptions of liability to the recipient, for ++ any liability that these contractual assumptions directly impose on ++ those licensors and authors. ++ ++ All other non-permissive additional terms are considered "further ++restrictions" within the meaning of section 10. If the Program as you ++received it, or any part of it, contains a notice stating that it is ++governed by this License along with a term that is a further ++restriction, you may remove that term. If a license document contains ++a further restriction but permits relicensing or conveying under this ++License, you may add to a covered work material governed by the terms ++of that license document, provided that the further restriction does ++not survive such relicensing or conveying. ++ ++ If you add terms to a covered work in accord with this section, you ++must place, in the relevant source files, a statement of the ++additional terms that apply to those files, or a notice indicating ++where to find the applicable terms. ++ ++ Additional terms, permissive or non-permissive, may be stated in the ++form of a separately written license, or stated as exceptions; ++the above requirements apply either way. ++ ++ 8. Termination. ++ ++ You may not propagate or modify a covered work except as expressly ++provided under this License. Any attempt otherwise to propagate or ++modify it is void, and will automatically terminate your rights under ++this License (including any patent licenses granted under the third ++paragraph of section 11). ++ ++ However, if you cease all violation of this License, then your ++license from a particular copyright holder is reinstated (a) ++provisionally, unless and until the copyright holder explicitly and ++finally terminates your license, and (b) permanently, if the copyright ++holder fails to notify you of the violation by some reasonable means ++prior to 60 days after the cessation. ++ ++ Moreover, your license from a particular copyright holder is ++reinstated permanently if the copyright holder notifies you of the ++violation by some reasonable means, this is the first time you have ++received notice of violation of this License (for any work) from that ++copyright holder, and you cure the violation prior to 30 days after ++your receipt of the notice. ++ ++ Termination of your rights under this section does not terminate the ++licenses of parties who have received copies or rights from you under ++this License. If your rights have been terminated and not permanently ++reinstated, you do not qualify to receive new licenses for the same ++material under section 10. ++ ++ 9. Acceptance Not Required for Having Copies. ++ ++ You are not required to accept this License in order to receive or ++run a copy of the Program. Ancillary propagation of a covered work ++occurring solely as a consequence of using peer-to-peer transmission ++to receive a copy likewise does not require acceptance. However, ++nothing other than this License grants you permission to propagate or ++modify any covered work. These actions infringe copyright if you do ++not accept this License. Therefore, by modifying or propagating a ++covered work, you indicate your acceptance of this License to do so. ++ ++ 10. Automatic Licensing of Downstream Recipients. ++ ++ Each time you convey a covered work, the recipient automatically ++receives a license from the original licensors, to run, modify and ++propagate that work, subject to this License. You are not responsible ++for enforcing compliance by third parties with this License. ++ ++ An "entity transaction" is a transaction transferring control of an ++organization, or substantially all assets of one, or subdividing an ++organization, or merging organizations. If propagation of a covered ++work results from an entity transaction, each party to that ++transaction who receives a copy of the work also receives whatever ++licenses to the work the party's predecessor in interest had or could ++give under the previous paragraph, plus a right to possession of the ++Corresponding Source of the work from the predecessor in interest, if ++the predecessor has it or can get it with reasonable efforts. ++ ++ You may not impose any further restrictions on the exercise of the ++rights granted or affirmed under this License. For example, you may ++not impose a license fee, royalty, or other charge for exercise of ++rights granted under this License, and you may not initiate litigation ++(including a cross-claim or counterclaim in a lawsuit) alleging that ++any patent claim is infringed by making, using, selling, offering for ++sale, or importing the Program or any portion of it. ++ ++ 11. Patents. ++ ++ A "contributor" is a copyright holder who authorizes use under this ++License of the Program or a work on which the Program is based. The ++work thus licensed is called the contributor's "contributor version". ++ ++ A contributor's "essential patent claims" are all patent claims ++owned or controlled by the contributor, whether already acquired or ++hereafter acquired, that would be infringed by some manner, permitted ++by this License, of making, using, or selling its contributor version, ++but do not include claims that would be infringed only as a ++consequence of further modification of the contributor version. For ++purposes of this definition, "control" includes the right to grant ++patent sublicenses in a manner consistent with the requirements of ++this License. ++ ++ Each contributor grants you a non-exclusive, worldwide, royalty-free ++patent license under the contributor's essential patent claims, to ++make, use, sell, offer for sale, import and otherwise run, modify and ++propagate the contents of its contributor version. ++ ++ In the following three paragraphs, a "patent license" is any express ++agreement or commitment, however denominated, not to enforce a patent ++(such as an express permission to practice a patent or covenant not to ++sue for patent infringement). To "grant" such a patent license to a ++party means to make such an agreement or commitment not to enforce a ++patent against the party. ++ ++ If you convey a covered work, knowingly relying on a patent license, ++and the Corresponding Source of the work is not available for anyone ++to copy, free of charge and under the terms of this License, through a ++publicly available network server or other readily accessible means, ++then you must either (1) cause the Corresponding Source to be so ++available, or (2) arrange to deprive yourself of the benefit of the ++patent license for this particular work, or (3) arrange, in a manner ++consistent with the requirements of this License, to extend the patent ++license to downstream recipients. "Knowingly relying" means you have ++actual knowledge that, but for the patent license, your conveying the ++covered work in a country, or your recipient's use of the covered work ++in a country, would infringe one or more identifiable patents in that ++country that you have reason to believe are valid. ++ ++ If, pursuant to or in connection with a single transaction or ++arrangement, you convey, or propagate by procuring conveyance of, a ++covered work, and grant a patent license to some of the parties ++receiving the covered work authorizing them to use, propagate, modify ++or convey a specific copy of the covered work, then the patent license ++you grant is automatically extended to all recipients of the covered ++work and works based on it. ++ ++ A patent license is "discriminatory" if it does not include within ++the scope of its coverage, prohibits the exercise of, or is ++conditioned on the non-exercise of one or more of the rights that are ++specifically granted under this License. You may not convey a covered ++work if you are a party to an arrangement with a third party that is ++in the business of distributing software, under which you make payment ++to the third party based on the extent of your activity of conveying ++the work, and under which the third party grants, to any of the ++parties who would receive the covered work from you, a discriminatory ++patent license (a) in connection with copies of the covered work ++conveyed by you (or copies made from those copies), or (b) primarily ++for and in connection with specific products or compilations that ++contain the covered work, unless you entered into that arrangement, ++or that patent license was granted, prior to 28 March 2007. ++ ++ Nothing in this License shall be construed as excluding or limiting ++any implied license or other defenses to infringement that may ++otherwise be available to you under applicable patent law. ++ ++ 12. No Surrender of Others' Freedom. ++ ++ If conditions are imposed on you (whether by court order, agreement or ++otherwise) that contradict the conditions of this License, they do not ++excuse you from the conditions of this License. If you cannot convey a ++covered work so as to satisfy simultaneously your obligations under this ++License and any other pertinent obligations, then as a consequence you may ++not convey it at all. For example, if you agree to terms that obligate you ++to collect a royalty for further conveying from those to whom you convey ++the Program, the only way you could satisfy both those terms and this ++License would be to refrain entirely from conveying the Program. ++ ++ 13. Use with the GNU Affero General Public License. ++ ++ Notwithstanding any other provision of this License, you have ++permission to link or combine any covered work with a work licensed ++under version 3 of the GNU Affero General Public License into a single ++combined work, and to convey the resulting work. The terms of this ++License will continue to apply to the part which is the covered work, ++but the special requirements of the GNU Affero General Public License, ++section 13, concerning interaction through a network will apply to the ++combination as such. ++ ++ 14. Revised Versions of this License. ++ ++ The Free Software Foundation may publish revised and/or new versions of ++the GNU General Public License from time to time. Such new versions will ++be similar in spirit to the present version, but may differ in detail to ++address new problems or concerns. ++ ++ Each version is given a distinguishing version number. If the ++Program specifies that a certain numbered version of the GNU General ++Public License "or any later version" applies to it, you have the ++option of following the terms and conditions either of that numbered ++version or of any later version published by the Free Software ++Foundation. If the Program does not specify a version number of the ++GNU General Public License, you may choose any version ever published ++by the Free Software Foundation. ++ ++ If the Program specifies that a proxy can decide which future ++versions of the GNU General Public License can be used, that proxy's ++public statement of acceptance of a version permanently authorizes you ++to choose that version for the Program. ++ ++ Later license versions may give you additional or different ++permissions. However, no additional obligations are imposed on any ++author or copyright holder as a result of your choosing to follow a ++later version. ++ ++ 15. Disclaimer of Warranty. ++ ++ THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY ++APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT ++HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY ++OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, ++THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR ++PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM ++IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ++ALL NECESSARY SERVICING, REPAIR OR CORRECTION. ++ ++ 16. Limitation of Liability. ++ ++ IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING ++WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS ++THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY ++GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE ++USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF ++DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD ++PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), ++EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF ++SUCH DAMAGES. ++ ++ 17. Interpretation of Sections 15 and 16. ++ ++ If the disclaimer of warranty and limitation of liability provided ++above cannot be given local legal effect according to their terms, ++reviewing courts shall apply local law that most closely approximates ++an absolute waiver of all civil liability in connection with the ++Program, unless a warranty or assumption of liability accompanies a ++copy of the Program in return for a fee. ++ ++ END OF TERMS AND CONDITIONS ++ ++ How to Apply These Terms to Your New Programs ++ ++ If you develop a new program, and you want it to be of the greatest ++possible use to the public, the best way to achieve this is to make it ++free software which everyone can redistribute and change under these terms. ++ ++ To do so, attach the following notices to the program. It is safest ++to attach them to the start of each source file to most effectively ++state the exclusion of warranty; and each file should have at least ++the "copyright" line and a pointer to where the full notice is found. ++ ++ ++ Copyright (C) ++ ++ This program is free software: you can redistribute it and/or modify ++ it under the terms of the GNU General Public License as published by ++ the Free Software Foundation, either version 3 of the License, or ++ (at your option) any later version. ++ ++ This program is distributed in the hope that it will be useful, ++ but WITHOUT ANY WARRANTY; without even the implied warranty of ++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ GNU General Public License for more details. ++ ++ You should have received a copy of the GNU General Public License ++ along with this program. If not, see . ++ ++Also add information on how to contact you by electronic and paper mail. ++ ++ If the program does terminal interaction, make it output a short ++notice like this when it starts in an interactive mode: ++ ++ Copyright (C) ++ This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'. ++ This is free software, and you are welcome to redistribute it ++ under certain conditions; type `show c' for details. ++ ++The hypothetical commands `show w' and `show c' should show the appropriate ++parts of the General Public License. Of course, your program's commands ++might be different; for a GUI interface, you would use an "about box". ++ ++ You should also get your employer (if you work as a programmer) or school, ++if any, to sign a "copyright disclaimer" for the program, if necessary. ++For more information on this, and how to apply and follow the GNU GPL, see ++. ++ ++ The GNU General Public License does not permit incorporating your program ++into proprietary programs. If your program is a subroutine library, you ++may consider it more useful to permit linking proprietary applications with ++the library. If this is what you want to do, use the GNU Lesser General ++Public License instead of this License. But first, please read ++. +--- shadowsocks-1.0.orig/COPYING ++++ shadowsocks-1.0/COPYING +@@ -1,674 +1,12 @@ +- GNU GENERAL PUBLIC LICENSE +- Version 3, 29 June 2007 ++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. + +- 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 +-. ++You should have received a copy of the GNU General Public License ++along with this program. If not, see . +--- shadowsocks-1.0.orig/libasyncns/Makefile.am ++++ shadowsocks-1.0/libasyncns/Makefile.am +@@ -21,6 +21,7 @@ AM_CFLAGS=-D__EXTENSIONS__ $(PTHREAD_CFL + lib_LTLIBRARIES=libasyncns.la + libasyncns_la_CC=$(PTHREAD_CC) + libasyncns_la_SOURCES=asyncns.c asyncns.h ++libasyncns_la_LDFLAGS= -static + libasyncns_la_LIBADD=$(PTHREAD_LIBS) + + include_HEADERS=asyncns.h +--- /dev/null ++++ shadowsocks-1.0/libev/ev.3 +@@ -0,0 +1,5626 @@ ++.\" Automatically generated by Pod::Man 2.22 (Pod::Simple 3.07) ++.\" ++.\" Standard preamble: ++.\" ======================================================================== ++.de Sp \" Vertical space (when we can't use .PP) ++.if t .sp .5v ++.if n .sp ++.. ++.de Vb \" Begin verbatim text ++.ft CW ++.nf ++.ne \\$1 ++.. ++.de Ve \" End verbatim text ++.ft R ++.fi ++.. ++.\" Set up some character translations and predefined strings. \*(-- will ++.\" give an unbreakable dash, \*(PI will give pi, \*(L" will give a left ++.\" double quote, and \*(R" will give a right double quote. \*(C+ will ++.\" give a nicer C++. Capital omega is used to do unbreakable dashes and ++.\" therefore won't be available. \*(C` and \*(C' expand to `' in nroff, ++.\" nothing in troff, for use with C<>. ++.tr \(*W- ++.ds C+ C\v'-.1v'\h'-1p'\s-2+\h'-1p'+\s0\v'.1v'\h'-1p' ++.ie n \{\ ++. ds -- \(*W- ++. ds PI pi ++. if (\n(.H=4u)&(1m=24u) .ds -- \(*W\h'-12u'\(*W\h'-12u'-\" diablo 10 pitch ++. if (\n(.H=4u)&(1m=20u) .ds -- \(*W\h'-12u'\(*W\h'-8u'-\" diablo 12 pitch ++. ds L" "" ++. ds R" "" ++. ds C` "" ++. ds C' "" ++'br\} ++.el\{\ ++. ds -- \|\(em\| ++. ds PI \(*p ++. ds L" `` ++. ds R" '' ++'br\} ++.\" ++.\" Escape single quotes in literal strings from groff's Unicode transform. ++.ie \n(.g .ds Aq \(aq ++.el .ds Aq ' ++.\" ++.\" If the F register is turned on, we'll generate index entries on stderr for ++.\" titles (.TH), headers (.SH), subsections (.SS), items (.Ip), and index ++.\" entries marked with X<> in POD. Of course, you'll have to process the ++.\" output yourself in some meaningful fashion. ++.ie \nF \{\ ++. de IX ++. tm Index:\\$1\t\\n%\t"\\$2" ++.. ++. nr % 0 ++. rr F ++.\} ++.el \{\ ++. de IX ++.. ++.\} ++.\" ++.\" Accent mark definitions (@(#)ms.acc 1.5 88/02/08 SMI; from UCB 4.2). ++.\" Fear. Run. Save yourself. No user-serviceable parts. ++. \" fudge factors for nroff and troff ++.if n \{\ ++. ds #H 0 ++. ds #V .8m ++. ds #F .3m ++. ds #[ \f1 ++. ds #] \fP ++.\} ++.if t \{\ ++. ds #H ((1u-(\\\\n(.fu%2u))*.13m) ++. ds #V .6m ++. ds #F 0 ++. ds #[ \& ++. ds #] \& ++.\} ++. \" simple accents for nroff and troff ++.if n \{\ ++. ds ' \& ++. ds ` \& ++. ds ^ \& ++. ds , \& ++. ds ~ ~ ++. ds / ++.\} ++.if t \{\ ++. ds ' \\k:\h'-(\\n(.wu*8/10-\*(#H)'\'\h"|\\n:u" ++. ds ` \\k:\h'-(\\n(.wu*8/10-\*(#H)'\`\h'|\\n:u' ++. ds ^ \\k:\h'-(\\n(.wu*10/11-\*(#H)'^\h'|\\n:u' ++. ds , \\k:\h'-(\\n(.wu*8/10)',\h'|\\n:u' ++. ds ~ \\k:\h'-(\\n(.wu-\*(#H-.1m)'~\h'|\\n:u' ++. ds / \\k:\h'-(\\n(.wu*8/10-\*(#H)'\z\(sl\h'|\\n:u' ++.\} ++. \" troff and (daisy-wheel) nroff accents ++.ds : \\k:\h'-(\\n(.wu*8/10-\*(#H+.1m+\*(#F)'\v'-\*(#V'\z.\h'.2m+\*(#F'.\h'|\\n:u'\v'\*(#V' ++.ds 8 \h'\*(#H'\(*b\h'-\*(#H' ++.ds o \\k:\h'-(\\n(.wu+\w'\(de'u-\*(#H)/2u'\v'-.3n'\*(#[\z\(de\v'.3n'\h'|\\n:u'\*(#] ++.ds d- \h'\*(#H'\(pd\h'-\w'~'u'\v'-.25m'\f2\(hy\fP\v'.25m'\h'-\*(#H' ++.ds D- D\\k:\h'-\w'D'u'\v'-.11m'\z\(hy\v'.11m'\h'|\\n:u' ++.ds th \*(#[\v'.3m'\s+1I\s-1\v'-.3m'\h'-(\w'I'u*2/3)'\s-1o\s+1\*(#] ++.ds Th \*(#[\s+2I\s-2\h'-\w'I'u*3/5'\v'-.3m'o\v'.3m'\*(#] ++.ds ae a\h'-(\w'a'u*4/10)'e ++.ds Ae A\h'-(\w'A'u*4/10)'E ++. \" corrections for vroff ++.if v .ds ~ \\k:\h'-(\\n(.wu*9/10-\*(#H)'\s-2\u~\d\s+2\h'|\\n:u' ++.if v .ds ^ \\k:\h'-(\\n(.wu*10/11-\*(#H)'\v'-.4m'^\v'.4m'\h'|\\n:u' ++. \" for low resolution devices (crt and lpr) ++.if \n(.H>23 .if \n(.V>19 \ ++\{\ ++. ds : e ++. ds 8 ss ++. ds o a ++. ds d- d\h'-1'\(ga ++. ds D- D\h'-1'\(hy ++. ds th \o'bp' ++. ds Th \o'LP' ++. ds ae ae ++. ds Ae AE ++.\} ++.rm #[ #] #H #V #F C ++.\" ======================================================================== ++.\" ++.IX Title "LIBEV 3" ++.TH LIBEV 3 "2013-04-02" "libev-0.9" "libev - high performance full featured event loop" ++.\" For nroff, turn off justification. Always turn off hyphenation; it makes ++.\" way too many mistakes in technical documents. ++.if n .ad l ++.nh ++.SH "NAME" ++libev \- a high performance full\-featured event loop written in C ++.SH "SYNOPSIS" ++.IX Header "SYNOPSIS" ++.Vb 1 ++\& #include ++.Ve ++.SS "\s-1EXAMPLE\s0 \s-1PROGRAM\s0" ++.IX Subsection "EXAMPLE PROGRAM" ++.Vb 2 ++\& // a single header file is required ++\& #include ++\& ++\& #include // for puts ++\& ++\& // every watcher type has its own typedef\*(Aqd struct ++\& // with the name ev_TYPE ++\& ev_io stdin_watcher; ++\& ev_timer timeout_watcher; ++\& ++\& // all watcher callbacks have a similar signature ++\& // this callback is called when data is readable on stdin ++\& static void ++\& stdin_cb (EV_P_ ev_io *w, int revents) ++\& { ++\& puts ("stdin ready"); ++\& // for one\-shot events, one must manually stop the watcher ++\& // with its corresponding stop function. ++\& ev_io_stop (EV_A_ w); ++\& ++\& // this causes all nested ev_run\*(Aqs to stop iterating ++\& ev_break (EV_A_ EVBREAK_ALL); ++\& } ++\& ++\& // another callback, this time for a time\-out ++\& static void ++\& timeout_cb (EV_P_ ev_timer *w, int revents) ++\& { ++\& puts ("timeout"); ++\& // this causes the innermost ev_run to stop iterating ++\& ev_break (EV_A_ EVBREAK_ONE); ++\& } ++\& ++\& int ++\& main (void) ++\& { ++\& // use the default event loop unless you have special needs ++\& struct ev_loop *loop = EV_DEFAULT; ++\& ++\& // initialise an io watcher, then start it ++\& // this one will watch for stdin to become readable ++\& ev_io_init (&stdin_watcher, stdin_cb, /*STDIN_FILENO*/ 0, EV_READ); ++\& ev_io_start (loop, &stdin_watcher); ++\& ++\& // initialise a timer watcher, then start it ++\& // simple non\-repeating 5.5 second timeout ++\& ev_timer_init (&timeout_watcher, timeout_cb, 5.5, 0.); ++\& ev_timer_start (loop, &timeout_watcher); ++\& ++\& // now wait for events to arrive ++\& ev_run (loop, 0); ++\& ++\& // break was called, so exit ++\& return 0; ++\& } ++.Ve ++.SH "ABOUT THIS DOCUMENT" ++.IX Header "ABOUT THIS DOCUMENT" ++This document documents the libev software package. ++.PP ++The newest version of this document is also available as an html-formatted ++web page you might find easier to navigate when reading it for the first ++time: . ++.PP ++While this document tries to be as complete as possible in documenting ++libev, its usage and the rationale behind its design, it is not a tutorial ++on event-based programming, nor will it introduce event-based programming ++with libev. ++.PP ++Familiarity with event based programming techniques in general is assumed ++throughout this document. ++.SH "WHAT TO READ WHEN IN A HURRY" ++.IX Header "WHAT TO READ WHEN IN A HURRY" ++This manual tries to be very detailed, but unfortunately, this also makes ++it very long. If you just want to know the basics of libev, I suggest ++reading \*(L"\s-1ANATOMY\s0 \s-1OF\s0 A \s-1WATCHER\s0\*(R", then the \*(L"\s-1EXAMPLE\s0 \s-1PROGRAM\s0\*(R" above and ++look up the missing functions in \*(L"\s-1GLOBAL\s0 \s-1FUNCTIONS\s0\*(R" and the \f(CW\*(C`ev_io\*(C'\fR and ++\&\f(CW\*(C`ev_timer\*(C'\fR sections in \*(L"\s-1WATCHER\s0 \s-1TYPES\s0\*(R". ++.SH "ABOUT LIBEV" ++.IX Header "ABOUT LIBEV" ++Libev is an event loop: you register interest in certain events (such as a ++file descriptor being readable or a timeout occurring), and it will manage ++these event sources and provide your program with events. ++.PP ++To do this, it must take more or less complete control over your process ++(or thread) by executing the \fIevent loop\fR handler, and will then ++communicate events via a callback mechanism. ++.PP ++You register interest in certain events by registering so-called \fIevent ++watchers\fR, which are relatively small C structures you initialise with the ++details of the event, and then hand it over to libev by \fIstarting\fR the ++watcher. ++.SS "\s-1FEATURES\s0" ++.IX Subsection "FEATURES" ++Libev supports \f(CW\*(C`select\*(C'\fR, \f(CW\*(C`poll\*(C'\fR, the Linux-specific \f(CW\*(C`epoll\*(C'\fR, the ++BSD-specific \f(CW\*(C`kqueue\*(C'\fR and the Solaris-specific event port mechanisms ++for file descriptor events (\f(CW\*(C`ev_io\*(C'\fR), the Linux \f(CW\*(C`inotify\*(C'\fR interface ++(for \f(CW\*(C`ev_stat\*(C'\fR), Linux eventfd/signalfd (for faster and cleaner ++inter-thread wakeup (\f(CW\*(C`ev_async\*(C'\fR)/signal handling (\f(CW\*(C`ev_signal\*(C'\fR)) relative ++timers (\f(CW\*(C`ev_timer\*(C'\fR), absolute timers with customised rescheduling ++(\f(CW\*(C`ev_periodic\*(C'\fR), synchronous signals (\f(CW\*(C`ev_signal\*(C'\fR), process status ++change events (\f(CW\*(C`ev_child\*(C'\fR), and event watchers dealing with the event ++loop mechanism itself (\f(CW\*(C`ev_idle\*(C'\fR, \f(CW\*(C`ev_embed\*(C'\fR, \f(CW\*(C`ev_prepare\*(C'\fR and ++\&\f(CW\*(C`ev_check\*(C'\fR watchers) as well as file watchers (\f(CW\*(C`ev_stat\*(C'\fR) and even ++limited support for fork events (\f(CW\*(C`ev_fork\*(C'\fR). ++.PP ++It also is quite fast (see this ++ comparing it to libevent ++for example). ++.SS "\s-1CONVENTIONS\s0" ++.IX Subsection "CONVENTIONS" ++Libev is very configurable. In this manual the default (and most common) ++configuration will be described, which supports multiple event loops. For ++more info about various configuration options please have a look at ++\&\fB\s-1EMBED\s0\fR section in this manual. If libev was configured without support ++for multiple event loops, then all functions taking an initial argument of ++name \f(CW\*(C`loop\*(C'\fR (which is always of type \f(CW\*(C`struct ev_loop *\*(C'\fR) will not have ++this argument. ++.SS "\s-1TIME\s0 \s-1REPRESENTATION\s0" ++.IX Subsection "TIME REPRESENTATION" ++Libev represents time as a single floating point number, representing ++the (fractional) number of seconds since the (\s-1POSIX\s0) epoch (in practice ++somewhere near the beginning of 1970, details are complicated, don't ++ask). This type is called \f(CW\*(C`ev_tstamp\*(C'\fR, which is what you should use ++too. It usually aliases to the \f(CW\*(C`double\*(C'\fR type in C. When you need to do ++any calculations on it, you should treat it as some floating point value. ++.PP ++Unlike the name component \f(CW\*(C`stamp\*(C'\fR might indicate, it is also used for ++time differences (e.g. delays) throughout libev. ++.SH "ERROR HANDLING" ++.IX Header "ERROR HANDLING" ++Libev knows three classes of errors: operating system errors, usage errors ++and internal errors (bugs). ++.PP ++When libev catches an operating system error it cannot handle (for example ++a system call indicating a condition libev cannot fix), it calls the callback ++set via \f(CW\*(C`ev_set_syserr_cb\*(C'\fR, which is supposed to fix the problem or ++abort. The default is to print a diagnostic message and to call \f(CW\*(C`abort ++()\*(C'\fR. ++.PP ++When libev detects a usage error such as a negative timer interval, then ++it will print a diagnostic message and abort (via the \f(CW\*(C`assert\*(C'\fR mechanism, ++so \f(CW\*(C`NDEBUG\*(C'\fR will disable this checking): these are programming errors in ++the libev caller and need to be fixed there. ++.PP ++Libev also has a few internal error-checking \f(CW\*(C`assert\*(C'\fRions, and also has ++extensive consistency checking code. These do not trigger under normal ++circumstances, as they indicate either a bug in libev or worse. ++.SH "GLOBAL FUNCTIONS" ++.IX Header "GLOBAL FUNCTIONS" ++These functions can be called anytime, even before initialising the ++library in any way. ++.IP "ev_tstamp ev_time ()" 4 ++.IX Item "ev_tstamp ev_time ()" ++Returns the current time as libev would use it. Please note that the ++\&\f(CW\*(C`ev_now\*(C'\fR function is usually faster and also often returns the timestamp ++you actually want to know. Also interesting is the combination of ++\&\f(CW\*(C`ev_now_update\*(C'\fR and \f(CW\*(C`ev_now\*(C'\fR. ++.IP "ev_sleep (ev_tstamp interval)" 4 ++.IX Item "ev_sleep (ev_tstamp interval)" ++Sleep for the given interval: The current thread will be blocked ++until either it is interrupted or the given time interval has ++passed (approximately \- it might return a bit earlier even if not ++interrupted). Returns immediately if \f(CW\*(C`interval <= 0\*(C'\fR. ++.Sp ++Basically this is a sub-second-resolution \f(CW\*(C`sleep ()\*(C'\fR. ++.Sp ++The range of the \f(CW\*(C`interval\*(C'\fR is limited \- libev only guarantees to work ++with sleep times of up to one day (\f(CW\*(C`interval <= 86400\*(C'\fR). ++.IP "int ev_version_major ()" 4 ++.IX Item "int ev_version_major ()" ++.PD 0 ++.IP "int ev_version_minor ()" 4 ++.IX Item "int ev_version_minor ()" ++.PD ++You can find out the major and minor \s-1ABI\s0 version numbers of the library ++you linked against by calling the functions \f(CW\*(C`ev_version_major\*(C'\fR and ++\&\f(CW\*(C`ev_version_minor\*(C'\fR. If you want, you can compare against the global ++symbols \f(CW\*(C`EV_VERSION_MAJOR\*(C'\fR and \f(CW\*(C`EV_VERSION_MINOR\*(C'\fR, which specify the ++version of the library your program was compiled against. ++.Sp ++These version numbers refer to the \s-1ABI\s0 version of the library, not the ++release version. ++.Sp ++Usually, it's a good idea to terminate if the major versions mismatch, ++as this indicates an incompatible change. Minor versions are usually ++compatible to older versions, so a larger minor version alone is usually ++not a problem. ++.Sp ++Example: Make sure we haven't accidentally been linked against the wrong ++version (note, however, that this will not detect other \s-1ABI\s0 mismatches, ++such as \s-1LFS\s0 or reentrancy). ++.Sp ++.Vb 3 ++\& assert (("libev version mismatch", ++\& ev_version_major () == EV_VERSION_MAJOR ++\& && ev_version_minor () >= EV_VERSION_MINOR)); ++.Ve ++.IP "unsigned int ev_supported_backends ()" 4 ++.IX Item "unsigned int ev_supported_backends ()" ++Return the set of all backends (i.e. their corresponding \f(CW\*(C`EV_BACKEND_*\*(C'\fR ++value) compiled into this binary of libev (independent of their ++availability on the system you are running on). See \f(CW\*(C`ev_default_loop\*(C'\fR for ++a description of the set values. ++.Sp ++Example: make sure we have the epoll method, because yeah this is cool and ++a must have and can we have a torrent of it please!!!11 ++.Sp ++.Vb 2 ++\& assert (("sorry, no epoll, no sex", ++\& ev_supported_backends () & EVBACKEND_EPOLL)); ++.Ve ++.IP "unsigned int ev_recommended_backends ()" 4 ++.IX Item "unsigned int ev_recommended_backends ()" ++Return the set of all backends compiled into this binary of libev and ++also recommended for this platform, meaning it will work for most file ++descriptor types. This set is often smaller than the one returned by ++\&\f(CW\*(C`ev_supported_backends\*(C'\fR, as for example kqueue is broken on most BSDs ++and will not be auto-detected unless you explicitly request it (assuming ++you know what you are doing). This is the set of backends that libev will ++probe for if you specify no backends explicitly. ++.IP "unsigned int ev_embeddable_backends ()" 4 ++.IX Item "unsigned int ev_embeddable_backends ()" ++Returns the set of backends that are embeddable in other event loops. This ++value is platform-specific but can include backends not available on the ++current system. To find which embeddable backends might be supported on ++the current system, you would need to look at \f(CW\*(C`ev_embeddable_backends () ++& ev_supported_backends ()\*(C'\fR, likewise for recommended ones. ++.Sp ++See the description of \f(CW\*(C`ev_embed\*(C'\fR watchers for more info. ++.IP "ev_set_allocator (void *(*cb)(void *ptr, long size) throw ())" 4 ++.IX Item "ev_set_allocator (void *(*cb)(void *ptr, long size) throw ())" ++Sets the allocation function to use (the prototype is similar \- the ++semantics are identical to the \f(CW\*(C`realloc\*(C'\fR C89/SuS/POSIX function). It is ++used to allocate and free memory (no surprises here). If it returns zero ++when memory needs to be allocated (\f(CW\*(C`size != 0\*(C'\fR), the library might abort ++or take some potentially destructive action. ++.Sp ++Since some systems (at least OpenBSD and Darwin) fail to implement ++correct \f(CW\*(C`realloc\*(C'\fR semantics, libev will use a wrapper around the system ++\&\f(CW\*(C`realloc\*(C'\fR and \f(CW\*(C`free\*(C'\fR functions by default. ++.Sp ++You could override this function in high-availability programs to, say, ++free some memory if it cannot allocate memory, to use a special allocator, ++or even to sleep a while and retry until some memory is available. ++.Sp ++Example: Replace the libev allocator with one that waits a bit and then ++retries (example requires a standards-compliant \f(CW\*(C`realloc\*(C'\fR). ++.Sp ++.Vb 6 ++\& static void * ++\& persistent_realloc (void *ptr, size_t size) ++\& { ++\& for (;;) ++\& { ++\& void *newptr = realloc (ptr, size); ++\& ++\& if (newptr) ++\& return newptr; ++\& ++\& sleep (60); ++\& } ++\& } ++\& ++\& ... ++\& ev_set_allocator (persistent_realloc); ++.Ve ++.IP "ev_set_syserr_cb (void (*cb)(const char *msg) throw ())" 4 ++.IX Item "ev_set_syserr_cb (void (*cb)(const char *msg) throw ())" ++Set the callback function to call on a retryable system call error (such ++as failed select, poll, epoll_wait). The message is a printable string ++indicating the system call or subsystem causing the problem. If this ++callback is set, then libev will expect it to remedy the situation, no ++matter what, when it returns. That is, libev will generally retry the ++requested operation, or, if the condition doesn't go away, do bad stuff ++(such as abort). ++.Sp ++Example: This is basically the same thing that libev does internally, too. ++.Sp ++.Vb 6 ++\& static void ++\& fatal_error (const char *msg) ++\& { ++\& perror (msg); ++\& abort (); ++\& } ++\& ++\& ... ++\& ev_set_syserr_cb (fatal_error); ++.Ve ++.IP "ev_feed_signal (int signum)" 4 ++.IX Item "ev_feed_signal (int signum)" ++This function can be used to \*(L"simulate\*(R" a signal receive. It is completely ++safe to call this function at any time, from any context, including signal ++handlers or random threads. ++.Sp ++Its main use is to customise signal handling in your process, especially ++in the presence of threads. For example, you could block signals ++by default in all threads (and specifying \f(CW\*(C`EVFLAG_NOSIGMASK\*(C'\fR when ++creating any loops), and in one thread, use \f(CW\*(C`sigwait\*(C'\fR or any other ++mechanism to wait for signals, then \*(L"deliver\*(R" them to libev by calling ++\&\f(CW\*(C`ev_feed_signal\*(C'\fR. ++.SH "FUNCTIONS CONTROLLING EVENT LOOPS" ++.IX Header "FUNCTIONS CONTROLLING EVENT LOOPS" ++An event loop is described by a \f(CW\*(C`struct ev_loop *\*(C'\fR (the \f(CW\*(C`struct\*(C'\fR is ++\&\fInot\fR optional in this case unless libev 3 compatibility is disabled, as ++libev 3 had an \f(CW\*(C`ev_loop\*(C'\fR function colliding with the struct name). ++.PP ++The library knows two types of such loops, the \fIdefault\fR loop, which ++supports child process events, and dynamically created event loops which ++do not. ++.IP "struct ev_loop *ev_default_loop (unsigned int flags)" 4 ++.IX Item "struct ev_loop *ev_default_loop (unsigned int flags)" ++This returns the \*(L"default\*(R" event loop object, which is what you should ++normally use when you just need \*(L"the event loop\*(R". Event loop objects and ++the \f(CW\*(C`flags\*(C'\fR parameter are described in more detail in the entry for ++\&\f(CW\*(C`ev_loop_new\*(C'\fR. ++.Sp ++If the default loop is already initialised then this function simply ++returns it (and ignores the flags. If that is troubling you, check ++\&\f(CW\*(C`ev_backend ()\*(C'\fR afterwards). Otherwise it will create it with the given ++flags, which should almost always be \f(CW0\fR, unless the caller is also the ++one calling \f(CW\*(C`ev_run\*(C'\fR or otherwise qualifies as \*(L"the main program\*(R". ++.Sp ++If you don't know what event loop to use, use the one returned from this ++function (or via the \f(CW\*(C`EV_DEFAULT\*(C'\fR macro). ++.Sp ++Note that this function is \fInot\fR thread-safe, so if you want to use it ++from multiple threads, you have to employ some kind of mutex (note also ++that this case is unlikely, as loops cannot be shared easily between ++threads anyway). ++.Sp ++The default loop is the only loop that can handle \f(CW\*(C`ev_child\*(C'\fR watchers, ++and to do this, it always registers a handler for \f(CW\*(C`SIGCHLD\*(C'\fR. If this is ++a problem for your application you can either create a dynamic loop with ++\&\f(CW\*(C`ev_loop_new\*(C'\fR which doesn't do that, or you can simply overwrite the ++\&\f(CW\*(C`SIGCHLD\*(C'\fR signal handler \fIafter\fR calling \f(CW\*(C`ev_default_init\*(C'\fR. ++.Sp ++Example: This is the most typical usage. ++.Sp ++.Vb 2 ++\& if (!ev_default_loop (0)) ++\& fatal ("could not initialise libev, bad $LIBEV_FLAGS in environment?"); ++.Ve ++.Sp ++Example: Restrict libev to the select and poll backends, and do not allow ++environment settings to be taken into account: ++.Sp ++.Vb 1 ++\& ev_default_loop (EVBACKEND_POLL | EVBACKEND_SELECT | EVFLAG_NOENV); ++.Ve ++.IP "struct ev_loop *ev_loop_new (unsigned int flags)" 4 ++.IX Item "struct ev_loop *ev_loop_new (unsigned int flags)" ++This will create and initialise a new event loop object. If the loop ++could not be initialised, returns false. ++.Sp ++This function is thread-safe, and one common way to use libev with ++threads is indeed to create one loop per thread, and using the default ++loop in the \*(L"main\*(R" or \*(L"initial\*(R" thread. ++.Sp ++The flags argument can be used to specify special behaviour or specific ++backends to use, and is usually specified as \f(CW0\fR (or \f(CW\*(C`EVFLAG_AUTO\*(C'\fR). ++.Sp ++The following flags are supported: ++.RS 4 ++.ie n .IP """EVFLAG_AUTO""" 4 ++.el .IP "\f(CWEVFLAG_AUTO\fR" 4 ++.IX Item "EVFLAG_AUTO" ++The default flags value. Use this if you have no clue (it's the right ++thing, believe me). ++.ie n .IP """EVFLAG_NOENV""" 4 ++.el .IP "\f(CWEVFLAG_NOENV\fR" 4 ++.IX Item "EVFLAG_NOENV" ++If this flag bit is or'ed into the flag value (or the program runs setuid ++or setgid) then libev will \fInot\fR look at the environment variable ++\&\f(CW\*(C`LIBEV_FLAGS\*(C'\fR. Otherwise (the default), this environment variable will ++override the flags completely if it is found in the environment. This is ++useful to try out specific backends to test their performance, or to work ++around bugs. ++.ie n .IP """EVFLAG_FORKCHECK""" 4 ++.el .IP "\f(CWEVFLAG_FORKCHECK\fR" 4 ++.IX Item "EVFLAG_FORKCHECK" ++Instead of calling \f(CW\*(C`ev_loop_fork\*(C'\fR manually after a fork, you can also ++make libev check for a fork in each iteration by enabling this flag. ++.Sp ++This works by calling \f(CW\*(C`getpid ()\*(C'\fR on every iteration of the loop, ++and thus this might slow down your event loop if you do a lot of loop ++iterations and little real work, but is usually not noticeable (on my ++GNU/Linux system for example, \f(CW\*(C`getpid\*(C'\fR is actually a simple 5\-insn sequence ++without a system call and thus \fIvery\fR fast, but my GNU/Linux system also has ++\&\f(CW\*(C`pthread_atfork\*(C'\fR which is even faster). ++.Sp ++The big advantage of this flag is that you can forget about fork (and ++forget about forgetting to tell libev about forking) when you use this ++flag. ++.Sp ++This flag setting cannot be overridden or specified in the \f(CW\*(C`LIBEV_FLAGS\*(C'\fR ++environment variable. ++.ie n .IP """EVFLAG_NOINOTIFY""" 4 ++.el .IP "\f(CWEVFLAG_NOINOTIFY\fR" 4 ++.IX Item "EVFLAG_NOINOTIFY" ++When this flag is specified, then libev will not attempt to use the ++\&\fIinotify\fR \s-1API\s0 for its \f(CW\*(C`ev_stat\*(C'\fR watchers. Apart from debugging and ++testing, this flag can be useful to conserve inotify file descriptors, as ++otherwise each loop using \f(CW\*(C`ev_stat\*(C'\fR watchers consumes one inotify handle. ++.ie n .IP """EVFLAG_SIGNALFD""" 4 ++.el .IP "\f(CWEVFLAG_SIGNALFD\fR" 4 ++.IX Item "EVFLAG_SIGNALFD" ++When this flag is specified, then libev will attempt to use the ++\&\fIsignalfd\fR \s-1API\s0 for its \f(CW\*(C`ev_signal\*(C'\fR (and \f(CW\*(C`ev_child\*(C'\fR) watchers. This \s-1API\s0 ++delivers signals synchronously, which makes it both faster and might make ++it possible to get the queued signal data. It can also simplify signal ++handling with threads, as long as you properly block signals in your ++threads that are not interested in handling them. ++.Sp ++Signalfd will not be used by default as this changes your signal mask, and ++there are a lot of shoddy libraries and programs (glib's threadpool for ++example) that can't properly initialise their signal masks. ++.ie n .IP """EVFLAG_NOSIGMASK""" 4 ++.el .IP "\f(CWEVFLAG_NOSIGMASK\fR" 4 ++.IX Item "EVFLAG_NOSIGMASK" ++When this flag is specified, then libev will avoid to modify the signal ++mask. Specifically, this means you have to make sure signals are unblocked ++when you want to receive them. ++.Sp ++This behaviour is useful when you want to do your own signal handling, or ++want to handle signals only in specific threads and want to avoid libev ++unblocking the signals. ++.Sp ++It's also required by \s-1POSIX\s0 in a threaded program, as libev calls ++\&\f(CW\*(C`sigprocmask\*(C'\fR, whose behaviour is officially unspecified. ++.Sp ++This flag's behaviour will become the default in future versions of libev. ++.ie n .IP """EVBACKEND_SELECT"" (value 1, portable select backend)" 4 ++.el .IP "\f(CWEVBACKEND_SELECT\fR (value 1, portable select backend)" 4 ++.IX Item "EVBACKEND_SELECT (value 1, portable select backend)" ++This is your standard \fIselect\fR\|(2) backend. Not \fIcompletely\fR standard, as ++libev tries to roll its own fd_set with no limits on the number of fds, ++but if that fails, expect a fairly low limit on the number of fds when ++using this backend. It doesn't scale too well (O(highest_fd)), but its ++usually the fastest backend for a low number of (low-numbered :) fds. ++.Sp ++To get good performance out of this backend you need a high amount of ++parallelism (most of the file descriptors should be busy). If you are ++writing a server, you should \f(CW\*(C`accept ()\*(C'\fR in a loop to accept as many ++connections as possible during one iteration. You might also want to have ++a look at \f(CW\*(C`ev_set_io_collect_interval ()\*(C'\fR to increase the amount of ++readiness notifications you get per iteration. ++.Sp ++This backend maps \f(CW\*(C`EV_READ\*(C'\fR to the \f(CW\*(C`readfds\*(C'\fR set and \f(CW\*(C`EV_WRITE\*(C'\fR to the ++\&\f(CW\*(C`writefds\*(C'\fR set (and to work around Microsoft Windows bugs, also onto the ++\&\f(CW\*(C`exceptfds\*(C'\fR set on that platform). ++.ie n .IP """EVBACKEND_POLL"" (value 2, poll backend, available everywhere except on windows)" 4 ++.el .IP "\f(CWEVBACKEND_POLL\fR (value 2, poll backend, available everywhere except on windows)" 4 ++.IX Item "EVBACKEND_POLL (value 2, poll backend, available everywhere except on windows)" ++And this is your standard \fIpoll\fR\|(2) backend. It's more complicated ++than select, but handles sparse fds better and has no artificial ++limit on the number of fds you can use (except it will slow down ++considerably with a lot of inactive fds). It scales similarly to select, ++i.e. O(total_fds). See the entry for \f(CW\*(C`EVBACKEND_SELECT\*(C'\fR, above, for ++performance tips. ++.Sp ++This backend maps \f(CW\*(C`EV_READ\*(C'\fR to \f(CW\*(C`POLLIN | POLLERR | POLLHUP\*(C'\fR, and ++\&\f(CW\*(C`EV_WRITE\*(C'\fR to \f(CW\*(C`POLLOUT | POLLERR | POLLHUP\*(C'\fR. ++.ie n .IP """EVBACKEND_EPOLL"" (value 4, Linux)" 4 ++.el .IP "\f(CWEVBACKEND_EPOLL\fR (value 4, Linux)" 4 ++.IX Item "EVBACKEND_EPOLL (value 4, Linux)" ++Use the linux-specific \fIepoll\fR\|(7) interface (for both pre\- and post\-2.6.9 ++kernels). ++.Sp ++For few fds, this backend is a bit little slower than poll and select, but ++it scales phenomenally better. While poll and select usually scale like ++O(total_fds) where total_fds is the total number of fds (or the highest ++fd), epoll scales either O(1) or O(active_fds). ++.Sp ++The epoll mechanism deserves honorable mention as the most misdesigned ++of the more advanced event mechanisms: mere annoyances include silently ++dropping file descriptors, requiring a system call per change per file ++descriptor (and unnecessary guessing of parameters), problems with dup, ++returning before the timeout value, resulting in additional iterations ++(and only giving 5ms accuracy while select on the same platform gives ++0.1ms) and so on. The biggest issue is fork races, however \- if a program ++forks then \fIboth\fR parent and child process have to recreate the epoll ++set, which can take considerable time (one syscall per file descriptor) ++and is of course hard to detect. ++.Sp ++Epoll is also notoriously buggy \- embedding epoll fds \fIshould\fR work, ++but of course \fIdoesn't\fR, and epoll just loves to report events for ++totally \fIdifferent\fR file descriptors (even already closed ones, so ++one cannot even remove them from the set) than registered in the set ++(especially on \s-1SMP\s0 systems). Libev tries to counter these spurious ++notifications by employing an additional generation counter and comparing ++that against the events to filter out spurious ones, recreating the set ++when required. Epoll also erroneously rounds down timeouts, but gives you ++no way to know when and by how much, so sometimes you have to busy-wait ++because epoll returns immediately despite a nonzero timeout. And last ++not least, it also refuses to work with some file descriptors which work ++perfectly fine with \f(CW\*(C`select\*(C'\fR (files, many character devices...). ++.Sp ++Epoll is truly the train wreck among event poll mechanisms, a frankenpoll, ++cobbled together in a hurry, no thought to design or interaction with ++others. Oh, the pain, will it ever stop... ++.Sp ++While stopping, setting and starting an I/O watcher in the same iteration ++will result in some caching, there is still a system call per such ++incident (because the same \fIfile descriptor\fR could point to a different ++\&\fIfile description\fR now), so its best to avoid that. Also, \f(CW\*(C`dup ()\*(C'\fR'ed ++file descriptors might not work very well if you register events for both ++file descriptors. ++.Sp ++Best performance from this backend is achieved by not unregistering all ++watchers for a file descriptor until it has been closed, if possible, ++i.e. keep at least one watcher active per fd at all times. Stopping and ++starting a watcher (without re-setting it) also usually doesn't cause ++extra overhead. A fork can both result in spurious notifications as well ++as in libev having to destroy and recreate the epoll object, which can ++take considerable time and thus should be avoided. ++.Sp ++All this means that, in practice, \f(CW\*(C`EVBACKEND_SELECT\*(C'\fR can be as fast or ++faster than epoll for maybe up to a hundred file descriptors, depending on ++the usage. So sad. ++.Sp ++While nominally embeddable in other event loops, this feature is broken in ++all kernel versions tested so far. ++.Sp ++This backend maps \f(CW\*(C`EV_READ\*(C'\fR and \f(CW\*(C`EV_WRITE\*(C'\fR in the same way as ++\&\f(CW\*(C`EVBACKEND_POLL\*(C'\fR. ++.ie n .IP """EVBACKEND_KQUEUE"" (value 8, most \s-1BSD\s0 clones)" 4 ++.el .IP "\f(CWEVBACKEND_KQUEUE\fR (value 8, most \s-1BSD\s0 clones)" 4 ++.IX Item "EVBACKEND_KQUEUE (value 8, most BSD clones)" ++Kqueue deserves special mention, as at the time of this writing, it ++was broken on all BSDs except NetBSD (usually it doesn't work reliably ++with anything but sockets and pipes, except on Darwin, where of course ++it's completely useless). Unlike epoll, however, whose brokenness ++is by design, these kqueue bugs can (and eventually will) be fixed ++without \s-1API\s0 changes to existing programs. For this reason it's not being ++\&\*(L"auto-detected\*(R" unless you explicitly specify it in the flags (i.e. using ++\&\f(CW\*(C`EVBACKEND_KQUEUE\*(C'\fR) or libev was compiled on a known-to-be-good (\-enough) ++system like NetBSD. ++.Sp ++You still can embed kqueue into a normal poll or select backend and use it ++only for sockets (after having made sure that sockets work with kqueue on ++the target platform). See \f(CW\*(C`ev_embed\*(C'\fR watchers for more info. ++.Sp ++It scales in the same way as the epoll backend, but the interface to the ++kernel is more efficient (which says nothing about its actual speed, of ++course). While stopping, setting and starting an I/O watcher does never ++cause an extra system call as with \f(CW\*(C`EVBACKEND_EPOLL\*(C'\fR, it still adds up to ++two event changes per incident. Support for \f(CW\*(C`fork ()\*(C'\fR is very bad (you ++might have to leak fd's on fork, but it's more sane than epoll) and it ++drops fds silently in similarly hard-to-detect cases. ++.Sp ++This backend usually performs well under most conditions. ++.Sp ++While nominally embeddable in other event loops, this doesn't work ++everywhere, so you might need to test for this. And since it is broken ++almost everywhere, you should only use it when you have a lot of sockets ++(for which it usually works), by embedding it into another event loop ++(e.g. \f(CW\*(C`EVBACKEND_SELECT\*(C'\fR or \f(CW\*(C`EVBACKEND_POLL\*(C'\fR (but \f(CW\*(C`poll\*(C'\fR is of course ++also broken on \s-1OS\s0 X)) and, did I mention it, using it only for sockets. ++.Sp ++This backend maps \f(CW\*(C`EV_READ\*(C'\fR into an \f(CW\*(C`EVFILT_READ\*(C'\fR kevent with ++\&\f(CW\*(C`NOTE_EOF\*(C'\fR, and \f(CW\*(C`EV_WRITE\*(C'\fR into an \f(CW\*(C`EVFILT_WRITE\*(C'\fR kevent with ++\&\f(CW\*(C`NOTE_EOF\*(C'\fR. ++.ie n .IP """EVBACKEND_DEVPOLL"" (value 16, Solaris 8)" 4 ++.el .IP "\f(CWEVBACKEND_DEVPOLL\fR (value 16, Solaris 8)" 4 ++.IX Item "EVBACKEND_DEVPOLL (value 16, Solaris 8)" ++This is not implemented yet (and might never be, unless you send me an ++implementation). According to reports, \f(CW\*(C`/dev/poll\*(C'\fR only supports sockets ++and is not embeddable, which would limit the usefulness of this backend ++immensely. ++.ie n .IP """EVBACKEND_PORT"" (value 32, Solaris 10)" 4 ++.el .IP "\f(CWEVBACKEND_PORT\fR (value 32, Solaris 10)" 4 ++.IX Item "EVBACKEND_PORT (value 32, Solaris 10)" ++This uses the Solaris 10 event port mechanism. As with everything on Solaris, ++it's really slow, but it still scales very well (O(active_fds)). ++.Sp ++While this backend scales well, it requires one system call per active ++file descriptor per loop iteration. For small and medium numbers of file ++descriptors a \*(L"slow\*(R" \f(CW\*(C`EVBACKEND_SELECT\*(C'\fR or \f(CW\*(C`EVBACKEND_POLL\*(C'\fR backend ++might perform better. ++.Sp ++On the positive side, this backend actually performed fully to ++specification in all tests and is fully embeddable, which is a rare feat ++among the OS-specific backends (I vastly prefer correctness over speed ++hacks). ++.Sp ++On the negative side, the interface is \fIbizarre\fR \- so bizarre that ++even sun itself gets it wrong in their code examples: The event polling ++function sometimes returns events to the caller even though an error ++occurred, but with no indication whether it has done so or not (yes, it's ++even documented that way) \- deadly for edge-triggered interfaces where you ++absolutely have to know whether an event occurred or not because you have ++to re-arm the watcher. ++.Sp ++Fortunately libev seems to be able to work around these idiocies. ++.Sp ++This backend maps \f(CW\*(C`EV_READ\*(C'\fR and \f(CW\*(C`EV_WRITE\*(C'\fR in the same way as ++\&\f(CW\*(C`EVBACKEND_POLL\*(C'\fR. ++.ie n .IP """EVBACKEND_ALL""" 4 ++.el .IP "\f(CWEVBACKEND_ALL\fR" 4 ++.IX Item "EVBACKEND_ALL" ++Try all backends (even potentially broken ones that wouldn't be tried ++with \f(CW\*(C`EVFLAG_AUTO\*(C'\fR). Since this is a mask, you can do stuff such as ++\&\f(CW\*(C`EVBACKEND_ALL & ~EVBACKEND_KQUEUE\*(C'\fR. ++.Sp ++It is definitely not recommended to use this flag, use whatever ++\&\f(CW\*(C`ev_recommended_backends ()\*(C'\fR returns, or simply do not specify a backend ++at all. ++.ie n .IP """EVBACKEND_MASK""" 4 ++.el .IP "\f(CWEVBACKEND_MASK\fR" 4 ++.IX Item "EVBACKEND_MASK" ++Not a backend at all, but a mask to select all backend bits from a ++\&\f(CW\*(C`flags\*(C'\fR value, in case you want to mask out any backends from a flags ++value (e.g. when modifying the \f(CW\*(C`LIBEV_FLAGS\*(C'\fR environment variable). ++.RE ++.RS 4 ++.Sp ++If one or more of the backend flags are or'ed into the flags value, ++then only these backends will be tried (in the reverse order as listed ++here). If none are specified, all backends in \f(CW\*(C`ev_recommended_backends ++()\*(C'\fR will be tried. ++.Sp ++Example: Try to create a event loop that uses epoll and nothing else. ++.Sp ++.Vb 3 ++\& struct ev_loop *epoller = ev_loop_new (EVBACKEND_EPOLL | EVFLAG_NOENV); ++\& if (!epoller) ++\& fatal ("no epoll found here, maybe it hides under your chair"); ++.Ve ++.Sp ++Example: Use whatever libev has to offer, but make sure that kqueue is ++used if available. ++.Sp ++.Vb 1 ++\& struct ev_loop *loop = ev_loop_new (ev_recommended_backends () | EVBACKEND_KQUEUE); ++.Ve ++.RE ++.IP "ev_loop_destroy (loop)" 4 ++.IX Item "ev_loop_destroy (loop)" ++Destroys an event loop object (frees all memory and kernel state ++etc.). None of the active event watchers will be stopped in the normal ++sense, so e.g. \f(CW\*(C`ev_is_active\*(C'\fR might still return true. It is your ++responsibility to either stop all watchers cleanly yourself \fIbefore\fR ++calling this function, or cope with the fact afterwards (which is usually ++the easiest thing, you can just ignore the watchers and/or \f(CW\*(C`free ()\*(C'\fR them ++for example). ++.Sp ++Note that certain global state, such as signal state (and installed signal ++handlers), will not be freed by this function, and related watchers (such ++as signal and child watchers) would need to be stopped manually. ++.Sp ++This function is normally used on loop objects allocated by ++\&\f(CW\*(C`ev_loop_new\*(C'\fR, but it can also be used on the default loop returned by ++\&\f(CW\*(C`ev_default_loop\*(C'\fR, in which case it is not thread-safe. ++.Sp ++Note that it is not advisable to call this function on the default loop ++except in the rare occasion where you really need to free its resources. ++If you need dynamically allocated loops it is better to use \f(CW\*(C`ev_loop_new\*(C'\fR ++and \f(CW\*(C`ev_loop_destroy\*(C'\fR. ++.IP "ev_loop_fork (loop)" 4 ++.IX Item "ev_loop_fork (loop)" ++This function sets a flag that causes subsequent \f(CW\*(C`ev_run\*(C'\fR iterations to ++reinitialise the kernel state for backends that have one. Despite the ++name, you can call it anytime, but it makes most sense after forking, in ++the child process. You \fImust\fR call it (or use \f(CW\*(C`EVFLAG_FORKCHECK\*(C'\fR) in the ++child before resuming or calling \f(CW\*(C`ev_run\*(C'\fR. ++.Sp ++Again, you \fIhave\fR to call it on \fIany\fR loop that you want to re-use after ++a fork, \fIeven if you do not plan to use the loop in the parent\fR. This is ++because some kernel interfaces *cough* \fIkqueue\fR *cough* do funny things ++during fork. ++.Sp ++On the other hand, you only need to call this function in the child ++process if and only if you want to use the event loop in the child. If ++you just fork+exec or create a new loop in the child, you don't have to ++call it at all (in fact, \f(CW\*(C`epoll\*(C'\fR is so badly broken that it makes a ++difference, but libev will usually detect this case on its own and do a ++costly reset of the backend). ++.Sp ++The function itself is quite fast and it's usually not a problem to call ++it just in case after a fork. ++.Sp ++Example: Automate calling \f(CW\*(C`ev_loop_fork\*(C'\fR on the default loop when ++using pthreads. ++.Sp ++.Vb 5 ++\& static void ++\& post_fork_child (void) ++\& { ++\& ev_loop_fork (EV_DEFAULT); ++\& } ++\& ++\& ... ++\& pthread_atfork (0, 0, post_fork_child); ++.Ve ++.IP "int ev_is_default_loop (loop)" 4 ++.IX Item "int ev_is_default_loop (loop)" ++Returns true when the given loop is, in fact, the default loop, and false ++otherwise. ++.IP "unsigned int ev_iteration (loop)" 4 ++.IX Item "unsigned int ev_iteration (loop)" ++Returns the current iteration count for the event loop, which is identical ++to the number of times libev did poll for new events. It starts at \f(CW0\fR ++and happily wraps around with enough iterations. ++.Sp ++This value can sometimes be useful as a generation counter of sorts (it ++\&\*(L"ticks\*(R" the number of loop iterations), as it roughly corresponds with ++\&\f(CW\*(C`ev_prepare\*(C'\fR and \f(CW\*(C`ev_check\*(C'\fR calls \- and is incremented between the ++prepare and check phases. ++.IP "unsigned int ev_depth (loop)" 4 ++.IX Item "unsigned int ev_depth (loop)" ++Returns the number of times \f(CW\*(C`ev_run\*(C'\fR was entered minus the number of ++times \f(CW\*(C`ev_run\*(C'\fR was exited normally, in other words, the recursion depth. ++.Sp ++Outside \f(CW\*(C`ev_run\*(C'\fR, this number is zero. In a callback, this number is ++\&\f(CW1\fR, unless \f(CW\*(C`ev_run\*(C'\fR was invoked recursively (or from another thread), ++in which case it is higher. ++.Sp ++Leaving \f(CW\*(C`ev_run\*(C'\fR abnormally (setjmp/longjmp, cancelling the thread, ++throwing an exception etc.), doesn't count as \*(L"exit\*(R" \- consider this ++as a hint to avoid such ungentleman-like behaviour unless it's really ++convenient, in which case it is fully supported. ++.IP "unsigned int ev_backend (loop)" 4 ++.IX Item "unsigned int ev_backend (loop)" ++Returns one of the \f(CW\*(C`EVBACKEND_*\*(C'\fR flags indicating the event backend in ++use. ++.IP "ev_tstamp ev_now (loop)" 4 ++.IX Item "ev_tstamp ev_now (loop)" ++Returns the current \*(L"event loop time\*(R", which is the time the event loop ++received events and started processing them. This timestamp does not ++change as long as callbacks are being processed, and this is also the base ++time used for relative timers. You can treat it as the timestamp of the ++event occurring (or more correctly, libev finding out about it). ++.IP "ev_now_update (loop)" 4 ++.IX Item "ev_now_update (loop)" ++Establishes the current time by querying the kernel, updating the time ++returned by \f(CW\*(C`ev_now ()\*(C'\fR in the progress. This is a costly operation and ++is usually done automatically within \f(CW\*(C`ev_run ()\*(C'\fR. ++.Sp ++This function is rarely useful, but when some event callback runs for a ++very long time without entering the event loop, updating libev's idea of ++the current time is a good idea. ++.Sp ++See also \*(L"The special problem of time updates\*(R" in the \f(CW\*(C`ev_timer\*(C'\fR section. ++.IP "ev_suspend (loop)" 4 ++.IX Item "ev_suspend (loop)" ++.PD 0 ++.IP "ev_resume (loop)" 4 ++.IX Item "ev_resume (loop)" ++.PD ++These two functions suspend and resume an event loop, for use when the ++loop is not used for a while and timeouts should not be processed. ++.Sp ++A typical use case would be an interactive program such as a game: When ++the user presses \f(CW\*(C`^Z\*(C'\fR to suspend the game and resumes it an hour later it ++would be best to handle timeouts as if no time had actually passed while ++the program was suspended. This can be achieved by calling \f(CW\*(C`ev_suspend\*(C'\fR ++in your \f(CW\*(C`SIGTSTP\*(C'\fR handler, sending yourself a \f(CW\*(C`SIGSTOP\*(C'\fR and calling ++\&\f(CW\*(C`ev_resume\*(C'\fR directly afterwards to resume timer processing. ++.Sp ++Effectively, all \f(CW\*(C`ev_timer\*(C'\fR watchers will be delayed by the time spend ++between \f(CW\*(C`ev_suspend\*(C'\fR and \f(CW\*(C`ev_resume\*(C'\fR, and all \f(CW\*(C`ev_periodic\*(C'\fR watchers ++will be rescheduled (that is, they will lose any events that would have ++occurred while suspended). ++.Sp ++After calling \f(CW\*(C`ev_suspend\*(C'\fR you \fBmust not\fR call \fIany\fR function on the ++given loop other than \f(CW\*(C`ev_resume\*(C'\fR, and you \fBmust not\fR call \f(CW\*(C`ev_resume\*(C'\fR ++without a previous call to \f(CW\*(C`ev_suspend\*(C'\fR. ++.Sp ++Calling \f(CW\*(C`ev_suspend\*(C'\fR/\f(CW\*(C`ev_resume\*(C'\fR has the side effect of updating the ++event loop time (see \f(CW\*(C`ev_now_update\*(C'\fR). ++.IP "bool ev_run (loop, int flags)" 4 ++.IX Item "bool ev_run (loop, int flags)" ++Finally, this is it, the event handler. This function usually is called ++after you have initialised all your watchers and you want to start ++handling events. It will ask the operating system for any new events, call ++the watcher callbacks, and then repeat the whole process indefinitely: This ++is why event loops are called \fIloops\fR. ++.Sp ++If the flags argument is specified as \f(CW0\fR, it will keep handling events ++until either no event watchers are active anymore or \f(CW\*(C`ev_break\*(C'\fR was ++called. ++.Sp ++The return value is false if there are no more active watchers (which ++usually means \*(L"all jobs done\*(R" or \*(L"deadlock\*(R"), and true in all other cases ++(which usually means " you should call \f(CW\*(C`ev_run\*(C'\fR again"). ++.Sp ++Please note that an explicit \f(CW\*(C`ev_break\*(C'\fR is usually better than ++relying on all watchers to be stopped when deciding when a program has ++finished (especially in interactive programs), but having a program ++that automatically loops as long as it has to and no longer by virtue ++of relying on its watchers stopping correctly, that is truly a thing of ++beauty. ++.Sp ++This function is \fImostly\fR exception-safe \- you can break out of a ++\&\f(CW\*(C`ev_run\*(C'\fR call by calling \f(CW\*(C`longjmp\*(C'\fR in a callback, throwing a \*(C+ ++exception and so on. This does not decrement the \f(CW\*(C`ev_depth\*(C'\fR value, nor ++will it clear any outstanding \f(CW\*(C`EVBREAK_ONE\*(C'\fR breaks. ++.Sp ++A flags value of \f(CW\*(C`EVRUN_NOWAIT\*(C'\fR will look for new events, will handle ++those events and any already outstanding ones, but will not wait and ++block your process in case there are no events and will return after one ++iteration of the loop. This is sometimes useful to poll and handle new ++events while doing lengthy calculations, to keep the program responsive. ++.Sp ++A flags value of \f(CW\*(C`EVRUN_ONCE\*(C'\fR will look for new events (waiting if ++necessary) and will handle those and any already outstanding ones. It ++will block your process until at least one new event arrives (which could ++be an event internal to libev itself, so there is no guarantee that a ++user-registered callback will be called), and will return after one ++iteration of the loop. ++.Sp ++This is useful if you are waiting for some external event in conjunction ++with something not expressible using other libev watchers (i.e. "roll your ++own \f(CW\*(C`ev_run\*(C'\fR"). However, a pair of \f(CW\*(C`ev_prepare\*(C'\fR/\f(CW\*(C`ev_check\*(C'\fR watchers is ++usually a better approach for this kind of thing. ++.Sp ++Here are the gory details of what \f(CW\*(C`ev_run\*(C'\fR does (this is for your ++understanding, not a guarantee that things will work exactly like this in ++future versions): ++.Sp ++.Vb 10 ++\& \- Increment loop depth. ++\& \- Reset the ev_break status. ++\& \- Before the first iteration, call any pending watchers. ++\& LOOP: ++\& \- If EVFLAG_FORKCHECK was used, check for a fork. ++\& \- If a fork was detected (by any means), queue and call all fork watchers. ++\& \- Queue and call all prepare watchers. ++\& \- If ev_break was called, goto FINISH. ++\& \- If we have been forked, detach and recreate the kernel state ++\& as to not disturb the other process. ++\& \- Update the kernel state with all outstanding changes. ++\& \- Update the "event loop time" (ev_now ()). ++\& \- Calculate for how long to sleep or block, if at all ++\& (active idle watchers, EVRUN_NOWAIT or not having ++\& any active watchers at all will result in not sleeping). ++\& \- Sleep if the I/O and timer collect interval say so. ++\& \- Increment loop iteration counter. ++\& \- Block the process, waiting for any events. ++\& \- Queue all outstanding I/O (fd) events. ++\& \- Update the "event loop time" (ev_now ()), and do time jump adjustments. ++\& \- Queue all expired timers. ++\& \- Queue all expired periodics. ++\& \- Queue all idle watchers with priority higher than that of pending events. ++\& \- Queue all check watchers. ++\& \- Call all queued watchers in reverse order (i.e. check watchers first). ++\& Signals and child watchers are implemented as I/O watchers, and will ++\& be handled here by queueing them when their watcher gets executed. ++\& \- If ev_break has been called, or EVRUN_ONCE or EVRUN_NOWAIT ++\& were used, or there are no active watchers, goto FINISH, otherwise ++\& continue with step LOOP. ++\& FINISH: ++\& \- Reset the ev_break status iff it was EVBREAK_ONE. ++\& \- Decrement the loop depth. ++\& \- Return. ++.Ve ++.Sp ++Example: Queue some jobs and then loop until no events are outstanding ++anymore. ++.Sp ++.Vb 4 ++\& ... queue jobs here, make sure they register event watchers as long ++\& ... as they still have work to do (even an idle watcher will do..) ++\& ev_run (my_loop, 0); ++\& ... jobs done or somebody called break. yeah! ++.Ve ++.IP "ev_break (loop, how)" 4 ++.IX Item "ev_break (loop, how)" ++Can be used to make a call to \f(CW\*(C`ev_run\*(C'\fR return early (but only after it ++has processed all outstanding events). The \f(CW\*(C`how\*(C'\fR argument must be either ++\&\f(CW\*(C`EVBREAK_ONE\*(C'\fR, which will make the innermost \f(CW\*(C`ev_run\*(C'\fR call return, or ++\&\f(CW\*(C`EVBREAK_ALL\*(C'\fR, which will make all nested \f(CW\*(C`ev_run\*(C'\fR calls return. ++.Sp ++This \*(L"break state\*(R" will be cleared on the next call to \f(CW\*(C`ev_run\*(C'\fR. ++.Sp ++It is safe to call \f(CW\*(C`ev_break\*(C'\fR from outside any \f(CW\*(C`ev_run\*(C'\fR calls, too, in ++which case it will have no effect. ++.IP "ev_ref (loop)" 4 ++.IX Item "ev_ref (loop)" ++.PD 0 ++.IP "ev_unref (loop)" 4 ++.IX Item "ev_unref (loop)" ++.PD ++Ref/unref can be used to add or remove a reference count on the event ++loop: Every watcher keeps one reference, and as long as the reference ++count is nonzero, \f(CW\*(C`ev_run\*(C'\fR will not return on its own. ++.Sp ++This is useful when you have a watcher that you never intend to ++unregister, but that nevertheless should not keep \f(CW\*(C`ev_run\*(C'\fR from ++returning. In such a case, call \f(CW\*(C`ev_unref\*(C'\fR after starting, and \f(CW\*(C`ev_ref\*(C'\fR ++before stopping it. ++.Sp ++As an example, libev itself uses this for its internal signal pipe: It ++is not visible to the libev user and should not keep \f(CW\*(C`ev_run\*(C'\fR from ++exiting if no event watchers registered by it are active. It is also an ++excellent way to do this for generic recurring timers or from within ++third-party libraries. Just remember to \fIunref after start\fR and \fIref ++before stop\fR (but only if the watcher wasn't active before, or was active ++before, respectively. Note also that libev might stop watchers itself ++(e.g. non-repeating timers) in which case you have to \f(CW\*(C`ev_ref\*(C'\fR ++in the callback). ++.Sp ++Example: Create a signal watcher, but keep it from keeping \f(CW\*(C`ev_run\*(C'\fR ++running when nothing else is active. ++.Sp ++.Vb 4 ++\& ev_signal exitsig; ++\& ev_signal_init (&exitsig, sig_cb, SIGINT); ++\& ev_signal_start (loop, &exitsig); ++\& ev_unref (loop); ++.Ve ++.Sp ++Example: For some weird reason, unregister the above signal handler again. ++.Sp ++.Vb 2 ++\& ev_ref (loop); ++\& ev_signal_stop (loop, &exitsig); ++.Ve ++.IP "ev_set_io_collect_interval (loop, ev_tstamp interval)" 4 ++.IX Item "ev_set_io_collect_interval (loop, ev_tstamp interval)" ++.PD 0 ++.IP "ev_set_timeout_collect_interval (loop, ev_tstamp interval)" 4 ++.IX Item "ev_set_timeout_collect_interval (loop, ev_tstamp interval)" ++.PD ++These advanced functions influence the time that libev will spend waiting ++for events. Both time intervals are by default \f(CW0\fR, meaning that libev ++will try to invoke timer/periodic callbacks and I/O callbacks with minimum ++latency. ++.Sp ++Setting these to a higher value (the \f(CW\*(C`interval\*(C'\fR \fImust\fR be >= \f(CW0\fR) ++allows libev to delay invocation of I/O and timer/periodic callbacks ++to increase efficiency of loop iterations (or to increase power-saving ++opportunities). ++.Sp ++The idea is that sometimes your program runs just fast enough to handle ++one (or very few) event(s) per loop iteration. While this makes the ++program responsive, it also wastes a lot of \s-1CPU\s0 time to poll for new ++events, especially with backends like \f(CW\*(C`select ()\*(C'\fR which have a high ++overhead for the actual polling but can deliver many events at once. ++.Sp ++By setting a higher \fIio collect interval\fR you allow libev to spend more ++time collecting I/O events, so you can handle more events per iteration, ++at the cost of increasing latency. Timeouts (both \f(CW\*(C`ev_periodic\*(C'\fR and ++\&\f(CW\*(C`ev_timer\*(C'\fR) will not be affected. Setting this to a non-null value will ++introduce an additional \f(CW\*(C`ev_sleep ()\*(C'\fR call into most loop iterations. The ++sleep time ensures that libev will not poll for I/O events more often then ++once per this interval, on average (as long as the host time resolution is ++good enough). ++.Sp ++Likewise, by setting a higher \fItimeout collect interval\fR you allow libev ++to spend more time collecting timeouts, at the expense of increased ++latency/jitter/inexactness (the watcher callback will be called ++later). \f(CW\*(C`ev_io\*(C'\fR watchers will not be affected. Setting this to a non-null ++value will not introduce any overhead in libev. ++.Sp ++Many (busy) programs can usually benefit by setting the I/O collect ++interval to a value near \f(CW0.1\fR or so, which is often enough for ++interactive servers (of course not for games), likewise for timeouts. It ++usually doesn't make much sense to set it to a lower value than \f(CW0.01\fR, ++as this approaches the timing granularity of most systems. Note that if ++you do transactions with the outside world and you can't increase the ++parallelity, then this setting will limit your transaction rate (if you ++need to poll once per transaction and the I/O collect interval is 0.01, ++then you can't do more than 100 transactions per second). ++.Sp ++Setting the \fItimeout collect interval\fR can improve the opportunity for ++saving power, as the program will \*(L"bundle\*(R" timer callback invocations that ++are \*(L"near\*(R" in time together, by delaying some, thus reducing the number of ++times the process sleeps and wakes up again. Another useful technique to ++reduce iterations/wake\-ups is to use \f(CW\*(C`ev_periodic\*(C'\fR watchers and make sure ++they fire on, say, one-second boundaries only. ++.Sp ++Example: we only need 0.1s timeout granularity, and we wish not to poll ++more often than 100 times per second: ++.Sp ++.Vb 2 ++\& ev_set_timeout_collect_interval (EV_DEFAULT_UC_ 0.1); ++\& ev_set_io_collect_interval (EV_DEFAULT_UC_ 0.01); ++.Ve ++.IP "ev_invoke_pending (loop)" 4 ++.IX Item "ev_invoke_pending (loop)" ++This call will simply invoke all pending watchers while resetting their ++pending state. Normally, \f(CW\*(C`ev_run\*(C'\fR does this automatically when required, ++but when overriding the invoke callback this call comes handy. This ++function can be invoked from a watcher \- this can be useful for example ++when you want to do some lengthy calculation and want to pass further ++event handling to another thread (you still have to make sure only one ++thread executes within \f(CW\*(C`ev_invoke_pending\*(C'\fR or \f(CW\*(C`ev_run\*(C'\fR of course). ++.IP "int ev_pending_count (loop)" 4 ++.IX Item "int ev_pending_count (loop)" ++Returns the number of pending watchers \- zero indicates that no watchers ++are pending. ++.IP "ev_set_invoke_pending_cb (loop, void (*invoke_pending_cb)(\s-1EV_P\s0))" 4 ++.IX Item "ev_set_invoke_pending_cb (loop, void (*invoke_pending_cb)(EV_P))" ++This overrides the invoke pending functionality of the loop: Instead of ++invoking all pending watchers when there are any, \f(CW\*(C`ev_run\*(C'\fR will call ++this callback instead. This is useful, for example, when you want to ++invoke the actual watchers inside another context (another thread etc.). ++.Sp ++If you want to reset the callback, use \f(CW\*(C`ev_invoke_pending\*(C'\fR as new ++callback. ++.IP "ev_set_loop_release_cb (loop, void (*release)(\s-1EV_P\s0) throw (), void (*acquire)(\s-1EV_P\s0) throw ())" 4 ++.IX Item "ev_set_loop_release_cb (loop, void (*release)(EV_P) throw (), void (*acquire)(EV_P) throw ())" ++Sometimes you want to share the same loop between multiple threads. This ++can be done relatively simply by putting mutex_lock/unlock calls around ++each call to a libev function. ++.Sp ++However, \f(CW\*(C`ev_run\*(C'\fR can run an indefinite time, so it is not feasible ++to wait for it to return. One way around this is to wake up the event ++loop via \f(CW\*(C`ev_break\*(C'\fR and \f(CW\*(C`ev_async_send\*(C'\fR, another way is to set these ++\&\fIrelease\fR and \fIacquire\fR callbacks on the loop. ++.Sp ++When set, then \f(CW\*(C`release\*(C'\fR will be called just before the thread is ++suspended waiting for new events, and \f(CW\*(C`acquire\*(C'\fR is called just ++afterwards. ++.Sp ++Ideally, \f(CW\*(C`release\*(C'\fR will just call your mutex_unlock function, and ++\&\f(CW\*(C`acquire\*(C'\fR will just call the mutex_lock function again. ++.Sp ++While event loop modifications are allowed between invocations of ++\&\f(CW\*(C`release\*(C'\fR and \f(CW\*(C`acquire\*(C'\fR (that's their only purpose after all), no ++modifications done will affect the event loop, i.e. adding watchers will ++have no effect on the set of file descriptors being watched, or the time ++waited. Use an \f(CW\*(C`ev_async\*(C'\fR watcher to wake up \f(CW\*(C`ev_run\*(C'\fR when you want it ++to take note of any changes you made. ++.Sp ++In theory, threads executing \f(CW\*(C`ev_run\*(C'\fR will be async-cancel safe between ++invocations of \f(CW\*(C`release\*(C'\fR and \f(CW\*(C`acquire\*(C'\fR. ++.Sp ++See also the locking example in the \f(CW\*(C`THREADS\*(C'\fR section later in this ++document. ++.IP "ev_set_userdata (loop, void *data)" 4 ++.IX Item "ev_set_userdata (loop, void *data)" ++.PD 0 ++.IP "void *ev_userdata (loop)" 4 ++.IX Item "void *ev_userdata (loop)" ++.PD ++Set and retrieve a single \f(CW\*(C`void *\*(C'\fR associated with a loop. When ++\&\f(CW\*(C`ev_set_userdata\*(C'\fR has never been called, then \f(CW\*(C`ev_userdata\*(C'\fR returns ++\&\f(CW0\fR. ++.Sp ++These two functions can be used to associate arbitrary data with a loop, ++and are intended solely for the \f(CW\*(C`invoke_pending_cb\*(C'\fR, \f(CW\*(C`release\*(C'\fR and ++\&\f(CW\*(C`acquire\*(C'\fR callbacks described above, but of course can be (ab\-)used for ++any other purpose as well. ++.IP "ev_verify (loop)" 4 ++.IX Item "ev_verify (loop)" ++This function only does something when \f(CW\*(C`EV_VERIFY\*(C'\fR support has been ++compiled in, which is the default for non-minimal builds. It tries to go ++through all internal structures and checks them for validity. If anything ++is found to be inconsistent, it will print an error message to standard ++error and call \f(CW\*(C`abort ()\*(C'\fR. ++.Sp ++This can be used to catch bugs inside libev itself: under normal ++circumstances, this function will never abort as of course libev keeps its ++data structures consistent. ++.SH "ANATOMY OF A WATCHER" ++.IX Header "ANATOMY OF A WATCHER" ++In the following description, uppercase \f(CW\*(C`TYPE\*(C'\fR in names stands for the ++watcher type, e.g. \f(CW\*(C`ev_TYPE_start\*(C'\fR can mean \f(CW\*(C`ev_timer_start\*(C'\fR for timer ++watchers and \f(CW\*(C`ev_io_start\*(C'\fR for I/O watchers. ++.PP ++A watcher is an opaque structure that you allocate and register to record ++your interest in some event. To make a concrete example, imagine you want ++to wait for \s-1STDIN\s0 to become readable, you would create an \f(CW\*(C`ev_io\*(C'\fR watcher ++for that: ++.PP ++.Vb 5 ++\& static void my_cb (struct ev_loop *loop, ev_io *w, int revents) ++\& { ++\& ev_io_stop (w); ++\& ev_break (loop, EVBREAK_ALL); ++\& } ++\& ++\& struct ev_loop *loop = ev_default_loop (0); ++\& ++\& ev_io stdin_watcher; ++\& ++\& ev_init (&stdin_watcher, my_cb); ++\& ev_io_set (&stdin_watcher, STDIN_FILENO, EV_READ); ++\& ev_io_start (loop, &stdin_watcher); ++\& ++\& ev_run (loop, 0); ++.Ve ++.PP ++As you can see, you are responsible for allocating the memory for your ++watcher structures (and it is \fIusually\fR a bad idea to do this on the ++stack). ++.PP ++Each watcher has an associated watcher structure (called \f(CW\*(C`struct ev_TYPE\*(C'\fR ++or simply \f(CW\*(C`ev_TYPE\*(C'\fR, as typedefs are provided for all watcher structs). ++.PP ++Each watcher structure must be initialised by a call to \f(CW\*(C`ev_init (watcher ++*, callback)\*(C'\fR, which expects a callback to be provided. This callback is ++invoked each time the event occurs (or, in the case of I/O watchers, each ++time the event loop detects that the file descriptor given is readable ++and/or writable). ++.PP ++Each watcher type further has its own \f(CW\*(C`ev_TYPE_set (watcher *, ...)\*(C'\fR ++macro to configure it, with arguments specific to the watcher type. There ++is also a macro to combine initialisation and setting in one call: \f(CW\*(C`ev_TYPE_init (watcher *, callback, ...)\*(C'\fR. ++.PP ++To make the watcher actually watch out for events, you have to start it ++with a watcher-specific start function (\f(CW\*(C`ev_TYPE_start (loop, watcher ++*)\*(C'\fR), and you can stop watching for events at any time by calling the ++corresponding stop function (\f(CW\*(C`ev_TYPE_stop (loop, watcher *)\*(C'\fR. ++.PP ++As long as your watcher is active (has been started but not stopped) you ++must not touch the values stored in it. Most specifically you must never ++reinitialise it or call its \f(CW\*(C`ev_TYPE_set\*(C'\fR macro. ++.PP ++Each and every callback receives the event loop pointer as first, the ++registered watcher structure as second, and a bitset of received events as ++third argument. ++.PP ++The received events usually include a single bit per event type received ++(you can receive multiple events at the same time). The possible bit masks ++are: ++.ie n .IP """EV_READ""" 4 ++.el .IP "\f(CWEV_READ\fR" 4 ++.IX Item "EV_READ" ++.PD 0 ++.ie n .IP """EV_WRITE""" 4 ++.el .IP "\f(CWEV_WRITE\fR" 4 ++.IX Item "EV_WRITE" ++.PD ++The file descriptor in the \f(CW\*(C`ev_io\*(C'\fR watcher has become readable and/or ++writable. ++.ie n .IP """EV_TIMER""" 4 ++.el .IP "\f(CWEV_TIMER\fR" 4 ++.IX Item "EV_TIMER" ++The \f(CW\*(C`ev_timer\*(C'\fR watcher has timed out. ++.ie n .IP """EV_PERIODIC""" 4 ++.el .IP "\f(CWEV_PERIODIC\fR" 4 ++.IX Item "EV_PERIODIC" ++The \f(CW\*(C`ev_periodic\*(C'\fR watcher has timed out. ++.ie n .IP """EV_SIGNAL""" 4 ++.el .IP "\f(CWEV_SIGNAL\fR" 4 ++.IX Item "EV_SIGNAL" ++The signal specified in the \f(CW\*(C`ev_signal\*(C'\fR watcher has been received by a thread. ++.ie n .IP """EV_CHILD""" 4 ++.el .IP "\f(CWEV_CHILD\fR" 4 ++.IX Item "EV_CHILD" ++The pid specified in the \f(CW\*(C`ev_child\*(C'\fR watcher has received a status change. ++.ie n .IP """EV_STAT""" 4 ++.el .IP "\f(CWEV_STAT\fR" 4 ++.IX Item "EV_STAT" ++The path specified in the \f(CW\*(C`ev_stat\*(C'\fR watcher changed its attributes somehow. ++.ie n .IP """EV_IDLE""" 4 ++.el .IP "\f(CWEV_IDLE\fR" 4 ++.IX Item "EV_IDLE" ++The \f(CW\*(C`ev_idle\*(C'\fR watcher has determined that you have nothing better to do. ++.ie n .IP """EV_PREPARE""" 4 ++.el .IP "\f(CWEV_PREPARE\fR" 4 ++.IX Item "EV_PREPARE" ++.PD 0 ++.ie n .IP """EV_CHECK""" 4 ++.el .IP "\f(CWEV_CHECK\fR" 4 ++.IX Item "EV_CHECK" ++.PD ++All \f(CW\*(C`ev_prepare\*(C'\fR watchers are invoked just \fIbefore\fR \f(CW\*(C`ev_run\*(C'\fR starts to ++gather new events, and all \f(CW\*(C`ev_check\*(C'\fR watchers are queued (not invoked) ++just after \f(CW\*(C`ev_run\*(C'\fR has gathered them, but before it queues any callbacks ++for any received events. That means \f(CW\*(C`ev_prepare\*(C'\fR watchers are the last ++watchers invoked before the event loop sleeps or polls for new events, and ++\&\f(CW\*(C`ev_check\*(C'\fR watchers will be invoked before any other watchers of the same ++or lower priority within an event loop iteration. ++.Sp ++Callbacks of both watcher types can start and stop as many watchers as ++they want, and all of them will be taken into account (for example, a ++\&\f(CW\*(C`ev_prepare\*(C'\fR watcher might start an idle watcher to keep \f(CW\*(C`ev_run\*(C'\fR from ++blocking). ++.ie n .IP """EV_EMBED""" 4 ++.el .IP "\f(CWEV_EMBED\fR" 4 ++.IX Item "EV_EMBED" ++The embedded event loop specified in the \f(CW\*(C`ev_embed\*(C'\fR watcher needs attention. ++.ie n .IP """EV_FORK""" 4 ++.el .IP "\f(CWEV_FORK\fR" 4 ++.IX Item "EV_FORK" ++The event loop has been resumed in the child process after fork (see ++\&\f(CW\*(C`ev_fork\*(C'\fR). ++.ie n .IP """EV_CLEANUP""" 4 ++.el .IP "\f(CWEV_CLEANUP\fR" 4 ++.IX Item "EV_CLEANUP" ++The event loop is about to be destroyed (see \f(CW\*(C`ev_cleanup\*(C'\fR). ++.ie n .IP """EV_ASYNC""" 4 ++.el .IP "\f(CWEV_ASYNC\fR" 4 ++.IX Item "EV_ASYNC" ++The given async watcher has been asynchronously notified (see \f(CW\*(C`ev_async\*(C'\fR). ++.ie n .IP """EV_CUSTOM""" 4 ++.el .IP "\f(CWEV_CUSTOM\fR" 4 ++.IX Item "EV_CUSTOM" ++Not ever sent (or otherwise used) by libev itself, but can be freely used ++by libev users to signal watchers (e.g. via \f(CW\*(C`ev_feed_event\*(C'\fR). ++.ie n .IP """EV_ERROR""" 4 ++.el .IP "\f(CWEV_ERROR\fR" 4 ++.IX Item "EV_ERROR" ++An unspecified error has occurred, the watcher has been stopped. This might ++happen because the watcher could not be properly started because libev ++ran out of memory, a file descriptor was found to be closed or any other ++problem. Libev considers these application bugs. ++.Sp ++You best act on it by reporting the problem and somehow coping with the ++watcher being stopped. Note that well-written programs should not receive ++an error ever, so when your watcher receives it, this usually indicates a ++bug in your program. ++.Sp ++Libev will usually signal a few \*(L"dummy\*(R" events together with an error, for ++example it might indicate that a fd is readable or writable, and if your ++callbacks is well-written it can just attempt the operation and cope with ++the error from \fIread()\fR or \fIwrite()\fR. This will not work in multi-threaded ++programs, though, as the fd could already be closed and reused for another ++thing, so beware. ++.SS "\s-1GENERIC\s0 \s-1WATCHER\s0 \s-1FUNCTIONS\s0" ++.IX Subsection "GENERIC WATCHER FUNCTIONS" ++.ie n .IP """ev_init"" (ev_TYPE *watcher, callback)" 4 ++.el .IP "\f(CWev_init\fR (ev_TYPE *watcher, callback)" 4 ++.IX Item "ev_init (ev_TYPE *watcher, callback)" ++This macro initialises the generic portion of a watcher. The contents ++of the watcher object can be arbitrary (so \f(CW\*(C`malloc\*(C'\fR will do). Only ++the generic parts of the watcher are initialised, you \fIneed\fR to call ++the type-specific \f(CW\*(C`ev_TYPE_set\*(C'\fR macro afterwards to initialise the ++type-specific parts. For each type there is also a \f(CW\*(C`ev_TYPE_init\*(C'\fR macro ++which rolls both calls into one. ++.Sp ++You can reinitialise a watcher at any time as long as it has been stopped ++(or never started) and there are no pending events outstanding. ++.Sp ++The callback is always of type \f(CW\*(C`void (*)(struct ev_loop *loop, ev_TYPE *watcher, ++int revents)\*(C'\fR. ++.Sp ++Example: Initialise an \f(CW\*(C`ev_io\*(C'\fR watcher in two steps. ++.Sp ++.Vb 3 ++\& ev_io w; ++\& ev_init (&w, my_cb); ++\& ev_io_set (&w, STDIN_FILENO, EV_READ); ++.Ve ++.ie n .IP """ev_TYPE_set"" (ev_TYPE *watcher, [args])" 4 ++.el .IP "\f(CWev_TYPE_set\fR (ev_TYPE *watcher, [args])" 4 ++.IX Item "ev_TYPE_set (ev_TYPE *watcher, [args])" ++This macro initialises the type-specific parts of a watcher. You need to ++call \f(CW\*(C`ev_init\*(C'\fR at least once before you call this macro, but you can ++call \f(CW\*(C`ev_TYPE_set\*(C'\fR any number of times. You must not, however, call this ++macro on a watcher that is active (it can be pending, however, which is a ++difference to the \f(CW\*(C`ev_init\*(C'\fR macro). ++.Sp ++Although some watcher types do not have type-specific arguments ++(e.g. \f(CW\*(C`ev_prepare\*(C'\fR) you still need to call its \f(CW\*(C`set\*(C'\fR macro. ++.Sp ++See \f(CW\*(C`ev_init\*(C'\fR, above, for an example. ++.ie n .IP """ev_TYPE_init"" (ev_TYPE *watcher, callback, [args])" 4 ++.el .IP "\f(CWev_TYPE_init\fR (ev_TYPE *watcher, callback, [args])" 4 ++.IX Item "ev_TYPE_init (ev_TYPE *watcher, callback, [args])" ++This convenience macro rolls both \f(CW\*(C`ev_init\*(C'\fR and \f(CW\*(C`ev_TYPE_set\*(C'\fR macro ++calls into a single call. This is the most convenient method to initialise ++a watcher. The same limitations apply, of course. ++.Sp ++Example: Initialise and set an \f(CW\*(C`ev_io\*(C'\fR watcher in one step. ++.Sp ++.Vb 1 ++\& ev_io_init (&w, my_cb, STDIN_FILENO, EV_READ); ++.Ve ++.ie n .IP """ev_TYPE_start"" (loop, ev_TYPE *watcher)" 4 ++.el .IP "\f(CWev_TYPE_start\fR (loop, ev_TYPE *watcher)" 4 ++.IX Item "ev_TYPE_start (loop, ev_TYPE *watcher)" ++Starts (activates) the given watcher. Only active watchers will receive ++events. If the watcher is already active nothing will happen. ++.Sp ++Example: Start the \f(CW\*(C`ev_io\*(C'\fR watcher that is being abused as example in this ++whole section. ++.Sp ++.Vb 1 ++\& ev_io_start (EV_DEFAULT_UC, &w); ++.Ve ++.ie n .IP """ev_TYPE_stop"" (loop, ev_TYPE *watcher)" 4 ++.el .IP "\f(CWev_TYPE_stop\fR (loop, ev_TYPE *watcher)" 4 ++.IX Item "ev_TYPE_stop (loop, ev_TYPE *watcher)" ++Stops the given watcher if active, and clears the pending status (whether ++the watcher was active or not). ++.Sp ++It is possible that stopped watchers are pending \- for example, ++non-repeating timers are being stopped when they become pending \- but ++calling \f(CW\*(C`ev_TYPE_stop\*(C'\fR ensures that the watcher is neither active nor ++pending. If you want to free or reuse the memory used by the watcher it is ++therefore a good idea to always call its \f(CW\*(C`ev_TYPE_stop\*(C'\fR function. ++.IP "bool ev_is_active (ev_TYPE *watcher)" 4 ++.IX Item "bool ev_is_active (ev_TYPE *watcher)" ++Returns a true value iff the watcher is active (i.e. it has been started ++and not yet been stopped). As long as a watcher is active you must not modify ++it. ++.IP "bool ev_is_pending (ev_TYPE *watcher)" 4 ++.IX Item "bool ev_is_pending (ev_TYPE *watcher)" ++Returns a true value iff the watcher is pending, (i.e. it has outstanding ++events but its callback has not yet been invoked). As long as a watcher ++is pending (but not active) you must not call an init function on it (but ++\&\f(CW\*(C`ev_TYPE_set\*(C'\fR is safe), you must not change its priority, and you must ++make sure the watcher is available to libev (e.g. you cannot \f(CW\*(C`free ()\*(C'\fR ++it). ++.IP "callback ev_cb (ev_TYPE *watcher)" 4 ++.IX Item "callback ev_cb (ev_TYPE *watcher)" ++Returns the callback currently set on the watcher. ++.IP "ev_set_cb (ev_TYPE *watcher, callback)" 4 ++.IX Item "ev_set_cb (ev_TYPE *watcher, callback)" ++Change the callback. You can change the callback at virtually any time ++(modulo threads). ++.IP "ev_set_priority (ev_TYPE *watcher, int priority)" 4 ++.IX Item "ev_set_priority (ev_TYPE *watcher, int priority)" ++.PD 0 ++.IP "int ev_priority (ev_TYPE *watcher)" 4 ++.IX Item "int ev_priority (ev_TYPE *watcher)" ++.PD ++Set and query the priority of the watcher. The priority is a small ++integer between \f(CW\*(C`EV_MAXPRI\*(C'\fR (default: \f(CW2\fR) and \f(CW\*(C`EV_MINPRI\*(C'\fR ++(default: \f(CW\*(C`\-2\*(C'\fR). Pending watchers with higher priority will be invoked ++before watchers with lower priority, but priority will not keep watchers ++from being executed (except for \f(CW\*(C`ev_idle\*(C'\fR watchers). ++.Sp ++If you need to suppress invocation when higher priority events are pending ++you need to look at \f(CW\*(C`ev_idle\*(C'\fR watchers, which provide this functionality. ++.Sp ++You \fImust not\fR change the priority of a watcher as long as it is active or ++pending. ++.Sp ++Setting a priority outside the range of \f(CW\*(C`EV_MINPRI\*(C'\fR to \f(CW\*(C`EV_MAXPRI\*(C'\fR is ++fine, as long as you do not mind that the priority value you query might ++or might not have been clamped to the valid range. ++.Sp ++The default priority used by watchers when no priority has been set is ++always \f(CW0\fR, which is supposed to not be too high and not be too low :). ++.Sp ++See \*(L"\s-1WATCHER\s0 \s-1PRIORITY\s0 \s-1MODELS\s0\*(R", below, for a more thorough treatment of ++priorities. ++.IP "ev_invoke (loop, ev_TYPE *watcher, int revents)" 4 ++.IX Item "ev_invoke (loop, ev_TYPE *watcher, int revents)" ++Invoke the \f(CW\*(C`watcher\*(C'\fR with the given \f(CW\*(C`loop\*(C'\fR and \f(CW\*(C`revents\*(C'\fR. Neither ++\&\f(CW\*(C`loop\*(C'\fR nor \f(CW\*(C`revents\*(C'\fR need to be valid as long as the watcher callback ++can deal with that fact, as both are simply passed through to the ++callback. ++.IP "int ev_clear_pending (loop, ev_TYPE *watcher)" 4 ++.IX Item "int ev_clear_pending (loop, ev_TYPE *watcher)" ++If the watcher is pending, this function clears its pending status and ++returns its \f(CW\*(C`revents\*(C'\fR bitset (as if its callback was invoked). If the ++watcher isn't pending it does nothing and returns \f(CW0\fR. ++.Sp ++Sometimes it can be useful to \*(L"poll\*(R" a watcher instead of waiting for its ++callback to be invoked, which can be accomplished with this function. ++.IP "ev_feed_event (loop, ev_TYPE *watcher, int revents)" 4 ++.IX Item "ev_feed_event (loop, ev_TYPE *watcher, int revents)" ++Feeds the given event set into the event loop, as if the specified event ++had happened for the specified watcher (which must be a pointer to an ++initialised but not necessarily started event watcher). Obviously you must ++not free the watcher as long as it has pending events. ++.Sp ++Stopping the watcher, letting libev invoke it, or calling ++\&\f(CW\*(C`ev_clear_pending\*(C'\fR will clear the pending event, even if the watcher was ++not started in the first place. ++.Sp ++See also \f(CW\*(C`ev_feed_fd_event\*(C'\fR and \f(CW\*(C`ev_feed_signal_event\*(C'\fR for related ++functions that do not need a watcher. ++.PP ++See also the \*(L"\s-1ASSOCIATING\s0 \s-1CUSTOM\s0 \s-1DATA\s0 \s-1WITH\s0 A \s-1WATCHER\s0\*(R" and \*(L"\s-1BUILDING\s0 \s-1YOUR\s0 ++\&\s-1OWN\s0 \s-1COMPOSITE\s0 \s-1WATCHERS\s0\*(R" idioms. ++.SS "\s-1WATCHER\s0 \s-1STATES\s0" ++.IX Subsection "WATCHER STATES" ++There are various watcher states mentioned throughout this manual \- ++active, pending and so on. In this section these states and the rules to ++transition between them will be described in more detail \- and while these ++rules might look complicated, they usually do \*(L"the right thing\*(R". ++.IP "initialised" 4 ++.IX Item "initialised" ++Before a watcher can be registered with the event loop it has to be ++initialised. This can be done with a call to \f(CW\*(C`ev_TYPE_init\*(C'\fR, or calls to ++\&\f(CW\*(C`ev_init\*(C'\fR followed by the watcher-specific \f(CW\*(C`ev_TYPE_set\*(C'\fR function. ++.Sp ++In this state it is simply some block of memory that is suitable for ++use in an event loop. It can be moved around, freed, reused etc. at ++will \- as long as you either keep the memory contents intact, or call ++\&\f(CW\*(C`ev_TYPE_init\*(C'\fR again. ++.IP "started/running/active" 4 ++.IX Item "started/running/active" ++Once a watcher has been started with a call to \f(CW\*(C`ev_TYPE_start\*(C'\fR it becomes ++property of the event loop, and is actively waiting for events. While in ++this state it cannot be accessed (except in a few documented ways), moved, ++freed or anything else \- the only legal thing is to keep a pointer to it, ++and call libev functions on it that are documented to work on active watchers. ++.IP "pending" 4 ++.IX Item "pending" ++If a watcher is active and libev determines that an event it is interested ++in has occurred (such as a timer expiring), it will become pending. It will ++stay in this pending state until either it is stopped or its callback is ++about to be invoked, so it is not normally pending inside the watcher ++callback. ++.Sp ++The watcher might or might not be active while it is pending (for example, ++an expired non-repeating timer can be pending but no longer active). If it ++is stopped, it can be freely accessed (e.g. by calling \f(CW\*(C`ev_TYPE_set\*(C'\fR), ++but it is still property of the event loop at this time, so cannot be ++moved, freed or reused. And if it is active the rules described in the ++previous item still apply. ++.Sp ++It is also possible to feed an event on a watcher that is not active (e.g. ++via \f(CW\*(C`ev_feed_event\*(C'\fR), in which case it becomes pending without being ++active. ++.IP "stopped" 4 ++.IX Item "stopped" ++A watcher can be stopped implicitly by libev (in which case it might still ++be pending), or explicitly by calling its \f(CW\*(C`ev_TYPE_stop\*(C'\fR function. The ++latter will clear any pending state the watcher might be in, regardless ++of whether it was active or not, so stopping a watcher explicitly before ++freeing it is often a good idea. ++.Sp ++While stopped (and not pending) the watcher is essentially in the ++initialised state, that is, it can be reused, moved, modified in any way ++you wish (but when you trash the memory block, you need to \f(CW\*(C`ev_TYPE_init\*(C'\fR ++it again). ++.SS "\s-1WATCHER\s0 \s-1PRIORITY\s0 \s-1MODELS\s0" ++.IX Subsection "WATCHER PRIORITY MODELS" ++Many event loops support \fIwatcher priorities\fR, which are usually small ++integers that influence the ordering of event callback invocation ++between watchers in some way, all else being equal. ++.PP ++In libev, Watcher priorities can be set using \f(CW\*(C`ev_set_priority\*(C'\fR. See its ++description for the more technical details such as the actual priority ++range. ++.PP ++There are two common ways how these these priorities are being interpreted ++by event loops: ++.PP ++In the more common lock-out model, higher priorities \*(L"lock out\*(R" invocation ++of lower priority watchers, which means as long as higher priority ++watchers receive events, lower priority watchers are not being invoked. ++.PP ++The less common only-for-ordering model uses priorities solely to order ++callback invocation within a single event loop iteration: Higher priority ++watchers are invoked before lower priority ones, but they all get invoked ++before polling for new events. ++.PP ++Libev uses the second (only-for-ordering) model for all its watchers ++except for idle watchers (which use the lock-out model). ++.PP ++The rationale behind this is that implementing the lock-out model for ++watchers is not well supported by most kernel interfaces, and most event ++libraries will just poll for the same events again and again as long as ++their callbacks have not been executed, which is very inefficient in the ++common case of one high-priority watcher locking out a mass of lower ++priority ones. ++.PP ++Static (ordering) priorities are most useful when you have two or more ++watchers handling the same resource: a typical usage example is having an ++\&\f(CW\*(C`ev_io\*(C'\fR watcher to receive data, and an associated \f(CW\*(C`ev_timer\*(C'\fR to handle ++timeouts. Under load, data might be received while the program handles ++other jobs, but since timers normally get invoked first, the timeout ++handler will be executed before checking for data. In that case, giving ++the timer a lower priority than the I/O watcher ensures that I/O will be ++handled first even under adverse conditions (which is usually, but not ++always, what you want). ++.PP ++Since idle watchers use the \*(L"lock-out\*(R" model, meaning that idle watchers ++will only be executed when no same or higher priority watchers have ++received events, they can be used to implement the \*(L"lock-out\*(R" model when ++required. ++.PP ++For example, to emulate how many other event libraries handle priorities, ++you can associate an \f(CW\*(C`ev_idle\*(C'\fR watcher to each such watcher, and in ++the normal watcher callback, you just start the idle watcher. The real ++processing is done in the idle watcher callback. This causes libev to ++continuously poll and process kernel event data for the watcher, but when ++the lock-out case is known to be rare (which in turn is rare :), this is ++workable. ++.PP ++Usually, however, the lock-out model implemented that way will perform ++miserably under the type of load it was designed to handle. In that case, ++it might be preferable to stop the real watcher before starting the ++idle watcher, so the kernel will not have to process the event in case ++the actual processing will be delayed for considerable time. ++.PP ++Here is an example of an I/O watcher that should run at a strictly lower ++priority than the default, and which should only process data when no ++other events are pending: ++.PP ++.Vb 2 ++\& ev_idle idle; // actual processing watcher ++\& ev_io io; // actual event watcher ++\& ++\& static void ++\& io_cb (EV_P_ ev_io *w, int revents) ++\& { ++\& // stop the I/O watcher, we received the event, but ++\& // are not yet ready to handle it. ++\& ev_io_stop (EV_A_ w); ++\& ++\& // start the idle watcher to handle the actual event. ++\& // it will not be executed as long as other watchers ++\& // with the default priority are receiving events. ++\& ev_idle_start (EV_A_ &idle); ++\& } ++\& ++\& static void ++\& idle_cb (EV_P_ ev_idle *w, int revents) ++\& { ++\& // actual processing ++\& read (STDIN_FILENO, ...); ++\& ++\& // have to start the I/O watcher again, as ++\& // we have handled the event ++\& ev_io_start (EV_P_ &io); ++\& } ++\& ++\& // initialisation ++\& ev_idle_init (&idle, idle_cb); ++\& ev_io_init (&io, io_cb, STDIN_FILENO, EV_READ); ++\& ev_io_start (EV_DEFAULT_ &io); ++.Ve ++.PP ++In the \*(L"real\*(R" world, it might also be beneficial to start a timer, so that ++low-priority connections can not be locked out forever under load. This ++enables your program to keep a lower latency for important connections ++during short periods of high load, while not completely locking out less ++important ones. ++.SH "WATCHER TYPES" ++.IX Header "WATCHER TYPES" ++This section describes each watcher in detail, but will not repeat ++information given in the last section. Any initialisation/set macros, ++functions and members specific to the watcher type are explained. ++.PP ++Members are additionally marked with either \fI[read\-only]\fR, meaning that, ++while the watcher is active, you can look at the member and expect some ++sensible content, but you must not modify it (you can modify it while the ++watcher is stopped to your hearts content), or \fI[read\-write]\fR, which ++means you can expect it to have some sensible content while the watcher ++is active, but you can also modify it. Modifying it may not do something ++sensible or take immediate effect (or do anything at all), but libev will ++not crash or malfunction in any way. ++.ie n .SS """ev_io"" \- is this file descriptor readable or writable?" ++.el .SS "\f(CWev_io\fP \- is this file descriptor readable or writable?" ++.IX Subsection "ev_io - is this file descriptor readable or writable?" ++I/O watchers check whether a file descriptor is readable or writable ++in each iteration of the event loop, or, more precisely, when reading ++would not block the process and writing would at least be able to write ++some data. This behaviour is called level-triggering because you keep ++receiving events as long as the condition persists. Remember you can stop ++the watcher if you don't want to act on the event and neither want to ++receive future events. ++.PP ++In general you can register as many read and/or write event watchers per ++fd as you want (as long as you don't confuse yourself). Setting all file ++descriptors to non-blocking mode is also usually a good idea (but not ++required if you know what you are doing). ++.PP ++Another thing you have to watch out for is that it is quite easy to ++receive \*(L"spurious\*(R" readiness notifications, that is, your callback might ++be called with \f(CW\*(C`EV_READ\*(C'\fR but a subsequent \f(CW\*(C`read\*(C'\fR(2) will actually block ++because there is no data. It is very easy to get into this situation even ++with a relatively standard program structure. Thus it is best to always ++use non-blocking I/O: An extra \f(CW\*(C`read\*(C'\fR(2) returning \f(CW\*(C`EAGAIN\*(C'\fR is far ++preferable to a program hanging until some data arrives. ++.PP ++If you cannot run the fd in non-blocking mode (for example you should ++not play around with an Xlib connection), then you have to separately ++re-test whether a file descriptor is really ready with a known-to-be good ++interface such as poll (fortunately in the case of Xlib, it already does ++this on its own, so its quite safe to use). Some people additionally ++use \f(CW\*(C`SIGALRM\*(C'\fR and an interval timer, just to be sure you won't block ++indefinitely. ++.PP ++But really, best use non-blocking mode. ++.PP ++\fIThe special problem of disappearing file descriptors\fR ++.IX Subsection "The special problem of disappearing file descriptors" ++.PP ++Some backends (e.g. kqueue, epoll) need to be told about closing a file ++descriptor (either due to calling \f(CW\*(C`close\*(C'\fR explicitly or any other means, ++such as \f(CW\*(C`dup2\*(C'\fR). The reason is that you register interest in some file ++descriptor, but when it goes away, the operating system will silently drop ++this interest. If another file descriptor with the same number then is ++registered with libev, there is no efficient way to see that this is, in ++fact, a different file descriptor. ++.PP ++To avoid having to explicitly tell libev about such cases, libev follows ++the following policy: Each time \f(CW\*(C`ev_io_set\*(C'\fR is being called, libev ++will assume that this is potentially a new file descriptor, otherwise ++it is assumed that the file descriptor stays the same. That means that ++you \fIhave\fR to call \f(CW\*(C`ev_io_set\*(C'\fR (or \f(CW\*(C`ev_io_init\*(C'\fR) when you change the ++descriptor even if the file descriptor number itself did not change. ++.PP ++This is how one would do it normally anyway, the important point is that ++the libev application should not optimise around libev but should leave ++optimisations to libev. ++.PP ++\fIThe special problem of dup'ed file descriptors\fR ++.IX Subsection "The special problem of dup'ed file descriptors" ++.PP ++Some backends (e.g. epoll), cannot register events for file descriptors, ++but only events for the underlying file descriptions. That means when you ++have \f(CW\*(C`dup ()\*(C'\fR'ed file descriptors or weirder constellations, and register ++events for them, only one file descriptor might actually receive events. ++.PP ++There is no workaround possible except not registering events ++for potentially \f(CW\*(C`dup ()\*(C'\fR'ed file descriptors, or to resort to ++\&\f(CW\*(C`EVBACKEND_SELECT\*(C'\fR or \f(CW\*(C`EVBACKEND_POLL\*(C'\fR. ++.PP ++\fIThe special problem of files\fR ++.IX Subsection "The special problem of files" ++.PP ++Many people try to use \f(CW\*(C`select\*(C'\fR (or libev) on file descriptors ++representing files, and expect it to become ready when their program ++doesn't block on disk accesses (which can take a long time on their own). ++.PP ++However, this cannot ever work in the \*(L"expected\*(R" way \- you get a readiness ++notification as soon as the kernel knows whether and how much data is ++there, and in the case of open files, that's always the case, so you ++always get a readiness notification instantly, and your read (or possibly ++write) will still block on the disk I/O. ++.PP ++Another way to view it is that in the case of sockets, pipes, character ++devices and so on, there is another party (the sender) that delivers data ++on its own, but in the case of files, there is no such thing: the disk ++will not send data on its own, simply because it doesn't know what you ++wish to read \- you would first have to request some data. ++.PP ++Since files are typically not-so-well supported by advanced notification ++mechanism, libev tries hard to emulate \s-1POSIX\s0 behaviour with respect ++to files, even though you should not use it. The reason for this is ++convenience: sometimes you want to watch \s-1STDIN\s0 or \s-1STDOUT\s0, which is ++usually a tty, often a pipe, but also sometimes files or special devices ++(for example, \f(CW\*(C`epoll\*(C'\fR on Linux works with \fI/dev/random\fR but not with ++\&\fI/dev/urandom\fR), and even though the file might better be served with ++asynchronous I/O instead of with non-blocking I/O, it is still useful when ++it \*(L"just works\*(R" instead of freezing. ++.PP ++So avoid file descriptors pointing to files when you know it (e.g. use ++libeio), but use them when it is convenient, e.g. for \s-1STDIN/STDOUT\s0, or ++when you rarely read from a file instead of from a socket, and want to ++reuse the same code path. ++.PP ++\fIThe special problem of fork\fR ++.IX Subsection "The special problem of fork" ++.PP ++Some backends (epoll, kqueue) do not support \f(CW\*(C`fork ()\*(C'\fR at all or exhibit ++useless behaviour. Libev fully supports fork, but needs to be told about ++it in the child if you want to continue to use it in the child. ++.PP ++To support fork in your child processes, you have to call \f(CW\*(C`ev_loop_fork ++()\*(C'\fR after a fork in the child, enable \f(CW\*(C`EVFLAG_FORKCHECK\*(C'\fR, or resort to ++\&\f(CW\*(C`EVBACKEND_SELECT\*(C'\fR or \f(CW\*(C`EVBACKEND_POLL\*(C'\fR. ++.PP ++\fIThe special problem of \s-1SIGPIPE\s0\fR ++.IX Subsection "The special problem of SIGPIPE" ++.PP ++While not really specific to libev, it is easy to forget about \f(CW\*(C`SIGPIPE\*(C'\fR: ++when writing to a pipe whose other end has been closed, your program gets ++sent a \s-1SIGPIPE\s0, which, by default, aborts your program. For most programs ++this is sensible behaviour, for daemons, this is usually undesirable. ++.PP ++So when you encounter spurious, unexplained daemon exits, make sure you ++ignore \s-1SIGPIPE\s0 (and maybe make sure you log the exit status of your daemon ++somewhere, as that would have given you a big clue). ++.PP ++\fIThe special problem of \fIaccept()\fIing when you can't\fR ++.IX Subsection "The special problem of accept()ing when you can't" ++.PP ++Many implementations of the \s-1POSIX\s0 \f(CW\*(C`accept\*(C'\fR function (for example, ++found in post\-2004 Linux) have the peculiar behaviour of not removing a ++connection from the pending queue in all error cases. ++.PP ++For example, larger servers often run out of file descriptors (because ++of resource limits), causing \f(CW\*(C`accept\*(C'\fR to fail with \f(CW\*(C`ENFILE\*(C'\fR but not ++rejecting the connection, leading to libev signalling readiness on ++the next iteration again (the connection still exists after all), and ++typically causing the program to loop at 100% \s-1CPU\s0 usage. ++.PP ++Unfortunately, the set of errors that cause this issue differs between ++operating systems, there is usually little the app can do to remedy the ++situation, and no known thread-safe method of removing the connection to ++cope with overload is known (to me). ++.PP ++One of the easiest ways to handle this situation is to just ignore it ++\&\- when the program encounters an overload, it will just loop until the ++situation is over. While this is a form of busy waiting, no \s-1OS\s0 offers an ++event-based way to handle this situation, so it's the best one can do. ++.PP ++A better way to handle the situation is to log any errors other than ++\&\f(CW\*(C`EAGAIN\*(C'\fR and \f(CW\*(C`EWOULDBLOCK\*(C'\fR, making sure not to flood the log with such ++messages, and continue as usual, which at least gives the user an idea of ++what could be wrong (\*(L"raise the ulimit!\*(R"). For extra points one could stop ++the \f(CW\*(C`ev_io\*(C'\fR watcher on the listening fd \*(L"for a while\*(R", which reduces \s-1CPU\s0 ++usage. ++.PP ++If your program is single-threaded, then you could also keep a dummy file ++descriptor for overload situations (e.g. by opening \fI/dev/null\fR), and ++when you run into \f(CW\*(C`ENFILE\*(C'\fR or \f(CW\*(C`EMFILE\*(C'\fR, close it, run \f(CW\*(C`accept\*(C'\fR, ++close that fd, and create a new dummy fd. This will gracefully refuse ++clients under typical overload conditions. ++.PP ++The last way to handle it is to simply log the error and \f(CW\*(C`exit\*(C'\fR, as ++is often done with \f(CW\*(C`malloc\*(C'\fR failures, but this results in an easy ++opportunity for a DoS attack. ++.PP ++\fIWatcher-Specific Functions\fR ++.IX Subsection "Watcher-Specific Functions" ++.IP "ev_io_init (ev_io *, callback, int fd, int events)" 4 ++.IX Item "ev_io_init (ev_io *, callback, int fd, int events)" ++.PD 0 ++.IP "ev_io_set (ev_io *, int fd, int events)" 4 ++.IX Item "ev_io_set (ev_io *, int fd, int events)" ++.PD ++Configures an \f(CW\*(C`ev_io\*(C'\fR watcher. The \f(CW\*(C`fd\*(C'\fR is the file descriptor to ++receive events for and \f(CW\*(C`events\*(C'\fR is either \f(CW\*(C`EV_READ\*(C'\fR, \f(CW\*(C`EV_WRITE\*(C'\fR or ++\&\f(CW\*(C`EV_READ | EV_WRITE\*(C'\fR, to express the desire to receive the given events. ++.IP "int fd [read\-only]" 4 ++.IX Item "int fd [read-only]" ++The file descriptor being watched. ++.IP "int events [read\-only]" 4 ++.IX Item "int events [read-only]" ++The events being watched. ++.PP ++\fIExamples\fR ++.IX Subsection "Examples" ++.PP ++Example: Call \f(CW\*(C`stdin_readable_cb\*(C'\fR when \s-1STDIN_FILENO\s0 has become, well ++readable, but only once. Since it is likely line-buffered, you could ++attempt to read a whole line in the callback. ++.PP ++.Vb 6 ++\& static void ++\& stdin_readable_cb (struct ev_loop *loop, ev_io *w, int revents) ++\& { ++\& ev_io_stop (loop, w); ++\& .. read from stdin here (or from w\->fd) and handle any I/O errors ++\& } ++\& ++\& ... ++\& struct ev_loop *loop = ev_default_init (0); ++\& ev_io stdin_readable; ++\& ev_io_init (&stdin_readable, stdin_readable_cb, STDIN_FILENO, EV_READ); ++\& ev_io_start (loop, &stdin_readable); ++\& ev_run (loop, 0); ++.Ve ++.ie n .SS """ev_timer"" \- relative and optionally repeating timeouts" ++.el .SS "\f(CWev_timer\fP \- relative and optionally repeating timeouts" ++.IX Subsection "ev_timer - relative and optionally repeating timeouts" ++Timer watchers are simple relative timers that generate an event after a ++given time, and optionally repeating in regular intervals after that. ++.PP ++The timers are based on real time, that is, if you register an event that ++times out after an hour and you reset your system clock to January last ++year, it will still time out after (roughly) one hour. \*(L"Roughly\*(R" because ++detecting time jumps is hard, and some inaccuracies are unavoidable (the ++monotonic clock option helps a lot here). ++.PP ++The callback is guaranteed to be invoked only \fIafter\fR its timeout has ++passed (not \fIat\fR, so on systems with very low-resolution clocks this ++might introduce a small delay, see \*(L"the special problem of being too ++early\*(R", below). If multiple timers become ready during the same loop ++iteration then the ones with earlier time-out values are invoked before ++ones of the same priority with later time-out values (but this is no ++longer true when a callback calls \f(CW\*(C`ev_run\*(C'\fR recursively). ++.PP ++\fIBe smart about timeouts\fR ++.IX Subsection "Be smart about timeouts" ++.PP ++Many real-world problems involve some kind of timeout, usually for error ++recovery. A typical example is an \s-1HTTP\s0 request \- if the other side hangs, ++you want to raise some error after a while. ++.PP ++What follows are some ways to handle this problem, from obvious and ++inefficient to smart and efficient. ++.PP ++In the following, a 60 second activity timeout is assumed \- a timeout that ++gets reset to 60 seconds each time there is activity (e.g. each time some ++data or other life sign was received). ++.IP "1. Use a timer and stop, reinitialise and start it on activity." 4 ++.IX Item "1. Use a timer and stop, reinitialise and start it on activity." ++This is the most obvious, but not the most simple way: In the beginning, ++start the watcher: ++.Sp ++.Vb 2 ++\& ev_timer_init (timer, callback, 60., 0.); ++\& ev_timer_start (loop, timer); ++.Ve ++.Sp ++Then, each time there is some activity, \f(CW\*(C`ev_timer_stop\*(C'\fR it, initialise it ++and start it again: ++.Sp ++.Vb 3 ++\& ev_timer_stop (loop, timer); ++\& ev_timer_set (timer, 60., 0.); ++\& ev_timer_start (loop, timer); ++.Ve ++.Sp ++This is relatively simple to implement, but means that each time there is ++some activity, libev will first have to remove the timer from its internal ++data structure and then add it again. Libev tries to be fast, but it's ++still not a constant-time operation. ++.ie n .IP "2. Use a timer and re-start it with ""ev_timer_again"" inactivity." 4 ++.el .IP "2. Use a timer and re-start it with \f(CWev_timer_again\fR inactivity." 4 ++.IX Item "2. Use a timer and re-start it with ev_timer_again inactivity." ++This is the easiest way, and involves using \f(CW\*(C`ev_timer_again\*(C'\fR instead of ++\&\f(CW\*(C`ev_timer_start\*(C'\fR. ++.Sp ++To implement this, configure an \f(CW\*(C`ev_timer\*(C'\fR with a \f(CW\*(C`repeat\*(C'\fR value ++of \f(CW60\fR and then call \f(CW\*(C`ev_timer_again\*(C'\fR at start and each time you ++successfully read or write some data. If you go into an idle state where ++you do not expect data to travel on the socket, you can \f(CW\*(C`ev_timer_stop\*(C'\fR ++the timer, and \f(CW\*(C`ev_timer_again\*(C'\fR will automatically restart it if need be. ++.Sp ++That means you can ignore both the \f(CW\*(C`ev_timer_start\*(C'\fR function and the ++\&\f(CW\*(C`after\*(C'\fR argument to \f(CW\*(C`ev_timer_set\*(C'\fR, and only ever use the \f(CW\*(C`repeat\*(C'\fR ++member and \f(CW\*(C`ev_timer_again\*(C'\fR. ++.Sp ++At start: ++.Sp ++.Vb 3 ++\& ev_init (timer, callback); ++\& timer\->repeat = 60.; ++\& ev_timer_again (loop, timer); ++.Ve ++.Sp ++Each time there is some activity: ++.Sp ++.Vb 1 ++\& ev_timer_again (loop, timer); ++.Ve ++.Sp ++It is even possible to change the time-out on the fly, regardless of ++whether the watcher is active or not: ++.Sp ++.Vb 2 ++\& timer\->repeat = 30.; ++\& ev_timer_again (loop, timer); ++.Ve ++.Sp ++This is slightly more efficient then stopping/starting the timer each time ++you want to modify its timeout value, as libev does not have to completely ++remove and re-insert the timer from/into its internal data structure. ++.Sp ++It is, however, even simpler than the \*(L"obvious\*(R" way to do it. ++.IP "3. Let the timer time out, but then re-arm it as required." 4 ++.IX Item "3. Let the timer time out, but then re-arm it as required." ++This method is more tricky, but usually most efficient: Most timeouts are ++relatively long compared to the intervals between other activity \- in ++our example, within 60 seconds, there are usually many I/O events with ++associated activity resets. ++.Sp ++In this case, it would be more efficient to leave the \f(CW\*(C`ev_timer\*(C'\fR alone, ++but remember the time of last activity, and check for a real timeout only ++within the callback: ++.Sp ++.Vb 3 ++\& ev_tstamp timeout = 60.; ++\& ev_tstamp last_activity; // time of last activity ++\& ev_timer timer; ++\& ++\& static void ++\& callback (EV_P_ ev_timer *w, int revents) ++\& { ++\& // calculate when the timeout would happen ++\& ev_tstamp after = last_activity \- ev_now (EV_A) + timeout; ++\& ++\& // if negative, it means we the timeout already occurred ++\& if (after < 0.) ++\& { ++\& // timeout occurred, take action ++\& } ++\& else ++\& { ++\& // callback was invoked, but there was some recent ++\& // activity. simply restart the timer to time out ++\& // after "after" seconds, which is the earliest time ++\& // the timeout can occur. ++\& ev_timer_set (w, after, 0.); ++\& ev_timer_start (EV_A_ w); ++\& } ++\& } ++.Ve ++.Sp ++To summarise the callback: first calculate in how many seconds the ++timeout will occur (by calculating the absolute time when it would occur, ++\&\f(CW\*(C`last_activity + timeout\*(C'\fR, and subtracting the current time, \f(CW\*(C`ev_now ++(EV_A)\*(C'\fR from that). ++.Sp ++If this value is negative, then we are already past the timeout, i.e. we ++timed out, and need to do whatever is needed in this case. ++.Sp ++Otherwise, we now the earliest time at which the timeout would trigger, ++and simply start the timer with this timeout value. ++.Sp ++In other words, each time the callback is invoked it will check whether ++the timeout occurred. If not, it will simply reschedule itself to check ++again at the earliest time it could time out. Rinse. Repeat. ++.Sp ++This scheme causes more callback invocations (about one every 60 seconds ++minus half the average time between activity), but virtually no calls to ++libev to change the timeout. ++.Sp ++To start the machinery, simply initialise the watcher and set ++\&\f(CW\*(C`last_activity\*(C'\fR to the current time (meaning there was some activity just ++now), then call the callback, which will \*(L"do the right thing\*(R" and start ++the timer: ++.Sp ++.Vb 3 ++\& last_activity = ev_now (EV_A); ++\& ev_init (&timer, callback); ++\& callback (EV_A_ &timer, 0); ++.Ve ++.Sp ++When there is some activity, simply store the current time in ++\&\f(CW\*(C`last_activity\*(C'\fR, no libev calls at all: ++.Sp ++.Vb 2 ++\& if (activity detected) ++\& last_activity = ev_now (EV_A); ++.Ve ++.Sp ++When your timeout value changes, then the timeout can be changed by simply ++providing a new value, stopping the timer and calling the callback, which ++will again do the right thing (for example, time out immediately :). ++.Sp ++.Vb 3 ++\& timeout = new_value; ++\& ev_timer_stop (EV_A_ &timer); ++\& callback (EV_A_ &timer, 0); ++.Ve ++.Sp ++This technique is slightly more complex, but in most cases where the ++time-out is unlikely to be triggered, much more efficient. ++.IP "4. Wee, just use a double-linked list for your timeouts." 4 ++.IX Item "4. Wee, just use a double-linked list for your timeouts." ++If there is not one request, but many thousands (millions...), all ++employing some kind of timeout with the same timeout value, then one can ++do even better: ++.Sp ++When starting the timeout, calculate the timeout value and put the timeout ++at the \fIend\fR of the list. ++.Sp ++Then use an \f(CW\*(C`ev_timer\*(C'\fR to fire when the timeout at the \fIbeginning\fR of ++the list is expected to fire (for example, using the technique #3). ++.Sp ++When there is some activity, remove the timer from the list, recalculate ++the timeout, append it to the end of the list again, and make sure to ++update the \f(CW\*(C`ev_timer\*(C'\fR if it was taken from the beginning of the list. ++.Sp ++This way, one can manage an unlimited number of timeouts in O(1) time for ++starting, stopping and updating the timers, at the expense of a major ++complication, and having to use a constant timeout. The constant timeout ++ensures that the list stays sorted. ++.PP ++So which method the best? ++.PP ++Method #2 is a simple no-brain-required solution that is adequate in most ++situations. Method #3 requires a bit more thinking, but handles many cases ++better, and isn't very complicated either. In most case, choosing either ++one is fine, with #3 being better in typical situations. ++.PP ++Method #1 is almost always a bad idea, and buys you nothing. Method #4 is ++rather complicated, but extremely efficient, something that really pays ++off after the first million or so of active timers, i.e. it's usually ++overkill :) ++.PP ++\fIThe special problem of being too early\fR ++.IX Subsection "The special problem of being too early" ++.PP ++If you ask a timer to call your callback after three seconds, then ++you expect it to be invoked after three seconds \- but of course, this ++cannot be guaranteed to infinite precision. Less obviously, it cannot be ++guaranteed to any precision by libev \- imagine somebody suspending the ++process with a \s-1STOP\s0 signal for a few hours for example. ++.PP ++So, libev tries to invoke your callback as soon as possible \fIafter\fR the ++delay has occurred, but cannot guarantee this. ++.PP ++A less obvious failure mode is calling your callback too early: many event ++loops compare timestamps with a \*(L"elapsed delay >= requested delay\*(R", but ++this can cause your callback to be invoked much earlier than you would ++expect. ++.PP ++To see why, imagine a system with a clock that only offers full second ++resolution (think windows if you can't come up with a broken enough \s-1OS\s0 ++yourself). If you schedule a one-second timer at the time 500.9, then the ++event loop will schedule your timeout to elapse at a system time of 500 ++(500.9 truncated to the resolution) + 1, or 501. ++.PP ++If an event library looks at the timeout 0.1s later, it will see \*(L"501 >= ++501\*(R" and invoke the callback 0.1s after it was started, even though a ++one-second delay was requested \- this is being \*(L"too early\*(R", despite best ++intentions. ++.PP ++This is the reason why libev will never invoke the callback if the elapsed ++delay equals the requested delay, but only when the elapsed delay is ++larger than the requested delay. In the example above, libev would only invoke ++the callback at system time 502, or 1.1s after the timer was started. ++.PP ++So, while libev cannot guarantee that your callback will be invoked ++exactly when requested, it \fIcan\fR and \fIdoes\fR guarantee that the requested ++delay has actually elapsed, or in other words, it always errs on the \*(L"too ++late\*(R" side of things. ++.PP ++\fIThe special problem of time updates\fR ++.IX Subsection "The special problem of time updates" ++.PP ++Establishing the current time is a costly operation (it usually takes ++at least one system call): \s-1EV\s0 therefore updates its idea of the current ++time only before and after \f(CW\*(C`ev_run\*(C'\fR collects new events, which causes a ++growing difference between \f(CW\*(C`ev_now ()\*(C'\fR and \f(CW\*(C`ev_time ()\*(C'\fR when handling ++lots of events in one iteration. ++.PP ++The relative timeouts are calculated relative to the \f(CW\*(C`ev_now ()\*(C'\fR ++time. This is usually the right thing as this timestamp refers to the time ++of the event triggering whatever timeout you are modifying/starting. If ++you suspect event processing to be delayed and you \fIneed\fR to base the ++timeout on the current time, use something like this to adjust for this: ++.PP ++.Vb 1 ++\& ev_timer_set (&timer, after + ev_now () \- ev_time (), 0.); ++.Ve ++.PP ++If the event loop is suspended for a long time, you can also force an ++update of the time returned by \f(CW\*(C`ev_now ()\*(C'\fR by calling \f(CW\*(C`ev_now_update ++()\*(C'\fR. ++.PP ++\fIThe special problem of unsynchronised clocks\fR ++.IX Subsection "The special problem of unsynchronised clocks" ++.PP ++Modern systems have a variety of clocks \- libev itself uses the normal ++\&\*(L"wall clock\*(R" clock and, if available, the monotonic clock (to avoid time ++jumps). ++.PP ++Neither of these clocks is synchronised with each other or any other clock ++on the system, so \f(CW\*(C`ev_time ()\*(C'\fR might return a considerably different time ++than \f(CW\*(C`gettimeofday ()\*(C'\fR or \f(CW\*(C`time ()\*(C'\fR. On a GNU/Linux system, for example, ++a call to \f(CW\*(C`gettimeofday\*(C'\fR might return a second count that is one higher ++than a directly following call to \f(CW\*(C`time\*(C'\fR. ++.PP ++The moral of this is to only compare libev-related timestamps with ++\&\f(CW\*(C`ev_time ()\*(C'\fR and \f(CW\*(C`ev_now ()\*(C'\fR, at least if you want better precision than ++a second or so. ++.PP ++One more problem arises due to this lack of synchronisation: if libev uses ++the system monotonic clock and you compare timestamps from \f(CW\*(C`ev_time\*(C'\fR ++or \f(CW\*(C`ev_now\*(C'\fR from when you started your timer and when your callback is ++invoked, you will find that sometimes the callback is a bit \*(L"early\*(R". ++.PP ++This is because \f(CW\*(C`ev_timer\*(C'\fRs work in real time, not wall clock time, so ++libev makes sure your callback is not invoked before the delay happened, ++\&\fImeasured according to the real time\fR, not the system clock. ++.PP ++If your timeouts are based on a physical timescale (e.g. \*(L"time out this ++connection after 100 seconds\*(R") then this shouldn't bother you as it is ++exactly the right behaviour. ++.PP ++If you want to compare wall clock/system timestamps to your timers, then ++you need to use \f(CW\*(C`ev_periodic\*(C'\fRs, as these are based on the wall clock ++time, where your comparisons will always generate correct results. ++.PP ++\fIThe special problems of suspended animation\fR ++.IX Subsection "The special problems of suspended animation" ++.PP ++When you leave the server world it is quite customary to hit machines that ++can suspend/hibernate \- what happens to the clocks during such a suspend? ++.PP ++Some quick tests made with a Linux 2.6.28 indicate that a suspend freezes ++all processes, while the clocks (\f(CW\*(C`times\*(C'\fR, \f(CW\*(C`CLOCK_MONOTONIC\*(C'\fR) continue ++to run until the system is suspended, but they will not advance while the ++system is suspended. That means, on resume, it will be as if the program ++was frozen for a few seconds, but the suspend time will not be counted ++towards \f(CW\*(C`ev_timer\*(C'\fR when a monotonic clock source is used. The real time ++clock advanced as expected, but if it is used as sole clocksource, then a ++long suspend would be detected as a time jump by libev, and timers would ++be adjusted accordingly. ++.PP ++I would not be surprised to see different behaviour in different between ++operating systems, \s-1OS\s0 versions or even different hardware. ++.PP ++The other form of suspend (job control, or sending a \s-1SIGSTOP\s0) will see a ++time jump in the monotonic clocks and the realtime clock. If the program ++is suspended for a very long time, and monotonic clock sources are in use, ++then you can expect \f(CW\*(C`ev_timer\*(C'\fRs to expire as the full suspension time ++will be counted towards the timers. When no monotonic clock source is in ++use, then libev will again assume a timejump and adjust accordingly. ++.PP ++It might be beneficial for this latter case to call \f(CW\*(C`ev_suspend\*(C'\fR ++and \f(CW\*(C`ev_resume\*(C'\fR in code that handles \f(CW\*(C`SIGTSTP\*(C'\fR, to at least get ++deterministic behaviour in this case (you can do nothing against ++\&\f(CW\*(C`SIGSTOP\*(C'\fR). ++.PP ++\fIWatcher-Specific Functions and Data Members\fR ++.IX Subsection "Watcher-Specific Functions and Data Members" ++.IP "ev_timer_init (ev_timer *, callback, ev_tstamp after, ev_tstamp repeat)" 4 ++.IX Item "ev_timer_init (ev_timer *, callback, ev_tstamp after, ev_tstamp repeat)" ++.PD 0 ++.IP "ev_timer_set (ev_timer *, ev_tstamp after, ev_tstamp repeat)" 4 ++.IX Item "ev_timer_set (ev_timer *, ev_tstamp after, ev_tstamp repeat)" ++.PD ++Configure the timer to trigger after \f(CW\*(C`after\*(C'\fR seconds. If \f(CW\*(C`repeat\*(C'\fR ++is \f(CW0.\fR, then it will automatically be stopped once the timeout is ++reached. If it is positive, then the timer will automatically be ++configured to trigger again \f(CW\*(C`repeat\*(C'\fR seconds later, again, and again, ++until stopped manually. ++.Sp ++The timer itself will do a best-effort at avoiding drift, that is, if ++you configure a timer to trigger every 10 seconds, then it will normally ++trigger at exactly 10 second intervals. If, however, your program cannot ++keep up with the timer (because it takes longer than those 10 seconds to ++do stuff) the timer will not fire more than once per event loop iteration. ++.IP "ev_timer_again (loop, ev_timer *)" 4 ++.IX Item "ev_timer_again (loop, ev_timer *)" ++This will act as if the timer timed out, and restarts it again if it is ++repeating. It basically works like calling \f(CW\*(C`ev_timer_stop\*(C'\fR, updating the ++timeout to the \f(CW\*(C`repeat\*(C'\fR value and calling \f(CW\*(C`ev_timer_start\*(C'\fR. ++.Sp ++The exact semantics are as in the following rules, all of which will be ++applied to the watcher: ++.RS 4 ++.IP "If the timer is pending, the pending status is always cleared." 4 ++.IX Item "If the timer is pending, the pending status is always cleared." ++.PD 0 ++.IP "If the timer is started but non-repeating, stop it (as if it timed out, without invoking it)." 4 ++.IX Item "If the timer is started but non-repeating, stop it (as if it timed out, without invoking it)." ++.ie n .IP "If the timer is repeating, make the ""repeat"" value the new timeout and start the timer, if necessary." 4 ++.el .IP "If the timer is repeating, make the \f(CWrepeat\fR value the new timeout and start the timer, if necessary." 4 ++.IX Item "If the timer is repeating, make the repeat value the new timeout and start the timer, if necessary." ++.RE ++.RS 4 ++.PD ++.Sp ++This sounds a bit complicated, see \*(L"Be smart about timeouts\*(R", above, for a ++usage example. ++.RE ++.IP "ev_tstamp ev_timer_remaining (loop, ev_timer *)" 4 ++.IX Item "ev_tstamp ev_timer_remaining (loop, ev_timer *)" ++Returns the remaining time until a timer fires. If the timer is active, ++then this time is relative to the current event loop time, otherwise it's ++the timeout value currently configured. ++.Sp ++That is, after an \f(CW\*(C`ev_timer_set (w, 5, 7)\*(C'\fR, \f(CW\*(C`ev_timer_remaining\*(C'\fR returns ++\&\f(CW5\fR. When the timer is started and one second passes, \f(CW\*(C`ev_timer_remaining\*(C'\fR ++will return \f(CW4\fR. When the timer expires and is restarted, it will return ++roughly \f(CW7\fR (likely slightly less as callback invocation takes some time, ++too), and so on. ++.IP "ev_tstamp repeat [read\-write]" 4 ++.IX Item "ev_tstamp repeat [read-write]" ++The current \f(CW\*(C`repeat\*(C'\fR value. Will be used each time the watcher times out ++or \f(CW\*(C`ev_timer_again\*(C'\fR is called, and determines the next timeout (if any), ++which is also when any modifications are taken into account. ++.PP ++\fIExamples\fR ++.IX Subsection "Examples" ++.PP ++Example: Create a timer that fires after 60 seconds. ++.PP ++.Vb 5 ++\& static void ++\& one_minute_cb (struct ev_loop *loop, ev_timer *w, int revents) ++\& { ++\& .. one minute over, w is actually stopped right here ++\& } ++\& ++\& ev_timer mytimer; ++\& ev_timer_init (&mytimer, one_minute_cb, 60., 0.); ++\& ev_timer_start (loop, &mytimer); ++.Ve ++.PP ++Example: Create a timeout timer that times out after 10 seconds of ++inactivity. ++.PP ++.Vb 5 ++\& static void ++\& timeout_cb (struct ev_loop *loop, ev_timer *w, int revents) ++\& { ++\& .. ten seconds without any activity ++\& } ++\& ++\& ev_timer mytimer; ++\& ev_timer_init (&mytimer, timeout_cb, 0., 10.); /* note, only repeat used */ ++\& ev_timer_again (&mytimer); /* start timer */ ++\& ev_run (loop, 0); ++\& ++\& // and in some piece of code that gets executed on any "activity": ++\& // reset the timeout to start ticking again at 10 seconds ++\& ev_timer_again (&mytimer); ++.Ve ++.ie n .SS """ev_periodic"" \- to cron or not to cron?" ++.el .SS "\f(CWev_periodic\fP \- to cron or not to cron?" ++.IX Subsection "ev_periodic - to cron or not to cron?" ++Periodic watchers are also timers of a kind, but they are very versatile ++(and unfortunately a bit complex). ++.PP ++Unlike \f(CW\*(C`ev_timer\*(C'\fR, periodic watchers are not based on real time (or ++relative time, the physical time that passes) but on wall clock time ++(absolute time, the thing you can read on your calender or clock). The ++difference is that wall clock time can run faster or slower than real ++time, and time jumps are not uncommon (e.g. when you adjust your ++wrist-watch). ++.PP ++You can tell a periodic watcher to trigger after some specific point ++in time: for example, if you tell a periodic watcher to trigger \*(L"in 10 ++seconds\*(R" (by specifying e.g. \f(CW\*(C`ev_now () + 10.\*(C'\fR, that is, an absolute time ++not a delay) and then reset your system clock to January of the previous ++year, then it will take a year or more to trigger the event (unlike an ++\&\f(CW\*(C`ev_timer\*(C'\fR, which would still trigger roughly 10 seconds after starting ++it, as it uses a relative timeout). ++.PP ++\&\f(CW\*(C`ev_periodic\*(C'\fR watchers can also be used to implement vastly more complex ++timers, such as triggering an event on each \*(L"midnight, local time\*(R", or ++other complicated rules. This cannot be done with \f(CW\*(C`ev_timer\*(C'\fR watchers, as ++those cannot react to time jumps. ++.PP ++As with timers, the callback is guaranteed to be invoked only when the ++point in time where it is supposed to trigger has passed. If multiple ++timers become ready during the same loop iteration then the ones with ++earlier time-out values are invoked before ones with later time-out values ++(but this is no longer true when a callback calls \f(CW\*(C`ev_run\*(C'\fR recursively). ++.PP ++\fIWatcher-Specific Functions and Data Members\fR ++.IX Subsection "Watcher-Specific Functions and Data Members" ++.IP "ev_periodic_init (ev_periodic *, callback, ev_tstamp offset, ev_tstamp interval, reschedule_cb)" 4 ++.IX Item "ev_periodic_init (ev_periodic *, callback, ev_tstamp offset, ev_tstamp interval, reschedule_cb)" ++.PD 0 ++.IP "ev_periodic_set (ev_periodic *, ev_tstamp offset, ev_tstamp interval, reschedule_cb)" 4 ++.IX Item "ev_periodic_set (ev_periodic *, ev_tstamp offset, ev_tstamp interval, reschedule_cb)" ++.PD ++Lots of arguments, let's sort it out... There are basically three modes of ++operation, and we will explain them from simplest to most complex: ++.RS 4 ++.IP "\(bu" 4 ++absolute timer (offset = absolute time, interval = 0, reschedule_cb = 0) ++.Sp ++In this configuration the watcher triggers an event after the wall clock ++time \f(CW\*(C`offset\*(C'\fR has passed. It will not repeat and will not adjust when a ++time jump occurs, that is, if it is to be run at January 1st 2011 then it ++will be stopped and invoked when the system clock reaches or surpasses ++this point in time. ++.IP "\(bu" 4 ++repeating interval timer (offset = offset within interval, interval > 0, reschedule_cb = 0) ++.Sp ++In this mode the watcher will always be scheduled to time out at the next ++\&\f(CW\*(C`offset + N * interval\*(C'\fR time (for some integer N, which can also be ++negative) and then repeat, regardless of any time jumps. The \f(CW\*(C`offset\*(C'\fR ++argument is merely an offset into the \f(CW\*(C`interval\*(C'\fR periods. ++.Sp ++This can be used to create timers that do not drift with respect to the ++system clock, for example, here is an \f(CW\*(C`ev_periodic\*(C'\fR that triggers each ++hour, on the hour (with respect to \s-1UTC\s0): ++.Sp ++.Vb 1 ++\& ev_periodic_set (&periodic, 0., 3600., 0); ++.Ve ++.Sp ++This doesn't mean there will always be 3600 seconds in between triggers, ++but only that the callback will be called when the system time shows a ++full hour (\s-1UTC\s0), or more correctly, when the system time is evenly divisible ++by 3600. ++.Sp ++Another way to think about it (for the mathematically inclined) is that ++\&\f(CW\*(C`ev_periodic\*(C'\fR will try to run the callback in this mode at the next possible ++time where \f(CW\*(C`time = offset (mod interval)\*(C'\fR, regardless of any time jumps. ++.Sp ++The \f(CW\*(C`interval\*(C'\fR \fI\s-1MUST\s0\fR be positive, and for numerical stability, the ++interval value should be higher than \f(CW\*(C`1/8192\*(C'\fR (which is around 100 ++microseconds) and \f(CW\*(C`offset\*(C'\fR should be higher than \f(CW0\fR and should have ++at most a similar magnitude as the current time (say, within a factor of ++ten). Typical values for offset are, in fact, \f(CW0\fR or something between ++\&\f(CW0\fR and \f(CW\*(C`interval\*(C'\fR, which is also the recommended range. ++.Sp ++Note also that there is an upper limit to how often a timer can fire (\s-1CPU\s0 ++speed for example), so if \f(CW\*(C`interval\*(C'\fR is very small then timing stability ++will of course deteriorate. Libev itself tries to be exact to be about one ++millisecond (if the \s-1OS\s0 supports it and the machine is fast enough). ++.IP "\(bu" 4 ++manual reschedule mode (offset ignored, interval ignored, reschedule_cb = callback) ++.Sp ++In this mode the values for \f(CW\*(C`interval\*(C'\fR and \f(CW\*(C`offset\*(C'\fR are both being ++ignored. Instead, each time the periodic watcher gets scheduled, the ++reschedule callback will be called with the watcher as first, and the ++current time as second argument. ++.Sp ++\&\s-1NOTE:\s0 \fIThis callback \s-1MUST\s0 \s-1NOT\s0 stop or destroy any periodic watcher, ever, ++or make \s-1ANY\s0 other event loop modifications whatsoever, unless explicitly ++allowed by documentation here\fR. ++.Sp ++If you need to stop it, return \f(CW\*(C`now + 1e30\*(C'\fR (or so, fudge fudge) and stop ++it afterwards (e.g. by starting an \f(CW\*(C`ev_prepare\*(C'\fR watcher, which is the ++only event loop modification you are allowed to do). ++.Sp ++The callback prototype is \f(CW\*(C`ev_tstamp (*reschedule_cb)(ev_periodic ++*w, ev_tstamp now)\*(C'\fR, e.g.: ++.Sp ++.Vb 5 ++\& static ev_tstamp ++\& my_rescheduler (ev_periodic *w, ev_tstamp now) ++\& { ++\& return now + 60.; ++\& } ++.Ve ++.Sp ++It must return the next time to trigger, based on the passed time value ++(that is, the lowest time value larger than to the second argument). It ++will usually be called just before the callback will be triggered, but ++might be called at other times, too. ++.Sp ++\&\s-1NOTE:\s0 \fIThis callback must always return a time that is higher than or ++equal to the passed \f(CI\*(C`now\*(C'\fI value\fR. ++.Sp ++This can be used to create very complex timers, such as a timer that ++triggers on \*(L"next midnight, local time\*(R". To do this, you would calculate the ++next midnight after \f(CW\*(C`now\*(C'\fR and return the timestamp value for this. How ++you do this is, again, up to you (but it is not trivial, which is the main ++reason I omitted it as an example). ++.RE ++.RS 4 ++.RE ++.IP "ev_periodic_again (loop, ev_periodic *)" 4 ++.IX Item "ev_periodic_again (loop, ev_periodic *)" ++Simply stops and restarts the periodic watcher again. This is only useful ++when you changed some parameters or the reschedule callback would return ++a different time than the last time it was called (e.g. in a crond like ++program when the crontabs have changed). ++.IP "ev_tstamp ev_periodic_at (ev_periodic *)" 4 ++.IX Item "ev_tstamp ev_periodic_at (ev_periodic *)" ++When active, returns the absolute time that the watcher is supposed ++to trigger next. This is not the same as the \f(CW\*(C`offset\*(C'\fR argument to ++\&\f(CW\*(C`ev_periodic_set\*(C'\fR, but indeed works even in interval and manual ++rescheduling modes. ++.IP "ev_tstamp offset [read\-write]" 4 ++.IX Item "ev_tstamp offset [read-write]" ++When repeating, this contains the offset value, otherwise this is the ++absolute point in time (the \f(CW\*(C`offset\*(C'\fR value passed to \f(CW\*(C`ev_periodic_set\*(C'\fR, ++although libev might modify this value for better numerical stability). ++.Sp ++Can be modified any time, but changes only take effect when the periodic ++timer fires or \f(CW\*(C`ev_periodic_again\*(C'\fR is being called. ++.IP "ev_tstamp interval [read\-write]" 4 ++.IX Item "ev_tstamp interval [read-write]" ++The current interval value. Can be modified any time, but changes only ++take effect when the periodic timer fires or \f(CW\*(C`ev_periodic_again\*(C'\fR is being ++called. ++.IP "ev_tstamp (*reschedule_cb)(ev_periodic *w, ev_tstamp now) [read\-write]" 4 ++.IX Item "ev_tstamp (*reschedule_cb)(ev_periodic *w, ev_tstamp now) [read-write]" ++The current reschedule callback, or \f(CW0\fR, if this functionality is ++switched off. Can be changed any time, but changes only take effect when ++the periodic timer fires or \f(CW\*(C`ev_periodic_again\*(C'\fR is being called. ++.PP ++\fIExamples\fR ++.IX Subsection "Examples" ++.PP ++Example: Call a callback every hour, or, more precisely, whenever the ++system time is divisible by 3600. The callback invocation times have ++potentially a lot of jitter, but good long-term stability. ++.PP ++.Vb 5 ++\& static void ++\& clock_cb (struct ev_loop *loop, ev_periodic *w, int revents) ++\& { ++\& ... its now a full hour (UTC, or TAI or whatever your clock follows) ++\& } ++\& ++\& ev_periodic hourly_tick; ++\& ev_periodic_init (&hourly_tick, clock_cb, 0., 3600., 0); ++\& ev_periodic_start (loop, &hourly_tick); ++.Ve ++.PP ++Example: The same as above, but use a reschedule callback to do it: ++.PP ++.Vb 1 ++\& #include ++\& ++\& static ev_tstamp ++\& my_scheduler_cb (ev_periodic *w, ev_tstamp now) ++\& { ++\& return now + (3600. \- fmod (now, 3600.)); ++\& } ++\& ++\& ev_periodic_init (&hourly_tick, clock_cb, 0., 0., my_scheduler_cb); ++.Ve ++.PP ++Example: Call a callback every hour, starting now: ++.PP ++.Vb 4 ++\& ev_periodic hourly_tick; ++\& ev_periodic_init (&hourly_tick, clock_cb, ++\& fmod (ev_now (loop), 3600.), 3600., 0); ++\& ev_periodic_start (loop, &hourly_tick); ++.Ve ++.ie n .SS """ev_signal"" \- signal me when a signal gets signalled!" ++.el .SS "\f(CWev_signal\fP \- signal me when a signal gets signalled!" ++.IX Subsection "ev_signal - signal me when a signal gets signalled!" ++Signal watchers will trigger an event when the process receives a specific ++signal one or more times. Even though signals are very asynchronous, libev ++will try its best to deliver signals synchronously, i.e. as part of the ++normal event processing, like any other event. ++.PP ++If you want signals to be delivered truly asynchronously, just use ++\&\f(CW\*(C`sigaction\*(C'\fR as you would do without libev and forget about sharing ++the signal. You can even use \f(CW\*(C`ev_async\*(C'\fR from a signal handler to ++synchronously wake up an event loop. ++.PP ++You can configure as many watchers as you like for the same signal, but ++only within the same loop, i.e. you can watch for \f(CW\*(C`SIGINT\*(C'\fR in your ++default loop and for \f(CW\*(C`SIGIO\*(C'\fR in another loop, but you cannot watch for ++\&\f(CW\*(C`SIGINT\*(C'\fR in both the default loop and another loop at the same time. At ++the moment, \f(CW\*(C`SIGCHLD\*(C'\fR is permanently tied to the default loop. ++.PP ++When the first watcher gets started will libev actually register something ++with the kernel (thus it coexists with your own signal handlers as long as ++you don't register any with libev for the same signal). ++.PP ++If possible and supported, libev will install its handlers with ++\&\f(CW\*(C`SA_RESTART\*(C'\fR (or equivalent) behaviour enabled, so system calls should ++not be unduly interrupted. If you have a problem with system calls getting ++interrupted by signals you can block all signals in an \f(CW\*(C`ev_check\*(C'\fR watcher ++and unblock them in an \f(CW\*(C`ev_prepare\*(C'\fR watcher. ++.PP ++\fIThe special problem of inheritance over fork/execve/pthread_create\fR ++.IX Subsection "The special problem of inheritance over fork/execve/pthread_create" ++.PP ++Both the signal mask (\f(CW\*(C`sigprocmask\*(C'\fR) and the signal disposition ++(\f(CW\*(C`sigaction\*(C'\fR) are unspecified after starting a signal watcher (and after ++stopping it again), that is, libev might or might not block the signal, ++and might or might not set or restore the installed signal handler (but ++see \f(CW\*(C`EVFLAG_NOSIGMASK\*(C'\fR). ++.PP ++While this does not matter for the signal disposition (libev never ++sets signals to \f(CW\*(C`SIG_IGN\*(C'\fR, so handlers will be reset to \f(CW\*(C`SIG_DFL\*(C'\fR on ++\&\f(CW\*(C`execve\*(C'\fR), this matters for the signal mask: many programs do not expect ++certain signals to be blocked. ++.PP ++This means that before calling \f(CW\*(C`exec\*(C'\fR (from the child) you should reset ++the signal mask to whatever \*(L"default\*(R" you expect (all clear is a good ++choice usually). ++.PP ++The simplest way to ensure that the signal mask is reset in the child is ++to install a fork handler with \f(CW\*(C`pthread_atfork\*(C'\fR that resets it. That will ++catch fork calls done by libraries (such as the libc) as well. ++.PP ++In current versions of libev, the signal will not be blocked indefinitely ++unless you use the \f(CW\*(C`signalfd\*(C'\fR \s-1API\s0 (\f(CW\*(C`EV_SIGNALFD\*(C'\fR). While this reduces ++the window of opportunity for problems, it will not go away, as libev ++\&\fIhas\fR to modify the signal mask, at least temporarily. ++.PP ++So I can't stress this enough: \fIIf you do not reset your signal mask when ++you expect it to be empty, you have a race condition in your code\fR. This ++is not a libev-specific thing, this is true for most event libraries. ++.PP ++\fIThe special problem of threads signal handling\fR ++.IX Subsection "The special problem of threads signal handling" ++.PP ++\&\s-1POSIX\s0 threads has problematic signal handling semantics, specifically, ++a lot of functionality (sigfd, sigwait etc.) only really works if all ++threads in a process block signals, which is hard to achieve. ++.PP ++When you want to use sigwait (or mix libev signal handling with your own ++for the same signals), you can tackle this problem by globally blocking ++all signals before creating any threads (or creating them with a fully set ++sigprocmask) and also specifying the \f(CW\*(C`EVFLAG_NOSIGMASK\*(C'\fR when creating ++loops. Then designate one thread as \*(L"signal receiver thread\*(R" which handles ++these signals. You can pass on any signals that libev might be interested ++in by calling \f(CW\*(C`ev_feed_signal\*(C'\fR. ++.PP ++\fIWatcher-Specific Functions and Data Members\fR ++.IX Subsection "Watcher-Specific Functions and Data Members" ++.IP "ev_signal_init (ev_signal *, callback, int signum)" 4 ++.IX Item "ev_signal_init (ev_signal *, callback, int signum)" ++.PD 0 ++.IP "ev_signal_set (ev_signal *, int signum)" 4 ++.IX Item "ev_signal_set (ev_signal *, int signum)" ++.PD ++Configures the watcher to trigger on the given signal number (usually one ++of the \f(CW\*(C`SIGxxx\*(C'\fR constants). ++.IP "int signum [read\-only]" 4 ++.IX Item "int signum [read-only]" ++The signal the watcher watches out for. ++.PP ++\fIExamples\fR ++.IX Subsection "Examples" ++.PP ++Example: Try to exit cleanly on \s-1SIGINT\s0. ++.PP ++.Vb 5 ++\& static void ++\& sigint_cb (struct ev_loop *loop, ev_signal *w, int revents) ++\& { ++\& ev_break (loop, EVBREAK_ALL); ++\& } ++\& ++\& ev_signal signal_watcher; ++\& ev_signal_init (&signal_watcher, sigint_cb, SIGINT); ++\& ev_signal_start (loop, &signal_watcher); ++.Ve ++.ie n .SS """ev_child"" \- watch out for process status changes" ++.el .SS "\f(CWev_child\fP \- watch out for process status changes" ++.IX Subsection "ev_child - watch out for process status changes" ++Child watchers trigger when your process receives a \s-1SIGCHLD\s0 in response to ++some child status changes (most typically when a child of yours dies or ++exits). It is permissible to install a child watcher \fIafter\fR the child ++has been forked (which implies it might have already exited), as long ++as the event loop isn't entered (or is continued from a watcher), i.e., ++forking and then immediately registering a watcher for the child is fine, ++but forking and registering a watcher a few event loop iterations later or ++in the next callback invocation is not. ++.PP ++Only the default event loop is capable of handling signals, and therefore ++you can only register child watchers in the default event loop. ++.PP ++Due to some design glitches inside libev, child watchers will always be ++handled at maximum priority (their priority is set to \f(CW\*(C`EV_MAXPRI\*(C'\fR by ++libev) ++.PP ++\fIProcess Interaction\fR ++.IX Subsection "Process Interaction" ++.PP ++Libev grabs \f(CW\*(C`SIGCHLD\*(C'\fR as soon as the default event loop is ++initialised. This is necessary to guarantee proper behaviour even if the ++first child watcher is started after the child exits. The occurrence ++of \f(CW\*(C`SIGCHLD\*(C'\fR is recorded asynchronously, but child reaping is done ++synchronously as part of the event loop processing. Libev always reaps all ++children, even ones not watched. ++.PP ++\fIOverriding the Built-In Processing\fR ++.IX Subsection "Overriding the Built-In Processing" ++.PP ++Libev offers no special support for overriding the built-in child ++processing, but if your application collides with libev's default child ++handler, you can override it easily by installing your own handler for ++\&\f(CW\*(C`SIGCHLD\*(C'\fR after initialising the default loop, and making sure the ++default loop never gets destroyed. You are encouraged, however, to use an ++event-based approach to child reaping and thus use libev's support for ++that, so other libev users can use \f(CW\*(C`ev_child\*(C'\fR watchers freely. ++.PP ++\fIStopping the Child Watcher\fR ++.IX Subsection "Stopping the Child Watcher" ++.PP ++Currently, the child watcher never gets stopped, even when the ++child terminates, so normally one needs to stop the watcher in the ++callback. Future versions of libev might stop the watcher automatically ++when a child exit is detected (calling \f(CW\*(C`ev_child_stop\*(C'\fR twice is not a ++problem). ++.PP ++\fIWatcher-Specific Functions and Data Members\fR ++.IX Subsection "Watcher-Specific Functions and Data Members" ++.IP "ev_child_init (ev_child *, callback, int pid, int trace)" 4 ++.IX Item "ev_child_init (ev_child *, callback, int pid, int trace)" ++.PD 0 ++.IP "ev_child_set (ev_child *, int pid, int trace)" 4 ++.IX Item "ev_child_set (ev_child *, int pid, int trace)" ++.PD ++Configures the watcher to wait for status changes of process \f(CW\*(C`pid\*(C'\fR (or ++\&\fIany\fR process if \f(CW\*(C`pid\*(C'\fR is specified as \f(CW0\fR). The callback can look ++at the \f(CW\*(C`rstatus\*(C'\fR member of the \f(CW\*(C`ev_child\*(C'\fR watcher structure to see ++the status word (use the macros from \f(CW\*(C`sys/wait.h\*(C'\fR and see your systems ++\&\f(CW\*(C`waitpid\*(C'\fR documentation). The \f(CW\*(C`rpid\*(C'\fR member contains the pid of the ++process causing the status change. \f(CW\*(C`trace\*(C'\fR must be either \f(CW0\fR (only ++activate the watcher when the process terminates) or \f(CW1\fR (additionally ++activate the watcher when the process is stopped or continued). ++.IP "int pid [read\-only]" 4 ++.IX Item "int pid [read-only]" ++The process id this watcher watches out for, or \f(CW0\fR, meaning any process id. ++.IP "int rpid [read\-write]" 4 ++.IX Item "int rpid [read-write]" ++The process id that detected a status change. ++.IP "int rstatus [read\-write]" 4 ++.IX Item "int rstatus [read-write]" ++The process exit/trace status caused by \f(CW\*(C`rpid\*(C'\fR (see your systems ++\&\f(CW\*(C`waitpid\*(C'\fR and \f(CW\*(C`sys/wait.h\*(C'\fR documentation for details). ++.PP ++\fIExamples\fR ++.IX Subsection "Examples" ++.PP ++Example: \f(CW\*(C`fork()\*(C'\fR a new process and install a child handler to wait for ++its completion. ++.PP ++.Vb 1 ++\& ev_child cw; ++\& ++\& static void ++\& child_cb (EV_P_ ev_child *w, int revents) ++\& { ++\& ev_child_stop (EV_A_ w); ++\& printf ("process %d exited with status %x\en", w\->rpid, w\->rstatus); ++\& } ++\& ++\& pid_t pid = fork (); ++\& ++\& if (pid < 0) ++\& // error ++\& else if (pid == 0) ++\& { ++\& // the forked child executes here ++\& exit (1); ++\& } ++\& else ++\& { ++\& ev_child_init (&cw, child_cb, pid, 0); ++\& ev_child_start (EV_DEFAULT_ &cw); ++\& } ++.Ve ++.ie n .SS """ev_stat"" \- did the file attributes just change?" ++.el .SS "\f(CWev_stat\fP \- did the file attributes just change?" ++.IX Subsection "ev_stat - did the file attributes just change?" ++This watches a file system path for attribute changes. That is, it calls ++\&\f(CW\*(C`stat\*(C'\fR on that path in regular intervals (or when the \s-1OS\s0 says it changed) ++and sees if it changed compared to the last time, invoking the callback ++if it did. Starting the watcher \f(CW\*(C`stat\*(C'\fR's the file, so only changes that ++happen after the watcher has been started will be reported. ++.PP ++The path does not need to exist: changing from \*(L"path exists\*(R" to \*(L"path does ++not exist\*(R" is a status change like any other. The condition \*(L"path does not ++exist\*(R" (or more correctly \*(L"path cannot be stat'ed\*(R") is signified by the ++\&\f(CW\*(C`st_nlink\*(C'\fR field being zero (which is otherwise always forced to be at ++least one) and all the other fields of the stat buffer having unspecified ++contents. ++.PP ++The path \fImust not\fR end in a slash or contain special components such as ++\&\f(CW\*(C`.\*(C'\fR or \f(CW\*(C`..\*(C'\fR. The path \fIshould\fR be absolute: If it is relative and ++your working directory changes, then the behaviour is undefined. ++.PP ++Since there is no portable change notification interface available, the ++portable implementation simply calls \f(CWstat(2)\fR regularly on the path ++to see if it changed somehow. You can specify a recommended polling ++interval for this case. If you specify a polling interval of \f(CW0\fR (highly ++recommended!) then a \fIsuitable, unspecified default\fR value will be used ++(which you can expect to be around five seconds, although this might ++change dynamically). Libev will also impose a minimum interval which is ++currently around \f(CW0.1\fR, but that's usually overkill. ++.PP ++This watcher type is not meant for massive numbers of stat watchers, ++as even with OS-supported change notifications, this can be ++resource-intensive. ++.PP ++At the time of this writing, the only OS-specific interface implemented ++is the Linux inotify interface (implementing kqueue support is left as an ++exercise for the reader. Note, however, that the author sees no way of ++implementing \f(CW\*(C`ev_stat\*(C'\fR semantics with kqueue, except as a hint). ++.PP ++\fI\s-1ABI\s0 Issues (Largefile Support)\fR ++.IX Subsection "ABI Issues (Largefile Support)" ++.PP ++Libev by default (unless the user overrides this) uses the default ++compilation environment, which means that on systems with large file ++support disabled by default, you get the 32 bit version of the stat ++structure. When using the library from programs that change the \s-1ABI\s0 to ++use 64 bit file offsets the programs will fail. In that case you have to ++compile libev with the same flags to get binary compatibility. This is ++obviously the case with any flags that change the \s-1ABI\s0, but the problem is ++most noticeably displayed with ev_stat and large file support. ++.PP ++The solution for this is to lobby your distribution maker to make large ++file interfaces available by default (as e.g. FreeBSD does) and not ++optional. Libev cannot simply switch on large file support because it has ++to exchange stat structures with application programs compiled using the ++default compilation environment. ++.PP ++\fIInotify and Kqueue\fR ++.IX Subsection "Inotify and Kqueue" ++.PP ++When \f(CW\*(C`inotify (7)\*(C'\fR support has been compiled into libev and present at ++runtime, it will be used to speed up change detection where possible. The ++inotify descriptor will be created lazily when the first \f(CW\*(C`ev_stat\*(C'\fR ++watcher is being started. ++.PP ++Inotify presence does not change the semantics of \f(CW\*(C`ev_stat\*(C'\fR watchers ++except that changes might be detected earlier, and in some cases, to avoid ++making regular \f(CW\*(C`stat\*(C'\fR calls. Even in the presence of inotify support ++there are many cases where libev has to resort to regular \f(CW\*(C`stat\*(C'\fR polling, ++but as long as kernel 2.6.25 or newer is used (2.6.24 and older have too ++many bugs), the path exists (i.e. stat succeeds), and the path resides on ++a local filesystem (libev currently assumes only ext2/3, jfs, reiserfs and ++xfs are fully working) libev usually gets away without polling. ++.PP ++There is no support for kqueue, as apparently it cannot be used to ++implement this functionality, due to the requirement of having a file ++descriptor open on the object at all times, and detecting renames, unlinks ++etc. is difficult. ++.PP ++\fI\f(CI\*(C`stat ()\*(C'\fI is a synchronous operation\fR ++.IX Subsection "stat () is a synchronous operation" ++.PP ++Libev doesn't normally do any kind of I/O itself, and so is not blocking ++the process. The exception are \f(CW\*(C`ev_stat\*(C'\fR watchers \- those call \f(CW\*(C`stat ++()\*(C'\fR, which is a synchronous operation. ++.PP ++For local paths, this usually doesn't matter: unless the system is very ++busy or the intervals between stat's are large, a stat call will be fast, ++as the path data is usually in memory already (except when starting the ++watcher). ++.PP ++For networked file systems, calling \f(CW\*(C`stat ()\*(C'\fR can block an indefinite ++time due to network issues, and even under good conditions, a stat call ++often takes multiple milliseconds. ++.PP ++Therefore, it is best to avoid using \f(CW\*(C`ev_stat\*(C'\fR watchers on networked ++paths, although this is fully supported by libev. ++.PP ++\fIThe special problem of stat time resolution\fR ++.IX Subsection "The special problem of stat time resolution" ++.PP ++The \f(CW\*(C`stat ()\*(C'\fR system call only supports full-second resolution portably, ++and even on systems where the resolution is higher, most file systems ++still only support whole seconds. ++.PP ++That means that, if the time is the only thing that changes, you can ++easily miss updates: on the first update, \f(CW\*(C`ev_stat\*(C'\fR detects a change and ++calls your callback, which does something. When there is another update ++within the same second, \f(CW\*(C`ev_stat\*(C'\fR will be unable to detect unless the ++stat data does change in other ways (e.g. file size). ++.PP ++The solution to this is to delay acting on a change for slightly more ++than a second (or till slightly after the next full second boundary), using ++a roughly one-second-delay \f(CW\*(C`ev_timer\*(C'\fR (e.g. \f(CW\*(C`ev_timer_set (w, 0., 1.02); ++ev_timer_again (loop, w)\*(C'\fR). ++.PP ++The \f(CW.02\fR offset is added to work around small timing inconsistencies ++of some operating systems (where the second counter of the current time ++might be be delayed. One such system is the Linux kernel, where a call to ++\&\f(CW\*(C`gettimeofday\*(C'\fR might return a timestamp with a full second later than ++a subsequent \f(CW\*(C`time\*(C'\fR call \- if the equivalent of \f(CW\*(C`time ()\*(C'\fR is used to ++update file times then there will be a small window where the kernel uses ++the previous second to update file times but libev might already execute ++the timer callback). ++.PP ++\fIWatcher-Specific Functions and Data Members\fR ++.IX Subsection "Watcher-Specific Functions and Data Members" ++.IP "ev_stat_init (ev_stat *, callback, const char *path, ev_tstamp interval)" 4 ++.IX Item "ev_stat_init (ev_stat *, callback, const char *path, ev_tstamp interval)" ++.PD 0 ++.IP "ev_stat_set (ev_stat *, const char *path, ev_tstamp interval)" 4 ++.IX Item "ev_stat_set (ev_stat *, const char *path, ev_tstamp interval)" ++.PD ++Configures the watcher to wait for status changes of the given ++\&\f(CW\*(C`path\*(C'\fR. The \f(CW\*(C`interval\*(C'\fR is a hint on how quickly a change is expected to ++be detected and should normally be specified as \f(CW0\fR to let libev choose ++a suitable value. The memory pointed to by \f(CW\*(C`path\*(C'\fR must point to the same ++path for as long as the watcher is active. ++.Sp ++The callback will receive an \f(CW\*(C`EV_STAT\*(C'\fR event when a change was detected, ++relative to the attributes at the time the watcher was started (or the ++last change was detected). ++.IP "ev_stat_stat (loop, ev_stat *)" 4 ++.IX Item "ev_stat_stat (loop, ev_stat *)" ++Updates the stat buffer immediately with new values. If you change the ++watched path in your callback, you could call this function to avoid ++detecting this change (while introducing a race condition if you are not ++the only one changing the path). Can also be useful simply to find out the ++new values. ++.IP "ev_statdata attr [read\-only]" 4 ++.IX Item "ev_statdata attr [read-only]" ++The most-recently detected attributes of the file. Although the type is ++\&\f(CW\*(C`ev_statdata\*(C'\fR, this is usually the (or one of the) \f(CW\*(C`struct stat\*(C'\fR types ++suitable for your system, but you can only rely on the POSIX-standardised ++members to be present. If the \f(CW\*(C`st_nlink\*(C'\fR member is \f(CW0\fR, then there was ++some error while \f(CW\*(C`stat\*(C'\fRing the file. ++.IP "ev_statdata prev [read\-only]" 4 ++.IX Item "ev_statdata prev [read-only]" ++The previous attributes of the file. The callback gets invoked whenever ++\&\f(CW\*(C`prev\*(C'\fR != \f(CW\*(C`attr\*(C'\fR, or, more precisely, one or more of these members ++differ: \f(CW\*(C`st_dev\*(C'\fR, \f(CW\*(C`st_ino\*(C'\fR, \f(CW\*(C`st_mode\*(C'\fR, \f(CW\*(C`st_nlink\*(C'\fR, \f(CW\*(C`st_uid\*(C'\fR, ++\&\f(CW\*(C`st_gid\*(C'\fR, \f(CW\*(C`st_rdev\*(C'\fR, \f(CW\*(C`st_size\*(C'\fR, \f(CW\*(C`st_atime\*(C'\fR, \f(CW\*(C`st_mtime\*(C'\fR, \f(CW\*(C`st_ctime\*(C'\fR. ++.IP "ev_tstamp interval [read\-only]" 4 ++.IX Item "ev_tstamp interval [read-only]" ++The specified interval. ++.IP "const char *path [read\-only]" 4 ++.IX Item "const char *path [read-only]" ++The file system path that is being watched. ++.PP ++\fIExamples\fR ++.IX Subsection "Examples" ++.PP ++Example: Watch \f(CW\*(C`/etc/passwd\*(C'\fR for attribute changes. ++.PP ++.Vb 10 ++\& static void ++\& passwd_cb (struct ev_loop *loop, ev_stat *w, int revents) ++\& { ++\& /* /etc/passwd changed in some way */ ++\& if (w\->attr.st_nlink) ++\& { ++\& printf ("passwd current size %ld\en", (long)w\->attr.st_size); ++\& printf ("passwd current atime %ld\en", (long)w\->attr.st_mtime); ++\& printf ("passwd current mtime %ld\en", (long)w\->attr.st_mtime); ++\& } ++\& else ++\& /* you shalt not abuse printf for puts */ ++\& puts ("wow, /etc/passwd is not there, expect problems. " ++\& "if this is windows, they already arrived\en"); ++\& } ++\& ++\& ... ++\& ev_stat passwd; ++\& ++\& ev_stat_init (&passwd, passwd_cb, "/etc/passwd", 0.); ++\& ev_stat_start (loop, &passwd); ++.Ve ++.PP ++Example: Like above, but additionally use a one-second delay so we do not ++miss updates (however, frequent updates will delay processing, too, so ++one might do the work both on \f(CW\*(C`ev_stat\*(C'\fR callback invocation \fIand\fR on ++\&\f(CW\*(C`ev_timer\*(C'\fR callback invocation). ++.PP ++.Vb 2 ++\& static ev_stat passwd; ++\& static ev_timer timer; ++\& ++\& static void ++\& timer_cb (EV_P_ ev_timer *w, int revents) ++\& { ++\& ev_timer_stop (EV_A_ w); ++\& ++\& /* now it\*(Aqs one second after the most recent passwd change */ ++\& } ++\& ++\& static void ++\& stat_cb (EV_P_ ev_stat *w, int revents) ++\& { ++\& /* reset the one\-second timer */ ++\& ev_timer_again (EV_A_ &timer); ++\& } ++\& ++\& ... ++\& ev_stat_init (&passwd, stat_cb, "/etc/passwd", 0.); ++\& ev_stat_start (loop, &passwd); ++\& ev_timer_init (&timer, timer_cb, 0., 1.02); ++.Ve ++.ie n .SS """ev_idle"" \- when you've got nothing better to do..." ++.el .SS "\f(CWev_idle\fP \- when you've got nothing better to do..." ++.IX Subsection "ev_idle - when you've got nothing better to do..." ++Idle watchers trigger events when no other events of the same or higher ++priority are pending (prepare, check and other idle watchers do not count ++as receiving \*(L"events\*(R"). ++.PP ++That is, as long as your process is busy handling sockets or timeouts ++(or even signals, imagine) of the same or higher priority it will not be ++triggered. But when your process is idle (or only lower-priority watchers ++are pending), the idle watchers are being called once per event loop ++iteration \- until stopped, that is, or your process receives more events ++and becomes busy again with higher priority stuff. ++.PP ++The most noteworthy effect is that as long as any idle watchers are ++active, the process will not block when waiting for new events. ++.PP ++Apart from keeping your process non-blocking (which is a useful ++effect on its own sometimes), idle watchers are a good place to do ++\&\*(L"pseudo-background processing\*(R", or delay processing stuff to after the ++event loop has handled all outstanding events. ++.PP ++\fIAbusing an \f(CI\*(C`ev_idle\*(C'\fI watcher for its side-effect\fR ++.IX Subsection "Abusing an ev_idle watcher for its side-effect" ++.PP ++As long as there is at least one active idle watcher, libev will never ++sleep unnecessarily. Or in other words, it will loop as fast as possible. ++For this to work, the idle watcher doesn't need to be invoked at all \- the ++lowest priority will do. ++.PP ++This mode of operation can be useful together with an \f(CW\*(C`ev_check\*(C'\fR watcher, ++to do something on each event loop iteration \- for example to balance load ++between different connections. ++.PP ++See \*(L"Abusing an ev_check watcher for its side-effect\*(R" for a longer ++example. ++.PP ++\fIWatcher-Specific Functions and Data Members\fR ++.IX Subsection "Watcher-Specific Functions and Data Members" ++.IP "ev_idle_init (ev_idle *, callback)" 4 ++.IX Item "ev_idle_init (ev_idle *, callback)" ++Initialises and configures the idle watcher \- it has no parameters of any ++kind. There is a \f(CW\*(C`ev_idle_set\*(C'\fR macro, but using it is utterly pointless, ++believe me. ++.PP ++\fIExamples\fR ++.IX Subsection "Examples" ++.PP ++Example: Dynamically allocate an \f(CW\*(C`ev_idle\*(C'\fR watcher, start it, and in the ++callback, free it. Also, use no error checking, as usual. ++.PP ++.Vb 5 ++\& static void ++\& idle_cb (struct ev_loop *loop, ev_idle *w, int revents) ++\& { ++\& // stop the watcher ++\& ev_idle_stop (loop, w); ++\& ++\& // now we can free it ++\& free (w); ++\& ++\& // now do something you wanted to do when the program has ++\& // no longer anything immediate to do. ++\& } ++\& ++\& ev_idle *idle_watcher = malloc (sizeof (ev_idle)); ++\& ev_idle_init (idle_watcher, idle_cb); ++\& ev_idle_start (loop, idle_watcher); ++.Ve ++.ie n .SS """ev_prepare"" and ""ev_check"" \- customise your event loop!" ++.el .SS "\f(CWev_prepare\fP and \f(CWev_check\fP \- customise your event loop!" ++.IX Subsection "ev_prepare and ev_check - customise your event loop!" ++Prepare and check watchers are often (but not always) used in pairs: ++prepare watchers get invoked before the process blocks and check watchers ++afterwards. ++.PP ++You \fImust not\fR call \f(CW\*(C`ev_run\*(C'\fR or similar functions that enter ++the current event loop from either \f(CW\*(C`ev_prepare\*(C'\fR or \f(CW\*(C`ev_check\*(C'\fR ++watchers. Other loops than the current one are fine, however. The ++rationale behind this is that you do not need to check for recursion in ++those watchers, i.e. the sequence will always be \f(CW\*(C`ev_prepare\*(C'\fR, blocking, ++\&\f(CW\*(C`ev_check\*(C'\fR so if you have one watcher of each kind they will always be ++called in pairs bracketing the blocking call. ++.PP ++Their main purpose is to integrate other event mechanisms into libev and ++their use is somewhat advanced. They could be used, for example, to track ++variable changes, implement your own watchers, integrate net-snmp or a ++coroutine library and lots more. They are also occasionally useful if ++you cache some data and want to flush it before blocking (for example, ++in X programs you might want to do an \f(CW\*(C`XFlush ()\*(C'\fR in an \f(CW\*(C`ev_prepare\*(C'\fR ++watcher). ++.PP ++This is done by examining in each prepare call which file descriptors ++need to be watched by the other library, registering \f(CW\*(C`ev_io\*(C'\fR watchers ++for them and starting an \f(CW\*(C`ev_timer\*(C'\fR watcher for any timeouts (many ++libraries provide exactly this functionality). Then, in the check watcher, ++you check for any events that occurred (by checking the pending status ++of all watchers and stopping them) and call back into the library. The ++I/O and timer callbacks will never actually be called (but must be valid ++nevertheless, because you never know, you know?). ++.PP ++As another example, the Perl Coro module uses these hooks to integrate ++coroutines into libev programs, by yielding to other active coroutines ++during each prepare and only letting the process block if no coroutines ++are ready to run (it's actually more complicated: it only runs coroutines ++with priority higher than or equal to the event loop and one coroutine ++of lower priority, but only once, using idle watchers to keep the event ++loop from blocking if lower-priority coroutines are active, thus mapping ++low-priority coroutines to idle/background tasks). ++.PP ++When used for this purpose, it is recommended to give \f(CW\*(C`ev_check\*(C'\fR watchers ++highest (\f(CW\*(C`EV_MAXPRI\*(C'\fR) priority, to ensure that they are being run before ++any other watchers after the poll (this doesn't matter for \f(CW\*(C`ev_prepare\*(C'\fR ++watchers). ++.PP ++Also, \f(CW\*(C`ev_check\*(C'\fR watchers (and \f(CW\*(C`ev_prepare\*(C'\fR watchers, too) should not ++activate (\*(L"feed\*(R") events into libev. While libev fully supports this, they ++might get executed before other \f(CW\*(C`ev_check\*(C'\fR watchers did their job. As ++\&\f(CW\*(C`ev_check\*(C'\fR watchers are often used to embed other (non-libev) event ++loops those other event loops might be in an unusable state until their ++\&\f(CW\*(C`ev_check\*(C'\fR watcher ran (always remind yourself to coexist peacefully with ++others). ++.PP ++\fIAbusing an \f(CI\*(C`ev_check\*(C'\fI watcher for its side-effect\fR ++.IX Subsection "Abusing an ev_check watcher for its side-effect" ++.PP ++\&\f(CW\*(C`ev_check\*(C'\fR (and less often also \f(CW\*(C`ev_prepare\*(C'\fR) watchers can also be ++useful because they are called once per event loop iteration. For ++example, if you want to handle a large number of connections fairly, you ++normally only do a bit of work for each active connection, and if there ++is more work to do, you wait for the next event loop iteration, so other ++connections have a chance of making progress. ++.PP ++Using an \f(CW\*(C`ev_check\*(C'\fR watcher is almost enough: it will be called on the ++next event loop iteration. However, that isn't as soon as possible \- ++without external events, your \f(CW\*(C`ev_check\*(C'\fR watcher will not be invoked. ++.PP ++This is where \f(CW\*(C`ev_idle\*(C'\fR watchers come in handy \- all you need is a ++single global idle watcher that is active as long as you have one active ++\&\f(CW\*(C`ev_check\*(C'\fR watcher. The \f(CW\*(C`ev_idle\*(C'\fR watcher makes sure the event loop ++will not sleep, and the \f(CW\*(C`ev_check\*(C'\fR watcher makes sure a callback gets ++invoked. Neither watcher alone can do that. ++.PP ++\fIWatcher-Specific Functions and Data Members\fR ++.IX Subsection "Watcher-Specific Functions and Data Members" ++.IP "ev_prepare_init (ev_prepare *, callback)" 4 ++.IX Item "ev_prepare_init (ev_prepare *, callback)" ++.PD 0 ++.IP "ev_check_init (ev_check *, callback)" 4 ++.IX Item "ev_check_init (ev_check *, callback)" ++.PD ++Initialises and configures the prepare or check watcher \- they have no ++parameters of any kind. There are \f(CW\*(C`ev_prepare_set\*(C'\fR and \f(CW\*(C`ev_check_set\*(C'\fR ++macros, but using them is utterly, utterly, utterly and completely ++pointless. ++.PP ++\fIExamples\fR ++.IX Subsection "Examples" ++.PP ++There are a number of principal ways to embed other event loops or modules ++into libev. Here are some ideas on how to include libadns into libev ++(there is a Perl module named \f(CW\*(C`EV::ADNS\*(C'\fR that does this, which you could ++use as a working example. Another Perl module named \f(CW\*(C`EV::Glib\*(C'\fR embeds a ++Glib main context into libev, and finally, \f(CW\*(C`Glib::EV\*(C'\fR embeds \s-1EV\s0 into the ++Glib event loop). ++.PP ++Method 1: Add \s-1IO\s0 watchers and a timeout watcher in a prepare handler, ++and in a check watcher, destroy them and call into libadns. What follows ++is pseudo-code only of course. This requires you to either use a low ++priority for the check watcher or use \f(CW\*(C`ev_clear_pending\*(C'\fR explicitly, as ++the callbacks for the IO/timeout watchers might not have been called yet. ++.PP ++.Vb 2 ++\& static ev_io iow [nfd]; ++\& static ev_timer tw; ++\& ++\& static void ++\& io_cb (struct ev_loop *loop, ev_io *w, int revents) ++\& { ++\& } ++\& ++\& // create io watchers for each fd and a timer before blocking ++\& static void ++\& adns_prepare_cb (struct ev_loop *loop, ev_prepare *w, int revents) ++\& { ++\& int timeout = 3600000; ++\& struct pollfd fds [nfd]; ++\& // actual code will need to loop here and realloc etc. ++\& adns_beforepoll (ads, fds, &nfd, &timeout, timeval_from (ev_time ())); ++\& ++\& /* the callback is illegal, but won\*(Aqt be called as we stop during check */ ++\& ev_timer_init (&tw, 0, timeout * 1e\-3, 0.); ++\& ev_timer_start (loop, &tw); ++\& ++\& // create one ev_io per pollfd ++\& for (int i = 0; i < nfd; ++i) ++\& { ++\& ev_io_init (iow + i, io_cb, fds [i].fd, ++\& ((fds [i].events & POLLIN ? EV_READ : 0) ++\& | (fds [i].events & POLLOUT ? EV_WRITE : 0))); ++\& ++\& fds [i].revents = 0; ++\& ev_io_start (loop, iow + i); ++\& } ++\& } ++\& ++\& // stop all watchers after blocking ++\& static void ++\& adns_check_cb (struct ev_loop *loop, ev_check *w, int revents) ++\& { ++\& ev_timer_stop (loop, &tw); ++\& ++\& for (int i = 0; i < nfd; ++i) ++\& { ++\& // set the relevant poll flags ++\& // could also call adns_processreadable etc. here ++\& struct pollfd *fd = fds + i; ++\& int revents = ev_clear_pending (iow + i); ++\& if (revents & EV_READ ) fd\->revents |= fd\->events & POLLIN; ++\& if (revents & EV_WRITE) fd\->revents |= fd\->events & POLLOUT; ++\& ++\& // now stop the watcher ++\& ev_io_stop (loop, iow + i); ++\& } ++\& ++\& adns_afterpoll (adns, fds, nfd, timeval_from (ev_now (loop)); ++\& } ++.Ve ++.PP ++Method 2: This would be just like method 1, but you run \f(CW\*(C`adns_afterpoll\*(C'\fR ++in the prepare watcher and would dispose of the check watcher. ++.PP ++Method 3: If the module to be embedded supports explicit event ++notification (libadns does), you can also make use of the actual watcher ++callbacks, and only destroy/create the watchers in the prepare watcher. ++.PP ++.Vb 5 ++\& static void ++\& timer_cb (EV_P_ ev_timer *w, int revents) ++\& { ++\& adns_state ads = (adns_state)w\->data; ++\& update_now (EV_A); ++\& ++\& adns_processtimeouts (ads, &tv_now); ++\& } ++\& ++\& static void ++\& io_cb (EV_P_ ev_io *w, int revents) ++\& { ++\& adns_state ads = (adns_state)w\->data; ++\& update_now (EV_A); ++\& ++\& if (revents & EV_READ ) adns_processreadable (ads, w\->fd, &tv_now); ++\& if (revents & EV_WRITE) adns_processwriteable (ads, w\->fd, &tv_now); ++\& } ++\& ++\& // do not ever call adns_afterpoll ++.Ve ++.PP ++Method 4: Do not use a prepare or check watcher because the module you ++want to embed is not flexible enough to support it. Instead, you can ++override their poll function. The drawback with this solution is that the ++main loop is now no longer controllable by \s-1EV\s0. The \f(CW\*(C`Glib::EV\*(C'\fR module uses ++this approach, effectively embedding \s-1EV\s0 as a client into the horrible ++libglib event loop. ++.PP ++.Vb 4 ++\& static gint ++\& event_poll_func (GPollFD *fds, guint nfds, gint timeout) ++\& { ++\& int got_events = 0; ++\& ++\& for (n = 0; n < nfds; ++n) ++\& // create/start io watcher that sets the relevant bits in fds[n] and increment got_events ++\& ++\& if (timeout >= 0) ++\& // create/start timer ++\& ++\& // poll ++\& ev_run (EV_A_ 0); ++\& ++\& // stop timer again ++\& if (timeout >= 0) ++\& ev_timer_stop (EV_A_ &to); ++\& ++\& // stop io watchers again \- their callbacks should have set ++\& for (n = 0; n < nfds; ++n) ++\& ev_io_stop (EV_A_ iow [n]); ++\& ++\& return got_events; ++\& } ++.Ve ++.ie n .SS """ev_embed"" \- when one backend isn't enough..." ++.el .SS "\f(CWev_embed\fP \- when one backend isn't enough..." ++.IX Subsection "ev_embed - when one backend isn't enough..." ++This is a rather advanced watcher type that lets you embed one event loop ++into another (currently only \f(CW\*(C`ev_io\*(C'\fR events are supported in the embedded ++loop, other types of watchers might be handled in a delayed or incorrect ++fashion and must not be used). ++.PP ++There are primarily two reasons you would want that: work around bugs and ++prioritise I/O. ++.PP ++As an example for a bug workaround, the kqueue backend might only support ++sockets on some platform, so it is unusable as generic backend, but you ++still want to make use of it because you have many sockets and it scales ++so nicely. In this case, you would create a kqueue-based loop and embed ++it into your default loop (which might use e.g. poll). Overall operation ++will be a bit slower because first libev has to call \f(CW\*(C`poll\*(C'\fR and then ++\&\f(CW\*(C`kevent\*(C'\fR, but at least you can use both mechanisms for what they are ++best: \f(CW\*(C`kqueue\*(C'\fR for scalable sockets and \f(CW\*(C`poll\*(C'\fR if you want it to work :) ++.PP ++As for prioritising I/O: under rare circumstances you have the case where ++some fds have to be watched and handled very quickly (with low latency), ++and even priorities and idle watchers might have too much overhead. In ++this case you would put all the high priority stuff in one loop and all ++the rest in a second one, and embed the second one in the first. ++.PP ++As long as the watcher is active, the callback will be invoked every ++time there might be events pending in the embedded loop. The callback ++must then call \f(CW\*(C`ev_embed_sweep (mainloop, watcher)\*(C'\fR to make a single ++sweep and invoke their callbacks (the callback doesn't need to invoke the ++\&\f(CW\*(C`ev_embed_sweep\*(C'\fR function directly, it could also start an idle watcher ++to give the embedded loop strictly lower priority for example). ++.PP ++You can also set the callback to \f(CW0\fR, in which case the embed watcher ++will automatically execute the embedded loop sweep whenever necessary. ++.PP ++Fork detection will be handled transparently while the \f(CW\*(C`ev_embed\*(C'\fR watcher ++is active, i.e., the embedded loop will automatically be forked when the ++embedding loop forks. In other cases, the user is responsible for calling ++\&\f(CW\*(C`ev_loop_fork\*(C'\fR on the embedded loop. ++.PP ++Unfortunately, not all backends are embeddable: only the ones returned by ++\&\f(CW\*(C`ev_embeddable_backends\*(C'\fR are, which, unfortunately, does not include any ++portable one. ++.PP ++So when you want to use this feature you will always have to be prepared ++that you cannot get an embeddable loop. The recommended way to get around ++this is to have a separate variables for your embeddable loop, try to ++create it, and if that fails, use the normal loop for everything. ++.PP ++\fI\f(CI\*(C`ev_embed\*(C'\fI and fork\fR ++.IX Subsection "ev_embed and fork" ++.PP ++While the \f(CW\*(C`ev_embed\*(C'\fR watcher is running, forks in the embedding loop will ++automatically be applied to the embedded loop as well, so no special ++fork handling is required in that case. When the watcher is not running, ++however, it is still the task of the libev user to call \f(CW\*(C`ev_loop_fork ()\*(C'\fR ++as applicable. ++.PP ++\fIWatcher-Specific Functions and Data Members\fR ++.IX Subsection "Watcher-Specific Functions and Data Members" ++.IP "ev_embed_init (ev_embed *, callback, struct ev_loop *embedded_loop)" 4 ++.IX Item "ev_embed_init (ev_embed *, callback, struct ev_loop *embedded_loop)" ++.PD 0 ++.IP "ev_embed_set (ev_embed *, struct ev_loop *embedded_loop)" 4 ++.IX Item "ev_embed_set (ev_embed *, struct ev_loop *embedded_loop)" ++.PD ++Configures the watcher to embed the given loop, which must be ++embeddable. If the callback is \f(CW0\fR, then \f(CW\*(C`ev_embed_sweep\*(C'\fR will be ++invoked automatically, otherwise it is the responsibility of the callback ++to invoke it (it will continue to be called until the sweep has been done, ++if you do not want that, you need to temporarily stop the embed watcher). ++.IP "ev_embed_sweep (loop, ev_embed *)" 4 ++.IX Item "ev_embed_sweep (loop, ev_embed *)" ++Make a single, non-blocking sweep over the embedded loop. This works ++similarly to \f(CW\*(C`ev_run (embedded_loop, EVRUN_NOWAIT)\*(C'\fR, but in the most ++appropriate way for embedded loops. ++.IP "struct ev_loop *other [read\-only]" 4 ++.IX Item "struct ev_loop *other [read-only]" ++The embedded event loop. ++.PP ++\fIExamples\fR ++.IX Subsection "Examples" ++.PP ++Example: Try to get an embeddable event loop and embed it into the default ++event loop. If that is not possible, use the default loop. The default ++loop is stored in \f(CW\*(C`loop_hi\*(C'\fR, while the embeddable loop is stored in ++\&\f(CW\*(C`loop_lo\*(C'\fR (which is \f(CW\*(C`loop_hi\*(C'\fR in the case no embeddable loop can be ++used). ++.PP ++.Vb 3 ++\& struct ev_loop *loop_hi = ev_default_init (0); ++\& struct ev_loop *loop_lo = 0; ++\& ev_embed embed; ++\& ++\& // see if there is a chance of getting one that works ++\& // (remember that a flags value of 0 means autodetection) ++\& loop_lo = ev_embeddable_backends () & ev_recommended_backends () ++\& ? ev_loop_new (ev_embeddable_backends () & ev_recommended_backends ()) ++\& : 0; ++\& ++\& // if we got one, then embed it, otherwise default to loop_hi ++\& if (loop_lo) ++\& { ++\& ev_embed_init (&embed, 0, loop_lo); ++\& ev_embed_start (loop_hi, &embed); ++\& } ++\& else ++\& loop_lo = loop_hi; ++.Ve ++.PP ++Example: Check if kqueue is available but not recommended and create ++a kqueue backend for use with sockets (which usually work with any ++kqueue implementation). Store the kqueue/socket\-only event loop in ++\&\f(CW\*(C`loop_socket\*(C'\fR. (One might optionally use \f(CW\*(C`EVFLAG_NOENV\*(C'\fR, too). ++.PP ++.Vb 3 ++\& struct ev_loop *loop = ev_default_init (0); ++\& struct ev_loop *loop_socket = 0; ++\& ev_embed embed; ++\& ++\& if (ev_supported_backends () & ~ev_recommended_backends () & EVBACKEND_KQUEUE) ++\& if ((loop_socket = ev_loop_new (EVBACKEND_KQUEUE)) ++\& { ++\& ev_embed_init (&embed, 0, loop_socket); ++\& ev_embed_start (loop, &embed); ++\& } ++\& ++\& if (!loop_socket) ++\& loop_socket = loop; ++\& ++\& // now use loop_socket for all sockets, and loop for everything else ++.Ve ++.ie n .SS """ev_fork"" \- the audacity to resume the event loop after a fork" ++.el .SS "\f(CWev_fork\fP \- the audacity to resume the event loop after a fork" ++.IX Subsection "ev_fork - the audacity to resume the event loop after a fork" ++Fork watchers are called when a \f(CW\*(C`fork ()\*(C'\fR was detected (usually because ++whoever is a good citizen cared to tell libev about it by calling ++\&\f(CW\*(C`ev_loop_fork\*(C'\fR). The invocation is done before the event loop blocks next ++and before \f(CW\*(C`ev_check\*(C'\fR watchers are being called, and only in the child ++after the fork. If whoever good citizen calling \f(CW\*(C`ev_default_fork\*(C'\fR cheats ++and calls it in the wrong process, the fork handlers will be invoked, too, ++of course. ++.PP ++\fIThe special problem of life after fork \- how is it possible?\fR ++.IX Subsection "The special problem of life after fork - how is it possible?" ++.PP ++Most uses of \f(CW\*(C`fork()\*(C'\fR consist of forking, then some simple calls to set ++up/change the process environment, followed by a call to \f(CW\*(C`exec()\*(C'\fR. This ++sequence should be handled by libev without any problems. ++.PP ++This changes when the application actually wants to do event handling ++in the child, or both parent in child, in effect \*(L"continuing\*(R" after the ++fork. ++.PP ++The default mode of operation (for libev, with application help to detect ++forks) is to duplicate all the state in the child, as would be expected ++when \fIeither\fR the parent \fIor\fR the child process continues. ++.PP ++When both processes want to continue using libev, then this is usually the ++wrong result. In that case, usually one process (typically the parent) is ++supposed to continue with all watchers in place as before, while the other ++process typically wants to start fresh, i.e. without any active watchers. ++.PP ++The cleanest and most efficient way to achieve that with libev is to ++simply create a new event loop, which of course will be \*(L"empty\*(R", and ++use that for new watchers. This has the advantage of not touching more ++memory than necessary, and thus avoiding the copy-on-write, and the ++disadvantage of having to use multiple event loops (which do not support ++signal watchers). ++.PP ++When this is not possible, or you want to use the default loop for ++other reasons, then in the process that wants to start \*(L"fresh\*(R", call ++\&\f(CW\*(C`ev_loop_destroy (EV_DEFAULT)\*(C'\fR followed by \f(CW\*(C`ev_default_loop (...)\*(C'\fR. ++Destroying the default loop will \*(L"orphan\*(R" (not stop) all registered ++watchers, so you have to be careful not to execute code that modifies ++those watchers. Note also that in that case, you have to re-register any ++signal watchers. ++.PP ++\fIWatcher-Specific Functions and Data Members\fR ++.IX Subsection "Watcher-Specific Functions and Data Members" ++.IP "ev_fork_init (ev_fork *, callback)" 4 ++.IX Item "ev_fork_init (ev_fork *, callback)" ++Initialises and configures the fork watcher \- it has no parameters of any ++kind. There is a \f(CW\*(C`ev_fork_set\*(C'\fR macro, but using it is utterly pointless, ++really. ++.ie n .SS """ev_cleanup"" \- even the best things end" ++.el .SS "\f(CWev_cleanup\fP \- even the best things end" ++.IX Subsection "ev_cleanup - even the best things end" ++Cleanup watchers are called just before the event loop is being destroyed ++by a call to \f(CW\*(C`ev_loop_destroy\*(C'\fR. ++.PP ++While there is no guarantee that the event loop gets destroyed, cleanup ++watchers provide a convenient method to install cleanup hooks for your ++program, worker threads and so on \- you just to make sure to destroy the ++loop when you want them to be invoked. ++.PP ++Cleanup watchers are invoked in the same way as any other watcher. Unlike ++all other watchers, they do not keep a reference to the event loop (which ++makes a lot of sense if you think about it). Like all other watchers, you ++can call libev functions in the callback, except \f(CW\*(C`ev_cleanup_start\*(C'\fR. ++.PP ++\fIWatcher-Specific Functions and Data Members\fR ++.IX Subsection "Watcher-Specific Functions and Data Members" ++.IP "ev_cleanup_init (ev_cleanup *, callback)" 4 ++.IX Item "ev_cleanup_init (ev_cleanup *, callback)" ++Initialises and configures the cleanup watcher \- it has no parameters of ++any kind. There is a \f(CW\*(C`ev_cleanup_set\*(C'\fR macro, but using it is utterly ++pointless, I assure you. ++.PP ++Example: Register an atexit handler to destroy the default loop, so any ++cleanup functions are called. ++.PP ++.Vb 5 ++\& static void ++\& program_exits (void) ++\& { ++\& ev_loop_destroy (EV_DEFAULT_UC); ++\& } ++\& ++\& ... ++\& atexit (program_exits); ++.Ve ++.ie n .SS """ev_async"" \- how to wake up an event loop" ++.el .SS "\f(CWev_async\fP \- how to wake up an event loop" ++.IX Subsection "ev_async - how to wake up an event loop" ++In general, you cannot use an \f(CW\*(C`ev_loop\*(C'\fR from multiple threads or other ++asynchronous sources such as signal handlers (as opposed to multiple event ++loops \- those are of course safe to use in different threads). ++.PP ++Sometimes, however, you need to wake up an event loop you do not control, ++for example because it belongs to another thread. This is what \f(CW\*(C`ev_async\*(C'\fR ++watchers do: as long as the \f(CW\*(C`ev_async\*(C'\fR watcher is active, you can signal ++it by calling \f(CW\*(C`ev_async_send\*(C'\fR, which is thread\- and signal safe. ++.PP ++This functionality is very similar to \f(CW\*(C`ev_signal\*(C'\fR watchers, as signals, ++too, are asynchronous in nature, and signals, too, will be compressed ++(i.e. the number of callback invocations may be less than the number of ++\&\f(CW\*(C`ev_async_send\*(C'\fR calls). In fact, you could use signal watchers as a kind ++of \*(L"global async watchers\*(R" by using a watcher on an otherwise unused ++signal, and \f(CW\*(C`ev_feed_signal\*(C'\fR to signal this watcher from another thread, ++even without knowing which loop owns the signal. ++.PP ++\fIQueueing\fR ++.IX Subsection "Queueing" ++.PP ++\&\f(CW\*(C`ev_async\*(C'\fR does not support queueing of data in any way. The reason ++is that the author does not know of a simple (or any) algorithm for a ++multiple-writer-single-reader queue that works in all cases and doesn't ++need elaborate support such as pthreads or unportable memory access ++semantics. ++.PP ++That means that if you want to queue data, you have to provide your own ++queue. But at least I can tell you how to implement locking around your ++queue: ++.IP "queueing from a signal handler context" 4 ++.IX Item "queueing from a signal handler context" ++To implement race-free queueing, you simply add to the queue in the signal ++handler but you block the signal handler in the watcher callback. Here is ++an example that does that for some fictitious \s-1SIGUSR1\s0 handler: ++.Sp ++.Vb 1 ++\& static ev_async mysig; ++\& ++\& static void ++\& sigusr1_handler (void) ++\& { ++\& sometype data; ++\& ++\& // no locking etc. ++\& queue_put (data); ++\& ev_async_send (EV_DEFAULT_ &mysig); ++\& } ++\& ++\& static void ++\& mysig_cb (EV_P_ ev_async *w, int revents) ++\& { ++\& sometype data; ++\& sigset_t block, prev; ++\& ++\& sigemptyset (&block); ++\& sigaddset (&block, SIGUSR1); ++\& sigprocmask (SIG_BLOCK, &block, &prev); ++\& ++\& while (queue_get (&data)) ++\& process (data); ++\& ++\& if (sigismember (&prev, SIGUSR1) ++\& sigprocmask (SIG_UNBLOCK, &block, 0); ++\& } ++.Ve ++.Sp ++(Note: pthreads in theory requires you to use \f(CW\*(C`pthread_setmask\*(C'\fR ++instead of \f(CW\*(C`sigprocmask\*(C'\fR when you use threads, but libev doesn't do it ++either...). ++.IP "queueing from a thread context" 4 ++.IX Item "queueing from a thread context" ++The strategy for threads is different, as you cannot (easily) block ++threads but you can easily preempt them, so to queue safely you need to ++employ a traditional mutex lock, such as in this pthread example: ++.Sp ++.Vb 2 ++\& static ev_async mysig; ++\& static pthread_mutex_t mymutex = PTHREAD_MUTEX_INITIALIZER; ++\& ++\& static void ++\& otherthread (void) ++\& { ++\& // only need to lock the actual queueing operation ++\& pthread_mutex_lock (&mymutex); ++\& queue_put (data); ++\& pthread_mutex_unlock (&mymutex); ++\& ++\& ev_async_send (EV_DEFAULT_ &mysig); ++\& } ++\& ++\& static void ++\& mysig_cb (EV_P_ ev_async *w, int revents) ++\& { ++\& pthread_mutex_lock (&mymutex); ++\& ++\& while (queue_get (&data)) ++\& process (data); ++\& ++\& pthread_mutex_unlock (&mymutex); ++\& } ++.Ve ++.PP ++\fIWatcher-Specific Functions and Data Members\fR ++.IX Subsection "Watcher-Specific Functions and Data Members" ++.IP "ev_async_init (ev_async *, callback)" 4 ++.IX Item "ev_async_init (ev_async *, callback)" ++Initialises and configures the async watcher \- it has no parameters of any ++kind. There is a \f(CW\*(C`ev_async_set\*(C'\fR macro, but using it is utterly pointless, ++trust me. ++.IP "ev_async_send (loop, ev_async *)" 4 ++.IX Item "ev_async_send (loop, ev_async *)" ++Sends/signals/activates the given \f(CW\*(C`ev_async\*(C'\fR watcher, that is, feeds ++an \f(CW\*(C`EV_ASYNC\*(C'\fR event on the watcher into the event loop, and instantly ++returns. ++.Sp ++Unlike \f(CW\*(C`ev_feed_event\*(C'\fR, this call is safe to do from other threads, ++signal or similar contexts (see the discussion of \f(CW\*(C`EV_ATOMIC_T\*(C'\fR in the ++embedding section below on what exactly this means). ++.Sp ++Note that, as with other watchers in libev, multiple events might get ++compressed into a single callback invocation (another way to look at ++this is that \f(CW\*(C`ev_async\*(C'\fR watchers are level-triggered: they are set on ++\&\f(CW\*(C`ev_async_send\*(C'\fR, reset when the event loop detects that). ++.Sp ++This call incurs the overhead of at most one extra system call per event ++loop iteration, if the event loop is blocked, and no syscall at all if ++the event loop (or your program) is processing events. That means that ++repeated calls are basically free (there is no need to avoid calls for ++performance reasons) and that the overhead becomes smaller (typically ++zero) under load. ++.IP "bool = ev_async_pending (ev_async *)" 4 ++.IX Item "bool = ev_async_pending (ev_async *)" ++Returns a non-zero value when \f(CW\*(C`ev_async_send\*(C'\fR has been called on the ++watcher but the event has not yet been processed (or even noted) by the ++event loop. ++.Sp ++\&\f(CW\*(C`ev_async_send\*(C'\fR sets a flag in the watcher and wakes up the loop. When ++the loop iterates next and checks for the watcher to have become active, ++it will reset the flag again. \f(CW\*(C`ev_async_pending\*(C'\fR can be used to very ++quickly check whether invoking the loop might be a good idea. ++.Sp ++Not that this does \fInot\fR check whether the watcher itself is pending, ++only whether it has been requested to make this watcher pending: there ++is a time window between the event loop checking and resetting the async ++notification, and the callback being invoked. ++.SH "OTHER FUNCTIONS" ++.IX Header "OTHER FUNCTIONS" ++There are some other functions of possible interest. Described. Here. Now. ++.IP "ev_once (loop, int fd, int events, ev_tstamp timeout, callback)" 4 ++.IX Item "ev_once (loop, int fd, int events, ev_tstamp timeout, callback)" ++This function combines a simple timer and an I/O watcher, calls your ++callback on whichever event happens first and automatically stops both ++watchers. This is useful if you want to wait for a single event on an fd ++or timeout without having to allocate/configure/start/stop/free one or ++more watchers yourself. ++.Sp ++If \f(CW\*(C`fd\*(C'\fR is less than 0, then no I/O watcher will be started and the ++\&\f(CW\*(C`events\*(C'\fR argument is being ignored. Otherwise, an \f(CW\*(C`ev_io\*(C'\fR watcher for ++the given \f(CW\*(C`fd\*(C'\fR and \f(CW\*(C`events\*(C'\fR set will be created and started. ++.Sp ++If \f(CW\*(C`timeout\*(C'\fR is less than 0, then no timeout watcher will be ++started. Otherwise an \f(CW\*(C`ev_timer\*(C'\fR watcher with after = \f(CW\*(C`timeout\*(C'\fR (and ++repeat = 0) will be started. \f(CW0\fR is a valid timeout. ++.Sp ++The callback has the type \f(CW\*(C`void (*cb)(int revents, void *arg)\*(C'\fR and is ++passed an \f(CW\*(C`revents\*(C'\fR set like normal event callbacks (a combination of ++\&\f(CW\*(C`EV_ERROR\*(C'\fR, \f(CW\*(C`EV_READ\*(C'\fR, \f(CW\*(C`EV_WRITE\*(C'\fR or \f(CW\*(C`EV_TIMER\*(C'\fR) and the \f(CW\*(C`arg\*(C'\fR ++value passed to \f(CW\*(C`ev_once\*(C'\fR. Note that it is possible to receive \fIboth\fR ++a timeout and an io event at the same time \- you probably should give io ++events precedence. ++.Sp ++Example: wait up to ten seconds for data to appear on \s-1STDIN_FILENO\s0. ++.Sp ++.Vb 7 ++\& static void stdin_ready (int revents, void *arg) ++\& { ++\& if (revents & EV_READ) ++\& /* stdin might have data for us, joy! */; ++\& else if (revents & EV_TIMER) ++\& /* doh, nothing entered */; ++\& } ++\& ++\& ev_once (STDIN_FILENO, EV_READ, 10., stdin_ready, 0); ++.Ve ++.IP "ev_feed_fd_event (loop, int fd, int revents)" 4 ++.IX Item "ev_feed_fd_event (loop, int fd, int revents)" ++Feed an event on the given fd, as if a file descriptor backend detected ++the given events. ++.IP "ev_feed_signal_event (loop, int signum)" 4 ++.IX Item "ev_feed_signal_event (loop, int signum)" ++Feed an event as if the given signal occurred. See also \f(CW\*(C`ev_feed_signal\*(C'\fR, ++which is async-safe. ++.SH "COMMON OR USEFUL IDIOMS (OR BOTH)" ++.IX Header "COMMON OR USEFUL IDIOMS (OR BOTH)" ++This section explains some common idioms that are not immediately ++obvious. Note that examples are sprinkled over the whole manual, and this ++section only contains stuff that wouldn't fit anywhere else. ++.SS "\s-1ASSOCIATING\s0 \s-1CUSTOM\s0 \s-1DATA\s0 \s-1WITH\s0 A \s-1WATCHER\s0" ++.IX Subsection "ASSOCIATING CUSTOM DATA WITH A WATCHER" ++Each watcher has, by default, a \f(CW\*(C`void *data\*(C'\fR member that you can read ++or modify at any time: libev will completely ignore it. This can be used ++to associate arbitrary data with your watcher. If you need more data and ++don't want to allocate memory separately and store a pointer to it in that ++data member, you can also \*(L"subclass\*(R" the watcher type and provide your own ++data: ++.PP ++.Vb 7 ++\& struct my_io ++\& { ++\& ev_io io; ++\& int otherfd; ++\& void *somedata; ++\& struct whatever *mostinteresting; ++\& }; ++\& ++\& ... ++\& struct my_io w; ++\& ev_io_init (&w.io, my_cb, fd, EV_READ); ++.Ve ++.PP ++And since your callback will be called with a pointer to the watcher, you ++can cast it back to your own type: ++.PP ++.Vb 5 ++\& static void my_cb (struct ev_loop *loop, ev_io *w_, int revents) ++\& { ++\& struct my_io *w = (struct my_io *)w_; ++\& ... ++\& } ++.Ve ++.PP ++More interesting and less C\-conformant ways of casting your callback ++function type instead have been omitted. ++.SS "\s-1BUILDING\s0 \s-1YOUR\s0 \s-1OWN\s0 \s-1COMPOSITE\s0 \s-1WATCHERS\s0" ++.IX Subsection "BUILDING YOUR OWN COMPOSITE WATCHERS" ++Another common scenario is to use some data structure with multiple ++embedded watchers, in effect creating your own watcher that combines ++multiple libev event sources into one \*(L"super-watcher\*(R": ++.PP ++.Vb 6 ++\& struct my_biggy ++\& { ++\& int some_data; ++\& ev_timer t1; ++\& ev_timer t2; ++\& } ++.Ve ++.PP ++In this case getting the pointer to \f(CW\*(C`my_biggy\*(C'\fR is a bit more ++complicated: Either you store the address of your \f(CW\*(C`my_biggy\*(C'\fR struct in ++the \f(CW\*(C`data\*(C'\fR member of the watcher (for woozies or \*(C+ coders), or you need ++to use some pointer arithmetic using \f(CW\*(C`offsetof\*(C'\fR inside your watchers (for ++real programmers): ++.PP ++.Vb 1 ++\& #include ++\& ++\& static void ++\& t1_cb (EV_P_ ev_timer *w, int revents) ++\& { ++\& struct my_biggy big = (struct my_biggy *) ++\& (((char *)w) \- offsetof (struct my_biggy, t1)); ++\& } ++\& ++\& static void ++\& t2_cb (EV_P_ ev_timer *w, int revents) ++\& { ++\& struct my_biggy big = (struct my_biggy *) ++\& (((char *)w) \- offsetof (struct my_biggy, t2)); ++\& } ++.Ve ++.SS "\s-1AVOIDING\s0 \s-1FINISHING\s0 \s-1BEFORE\s0 \s-1RETURNING\s0" ++.IX Subsection "AVOIDING FINISHING BEFORE RETURNING" ++Often you have structures like this in event-based programs: ++.PP ++.Vb 4 ++\& callback () ++\& { ++\& free (request); ++\& } ++\& ++\& request = start_new_request (..., callback); ++.Ve ++.PP ++The intent is to start some \*(L"lengthy\*(R" operation. The \f(CW\*(C`request\*(C'\fR could be ++used to cancel the operation, or do other things with it. ++.PP ++It's not uncommon to have code paths in \f(CW\*(C`start_new_request\*(C'\fR that ++immediately invoke the callback, for example, to report errors. Or you add ++some caching layer that finds that it can skip the lengthy aspects of the ++operation and simply invoke the callback with the result. ++.PP ++The problem here is that this will happen \fIbefore\fR \f(CW\*(C`start_new_request\*(C'\fR ++has returned, so \f(CW\*(C`request\*(C'\fR is not set. ++.PP ++Even if you pass the request by some safer means to the callback, you ++might want to do something to the request after starting it, such as ++canceling it, which probably isn't working so well when the callback has ++already been invoked. ++.PP ++A common way around all these issues is to make sure that ++\&\f(CW\*(C`start_new_request\*(C'\fR \fIalways\fR returns before the callback is invoked. If ++\&\f(CW\*(C`start_new_request\*(C'\fR immediately knows the result, it can artificially ++delay invoking the callback by using a \f(CW\*(C`prepare\*(C'\fR or \f(CW\*(C`idle\*(C'\fR watcher for ++example, or more sneakily, by reusing an existing (stopped) watcher and ++pushing it into the pending queue: ++.PP ++.Vb 2 ++\& ev_set_cb (watcher, callback); ++\& ev_feed_event (EV_A_ watcher, 0); ++.Ve ++.PP ++This way, \f(CW\*(C`start_new_request\*(C'\fR can safely return before the callback is ++invoked, while not delaying callback invocation too much. ++.SS "\s-1MODEL/NESTED\s0 \s-1EVENT\s0 \s-1LOOP\s0 \s-1INVOCATIONS\s0 \s-1AND\s0 \s-1EXIT\s0 \s-1CONDITIONS\s0" ++.IX Subsection "MODEL/NESTED EVENT LOOP INVOCATIONS AND EXIT CONDITIONS" ++Often (especially in \s-1GUI\s0 toolkits) there are places where you have ++\&\fImodal\fR interaction, which is most easily implemented by recursively ++invoking \f(CW\*(C`ev_run\*(C'\fR. ++.PP ++This brings the problem of exiting \- a callback might want to finish the ++main \f(CW\*(C`ev_run\*(C'\fR call, but not the nested one (e.g. user clicked \*(L"Quit\*(R", but ++a modal \*(L"Are you sure?\*(R" dialog is still waiting), or just the nested one ++and not the main one (e.g. user clocked \*(L"Ok\*(R" in a modal dialog), or some ++other combination: In these cases, a simple \f(CW\*(C`ev_break\*(C'\fR will not work. ++.PP ++The solution is to maintain \*(L"break this loop\*(R" variable for each \f(CW\*(C`ev_run\*(C'\fR ++invocation, and use a loop around \f(CW\*(C`ev_run\*(C'\fR until the condition is ++triggered, using \f(CW\*(C`EVRUN_ONCE\*(C'\fR: ++.PP ++.Vb 2 ++\& // main loop ++\& int exit_main_loop = 0; ++\& ++\& while (!exit_main_loop) ++\& ev_run (EV_DEFAULT_ EVRUN_ONCE); ++\& ++\& // in a modal watcher ++\& int exit_nested_loop = 0; ++\& ++\& while (!exit_nested_loop) ++\& ev_run (EV_A_ EVRUN_ONCE); ++.Ve ++.PP ++To exit from any of these loops, just set the corresponding exit variable: ++.PP ++.Vb 2 ++\& // exit modal loop ++\& exit_nested_loop = 1; ++\& ++\& // exit main program, after modal loop is finished ++\& exit_main_loop = 1; ++\& ++\& // exit both ++\& exit_main_loop = exit_nested_loop = 1; ++.Ve ++.SS "\s-1THREAD\s0 \s-1LOCKING\s0 \s-1EXAMPLE\s0" ++.IX Subsection "THREAD LOCKING EXAMPLE" ++Here is a fictitious example of how to run an event loop in a different ++thread from where callbacks are being invoked and watchers are ++created/added/removed. ++.PP ++For a real-world example, see the \f(CW\*(C`EV::Loop::Async\*(C'\fR perl module, ++which uses exactly this technique (which is suited for many high-level ++languages). ++.PP ++The example uses a pthread mutex to protect the loop data, a condition ++variable to wait for callback invocations, an async watcher to notify the ++event loop thread and an unspecified mechanism to wake up the main thread. ++.PP ++First, you need to associate some data with the event loop: ++.PP ++.Vb 6 ++\& typedef struct { ++\& mutex_t lock; /* global loop lock */ ++\& ev_async async_w; ++\& thread_t tid; ++\& cond_t invoke_cv; ++\& } userdata; ++\& ++\& void prepare_loop (EV_P) ++\& { ++\& // for simplicity, we use a static userdata struct. ++\& static userdata u; ++\& ++\& ev_async_init (&u\->async_w, async_cb); ++\& ev_async_start (EV_A_ &u\->async_w); ++\& ++\& pthread_mutex_init (&u\->lock, 0); ++\& pthread_cond_init (&u\->invoke_cv, 0); ++\& ++\& // now associate this with the loop ++\& ev_set_userdata (EV_A_ u); ++\& ev_set_invoke_pending_cb (EV_A_ l_invoke); ++\& ev_set_loop_release_cb (EV_A_ l_release, l_acquire); ++\& ++\& // then create the thread running ev_run ++\& pthread_create (&u\->tid, 0, l_run, EV_A); ++\& } ++.Ve ++.PP ++The callback for the \f(CW\*(C`ev_async\*(C'\fR watcher does nothing: the watcher is used ++solely to wake up the event loop so it takes notice of any new watchers ++that might have been added: ++.PP ++.Vb 5 ++\& static void ++\& async_cb (EV_P_ ev_async *w, int revents) ++\& { ++\& // just used for the side effects ++\& } ++.Ve ++.PP ++The \f(CW\*(C`l_release\*(C'\fR and \f(CW\*(C`l_acquire\*(C'\fR callbacks simply unlock/lock the mutex ++protecting the loop data, respectively. ++.PP ++.Vb 6 ++\& static void ++\& l_release (EV_P) ++\& { ++\& userdata *u = ev_userdata (EV_A); ++\& pthread_mutex_unlock (&u\->lock); ++\& } ++\& ++\& static void ++\& l_acquire (EV_P) ++\& { ++\& userdata *u = ev_userdata (EV_A); ++\& pthread_mutex_lock (&u\->lock); ++\& } ++.Ve ++.PP ++The event loop thread first acquires the mutex, and then jumps straight ++into \f(CW\*(C`ev_run\*(C'\fR: ++.PP ++.Vb 4 ++\& void * ++\& l_run (void *thr_arg) ++\& { ++\& struct ev_loop *loop = (struct ev_loop *)thr_arg; ++\& ++\& l_acquire (EV_A); ++\& pthread_setcanceltype (PTHREAD_CANCEL_ASYNCHRONOUS, 0); ++\& ev_run (EV_A_ 0); ++\& l_release (EV_A); ++\& ++\& return 0; ++\& } ++.Ve ++.PP ++Instead of invoking all pending watchers, the \f(CW\*(C`l_invoke\*(C'\fR callback will ++signal the main thread via some unspecified mechanism (signals? pipe ++writes? \f(CW\*(C`Async::Interrupt\*(C'\fR?) and then waits until all pending watchers ++have been called (in a while loop because a) spurious wakeups are possible ++and b) skipping inter-thread-communication when there are no pending ++watchers is very beneficial): ++.PP ++.Vb 4 ++\& static void ++\& l_invoke (EV_P) ++\& { ++\& userdata *u = ev_userdata (EV_A); ++\& ++\& while (ev_pending_count (EV_A)) ++\& { ++\& wake_up_other_thread_in_some_magic_or_not_so_magic_way (); ++\& pthread_cond_wait (&u\->invoke_cv, &u\->lock); ++\& } ++\& } ++.Ve ++.PP ++Now, whenever the main thread gets told to invoke pending watchers, it ++will grab the lock, call \f(CW\*(C`ev_invoke_pending\*(C'\fR and then signal the loop ++thread to continue: ++.PP ++.Vb 4 ++\& static void ++\& real_invoke_pending (EV_P) ++\& { ++\& userdata *u = ev_userdata (EV_A); ++\& ++\& pthread_mutex_lock (&u\->lock); ++\& ev_invoke_pending (EV_A); ++\& pthread_cond_signal (&u\->invoke_cv); ++\& pthread_mutex_unlock (&u\->lock); ++\& } ++.Ve ++.PP ++Whenever you want to start/stop a watcher or do other modifications to an ++event loop, you will now have to lock: ++.PP ++.Vb 2 ++\& ev_timer timeout_watcher; ++\& userdata *u = ev_userdata (EV_A); ++\& ++\& ev_timer_init (&timeout_watcher, timeout_cb, 5.5, 0.); ++\& ++\& pthread_mutex_lock (&u\->lock); ++\& ev_timer_start (EV_A_ &timeout_watcher); ++\& ev_async_send (EV_A_ &u\->async_w); ++\& pthread_mutex_unlock (&u\->lock); ++.Ve ++.PP ++Note that sending the \f(CW\*(C`ev_async\*(C'\fR watcher is required because otherwise ++an event loop currently blocking in the kernel will have no knowledge ++about the newly added timer. By waking up the loop it will pick up any new ++watchers in the next event loop iteration. ++.SS "\s-1THREADS\s0, \s-1COROUTINES\s0, \s-1CONTINUATIONS\s0, \s-1QUEUES\s0... \s-1INSTEAD\s0 \s-1OF\s0 \s-1CALLBACKS\s0" ++.IX Subsection "THREADS, COROUTINES, CONTINUATIONS, QUEUES... INSTEAD OF CALLBACKS" ++While the overhead of a callback that e.g. schedules a thread is small, it ++is still an overhead. If you embed libev, and your main usage is with some ++kind of threads or coroutines, you might want to customise libev so that ++doesn't need callbacks anymore. ++.PP ++Imagine you have coroutines that you can switch to using a function ++\&\f(CW\*(C`switch_to (coro)\*(C'\fR, that libev runs in a coroutine called \f(CW\*(C`libev_coro\*(C'\fR ++and that due to some magic, the currently active coroutine is stored in a ++global called \f(CW\*(C`current_coro\*(C'\fR. Then you can build your own \*(L"wait for libev ++event\*(R" primitive by changing \f(CW\*(C`EV_CB_DECLARE\*(C'\fR and \f(CW\*(C`EV_CB_INVOKE\*(C'\fR (note ++the differing \f(CW\*(C`;\*(C'\fR conventions): ++.PP ++.Vb 2 ++\& #define EV_CB_DECLARE(type) struct my_coro *cb; ++\& #define EV_CB_INVOKE(watcher) switch_to ((watcher)\->cb) ++.Ve ++.PP ++That means instead of having a C callback function, you store the ++coroutine to switch to in each watcher, and instead of having libev call ++your callback, you instead have it switch to that coroutine. ++.PP ++A coroutine might now wait for an event with a function called ++\&\f(CW\*(C`wait_for_event\*(C'\fR. (the watcher needs to be started, as always, but it doesn't ++matter when, or whether the watcher is active or not when this function is ++called): ++.PP ++.Vb 6 ++\& void ++\& wait_for_event (ev_watcher *w) ++\& { ++\& ev_set_cb (w, current_coro); ++\& switch_to (libev_coro); ++\& } ++.Ve ++.PP ++That basically suspends the coroutine inside \f(CW\*(C`wait_for_event\*(C'\fR and ++continues the libev coroutine, which, when appropriate, switches back to ++this or any other coroutine. ++.PP ++You can do similar tricks if you have, say, threads with an event queue \- ++instead of storing a coroutine, you store the queue object and instead of ++switching to a coroutine, you push the watcher onto the queue and notify ++any waiters. ++.PP ++To embed libev, see \*(L"\s-1EMBEDDING\s0\*(R", but in short, it's easiest to create two ++files, \fImy_ev.h\fR and \fImy_ev.c\fR that include the respective libev files: ++.PP ++.Vb 4 ++\& // my_ev.h ++\& #define EV_CB_DECLARE(type) struct my_coro *cb; ++\& #define EV_CB_INVOKE(watcher) switch_to ((watcher)\->cb); ++\& #include "../libev/ev.h" ++\& ++\& // my_ev.c ++\& #define EV_H "my_ev.h" ++\& #include "../libev/ev.c" ++.Ve ++.PP ++And then use \fImy_ev.h\fR when you would normally use \fIev.h\fR, and compile ++\&\fImy_ev.c\fR into your project. When properly specifying include paths, you ++can even use \fIev.h\fR as header file name directly. ++.SH "LIBEVENT EMULATION" ++.IX Header "LIBEVENT EMULATION" ++Libev offers a compatibility emulation layer for libevent. It cannot ++emulate the internals of libevent, so here are some usage hints: ++.IP "\(bu" 4 ++Only the libevent\-1.4.1\-beta \s-1API\s0 is being emulated. ++.Sp ++This was the newest libevent version available when libev was implemented, ++and is still mostly unchanged in 2010. ++.IP "\(bu" 4 ++Use it by including , as usual. ++.IP "\(bu" 4 ++The following members are fully supported: ev_base, ev_callback, ++ev_arg, ev_fd, ev_res, ev_events. ++.IP "\(bu" 4 ++Avoid using ev_flags and the EVLIST_*\-macros, while it is ++maintained by libev, it does not work exactly the same way as in libevent (consider ++it a private \s-1API\s0). ++.IP "\(bu" 4 ++Priorities are not currently supported. Initialising priorities ++will fail and all watchers will have the same priority, even though there ++is an ev_pri field. ++.IP "\(bu" 4 ++In libevent, the last base created gets the signals, in libev, the ++base that registered the signal gets the signals. ++.IP "\(bu" 4 ++Other members are not supported. ++.IP "\(bu" 4 ++The libev emulation is \fInot\fR \s-1ABI\s0 compatible to libevent, you need ++to use the libev header file and library. ++.SH "\*(C+ SUPPORT" ++.IX Header " SUPPORT" ++.SS "C \s-1API\s0" ++.IX Subsection "C API" ++The normal C \s-1API\s0 should work fine when used from \*(C+: both ev.h and the ++libev sources can be compiled as \*(C+. Therefore, code that uses the C \s-1API\s0 ++will work fine. ++.PP ++Proper exception specifications might have to be added to callbacks passed ++to libev: exceptions may be thrown only from watcher callbacks, all ++other callbacks (allocator, syserr, loop acquire/release and periodic ++reschedule callbacks) must not throw exceptions, and might need a \f(CW\*(C`throw ++()\*(C'\fR specification. If you have code that needs to be compiled as both C ++and \*(C+ you can use the \f(CW\*(C`EV_THROW\*(C'\fR macro for this: ++.PP ++.Vb 6 ++\& static void ++\& fatal_error (const char *msg) EV_THROW ++\& { ++\& perror (msg); ++\& abort (); ++\& } ++\& ++\& ... ++\& ev_set_syserr_cb (fatal_error); ++.Ve ++.PP ++The only \s-1API\s0 functions that can currently throw exceptions are \f(CW\*(C`ev_run\*(C'\fR, ++\&\f(CW\*(C`ev_invoke\*(C'\fR, \f(CW\*(C`ev_invoke_pending\*(C'\fR and \f(CW\*(C`ev_loop_destroy\*(C'\fR (the latter ++because it runs cleanup watchers). ++.PP ++Throwing exceptions in watcher callbacks is only supported if libev itself ++is compiled with a \*(C+ compiler or your C and \*(C+ environments allow ++throwing exceptions through C libraries (most do). ++.SS "\*(C+ \s-1API\s0" ++.IX Subsection " API" ++Libev comes with some simplistic wrapper classes for \*(C+ that mainly allow ++you to use some convenience methods to start/stop watchers and also change ++the callback model to a model using method callbacks on objects. ++.PP ++To use it, ++.PP ++.Vb 1 ++\& #include ++.Ve ++.PP ++This automatically includes \fIev.h\fR and puts all of its definitions (many ++of them macros) into the global namespace. All \*(C+ specific things are ++put into the \f(CW\*(C`ev\*(C'\fR namespace. It should support all the same embedding ++options as \fIev.h\fR, most notably \f(CW\*(C`EV_MULTIPLICITY\*(C'\fR. ++.PP ++Care has been taken to keep the overhead low. The only data member the \*(C+ ++classes add (compared to plain C\-style watchers) is the event loop pointer ++that the watcher is associated with (or no additional members at all if ++you disable \f(CW\*(C`EV_MULTIPLICITY\*(C'\fR when embedding libev). ++.PP ++Currently, functions, static and non-static member functions and classes ++with \f(CW\*(C`operator ()\*(C'\fR can be used as callbacks. Other types should be easy ++to add as long as they only need one additional pointer for context. If ++you need support for other types of functors please contact the author ++(preferably after implementing it). ++.PP ++For all this to work, your \*(C+ compiler either has to use the same calling ++conventions as your C compiler (for static member functions), or you have ++to embed libev and compile libev itself as \*(C+. ++.PP ++Here is a list of things available in the \f(CW\*(C`ev\*(C'\fR namespace: ++.ie n .IP """ev::READ"", ""ev::WRITE"" etc." 4 ++.el .IP "\f(CWev::READ\fR, \f(CWev::WRITE\fR etc." 4 ++.IX Item "ev::READ, ev::WRITE etc." ++These are just enum values with the same values as the \f(CW\*(C`EV_READ\*(C'\fR etc. ++macros from \fIev.h\fR. ++.ie n .IP """ev::tstamp"", ""ev::now""" 4 ++.el .IP "\f(CWev::tstamp\fR, \f(CWev::now\fR" 4 ++.IX Item "ev::tstamp, ev::now" ++Aliases to the same types/functions as with the \f(CW\*(C`ev_\*(C'\fR prefix. ++.ie n .IP """ev::io"", ""ev::timer"", ""ev::periodic"", ""ev::idle"", ""ev::sig"" etc." 4 ++.el .IP "\f(CWev::io\fR, \f(CWev::timer\fR, \f(CWev::periodic\fR, \f(CWev::idle\fR, \f(CWev::sig\fR etc." 4 ++.IX Item "ev::io, ev::timer, ev::periodic, ev::idle, ev::sig etc." ++For each \f(CW\*(C`ev_TYPE\*(C'\fR watcher in \fIev.h\fR there is a corresponding class of ++the same name in the \f(CW\*(C`ev\*(C'\fR namespace, with the exception of \f(CW\*(C`ev_signal\*(C'\fR ++which is called \f(CW\*(C`ev::sig\*(C'\fR to avoid clashes with the \f(CW\*(C`signal\*(C'\fR macro ++defined by many implementations. ++.Sp ++All of those classes have these methods: ++.RS 4 ++.IP "ev::TYPE::TYPE ()" 4 ++.IX Item "ev::TYPE::TYPE ()" ++.PD 0 ++.IP "ev::TYPE::TYPE (loop)" 4 ++.IX Item "ev::TYPE::TYPE (loop)" ++.IP "ev::TYPE::~TYPE" 4 ++.IX Item "ev::TYPE::~TYPE" ++.PD ++The constructor (optionally) takes an event loop to associate the watcher ++with. If it is omitted, it will use \f(CW\*(C`EV_DEFAULT\*(C'\fR. ++.Sp ++The constructor calls \f(CW\*(C`ev_init\*(C'\fR for you, which means you have to call the ++\&\f(CW\*(C`set\*(C'\fR method before starting it. ++.Sp ++It will not set a callback, however: You have to call the templated \f(CW\*(C`set\*(C'\fR ++method to set a callback before you can start the watcher. ++.Sp ++(The reason why you have to use a method is a limitation in \*(C+ which does ++not allow explicit template arguments for constructors). ++.Sp ++The destructor automatically stops the watcher if it is active. ++.IP "w\->set (object *)" 4 ++.IX Item "w->set (object *)" ++This method sets the callback method to call. The method has to have a ++signature of \f(CW\*(C`void (*)(ev_TYPE &, int)\*(C'\fR, it receives the watcher as ++first argument and the \f(CW\*(C`revents\*(C'\fR as second. The object must be given as ++parameter and is stored in the \f(CW\*(C`data\*(C'\fR member of the watcher. ++.Sp ++This method synthesizes efficient thunking code to call your method from ++the C callback that libev requires. If your compiler can inline your ++callback (i.e. it is visible to it at the place of the \f(CW\*(C`set\*(C'\fR call and ++your compiler is good :), then the method will be fully inlined into the ++thunking function, making it as fast as a direct C callback. ++.Sp ++Example: simple class declaration and watcher initialisation ++.Sp ++.Vb 4 ++\& struct myclass ++\& { ++\& void io_cb (ev::io &w, int revents) { } ++\& } ++\& ++\& myclass obj; ++\& ev::io iow; ++\& iow.set (&obj); ++.Ve ++.IP "w\->set (object *)" 4 ++.IX Item "w->set (object *)" ++This is a variation of a method callback \- leaving out the method to call ++will default the method to \f(CW\*(C`operator ()\*(C'\fR, which makes it possible to use ++functor objects without having to manually specify the \f(CW\*(C`operator ()\*(C'\fR all ++the time. Incidentally, you can then also leave out the template argument ++list. ++.Sp ++The \f(CW\*(C`operator ()\*(C'\fR method prototype must be \f(CW\*(C`void operator ()(watcher &w, ++int revents)\*(C'\fR. ++.Sp ++See the method\-\f(CW\*(C`set\*(C'\fR above for more details. ++.Sp ++Example: use a functor object as callback. ++.Sp ++.Vb 7 ++\& struct myfunctor ++\& { ++\& void operator() (ev::io &w, int revents) ++\& { ++\& ... ++\& } ++\& } ++\& ++\& myfunctor f; ++\& ++\& ev::io w; ++\& w.set (&f); ++.Ve ++.IP "w\->set (void *data = 0)" 4 ++.IX Item "w->set (void *data = 0)" ++Also sets a callback, but uses a static method or plain function as ++callback. The optional \f(CW\*(C`data\*(C'\fR argument will be stored in the watcher's ++\&\f(CW\*(C`data\*(C'\fR member and is free for you to use. ++.Sp ++The prototype of the \f(CW\*(C`function\*(C'\fR must be \f(CW\*(C`void (*)(ev::TYPE &w, int)\*(C'\fR. ++.Sp ++See the method\-\f(CW\*(C`set\*(C'\fR above for more details. ++.Sp ++Example: Use a plain function as callback. ++.Sp ++.Vb 2 ++\& static void io_cb (ev::io &w, int revents) { } ++\& iow.set (); ++.Ve ++.IP "w\->set (loop)" 4 ++.IX Item "w->set (loop)" ++Associates a different \f(CW\*(C`struct ev_loop\*(C'\fR with this watcher. You can only ++do this when the watcher is inactive (and not pending either). ++.IP "w\->set ([arguments])" 4 ++.IX Item "w->set ([arguments])" ++Basically the same as \f(CW\*(C`ev_TYPE_set\*(C'\fR (except for \f(CW\*(C`ev::embed\*(C'\fR watchers>), ++with the same arguments. Either this method or a suitable start method ++must be called at least once. Unlike the C counterpart, an active watcher ++gets automatically stopped and restarted when reconfiguring it with this ++method. ++.Sp ++For \f(CW\*(C`ev::embed\*(C'\fR watchers this method is called \f(CW\*(C`set_embed\*(C'\fR, to avoid ++clashing with the \f(CW\*(C`set (loop)\*(C'\fR method. ++.IP "w\->start ()" 4 ++.IX Item "w->start ()" ++Starts the watcher. Note that there is no \f(CW\*(C`loop\*(C'\fR argument, as the ++constructor already stores the event loop. ++.IP "w\->start ([arguments])" 4 ++.IX Item "w->start ([arguments])" ++Instead of calling \f(CW\*(C`set\*(C'\fR and \f(CW\*(C`start\*(C'\fR methods separately, it is often ++convenient to wrap them in one call. Uses the same type of arguments as ++the configure \f(CW\*(C`set\*(C'\fR method of the watcher. ++.IP "w\->stop ()" 4 ++.IX Item "w->stop ()" ++Stops the watcher if it is active. Again, no \f(CW\*(C`loop\*(C'\fR argument. ++.ie n .IP "w\->again () (""ev::timer"", ""ev::periodic"" only)" 4 ++.el .IP "w\->again () (\f(CWev::timer\fR, \f(CWev::periodic\fR only)" 4 ++.IX Item "w->again () (ev::timer, ev::periodic only)" ++For \f(CW\*(C`ev::timer\*(C'\fR and \f(CW\*(C`ev::periodic\*(C'\fR, this invokes the corresponding ++\&\f(CW\*(C`ev_TYPE_again\*(C'\fR function. ++.ie n .IP "w\->sweep () (""ev::embed"" only)" 4 ++.el .IP "w\->sweep () (\f(CWev::embed\fR only)" 4 ++.IX Item "w->sweep () (ev::embed only)" ++Invokes \f(CW\*(C`ev_embed_sweep\*(C'\fR. ++.ie n .IP "w\->update () (""ev::stat"" only)" 4 ++.el .IP "w\->update () (\f(CWev::stat\fR only)" 4 ++.IX Item "w->update () (ev::stat only)" ++Invokes \f(CW\*(C`ev_stat_stat\*(C'\fR. ++.RE ++.RS 4 ++.RE ++.PP ++Example: Define a class with two I/O and idle watchers, start the I/O ++watchers in the constructor. ++.PP ++.Vb 5 ++\& class myclass ++\& { ++\& ev::io io ; void io_cb (ev::io &w, int revents); ++\& ev::io io2 ; void io2_cb (ev::io &w, int revents); ++\& ev::idle idle; void idle_cb (ev::idle &w, int revents); ++\& ++\& myclass (int fd) ++\& { ++\& io .set (this); ++\& io2 .set (this); ++\& idle.set (this); ++\& ++\& io.set (fd, ev::WRITE); // configure the watcher ++\& io.start (); // start it whenever convenient ++\& ++\& io2.start (fd, ev::READ); // set + start in one call ++\& } ++\& }; ++.Ve ++.SH "OTHER LANGUAGE BINDINGS" ++.IX Header "OTHER LANGUAGE BINDINGS" ++Libev does not offer other language bindings itself, but bindings for a ++number of languages exist in the form of third-party packages. If you know ++any interesting language binding in addition to the ones listed here, drop ++me a note. ++.IP "Perl" 4 ++.IX Item "Perl" ++The \s-1EV\s0 module implements the full libev \s-1API\s0 and is actually used to test ++libev. \s-1EV\s0 is developed together with libev. Apart from the \s-1EV\s0 core module, ++there are additional modules that implement libev-compatible interfaces ++to \f(CW\*(C`libadns\*(C'\fR (\f(CW\*(C`EV::ADNS\*(C'\fR, but \f(CW\*(C`AnyEvent::DNS\*(C'\fR is preferred nowadays), ++\&\f(CW\*(C`Net::SNMP\*(C'\fR (\f(CW\*(C`Net::SNMP::EV\*(C'\fR) and the \f(CW\*(C`libglib\*(C'\fR event core (\f(CW\*(C`Glib::EV\*(C'\fR ++and \f(CW\*(C`EV::Glib\*(C'\fR). ++.Sp ++It can be found and installed via \s-1CPAN\s0, its homepage is at ++. ++.IP "Python" 4 ++.IX Item "Python" ++Python bindings can be found at . It ++seems to be quite complete and well-documented. ++.IP "Ruby" 4 ++.IX Item "Ruby" ++Tony Arcieri has written a ruby extension that offers access to a subset ++of the libev \s-1API\s0 and adds file handle abstractions, asynchronous \s-1DNS\s0 and ++more on top of it. It can be found via gem servers. Its homepage is at ++. ++.Sp ++Roger Pack reports that using the link order \f(CW\*(C`\-lws2_32 \-lmsvcrt\-ruby\-190\*(C'\fR ++makes rev work even on mingw. ++.IP "Haskell" 4 ++.IX Item "Haskell" ++A haskell binding to libev is available at ++. ++.IP "D" 4 ++.IX Item "D" ++Leandro Lucarella has written a D language binding (\fIev.d\fR) for libev, to ++be found at . ++.IP "Ocaml" 4 ++.IX Item "Ocaml" ++Erkki Seppala has written Ocaml bindings for libev, to be found at ++. ++.IP "Lua" 4 ++.IX Item "Lua" ++Brian Maher has written a partial interface to libev for lua (at the ++time of this writing, only \f(CW\*(C`ev_io\*(C'\fR and \f(CW\*(C`ev_timer\*(C'\fR), to be found at ++. ++.IP "Javascript" 4 ++.IX Item "Javascript" ++Node.js () uses libev as the underlying event library. ++.IP "Others" 4 ++.IX Item "Others" ++There are others, and I stopped counting. ++.SH "MACRO MAGIC" ++.IX Header "MACRO MAGIC" ++Libev can be compiled with a variety of options, the most fundamental ++of which is \f(CW\*(C`EV_MULTIPLICITY\*(C'\fR. This option determines whether (most) ++functions and callbacks have an initial \f(CW\*(C`struct ev_loop *\*(C'\fR argument. ++.PP ++To make it easier to write programs that cope with either variant, the ++following macros are defined: ++.ie n .IP """EV_A"", ""EV_A_""" 4 ++.el .IP "\f(CWEV_A\fR, \f(CWEV_A_\fR" 4 ++.IX Item "EV_A, EV_A_" ++This provides the loop \fIargument\fR for functions, if one is required (\*(L"ev ++loop argument\*(R"). The \f(CW\*(C`EV_A\*(C'\fR form is used when this is the sole argument, ++\&\f(CW\*(C`EV_A_\*(C'\fR is used when other arguments are following. Example: ++.Sp ++.Vb 3 ++\& ev_unref (EV_A); ++\& ev_timer_add (EV_A_ watcher); ++\& ev_run (EV_A_ 0); ++.Ve ++.Sp ++It assumes the variable \f(CW\*(C`loop\*(C'\fR of type \f(CW\*(C`struct ev_loop *\*(C'\fR is in scope, ++which is often provided by the following macro. ++.ie n .IP """EV_P"", ""EV_P_""" 4 ++.el .IP "\f(CWEV_P\fR, \f(CWEV_P_\fR" 4 ++.IX Item "EV_P, EV_P_" ++This provides the loop \fIparameter\fR for functions, if one is required (\*(L"ev ++loop parameter\*(R"). The \f(CW\*(C`EV_P\*(C'\fR form is used when this is the sole parameter, ++\&\f(CW\*(C`EV_P_\*(C'\fR is used when other parameters are following. Example: ++.Sp ++.Vb 2 ++\& // this is how ev_unref is being declared ++\& static void ev_unref (EV_P); ++\& ++\& // this is how you can declare your typical callback ++\& static void cb (EV_P_ ev_timer *w, int revents) ++.Ve ++.Sp ++It declares a parameter \f(CW\*(C`loop\*(C'\fR of type \f(CW\*(C`struct ev_loop *\*(C'\fR, quite ++suitable for use with \f(CW\*(C`EV_A\*(C'\fR. ++.ie n .IP """EV_DEFAULT"", ""EV_DEFAULT_""" 4 ++.el .IP "\f(CWEV_DEFAULT\fR, \f(CWEV_DEFAULT_\fR" 4 ++.IX Item "EV_DEFAULT, EV_DEFAULT_" ++Similar to the other two macros, this gives you the value of the default ++loop, if multiple loops are supported (\*(L"ev loop default\*(R"). The default loop ++will be initialised if it isn't already initialised. ++.Sp ++For non-multiplicity builds, these macros do nothing, so you always have ++to initialise the loop somewhere. ++.ie n .IP """EV_DEFAULT_UC"", ""EV_DEFAULT_UC_""" 4 ++.el .IP "\f(CWEV_DEFAULT_UC\fR, \f(CWEV_DEFAULT_UC_\fR" 4 ++.IX Item "EV_DEFAULT_UC, EV_DEFAULT_UC_" ++Usage identical to \f(CW\*(C`EV_DEFAULT\*(C'\fR and \f(CW\*(C`EV_DEFAULT_\*(C'\fR, but requires that the ++default loop has been initialised (\f(CW\*(C`UC\*(C'\fR == unchecked). Their behaviour ++is undefined when the default loop has not been initialised by a previous ++execution of \f(CW\*(C`EV_DEFAULT\*(C'\fR, \f(CW\*(C`EV_DEFAULT_\*(C'\fR or \f(CW\*(C`ev_default_init (...)\*(C'\fR. ++.Sp ++It is often prudent to use \f(CW\*(C`EV_DEFAULT\*(C'\fR when initialising the first ++watcher in a function but use \f(CW\*(C`EV_DEFAULT_UC\*(C'\fR afterwards. ++.PP ++Example: Declare and initialise a check watcher, utilising the above ++macros so it will work regardless of whether multiple loops are supported ++or not. ++.PP ++.Vb 5 ++\& static void ++\& check_cb (EV_P_ ev_timer *w, int revents) ++\& { ++\& ev_check_stop (EV_A_ w); ++\& } ++\& ++\& ev_check check; ++\& ev_check_init (&check, check_cb); ++\& ev_check_start (EV_DEFAULT_ &check); ++\& ev_run (EV_DEFAULT_ 0); ++.Ve ++.SH "EMBEDDING" ++.IX Header "EMBEDDING" ++Libev can (and often is) directly embedded into host ++applications. Examples of applications that embed it include the Deliantra ++Game Server, the \s-1EV\s0 perl module, the \s-1GNU\s0 Virtual Private Ethernet (gvpe) ++and rxvt-unicode. ++.PP ++The goal is to enable you to just copy the necessary files into your ++source directory without having to change even a single line in them, so ++you can easily upgrade by simply copying (or having a checked-out copy of ++libev somewhere in your source tree). ++.SS "\s-1FILESETS\s0" ++.IX Subsection "FILESETS" ++Depending on what features you need you need to include one or more sets of files ++in your application. ++.PP ++\fI\s-1CORE\s0 \s-1EVENT\s0 \s-1LOOP\s0\fR ++.IX Subsection "CORE EVENT LOOP" ++.PP ++To include only the libev core (all the \f(CW\*(C`ev_*\*(C'\fR functions), with manual ++configuration (no autoconf): ++.PP ++.Vb 2 ++\& #define EV_STANDALONE 1 ++\& #include "ev.c" ++.Ve ++.PP ++This will automatically include \fIev.h\fR, too, and should be done in a ++single C source file only to provide the function implementations. To use ++it, do the same for \fIev.h\fR in all files wishing to use this \s-1API\s0 (best ++done by writing a wrapper around \fIev.h\fR that you can include instead and ++where you can put other configuration options): ++.PP ++.Vb 2 ++\& #define EV_STANDALONE 1 ++\& #include "ev.h" ++.Ve ++.PP ++Both header files and implementation files can be compiled with a \*(C+ ++compiler (at least, that's a stated goal, and breakage will be treated ++as a bug). ++.PP ++You need the following files in your source tree, or in a directory ++in your include path (e.g. in libev/ when using \-Ilibev): ++.PP ++.Vb 4 ++\& ev.h ++\& ev.c ++\& ev_vars.h ++\& ev_wrap.h ++\& ++\& ev_win32.c required on win32 platforms only ++\& ++\& ev_select.c only when select backend is enabled (which is enabled by default) ++\& ev_poll.c only when poll backend is enabled (disabled by default) ++\& ev_epoll.c only when the epoll backend is enabled (disabled by default) ++\& ev_kqueue.c only when the kqueue backend is enabled (disabled by default) ++\& ev_port.c only when the solaris port backend is enabled (disabled by default) ++.Ve ++.PP ++\&\fIev.c\fR includes the backend files directly when enabled, so you only need ++to compile this single file. ++.PP ++\fI\s-1LIBEVENT\s0 \s-1COMPATIBILITY\s0 \s-1API\s0\fR ++.IX Subsection "LIBEVENT COMPATIBILITY API" ++.PP ++To include the libevent compatibility \s-1API\s0, also include: ++.PP ++.Vb 1 ++\& #include "event.c" ++.Ve ++.PP ++in the file including \fIev.c\fR, and: ++.PP ++.Vb 1 ++\& #include "event.h" ++.Ve ++.PP ++in the files that want to use the libevent \s-1API\s0. This also includes \fIev.h\fR. ++.PP ++You need the following additional files for this: ++.PP ++.Vb 2 ++\& event.h ++\& event.c ++.Ve ++.PP ++\fI\s-1AUTOCONF\s0 \s-1SUPPORT\s0\fR ++.IX Subsection "AUTOCONF SUPPORT" ++.PP ++Instead of using \f(CW\*(C`EV_STANDALONE=1\*(C'\fR and providing your configuration in ++whatever way you want, you can also \f(CW\*(C`m4_include([libev.m4])\*(C'\fR in your ++\&\fIconfigure.ac\fR and leave \f(CW\*(C`EV_STANDALONE\*(C'\fR undefined. \fIev.c\fR will then ++include \fIconfig.h\fR and configure itself accordingly. ++.PP ++For this of course you need the m4 file: ++.PP ++.Vb 1 ++\& libev.m4 ++.Ve ++.SS "\s-1PREPROCESSOR\s0 \s-1SYMBOLS/MACROS\s0" ++.IX Subsection "PREPROCESSOR SYMBOLS/MACROS" ++Libev can be configured via a variety of preprocessor symbols you have to ++define before including (or compiling) any of its files. The default in ++the absence of autoconf is documented for every option. ++.PP ++Symbols marked with \*(L"(h)\*(R" do not change the \s-1ABI\s0, and can have different ++values when compiling libev vs. including \fIev.h\fR, so it is permissible ++to redefine them before including \fIev.h\fR without breaking compatibility ++to a compiled library. All other symbols change the \s-1ABI\s0, which means all ++users of libev and the libev code itself must be compiled with compatible ++settings. ++.IP "\s-1EV_COMPAT3\s0 (h)" 4 ++.IX Item "EV_COMPAT3 (h)" ++Backwards compatibility is a major concern for libev. This is why this ++release of libev comes with wrappers for the functions and symbols that ++have been renamed between libev version 3 and 4. ++.Sp ++You can disable these wrappers (to test compatibility with future ++versions) by defining \f(CW\*(C`EV_COMPAT3\*(C'\fR to \f(CW0\fR when compiling your ++sources. This has the additional advantage that you can drop the \f(CW\*(C`struct\*(C'\fR ++from \f(CW\*(C`struct ev_loop\*(C'\fR declarations, as libev will provide an \f(CW\*(C`ev_loop\*(C'\fR ++typedef in that case. ++.Sp ++In some future version, the default for \f(CW\*(C`EV_COMPAT3\*(C'\fR will become \f(CW0\fR, ++and in some even more future version the compatibility code will be ++removed completely. ++.IP "\s-1EV_STANDALONE\s0 (h)" 4 ++.IX Item "EV_STANDALONE (h)" ++Must always be \f(CW1\fR if you do not use autoconf configuration, which ++keeps libev from including \fIconfig.h\fR, and it also defines dummy ++implementations for some libevent functions (such as logging, which is not ++supported). It will also not define any of the structs usually found in ++\&\fIevent.h\fR that are not directly supported by the libev core alone. ++.Sp ++In standalone mode, libev will still try to automatically deduce the ++configuration, but has to be more conservative. ++.IP "\s-1EV_USE_FLOOR\s0" 4 ++.IX Item "EV_USE_FLOOR" ++If defined to be \f(CW1\fR, libev will use the \f(CW\*(C`floor ()\*(C'\fR function for its ++periodic reschedule calculations, otherwise libev will fall back on a ++portable (slower) implementation. If you enable this, you usually have to ++link against libm or something equivalent. Enabling this when the \f(CW\*(C`floor\*(C'\fR ++function is not available will fail, so the safe default is to not enable ++this. ++.IP "\s-1EV_USE_MONOTONIC\s0" 4 ++.IX Item "EV_USE_MONOTONIC" ++If defined to be \f(CW1\fR, libev will try to detect the availability of the ++monotonic clock option at both compile time and runtime. Otherwise no ++use of the monotonic clock option will be attempted. If you enable this, ++you usually have to link against librt or something similar. Enabling it ++when the functionality isn't available is safe, though, although you have ++to make sure you link against any libraries where the \f(CW\*(C`clock_gettime\*(C'\fR ++function is hiding in (often \fI\-lrt\fR). See also \f(CW\*(C`EV_USE_CLOCK_SYSCALL\*(C'\fR. ++.IP "\s-1EV_USE_REALTIME\s0" 4 ++.IX Item "EV_USE_REALTIME" ++If defined to be \f(CW1\fR, libev will try to detect the availability of the ++real-time clock option at compile time (and assume its availability ++at runtime if successful). Otherwise no use of the real-time clock ++option will be attempted. This effectively replaces \f(CW\*(C`gettimeofday\*(C'\fR ++by \f(CW\*(C`clock_get (CLOCK_REALTIME, ...)\*(C'\fR and will not normally affect ++correctness. See the note about libraries in the description of ++\&\f(CW\*(C`EV_USE_MONOTONIC\*(C'\fR, though. Defaults to the opposite value of ++\&\f(CW\*(C`EV_USE_CLOCK_SYSCALL\*(C'\fR. ++.IP "\s-1EV_USE_CLOCK_SYSCALL\s0" 4 ++.IX Item "EV_USE_CLOCK_SYSCALL" ++If defined to be \f(CW1\fR, libev will try to use a direct syscall instead ++of calling the system-provided \f(CW\*(C`clock_gettime\*(C'\fR function. This option ++exists because on GNU/Linux, \f(CW\*(C`clock_gettime\*(C'\fR is in \f(CW\*(C`librt\*(C'\fR, but \f(CW\*(C`librt\*(C'\fR ++unconditionally pulls in \f(CW\*(C`libpthread\*(C'\fR, slowing down single-threaded ++programs needlessly. Using a direct syscall is slightly slower (in ++theory), because no optimised vdso implementation can be used, but avoids ++the pthread dependency. Defaults to \f(CW1\fR on GNU/Linux with glibc 2.x or ++higher, as it simplifies linking (no need for \f(CW\*(C`\-lrt\*(C'\fR). ++.IP "\s-1EV_USE_NANOSLEEP\s0" 4 ++.IX Item "EV_USE_NANOSLEEP" ++If defined to be \f(CW1\fR, libev will assume that \f(CW\*(C`nanosleep ()\*(C'\fR is available ++and will use it for delays. Otherwise it will use \f(CW\*(C`select ()\*(C'\fR. ++.IP "\s-1EV_USE_EVENTFD\s0" 4 ++.IX Item "EV_USE_EVENTFD" ++If defined to be \f(CW1\fR, then libev will assume that \f(CW\*(C`eventfd ()\*(C'\fR is ++available and will probe for kernel support at runtime. This will improve ++\&\f(CW\*(C`ev_signal\*(C'\fR and \f(CW\*(C`ev_async\*(C'\fR performance and reduce resource consumption. ++If undefined, it will be enabled if the headers indicate GNU/Linux + Glibc ++2.7 or newer, otherwise disabled. ++.IP "\s-1EV_USE_SELECT\s0" 4 ++.IX Item "EV_USE_SELECT" ++If undefined or defined to be \f(CW1\fR, libev will compile in support for the ++\&\f(CW\*(C`select\*(C'\fR(2) backend. No attempt at auto-detection will be done: if no ++other method takes over, select will be it. Otherwise the select backend ++will not be compiled in. ++.IP "\s-1EV_SELECT_USE_FD_SET\s0" 4 ++.IX Item "EV_SELECT_USE_FD_SET" ++If defined to \f(CW1\fR, then the select backend will use the system \f(CW\*(C`fd_set\*(C'\fR ++structure. This is useful if libev doesn't compile due to a missing ++\&\f(CW\*(C`NFDBITS\*(C'\fR or \f(CW\*(C`fd_mask\*(C'\fR definition or it mis-guesses the bitset layout ++on exotic systems. This usually limits the range of file descriptors to ++some low limit such as 1024 or might have other limitations (winsocket ++only allows 64 sockets). The \f(CW\*(C`FD_SETSIZE\*(C'\fR macro, set before compilation, ++configures the maximum size of the \f(CW\*(C`fd_set\*(C'\fR. ++.IP "\s-1EV_SELECT_IS_WINSOCKET\s0" 4 ++.IX Item "EV_SELECT_IS_WINSOCKET" ++When defined to \f(CW1\fR, the select backend will assume that ++select/socket/connect etc. don't understand file descriptors but ++wants osf handles on win32 (this is the case when the select to ++be used is the winsock select). This means that it will call ++\&\f(CW\*(C`_get_osfhandle\*(C'\fR on the fd to convert it to an \s-1OS\s0 handle. Otherwise, ++it is assumed that all these functions actually work on fds, even ++on win32. Should not be defined on non\-win32 platforms. ++.IP "\s-1EV_FD_TO_WIN32_HANDLE\s0(fd)" 4 ++.IX Item "EV_FD_TO_WIN32_HANDLE(fd)" ++If \f(CW\*(C`EV_SELECT_IS_WINSOCKET\*(C'\fR is enabled, then libev needs a way to map ++file descriptors to socket handles. When not defining this symbol (the ++default), then libev will call \f(CW\*(C`_get_osfhandle\*(C'\fR, which is usually ++correct. In some cases, programs use their own file descriptor management, ++in which case they can provide this function to map fds to socket handles. ++.IP "\s-1EV_WIN32_HANDLE_TO_FD\s0(handle)" 4 ++.IX Item "EV_WIN32_HANDLE_TO_FD(handle)" ++If \f(CW\*(C`EV_SELECT_IS_WINSOCKET\*(C'\fR then libev maps handles to file descriptors ++using the standard \f(CW\*(C`_open_osfhandle\*(C'\fR function. For programs implementing ++their own fd to handle mapping, overwriting this function makes it easier ++to do so. This can be done by defining this macro to an appropriate value. ++.IP "\s-1EV_WIN32_CLOSE_FD\s0(fd)" 4 ++.IX Item "EV_WIN32_CLOSE_FD(fd)" ++If programs implement their own fd to handle mapping on win32, then this ++macro can be used to override the \f(CW\*(C`close\*(C'\fR function, useful to unregister ++file descriptors again. Note that the replacement function has to close ++the underlying \s-1OS\s0 handle. ++.IP "\s-1EV_USE_WSASOCKET\s0" 4 ++.IX Item "EV_USE_WSASOCKET" ++If defined to be \f(CW1\fR, libev will use \f(CW\*(C`WSASocket\*(C'\fR to create its internal ++communication socket, which works better in some environments. Otherwise, ++the normal \f(CW\*(C`socket\*(C'\fR function will be used, which works better in other ++environments. ++.IP "\s-1EV_USE_POLL\s0" 4 ++.IX Item "EV_USE_POLL" ++If defined to be \f(CW1\fR, libev will compile in support for the \f(CW\*(C`poll\*(C'\fR(2) ++backend. Otherwise it will be enabled on non\-win32 platforms. It ++takes precedence over select. ++.IP "\s-1EV_USE_EPOLL\s0" 4 ++.IX Item "EV_USE_EPOLL" ++If defined to be \f(CW1\fR, libev will compile in support for the Linux ++\&\f(CW\*(C`epoll\*(C'\fR(7) backend. Its availability will be detected at runtime, ++otherwise another method will be used as fallback. This is the preferred ++backend for GNU/Linux systems. If undefined, it will be enabled if the ++headers indicate GNU/Linux + Glibc 2.4 or newer, otherwise disabled. ++.IP "\s-1EV_USE_KQUEUE\s0" 4 ++.IX Item "EV_USE_KQUEUE" ++If defined to be \f(CW1\fR, libev will compile in support for the \s-1BSD\s0 style ++\&\f(CW\*(C`kqueue\*(C'\fR(2) backend. Its actual availability will be detected at runtime, ++otherwise another method will be used as fallback. This is the preferred ++backend for \s-1BSD\s0 and BSD-like systems, although on most BSDs kqueue only ++supports some types of fds correctly (the only platform we found that ++supports ptys for example was NetBSD), so kqueue might be compiled in, but ++not be used unless explicitly requested. The best way to use it is to find ++out whether kqueue supports your type of fd properly and use an embedded ++kqueue loop. ++.IP "\s-1EV_USE_PORT\s0" 4 ++.IX Item "EV_USE_PORT" ++If defined to be \f(CW1\fR, libev will compile in support for the Solaris ++10 port style backend. Its availability will be detected at runtime, ++otherwise another method will be used as fallback. This is the preferred ++backend for Solaris 10 systems. ++.IP "\s-1EV_USE_DEVPOLL\s0" 4 ++.IX Item "EV_USE_DEVPOLL" ++Reserved for future expansion, works like the \s-1USE\s0 symbols above. ++.IP "\s-1EV_USE_INOTIFY\s0" 4 ++.IX Item "EV_USE_INOTIFY" ++If defined to be \f(CW1\fR, libev will compile in support for the Linux inotify ++interface to speed up \f(CW\*(C`ev_stat\*(C'\fR watchers. Its actual availability will ++be detected at runtime. If undefined, it will be enabled if the headers ++indicate GNU/Linux + Glibc 2.4 or newer, otherwise disabled. ++.IP "\s-1EV_NO_SMP\s0" 4 ++.IX Item "EV_NO_SMP" ++If defined to be \f(CW1\fR, libev will assume that memory is always coherent ++between threads, that is, threads can be used, but threads never run on ++different cpus (or different cpu cores). This reduces dependencies ++and makes libev faster. ++.IP "\s-1EV_NO_THREADS\s0" 4 ++.IX Item "EV_NO_THREADS" ++If defined to be \f(CW1\fR, libev will assume that it will never be called from ++different threads (that includes signal handlers), which is a stronger ++assumption than \f(CW\*(C`EV_NO_SMP\*(C'\fR, above. This reduces dependencies and makes ++libev faster. ++.IP "\s-1EV_ATOMIC_T\s0" 4 ++.IX Item "EV_ATOMIC_T" ++Libev requires an integer type (suitable for storing \f(CW0\fR or \f(CW1\fR) whose ++access is atomic with respect to other threads or signal contexts. No ++such type is easily found in the C language, so you can provide your own ++type that you know is safe for your purposes. It is used both for signal ++handler \*(L"locking\*(R" as well as for signal and thread safety in \f(CW\*(C`ev_async\*(C'\fR ++watchers. ++.Sp ++In the absence of this define, libev will use \f(CW\*(C`sig_atomic_t volatile\*(C'\fR ++(from \fIsignal.h\fR), which is usually good enough on most platforms. ++.IP "\s-1EV_H\s0 (h)" 4 ++.IX Item "EV_H (h)" ++The name of the \fIev.h\fR header file used to include it. The default if ++undefined is \f(CW"ev.h"\fR in \fIevent.h\fR, \fIev.c\fR and \fIev++.h\fR. This can be ++used to virtually rename the \fIev.h\fR header file in case of conflicts. ++.IP "\s-1EV_CONFIG_H\s0 (h)" 4 ++.IX Item "EV_CONFIG_H (h)" ++If \f(CW\*(C`EV_STANDALONE\*(C'\fR isn't \f(CW1\fR, this variable can be used to override ++\&\fIev.c\fR's idea of where to find the \fIconfig.h\fR file, similarly to ++\&\f(CW\*(C`EV_H\*(C'\fR, above. ++.IP "\s-1EV_EVENT_H\s0 (h)" 4 ++.IX Item "EV_EVENT_H (h)" ++Similarly to \f(CW\*(C`EV_H\*(C'\fR, this macro can be used to override \fIevent.c\fR's idea ++of how the \fIevent.h\fR header can be found, the default is \f(CW"event.h"\fR. ++.IP "\s-1EV_PROTOTYPES\s0 (h)" 4 ++.IX Item "EV_PROTOTYPES (h)" ++If defined to be \f(CW0\fR, then \fIev.h\fR will not define any function ++prototypes, but still define all the structs and other symbols. This is ++occasionally useful if you want to provide your own wrapper functions ++around libev functions. ++.IP "\s-1EV_MULTIPLICITY\s0" 4 ++.IX Item "EV_MULTIPLICITY" ++If undefined or defined to \f(CW1\fR, then all event-loop-specific functions ++will have the \f(CW\*(C`struct ev_loop *\*(C'\fR as first argument, and you can create ++additional independent event loops. Otherwise there will be no support ++for multiple event loops and there is no first event loop pointer ++argument. Instead, all functions act on the single default loop. ++.Sp ++Note that \f(CW\*(C`EV_DEFAULT\*(C'\fR and \f(CW\*(C`EV_DEFAULT_\*(C'\fR will no longer provide a ++default loop when multiplicity is switched off \- you always have to ++initialise the loop manually in this case. ++.IP "\s-1EV_MINPRI\s0" 4 ++.IX Item "EV_MINPRI" ++.PD 0 ++.IP "\s-1EV_MAXPRI\s0" 4 ++.IX Item "EV_MAXPRI" ++.PD ++The range of allowed priorities. \f(CW\*(C`EV_MINPRI\*(C'\fR must be smaller or equal to ++\&\f(CW\*(C`EV_MAXPRI\*(C'\fR, but otherwise there are no non-obvious limitations. You can ++provide for more priorities by overriding those symbols (usually defined ++to be \f(CW\*(C`\-2\*(C'\fR and \f(CW2\fR, respectively). ++.Sp ++When doing priority-based operations, libev usually has to linearly search ++all the priorities, so having many of them (hundreds) uses a lot of space ++and time, so using the defaults of five priorities (\-2 .. +2) is usually ++fine. ++.Sp ++If your embedding application does not need any priorities, defining these ++both to \f(CW0\fR will save some memory and \s-1CPU\s0. ++.IP "\s-1EV_PERIODIC_ENABLE\s0, \s-1EV_IDLE_ENABLE\s0, \s-1EV_EMBED_ENABLE\s0, \s-1EV_STAT_ENABLE\s0, \s-1EV_PREPARE_ENABLE\s0, \s-1EV_CHECK_ENABLE\s0, \s-1EV_FORK_ENABLE\s0, \s-1EV_SIGNAL_ENABLE\s0, \s-1EV_ASYNC_ENABLE\s0, \s-1EV_CHILD_ENABLE\s0." 4 ++.IX Item "EV_PERIODIC_ENABLE, EV_IDLE_ENABLE, EV_EMBED_ENABLE, EV_STAT_ENABLE, EV_PREPARE_ENABLE, EV_CHECK_ENABLE, EV_FORK_ENABLE, EV_SIGNAL_ENABLE, EV_ASYNC_ENABLE, EV_CHILD_ENABLE." ++If undefined or defined to be \f(CW1\fR (and the platform supports it), then ++the respective watcher type is supported. If defined to be \f(CW0\fR, then it ++is not. Disabling watcher types mainly saves code size. ++.IP "\s-1EV_FEATURES\s0" 4 ++.IX Item "EV_FEATURES" ++If you need to shave off some kilobytes of code at the expense of some ++speed (but with the full \s-1API\s0), you can define this symbol to request ++certain subsets of functionality. The default is to enable all features ++that can be enabled on the platform. ++.Sp ++A typical way to use this symbol is to define it to \f(CW0\fR (or to a bitset ++with some broad features you want) and then selectively re-enable ++additional parts you want, for example if you want everything minimal, ++but multiple event loop support, async and child watchers and the poll ++backend, use this: ++.Sp ++.Vb 5 ++\& #define EV_FEATURES 0 ++\& #define EV_MULTIPLICITY 1 ++\& #define EV_USE_POLL 1 ++\& #define EV_CHILD_ENABLE 1 ++\& #define EV_ASYNC_ENABLE 1 ++.Ve ++.Sp ++The actual value is a bitset, it can be a combination of the following ++values (by default, all of these are enabled): ++.RS 4 ++.ie n .IP "1 \- faster/larger code" 4 ++.el .IP "\f(CW1\fR \- faster/larger code" 4 ++.IX Item "1 - faster/larger code" ++Use larger code to speed up some operations. ++.Sp ++Currently this is used to override some inlining decisions (enlarging the ++code size by roughly 30% on amd64). ++.Sp ++When optimising for size, use of compiler flags such as \f(CW\*(C`\-Os\*(C'\fR with ++gcc is recommended, as well as \f(CW\*(C`\-DNDEBUG\*(C'\fR, as libev contains a number of ++assertions. ++.Sp ++The default is off when \f(CW\*(C`_\|_OPTIMIZE_SIZE_\|_\*(C'\fR is defined by your compiler ++(e.g. gcc with \f(CW\*(C`\-Os\*(C'\fR). ++.ie n .IP "2 \- faster/larger data structures" 4 ++.el .IP "\f(CW2\fR \- faster/larger data structures" 4 ++.IX Item "2 - faster/larger data structures" ++Replaces the small 2\-heap for timer management by a faster 4\-heap, larger ++hash table sizes and so on. This will usually further increase code size ++and can additionally have an effect on the size of data structures at ++runtime. ++.Sp ++The default is off when \f(CW\*(C`_\|_OPTIMIZE_SIZE_\|_\*(C'\fR is defined by your compiler ++(e.g. gcc with \f(CW\*(C`\-Os\*(C'\fR). ++.ie n .IP "4 \- full \s-1API\s0 configuration" 4 ++.el .IP "\f(CW4\fR \- full \s-1API\s0 configuration" 4 ++.IX Item "4 - full API configuration" ++This enables priorities (sets \f(CW\*(C`EV_MAXPRI\*(C'\fR=2 and \f(CW\*(C`EV_MINPRI\*(C'\fR=\-2), and ++enables multiplicity (\f(CW\*(C`EV_MULTIPLICITY\*(C'\fR=1). ++.ie n .IP "8 \- full \s-1API\s0" 4 ++.el .IP "\f(CW8\fR \- full \s-1API\s0" 4 ++.IX Item "8 - full API" ++This enables a lot of the \*(L"lesser used\*(R" \s-1API\s0 functions. See \f(CW\*(C`ev.h\*(C'\fR for ++details on which parts of the \s-1API\s0 are still available without this ++feature, and do not complain if this subset changes over time. ++.ie n .IP "16 \- enable all optional watcher types" 4 ++.el .IP "\f(CW16\fR \- enable all optional watcher types" 4 ++.IX Item "16 - enable all optional watcher types" ++Enables all optional watcher types. If you want to selectively enable ++only some watcher types other than I/O and timers (e.g. prepare, ++embed, async, child...) you can enable them manually by defining ++\&\f(CW\*(C`EV_watchertype_ENABLE\*(C'\fR to \f(CW1\fR instead. ++.ie n .IP "32 \- enable all backends" 4 ++.el .IP "\f(CW32\fR \- enable all backends" 4 ++.IX Item "32 - enable all backends" ++This enables all backends \- without this feature, you need to enable at ++least one backend manually (\f(CW\*(C`EV_USE_SELECT\*(C'\fR is a good choice). ++.ie n .IP "64 \- enable OS-specific ""helper"" APIs" 4 ++.el .IP "\f(CW64\fR \- enable OS-specific ``helper'' APIs" 4 ++.IX Item "64 - enable OS-specific helper APIs" ++Enable inotify, eventfd, signalfd and similar OS-specific helper APIs by ++default. ++.RE ++.RS 4 ++.Sp ++Compiling with \f(CW\*(C`gcc \-Os \-DEV_STANDALONE \-DEV_USE_EPOLL=1 \-DEV_FEATURES=0\*(C'\fR ++reduces the compiled size of libev from 24.7Kb code/2.8Kb data to 6.5Kb ++code/0.3Kb data on my GNU/Linux amd64 system, while still giving you I/O ++watchers, timers and monotonic clock support. ++.Sp ++With an intelligent-enough linker (gcc+binutils are intelligent enough ++when you use \f(CW\*(C`\-Wl,\-\-gc\-sections \-ffunction\-sections\*(C'\fR) functions unused by ++your program might be left out as well \- a binary starting a timer and an ++I/O watcher then might come out at only 5Kb. ++.RE ++.IP "\s-1EV_API_STATIC\s0" 4 ++.IX Item "EV_API_STATIC" ++If this symbol is defined (by default it is not), then all identifiers ++will have static linkage. This means that libev will not export any ++identifiers, and you cannot link against libev anymore. This can be useful ++when you embed libev, only want to use libev functions in a single file, ++and do not want its identifiers to be visible. ++.Sp ++To use this, define \f(CW\*(C`EV_API_STATIC\*(C'\fR and include \fIev.c\fR in the file that ++wants to use libev. ++.Sp ++This option only works when libev is compiled with a C compiler, as \*(C+ ++doesn't support the required declaration syntax. ++.IP "\s-1EV_AVOID_STDIO\s0" 4 ++.IX Item "EV_AVOID_STDIO" ++If this is set to \f(CW1\fR at compiletime, then libev will avoid using stdio ++functions (printf, scanf, perror etc.). This will increase the code size ++somewhat, but if your program doesn't otherwise depend on stdio and your ++libc allows it, this avoids linking in the stdio library which is quite ++big. ++.Sp ++Note that error messages might become less precise when this option is ++enabled. ++.IP "\s-1EV_NSIG\s0" 4 ++.IX Item "EV_NSIG" ++The highest supported signal number, +1 (or, the number of ++signals): Normally, libev tries to deduce the maximum number of signals ++automatically, but sometimes this fails, in which case it can be ++specified. Also, using a lower number than detected (\f(CW32\fR should be ++good for about any system in existence) can save some memory, as libev ++statically allocates some 12\-24 bytes per signal number. ++.IP "\s-1EV_PID_HASHSIZE\s0" 4 ++.IX Item "EV_PID_HASHSIZE" ++\&\f(CW\*(C`ev_child\*(C'\fR watchers use a small hash table to distribute workload by ++pid. The default size is \f(CW16\fR (or \f(CW1\fR with \f(CW\*(C`EV_FEATURES\*(C'\fR disabled), ++usually more than enough. If you need to manage thousands of children you ++might want to increase this value (\fImust\fR be a power of two). ++.IP "\s-1EV_INOTIFY_HASHSIZE\s0" 4 ++.IX Item "EV_INOTIFY_HASHSIZE" ++\&\f(CW\*(C`ev_stat\*(C'\fR watchers use a small hash table to distribute workload by ++inotify watch id. The default size is \f(CW16\fR (or \f(CW1\fR with \f(CW\*(C`EV_FEATURES\*(C'\fR ++disabled), usually more than enough. If you need to manage thousands of ++\&\f(CW\*(C`ev_stat\*(C'\fR watchers you might want to increase this value (\fImust\fR be a ++power of two). ++.IP "\s-1EV_USE_4HEAP\s0" 4 ++.IX Item "EV_USE_4HEAP" ++Heaps are not very cache-efficient. To improve the cache-efficiency of the ++timer and periodics heaps, libev uses a 4\-heap when this symbol is defined ++to \f(CW1\fR. The 4\-heap uses more complicated (longer) code but has noticeably ++faster performance with many (thousands) of watchers. ++.Sp ++The default is \f(CW1\fR, unless \f(CW\*(C`EV_FEATURES\*(C'\fR overrides it, in which case it ++will be \f(CW0\fR. ++.IP "\s-1EV_HEAP_CACHE_AT\s0" 4 ++.IX Item "EV_HEAP_CACHE_AT" ++Heaps are not very cache-efficient. To improve the cache-efficiency of the ++timer and periodics heaps, libev can cache the timestamp (\fIat\fR) within ++the heap structure (selected by defining \f(CW\*(C`EV_HEAP_CACHE_AT\*(C'\fR to \f(CW1\fR), ++which uses 8\-12 bytes more per watcher and a few hundred bytes more code, ++but avoids random read accesses on heap changes. This improves performance ++noticeably with many (hundreds) of watchers. ++.Sp ++The default is \f(CW1\fR, unless \f(CW\*(C`EV_FEATURES\*(C'\fR overrides it, in which case it ++will be \f(CW0\fR. ++.IP "\s-1EV_VERIFY\s0" 4 ++.IX Item "EV_VERIFY" ++Controls how much internal verification (see \f(CW\*(C`ev_verify ()\*(C'\fR) will ++be done: If set to \f(CW0\fR, no internal verification code will be compiled ++in. If set to \f(CW1\fR, then verification code will be compiled in, but not ++called. If set to \f(CW2\fR, then the internal verification code will be ++called once per loop, which can slow down libev. If set to \f(CW3\fR, then the ++verification code will be called very frequently, which will slow down ++libev considerably. ++.Sp ++The default is \f(CW1\fR, unless \f(CW\*(C`EV_FEATURES\*(C'\fR overrides it, in which case it ++will be \f(CW0\fR. ++.IP "\s-1EV_COMMON\s0" 4 ++.IX Item "EV_COMMON" ++By default, all watchers have a \f(CW\*(C`void *data\*(C'\fR member. By redefining ++this macro to something else you can include more and other types of ++members. You have to define it each time you include one of the files, ++though, and it must be identical each time. ++.Sp ++For example, the perl \s-1EV\s0 module uses something like this: ++.Sp ++.Vb 3 ++\& #define EV_COMMON \e ++\& SV *self; /* contains this struct */ \e ++\& SV *cb_sv, *fh /* note no trailing ";" */ ++.Ve ++.IP "\s-1EV_CB_DECLARE\s0 (type)" 4 ++.IX Item "EV_CB_DECLARE (type)" ++.PD 0 ++.IP "\s-1EV_CB_INVOKE\s0 (watcher, revents)" 4 ++.IX Item "EV_CB_INVOKE (watcher, revents)" ++.IP "ev_set_cb (ev, cb)" 4 ++.IX Item "ev_set_cb (ev, cb)" ++.PD ++Can be used to change the callback member declaration in each watcher, ++and the way callbacks are invoked and set. Must expand to a struct member ++definition and a statement, respectively. See the \fIev.h\fR header file for ++their default definitions. One possible use for overriding these is to ++avoid the \f(CW\*(C`struct ev_loop *\*(C'\fR as first argument in all cases, or to use ++method calls instead of plain function calls in \*(C+. ++.SS "\s-1EXPORTED\s0 \s-1API\s0 \s-1SYMBOLS\s0" ++.IX Subsection "EXPORTED API SYMBOLS" ++If you need to re-export the \s-1API\s0 (e.g. via a \s-1DLL\s0) and you need a list of ++exported symbols, you can use the provided \fISymbol.*\fR files which list ++all public symbols, one per line: ++.PP ++.Vb 2 ++\& Symbols.ev for libev proper ++\& Symbols.event for the libevent emulation ++.Ve ++.PP ++This can also be used to rename all public symbols to avoid clashes with ++multiple versions of libev linked together (which is obviously bad in ++itself, but sometimes it is inconvenient to avoid this). ++.PP ++A sed command like this will create wrapper \f(CW\*(C`#define\*(C'\fR's that you need to ++include before including \fIev.h\fR: ++.PP ++.Vb 1 ++\& wrap.h ++.Ve ++.PP ++This would create a file \fIwrap.h\fR which essentially looks like this: ++.PP ++.Vb 4 ++\& #define ev_backend myprefix_ev_backend ++\& #define ev_check_start myprefix_ev_check_start ++\& #define ev_check_stop myprefix_ev_check_stop ++\& ... ++.Ve ++.SS "\s-1EXAMPLES\s0" ++.IX Subsection "EXAMPLES" ++For a real-world example of a program the includes libev ++verbatim, you can have a look at the \s-1EV\s0 perl module ++(). It has the libev files in ++the \fIlibev/\fR subdirectory and includes them in the \fI\s-1EV/EVAPI\s0.h\fR (public ++interface) and \fI\s-1EV\s0.xs\fR (implementation) files. Only the \fI\s-1EV\s0.xs\fR file ++will be compiled. It is pretty complex because it provides its own header ++file. ++.PP ++The usage in rxvt-unicode is simpler. It has a \fIev_cpp.h\fR header file ++that everybody includes and which overrides some configure choices: ++.PP ++.Vb 8 ++\& #define EV_FEATURES 8 ++\& #define EV_USE_SELECT 1 ++\& #define EV_PREPARE_ENABLE 1 ++\& #define EV_IDLE_ENABLE 1 ++\& #define EV_SIGNAL_ENABLE 1 ++\& #define EV_CHILD_ENABLE 1 ++\& #define EV_USE_STDEXCEPT 0 ++\& #define EV_CONFIG_H ++\& ++\& #include "ev++.h" ++.Ve ++.PP ++And a \fIev_cpp.C\fR implementation file that contains libev proper and is compiled: ++.PP ++.Vb 2 ++\& #include "ev_cpp.h" ++\& #include "ev.c" ++.Ve ++.SH "INTERACTION WITH OTHER PROGRAMS, LIBRARIES OR THE ENVIRONMENT" ++.IX Header "INTERACTION WITH OTHER PROGRAMS, LIBRARIES OR THE ENVIRONMENT" ++.SS "\s-1THREADS\s0 \s-1AND\s0 \s-1COROUTINES\s0" ++.IX Subsection "THREADS AND COROUTINES" ++\fI\s-1THREADS\s0\fR ++.IX Subsection "THREADS" ++.PP ++All libev functions are reentrant and thread-safe unless explicitly ++documented otherwise, but libev implements no locking itself. This means ++that you can use as many loops as you want in parallel, as long as there ++are no concurrent calls into any libev function with the same loop ++parameter (\f(CW\*(C`ev_default_*\*(C'\fR calls have an implicit default loop parameter, ++of course): libev guarantees that different event loops share no data ++structures that need any locking. ++.PP ++Or to put it differently: calls with different loop parameters can be done ++concurrently from multiple threads, calls with the same loop parameter ++must be done serially (but can be done from different threads, as long as ++only one thread ever is inside a call at any point in time, e.g. by using ++a mutex per loop). ++.PP ++Specifically to support threads (and signal handlers), libev implements ++so-called \f(CW\*(C`ev_async\*(C'\fR watchers, which allow some limited form of ++concurrency on the same event loop, namely waking it up \*(L"from the ++outside\*(R". ++.PP ++If you want to know which design (one loop, locking, or multiple loops ++without or something else still) is best for your problem, then I cannot ++help you, but here is some generic advice: ++.IP "\(bu" 4 ++most applications have a main thread: use the default libev loop ++in that thread, or create a separate thread running only the default loop. ++.Sp ++This helps integrating other libraries or software modules that use libev ++themselves and don't care/know about threading. ++.IP "\(bu" 4 ++one loop per thread is usually a good model. ++.Sp ++Doing this is almost never wrong, sometimes a better-performance model ++exists, but it is always a good start. ++.IP "\(bu" 4 ++other models exist, such as the leader/follower pattern, where one ++loop is handed through multiple threads in a kind of round-robin fashion. ++.Sp ++Choosing a model is hard \- look around, learn, know that usually you can do ++better than you currently do :\-) ++.IP "\(bu" 4 ++often you need to talk to some other thread which blocks in the ++event loop. ++.Sp ++\&\f(CW\*(C`ev_async\*(C'\fR watchers can be used to wake them up from other threads safely ++(or from signal contexts...). ++.Sp ++An example use would be to communicate signals or other events that only ++work in the default loop by registering the signal watcher with the ++default loop and triggering an \f(CW\*(C`ev_async\*(C'\fR watcher from the default loop ++watcher callback into the event loop interested in the signal. ++.PP ++See also \*(L"\s-1THREAD\s0 \s-1LOCKING\s0 \s-1EXAMPLE\s0\*(R". ++.PP ++\fI\s-1COROUTINES\s0\fR ++.IX Subsection "COROUTINES" ++.PP ++Libev is very accommodating to coroutines (\*(L"cooperative threads\*(R"): ++libev fully supports nesting calls to its functions from different ++coroutines (e.g. you can call \f(CW\*(C`ev_run\*(C'\fR on the same loop from two ++different coroutines, and switch freely between both coroutines running ++the loop, as long as you don't confuse yourself). The only exception is ++that you must not do this from \f(CW\*(C`ev_periodic\*(C'\fR reschedule callbacks. ++.PP ++Care has been taken to ensure that libev does not keep local state inside ++\&\f(CW\*(C`ev_run\*(C'\fR, and other calls do not usually allow for coroutine switches as ++they do not call any callbacks. ++.SS "\s-1COMPILER\s0 \s-1WARNINGS\s0" ++.IX Subsection "COMPILER WARNINGS" ++Depending on your compiler and compiler settings, you might get no or a ++lot of warnings when compiling libev code. Some people are apparently ++scared by this. ++.PP ++However, these are unavoidable for many reasons. For one, each compiler ++has different warnings, and each user has different tastes regarding ++warning options. \*(L"Warn-free\*(R" code therefore cannot be a goal except when ++targeting a specific compiler and compiler-version. ++.PP ++Another reason is that some compiler warnings require elaborate ++workarounds, or other changes to the code that make it less clear and less ++maintainable. ++.PP ++And of course, some compiler warnings are just plain stupid, or simply ++wrong (because they don't actually warn about the condition their message ++seems to warn about). For example, certain older gcc versions had some ++warnings that resulted in an extreme number of false positives. These have ++been fixed, but some people still insist on making code warn-free with ++such buggy versions. ++.PP ++While libev is written to generate as few warnings as possible, ++\&\*(L"warn-free\*(R" code is not a goal, and it is recommended not to build libev ++with any compiler warnings enabled unless you are prepared to cope with ++them (e.g. by ignoring them). Remember that warnings are just that: ++warnings, not errors, or proof of bugs. ++.SS "\s-1VALGRIND\s0" ++.IX Subsection "VALGRIND" ++Valgrind has a special section here because it is a popular tool that is ++highly useful. Unfortunately, valgrind reports are very hard to interpret. ++.PP ++If you think you found a bug (memory leak, uninitialised data access etc.) ++in libev, then check twice: If valgrind reports something like: ++.PP ++.Vb 3 ++\& ==2274== definitely lost: 0 bytes in 0 blocks. ++\& ==2274== possibly lost: 0 bytes in 0 blocks. ++\& ==2274== still reachable: 256 bytes in 1 blocks. ++.Ve ++.PP ++Then there is no memory leak, just as memory accounted to global variables ++is not a memleak \- the memory is still being referenced, and didn't leak. ++.PP ++Similarly, under some circumstances, valgrind might report kernel bugs ++as if it were a bug in libev (e.g. in realloc or in the poll backend, ++although an acceptable workaround has been found here), or it might be ++confused. ++.PP ++Keep in mind that valgrind is a very good tool, but only a tool. Don't ++make it into some kind of religion. ++.PP ++If you are unsure about something, feel free to contact the mailing list ++with the full valgrind report and an explanation on why you think this ++is a bug in libev (best check the archives, too :). However, don't be ++annoyed when you get a brisk \*(L"this is no bug\*(R" answer and take the chance ++of learning how to interpret valgrind properly. ++.PP ++If you need, for some reason, empty reports from valgrind for your project ++I suggest using suppression lists. ++.SH "PORTABILITY NOTES" ++.IX Header "PORTABILITY NOTES" ++.SS "\s-1GNU/LINUX\s0 32 \s-1BIT\s0 \s-1LIMITATIONS\s0" ++.IX Subsection "GNU/LINUX 32 BIT LIMITATIONS" ++GNU/Linux is the only common platform that supports 64 bit file/large file ++interfaces but \fIdisables\fR them by default. ++.PP ++That means that libev compiled in the default environment doesn't support ++files larger than 2GiB or so, which mainly affects \f(CW\*(C`ev_stat\*(C'\fR watchers. ++.PP ++Unfortunately, many programs try to work around this GNU/Linux issue ++by enabling the large file \s-1API\s0, which makes them incompatible with the ++standard libev compiled for their system. ++.PP ++Likewise, libev cannot enable the large file \s-1API\s0 itself as this would ++suddenly make it incompatible to the default compile time environment, ++i.e. all programs not using special compile switches. ++.SS "\s-1OS/X\s0 \s-1AND\s0 \s-1DARWIN\s0 \s-1BUGS\s0" ++.IX Subsection "OS/X AND DARWIN BUGS" ++The whole thing is a bug if you ask me \- basically any system interface ++you touch is broken, whether it is locales, poll, kqueue or even the ++OpenGL drivers. ++.PP ++\fI\f(CI\*(C`kqueue\*(C'\fI is buggy\fR ++.IX Subsection "kqueue is buggy" ++.PP ++The kqueue syscall is broken in all known versions \- most versions support ++only sockets, many support pipes. ++.PP ++Libev tries to work around this by not using \f(CW\*(C`kqueue\*(C'\fR by default on this ++rotten platform, but of course you can still ask for it when creating a ++loop \- embedding a socket-only kqueue loop into a select-based one is ++probably going to work well. ++.PP ++\fI\f(CI\*(C`poll\*(C'\fI is buggy\fR ++.IX Subsection "poll is buggy" ++.PP ++Instead of fixing \f(CW\*(C`kqueue\*(C'\fR, Apple replaced their (working) \f(CW\*(C`poll\*(C'\fR ++implementation by something calling \f(CW\*(C`kqueue\*(C'\fR internally around the 10.5.6 ++release, so now \f(CW\*(C`kqueue\*(C'\fR \fIand\fR \f(CW\*(C`poll\*(C'\fR are broken. ++.PP ++Libev tries to work around this by not using \f(CW\*(C`poll\*(C'\fR by default on ++this rotten platform, but of course you can still ask for it when creating ++a loop. ++.PP ++\fI\f(CI\*(C`select\*(C'\fI is buggy\fR ++.IX Subsection "select is buggy" ++.PP ++All that's left is \f(CW\*(C`select\*(C'\fR, and of course Apple found a way to fuck this ++one up as well: On \s-1OS/X\s0, \f(CW\*(C`select\*(C'\fR actively limits the number of file ++descriptors you can pass in to 1024 \- your program suddenly crashes when ++you use more. ++.PP ++There is an undocumented \*(L"workaround\*(R" for this \- defining ++\&\f(CW\*(C`_DARWIN_UNLIMITED_SELECT\*(C'\fR, which libev tries to use, so select \fIshould\fR ++work on \s-1OS/X\s0. ++.SS "\s-1SOLARIS\s0 \s-1PROBLEMS\s0 \s-1AND\s0 \s-1WORKAROUNDS\s0" ++.IX Subsection "SOLARIS PROBLEMS AND WORKAROUNDS" ++\fI\f(CI\*(C`errno\*(C'\fI reentrancy\fR ++.IX Subsection "errno reentrancy" ++.PP ++The default compile environment on Solaris is unfortunately so ++thread-unsafe that you can't even use components/libraries compiled ++without \f(CW\*(C`\-D_REENTRANT\*(C'\fR in a threaded program, which, of course, isn't ++defined by default. A valid, if stupid, implementation choice. ++.PP ++If you want to use libev in threaded environments you have to make sure ++it's compiled with \f(CW\*(C`_REENTRANT\*(C'\fR defined. ++.PP ++\fIEvent port backend\fR ++.IX Subsection "Event port backend" ++.PP ++The scalable event interface for Solaris is called \*(L"event ++ports\*(R". Unfortunately, this mechanism is very buggy in all major ++releases. If you run into high \s-1CPU\s0 usage, your program freezes or you get ++a large number of spurious wakeups, make sure you have all the relevant ++and latest kernel patches applied. No, I don't know which ones, but there ++are multiple ones to apply, and afterwards, event ports actually work ++great. ++.PP ++If you can't get it to work, you can try running the program by setting ++the environment variable \f(CW\*(C`LIBEV_FLAGS=3\*(C'\fR to only allow \f(CW\*(C`poll\*(C'\fR and ++\&\f(CW\*(C`select\*(C'\fR backends. ++.SS "\s-1AIX\s0 \s-1POLL\s0 \s-1BUG\s0" ++.IX Subsection "AIX POLL BUG" ++\&\s-1AIX\s0 unfortunately has a broken \f(CW\*(C`poll.h\*(C'\fR header. Libev works around ++this by trying to avoid the poll backend altogether (i.e. it's not even ++compiled in), which normally isn't a big problem as \f(CW\*(C`select\*(C'\fR works fine ++with large bitsets on \s-1AIX\s0, and \s-1AIX\s0 is dead anyway. ++.SS "\s-1WIN32\s0 \s-1PLATFORM\s0 \s-1LIMITATIONS\s0 \s-1AND\s0 \s-1WORKAROUNDS\s0" ++.IX Subsection "WIN32 PLATFORM LIMITATIONS AND WORKAROUNDS" ++\fIGeneral issues\fR ++.IX Subsection "General issues" ++.PP ++Win32 doesn't support any of the standards (e.g. \s-1POSIX\s0) that libev ++requires, and its I/O model is fundamentally incompatible with the \s-1POSIX\s0 ++model. Libev still offers limited functionality on this platform in ++the form of the \f(CW\*(C`EVBACKEND_SELECT\*(C'\fR backend, and only supports socket ++descriptors. This only applies when using Win32 natively, not when using ++e.g. cygwin. Actually, it only applies to the microsofts own compilers, ++as every compiler comes with a slightly differently broken/incompatible ++environment. ++.PP ++Lifting these limitations would basically require the full ++re-implementation of the I/O system. If you are into this kind of thing, ++then note that glib does exactly that for you in a very portable way (note ++also that glib is the slowest event library known to man). ++.PP ++There is no supported compilation method available on windows except ++embedding it into other applications. ++.PP ++Sensible signal handling is officially unsupported by Microsoft \- libev ++tries its best, but under most conditions, signals will simply not work. ++.PP ++Not a libev limitation but worth mentioning: windows apparently doesn't ++accept large writes: instead of resulting in a partial write, windows will ++either accept everything or return \f(CW\*(C`ENOBUFS\*(C'\fR if the buffer is too large, ++so make sure you only write small amounts into your sockets (less than a ++megabyte seems safe, but this apparently depends on the amount of memory ++available). ++.PP ++Due to the many, low, and arbitrary limits on the win32 platform and ++the abysmal performance of winsockets, using a large number of sockets ++is not recommended (and not reasonable). If your program needs to use ++more than a hundred or so sockets, then likely it needs to use a totally ++different implementation for windows, as libev offers the \s-1POSIX\s0 readiness ++notification model, which cannot be implemented efficiently on windows ++(due to Microsoft monopoly games). ++.PP ++A typical way to use libev under windows is to embed it (see the embedding ++section for details) and use the following \fIevwrap.h\fR header file instead ++of \fIev.h\fR: ++.PP ++.Vb 2 ++\& #define EV_STANDALONE /* keeps ev from requiring config.h */ ++\& #define EV_SELECT_IS_WINSOCKET 1 /* configure libev for windows select */ ++\& ++\& #include "ev.h" ++.Ve ++.PP ++And compile the following \fIevwrap.c\fR file into your project (make sure ++you do \fInot\fR compile the \fIev.c\fR or any other embedded source files!): ++.PP ++.Vb 2 ++\& #include "evwrap.h" ++\& #include "ev.c" ++.Ve ++.PP ++\fIThe winsocket \f(CI\*(C`select\*(C'\fI function\fR ++.IX Subsection "The winsocket select function" ++.PP ++The winsocket \f(CW\*(C`select\*(C'\fR function doesn't follow \s-1POSIX\s0 in that it ++requires socket \fIhandles\fR and not socket \fIfile descriptors\fR (it is ++also extremely buggy). This makes select very inefficient, and also ++requires a mapping from file descriptors to socket handles (the Microsoft ++C runtime provides the function \f(CW\*(C`_open_osfhandle\*(C'\fR for this). See the ++discussion of the \f(CW\*(C`EV_SELECT_USE_FD_SET\*(C'\fR, \f(CW\*(C`EV_SELECT_IS_WINSOCKET\*(C'\fR and ++\&\f(CW\*(C`EV_FD_TO_WIN32_HANDLE\*(C'\fR preprocessor symbols for more info. ++.PP ++The configuration for a \*(L"naked\*(R" win32 using the Microsoft runtime ++libraries and raw winsocket select is: ++.PP ++.Vb 2 ++\& #define EV_USE_SELECT 1 ++\& #define EV_SELECT_IS_WINSOCKET 1 /* forces EV_SELECT_USE_FD_SET, too */ ++.Ve ++.PP ++Note that winsockets handling of fd sets is O(n), so you can easily get a ++complexity in the O(nA\*^X) range when using win32. ++.PP ++\fILimited number of file descriptors\fR ++.IX Subsection "Limited number of file descriptors" ++.PP ++Windows has numerous arbitrary (and low) limits on things. ++.PP ++Early versions of winsocket's select only supported waiting for a maximum ++of \f(CW64\fR handles (probably owning to the fact that all windows kernels ++can only wait for \f(CW64\fR things at the same time internally; Microsoft ++recommends spawning a chain of threads and wait for 63 handles and the ++previous thread in each. Sounds great!). ++.PP ++Newer versions support more handles, but you need to define \f(CW\*(C`FD_SETSIZE\*(C'\fR ++to some high number (e.g. \f(CW2048\fR) before compiling the winsocket select ++call (which might be in libev or elsewhere, for example, perl and many ++other interpreters do their own select emulation on windows). ++.PP ++Another limit is the number of file descriptors in the Microsoft runtime ++libraries, which by default is \f(CW64\fR (there must be a hidden \fI64\fR ++fetish or something like this inside Microsoft). You can increase this ++by calling \f(CW\*(C`_setmaxstdio\*(C'\fR, which can increase this limit to \f(CW2048\fR ++(another arbitrary limit), but is broken in many versions of the Microsoft ++runtime libraries. This might get you to about \f(CW512\fR or \f(CW2048\fR sockets ++(depending on windows version and/or the phase of the moon). To get more, ++you need to wrap all I/O functions and provide your own fd management, but ++the cost of calling select (O(nA\*^X)) will likely make this unworkable. ++.SS "\s-1PORTABILITY\s0 \s-1REQUIREMENTS\s0" ++.IX Subsection "PORTABILITY REQUIREMENTS" ++In addition to a working ISO-C implementation and of course the ++backend-specific APIs, libev relies on a few additional extensions: ++.ie n .IP """void (*)(ev_watcher_type *, int revents)"" must have compatible calling conventions regardless of ""ev_watcher_type *""." 4 ++.el .IP "\f(CWvoid (*)(ev_watcher_type *, int revents)\fR must have compatible calling conventions regardless of \f(CWev_watcher_type *\fR." 4 ++.IX Item "void (*)(ev_watcher_type *, int revents) must have compatible calling conventions regardless of ev_watcher_type *." ++Libev assumes not only that all watcher pointers have the same internal ++structure (guaranteed by \s-1POSIX\s0 but not by \s-1ISO\s0 C for example), but it also ++assumes that the same (machine) code can be used to call any watcher ++callback: The watcher callbacks have different type signatures, but libev ++calls them using an \f(CW\*(C`ev_watcher *\*(C'\fR internally. ++.IP "pointer accesses must be thread-atomic" 4 ++.IX Item "pointer accesses must be thread-atomic" ++Accessing a pointer value must be atomic, it must both be readable and ++writable in one piece \- this is the case on all current architectures. ++.ie n .IP """sig_atomic_t volatile"" must be thread-atomic as well" 4 ++.el .IP "\f(CWsig_atomic_t volatile\fR must be thread-atomic as well" 4 ++.IX Item "sig_atomic_t volatile must be thread-atomic as well" ++The type \f(CW\*(C`sig_atomic_t volatile\*(C'\fR (or whatever is defined as ++\&\f(CW\*(C`EV_ATOMIC_T\*(C'\fR) must be atomic with respect to accesses from different ++threads. This is not part of the specification for \f(CW\*(C`sig_atomic_t\*(C'\fR, but is ++believed to be sufficiently portable. ++.ie n .IP """sigprocmask"" must work in a threaded environment" 4 ++.el .IP "\f(CWsigprocmask\fR must work in a threaded environment" 4 ++.IX Item "sigprocmask must work in a threaded environment" ++Libev uses \f(CW\*(C`sigprocmask\*(C'\fR to temporarily block signals. This is not ++allowed in a threaded program (\f(CW\*(C`pthread_sigmask\*(C'\fR has to be used). Typical ++pthread implementations will either allow \f(CW\*(C`sigprocmask\*(C'\fR in the \*(L"main ++thread\*(R" or will block signals process-wide, both behaviours would ++be compatible with libev. Interaction between \f(CW\*(C`sigprocmask\*(C'\fR and ++\&\f(CW\*(C`pthread_sigmask\*(C'\fR could complicate things, however. ++.Sp ++The most portable way to handle signals is to block signals in all threads ++except the initial one, and run the signal handling loop in the initial ++thread as well. ++.ie n .IP """long"" must be large enough for common memory allocation sizes" 4 ++.el .IP "\f(CWlong\fR must be large enough for common memory allocation sizes" 4 ++.IX Item "long must be large enough for common memory allocation sizes" ++To improve portability and simplify its \s-1API\s0, libev uses \f(CW\*(C`long\*(C'\fR internally ++instead of \f(CW\*(C`size_t\*(C'\fR when allocating its data structures. On non-POSIX ++systems (Microsoft...) this might be unexpectedly low, but is still at ++least 31 bits everywhere, which is enough for hundreds of millions of ++watchers. ++.ie n .IP """double"" must hold a time value in seconds with enough accuracy" 4 ++.el .IP "\f(CWdouble\fR must hold a time value in seconds with enough accuracy" 4 ++.IX Item "double must hold a time value in seconds with enough accuracy" ++The type \f(CW\*(C`double\*(C'\fR is used to represent timestamps. It is required to ++have at least 51 bits of mantissa (and 9 bits of exponent), which is ++good enough for at least into the year 4000 with millisecond accuracy ++(the design goal for libev). This requirement is overfulfilled by ++implementations using \s-1IEEE\s0 754, which is basically all existing ones. ++.Sp ++With \s-1IEEE\s0 754 doubles, you get microsecond accuracy until at least the ++year 2255 (and millisecond accuracy till the year 287396 \- by then, libev ++is either obsolete or somebody patched it to use \f(CW\*(C`long double\*(C'\fR or ++something like that, just kidding). ++.PP ++If you know of other additional requirements drop me a note. ++.SH "ALGORITHMIC COMPLEXITIES" ++.IX Header "ALGORITHMIC COMPLEXITIES" ++In this section the complexities of (many of) the algorithms used inside ++libev will be documented. For complexity discussions about backends see ++the documentation for \f(CW\*(C`ev_default_init\*(C'\fR. ++.PP ++All of the following are about amortised time: If an array needs to be ++extended, libev needs to realloc and move the whole array, but this ++happens asymptotically rarer with higher number of elements, so O(1) might ++mean that libev does a lengthy realloc operation in rare cases, but on ++average it is much faster and asymptotically approaches constant time. ++.IP "Starting and stopping timer/periodic watchers: O(log skipped_other_timers)" 4 ++.IX Item "Starting and stopping timer/periodic watchers: O(log skipped_other_timers)" ++This means that, when you have a watcher that triggers in one hour and ++there are 100 watchers that would trigger before that, then inserting will ++have to skip roughly seven (\f(CW\*(C`ld 100\*(C'\fR) of these watchers. ++.IP "Changing timer/periodic watchers (by autorepeat or calling again): O(log skipped_other_timers)" 4 ++.IX Item "Changing timer/periodic watchers (by autorepeat or calling again): O(log skipped_other_timers)" ++That means that changing a timer costs less than removing/adding them, ++as only the relative motion in the event queue has to be paid for. ++.IP "Starting io/check/prepare/idle/signal/child/fork/async watchers: O(1)" 4 ++.IX Item "Starting io/check/prepare/idle/signal/child/fork/async watchers: O(1)" ++These just add the watcher into an array or at the head of a list. ++.IP "Stopping check/prepare/idle/fork/async watchers: O(1)" 4 ++.IX Item "Stopping check/prepare/idle/fork/async watchers: O(1)" ++.PD 0 ++.IP "Stopping an io/signal/child watcher: O(number_of_watchers_for_this_(fd/signal/pid % \s-1EV_PID_HASHSIZE\s0))" 4 ++.IX Item "Stopping an io/signal/child watcher: O(number_of_watchers_for_this_(fd/signal/pid % EV_PID_HASHSIZE))" ++.PD ++These watchers are stored in lists, so they need to be walked to find the ++correct watcher to remove. The lists are usually short (you don't usually ++have many watchers waiting for the same fd or signal: one is typical, two ++is rare). ++.IP "Finding the next timer in each loop iteration: O(1)" 4 ++.IX Item "Finding the next timer in each loop iteration: O(1)" ++By virtue of using a binary or 4\-heap, the next timer is always found at a ++fixed position in the storage array. ++.IP "Each change on a file descriptor per loop iteration: O(number_of_watchers_for_this_fd)" 4 ++.IX Item "Each change on a file descriptor per loop iteration: O(number_of_watchers_for_this_fd)" ++A change means an I/O watcher gets started or stopped, which requires ++libev to recalculate its status (and possibly tell the kernel, depending ++on backend and whether \f(CW\*(C`ev_io_set\*(C'\fR was used). ++.IP "Activating one watcher (putting it into the pending state): O(1)" 4 ++.IX Item "Activating one watcher (putting it into the pending state): O(1)" ++.PD 0 ++.IP "Priority handling: O(number_of_priorities)" 4 ++.IX Item "Priority handling: O(number_of_priorities)" ++.PD ++Priorities are implemented by allocating some space for each ++priority. When doing priority-based operations, libev usually has to ++linearly search all the priorities, but starting/stopping and activating ++watchers becomes O(1) with respect to priority handling. ++.IP "Sending an ev_async: O(1)" 4 ++.IX Item "Sending an ev_async: O(1)" ++.PD 0 ++.IP "Processing ev_async_send: O(number_of_async_watchers)" 4 ++.IX Item "Processing ev_async_send: O(number_of_async_watchers)" ++.IP "Processing signals: O(max_signal_number)" 4 ++.IX Item "Processing signals: O(max_signal_number)" ++.PD ++Sending involves a system call \fIiff\fR there were no other \f(CW\*(C`ev_async_send\*(C'\fR ++calls in the current loop iteration and the loop is currently ++blocked. Checking for async and signal events involves iterating over all ++running async watchers or all signal numbers. ++.SH "PORTING FROM LIBEV 3.X TO 4.X" ++.IX Header "PORTING FROM LIBEV 3.X TO 4.X" ++The major version 4 introduced some incompatible changes to the \s-1API\s0. ++.PP ++At the moment, the \f(CW\*(C`ev.h\*(C'\fR header file provides compatibility definitions ++for all changes, so most programs should still compile. The compatibility ++layer might be removed in later versions of libev, so better update to the ++new \s-1API\s0 early than late. ++.ie n .IP """EV_COMPAT3"" backwards compatibility mechanism" 4 ++.el .IP "\f(CWEV_COMPAT3\fR backwards compatibility mechanism" 4 ++.IX Item "EV_COMPAT3 backwards compatibility mechanism" ++The backward compatibility mechanism can be controlled by ++\&\f(CW\*(C`EV_COMPAT3\*(C'\fR. See \*(L"\s-1PREPROCESSOR\s0 \s-1SYMBOLS/MACROS\s0\*(R" in the \*(L"\s-1EMBEDDING\s0\*(R" ++section. ++.ie n .IP """ev_default_destroy"" and ""ev_default_fork"" have been removed" 4 ++.el .IP "\f(CWev_default_destroy\fR and \f(CWev_default_fork\fR have been removed" 4 ++.IX Item "ev_default_destroy and ev_default_fork have been removed" ++These calls can be replaced easily by their \f(CW\*(C`ev_loop_xxx\*(C'\fR counterparts: ++.Sp ++.Vb 2 ++\& ev_loop_destroy (EV_DEFAULT_UC); ++\& ev_loop_fork (EV_DEFAULT); ++.Ve ++.IP "function/symbol renames" 4 ++.IX Item "function/symbol renames" ++A number of functions and symbols have been renamed: ++.Sp ++.Vb 3 ++\& ev_loop => ev_run ++\& EVLOOP_NONBLOCK => EVRUN_NOWAIT ++\& EVLOOP_ONESHOT => EVRUN_ONCE ++\& ++\& ev_unloop => ev_break ++\& EVUNLOOP_CANCEL => EVBREAK_CANCEL ++\& EVUNLOOP_ONE => EVBREAK_ONE ++\& EVUNLOOP_ALL => EVBREAK_ALL ++\& ++\& EV_TIMEOUT => EV_TIMER ++\& ++\& ev_loop_count => ev_iteration ++\& ev_loop_depth => ev_depth ++\& ev_loop_verify => ev_verify ++.Ve ++.Sp ++Most functions working on \f(CW\*(C`struct ev_loop\*(C'\fR objects don't have an ++\&\f(CW\*(C`ev_loop_\*(C'\fR prefix, so it was removed; \f(CW\*(C`ev_loop\*(C'\fR, \f(CW\*(C`ev_unloop\*(C'\fR and ++associated constants have been renamed to not collide with the \f(CW\*(C`struct ++ev_loop\*(C'\fR anymore and \f(CW\*(C`EV_TIMER\*(C'\fR now follows the same naming scheme ++as all other watcher types. Note that \f(CW\*(C`ev_loop_fork\*(C'\fR is still called ++\&\f(CW\*(C`ev_loop_fork\*(C'\fR because it would otherwise clash with the \f(CW\*(C`ev_fork\*(C'\fR ++typedef. ++.ie n .IP """EV_MINIMAL"" mechanism replaced by ""EV_FEATURES""" 4 ++.el .IP "\f(CWEV_MINIMAL\fR mechanism replaced by \f(CWEV_FEATURES\fR" 4 ++.IX Item "EV_MINIMAL mechanism replaced by EV_FEATURES" ++The preprocessor symbol \f(CW\*(C`EV_MINIMAL\*(C'\fR has been replaced by a different ++mechanism, \f(CW\*(C`EV_FEATURES\*(C'\fR. Programs using \f(CW\*(C`EV_MINIMAL\*(C'\fR usually compile ++and work, but the library code will of course be larger. ++.SH "GLOSSARY" ++.IX Header "GLOSSARY" ++.IP "active" 4 ++.IX Item "active" ++A watcher is active as long as it has been started and not yet stopped. ++See \*(L"\s-1WATCHER\s0 \s-1STATES\s0\*(R" for details. ++.IP "application" 4 ++.IX Item "application" ++In this document, an application is whatever is using libev. ++.IP "backend" 4 ++.IX Item "backend" ++The part of the code dealing with the operating system interfaces. ++.IP "callback" 4 ++.IX Item "callback" ++The address of a function that is called when some event has been ++detected. Callbacks are being passed the event loop, the watcher that ++received the event, and the actual event bitset. ++.IP "callback/watcher invocation" 4 ++.IX Item "callback/watcher invocation" ++The act of calling the callback associated with a watcher. ++.IP "event" 4 ++.IX Item "event" ++A change of state of some external event, such as data now being available ++for reading on a file descriptor, time having passed or simply not having ++any other events happening anymore. ++.Sp ++In libev, events are represented as single bits (such as \f(CW\*(C`EV_READ\*(C'\fR or ++\&\f(CW\*(C`EV_TIMER\*(C'\fR). ++.IP "event library" 4 ++.IX Item "event library" ++A software package implementing an event model and loop. ++.IP "event loop" 4 ++.IX Item "event loop" ++An entity that handles and processes external events and converts them ++into callback invocations. ++.IP "event model" 4 ++.IX Item "event model" ++The model used to describe how an event loop handles and processes ++watchers and events. ++.IP "pending" 4 ++.IX Item "pending" ++A watcher is pending as soon as the corresponding event has been ++detected. See \*(L"\s-1WATCHER\s0 \s-1STATES\s0\*(R" for details. ++.IP "real time" 4 ++.IX Item "real time" ++The physical time that is observed. It is apparently strictly monotonic :) ++.IP "wall-clock time" 4 ++.IX Item "wall-clock time" ++The time and date as shown on clocks. Unlike real time, it can actually ++be wrong and jump forwards and backwards, e.g. when you adjust your ++clock. ++.IP "watcher" 4 ++.IX Item "watcher" ++A data structure that describes interest in certain events. Watchers need ++to be started (attached to an event loop) before they can receive events. ++.SH "AUTHOR" ++.IX Header "AUTHOR" ++Marc Lehmann , with repeated corrections by Mikael ++Magnusson and Emanuele Giaquinta, and minor corrections by many others. +--- shadowsocks-1.0.orig/libev/Makefile.am ++++ shadowsocks-1.0/libev/Makefile.am +@@ -14,7 +14,7 @@ include_HEADERS = ev.h ev++.h event.h + lib_LTLIBRARIES = libev.la + + libev_la_SOURCES = ev.c event.c +-libev_la_LDFLAGS = -version-info $(VERSION_INFO) ++libev_la_LDFLAGS = -static -version-info $(VERSION_INFO) + + ev.3: ev.pod + pod2man -n LIBEV -r "libev-$(VERSION)" -c "libev - high performance full featured event loop" -s3 <$< >$@ diff --git a/debian/patches/series b/debian/patches/series new file mode 100644 index 00000000..9ca2b603 --- /dev/null +++ b/debian/patches/series @@ -0,0 +1 @@ +debian-changes-1.0-1 diff --git a/debian/rules b/debian/rules new file mode 100755 index 00000000..c30bbdbb --- /dev/null +++ b/debian/rules @@ -0,0 +1,21 @@ +#!/usr/bin/make -f +# -*- makefile -*- +# Sample debian/rules that uses debhelper. +# +# This file was originally written by Joey Hess and Craig Small. +# As a special exception, when this file is copied by dh-make into a +# dh-make output file, you may use that output file without restriction. +# This special exception was added by Craig Small in version 0.37 of dh-make. +# +# Modified to make a template file for a multi-binary package with separated +# build-arch and build-indep targets by Bill Allombert 2001 + +# Uncomment this to turn on verbose mode. +#export DH_VERBOSE=1 + +# This has to be exported to make some magic below work. +export DH_OPTIONS + + +%: + dh $@ diff --git a/debian/shadowsocks.postinst.debhelper b/debian/shadowsocks.postinst.debhelper new file mode 100644 index 00000000..3d89d3ef --- /dev/null +++ b/debian/shadowsocks.postinst.debhelper @@ -0,0 +1,5 @@ +# Automatically added by dh_makeshlibs +if [ "$1" = "configure" ]; then + ldconfig +fi +# End automatically added section diff --git a/debian/shadowsocks.postrm.debhelper b/debian/shadowsocks.postrm.debhelper new file mode 100644 index 00000000..7f440472 --- /dev/null +++ b/debian/shadowsocks.postrm.debhelper @@ -0,0 +1,5 @@ +# Automatically added by dh_makeshlibs +if [ "$1" = "remove" ]; then + ldconfig +fi +# End automatically added section diff --git a/debian/shadowsocks.substvars b/debian/shadowsocks.substvars new file mode 100644 index 00000000..63feafd7 --- /dev/null +++ b/debian/shadowsocks.substvars @@ -0,0 +1,2 @@ +shlibs:Depends=libc6 (>= 2.3.6-6~), libc6 (>= 2.9) +misc:Depends= diff --git a/debian/source/format b/debian/source/format new file mode 100644 index 00000000..163aaf8d --- /dev/null +++ b/debian/source/format @@ -0,0 +1 @@ +3.0 (quilt) diff --git a/libasyncns/Makefile.am b/libasyncns/Makefile.am index 54f39418..39197d14 100644 --- a/libasyncns/Makefile.am +++ b/libasyncns/Makefile.am @@ -21,6 +21,7 @@ AM_CFLAGS=-D__EXTENSIONS__ $(PTHREAD_CFLAGS) lib_LTLIBRARIES=libasyncns.la libasyncns_la_CC=$(PTHREAD_CC) libasyncns_la_SOURCES=asyncns.c asyncns.h +libasyncns_la_LDFLAGS= -static libasyncns_la_LIBADD=$(PTHREAD_LIBS) include_HEADERS=asyncns.h diff --git a/libev/Makefile.am b/libev/Makefile.am index 059305bc..abf0c133 100644 --- a/libev/Makefile.am +++ b/libev/Makefile.am @@ -14,7 +14,7 @@ include_HEADERS = ev.h ev++.h event.h lib_LTLIBRARIES = libev.la libev_la_SOURCES = ev.c event.c -libev_la_LDFLAGS = -version-info $(VERSION_INFO) +libev_la_LDFLAGS = -static -version-info $(VERSION_INFO) ev.3: ev.pod pod2man -n LIBEV -r "libev-$(VERSION)" -c "libev - high performance full featured event loop" -s3 <$< >$@