From 7eb00b49f80e2b7c39cdf7a75662bf9c68c33f25 Mon Sep 17 00:00:00 2001 From: swirl Date: Sat, 18 Sep 2021 18:50:57 -0400 Subject: [PATCH] initial --- LICENSE | 661 +++++++++++ Makefile | 35 + README.md | 152 +++ doc/pacebin.conf | 5 + doc/pacebin.nginx | 12 + doc/pacebin.service | 10 + index.h | 55 + main.c | 254 ++++ mongoose.c | 2713 +++++++++++++++++++++++++++++++++++++++++++ mongoose.h | 737 ++++++++++++ 10 files changed, 4634 insertions(+) create mode 100644 LICENSE create mode 100644 Makefile create mode 100644 README.md create mode 100644 doc/pacebin.conf create mode 100644 doc/pacebin.nginx create mode 100644 doc/pacebin.service create mode 100644 index.h create mode 100644 main.c create mode 100644 mongoose.c create mode 100644 mongoose.h diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..be3f7b2 --- /dev/null +++ b/LICENSE @@ -0,0 +1,661 @@ + GNU AFFERO GENERAL PUBLIC LICENSE + Version 3, 19 November 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 Affero General Public License is a free, copyleft license for +software and other kinds of works, specifically designed to ensure +cooperation with the community in the case of network server software. + + The licenses for most software and other practical works are designed +to take away your freedom to share and change the works. By contrast, +our General Public Licenses are intended to guarantee your freedom to +share and change all versions of a program--to make sure it remains free +software for all its users. + + When we speak of free software, we are referring to freedom, not +price. Our General Public Licenses are designed to make sure that you +have the freedom to distribute copies of free software (and charge for +them if you wish), that you receive source code or can get it if you +want it, that you can change the software or use pieces of it in new +free programs, and that you know you can do these things. + + Developers that use our General Public Licenses protect your rights +with two steps: (1) assert copyright on the software, and (2) offer +you this License which gives you legal permission to copy, distribute +and/or modify the software. + + A secondary benefit of defending all users' freedom is that +improvements made in alternate versions of the program, if they +receive widespread use, become available for other developers to +incorporate. Many developers of free software are heartened and +encouraged by the resulting cooperation. However, in the case of +software used on network servers, this result may fail to come about. +The GNU General Public License permits making a modified version and +letting the public access it on a server without ever releasing its +source code to the public. + + The GNU Affero General Public License is designed specifically to +ensure that, in such cases, the modified source code becomes available +to the community. It requires the operator of a network server to +provide the source code of the modified version running there to the +users of that server. Therefore, public use of a modified version, on +a publicly accessible server, gives the public access to the source +code of the modified version. + + An older license, called the Affero General Public License and +published by Affero, was designed to accomplish similar goals. This is +a different license, not a version of the Affero GPL, but Affero has +released a new version of the Affero GPL which permits relicensing under +this license. + + The precise terms and conditions for copying, distribution and +modification follow. + + TERMS AND CONDITIONS + + 0. Definitions. + + "This License" refers to version 3 of the GNU Affero General Public License. + + "Copyright" also means copyright-like laws that apply to other kinds of +works, such as semiconductor masks. + + "The Program" refers to any copyrightable work licensed under this +License. Each licensee is addressed as "you". "Licensees" and +"recipients" may be individuals or organizations. + + To "modify" a work means to copy from or adapt all or part of the work +in a fashion requiring copyright permission, other than the making of an +exact copy. The resulting work is called a "modified version" of the +earlier work or a work "based on" the earlier work. + + A "covered work" means either the unmodified Program or a work based +on the Program. + + To "propagate" a work means to do anything with it that, without +permission, would make you directly or secondarily liable for +infringement under applicable copyright law, except executing it on a +computer or modifying a private copy. Propagation includes copying, +distribution (with or without modification), making available to the +public, and in some countries other activities as well. + + To "convey" a work means any kind of propagation that enables other +parties to make or receive copies. Mere interaction with a user through +a computer network, with no transfer of a copy, is not conveying. + + An interactive user interface displays "Appropriate Legal Notices" +to the extent that it includes a convenient and prominently visible +feature that (1) displays an appropriate copyright notice, and (2) +tells the user that there is no warranty for the work (except to the +extent that warranties are provided), that licensees may convey the +work under this License, and how to view a copy of this License. If +the interface presents a list of user commands or options, such as a +menu, a prominent item in the list meets this criterion. + + 1. Source Code. + + The "source code" for a work means the preferred form of the work +for making modifications to it. "Object code" means any non-source +form of a work. + + A "Standard Interface" means an interface that either is an official +standard defined by a recognized standards body, or, in the case of +interfaces specified for a particular programming language, one that +is widely used among developers working in that language. + + The "System Libraries" of an executable work include anything, other +than the work as a whole, that (a) is included in the normal form of +packaging a Major Component, but which is not part of that Major +Component, and (b) serves only to enable use of the work with that +Major Component, or to implement a Standard Interface for which an +implementation is available to the public in source code form. A +"Major Component", in this context, means a major essential component +(kernel, window system, and so on) of the specific operating system +(if any) on which the executable work runs, or a compiler used to +produce the work, or an object code interpreter used to run it. + + The "Corresponding Source" for a work in object code form means all +the source code needed to generate, install, and (for an executable +work) run the object code and to modify the work, including scripts to +control those activities. However, it does not include the work's +System Libraries, or general-purpose tools or generally available free +programs which are used unmodified in performing those activities but +which are not part of the work. For example, Corresponding Source +includes interface definition files associated with source files for +the work, and the source code for shared libraries and dynamically +linked subprograms that the work is specifically designed to require, +such as by intimate data communication or control flow between those +subprograms and other parts of the work. + + The Corresponding Source need not include anything that users +can regenerate automatically from other parts of the Corresponding +Source. + + The Corresponding Source for a work in source code form is that +same work. + + 2. Basic Permissions. + + All rights granted under this License are granted for the term of +copyright on the Program, and are irrevocable provided the stated +conditions are met. This License explicitly affirms your unlimited +permission to run the unmodified Program. The output from running a +covered work is covered by this License only if the output, given its +content, constitutes a covered work. This License acknowledges your +rights of fair use or other equivalent, as provided by copyright law. + + You may make, run and propagate covered works that you do not +convey, without conditions so long as your license otherwise remains +in force. You may convey covered works to others for the sole purpose +of having them make modifications exclusively for you, or provide you +with facilities for running those works, provided that you comply with +the terms of this License in conveying all material for which you do +not control copyright. Those thus making or running the covered works +for you must do so exclusively on your behalf, under your direction +and control, on terms that prohibit them from making any copies of +your copyrighted material outside their relationship with you. + + Conveying under any other circumstances is permitted solely under +the conditions stated below. Sublicensing is not allowed; section 10 +makes it unnecessary. + + 3. Protecting Users' Legal Rights From Anti-Circumvention Law. + + No covered work shall be deemed part of an effective technological +measure under any applicable law fulfilling obligations under article +11 of the WIPO copyright treaty adopted on 20 December 1996, or +similar laws prohibiting or restricting circumvention of such +measures. + + When you convey a covered work, you waive any legal power to forbid +circumvention of technological measures to the extent such circumvention +is effected by exercising rights under this License with respect to +the covered work, and you disclaim any intention to limit operation or +modification of the work as a means of enforcing, against the work's +users, your or third parties' legal rights to forbid circumvention of +technological measures. + + 4. Conveying Verbatim Copies. + + You may convey verbatim copies of the Program's source code as you +receive it, in any medium, provided that you conspicuously and +appropriately publish on each copy an appropriate copyright notice; +keep intact all notices stating that this License and any +non-permissive terms added in accord with section 7 apply to the code; +keep intact all notices of the absence of any warranty; and give all +recipients a copy of this License along with the Program. + + You may charge any price or no price for each copy that you convey, +and you may offer support or warranty protection for a fee. + + 5. Conveying Modified Source Versions. + + You may convey a work based on the Program, or the modifications to +produce it from the Program, in the form of source code under the +terms of section 4, provided that you also meet all of these conditions: + + a) The work must carry prominent notices stating that you modified + it, and giving a relevant date. + + b) The work must carry prominent notices stating that it is + released under this License and any conditions added under section + 7. This requirement modifies the requirement in section 4 to + "keep intact all notices". + + c) You must license the entire work, as a whole, under this + License to anyone who comes into possession of a copy. This + License will therefore apply, along with any applicable section 7 + additional terms, to the whole of the work, and all its parts, + regardless of how they are packaged. This License gives no + permission to license the work in any other way, but it does not + invalidate such permission if you have separately received it. + + d) If the work has interactive user interfaces, each must display + Appropriate Legal Notices; however, if the Program has interactive + interfaces that do not display Appropriate Legal Notices, your + work need not make them do so. + + A compilation of a covered work with other separate and independent +works, which are not by their nature extensions of the covered work, +and which are not combined with it such as to form a larger program, +in or on a volume of a storage or distribution medium, is called an +"aggregate" if the compilation and its resulting copyright are not +used to limit the access or legal rights of the compilation's users +beyond what the individual works permit. Inclusion of a covered work +in an aggregate does not cause this License to apply to the other +parts of the aggregate. + + 6. Conveying Non-Source Forms. + + You may convey a covered work in object code form under the terms +of sections 4 and 5, provided that you also convey the +machine-readable Corresponding Source under the terms of this License, +in one of these ways: + + a) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by the + Corresponding Source fixed on a durable physical medium + customarily used for software interchange. + + b) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by a + written offer, valid for at least three years and valid for as + long as you offer spare parts or customer support for that product + model, to give anyone who possesses the object code either (1) a + copy of the Corresponding Source for all the software in the + product that is covered by this License, on a durable physical + medium customarily used for software interchange, for a price no + more than your reasonable cost of physically performing this + conveying of source, or (2) access to copy the + Corresponding Source from a network server at no charge. + + c) Convey individual copies of the object code with a copy of the + written offer to provide the Corresponding Source. This + alternative is allowed only occasionally and noncommercially, and + only if you received the object code with such an offer, in accord + with subsection 6b. + + d) Convey the object code by offering access from a designated + place (gratis or for a charge), and offer equivalent access to the + Corresponding Source in the same way through the same place at no + further charge. You need not require recipients to copy the + Corresponding Source along with the object code. If the place to + copy the object code is a network server, the Corresponding Source + may be on a different server (operated by you or a third party) + that supports equivalent copying facilities, provided you maintain + clear directions next to the object code saying where to find the + Corresponding Source. Regardless of what server hosts the + Corresponding Source, you remain obligated to ensure that it is + available for as long as needed to satisfy these requirements. + + e) Convey the object code using peer-to-peer transmission, provided + you inform other peers where the object code and Corresponding + Source of the work are being offered to the general public at no + charge under subsection 6d. + + A separable portion of the object code, whose source code is excluded +from the Corresponding Source as a System Library, need not be +included in conveying the object code work. + + A "User Product" is either (1) a "consumer product", which means any +tangible personal property which is normally used for personal, family, +or household purposes, or (2) anything designed or sold for incorporation +into a dwelling. In determining whether a product is a consumer product, +doubtful cases shall be resolved in favor of coverage. For a particular +product received by a particular user, "normally used" refers to a +typical or common use of that class of product, regardless of the status +of the particular user or of the way in which the particular user +actually uses, or expects or is expected to use, the product. A product +is a consumer product regardless of whether the product has substantial +commercial, industrial or non-consumer uses, unless such uses represent +the only significant mode of use of the product. + + "Installation Information" for a User Product means any methods, +procedures, authorization keys, or other information required to install +and execute modified versions of a covered work in that User Product from +a modified version of its Corresponding Source. The information must +suffice to ensure that the continued functioning of the modified object +code is in no case prevented or interfered with solely because +modification has been made. + + If you convey an object code work under this section in, or with, or +specifically for use in, a User Product, and the conveying occurs as +part of a transaction in which the right of possession and use of the +User Product is transferred to the recipient in perpetuity or for a +fixed term (regardless of how the transaction is characterized), the +Corresponding Source conveyed under this section must be accompanied +by the Installation Information. But this requirement does not apply +if neither you nor any third party retains the ability to install +modified object code on the User Product (for example, the work has +been installed in ROM). + + The requirement to provide Installation Information does not include a +requirement to continue to provide support service, warranty, or updates +for a work that has been modified or installed by the recipient, or for +the User Product in which it has been modified or installed. Access to a +network may be denied when the modification itself materially and +adversely affects the operation of the network or violates the rules and +protocols for communication across the network. + + Corresponding Source conveyed, and Installation Information provided, +in accord with this section must be in a format that is publicly +documented (and with an implementation available to the public in +source code form), and must require no special password or key for +unpacking, reading or copying. + + 7. Additional Terms. + + "Additional permissions" are terms that supplement the terms of this +License by making exceptions from one or more of its conditions. +Additional permissions that are applicable to the entire Program shall +be treated as though they were included in this License, to the extent +that they are valid under applicable law. If additional permissions +apply only to part of the Program, that part may be used separately +under those permissions, but the entire Program remains governed by +this License without regard to the additional permissions. + + When you convey a copy of a covered work, you may at your option +remove any additional permissions from that copy, or from any part of +it. (Additional permissions may be written to require their own +removal in certain cases when you modify the work.) You may place +additional permissions on material, added by you to a covered work, +for which you have or can give appropriate copyright permission. + + Notwithstanding any other provision of this License, for material you +add to a covered work, you may (if authorized by the copyright holders of +that material) supplement the terms of this License with terms: + + a) Disclaiming warranty or limiting liability differently from the + terms of sections 15 and 16 of this License; or + + b) Requiring preservation of specified reasonable legal notices or + author attributions in that material or in the Appropriate Legal + Notices displayed by works containing it; or + + c) Prohibiting misrepresentation of the origin of that material, or + requiring that modified versions of such material be marked in + reasonable ways as different from the original version; or + + d) Limiting the use for publicity purposes of names of licensors or + authors of the material; or + + e) Declining to grant rights under trademark law for use of some + trade names, trademarks, or service marks; or + + f) Requiring indemnification of licensors and authors of that + material by anyone who conveys the material (or modified versions of + it) with contractual assumptions of liability to the recipient, for + any liability that these contractual assumptions directly impose on + those licensors and authors. + + All other non-permissive additional terms are considered "further +restrictions" within the meaning of section 10. If the Program as you +received it, or any part of it, contains a notice stating that it is +governed by this License along with a term that is a further +restriction, you may remove that term. If a license document contains +a further restriction but permits relicensing or conveying under this +License, you may add to a covered work material governed by the terms +of that license document, provided that the further restriction does +not survive such relicensing or conveying. + + If you add terms to a covered work in accord with this section, you +must place, in the relevant source files, a statement of the +additional terms that apply to those files, or a notice indicating +where to find the applicable terms. + + Additional terms, permissive or non-permissive, may be stated in the +form of a separately written license, or stated as exceptions; +the above requirements apply either way. + + 8. Termination. + + You may not propagate or modify a covered work except as expressly +provided under this License. Any attempt otherwise to propagate or +modify it is void, and will automatically terminate your rights under +this License (including any patent licenses granted under the third +paragraph of section 11). + + However, if you cease all violation of this License, then your +license from a particular copyright holder is reinstated (a) +provisionally, unless and until the copyright holder explicitly and +finally terminates your license, and (b) permanently, if the copyright +holder fails to notify you of the violation by some reasonable means +prior to 60 days after the cessation. + + Moreover, your license from a particular copyright holder is +reinstated permanently if the copyright holder notifies you of the +violation by some reasonable means, this is the first time you have +received notice of violation of this License (for any work) from that +copyright holder, and you cure the violation prior to 30 days after +your receipt of the notice. + + Termination of your rights under this section does not terminate the +licenses of parties who have received copies or rights from you under +this License. If your rights have been terminated and not permanently +reinstated, you do not qualify to receive new licenses for the same +material under section 10. + + 9. Acceptance Not Required for Having Copies. + + You are not required to accept this License in order to receive or +run a copy of the Program. Ancillary propagation of a covered work +occurring solely as a consequence of using peer-to-peer transmission +to receive a copy likewise does not require acceptance. However, +nothing other than this License grants you permission to propagate or +modify any covered work. These actions infringe copyright if you do +not accept this License. Therefore, by modifying or propagating a +covered work, you indicate your acceptance of this License to do so. + + 10. Automatic Licensing of Downstream Recipients. + + Each time you convey a covered work, the recipient automatically +receives a license from the original licensors, to run, modify and +propagate that work, subject to this License. You are not responsible +for enforcing compliance by third parties with this License. + + An "entity transaction" is a transaction transferring control of an +organization, or substantially all assets of one, or subdividing an +organization, or merging organizations. If propagation of a covered +work results from an entity transaction, each party to that +transaction who receives a copy of the work also receives whatever +licenses to the work the party's predecessor in interest had or could +give under the previous paragraph, plus a right to possession of the +Corresponding Source of the work from the predecessor in interest, if +the predecessor has it or can get it with reasonable efforts. + + You may not impose any further restrictions on the exercise of the +rights granted or affirmed under this License. For example, you may +not impose a license fee, royalty, or other charge for exercise of +rights granted under this License, and you may not initiate litigation +(including a cross-claim or counterclaim in a lawsuit) alleging that +any patent claim is infringed by making, using, selling, offering for +sale, or importing the Program or any portion of it. + + 11. Patents. + + A "contributor" is a copyright holder who authorizes use under this +License of the Program or a work on which the Program is based. The +work thus licensed is called the contributor's "contributor version". + + A contributor's "essential patent claims" are all patent claims +owned or controlled by the contributor, whether already acquired or +hereafter acquired, that would be infringed by some manner, permitted +by this License, of making, using, or selling its contributor version, +but do not include claims that would be infringed only as a +consequence of further modification of the contributor version. For +purposes of this definition, "control" includes the right to grant +patent sublicenses in a manner consistent with the requirements of +this License. + + Each contributor grants you a non-exclusive, worldwide, royalty-free +patent license under the contributor's essential patent claims, to +make, use, sell, offer for sale, import and otherwise run, modify and +propagate the contents of its contributor version. + + In the following three paragraphs, a "patent license" is any express +agreement or commitment, however denominated, not to enforce a patent +(such as an express permission to practice a patent or covenant not to +sue for patent infringement). To "grant" such a patent license to a +party means to make such an agreement or commitment not to enforce a +patent against the party. + + If you convey a covered work, knowingly relying on a patent license, +and the Corresponding Source of the work is not available for anyone +to copy, free of charge and under the terms of this License, through a +publicly available network server or other readily accessible means, +then you must either (1) cause the Corresponding Source to be so +available, or (2) arrange to deprive yourself of the benefit of the +patent license for this particular work, or (3) arrange, in a manner +consistent with the requirements of this License, to extend the patent +license to downstream recipients. "Knowingly relying" means you have +actual knowledge that, but for the patent license, your conveying the +covered work in a country, or your recipient's use of the covered work +in a country, would infringe one or more identifiable patents in that +country that you have reason to believe are valid. + + If, pursuant to or in connection with a single transaction or +arrangement, you convey, or propagate by procuring conveyance of, a +covered work, and grant a patent license to some of the parties +receiving the covered work authorizing them to use, propagate, modify +or convey a specific copy of the covered work, then the patent license +you grant is automatically extended to all recipients of the covered +work and works based on it. + + A patent license is "discriminatory" if it does not include within +the scope of its coverage, prohibits the exercise of, or is +conditioned on the non-exercise of one or more of the rights that are +specifically granted under this License. You may not convey a covered +work if you are a party to an arrangement with a third party that is +in the business of distributing software, under which you make payment +to the third party based on the extent of your activity of conveying +the work, and under which the third party grants, to any of the +parties who would receive the covered work from you, a discriminatory +patent license (a) in connection with copies of the covered work +conveyed by you (or copies made from those copies), or (b) primarily +for and in connection with specific products or compilations that +contain the covered work, unless you entered into that arrangement, +or that patent license was granted, prior to 28 March 2007. + + Nothing in this License shall be construed as excluding or limiting +any implied license or other defenses to infringement that may +otherwise be available to you under applicable patent law. + + 12. No Surrender of Others' Freedom. + + If conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot convey a +covered work so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you may +not convey it at all. For example, if you agree to terms that obligate you +to collect a royalty for further conveying from those to whom you convey +the Program, the only way you could satisfy both those terms and this +License would be to refrain entirely from conveying the Program. + + 13. Remote Network Interaction; Use with the GNU General Public License. + + Notwithstanding any other provision of this License, if you modify the +Program, your modified version must prominently offer all users +interacting with it remotely through a computer network (if your version +supports such interaction) an opportunity to receive the Corresponding +Source of your version by providing access to the Corresponding Source +from a network server at no charge, through some standard or customary +means of facilitating copying of software. This Corresponding Source +shall include the Corresponding Source for any work covered by version 3 +of the GNU General Public License that is incorporated pursuant to the +following paragraph. + + Notwithstanding any other provision of this License, you have +permission to link or combine any covered work with a work licensed +under version 3 of the GNU General Public License into a single +combined work, and to convey the resulting work. The terms of this +License will continue to apply to the part which is the covered work, +but the work with which it is combined will remain governed by version +3 of the GNU General Public License. + + 14. Revised Versions of this License. + + The Free Software Foundation may publish revised and/or new versions of +the GNU Affero General Public License from time to time. Such new versions +will be similar in spirit to the present version, but may differ in detail to +address new problems or concerns. + + Each version is given a distinguishing version number. If the +Program specifies that a certain numbered version of the GNU Affero General +Public License "or any later version" applies to it, you have the +option of following the terms and conditions either of that numbered +version or of any later version published by the Free Software +Foundation. If the Program does not specify a version number of the +GNU Affero General Public License, you may choose any version ever published +by the Free Software Foundation. + + If the Program specifies that a proxy can decide which future +versions of the GNU Affero General Public License can be used, that proxy's +public statement of acceptance of a version permanently authorizes you +to choose that version for the Program. + + Later license versions may give you additional or different +permissions. However, no additional obligations are imposed on any +author or copyright holder as a result of your choosing to follow a +later version. + + 15. Disclaimer of Warranty. + + THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY +APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT +HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY +OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, +THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM +IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF +ALL NECESSARY SERVICING, REPAIR OR CORRECTION. + + 16. Limitation of Liability. + + IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING +WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS +THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY +GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE +USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF +DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD +PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), +EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF +SUCH DAMAGES. + + 17. Interpretation of Sections 15 and 16. + + If the disclaimer of warranty and limitation of liability provided +above cannot be given local legal effect according to their terms, +reviewing courts shall apply local law that most closely approximates +an absolute waiver of all civil liability in connection with the +Program, unless a warranty or assumption of liability accompanies a +copy of the Program in return for a fee. + + END OF TERMS AND CONDITIONS + + How to Apply These Terms to Your New Programs + + If you develop a new program, and you want it to be of the greatest +possible use to the public, the best way to achieve this is to make it +free software which everyone can redistribute and change under these terms. + + To do so, attach the following notices to the program. It is safest +to attach them to the start of each source file to most effectively +state the exclusion of warranty; and each file should have at least +the "copyright" line and a pointer to where the full notice is found. + + + Copyright (C) + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU Affero General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Affero General Public License for more details. + + You should have received a copy of the GNU Affero General Public License + along with this program. If not, see . + +Also add information on how to contact you by electronic and paper mail. + + If your software can interact with users remotely through a computer +network, you should also make sure that it provides a way for users to +get its source. For example, if your program is a web application, its +interface could display a "Source" link that leads users to an archive +of the code. There are many ways you could offer source, and different +solutions will be better for different programs; see section 13 for the +specific requirements. + + You should also get your employer (if you work as a programmer) or school, +if any, to sign a "copyright disclaimer" for the program, if necessary. +For more information on this, and how to apply and follow the GNU AGPL, see +. diff --git a/Makefile b/Makefile new file mode 100644 index 0000000..103dd5c --- /dev/null +++ b/Makefile @@ -0,0 +1,35 @@ +prefix=/usr/local +confdir=/etc +systemd_dir=${DESTDIR}${confdir}/systemd/system +nginx_dir=${DESTDIR}${confdir}/nginx +bindir=${DESTDIR}${prefix}/bin + +CC := gcc +CFLAGS := -O2 + +BIN := pacebin + +SOURCE := main.c mongoose.c +OBJ := mongoose.o main.o +DEPS := mongoose.h index.h +LIBS := -lcrypt + +all: $(BIN) + +clean: + rm -f $(OBJ) + +$(BIN): $(OBJ) + $(CC) $(CFLAGS) -o $@ $^ $(LIBS) + +install-nginx: + @install -Dm644 doc/pastebin.nginx ${nginx_dir}/sites-available/pastebin + +install-systemd: + @install -Dm644 doc/pastebin.service ${systemd_dir}/pastebin.service + @install -Dm644 doc/pastebin.conf ${DESTDIR}/${confdir}/pastebin.conf + +install-bin: + @install -Dm755 ${BIN} ${bindir}/${BIN} + +install: install-bin install-nginx install-systemd diff --git a/README.md b/README.md new file mode 100644 index 0000000..0a222dc --- /dev/null +++ b/README.md @@ -0,0 +1,152 @@ +A dead-simple, self-hostable, filesystem-backed pastebin, written in C using [Mongoose](https://cesanta.com). + +This project is largely based off of my [clink](https://git.swurl.xyz/swirl/clink) project. Almost all the main code comes from there, and it uses the exact same design philosophies. + +Please access this project on my [Gitea](https://git.swurl.xyz/swirl/pacebin) instance, NOT GitHub. + +# Features +- Tiny executable size (~80kb) +- No dependencies, just libc +- Extremely simple to use--basic POST and GET +- No bloated webapp, just a simple reverse proxy +- Super light on resources +- Basic and easy paste deletion +- Custom short paste links +- Fast! +- Basic filesystem storage--easy to manage without external programs/libraries + +# Self-Hosting +You can host this yourself. + +Note: all commands here are done as root. + +## Building & Installing +To build this project, you'll need a libc implementation (only tested with glibc), optionally a separate libcrypt implementation, and Git. Most Linux distributions should have all of these by default, but in case yours doesn't: +- `pacman -S glibc libxcrypt git` +- `emerge --ask sys-libs/glibc dev-vcs/git` +- `apt install glibc git` + +1. Clone this repository: + +```bash +git clone https://git.swurl.xyz/swirl/pacebin && cd pacebin +``` + +2. Compile: +```bash +make +``` + +3. Now, you need to install. NGINX and systemd files are provided in this project; you may choose not to install them. + +For all install commands, you may optionally provide `prefix` and `DESTDIR` options. This is useful for packagers; i.e. for a PKGBUILD: `make prefix=/usr DESTDIR=${pkgdir} install`. + +Available install commands are as follows: +- `make install` installs the executable, NGINX, and systemd files. +- `make install-bin` installs the executable file. +- `make install-systemd` installs the systemd file, as well as its environment file. +- `make install-nginx` installs the NGINX file. + +For example, on a non-systemd system using NGINX, you would run `make install-bin install-nginx`. + +4. If using systemd, change the environment file to reflect your desired options: +```bash +vim /etc/pacebin.conf +``` + +5. You can now enable and start the service: +```bash +systemctl enable --now pacebin +``` + +The server should now be running on localhost at port 8081. + +## NGINX Reverse Proxy +An NGINX file is provided with this project. Sorry, no support for Apache or lighttpd or anything else; should've chosen a better HTTP server. + +For this, you'll need [NGINX](https://nginx.org/en/download.html) (obviously), certbot, and its NGINX plugin. Most Linux distributions should have these in their repositories, i.e.: +- `pacman -S nginx certbot-nginx` +- `emerge --ask www-servers/nginx app-crypt/certbot-nginx` +- `apt install nginx python-certbot-nginx` + +This section assumes you've already followed the last. + +1. Change the domain in the NGINX file: +```bash +sed -i 's/your.doma.in/[DOMAIN HERE]' /etc/nginx/sites-available/pacebin +``` + +2. Enable the site: +```bash +ln -s /etc/nginx/sites-{available,enabled}/pacebin +``` + +3. Enable HTTPS for the site: +```bash +certbot --nginx -d [DOMAIN HERE] +``` + +4. Enable and start NGINX: +```bash +systemctl enable --now nginx +``` + +If it's already running, reload: +```bash +systemctl reload nginx +``` + +Your site should be running at https://your.doma.in. Test it by going there, and trying the examples. If they don't work, open an issue. + +# Contributions +Contributions are always welcome. + +# FAQ +## A user has made a paste containing bad content! What do I do? +Clean it up, janny! + +Deleting a paste can be done simply by running: +```bash +rm /srv/pacebin/*/BADLINKHERE +``` + +Replace `/srv/pacebin` with whatever your data directory is. + +## Can I blacklist certain words from being used in pastes or custom short links? +No. While it might be possible through some NGINX stuff, **this is not supported nor it is encouraged.** + +## Is this an IP grabber? +No, unless someone links to grabify or something. If access logs are turned on, then the server administrator can see your IP, but management of access logs is up to them. + +## Can I use this without a reverse proxy? +Probably, I don't know. Won't have HTTPS though, so either way, I heavily recommend you use a reverse proxy. + +## What's the seed for? +The seed is used for generating deletion keys. Do not share it whatsoever. + +## What operating systems are supported? +I've only tested it on my Arch Linux server, but it should work perfectly fine on all Linux distributions. Probably doesn't work on Windows. + +## Can I run this in a subdirectory of my site? +Yes. Simply put the `proxy_pass` directive in a subdirectory, i.e.: +``` +location /paste { + proxy_pass http://localhost:8081; +} +``` + +## Why'd you make this? +Every pastebin sucks. Simple as. All of the self-hostable options I could find had problems, including: +- Loads of unnecessary dependencies +- Huge executable size (Go lol) +- Used some bloated webapp with no basic API +- Feature bloat; i.e. encryption, password protection, file upload, syntax highlighting, etc. +- Written in Ruby, or some other bad language +- No direct reverse-proxy (or in some cases, even HTTP) support +- Reliance on statically serving the index files +- Reliance on static configuration like the host +- Reliance on other services (i.e. link shorteners) + +This project is intended to be a pastebin that is **as simple as possible**. Literally just make, view, and delete pastes. That's it. + +If you, by chance, need encryption, password protection, etc. then use PrivateBin or something. diff --git a/doc/pacebin.conf b/doc/pacebin.conf new file mode 100644 index 0000000..13694fe --- /dev/null +++ b/doc/pacebin.conf @@ -0,0 +1,5 @@ +BIN="BINDIR/BINNAME" +# replace this with the path to clink (usually /usr/local/bin/pacebin by default) +DIR="/srv/pacebin" +PORT=8081 +SEED="secret" diff --git a/doc/pacebin.nginx b/doc/pacebin.nginx new file mode 100644 index 0000000..34c0df7 --- /dev/null +++ b/doc/pacebin.nginx @@ -0,0 +1,12 @@ +server { + rewrite_log on; + server_name your.doma.in; + + location / { + proxy_set_header Host $host; + proxy_pass http://localhost:8081; + } + + listen 80 ; # use certbot to enable https + listen [::]:80 ; +} diff --git a/doc/pacebin.service b/doc/pacebin.service new file mode 100644 index 0000000..637d8d3 --- /dev/null +++ b/doc/pacebin.service @@ -0,0 +1,10 @@ +[Unit] +Description=serve pacebin instance +After=network.target + +[Service] +EnvironmentFile=/etc/pacebin.conf +ExecStart=/bin/sh -c '${BIN} -d "${DIR}" -p ${PORT} -s "${SEED}"' + +[Install] +WantedBy=multi-user.target diff --git a/index.h b/index.h new file mode 100644 index 0000000..6d45e88 --- /dev/null +++ b/index.h @@ -0,0 +1,55 @@ +const char *INDEX_HTML = +"\r\n" +"\r\n" +" \r\n" +" A Minimal, Filesystem-Backed Pastebin\r\n" +" \r\n" +" \r\n" +" \r\n" +" \r\n" +" \r\n" +" \r\n" +" \r\n" +"\r\n" +"
\r\n" +"A Minimal, Filesystem-Backed Pastebin\r\n" +"
\r\n" +"\r\n" +"\r\n" +"\r\n" +"
Examples:\r\n"
+" 1. Create a paste\r\n"
+"   $ curl -d \"some content\" %s\r\n"
+"   %s/502fb5543c36014f\r\n"
+"\r\n"
+" 2. Create a paste with a custom path\r\n"
+"  $ curl -d \"some content\" %s/some-content\r\n"
+"   %s/some-content\r\n"
+"\r\n"
+" 3. Deleting a paste\r\n"
+"   $ TMP=$(mktemp)\r\n"
+"   $ LINK=$(curl -sS %s -d \"some content\" -D $TMP)\r\n"
+"   $ # Paste created, headers stored in temp file\r\n"
+"   $ DEL=$(cat $TMP | grep -i delete-with | awk '{print$2}'| tr -d '\\r')\r\n"
+"   $ # Gets the deletion key, in the 'X-Delete-With' header\r\n"
+"   $ curl $LINK\r\n"
+"   some content\r\n"
+"   $ curl $LINK -X DELETE -d $DEL\r\n"
+"   $ curl $LINK\r\n"
+"   Not found\r\n"
+"   $ # Paste has been deleted
\r\n" +"\r\n" +"\r\n" +"\r\n"; + diff --git a/main.c b/main.c new file mode 100644 index 0000000..d3c0b1f --- /dev/null +++ b/main.c @@ -0,0 +1,254 @@ +#include "mongoose.h" +#include "index.h" + +#include +#include +#include +#include +#include +#include +#include +#include + +char *port = "8081"; +char *data_dir = "/srv/pacebin"; +char *seed = "secret"; + +static struct mg_http_serve_opts s_http_server_opts; + +static void rec_mkdir(const char *dir) { + char tmp[256]; + char *p = NULL; + size_t len; + + snprintf(tmp, sizeof(tmp),"%s",dir); + len = strlen(tmp); + if (tmp[len - 1] == '/') + tmp[len - 1] = 0; + for (p = tmp + 1; *p; p++) + if (*p == '/') { + *p = 0; + mkdir(tmp, S_IRWXU); + *p = '/'; + } + mkdir(tmp, S_IRWXU); +} + +bool file_exists(char *filename) { + struct stat buffer; + return (stat (filename, &buffer) == 0); +} + +char *get_paste_filename(char *link) { + char *filename = malloc(strlen(data_dir) + strlen(link) + 8); + sprintf(filename, "%s/paste/%s", data_dir, link); + return filename; +} + +char *get_del_filename(char *link) { + char *filename = malloc(strlen(data_dir) + strlen(link) + 6); + sprintf(filename, "%s/del/%s", data_dir, link); + return filename; +} + +bool paste_exists(char *link) { + return file_exists(get_paste_filename(link)); +} + +FILE *get_paste_file(char *link, const char *mode) { + return fopen(get_paste_filename(link), mode); +} + +FILE *get_del_file(char *link, const char *mode) { + return fopen(get_del_filename(link), mode); +} + +char *gen_random_link() { + srand(time(NULL)); + char *short_link = malloc(17); + do { + for(size_t i = 0; i < 16; ++i) { + sprintf(short_link + i, "%x", rand() % 16); + } + } while (paste_exists(short_link)); + return short_link; +} + +char *gen_del_key(char *link) { + char *salt = malloc(20); + char *rand_str = malloc(17); + srand(time(NULL)); + for (size_t i = 0; i < 16; ++i) { + rand_str[i] = 37 + (rand() % 90); // random printable char + if (rand_str[i] == 92 || rand_str[i] == 58 || + rand_str[i] == 59 || rand_str[i] == 42) --i; // chars not allowed for salts + } + rand_str[16] = 0; + sprintf(salt, "$6$%s", rand_str); + + char *use_link = malloc(strlen(link) + strlen(seed) + 1); + sprintf(use_link, "%s%s", seed, link); + + char *del_key = crypt(use_link, salt); + + return del_key; +} + +void trim(char *str) { + char *_str = str; + int len = strlen(_str); + + while(*_str && *_str == '/') ++_str, --len; + + memmove(str, _str, len + 1); +} + +void handle_post(struct mg_connection *nc, char *content, char *host, char *link) { + char *short_link; + if (strlen(link) == 0) { + short_link = gen_random_link(); + } else if (strlen(link) >= 255) { + return mg_http_reply(nc, 413, "", "paste link length can not exceed 255 characters"); + } else { + short_link = link; + } + + if (paste_exists(short_link)) { + return mg_http_reply(nc, 500, "", "a paste named %s already exists", short_link); + } + + FILE *url = get_paste_file(short_link, "w+"); + fputs(content, url); + fclose(url); + + FILE *del = get_del_file(short_link, "w+"); + char *del_key = gen_del_key(short_link); + fputs(del_key, del); + fclose(del); + + char *del_header = malloc(256); + sprintf(del_header, "X-Delete-With: %s\r\n", del_key); + + mg_http_reply(nc, 201, del_header, "http://%s/%s", host, short_link); +} + +void handle_delete(struct mg_connection *nc, char *link, char *del_key) { + if (paste_exists(link)) { + FILE *del = get_del_file(link, "r"); + char *key = malloc(256); + fgets(key, 255, del); + if (strcmp(key, del_key) == 0) { + remove(get_paste_filename(link)); + remove(get_del_filename(link)); + mg_http_reply(nc, 204, "", ""); + } else { + mg_http_reply(nc, 403, "", "incorrect deletion key"); + } + } else { + mg_http_reply(nc, 404, "", "this paste does not exist"); + } +} + +static void ev_handler(struct mg_connection *nc, int ev, void *p, void *f) { + if (ev == MG_EV_HTTP_MSG) { + struct mg_http_message *hm = (struct mg_http_message *) p; + char *uri = malloc(hm->uri.len + 1); + + snprintf(uri, hm->uri.len + 1, "%s", hm->uri.ptr); + trim(uri); + + struct mg_str *mhost = mg_http_get_header(hm, "Host"); + char *host = malloc(mhost->len + 1); + snprintf(host, mhost->len + 1, "%s", mhost->ptr); + + char *body = strdup(hm->body.ptr); + + if (strncmp(hm->method.ptr, "POST", hm->method.len) == 0) { + handle_post(nc, body, host, uri); // FIXME: return 400 on bad Content-Type + } else if (strncmp(hm->method.ptr, "DELETE", hm->method.len) == 0) { + handle_delete(nc, uri, body); + } else if (strncmp(hm->method.ptr, "GET", hm->method.len) == 0) { + if (strlen(uri) == 0) { + return mg_http_reply(nc, 200, "Content-Type: text/html\r\n", INDEX_HTML, + host, host, host, host, host); // FIXME: need better solution + } + + mg_http_serve_dir(nc, hm, &s_http_server_opts); + } else { + mg_http_reply(nc, 405, "Allow: GET, POST, DELETE\r\n", ""); + } + } +} + +int main(int argc, char *argv[]) { + int index; + int c; + + opterr = 0; + setvbuf(stdout, NULL, _IONBF, 0); + + while ((c = getopt (argc, argv, "p:d:s:h")) != -1) { + switch (c) { + case 'p': + port = optarg; + break; + case 'd': + data_dir = optarg; + break; + case 's': + seed = optarg; + break; + case 'h': + printf("pacebin: a minimal pastebin\n"); + printf("usage: %s [-p port] [-d data_dir] [-s seed]\n\n", argv[0]); + printf("options:\n"); + printf("-p \t\tport to use (default 8081)\n"); + printf("-d \tdirectory to store data (default /srv/pacebin)\n"); + printf("-s \t\tsecret seed to use (DO NOT SHARE THIS; default 'secret')\n\n"); + printf("source: https://short.swurl.xyz/pacebin (submit bug reports, suggestions, etc. here)\n"); + return 0; + case '?': + if (optopt == 'p' || optopt == 'd' || optopt == 's') { + fprintf(stderr, "Option -%c requires an argument.\n", optopt); + } + else if (isprint (optopt)) { + fprintf(stderr, "Unknown option `-%c'.\n", optopt); + } + else { + fprintf(stderr, "Unknown option character `\\x%x'.\n", optopt); + } + return 1; + default: + abort(); + } + } + + for (index = optind; index < argc; index++) { + printf ("Non-option argument %s\n", argv[index]); + } + + rec_mkdir(strcat(strdup(data_dir), "/paste")); + rec_mkdir(strcat(strdup(data_dir), "/del")); + struct mg_mgr mgr; + struct mg_connection *nc; + + char *root = malloc(strlen(data_dir) + 7); + snprintf(root, strlen(data_dir) + 7, "%s/paste", data_dir); + memset(&s_http_server_opts, 0, sizeof(s_http_server_opts)); + s_http_server_opts.root_dir = root; + + mg_mgr_init(&mgr); + printf("Starting web server on port %s\n", port); + char *str_port = malloc(20); + sprintf(str_port, "http://0.0.0.0:%s", port); + nc = mg_http_listen(&mgr, str_port, ev_handler, &mgr); + if (nc == NULL) { + printf("Failed to create listener\n"); + return 1; + } + + for (;;) { mg_mgr_poll(&mgr, 1000); } + mg_mgr_free(&mgr); + return 0; +} + diff --git a/mongoose.c b/mongoose.c new file mode 100644 index 0000000..6b20b43 --- /dev/null +++ b/mongoose.c @@ -0,0 +1,2713 @@ +// Copyright (c) 2004-2013 Sergey Lyubka +// Copyright (c) 2013-2021 Cesanta Software Limited +// All rights reserved +// +// This software is dual-licensed: you can redistribute it and/or modify +// it under the terms of the GNU General Public License version 2 as +// published by the Free Software Foundation. For the terms of this +// license, see . +// +// You are free to use this software under the terms of the GNU General +// Public License, 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. +// +// Alternatively, you can license this software under a commercial +// license, as set out in . + +#include "mongoose.h" + +#ifdef MG_ENABLE_LINES +#line 1 "src/private.h" +#endif +void mg_connect_resolved(struct mg_connection *); + +#ifdef MG_ENABLE_LINES +#line 1 "src/event.c" +#endif + +void mg_call(struct mg_connection *c, int ev, void *ev_data) { + if (c->pfn != NULL) c->pfn(c, ev, ev_data, c->pfn_data); + if (c->fn != NULL) c->fn(c, ev, ev_data, c->fn_data); +} + +void mg_error(struct mg_connection *c, const char *fmt, ...) { + char mem[256], *buf = mem; + va_list ap; + va_start(ap, fmt); + mg_vasprintf(&buf, sizeof(mem), fmt, ap); + va_end(ap); + LOG(LL_ERROR, ("%lu %s", c->id, buf)); + mg_call(c, MG_EV_ERROR, buf); + if (buf != mem) free(buf); + c->is_closing = 1; +} + +#ifdef MG_ENABLE_LINES +#line 1 "src/fs_packed.c" +#endif + +struct packed_file { + const char *data; + size_t size; + size_t pos; +}; + +const char *mg_unpack(const char *path, size_t *size, time_t *mtime); +const char *mg_unlist(size_t no); +#if MG_ENABLE_PACKED_FS +#else +const char *mg_unpack(const char *path, size_t *size, time_t *mtime) { + (void) path, (void) size, (void) mtime; + return NULL; +} +const char *mg_unlist(size_t no) { + (void) no; + return NULL; +} +#endif + +static int is_dir_prefix(const char *prefix, size_t n, const char *path) { + return n < strlen(path) && memcmp(prefix, path, n) == 0 && path[n] == '/'; + //(n == 0 || path[n] == MG_DIRSEP); +} + +static int packed_stat(const char *path, size_t *size, time_t *mtime) { + const char *p; + size_t i, n = strlen(path); + if (mg_unpack(path, size, mtime)) return MG_FS_READ; // Regular file + // Scan all files. If `path` is a dir prefix for any of them, it's a dir + for (i = 0; (p = mg_unlist(i)) != NULL; i++) { + if (is_dir_prefix(path, n, p)) return MG_FS_DIR; + } + return 0; +} + +static void packed_list(const char *dir, void (*fn)(const char *, void *), + void *userdata) { + char buf[256], tmp[sizeof(buf)]; + const char *path, *begin, *end; + size_t i, n = strlen(dir); + tmp[0] = '\0'; // Previously listed entry + for (i = 0; (path = mg_unlist(i)) != NULL; i++) { + if (!is_dir_prefix(dir, n, path)) continue; + begin = &path[n + 1]; + end = strchr(begin, '/'); + if (end == NULL) end = begin + strlen(begin); + snprintf(buf, sizeof(buf), "%.*s", (int) (end - begin), begin); + buf[sizeof(buf) - 1] = '\0'; + // If this entry has been already listed, skip + // NOTE: we're assuming that file list is sorted alphabetically + if (strcmp(buf, tmp) == 0) continue; + fn(buf, userdata); // Not yet listed, call user function + strcpy(tmp, buf); // And save this entry as listed + } +} + +static struct mg_fd *packed_open(const char *path, int flags) { + size_t size = 0; + const char *data = mg_unpack(path, &size, NULL); + struct packed_file *fp = NULL; + struct mg_fd *fd = NULL; + if (data == NULL) return NULL; + if (flags & MG_FS_WRITE) return NULL; + fp = (struct packed_file *) calloc(1, sizeof(*fp)); + fd = (struct mg_fd *) calloc(1, sizeof(*fd)); + fp->size = size; + fp->data = data; + fd->fd = fp; + fd->fs = &mg_fs_packed; + return fd; +} + +static void packed_close(struct mg_fd *fd) { + if (fd) free(fd->fd), free(fd); +} + +static size_t packed_read(void *fd, void *buf, size_t len) { + struct packed_file *fp = (struct packed_file *) fd; + if (fp->pos + len > fp->size) len = fp->size - fp->pos; + memcpy(buf, &fp->data[fp->pos], len); + fp->pos += len; + return len; +} + +static size_t packed_write(void *fd, const void *buf, size_t len) { + (void) fd, (void) buf, (void) len; + return 0; +} + +static size_t packed_seek(void *fd, size_t offset) { + struct packed_file *fp = (struct packed_file *) fd; + fp->pos = offset; + if (fp->pos > fp->size) fp->pos = fp->size; + return fp->pos; +} + +struct mg_fs mg_fs_packed = {packed_stat, packed_list, packed_open, + packed_close, packed_read, packed_write, + packed_seek}; + +#ifdef MG_ENABLE_LINES +#line 1 "src/fs_posix.c" +#endif + +#if defined(FOPEN_MAX) +static int p_stat(const char *path, size_t *size, time_t *mtime) { +#ifdef _WIN32 + struct _stati64 st; + wchar_t tmp[PATH_MAX]; + MultiByteToWideChar(CP_UTF8, 0, path, -1, tmp, sizeof(tmp) / sizeof(tmp[0])); + if (_wstati64(tmp, &st) != 0) return 0; +#else + struct stat st; + if (stat(path, &st) != 0) return 0; +#endif + if (size) *size = (size_t) st.st_size; + if (mtime) *mtime = st.st_mtime; + return MG_FS_READ | MG_FS_WRITE | (S_ISDIR(st.st_mode) ? MG_FS_DIR : 0); +} + +#ifdef _WIN32 +struct dirent { + char d_name[MAX_PATH]; +}; + +typedef struct win32_dir { + HANDLE handle; + WIN32_FIND_DATAW info; + struct dirent result; +} DIR; + +int gettimeofday(struct timeval *tv, void *tz) { + FILETIME ft; + unsigned __int64 tmpres = 0; + + if (tv != NULL) { + GetSystemTimeAsFileTime(&ft); + tmpres |= ft.dwHighDateTime; + tmpres <<= 32; + tmpres |= ft.dwLowDateTime; + tmpres /= 10; // convert into microseconds + tmpres -= (int64_t) 11644473600000000; + tv->tv_sec = (long) (tmpres / 1000000UL); + tv->tv_usec = (long) (tmpres % 1000000UL); + } + (void) tz; + return 0; +} + +static int to_wchar(const char *path, wchar_t *wbuf, size_t wbuf_len) { + int ret; + char buf[MAX_PATH * 2], buf2[MAX_PATH * 2], *p; + strncpy(buf, path, sizeof(buf)); + buf[sizeof(buf) - 1] = '\0'; + // Trim trailing slashes. Leave backslash for paths like "X:\" + p = buf + strlen(buf) - 1; + while (p > buf && p[-1] != ':' && (p[0] == '\\' || p[0] == '/')) *p-- = '\0'; + memset(wbuf, 0, wbuf_len * sizeof(wchar_t)); + ret = MultiByteToWideChar(CP_UTF8, 0, buf, -1, wbuf, (int) wbuf_len); + // Convert back to Unicode. If doubly-converted string does not match the + // original, something is fishy, reject. + WideCharToMultiByte(CP_UTF8, 0, wbuf, (int) wbuf_len, buf2, sizeof(buf2), + NULL, NULL); + if (strcmp(buf, buf2) != 0) { + wbuf[0] = L'\0'; + ret = 0; + } + return ret; +} + +DIR *opendir(const char *name) { + DIR *d = NULL; + wchar_t wpath[MAX_PATH]; + DWORD attrs; + + if (name == NULL) { + SetLastError(ERROR_BAD_ARGUMENTS); + } else if ((d = (DIR *) calloc(1, sizeof(*d))) == NULL) { + SetLastError(ERROR_NOT_ENOUGH_MEMORY); + } else { + to_wchar(name, wpath, sizeof(wpath) / sizeof(wpath[0])); + attrs = GetFileAttributesW(wpath); + if (attrs != 0Xffffffff && (attrs & FILE_ATTRIBUTE_DIRECTORY)) { + (void) wcscat(wpath, L"\\*"); + d->handle = FindFirstFileW(wpath, &d->info); + d->result.d_name[0] = '\0'; + } else { + free(d); + d = NULL; + } + } + return d; +} + +int closedir(DIR *d) { + int result = 0; + if (d != NULL) { + if (d->handle != INVALID_HANDLE_VALUE) + result = FindClose(d->handle) ? 0 : -1; + free(d); + } else { + result = -1; + SetLastError(ERROR_BAD_ARGUMENTS); + } + return result; +} + +struct dirent *readdir(DIR *d) { + struct dirent *result = NULL; + if (d != NULL) { + memset(&d->result, 0, sizeof(d->result)); + if (d->handle != INVALID_HANDLE_VALUE) { + result = &d->result; + WideCharToMultiByte(CP_UTF8, 0, d->info.cFileName, -1, result->d_name, + sizeof(result->d_name), NULL, NULL); + if (!FindNextFileW(d->handle, &d->info)) { + FindClose(d->handle); + d->handle = INVALID_HANDLE_VALUE; + } + } else { + SetLastError(ERROR_FILE_NOT_FOUND); + } + } else { + SetLastError(ERROR_BAD_ARGUMENTS); + } + return result; +} +#endif + +static void p_list(const char *dir, void (*fn)(const char *, void *), + void *userdata) { +#if MG_ENABLE_DIRLIST + struct dirent *dp; + DIR *dirp; + if ((dirp = (opendir(dir))) == NULL) return; + while ((dp = readdir(dirp)) != NULL) { + if (!strcmp(dp->d_name, ".") || !strcmp(dp->d_name, "..")) continue; + fn(dp->d_name, userdata); + } + closedir(dirp); +#else + (void) dir, (void) fn, (void) userdata; +#endif +} + +static struct mg_fd *p_open(const char *path, int flags) { + const char *mode = flags == (MG_FS_READ | MG_FS_WRITE) ? "r+b" + : flags & MG_FS_READ ? "rb" + : flags & MG_FS_WRITE ? "wb" + : ""; + void *fp = NULL; + struct mg_fd *fd = NULL; +#ifdef _WIN32 + wchar_t b1[PATH_MAX], b2[10]; + MultiByteToWideChar(CP_UTF8, 0, path, -1, b1, sizeof(b1) / sizeof(b1[0])); + MultiByteToWideChar(CP_UTF8, 0, mode, -1, b2, sizeof(b2) / sizeof(b2[0])); + fp = (void *) _wfopen(b1, b2); +#else + fp = (void *) fopen(path, mode); +#endif + if (fp == NULL) return NULL; + fd = (struct mg_fd *) calloc(1, sizeof(*fd)); + fd->fd = fp; + fd->fs = &mg_fs_posix; + return fd; +} + +static void p_close(struct mg_fd *fd) { + if (fd != NULL) fclose((FILE *) fd->fd), free(fd); +} + +static size_t p_read(void *fp, void *buf, size_t len) { + return fread(buf, 1, len, (FILE *) fp); +} + +static size_t p_write(void *fp, const void *buf, size_t len) { + return fwrite(buf, 1, len, (FILE *) fp); +} + +static size_t p_seek(void *fp, size_t offset) { +#if _FILE_OFFSET_BITS == 64 || _POSIX_C_SOURCE >= 200112L || \ + _XOPEN_SOURCE >= 600 + fseeko((FILE *) fp, (off_t) offset, SEEK_SET); +#else + fseek((FILE *) fp, (long) offset, SEEK_SET); +#endif + return (size_t) ftell((FILE *) fp); +} +#else +static char *p_realpath(const char *path, char *resolved_path) { + (void) path, (void) resolved_path; + return NULL; +} + +static int p_stat(const char *path, size_t *size, time_t *mtime) { + (void) path, (void) size, (void) mtime; + return 0; +} + +static void p_list(const char *path, void (*fn)(const char *, void *), + void *userdata) { + (void) path, (void) fn, (void) userdata; +} + +static struct mg_fd *p_open(const char *path, int flags) { + (void) path, (void) flags; + return NULL; +} + +static void p_close(struct mg_fd *fd) { + (void) fd; +} + +static size_t p_read(void *fd, void *buf, size_t len) { + (void) fd, (void) buf, (void) len; + return 0; +} + +static size_t p_write(void *fd, const void *buf, size_t len) { + (void) fd, (void) buf, (void) len; + return 0; +} + +static size_t p_seek(void *fd, size_t offset) { + (void) fd, (void) offset; + return (size_t) ~0; +} +#endif + +struct mg_fs mg_fs_posix = {p_stat, p_list, p_open, p_close, + p_read, p_write, p_seek}; + +#ifdef MG_ENABLE_LINES +#line 1 "src/http.c" +#endif + +// Multipart POST example: +// --xyz +// Content-Disposition: form-data; name="val" +// +// abcdef +// --xyz +// Content-Disposition: form-data; name="foo"; filename="a.txt" +// Content-Type: text/plain +// +// hello world +// +// --xyz-- +size_t mg_http_next_multipart(struct mg_str body, size_t ofs, + struct mg_http_part *part) { + struct mg_str cd = mg_str_n("Content-Disposition", 19); + const char *s = body.ptr; + size_t b = ofs, h1, h2, b1, b2, max = body.len; + + // Init part params + if (part != NULL) part->name = part->filename = part->body = mg_str_n(0, 0); + + // Skip boundary + while (b + 2 < max && s[b] != '\r' && s[b + 1] != '\n') b++; + if (b <= ofs || b + 2 >= max) return 0; + // LOG(LL_INFO, ("B: %zu %zu [%.*s]", ofs, b - ofs, (int) (b - ofs), s)); + + // Skip headers + h1 = h2 = b + 2; + for (;;) { + while (h2 + 2 < max && s[h2] != '\r' && s[h2 + 1] != '\n') h2++; + if (h2 == h1) break; + if (h2 + 2 >= max) return 0; + // LOG(LL_INFO, ("Header: [%.*s]", (int) (h2 - h1), &s[h1])); + if (part != NULL && h1 + cd.len + 2 < h2 && s[h1 + cd.len] == ':' && + mg_ncasecmp(&s[h1], cd.ptr, cd.len) == 0) { + struct mg_str v = mg_str_n(&s[h1 + cd.len + 2], h2 - (h1 + cd.len + 2)); + part->name = mg_http_get_header_var(v, mg_str_n("name", 4)); + part->filename = mg_http_get_header_var(v, mg_str_n("filename", 8)); + } + h1 = h2 = h2 + 2; + } + b1 = b2 = h2 + 2; + while (b2 + 2 + (b - ofs) + 2 < max && !(s[b2] == '\r' && s[b2 + 1] == '\n' && + memcmp(&s[b2 + 2], s, b - ofs) == 0)) + b2++; + + if (b2 + 2 >= max) return 0; + if (part != NULL) part->body = mg_str_n(&s[b1], b2 - b1); + // LOG(LL_INFO, ("Body: [%.*s]", (int) (b2 - b1), &s[b1])); + return b2 + 2; +} + +int mg_http_get_var(const struct mg_str *buf, const char *name, char *dst, + size_t dst_len) { + const char *p, *e, *s; + size_t name_len; + int len; + + if (dst == NULL || dst_len == 0) { + len = -2; // Bad destination + } else if (buf->ptr == NULL || name == NULL || buf->len == 0) { + len = -1; // Bad source + dst[0] = '\0'; + } else { + name_len = strlen(name); + e = buf->ptr + buf->len; + len = -4; // Name does not exist + dst[0] = '\0'; + for (p = buf->ptr; p + name_len < e; p++) { + if ((p == buf->ptr || p[-1] == '&') && p[name_len] == '=' && + !mg_ncasecmp(name, p, name_len)) { + p += name_len + 1; + s = (const char *) memchr(p, '&', (size_t) (e - p)); + if (s == NULL) s = e; + len = mg_url_decode(p, (size_t) (s - p), dst, dst_len, 1); + if (len < 0) len = -3; // Failed to decode + break; + } + } + } + return len; +} + +int mg_url_decode(const char *src, size_t src_len, char *dst, size_t dst_len, + int is_form_url_encoded) { + size_t i, j; + for (i = j = 0; i < src_len && j + 1 < dst_len; i++, j++) { + if (src[i] == '%') { + // Use `i + 2 < src_len`, not `i < src_len - 2`, note small src_len + if (i + 2 < src_len && isxdigit(*(const unsigned char *) (src + i + 1)) && + isxdigit(*(const unsigned char *) (src + i + 2))) { + mg_unhex(src + i + 1, 2, (uint8_t *) &dst[j]); + i += 2; + } else { + return -1; + } + } else if (is_form_url_encoded && src[i] == '+') { + dst[j] = ' '; + } else { + dst[j] = src[i]; + } + } + if (j < dst_len) dst[j] = '\0'; // Null-terminate the destination + return i >= src_len && j < dst_len ? (int) j : -1; +} + +int mg_http_get_request_len(const unsigned char *buf, size_t buf_len) { + size_t i; + for (i = 0; i < buf_len; i++) { + if (!isprint(buf[i]) && buf[i] != '\r' && buf[i] != '\n' && buf[i] < 128) + return -1; + if ((i > 0 && buf[i] == '\n' && buf[i - 1] == '\n') || + (i > 3 && buf[i] == '\n' && buf[i - 1] == '\r' && buf[i - 2] == '\n')) + return (int) i + 1; + } + return 0; +} + +static const char *skip(const char *s, const char *e, const char *d, + struct mg_str *v) { + v->ptr = s; + while (s < e && *s != '\n' && strchr(d, *s) == NULL) s++; + v->len = (size_t) (s - v->ptr); + while (s < e && strchr(d, *s) != NULL) s++; + return s; +} + +struct mg_str *mg_http_get_header(struct mg_http_message *h, const char *name) { + size_t i, n = strlen(name), max = sizeof(h->headers) / sizeof(h->headers[0]); + for (i = 0; i < max && h->headers[i].name.len > 0; i++) { + struct mg_str *k = &h->headers[i].name, *v = &h->headers[i].value; + if (n == k->len && mg_ncasecmp(k->ptr, name, n) == 0) return v; + } + return NULL; +} + +void mg_http_parse_headers(const char *s, const char *end, + struct mg_http_header *h, int max_headers) { + int i; + for (i = 0; i < max_headers; i++) { + struct mg_str k, v, tmp; + const char *he = skip(s, end, "\n", &tmp); + s = skip(s, he, ": \r\n", &k); + s = skip(s, he, "\r\n", &v); + if (k.len == tmp.len) continue; + while (v.len > 0 && v.ptr[v.len - 1] == ' ') v.len--; // Trim spaces + if (k.len == 0) break; + // LOG(LL_INFO, ("--HH [%.*s] [%.*s] [%.*s]", (int) tmp.len - 1, tmp.ptr, + //(int) k.len, k.ptr, (int) v.len, v.ptr)); + h[i].name = k; + h[i].value = v; + } +} + +int mg_http_parse(const char *s, size_t len, struct mg_http_message *hm) { + int is_response, req_len = mg_http_get_request_len((unsigned char *) s, len); + const char *end = s + req_len, *qs; + struct mg_str *cl; + + memset(hm, 0, sizeof(*hm)); + if (req_len <= 0) return req_len; + + hm->message.ptr = hm->head.ptr = s; + hm->body.ptr = end; + hm->head.len = (size_t) req_len; + hm->chunk.ptr = end; + hm->message.len = hm->body.len = (size_t) ~0; // Set body length to infinite + + // Parse request line + s = skip(s, end, " ", &hm->method); + s = skip(s, end, " ", &hm->uri); + s = skip(s, end, "\r\n", &hm->proto); + + // Sanity check. Allow protocol/reason to be empty + if (hm->method.len == 0 || hm->uri.len == 0) return -1; + + // If URI contains '?' character, setup query string + if ((qs = (const char *) memchr(hm->uri.ptr, '?', hm->uri.len)) != NULL) { + hm->query.ptr = qs + 1; + hm->query.len = (size_t) (&hm->uri.ptr[hm->uri.len] - (qs + 1)); + hm->uri.len = (size_t) (qs - hm->uri.ptr); + } + + mg_http_parse_headers(s, end, hm->headers, + sizeof(hm->headers) / sizeof(hm->headers[0])); + if ((cl = mg_http_get_header(hm, "Content-Length")) != NULL) { + hm->body.len = (size_t) mg_to64(*cl); + hm->message.len = (size_t) req_len + hm->body.len; + } + + // mg_http_parse() is used to parse both HTTP requests and HTTP + // responses. If HTTP response does not have Content-Length set, then + // body is read until socket is closed, i.e. body.len is infinite (~0). + // + // For HTTP requests though, according to + // http://tools.ietf.org/html/rfc7231#section-8.1.3, + // only POST and PUT methods have defined body semantics. + // Therefore, if Content-Length is not specified and methods are + // not one of PUT or POST, set body length to 0. + // + // So, if it is HTTP request, and Content-Length is not set, + // and method is not (PUT or POST) then reset body length to zero. + is_response = mg_ncasecmp(hm->method.ptr, "HTTP/", 5) == 0; + if (hm->body.len == (size_t) ~0 && !is_response && + mg_vcasecmp(&hm->method, "PUT") != 0 && + mg_vcasecmp(&hm->method, "POST") != 0) { + hm->body.len = 0; + hm->message.len = (size_t) req_len; + } + + // The 204 (No content) responses also have 0 body length + if (hm->body.len == (size_t) ~0 && is_response && + mg_vcasecmp(&hm->uri, "204") == 0) { + hm->body.len = 0; + hm->message.len = (size_t) req_len; + } + + return req_len; +} + +static void mg_http_vprintf_chunk(struct mg_connection *c, const char *fmt, + va_list ap) { + char mem[256], *buf = mem; + int len = mg_vasprintf(&buf, sizeof(mem), fmt, ap); + mg_printf(c, "%X\r\n", len); + mg_send(c, buf, len > 0 ? (size_t) len : 0); + mg_send(c, "\r\n", 2); + if (buf != mem) free(buf); +} + +void mg_http_printf_chunk(struct mg_connection *c, const char *fmt, ...) { + va_list ap; + va_start(ap, fmt); + mg_http_vprintf_chunk(c, fmt, ap); + va_end(ap); +} + +void mg_http_write_chunk(struct mg_connection *c, const char *buf, size_t len) { + mg_printf(c, "%lX\r\n", (unsigned long) len); + mg_send(c, buf, len); + mg_send(c, "\r\n", 2); +} + +// clang-format off +static const char *mg_http_status_code_str(int status_code) { + switch (status_code) { + case 100: return "Continue"; + case 101: return "Switching Protocols"; + case 102: return "Processing"; + case 200: return "OK"; + case 201: return "Created"; + case 202: return "Accepted"; + case 203: return "Non-authoritative Information"; + case 204: return "No Content"; + case 205: return "Reset Content"; + case 206: return "Partial Content"; + case 207: return "Multi-Status"; + case 208: return "Already Reported"; + case 226: return "IM Used"; + case 300: return "Multiple Choices"; + case 301: return "Moved Permanently"; + case 302: return "Found"; + case 303: return "See Other"; + case 304: return "Not Modified"; + case 305: return "Use Proxy"; + case 307: return "Temporary Redirect"; + case 308: return "Permanent Redirect"; + case 400: return "Bad Request"; + case 401: return "Unauthorized"; + case 402: return "Payment Required"; + case 403: return "Forbidden"; + case 404: return "Not Found"; + case 405: return "Method Not Allowed"; + case 406: return "Not Acceptable"; + case 407: return "Proxy Authentication Required"; + case 408: return "Request Timeout"; + case 409: return "Conflict"; + case 410: return "Gone"; + case 411: return "Length Required"; + case 412: return "Precondition Failed"; + case 413: return "Payload Too Large"; + case 414: return "Request-URI Too Long"; + case 415: return "Unsupported Media Type"; + case 416: return "Requested Range Not Satisfiable"; + case 417: return "Expectation Failed"; + case 418: return "I'm a teapot"; + case 421: return "Misdirected Request"; + case 422: return "Unprocessable Entity"; + case 423: return "Locked"; + case 424: return "Failed Dependency"; + case 426: return "Upgrade Required"; + case 428: return "Precondition Required"; + case 429: return "Too Many Requests"; + case 431: return "Request Header Fields Too Large"; + case 444: return "Connection Closed Without Response"; + case 451: return "Unavailable For Legal Reasons"; + case 499: return "Client Closed Request"; + case 500: return "Internal Server Error"; + case 501: return "Not Implemented"; + case 502: return "Bad Gateway"; + case 503: return "Service Unavailable"; + case 504: return "Gateway Timeout"; + case 505: return "HTTP Version Not Supported"; + case 506: return "Variant Also Negotiates"; + case 507: return "Insufficient Storage"; + case 508: return "Loop Detected"; + case 510: return "Not Extended"; + case 511: return "Network Authentication Required"; + case 599: return "Network Connect Timeout Error"; + default: return "OK"; + } +} +// clang-format on + +void mg_http_reply(struct mg_connection *c, int code, const char *headers, + const char *fmt, ...) { + char mem[256], *buf = mem; + va_list ap; + int len; + va_start(ap, fmt); + len = mg_vasprintf(&buf, sizeof(mem), fmt, ap); + va_end(ap); + mg_printf(c, "HTTP/1.1 %d %s\r\n%sContent-Length: %d\r\n\r\n", code, + mg_http_status_code_str(code), headers == NULL ? "" : headers, len); + mg_send(c, buf, len > 0 ? (size_t) len : 0); + if (buf != mem) free(buf); +} + +static void http_cb(struct mg_connection *, int, void *, void *); +static void restore_http_cb(struct mg_connection *c) { + struct mg_fd *fd = (struct mg_fd *) c->pfn_data; + if (fd != NULL) fd->fs->close(fd); + c->pfn_data = NULL; + c->pfn = http_cb; +} + +char *mg_http_etag(char *buf, size_t len, size_t size, time_t mtime) { + snprintf(buf, len, "\"%lx." MG_INT64_FMT "\"", (unsigned long) mtime, + (int64_t) size); + return buf; +} + +int mg_http_upload(struct mg_connection *c, struct mg_http_message *hm, + const char *dir) { + char offset[40] = "", name[200] = "", path[256]; + mg_http_get_var(&hm->query, "offset", offset, sizeof(offset)); + mg_http_get_var(&hm->query, "name", name, sizeof(name)); + if (name[0] == '\0') { + mg_http_reply(c, 400, "", "%s", "name required"); + return -1; + } else { + FILE *fp; + size_t oft = strtoul(offset, NULL, 0); + snprintf(path, sizeof(path), "%s%c%s", dir, MG_DIRSEP, name); + LOG(LL_DEBUG, + ("%p %d bytes @ %d [%s]", c->fd, (int) hm->body.len, (int) oft, name)); + if ((fp = fopen(path, oft == 0 ? "wb" : "ab")) == NULL) { + mg_http_reply(c, 400, "", "fopen(%s): %d", name, errno); + return -2; + } else { + fwrite(hm->body.ptr, 1, hm->body.len, fp); + fclose(fp); + mg_http_reply(c, 200, "", ""); + return (int) hm->body.len; + } + } +} + +static void static_cb(struct mg_connection *c, int ev, void *ev_data, + void *fn_data) { + if (ev == MG_EV_WRITE || ev == MG_EV_POLL) { + struct mg_fd *fd = (struct mg_fd *) fn_data; + // Read to send IO buffer directly, avoid extra on-stack buffer + size_t n, max = 2 * MG_IO_SIZE; + if (c->send.size < max) mg_iobuf_resize(&c->send, max); + if (c->send.len >= c->send.size) return; // Rate limit + n = fd->fs->read(fd->fd, c->send.buf + c->send.len, + c->send.size - c->send.len); + if (n > 0) c->send.len += n; + if (c->send.len < c->send.size) restore_http_cb(c); + } else if (ev == MG_EV_CLOSE) { + restore_http_cb(c); + } + (void) ev_data; +} + +static struct mg_str guess_content_type(struct mg_str path, const char *extra) { + // clang-format off + struct mimeentry { struct mg_str extension, value; }; + #define MIME_ENTRY(a, b) {{a, sizeof(a) - 1 }, { b, sizeof(b) - 1 }} + // clang-format on + const struct mimeentry tab[] = { + MIME_ENTRY("html", "text/html; charset=utf-8"), + MIME_ENTRY("htm", "text/html; charset=utf-8"), + MIME_ENTRY("css", "text/css; charset=utf-8"), + MIME_ENTRY("js", "text/javascript; charset=utf-8"), + MIME_ENTRY("gif", "image/gif"), + MIME_ENTRY("png", "image/png"), + MIME_ENTRY("woff", "font/woff"), + MIME_ENTRY("ttf", "font/ttf"), + MIME_ENTRY("aac", "audio/aac"), + MIME_ENTRY("avi", "video/x-msvideo"), + MIME_ENTRY("azw", "application/vnd.amazon.ebook"), + MIME_ENTRY("bin", "application/octet-stream"), + MIME_ENTRY("bmp", "image/bmp"), + MIME_ENTRY("bz", "application/x-bzip"), + MIME_ENTRY("bz2", "application/x-bzip2"), + MIME_ENTRY("csv", "text/csv"), + MIME_ENTRY("doc", "application/msword"), + MIME_ENTRY("epub", "application/epub+zip"), + MIME_ENTRY("exe", "application/octet-stream"), + MIME_ENTRY("gz", "application/gzip"), + MIME_ENTRY("ico", "image/x-icon"), + MIME_ENTRY("json", "application/json"), + MIME_ENTRY("mid", "audio/mid"), + MIME_ENTRY("mjs", "text/javascript"), + MIME_ENTRY("mov", "video/quicktime"), + MIME_ENTRY("mp3", "audio/mpeg"), + MIME_ENTRY("mp4", "video/mp4"), + MIME_ENTRY("mpeg", "video/mpeg"), + MIME_ENTRY("mpg", "video/mpeg"), + MIME_ENTRY("ogg", "application/ogg"), + MIME_ENTRY("pdf", "application/pdf"), + MIME_ENTRY("rar", "application/rar"), + MIME_ENTRY("rtf", "application/rtf"), + MIME_ENTRY("shtml", "text/html; charset=utf-8"), + MIME_ENTRY("svg", "image/svg+xml"), + MIME_ENTRY("tar", "application/tar"), + MIME_ENTRY("tgz", "application/tar-gz"), + MIME_ENTRY("txt", "text/plain; charset=utf-8"), + MIME_ENTRY("wasm", "application/wasm"), + MIME_ENTRY("wav", "audio/wav"), + MIME_ENTRY("weba", "audio/webm"), + MIME_ENTRY("webm", "video/webm"), + MIME_ENTRY("webp", "image/webp"), + MIME_ENTRY("xls", "application/excel"), + MIME_ENTRY("xml", "application/xml"), + MIME_ENTRY("xsl", "application/xml"), + MIME_ENTRY("zip", "application/zip"), + MIME_ENTRY("3gp", "video/3gpp"), + MIME_ENTRY("7z", "application/x-7z-compressed"), + MIME_ENTRY("7z", "application/x-7z-compressed"), + {{0, 0}, {0, 0}}, + }; + size_t i = 0; + struct mg_str k, v, s = mg_str(extra); + + // Shrink path to its extension only + while (i < path.len && path.ptr[path.len - i - 1] != '.') i++; + path.ptr += path.len - i; + path.len = i; + + // Process user-provided mime type overrides, if any + while (mg_commalist(&s, &k, &v)) { + if (mg_strcmp(path, k) == 0) return v; + } + + // Process built-in mime types + for (i = 0; tab[i].extension.ptr != NULL; i++) { + if (mg_strcmp(path, tab[i].extension) == 0) return tab[i].value; + } + + return mg_str("text/plain; charset=utf-8"); +} + +static int getrange(struct mg_str *s, int64_t *a, int64_t *b) { + size_t i, numparsed = 0; + LOG(LL_INFO, ("%.*s", (int) s->len, s->ptr)); + for (i = 0; i + 6 < s->len; i++) { + if (memcmp(&s->ptr[i], "bytes=", 6) == 0) { + struct mg_str p = mg_str_n(s->ptr + i + 6, s->len - i - 6); + if (p.len > 0 && p.ptr[0] >= '0' && p.ptr[0] <= '9') numparsed++; + *a = mg_to64(p); + // LOG(LL_INFO, ("PPP [%.*s] %d", (int) p.len, p.ptr, numparsed)); + while (p.len && p.ptr[0] >= '0' && p.ptr[0] <= '9') p.ptr++, p.len--; + if (p.len && p.ptr[0] == '-') p.ptr++, p.len--; + *b = mg_to64(p); + if (p.len > 0 && p.ptr[0] >= '0' && p.ptr[0] <= '9') numparsed++; + // LOG(LL_INFO, ("PPP [%.*s] %d", (int) p.len, p.ptr, numparsed)); + break; + } + } + return (int) numparsed; +} + +void mg_http_serve_file(struct mg_connection *c, struct mg_http_message *hm, + const char *path, struct mg_http_serve_opts *opts) { + char etag[64]; + struct mg_fs *fs = opts->fs == NULL ? &mg_fs_posix : opts->fs; + struct mg_fd *fd = fs->open(path, MG_FS_READ); + size_t size = 0; + time_t mtime = 0; + struct mg_str *inm = NULL; + + if (fd == NULL || fs->stat(path, &size, &mtime) == 0) { + LOG(LL_DEBUG, ("404 [%s] %p", path, (void *) fd)); + mg_http_reply(c, 404, "", "%s", "Not found\n"); + fs->close(fd); + // NOTE: mg_http_etag() call should go first! + } else if (mg_http_etag(etag, sizeof(etag), size, mtime) != NULL && + (inm = mg_http_get_header(hm, "If-None-Match")) != NULL && + mg_vcasecmp(inm, etag) == 0) { + fs->close(fd); + mg_printf(c, "HTTP/1.1 304 Not Modified\r\nContent-Length: 0\r\n\r\n"); + } else { + int n, status = 200; + char range[100] = ""; + int64_t r1 = 0, r2 = 0, cl = (int64_t) size; + struct mg_str mime = guess_content_type(mg_str(path), opts->mime_types); + + // Handle Range header + struct mg_str *rh = mg_http_get_header(hm, "Range"); + if (rh != NULL && (n = getrange(rh, &r1, &r2)) > 0 && r1 >= 0 && r2 >= 0) { + // If range is specified like "400-", set second limit to content len + if (n == 1) r2 = cl - 1; + if (r1 > r2 || r2 >= cl) { + status = 416; + cl = 0; + snprintf(range, sizeof(range), + "Content-Range: bytes */" MG_INT64_FMT "\r\n", (int64_t) size); + } else { + status = 206; + cl = r2 - r1 + 1; + snprintf(range, sizeof(range), + "Content-Range: bytes " MG_INT64_FMT "-" MG_INT64_FMT + "/" MG_INT64_FMT "\r\n", + r1, r1 + cl - 1, (int64_t) size); + fs->seek(fd->fd, (size_t) r1); + } + } + + mg_printf(c, + "HTTP/1.1 %d %s\r\nContent-Type: %.*s\r\n" + "Etag: %s\r\nContent-Length: " MG_INT64_FMT "\r\n%s%s\r\n", + status, mg_http_status_code_str(status), (int) mime.len, mime.ptr, + etag, cl, range, opts->extra_headers ? opts->extra_headers : ""); + if (mg_vcasecmp(&hm->method, "HEAD") == 0) { + c->is_draining = 1; + fs->close(fd); + } else { + c->pfn = static_cb; + c->pfn_data = fd; + } + } +} + +struct printdirentrydata { + struct mg_connection *c; + struct mg_http_message *hm; + struct mg_http_serve_opts *opts; + const char *dir; +}; + +static void printdirentry(const char *name, void *userdata) { + struct printdirentrydata *d = (struct printdirentrydata *) userdata; + struct mg_fs *fs = d->opts->fs == NULL ? &mg_fs_posix : d->opts->fs; + size_t size = 0; + time_t mtime = 0; + char path[MG_PATH_MAX], sz[64], mod[64]; + int flags, n = 0; + + // LOG(LL_DEBUG, ("[%s] [%s]", d->dir, name)); + if (snprintf(path, sizeof(path), "%s%c%s", d->dir, '/', name) < 0) { + LOG(LL_ERROR, ("%s truncated", name)); + } else if ((flags = fs->stat(path, &size, &mtime)) == 0) { + LOG(LL_ERROR, ("%lu stat(%s): %d", d->c->id, path, errno)); + } else { + const char *slash = flags & MG_FS_DIR ? "/" : ""; + struct tm t; + if (flags & MG_FS_DIR) { + snprintf(sz, sizeof(sz), "%s", "[DIR]"); + } else if (size < 1024) { + snprintf(sz, sizeof(sz), "%d", (int) size); + } else if (size < 0x100000) { + snprintf(sz, sizeof(sz), "%.1fk", (double) size / 1024.0); + } else if (size < 0x40000000) { + snprintf(sz, sizeof(sz), "%.1fM", (double) size / 1048576); + } else { + snprintf(sz, sizeof(sz), "%.1fG", (double) size / 1073741824); + } + strftime(mod, sizeof(mod), "%d-%b-%Y %H:%M", localtime_r(&mtime, &t)); + n = (int) mg_url_encode(name, strlen(name), path, sizeof(path)); + mg_printf(d->c, + " %s%s" + "%s%s\n", + n, path, slash, name, slash, mod, sz); + } +} + +static void listdir(struct mg_connection *c, struct mg_http_message *hm, + struct mg_http_serve_opts *opts, char *dir) { + static const char *sort_js_code = + ""; + struct mg_fs *fs = opts->fs == NULL ? &mg_fs_posix : opts->fs; + struct printdirentrydata d = {c, hm, opts, dir}; + char tmp[10]; + size_t off, n; + + mg_printf(c, + "HTTP/1.1 200 OK\r\n" + "Content-Type: text/html; charset=utf-8\r\n" + "%s" + "Content-Length: \r\n\r\n", + opts->extra_headers == NULL ? "" : opts->extra_headers); + off = c->send.len; // Start of body + mg_printf(c, + "Index of %.*s%s%s" + "" + "

Index of %.*s

" + "" + "" + "" + "" + "\n", + (int) hm->uri.len, hm->uri.ptr, sort_js_code, sort_js_code2, + (int) hm->uri.len, hm->uri.ptr); + + fs->list(dir, printdirentry, &d); + mg_printf(c, + "" + "
Name" + "ModifiedSize
Mongoose v.%s
\n", + MG_VERSION); + n = (size_t) snprintf(tmp, sizeof(tmp), "%lu", + (unsigned long) (c->send.len - off)); + if (n > sizeof(tmp)) n = 0; + memcpy(c->send.buf + off - 10, tmp, n); // Set content length +} + +static void remove_double_dots(char *s) { + char *p = s; + while (*s != '\0') { + *p++ = *s++; + if (s[-1] == '/' || s[-1] == '\\') { + while (s[0] != '\0') { + if (s[0] == '/' || s[0] == '\\') { + s++; + } else if (s[0] == '.' && s[1] == '.') { + s += 2; + } else { + break; + } + } + } + } + *p = '\0'; +} + +// Resolve requested file into `path` and return its fs->stat() result +static int uri_to_path(struct mg_connection *c, struct mg_http_message *hm, + struct mg_http_serve_opts *opts, char *path, + size_t path_size) { + struct mg_fs *fs = opts->fs == NULL ? &mg_fs_posix : opts->fs; + int flags = 0, tmp; + // Append URI to the root_dir, and sanitize it + size_t n = (size_t) snprintf(path, path_size, "%s", opts->root_dir); + if (n > path_size) n = path_size; + mg_url_decode(hm->uri.ptr, hm->uri.len, path + n, path_size - n, 0); + path[path_size - 1] = '\0'; // Double-check + remove_double_dots(path); + n = strlen(path); + while (n > 0 && path[n - 1] == '/') path[--n] = 0; // Strip trailing slashes + flags = fs->stat(path, NULL, NULL); // Does it exist? + if (flags == 0) { + mg_http_reply(c, 404, "", "Not found\n"); // Does not exist, doh + } else if (flags & MG_FS_DIR) { + if (((snprintf(path + n, path_size - n, "/index.html") > 0 && + (tmp = fs->stat(path, NULL, NULL)) != 0) || + (snprintf(path + n, path_size - n, "/index.shtml") > 0 && + (tmp = fs->stat(path, NULL, NULL)) != 0))) { + flags = tmp; + } else { + path[n] = '\0'; // Remove appended index file name + } + } + return flags; +} + +void mg_http_serve_dir(struct mg_connection *c, struct mg_http_message *hm, + struct mg_http_serve_opts *opts) { + char path[MG_PATH_MAX] = ""; + struct mg_fs *fs = opts->fs == NULL ? &mg_fs_posix : opts->fs; + if ((fs->stat(opts->root_dir, NULL, NULL) & MG_FS_DIR) == 0) { + mg_http_reply(c, 400, "", "Invalid web root [%s]\n", opts->root_dir); + } else { + int flags = uri_to_path(c, hm, opts, path, sizeof(path)); + if (flags == 0) return; + LOG(LL_DEBUG, ("%.*s %s %d", (int) hm->uri.len, hm->uri.ptr, path, flags)); + if (flags & MG_FS_DIR) { + listdir(c, hm, opts, path); + } else { + mg_http_serve_file(c, hm, path, opts); + } + } +} + +static bool mg_is_url_safe(int c) { + return (c >= '0' && c <= '9') || (c >= 'a' && c <= 'z') || + (c >= 'A' && c <= 'Z') || c == '.' || c == '_' || c == '-' || c == '~'; +} + +size_t mg_url_encode(const char *s, size_t sl, char *buf, size_t len) { + size_t i, n = 0; + for (i = 0; i < sl; i++) { + int c = *(unsigned char *) &s[i]; + if (n + 4 >= len) return 0; + if (mg_is_url_safe(c)) { + buf[n++] = s[i]; + } else { + buf[n++] = '%'; + mg_hex(&s[i], 1, &buf[n]); + n += 2; + } + } + return n; +} + +static struct mg_str stripquotes(struct mg_str s) { + return s.len > 1 && s.ptr[0] == '"' && s.ptr[s.len - 1] == '"' + ? mg_str_n(s.ptr + 1, s.len - 2) + : s; +} + +struct mg_str mg_http_get_header_var(struct mg_str s, struct mg_str v) { + size_t i; + for (i = 0; i + v.len + 2 < s.len; i++) { + if (s.ptr[i + v.len] == '=' && memcmp(&s.ptr[i], v.ptr, v.len) == 0) { + const char *p = &s.ptr[i + v.len + 1], *b = p, *x = &s.ptr[s.len]; + int q = p < x && *p == '"' ? 1 : 0; + while (p < x && (q ? p == b || *p != '"' : *p != ';' && *p != ' ')) p++; + // LOG(LL_INFO, ("[%.*s] [%.*s] [%.*s]", (int) s.len, s.ptr, (int) v.len, + // v.ptr, (int) (p - b), b)); + return stripquotes(mg_str_n(b, (size_t) (p - b + q))); + } + } + return mg_str_n(NULL, 0); +} + +bool mg_http_match_uri(const struct mg_http_message *hm, const char *glob) { + return mg_globmatch(glob, strlen(glob), hm->uri.ptr, hm->uri.len); +} + +static size_t get_chunk_length(const char *buf, size_t len, size_t *ll) { + size_t i = 0, n; + while (i < len && buf[i] != '\r' && i != '\n') i++; + n = mg_unhexn((char *) buf, i); + while (i < len && (buf[i] == '\r' || i == '\n')) i++; + // LOG(LL_INFO, ("len %zu i %zu n %zu ", len, i, n)); + if (ll != NULL) *ll = i + 1; + if (i < len && i + n + 2 < len) return i + n + 3; + return 0; +} + +// Walk through all chunks in the chunked body. For each chunk, fire +// an MG_EV_HTTP_CHUNK event. +static void walkchunks(struct mg_connection *c, struct mg_http_message *hm, + size_t reqlen) { + size_t off = 0, bl, ll; + while (off + reqlen < c->recv.len) { + char *buf = (char *) &c->recv.buf[reqlen]; + size_t memo = c->recv.len; + size_t cl = get_chunk_length(&buf[off], memo - reqlen - off, &ll); + // LOG(LL_INFO, ("len %zu off %zu cl %zu ll %zu", len, off, cl, ll)); + if (cl == 0) break; + hm->chunk = mg_str_n(&buf[off + ll], cl < ll + 2 ? 0 : cl - ll - 2); + mg_call(c, MG_EV_HTTP_CHUNK, hm); + // Increase offset only if user has not deleted this chunk + if (memo == c->recv.len) off += cl; + if (cl <= 5) { + // Zero chunk - last one. Prepare body - cut off chunk lengths + off = bl = 0; + while (off + reqlen < c->recv.len) { + char *buf2 = (char *) &c->recv.buf[reqlen]; + size_t memo2 = c->recv.len; + size_t cl2 = get_chunk_length(&buf2[off], memo2 - reqlen - off, &ll); + size_t n = cl2 < ll + 2 ? 0 : cl2 - ll - 2; + memmove(buf2 + bl, buf2 + off + ll, n); + bl += n; + off += cl2; + if (cl2 <= 5) break; + } + // LOG(LL_INFO, ("BL->%d del %d off %d", (int) bl, (int) del, (int) off)); + c->recv.len -= off - bl; + // Set message length to indicate we've received + // everything, to fire MG_EV_HTTP_MSG + hm->message.len = bl + reqlen; + hm->body.len = bl; + break; + } + } +} + +static bool mg_is_chunked(struct mg_http_message *hm) { + struct mg_str needle = mg_str_n("chunked", 7); + struct mg_str *te = mg_http_get_header(hm, "Transfer-Encoding"); + return te != NULL && mg_strstr(*te, needle) != NULL; +} + +void mg_http_delete_chunk(struct mg_connection *c, struct mg_http_message *hm) { + struct mg_str ch = hm->chunk; + if (mg_is_chunked(hm)) { + ch.len += 4; // \r\n before and after the chunk + ch.ptr -= 2; + while (ch.ptr > hm->body.ptr && *ch.ptr != '\n') ch.ptr--, ch.len++; + } + { + const char *end = &ch.ptr[ch.len]; + size_t n = (size_t) (end - (char *) c->recv.buf); + if (c->recv.len > n) { + memmove((char *) ch.ptr, end, (size_t) (c->recv.len - n)); + } + // LOG(LL_INFO, ("DELETING CHUNK: %zu %zu %zu\n%.*s", c->recv.len, n, + // ch.len, (int) ch.len, ch.ptr)); + } + c->recv.len -= ch.len; +} + +static void http_cb(struct mg_connection *c, int ev, void *evd, void *fnd) { + if (ev == MG_EV_READ || ev == MG_EV_CLOSE) { + struct mg_http_message hm; + for (;;) { + int n = mg_http_parse((char *) c->recv.buf, c->recv.len, &hm); + bool is_chunked = n > 0 && mg_is_chunked(&hm); + if (ev == MG_EV_CLOSE) { + hm.message.len = c->recv.len; + hm.body.len = hm.message.len - (size_t) (hm.body.ptr - hm.message.ptr); + } else if (is_chunked && n > 0) { + walkchunks(c, &hm, (size_t) n); + } + // LOG(LL_INFO, + //("---->%d %d\n%.*s", n, is_chunked, (int) c->recv.len, c->recv.buf)); + if (n < 0 && ev == MG_EV_READ) { + mg_error(c, "HTTP parse:\n%.*s", (int) c->recv.len, c->recv.buf); + break; + } else if (n > 0 && (size_t) c->recv.len >= hm.message.len) { + mg_call(c, MG_EV_HTTP_MSG, &hm); + mg_iobuf_del(&c->recv, 0, hm.message.len); + } else { + if (n > 0 && !is_chunked) { + hm.chunk = + mg_str_n((char *) &c->recv.buf[n], c->recv.len - (size_t) n); + mg_call(c, MG_EV_HTTP_CHUNK, &hm); + } + break; + } + } + } + (void) fnd; + (void) evd; +} + +struct mg_connection *mg_http_connect(struct mg_mgr *mgr, const char *url, + mg_event_handler_t fn, void *fn_data) { + struct mg_connection *c = mg_connect(mgr, url, fn, fn_data); + if (c != NULL) c->pfn = http_cb; + return c; +} + +struct mg_connection *mg_http_listen(struct mg_mgr *mgr, const char *url, + mg_event_handler_t fn, void *fn_data) { + struct mg_connection *c = mg_listen(mgr, url, fn, fn_data); + if (c != NULL) c->pfn = http_cb; + return c; +} + +#ifdef MG_ENABLE_LINES +#line 1 "src/iobuf.c" +#endif + +#include + +// Not using memset for zeroing memory, cause it can be dropped by compiler +// See https://github.com/cesanta/mongoose/pull/1265 +static void zeromem(volatile unsigned char *buf, size_t len) { + if (buf != NULL) { + while (len--) *buf++ = 0; + } +} + +int mg_iobuf_resize(struct mg_iobuf *io, size_t new_size) { + int ok = 1; + if (new_size == 0) { + zeromem(io->buf, io->size); + free(io->buf); + io->buf = NULL; + io->len = io->size = 0; + } else if (new_size != io->size) { + // NOTE(lsm): do not use realloc here. Use calloc/free only, to ease the + // porting to some obscure platforms like FreeRTOS + void *p = calloc(1, new_size); + if (p != NULL) { + size_t len = new_size < io->len ? new_size : io->len; + if (len > 0) memcpy(p, io->buf, len); + zeromem(io->buf, io->size); + free(io->buf); + io->buf = (unsigned char *) p; + io->size = new_size; + } else { + ok = 0; + LOG(LL_ERROR, + ("%lu->%lu", (unsigned long) io->size, (unsigned long) new_size)); + } + } + return ok; +} + +int mg_iobuf_init(struct mg_iobuf *io, size_t size) { + return mg_iobuf_resize(io, size); +} + +size_t mg_iobuf_add(struct mg_iobuf *io, size_t ofs, const void *buf, + size_t len, size_t chunk_size) { + size_t new_size = io->len + len; + if (new_size > io->size) { + new_size += chunk_size; // Make sure that io->size + new_size -= new_size % chunk_size; // is aligned by chunk_size boundary + mg_iobuf_resize(io, new_size); // Attempt to realloc + if (new_size != io->size) len = 0; // Realloc failure, append nothing + } + if (ofs < io->len) memmove(io->buf + ofs + len, io->buf + ofs, io->len - ofs); + if (buf != NULL) memmove(io->buf + ofs, buf, len); + if (ofs > io->len) io->len += ofs - io->len; + io->len += len; + return len; +} + +size_t mg_iobuf_del(struct mg_iobuf *io, size_t ofs, size_t len) { + if (ofs > io->len) ofs = io->len; + if (ofs + len > io->len) len = io->len - ofs; + memmove(io->buf + ofs, io->buf + ofs + len, io->len - ofs - len); + zeromem(io->buf + io->len - len, len); + io->len -= len; + return len; +} + +void mg_iobuf_free(struct mg_iobuf *io) { + mg_iobuf_resize(io, 0); +} + +#ifdef MG_ENABLE_LINES +#line 1 "src/log.c" +#endif + +#if MG_ENABLE_LOG +static void mg_log_stdout(const void *buf, size_t len, void *userdata) { + (void) userdata; + fwrite(buf, 1, len, stdout); +} + +static const char *s_spec = "2"; +static void (*s_fn)(const void *, size_t, void *) = mg_log_stdout; +static void *s_fn_param = NULL; + +void mg_log_set(const char *spec) { + LOG(LL_DEBUG, ("Setting log level to %s", spec)); + s_spec = spec; +} + +bool mg_log_prefix(int level, const char *file, int line, const char *fname) { + // static unsigned long seq; + int max = LL_INFO; + struct mg_str k, v, s = mg_str(s_spec); + const char *p = strrchr(file, '/'); + + if (s_fn == NULL) return false; + + if (p == NULL) p = strrchr(file, '\\'); + p = p == NULL ? file : p + 1; + + while (mg_commalist(&s, &k, &v)) { + if (v.len == 0) max = atoi(k.ptr); + if (v.len > 0 && strncmp(p, k.ptr, k.len) == 0) max = atoi(v.ptr); + } + + if (level <= max) { + char timebuf[21], buf[50] = ""; + time_t t = time(NULL); + struct tm tmp, *tm = gmtime_r(&t, &tmp); + int n; + (void) tmp; + strftime(timebuf, sizeof(timebuf), "%Y-%m-%d %H:%M:%S", tm); + n = snprintf(buf, sizeof(buf), "%s %d %s:%d:%s", timebuf, level, p, line, + fname); + if (n < 0 || n > (int) sizeof(buf) - 2) n = sizeof(buf) - 2; + while (n < (int) sizeof(buf) - 1) buf[n++] = ' '; + s_fn(buf, sizeof(buf) - 1, s_fn_param); + return true; + } else { + return false; + } +} + +void mg_log(const char *fmt, ...) { + char mem[256], *buf = mem; + va_list ap; + int len = 0; + va_start(ap, fmt); + len = mg_vasprintf(&buf, sizeof(mem), fmt, ap); + va_end(ap); + s_fn(buf, len > 0 ? (size_t) len : 0, s_fn_param); + s_fn("\n", 1, s_fn_param); + if (buf != mem) free(buf); +} + +void mg_log_set_callback(void (*fn)(const void *, size_t, void *), void *fnd) { + s_fn = fn; + s_fn_param = fnd; +} +#endif + +#ifdef MG_ENABLE_LINES +#line 1 "src/net.c" +#endif + +int mg_vprintf(struct mg_connection *c, const char *fmt, va_list ap) { + char mem[256], *buf = mem; + int len = mg_vasprintf(&buf, sizeof(mem), fmt, ap); + len = mg_send(c, buf, len > 0 ? (size_t) len : 0); + if (buf != mem) free(buf); + return len; +} + +int mg_printf(struct mg_connection *c, const char *fmt, ...) { + int len = 0; + va_list ap; + va_start(ap, fmt); + len = mg_vprintf(c, fmt, ap); + va_end(ap); + return len; +} + +char *mg_straddr(struct mg_connection *c, char *buf, size_t len) { + char tmp[100]; + const char *fmt = c->peer.is_ip6 ? "[%s]:%d" : "%s:%d"; + mg_ntoa(&c->peer, tmp, sizeof(tmp)); + snprintf(buf, len, fmt, tmp, (int) mg_ntohs(c->peer.port)); + return buf; +} + +char *mg_ntoa(const struct mg_addr *addr, char *buf, size_t len) { + if (addr->is_ip6) { + uint16_t *p = (uint16_t *) addr->ip6; + snprintf(buf, len, "%x:%x:%x:%x:%x:%x:%x:%x", mg_htons(p[0]), + mg_htons(p[1]), mg_htons(p[2]), mg_htons(p[3]), mg_htons(p[4]), + mg_htons(p[5]), mg_htons(p[6]), mg_htons(p[7])); + } else { + uint8_t p[4]; + memcpy(p, &addr->ip, sizeof(p)); + snprintf(buf, len, "%d.%d.%d.%d", (int) p[0], (int) p[1], (int) p[2], + (int) p[3]); + } + return buf; +} + +static bool mg_atonl(struct mg_str str, struct mg_addr *addr) { + if (mg_vcasecmp(&str, "localhost") != 0) return false; + addr->ip = mg_htonl(0x7f000001); + addr->is_ip6 = false; + return true; +} + +static bool mg_aton4(struct mg_str str, struct mg_addr *addr) { + uint8_t data[4] = {0, 0, 0, 0}; + size_t i, num_dots = 0; + for (i = 0; i < str.len; i++) { + if (str.ptr[i] >= '0' && str.ptr[i] <= '9') { + int octet = data[num_dots] * 10 + (str.ptr[i] - '0'); + if (octet > 255) return false; + data[num_dots] = (uint8_t) octet; + } else if (str.ptr[i] == '.') { + if (num_dots >= 3 || i == 0 || str.ptr[i - 1] == '.') return false; + num_dots++; + } else { + return false; + } + } + if (num_dots != 3 || str.ptr[i - 1] == '.') return false; + memcpy(&addr->ip, data, sizeof(data)); + addr->is_ip6 = false; + return true; +} + +static bool mg_v4mapped(struct mg_str str, struct mg_addr *addr) { + int i; + if (str.len < 14) return false; + if (str.ptr[0] != ':' || str.ptr[1] != ':' || str.ptr[6] != ':') return false; + for (i = 2; i < 6; i++) { + if (str.ptr[i] != 'f' && str.ptr[i] != 'F') return false; + } + if (!mg_aton4(mg_str_n(&str.ptr[7], str.len - 7), addr)) return false; + memset(addr->ip6, 0, sizeof(addr->ip6)); + addr->ip6[10] = addr->ip6[11] = 255; + memcpy(&addr->ip6[12], &addr->ip, 4); + addr->is_ip6 = true; + return true; +} + +static bool mg_aton6(struct mg_str str, struct mg_addr *addr) { + size_t i, j = 0, n = 0, dc = 42; + if (mg_v4mapped(str, addr)) return true; + for (i = 0; i < str.len; i++) { + if ((str.ptr[i] >= '0' && str.ptr[i] <= '9') || + (str.ptr[i] >= 'a' && str.ptr[i] <= 'f') || + (str.ptr[i] >= 'A' && str.ptr[i] <= 'F')) { + unsigned long val; + if (i > j + 3) return false; + // LOG(LL_DEBUG, ("%zu %zu [%.*s]", i, j, (int) (i - j + 1), + // &str.ptr[j])); + val = mg_unhexn(&str.ptr[j], i - j + 1); + addr->ip6[n] = (uint8_t) ((val >> 8) & 255); + addr->ip6[n + 1] = (uint8_t) (val & 255); + } else if (str.ptr[i] == ':') { + j = i + 1; + if (i > 0 && str.ptr[i - 1] == ':') { + dc = n; // Double colon + if (i > 1 && str.ptr[i - 2] == ':') return false; + } else if (i > 0) { + n += 2; + } + if (n > 14) return false; + addr->ip6[n] = addr->ip6[n + 1] = 0; // For trailing :: + } else { + return false; + } + } + if (n < 14 && dc == 42) return false; + if (n < 14) { + memmove(&addr->ip6[dc + (14 - n)], &addr->ip6[dc], n - dc + 2); + memset(&addr->ip6[dc], 0, 14 - n); + } + addr->is_ip6 = true; + return true; +} + +bool mg_aton(struct mg_str str, struct mg_addr *addr) { + // LOG(LL_INFO, ("[%.*s]", (int) str.len, str.ptr)); + return mg_atonl(str, addr) || mg_aton4(str, addr) || mg_aton6(str, addr); +} + +void mg_mgr_free(struct mg_mgr *mgr) { + struct mg_connection *c; + for (c = mgr->conns; c != NULL; c = c->next) c->is_closing = 1; + mg_mgr_poll(mgr, 0); +#if MG_ARCH == MG_ARCH_FREERTOS_TCP + FreeRTOS_DeleteSocketSet(mgr->ss); +#endif + LOG(LL_INFO, ("All connections closed")); +} + +void mg_mgr_init(struct mg_mgr *mgr) { + memset(mgr, 0, sizeof(*mgr)); +#if defined(_WIN32) && MG_ENABLE_WINSOCK + // clang-format off + { WSADATA data; WSAStartup(MAKEWORD(2, 2), &data); } + // clang-format on +#elif MG_ARCH == MG_ARCH_FREERTOS_TCP + mgr->ss = FreeRTOS_CreateSocketSet(); +#elif defined(__unix) || defined(__unix__) || defined(__APPLE__) + // Ignore SIGPIPE signal, so if client cancels the request, it + // won't kill the whole process. + signal(SIGPIPE, SIG_IGN); +#endif +} + +#ifdef MG_ENABLE_LINES +#line 1 "src/sock.c" +#endif + +#if MG_ENABLE_SOCKET +#if defined(_WIN32) && MG_ENABLE_WINSOCK +#define MG_SOCK_ERRNO WSAGetLastError() +#ifndef SO_EXCLUSIVEADDRUSE +#define SO_EXCLUSIVEADDRUSE ((int) (~SO_REUSEADDR)) +#endif +#elif MG_ARCH == MG_ARCH_FREERTOS_TCP +#define MG_SOCK_ERRNO errno +typedef Socket_t SOCKET; +#define INVALID_SOCKET FREERTOS_INVALID_SOCKET +#else +#define MG_SOCK_ERRNO errno +#ifndef closesocket +#define closesocket(x) close(x) +#endif +#define INVALID_SOCKET (-1) +typedef int SOCKET; +#endif + +#define FD(c_) ((SOCKET) (size_t) (c_)->fd) +#define S2PTR(s_) ((void *) (size_t) (s_)) + +#ifndef MSG_NONBLOCKING +#define MSG_NONBLOCKING 0 +#endif + +#ifndef AF_INET6 +#define AF_INET6 10 +#endif + +union usa { + struct sockaddr sa; + struct sockaddr_in sin; +#if MG_ENABLE_IPV6 + struct sockaddr_in6 sin6; +#endif +}; + +static socklen_t tousa(struct mg_addr *a, union usa *usa) { + socklen_t len = sizeof(usa->sin); + memset(usa, 0, sizeof(*usa)); + usa->sin.sin_family = AF_INET; + usa->sin.sin_port = a->port; + *(uint32_t *) &usa->sin.sin_addr = a->ip; +#if MG_ENABLE_IPV6 + if (a->is_ip6) { + usa->sin.sin_family = AF_INET6; + usa->sin6.sin6_port = a->port; + memcpy(&usa->sin6.sin6_addr, a->ip6, sizeof(a->ip6)); + len = sizeof(usa->sin6); + } +#endif + return len; +} + +static void tomgaddr(union usa *usa, struct mg_addr *a, bool is_ip6) { + a->is_ip6 = is_ip6; + a->port = usa->sin.sin_port; + memcpy(&a->ip, &usa->sin.sin_addr, sizeof(a->ip)); +#if MG_ENABLE_IPV6 + if (is_ip6) { + memcpy(a->ip6, &usa->sin6.sin6_addr, sizeof(a->ip6)); + a->port = usa->sin6.sin6_port; + } +#endif +} + +static bool mg_sock_would_block(void) { + int err = MG_SOCK_ERRNO; + return err == EINPROGRESS || err == EWOULDBLOCK +#ifndef WINCE + || err == EAGAIN || err == EINTR +#endif +#if defined(_WIN32) && MG_ENABLE_WINSOCK + || err == WSAEINTR || err == WSAEWOULDBLOCK +#endif + ; +} + +static struct mg_connection *alloc_conn(struct mg_mgr *mgr, bool is_client, + SOCKET fd) { + struct mg_connection *c = (struct mg_connection *) calloc(1, sizeof(*c)); + if (c != NULL) { + c->is_client = is_client; + c->fd = S2PTR(fd); + c->mgr = mgr; + c->id = ++mgr->nextid; + } + return c; +} + +static long mg_sock_send(struct mg_connection *c, const void *buf, size_t len) { + long n = send(FD(c), (char *) buf, len, MSG_NONBLOCKING); + return n == 0 ? -1 : n < 0 && mg_sock_would_block() ? 0 : n; +} + +bool mg_send(struct mg_connection *c, const void *buf, size_t len) { + return c->is_udp ? mg_sock_send(c, buf, len) > 0 + : mg_iobuf_add(&c->send, c->send.len, buf, len, MG_IO_SIZE); +} + +static void mg_set_non_blocking_mode(SOCKET fd) { +#if defined(_WIN32) && MG_ENABLE_WINSOCK + unsigned long on = 1; +#elif MG_ARCH == MG_ARCH_FREERTOS_TCP + const BaseType_t off = 0; + setsockopt(fd, 0, FREERTOS_SO_RCVTIMEO, &off, sizeof(off)); + setsockopt(fd, 0, FREERTOS_SO_SNDTIMEO, &off, sizeof(off)); +#elif MG_ARCH == MG_ARCH_FREERTOS_LWIP + lwip_fcntl(fd, F_SETFL, O_NONBLOCK); +#else + fcntl(fd, F_SETFL, fcntl(fd, F_GETFL, 0) | O_NONBLOCK, FD_CLOEXEC); +#endif +} + +SOCKET mg_open_listener(const char *url, struct mg_addr *addr) { + SOCKET fd = INVALID_SOCKET; + memset(addr, 0, sizeof(*addr)); + addr->port = mg_htons(mg_url_port(url)); + if (!mg_aton(mg_url_host(url), addr)) { + LOG(LL_ERROR, ("invalid listening URL: %s", url)); + } else { + union usa usa; + socklen_t slen = tousa(addr, &usa); + int on = 1, af = addr->is_ip6 ? AF_INET6 : AF_INET; + int type = strncmp(url, "udp:", 4) == 0 ? SOCK_DGRAM : SOCK_STREAM; + int proto = type == SOCK_DGRAM ? IPPROTO_UDP : IPPROTO_TCP; + (void) on; + + if ((fd = socket(af, type, proto)) != INVALID_SOCKET && +#if (!defined(_WIN32) || !defined(SO_EXCLUSIVEADDRUSE)) && \ + (!defined(LWIP_SOCKET) || (defined(LWIP_SOCKET) && SO_REUSE == 1)) + // 1. SO_RESUSEADDR is not enabled on Windows because the semantics of + // SO_REUSEADDR on UNIX and Windows is different. On Windows, + // SO_REUSEADDR allows to bind a socket to a port without error even + // if the port is already open by another program. This is not the + // behavior SO_REUSEADDR was designed for, and leads to hard-to-track + // failure scenarios. Therefore, SO_REUSEADDR was disabled on Windows + // unless SO_EXCLUSIVEADDRUSE is supported and set on a socket. + // 2. In case of LWIP, SO_REUSEADDR should be explicitly enabled, by + // defining + // SO_REUSE (in lwipopts.h), otherwise the code below will compile + // but won't work! (setsockopt will return EINVAL) + !setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (char *) &on, sizeof(on)) && +#endif +#if defined(_WIN32) && defined(SO_EXCLUSIVEADDRUSE) && !defined(WINCE) + // "Using SO_REUSEADDR and SO_EXCLUSIVEADDRUSE" + //! setsockopt(fd, SOL_SOCKET, SO_BROADCAST, (char *) &on, sizeof(on)) + //! && + !setsockopt(fd, SOL_SOCKET, SO_EXCLUSIVEADDRUSE, (char *) &on, + sizeof(on)) && +#endif + bind(fd, &usa.sa, slen) == 0 && + // NOTE(lsm): FreeRTOS uses backlog value as a connection limit + (type == SOCK_DGRAM || listen(fd, 128) == 0)) { + // In case port was set to 0, get the real port number + if (getsockname(fd, &usa.sa, &slen) == 0) { + addr->port = usa.sin.sin_port; +#if MG_ENABLE_IPV6 + if (addr->is_ip6) addr->port = usa.sin6.sin6_port; +#endif + } + mg_set_non_blocking_mode(fd); + } else if (fd != INVALID_SOCKET) { + closesocket(fd); + fd = INVALID_SOCKET; + } + } + if (fd == INVALID_SOCKET) { + LOG(LL_ERROR, ("Failed to listen on %s, errno %d", url, MG_SOCK_ERRNO)); + } + + return fd; +} + +static long mg_sock_recv(struct mg_connection *c, void *buf, size_t len) { + long n = 0; + if (c->is_udp) { + union usa usa; + socklen_t slen = tousa(&c->peer, &usa); + n = recvfrom(FD(c), (char *) buf, len, 0, &usa.sa, &slen); + if (n > 0) tomgaddr(&usa, &c->peer, slen != sizeof(usa.sin)); + } else { + n = recv(FD(c), (char *) buf, len, MSG_NONBLOCKING); + } + return n == 0 ? -1 : n < 0 && mg_sock_would_block() ? 0 : n; +} + +// NOTE(lsm): do only one iteration of reads, cause some systems +// (e.g. FreeRTOS stack) return 0 instead of -1/EWOULDBLOCK when no data +static void read_conn(struct mg_connection *c) { + if (c->recv.len >= MG_MAX_RECV_BUF_SIZE) { + mg_error(c, "max_recv_buf_size reached"); + } else if (c->recv.size - c->recv.len < MG_IO_SIZE && + !mg_iobuf_resize(&c->recv, c->recv.size + MG_IO_SIZE)) { + mg_error(c, "oom"); + } else { + char *buf = (char *) &c->recv.buf[c->recv.len]; + size_t len = c->recv.size - c->recv.len; + long n = mg_sock_recv(c, buf, len); + LOG(n > 0 ? LL_VERBOSE_DEBUG : LL_DEBUG, + ("%-3lu %d%d%d%d%d%d%d%d%d%d%d%d %7ld %ld/%ld err %d", c->id, + c->is_listening, c->is_client, c->is_accepted, c->is_resolving, + c->is_connecting, c->is_udp, c->is_websocket, c->is_hexdumping, + c->is_draining, c->is_closing, c->is_readable, + c->is_writable, (long) c->recv.len, n, (long) len, MG_SOCK_ERRNO)); + if (n == 0) { + // Do nothing + } else if (n < 0) { + c->is_closing = 1; // Error, or normal termination + } else if (n > 0) { + struct mg_str evd = mg_str_n(buf, (size_t) n); + if (c->is_hexdumping) { + char *s = mg_hexdump(buf, (size_t) n); + LOG(LL_INFO, ("\n-- %lu %s %s %ld\n%s", c->id, c->label, "<-", n, s)); + free(s); + } + c->recv.len += (size_t) n; + mg_call(c, MG_EV_READ, &evd); + } + } +} + +static void write_conn(struct mg_connection *c) { + char *buf = (char *) c->send.buf; + size_t len = c->send.len; + long n = mg_sock_send(c, buf, len); + + LOG(n > 0 ? LL_VERBOSE_DEBUG : LL_DEBUG, + ("%-3lu %d%d%d%d%d%d%d%d%d%d%d%d %7ld %ld err %d", c->id, + c->is_listening, c->is_client, c->is_accepted, c->is_resolving, + c->is_connecting, c->is_udp, c->is_websocket, c->is_hexdumping, + c->is_draining, c->is_closing, c->is_readable, + c->is_writable, (long) c->send.len, n, MG_SOCK_ERRNO)); + + if (n == 0) { + // Do nothing + } else if (n < 0) { + c->is_closing = 1; // Error, or normal termination + } else if (n > 0) { + // Hexdump before deleting + if (c->is_hexdumping) { + char *s = mg_hexdump(buf, (size_t) n); + LOG(LL_INFO, ("\n-- %lu %s %s %ld\n%s", c->id, c->label, "<-", n, s)); + free(s); + } + mg_iobuf_del(&c->send, 0, (size_t) n); + if (c->send.len == 0) mg_iobuf_resize(&c->send, 0); + mg_call(c, MG_EV_WRITE, &n); + // if (c->send.len == 0) mg_iobuf_resize(&c->send, 0); + } +} + +static void close_conn(struct mg_connection *c) { + LIST_DELETE(struct mg_connection, &c->mgr->conns, c); + // Order of operations is important. `MG_EV_CLOSE` event must be fired + // before we deallocate received data, see #1331 + mg_call(c, MG_EV_CLOSE, NULL); + LOG(LL_DEBUG, ("%lu closed", c->id)); + if (FD(c) != INVALID_SOCKET) { + closesocket(FD(c)); +#if MG_ARCH == MG_ARCH_FREERTOS_TCP + FreeRTOS_FD_CLR(c->fd, c->mgr->ss, eSELECT_ALL); +#endif + c->fd = S2PTR(INVALID_SOCKET); + } + mg_iobuf_free(&c->recv); + mg_iobuf_free(&c->send); + memset(c, 0, sizeof(*c)); + free(c); +} + +static void setsockopts(struct mg_connection *c) { +#if MG_ARCH == MG_ARCH_FREERTOS_TCP + (void) c; +#else + int on = 1; +#if !defined(SOL_TCP) +#define SOL_TCP IPPROTO_TCP +#endif + setsockopt(FD(c), SOL_TCP, TCP_NODELAY, (char *) &on, sizeof(on)); +#if defined(TCP_QUICKACK) + setsockopt(FD(c), SOL_TCP, TCP_QUICKACK, (char *) &on, sizeof(on)); +#endif + setsockopt(FD(c), SOL_SOCKET, SO_KEEPALIVE, (char *) &on, sizeof(on)); +#if ESP32 || ESP8266 || defined(__linux__) + int idle = 60; + setsockopt(FD(c), IPPROTO_TCP, TCP_KEEPIDLE, &idle, sizeof(idle)); +#endif +#if !defined(_WIN32) && !defined(__QNX__) + { + int cnt = 3, intvl = 20; + setsockopt(FD(c), IPPROTO_TCP, TCP_KEEPCNT, &cnt, sizeof(cnt)); + setsockopt(FD(c), IPPROTO_TCP, TCP_KEEPINTVL, &intvl, sizeof(intvl)); + } +#endif +#endif +} + +void mg_connect_resolved(struct mg_connection *c) { + char buf[40]; + int type = c->is_udp ? SOCK_DGRAM : SOCK_STREAM; + int rc, af = c->peer.is_ip6 ? AF_INET6 : AF_INET; + mg_straddr(c, buf, sizeof(buf)); + c->fd = S2PTR(socket(af, type, 0)); + if (FD(c) == INVALID_SOCKET) { + mg_error(c, "socket(): %d", MG_SOCK_ERRNO); + } else { + union usa usa; + socklen_t slen = tousa(&c->peer, &usa); + if (c->is_udp == 0) mg_set_non_blocking_mode(FD(c)); + if (c->is_udp == 0) setsockopts(c); + mg_call(c, MG_EV_RESOLVE, NULL); + if ((rc = connect(FD(c), &usa.sa, slen)) == 0) { + mg_call(c, MG_EV_CONNECT, NULL); + } else if (mg_sock_would_block()) { + c->is_connecting = 1; + } else { + mg_error(c, "connect: %d", MG_SOCK_ERRNO); + } + } +} + +struct mg_connection *mg_connect(struct mg_mgr *mgr, const char *url, + mg_event_handler_t fn, void *fn_data) { + struct mg_connection *c = NULL; + if ((c = alloc_conn(mgr, 1, INVALID_SOCKET)) == NULL) { + LOG(LL_ERROR, ("OOM")); + } else { + struct mg_str host = mg_url_host(url); + LIST_ADD_HEAD(struct mg_connection, &mgr->conns, c); + c->is_udp = (strncmp(url, "udp:", 4) == 0); + c->peer.port = mg_htons(mg_url_port(url)); + c->fn = fn; + c->fn_data = fn_data; + LOG(LL_DEBUG, ("%lu -> %s", c->id, url)); + } + return c; +} + +static void accept_conn(struct mg_mgr *mgr, struct mg_connection *lsn) { + struct mg_connection *c = NULL; + union usa usa; + socklen_t sa_len = sizeof(usa); + SOCKET fd = accept(FD(lsn), &usa.sa, &sa_len); + if (fd == INVALID_SOCKET) { + LOG(LL_ERROR, ("%lu accept failed, errno %d", lsn->id, MG_SOCK_ERRNO)); +#if (!defined(_WIN32) && (MG_ARCH != MG_ARCH_FREERTOS_TCP)) + } else if ((long) fd >= FD_SETSIZE) { + LOG(LL_ERROR, ("%ld > %ld", (long) fd, (long) FD_SETSIZE)); + closesocket(fd); +#endif + } else if ((c = alloc_conn(mgr, 0, fd)) == NULL) { + LOG(LL_ERROR, ("%lu OOM", lsn->id)); + closesocket(fd); + } else { + char buf[40]; + tomgaddr(&usa, &c->peer, sa_len != sizeof(usa.sin)); + mg_straddr(c, buf, sizeof(buf)); + LOG(LL_DEBUG, ("%lu accepted %s", c->id, buf)); + mg_set_non_blocking_mode(FD(c)); + setsockopts(c); + LIST_ADD_HEAD(struct mg_connection, &mgr->conns, c); + c->is_accepted = 1; + c->is_hexdumping = lsn->is_hexdumping; + c->pfn = lsn->pfn; + c->pfn_data = lsn->pfn_data; + c->fn = lsn->fn; + c->fn_data = lsn->fn_data; + mg_call(c, MG_EV_ACCEPT, NULL); + } +} + +static bool mg_socketpair(SOCKET sp[2], union usa usa[2]) { + socklen_t n = sizeof(usa[0].sin); + bool result = false; + + (void) memset(&usa[0], 0, sizeof(usa[0])); + usa[0].sin.sin_family = AF_INET; + *(uint32_t *) &usa->sin.sin_addr = mg_htonl(0x7f000001); // 127.0.0.1 + usa[1] = usa[0]; + + if ((sp[0] = socket(AF_INET, SOCK_DGRAM, 0)) != INVALID_SOCKET && + (sp[1] = socket(AF_INET, SOCK_DGRAM, 0)) != INVALID_SOCKET && + bind(sp[0], &usa[0].sa, n) == 0 && bind(sp[1], &usa[1].sa, n) == 0 && + getsockname(sp[0], &usa[0].sa, &n) == 0 && + getsockname(sp[1], &usa[1].sa, &n) == 0 && + connect(sp[0], &usa[1].sa, n) == 0 && + connect(sp[1], &usa[0].sa, n) == 0) { + mg_set_non_blocking_mode(sp[1]); // Set close-on-exec + result = true; + } else { + if (sp[0] != INVALID_SOCKET) closesocket(sp[0]); + if (sp[1] != INVALID_SOCKET) closesocket(sp[1]); + sp[0] = sp[1] = INVALID_SOCKET; + } + + return result; +} + +void mg_mgr_wakeup(struct mg_connection *c) { + LOG(LL_INFO, ("skt: %p", c->pfn_data)); + send((SOCKET) (size_t) c->pfn_data, "\x01", 1, MSG_NONBLOCKING); +} + +static void pf1(struct mg_connection *c, int ev, void *ev_data, void *fn_data) { + if (ev == MG_EV_READ) mg_iobuf_free(&c->recv); + (void) ev_data, (void) fn_data; +} + +struct mg_connection *mg_mkpipe(struct mg_mgr *mgr, mg_event_handler_t fn, + void *fn_data) { + union usa usa[2]; + SOCKET sp[2] = {INVALID_SOCKET, INVALID_SOCKET}; + struct mg_connection *c = NULL; + if (!mg_socketpair(sp, usa)) { + LOG(LL_ERROR, ("Cannot create socket pair")); + } else if ((c = alloc_conn(mgr, false, sp[1])) == NULL) { + closesocket(sp[0]); + closesocket(sp[1]); + LOG(LL_ERROR, ("OOM")); + } else { + LOG(LL_INFO, ("pipe %lu", (unsigned long) sp[0])); + tomgaddr(&usa[0], &c->peer, false); + c->is_udp = 1; + c->pfn = pf1; + c->pfn_data = (void *) (size_t) sp[0]; + c->fn = fn; + c->fn_data = fn_data; + LIST_ADD_HEAD(struct mg_connection, &mgr->conns, c); + } + return c; +} + +struct mg_connection *mg_listen(struct mg_mgr *mgr, const char *url, + mg_event_handler_t fn, void *fn_data) { + struct mg_connection *c = NULL; + bool is_udp = strncmp(url, "udp:", 4) == 0; + struct mg_addr addr; + SOCKET fd = mg_open_listener(url, &addr); + if (fd == INVALID_SOCKET) { + LOG(LL_ERROR, ("Failed: %s, errno %d", url, MG_SOCK_ERRNO)); + } else if ((c = alloc_conn(mgr, 0, fd)) == NULL) { + LOG(LL_ERROR, ("OOM %s", url)); + closesocket(fd); + } else { + memcpy(&c->peer, &addr, sizeof(struct mg_addr)); + c->fd = S2PTR(fd); + c->is_listening = 1; + c->is_udp = is_udp; + LIST_ADD_HEAD(struct mg_connection, &mgr->conns, c); + c->fn = fn; + c->fn_data = fn_data; + LOG(LL_INFO, + ("%lu accepting on %s (port %u)", c->id, url, mg_ntohs(c->peer.port))); + } + return c; +} + +static void mg_iotest(struct mg_mgr *mgr, int ms) { +#if MG_ARCH == MG_ARCH_FREERTOS_TCP + struct mg_connection *c; + for (c = mgr->conns; c != NULL; c = c->next) { + if (c->is_closing || c->is_resolving || FD(c) == INVALID_SOCKET) continue; + FreeRTOS_FD_SET(c->fd, mgr->ss, eSELECT_READ | eSELECT_EXCEPT); + if (c->is_connecting || (c->send.len > 0)) + FreeRTOS_FD_SET(c->fd, mgr->ss, eSELECT_WRITE); + } + FreeRTOS_select(mgr->ss, pdMS_TO_TICKS(ms)); + for (c = mgr->conns; c != NULL; c = c->next) { + EventBits_t bits = FreeRTOS_FD_ISSET(c->fd, mgr->ss); + c->is_readable = bits & (eSELECT_READ | eSELECT_EXCEPT) ? 1 : 0; + c->is_writable = bits & eSELECT_WRITE ? 1 : 0; + FreeRTOS_FD_CLR(c->fd, mgr->ss, + eSELECT_READ | eSELECT_EXCEPT | eSELECT_WRITE); + } +#else + struct timeval tv = {ms / 1000, (ms % 1000) * 1000}; + struct mg_connection *c; + fd_set rset, wset; + SOCKET maxfd = 0; + int rc; + + FD_ZERO(&rset); + FD_ZERO(&wset); + + for (c = mgr->conns; c != NULL; c = c->next) { + if (c->is_closing || c->is_resolving || FD(c) == INVALID_SOCKET) continue; + FD_SET(FD(c), &rset); + if (FD(c) > maxfd) maxfd = FD(c); + if (c->is_connecting || (c->send.len > 0)) + FD_SET(FD(c), &wset); + } + + if ((rc = select((int) maxfd + 1, &rset, &wset, NULL, &tv)) < 0) { + LOG(LL_DEBUG, ("select: %d %d", rc, MG_SOCK_ERRNO)); + FD_ZERO(&rset); + FD_ZERO(&wset); + } + + for (c = mgr->conns; c != NULL; c = c->next) { + c->is_readable = c->is_tls && c->is_readable + ? 1 + : FD(c) != INVALID_SOCKET && FD_ISSET(FD(c), &rset); + c->is_writable = FD(c) != INVALID_SOCKET && FD_ISSET(FD(c), &wset); + } +#endif +} + +static void connect_conn(struct mg_connection *c) { + int rc = 0; +#if MG_ARCH != MG_ARCH_FREERTOS_TCP + socklen_t len = sizeof(rc); + if (getsockopt(FD(c), SOL_SOCKET, SO_ERROR, (char *) &rc, &len)) rc = 1; +#endif + if (rc == EAGAIN || rc == EWOULDBLOCK) rc = 0; + c->is_connecting = 0; + if (rc) { + char buf[40]; + mg_error(c, "error connecting to %s", mg_straddr(c, buf, sizeof(buf))); + } else { + mg_call(c, MG_EV_CONNECT, NULL); + } +} + +void mg_mgr_poll(struct mg_mgr *mgr, int ms) { + struct mg_connection *c, *tmp; + unsigned long now; + + mg_iotest(mgr, ms); + now = mg_millis(); + mg_timer_poll(now); + + for (c = mgr->conns; c != NULL; c = tmp) { + tmp = c->next; + mg_call(c, MG_EV_POLL, &now); + LOG(LL_VERBOSE_DEBUG, + ("%lu %c%c %c%c%c", c->id, c->is_readable ? 'r' : '-', + c->is_writable ? 'w' : '-', + c->is_connecting ? 'C' : 'c', + c->is_resolving ? 'R' : 'r', c->is_closing ? 'C' : 'c')); + if (c->is_resolving || c->is_closing) { + // Do nothing + } else if (c->is_listening && c->is_udp == 0) { + if (c->is_readable) accept_conn(mgr, c); + } else if (c->is_connecting) { + if (c->is_readable || c->is_writable) connect_conn(c); + } else { + if (c->is_readable) read_conn(c); + if (c->is_writable) write_conn(c); + } + + if (c->is_draining && c->send.len == 0) c->is_closing = 1; + if (c->is_closing) close_conn(c); + } +} +#endif + +#ifdef MG_ENABLE_LINES +#line 1 "src/str.c" +#endif + +#include + +struct mg_str mg_str_s(const char *s) { + struct mg_str str = {s, s == NULL ? 0 : strlen(s)}; + return str; +} + +struct mg_str mg_str_n(const char *s, size_t n) { + struct mg_str str = {s, n}; + return str; +} + +int mg_lower(const char *s) { + return tolower(*(const unsigned char *) s); +} + +int mg_ncasecmp(const char *s1, const char *s2, size_t len) { + int diff = 0; + if (len > 0) do { + diff = mg_lower(s1++) - mg_lower(s2++); + } while (diff == 0 && s1[-1] != '\0' && --len > 0); + return diff; +} + +int mg_casecmp(const char *s1, const char *s2) { + return mg_ncasecmp(s1, s2, (size_t) ~0); +} + +int mg_vcmp(const struct mg_str *s1, const char *s2) { + size_t n2 = strlen(s2), n1 = s1->len; + int r = strncmp(s1->ptr, s2, (n1 < n2) ? n1 : n2); + if (r == 0) return (int) (n1 - n2); + return r; +} + +int mg_vcasecmp(const struct mg_str *str1, const char *str2) { + size_t n2 = strlen(str2), n1 = str1->len; + int r = mg_ncasecmp(str1->ptr, str2, (n1 < n2) ? n1 : n2); + if (r == 0) return (int) (n1 - n2); + return r; +} + +struct mg_str mg_strdup(const struct mg_str s) { + struct mg_str r = {NULL, 0}; + if (s.len > 0 && s.ptr != NULL) { + char *sc = (char *) calloc(1, s.len + 1); + if (sc != NULL) { + memcpy(sc, s.ptr, s.len); + sc[s.len] = '\0'; + r.ptr = sc; + r.len = s.len; + } + } + return r; +} + +int mg_strcmp(const struct mg_str str1, const struct mg_str str2) { + size_t i = 0; + while (i < str1.len && i < str2.len) { + int c1 = str1.ptr[i]; + int c2 = str2.ptr[i]; + if (c1 < c2) return -1; + if (c1 > c2) return 1; + i++; + } + if (i < str1.len) return 1; + if (i < str2.len) return -1; + return 0; +} + +const char *mg_strstr(const struct mg_str haystack, + const struct mg_str needle) { + size_t i; + if (needle.len > haystack.len) return NULL; + for (i = 0; i <= haystack.len - needle.len; i++) { + if (memcmp(haystack.ptr + i, needle.ptr, needle.len) == 0) { + return haystack.ptr + i; + } + } + return NULL; +} + +struct mg_str mg_strstrip(struct mg_str s) { + while (s.len > 0 && isspace((int) *s.ptr)) s.ptr++, s.len--; + while (s.len > 0 && isspace((int) *(s.ptr + s.len - 1))) s.len--; + return s; +} + +#ifdef MG_ENABLE_LINES +#line 1 "src/timer.c" +#endif +// Copyright (c) Cesanta Software Limited +// All rights reserved + +struct mg_timer *g_timers; + +void mg_timer_init(struct mg_timer *t, unsigned long ms, unsigned flags, + void (*fn)(void *), void *arg) { + struct mg_timer tmp = {ms, flags, fn, arg, 0UL, g_timers}; + *t = tmp; + g_timers = t; + if (flags & MG_TIMER_RUN_NOW) fn(arg); +} + +void mg_timer_free(struct mg_timer *t) { + struct mg_timer **head = &g_timers; + while (*head && *head != t) head = &(*head)->next; + if (*head) *head = t->next; +} + +void mg_timer_poll(unsigned long now_ms) { + // If time goes back (wrapped around), reset timers + struct mg_timer *t, *tmp; + static unsigned long oldnow; // Timestamp in a previous invocation + if (oldnow > now_ms) { // If it is wrapped, reset timers + for (t = g_timers; t != NULL; t = t->next) t->expire = 0; + } + oldnow = now_ms; + + for (t = g_timers; t != NULL; t = tmp) { + tmp = t->next; + if (t->expire == 0) t->expire = now_ms + t->period_ms; + if (t->expire > now_ms) continue; + t->fn(t->arg); + // Try to tick timers with the given period as accurate as possible, + // even if this polling function is called with some random period. + t->expire = now_ms - t->expire > (unsigned long) t->period_ms + ? now_ms + t->period_ms + : t->expire + t->period_ms; + if (!(t->flags & MG_TIMER_REPEAT)) mg_timer_free(t); + } +} + +#ifdef MG_ENABLE_LINES +#line 1 "src/url.c" +#endif +#include + +struct url { + size_t key, user, pass, host, port, uri, end; +}; + +int mg_url_is_ssl(const char *url) { + return strncmp(url, "https:", 6) == 0 || strncmp(url, "ssl:", 4) == 0; +} + +static struct url urlparse(const char *url) { + size_t i; + struct url u; + memset(&u, 0, sizeof(u)); + for (i = 0; url[i] != '\0'; i++) { + if (i > 0 && u.host == 0 && url[i - 1] == '/' && url[i] == '/') { + u.host = i + 1; + u.port = 0; + } else if (url[i] == ']') { + u.port = 0; // IPv6 URLs, like http://[::1]/bar + } else if (url[i] == ':' && u.port == 0 && u.uri == 0) { + u.port = i + 1; + } else if (url[i] == '@' && u.user == 0 && u.pass == 0) { + u.user = u.host; + u.pass = u.port; + u.host = i + 1; + u.port = 0; + } else if (u.host && u.uri == 0 && url[i] == '/') { + u.uri = i; + } + } + u.end = i; +#if 0 + printf("[%s] %d %d %d %d %d\n", url, u.user, u.pass, u.host, u.port, u.uri); +#endif + return u; +} + +struct mg_str mg_url_host(const char *url) { + struct url u = urlparse(url); + size_t n = u.port ? u.port - u.host - 1 + : u.uri ? u.uri - u.host + : u.end - u.host; + struct mg_str s = mg_str_n(url + u.host, n); + if (s.len > 2 && s.ptr[0] == '[' && s.ptr[s.len - 1] == ']') { + s.len -= 2; + s.ptr++; + } + return s; +} + +const char *mg_url_uri(const char *url) { + struct url u = urlparse(url); + return u.uri ? url + u.uri : "/"; +} + +unsigned short mg_url_port(const char *url) { + struct url u = urlparse(url); + unsigned short port = 0; + if (memcmp(url, "http:", 5) == 0) port = 80; + if (memcmp(url, "https:", 6) == 0) port = 443; + if (u.port) port = (unsigned short) atoi(url + u.port); + return port; +} + +struct mg_str mg_url_user(const char *url) { + struct url u = urlparse(url); + struct mg_str s = mg_str(""); + if (u.user && (u.pass || u.host)) { + size_t n = u.pass ? u.pass - u.user - 1 : u.host - u.user - 1; + s = mg_str_n(url + u.user, n); + } + return s; +} + +struct mg_str mg_url_pass(const char *url) { + struct url u = urlparse(url); + struct mg_str s = mg_str_n("", 0UL); + if (u.pass && u.host) { + size_t n = u.host - u.pass - 1; + s = mg_str_n(url + u.pass, n); + } + return s; +} + +#ifdef MG_ENABLE_LINES +#line 1 "src/util.c" +#endif + +char *mg_file_read(const char *path, size_t *sizep) { + FILE *fp; + char *data = NULL; + size_t size = 0; + if ((fp = fopen(path, "rb")) != NULL) { + fseek(fp, 0, SEEK_END); + size = (size_t) ftell(fp); + rewind(fp); + data = (char *) calloc(1, size + 1); + if (data != NULL) { + if (fread(data, 1, size, fp) != size) { + free(data); + data = NULL; + } else { + data[size] = '\0'; + if (sizep != NULL) *sizep = size; + } + } + fclose(fp); + } + return data; +} + +bool mg_file_write(const char *path, const void *buf, size_t len) { + bool result = false; + FILE *fp; + char tmp[MG_PATH_MAX]; + snprintf(tmp, sizeof(tmp), "%s.%d", path, rand()); + fp = fopen(tmp, "wb"); + if (fp != NULL) { + result = fwrite(buf, 1, len, fp) == len; + fclose(fp); + if (result) { + remove(path); + rename(tmp, path); + } else { + remove(tmp); + } + } + return result; +} + +bool mg_file_printf(const char *path, const char *fmt, ...) { + char tmp[256], *buf = tmp; + bool result; + int len; + va_list ap; + va_start(ap, fmt); + len = mg_vasprintf(&buf, sizeof(tmp), fmt, ap); + va_end(ap); + result = mg_file_write(path, buf, len > 0 ? (size_t) len : 0); + if (buf != tmp) free(buf); + return result; +} + +#if MG_ENABLE_CUSTOM_RANDOM +#else +void mg_random(void *buf, size_t len) { + bool done = false; + unsigned char *p = (unsigned char *) buf; +#if MG_ARCH == MG_ARCH_ESP32 + while (len--) *p++ = (unsigned char) (esp_random() & 255); +#elif MG_ARCH == MG_ARCH_WIN32 +#elif MG_ARCH_UNIX + FILE *fp = fopen("/dev/urandom", "rb"); + if (fp != NULL) { + if (fread(buf, 1, len, fp) == len) done = true; + fclose(fp); + } +#endif + // Fallback to a pseudo random gen + if (!done) { + while (len--) *p++ = (unsigned char) (rand() & 255); + } +} +#endif + +bool mg_globmatch(const char *s1, size_t n1, const char *s2, size_t n2) { + size_t i = 0, j = 0, ni = 0, nj = 0; + while (i < n1 || j < n2) { + if (i < n1 && j < n2 && (s1[i] == '?' || s2[j] == s1[i])) { + i++, j++; + } else if (i < n1 && (s1[i] == '*' || s1[i] == '#')) { + ni = i, nj = j + 1, i++; + } else if (nj > 0 && nj <= n2 && (s1[ni] == '#' || s2[j] != '/')) { + i = ni, j = nj; + } else { + // printf(">>: [%s] [%s] %d %d %d %d\n", s1, s2, i, j, ni, nj); + return false; + } + } + return true; +} + +static size_t mg_nce(const char *s, size_t n, size_t ofs, size_t *koff, + size_t *klen, size_t *voff, size_t *vlen) { + size_t kvlen, kl; + for (kvlen = 0; ofs + kvlen < n && s[ofs + kvlen] != ',';) kvlen++; + for (kl = 0; kl < kvlen && s[ofs + kl] != '=';) kl++; + if (koff != NULL) *koff = ofs; + if (klen != NULL) *klen = kl; + if (voff != NULL) *voff = kl < kvlen ? ofs + kl + 1 : 0; + if (vlen != NULL) *vlen = kl < kvlen ? kvlen - kl - 1 : 0; + ofs += kvlen + 1; + return ofs > n ? n : ofs; +} + +bool mg_commalist(struct mg_str *s, struct mg_str *k, struct mg_str *v) { + size_t koff = 0, klen = 0, voff = 0, vlen = 0; + size_t off = mg_nce(s->ptr, s->len, 0, &koff, &klen, &voff, &vlen); + if (k != NULL) *k = mg_str_n(s->ptr + koff, klen); + if (v != NULL) *v = mg_str_n(s->ptr + voff, vlen); + *s = mg_str_n(s->ptr + off, s->len - off); + return off > 0; +} + +uint32_t mg_ntohl(uint32_t net) { + uint8_t data[4] = {0, 0, 0, 0}; + memcpy(&data, &net, sizeof(data)); + return (((uint32_t) data[3]) << 0) | (((uint32_t) data[2]) << 8) | + (((uint32_t) data[1]) << 16) | (((uint32_t) data[0]) << 24); +} + +uint16_t mg_ntohs(uint16_t net) { + uint8_t data[2] = {0, 0}; + memcpy(&data, &net, sizeof(data)); + return (uint16_t) ((uint16_t) data[1] | (((uint16_t) data[0]) << 8)); +} + +char *mg_hexdump(const void *buf, size_t len) { + const unsigned char *p = (const unsigned char *) buf; + size_t i, idx, n = 0, ofs = 0, dlen = len * 5 + 100; + char ascii[17] = "", *dst = (char *) calloc(1, dlen); + if (dst == NULL) return dst; + for (i = 0; i < len; i++) { + idx = i % 16; + if (idx == 0) { + if (i > 0 && dlen > n) + n += (size_t) snprintf(dst + n, dlen - n, " %s\n", ascii); + if (dlen > n) + n += (size_t) snprintf(dst + n, dlen - n, "%04x ", (int) (i + ofs)); + } + if (dlen < n) break; + n += (size_t) snprintf(dst + n, dlen - n, " %02x", p[i]); + ascii[idx] = (char) (p[i] < 0x20 || p[i] > 0x7e ? '.' : p[i]); + ascii[idx + 1] = '\0'; + } + while (i++ % 16) { + if (n < dlen) n += (size_t) snprintf(dst + n, dlen - n, "%s", " "); + } + if (n < dlen) n += (size_t) snprintf(dst + n, dlen - n, " %s\n", ascii); + if (n > dlen - 1) n = dlen - 1; + dst[n] = '\0'; + return dst; +} + +char *mg_hex(const void *buf, size_t len, char *to) { + const unsigned char *p = (const unsigned char *) buf; + static const char *hex = "0123456789abcdef"; + size_t i = 0; + for (; len--; p++) { + to[i++] = hex[p[0] >> 4]; + to[i++] = hex[p[0] & 0x0f]; + } + to[i] = '\0'; + return to; +} + +static unsigned char mg_unhex_nimble(unsigned char c) { + return (c >= '0' && c <= '9') ? (unsigned char) (c - '0') + : (c >= 'A' && c <= 'F') ? (unsigned char) (c - '7') + : (unsigned char) (c - 'W'); +} + +unsigned long mg_unhexn(const char *s, size_t len) { + unsigned long i = 0, v = 0; + for (i = 0; i < len; i++) v <<= 4, v |= mg_unhex_nimble(((uint8_t *) s)[i]); + return v; +} + +void mg_unhex(const char *buf, size_t len, unsigned char *to) { + size_t i; + for (i = 0; i < len; i += 2) { + to[i >> 1] = (unsigned char) mg_unhexn(&buf[i], 2); + } +} + +int mg_vasprintf(char **buf, size_t size, const char *fmt, va_list ap) { + va_list ap_copy; + int len; + + va_copy(ap_copy, ap); + len = vsnprintf(*buf, size, fmt, ap_copy); + va_end(ap_copy); + + if (len < 0) { + // eCos and Windows are not standard-compliant and return -1 when + // the buffer is too small. Keep allocating larger buffers until we + // succeed or out of memory. + // LCOV_EXCL_START + *buf = NULL; + while (len < 0) { + free(*buf); + if (size == 0) size = 5; + size *= 2; + if ((*buf = (char *) calloc(1, size)) == NULL) { + len = -1; + break; + } + va_copy(ap_copy, ap); + len = vsnprintf(*buf, size - 1, fmt, ap_copy); + va_end(ap_copy); + } + // Microsoft version of vsnprintf() is not always null-terminated, so put + // the terminator manually + if (*buf != NULL) (*buf)[len] = 0; + // LCOV_EXCL_STOP + } else if (len >= (int) size) { + /// Standard-compliant code path. Allocate a buffer that is large enough + if ((*buf = (char *) calloc(1, (size_t) len + 1)) == NULL) { + len = -1; // LCOV_EXCL_LINE + } else { // LCOV_EXCL_LINE + va_copy(ap_copy, ap); + len = vsnprintf(*buf, (size_t) len + 1, fmt, ap_copy); + va_end(ap_copy); + } + } + + return len; +} + +int mg_asprintf(char **buf, size_t size, const char *fmt, ...) { + int ret; + va_list ap; + va_start(ap, fmt); + ret = mg_vasprintf(buf, size, fmt, ap); + va_end(ap); + return ret; +} + +int64_t mg_to64(struct mg_str str) { + int64_t result = 0, neg = 1, max = 922337203685477570 /* INT64_MAX/10-10 */; + size_t i = 0; + while (i < str.len && (str.ptr[i] == ' ' || str.ptr[i] == '\t')) i++; + if (i < str.len && str.ptr[i] == '-') neg = -1, i++; + while (i < str.len && str.ptr[i] >= '0' && str.ptr[i] <= '9') { + if (result > max) return 0; + result *= 10; + result += (str.ptr[i] - '0'); + i++; + } + return result * neg; +} + +uint32_t mg_crc32(uint32_t crc, const char *buf, size_t len) { + int i; + crc = ~crc; + while (len--) { + crc ^= *(unsigned char *) buf++; + for (i = 0; i < 8; i++) crc = crc & 1 ? (crc >> 1) ^ 0xedb88320 : crc >> 1; + } + return ~crc; +} + +static int isbyte(int n) { + return n >= 0 && n <= 255; +} + +static int parse_net(const char *spec, uint32_t *net, uint32_t *mask) { + int n, a, b, c, d, slash = 32, len = 0; + if ((sscanf(spec, "%d.%d.%d.%d/%d%n", &a, &b, &c, &d, &slash, &n) == 5 || + sscanf(spec, "%d.%d.%d.%d%n", &a, &b, &c, &d, &n) == 4) && + isbyte(a) && isbyte(b) && isbyte(c) && isbyte(d) && slash >= 0 && + slash < 33) { + len = n; + *net = ((uint32_t) a << 24) | ((uint32_t) b << 16) | ((uint32_t) c << 8) | + (uint32_t) d; + *mask = slash ? (uint32_t) (0xffffffffU << (32 - slash)) : (uint32_t) 0; + } + return len; +} + +int mg_check_ip_acl(struct mg_str acl, uint32_t remote_ip) { + struct mg_str k, v; + int allowed = acl.len == 0 ? '+' : '-'; // If any ACL is set, deny by default + while (mg_commalist(&acl, &k, &v)) { + uint32_t net, mask; + if (k.ptr[0] != '+' && k.ptr[0] != '-') return -1; + if (parse_net(&k.ptr[1], &net, &mask) == 0) return -2; + if ((remote_ip & mask) == net) allowed = k.ptr[0]; + } + return allowed == '+'; +} + +double mg_time(void) { +#if MG_ARCH == MG_ARCH_WIN32 + SYSTEMTIME sysnow; + FILETIME ftime; + GetLocalTime(&sysnow); + SystemTimeToFileTime(&sysnow, &ftime); + /* + * 1. VC 6.0 doesn't support conversion uint64 -> double, so, using int64 + * This should not cause a problems in this (21th) century + * 2. Windows FILETIME is a number of 100-nanosecond intervals since January + * 1, 1601 while time_t is a number of _seconds_ since January 1, 1970 UTC, + * thus, we need to convert to seconds and adjust amount (subtract 11644473600 + * seconds) + */ + return (double) (((int64_t) ftime.dwLowDateTime + + ((int64_t) ftime.dwHighDateTime << 32)) / + 10000000.0) - + 11644473600; +#elif MG_ARCH == MG_ARCH_FREERTOS_TCP + return mg_millis() / 1000.0; +#else + struct timeval tv; + if (gettimeofday(&tv, NULL /* tz */) != 0) return 0; + return (double) tv.tv_sec + (((double) tv.tv_usec) / 1000000.0); +#endif /* _WIN32 */ +} + +void mg_usleep(unsigned long usecs) { +#if MG_ARCH == MG_ARCH_WIN32 + Sleep(usecs / 1000); +#elif MG_ARCH == MG_ARCH_ESP8266 + ets_delay_us(usecs); +#elif MG_ARCH == MG_ARCH_FREERTOS_TCP || MG_ARCH == MG_ARCH_FREERTOS_LWIP + vTaskDelay(pdMS_TO_TICKS(usecs / 1000)); +#else + usleep((useconds_t) usecs); +#endif +} + +unsigned long mg_millis(void) { +#if MG_ARCH == MG_ARCH_WIN32 + return GetTickCount(); +#elif MG_ARCH == MG_ARCH_ESP32 + return esp_timer_get_time() / 1000; +#elif MG_ARCH == MG_ARCH_ESP8266 + return xTaskGetTickCount() * portTICK_PERIOD_MS; +#elif MG_ARCH == MG_ARCH_FREERTOS_TCP || MG_ARCH == MG_ARCH_FREERTOS_LWIP + return xTaskGetTickCount() * portTICK_PERIOD_MS; +#else + struct timespec ts; + clock_gettime(CLOCK_REALTIME, &ts); + return (unsigned long) ((uint64_t) ts.tv_sec * 1000 + + (uint64_t) ts.tv_nsec / 1000000); +#endif +} + diff --git a/mongoose.h b/mongoose.h new file mode 100644 index 0000000..ddd88ce --- /dev/null +++ b/mongoose.h @@ -0,0 +1,737 @@ +// Copyright (c) 2004-2013 Sergey Lyubka +// Copyright (c) 2013-2021 Cesanta Software Limited +// All rights reserved +// +// This software is dual-licensed: you can redistribute it and/or modify +// it under the terms of the GNU General Public License version 2 as +// published by the Free Software Foundation. For the terms of this +// license, see . +// +// You are free to use this software under the terms of the GNU General +// Public License, 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. +// +// Alternatively, you can license this software under a commercial +// license, as set out in . + +#ifndef MONGOOSE_H +#define MONGOOSE_H + +#define MG_VERSION "7.4" + +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef MG_ENABLE_SOCKET +#define MG_ENABLE_SOCKET 1 +#endif + +#ifndef MG_ENABLE_IPV6 +#define MG_ENABLE_IPV6 0 +#endif + +#ifndef MG_ENABLE_LOG +#define MG_ENABLE_LOG 1 +#endif + +// Set MG_ENABLE_WINSOCK=0 for Win32 builds with external IP stack (like LWIP) +#ifndef MG_ENABLE_WINSOCK +#define MG_ENABLE_WINSOCK 1 +#endif + +#ifndef MG_ENABLE_DIRLIST +#define MG_ENABLE_DIRLIST 0 +#endif + +#ifndef MG_ENABLE_CUSTOM_RANDOM +#define MG_ENABLE_CUSTOM_RANDOM 0 +#endif + +#ifndef MG_ENABLE_PACKED_FS +#define MG_ENABLE_PACKED_FS 0 +#endif + +// Granularity of the send/recv IO buffer growth +#ifndef MG_IO_SIZE +#define MG_IO_SIZE 2048 +#endif + +// Maximum size of the recv IO buffer +#ifndef MG_MAX_RECV_BUF_SIZE +#define MG_MAX_RECV_BUF_SIZE (3 * 1024 * 1024) +#endif + +#ifndef MG_MAX_HTTP_HEADERS +#define MG_MAX_HTTP_HEADERS 40 +#endif + +#ifndef MG_PATH_MAX +#define MG_PATH_MAX PATH_MAX +#endif + +#define MG_ARCH_CUSTOM 0 +#define MG_ARCH_UNIX 1 +#define MG_ARCH_WIN32 2 +#define MG_ARCH_ESP32 3 +#define MG_ARCH_ESP8266 4 +#define MG_ARCH_FREERTOS_TCP 5 +#define MG_ARCH_FREERTOS_LWIP 6 + +#if !defined(MG_ARCH) +#if defined(__unix__) || defined(__APPLE__) +#define MG_ARCH MG_ARCH_UNIX +#elif defined(_WIN32) +#define MG_ARCH MG_ARCH_WIN32 +#elif defined(ICACHE_FLASH) || defined(ICACHE_RAM_ATTR) +#define MG_ARCH MG_ARCH_ESP8266 +#elif defined(ESP_PLATFORM) +#define MG_ARCH MG_ARCH_ESP32 +#elif defined(FREERTOS_IP_H) +#define MG_ARCH MG_ARCH_FREERTOS_TCP +#endif + +#if !defined(MG_ARCH) +#error "MG_ARCH is not specified and we couldn't guess it." +#endif +#endif // !defined(MG_ARCH) + +#if !defined(PRINTF_LIKE) +#if defined(__GNUC__) || defined(__clang__) || defined(__TI_COMPILER_VERSION__) +#define PRINTF_LIKE(f, a) __attribute__((format(printf, f, a))) +#else +#define PRINTF_LIKE(f, a) +#endif +#endif + +#if MG_ARCH == MG_ARCH_CUSTOM +#include +#endif + +#if MG_ARCH == MG_ARCH_ESP32 + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#define MG_DIRSEP '/' +#define MG_INT64_FMT "%lld" +#ifndef MG_PATH_MAX +#define MG_PATH_MAX 128 +#endif +#undef MG_ENABLE_DIRLIST +#define MG_ENABLE_DIRLIST 1 + +#endif + +#if MG_ARCH == MG_ARCH_ESP8266 + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +#define MG_DIRSEP '/' +#define MG_INT64_FMT "%lld" + +#endif + +#if MG_ARCH == MG_ARCH_FREERTOS_LWIP + +#include +#include +#include +#include + +#if defined(__GNUC__) +#include +#include +#else +typedef long suseconds_t; +struct timeval { + time_t tv_sec; + suseconds_t tv_usec; +}; +#endif + +#include +#include + +#include + +#if LWIP_SOCKET != 1 +// Sockets support disabled in LWIP by default +#error Set LWIP_SOCKET variable to 1 (in lwipopts.h) +#endif + +#if LWIP_POSIX_SOCKETS_IO_NAMES != 0 +// LWIP_POSIX_SOCKETS_IO_NAMES must be disabled in posix-compatible OS +// enviroment (freertos mimics to one) otherwise names like `read` and `write` +// conflict +#error LWIP_POSIX_SOCKETS_IO_NAMES must be set to 0 (in lwipopts.h) for FreeRTOS +#endif + +#define MG_INT64_FMT "%lld" +#define MG_DIRSEP '/' + +// Re-route calloc/free to the FreeRTOS's functions, don't use stdlib +static inline void *mg_calloc(int cnt, size_t size) { + void *p = pvPortMalloc(cnt * size); + if (p != NULL) memset(p, 0, size); + return p; +} +#define calloc(a, b) mg_calloc((a), (b)) +#define free(a) vPortFree(a) +#define malloc(a) pvPortMalloc(a) + +#define gmtime_r(a, b) gmtime(a) + +#endif // MG_ARCH == MG_ARCH_FREERTOS_LWIP + +#if MG_ARCH == MG_ARCH_FREERTOS_TCP + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include + +#define MG_INT64_FMT "%lld" +#define MG_DIRSEP '/' + +// Why FreeRTOS-TCP did not implement a clean BSD API, but its own thing +// with FreeRTOS_ prefix, is beyond me +#define IPPROTO_TCP FREERTOS_IPPROTO_TCP +#define IPPROTO_UDP FREERTOS_IPPROTO_UDP +#define AF_INET FREERTOS_AF_INET +#define SOCK_STREAM FREERTOS_SOCK_STREAM +#define SOCK_DGRAM FREERTOS_SOCK_DGRAM +#define SO_BROADCAST 0 +#define SO_ERROR 0 +#define SOL_SOCKET 0 +#define SO_REUSEADDR 0 +#define sockaddr_in freertos_sockaddr +#define sockaddr freertos_sockaddr +#define accept(a, b, c) FreeRTOS_accept((a), (b), (c)) +#define connect(a, b, c) FreeRTOS_connect((a), (b), (c)) +#define bind(a, b, c) FreeRTOS_bind((a), (b), (c)) +#define listen(a, b) FreeRTOS_listen((a), (b)) +#define socket(a, b, c) FreeRTOS_socket((a), (b), (c)) +#define send(a, b, c, d) FreeRTOS_send((a), (b), (c), (d)) +#define recv(a, b, c, d) FreeRTOS_recv((a), (b), (c), (d)) +#define setsockopt(a, b, c, d, e) FreeRTOS_setsockopt((a), (b), (c), (d), (e)) +#define sendto(a, b, c, d, e, f) FreeRTOS_sendto((a), (b), (c), (d), (e), (f)) +#define recvfrom(a, b, c, d, e, f) \ + FreeRTOS_recvfrom((a), (b), (c), (d), (e), (f)) +#define closesocket(x) FreeRTOS_closesocket(x) +#define gethostbyname(x) FreeRTOS_gethostbyname(x) +#define getsockname(a, b, c) (-1) + +// Re-route calloc/free to the FreeRTOS's functions, don't use stdlib +static inline void *mg_calloc(int cnt, size_t size) { + void *p = pvPortMalloc(cnt * size); + if (p != NULL) memset(p, 0, size); + return p; +} +#define calloc(a, b) mg_calloc((a), (b)) +#define free(a) vPortFree(a) +#define malloc(a) pvPortMalloc(a) + +#define gmtime_r(a, b) gmtime(a) + +#if !defined(__GNUC__) +// copied from GCC on ARM; for some reason useconds are signed +typedef long suseconds_t; +struct timeval { + time_t tv_sec; + suseconds_t tv_usec; +}; +#endif + +#ifndef EINPROGRESS +#define EINPROGRESS pdFREERTOS_ERRNO_EINPROGRESS +#endif +#ifndef EWOULDBLOCK +#define EWOULDBLOCK pdFREERTOS_ERRNO_EWOULDBLOCK +#endif +#ifndef EAGAIN +#define EAGAIN pdFREERTOS_ERRNO_EAGAIN +#endif +#ifndef EINTR +#define EINTR pdFREERTOS_ERRNO_EINTR +#endif + +#endif // MG_ARCH == MG_ARCH_FREERTOS_TCP + +#if MG_ARCH == MG_ARCH_UNIX + +#define _DARWIN_UNLIMITED_SELECT 1 // No limit on file descriptors + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#define MG_DIRSEP '/' +#define MG_INT64_FMT "%" PRId64 +#undef MG_ENABLE_DIRLIST +#define MG_ENABLE_DIRLIST 1 + +#endif + +#if MG_ARCH == MG_ARCH_WIN32 + +#ifndef WIN32_LEAN_AND_MEAN +#define WIN32_LEAN_AND_MEAN +#endif + +#ifndef _CRT_SECURE_NO_WARNINGS +#define _CRT_SECURE_NO_WARNINGS +#endif + +#ifndef _WINSOCK_DEPRECATED_NO_WARNINGS +#define _WINSOCK_DEPRECATED_NO_WARNINGS +#endif + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#if defined(_MSC_VER) && _MSC_VER < 1700 +#define __func__ "" +typedef __int64 int64_t; +typedef unsigned __int64 uint64_t; +typedef unsigned char uint8_t; +typedef char int8_t; +typedef unsigned short uint16_t; +typedef short int16_t; +typedef unsigned int uint32_t; +typedef int int32_t; +typedef enum { false = 0, true = 1 } bool; +#else +#include +#include +#include +#endif + +#include + +// Protect from calls like std::snprintf in app code +// See https://github.com/cesanta/mongoose/issues/1047 +#ifndef __cplusplus +#define snprintf _snprintf +#define vsnprintf _vsnprintf +#define strdup(x) _strdup(x) +#endif + +typedef unsigned suseconds_t; +typedef int socklen_t; +#define MG_DIRSEP '\\' +#ifndef PATH_MAX +#define PATH_MAX MAX_PATH +#endif +#ifndef EINPROGRESS +#define EINPROGRESS WSAEINPROGRESS +#endif +#ifndef EWOULDBLOCK +#define EWOULDBLOCK WSAEWOULDBLOCK +#endif + +#ifndef va_copy +#ifdef __va_copy +#define va_copy __va_copy +#else +#define va_copy(x, y) (x) = (y) +#endif +#endif +#ifndef S_ISDIR +#define S_ISDIR(x) (((x) &_S_IFMT) == _S_IFDIR) +#endif + +#define MG_INT64_FMT "%I64d" + +#undef MG_ENABLE_DIRLIST +#define MG_ENABLE_DIRLIST 1 + +// https://lgtm.com/rules/2154840805/ -gmtime, localtime, ctime and asctime +static __inline struct tm *gmtime_r(time_t *t, struct tm *tm) { + (void) tm; + return gmtime(t); +} + +static __inline struct tm *localtime_r(time_t *t, struct tm *tm) { + (void) tm; + return localtime(t); +} + +#endif + +#include +#include + +struct mg_str { + const char *ptr; // Pointer to string data + size_t len; // String len +}; + +#define MG_NULL_STR \ + { NULL, 0 } + +// Using macro to avoid shadowing C++ struct constructor, see #1298 +#define mg_str(s) mg_str_s(s) + +struct mg_str mg_str(const char *s); +struct mg_str mg_str_n(const char *s, size_t n); +int mg_lower(const char *s); +int mg_ncasecmp(const char *s1, const char *s2, size_t len); +int mg_casecmp(const char *s1, const char *s2); +int mg_vcmp(const struct mg_str *s1, const char *s2); +int mg_vcasecmp(const struct mg_str *str1, const char *str2); +int mg_strcmp(const struct mg_str str1, const struct mg_str str2); +struct mg_str mg_strstrip(struct mg_str s); +struct mg_str mg_strdup(const struct mg_str s); +const char *mg_strstr(const struct mg_str haystack, const struct mg_str needle); + +#if MG_ENABLE_LOG +#define LOG(level, args) \ + do { \ + if (mg_log_prefix((level), __FILE__, __LINE__, __func__)) mg_log args; \ + } while (0) +enum { LL_NONE, LL_ERROR, LL_INFO, LL_DEBUG, LL_VERBOSE_DEBUG }; +bool mg_log_prefix(int ll, const char *file, int line, const char *fname); +void mg_log(const char *fmt, ...) PRINTF_LIKE(1, 2); +void mg_log_set(const char *spec); +void mg_log_set_callback(void (*fn)(const void *, size_t, void *), void *param); +#else +#define LOG(level, args) (void) 0 +#define mg_log_set(x) (void) (x) +#endif + +struct mg_timer { + unsigned long period_ms; // Timer period in milliseconds + unsigned flags; // Possible flags values below + void (*fn)(void *); // Function to call + void *arg; // Function argument + unsigned long expire; // Expiration timestamp in milliseconds + struct mg_timer *next; // Linkage in g_timers list +}; + +#define MG_TIMER_REPEAT 1 // Call function periodically, otherwise run once +#define MG_TIMER_RUN_NOW 2 // Call immediately when timer is set + +extern struct mg_timer *g_timers; // Global list of timers + +void mg_timer_init(struct mg_timer *, unsigned long ms, unsigned, + void (*fn)(void *), void *); +void mg_timer_free(struct mg_timer *); +void mg_timer_poll(unsigned long uptime_ms); + +char *mg_file_read(const char *path, size_t *size); +bool mg_file_write(const char *path, const void *buf, size_t len); +bool mg_file_printf(const char *path, const char *fmt, ...); +void mg_random(void *buf, size_t len); +bool mg_globmatch(const char *pattern, size_t plen, const char *s, size_t n); +bool mg_commalist(struct mg_str *s, struct mg_str *k, struct mg_str *v); +uint16_t mg_ntohs(uint16_t net); +uint32_t mg_ntohl(uint32_t net); +uint32_t mg_crc32(uint32_t crc, const char *buf, size_t len); +char *mg_hexdump(const void *buf, size_t len); +char *mg_hex(const void *buf, size_t len, char *dst); +void mg_unhex(const char *buf, size_t len, unsigned char *to); +unsigned long mg_unhexn(const char *s, size_t len); +int mg_asprintf(char **buf, size_t size, const char *fmt, ...); +int mg_vasprintf(char **buf, size_t size, const char *fmt, va_list ap); +int64_t mg_to64(struct mg_str str); +int mg_check_ip_acl(struct mg_str acl, uint32_t remote_ip); +double mg_time(void); +unsigned long mg_millis(void); +void mg_usleep(unsigned long usecs); + +#define mg_htons(x) mg_ntohs(x) +#define mg_htonl(x) mg_ntohl(x) + +// Expands to a string representation of its argument: e.g. +// MG_STRINGIFY_LITERAL(5) expands to "5" +#if !defined(_MSC_VER) || _MSC_VER >= 1900 +#define MG_STRINGIFY_LITERAL(...) #__VA_ARGS__ +#else +#define MG_STRINGIFY_LITERAL(x) #x +#endif +// Expands to a string representation of its argument, which can be a macro: +// #define FOO 123 +// MG_STRINGIFY_MACRO(FOO) // Expands to 123 +#define MG_STRINGIFY_MACRO(x) MG_STRINGIFY_LITERAL(x) + +// Linked list management macros +#define LIST_ADD_HEAD(type_, head_, elem_) \ + do { \ + (elem_)->next = (*head_); \ + *(head_) = (elem_); \ + } while (0) + +#define LIST_ADD_TAIL(type_, head_, elem_) \ + do { \ + type_ **h = head_; \ + while (*h != NULL) h = &(*h)->next; \ + *h = (elem_); \ + } while (0) + +#define LIST_DELETE(type_, head_, elem_) \ + do { \ + type_ **h = head_; \ + while (*h != (elem_)) h = &(*h)->next; \ + *h = (elem_)->next; \ + } while (0) + +enum { MG_FS_READ = 1, MG_FS_WRITE = 2, MG_FS_DIR = 4 }; + +// Filesystem API functions +// stat() returns MG_FS_* flags and populates file size and modification time +// list() calls fn() for every directory entry, allowing to list a directory +struct mg_fs { + int (*stat)(const char *path, size_t *size, time_t *mtime); + void (*list)(const char *path, void (*fn)(const char *, void *), void *); + struct mg_fd *(*open)(const char *path, int flags); // Open file + void (*close)(struct mg_fd *fd); // Close file + size_t (*read)(void *fd, void *buf, size_t len); // Read file + size_t (*write)(void *fd, const void *buf, size_t len); // Write file + size_t (*seek)(void *fd, size_t offset); // Set file position +}; + +// File descriptor +struct mg_fd { + void *fd; + struct mg_fs *fs; +}; + +extern struct mg_fs mg_fs_posix; // POSIX open/close/read/write/seek +extern struct mg_fs mg_fs_packed; // Packed FS, see examples/complete + +unsigned short mg_url_port(const char *url); +int mg_url_is_ssl(const char *url); +struct mg_str mg_url_host(const char *url); +struct mg_str mg_url_user(const char *url); +struct mg_str mg_url_pass(const char *url); +const char *mg_url_uri(const char *url); + +#include + +struct mg_iobuf { + unsigned char *buf; // Pointer to stored data + size_t size; // Total size available + size_t len; // Current number of bytes +}; + +int mg_iobuf_init(struct mg_iobuf *, size_t); +int mg_iobuf_resize(struct mg_iobuf *, size_t); +void mg_iobuf_free(struct mg_iobuf *); +size_t mg_iobuf_add(struct mg_iobuf *, size_t, const void *, size_t, size_t); +size_t mg_iobuf_del(struct mg_iobuf *, size_t ofs, size_t len); + +struct mg_connection; +typedef void (*mg_event_handler_t)(struct mg_connection *, int ev, + void *ev_data, void *fn_data); +void mg_call(struct mg_connection *c, int ev, void *ev_data); +void mg_error(struct mg_connection *c, const char *fmt, ...); + +enum { + MG_EV_ERROR, // Error char *error_message + MG_EV_POLL, // mg_mgr_poll iteration unsigned long *millis + MG_EV_RESOLVE, // Host name is resolved NULL + MG_EV_CONNECT, // Connection established NULL + MG_EV_ACCEPT, // Connection accepted NULL + MG_EV_READ, // Data received from socket struct mg_str * + MG_EV_WRITE, // Data written to socket long *bytes_written + MG_EV_CLOSE, // Connection closed NULL + MG_EV_HTTP_MSG, // HTTP request/response struct mg_http_message * + MG_EV_HTTP_CHUNK, // HTTP chunk (partial msg) struct mg_http_message * + MG_EV_USER, // Starting ID for user events +}; + +struct mg_addr { + uint16_t port; // TCP or UDP port in network byte order + uint32_t ip; // IP address in network byte order + uint8_t ip6[16]; // IPv6 address + bool is_ip6; // True when address is IPv6 address +}; + +struct mg_mgr { + struct mg_connection *conns; // List of active connections + unsigned long nextid; // Next connection ID + void *userdata; // Arbitrary user data pointer +#if MG_ARCH == MG_ARCH_FREERTOS_TCP + SocketSet_t ss; // NOTE(lsm): referenced from socket struct +#endif +}; + +struct mg_connection { + struct mg_connection *next; // Linkage in struct mg_mgr :: connections + struct mg_mgr *mgr; // Our container + struct mg_addr peer; // Remote address. For listeners, local address + void *fd; // Connected socket, or LWIP data + unsigned long id; // Auto-incrementing unique connection ID + struct mg_iobuf recv; // Incoming data + struct mg_iobuf send; // Outgoing data + mg_event_handler_t fn; // User-specified event handler function + void *fn_data; // User-specified function parameter + mg_event_handler_t pfn; // Protocol-specific handler function + void *pfn_data; // Protocol-specific function parameter + char label[50]; // Arbitrary label + void *tls; // TLS specific data + unsigned is_listening : 1; // Listening connection + unsigned is_client : 1; // Outbound (client) connection + unsigned is_accepted : 1; // Accepted (server) connection + unsigned is_resolving : 1; // Non-blocking DNS resolution is in progress + unsigned is_connecting : 1; // Non-blocking connect is in progress + unsigned is_tls : 1; // TLS-enabled connection + unsigned is_tls_hs : 1; // TLS handshake is in progress + unsigned is_udp : 1; // UDP connection + unsigned is_websocket : 1; // WebSocket connection + unsigned is_hexdumping : 1; // Hexdump in/out traffic + unsigned is_draining : 1; // Send remaining data, then close and free + unsigned is_closing : 1; // Close and free the connection immediately + unsigned is_readable : 1; // Connection is ready to read + unsigned is_writable : 1; // Connection is ready to write +}; + +void mg_mgr_poll(struct mg_mgr *, int ms); +void mg_mgr_init(struct mg_mgr *); +void mg_mgr_free(struct mg_mgr *); + +struct mg_connection *mg_listen(struct mg_mgr *, const char *url, + mg_event_handler_t fn, void *fn_data); +struct mg_connection *mg_connect(struct mg_mgr *, const char *url, + mg_event_handler_t fn, void *fn_data); +bool mg_send(struct mg_connection *, const void *, size_t); +int mg_printf(struct mg_connection *, const char *fmt, ...); +int mg_vprintf(struct mg_connection *, const char *fmt, va_list ap); +char *mg_straddr(struct mg_connection *, char *, size_t); +bool mg_aton(struct mg_str str, struct mg_addr *addr); +char *mg_ntoa(const struct mg_addr *addr, char *buf, size_t len); + +struct mg_connection *mg_mkpipe(struct mg_mgr *, mg_event_handler_t, void *); +void mg_mgr_wakeup(struct mg_connection *pipe); + +struct mg_http_header { + struct mg_str name; // Header name + struct mg_str value; // Header value +}; + +struct mg_http_message { + struct mg_str method, uri, query, proto; // Request/response line + struct mg_http_header headers[MG_MAX_HTTP_HEADERS]; // Headers + struct mg_str body; // Body + struct mg_str head; // Request + headers + struct mg_str chunk; // Chunk for chunked encoding, or partial body + struct mg_str message; // Request + headers + body +}; + +// Parameter for mg_http_serve_dir() +struct mg_http_serve_opts { + const char *root_dir; // Web root directory, must be non-NULL + const char *extra_headers; // Extra HTTP headers to add in responses + const char *mime_types; // Extra mime types, ext1=type1,ext2=type2,.. + struct mg_fs *fs; // Filesystem implementation. Use NULL for POSIX +}; + +// Parameter for mg_http_next_multipart +struct mg_http_part { + struct mg_str name; // Form field name + struct mg_str filename; // Filename for file uploads + struct mg_str body; // Part contents +}; + +int mg_http_parse(const char *s, size_t len, struct mg_http_message *); +int mg_http_get_request_len(const unsigned char *buf, size_t buf_len); +void mg_http_printf_chunk(struct mg_connection *cnn, const char *fmt, ...); +void mg_http_write_chunk(struct mg_connection *c, const char *buf, size_t len); +void mg_http_delete_chunk(struct mg_connection *c, struct mg_http_message *hm); +struct mg_connection *mg_http_listen(struct mg_mgr *, const char *url, + mg_event_handler_t fn, void *fn_data); +struct mg_connection *mg_http_connect(struct mg_mgr *, const char *url, + mg_event_handler_t fn, void *fn_data); +void mg_http_serve_dir(struct mg_connection *, struct mg_http_message *hm, + struct mg_http_serve_opts *opts); +void mg_http_serve_file(struct mg_connection *, struct mg_http_message *hm, + const char *path, struct mg_http_serve_opts *opts); +void mg_http_reply(struct mg_connection *, int status_code, const char *headers, + const char *body_fmt, ...); +struct mg_str *mg_http_get_header(struct mg_http_message *, const char *name); +int mg_http_get_var(const struct mg_str *, const char *name, char *, size_t); +int mg_url_decode(const char *s, size_t n, char *to, size_t to_len, int form); +size_t mg_url_encode(const char *s, size_t n, char *buf, size_t len); +bool mg_http_match_uri(const struct mg_http_message *, const char *glob); +struct mg_str mg_http_get_header_var(struct mg_str s, struct mg_str v); +size_t mg_http_next_multipart(struct mg_str, size_t, struct mg_http_part *); + +#ifdef __cplusplus +} +#endif +#endif // MONGOOSE_H +