--- /dev/null
+ GNU AFFERO GENERAL PUBLIC LICENSE
+ Version 3, 19 November 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+ Preamble
+
+ The GNU Affero General Public License is a free, copyleft license
+for software and other kinds of works, specifically designed to ensure
+cooperation with the community in the case of network server software.
+
+ The licenses for most software and other practical works are
+designed to take away your freedom to share and change the works. By
+contrast, our General Public Licenses are 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.
+
+ 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.
+
+ Developers that use our General Public Licenses protect your rights
+with two steps: (1) assert copyright on the software, and (2) offer
+you this License which gives you legal permission to copy, distribute
+and/or modify the software.
+
+ A secondary benefit of defending all users' freedom is that
+improvements made in alternate versions of the program, if they
+receive widespread use, become available for other developers to
+incorporate. Many developers of free software are heartened and
+encouraged by the resulting cooperation. However, in the case of
+software used on network servers, this result may fail to come about.
+The GNU General Public License permits making a modified version and
+letting the public access it on a server without ever releasing its
+source code to the public.
+
+ The GNU Affero General Public License is designed specifically to
+ensure that, in such cases, the modified source code becomes available
+to the community. It requires the operator of a network server to
+provide the source code of the modified version running there to the
+users of that server. Therefore, public use of a modified version, on
+a publicly accessible server, gives the public access to the source
+code of the modified version.
+
+ An older license, called the Affero General Public License and
+published by Affero, was designed to accomplish similar goals. This is
+a different license, not a version of the Affero GPL, but Affero has
+released a new version of the Affero GPL which permits relicensing under
+this license.
+
+ 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 Affero 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. Remote Network Interaction; Use with the GNU General Public License.
+
+ Notwithstanding any other provision of this License, if you modify the
+Program, your modified version must prominently offer all users
+interacting with it remotely through a computer network (if your version
+supports such interaction) an opportunity to receive the Corresponding
+Source of your version by providing access to the Corresponding Source
+from a network server at no charge, through some standard or customary
+means of facilitating copying of software. This Corresponding Source
+shall include the Corresponding Source for any work covered by version 3
+of the GNU General Public License that is incorporated pursuant to the
+following paragraph.
+
+ 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 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 work with which it is
+combined will remain governed by version 3 of the GNU General Public
+License.
+
+ 14. Revised Versions of this License.
+
+ The Free Software Foundation may publish revised and/or new versions of
+the GNU Affero 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 Affero
+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 Affero 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 Affero General Public License can be used, that
+proxy's public statement of acceptance of a version permanently
+authorizes you to choose that version for the Program.
+
+ Later license versions may give you additional or different
+permissions. However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+ 15. Disclaimer of Warranty.
+
+ THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+ 16. Limitation of Liability.
+
+ IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+ 17. Interpretation of Sections 15 and 16.
+
+ If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+ END OF TERMS AND CONDITIONS
+
+ How to Apply These Terms to Your New Programs
+
+ If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+ To do so, attach the following notices to the program. It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+ <one line to give the program's name and a brief idea of what it does.>
+ Copyright (C) <year> <name of author>
+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU Affero 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 Affero General Public License for more details.
+
+ You should have received a copy of the GNU Affero General Public License
+ along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+ If your software can interact with users remotely through a computer
+network, you should also make sure that it provides a way for users to
+get its source. For example, if your program is a web application, its
+interface could display a "Source" link that leads users to an archive
+of the code. There are many ways you could offer source, and different
+solutions will be better for different programs; see section 13 for the
+specific requirements.
+
+ 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 AGPL, see
+<http://www.gnu.org/licenses/>.
+VoRS -- Vo(IP) Really Simple
+Very simple and usable multi-user VoIP solution.
+Some kind of alternative to Mumble.
+VoRS is copylefted free software: see the file COPYING for copying
+conditions. It should work on all POSIX-compatible systems.
--- /dev/null
+* Audio mixing on server-side
--- /dev/null
+// VoRS -- Vo(IP) Really Simple
+// Copyright (C) 2024 Sergey Matveev <stargrave@stargrave.org>
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as
+// published by the Free Software Foundation, version 3 of the License.
+//
+// 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 <http://www.gnu.org/licenses/>.
+
+package main
+
+import (
+ "sort"
+
+ "github.com/jroimartin/gocui"
+)
+
+var (
+ GUI *gocui.Gui
+ GUIReady bool
+ GUIReadyC = make(chan struct{})
+ GUIMaxY int
+)
+
+func guiQuit(gui *gocui.Gui, v *gocui.View) error {
+ Finish <- struct{}{}
+ return gocui.ErrQuit
+}
+
+func mute(gui *gocui.Gui, v *gocui.View) error {
+ Muted = !Muted
+ return nil
+}
+
+func guiLayout(gui *gocui.Gui) error {
+ var maxX int
+ maxX, GUIMaxY = gui.Size()
+ prevY := 0
+ v, err := gui.SetView("logs", 0, prevY, maxX-1, prevY+10+2)
+ prevY += 10 + 2
+ if err != nil {
+ if err != gocui.ErrUnknownView {
+ return err
+ }
+ v.Title = "Logs"
+ v.Autoscroll = true
+ }
+ sids := make([]int, 0, len(Streams))
+ for sid := range Streams {
+ sids = append(sids, int(sid))
+ }
+ sort.Ints(sids)
+ var stream *Stream
+ for _, sid := range sids {
+ stream = Streams[byte(sid)]
+ v, err = gui.SetView(stream.name, 0, prevY, maxX/2-1, prevY+2)
+ if err != nil {
+ if err != gocui.ErrUnknownView {
+ return err
+ }
+ v.Title = stream.name
+ }
+ _, err = gui.SetView(stream.name+"-vol", maxX/2, prevY, maxX-1, prevY+2)
+ prevY += 3
+ if err != nil {
+ if err != gocui.ErrUnknownView {
+ return err
+ }
+ }
+ }
+ if !GUIReady {
+ close(GUIReadyC)
+ GUIReady = true
+ gui.SetCurrentView(*Name)
+ }
+ return nil
+}
--- /dev/null
+// VoRS -- Vo(IP) Really Simple
+// Copyright (C) 2024 Sergey Matveev <stargrave@stargrave.org>
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as
+// published by the Free Software Foundation, version 3 of the License.
+//
+// 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 <http://www.gnu.org/licenses/>.
+
+package main
+
+import (
+ "bufio"
+ "bytes"
+ "crypto/tls"
+ "crypto/x509"
+ "encoding/binary"
+ "encoding/hex"
+ "errors"
+ "flag"
+ "fmt"
+ "io"
+ "log"
+ "net"
+ "net/netip"
+ "os"
+ "os/exec"
+ "strconv"
+ "strings"
+ "time"
+
+ "github.com/jroimartin/gocui"
+ vors "go.stargrave.org/vors/internal"
+ "golang.org/x/crypto/blake2s"
+ "golang.org/x/crypto/chacha20"
+ "golang.org/x/crypto/chacha20poly1305"
+ "golang.org/x/crypto/poly1305"
+ "gopkg.in/hraban/opus.v2"
+)
+
+type Stream struct {
+ name string
+ ctr uint32
+ in chan []byte
+ stats *Stats
+}
+
+var (
+ Streams = map[byte]*Stream{}
+ Finish = make(chan struct{})
+ OurStats = &Stats{dead: make(chan struct{})}
+ Name = flag.String("name", "test", "Username")
+ Muted bool
+)
+
+func parseSID(s string) byte {
+ n, err := strconv.Atoi(s)
+ if err != nil {
+ log.Fatal(err)
+ }
+ if n > 255 {
+ log.Fatal("too big stream num")
+ }
+ return byte(n)
+}
+
+func makeCmd(cmd string) *exec.Cmd {
+ args := strings.Fields(cmd)
+ if len(args) == 1 {
+ return exec.Command(args[0])
+ }
+ return exec.Command(args[0], args[1:]...)
+}
+
+func incr(data []byte) {
+ for i := len(data) - 1; i >= 0; i-- {
+ data[i]++
+ if data[i] != 0 {
+ return
+ }
+ }
+ panic("overflow")
+}
+
+func main() {
+ vadRaw := flag.Uint("vad", 0, "VAD threshold")
+ hostport := flag.String("srv", "[::1]:12345", "TCP/UDP port to connect to")
+ spkiHash := flag.String("spki", "FILL-ME", "SHA256 hash of server's certificate SPKI")
+ passwd := flag.String("passwd", "", "Password")
+ recCmd := flag.String("rec", "rec --no-show-progress --buffer 1920 --channels 1 --endian little --encoding signed --rate 48000 --bits 16 --type raw -", "rec command")
+ playCmd := flag.String("play", "play --no-show-progress --buffer 1920 --channels 1 --endian little --encoding signed --rate 48000 --bits 16 --type raw -", "play command")
+ flag.Parse()
+ log.SetFlags(log.Lmicroseconds | log.Lshortfile)
+
+ vad := uint64(*vadRaw)
+ opusEnc := newOpusEnc()
+ var mic io.ReadCloser
+ var err error
+ if *recCmd != "" {
+ cmd := makeCmd(*recCmd)
+ mic, err = cmd.StdoutPipe()
+ if err != nil {
+ log.Fatal(err)
+ }
+ err = cmd.Start()
+ if err != nil {
+ log.Fatal(err)
+ }
+ }
+
+ addrTCP, err := net.ResolveTCPAddr("tcp", *hostport)
+ if err != nil {
+ log.Fatal(err)
+ }
+ addrUDP, err := net.ResolveUDPAddr("udp", *hostport)
+ if err != nil {
+ log.Fatal(err)
+ }
+ ctrlRaw, err := net.DialTCP("tcp", nil, addrTCP)
+ if err != nil {
+ log.Fatalln("dial server:", err)
+ }
+ defer ctrlRaw.Close()
+ ourAddr := net.UDPAddrFromAddrPort(
+ netip.MustParseAddrPort(ctrlRaw.LocalAddr().String()))
+ ln, err := net.ListenUDP("udp", ourAddr)
+ if err != nil {
+ log.Fatal(err)
+ }
+ ctrl := tls.Client(ctrlRaw, &tls.Config{
+ MinVersion: tls.VersionTLS13,
+ CurvePreferences: []tls.CurveID{tls.X25519},
+ ServerName: vors.CN,
+ InsecureSkipVerify: true,
+ VerifyPeerCertificate: func(
+ rawCerts [][]byte, verifiedChains [][]*x509.Certificate,
+ ) error {
+ cer, err := x509.ParseCertificate(rawCerts[0])
+ if err != nil {
+ return err
+ }
+ if *spkiHash != vors.SPKIHash(cer) {
+ return errors.New("server certificate's SPKI hash mismatch")
+ }
+ return nil
+ },
+ })
+ err = ctrl.Handshake()
+ if err != nil {
+ log.Println("TLS handshake:", err)
+ return
+ }
+ defer ctrl.Close()
+
+ scanner := bufio.NewScanner(ctrl)
+ if !scanner.Scan() {
+ log.Println("read challenge:", scanner.Err())
+ return
+ }
+ {
+ h, err := blake2s.New256([]byte(*passwd))
+ if err != nil {
+ log.Fatal(err)
+ }
+ h.Write(scanner.Bytes())
+ if _, err = io.Copy(ctrl, strings.NewReader(fmt.Sprintf(
+ "%s %s\n", hex.EncodeToString(h.Sum(nil)), *Name))); err != nil {
+ log.Println("write password:", err)
+ return
+ }
+ }
+ if !scanner.Scan() {
+ log.Println("auth", scanner.Err())
+ return
+ }
+ cols := strings.Fields(scanner.Text())
+ if cols[0] != "OK" {
+ log.Println("auth failed:", scanner.Text())
+ return
+ }
+ sid := parseSID(cols[1])
+ Streams[sid] = &Stream{name: *Name, stats: OurStats}
+
+ tlsState := ctrl.ConnectionState()
+ key, err := tlsState.ExportKeyingMaterial(
+ cols[1], nil, chacha20poly1305.KeySize)
+ if err != nil {
+ log.Fatal(err)
+ }
+ ciph, err := chacha20poly1305.New(key)
+ if err != nil {
+ log.Fatal(err)
+ }
+ seen := time.Now()
+
+ LoggerReady := make(chan struct{})
+ GUI, err = gocui.NewGui(gocui.OutputNormal)
+ if err != nil {
+ log.Fatal(err)
+ }
+ defer GUI.Close()
+ GUI.SelFgColor = gocui.ColorCyan
+ GUI.Highlight = true
+ GUI.SetManagerFunc(guiLayout)
+ if err := GUI.SetKeybinding("", gocui.KeyF10, gocui.ModNone, guiQuit); err != nil {
+ log.Fatal(err)
+ }
+ if err := GUI.SetKeybinding("", gocui.KeyEnter, gocui.ModNone, mute); err != nil {
+ log.Fatal(err)
+ }
+
+ go func() {
+ <-GUIReadyC
+ v, err := GUI.View("logs")
+ if err != nil {
+ log.Fatal(err)
+ }
+ log.SetOutput(v)
+ log.Println("connected")
+ close(LoggerReady)
+ for {
+ time.Sleep(vors.ScreenRefresh)
+ GUI.Update(func(gui *gocui.Gui) error {
+ return nil
+ })
+ }
+ }()
+
+ go func() {
+ <-Finish
+ go GUI.Close()
+ time.Sleep(100 * time.Millisecond)
+ os.Exit(0)
+ }()
+
+ go func() {
+ var err error
+ for {
+ time.Sleep(vors.PingTime)
+ if _, err = ctrl.Write([]byte(vors.CmdPing + "\n")); err != nil {
+ log.Println("ping:", err)
+ Finish <- struct{}{}
+ break
+ }
+ }
+ }()
+
+ go func(seen *time.Time) {
+ var t string
+ var now time.Time
+ for scanner.Scan() {
+ t = scanner.Text()
+ if t == vors.CmdPong {
+ now = time.Now()
+ *seen = now
+ continue
+ }
+ cols := strings.Fields(t)
+ switch cols[0] {
+ case vors.CmdAdd:
+ sidRaw, name, keyHex := cols[1], cols[2], cols[3]
+ log.Println("add", name)
+ sid := parseSID(sidRaw)
+ key, err := hex.DecodeString(keyHex)
+ if err != nil {
+ log.Fatal(err)
+ }
+ stream := &Stream{
+ name: name,
+ in: make(chan []byte, 1<<10),
+ stats: &Stats{dead: make(chan struct{})},
+ }
+ go func() {
+ ciph, err := chacha20poly1305.New(key)
+ if err != nil {
+ log.Fatal(err)
+ }
+ dec, err := opus.NewDecoder(vors.Rate, 1)
+ if err != nil {
+ log.Fatal(err)
+ }
+
+ var player io.WriteCloser
+ var cmd *exec.Cmd
+ if *playCmd != "" {
+ cmd = makeCmd(*playCmd)
+ player, err = cmd.StdinPipe()
+ if err != nil {
+ log.Fatal(err)
+ }
+ err = cmd.Start()
+ if err != nil {
+ log.Fatal(err)
+ }
+ }
+
+ ctr := uint32(sid) << 24
+ pcm := make([]int16, vors.FrameLen)
+ pcmbuf := make([]byte, 2*vors.FrameLen)
+ decbuf := make([]byte, 2*vors.FrameLen)
+ nonce := make([]byte, chacha20.NonceSize)
+ ctrBuf := nonce[len(nonce)-4:]
+ var pkt []byte
+ lost := -1
+ var lastDur int
+ for buf := range stream.in {
+ ctr = binary.BigEndian.Uint32(buf)
+ copy(ctrBuf, buf)
+ pkt, err = ciph.Open(
+ decbuf[:0], nonce, buf[4:], []byte{buf[0]})
+ if err != nil {
+ log.Println("decrypt:", stream.name, err)
+ continue
+ }
+ if lost == -1 {
+ // ignore the very first packet in the stream
+ lost = 0
+ } else {
+ lost = int(ctr - (stream.ctr + 1))
+ }
+ stream.ctr = ctr
+ stream.stats.lost += int64(lost)
+ if lost > vors.MaxLost {
+ lost = 0
+ }
+ for ; lost > 0; lost-- {
+ lastDur, err = dec.LastPacketDuration()
+ if err != nil {
+ log.Println("PLC:", err)
+ continue
+ }
+ err = dec.DecodePLC(pcm[:lastDur])
+ if err != nil {
+ log.Println("PLC:", err)
+ continue
+ }
+ stream.stats.AddRMS(pcm)
+ if cmd == nil {
+ continue
+ }
+ pcmConv(pcmbuf, pcm[:lastDur])
+ if _, err = io.Copy(player, bytes.NewReader(
+ pcmbuf[:2*lastDur])); err != nil {
+ log.Println("play:", err)
+ }
+ }
+ _, err = dec.Decode(pkt, pcm)
+ if err != nil {
+ log.Println("decode:", err)
+ continue
+ }
+ stream.stats.AddRMS(pcm)
+ stream.stats.last = time.Now()
+ if cmd == nil {
+ continue
+ }
+ pcmConv(pcmbuf, pcm)
+ if _, err = io.Copy(player,
+ bytes.NewReader(pcmbuf)); err != nil {
+ log.Println("play:", err)
+ }
+ }
+ if cmd != nil {
+ cmd.Process.Kill()
+ }
+ }()
+ go statsDrawer(stream.stats, stream.name)
+ Streams[sid] = stream
+ case vors.CmdDel:
+ sid := parseSID(cols[1])
+ s := Streams[sid]
+ if s == nil {
+ log.Println("unknown sid:", sid)
+ continue
+ }
+ delete(Streams, sid)
+ close(s.in)
+ close(s.stats.dead)
+ log.Println("del", s.name)
+ default:
+ log.Fatal("unknown cmd:", cols[0])
+ }
+ }
+ if scanner.Err() != nil {
+ log.Print("scanner:", err)
+ Finish <- struct{}{}
+ }
+ }(&seen)
+
+ go func(seen *time.Time) {
+ for now := range time.Tick(vors.PingTime) {
+ if seen.Add(2 * vors.PingTime).Before(now) {
+ log.Println("timeout:", seen)
+ Finish <- struct{}{}
+ break
+ }
+ }
+ }(&seen)
+
+ go func() {
+ <-LoggerReady
+ var n int
+ var from *net.UDPAddr
+ var err error
+ var stream *Stream
+ var ctr uint32
+ for {
+ buf := make([]byte, 2*vors.FrameLen)
+ n, from, err = ln.ReadFromUDP(buf)
+ if err != nil {
+ log.Println("recvfrom:", err)
+ Finish <- struct{}{}
+ break
+ }
+ if from.Port != addrUDP.Port || !from.IP.Equal(addrUDP.IP) {
+ log.Println("wrong addr:", from)
+ continue
+ }
+ if n <= 1+4+poly1305.TagSize {
+ log.Println("too small:", n)
+ continue
+ }
+ stream = Streams[buf[0]]
+ if stream == nil {
+ log.Println("unknown stream:", buf[0])
+ continue
+ }
+ stream.stats.pkts++
+ stream.stats.bytes += uint64(n)
+ ctr = binary.BigEndian.Uint32(buf)
+ if ctr <= stream.ctr {
+ stream.stats.reorder++
+ continue
+ }
+ stream.in <- buf[:n]
+ }
+ }()
+
+ go statsDrawer(OurStats, *Name)
+ go func() {
+ <-LoggerReady
+ for {
+ OurStats.pkts++
+ OurStats.bytes += 1
+ if _, err = ln.WriteTo([]byte{sid}, addrUDP); err != nil {
+ log.Println("send:", err)
+ Finish <- struct{}{}
+ }
+ time.Sleep(time.Second)
+ }
+ }()
+ go func() {
+ if *recCmd == "" {
+ return
+ }
+ <-LoggerReady
+ buf := make([]byte, 2*vors.FrameLen)
+ pcm := make([]int16, vors.FrameLen)
+ nonce := make([]byte, ciph.NonceSize())
+ nonce[len(nonce)-4] = sid
+ ctr := nonce[len(nonce)-3:]
+ sidAndCtr := nonce[len(nonce)-4:]
+ var pkt []byte
+ var n, i int
+ for {
+ _, err = io.ReadFull(mic, buf)
+ if err != nil {
+ log.Println("mic:", err)
+ break
+ }
+ if Muted {
+ continue
+ }
+ for i = 0; i < vors.FrameLen; i++ {
+ pcm[i] = int16(uint16(buf[i*2+0]) | (uint16(buf[i*2+1]) << 8))
+ }
+ if vad != 0 && vors.RMS(pcm) < vad {
+ continue
+ }
+ incr(ctr)
+ copy(buf, sidAndCtr)
+ n, err = opusEnc.Encode(pcm, buf[4:])
+ if err != nil {
+ log.Fatal(err)
+ }
+ pkt = ciph.Seal(buf[:4], nonce, buf[4:4+n], []byte{sid})
+ OurStats.pkts++
+ OurStats.bytes += uint64(len(pkt))
+ OurStats.last = time.Now()
+ OurStats.AddRMS(pcm)
+ if _, err = ln.WriteTo(pkt, addrUDP); err != nil {
+ log.Println("send:", err)
+ break
+ }
+ }
+ }()
+
+ err = GUI.MainLoop()
+ if err != nil && err != gocui.ErrQuit {
+ log.Fatal(err)
+ }
+}
--- /dev/null
+// VoRS -- Vo(IP) Really Simple
+// Copyright (C) 2024 Sergey Matveev <stargrave@stargrave.org>
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as
+// published by the Free Software Foundation, version 3 of the License.
+//
+// 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 <http://www.gnu.org/licenses/>.
+
+package main
+
+import (
+ "log"
+
+ vors "go.stargrave.org/vors/internal"
+ "gopkg.in/hraban/opus.v2"
+)
+
+func newOpusEnc() *opus.Encoder {
+ enc, err := opus.NewEncoder(vors.Rate, 1, opus.AppVoIP)
+ if err != nil {
+ log.Fatal(err)
+ }
+ err = enc.SetComplexity(10)
+ if err != nil {
+ log.Fatal(err)
+ }
+ err = enc.SetBitrate(vors.Bitrate)
+ if err != nil {
+ log.Fatal(err)
+ }
+ return enc
+}
+
+func pcmConv(buf []byte, pcm []int16) {
+ for i := 0; i < len(pcm); i++ {
+ buf[i*2+0] = byte((uint16(pcm[i]) & 0x00FF) >> 0)
+ buf[i*2+1] = byte((uint16(pcm[i]) & 0xFF00) >> 8)
+ }
+}
--- /dev/null
+// VoRS -- Vo(IP) Really Simple
+// Copyright (C) 2024 Sergey Matveev <stargrave@stargrave.org>
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as
+// published by the Free Software Foundation, version 3 of the License.
+//
+// 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 <http://www.gnu.org/licenses/>.
+
+package main
+
+import (
+ "fmt"
+ "math"
+ "strings"
+ "sync/atomic"
+ "time"
+
+ "github.com/dustin/go-humanize"
+ "github.com/jroimartin/gocui"
+ vors "go.stargrave.org/vors/internal"
+)
+
+type Stats struct {
+ pkts int64
+ bytes uint64
+ lost int64
+ reorder int64
+ last time.Time
+ vol uint64
+ volN uint64
+ dead chan struct{}
+}
+
+func (stats *Stats) AddRMS(pcm []int16) {
+ var vol uint64
+ for _, s := range pcm {
+ vol += uint64(int64(s) * int64(s))
+ }
+ atomic.AddUint64(&stats.vol, vol)
+ atomic.AddUint64(&stats.volN, uint64(len(pcm)))
+}
+
+func statsDrawer(stats *Stats, name string) {
+ var err error
+ tick := time.Tick(vors.ScreenRefresh)
+ var now time.Time
+ var v *gocui.View
+ var vol, volN float64
+ var rep int
+ for {
+ select {
+ case <-stats.dead:
+ GUI.DeleteView(name)
+ GUI.DeleteView(name + "-vol")
+ return
+ case now = <-tick:
+ s := fmt.Sprintf(
+ "%s | %s | L/R: %s / %s",
+ humanize.Comma(stats.pkts),
+ humanize.IBytes(stats.bytes),
+ humanize.Comma(stats.lost),
+ humanize.Comma(stats.reorder),
+ )
+ if name == *Name && Muted {
+ s += " | " + vors.CRed + "MUTE" + vors.CReset
+ } else {
+ if stats.last.Add(time.Second).After(now) {
+ s += " | " + vors.CGreen + "TALK" + vors.CReset
+ }
+ }
+ v, err = GUI.View(name)
+ if err == nil {
+ v.Clear()
+ v.Write([]byte(s))
+ }
+ vol = float64(atomic.SwapUint64(&stats.vol, 0))
+ volN = float64(atomic.SwapUint64(&stats.volN, 0))
+ v, err = GUI.View(name + "-vol")
+ if err == nil {
+ v.Clear()
+ if volN == 0 {
+ continue
+ }
+ vol = math.Sqrt(vol / volN)
+ rep = int(float64(GUIMaxY) * vol / 5000)
+ v.Write([]byte(strings.Repeat("â–’", rep)))
+ }
+ }
+ }
+}
--- /dev/null
+// VoRS -- Vo(IP) Really Simple
+// Copyright (C) 2024 Sergey Matveev <stargrave@stargrave.org>
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as
+// published by the Free Software Foundation, version 3 of the License.
+//
+// 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 <http://www.gnu.org/licenses/>.
+
+package main
+
+import (
+ "crypto/ed25519"
+ "crypto/rand"
+ "crypto/x509"
+ "crypto/x509/pkix"
+ "encoding/pem"
+ "fmt"
+ "log"
+ "math/big"
+ "os"
+ "time"
+
+ vors "go.stargrave.org/vors/internal"
+)
+
+func main() {
+ log.SetFlags(log.Lmicroseconds | log.Lshortfile)
+ pub, prv, err := ed25519.GenerateKey(rand.Reader)
+ if err != nil {
+ log.Fatal(err)
+ }
+ notBefore := time.Now()
+ tmpl := x509.Certificate{
+ SerialNumber: big.NewInt(1),
+ Subject: pkix.Name{CommonName: vors.CN},
+ NotBefore: notBefore,
+ NotAfter: notBefore.Add(365 * 24 * time.Hour),
+ KeyUsage: x509.KeyUsageDigitalSignature,
+ ExtKeyUsage: []x509.ExtKeyUsage{x509.ExtKeyUsageServerAuth},
+ BasicConstraintsValid: true,
+ DNSNames: []string{vors.CN},
+ }
+ der, err := x509.CreateCertificate(rand.Reader, &tmpl, &tmpl, pub, prv)
+ if err != nil {
+ log.Fatal(err)
+ }
+ cer, err := x509.ParseCertificate(der)
+ if err != nil {
+ log.Fatal(err)
+ }
+ fmt.Fprintln(os.Stderr, "SPKI hash:", vors.SPKIHash(cer))
+ key, err := x509.MarshalPKCS8PrivateKey(prv)
+ if err != nil {
+ log.Fatal(err)
+ }
+ err = pem.Encode(os.Stdout, &pem.Block{Type: "PRIVATE KEY", Bytes: key})
+ if err != nil {
+ log.Fatal(err)
+ }
+ err = pem.Encode(os.Stdout, &pem.Block{Type: "CERTIFICATE", Bytes: der})
+ if err != nil {
+ log.Fatal(err)
+ }
+}
--- /dev/null
+// VoRS -- Vo(IP) Really Simple
+// Copyright (C) 2024 Sergey Matveev <stargrave@stargrave.org>
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as
+// published by the Free Software Foundation, version 3 of the License.
+//
+// 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 <http://www.gnu.org/licenses/>.
+
+package main
+
+import (
+ "flag"
+ "os"
+ "sort"
+ "time"
+
+ "github.com/jroimartin/gocui"
+)
+
+var (
+ NoGUI = flag.Bool("tuiless", false, "No fancy TUI, only logs")
+ GUI *gocui.Gui
+ GUIReady bool
+ GUIReadyC = make(chan struct{})
+)
+
+func guiQuit(g *gocui.Gui, v *gocui.View) error {
+ go func() {
+ time.Sleep(100 * time.Millisecond)
+ os.Exit(0)
+ }()
+ return gocui.ErrQuit
+}
+
+func guiLayout(gui *gocui.Gui) error {
+ maxX, _ := gui.Size()
+ prevY := 0
+ v, err := gui.SetView("logs", 0, prevY, maxX-1, prevY+10+2)
+ prevY += 10 + 2
+ if err != nil {
+ if err != gocui.ErrUnknownView {
+ return err
+ }
+ v.Title = "Logs"
+ v.Autoscroll = true
+ }
+ sids := make([]int, 0, len(Peers))
+ for sid := range Peers {
+ sids = append(sids, int(sid))
+ }
+ sort.Ints(sids)
+ for _, sid := range sids {
+ peer := Peers[byte(sid)]
+ v, err := gui.SetView(peer.name, 0, prevY, maxX-1, prevY+2)
+ prevY += 3
+ if err != nil {
+ if err != gocui.ErrUnknownView {
+ return err
+ }
+ v.Title = peer.name
+ }
+ }
+ if !GUIReady {
+ close(GUIReadyC)
+ GUIReady = true
+ }
+ return nil
+}
--- /dev/null
+// VoRS -- Vo(IP) Really Simple
+// Copyright (C) 2024 Sergey Matveev <stargrave@stargrave.org>
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as
+// published by the Free Software Foundation, version 3 of the License.
+//
+// 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 <http://www.gnu.org/licenses/>.
+
+package main
+
+import (
+ "bufio"
+ "crypto/rand"
+ "crypto/tls"
+ "encoding/hex"
+ "flag"
+ "fmt"
+ "io"
+ "log"
+ "log/slog"
+ "net"
+ "net/netip"
+ "os"
+ "strconv"
+ "strings"
+ "sync"
+ "time"
+
+ "github.com/dustin/go-humanize"
+ "github.com/jroimartin/gocui"
+ vors "go.stargrave.org/vors/internal"
+ "golang.org/x/crypto/blake2s"
+ "golang.org/x/crypto/chacha20poly1305"
+)
+
+var (
+ TLSCfg = &tls.Config{
+ MinVersion: tls.VersionTLS13,
+ CurvePreferences: []tls.CurveID{tls.X25519},
+ }
+ SPKI string
+ Passwd = flag.String("passwd", "", "Shared password")
+ Peers = map[byte]*Peer{}
+ PeersM sync.Mutex
+)
+
+type Peer struct {
+ name string
+ sid byte
+ addr *net.UDPAddr
+ conn net.Conn
+ key []byte
+ stats *Stats
+}
+
+func newPeer(connRaw net.Conn) {
+ logger := slog.With("remote", connRaw.RemoteAddr().String())
+ logger.Info("connected")
+ defer connRaw.Close()
+ if len(Peers) == 256 {
+ logger.Error("too many peers")
+ return
+ }
+ conn := tls.Server(connRaw, TLSCfg)
+ err := conn.Handshake()
+ if err != nil {
+ logger.Error("handshake:", "err", err)
+ return
+ }
+ defer conn.Close()
+
+ scanner := bufio.NewScanner(conn)
+ peer := Peer{conn: conn, stats: &Stats{dead: make(chan struct{})}}
+ peer.addr = net.UDPAddrFromAddrPort(
+ netip.MustParseAddrPort(conn.RemoteAddr().String()))
+ if err != nil {
+ log.Fatal(err)
+ }
+ {
+ chlng := make([]byte, 16)
+ if _, err = io.ReadFull(rand.Reader, chlng); err != nil {
+ log.Fatal(err)
+ return
+ }
+ chlngHex := hex.EncodeToString(chlng)
+ if _, err = io.Copy(conn, strings.NewReader(chlngHex+"\n")); err != nil {
+ logger.Error("write challenge:", "err", err)
+ return
+ }
+ h, err := blake2s.New256([]byte(*Passwd))
+ if err != nil {
+ log.Fatal(err)
+ }
+ h.Write([]byte(chlngHex))
+ if !scanner.Scan() {
+ logger.Error("read password:", "err", scanner.Err())
+ return
+ }
+ cols := strings.Fields(scanner.Text())
+ if len(cols) == 1 {
+ logger.Error("no name")
+ io.Copy(conn, strings.NewReader("no name\n"))
+ return
+ }
+ peer.name = cols[1]
+ if peer.name == "myself" {
+ logger.Error("reserved name")
+ io.Copy(conn, strings.NewReader("reserved name\n"))
+ return
+ }
+ logger = logger.With("name", cols[1])
+ if hex.EncodeToString(h.Sum(nil)) != cols[0] {
+ logger.Error("wrong password")
+ io.Copy(conn, strings.NewReader("wrong password\n"))
+ return
+ }
+ for _, p := range Peers {
+ if p.name == peer.name {
+ logger.Error("name already taken")
+ io.Copy(conn, strings.NewReader("name already taken\n"))
+ return
+ }
+ }
+ var i byte
+ var ok bool
+ PeersM.Lock()
+ for i = 0; i <= 255; i++ {
+ if _, ok = Peers[i]; !ok {
+ peer.sid = i
+ break
+ }
+ }
+ Peers[peer.sid] = &peer
+ PeersM.Unlock()
+ logger = logger.With("sid", peer.sid)
+ logger.Info("authenticated")
+ defer func() {
+ logger.Info("removing")
+ PeersM.Lock()
+ delete(Peers, peer.sid)
+ close(peer.stats.dead)
+ s := fmt.Sprintf("%s %d\n", vors.CmdDel, peer.sid)
+ for _, p := range Peers {
+ go io.Copy(p.conn, strings.NewReader(s))
+ }
+ PeersM.Unlock()
+ }()
+ if _, err = io.Copy(conn, strings.NewReader(
+ fmt.Sprintf("OK %d\n", peer.sid))); err != nil {
+ logger.Error("write ok:", "err", err)
+ return
+ }
+ for _, p := range Peers {
+ if p.sid == peer.sid {
+ continue
+ }
+ if _, err = io.Copy(conn, strings.NewReader(fmt.Sprintf(
+ "%s %d %s %s\n", vors.CmdAdd, p.sid, p.name, hex.EncodeToString(p.key),
+ ))); err != nil {
+ logger.Error("write ADD:", "err", err)
+ return
+ }
+ }
+ tlsState := conn.ConnectionState()
+ peer.key, err = tlsState.ExportKeyingMaterial(
+ strconv.Itoa(int(peer.sid)), nil, chacha20poly1305.KeySize)
+ if err != nil {
+ log.Fatal(err)
+ }
+ {
+ // assume atomic write
+ s := fmt.Sprintf("%s %d %s %s\n",
+ vors.CmdAdd, peer.sid, peer.name, hex.EncodeToString(peer.key))
+ for _, p := range Peers {
+ if p.sid == peer.sid {
+ continue
+ }
+ go io.Copy(p.conn, strings.NewReader(s))
+ }
+ }
+ seen := time.Now()
+ go func(seen *time.Time) {
+ for now := range time.Tick(vors.PingTime) {
+ if seen.Add(2 * vors.PingTime).Before(now) {
+ logger.Error("timeout:", "seen", seen)
+ conn.Close()
+ break
+ }
+ }
+ }(&seen)
+ go func(stats *Stats) {
+ if *NoGUI {
+ return
+ }
+ tick := time.Tick(vors.ScreenRefresh)
+ var now time.Time
+ var v *gocui.View
+ for {
+ select {
+ case <-stats.dead:
+ GUI.DeleteView(peer.name)
+ return
+ case now = <-tick:
+ s := fmt.Sprintf(
+ "Rx/Tx: %s / %s | %s / %s",
+ humanize.Comma(stats.pktsRx),
+ humanize.Comma(stats.pktsTx),
+ humanize.IBytes(stats.bytesRx),
+ humanize.IBytes(stats.bytesTx),
+ )
+ if stats.last.Add(time.Second).After(now) {
+ s += " | " + vors.CGreen + "TALK" + vors.CReset
+ }
+ v, err = GUI.View(peer.name)
+ if err == nil {
+ v.Clear()
+ v.Write([]byte(s))
+ }
+ }
+ }
+ }(peer.stats)
+ for scanner.Scan() {
+ if scanner.Text() == vors.CmdPing {
+ if _, err = io.Copy(conn,
+ strings.NewReader(vors.CmdPong+"\n")); err != nil {
+ logger.Error("write ok:", "err", err)
+ return
+ }
+ seen = time.Now()
+ }
+ }
+ if scanner.Err() != nil {
+ logger.Error(scanner.Err().Error())
+ }
+ }
+}
+
+func main() {
+ bind := flag.String("bind", "[::1]:12345", "TCP/UDP port to listen on")
+ pemFile := flag.String("pem", "keypair.pem", "PEM with keypair")
+ flag.Parse()
+ log.SetFlags(log.Lmicroseconds | log.Lshortfile)
+ if *Passwd == "" {
+ log.Fatal("no -passwd specified")
+ }
+ if err := parsePEM(*pemFile); err != nil {
+ log.Fatal(err)
+ }
+
+ addrTCP, err := net.ResolveTCPAddr("tcp", *bind)
+ if err != nil {
+ log.Fatal(err)
+ }
+ addrUDP, err := net.ResolveUDPAddr("udp", *bind)
+ if err != nil {
+ log.Fatal(err)
+ }
+ lnTCP, err := net.ListenTCP("tcp", addrTCP)
+ if err != nil {
+ log.Fatal(err)
+ }
+ lnUDP, err := net.ListenUDP("udp", addrUDP)
+ if err != nil {
+ log.Fatal(err)
+ }
+
+ LoggerReady := make(chan struct{})
+ if *NoGUI {
+ close(GUIReadyC)
+ slog.SetDefault(slog.New(slog.NewTextHandler(os.Stderr, nil)))
+ close(LoggerReady)
+ } else {
+ GUI, err = gocui.NewGui(gocui.OutputNormal)
+ if err != nil {
+ log.Fatal(err)
+ }
+ defer GUI.Close()
+ GUI.SetManagerFunc(guiLayout)
+ if err := GUI.SetKeybinding("", gocui.KeyF10, gocui.ModNone, guiQuit); err != nil {
+ log.Fatal(err)
+ }
+
+ go func() {
+ <-GUIReadyC
+ v, err := GUI.View("logs")
+ if err != nil {
+ log.Fatal(err)
+ }
+ slog.SetDefault(slog.New(slog.NewTextHandler(v, nil)))
+ close(LoggerReady)
+ for {
+ time.Sleep(vors.ScreenRefresh)
+ GUI.Update(func(gui *gocui.Gui) error {
+ return nil
+ })
+ }
+ }()
+ }
+
+ go func() {
+ <-LoggerReady
+ buf := make([]byte, 2*vors.FrameLen)
+ var n int
+ var from *net.UDPAddr
+ var err error
+ var sid byte
+ var peer *Peer
+ for {
+ n, from, err = lnUDP.ReadFromUDP(buf)
+ if err != nil {
+ log.Fatalln("recvfrom:", err)
+ }
+ sid = buf[0]
+ peer = Peers[sid]
+ if peer == nil {
+ slog.Info("unknown:", "sid", sid, "from", from)
+ continue
+ }
+ if from.Port != peer.addr.Port || !from.IP.Equal(peer.addr.IP) {
+ slog.Info("wrong addr:",
+ "peer", peer.name,
+ "our", peer.addr,
+ "got", from)
+ continue
+ }
+ peer.stats.pktsRx++
+ peer.stats.bytesRx += uint64(n)
+ if n == 1 {
+ continue
+ }
+ peer.stats.last = time.Now()
+ for _, p := range Peers {
+ if p.sid == sid {
+ continue
+ }
+ p.stats.pktsTx++
+ p.stats.bytesTx += uint64(n)
+ if _, err = lnUDP.WriteToUDP(buf[:n], p.addr); err != nil {
+ slog.Warn("sendto:", "peer", peer.name, "err", err)
+ }
+ }
+ }
+ }()
+
+ go func() {
+ <-LoggerReady
+ slog.Info("listening", "bind", *bind, "spki", SPKI)
+ for {
+ conn, err := lnTCP.Accept()
+ if err != nil {
+ log.Fatalln("accept:", err)
+ }
+ go newPeer(conn)
+ }
+ }()
+
+ if *NoGUI {
+ dummy := make(chan struct{})
+ <-dummy
+ } else {
+ err = GUI.MainLoop()
+ if err != nil && err != gocui.ErrQuit {
+ log.Fatal(err)
+ }
+ }
+}
--- /dev/null
+package main
+
+import "time"
+
+type Stats struct {
+ pktsRx int64
+ pktsTx int64
+ bytesRx uint64
+ bytesTx uint64
+ last time.Time
+ dead chan struct{}
+}
--- /dev/null
+// VoRS -- Vo(IP) Really Simple
+// Copyright (C) 2024 Sergey Matveev <stargrave@stargrave.org>
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as
+// published by the Free Software Foundation, version 3 of the License.
+//
+// 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 <http://www.gnu.org/licenses/>.
+
+package main
+
+import (
+ "crypto/tls"
+ "crypto/x509"
+ "encoding/pem"
+ "os"
+
+ vors "go.stargrave.org/vors/internal"
+)
+
+func parsePEM(pth string) error {
+ data, err := os.ReadFile(pth)
+ if err != nil {
+ return err
+ }
+ cert := tls.Certificate{}
+ var b *pem.Block
+ for len(data) > 0 {
+ b, data = pem.Decode(data)
+ if b == nil {
+ continue
+ }
+ switch b.Type {
+ case "CERTIFICATE":
+ cert.Certificate = append(cert.Certificate, b.Bytes)
+ cer, err := x509.ParseCertificate(b.Bytes)
+ if err != nil {
+ return err
+ }
+ SPKI = vors.SPKIHash(cer)
+ case "PRIVATE KEY":
+ prv, err := x509.ParsePKCS8PrivateKey(b.Bytes)
+ if err != nil {
+ return err
+ }
+ cert.PrivateKey = prv
+ }
+ }
+ TLSCfg.Certificates = append(TLSCfg.Certificates, cert)
+ return nil
+}
--- /dev/null
+// VoRS -- Vo(IP) Really Simple
+// Copyright (C) 2024 Sergey Matveev <stargrave@stargrave.org>
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as
+// published by the Free Software Foundation, version 3 of the License.
+//
+// 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 <http://www.gnu.org/licenses/>.
+
+package main
+
+import (
+ "io"
+ "os"
+ "strconv"
+
+ vors "go.stargrave.org/vors/internal"
+)
+
+func main() {
+ thres, err := strconv.ParseUint(os.Args[1], 10, 64)
+ if err != nil {
+ panic(err)
+ }
+ buf := make([]byte, 2*vors.FrameLen)
+ pcm := make([]int16, vors.FrameLen)
+ var rms uint64
+ var i int
+ for {
+ _, err = io.ReadFull(os.Stdin, buf)
+ if err != nil {
+ panic(err)
+ }
+ for i = 0; i < vors.FrameLen; i++ {
+ pcm[i] = int16(uint16(buf[i*2+0]) | (uint16(buf[i*2+1]) << 8))
+ }
+ rms = vors.RMS(pcm)
+ if rms > thres {
+ println(rms)
+ }
+ }
+}
--- /dev/null
+/vors.info
--- /dev/null
+\input texinfo
+@settitle VoRS
+
+@copying
+Copyright @copyright{} 2024 @email{stargrave@@stargrave.org, Sergey Matveev}
+@end copying
+
+@node Top
+@top VoRS
+
+VoRS -- Vo(IP) Really Simple.
+Very simple and usable multi-user VoIP solution.
+Some kind of alternative to @url{https://www.mumble.info/, Mumble}.
+
+@float
+@image{screenshots/example,,,Server and 2 clients,.webp}
+@caption{Server and two clients}
+@end float
+
+But why? SIP-based solutions are pretty complicated to setup, because
+they are not for simple tasks like sudden voice chats between a few
+people. WebRTC-based solutions are insane bloated incredible monsters
+by complexity and size, hardly possible to debug and having frequent
+compatibility problems. They work mainly only if you use the same kind
+of software and codecs, for example Chromium, that requires dozens of
+gigabytes of disk space and much RAM, CPU time to build it. Is not it
+pure insanity for that relatively simple task?
+
+Mumble has wonderful simplicity and workability, but even its server
+side is still written on Qt, that requires hundreds of megabytes of
+additional libraries to build it up. And users tend to complain about
+its newer client versions quality and convenience.
+
+So let's write as simple VoIP talking client as it is possible, without
+compromising convenience and simplicity for user! I just want a simple
+command, which I can specify server's address and just immediately talk
+with someone.
+
+@itemize
+
+@item No GUI requirement. Why would someone need it for voice
+application? But fancy real-time refreshing TUI would be desirable.
+Mumble tends to output no information, sometimes hiding the fact of a
+problem and that everything stopped working.
+
+@item No NAT-traversal possibility. Its 2024 year already, stop trying
+to use and revive legacy obsolete IPv4. Or use some overlay network on
+top of it, VPN. Just stop using that piece of shit with all complexities
+it brings you to.
+
+@item Mono-cypher, mono-codec protocol. @url{https://opus-codec.org/, Opus}
+audio codec is perfect for VoIP tasks. ChaCha20-Poly1305 is more than
+appropriate and satisfiable as fast and secure encryption solution.
+
+@end itemize
+
+Current biggest drawback is lack of audio mixing on the server side.
+Each client's voice traffic is just copied by server to every other
+client. Hopefully that is temporary solution.
+
+@include install.texi
+@include usage.texi
+@include vad.texi
+@include proto.texi
+
+@bye
--- /dev/null
+@node Install
+@unnumbered Install
+
+VoRS is written on @url{https://go.dev/, Go}, but depends on
+@url{https://github.com/hraban/opus, gopkg.in/hraban/opus.v2}
+library, that links it with C-written @code{libopus} library.
+So you will need its development headers.
+
+@example
+$ git clone git://git.stargrave.org/vors.git
+$ cd vors
+$ ./mk-bin
+$ cp bin/vors-* $PATH/bin
+@end example
+
+Audio recording and playback is done through external utilities, capable
+of reading/writing raw audio samples from stdin/stdout.
+@url{https://sourceforge.net/projects/sox/, SoX}'es @command{rec} and
+@command{play} are used by default. You can use anything you want by
+overriding them with @option{-rec} and @option{-play} options to
+@command{vors-client}.
--- /dev/null
+#!/bin/sh -e
+
+makeinfo \
+ --set-customization-variable SECTION_NAME_IN_TITLE=1 \
+ --set-customization-variable TREE_TRANSFORMATIONS=complete_tree_nodes_menus \
+ --set-customization-variable ASCII_PUNCTUATION=1 \
+ --output vors.info index.texi
--- /dev/null
+@node Protocol
+@unnumbered Protocol
+
+VoRS uses Opus codec with 20ms frames with 48kHz 1ch 16-bit S-LE sound.
+It uses native @code{libopus}'es Packet Loss Concealment (PLC) feature
+if number of lost frame does not excess 32 count.
+
+Each frame has single byte stream identifier (unique identifier of the
+participant) and 24-bit big-endian packet counter. Reordered packets are
+dropped. 24-bit counter is long enough for very long talk sessions.
+
+Each packet is encrypted with ChaCha20-Poly1305. Key is generated during
+handshake procedure with the server and is shared among other participants.
+Packet counter is used as a nonce. Stream identifier is additional
+authenticated data.
+
+It is tuned for 32Kbps bandwidth. 24Kbps should be enough, but 40B of
+IPv6 header, +16B of Poly1305 authentication tag, +4B of stream
+identifier with the counter, +8B of UDP header for 50pps means ~28Kbps
+of bandwidth only for overhead transmission.
+
+Each client handshakes with the server over TCP protocol using TLS 1.3
+with curve25519 key-agreement protocol. @command{vors-keygen} generates
+ed25519-based certificates -- so everything here is nearly completely
+NIST-free.
+
+After TLS session is established, simple text-based protocol is run:
+
+@example
+TLS 1.3:
+ S <- C : ClientHello
+ S -> C : ServerHello+ServerFinished
+ S <- C : ClientFinished
+
+S -> C : HEX(128-bit random CHALLENGE)
+S <- C : HEX(BLAKE2s-256(PASSWORD, CHALLENGE)) USERNAME
+S -> C : OK SID
+
+S <- C : PING
+S -> C : PONG
+S <> C : ...
+
+S -> C : ADD SID USERNAME HEX(KEY)
+S -> C : ...
+
+S -> C : DEL SID
+S -> C : ...
+@end example
+
+Client is authenticated by hashing the challenge with keyed hash. Every
+ten seconds it PINGs server, awaiting for PONG in return. Server may
+acknowledge client about new peer appearing, sending its SID (stream
+identifier) in ASCII decimal form, username and encryption key. Also it
+may notify about peer disappearing.
+
+If client did not get @code{OK SID} reply, then it disconnects.
+@code{SID} is our stream identifier. When we are successfully
+authenticated, we both derive our encryption key for UDP packets by
+"exporting keying material" (EKM) from TLS session context.
+
+Every second client sends UDP packet with his single-byte stream
+identifier, even if it is muted. That may help punching holes in
+stateful firewalls.
--- /dev/null
+@node Usage
+@unnumbered Usage
+
+Server is required to authenticate clients, give them unique stream
+numbers and relay their voice traffic. Except for address to bind to, it
+requires only password and keypair specification. Clients authenticate
+server by its X.509 certificate's SubjectPublicKeyInfo's SHA2-256 hash.
+Clients are authenticate by challenge-response protocol based on
+provided password.
+
+Generate server's keypair with @command{vors-keygen} and run the server.
+Its SPKI hash will also be printed in the logs.
+
+@example
+$ umask 077
+$ vors-keygen > keypair.pem
+$ vors-server -bind "[2001:db8::1234]:12345" -passwd PASSWORD -pem keypair.pem
+@end example
+
+Client uses external commands for reading from microphone and playing it
+back. By default it uses SoX'es @command{rec} and @command{play}
+commands. Pay attention that VoRS expects @strong{ONLY} one channel,
+48kHz, 16-bit signed little-endian audio format. Empty strings in
+@option{-rec}/@option{-play} options mean no recording/playback attempts.
+
+@command{-play} command is spawned for each participant. Your OS should
+mix their output together.
+
+Why no audio libraries solutions? OpenAL, PulseAudio, PortAudio,
+PipeWire, OSS, sndio, libao, JACK. Too much to choose from. None of them
+present by default in every distribution. All of them have problems,
+issues, and libao offers only playback capability for example. And pay
+attention that we have to use them from Go. Luckily SoX can use any of
+OS'es backend and we can use it transparently. And we do not have to
+create complex interface to configure in/out audio resources.
+
+Start the client, providing server's SPKI hash, password and our username:
+
+@example
+$ vors-client -spki SPKI -passwd PASSWORD -name NAME \
+ -srv "[2001:db8::1234]:12345"
+@end example
+
+Pressing F10 in server/client TUIs means quitting. Pressing Enter in
+client means "mute" toggling.
--- /dev/null
+@node VAD
+@unnumbered VAD
+
+Voice Activity Detection is off by default. You can use
+@command{vors-vad THRES} command with feeding audio record in its stdin.
+It will print calculated sound RMS value if it exceeds the
+@option{THRES} threshold. So you can manually try various @option{THRES}
+values to see when it is comfortable to detect your voice. Pass that
+desired @option{THRES} value to @option{-vad} option of
+@command{vors-client}.
+
+@example
+$ rec [...] | vors-vad 100
+[talk and see if threshold is low/high enough]
+[it is too sensible, let's try higher one]
+$ rec [...] | vors-vad 200
+[perfect!]
+$ vors-client -vad 200 [...]
+@end example
--- /dev/null
+module go.stargrave.org/vors
+
+go 1.22.2
+
+require (
+ github.com/dustin/go-humanize v1.0.1
+ github.com/jroimartin/gocui v0.5.0
+ golang.org/x/term v0.19.0
+ gopkg.in/hraban/opus.v2 v2.0.0-20230925203106-0188a62cb302
+)
+
+require (
+ github.com/mattn/go-runewidth v0.0.9 // indirect
+ github.com/nsf/termbox-go v1.1.1 // indirect
+)
+
+require (
+ golang.org/x/crypto v0.22.0
+ golang.org/x/sys v0.19.0 // indirect
+)
--- /dev/null
+github.com/dustin/go-humanize v1.0.1 h1:GzkhY7T5VNhEkwH0PVJgjz+fX1rhBrR7pRT3mDkpeCY=
+github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+mFykh5fBlto=
+github.com/jroimartin/gocui v0.5.0 h1:DCZc97zY9dMnHXJSJLLmx9VqiEnAj0yh0eTNpuEtG/4=
+github.com/jroimartin/gocui v0.5.0/go.mod h1:l7Hz8DoYoL6NoYnlnaX6XCNR62G7J5FfSW5jEogzaxE=
+github.com/mattn/go-runewidth v0.0.9 h1:Lm995f3rfxdpd6TSmuVCHVb/QhupuXlYr8sCI/QdE+0=
+github.com/mattn/go-runewidth v0.0.9/go.mod h1:H031xJmbD/WCDINGzjvQ9THkh0rPKHF+m2gUSrubnMI=
+github.com/nsf/termbox-go v1.1.1 h1:nksUPLCb73Q++DwbYUBEglYBRPZyoXJdrj5L+TkjyZY=
+github.com/nsf/termbox-go v1.1.1/go.mod h1:T0cTdVuOwf7pHQNtfhnEbzHbcNyCEcVU4YPpouCbVxo=
+golang.org/x/crypto v0.22.0 h1:g1v0xeRhjcugydODzvb3mEM9SQ0HGp9s/nh3COQ/C30=
+golang.org/x/crypto v0.22.0/go.mod h1:vr6Su+7cTlO45qkww3VDJlzDn0ctJvRgYbC2NvXHt+M=
+golang.org/x/sys v0.19.0 h1:q5f1RH2jigJ1MoAWp2KTp3gm5zAGFUTarQZ5U386+4o=
+golang.org/x/sys v0.19.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/term v0.19.0 h1:+ThwsDv+tYfnJFhF4L8jITxu1tdTWRTZpdsWgEgjL6Q=
+golang.org/x/term v0.19.0/go.mod h1:2CuTdWZ7KHSQwUzKva0cbMg6q2DMI3Mmxp+gKJbskEk=
+gopkg.in/hraban/opus.v2 v2.0.0-20230925203106-0188a62cb302 h1:xeVptzkP8BuJhoIjNizd2bRHfq9KB9HfOLZu90T04XM=
+gopkg.in/hraban/opus.v2 v2.0.0-20230925203106-0188a62cb302/go.mod h1:/L5E7a21VWl8DeuCPKxQBdVG5cy+L0MRZ08B1wnqt7g=
--- /dev/null
+package internal
+
+import (
+ "bytes"
+
+ "golang.org/x/term"
+)
+
+var (
+ CGreen string
+ CRed string
+ CReset string
+)
+
+func init() {
+ var b bytes.Buffer
+ t := term.NewTerminal(&b, "")
+ CGreen = string(t.Escape.Green)
+ CRed = string(t.Escape.Red)
+ CReset = string(t.Escape.Reset)
+}
--- /dev/null
+package internal
+
+import "math"
+
+func RMS(pcm []int16) uint64 {
+ var vol uint64
+ for _, s := range pcm {
+ vol += uint64(int64(s) * int64(s))
+ }
+ return uint64(math.Sqrt(float64(vol) / float64(len(pcm))))
+}
--- /dev/null
+package internal
+
+import "time"
+
+const (
+ Rate = 48000
+ FrameMs = 20
+ Bitrate = 32000
+ FrameLen = FrameMs * Rate / 1000
+
+ CN = "vors"
+ MaxLost = 32
+
+ CmdPing = "PING"
+ CmdPong = "PONG"
+ CmdAdd = "ADD"
+ CmdDel = "DEL"
+)
+
+var (
+ PingTime = 10 * time.Second
+ ScreenRefresh = 200 * time.Millisecond
+)
--- /dev/null
+package internal
+
+import (
+ "crypto/sha256"
+ "crypto/x509"
+ "encoding/hex"
+)
+
+func SPKIHash(c *x509.Certificate) string {
+ spki := c.RawSubjectPublicKeyInfo
+ hsh := sha256.Sum256(spki)
+ return hex.EncodeToString(hsh[:])
+}
--- /dev/null
+#!/bin/sh -e
+
+mkdir -p bin
+[ -d vendor ] && $vendor="-mod=vendor"
+strip=-ldflags=-s
+go build -C cmd/vad $strip $vendor $@ -o ../../bin/vors-vad
+go build -C cmd/keygen $strip $vendor $@ -o ../../bin/vors-keygen
+go build -C cmd/server $strip $vendor $@ -o ../../bin/vors-server
+go build -C cmd/client -tags nolibopusfile $strip $vendor $@ -o ../../bin/vors-client