commit 40a756ec8e472c8ed0b43ae0e9e87a6edbf51450 Author: Daniele Lacamera Date: Sun Oct 27 13:23:31 2024 +0100 Initial import diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..1474cb7 --- /dev/null +++ b/.gitignore @@ -0,0 +1,6 @@ +*.o +*.a +*.pcap +build/* +test/unit/unit-core +tags diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..f288702 --- /dev/null +++ b/LICENSE @@ -0,0 +1,674 @@ + GNU GENERAL PUBLIC LICENSE + Version 3, 29 June 2007 + + Copyright (C) 2007 Free Software Foundation, Inc. + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + Preamble + + The GNU General Public License is a free, copyleft license for +software and other kinds of works. + + The licenses for most software and other practical works are designed +to take away your freedom to share and change the works. By contrast, +the GNU General Public License is intended to guarantee your freedom to +share and change all versions of a program--to make sure it remains free +software for all its users. We, the Free Software Foundation, use the +GNU General Public License for most of our software; it applies also to +any other work released this way by its authors. You can apply it to +your programs, too. + + When we speak of free software, we are referring to freedom, not +price. Our General Public Licenses are designed to make sure that you +have the freedom to distribute copies of free software (and charge for +them if you wish), that you receive source code or can get it if you +want it, that you can change the software or use pieces of it in new +free programs, and that you know you can do these things. + + To protect your rights, we need to prevent others from denying you +these rights or asking you to surrender the rights. Therefore, you have +certain responsibilities if you distribute copies of the software, or if +you modify it: responsibilities to respect the freedom of others. + + For example, if you distribute copies of such a program, whether +gratis or for a fee, you must pass on to the recipients the same +freedoms that you received. You must make sure that they, too, receive +or can get the source code. And you must show them these terms so they +know their rights. + + Developers that use the GNU GPL protect your rights with two steps: +(1) assert copyright on the software, and (2) offer you this License +giving you legal permission to copy, distribute and/or modify it. + + For the developers' and authors' protection, the GPL clearly explains +that there is no warranty for this free software. For both users' and +authors' sake, the GPL requires that modified versions be marked as +changed, so that their problems will not be attributed erroneously to +authors of previous versions. + + Some devices are designed to deny users access to install or run +modified versions of the software inside them, although the manufacturer +can do so. This is fundamentally incompatible with the aim of +protecting users' freedom to change the software. The systematic +pattern of such abuse occurs in the area of products for individuals to +use, which is precisely where it is most unacceptable. Therefore, we +have designed this version of the GPL to prohibit the practice for those +products. If such problems arise substantially in other domains, we +stand ready to extend this provision to those domains in future versions +of the GPL, as needed to protect the freedom of users. + + Finally, every program is threatened constantly by software patents. +States should not allow patents to restrict development and use of +software on general-purpose computers, but in those that do, we wish to +avoid the special danger that patents applied to a free program could +make it effectively proprietary. To prevent this, the GPL assures that +patents cannot be used to render the program non-free. + + The precise terms and conditions for copying, distribution and +modification follow. + + TERMS AND CONDITIONS + + 0. Definitions. + + "This License" refers to version 3 of the GNU General Public License. + + "Copyright" also means copyright-like laws that apply to other kinds of +works, such as semiconductor masks. + + "The Program" refers to any copyrightable work licensed under this +License. Each licensee is addressed as "you". "Licensees" and +"recipients" may be individuals or organizations. + + To "modify" a work means to copy from or adapt all or part of the work +in a fashion requiring copyright permission, other than the making of an +exact copy. The resulting work is called a "modified version" of the +earlier work or a work "based on" the earlier work. + + A "covered work" means either the unmodified Program or a work based +on the Program. + + To "propagate" a work means to do anything with it that, without +permission, would make you directly or secondarily liable for +infringement under applicable copyright law, except executing it on a +computer or modifying a private copy. Propagation includes copying, +distribution (with or without modification), making available to the +public, and in some countries other activities as well. + + To "convey" a work means any kind of propagation that enables other +parties to make or receive copies. Mere interaction with a user through +a computer network, with no transfer of a copy, is not conveying. + + An interactive user interface displays "Appropriate Legal Notices" +to the extent that it includes a convenient and prominently visible +feature that (1) displays an appropriate copyright notice, and (2) +tells the user that there is no warranty for the work (except to the +extent that warranties are provided), that licensees may convey the +work under this License, and how to view a copy of this License. If +the interface presents a list of user commands or options, such as a +menu, a prominent item in the list meets this criterion. + + 1. Source Code. + + The "source code" for a work means the preferred form of the work +for making modifications to it. "Object code" means any non-source +form of a work. + + A "Standard Interface" means an interface that either is an official +standard defined by a recognized standards body, or, in the case of +interfaces specified for a particular programming language, one that +is widely used among developers working in that language. + + The "System Libraries" of an executable work include anything, other +than the work as a whole, that (a) is included in the normal form of +packaging a Major Component, but which is not part of that Major +Component, and (b) serves only to enable use of the work with that +Major Component, or to implement a Standard Interface for which an +implementation is available to the public in source code form. A +"Major Component", in this context, means a major essential component +(kernel, window system, and so on) of the specific operating system +(if any) on which the executable work runs, or a compiler used to +produce the work, or an object code interpreter used to run it. + + The "Corresponding Source" for a work in object code form means all +the source code needed to generate, install, and (for an executable +work) run the object code and to modify the work, including scripts to +control those activities. However, it does not include the work's +System Libraries, or general-purpose tools or generally available free +programs which are used unmodified in performing those activities but +which are not part of the work. For example, Corresponding Source +includes interface definition files associated with source files for +the work, and the source code for shared libraries and dynamically +linked subprograms that the work is specifically designed to require, +such as by intimate data communication or control flow between those +subprograms and other parts of the work. + + The Corresponding Source need not include anything that users +can regenerate automatically from other parts of the Corresponding +Source. + + The Corresponding Source for a work in source code form is that +same work. + + 2. Basic Permissions. + + All rights granted under this License are granted for the term of +copyright on the Program, and are irrevocable provided the stated +conditions are met. This License explicitly affirms your unlimited +permission to run the unmodified Program. The output from running a +covered work is covered by this License only if the output, given its +content, constitutes a covered work. This License acknowledges your +rights of fair use or other equivalent, as provided by copyright law. + + You may make, run and propagate covered works that you do not +convey, without conditions so long as your license otherwise remains +in force. You may convey covered works to others for the sole purpose +of having them make modifications exclusively for you, or provide you +with facilities for running those works, provided that you comply with +the terms of this License in conveying all material for which you do +not control copyright. Those thus making or running the covered works +for you must do so exclusively on your behalf, under your direction +and control, on terms that prohibit them from making any copies of +your copyrighted material outside their relationship with you. + + Conveying under any other circumstances is permitted solely under +the conditions stated below. Sublicensing is not allowed; section 10 +makes it unnecessary. + + 3. Protecting Users' Legal Rights From Anti-Circumvention Law. + + No covered work shall be deemed part of an effective technological +measure under any applicable law fulfilling obligations under article +11 of the WIPO copyright treaty adopted on 20 December 1996, or +similar laws prohibiting or restricting circumvention of such +measures. + + When you convey a covered work, you waive any legal power to forbid +circumvention of technological measures to the extent such circumvention +is effected by exercising rights under this License with respect to +the covered work, and you disclaim any intention to limit operation or +modification of the work as a means of enforcing, against the work's +users, your or third parties' legal rights to forbid circumvention of +technological measures. + + 4. Conveying Verbatim Copies. + + You may convey verbatim copies of the Program's source code as you +receive it, in any medium, provided that you conspicuously and +appropriately publish on each copy an appropriate copyright notice; +keep intact all notices stating that this License and any +non-permissive terms added in accord with section 7 apply to the code; +keep intact all notices of the absence of any warranty; and give all +recipients a copy of this License along with the Program. + + You may charge any price or no price for each copy that you convey, +and you may offer support or warranty protection for a fee. + + 5. Conveying Modified Source Versions. + + You may convey a work based on the Program, or the modifications to +produce it from the Program, in the form of source code under the +terms of section 4, provided that you also meet all of these conditions: + + a) The work must carry prominent notices stating that you modified + it, and giving a relevant date. + + b) The work must carry prominent notices stating that it is + released under this License and any conditions added under section + 7. This requirement modifies the requirement in section 4 to + "keep intact all notices". + + c) You must license the entire work, as a whole, under this + License to anyone who comes into possession of a copy. This + License will therefore apply, along with any applicable section 7 + additional terms, to the whole of the work, and all its parts, + regardless of how they are packaged. This License gives no + permission to license the work in any other way, but it does not + invalidate such permission if you have separately received it. + + d) If the work has interactive user interfaces, each must display + Appropriate Legal Notices; however, if the Program has interactive + interfaces that do not display Appropriate Legal Notices, your + work need not make them do so. + + A compilation of a covered work with other separate and independent +works, which are not by their nature extensions of the covered work, +and which are not combined with it such as to form a larger program, +in or on a volume of a storage or distribution medium, is called an +"aggregate" if the compilation and its resulting copyright are not +used to limit the access or legal rights of the compilation's users +beyond what the individual works permit. Inclusion of a covered work +in an aggregate does not cause this License to apply to the other +parts of the aggregate. + + 6. Conveying Non-Source Forms. + + You may convey a covered work in object code form under the terms +of sections 4 and 5, provided that you also convey the +machine-readable Corresponding Source under the terms of this License, +in one of these ways: + + a) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by the + Corresponding Source fixed on a durable physical medium + customarily used for software interchange. + + b) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by a + written offer, valid for at least three years and valid for as + long as you offer spare parts or customer support for that product + model, to give anyone who possesses the object code either (1) a + copy of the Corresponding Source for all the software in the + product that is covered by this License, on a durable physical + medium customarily used for software interchange, for a price no + more than your reasonable cost of physically performing this + conveying of source, or (2) access to copy the + Corresponding Source from a network server at no charge. + + c) Convey individual copies of the object code with a copy of the + written offer to provide the Corresponding Source. This + alternative is allowed only occasionally and noncommercially, and + only if you received the object code with such an offer, in accord + with subsection 6b. + + d) Convey the object code by offering access from a designated + place (gratis or for a charge), and offer equivalent access to the + Corresponding Source in the same way through the same place at no + further charge. You need not require recipients to copy the + Corresponding Source along with the object code. If the place to + copy the object code is a network server, the Corresponding Source + may be on a different server (operated by you or a third party) + that supports equivalent copying facilities, provided you maintain + clear directions next to the object code saying where to find the + Corresponding Source. Regardless of what server hosts the + Corresponding Source, you remain obligated to ensure that it is + available for as long as needed to satisfy these requirements. + + e) Convey the object code using peer-to-peer transmission, provided + you inform other peers where the object code and Corresponding + Source of the work are being offered to the general public at no + charge under subsection 6d. + + A separable portion of the object code, whose source code is excluded +from the Corresponding Source as a System Library, need not be +included in conveying the object code work. + + A "User Product" is either (1) a "consumer product", which means any +tangible personal property which is normally used for personal, family, +or household purposes, or (2) anything designed or sold for incorporation +into a dwelling. In determining whether a product is a consumer product, +doubtful cases shall be resolved in favor of coverage. For a particular +product received by a particular user, "normally used" refers to a +typical or common use of that class of product, regardless of the status +of the particular user or of the way in which the particular user +actually uses, or expects or is expected to use, the product. A product +is a consumer product regardless of whether the product has substantial +commercial, industrial or non-consumer uses, unless such uses represent +the only significant mode of use of the product. + + "Installation Information" for a User Product means any methods, +procedures, authorization keys, or other information required to install +and execute modified versions of a covered work in that User Product from +a modified version of its Corresponding Source. The information must +suffice to ensure that the continued functioning of the modified object +code is in no case prevented or interfered with solely because +modification has been made. + + If you convey an object code work under this section in, or with, or +specifically for use in, a User Product, and the conveying occurs as +part of a transaction in which the right of possession and use of the +User Product is transferred to the recipient in perpetuity or for a +fixed term (regardless of how the transaction is characterized), the +Corresponding Source conveyed under this section must be accompanied +by the Installation Information. But this requirement does not apply +if neither you nor any third party retains the ability to install +modified object code on the User Product (for example, the work has +been installed in ROM). + + The requirement to provide Installation Information does not include a +requirement to continue to provide support service, warranty, or updates +for a work that has been modified or installed by the recipient, or for +the User Product in which it has been modified or installed. Access to a +network may be denied when the modification itself materially and +adversely affects the operation of the network or violates the rules and +protocols for communication across the network. + + Corresponding Source conveyed, and Installation Information provided, +in accord with this section must be in a format that is publicly +documented (and with an implementation available to the public in +source code form), and must require no special password or key for +unpacking, reading or copying. + + 7. Additional Terms. + + "Additional permissions" are terms that supplement the terms of this +License by making exceptions from one or more of its conditions. +Additional permissions that are applicable to the entire Program shall +be treated as though they were included in this License, to the extent +that they are valid under applicable law. If additional permissions +apply only to part of the Program, that part may be used separately +under those permissions, but the entire Program remains governed by +this License without regard to the additional permissions. + + When you convey a copy of a covered work, you may at your option +remove any additional permissions from that copy, or from any part of +it. (Additional permissions may be written to require their own +removal in certain cases when you modify the work.) You may place +additional permissions on material, added by you to a covered work, +for which you have or can give appropriate copyright permission. + + Notwithstanding any other provision of this License, for material you +add to a covered work, you may (if authorized by the copyright holders of +that material) supplement the terms of this License with terms: + + a) Disclaiming warranty or limiting liability differently from the + terms of sections 15 and 16 of this License; or + + b) Requiring preservation of specified reasonable legal notices or + author attributions in that material or in the Appropriate Legal + Notices displayed by works containing it; or + + c) Prohibiting misrepresentation of the origin of that material, or + requiring that modified versions of such material be marked in + reasonable ways as different from the original version; or + + d) Limiting the use for publicity purposes of names of licensors or + authors of the material; or + + e) Declining to grant rights under trademark law for use of some + trade names, trademarks, or service marks; or + + f) Requiring indemnification of licensors and authors of that + material by anyone who conveys the material (or modified versions of + it) with contractual assumptions of liability to the recipient, for + any liability that these contractual assumptions directly impose on + those licensors and authors. + + All other non-permissive additional terms are considered "further +restrictions" within the meaning of section 10. If the Program as you +received it, or any part of it, contains a notice stating that it is +governed by this License along with a term that is a further +restriction, you may remove that term. If a license document contains +a further restriction but permits relicensing or conveying under this +License, you may add to a covered work material governed by the terms +of that license document, provided that the further restriction does +not survive such relicensing or conveying. + + If you add terms to a covered work in accord with this section, you +must place, in the relevant source files, a statement of the +additional terms that apply to those files, or a notice indicating +where to find the applicable terms. + + Additional terms, permissive or non-permissive, may be stated in the +form of a separately written license, or stated as exceptions; +the above requirements apply either way. + + 8. Termination. + + You may not propagate or modify a covered work except as expressly +provided under this License. Any attempt otherwise to propagate or +modify it is void, and will automatically terminate your rights under +this License (including any patent licenses granted under the third +paragraph of section 11). + + However, if you cease all violation of this License, then your +license from a particular copyright holder is reinstated (a) +provisionally, unless and until the copyright holder explicitly and +finally terminates your license, and (b) permanently, if the copyright +holder fails to notify you of the violation by some reasonable means +prior to 60 days after the cessation. + + Moreover, your license from a particular copyright holder is +reinstated permanently if the copyright holder notifies you of the +violation by some reasonable means, this is the first time you have +received notice of violation of this License (for any work) from that +copyright holder, and you cure the violation prior to 30 days after +your receipt of the notice. + + Termination of your rights under this section does not terminate the +licenses of parties who have received copies or rights from you under +this License. If your rights have been terminated and not permanently +reinstated, you do not qualify to receive new licenses for the same +material under section 10. + + 9. Acceptance Not Required for Having Copies. + + You are not required to accept this License in order to receive or +run a copy of the Program. Ancillary propagation of a covered work +occurring solely as a consequence of using peer-to-peer transmission +to receive a copy likewise does not require acceptance. However, +nothing other than this License grants you permission to propagate or +modify any covered work. These actions infringe copyright if you do +not accept this License. Therefore, by modifying or propagating a +covered work, you indicate your acceptance of this License to do so. + + 10. Automatic Licensing of Downstream Recipients. + + Each time you convey a covered work, the recipient automatically +receives a license from the original licensors, to run, modify and +propagate that work, subject to this License. You are not responsible +for enforcing compliance by third parties with this License. + + An "entity transaction" is a transaction transferring control of an +organization, or substantially all assets of one, or subdividing an +organization, or merging organizations. If propagation of a covered +work results from an entity transaction, each party to that +transaction who receives a copy of the work also receives whatever +licenses to the work the party's predecessor in interest had or could +give under the previous paragraph, plus a right to possession of the +Corresponding Source of the work from the predecessor in interest, if +the predecessor has it or can get it with reasonable efforts. + + You may not impose any further restrictions on the exercise of the +rights granted or affirmed under this License. For example, you may +not impose a license fee, royalty, or other charge for exercise of +rights granted under this License, and you may not initiate litigation +(including a cross-claim or counterclaim in a lawsuit) alleging that +any patent claim is infringed by making, using, selling, offering for +sale, or importing the Program or any portion of it. + + 11. Patents. + + A "contributor" is a copyright holder who authorizes use under this +License of the Program or a work on which the Program is based. The +work thus licensed is called the contributor's "contributor version". + + A contributor's "essential patent claims" are all patent claims +owned or controlled by the contributor, whether already acquired or +hereafter acquired, that would be infringed by some manner, permitted +by this License, of making, using, or selling its contributor version, +but do not include claims that would be infringed only as a +consequence of further modification of the contributor version. For +purposes of this definition, "control" includes the right to grant +patent sublicenses in a manner consistent with the requirements of +this License. + + Each contributor grants you a non-exclusive, worldwide, royalty-free +patent license under the contributor's essential patent claims, to +make, use, sell, offer for sale, import and otherwise run, modify and +propagate the contents of its contributor version. + + In the following three paragraphs, a "patent license" is any express +agreement or commitment, however denominated, not to enforce a patent +(such as an express permission to practice a patent or covenant not to +sue for patent infringement). To "grant" such a patent license to a +party means to make such an agreement or commitment not to enforce a +patent against the party. + + If you convey a covered work, knowingly relying on a patent license, +and the Corresponding Source of the work is not available for anyone +to copy, free of charge and under the terms of this License, through a +publicly available network server or other readily accessible means, +then you must either (1) cause the Corresponding Source to be so +available, or (2) arrange to deprive yourself of the benefit of the +patent license for this particular work, or (3) arrange, in a manner +consistent with the requirements of this License, to extend the patent +license to downstream recipients. "Knowingly relying" means you have +actual knowledge that, but for the patent license, your conveying the +covered work in a country, or your recipient's use of the covered work +in a country, would infringe one or more identifiable patents in that +country that you have reason to believe are valid. + + If, pursuant to or in connection with a single transaction or +arrangement, you convey, or propagate by procuring conveyance of, a +covered work, and grant a patent license to some of the parties +receiving the covered work authorizing them to use, propagate, modify +or convey a specific copy of the covered work, then the patent license +you grant is automatically extended to all recipients of the covered +work and works based on it. + + A patent license is "discriminatory" if it does not include within +the scope of its coverage, prohibits the exercise of, or is +conditioned on the non-exercise of one or more of the rights that are +specifically granted under this License. You may not convey a covered +work if you are a party to an arrangement with a third party that is +in the business of distributing software, under which you make payment +to the third party based on the extent of your activity of conveying +the work, and under which the third party grants, to any of the +parties who would receive the covered work from you, a discriminatory +patent license (a) in connection with copies of the covered work +conveyed by you (or copies made from those copies), or (b) primarily +for and in connection with specific products or compilations that +contain the covered work, unless you entered into that arrangement, +or that patent license was granted, prior to 28 March 2007. + + Nothing in this License shall be construed as excluding or limiting +any implied license or other defenses to infringement that may +otherwise be available to you under applicable patent law. + + 12. No Surrender of Others' Freedom. + + If conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot convey a +covered work so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you may +not convey it at all. For example, if you agree to terms that obligate you +to collect a royalty for further conveying from those to whom you convey +the Program, the only way you could satisfy both those terms and this +License would be to refrain entirely from conveying the Program. + + 13. Use with the GNU Affero General Public License. + + Notwithstanding any other provision of this License, you have +permission to link or combine any covered work with a work licensed +under version 3 of the GNU Affero General Public License into a single +combined work, and to convey the resulting work. The terms of this +License will continue to apply to the part which is the covered work, +but the special requirements of the GNU Affero General Public License, +section 13, concerning interaction through a network will apply to the +combination as such. + + 14. Revised Versions of this License. + + The Free Software Foundation may publish revised and/or new versions of +the GNU General Public License from time to time. Such new versions will +be similar in spirit to the present version, but may differ in detail to +address new problems or concerns. + + Each version is given a distinguishing version number. If the +Program specifies that a certain numbered version of the GNU General +Public License "or any later version" applies to it, you have the +option of following the terms and conditions either of that numbered +version or of any later version published by the Free Software +Foundation. If the Program does not specify a version number of the +GNU General Public License, you may choose any version ever published +by the Free Software Foundation. + + If the Program specifies that a proxy can decide which future +versions of the GNU General Public License can be used, that proxy's +public statement of acceptance of a version permanently authorizes you +to choose that version for the Program. + + Later license versions may give you additional or different +permissions. However, no additional obligations are imposed on any +author or copyright holder as a result of your choosing to follow a +later version. + + 15. Disclaimer of Warranty. + + THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY +APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT +HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY +OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, +THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM +IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF +ALL NECESSARY SERVICING, REPAIR OR CORRECTION. + + 16. Limitation of Liability. + + IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING +WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS +THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY +GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE +USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF +DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD +PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), +EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF +SUCH DAMAGES. + + 17. Interpretation of Sections 15 and 16. + + If the disclaimer of warranty and limitation of liability provided +above cannot be given local legal effect according to their terms, +reviewing courts shall apply local law that most closely approximates +an absolute waiver of all civil liability in connection with the +Program, unless a warranty or assumption of liability accompanies a +copy of the Program in return for a fee. + + END OF TERMS AND CONDITIONS + + How to Apply These Terms to Your New Programs + + If you develop a new program, and you want it to be of the greatest +possible use to the public, the best way to achieve this is to make it +free software which everyone can redistribute and change under these terms. + + To do so, attach the following notices to the program. It is safest +to attach them to the start of each source file to most effectively +state the exclusion of warranty; and each file should have at least +the "copyright" line and a pointer to where the full notice is found. + + + Copyright (C) + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . + +Also add information on how to contact you by electronic and paper mail. + + If the program does terminal interaction, make it output a short +notice like this when it starts in an interactive mode: + + Copyright (C) + This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'. + This is free software, and you are welcome to redistribute it + under certain conditions; type `show c' for details. + +The hypothetical commands `show w' and `show c' should show the appropriate +parts of the General Public License. Of course, your program's commands +might be different; for a GUI interface, you would use an "about box". + + You should also get your employer (if you work as a programmer) or school, +if any, to sign a "copyright disclaimer" for the program, if necessary. +For more information on this, and how to apply and follow the GNU GPL, see +. + + The GNU General Public License does not permit incorporating your program +into proprietary programs. If your program is a subroutine library, you +may consider it more useful to permit linking proprietary applications with +the library. If this is what you want to do, use the GNU Lesser General +Public License instead of this License. But first, please read +. diff --git a/Makefile b/Makefile new file mode 100644 index 0000000..c858205 --- /dev/null +++ b/Makefile @@ -0,0 +1,42 @@ +CC?=gcc +CFLAGS:=-Wall -Werror -Wextra -I. +OBJ=build/femtotcp.o build/test-linux.o + +all: build/test + + +#Static library +static: CFLAGS+=-static +static: libtcpip.a + +libtcpip.a: $(OBJ) + @ar rcs $@ $^ + +clean: + @rm -f build/* + @make -C test/unit clean + +# Test +asan: build/test +asan:CFLAGS+=-fsanitize=address +asan:LDFLAGS+=-static-libasan +build/test:CFLAGS+=-g -ggdb -DTEST_MAIN -DETHERNET +build/test:LDFLAGS+=-pthread + + +build/test: $(OBJ) + @echo "Linking $@" + @$(CC) $(CFLAGS) $(LDFLAGS) -o $@ $(OBJ) + +build/test-linux.o: test/test-linux.c + @echo "Compiling $<" + @$(CC) $(CFLAGS) -c $< -o $@ + +build/%.o: src/%.c + @echo "Compiling $<" + @$(CC) $(CFLAGS) -c $< -o $@ + +unit: + @make -C test/unit + +.PHONY: clean all static diff --git a/README.md b/README.md new file mode 100644 index 0000000..e0b29d9 --- /dev/null +++ b/README.md @@ -0,0 +1,33 @@ +# FemtoTCP + +The smallest TCP/IP stack on the planet + +## Description and project goals + +FemtoTCP is a TCP/IP stack with no dynamic memory allocations, designed to be +used in resource-constrained embedded systems. + +Endpoint only mode is supported, which means that femtotcp can be used to +establish network connections but it does not route traffic between different +network interfaces. + +A single network interface can be associated with the device. + +## Features supported + +- ARP (RFC 826) +- IPv4 (RFC 791) +- ICMP (RFC 792): only ping replies +- DHCP (RFC 2131): client only +- UDP (RFC 768): unicast only +- TCP (RFC 793) + - TCP options supported: Timestamps, Maximum Segment Size +- BSD-like, non blocking socket API, with custom callbacks +- No dynamic memory allocation + + +## Copyright and License + +FemtoTCP is licensed under the GPLv3 license. See the LICENSE file for details. +Copyright (c) 2024 Daniele Lacamera. Some right reserved + diff --git a/femtotcp.h b/femtotcp.h new file mode 100644 index 0000000..5bc2441 --- /dev/null +++ b/femtotcp.h @@ -0,0 +1,84 @@ +#ifndef QUECTONET_H +#define QUECTONET_H +#include + +/* Types */ +struct ipstack; +typedef uint32_t ip4; + +/* Macros, compiler specific. */ +#define PACKED __attribute__((packed)) +#define ee16(x) __builtin_bswap16(x) +#define ee32(x) __builtin_bswap32(x) +#define DEBUG + +#ifdef DEBUG +#include +#define LOG(fmt, ...) printf(fmt, ##__VA_ARGS__) +#else +#define LOG(fmt, ...) do{}while(0) +#endif + +/* Device driver interface */ +/* Struct to contain a hw device description */ +struct ll { + uint8_t mac[6]; + uint8_t ifname[16]; + /* poll function */ + int (*poll)(struct ll *ll, void *buf, int len); + /* send function */ + int (*send)(struct ll *ll, void *buf, int len); +}; + +/* Struct to contain an IP device configuration */ +struct ipconf { + struct ll *ll; + ip4 ip; + ip4 mask; + ip4 gw; +}; + +/* Socket interface */ +#ifndef NATIVE_POSIX_SOCKET +#define IPSTACK_SOCK_STREAM 1 +#define IPSTACK_SOCK_DGRAM 2 +struct ipstack_sockaddr_in { + uint16_t sin_family; + uint16_t sin_port; + struct sin_addr { uint32_t s_addr; } sin_addr; +}; +struct ipstack_sockaddr { uint16_t sa_family; }; +typedef uint32_t socklen_t; +#ifndef AF_INET +#define AF_INET 2 +#endif +#endif + +int posix_socket(struct ipstack *s, int domain, int type, int protocol); +int posix_bind(struct ipstack *s, int sockfd, const struct ipstack_sockaddr *addr, socklen_t addrlen); +int posix_listen(struct ipstack *s, int sockfd, int backlog); +int posix_accept(struct ipstack *s, int sockfd, struct ipstack_sockaddr *addr, socklen_t *addrlen); +int posix_connect(struct ipstack *s, int sockfd, const struct ipstack_sockaddr *addr, socklen_t addrlen); +int posix_sendto(struct ipstack *s, int sockfd, const void *buf, size_t len, int flags, const struct ipstack_sockaddr *dest_addr, socklen_t addrlen); +int posix_recvfrom(struct ipstack *s, int sockfd, void *buf, size_t len, int flags, struct ipstack_sockaddr *src_addr, socklen_t *addrlen); +int posix_close(struct ipstack *s, int sockfd); +int posix_getpeername(struct ipstack *s, int sockfd, struct ipstack_sockaddr *addr, socklen_t *addrlen); +int posix_getsockname(struct ipstack *s, int sockfd, struct ipstack_sockaddr *addr, socklen_t *addrlen); + +int dhcp_client_init(struct ipstack *s); +int dhcp_bound(struct ipstack *s); + +/* IP stack interface */ +void ipstack_init(struct ipstack *s); +void ipstack_init_static(struct ipstack **s); +int ipstack_poll(struct ipstack *s, uint64_t now); +void ipstack_ipconfig_set(struct ipstack *s, ip4 ip, ip4 mask, ip4 gw); +void ipstack_ipconfig_get(struct ipstack *s, ip4 *ip, ip4 *mask, ip4 *gw); + +struct ll *ipstack_getdev(struct ipstack *s); +ip4 atoip4(const char *ip); + + + + +#endif diff --git a/src/femtotcp.c b/src/femtotcp.c new file mode 100644 index 0000000..3bf1300 --- /dev/null +++ b/src/femtotcp.c @@ -0,0 +1,2108 @@ +/* GPLv3 + * This is a simple IP stack with no dynamic memory allocation. + * License: GPLv3 + * Copyright: 2024 Danielinux + * + */ + +#include +#include +#include "femtotcp.h" + +/* Config (TODO: move to some config.h later) */ + +#define LINK_MTU 1536 + +#define MAX_TCPSOCKETS 2 +#define MAX_UDPSOCKETS 2 +#define RXBUF_SIZE LINK_MTU * 8 +#define TXBUF_SIZE LINK_MTU * 2 + +#define MAX_NEIGHBORS 16 + +/* Constants */ +#define MARK_TCP_SOCKET 0x8000 /* Mark a socket as TCP */ +#define MARK_UDP_SOCKET 0x4000 /* Mark a socket as UDP */ + +#define IPPROTO_ICMP 0x01 +#define IPPROTO_TCP 0x06 +#define IPPROTO_UDP 0x11 +#define IPADDR_ANY 0x00000000 + +#define TCP_OPTION_MSS 0x02 +#define TCP_OPTION_MSS_LEN 4 +#define TCP_OPTION_TS 0x08 +#define TCP_OPTION_TS_LEN 10 +#define TCP_OPTIONS_LEN 12 +#define TCP_OPTION_NOP 0x01 +#define TCP_OPTION_EOO 0x00 + +#define TCP_HEADER_LEN 20 +#define IP_HEADER_LEN 20 +#define UDP_HEADER_LEN 8 +#define ICMP_HEADER_LEN 8 +#define ARP_HEADER_LEN 28 + +#ifdef ETHERNET +#define ETH_HEADER_LEN 14 +#else +#define ETH_HEADER_LEN 0 +#endif + +#define ETH_TYPE_IP 0x0800 +#define ETH_TYPE_ARP 0x0806 + +#define NO_TIMER 0 + +#define IP_MTU 1500 +#define TCP_MSS (IP_MTU - (IP_HEADER_LEN + TCP_HEADER_LEN)) + +/* Macros */ +#define IS_IP_BCAST(ip) (ip == 0xFFFFFFFF) +#define IS_IP_LOCAL(s,ipa) \ + ((ipa & s->ipconf.mask) == (s->ipconf.ip & s->ipconf.mask)) + +#define NEXTHOP(s,ip) \ + (IS_IP_BCAST(ip)?ip: \ + ((IS_IP_LOCAL(s,ip) ? ip : s->ipconf.gw))) + +#define PKT_FLAG_SENT 0x01 +#define PKT_FLAG_ACKED 0x02 +#define PKT_FLAG_FIN 0x04 + +/* Callback flags */ +#define CB_EVENT_READABLE 0x01 /* Accepted connection or data available */ +#define CB_EVENT_WRITABLE 0x02 /* Connected or space available to send */ +#define CB_EVENT_CLOSED 0x04 /* Connection closed by peer */ +#define CB_EVENT_TIMEOUT 0x08 /* Timeout */ + +/* Random number generator, provided by the user */ +uint32_t ipstack_getrandom(void); + +struct PACKED pkt_desc { + uint32_t pos, len; + uint16_t flags, time_sent; +}; + +struct fifo { + uint32_t head, tail, size, h_wrap; + uint8_t *data; +}; + +/* TCP TX is a circular buffer and contains an array of full packets */ +/* TCP RX only contains application data */ + +/* FIFO functions + * head: next empty slot + * tail: oldest populated slot + * + * */ + +/* Initialize a FIFO */ +static void fifo_init(struct fifo *f, uint8_t *data, uint32_t size) +{ + f->head = 0; + f->tail = 0; + f->h_wrap = 0; + f->size = size; + f->data = data; +} + +/* Return the number of bytes available */ +static uint32_t fifo_space(struct fifo *f) +{ + int ret = 0; + if (f->head == f->tail) { + f->head = 0; + f->tail = 0; + return f->size; + } + if (f->tail == f->h_wrap) { + f->tail = 0; + f->h_wrap = 0; + } + if (f->h_wrap == 0) { + if (f->head >= f->tail) { + ret = f->size - (f->head - f->tail); + } else { + ret = f->tail - f->head; + } + /* Take into account the wraparound to always keep the segment contiguous */ + if ((f->size - f->head) < (sizeof(struct pkt_desc) + LINK_MTU)) { + if (f->tail > (sizeof(struct pkt_desc) + LINK_MTU)) { + f->h_wrap = f->head; + f->head = 0; + return f->tail - f->head; + } else return 0; + } + } else { + ret = f->size - (f->tail - f->head); + } + return ret; +} + +/* Check the descriptor of the next packet */ +static struct pkt_desc *fifo_peek(struct fifo *f) +{ + if (f->tail == f->h_wrap) { + f->tail = 0; + f->h_wrap = 0; + } + if (f->tail == f->head) + return NULL; + while (f->tail % 4) + f->tail++; + if ((f->head < f->tail) && ((f->tail + sizeof(struct pkt_desc) + LINK_MTU > f->size))) + f->tail = 0; + return (struct pkt_desc *)(f->data + f->tail); +} + +/* Continue reading starting from a descriptor returned by fifo_peek */ +static struct pkt_desc *fifo_next(struct fifo *f, struct pkt_desc *desc) +{ + uint32_t len; + if (desc == NULL) + return NULL; + len = sizeof(struct pkt_desc) + desc->len; + if ((desc->pos + len) == f->head) + return NULL; + while ((desc->pos + len) % 4) + len++; + if ((desc->pos + len + sizeof(struct pkt_desc) + LINK_MTU ) >= f->size) + desc = (struct pkt_desc *)(f->data); + else + desc = (struct pkt_desc *)((f->data + desc->pos + len)); + if ((desc->pos + len) == f->h_wrap) { + desc = (struct pkt_desc *)(f->data); + } + return desc; +} + +/* Return the number of bytes used */ +static uint32_t fifo_len(struct fifo *f) +{ + while (f->tail % 4) + f->tail++; + f->tail %= f->size; + if (f->tail == f->head) + return 0; + if (f->tail > f->head) { + if (f->h_wrap > 0) + return f->h_wrap - f->tail + f->head; + else + return f->size - (f->tail - f->head); + } else { + return f->head - f->tail; + } +} + +/* Insert data into the FIFO */ +static int fifo_push(struct fifo *f, void *data, uint32_t len) +{ + struct pkt_desc desc; + memset(&desc, 0, sizeof(struct pkt_desc)); + /* Ensure 4-byte alignment in the buffer */ + if (f->head % 4) + f->head += 4 - (f->head % 4); + if (fifo_space(f) < (sizeof(struct pkt_desc) + len)) + return -1; + desc.pos = f->head; + desc.len = len; + memcpy(f->data + f->head, &desc, sizeof(struct pkt_desc)); + f->head += sizeof(struct pkt_desc); + memcpy(f->data + f->head, data, len); + f->head += len; + return 0; +} + +/* Grab the tail packet and advance the tail pointer */ +static struct pkt_desc *fifo_pop(struct fifo *f) +{ + struct pkt_desc *desc; + if (f->tail == f->head) + return NULL; + while (f->tail % 4) + f->tail++; + f->tail %= f->size; + if (f->tail == f->head) + return NULL; + if ((f->head < f->tail) && ((f->tail + sizeof(struct pkt_desc) + LINK_MTU > f->size))) + f->tail = 0; + desc = (struct pkt_desc *)(f->data + f->tail); + f->tail += sizeof(struct pkt_desc) + desc->len; + f->tail %= f->size; + return desc; +} + +/* Simple queue structure for TCP RX, keeping only the data in the buffer */ +struct queue { + uint32_t seq_base, head, tail, size; + uint8_t *data; +}; + +/* Initialize a queue */ +/* head: next empty slot + * tail: oldest populated slot + */ +static void queue_init(struct queue *q, uint8_t *data, uint32_t size, uint32_t seq_base) +{ + q->seq_base = seq_base; + q->tail = 0; + q->head = 0; + q->size = size; + q->data = data; +} + +/* Return the number of bytes available */ +static uint32_t queue_space(struct queue *q) +{ + if (q->head >= q->tail) { + return q->size - (q->head - q->tail); + } else { + return q->tail - q->head; + } +} + +/* Return the number of bytes used */ +static uint32_t queue_len(struct queue *q) +{ + return q->size - queue_space(q); +} + +/* Insert data into the queue */ +static int queue_insert(struct queue *q, void *data, uint32_t seq, uint32_t len) +{ + uint32_t pos; + int diff; + if ((len > queue_space(q)) || (len > q->size)) { + return -1; + } + if (queue_len(q) == 0) { + q->tail = q->head = 0; + memcpy(q->data, data, len); + q->head = len; + q->seq_base = seq; + } else { + diff = seq - q->seq_base; + if (diff < 0) + return -1; + pos = (uint32_t)diff; + if (pos > q->size) + return -1; + /* Check if the data is ancient */ + if (pos < q->tail) + return 0; + /* Write in two steps: consider wrapping */ + if (pos + len > q->size) { + memcpy(q->data + pos, data, q->size - pos); + memcpy(q->data, data + q->size - pos, len - (q->size - pos)); + } else { + memcpy(q->data + pos, data, len); + } + if (pos + len > q->head) + q->head = (pos + len) % q->size; + } + return 0; +} + +/* Grab the tail packet and advance the tail pointer */ +static int queue_pop(struct queue *q, void *data, uint32_t len) +{ + uint32_t q_len = queue_len(q); + if (q_len == 0) + return -11; + if (len > q_len) + len = q_len; + memcpy(data, q->data + q->tail, len); + q->tail += len; + q->tail %= q->size; + q->seq_base += len; + return len; +} + +/* ARP */ + +#define ARP_REQUEST 1 +#define ARP_REPLY 2 + +#ifdef ETHERNET +/* Struct to contain an ethernet frame with its header */ +struct PACKED ipstack_eth_frame { + uint8_t dst[6]; + uint8_t src[6]; + uint16_t type; + uint8_t data[0]; +}; +#endif + +/* Struct to contain a IPv4 packet with its header */ +struct PACKED ipstack_ip_packet { +#ifdef ETHERNET + struct ipstack_eth_frame eth; +#endif + uint8_t ver_ihl, tos; + uint16_t len, id, flags_fo; + uint8_t ttl, proto; + uint16_t csum; + ip4 src, dst; + uint8_t data[0]; +}; + +/* Describe a TCP segment down to the datalink layer */ +struct PACKED ipstack_tcp_seg { + struct ipstack_ip_packet ip; + uint16_t src_port, dst_port; + uint32_t seq, ack; + uint8_t hlen, flags; + uint16_t win, csum, urg; + uint8_t data[0]; +}; + +struct PACKED tcp_opt_ts { + /* Timestamp option (10 extra bytes) */ + uint8_t opt, len; + uint32_t val, ecr; + uint8_t pad, eoo; +}; + +struct PACKED tcp_opt_mss { + /* MSS option (4 extra bytes) */ + uint8_t opt, len; + uint16_t mss; +}; + +/* UDP datagram */ +struct PACKED ipstack_udp_datagram { + struct ipstack_ip_packet ip; + uint16_t src_port, dst_port, len, csum; + uint8_t data[0]; +}; + +/* For Checksums */ +union transport_pseudo_header { + struct PACKED ph { + ip4 src, dst; + uint8_t zero, proto; + uint16_t len; + } ph; + uint16_t buf[6]; +}; + +/* ICMP */ +struct PACKED ipstack_icmp_packet { + struct ipstack_ip_packet ip; + uint8_t type, code; + uint16_t csum; + uint8_t data[0]; +}; + +/* DHCP */ +#define BOOT_REQUEST 1 +#define BOOT_REPLY 2 + +#define DHCP_DISCOVER 1 +#define DHCP_OFFER 2 +#define DHCP_REQUEST 3 +#define DHCP_ACK 5 + +#define DHCP_MAGIC 0x63825363 +#define DHCP_SERVER_PORT 67 +#define DHCP_CLIENT_PORT 68 +#define DHCP_OPTION_MSG_TYPE 53 +#define DHCP_OPTION_SUBNET_MASK 1 +#define DHCP_OPTION_ROUTER 3 +#define DHCP_OPTION_DNS 6 +#define DHCP_OPTION_SERVER_ID 54 +#define DHCP_OPTION_PARAM_REQ 55 +#define DHCP_OPTION_OFFER_IP 50 +#define DHCP_OPTION_END 0xFF +#define DHCP_DISCOVER_TIMEOUT 2000 +#define DHCP_DISCOVER_RETRIES 3 +#define DHCP_REQUEST_TIMEOUT 2000 +#define DHCP_REQUEST_RETRIES 3 + +enum dhcp_state { + DHCP_OFF = 0, + DHCP_DISCOVER_SENT, + DHCP_REQUEST_SENT, + DHCP_BOUND, +}; + +#define DHCP_IS_RUNNING(s) \ + ((s->dhcp_state != DHCP_OFF) && (s->dhcp_state != DHCP_BOUND)) + +struct PACKED dhcp_msg { + uint8_t op, htype, hlen, hops; + uint32_t xid; + uint16_t secs, flags; + uint32_t ciaddr, yiaddr, siaddr, giaddr; + uint8_t chaddr[16], sname[64], file[128]; + uint32_t magic; + uint8_t options[312]; +}; + +#define DHCP_HEADER_LEN 240 + +struct PACKED dhcp_option { + uint8_t code, len, data[0]; +}; + +/* Sockets */ + +/* TCP socket */ +enum tcp_state { + TCP_CLOSED = 0, + TCP_LISTEN, + TCP_SYN_SENT, + TCP_SYN_RCVD, + TCP_ESTABLISHED, + TCP_FIN_WAIT_1, + TCP_FIN_WAIT_2, + TCP_CLOSING, + TCP_TIME_WAIT, + TCP_CLOSE_WAIT, + TCP_LAST_ACK +}; + +struct tcpsocket { + enum tcp_state state; + uint32_t last_ts, rtt, rto, cwnd, cwnd_count, ssthresh, tmr_rto, rto_backoff, + seq, ack, last_ack, last; + ip4 local_ip, remote_ip; + struct fifo txbuf; + struct queue rxbuf; +}; + +/* UDP socket */ +struct udpsocket { + struct fifo rxbuf, txbuf; +}; + +struct tsocket { + union tsocket_sock { + struct tcpsocket tcp; + struct udpsocket udp; + } sock; + uint16_t proto, events; + ip4 local_ip, remote_ip; + uint16_t src_port, dst_port; + struct ipstack *S; +#ifdef ETHERNET + uint8_t nexthop_mac[6]; +#endif + uint8_t rxmem[RXBUF_SIZE]; + uint8_t txmem[TXBUF_SIZE]; + void (*callback)(int sock_fd, uint16_t events, void *arg); + void *callback_arg; +}; +static void close_socket(struct tsocket *ts); + +#ifdef ETHERNET +struct PACKED arp_packet { + struct ipstack_eth_frame eth; + uint16_t htype, ptype; + uint8_t hlen, plen; + uint16_t opcode; + uint8_t sma[6]; + uint32_t sip; + uint8_t tma[6]; + uint32_t tip; +}; +struct arp_neighbor { + ip4 ip; + uint8_t mac[6]; +}; + +#endif + +struct ipstack; + +struct ipstack_timer { + uint32_t id; + uint64_t expires; + void *arg; + void (*cb)(void *arg); +}; + +/* Fixed size binary heap: each element is a timer. */ +#define MAX_TIMERS MAX_TCPSOCKETS * 3 +/* Timer binary heap */ +struct timers_binheap { + struct ipstack_timer timers[MAX_TIMERS]; + uint32_t size; +}; + +struct ipstack +{ + struct ll ll_dev; + struct ipconf ipconf; + enum dhcp_state dhcp_state; /* State machine for DHCP */ + uint32_t dhcp_xid; /* DHCP transaction ID while DORA */ + int dhcp_udp_sd; /* DHCP socket descriptor. DHCP uses an UDP socket */ + uint32_t dhcp_timer; /* Timer for DHCP */ + uint32_t dhcp_timeout_count; /* DHCP timeout counter */ + ip4 dhcp_server_ip; /* DHCP server IP */ + ip4 dhcp_ip; /* IP address assigned by DHCP */ + struct timers_binheap timers; + struct tsocket tcpsockets[MAX_TCPSOCKETS]; + struct tsocket udpsockets[MAX_UDPSOCKETS]; + uint16_t ipcounter; + uint64_t last_tick; +#ifdef ETHERNET + struct ipstack_arp { + uint64_t last_arp; + struct arp_neighbor neighbors[MAX_NEIGHBORS]; + } arp; +#endif +}; + +/* ***************************** */ +/* Implementation */ + +/* User Callbacks */ +void ipstack_register_callback(struct ipstack *s, int sock_fd, void (*cb)(int sock_fd, uint16_t events, void *arg), void *arg) +{ + struct tsocket *t; + if (sock_fd < 0) + return; + if (sock_fd & MARK_TCP_SOCKET) { + if (sock_fd >= MAX_TCPSOCKETS) + return; + t = &s->tcpsockets[sock_fd & ~MARK_TCP_SOCKET]; + t->callback = cb; + t->callback_arg = arg; + } else if (sock_fd & MARK_UDP_SOCKET) { + if (sock_fd >= MAX_UDPSOCKETS) + return; + t = &s->udpsockets[sock_fd & ~MARK_UDP_SOCKET]; + t->callback = cb; + t->callback_arg = arg; + } +} + +/* Timers */ +/* insert a timer into the binary heap */ + +static struct ipstack_timer timers_binheap_pop(struct timers_binheap *heap) +{ + uint32_t i = 0; + struct ipstack_timer tmr = heap->timers[0]; + heap->size--; + heap->timers[0] = heap->timers[heap->size]; + while (2*i+1 < heap->size) { + struct ipstack_timer tmp; + uint32_t j = 2*i+1; + if (j+1 < heap->size && heap->timers[j+1].expires < heap->timers[j].expires) { + j++; + } + if (heap->timers[i].expires <= heap->timers[j].expires) { + break; + } + tmp = heap->timers[i]; + heap->timers[i] = heap->timers[j]; + heap->timers[j] = tmp; + i = j; + } + return tmr; +} + +static int timers_binheap_insert(struct timers_binheap *heap, struct ipstack_timer tmr) +{ + static uint32_t timer_id = 1; + if (timer_id == 0) + timer_id = 1; + while (heap->size > 0 && heap->timers[0].expires == 0) + timers_binheap_pop(heap); + tmr.id = timer_id++; + /* Insert at the end */ + heap->timers[heap->size] = tmr; + heap->size++; + int i = heap->size - 1; + while (i > 0 && heap->timers[i].expires < heap->timers[(i-1)/2].expires) { + struct ipstack_timer tmp = heap->timers[i]; + heap->timers[i] = heap->timers[(i-1)/2]; + heap->timers[(i-1)/2] = tmp; + i = (i-1)/2; + } + return tmr.id; +} + +static int is_timer_expired(struct timers_binheap *heap, uint64_t now) +{ + while (heap->size > 0 && heap->timers[0].expires == 0) { + timers_binheap_pop(heap); + } + if (heap->size == 0) { + return 0; + } + return (heap->timers[0].expires <= now)?1:0; +} + +static void timer_binheap_cancel(struct timers_binheap *heap, uint32_t id) +{ + uint32_t i; + for (i = 0; i < heap->size; i++) { + if (heap->timers[i].id == id) { + heap->timers[i].expires = 0; + break; + } + } +} + +/* UDP */ +static struct tsocket *udp_new_socket(struct ipstack *s) +{ + struct tsocket *t; + + for (int i = 0; i < MAX_UDPSOCKETS; i++) { + t = &s->udpsockets[i]; + if (t->proto == 0) { + t->proto = IPPROTO_UDP; + t->S = s; + fifo_init(&t->sock.udp.rxbuf, t->rxmem, RXBUF_SIZE); + fifo_init(&t->sock.udp.txbuf, t->txmem, TXBUF_SIZE); + t->events = CB_EVENT_WRITABLE; + return t; + } + } + return NULL; +} + +static void udp_try_recv(struct ipstack *s, struct ipstack_udp_datagram *udp, uint32_t frame_len) +{ + for (int i = 0; i < MAX_UDPSOCKETS; i++) { + struct tsocket *t = &s->udpsockets[i]; + if (t->src_port == ee16(udp->dst_port) && t->dst_port == ee16(udp->src_port) && + (((t->local_ip == 0) && DHCP_IS_RUNNING(s)) || + (t->local_ip == ee32(udp->ip.dst) && t->remote_ip != s->ipconf.ip)) ) { + + /* UDP datagram sanity checks */ + if ((int)frame_len != ee16(udp->len) + IP_HEADER_LEN + ETH_HEADER_LEN) + return; + /* Insert into socket buffer */ + fifo_push(&t->sock.udp.rxbuf, udp, frame_len); + } + } +} + +/* TCP */ + +static struct tsocket *tcp_new_socket(struct ipstack *s) +{ + struct tsocket *t; + for (int i = 0; i < MAX_TCPSOCKETS; i++) { + t = &s->tcpsockets[i]; + if (t->proto == 0) { + t->proto = IPPROTO_TCP; + t->S = s; + t->sock.tcp.state = TCP_CLOSED; + t->sock.tcp.rto = 1000; + t->sock.tcp.cwnd = 2 * TCP_MSS; + t->sock.tcp.ssthresh = 64 * TCP_MSS; + t->sock.tcp.rtt = 0; + t->sock.tcp.rto_backoff = 0; + + queue_init(&t->sock.tcp.rxbuf, t->rxmem, RXBUF_SIZE, 0); + fifo_init(&t->sock.tcp.txbuf, t->txmem, TXBUF_SIZE); + return t; + } + } + return NULL; +} + +static void tcp_send_empty(struct tsocket *t, uint8_t flags) +{ + struct ipstack_tcp_seg *tcp; + struct tcp_opt_ts *ts; + uint8_t buffer[sizeof(struct ipstack_tcp_seg) + TCP_OPTIONS_LEN]; + tcp = (struct ipstack_tcp_seg *)buffer; + memset(tcp, 0, sizeof(buffer)); + tcp->src_port = ee16(t->src_port); + tcp->dst_port = ee16(t->dst_port); + tcp->seq = ee32(t->sock.tcp.seq); + tcp->ack = ee32(t->sock.tcp.ack); + tcp->hlen = ((20 + TCP_OPTIONS_LEN) << 2) & 0xF0; + tcp->flags = flags; + tcp->win = ee16((uint16_t)queue_space(&t->sock.tcp.rxbuf)); + tcp->csum = 0; + tcp->urg = 0; + ts = (struct tcp_opt_ts *)tcp->data; + ts->opt = TCP_OPTION_TS; + ts->len = TCP_OPTION_TS_LEN; + ts->val = ee32(t->S->last_tick & 0xFFFFFFFFU); + ts->ecr = t->sock.tcp.last_ts; + ts->pad = 0x01; + ts->eoo = 0x00; + fifo_push(&t->sock.tcp.txbuf, tcp, sizeof(struct ipstack_tcp_seg) + \ + TCP_OPTIONS_LEN); +} + +static void tcp_send_ack(struct tsocket *t) +{ + return tcp_send_empty(t, 0x10); +} + +static void tcp_send_finack(struct tsocket *t) +{ + tcp_send_empty(t, 0x11); + t->sock.tcp.last = t->sock.tcp.seq; +} + +static void tcp_send_syn(struct tsocket *t, uint8_t flags) +{ + struct ipstack_tcp_seg *tcp; + struct tcp_opt_ts *ts; + struct tcp_opt_mss *mss; + uint8_t buffer[sizeof(struct ipstack_tcp_seg) + TCP_OPTIONS_LEN + TCP_OPTION_MSS_LEN]; + tcp = (struct ipstack_tcp_seg *)buffer; + memset(tcp, 0, sizeof(buffer)); + tcp->src_port = ee16(t->src_port); + tcp->dst_port = ee16(t->dst_port); + tcp->seq = ee32(t->sock.tcp.seq); + tcp->ack = ee32(t->sock.tcp.ack); + tcp->hlen = ((20 + TCP_OPTIONS_LEN + TCP_OPTION_MSS_LEN) << 2) & 0xF0; + tcp->flags = flags; + tcp->win = ee16((uint16_t)queue_space(&t->sock.tcp.rxbuf)); + tcp->csum = 0; + tcp->urg = 0; + ts = (struct tcp_opt_ts *)tcp->data; + ts->opt = TCP_OPTION_TS; + ts->len = TCP_OPTION_TS_LEN; + ts->val = ee32(t->S->last_tick & 0xFFFFFFFFU); + ts->ecr = t->sock.tcp.last_ts; + ts->pad = 0x01; + ts->eoo = 0x01; + mss = (struct tcp_opt_mss *)(tcp->data + sizeof(struct tcp_opt_ts)); + mss->opt = TCP_OPTION_MSS; + mss->len = TCP_OPTION_MSS_LEN; + mss->mss = ee16(TCP_MSS); + fifo_push(&t->sock.tcp.txbuf, tcp, sizeof(struct ipstack_tcp_seg) + \ + TCP_OPTIONS_LEN + TCP_OPTION_MSS_LEN); +} + +static void tcp_send_synack(struct tsocket *t) +{ + return tcp_send_syn(t, 0x12); +} + +/* Add a segment to the rx buffer for the application to consume */ +static void tcp_recv(struct tsocket *t, struct ipstack_tcp_seg *seg) +{ + uint32_t seg_len = ee16(seg->ip.len) - (IP_HEADER_LEN + (seg->hlen >> 2)); + uint32_t seq = ee32(seg->seq); + if ((t->sock.tcp.state != TCP_ESTABLISHED) && (t->sock.tcp.state != TCP_CLOSE_WAIT)) { + return; + } + if (t->sock.tcp.ack == seq) { + /* push into queue */ + if (queue_insert(&t->sock.tcp.rxbuf, seg->ip.data + (seg->hlen >> 2), + seq, seg_len) < 0) { + /* Buffer full, dropped. This will send a duplicate ack. */ + } else { + /* Advance ack counter */ + t->sock.tcp.ack = seq + seg_len; + timer_binheap_cancel(&t->S->timers, t->sock.tcp.tmr_rto); + t->sock.tcp.tmr_rto = NO_TIMER; + } + tcp_send_ack(t); + } +} + +static uint16_t transport_checksum(union transport_pseudo_header *ph, void *_data) +{ + uint32_t sum = 0; + uint32_t i = 0; + uint16_t *ptr = (uint16_t *)ph->buf; + uint16_t *data = (uint16_t *)_data; + uint8_t *data8 = (uint8_t *)_data; + uint16_t len = ee16(ph->ph.len); + for (i = 0; i < 6; i++) { + sum += ee16(ptr[i]); + } + for (i = 0; i < (len / 2); i++) { + sum += ee16(data[i]); + } + if (len & 0x01) { + uint16_t spare = 0; + spare |= (data8[len - 1]) << 8; + sum += spare; + } + while (sum >> 16) { + sum = (sum & 0xffff) + (sum >> 16); + } + return ~sum; +} + +static void iphdr_set_checksum(struct ipstack_ip_packet *ip) +{ + uint32_t sum = 0; + uint32_t i = 0; + uint16_t *ptr = (uint16_t *)(&ip->ver_ihl); + for (i = 0; i < IP_HEADER_LEN / 2; i++) { + sum += ee16(ptr[i]); + } + while (sum >> 16) { + sum = (sum & 0xffff) + (sum >> 16); + } + ip->csum = ee16(~sum); +} + +#ifdef ETHERNET +static int eth_output_add_header(struct ipstack *S, const uint8_t *dst, struct ipstack_eth_frame *eth, + uint16_t type) +{ + if (!dst) { + /* Arp request, broadcast */ + memset(eth->dst, 0xff, 6); + } else { + /* Send to nexthop */ + memcpy(eth->dst, dst, 6); + } + memcpy(eth->src, S->ll_dev.mac, 6); + eth->type = ee16(type); + return 0; +} +#endif + +static int ip_output_add_header(struct tsocket *t, struct ipstack_ip_packet *ip, uint8_t proto, uint16_t len) +{ + union transport_pseudo_header ph; + memset(&ph, 0, sizeof(ph)); + memset(ip, 0, sizeof(struct ipstack_ip_packet)); + ip->src = ee32(t->local_ip); + ip->dst = ee32(t->remote_ip); + ip->ver_ihl = 0x45; + ip->tos = 0; + ip->len = ee16(len); + ip->flags_fo = 0; + ip->ttl = 64; + ip->proto = proto; + ip->id = ee16(t->S->ipcounter++); + ip->csum = 0; + iphdr_set_checksum(ip); + + ph.ph.src = ip->src; + ph.ph.dst = ip->dst; + ph.ph.zero = 0; + ph.ph.proto = proto; + ph.ph.len = ee16(len - IP_HEADER_LEN); + if (proto == IPPROTO_TCP) { + struct ipstack_tcp_seg *tcp = (struct ipstack_tcp_seg *)ip; + tcp->csum = 0; + tcp->csum = ee16(transport_checksum(&ph, &tcp->src_port)); + } else if (proto == IPPROTO_UDP) { + struct ipstack_udp_datagram *udp = (struct ipstack_udp_datagram *)ip; + udp->csum = 0; + udp->csum = ee16(transport_checksum(&ph, &udp->src_port)); + } +#ifdef ETHERNET + eth_output_add_header(t->S, t->nexthop_mac, (struct ipstack_eth_frame *)ip, ETH_TYPE_IP); +#endif + return 0; +} + +/* Process timestamp option, calculate RTT */ +static int tcp_process_ts(struct tsocket *t, struct ipstack_tcp_seg *tcp) +{ + struct tcp_opt_ts *ts; + uint8_t *opt = tcp->data; + while (opt < (tcp->data + (tcp->hlen >> 2))) { + if (*opt == TCP_OPTION_NOP) + opt++; + else if (*opt == TCP_OPTION_EOO) + break; + else { + ts = (struct tcp_opt_ts *)opt; + if (ts->opt == TCP_OPTION_TS) { + t->sock.tcp.last_ts = ts->val; + if (ts->ecr != 0) + return -1; + if (t->sock.tcp.rtt == 0) + t->sock.tcp.rtt = t->S->last_tick - ee32(ts->ecr); + else { + t->sock.tcp.rtt = (7 * (t->sock.tcp.rtt << 3)) + + ((t->S->last_tick - ee32(ts->ecr)) << 3); + } + return 0; + } else { + opt += ts->len; + } + } + } + return -1; +} + +#define SEQ_DIFF(a,b) ((a - b) > 0x7FFFFFFF) ? (b - a) : (a - b) + +/* Receive an ack */ +static void tcp_ack(struct tsocket *t, struct ipstack_tcp_seg *tcp) +{ + uint32_t ack = ee32(tcp->ack); + struct pkt_desc *desc; + int ack_count = 0; + desc = fifo_peek(&t->sock.tcp.txbuf); + while ((desc) && (desc->flags & PKT_FLAG_SENT)) { + struct ipstack_tcp_seg *seg = (struct ipstack_tcp_seg *)(t->txmem + desc->pos + sizeof(*desc)); + uint32_t seg_len = ee16(seg->ip.len) - (IP_HEADER_LEN + (seg->hlen >> 2)); + if (seg_len == 0) { + desc = fifo_pop(&t->sock.tcp.txbuf); + desc = fifo_peek(&t->sock.tcp.txbuf); + continue; + } + if (ee32(seg->seq) == t->sock.tcp.last && ee32(seg->seq) == ack) { + if (t->sock.tcp.state == TCP_LAST_ACK) { + t->sock.tcp.state = TCP_CLOSED; + close_socket(t); + return; + } + } + if (SEQ_DIFF(ee32(seg->seq) + seg_len, ack) < fifo_len(&t->sock.tcp.txbuf)) { + desc->flags |= PKT_FLAG_ACKED; + desc = fifo_next(&t->sock.tcp.txbuf, desc); + ack_count++; + } else { + break; + } + } + if (ack_count > 0) { + struct pkt_desc *fresh_desc; + struct ipstack_tcp_seg *tcp; + /* This ACK ackwnowledged some data. */ + desc = fifo_peek(&t->sock.tcp.txbuf); + while (desc && (desc->flags & PKT_FLAG_ACKED)) { + fresh_desc = fifo_pop(&t->sock.tcp.txbuf); + desc = fifo_peek(&t->sock.tcp.txbuf); + } + + tcp = (struct ipstack_tcp_seg *)(t->txmem + fresh_desc->pos + sizeof(*fresh_desc)); + /* Update rtt */ + if (tcp_process_ts(t, tcp) < 0) { + /* No timestamp option, use coarse RTT estimation */ + int rtt = t->S->last_tick - fresh_desc->time_sent; + if (t->sock.tcp.rtt == 0) { + t->sock.tcp.rtt = rtt; + } else { + t->sock.tcp.rtt = (7 * (t->sock.tcp.rtt << 3)) + (rtt << 3); + } + } + /* Update cwnd */ + if (t->sock.tcp.cwnd < t->sock.tcp.ssthresh) { + t->sock.tcp.cwnd += TCP_MSS; + } else { + t->sock.tcp.cwnd_count++; + if (t->sock.tcp.cwnd_count == t->sock.tcp.cwnd) { + t->sock.tcp.cwnd_count = 0; + t->sock.tcp.cwnd += TCP_MSS; + } + } + } else { + struct pkt_desc *desc; + /* Duplicate ack */ + t->sock.tcp.ssthresh = t->sock.tcp.cwnd / 2; + if (t->sock.tcp.ssthresh < 2 * TCP_MSS) { + t->sock.tcp.ssthresh = 2 * TCP_MSS; + } + t->sock.tcp.cwnd = t->sock.tcp.ssthresh + TCP_MSS; + t->sock.tcp.cwnd_count = 0; + desc = fifo_peek(&t->sock.tcp.txbuf); + while (desc && (desc->flags & PKT_FLAG_SENT)) { + struct ipstack_tcp_seg *seg = (struct ipstack_tcp_seg *)(t->txmem + desc->pos + sizeof(*desc)); + uint32_t seg_len = ee16(seg->ip.len) - (IP_HEADER_LEN + (seg->hlen >> 2)); + if (seg_len == 0) { + desc = fifo_pop(&t->sock.tcp.txbuf); + desc = fifo_peek(&t->sock.tcp.txbuf); + continue; + } + if (ee32(seg->seq) == ack) { + LOG("Retransmit %u size %d due to dupack %u\n", ee32(seg->seq), seg_len, ack); + desc->flags &= ~PKT_FLAG_SENT; /* Resend */ + break; + } + desc = fifo_next(&t->sock.tcp.txbuf, desc); + } + } +} + +/* Preselect socket, parse options, manage handshakes, pass to application */ +static void tcp_input(struct ipstack *S, struct ipstack_tcp_seg *tcp, uint32_t frame_len) +{ + for (int i = 0; i < MAX_TCPSOCKETS; i++) { + uint32_t tcplen; + uint32_t iplen; + struct tsocket *t = &S->tcpsockets[i]; + if (t->src_port == ee16(tcp->dst_port) && + t->local_ip == ee32(tcp->ip.dst) && t->remote_ip != S->ipconf.ip) { + /* TCP segment sanity checks */ + iplen = ee16(tcp->ip.len); + if (iplen > frame_len - sizeof(struct ipstack_eth_frame)) { + LOG("Wrong packet size %d, frame is %d\n", iplen, frame_len); + return; /* discard */ + } + + /* Check IP ttl */ + if (tcp->ip.ttl == 0) { + /* Send ICMP TTL exceeded */ + return; + } + tcplen = iplen - (IP_HEADER_LEN + (tcp->hlen >> 2)); + + /* Check if FIN */ + if (tcp->flags & 0x01) { + if (t->sock.tcp.state == TCP_ESTABLISHED) { + t->sock.tcp.state = TCP_CLOSE_WAIT; + t->sock.tcp.ack = ee32(tcp->seq) + 1; + tcp_send_ack(t); + } + else if (t->sock.tcp.state == TCP_FIN_WAIT_1) { + t->sock.tcp.state = TCP_CLOSING; + t->sock.tcp.ack = ee32(tcp->seq) + 1; + tcp_send_ack(t); + } + } + + /* Check if SYN */ + if (tcp->flags & 0x02) { + if (t->sock.tcp.state == TCP_LISTEN) { + t->sock.tcp.state = TCP_SYN_RCVD; + t->sock.tcp.ack = ee32(tcp->seq) + 1; + t->sock.tcp.seq = ipstack_getrandom(); + t->dst_port = ee16(tcp->src_port); + t->remote_ip = ee32(tcp->ip.src); + t->events |= CB_EVENT_READABLE; /* Keep flag until application calls accept */ + tcp_process_ts(t, tcp); + break; + } else if (t->sock.tcp.state == TCP_SYN_SENT) { + if (tcp->flags == 0x12) { + t->sock.tcp.state = TCP_ESTABLISHED; + t->sock.tcp.ack = ee32(tcp->seq) + 1; + t->sock.tcp.seq = ee32(tcp->ack); + t->events |= CB_EVENT_WRITABLE; + tcp_process_ts(t, tcp); + tcp_send_ack(t); + } + } + } + /* Check if pure ACK to SYN-ACK */ + if ((tcplen == 0) && (t->sock.tcp.state == TCP_SYN_RCVD)) { + if (tcp->flags == 0x10) { + t->sock.tcp.state = TCP_ESTABLISHED; + t->sock.tcp.ack = ee32(tcp->seq); + t->sock.tcp.seq = ee32(tcp->ack); + t->events |= CB_EVENT_WRITABLE; + } + } else if (t->sock.tcp.state == TCP_LAST_ACK) { + tcp_send_ack(t); + close_socket(t); + } + else if ((t->sock.tcp.state == TCP_ESTABLISHED) || + (t->sock.tcp.state == TCP_FIN_WAIT_1) || + (t->sock.tcp.state == TCP_FIN_WAIT_2) || + (t->sock.tcp.state == TCP_LAST_ACK)) { + + if (tcp->flags & 0x01) { + /* FIN */ + if (t->sock.tcp.state == TCP_ESTABLISHED) { + t->sock.tcp.state = TCP_CLOSE_WAIT; + t->events |= CB_EVENT_CLOSED; + t->events &= ~CB_EVENT_READABLE; + } else if (t->sock.tcp.state == TCP_FIN_WAIT_1) { + t->sock.tcp.state = TCP_CLOSING; + } + t->sock.tcp.ack = ee32(tcp->seq) + 1; + tcp_send_ack(t); + } + if (tcp->flags & 0x10) { + tcp_ack(t, tcp); + tcp_process_ts(t, tcp); + } + if (tcplen == 0) + return; + if ((t->sock.tcp.state == TCP_LAST_ACK) || (t->sock.tcp.state == TCP_CLOSING) || (t->sock.tcp.state == TCP_CLOSED)) + return; + tcp_recv(t, tcp); + } + } + } +} + +static void tcp_rto_cb(void *arg) +{ + struct tsocket *ts = (struct tsocket *)arg; + struct pkt_desc *desc; + struct ipstack_timer tmr = { }; + struct ipstack_timer *ptmr = NULL; + int pending = 0; + if ((ts->proto != IPPROTO_TCP) || (ts->sock.tcp.state != TCP_ESTABLISHED)) + return; + desc = fifo_peek(&ts->sock.tcp.txbuf); + while (desc) { + if (desc->flags & PKT_FLAG_SENT) { + desc->flags &= ~PKT_FLAG_SENT; + LOG("Scheduling retransmit %u\n", ee32(((struct ipstack_tcp_seg *)(ts->txmem + desc->pos + sizeof(*desc)))->seq)); + LOG("Fifo len: %d\n", fifo_len(&ts->sock.tcp.txbuf)); + LOG("Fifo space: %d\n", fifo_space(&ts->sock.tcp.txbuf)); + pending++; + } + desc = fifo_next(&ts->sock.tcp.txbuf, desc); + } + + if (ts->sock.tcp.tmr_rto != NO_TIMER) { + timer_binheap_cancel(&ts->S->timers, ts->sock.tcp.tmr_rto); + ts->sock.tcp.tmr_rto = NO_TIMER; + } + if (pending) { + LOG("RTO backoff: %d\n", ts->sock.tcp.rto_backoff); + ts->sock.tcp.rto_backoff++; + ts->sock.tcp.cwnd = TCP_MSS; + ts->sock.tcp.ssthresh = ts->sock.tcp.cwnd / 2; + + ptmr = &tmr; + ptmr->expires = ts->S->last_tick + (ts->sock.tcp.rto << ts->sock.tcp.rto_backoff); + ptmr->arg = ts; + ptmr->cb = tcp_rto_cb; + ts->sock.tcp.tmr_rto = timers_binheap_insert(&ts->S->timers, *ptmr); + } else { + ts->sock.tcp.rto_backoff = 0; + } +} + +static void close_socket(struct tsocket *ts) +{ + memset(ts, 0, sizeof(struct tsocket)); +} + + +int posix_socket(struct ipstack *s, int domain, int type, int protocol) +{ + struct tsocket *ts; + if (domain != AF_INET) + return -1; + (void)protocol; + if (type == IPSTACK_SOCK_STREAM) { + ts = tcp_new_socket(s); + if (!ts) + return -1; + return (ts - s->tcpsockets) | MARK_TCP_SOCKET; + } else if (type == IPSTACK_SOCK_DGRAM) { + ts = udp_new_socket(s); + if (!ts) + return -1; + return (ts - s->udpsockets) | MARK_UDP_SOCKET; + } + return -1; +} + +int posix_connect(struct ipstack *s, int sockfd, const struct ipstack_sockaddr *addr, socklen_t addrlen) +{ + struct tsocket *ts; + struct ipstack_sockaddr_in *sin = (struct ipstack_sockaddr_in *)addr; + struct ipstack_tcp_seg tcp; + if (!addr) + return -2; + ts = &s->tcpsockets[sockfd]; + if (ts->sock.tcp.state == TCP_ESTABLISHED) + return 0; + if (ts->sock.tcp.state == TCP_SYN_SENT) + return -11; /* Call again */ + if ((sin->sin_family != AF_INET) || (addrlen < sizeof(struct ipstack_sockaddr_in))) + return -2; + if (ts->sock.tcp.state == TCP_CLOSED) { + ts->sock.tcp.state = TCP_SYN_SENT; + ts->local_ip = s->ipconf.ip; + ts->remote_ip = ee32(sin->sin_addr.s_addr); + if (!ts->src_port) + ts->src_port = (uint16_t)(ipstack_getrandom() & 0xFFFF); + if (ts->src_port < 1024) + ts->src_port += 1024; + ts->dst_port = ee16(sin->sin_port); + tcp.src_port = ts->src_port; + tcp.dst_port = sin->sin_port; + tcp.seq = ts->sock.tcp.seq; + tcp.ack = 0; + tcp.hlen = (TCP_HEADER_LEN + TCP_OPTIONS_LEN) << 2; + tcp.flags = 0x02; /* SYN */ + tcp.win = ee16((uint16_t)queue_space(&ts->sock.tcp.rxbuf)); + tcp.csum = 0; + tcp.urg = 0; + fifo_push(&ts->sock.tcp.txbuf, &tcp, sizeof(struct ipstack_tcp_seg) + TCP_OPTIONS_LEN); + return -11; + } + return -2; +} + +int posix_accept(struct ipstack *s, int sockfd, struct ipstack_sockaddr *addr, socklen_t *addrlen) +{ + struct tsocket *ts; + struct ipstack_sockaddr_in *sin = (struct ipstack_sockaddr_in *)addr; + struct tsocket *newts; + + if ((addr) && (!(addrlen) || (*addrlen < sizeof(struct ipstack_sockaddr_in)))) + return -1; + + if (addr && addrlen) + *addrlen = sizeof(struct ipstack_sockaddr_in); + + if (sockfd & MARK_TCP_SOCKET) { + ts = &s->tcpsockets[sockfd & ~MARK_TCP_SOCKET]; + if ((ts->sock.tcp.state != TCP_SYN_RCVD) && (ts->sock.tcp.state != TCP_LISTEN)) + return -1; + + if (ts->sock.tcp.state == TCP_SYN_RCVD) { + tcp_send_synack(ts); + newts = tcp_new_socket(s); + if (!newts) + return -1; + ts->events &= ~CB_EVENT_READABLE; + newts->local_ip = ts->local_ip; + newts->remote_ip = ts->remote_ip; + newts->src_port = ts->src_port; + newts->dst_port = ts->dst_port; + newts->sock.tcp.ack = ts->sock.tcp.ack; + newts->sock.tcp.seq = ts->sock.tcp.seq + 1; + newts->sock.tcp.state = TCP_ESTABLISHED; + if (sin) { + sin->sin_family = AF_INET; + sin->sin_port = ee16(ts->dst_port); + sin->sin_addr.s_addr = ee32(ts->remote_ip); + } + ts->sock.tcp.state = TCP_LISTEN; + ts->sock.tcp.seq = ipstack_getrandom(); + return (newts - s->tcpsockets) | MARK_TCP_SOCKET; + } else if (ts->sock.tcp.state == TCP_LISTEN) { + return -11; + } + } + return -1;; +} + +int posix_sendto(struct ipstack *s, int sockfd, const void *buf, size_t len, int flags, + const struct ipstack_sockaddr *dest_addr, socklen_t addrlen) +{ + uint8_t frame[LINK_MTU]; + struct tsocket *ts; + struct ipstack_tcp_seg *tcp = (struct ipstack_tcp_seg *)frame; + struct ipstack_udp_datagram *udp = (struct ipstack_udp_datagram *)frame; + + (void)flags; + + if (sockfd < 0) + return -1; + if (sockfd & MARK_TCP_SOCKET) { + size_t sent = 0; + struct tcp_opt_ts *tsopt = (struct tcp_opt_ts *)tcp->data; + ts = &s->tcpsockets[sockfd & ~MARK_TCP_SOCKET]; + if (ts->sock.tcp.state != TCP_ESTABLISHED) + return -1; + while (sent < len) { + uint32_t payload_len = len - sent; + if (payload_len > (TCP_MSS - TCP_OPTIONS_LEN)) + payload_len = (TCP_MSS - TCP_OPTIONS_LEN); + if (fifo_space(&ts->sock.tcp.txbuf) < payload_len + sizeof(struct pkt_desc) + IP_HEADER_LEN + TCP_HEADER_LEN + TCP_OPTIONS_LEN) { + break; + } + memset(tcp, 0, sizeof(struct ipstack_tcp_seg)); + tcp->src_port = ee16(ts->src_port); + tcp->dst_port = ee16(ts->dst_port); + tcp->seq = ee32(ts->sock.tcp.seq); + tcp->ack = ee32(ts->sock.tcp.ack); + tcp->hlen = (TCP_HEADER_LEN + TCP_OPTIONS_LEN) << 2; + tcp->flags = 0x10 | ((sent == 0)? 0x08 : 0); /* ACK; PSH only on first */ + tcp->win = ee16(queue_space(&ts->sock.tcp.rxbuf)); + tcp->csum = 0; + tcp->urg = 0; + tsopt->opt = TCP_OPTION_TS; + tsopt->len = TCP_OPTION_TS_LEN; + tsopt->val = ee32(s->last_tick & 0xFFFFFFFF); + tsopt->ecr = ts->sock.tcp.last_ts; + tsopt->pad = 0x01; + tsopt->eoo = 0x00; + memcpy(tcp->data + TCP_OPTIONS_LEN, buf + sent, payload_len); + fifo_push(&ts->sock.tcp.txbuf, tcp, sizeof(struct ipstack_tcp_seg) + TCP_OPTIONS_LEN + payload_len); + sent += payload_len; + ts->sock.tcp.seq += payload_len; + } + if (sent == 0) + return -11; + else + return sent; + } else if (sockfd & MARK_UDP_SOCKET) { + struct ipstack_sockaddr_in *sin = (struct ipstack_sockaddr_in *)dest_addr; + ts = &s->udpsockets[sockfd & ~MARK_UDP_SOCKET]; + if ((ts->dst_port == 0) && (dest_addr == NULL)) + return -1; + memset(udp, 0, sizeof(struct ipstack_udp_datagram)); + if (sin) { + if (addrlen < sizeof(struct ipstack_sockaddr_in)) + return -1; + ts->dst_port = ee16(sin->sin_port); + ts->remote_ip = ee32(sin->sin_addr.s_addr); + } + if ((ts->dst_port==0) || (ts->remote_ip==0)) + return -1; + if (len > IP_MTU - IP_HEADER_LEN - UDP_HEADER_LEN) + return -1; /* Fragmentation not supported */ + if (fifo_space(&ts->sock.udp.txbuf) < len) + return -11; + if (ts->src_port == 0) { + ts->src_port = (uint16_t)(ipstack_getrandom() & 0xFFFF); + if (ts->src_port < 1024) + ts->src_port += 1024; + } + udp->src_port = ee16(ts->src_port); + udp->dst_port = ee16(ts->dst_port); + udp->len = ee16(len + UDP_HEADER_LEN); + udp->csum = 0; + memcpy(udp->data, buf, len); + fifo_push(&ts->sock.udp.txbuf, udp, sizeof(struct ipstack_udp_datagram) + len); + return len; + } else return -1; +} + +int posix_recvfrom(struct ipstack *s, int sockfd, void *buf, size_t len, int flags, + struct ipstack_sockaddr *src_addr, socklen_t *addrlen) +{ + uint32_t seg_len; + struct pkt_desc *desc; + struct ipstack_udp_datagram *udp; + struct tsocket *ts; + (void)flags; + + if (sockfd & MARK_TCP_SOCKET) { + ts = &s->tcpsockets[sockfd & ~MARK_TCP_SOCKET]; + if (ts->sock.tcp.state == TCP_CLOSE_WAIT) + { + /* In close-wait, return 0 if the queue is empty */ + if (queue_len(&ts->sock.tcp.rxbuf) == 0) + return 0; + return queue_pop(&ts->sock.tcp.rxbuf, buf, len); + } else if (ts->sock.tcp.state == TCP_ESTABLISHED) { + return queue_pop(&ts->sock.tcp.rxbuf, buf, len); + } else { /* Not established */ + return -1; + } + } else if (sockfd & MARK_UDP_SOCKET) { + struct ipstack_sockaddr_in *sin = (struct ipstack_sockaddr_in *)src_addr; + ts = &s->udpsockets[sockfd & ~MARK_UDP_SOCKET]; + if (sin && *addrlen < sizeof(struct ipstack_sockaddr_in)) + return -1; + *addrlen = sizeof(struct ipstack_sockaddr_in); + if (fifo_len(&ts->sock.udp.rxbuf) == 0) + return -11; + desc = fifo_peek(&ts->sock.udp.rxbuf); + udp = (struct ipstack_udp_datagram *)(ts->rxmem + desc->pos + sizeof(*desc)); + if (sin) { + sin->sin_family = AF_INET; + sin->sin_port = ee16(udp->src_port); + sin->sin_addr.s_addr = ee32(ts->remote_ip); + } + seg_len = ee16(udp->len) - UDP_HEADER_LEN; + if (seg_len > len) + return -1; + memcpy(buf, udp->data, seg_len); + fifo_pop(&ts->sock.udp.rxbuf); + return seg_len; + } else return -1; +} + +int posix_close(struct ipstack *s, int sockfd) +{ + if (sockfd & MARK_TCP_SOCKET) { + struct tsocket *ts = &s->tcpsockets[sockfd & ~MARK_TCP_SOCKET]; + if (ts->sock.tcp.state == TCP_ESTABLISHED) { + ts->sock.tcp.state = TCP_FIN_WAIT_1; + tcp_send_finack(ts); + return -11; + } else if (ts->sock.tcp.state == TCP_CLOSE_WAIT) { + ts->sock.tcp.state = TCP_LAST_ACK; + tcp_send_finack(ts); + return -11; + } else if (ts->sock.tcp.state == TCP_CLOSING) { + ts->sock.tcp.state = TCP_TIME_WAIT; + return -11; + } else if (ts->sock.tcp.state == TCP_FIN_WAIT_1) { + ts->sock.tcp.state = TCP_CLOSING; + return -11; + } else if (ts->sock.tcp.state == TCP_FIN_WAIT_2) { + ts->sock.tcp.state = TCP_TIME_WAIT; + return -11; + } else if (ts->sock.tcp.state != TCP_CLOSED) { + ts->sock.tcp.state = TCP_CLOSED; + close_socket(ts); + return 0; + } else return -1; + } else if (sockfd & MARK_UDP_SOCKET) { + struct tsocket *ts = &s->udpsockets[sockfd & ~MARK_UDP_SOCKET]; + close_socket(ts); + return 0; + } else return -1; + return 0; +} + +int posix_getsockname(struct ipstack *s, int sockfd, struct ipstack_sockaddr *addr, socklen_t *addrlen) +{ + struct tsocket *ts = &s->tcpsockets[sockfd]; + struct ipstack_sockaddr_in *sin = (struct ipstack_sockaddr_in *)addr; + if (!sin || *addrlen < sizeof(struct ipstack_sockaddr_in)) + return -1; + sin->sin_family = AF_INET; + sin->sin_port = ts->src_port; + sin->sin_addr.s_addr = ts->local_ip; + return 0; +} + +int posix_bind(struct ipstack *s, int sockfd, const struct ipstack_sockaddr *addr, socklen_t addrlen) +{ + struct tsocket *ts; + struct ipstack_sockaddr_in *sin = (struct ipstack_sockaddr_in *)addr; + if (!sin || addrlen < sizeof(struct ipstack_sockaddr_in)) + return -1; + + if (sockfd & MARK_TCP_SOCKET) { + ts = &s->tcpsockets[sockfd & ~MARK_TCP_SOCKET]; + if (ts->sock.tcp.state != TCP_CLOSED) + return -1; + if ((sin->sin_family != AF_INET) || (addrlen < sizeof(struct ipstack_sockaddr_in))) + return -1; + ts->local_ip = s->ipconf.ip; + ts->src_port = ee16(sin->sin_port); + return 0; + } else if (sockfd & MARK_UDP_SOCKET) { + ts = &s->udpsockets[sockfd & ~MARK_UDP_SOCKET]; + if (ts->src_port != 0) + return -1; + if ((sin->sin_family != AF_INET) || (addrlen < sizeof(struct ipstack_sockaddr_in))) + return -1; + ts->src_port = ee16(sin->sin_port); + return 0; + } else return -1; + +} + +int posix_listen(struct ipstack *s, int sockfd, int backlog) +{ + struct tsocket *ts; + (void)backlog; + if (sockfd & MARK_TCP_SOCKET) { + ts = &s->tcpsockets[sockfd & ~MARK_TCP_SOCKET]; + } else return -1; + if (ts->sock.tcp.state != TCP_CLOSED) + return -1; + ts->sock.tcp.state = TCP_LISTEN; + return 0; +} + +int posix_getpeername(struct ipstack *s, int sockfd, struct ipstack_sockaddr *addr, socklen_t *addrlen) +{ + struct tsocket *ts = &s->tcpsockets[sockfd]; + struct ipstack_sockaddr_in *sin = (struct ipstack_sockaddr_in *)addr; + if (!sin || *addrlen < sizeof(struct ipstack_sockaddr_in)) + return -1; + sin->sin_family = AF_INET; + sin->sin_port = ee16(ts->dst_port); + sin->sin_addr.s_addr = ee32(ts->remote_ip); + return 0; +} + +/* ICMP */ +#define ICMP_ECHO_REPLY 0 +#define ICMP_ECHO_REQUEST 8 + +/* Reply to ICMP echo requests */ +static void icmp_input(struct ipstack *s, struct ipstack_ip_packet *ip, uint32_t len) +{ + struct ipstack_icmp_packet *icmp = (struct ipstack_icmp_packet *)ip; + uint32_t tmp; + if (!DHCP_IS_RUNNING(s) && (icmp->type == ICMP_ECHO_REQUEST)) { + icmp->type = ICMP_ECHO_REPLY; + icmp->csum += 8; + tmp = ip->src; + ip->src = ip->dst; + ip->dst = tmp; + ip->id = ee16(s->ipcounter++); + ip->csum = 0; + iphdr_set_checksum(ip); + eth_output_add_header(s, ip->eth.src, &ip->eth, ETH_TYPE_IP); + s->ll_dev.send(&s->ll_dev, ip, len); + } +} + +static int dhcp_send_discover(struct ipstack *s); +static int dhcp_send_request(struct ipstack *s); +static void dhcp_timer_cb(void *arg) +{ + struct ipstack *s = (struct ipstack *)arg; + LOG("dhcp timeout\n"); + if (!s) + return; + switch(s->dhcp_state) { + case DHCP_DISCOVER_SENT: + if (s->dhcp_timeout_count < DHCP_DISCOVER_RETRIES) { + dhcp_send_discover(s); + s->dhcp_timeout_count++; + } else + s->dhcp_state = DHCP_OFF; + break; + case DHCP_REQUEST_SENT: + if (s->dhcp_timeout_count < DHCP_REQUEST_RETRIES) { + dhcp_send_request(s); + s->dhcp_timeout_count++; + } else + s->dhcp_state = DHCP_OFF; + break; + default: + break; + } +} + +static void dhcp_cancel_timer(struct ipstack *s) +{ + if (s->dhcp_timer != NO_TIMER) { + timer_binheap_cancel(&s->timers, s->dhcp_timer); + s->dhcp_timer = NO_TIMER; + s->dhcp_timeout_count = 0; + } +} + +static int dhcp_parse_offer(struct ipstack *s, struct dhcp_msg *msg) +{ + struct dhcp_option *opt = (struct dhcp_option *)(msg->options); + uint32_t ip; + uint32_t netmask = 0xFFFFFF00; + while (opt->code != 0xFF) { + if (opt->code == DHCP_OPTION_MSG_TYPE) { + if (opt->data[0] == DHCP_OFFER) { + opt = (struct dhcp_option *)((uint8_t *)opt + 3); + while (opt->code != 0xFF) { + if (opt->code == DHCP_OPTION_SERVER_ID) { + uint32_t data = opt->data[0] | (opt->data[1] << 8) | (opt->data[2] << 16) | (opt->data[3] << 24); + s->dhcp_server_ip = ee32(data); + } + if (opt->code == DHCP_OPTION_SUBNET_MASK) { + netmask = opt->data[0] | (opt->data[1] << 8) | (opt->data[2] << 16) | (opt->data[3] << 24); + } + + opt = (struct dhcp_option *)((uint8_t *)opt + 2 + opt->len); + } + ip = ee32(msg->yiaddr); + s->ipconf.ip = ip; + s->ipconf.mask = ee32(netmask); + s->dhcp_ip = ip; + dhcp_cancel_timer(s); + s->dhcp_state = DHCP_REQUEST_SENT; + return 0; + } + } + opt = (struct dhcp_option *)((uint8_t *)opt + 2 + opt->len); + } + if ((s->dhcp_server_ip != 0) && (s->dhcp_ip != 0)) { + s->dhcp_state = DHCP_REQUEST_SENT; + return 0; + } + return -1; +} + +static int dhcp_parse_ack(struct ipstack *s, struct dhcp_msg *msg) +{ + struct dhcp_option *opt = (struct dhcp_option *)(msg->options); + while (opt->code != 0xFF) { + if (opt->code == DHCP_OPTION_MSG_TYPE) { + if (opt->data[0] == DHCP_ACK) { + opt = (struct dhcp_option *)((uint8_t *)opt + 3); + while (opt->code != 0xFF) { + if (opt->code == DHCP_OPTION_SERVER_ID) { + uint32_t data = opt->data[0] | (opt->data[1] << 8) | (opt->data[2] << 16) | (opt->data[3] << 24); + s->dhcp_server_ip = ee32(data); + } + if (opt->code == DHCP_OPTION_OFFER_IP) { + uint32_t data = opt->data[0] | (opt->data[1] << 8) | (opt->data[2] << 16) | (opt->data[3] << 24); + s->ipconf.ip = ee32(data); + } + if (opt->code == DHCP_OPTION_SUBNET_MASK) { + uint32_t data = opt->data[0] | (opt->data[1] << 8) | (opt->data[2] << 16) | (opt->data[3] << 24); + s->ipconf.mask = ee32(data); + } + if (opt->code == DHCP_OPTION_ROUTER) { + uint32_t data = opt->data[0] | (opt->data[1] << 8) | (opt->data[2] << 16) | (opt->data[3] << 24); + s->ipconf.gw = ee32(data); + } + opt = (struct dhcp_option *)((uint8_t *)opt + 2 + opt->len); + } + if ((s->ipconf.ip != 0) && (s->ipconf.mask != 0)) { + dhcp_cancel_timer(s); + s->dhcp_state = DHCP_BOUND; + return 0; + } + } else break; + } else break; + } + return -1; +} + +static int dhcp_poll(struct ipstack *s) +{ + struct ipstack_sockaddr_in sin; + socklen_t sl = sizeof(struct ipstack_sockaddr_in); + struct dhcp_msg msg; + int len; + memset(&msg, 0xBB, sizeof(msg)); + len = posix_recvfrom(s, s->dhcp_udp_sd, &msg, sizeof(struct dhcp_msg), 0, (struct ipstack_sockaddr *)&sin, &sl); + if (len < 0) + return -1; + if ((s->dhcp_state == DHCP_DISCOVER_SENT) && (dhcp_parse_offer(s, &msg) == 0)) + dhcp_send_request(s); + else if ((s->dhcp_state == DHCP_REQUEST_SENT) && (dhcp_parse_ack(s, &msg) == 0)) + LOG("DHCP configuration received.\n"); + return 0; +} + +static int dhcp_send_request(struct ipstack *s) +{ + struct dhcp_msg req; + struct dhcp_option *opt = (struct dhcp_option *)(req.options); + struct ipstack_timer tmr = { }; + struct ipstack_sockaddr_in sin; + uint32_t opt_sz = 0; + /* Prepare DHCP request */ + memset(&req, 0, sizeof(struct dhcp_msg)); + req.op = BOOT_REQUEST; + s->dhcp_state = DHCP_REQUEST_SENT; + req.htype = 1; /* Ethernet */ + req.hlen = 6; /* MAC */ + req.xid = ee32(s->dhcp_xid); + req.magic = ee32(DHCP_MAGIC); + memcpy(req.chaddr, s->ll_dev.mac, 6); + + /* Set options */ + memset(req.options, 0xFF, sizeof(req.options)); + opt->code = DHCP_OPTION_MSG_TYPE; /* DHCP message type */ + opt->len = 1; + opt->data[0] = DHCP_REQUEST; + opt_sz += 3; + opt = (struct dhcp_option *)((uint8_t *)opt + 3); + opt->code = DHCP_OPTION_PARAM_REQ; /* Parameter request list */ + opt->len = 3; + opt->data[0] = 1; /* Subnet mask */ + opt->data[1] = 3; /* Router */ + opt->data[2] = 6; /* DNS */ + opt_sz += 5; + opt = (struct dhcp_option *)((uint8_t *)opt + 5); + opt->code = DHCP_OPTION_SERVER_ID; /* Server ID */ + opt->len = 4; + opt->data[0] = (s->dhcp_server_ip >> 24) & 0xFF; + opt->data[1] = (s->dhcp_server_ip >> 16) & 0xFF; + opt->data[2] = (s->dhcp_server_ip >> 8) & 0xFF; + opt->data[3] = (s->dhcp_server_ip >> 0) & 0xFF; + opt_sz += 6; + opt = (struct dhcp_option *)((uint8_t *)opt + 6); + opt->code = DHCP_OPTION_OFFER_IP; /* Requested IP */ + opt->len = 4; + opt->data[0] = (s->dhcp_ip >> 24) & 0xFF; + opt->data[1] = (s->dhcp_ip >> 16) & 0xFF; + opt->data[2] = (s->dhcp_ip >> 8) & 0xFF; + opt->data[3] = (s->dhcp_ip >> 0) & 0xFF; + opt_sz += 6; + + opt_sz++; + memset(&sin, 0, sizeof(struct ipstack_sockaddr_in)); + sin.sin_port = ee16(DHCP_SERVER_PORT); + sin.sin_addr.s_addr = ee32(0xFFFFFFFF); /* Broadcast */ + sin.sin_family = AF_INET; + posix_sendto(s, s->dhcp_udp_sd, &req, DHCP_HEADER_LEN + opt_sz, 0, + (struct ipstack_sockaddr *)&sin, sizeof(struct ipstack_sockaddr_in)); + tmr.expires = s->last_tick + DHCP_REQUEST_TIMEOUT + (ipstack_getrandom() % 200); + tmr.arg = s; + tmr.cb = dhcp_timer_cb; + s->dhcp_timer = timers_binheap_insert(&s->timers, tmr); + return 0; +} + +static int dhcp_send_discover(struct ipstack *s) +{ + struct dhcp_msg disc; + struct dhcp_option *opt = (struct dhcp_option *)(disc.options); + struct ipstack_timer tmr = { }; + struct ipstack_sockaddr_in sin; + uint32_t opt_sz = 0; + /* Prepare DHCP discover */ + memset(&disc, 0, sizeof(struct dhcp_msg)); + disc.op = BOOT_REQUEST; + disc.htype = 1; /* Ethernet */ + disc.hlen = 6; /* MAC */ + disc.xid = ee32(s->dhcp_xid); + disc.magic = ee32(DHCP_MAGIC); + memcpy(disc.chaddr, s->ll_dev.mac, 6); + + /* Set options */ + memset(disc.options, 0xFF, sizeof(disc.options)); + opt->code = DHCP_OPTION_MSG_TYPE; /* DHCP message type */ + opt->len = 1; + opt->data[0] = DHCP_DISCOVER; + opt_sz += 3; + opt = (struct dhcp_option *)((uint8_t *)opt + 3); + opt->code = 55; /* Parameter request list */ + opt->len = 3; + opt->data[0] = 1; /* Subnet mask */ + opt->data[1] = 3; /* Router */ + opt->data[2] = 6; /* DNS */ + opt_sz += 5; + opt_sz ++; + + memset(&sin, 0, sizeof(struct ipstack_sockaddr_in)); + sin.sin_port = ee16(DHCP_SERVER_PORT); + sin.sin_addr.s_addr = ee32(0xFFFFFFFF); /* Broadcast */ + sin.sin_family = AF_INET; + posix_sendto(s, s->dhcp_udp_sd, &disc, DHCP_HEADER_LEN + opt_sz, 0, + (struct ipstack_sockaddr *)&sin, sizeof(struct ipstack_sockaddr_in)); + tmr.expires = s->last_tick + DHCP_DISCOVER_TIMEOUT + (ipstack_getrandom() % 200); + tmr.arg = s; + tmr.cb = dhcp_timer_cb; + s->dhcp_state = DHCP_DISCOVER_SENT; + + s->dhcp_timer = timers_binheap_insert(&s->timers, tmr); + return 0; +} + +int dhcp_bound(struct ipstack *s) +{ + return (s->dhcp_state == DHCP_BOUND); +} + +int dhcp_client_init(struct ipstack *s) +{ + struct ipstack_sockaddr_in sin; + if (s->dhcp_state != DHCP_OFF) + return -1; + s->dhcp_xid = ipstack_getrandom(); + + if (s->dhcp_udp_sd > 0) { + posix_close(s, s->dhcp_udp_sd); + } + + s->dhcp_udp_sd = posix_socket(s, AF_INET, IPSTACK_SOCK_DGRAM, IPPROTO_UDP); + if (s->dhcp_udp_sd < 0) { + s->dhcp_state = DHCP_OFF; + return -1; + } + memset(&sin, 0, sizeof(struct ipstack_sockaddr_in)); + sin.sin_family = AF_INET; + sin.sin_port = ee16(DHCP_CLIENT_PORT); + if (posix_bind(s, s->dhcp_udp_sd, (struct ipstack_sockaddr *)&sin, sizeof(struct ipstack_sockaddr_in)) < 0) { + s->dhcp_state = DHCP_OFF; + return -1; + } + return dhcp_send_discover(s); +} + +/* ARP */ +#ifdef ETHERNET + +static void arp_request(struct ipstack *s, ip4 tip) +{ + struct arp_packet arp; + if (s->arp.last_arp + 1000 > s->last_tick) { + return; + } + s->arp.last_arp = s->last_tick; + memset(&arp, 0, sizeof(struct arp_packet)); + memcpy(arp.eth.dst, "\xff\xff\xff\xff\xff\xff", 6); + memcpy(arp.eth.src, s->ll_dev.mac, 6); + arp.eth.type = ee16(0x0806); + arp.htype = ee16(1); /* Ethernet */ + arp.ptype = ee16(0x0800); + arp.hlen = 6; + arp.plen = 4; + arp.opcode = ee16(ARP_REQUEST); + memcpy(arp.sma, s->ll_dev.mac, 6); + arp.sip = ee32(s->ipconf.ip); + memset(arp.tma, 0, 6); + arp.tip = ee32(tip); + eth_output_add_header(s, NULL, &arp.eth, ETH_TYPE_ARP); + s->ll_dev.send(&s->ll_dev, &arp, sizeof(struct arp_packet)); +} + +static void arp_recv(struct ipstack *s, void *buf, int len) +{ + struct arp_packet *arp = (struct arp_packet *)buf; + if (arp->opcode == ee16(ARP_REQUEST) && arp->tip == ee32(s->ipconf.ip)) { + arp->opcode = ee16(ARP_REPLY); + memcpy(arp->tma, arp->sma, 6); + memcpy(arp->sma, s->ll_dev.mac, 6); + arp->tip = arp->sip; + arp->sip = ee32(s->ipconf.ip); + /* Add neighbor to ARP table */ + for (int i = 0; i < MAX_NEIGHBORS; i++) { + if (s->arp.neighbors[i].ip == IPADDR_ANY) { + memcpy(s->arp.neighbors[i].mac, arp->sma, 6); + s->arp.neighbors[i].ip = ee32(arp->sip); + break; + } + } + eth_output_add_header(s, arp->tma, &arp->eth, ETH_TYPE_ARP); + s->ll_dev.send(&s->ll_dev, buf, len); + } + if (arp->opcode == ee16(ARP_REPLY)) { + int i; + for (i = 0; i < MAX_NEIGHBORS; i++) { + if (s->arp.neighbors[i].ip == ee32(arp->sip)) { + memcpy(s->arp.neighbors[i].mac, arp->sma, 6); + break; + } + } + for (i = 0; i < MAX_NEIGHBORS; i++) { + if (s->arp.neighbors[i].ip == IPADDR_ANY) { + memcpy(s->arp.neighbors[i].mac, arp->sma, 6); + s->arp.neighbors[i].ip = ee32(arp->sip); + break; + } + } + } +} + +static int arp_lookup(struct ipstack *s, ip4 ip, uint8_t *mac) +{ + memset(mac, 0, 6); + for (int i = 0; i < MAX_NEIGHBORS; i++) { + if (s->arp.neighbors[i].ip == ip) { + memcpy(mac, s->arp.neighbors[i].mac, 6); + return 0; + } + } + return -1; +} + +#endif + +/* Initialize the IP stack */ +void ipstack_init(struct ipstack *s) +{ + memset(s, 0, sizeof(struct ipstack)); +} + +struct ll *ipstack_getdev(struct ipstack *s) +{ + return &s->ll_dev; +} + +static struct ipstack ipstack_static; +void ipstack_init_static(struct ipstack **s) +{ + if (!s) + return; + ipstack_init(&ipstack_static); + *s = &ipstack_static; +} + +/* ipstack_poll: poll the network stack for incoming pacargts. + * This function should be called in a loop to process incoming packets. + * It will call the poll function of the device driver and process the + * received packets. + * + * This function also handles timers for all supported protocols. + * + * It returns the number of milliseconds to wait before + * calling it again. + */ +int ipstack_poll(struct ipstack *s, uint64_t now) +{ + int len = 0; + int i = 0; + uint8_t buf[LINK_MTU]; + struct ipstack_timer tmr; + memset(buf, 0, LINK_MTU); + + s->last_tick = now; + + /* Step 1: Poll the device */ + do { + len = s->ll_dev.poll(&s->ll_dev, buf, LINK_MTU); + if (len > 0) { + /* Process packet */ +#ifdef ETHERNET + struct ipstack_eth_frame *eth = (struct ipstack_eth_frame *)buf; + if (eth->type == ee16(0x0800)) { + if ((memcmp(eth->dst, s->ll_dev.mac, 6) != 0) && (memcmp(eth->dst, "\xff\xff\xff\xff\xff\xff", 6) != 0)) { + /* Not for us */ + continue; + } + struct ipstack_ip_packet *ip = (struct ipstack_ip_packet *)eth; + if (ip->ver_ihl == 0x45 && ip->proto == 0x06) { + struct ipstack_tcp_seg *tcp = (struct ipstack_tcp_seg *)ip; + tcp_input(s, tcp, len); + } + else if (ip->ver_ihl == 0x45 && ip->proto == 0x11) { + struct ipstack_udp_datagram *udp = (struct ipstack_udp_datagram *)ip; + udp_try_recv(s, udp, len); + } else if (ip->ver_ihl == 0x45 && ip->proto == 0x01) { + icmp_input(s, ip, len); + } + } else if (eth->type == ee16(0x0806)) { + arp_recv(s, buf, len); + } +#else + /* No ethernet, assume IP */ + struct ipstack_ip_packet *ip = (struct ipstack_ip_packet *)buf; + if (ip->ver_ihl == 0x45 && ip->proto == 0x06) { + struct ipstack_tcp_seg *tcp = (struct ipstack_tcp_seg *)ip; + tcp_input(s, tcp, len); + } + else if (ip->ver_ihl == 0x45 && ip->proto == 0x11) { + struct ipstack_udp_datagram *udp = (struct ipstack_udp_datagram *)ip; + udp_try_recv(s, udp, len); + } else if (ip->ver_ihl == 0x45 && ip->proto == 0x01) { + icmp_input(s, ip, len); + } +#endif + /* No default action required: the buffer is in stack and will be discarded on return */ + } + } while (len > 0); + + /* Step 2: Handle timers */ + while(is_timer_expired(&s->timers, now)) { + tmr = timers_binheap_pop(&s->timers); + tmr.cb(tmr.arg); + } + /* Step 3: handle DHCP and application callbacks */ + for (i = 0; i < MAX_TCPSOCKETS; i++) { + struct tsocket *ts = &s->tcpsockets[i]; + if ((ts->sock.tcp.state != TCP_CLOSED) && (ts->callback) && (ts->events)) { + ts->callback(i | MARK_TCP_SOCKET, ts->events, ts->callback_arg); + ts->events = 0; + } + } + for (i = 0; i < MAX_UDPSOCKETS; i++) { + struct tsocket *ts = &s->udpsockets[i]; + if ((ts->callback) && (ts->events)) { + ts->callback(i | MARK_UDP_SOCKET, ts->events, ts->callback_arg); + ts->events = 0; + } + } + /* Poll DHCP */ + if (s->dhcp_state == DHCP_DISCOVER_SENT || s->dhcp_state == DHCP_REQUEST_SENT) { + dhcp_poll(s); + } + + /* Step 4: attempt to write any pending data */ + for (i = 0; i < MAX_TCPSOCKETS; i++) { + struct tsocket *ts = &s->tcpsockets[i]; + uint32_t len; + uint32_t in_flight = 0; + struct pkt_desc *desc; + struct ipstack_tcp_seg *tcp; + desc = fifo_peek(&ts->sock.tcp.txbuf); + while (desc) { + tcp = (struct ipstack_tcp_seg *)(ts->txmem + desc->pos + sizeof(*desc)); + if (desc->flags & PKT_FLAG_SENT) { + in_flight += ee16(tcp->ip.len) - (IP_HEADER_LEN + (tcp->hlen >> 2)); + desc = fifo_next(&ts->sock.tcp.txbuf, desc); + continue; + } else if (desc != NULL) { +#ifdef ETHERNET + ip4 nexthop = NEXTHOP(s, ts->remote_ip); + if (arp_lookup(s, nexthop, ts->nexthop_mac) < 0) { + /* Send ARP request */ + arp_request(s, nexthop); + break; + }else +#endif + if (in_flight <= ts->sock.tcp.cwnd) { + struct ipstack_timer tmr = {}; + len = desc->len - ETH_HEADER_LEN; + tcp = (struct ipstack_tcp_seg *)(ts->txmem + desc->pos + sizeof(*desc)); + if ((ts->sock.tcp.ack == ts->sock.tcp.last_ack) && + (len == IP_HEADER_LEN + (uint32_t)(tcp->hlen >> 2)) && + (tcp->flags == 0x10)) { + desc->flags |= PKT_FLAG_SENT; + fifo_pop(&ts->sock.tcp.txbuf); + desc = fifo_peek(&ts->sock.tcp.txbuf); + continue; + } + /* Refresh ack counter */ + ts->sock.tcp.last_ack = ts->sock.tcp.ack; + tcp->ack = ee32(ts->sock.tcp.ack); + tcp->win = ee16(queue_space(&ts->sock.tcp.rxbuf)); + ip_output_add_header(ts, (struct ipstack_ip_packet *)tcp, IPPROTO_TCP, len); + s->ll_dev.send(&s->ll_dev, tcp, desc->len); + desc->flags |= PKT_FLAG_SENT; + desc->time_sent = now; + if (len == IP_HEADER_LEN + (uint32_t)(tcp->hlen >> 2)) { + desc = fifo_pop(&ts->sock.tcp.txbuf); + } else { + uint32_t payload_len = len - (IP_HEADER_LEN + (tcp->hlen >> 2)); + if (ts->sock.tcp.tmr_rto != NO_TIMER) { + timer_binheap_cancel(&s->timers, ts->sock.tcp.tmr_rto); + ts->sock.tcp.tmr_rto = NO_TIMER; + } + tmr.cb = tcp_rto_cb; + tmr.expires = now + (ts->sock.tcp.rto << ts->sock.tcp.rto_backoff); + tmr.arg = ts; + ts->sock.tcp.tmr_rto = timers_binheap_insert(&s->timers, tmr); + in_flight += payload_len; + desc = fifo_next(&ts->sock.tcp.txbuf, desc); + } + } else { + break; + } + } + } + } + for (i = 0; i < MAX_UDPSOCKETS; i++) { + struct tsocket *t = &s->udpsockets[i]; + struct pkt_desc *desc = fifo_peek(&t->sock.udp.txbuf); + while (desc) { + struct ipstack_udp_datagram *udp = (struct ipstack_udp_datagram *)(t->txmem + desc->pos + sizeof(*desc)); +#ifdef ETHERNET + ip4 nexthop = NEXTHOP(s, t->remote_ip); + if ((!IS_IP_BCAST(nexthop) && (arp_lookup(s, nexthop, t->nexthop_mac) < 0))) { + /* Send ARP request */ + arp_request(s, nexthop); + break; + } + if (IS_IP_BCAST(nexthop)) memset(t->nexthop_mac, 0xFF, 6); +#endif + len = desc->len - ETH_HEADER_LEN; + ip_output_add_header(t, (struct ipstack_ip_packet *)udp, IPPROTO_UDP, len); + s->ll_dev.send(&s->ll_dev, udp, desc->len); + fifo_pop(&t->sock.udp.txbuf); + desc = fifo_peek(&t->sock.udp.txbuf); + } + } + return 0; +} + +void ipstack_ipconfig_set(struct ipstack *s, ip4 ip, ip4 mask, ip4 gw) +{ + s->ipconf.ip = ip; + s->ipconf.mask = mask; + s->ipconf.gw = gw; +} + +void ipstack_ipconfig_get(struct ipstack *s, ip4 *ip, ip4 *mask, ip4 *gw) +{ + *ip = s->ipconf.ip; + *mask = s->ipconf.mask; + *gw = s->ipconf.gw; +} + +static uint32_t atou(const char *s) +{ + uint32_t ret = 0; + while (*s >= '0' && *s <= '9') { + ret = ret * 10 + (*s - '0'); + s++; + } + return ret; +} + +ip4 atoip4(const char *ip) +{ + ip4 ret = 0; + int i = 0; + int j = 0; + for (i = 0; i < 4; i++) { + ret |= (atou(ip + j) << (24 - i * 8)); + while (ip[j] != '.' && ip[j] != '\0') j++; + if (ip[j] == '\0') break; + j++; + } + return ret; +} diff --git a/test/test-linux.c b/test/test-linux.c new file mode 100644 index 0000000..07bffe1 --- /dev/null +++ b/test/test-linux.c @@ -0,0 +1,346 @@ +#include +#include +/* tap device */ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "femtotcp.h" +static int tap_fd; + +//#define DHCP +#define FEMTOTCP_IP "10.10.10.2" +#define LINUX_IP "10.10.10.1" +#define TEST_SIZE (8 * 1024) + +void print_buffer(uint8_t *buf, int len) +{ + int i; + for (i = 0; i < len; i++) { + if (i % 16 == 0) + printf("\n"); + printf("%02x ", buf[i]); + } + printf("\n"); +} + +int tap_poll(struct ll *ll, void *buf, int len) +{ + struct pollfd pfd; + (void)ll; + int ret; + pfd.fd = tap_fd; + pfd.events = POLLIN; + ret = poll(&pfd, 1, 2); + if (ret < 0) { + perror("poll"); + return -1; + } + if (ret == 0) { + return 0; + } + return read(tap_fd, buf, len); +} + +int tap_send(struct ll *ll, void *buf, int len) +{ + (void)ll; + //print_buffer(buf, len); + return write(tap_fd, buf, len); +} + +int tap_init(struct ll *ll, const char *ifname) +{ + struct ifreq ifr; + struct sockaddr_in *addr; + int sock_fd; + + if ((tap_fd = open("/dev/net/tun", O_RDWR)) < 0) { + perror("accessing /dev/net/tun"); + return -1; + } + memset(&ifr, 0, sizeof(ifr)); + ifr.ifr_flags = IFF_TAP | IFF_NO_PI; + strncpy(ifr.ifr_name, ifname, IFNAMSIZ); + if (ioctl(tap_fd, TUNSETIFF, (void *)&ifr) < 0) { + perror("ioctl TUNSETIFF"); + close(tap_fd); + return -1; + } + /* Get mac address */ + if (ioctl(tap_fd, SIOCGIFHWADDR, &ifr) < 0) { + perror("ioctl SIOCGIFHWADDR"); + close(tap_fd); + return -1; + } + memcpy(ll->mac, ifr.ifr_hwaddr.sa_data, 6); + ll->mac[5] ^= 1; + ll->poll = tap_poll; + ll->send = tap_send; + + + /* Set up network side */ + sock_fd = socket(AF_INET, SOCK_DGRAM, 0); + if (sock_fd < 0) { + perror("socket"); + close(tap_fd); + return -1; + } + memset(&ifr, 0, sizeof(ifr)); + ifr.ifr_flags = IFF_TAP | IFF_NO_PI; + strncpy(ifr.ifr_name, ifname, IFNAMSIZ); + if (ioctl(sock_fd, SIOCGIFFLAGS, &ifr) < 0) { + perror("ioctl SIOCGIFFLAGS"); + close(sock_fd); + return -1; + } + ifr.ifr_flags |= IFF_UP; + if (ioctl(sock_fd, SIOCSIFFLAGS, &ifr) < 0) { + perror("ioctl SIOCSIFFLAGS"); + close(sock_fd); + return -1; + } + addr = (struct sockaddr_in *)&ifr.ifr_addr; + addr->sin_family = AF_INET; + inet_pton(AF_INET, LINUX_IP, &addr->sin_addr); + if (ioctl(sock_fd, SIOCSIFADDR, &ifr) < 0) { + perror("ioctl SIOCSIFADDR"); + close(sock_fd); + return -1; + } + inet_pton(AF_INET, "255.255.255.0", &addr->sin_addr); + if (ioctl(sock_fd, SIOCSIFNETMASK, &ifr) < 0) { + perror("ioctl SIOCSIFNETMASK"); + close(sock_fd); + return -1; + } + if (ioctl(sock_fd, SIOCGIFFLAGS, &ifr) < 0) { + perror("ioctl SIOCGIFFLAGS"); + close(sock_fd); + return -1; + } + ifr.ifr_flags = IFF_UP | IFF_RUNNING; + if (ioctl(sock_fd, SIOCSIFFLAGS, &ifr) < 0) { + perror("ioctl SIOCSIFFLAGS"); + close(sock_fd); + return -1; + } + printf("Successfully initialized tap device %s\n", ifname); + return 0; +} + +#include +uint32_t ipstack_getrandom(void) +{ + uint32_t ret; + getrandom(&ret, sizeof(ret), 0); + return ret; +} +#define BUFFER_SIZE TEST_SIZE +static int test_echoserver_closewait(struct ipstack *s) +{ + int fd, ret; + int client_fd = -1; + int tot_sent = 0; + int exit_ok = 0, exit_count = 0; + struct ipstack_sockaddr_in local_sock = { + .sin_family = AF_INET, + .sin_port = ee16(8), /* Echo */ + .sin_addr.s_addr = 0 + }; + fd = posix_socket(s, AF_INET, IPSTACK_SOCK_STREAM, 0); + printf("socket: %04x\n", fd); + ret = posix_bind(s, fd, (struct ipstack_sockaddr *)&local_sock, sizeof(local_sock)); + printf("bind: %d\n", ret); + ret = posix_listen(s, fd, 1); + printf("listen: %d\n", ret); + + while(1) { + uint32_t ms_next; + uint8_t buf[BUFFER_SIZE]; + struct timeval tv; + gettimeofday(&tv, NULL); + ms_next = ipstack_poll(s, tv.tv_sec * 1000 + tv.tv_usec / 1000); + usleep(ms_next * 1000); + if (exit_ok > 0) { + if (exit_count++ < 10) + continue; + else break; + } + if (client_fd < 0) { + client_fd = posix_accept(s, fd, NULL, NULL); + if (client_fd > 0) { + printf("accept: %04x\n", client_fd); + } + } else { + if (ret <= 0) { + ret = posix_recvfrom(s, client_fd, buf, sizeof(buf), 0, NULL, NULL); + if (ret == -11) + continue; /* Call again */ + if (ret < 0) { + printf("Recv error: %d\n", ret); + posix_close(s, client_fd); + return -1; + } else if (ret == 0) { + printf("Client side closed the connection.\n"); + posix_close(s, client_fd); + client_fd = -1; + printf("Server: Exiting.\n"); + exit_ok = 1; + continue; + } else if (ret > 0) { + printf("recv: %d, echoing back\n", ret); + } + } + if (ret > 0) { + int snd_ret; + snd_ret = posix_sendto(s, client_fd, buf + tot_sent, ret - tot_sent, 0, NULL, 0); + if (snd_ret == -11) + continue; /* Call again */ + if (snd_ret < 0) { + printf("Send error: %d\n", snd_ret); + posix_close(s, client_fd); + return 0; + } + + tot_sent += snd_ret; + printf("sent %d bytes\n", snd_ret); + if (ret == tot_sent) { + tot_sent = 0; + ret = 0; + } + } + } + } + return 0; +} + +static void *pt_echoclient_closing(void *arg) +{ + int fd, ret; + unsigned total_r = 0; + unsigned i; + uint8_t buf[BUFFER_SIZE]; + uint8_t test_pattern[16] = "Test pattern - -"; + uint32_t *srv_addr = (uint32_t *)arg; + struct sockaddr_in remote_sock = { + .sin_family = AF_INET, + .sin_port = ntohs(8), /* Echo */ + }; + remote_sock.sin_addr.s_addr = *srv_addr; + fd = socket(AF_INET, IPSTACK_SOCK_STREAM, 0); + if (fd < 0) { + printf("test client socket: %d\n", fd); + return (void *)-1; + } + sleep(1); + printf("Connecting to echo server\n"); + ret = connect(fd, (struct sockaddr *)&remote_sock, sizeof(remote_sock)); + if (ret < 0) { + printf("test client connect: %d\n", ret); + perror("connect"); + return (void *)-1; + } + for (i = 0; i < sizeof(buf); i += sizeof(test_pattern)) { + memcpy(buf + i, test_pattern, sizeof(test_pattern)); + } + ret = write(fd, buf, sizeof(buf)); + if (ret < 0) { + printf("test client write: %d\n", ret); + return (void *)-1; + } + while (total_r < sizeof(buf)) { + ret = read(fd, buf + total_r, sizeof(buf) - total_r); + if (ret < 0) { + printf("failed test client read: %d\n", ret); + return (void *)-1; + } + if (ret == 0) { + printf("test client read: server has closed the connection.\n"); + return (void *)-1; + } + total_r += ret; + } + for (i = 0; i < sizeof(buf); i += sizeof(test_pattern)) { + if (memcmp(buf + i, test_pattern, sizeof(test_pattern))) { + printf("test client: pattern mismatch\n"); + printf("at position %d\n", i); + buf[i + 16] = 0; + printf("%s\n", &buf[i]); + return (void *)-1; + } + } + close(fd); + printf("Test client: success\n"); + return (void *)0; +} + +int main(int argc, char **argv) +{ + struct ipstack *s; + struct ll *tapdev; + pthread_t pt; + struct timeval tv; + ip4 ip = 0, nm = 0, gw = 0; + uint32_t srv_ip; + + int ret, test_ret; + (void)argc; + (void)argv; + (void)ip; + (void)nm; + (void)gw; + (void)tv; + ipstack_init_static(&s); + tapdev = ipstack_getdev(s); + if (!tapdev) + return 1; + + + if (tap_init(tapdev, "femt0") < 0) { + perror("tap init"); + return 2; + } + + system("tcpdump -i femt0 -w test.pcap &"); + sleep(1); + +#ifdef DHCP + gettimeofday(&tv, NULL); + ipstack_poll(s, tv.tv_sec * 1000 + tv.tv_usec / 1000); + dhcp_client_init(s); + do { + gettimeofday(&tv, NULL); + ipstack_poll(s, tv.tv_sec * 1000 + tv.tv_usec / 1000); + usleep(1000); + ipstack_ipconfig_get(s, &ip, &nm, &gw); + } while (!dhcp_bound(s)); + printf("DHCP: obtained IP address.\n"); + ipstack_ipconfig_get(s, &ip, &nm, &gw); + srv_ip = htonl(ip); +#else + ipstack_ipconfig_set(s, atoip4(FEMTOTCP_IP), atoip4("255.255.255.0"), + atoip4(LINUX_IP)); + printf("IP: manually configured\n"); + inet_pton(AF_INET, FEMTOTCP_IP, &srv_ip); +#endif + + + pthread_create(&pt, NULL, pt_echoclient_closing, &srv_ip); + printf("Starting test: echo server close-wait\n"); + ret = test_echoserver_closewait(s); + pthread_join(pt, (void **)&test_ret); + printf("Test echo server close-wait: %d\n", ret); + printf("Test linux client: %d\n", test_ret); + sleep(1); + system("killall tcpdump"); + return 0; +} + diff --git a/test/unit/Makefile b/test/unit/Makefile new file mode 100644 index 0000000..c0bd368 --- /dev/null +++ b/test/unit/Makefile @@ -0,0 +1,15 @@ +LDFLAGS=-lcheck -lm -lpthread -lrt -ldl -lsubunit +CFLAGS=-g -Wall -Wextra -Werror -I../../ -DETHERNET +CC=gcc + +all: unit + +unit: unit.o + $(CC) -o $@ $^ $(LDFLAGS) + + +%.o: %.c + $(CC) $(CFLAGS) -c $< + +clean: + rm -f *.o unit diff --git a/test/unit/unit.c b/test/unit/unit.c new file mode 100644 index 0000000..4f7f98c --- /dev/null +++ b/test/unit/unit.c @@ -0,0 +1,390 @@ +#include "check.h" +#include "../../src/femtotcp.c" +#include /* for random() */ + +/* pseudo random number generator to mock the random number generator */ +uint32_t ipstack_getrandom(void) +{ + unsigned int seed = 0xDAC0FFEE; + srandom(seed); + return random(); +} + +uint8_t mem[8 * 1024]; +uint32_t memsz = 8 * 1024; + +START_TEST(test_fifo_init) +{ + struct fifo f; + fifo_init(&f, mem, memsz); + ck_assert_int_eq(fifo_len(&f), 0); + ck_assert_int_eq(fifo_space(&f), memsz); + ck_assert_int_eq(fifo_len(&f), 0); +} +END_TEST + +START_TEST(test_fifo_push_and_pop) { + struct fifo f; + struct pkt_desc *desc, *desc2; + uint8_t data[] = {1, 2, 3, 4, 5}; + + fifo_init(&f, mem, memsz); + + ck_assert_int_eq(fifo_space(&f), memsz); + // Test push + ck_assert_int_eq(fifo_push(&f, data, sizeof(data)), 0); + + // Test peek + desc = fifo_peek(&f); + ck_assert_ptr_nonnull(desc); + ck_assert_int_eq(desc->len, sizeof(data)); + ck_assert_mem_eq(f.data + desc->pos + sizeof(struct pkt_desc), data, sizeof(data)); + desc2 = fifo_peek(&f); + ck_assert_ptr_nonnull(desc2); + ck_assert_ptr_eq(desc, desc2); + ck_assert_int_eq(fifo_len(&f), desc->len + sizeof(struct pkt_desc)); + + + // Test pop + desc = fifo_pop(&f); + ck_assert_int_eq(fifo_space(&f), memsz); + ck_assert_ptr_nonnull(desc); + ck_assert_int_eq(desc->len, sizeof(data)); + ck_assert_mem_eq(f.data + desc->pos + sizeof(struct pkt_desc), data, sizeof(data)); + ck_assert_int_eq(fifo_len(&f), 0); +} +END_TEST + +START_TEST(test_fifo_push_and_pop_multiple) { + struct fifo f; + uint8_t data[] = {1, 2, 3, 4, 5}; + uint8_t data2[] = {6, 7, 8, 9, 10}; + + fifo_init(&f, mem, memsz); + ck_assert_int_eq(fifo_space(&f), memsz); + + // Test push + ck_assert_int_eq(fifo_push(&f, data, sizeof(data)), 0); + ck_assert_int_eq(fifo_len(&f), sizeof(data) + sizeof(struct pkt_desc)); + ck_assert_int_eq(fifo_space(&f), f.size - (sizeof(data) + sizeof(struct pkt_desc))); + ck_assert_int_eq(fifo_push(&f, data2, sizeof(data2)), 0); + + // Test pop + struct pkt_desc *desc = fifo_pop(&f); + ck_assert_ptr_nonnull(desc); + ck_assert_int_eq(desc->len, sizeof(data)); + ck_assert_mem_eq(f.data + desc->pos + sizeof(struct pkt_desc), data, sizeof(data)); + + desc = fifo_pop(&f); + ck_assert_ptr_nonnull(desc); + ck_assert_int_eq(desc->len, sizeof(data2)); + ck_assert_mem_eq(f.data + desc->pos + sizeof(struct pkt_desc), data2, sizeof(data2)); +} +END_TEST + +START_TEST(test_fifo_pop_success) { + struct fifo f; + uint8_t data[] = {1, 2, 3, 4}; + fifo_init(&f, mem, memsz); + fifo_push(&f, data, sizeof(data)); // Add data to FIFO + + struct pkt_desc *desc = fifo_pop(&f); + ck_assert_ptr_nonnull(desc); // Ensure we got a valid descriptor + ck_assert_int_eq(desc->len, sizeof(data)); // Check length + ck_assert_mem_eq(f.data + desc->pos + sizeof(struct pkt_desc), data, sizeof(data)); // Check data +} + +START_TEST(test_fifo_pop_empty) { + struct fifo f; + fifo_init(&f, mem, memsz); + + struct pkt_desc *desc = fifo_pop(&f); + ck_assert_ptr_eq(desc, NULL); // Ensure pop returns NULL on empty FIFO +} + +START_TEST(test_fifo_push_full) { + struct fifo f; + uint8_t data[8 * 1024] = {1, 2, 3, 4}; + int ret; + fifo_init(&f, mem, memsz); + fifo_push(&f, data, sizeof(data)); // Add data to FIFO + + ret = fifo_push(&f, data, sizeof(data)); + ck_assert_int_eq(ret, -1); // Ensure push returns -1 when FIFO is full +} +END_TEST + +START_TEST(test_fifo_push_wrap) { + struct fifo f; + uint8_t buffer[100]; + uint8_t data[] = {1, 2, 3, 4}; + int ret; + fifo_init(&f, buffer, sizeof(buffer)); + fifo_push(&f, data, sizeof(data)); // Add data to FIFO + + // Pop the data to make space + struct pkt_desc *desc = fifo_pop(&f); + ck_assert_ptr_nonnull(desc); + + // Push data to wrap around the buffer + ret = fifo_push(&f, data, sizeof(data)); + ck_assert_int_eq(ret, 0); + ck_assert_int_eq(desc->len, sizeof(data)); + ck_assert_mem_eq(f.data + desc->pos + sizeof(struct pkt_desc), data, sizeof(data)); +} +END_TEST + +START_TEST(test_fifo_push_wrap_multiple) { + struct fifo f; + uint8_t data[] = {1, 2, 3, 4}; + uint8_t data2[] = {5, 6, 7, 8, 9}; + int ret; + fifo_init(&f, mem, memsz); + fifo_push(&f, data, sizeof(data)); // Add data to FIFO + + // Pop the data to make space + struct pkt_desc *desc = fifo_pop(&f); + ck_assert_ptr_nonnull(desc); + + // Push data to wrap around the buffer + ret = fifo_push(&f, data, sizeof(data)); + ck_assert_int_eq(ret, 0); + ck_assert_int_eq(desc->len, sizeof(data)); + ck_assert_mem_eq(f.data + desc->pos + sizeof(struct pkt_desc), data, sizeof(data)); + + // Push more data to wrap around the buffer + ret = fifo_push(&f, data2, sizeof(data2)); + ck_assert_int_eq(ret, 0); + ck_assert_int_eq(fifo_len(&f), sizeof(data2) + sizeof(data) + 2 * sizeof(struct pkt_desc)); +} +END_TEST + +START_TEST(test_fifo_next_success) { + struct fifo f; + uint8_t data1[] = {1, 2, 3, 4}; + uint8_t data2[] = {5, 6, 7, 8, 9}; + + fifo_init(&f, mem, memsz); + + // Add two packets to the FIFO + fifo_push(&f, data1, sizeof(data1)); + fifo_push(&f, data2, sizeof(data2)); + ck_assert_int_eq(fifo_len(&f), sizeof(data1) + sizeof(data2) + 2 * sizeof(struct pkt_desc)); + + // Get the first packet descriptor + struct pkt_desc *desc = fifo_peek(&f); + ck_assert_ptr_nonnull(desc); + + // Get the next packet descriptor using fifo_next + struct pkt_desc *next_desc = fifo_next(&f, desc); + ck_assert_ptr_nonnull(next_desc); // Ensure next descriptor is valid + ck_assert_int_eq(next_desc->len, sizeof(data2)); // Check length of next packet +} + +START_TEST(test_fifo_next_empty_fifo) { + struct fifo f; + fifo_init(&f, mem, memsz); + + // Start with an empty FIFO + struct pkt_desc *desc = NULL; + struct pkt_desc *next_desc = fifo_next(&f, desc); + ck_assert_ptr_eq(next_desc, NULL); // Ensure next returns NULL on empty FIFO +} + +START_TEST(test_fifo_next_end_of_fifo) { + struct fifo f; + uint8_t data[] = {1, 2, 3, 4}; + + fifo_init(&f, mem, memsz); + fifo_push(&f, data, sizeof(data)); + + struct pkt_desc *desc = fifo_peek(&f); // Get first packet + fifo_pop(&f); // Simulate removing the packet + struct pkt_desc *next_desc = fifo_next(&f, desc); + ck_assert_ptr_eq(next_desc, NULL); // Should return NULL as there are no more packets +} +END_TEST +START_TEST(test_queue_init) { + struct queue q; + queue_init(&q, mem, memsz, 0x12345678); + ck_assert_int_eq(q.size, memsz); + ck_assert_ptr_eq(q.data, mem); + ck_assert_int_eq(q.head, 0); + ck_assert_int_eq(q.tail, 0); + ck_assert_int_eq(q.seq_base, 0x12345678); + +} +END_TEST + +START_TEST(test_queue_space_empty) { + struct queue q; + + queue_init(&q, mem, memsz, 0x12345678); + ck_assert_int_eq(queue_space(&q), memsz); // Full space should be available + +} +END_TEST + +START_TEST(test_queue_len_empty) { + struct queue q; + + queue_init(&q, mem, memsz, 0x12345678); + ck_assert_int_eq(queue_len(&q), 0); // No bytes should be in use + +} +END_TEST + +START_TEST(test_queue_partial_fill) { + struct queue q; + queue_init(&q, mem, memsz, 0x12345678); + q.head = 256; // Simulate adding 256 bytes of data + ck_assert_int_eq(queue_space(&q), memsz - 256); + ck_assert_int_eq(queue_len(&q), 256); + +} +END_TEST + +START_TEST(test_queue_wrap_around) { + struct queue q; + queue_init(&q, mem, memsz, 0x12345678); + q.head = 800; + q.tail = 200; // Head has wrapped around, so 600 bytes are filled + ck_assert_int_eq(queue_space(&q), q.size - 600); + ck_assert_int_eq(queue_len(&q), 600); // 600 bytes filled +} +END_TEST + +START_TEST(test_queue_insert_empty) { + struct queue q; + queue_init(&q, mem, memsz, 0x12345678); + uint8_t data[] = {1, 2, 3, 4}; + + int res = queue_insert(&q, data, 0, sizeof(data)); + ck_assert_int_eq(res, 0); + ck_assert_int_eq(queue_len(&q), sizeof(data)); + ck_assert_int_eq(q.head, sizeof(data)); + ck_assert_mem_eq(q.data, data, sizeof(data)); +} +END_TEST + +START_TEST(test_queue_insert_sequential) { + struct queue q; + queue_init(&q, mem, memsz, 0x12345678); + uint8_t data1[] = {1, 2}; + uint8_t data2[] = {3, 4}; + + int res1 = queue_insert(&q, data1, 0, sizeof(data1)); + int res2 = queue_insert(&q, data2, 2, sizeof(data2)); + ck_assert_int_eq(res1, 0); + ck_assert_int_eq(res2, 0); + ck_assert_int_eq(queue_len(&q), sizeof(data1) + sizeof(data2)); + ck_assert_mem_eq(q.data, data1, sizeof(data1)); + ck_assert_mem_eq(q.data + 2, data2, sizeof(data2)); +} +END_TEST + +START_TEST(test_queue_pop) { + struct queue q; + queue_init(&q, mem, memsz, 0x12345678); + uint8_t data[] = {5, 6, 7, 8}; + uint8_t out[4]; + + queue_insert(&q, data, 0, sizeof(data)); + int len = queue_pop(&q, out, sizeof(out)); + ck_assert_int_eq(len, sizeof(out)); + ck_assert_mem_eq(out, data, sizeof(data)); + ck_assert_int_eq(queue_len(&q), 0); + ck_assert_int_eq(q.tail, 4); +} +END_TEST + +START_TEST(test_queue_pop_wraparound) { + struct queue q; + queue_init(&q, mem, memsz, 0x12345678); + uint8_t data[] = {9, 10, 11, 12}; + uint8_t out[4]; + + q.head = memsz - 1; + q.tail = memsz - 1; + queue_insert(&q, data, 0, sizeof(data)); + int len = queue_pop(&q, out, sizeof(out)); + ck_assert_int_eq(len, sizeof(out)); + ck_assert_mem_eq(out, data, sizeof(data)); + ck_assert_int_eq(queue_len(&q), 0); +} +END_TEST + + +Suite *femto_suite(void) +{ + Suite *s; + TCase *tc_core, *tc_proto; + + s = suite_create("FemtoTCP"); + tc_core = tcase_create("Core"); + tc_proto = tcase_create("Protocols"); + + tcase_add_test(tc_core, test_fifo_init); + suite_add_tcase(s, tc_core); + suite_add_tcase(s, tc_proto); + + tcase_add_test(tc_core, test_fifo_push_and_pop); + suite_add_tcase(s, tc_core); + tcase_add_test(tc_core, test_fifo_push_and_pop_multiple); + suite_add_tcase(s, tc_core); + tcase_add_test(tc_core, test_fifo_pop_success); + suite_add_tcase(s, tc_core); + tcase_add_test(tc_core, test_fifo_pop_empty); + suite_add_tcase(s, tc_core); + tcase_add_test(tc_core, test_fifo_push_full); + suite_add_tcase(s, tc_core); + tcase_add_test(tc_core, test_fifo_push_wrap); + suite_add_tcase(s, tc_core); + tcase_add_test(tc_core, test_fifo_push_wrap_multiple); + suite_add_tcase(s, tc_core); + tcase_add_test(tc_core, test_fifo_next_success); + suite_add_tcase(s, tc_core); + tcase_add_test(tc_core, test_fifo_next_empty_fifo); + suite_add_tcase(s, tc_core); + tcase_add_test(tc_core, test_fifo_next_end_of_fifo); + suite_add_tcase(s, tc_core); + + tcase_add_test(tc_core, test_queue_init); + suite_add_tcase(s, tc_core); + tcase_add_test(tc_core, test_queue_space_empty); + suite_add_tcase(s, tc_core); + tcase_add_test(tc_core, test_queue_len_empty); + suite_add_tcase(s, tc_core); + tcase_add_test(tc_core, test_queue_partial_fill); + suite_add_tcase(s, tc_core); + tcase_add_test(tc_core, test_queue_wrap_around); + suite_add_tcase(s, tc_core); + tcase_add_test(tc_core, test_queue_insert_empty); + suite_add_tcase(s, tc_core); + tcase_add_test(tc_core, test_queue_insert_sequential); + suite_add_tcase(s, tc_core); + tcase_add_test(tc_core, test_queue_pop); + suite_add_tcase(s, tc_core); + tcase_add_test(tc_core, test_queue_pop_wraparound); + suite_add_tcase(s, tc_core); + + return s; +} + + + +int main(void) +{ + int n_fail = 0; + Suite *s; + SRunner *sr; + + s = femto_suite(); + sr = srunner_create(s); + + srunner_run_all(sr, CK_NORMAL); + n_fail = srunner_ntests_failed(sr); + srunner_free(sr); + return (n_fail == 0) ? EXIT_SUCCESS : EXIT_FAILURE; + +}