diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..0e79ab9 --- /dev/null +++ b/.gitignore @@ -0,0 +1,33 @@ +# If you prefer the allow list template instead of the deny list, see community template: +# https://github.com/github/gitignore/blob/main/community/Golang/Go.AllowList.gitignore +# +# Binaries for programs and plugins +*.exe +*.exe~ +*.dll +*.so +*.dylib + +# Test binary, built with `go test -c` +*.test + +# Output of the go coverage tool, specifically when used with LiteIDE +*.out + +# Dependency directories (remove the comment below to include it) +# vendor/ + +# Go workspace file +go.work +go.work.sum + +# env file +.env + +auth.cred + +/config.toml +/db +/resources + +/.idea diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..f288702 --- /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/README.md b/README.md new file mode 100644 index 0000000..4e5deb7 --- /dev/null +++ b/README.md @@ -0,0 +1,29 @@ +# idou + +A server tool that allows to you join any external server from friend list. + +I heard a rumor that a world allows to connect external servers are no longer usable since 1.21.20, so I made one. +1.21.20 でコンソールなどで特集サーバー以外に接続するワールドが使えなくなった, という噂を聞いたので作ってみました. とても適当です. + +This server/tool can be hosted just like opening a world, with no port forwarding required to other players to join. +このサーバー/ツールは手軽にワールドを開く感覚で, ポート開放不要で使用できます. + +Compared to other methods (like DNS forwarding), You can just add a friend, and that's it. +従来の方法 (DNSなど) に比べて, フレンドを追加するだけで大丈夫です. + +## 使い方 / How to use +If you have Go installed on your device, you can run ``go install github.com/lactyy/idou@latest``, then run ``idou`` from command-line. + +If you haven't installed Go on your device, you can download an executable from Releases tab, then run ``./idou``. + +The location where you ran the command will be the data folder, which contains a database for remembering servers which players has added, and an auth.cred file that stores your credentials. + +## 警告 / Warning +Your IP addresses will be broadcasted to the players connecting to the world via signaling. It is highly recommended to host this server on a separated network. + +Please use a separate account for hosting this, to avoid getting flagged. + +## Credits +Thanks to the authors of [df-mc/nethernet-spec](https://github.com/df-mc/nethernet-spec) to writing the specification. + +A huge thanks to Da1z981 for joining the debugging, and the community for helping. \ No newline at end of file diff --git a/catalog.go b/catalog.go new file mode 100644 index 0000000..77d12eb --- /dev/null +++ b/catalog.go @@ -0,0 +1,102 @@ +package main + +import ( + "fmt" + "golang.org/x/text/language" + "golang.org/x/text/message" +) + +// TODO: Implement reading catalog from JSON files + +func init() { + for tag, dictionary := range map[language.Tag]map[string]string{ + language.English: { + "menu.title": "Menu", + + "item.menu": "Open Menu", + + "menu.add.title": "Add a server", + "menu.add.button": "Add a server", + "menu.add.alreadyExists": "§cThis server has already been added.", + "menu.add.success": "§aThe server has been added.", + + "menu.remove.title": "Remove a server", + "menu.remove.button": "Remove a server", + "menu.remove.success": "§cThe server has been removed.", + + "menu.connect.title": "Connect to a server", + "menu.connect.button": "Connect to a server", + "menu.connect.remember.text": "Remember this server", + + "menu.settings.title": "Settings", + "menu.settings.button": "Settings", + + "server.button.text": "%s", + "server.button.text.named": "%s (%s)", + "server.address.text": "Server Address", + "server.address.placeholder": "Address or address:port", + "server.name.text": "Server Name (Optional)", + + "server.error.resolve": "§cError resolving server address: %s", + "server.error.limit": "§cYou can add up to %d servers.", + + "command.language.error.parse": "§cError parsing language: %s", + + "language.unsupported": "§cUnsupported language: %s", + "language.changed": "§aThe language has been changed to %s.", + "language.auto": "§aWe have set your language to %s, based on your game language. You can change your language by opening settings.", + + "menu.language.title": "Change language", + "menu.language.button": "Change language", + "menu.language.dropdown.text": "Please select a language:", + "menu.language.dropdown.option": "%s (%s)", + }, + language.Japanese: { + "menu.title": "メニュー", + + "item.menu": "メニューを開く", + + "menu.add.title": "サーバーを追加", + "menu.add.button": "サーバーを追加", + "menu.add.alreadyExists": "§cこのサーバーは既に追加されています.", + "menu.add.success": "§aサーバーが追加されました.", + + "menu.remove.title": "サーバーを削除", + "menu.remove.button": "サーバーを削除", + "menu.remove.success": "§cサーバーが削除されました.", + + "menu.connect.title": "サーバーに接続", + "menu.connect.button": "サーバーに接続", + "menu.connect.remember.text": "このサーバーを記憶する", + + "menu.settings.title": "設定", + "menu.settings.button": "設定", + + "server.button.text": "%s", + "server.button.text.named": "%s (%s)", + "server.address.text": "サーバーのアドレス", + "server.address.placeholder": "アドレス, または アドレス:ポート", + "server.name.text": "サーバーの名前 (省略可)", + + "server.error.resolve": "§cサーバーアドレスを解決できませんでした: %s", + "server.error.limit": "§c追加できるサーバーは最大 %d 個までです.", + + "command.language.error.parse": "§c無効な言語です: %s", + + "language.unsupported": "§cサポートされていない言語です: %s", + "language.changed": "§a言語を %s に変更しました.", + "language.auto": "§aゲーム内の言語に基づいて, 言語を %s に変更しました. メニューから設定を開くことで, 言語を変更できます.", + + "menu.language.title": "言語を変更", + "menu.language.button": "言語を変更", + "menu.language.dropdown.text": "言語を選択してください:", + "menu.language.dropdown.option": "%s (%s)", + }, + } { + for key, msg := range dictionary { + if err := message.SetString(tag, key, msg); err != nil { + panic(fmt.Sprintf("%s: error registering catalog message: %q (%q)", tag, key, msg)) + } + } + } +} diff --git a/command.go b/command.go new file mode 100644 index 0000000..c5ee3cf --- /dev/null +++ b/command.go @@ -0,0 +1,10 @@ +package main + +import ( + "github.com/df-mc/dragonfly/server/cmd" +) + +func init() { + cmd.Register(cmd.New("transfer", "Transfers you to a server", nil, transferCommand{})) + cmd.Register(cmd.New("settings", "Change settings", nil, settingsCommand{}, languageCommand{})) +} diff --git a/command_language.go b/command_language.go new file mode 100644 index 0000000..1b4f962 --- /dev/null +++ b/command_language.go @@ -0,0 +1,69 @@ +package main + +import ( + "github.com/df-mc/dragonfly/server/cmd" + "github.com/df-mc/dragonfly/server/player" + "golang.org/x/text/language" + "golang.org/x/text/language/display" + "golang.org/x/text/message" + "slices" +) + +type languageCommand struct { + Sub cmd.SubCommand `cmd:"language"` + + Value cmd.Optional[supportedLanguage] `cmd:"value"` +} + +func (c languageCommand) Run(src cmd.Source, o *cmd.Output) { + p := src.(*player.Player) + v, _ := handlers.Load(p.UUID()) + h := v.(*handler) + m := h.m.Load() + + if value, ok := c.Value.Load(); ok { + tag, err := language.Parse(string(value)) + if err != nil { + o.Error(m.Sprintf("command.language.error.parse", err)) + return + } + if !slices.Contains(message.DefaultCatalog.Languages(), tag) { + o.Error(m.Sprintf("language.unsupported", display.Self.Name(tag))) + return + } + h.m.Store(message.NewPrinter(tag)) + + prof := h.prof.Load() + prof.Language = tag + h.prof.Store(prof) + + o.Printf(h.m.Load().Sprintf("language.changed", display.Self.Name(tag))) + } else { + p.SendForm(newLanguageForm(m, h.prof.Load())) + } +} + +func (c languageCommand) Allow(src cmd.Source) bool { + p, ok := src.(*player.Player) + if !ok { + o := new(cmd.Output) + o.Errorf("This command can only be executed from in-game.") + src.SendCommandOutput(o) + return false + } + _, ok = handlers.Load(p.UUID()) + return ok +} + +type supportedLanguage string + +func (supportedLanguage) Type() string { return "language" } + +func (e supportedLanguage) Options(cmd.Source) []string { + supported := message.DefaultCatalog.Languages() + s := make([]string, len(supported)) + for i, tag := range supported { + s[i] = tag.String() + } + return s +} diff --git a/command_settings.go b/command_settings.go new file mode 100644 index 0000000..b18a7b5 --- /dev/null +++ b/command_settings.go @@ -0,0 +1,22 @@ +package main + +import ( + "github.com/df-mc/dragonfly/server/cmd" + "github.com/df-mc/dragonfly/server/player" +) + +type settingsCommand struct{} + +func (c settingsCommand) Run(src cmd.Source, o *cmd.Output) { + p, ok := src.(*player.Player) + if !ok { + return + } + v, ok := handlers.Load(p.UUID()) + if !ok { + return + } + h := v.(*handler) + + p.SendForm(newSettingsForm(h.m.Load(), h.prof.Load())) +} diff --git a/command_transfer.go b/command_transfer.go new file mode 100644 index 0000000..984251c --- /dev/null +++ b/command_transfer.go @@ -0,0 +1,70 @@ +package main + +import ( + "fmt" + "github.com/df-mc/dragonfly/server/cmd" + "github.com/df-mc/dragonfly/server/player" + "net" + "reflect" +) + +type transferCommand struct { + Address rememberedAddress `cmd:"address"` +} + +func (c transferCommand) Run(src cmd.Source, o *cmd.Output) { + p := src.(*player.Player) + v, _ := handlers.Load(p.UUID()) + h := v.(*handler) + m := h.m.Load() + + if err := p.Transfer(addressWithPort(string(c.Address))); err != nil { + o.Errorf(m.Sprintf("server.error.resolve", err)) + } +} + +func (c transferCommand) Allow(src cmd.Source) bool { + p, ok := src.(*player.Player) + if !ok { + o := new(cmd.Output) + o.Errorf("This command can only be executed from in-game.") + src.SendCommandOutput(o) + return false + } + _, ok = handlers.Load(p.UUID()) + return ok +} + +type rememberedAddress string + +func (rememberedAddress) Type() string { return "address" } + +func (param rememberedAddress) Parse(line *cmd.Line, v reflect.Value) error { + arg, ok := line.Next() + if !ok { + return cmd.ErrInsufficientArgs + } + if _, _, err := net.SplitHostPort(addressWithPort(arg)); err != nil { + return fmt.Errorf("unable to parse server address: %w", err) + } + v.SetString(arg) + return nil +} + +func (param rememberedAddress) Options(src cmd.Source) []string { + p, ok := src.(*player.Player) + if !ok { + return nil + } + v, ok := handlers.Load(p.UUID()) + if !ok { + return nil + } + h := v.(*handler) + servers := h.prof.Load().Servers + s := make([]string, len(servers)) + for i, server := range servers { + s[i] = server.Address.String() + } + return s +} diff --git a/form_add.go b/form_add.go new file mode 100644 index 0000000..7799fbb --- /dev/null +++ b/form_add.go @@ -0,0 +1,70 @@ +package main + +import ( + "github.com/df-mc/dragonfly/server/player" + "github.com/df-mc/dragonfly/server/player/form" + "golang.org/x/text/message" + "net" +) + +func newAddForm(p *message.Printer) form.Form { + return form.New(addForm{ + Address: form.NewInput( + p.Sprintf("server.address.text"), + "", + p.Sprintf("server.address.placeholder"), + ), + Name: form.NewInput( + p.Sprintf("server.name.text"), + "", + "", + ), + + m: p, + }, p.Sprintf("menu.add.title")) +} + +type addForm struct { + Address form.Input + Name form.Input + + m *message.Printer +} + +func (f addForm) Submit(s form.Submitter) { + p, ok := s.(*player.Player) + if !ok { + return + } + if address := f.Address.Value(); address != "" { + address = addressWithPort(address) + addr, err := net.ResolveUDPAddr("udp", address) + if err != nil { + p.Message(f.m.Sprintf("server.error.resolve", err)) + return + } + + v, ok := handlers.Load(p.UUID()) + if !ok { + return + } + h := v.(*handler) + + prof := h.prof.Load() + if len(prof.Servers) >= 20 { + h.p.Message(f.m.Sprintf("server.error.limit", 20)) + return + } + if prof.shouldRemember(addr, address) { + prof.Servers = append(prof.Servers, serverProfile{ + Name: serverProfileName(f.Name.Value()), + Address: addr, + RawAddress: address, + }) + h.prof.Store(prof) + h.p.Message(f.m.Sprintf("menu.add.success")) + } else { + h.p.Message(f.m.Sprintf("menu.add.alreadyExists")) + } + } +} diff --git a/form_connect.go b/form_connect.go new file mode 100644 index 0000000..a1afbc2 --- /dev/null +++ b/form_connect.go @@ -0,0 +1,74 @@ +package main + +import ( + "github.com/df-mc/dragonfly/server/player" + "github.com/df-mc/dragonfly/server/player/form" + "golang.org/x/text/message" + "net" +) + +func newConnectForm(p *message.Printer) form.Form { + return form.New(connectForm{ + Address: form.NewInput( + p.Sprintf("server.address.text"), + "", + p.Sprintf("server.address.placeholder"), + ), + Name: form.NewInput( + p.Sprintf("server.name.text"), + "", + "", + ), + Remember: form.NewToggle( + p.Sprintf("menu.connect.remember.text"), + true, + ), + + m: p, + }, p.Sprintf("menu.connect.title")) +} + +type connectForm struct { + Address form.Input + Name form.Input + Remember form.Toggle + + m *message.Printer +} + +func (f connectForm) Submit(s form.Submitter) { + if p, ok := s.(*player.Player); ok { + if address := f.Address.Value(); address != "" { + address = addressWithPort(address) + addr, err := net.ResolveUDPAddr("udp", address) + if err != nil { + p.Message(f.m.Sprintf("server.error.resolve", err)) + return + } + if p.Transfer(address) != nil { + return + } + + if f.Remember.Value() { + v, ok := handlers.Load(p.UUID()) + if !ok { + return + } + h := v.(*handler) + + prof := h.prof.Load() + if len(prof.Servers) >= 20 { + return + } + if prof.shouldRemember(addr, address) { + prof.Servers = append(prof.Servers, serverProfile{ + Name: serverProfileName(f.Name.Value()), + Address: addr, + RawAddress: address, + }) + h.prof.Store(prof) + } + } + } + } +} diff --git a/form_language.go b/form_language.go new file mode 100644 index 0000000..3791451 --- /dev/null +++ b/form_language.go @@ -0,0 +1,57 @@ +package main + +import ( + "github.com/df-mc/dragonfly/server/player" + "github.com/df-mc/dragonfly/server/player/form" + "golang.org/x/text/language/display" + "golang.org/x/text/message" +) + +func newLanguageForm(p *message.Printer, prof profile) form.Form { + languages := message.DefaultCatalog.Languages() + dropdown := form.Dropdown{ + Text: p.Sprintf("menu.language.dropdown.text"), + Options: make([]string, len(languages)), + } + for i, tag := range languages { + if tag == prof.Language { + dropdown.DefaultIndex = i + } + dropdown.Options[i] = p.Sprintf("menu.language.dropdown.option", + display.Self.Name(tag), + display.English.Languages().Name(tag), + ) + } + return form.New(languageForm{ + Dropdown: dropdown, + }, p.Sprintf("menu.language.title")) +} + +type languageForm struct { + Dropdown form.Dropdown +} + +func (f languageForm) Submit(s form.Submitter) { + if p, ok := s.(*player.Player); ok { + v, ok := handlers.Load(p.UUID()) + if !ok { + return + } + h := v.(*handler) + prof := h.prof.Load() + + tag := message.DefaultCatalog.Languages()[f.Dropdown.Value()] + if prof.Language == tag { + return + } + + m := message.NewPrinter(tag) + h.m.Store(m) + + prof.Language = tag + h.prof.Store(prof) + h.setInventory(p, m) + + p.Message(m.Sprintf("language.changed", display.Self.Name(tag))) + } +} diff --git a/form_remove.go b/form_remove.go new file mode 100644 index 0000000..e6baacb --- /dev/null +++ b/form_remove.go @@ -0,0 +1,51 @@ +package main + +import ( + "github.com/df-mc/dragonfly/server/player" + "github.com/df-mc/dragonfly/server/player/form" + "golang.org/x/text/message" + "slices" +) + +func newRemoveForm(p *message.Printer, prof profile) form.Form { + buttons, servers := serverButtons(p, prof) + return form.NewMenu(removeForm{ + p: p, + + servers: servers, + }, p.Sprintf("menu.remove.title")).WithButtons(buttons...) +} + +type removeForm struct { + p *message.Printer + + servers map[string]serverProfile +} + +func (f removeForm) Submit(s form.Submitter, pressed form.Button) { + server, ok := f.servers[pressed.Text] + if !ok { + return + } + + p, ok := s.(*player.Player) + if !ok { + return + } + v, ok := handlers.Load(p.UUID()) + if !ok { + return + } + h := v.(*handler) + + prof := h.prof.Load() + i := slices.IndexFunc(prof.Servers, func(s serverProfile) bool { + return addressEqual(s.Address, server.Address) || s.RawAddress == server.RawAddress + }) + if i < 0 { + return + } + prof.Servers = slices.Delete(prof.Servers, i, i+1) + h.prof.Store(prof) + p.Message(f.p.Sprintf("menu.remove.success")) +} diff --git a/form_server.go b/form_server.go new file mode 100644 index 0000000..b38d7d7 --- /dev/null +++ b/form_server.go @@ -0,0 +1,92 @@ +package main + +import ( + "github.com/df-mc/dragonfly/server/player" + "github.com/df-mc/dragonfly/server/player/form" + "golang.org/x/text/message" + "net" +) + +const ( + imageConnect = "https://cdn.discordapp.com/attachments/1240581906567790632/1276169643375067200/normal.png?ex=66c88d19&is=66c73b99&hm=66a45478e69ccb336a9629b3d2a97c0fd4136d5fc822f23a942e1bfab0635ba0&" + imageAdd = "https://cdn.discordapp.com/attachments/1240581906567790632/1276169643693703269/eyes.png?ex=66c88d19&is=66c73b99&hm=1d6ec8fae2f4dc80cb82d985db9582eab85d96abb44aa80b45957b5e5978ad7f&" + imageRemove = "https://cdn.discordapp.com/attachments/1240581906567790632/1276169642829807666/nerd.png?ex=66c88d18&is=66c73b98&hm=e46585c3b856d8bc907c6b6712bce4b482c2e161a45301d998dbd95cc4af4342&" + imageSettings = "https://cdn.discordapp.com/attachments/1240581906567790632/1276169643069018296/40e8823345030871.png?ex=66c88d18&is=66c73b98&hm=fb37af01b153c27f7bb837d56f1ea25e3b6f7a6a54ec3c0db08ccf442821798a&" +) + +func newServerForm(p *message.Printer, prof profile) form.Form { + buttons, servers := serverButtons(p, prof) + + settings := form.NewButton( + p.Sprintf("menu.settings.button"), + imageSettings, + ) + return form.NewMenu(serverForm{ + Connect: form.NewButton(p.Sprintf("menu.connect.button"), imageConnect), + Add: form.NewButton(p.Sprintf("menu.add.button"), imageAdd), + Remove: form.NewButton(p.Sprintf("menu.remove.button"), imageRemove), + + settings: settings, + + p: p, + prof: prof, + servers: servers, + }, p.Sprintf("menu.title")).WithButtons(append(buttons, settings)...) +} + +type serverForm struct { + Connect form.Button + Add form.Button + Remove form.Button + settings form.Button + + p *message.Printer + prof profile + servers map[string]serverProfile +} + +func (f serverForm) Submit(s form.Submitter, pressed form.Button) { + switch pressed.Text { + case f.Connect.Text: + s.SendForm(newConnectForm(f.p)) + case f.Add.Text: + s.SendForm(newAddForm(f.p)) + case f.Remove.Text: + s.SendForm(newRemoveForm(f.p, f.prof)) + case f.settings.Text: + s.SendForm(newSettingsForm(f.p, f.prof)) + default: + p, ok := s.(*player.Player) + if !ok { + return + } + server, ok := f.servers[pressed.Text] + if !ok { + return + } + _, err := net.ResolveUDPAddr("udp", server.RawAddress) + if err != nil { + p.Message(f.p.Sprintf("server.error.resolve", err)) + return + } + if p.Transfer(server.RawAddress) != nil { + return + } + } +} + +func serverButtons(p *message.Printer, prof profile) ([]form.Button, map[string]serverProfile) { + buttons := make([]form.Button, len(prof.Servers)) + servers := make(map[string]serverProfile, len(prof.Servers)) + for i, server := range prof.Servers { + var button form.Button + if server.Name == "" { + button.Text = p.Sprintf("server.button.text", server.RawAddress) + } else { + button.Text = p.Sprintf("server.button.text.named", server.Name, server.RawAddress) + } + servers[button.Text] = server + buttons[i] = button + } + return buttons, servers +} diff --git a/form_settings.go b/form_settings.go new file mode 100644 index 0000000..a8cc34c --- /dev/null +++ b/form_settings.go @@ -0,0 +1,32 @@ +package main + +import ( + "github.com/df-mc/dragonfly/server/player/form" + "golang.org/x/text/message" +) + +func newSettingsForm(m *message.Printer, prof profile) form.Form { + return form.NewMenu(settingsForm{ + Language: form.NewButton( + m.Sprintf("menu.language.button"), + "", + ), + + m: m, + prof: prof, + }, m.Sprintf("menu.settings.title")) +} + +type settingsForm struct { + Language form.Button + + m *message.Printer + prof profile +} + +func (f settingsForm) Submit(s form.Submitter, pressed form.Button) { + switch pressed.Text { + case f.Language.Text: + s.SendForm(newLanguageForm(f.m, f.prof)) + } +} diff --git a/go.mod b/go.mod new file mode 100644 index 0000000..2456a7c --- /dev/null +++ b/go.mod @@ -0,0 +1,63 @@ +module github.com/lactyy/idou + +go 1.22.5 + +require ( + github.com/df-mc/atomic v1.10.0 + github.com/df-mc/dragonfly v0.9.18-0.20240818101738-29a214b79bd5 + github.com/df-mc/goleveldb v1.1.9 + github.com/google/uuid v1.6.0 + github.com/pelletier/go-toml v1.9.5 + github.com/sandertv/gophertunnel v1.40.1 + github.com/sirupsen/logrus v1.9.3 + golang.org/x/oauth2 v0.21.0 + golang.org/x/text v0.17.0 +) + +require ( + github.com/brentp/intintmap v0.0.0-20190211203843-30dc0ade9af9 // indirect + github.com/cespare/xxhash/v2 v2.2.0 // indirect + github.com/df-mc/worldupgrader v1.0.16 // indirect + github.com/go-gl/mathgl v1.1.0 // indirect + github.com/go-jose/go-jose/v3 v3.0.3 // indirect + github.com/golang/snappy v0.0.4 // indirect + github.com/klauspost/compress v1.17.9 // indirect + github.com/muhammadmuzzammil1998/jsonc v1.0.0 // indirect + github.com/nxadm/tail v1.4.11 // indirect + github.com/pion/datachannel v1.5.9 // indirect + github.com/pion/dtls/v2 v2.2.12 // indirect + github.com/pion/dtls/v3 v3.0.1 // indirect + github.com/pion/ice/v3 v3.0.16 // indirect + github.com/pion/ice/v4 v4.0.1 // indirect + github.com/pion/interceptor v0.1.30 // indirect + github.com/pion/logging v0.2.2 // indirect + github.com/pion/mdns/v2 v2.0.7 // indirect + github.com/pion/randutil v0.1.0 // indirect + github.com/pion/rtcp v1.2.14 // indirect + github.com/pion/rtp v1.8.9 // indirect + github.com/pion/sctp v1.8.33 // indirect + github.com/pion/sdp/v3 v3.0.9 // indirect + github.com/pion/srtp/v3 v3.0.3 // indirect + github.com/pion/stun/v2 v2.0.0 // indirect + github.com/pion/stun/v3 v3.0.0 // indirect + github.com/pion/transport/v2 v2.2.8 // indirect + github.com/pion/transport/v3 v3.0.7 // indirect + github.com/pion/turn/v3 v3.0.3 // indirect + github.com/pion/turn/v4 v4.0.0 // indirect + github.com/pion/webrtc/v4 v4.0.0-beta.29 // indirect + github.com/rogpeppe/go-internal v1.11.0 // indirect + github.com/sandertv/go-raknet v1.14.1 // indirect + github.com/segmentio/fasthash v1.0.3 // indirect + github.com/wlynxg/anet v0.0.3 // indirect + golang.org/x/crypto v0.26.0 // indirect + golang.org/x/exp v0.0.0-20230206171751-46f607a40771 // indirect + golang.org/x/image v0.17.0 // indirect + golang.org/x/net v0.27.0 // indirect + golang.org/x/sys v0.24.0 // indirect + nhooyr.io/websocket v1.8.11 // indirect +) + +replace ( + github.com/pion/sctp => github.com/lactyy/sctp v0.0.0-20240822210319-2eae0bcbc9f3 + github.com/sandertv/gophertunnel => github.com/lactyy/gophertunnel v0.0.0-20240822203049-e4fd4152ec74 +) diff --git a/go.sum b/go.sum new file mode 100644 index 0000000..ef2321f --- /dev/null +++ b/go.sum @@ -0,0 +1,203 @@ +github.com/brentp/intintmap v0.0.0-20190211203843-30dc0ade9af9 h1:/G0ghZwrhou0Wq21qc1vXXMm/t/aKWkALWwITptKbE0= +github.com/brentp/intintmap v0.0.0-20190211203843-30dc0ade9af9/go.mod h1:TOk10ahXejq9wkEaym3KPRNeuR/h5Jx+s8QRWIa2oTM= +github.com/cespare/xxhash/v2 v2.2.0 h1:DC2CZ1Ep5Y4k3ZQ899DldepgrayRUGE6BBZ/cd9Cj44= +github.com/cespare/xxhash/v2 v2.2.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= +github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= +github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/df-mc/atomic v1.10.0 h1:0ZuxBKwR/hxcFGorKiHIp+hY7hgY+XBTzhCYD2NqSEg= +github.com/df-mc/atomic v1.10.0/go.mod h1:Gw9rf+rPIbydMjA329Jn4yjd/O2c/qusw3iNp4tFGSc= +github.com/df-mc/dragonfly v0.9.18-0.20240818101738-29a214b79bd5 h1:lqeOxA7HkyMixyDRvmf9BR/1u+UVbh6/nKugX22hFto= +github.com/df-mc/dragonfly v0.9.18-0.20240818101738-29a214b79bd5/go.mod h1:nDs4PgdB+mXFLKKNBvCSxATrS4GBEIuV7vsaXUMAvgw= +github.com/df-mc/goleveldb v1.1.9 h1:ihdosZyy5jkQKrxucTQmN90jq/2lUwQnJZjIYIC/9YU= +github.com/df-mc/goleveldb v1.1.9/go.mod h1:+NHCup03Sci5q84APIA21z3iPZCuk6m6ABtg4nANCSk= +github.com/df-mc/worldupgrader v1.0.16 h1:3n9yvLFNCe8IDJnUEliTGbhDvV1frjtPX/y5zl3Q5EE= +github.com/df-mc/worldupgrader v1.0.16/go.mod h1:tsSOLTRm9mpG7VHvYpAjjZrkRHWmSbKZAm9bOLNnlDk= +github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo= +github.com/fsnotify/fsnotify v1.6.0 h1:n+5WquG0fcWoWp6xPWfHdbskMCQaFnG6PfBrh1Ky4HY= +github.com/fsnotify/fsnotify v1.6.0/go.mod h1:sl3t1tCWJFWoRz9R8WJCbQihKKwmorjAbSClcnxKAGw= +github.com/go-gl/mathgl v1.1.0 h1:0lzZ+rntPX3/oGrDzYGdowSLC2ky8Osirvf5uAwfIEA= +github.com/go-gl/mathgl v1.1.0/go.mod h1:yhpkQzEiH9yPyxDUGzkmgScbaBVlhC06qodikEM0ZwQ= +github.com/go-jose/go-jose/v3 v3.0.3 h1:fFKWeig/irsp7XD2zBxvnmA/XaRWp5V3CBsZXJF7G7k= +github.com/go-jose/go-jose/v3 v3.0.3/go.mod h1:5b+7YgP7ZICgJDBdfjZaIt+H/9L9T/YQrVfLAMboGkQ= +github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= +github.com/golang/snappy v0.0.1/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q= +github.com/golang/snappy v0.0.4 h1:yAGX7huGHXlcLOEtBnF4w7FQwA26wojNCwOYAEhLjQM= +github.com/golang/snappy v0.0.4/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q= +github.com/google/go-cmp v0.5.9 h1:O2Tfq5qg4qc4AmwVlvv0oLiVAGB7enBSJ2x2DqQFi38= +github.com/google/go-cmp v0.5.9/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY= +github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0= +github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= +github.com/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU= +github.com/klauspost/compress v1.13.6/go.mod h1:/3/Vjq9QcHkK5uEr5lBEmyoZ1iFhe47etQ6QUkpK6sk= +github.com/klauspost/compress v1.17.9 h1:6KIumPrER1LHsvBVuDa0r5xaG0Es51mhhB9BQB2qeMA= +github.com/klauspost/compress v1.17.9/go.mod h1:Di0epgTjJY877eYKx5yC51cX2A2Vl2ibi7bDH9ttBbw= +github.com/lactyy/gophertunnel v0.0.0-20240822203049-e4fd4152ec74 h1:FgGfN4NmRJI/ppLOJRFhW0ZC/YtcLASgrb4uK9PmadY= +github.com/lactyy/gophertunnel v0.0.0-20240822203049-e4fd4152ec74/go.mod h1:FXiFeM+OwR/cfH3mmfl0fgfsqQApLfqhKcdEi2JCfbc= +github.com/lactyy/sctp v0.0.0-20240822210319-2eae0bcbc9f3 h1:Nikw9jHHbZZgeN+YugbVOldbv+0PoZVm4ZSMSGItpeU= +github.com/lactyy/sctp v0.0.0-20240822210319-2eae0bcbc9f3/go.mod h1:beTnqSzewI53KWoG3nqB282oDMGrhNxBdb+JZnkCwRM= +github.com/muhammadmuzzammil1998/jsonc v1.0.0 h1:8o5gBQn4ZA3NBA9DlTujCj2a4w0tqWrPVjDwhzkgTIs= +github.com/muhammadmuzzammil1998/jsonc v1.0.0/go.mod h1:saF2fIVw4banK0H4+/EuqfFLpRnoy5S+ECwTOCcRcSU= +github.com/nxadm/tail v1.4.11 h1:8feyoE3OzPrcshW5/MJ4sGESc5cqmGkGCWlco4l0bqY= +github.com/nxadm/tail v1.4.11/go.mod h1:OTaG3NK980DZzxbRq6lEuzgU+mug70nY11sMd4JXXHc= +github.com/onsi/ginkgo v1.6.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE= +github.com/onsi/ginkgo v1.7.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE= +github.com/onsi/ginkgo v1.16.5 h1:8xi0RTUf59SOSfEtZMvwTvXYMzG4gV23XVHOZiXNtnE= +github.com/onsi/ginkgo v1.16.5/go.mod h1:+E8gABHa3K6zRBolWtd+ROzc/U5bkGt0FwiG042wbpU= +github.com/onsi/gomega v1.4.3/go.mod h1:ex+gbHU/CVuBBDIJjb2X0qEXbFg53c61hWP/1CpauHY= +github.com/onsi/gomega v1.17.0 h1:9Luw4uT5HTjHTN8+aNcSThgH1vdXnmdJ8xIfZ4wyTRE= +github.com/onsi/gomega v1.17.0/go.mod h1:HnhC7FXeEQY45zxNK3PPoIUhzk/80Xly9PcubAlGdZY= +github.com/pelletier/go-toml v1.9.5 h1:4yBQzkHv+7BHq2PQUZF3Mx0IYxG7LsP222s7Agd3ve8= +github.com/pelletier/go-toml v1.9.5/go.mod h1:u1nR/EPcESfeI/szUZKdtJ0xRNbUoANCkoOuaOx1Y+c= +github.com/pion/datachannel v1.5.9 h1:LpIWAOYPyDrXtU+BW7X0Yt/vGtYxtXQ8ql7dFfYUVZA= +github.com/pion/datachannel v1.5.9/go.mod h1:kDUuk4CU4Uxp82NH4LQZbISULkX/HtzKa4P7ldf9izE= +github.com/pion/dtls/v2 v2.2.7/go.mod h1:8WiMkebSHFD0T+dIU+UeBaoV7kDhOW5oDCzZ7WZ/F9s= +github.com/pion/dtls/v2 v2.2.12 h1:KP7H5/c1EiVAAKUmXyCzPiQe5+bCJrpOeKg/L05dunk= +github.com/pion/dtls/v2 v2.2.12/go.mod h1:d9SYc9fch0CqK90mRk1dC7AkzzpwJj6u2GU3u+9pqFE= +github.com/pion/dtls/v3 v3.0.1 h1:0kmoaPYLAo0md/VemjcrAXQiSf8U+tuU3nDYVNpEKaw= +github.com/pion/dtls/v3 v3.0.1/go.mod h1:dfIXcFkKoujDQ+jtd8M6RgqKK3DuaUilm3YatAbGp5k= +github.com/pion/ice/v3 v3.0.16 h1:YoPlNg3jU1UT/DDTa9v/g1vH6A2/pAzehevI1o66H8E= +github.com/pion/ice/v3 v3.0.16/go.mod h1:SdmubtIsCcvdb1ZInrTUz7Iaqi90/rYd1pzbzlMxsZg= +github.com/pion/ice/v4 v4.0.1 h1:2d3tPoTR90F3TcGYeXUwucGlXI3hds96cwv4kjZmb9s= +github.com/pion/ice/v4 v4.0.1/go.mod h1:2dpakjpd7+74L5j3TAe6gvkbI5UIzOgAnkimm9SuHvA= +github.com/pion/interceptor v0.1.30 h1:au5rlVHsgmxNi+v/mjOPazbW1SHzfx7/hYOEYQnUcxA= +github.com/pion/interceptor v0.1.30/go.mod h1:RQuKT5HTdkP2Fi0cuOS5G5WNymTjzXaGF75J4k7z2nc= +github.com/pion/logging v0.2.2 h1:M9+AIj/+pxNsDfAT64+MAVgJO0rsyLnoJKCqf//DoeY= +github.com/pion/logging v0.2.2/go.mod h1:k0/tDVsRCX2Mb2ZEmTqNa7CWsQPc+YYCB7Q+5pahoms= +github.com/pion/mdns/v2 v2.0.7 h1:c9kM8ewCgjslaAmicYMFQIde2H9/lrZpjBkN8VwoVtM= +github.com/pion/mdns/v2 v2.0.7/go.mod h1:vAdSYNAT0Jy3Ru0zl2YiW3Rm/fJCwIeM0nToenfOJKA= +github.com/pion/randutil v0.1.0 h1:CFG1UdESneORglEsnimhUjf33Rwjubwj6xfiOXBa3mA= +github.com/pion/randutil v0.1.0/go.mod h1:XcJrSMMbbMRhASFVOlj/5hQial/Y8oH/HVo7TBZq+j8= +github.com/pion/rtcp v1.2.14 h1:KCkGV3vJ+4DAJmvP0vaQShsb0xkRfWkO540Gy102KyE= +github.com/pion/rtcp v1.2.14/go.mod h1:sn6qjxvnwyAkkPzPULIbVqSKI5Dv54Rv7VG0kNxh9L4= +github.com/pion/rtp v1.8.9 h1:E2HX740TZKaqdcPmf4pw6ZZuG8u5RlMMt+l3dxeu6Wk= +github.com/pion/rtp v1.8.9/go.mod h1:pBGHaFt/yW7bf1jjWAoUjpSNoDnw98KTMg+jWWvziqU= +github.com/pion/sdp/v3 v3.0.9 h1:pX++dCHoHUwq43kuwf3PyJfHlwIj4hXA7Vrifiq0IJY= +github.com/pion/sdp/v3 v3.0.9/go.mod h1:B5xmvENq5IXJimIO4zfp6LAe1fD9N+kFv+V/1lOdz8M= +github.com/pion/srtp/v3 v3.0.3 h1:tRtEOpmR8NtsB/KndlKXFOj/AIIs6aPrCq4TlAatC4M= +github.com/pion/srtp/v3 v3.0.3/go.mod h1:Bp9ztzPCoE0ETca/R+bTVTO5kBgaQMiQkTmZWwazDTc= +github.com/pion/stun/v2 v2.0.0 h1:A5+wXKLAypxQri59+tmQKVs7+l6mMM+3d+eER9ifRU0= +github.com/pion/stun/v2 v2.0.0/go.mod h1:22qRSh08fSEttYUmJZGlriq9+03jtVmXNODgLccj8GQ= +github.com/pion/stun/v3 v3.0.0 h1:4h1gwhWLWuZWOJIJR9s2ferRO+W3zA/b6ijOI6mKzUw= +github.com/pion/stun/v3 v3.0.0/go.mod h1:HvCN8txt8mwi4FBvS3EmDghW6aQJ24T+y+1TKjB5jyU= +github.com/pion/transport/v2 v2.2.1/go.mod h1:cXXWavvCnFF6McHTft3DWS9iic2Mftcz1Aq29pGcU5g= +github.com/pion/transport/v2 v2.2.4/go.mod h1:q2U/tf9FEfnSBGSW6w5Qp5PFWRLRj3NjLhCCgpRK4p0= +github.com/pion/transport/v2 v2.2.8 h1:HzsqGBChgtF4Cj47gu51l5hONuK/NwgbZL17CMSuwS0= +github.com/pion/transport/v2 v2.2.8/go.mod h1:sq1kSLWs+cHW9E+2fJP95QudkzbK7wscs8yYgQToO5E= +github.com/pion/transport/v3 v3.0.1/go.mod h1:UY7kiITrlMv7/IKgd5eTUcaahZx5oUN3l9SzK5f5xE0= +github.com/pion/transport/v3 v3.0.7 h1:iRbMH05BzSNwhILHoBoAPxoB9xQgOaJk+591KC9P1o0= +github.com/pion/transport/v3 v3.0.7/go.mod h1:YleKiTZ4vqNxVwh77Z0zytYi7rXHl7j6uPLGhhz9rwo= +github.com/pion/turn/v3 v3.0.3 h1:1e3GVk8gHZLPBA5LqadWYV60lmaKUaHCkm9DX9CkGcE= +github.com/pion/turn/v3 v3.0.3/go.mod h1:vw0Dz420q7VYAF3J4wJKzReLHIo2LGp4ev8nXQexYsc= +github.com/pion/turn/v4 v4.0.0 h1:qxplo3Rxa9Yg1xXDxxH8xaqcyGUtbHYw4QSCvmFWvhM= +github.com/pion/turn/v4 v4.0.0/go.mod h1:MuPDkm15nYSklKpN8vWJ9W2M0PlyQZqYt1McGuxG7mA= +github.com/pion/webrtc/v4 v4.0.0-beta.29 h1:ahc4r88phf+Y+7YGl20gEfIYQ/eEMzNvd8KOMtxsE1s= +github.com/pion/webrtc/v4 v4.0.0-beta.29/go.mod h1:z1oOHeVfz+XE9bpuXODxIDJw+/TUvENs34YGbQEdB+c= +github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= +github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= +github.com/rogpeppe/go-internal v1.11.0 h1:cWPaGQEPrBb5/AsnsZesgZZ9yb1OQ+GOISoDNXVBh4M= +github.com/rogpeppe/go-internal v1.11.0/go.mod h1:ddIwULY96R17DhadqLgMfk9H9tvdUzkipdSkR5nkCZA= +github.com/sandertv/go-raknet v1.14.1 h1:V2Gslo+0x4jfj+p0PM48mWxmMbYkxSlgeKy//y3ZrzI= +github.com/sandertv/go-raknet v1.14.1/go.mod h1:/yysjwfCXm2+2OY8mBazLzcxJ3irnylKCyG3FLgUPVU= +github.com/segmentio/fasthash v1.0.3 h1:EI9+KE1EwvMLBWwjpRDc+fEM+prwxDYbslddQGtrmhM= +github.com/segmentio/fasthash v1.0.3/go.mod h1:waKX8l2N8yckOgmSsXJi7x1ZfdKZ4x7KRMzBtS3oedY= +github.com/sirupsen/logrus v1.9.3 h1:dueUQJ1C2q9oE3F7wvmSGAaVtTmUizReu6fjN8uqzbQ= +github.com/sirupsen/logrus v1.9.3/go.mod h1:naHLuLoDiP4jHNo9R0sCBMtWGeIprob74mVsIT4qYEQ= +github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= +github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw= +github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo= +github.com/stretchr/objx v0.5.2/go.mod h1:FRsXN1f5AsAjCGJKqEizvkpNtU+EGNCLh3NxZ/8L+MA= +github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= +github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= +github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU= +github.com/stretchr/testify v1.8.3/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo= +github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo= +github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg= +github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY= +github.com/wlynxg/anet v0.0.3 h1:PvR53psxFXstc12jelG6f1Lv4MWqE0tI76/hHGjh9rg= +github.com/wlynxg/anet v0.0.3/go.mod h1:eay5PRQr7fIVAMbTbchTnO9gG65Hg/uYGdc7mguHxoA= +github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY= +go.uber.org/atomic v1.9.0 h1:ECmE8Bn/WFTYwEW/bpKD3M8VtR/zQVbavAoalC1PYyE= +go.uber.org/atomic v1.9.0/go.mod h1:fEN4uk6kAWBTFdckzkM89CLk9XfWZrxpCo0nPH17wJc= +golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= +golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc= +golang.org/x/crypto v0.8.0/go.mod h1:mRqEX+O9/h5TFCrQhkgjo2yKi0yYA+9ecGkdQoHrywE= +golang.org/x/crypto v0.12.0/go.mod h1:NF0Gs7EO5K4qLn+Ylc+fih8BSTeIjAP05siRnAh98yw= +golang.org/x/crypto v0.18.0/go.mod h1:R0j02AL6hcrfOiy9T4ZYp/rcWeMxM3L6QYxlOuEG1mg= +golang.org/x/crypto v0.19.0/go.mod h1:Iy9bg/ha4yyC70EfRS8jz+B6ybOBKMaSxLj6P6oBDfU= +golang.org/x/crypto v0.26.0 h1:RrRspgV4mU+YwB4FYnuBoKsUapNIL5cohGAmSH3azsw= +golang.org/x/crypto v0.26.0/go.mod h1:GY7jblb9wI+FOo5y8/S2oY4zWP07AkOJ4+jxCqdqn54= +golang.org/x/exp v0.0.0-20230206171751-46f607a40771 h1:xP7rWLUr1e1n2xkK5YB4LI0hPEy3LJC6Wk+D4pGlOJg= +golang.org/x/exp v0.0.0-20230206171751-46f607a40771/go.mod h1:CxIveKay+FTh1D0yPZemJVgC/95VzuuOLq5Qi4xnoYc= +golang.org/x/image v0.0.0-20190321063152-3fc05d484e9f/go.mod h1:kZ7UVZpmo3dzQBMxlp+ypCbDeSB+sBbTgSJuh5dn5js= +golang.org/x/image v0.17.0 h1:nTRVVdajgB8zCMZVsViyzhnMKPwYeroEERRC64JuLco= +golang.org/x/image v0.17.0/go.mod h1:4yyo5vMFQjVjUcVk4jEQcU9MGy/rulF5WvUILseCM2E= +golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4= +golang.org/x/mod v0.8.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs= +golang.org/x/net v0.0.0-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= +golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= +golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c= +golang.org/x/net v0.6.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs= +golang.org/x/net v0.9.0/go.mod h1:d48xBJpPfHeWQsugry2m+kC02ZBRGRgulfHnEXEuWns= +golang.org/x/net v0.10.0/go.mod h1:0qNGK6F8kojg2nk9dLZ2mShWaEBan6FAoqfSigmmuDg= +golang.org/x/net v0.14.0/go.mod h1:PpSgVXXLK0OxS0F31C1/tv6XNguvCrnXIDrFMspZIUI= +golang.org/x/net v0.20.0/go.mod h1:z8BVo6PvndSri0LbOE3hAn0apkU+1YvI6E70E9jsnvY= +golang.org/x/net v0.27.0 h1:5K3Njcw06/l2y9vpGCSdcxWOYHOUk3dVNGDXN+FvAys= +golang.org/x/net v0.27.0/go.mod h1:dDi0PyhWNoiUOrAS8uXv/vnScO4wnHQO4mj9fn/RytE= +golang.org/x/oauth2 v0.21.0 h1:tsimM75w1tF/uws5rbeHzIWxEqElMehnc+iW793zsZs= +golang.org/x/oauth2 v0.21.0/go.mod h1:XYTD2NtWslqkgxebSiOHnXEap4TF09sJSc7H1sXbhtI= +golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sys v0.0.0-20180909124046-d0be0721c37e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220715151400-c0bba94af5f8/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220908164124-27713097b956/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.7.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.8.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.11.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.16.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= +golang.org/x/sys v0.17.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= +golang.org/x/sys v0.24.0 h1:Twjiwq9dn6R1fQcyiK+wQyHWfaz/BJB+YIpzU/Cv3Xg= +golang.org/x/sys v0.24.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= +golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= +golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8= +golang.org/x/term v0.5.0/go.mod h1:jMB1sMXY+tzblOD4FWmEbocvup2/aLOaQEp7JmGp78k= +golang.org/x/term v0.7.0/go.mod h1:P32HKFT3hSsZrRxla30E9HqToFYAQPCMs/zFMBUFqPY= +golang.org/x/term v0.8.0/go.mod h1:xPskH00ivmX89bAKVGSKKtLOWNx2+17Eiy94tnKShWo= +golang.org/x/term v0.11.0/go.mod h1:zC9APTIj3jG3FdV/Ons+XE1riIZXG4aZ4GTHiPZJPIU= +golang.org/x/term v0.16.0/go.mod h1:yn7UURbUtPyrVJPGPq404EukNFxcm/foM+bV/bfcDsY= +golang.org/x/term v0.17.0/go.mod h1:lLRBjIVuehSbZlaOtGMbcMncT+aqLLLmKrsjNrUguwk= +golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= +golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= +golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ= +golang.org/x/text v0.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8= +golang.org/x/text v0.9.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8= +golang.org/x/text v0.12.0/go.mod h1:TvPlkZtksWOMsz7fbANvkp4WM8x/WCo/om8BMLbz+aE= +golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU= +golang.org/x/text v0.17.0 h1:XtiM5bkSOt+ewxlOE/aE/AKEHibwj/6gvWMl9Rsh0Qc= +golang.org/x/text v0.17.0/go.mod h1:BuEKDfySbSR4drPmRPG/7iBdf8hvFMuRexcpahXilzY= +golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= +golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc= +golang.org/x/tools v0.6.0/go.mod h1:Xwgl3UAJ/d3gWutnCtw505GrjyAbvKui8lOU390QaIU= +golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= +gopkg.in/fsnotify.v1 v1.4.7/go.mod h1:Tz8NjZHkW78fSQdbUxIjBTcgA1z1m8ZHf0WmKUhAMys= +gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7 h1:uRGJdciOHaEIrze2W8Q3AKkepLTh2hOroT7a+7czfdQ= +gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7/go.mod h1:dt/ZhP58zS4L8KSrWDmTeBkI65Dw0HsyUHuEVlX15mw= +gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= +gopkg.in/yaml.v2 v2.3.0 h1:clyUAQHOM3G0M3f5vQj7LuJrETvjVot3Z5el9nffUtU= +gopkg.in/yaml.v2 v2.3.0/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= +gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= +gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= +gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= +nhooyr.io/websocket v1.8.11 h1:f/qXNc2/3DpoSZkHt1DQu6rj4zGC8JmkkLkWss0MgN0= +nhooyr.io/websocket v1.8.11/go.mod h1:rN9OFWIUwuxg4fR5tELlYC04bXYowCP9GX47ivo2l+c= diff --git a/handler.go b/handler.go new file mode 100644 index 0000000..14a36b5 --- /dev/null +++ b/handler.go @@ -0,0 +1,113 @@ +package main + +import ( + atomic2 "github.com/df-mc/atomic" + "github.com/df-mc/dragonfly/server/event" + "github.com/df-mc/dragonfly/server/item" + "github.com/df-mc/dragonfly/server/player" + "github.com/df-mc/dragonfly/server/session" + "github.com/df-mc/dragonfly/server/world" + "github.com/google/uuid" + "github.com/lactyy/idou/internal" + "github.com/sandertv/gophertunnel/minecraft/protocol/packet" + "github.com/sirupsen/logrus" + "golang.org/x/text/message" + "strings" + "sync" + "sync/atomic" + _ "unsafe" +) + +type handler struct { + p *player.Player + log *logrus.Logger + + m *atomic.Pointer[message.Printer] + + prof *atomic2.Value[profile] + storer internal.Storer[uuid.UUID, profile] // Store that profile on quit + + player.NopHandler +} + +func (h *handler) setInventory(p *player.Player, m *message.Printer) { + _ = p.Inventory().SetItem( + 4, + item.NewStack( + compass{}, + 1, + ).WithCustomName( + "§r§f"+m.Sprintf("item.menu"), + ).WithValue( + "menu", + true, + ), + ) +} + +func (h *handler) HandleChat(ctx *event.Context, message *string) { + ctx.Cancel() +} + +func (h *handler) HandleItemUse(ctx *event.Context) { + held, _ := h.p.HeldItems() + if _, ok := held.Value("menu"); ok { + h.p.SendForm(newServerForm(h.m.Load(), h.prof.Load())) + } + ctx.Cancel() +} + +func (h *handler) HandleQuit() { + if err := h.storer.Store(h.p.UUID(), h.prof.Load()); err != nil { + h.log.Errorf("error storing profile: %s", err) + } + handlers.Delete(h.p.UUID()) +} + +func addressWithPort(s string) string { + if strings.Count(s, ":") == 0 { + s += ":19132" + } + return s +} + +var handlers sync.Map + +type visitor struct{} + +func (visitor) AllowsEditing() bool { return false } +func (visitor) AllowsTakingDamage() bool { return false } +func (visitor) CreativeInventory() bool { return false } +func (visitor) HasCollision() bool { return true } // Returning false will make this game mode spectator when sent to players, and we don't want to make the slots invisible. +func (visitor) AllowsFlying() bool { return false } +func (visitor) AllowsInteraction() bool { return true } +func (visitor) Visible() bool { return false } + +type playerProvider struct{ player.NopProvider } + +func (playerProvider) Load(uuid.UUID, func(world.Dimension) *world.World) (player.Data, error) { + return player.Data{ + GameMode: visitor{}, + Health: 20, + MaxHealth: 20, + Hunger: 20, + }, nil +} + +type compass struct{ item.Compass } + +func (compass) EncodeNBT() map[string]any { + return map[string]any{ + "minecraft:item_lock": byte(0x1), // 0x1 locks in slot, 0x2 locks in inventory + } +} + +func (c compass) DecodeNBT(map[string]any) any { + return c +} + +//go:linkname sessionOf github.com/df-mc/dragonfly/server/player.(*Player).session +func sessionOf(*player.Player) *session.Session + +//go:linkname writePacket github.com/df-mc/dragonfly/server/session.(*Session).writePacket +func writePacket(*session.Session, packet.Packet) diff --git a/internal/conf/read.go b/internal/conf/read.go new file mode 100644 index 0000000..8dc60da --- /dev/null +++ b/internal/conf/read.go @@ -0,0 +1,74 @@ +package conf + +import ( + "encoding/json" + "fmt" + "github.com/pelletier/go-toml" + "io" + "os" + "path/filepath" +) + +func Read[T any](encoding Encoding, path string, d T) (t T, err error) { + if filepath.Ext(path) == "" { + path += encoding.Ext() + } + if _, err := os.Stat(path); os.IsNotExist(err) { + f, err := os.OpenFile(path, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, os.ModePerm) + if err != nil { + return t, err // The operation above is already wrapped by os.PathError + } + defer f.Close() + if err := encoding.Encode(f, d); err != nil { + return t, fmt.Errorf("encode default: %w", err) + } + return d, nil + } else if err != nil { + return t, fmt.Errorf("stat: %w", err) + } + f, err := os.Open(path) + if err != nil { + return t, nil // The operation above is already wrapped by os.PathError + } + defer f.Close() + if err := encoding.Decode(f, &t); err != nil { + return t, fmt.Errorf("decode: %w", err) + } + return t, nil +} + +type Encoding interface { + Encode(w io.Writer, v any) error + Decode(r io.Reader, v any) error + + Ext() string +} + +var ( + TOMLEncoding Encoding = tomlEncoding{} + JSONEncoding Encoding = jsonEncoding{} +) + +type tomlEncoding struct{} + +func (tomlEncoding) Encode(w io.Writer, v any) error { + return toml.NewEncoder(w).Encode(v) +} + +func (tomlEncoding) Decode(r io.Reader, v any) error { + return toml.NewDecoder(r).Decode(v) +} + +func (tomlEncoding) Ext() string { return ".toml" } + +type jsonEncoding struct{} + +func (jsonEncoding) Encode(w io.Writer, v any) error { + return json.NewEncoder(w).Encode(v) +} + +func (jsonEncoding) Decode(r io.Reader, v any) error { + return json.NewDecoder(r).Decode(v) +} + +func (jsonEncoding) Ext() string { return ".json" } diff --git a/internal/provider.go b/internal/provider.go new file mode 100644 index 0000000..42f7f9e --- /dev/null +++ b/internal/provider.go @@ -0,0 +1,69 @@ +package internal + +import ( + "encoding/json" + "errors" + "fmt" + "github.com/df-mc/goleveldb/leveldb" + "github.com/df-mc/goleveldb/leveldb/opt" +) + +func LoadDefault[K comparable, V any](l Loader[K, V], key K, d V) (value V, err error) { + value, err = l.Load(key) + if errors.Is(err, ErrNotFound) { + value, err = d, nil + } + return value, err +} + +var ErrNotFound = errors.New("internal: Loader: not found") + +type Loader[K comparable, V any] interface { + Load(key K) (value V, err error) +} + +type Storer[K comparable, V any] interface { + Store(key K, value V) error +} + +type LoadStorer[K comparable, V any] interface { + Loader[K, V] + Storer[K, V] +} + +type LevelDBProvider[K comparable, V any] struct { + DB *leveldb.DB + + ReadOptions *opt.ReadOptions + WriteOptions *opt.WriteOptions +} + +func (prov LevelDBProvider[K, V]) Load(key K) (value V, err error) { + k, err := json.Marshal(key) + if err != nil { + return value, fmt.Errorf("encode key: %w", err) + } + v, err := prov.DB.Get(k, prov.ReadOptions) + if err != nil { + if errors.Is(err, leveldb.ErrNotFound) { + err = ErrNotFound + } + return value, err + } + if err := json.Unmarshal(v, &value); err != nil { + return value, fmt.Errorf("decode: %w", err) + } + return value, nil +} + +func (prov LevelDBProvider[K, V]) Store(key K, value V) error { + k, err := json.Marshal(key) + if err != nil { + return fmt.Errorf("encode key: %w", err) + } + v, err := json.Marshal(value) + if err != nil { + return fmt.Errorf("encode value: %w", err) + } + return prov.DB.Put(k, v, prov.WriteOptions) +} diff --git a/main.go b/main.go new file mode 100644 index 0000000..806ee9f --- /dev/null +++ b/main.go @@ -0,0 +1,378 @@ +package main + +import ( + "context" + rand2 "crypto/rand" + "encoding/base64" + "encoding/json" + "fmt" + atomic2 "github.com/df-mc/atomic" + "github.com/df-mc/dragonfly/server" + "github.com/df-mc/dragonfly/server/block" + "github.com/df-mc/dragonfly/server/block/cube" + "github.com/df-mc/dragonfly/server/player" + "github.com/df-mc/dragonfly/server/world" + "github.com/df-mc/goleveldb/leveldb" + "github.com/google/uuid" + "github.com/lactyy/idou/internal" + "github.com/lactyy/idou/internal/conf" + "github.com/sandertv/gophertunnel/minecraft" + "github.com/sandertv/gophertunnel/minecraft/auth" + "github.com/sandertv/gophertunnel/minecraft/franchise" + "github.com/sandertv/gophertunnel/minecraft/franchise/signaling" + "github.com/sandertv/gophertunnel/minecraft/nethernet" + "github.com/sandertv/gophertunnel/minecraft/protocol" + "github.com/sandertv/gophertunnel/minecraft/protocol/packet" + "github.com/sandertv/gophertunnel/minecraft/room" + "github.com/sandertv/gophertunnel/xsapi" + "github.com/sandertv/gophertunnel/xsapi/mpsd" + "github.com/sandertv/gophertunnel/xsapi/xal" + "github.com/sirupsen/logrus" + "golang.org/x/oauth2" + "golang.org/x/text/language" + "golang.org/x/text/language/display" + "golang.org/x/text/message" + "log/slog" + "math/rand" + "net" + "os" + "strings" + "sync/atomic" + "time" + _ "unsafe" +) + +func main() { + log := logrus.New() + log.Level = logrus.DebugLevel + + // var setting webrtc.SettingEngine + // factory := logging.NewDefaultLoggerFactory() + // factory.DefaultLogLevel = logging.LogLevelDebug + // factory.Writer = log.WriterLevel(logrus.DebugLevel) + // setting.LoggerFactory = factory + // nethernet.DefaultDialer.API = webrtc.NewAPI(webrtc.WithSettingEngine(setting)) + + // May be we can make the default value a function, that is only called + // when the file does not exist. + cfg, err := conf.Read(conf.TOMLEncoding, "config", defaultConfig()) + if err != nil { + log.Fatalf("error reading config: %s", err) + } + + var profiles internal.LoadStorer[uuid.UUID, profile] + { + db, err := leveldb.OpenFile(cfg.Database.Folder, nil) + if err != nil { + log.Fatalf("error opening database: %s", err) + } + defer db.Close() + + log.Infof("Database opened at %q", cfg.Database.Folder) + profiles = internal.LevelDBProvider[uuid.UUID, profile]{ + DB: db, + } + } + + cred, err := conf.Read(conf.JSONEncoding, "auth.cred", &credentials{ + src: auth.TokenSource, + }) + if err != nil { + log.Fatalf("error reading credentials: %s", err) + } + src := auth.RefreshTokenSource(cred.Token) + + c, err := cfg.Server.Config(log) + if err != nil { + log.Fatalf("error creating config: %s", err) + } + + { + log.Infof("Publishing session...") + discovery, err := franchise.Discover(protocol.CurrentVersion) + if err != nil { + log.Fatalf("error retrieving discovery: %s", err) + } + a := new(franchise.AuthorizationEnvironment) + if err := discovery.Environment(a, franchise.EnvironmentTypeProduction); err != nil { + log.Fatalf("error reading environment for authorization: %s", err) + } + s := new(signaling.Environment) + if err := discovery.Environment(s, franchise.EnvironmentTypeProduction); err != nil { + log.Fatalf("error reading environment for signaling: %s", err) + } + + refresh, cancel := context.WithCancel(context.Background()) + defer cancel() + prov := franchise.PlayFabXBLIdentityProvider{ + Environment: a, + TokenSource: xal.RefreshTokenSourceContext(refresh, src, "http://playfab.xboxlive.com/"), + } + + d := signaling.Dialer{ + NetworkID: rand.Uint64(), + } + + dial, cancel := context.WithTimeout(context.Background(), time.Second*15) + defer cancel() + conn, err := d.DialContext(dial, prov, s) + if err != nil { + log.Fatalf("error dialing signaling: %s", err) + } + defer conn.Close() + + // A token source that refreshes a token used for generic Xbox Live services. + x := xal.RefreshTokenSourceContext(refresh, src, "http://xboxlive.com") + xt, err := x.Token() + if err != nil { + log.Fatalf("error refreshing xbox live token: %s", err) + } + claimer, ok := xt.(xsapi.DisplayClaimer) + if !ok { + log.Fatalf("xbox live token %T does not implement xsapi.DisplayClaimer", xt) + } + displayClaims := claimer.DisplayClaims() + + // The name of the session being published. This seems always to be generated + // randomly, referenced as "GUID" of the session. + name := strings.ToUpper(uuid.NewString()) + + levelID := make([]byte, 8) + _, _ = rand2.Read(levelID) + + custom, err := json.Marshal(room.Status{ + Joinability: room.JoinabilityJoinableByFriends, + HostName: displayClaims.GamerTag, + OwnerID: displayClaims.XUID, + RakNetGUID: "", + // This is displayed as the suffix of the world name. + Version: protocol.CurrentVersion, + LevelID: base64.StdEncoding.EncodeToString(levelID), + WorldName: c.Name, + WorldType: room.WorldTypeCreative, + // The game seems checking this field before joining a session, causes + // RequestNetworkSettings packet not being even sent to the remote host. + Protocol: protocol.CurrentProtocol, + MemberCount: 1, + MaxMemberCount: 8, + BroadcastSetting: room.BroadcastSettingFriendsOfFriends, + LanGame: true, + IsEditorWorld: false, + TransportLayer: 2, + WebRTCNetworkID: d.NetworkID, + OnlineCrossPlatformGame: true, + CrossPlayDisabled: false, + TitleID: 0, + SupportedConnections: []room.Connection{ + { + ConnectionType: 3, // WebSocketsWebRTCSignaling + HostIPAddress: "", + HostPort: 0, + NetherNetID: d.NetworkID, + WebRTCNetworkID: d.NetworkID, + RakNetGUID: "UNASSIGNED_RAKNET_GUID", + }, + }, + }) + if err != nil { + log.Fatalf("error encoding custom properties: %s", err) + } + cfg := mpsd.PublishConfig{ + Description: &mpsd.SessionDescription{ + Properties: &mpsd.SessionProperties{ + System: &mpsd.SessionPropertiesSystem{ + JoinRestriction: mpsd.SessionRestrictionFollowed, + ReadRestriction: mpsd.SessionRestrictionFollowed, + }, + Custom: custom, + }, + }, + } + + publish, cancel := context.WithTimeout(context.Background(), time.Second*15) + defer cancel() + session, err := cfg.PublishContext(publish, x, mpsd.SessionReference{ + ServiceConfigID: uuid.MustParse("4fc10100-5f7a-4470-899b-280835760c07"), + TemplateName: "MinecraftLobby", + Name: name, + }) + if err != nil { + log.Fatalf("error publishing session: %s", err) + } + defer session.Close() + + log.Debugf("Session Name: %q", name) + log.Debugf("Network ID: %d", d.NetworkID) + + slog.SetDefault(slog.New(slog.NewTextHandler(os.Stdout, &slog.HandlerOptions{ + Level: slog.LevelDebug, + }))) + + minecraft.RegisterNetwork("nethernet", &nethernet.Network{ + Signaling: conn, + }) + } + + c.WorldProvider = world.NopProvider{} + c.Generator = func(world.Dimension) world.Generator { + return world.NopGenerator{} + } + c.PlayerProvider = playerProvider{} + c.Listeners = []func(server.Config) (server.Listener, error){ + cfg.listenerFunc, + } + + srv := c.New() + srv.CloseOnProgramEnd() + + srv.World().SetBlock(cube.Pos{0, -2, 0}, block.Barrier{}, nil) + srv.World().StopWeatherCycle() + srv.World().StopTime() + + srv.Listen() + for srv.Accept(func(p *player.Player) { + plog := log.WithFields(logrus.Fields{ + "uuid": p.UUID(), + "address": p.Addr(), + "name": p.Name(), + }) + + // TODO + writePacket(sessionOf(p), &packet.GameRulesChanged{ + GameRules: []protocol.GameRule{ + { + Name: "showTags", + Value: false, + }, + }, + }) + + p.SetImmobile() + for _, other := range srv.Players() { + other.HideEntity(p) + p.HideEntity(other) + } + + prof, err := internal.LoadDefault(profiles, p.UUID(), profile{ + UUID: p.UUID(), + }) + if err != nil { + plog.Errorf("error loading profile: %s", err) + p.Disconnect("Sorry, We couldn't load your profile") + return + } + if prof.Language == language.Und { + locale := p.Locale() + base, _ := locale.Base() + for _, tag := range message.DefaultCatalog.Languages() { + if b, _ := tag.Base(); base == b { + prof.Language = tag + p.Message(message.NewPrinter(tag).Sprintf("language.auto", display.Self.Name(tag))) + goto FOUND + } + } + prof.Language = language.English + FOUND: + } + + m := message.NewPrinter(prof.Language) + a := new(atomic.Pointer[message.Printer]) + a.Store(m) + + h := &handler{ + p: p, + log: plog.Logger, + + m: a, + + prof: atomic2.NewValue(prof), + storer: profiles, + } + handlers.Store(p.UUID(), h) + p.Handle(h) + + p.SendForm(newServerForm(m, h.prof.Load())) + h.setInventory(p, m) + }) { + } +} + +type profile struct { + UUID uuid.UUID `json:"uuid"` + Language language.Tag `json:"language"` + Servers []serverProfile `json:"servers"` +} + +type serverProfile struct { + Name string `json:"name,omitempty"` + Address *net.UDPAddr `json:"address"` + RawAddress string `json:"rawAddress"` +} + +func serverProfileName(s string) string { + if len(s) > 20 { + s = "" + } + return s +} + +func addressEqual(a, b *net.UDPAddr) bool { + if a.String() == b.String() { + return true + } + if a.IP.Equal(b.IP) && a.Port == b.Port { + return true + } + return false +} + +func (prof profile) shouldRemember(addr *net.UDPAddr, rawAddr string) bool { + for _, srv := range prof.Servers { + if addressEqual(srv.Address, addr) || rawAddr == srv.RawAddress { + return false + } + } + return true +} + +func defaultConfig() (cfg config) { + cfg.Database.Folder = "db" + + cfg.Server = server.DefaultConfig() + cfg.Server.World.SaveData = false + cfg.Server.Players.SaveData = false + cfg.Server.Server.JoinMessage = "" + cfg.Server.Server.QuitMessage = "" + + cfg.Server.Server.Name = "Testing" + return cfg +} + +type config struct { + Listener struct { + NetworkID uint64 `json:"networkID" toml:"networkID"` + } `json:"listener" toml:"listener"` + Database struct { + Folder string `json:"folder" toml:"folder"` + } `json:"db" toml:"db"` + Server server.UserConfig `json:"server" toml:"server"` +} + +//go:linkname biomes github.com/df-mc/dragonfly/server.biomes +func biomes() map[string]any + +type credentials struct { + *oauth2.Token `json:"token"` + src oauth2.TokenSource +} + +func (cred *credentials) MarshalJSON() ([]byte, error) { + if cred.Token == nil { + t, err := cred.src.Token() + if err != nil { + return nil, fmt.Errorf("request token: %w", err) + } + cred.Token = t + } + return json.Marshal(*cred) +} diff --git a/network.go b/network.go new file mode 100644 index 0000000..56baedc --- /dev/null +++ b/network.go @@ -0,0 +1,56 @@ +package main + +import ( + "github.com/df-mc/dragonfly/server" + "github.com/df-mc/dragonfly/server/session" + "github.com/sandertv/gophertunnel/minecraft" + "github.com/sirupsen/logrus" + "log" + "math/rand" + "strconv" +) + +func (cfg config) listenerFunc(c server.Config) (server.Listener, error) { + listen := minecraft.ListenConfig{ + MaximumPlayers: c.MaxPlayers, + StatusProvider: minecraft.NewStatusProvider(c.Name, "idou"), + AuthenticationDisabled: c.AuthDisabled, + ResourcePacks: c.Resources, + Biomes: biomes(), + TexturePacksRequired: true, + } + if l, ok := c.Log.(*logrus.Logger); ok { + listen.ErrorLog = log.Default() + log.SetOutput(l.WithField("src", "gophertunnel").WriterLevel(logrus.DebugLevel)) + } + if cfg.Listener.NetworkID == 0 { + cfg.Listener.NetworkID = rand.Uint64() + } + l, err := listen.Listen("nethernet", strconv.FormatUint(cfg.Listener.NetworkID, 10)) + if err != nil { + return nil, err + } + c.Log.Infof("Server listening on %v.", l.Addr()) + return listener{l}, nil +} + +// listener is a Listener implementation that wraps around a minecraft.Listener so that it can be listened on by +// Server. +type listener struct { + *minecraft.Listener +} + +// Accept blocks until the next connection is established and returns it. An error is returned if the Listener was +// closed using Close. +func (l listener) Accept() (session.Conn, error) { + conn, err := l.Listener.Accept() + if err != nil { + return nil, err + } + return conn.(session.Conn), err +} + +// Disconnect disconnects a connection from the Listener with a reason. +func (l listener) Disconnect(conn session.Conn, reason string) error { + return l.Listener.Disconnect(conn.(*minecraft.Conn), reason) +}