[RFC v2 08/16] net: import picotcp from github
Antony Pavlov
antonynpavlov at gmail.com
Sun Jul 19 13:07:15 PDT 2015
Original repo: https://github.com/tass-belgium/picotcp
The last original repo commit is v1.5.0
commit f6d139147d86d74f9a53ba3c02b2a5b276858d95
Author: laurens <laurens at localhost.localdomain>
Date: Thu Jun 25 12:54:38 2015 +0100
Remove old check from fragments module
from development branch
Import mini-howto:
$ cd barebox.git
$ rm -rf net/picotcp
$ git clone --branch ${branch_name} ${PICOTCP_REPO} net/picotcp
$ rm -rf net/picotcp/*
$ ( cd net/picotcp; git checkout .gitignore COPYING LICENSE README.md )
$ ( cd net/picotcp; mkdir include modules stack )
$ ( cd net/picotcp/include; git checkout heap.h pico_addressing.h pico_config.h pico_constants.h pico_device.h pico_eth.h pico_frame.h pico_module_eth.h pico_protocol.h pico_queue.h pico_socket.h pico_socket_multicast.h pico_stack.h pico_tree.h )
$ ( cd net/picotcp/modules; git checkout pico_aodv.h pico_arp.c pico_arp.h pico_dev_loop.c pico_dev_loop.h pico_dev_mock.h pico_dev_null.c pico_dev_null.h pico_dhcp_client.c pico_dhcp_client.h pico_dhcp_common.c pico_dhcp_common.h pico_dns_client.h pico_dns_common.h pico_dns_sd.h pico_fragments.c pico_fragments.h pico_icmp4.c pico_icmp4.h pico_icmp6.h pico_igmp.h pico_ipfilter.h pico_ipv4.c pico_ipv4.h pico_ipv6.h pico_ipv6_nd.h pico_mm.h pico_nat.h pico_olsr.h pico_socket_tcp.h pico_socket_udp.c pico_socket_udp.h pico_tcp.h pico_udp.c pico_udp.h )
$ ( cd net/picotcp/stack; git checkout pico_device.c pico_frame.c pico_protocol.c pico_socket.c pico_socket_multicast.c pico_stack.c pico_tree.c )
$ rm -rf net/picotcp/.git
$ git add net/picotcp/
$ git commit -s
Signed-off-by: Antony Pavlov <antonynpavlov at gmail.com>
---
net/picotcp/.gitignore | 24 +
net/picotcp/COPYING | 8 +
net/picotcp/LICENSE | 339 ++++
net/picotcp/README.md | 33 +
net/picotcp/include/heap.h | 83 +
net/picotcp/include/pico_addressing.h | 52 +
net/picotcp/include/pico_config.h | 229 +++
net/picotcp/include/pico_constants.h | 54 +
net/picotcp/include/pico_device.h | 54 +
net/picotcp/include/pico_eth.h | 21 +
net/picotcp/include/pico_frame.h | 122 ++
net/picotcp/include/pico_module_eth.h | 33 +
net/picotcp/include/pico_protocol.h | 95 ++
net/picotcp/include/pico_queue.h | 166 ++
net/picotcp/include/pico_socket.h | 268 ++++
net/picotcp/include/pico_socket_multicast.h | 10 +
net/picotcp/include/pico_stack.h | 87 ++
net/picotcp/include/pico_tree.h | 93 ++
net/picotcp/modules/pico_aodv.h | 131 ++
net/picotcp/modules/pico_arp.c | 531 +++++++
net/picotcp/modules/pico_arp.h | 32 +
net/picotcp/modules/pico_dev_loop.c | 66 +
net/picotcp/modules/pico_dev_loop.h | 15 +
net/picotcp/modules/pico_dev_mock.h | 47 +
net/picotcp/modules/pico_dev_null.c | 60 +
net/picotcp/modules/pico_dev_null.h | 15 +
net/picotcp/modules/pico_dhcp_client.c | 960 ++++++++++++
net/picotcp/modules/pico_dhcp_client.h | 30 +
net/picotcp/modules/pico_dhcp_common.c | 189 +++
net/picotcp/modules/pico_dhcp_common.h | 186 +++
net/picotcp/modules/pico_dns_client.h | 46 +
net/picotcp/modules/pico_dns_common.h | 521 +++++++
net/picotcp/modules/pico_dns_sd.h | 90 ++
net/picotcp/modules/pico_fragments.c | 345 +++++
net/picotcp/modules/pico_fragments.h | 11 +
net/picotcp/modules/pico_icmp4.c | 395 +++++
net/picotcp/modules/pico_icmp4.h | 162 ++
net/picotcp/modules/pico_icmp6.h | 259 ++++
net/picotcp/modules/pico_igmp.h | 26 +
net/picotcp/modules/pico_ipfilter.h | 29 +
net/picotcp/modules/pico_ipv4.c | 1574 +++++++++++++++++++
net/picotcp/modules/pico_ipv4.h | 124 ++
net/picotcp/modules/pico_ipv6.h | 153 ++
net/picotcp/modules/pico_ipv6_nd.h | 26 +
net/picotcp/modules/pico_mm.h | 98 ++
net/picotcp/modules/pico_nat.h | 90 ++
net/picotcp/modules/pico_olsr.h | 32 +
net/picotcp/modules/pico_socket_tcp.h | 33 +
net/picotcp/modules/pico_socket_udp.c | 250 +++
net/picotcp/modules/pico_socket_udp.h | 19 +
net/picotcp/modules/pico_tcp.h | 102 ++
net/picotcp/modules/pico_udp.c | 216 +++
net/picotcp/modules/pico_udp.h | 45 +
net/picotcp/stack/pico_device.c | 408 +++++
net/picotcp/stack/pico_frame.c | 286 ++++
net/picotcp/stack/pico_protocol.c | 214 +++
net/picotcp/stack/pico_socket.c | 2213 +++++++++++++++++++++++++++
net/picotcp/stack/pico_socket_multicast.c | 956 ++++++++++++
net/picotcp/stack/pico_stack.c | 1157 ++++++++++++++
net/picotcp/stack/pico_tree.c | 575 +++++++
60 files changed, 14488 insertions(+)
diff --git a/net/picotcp/.gitignore b/net/picotcp/.gitignore
new file mode 100644
index 0000000..88593da
--- /dev/null
+++ b/net/picotcp/.gitignore
@@ -0,0 +1,24 @@
+*.d
+*.o
+*.a
+*.out
+*.swp
+tags
+build
+UNIT_*
+core
+core.*
+.DS_Store
+cscope.files
+cscope.out
+*.so
+*.aux
+*.pdf
+*.toc
+*.gz
+*.log
+*.pyc
+*.elf
+*.gcov
+*.gcda
+*.gcno
diff --git a/net/picotcp/COPYING b/net/picotcp/COPYING
new file mode 100644
index 0000000..8a5fe4b
--- /dev/null
+++ b/net/picotcp/COPYING
@@ -0,0 +1,8 @@
+PicoTCP. Copyright (c) 2012-2015 Altran Intelligent Systems.
+
+Released under the GNU General Public License, version 2.
+See LICENSE for details.
+
+Different licensing models may exist, at the sole discretion of
+the Copyright holders.
+
diff --git a/net/picotcp/LICENSE b/net/picotcp/LICENSE
new file mode 100644
index 0000000..d159169
--- /dev/null
+++ b/net/picotcp/LICENSE
@@ -0,0 +1,339 @@
+ GNU GENERAL PUBLIC LICENSE
+ Version 2, June 1991
+
+ Copyright (C) 1989, 1991 Free Software Foundation, Inc.,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+ Preamble
+
+ The licenses for most software are designed to take away your
+freedom to share and change it. By contrast, the GNU General Public
+License is intended to guarantee your freedom to share and change free
+software--to make sure the software is free for all its users. This
+General Public License applies to most of the Free Software
+Foundation's software and to any other program whose authors commit to
+using it. (Some other Free Software Foundation software is covered by
+the GNU Lesser General Public License instead.) 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
+this service 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 make restrictions that forbid
+anyone to deny you these rights or to ask you to surrender the rights.
+These restrictions translate to certain responsibilities for you if you
+distribute copies of the software, or if you modify it.
+
+ For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must give the recipients all the rights that
+you have. 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.
+
+ We protect your rights with two steps: (1) copyright the software, and
+(2) offer you this license which gives you legal permission to copy,
+distribute and/or modify the software.
+
+ Also, for each author's protection and ours, we want to make certain
+that everyone understands that there is no warranty for this free
+software. If the software is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original, so
+that any problems introduced by others will not reflect on the original
+authors' reputations.
+
+ Finally, any free program is threatened constantly by software
+patents. We wish to avoid the danger that redistributors of a free
+program will individually obtain patent licenses, in effect making the
+program proprietary. To prevent this, we have made it clear that any
+patent must be licensed for everyone's free use or not licensed at all.
+
+ The precise terms and conditions for copying, distribution and
+modification follow.
+
+ GNU GENERAL PUBLIC LICENSE
+ TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+ 0. This License applies to any program or other work which contains
+a notice placed by the copyright holder saying it may be distributed
+under the terms of this General Public License. The "Program", below,
+refers to any such program or work, and a "work based on the Program"
+means either the Program or any derivative work under copyright law:
+that is to say, a work containing the Program or a portion of it,
+either verbatim or with modifications and/or translated into another
+language. (Hereinafter, translation is included without limitation in
+the term "modification".) Each licensee is addressed as "you".
+
+Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope. The act of
+running the Program is not restricted, and the output from the Program
+is covered only if its contents constitute a work based on the
+Program (independent of having been made by running the Program).
+Whether that is true depends on what the Program does.
+
+ 1. You may copy and distribute 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 and disclaimer of warranty; keep intact all the
+notices that refer to this License and to the absence of any warranty;
+and give any other recipients of the Program a copy of this License
+along with the Program.
+
+You may charge a fee for the physical act of transferring a copy, and
+you may at your option offer warranty protection in exchange for a fee.
+
+ 2. You may modify your copy or copies of the Program or any portion
+of it, thus forming a work based on the Program, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+ a) You must cause the modified files to carry prominent notices
+ stating that you changed the files and the date of any change.
+
+ b) You must cause any work that you distribute or publish, that in
+ whole or in part contains or is derived from the Program or any
+ part thereof, to be licensed as a whole at no charge to all third
+ parties under the terms of this License.
+
+ c) If the modified program normally reads commands interactively
+ when run, you must cause it, when started running for such
+ interactive use in the most ordinary way, to print or display an
+ announcement including an appropriate copyright notice and a
+ notice that there is no warranty (or else, saying that you provide
+ a warranty) and that users may redistribute the program under
+ these conditions, and telling the user how to view a copy of this
+ License. (Exception: if the Program itself is interactive but
+ does not normally print such an announcement, your work based on
+ the Program is not required to print an announcement.)
+
+These requirements apply to the modified work as a whole. If
+identifiable sections of that work are not derived from the Program,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works. But when you
+distribute the same sections as part of a whole which is a work based
+on the Program, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Program.
+
+In addition, mere aggregation of another work not based on the Program
+with the Program (or with a work based on the Program) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+ 3. You may copy and distribute the Program (or a work based on it,
+under Section 2) in object code or executable form under the terms of
+Sections 1 and 2 above provided that you also do one of the following:
+
+ a) Accompany it with the complete corresponding machine-readable
+ source code, which must be distributed under the terms of Sections
+ 1 and 2 above on a medium customarily used for software interchange; or,
+
+ b) Accompany it with a written offer, valid for at least three
+ years, to give any third party, for a charge no more than your
+ cost of physically performing source distribution, a complete
+ machine-readable copy of the corresponding source code, to be
+ distributed under the terms of Sections 1 and 2 above on a medium
+ customarily used for software interchange; or,
+
+ c) Accompany it with the information you received as to the offer
+ to distribute corresponding source code. (This alternative is
+ allowed only for noncommercial distribution and only if you
+ received the program in object code or executable form with such
+ an offer, in accord with Subsection b above.)
+
+The source code for a work means the preferred form of the work for
+making modifications to it. For an executable work, complete source
+code means all the source code for all modules it contains, plus any
+associated interface definition files, plus the scripts used to
+control compilation and installation of the executable. However, as a
+special exception, the source code distributed need not include
+anything that is normally distributed (in either source or binary
+form) with the major components (compiler, kernel, and so on) of the
+operating system on which the executable runs, unless that component
+itself accompanies the executable.
+
+If distribution of executable or object code is made by offering
+access to copy from a designated place, then offering equivalent
+access to copy the source code from the same place counts as
+distribution of the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+ 4. You may not copy, modify, sublicense, or distribute the Program
+except as expressly provided under this License. Any attempt
+otherwise to copy, modify, sublicense or distribute the Program is
+void, and will automatically terminate your rights under this License.
+However, parties who have received copies, or rights, from you under
+this License will not have their licenses terminated so long as such
+parties remain in full compliance.
+
+ 5. You are not required to accept this License, since you have not
+signed it. However, nothing else grants you permission to modify or
+distribute the Program or its derivative works. These actions are
+prohibited by law if you do not accept this License. Therefore, by
+modifying or distributing the Program (or any work based on the
+Program), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Program or works based on it.
+
+ 6. Each time you redistribute the Program (or any work based on the
+Program), the recipient automatically receives a license from the
+original licensor to copy, distribute or modify the Program subject to
+these terms and conditions. You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties to
+this License.
+
+ 7. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+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
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Program at all. For example, if a patent
+license would not permit royalty-free redistribution of the Program by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Program.
+
+If any portion of this section is held invalid or unenforceable under
+any particular circumstance, the balance of the section is intended to
+apply and the section as a whole is intended to apply in other
+circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system, which is
+implemented by public license practices. Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+ 8. If the distribution and/or use of the Program is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Program under this License
+may add an explicit geographical distribution limitation excluding
+those countries, so that distribution is permitted only in or among
+countries not thus excluded. In such case, this License incorporates
+the limitation as if written in the body of this License.
+
+ 9. The Free Software Foundation may publish revised and/or new versions
+of the 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 a version number of this License which applies to it and "any
+later version", you have the option of following the terms and conditions
+either of that version or of any later version published by the Free
+Software Foundation. If the Program does not specify a version number of
+this License, you may choose any version ever published by the Free Software
+Foundation.
+
+ 10. If you wish to incorporate parts of the Program into other free
+programs whose distribution conditions are different, write to the author
+to ask for permission. For software which is copyrighted by the Free
+Software Foundation, write to the Free Software Foundation; we sometimes
+make exceptions for this. Our decision will be guided by the two goals
+of preserving the free status of all derivatives of our free software and
+of promoting the sharing and reuse of software generally.
+
+ NO WARRANTY
+
+ 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, 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.
+
+ 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
+REDISTRIBUTE 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.
+
+ 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
+convey the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+ <one line to give the program's name and a brief idea of what it does.>
+ Copyright (C) <year> <name of author>
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 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, write to the Free Software Foundation, Inc.,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+Also add information on how to contact you by electronic and paper mail.
+
+If the program is interactive, make it output a short notice like this
+when it starts in an interactive mode:
+
+ Gnomovision version 69, Copyright (C) year name of author
+ Gnomovision 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, the commands you use may
+be called something other than `show w' and `show c'; they could even be
+mouse-clicks or menu items--whatever suits your program.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the program, if
+necessary. Here is a sample; alter the names:
+
+ Yoyodyne, Inc., hereby disclaims all copyright interest in the program
+ `Gnomovision' (which makes passes at compilers) written by James Hacker.
+
+ <signature of Ty Coon>, 1 April 1989
+ Ty Coon, President of Vice
+
+This 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.
diff --git a/net/picotcp/README.md b/net/picotcp/README.md
new file mode 100644
index 0000000..9e32eb7
--- /dev/null
+++ b/net/picotcp/README.md
@@ -0,0 +1,33 @@
+picoTCP
+
+---------------
+
+Welcome to the one and only <font color=ff00f0>picoTCP repository</font>.
+
+picoTCP is a small-footprint, modular TCP/IP stack designed for embedded systems and the Internet of Things. It's actively being developed by *[Altran Intelligent Systems](http://intelligent-systems.altran.com/)*.
+
+This code is released under the terms of GNU GPL v2 only. Some rights reserved.
+Other licenses may apply at the sole discretion of the copyright holders.
+
+Learn how to use picoTCP in your project by going through the Getting Started guide on our [GitHub wiki](https://github.com/tass-belgium/picotcp/wiki).
+
+For more information visit the [picoTCP website](http://www.picotcp.com), send us an email or contact us on [Twitter](https://twitter.com/picotcp), [Facebook](https://www.facebook.com/picoTCP) or [Reddit](http://www.reddit.com/r/picotcp/).
+
+Wondering about picoTCP's code quality? Check [our TiCS score](http://tics.picotcp.com:42506/TIOBEPortal/TICS/treeviewer?)
+
+
+---------------
+
+Continuous integration
+
+Jenkins Functional tests:
+[](http://jenkins.picotcp.com:8080/job/PicoTCP_rel_autotest)
+
+Jenkins Unit tests :
+[](http://jenkins.picotcp.com:8080/job/PicoTCP_rel_unit_tests)
+
+Jenkins RFC compliance :
+[](http://jenkins.picotcp.com:8080/job/PicoTCP_rel_RF_mbed)
+
+Jenkins TICS quality :
+[](http://jenkins.picotcp.com:8080/job/PicoTCP_rel_TICS/)
diff --git a/net/picotcp/include/heap.h b/net/picotcp/include/heap.h
new file mode 100644
index 0000000..88f495d
--- /dev/null
+++ b/net/picotcp/include/heap.h
@@ -0,0 +1,83 @@
+/*********************************************************************
+ PicoTCP. Copyright (c) 2012-2015 Altran Intelligent Systems. Some rights reserved.
+ See LICENSE and COPYING for usage.
+
+ *********************************************************************/
+
+#define DECLARE_HEAP(type, orderby) \
+ struct heap_ ## type { \
+ uint32_t size; \
+ uint32_t n; \
+ type *top; \
+ }; \
+ typedef struct heap_ ## type heap_ ## type; \
+ static inline int heap_insert(struct heap_ ## type *heap, type * el) \
+ { \
+ uint32_t i; \
+ type *newTop; \
+ if (++heap->n >= heap->size) { \
+ newTop = PICO_ZALLOC((heap->n + 1) * sizeof(type)); \
+ if(!newTop) { \
+ heap->n--; \
+ return -1; \
+ } \
+ if (heap->top) { \
+ memcpy(newTop, heap->top, heap->n * sizeof(type)); \
+ PICO_FREE(heap->top); \
+ } \
+ heap->top = newTop; \
+ heap->size++; \
+ } \
+ if (heap->n == 1) { \
+ memcpy(&heap->top[1], el, sizeof(type)); \
+ return 0; \
+ } \
+ for (i = heap->n; ((i > 1) && (heap->top[i / 2].orderby > el->orderby)); i /= 2) { \
+ memcpy(&heap->top[i], &heap->top[i / 2], sizeof(type)); \
+ } \
+ memcpy(&heap->top[i], el, sizeof(type)); \
+ return 0; \
+ } \
+ static inline int heap_peek(struct heap_ ## type *heap, type * first) \
+ { \
+ type *last; \
+ uint32_t i, child; \
+ if(heap->n == 0) { \
+ return -1; \
+ } \
+ memcpy(first, &heap->top[1], sizeof(type)); \
+ last = &heap->top[heap->n--]; \
+ for(i = 1; (i * 2u) <= heap->n; i = child) { \
+ child = 2u * i; \
+ if ((child != heap->n) && \
+ (heap->top[child + 1]).orderby \
+ < (heap->top[child]).orderby) \
+ child++; \
+ if (last->orderby > \
+ heap->top[child].orderby) \
+ memcpy(&heap->top[i], &heap->top[child], \
+ sizeof(type)); \
+ else \
+ break; \
+ } \
+ memcpy(&heap->top[i], last, sizeof(type)); \
+ return 0; \
+ } \
+ static inline type *heap_first(heap_ ## type * heap) \
+ { \
+ if (heap->n == 0) \
+ return NULL; \
+ return &heap->top[1]; \
+ } \
+ static inline heap_ ## type *heap_init(void) \
+ { \
+ heap_ ## type * p = (heap_ ## type *)PICO_ZALLOC(sizeof(heap_ ## type)); \
+ return p; \
+ } \
+ /*static inline void heap_destroy(heap_ ## type * h) \
+ { \
+ PICO_FREE(h->top); \
+ PICO_FREE(h); \
+ } \*/
+
+
diff --git a/net/picotcp/include/pico_addressing.h b/net/picotcp/include/pico_addressing.h
new file mode 100644
index 0000000..de62281
--- /dev/null
+++ b/net/picotcp/include/pico_addressing.h
@@ -0,0 +1,52 @@
+/*********************************************************************
+ PicoTCP. Copyright (c) 2012-2015 Altran Intelligent Systems. Some rights reserved.
+ See LICENSE and COPYING for usage.
+
+ *********************************************************************/
+#ifndef INCLUDE_PICO_ADDRESSING
+#define INCLUDE_PICO_ADDRESSING
+
+#include "pico_config.h"
+
+PACKED_STRUCT_DEF pico_ip4
+{
+ uint32_t addr;
+};
+
+PACKED_STRUCT_DEF pico_ip6
+{
+ uint8_t addr[16];
+};
+
+union pico_address
+{
+ struct pico_ip4 ip4;
+ struct pico_ip6 ip6;
+};
+
+PACKED_STRUCT_DEF pico_eth
+{
+ uint8_t addr[6];
+ uint8_t padding[2];
+};
+
+extern const uint8_t PICO_ETHADDR_ALL[];
+
+
+PACKED_STRUCT_DEF pico_trans
+{
+ uint16_t sport;
+ uint16_t dport;
+
+};
+
+/* Here are some protocols. */
+#define PICO_PROTO_IPV4 0
+#define PICO_PROTO_ICMP4 1
+#define PICO_PROTO_IGMP 2
+#define PICO_PROTO_TCP 6
+#define PICO_PROTO_UDP 17
+#define PICO_PROTO_IPV6 41
+#define PICO_PROTO_ICMP6 58
+
+#endif
diff --git a/net/picotcp/include/pico_config.h b/net/picotcp/include/pico_config.h
new file mode 100644
index 0000000..6b9c040
--- /dev/null
+++ b/net/picotcp/include/pico_config.h
@@ -0,0 +1,229 @@
+/*********************************************************************
+ PicoTCP. Copyright (c) 2012-2015 Altran Intelligent Systems. Some rights reserved.
+ See LICENSE and COPYING for usage.
+
+ *********************************************************************/
+#include "pico_defines.h"
+#ifndef INCLUDE_PICO_CONFIG
+#define INCLUDE_PICO_CONFIG
+#ifndef __KERNEL__
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+#else
+#include <linux/types.h>
+#endif
+
+#if defined __IAR_SYSTEMS_ICC__ || defined ATOP
+# define PACKED_STRUCT_DEF __packed struct
+# define PEDANTIC_STRUCT_DEF __packed struct
+# define PACKED_UNION_DEF __packed union
+# define WEAK
+#else
+# define PACKED_STRUCT_DEF struct __attribute__((packed))
+# define PEDANTIC_STRUCT_DEF struct
+# define PACKED_UNION_DEF union /* Sane compilers do not require packed unions */
+# define WEAK __attribute__((weak))
+# ifdef __GNUC__
+# define GCC_VERSION (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__)
+# if ((GCC_VERSION >= 40800))
+# define BYTESWAP_GCC
+# endif
+# endif
+#endif
+
+#ifdef PICO_BIGENDIAN
+
+# define PICO_IDETH_IPV4 0x0800
+# define PICO_IDETH_ARP 0x0806
+# define PICO_IDETH_IPV6 0x86DD
+
+# define PICO_ARP_REQUEST 0x0001
+# define PICO_ARP_REPLY 0x0002
+# define PICO_ARP_HTYPE_ETH 0x0001
+
+#define short_be(x) (x)
+#define long_be(x) (x)
+#define long_long_be(x) (x)
+
+static inline uint16_t short_from(void *_p)
+{
+ unsigned char *p = (unsigned char *)_p;
+ uint16_t r, p0, p1;
+ p0 = p[0];
+ p1 = p[1];
+ r = (p0 << 8) + p1;
+ return r;
+}
+
+static inline uint32_t long_from(void *_p)
+{
+ unsigned char *p = (unsigned char *)_p;
+ uint32_t r, p0, p1, p2, p3;
+ p0 = p[0];
+ p1 = p[1];
+ p2 = p[2];
+ p3 = p[3];
+ r = (p0 << 24) + (p1 << 16) + (p2 << 8) + p3;
+ return r;
+}
+
+#else
+
+static inline uint16_t short_from(void *_p)
+{
+ unsigned char *p = (unsigned char *)_p;
+ uint16_t r, _p0, _p1;
+ _p0 = p[0];
+ _p1 = p[1];
+ r = (uint16_t)((_p1 << 8u) + _p0);
+ return r;
+}
+
+static inline uint32_t long_from(void *_p)
+{
+ unsigned char *p = (unsigned char *)_p;
+ uint32_t r, _p0, _p1, _p2, _p3;
+ _p0 = p[0];
+ _p1 = p[1];
+ _p2 = p[2];
+ _p3 = p[3];
+ r = (_p3 << 24) + (_p2 << 16) + (_p1 << 8) + _p0;
+ return r;
+}
+
+
+# define PICO_IDETH_IPV4 0x0008
+# define PICO_IDETH_ARP 0x0608
+# define PICO_IDETH_IPV6 0xDD86
+
+# define PICO_ARP_REQUEST 0x0100
+# define PICO_ARP_REPLY 0x0200
+# define PICO_ARP_HTYPE_ETH 0x0100
+
+# ifndef BYTESWAP_GCC
+static inline uint16_t short_be(uint16_t le)
+{
+ return (uint16_t)(((le & 0xFFu) << 8) | ((le >> 8u) & 0xFFu));
+}
+
+static inline uint32_t long_be(uint32_t le)
+{
+ uint8_t *b = (uint8_t *)≤
+ uint32_t be = 0;
+ uint32_t b0, b1, b2;
+ b0 = b[0];
+ b1 = b[1];
+ b2 = b[2];
+ be = b[3] + (b2 << 8) + (b1 << 16) + (b0 << 24);
+ return be;
+}
+static inline uint64_t long_long_be(uint64_t le)
+{
+ uint8_t *b = (uint8_t *)≤
+ uint64_t be = 0;
+ uint64_t b0, b1, b2, b3, b4, b5, b6;
+ b0 = b[0];
+ b1 = b[1];
+ b2 = b[2];
+ b3 = b[3];
+ b4 = b[4];
+ b5 = b[5];
+ b6 = b[6];
+ be = b[7] + (b6 << 8) + (b5 << 16) + (b4 << 24) + (b3 << 32) + (b2 << 40) + (b1 << 48) + (b0 << 56);
+ return be;
+}
+# else
+/*
+ extern uint32_t __builtin_bswap32(uint32_t);
+ extern uint16_t __builtin_bswap16(uint16_t);
+ extern uint64_t __builtin_bswap64(uint64_t);
+ */
+
+static inline uint32_t long_be(uint32_t le)
+{
+ return (uint32_t)__builtin_bswap32(le);
+}
+
+static inline uint16_t short_be(uint16_t le)
+{
+ return (uint16_t)__builtin_bswap16(le);
+}
+
+static inline uint64_t long_long_be(uint64_t le)
+{
+ return (uint64_t)__builtin_bswap64(le);
+}
+
+# endif /* BYTESWAP_GCC */
+#endif
+
+
+/* Mockables */
+#if defined UNIT_TEST
+# define MOCKABLE __attribute__((weak))
+#else
+# define MOCKABLE
+#endif
+
+#include "pico_constants.h"
+#include "pico_mm.h"
+
+#define IGNORE_PARAMETER(x) ((void)x)
+
+#define PICO_MEM_DEFAULT_SLAB_SIZE 1600
+#define PICO_MEM_PAGE_SIZE 4096
+#define PICO_MEM_PAGE_LIFETIME 100
+#define PICO_MIN_HEAP_SIZE 600
+#define PICO_MIN_SLAB_SIZE 1200
+#define PICO_MAX_SLAB_SIZE 1600
+#define PICO_MEM_MINIMUM_OBJECT_SIZE 4
+
+
+/*** *** *** *** *** *** ***
+ *** PLATFORM SPECIFIC ***
+ *** *** *** *** *** *** ***/
+#if defined PICO_PORT_CUSTOM
+# include "pico_port.h"
+#elif defined CORTEX_M4_HARDFLOAT
+# include "arch/pico_cortex_m.h"
+#elif defined CORTEX_M4_SOFTFLOAT
+# include "arch/pico_cortex_m.h"
+#elif defined CORTEX_M3
+# include "arch/pico_cortex_m.h"
+#elif defined PIC24
+# include "arch/pico_pic24.h"
+#elif defined MSP430
+# include "arch/pico_msp430.h"
+#elif defined MBED_TEST
+# include "arch/pico_mbed.h"
+#elif defined AVR
+# include "arch/pico_avr.h"
+#elif defined ARM9
+# include "arch/pico_arm9.h"
+#elif defined ESP8266
+# include "arch/pico_esp8266.h"
+#elif defined MT7681
+# include "arch/pico_generic_gcc.h"
+#elif defined FAULTY
+# include "../test/pico_faulty.h"
+#elif defined ARCHNONE
+# include "arch/pico_none.h"
+#elif defined GENERIC
+# include "arch/pico_generic_gcc.h"
+#elif defined __KERNEL__
+# include "arch/pico_linux.h"
+/* #elif defined ... */
+#else
+# include "arch/pico_posix.h"
+#endif
+
+#ifdef PICO_SUPPORT_MM
+#define PICO_ZALLOC(x) pico_mem_zalloc(x)
+#define PICO_FREE(x) pico_mem_free(x)
+#else
+#define PICO_ZALLOC(x) pico_zalloc(x)
+#define PICO_FREE(x) pico_free(x)
+#endif /* PICO_SUPPORT_MM */
+
+#endif
diff --git a/net/picotcp/include/pico_constants.h b/net/picotcp/include/pico_constants.h
new file mode 100644
index 0000000..f043408
--- /dev/null
+++ b/net/picotcp/include/pico_constants.h
@@ -0,0 +1,54 @@
+/*********************************************************************
+ PicoTCP. Copyright (c) 2012-2015 Altran Intelligent Systems. Some rights reserved.
+ See LICENSE and COPYING for usage.
+
+ *********************************************************************/
+#ifndef INCLUDE_PICO_CONST
+#define INCLUDE_PICO_CONST
+/* Included from pico_config.h */
+
+/** Non-endian dependant constants */
+#define PICO_SIZE_IP4 4
+#define PICO_SIZE_IP6 16
+#define PICO_SIZE_ETH 6
+#define PICO_SIZE_TRANS 8
+
+/** Endian-dependant constants **/
+typedef uint64_t pico_time;
+extern volatile uint64_t pico_tick;
+
+
+/*** *** *** *** *** *** ***
+ *** ARP CONFIG ***
+ *** *** *** *** *** *** ***/
+
+#include "pico_addressing.h"
+
+/* Maximum amount of accepted ARP requests per burst interval */
+#define PICO_ARP_MAX_RATE 1
+/* Duration of the burst interval in milliseconds */
+#define PICO_ARP_INTERVAL 1000
+
+/* Add well-known host numbers here. (bigendian constants only beyond this point) */
+#define PICO_IP4_ANY (0x00000000U)
+#define PICO_IP4_BCAST (0xffffffffU)
+
+/* defined in modules/pico_ipv6.c */
+#ifdef PICO_SUPPORT_IPV6
+extern const uint8_t PICO_IPV6_ANY[PICO_SIZE_IP6];
+#endif
+
+static inline uint32_t pico_hash(const void *buf, uint32_t size)
+{
+ uint32_t hash = 5381;
+ uint32_t i;
+ const uint8_t *ptr = (const uint8_t *)buf;
+ for(i = 0; i < size; i++)
+ hash = ((hash << 5) + hash) + ptr[i]; /* hash * 33 + char */
+ return hash;
+}
+
+/* Debug */
+/* #define PICO_SUPPORT_DEBUG_MEMORY */
+/* #define PICO_SUPPORT_DEBUG_TOOLS */
+#endif
diff --git a/net/picotcp/include/pico_device.h b/net/picotcp/include/pico_device.h
new file mode 100644
index 0000000..a2d03ec
--- /dev/null
+++ b/net/picotcp/include/pico_device.h
@@ -0,0 +1,54 @@
+/*********************************************************************
+ PicoTCP. Copyright (c) 2012-2015 Altran Intelligent Systems. Some rights reserved.
+ See LICENSE and COPYING for usage.
+
+ *********************************************************************/
+#ifndef INCLUDE_PICO_DEVICE
+#define INCLUDE_PICO_DEVICE
+#include "pico_queue.h"
+#include "pico_frame.h"
+#include "pico_addressing.h"
+#include "pico_tree.h"
+extern struct pico_tree Device_tree;
+#include "pico_ipv6_nd.h"
+#define MAX_DEVICE_NAME 16
+
+
+struct pico_ethdev {
+ struct pico_eth mac;
+};
+
+struct pico_device {
+ char name[MAX_DEVICE_NAME];
+ uint32_t hash;
+ uint32_t overhead;
+ uint32_t mtu;
+ struct pico_ethdev *eth; /* Null if non-ethernet */
+ struct pico_queue *q_in;
+ struct pico_queue *q_out;
+ int (*link_state)(struct pico_device *self);
+ int (*send)(struct pico_device *self, void *buf, int len); /* Send function. Return 0 if busy */
+ int (*poll)(struct pico_device *self, int loop_score);
+ void (*destroy)(struct pico_device *self);
+ int (*dsr)(struct pico_device *self, int loop_score);
+ int __serving_interrupt;
+ /* used to signal the upper layer the number of events arrived since the last processing */
+ volatile int eventCnt;
+ #ifdef PICO_SUPPORT_IPV6
+ struct pico_nd_hostvars hostvars;
+ #endif
+};
+
+
+int pico_device_init(struct pico_device *dev, const char *name, uint8_t *mac);
+void pico_device_destroy(struct pico_device *dev);
+int pico_devices_loop(int loop_score, int direction);
+struct pico_device*pico_get_device(const char*name);
+int32_t pico_device_broadcast(struct pico_frame *f);
+int pico_device_link_state(struct pico_device *dev);
+int pico_device_ipv6_random_ll(struct pico_device *dev);
+#ifdef PICO_SUPPORT_IPV6
+struct pico_ipv6_link *pico_ipv6_link_add_local(struct pico_device *dev, const struct pico_ip6 *prefix);
+#endif
+
+#endif
diff --git a/net/picotcp/include/pico_eth.h b/net/picotcp/include/pico_eth.h
new file mode 100644
index 0000000..89846c7
--- /dev/null
+++ b/net/picotcp/include/pico_eth.h
@@ -0,0 +1,21 @@
+/*********************************************************************
+ PicoTCP. Copyright (c) 2012-2015 Altran Intelligent Systems. Some rights reserved.
+ See LICENSE and COPYING for usage.
+
+ *********************************************************************/
+#ifndef INCLUDE_PICO_ETH
+#define INCLUDE_PICO_ETH
+#include "pico_addressing.h"
+#include "pico_ipv4.h"
+#include "pico_ipv6.h"
+
+
+PACKED_STRUCT_DEF pico_eth_hdr {
+ uint8_t daddr[6];
+ uint8_t saddr[6];
+ uint16_t proto;
+};
+
+#define PICO_SIZE_ETHHDR 14
+
+#endif
diff --git a/net/picotcp/include/pico_frame.h b/net/picotcp/include/pico_frame.h
new file mode 100644
index 0000000..feb8f78
--- /dev/null
+++ b/net/picotcp/include/pico_frame.h
@@ -0,0 +1,122 @@
+/*********************************************************************
+ PicoTCP. Copyright (c) 2012-2015 Altran Intelligent Systems. Some rights reserved.
+ See LICENSE and COPYING for usage.
+
+ *********************************************************************/
+#ifndef INCLUDE_PICO_FRAME
+#define INCLUDE_PICO_FRAME
+#include "pico_config.h"
+
+
+#define PICO_FRAME_FLAG_BCAST (0x01)
+#define PICO_FRAME_FLAG_EXT_BUFFER (0x02)
+#define PICO_FRAME_FLAG_EXT_USAGE_COUNTER (0x04)
+#define PICO_FRAME_FLAG_SACKED (0x80)
+#define IS_BCAST(f) ((f->flags & PICO_FRAME_FLAG_BCAST) == PICO_FRAME_FLAG_BCAST)
+
+
+struct pico_socket;
+
+
+struct pico_frame {
+
+ /* Connector for queues */
+ struct pico_frame *next;
+
+ /* Start of the whole buffer, total frame length. */
+ unsigned char *buffer;
+ uint32_t buffer_len;
+
+ /* For outgoing packets: this is the meaningful buffer. */
+ unsigned char *start;
+ uint32_t len;
+
+ /* Pointer to usage counter */
+ uint32_t *usage_count;
+
+ /* Pointer to protocol headers */
+ uint8_t *datalink_hdr;
+
+ uint8_t *net_hdr;
+ uint16_t net_len;
+ uint8_t *transport_hdr;
+ uint16_t transport_len;
+ uint8_t *app_hdr;
+ uint16_t app_len;
+
+ /* Pointer to the phisical device this packet belongs to.
+ * Should be valid in both routing directions
+ */
+ struct pico_device *dev;
+
+ pico_time timestamp;
+
+ /* Failures due to bad datalink addressing. */
+ uint16_t failure_count;
+
+ /* Protocol over IP */
+ uint8_t proto;
+
+ /* PICO_FRAME_FLAG_* */
+ uint8_t flags;
+
+ /* Pointer to payload */
+ unsigned char *payload;
+ uint16_t payload_len;
+
+#ifdef PICO_SUPPORT_IPFRAG
+ /* Payload fragmentation info */
+ uint16_t frag;
+#endif
+
+ /* Pointer to socket */
+ struct pico_socket *sock;
+
+ /* Pointer to transport info, used to store remote UDP endpoint (IP + port) */
+ void *info;
+
+ /*Priority. "best-effort" priority, the default value is 0. Priority can be in between -10 and +10*/
+ int8_t priority;
+ uint8_t transport_flags_saved;
+
+ /* Callback to notify listener when the buffer has been discarded */
+ void (*notify_free)(uint8_t *);
+
+ uint8_t send_ttl; /* Special TTL/HOPS value, 0 = auto assign */
+ uint8_t send_tos; /* Type of service */
+};
+
+/** frame alloc/dealloc/copy **/
+void pico_frame_discard(struct pico_frame *f);
+struct pico_frame *pico_frame_copy(struct pico_frame *f);
+struct pico_frame *pico_frame_deepcopy(struct pico_frame *f);
+struct pico_frame *pico_frame_alloc(uint32_t size);
+int pico_frame_grow(struct pico_frame *f, uint32_t size);
+struct pico_frame *pico_frame_alloc_skeleton(uint32_t size, int ext_buffer);
+int pico_frame_skeleton_set_buffer(struct pico_frame *f, void *buf);
+uint16_t pico_checksum(void *inbuf, uint32_t len);
+uint16_t pico_dualbuffer_checksum(void *b1, uint32_t len1, void *b2, uint32_t len2);
+
+static inline int pico_is_digit(char c)
+{
+ if (c < '0' || c > '9')
+ return 0;
+
+ return 1;
+}
+
+static inline int pico_is_hex(char c)
+{
+ if (c >= '0' && c <= '9')
+ return 1;
+
+ if (c >= 'a' && c <= 'f')
+ return 1;
+
+ if (c >= 'A' && c <= 'F')
+ return 1;
+
+ return 0;
+}
+
+#endif
diff --git a/net/picotcp/include/pico_module_eth.h b/net/picotcp/include/pico_module_eth.h
new file mode 100644
index 0000000..c86680d
--- /dev/null
+++ b/net/picotcp/include/pico_module_eth.h
@@ -0,0 +1,33 @@
+/*********************************************************************
+ PicoTCP. Copyright (c) 2012-2015 Altran Intelligent Systems. Some rights reserved.
+ See LICENSE and COPYING for usage.
+
+ *********************************************************************/
+#ifndef PICO_MODULE_IPV4_H
+#define PICO_MODULE_IPV4_H
+
+struct pico_arp_entry {
+ struct eth dest;
+#ifdef PICO_CONFIG_IPV4
+ struct ipv4 addr_ipv4;
+#endif
+ RB_ENTRY(pico_arp_entry) node;
+};
+
+/* Configured device */
+struct pico_eth_link {
+ struct pico_device *dev;
+ struct eth address;
+ struct eth netmask;
+ RB_ENTRY(pico_eth_link) node;
+};
+
+#ifndef IS_MODULE_ETH
+# define _mod extern
+#else
+# define _mod
+#endif
+_mod struct pico_module pico_module_eth;
+#undef _mod
+
+#endif
diff --git a/net/picotcp/include/pico_protocol.h b/net/picotcp/include/pico_protocol.h
new file mode 100644
index 0000000..fd7c122
--- /dev/null
+++ b/net/picotcp/include/pico_protocol.h
@@ -0,0 +1,95 @@
+/*********************************************************************
+ PicoTCP. Copyright (c) 2012-2015 Altran Intelligent Systems. Some rights reserved.
+ See LICENSE and COPYING for usage.
+
+ *********************************************************************/
+#ifndef INCLUDE_PICO_PROTOCOL
+#define INCLUDE_PICO_PROTOCOL
+#include "pico_config.h"
+#include "pico_queue.h"
+
+#define PICO_LOOP_DIR_IN 1
+#define PICO_LOOP_DIR_OUT 2
+
+enum pico_layer {
+ PICO_LAYER_DATALINK = 2, /* Ethernet only. */
+ PICO_LAYER_NETWORK = 3, /* IPv4, IPv6, ARP. Arp is there because it communicates with L2 */
+ PICO_LAYER_TRANSPORT = 4, /* UDP, TCP, ICMP */
+ PICO_LAYER_SOCKET = 5 /* Socket management */
+};
+
+enum pico_err_e {
+ PICO_ERR_NOERR = 0,
+ PICO_ERR_EPERM = 1,
+ PICO_ERR_ENOENT = 2,
+ /* ... */
+ PICO_ERR_EINTR = 4,
+ PICO_ERR_EIO = 5,
+ PICO_ERR_ENXIO = 6,
+ /* ... */
+ PICO_ERR_EAGAIN = 11,
+ PICO_ERR_ENOMEM = 12,
+ PICO_ERR_EACCESS = 13,
+ PICO_ERR_EFAULT = 14,
+ /* ... */
+ PICO_ERR_EBUSY = 16,
+ PICO_ERR_EEXIST = 17,
+ /* ... */
+ PICO_ERR_EINVAL = 22,
+ /* ... */
+ PICO_ERR_ENONET = 64,
+ /* ... */
+ PICO_ERR_EPROTO = 71,
+ /* ... */
+ PICO_ERR_ENOPROTOOPT = 92,
+ PICO_ERR_EPROTONOSUPPORT = 93,
+ /* ... */
+ PICO_ERR_EOPNOTSUPP = 95,
+ PICO_ERR_EADDRINUSE = 98,
+ PICO_ERR_EADDRNOTAVAIL = 99,
+ PICO_ERR_ENETDOWN = 100,
+ PICO_ERR_ENETUNREACH = 101,
+ /* ... */
+ PICO_ERR_ECONNRESET = 104,
+ /* ... */
+ PICO_ERR_EISCONN = 106,
+ PICO_ERR_ENOTCONN = 107,
+ PICO_ERR_ESHUTDOWN = 108,
+ /* ... */
+ PICO_ERR_ETIMEDOUT = 110,
+ PICO_ERR_ECONNREFUSED = 111,
+ PICO_ERR_EHOSTDOWN = 112,
+ PICO_ERR_EHOSTUNREACH = 113,
+};
+
+typedef enum pico_err_e pico_err_t;
+extern volatile pico_err_t pico_err;
+
+#define IS_IPV6(f) (f && f->net_hdr && ((((uint8_t *)(f->net_hdr))[0] & 0xf0) == 0x60))
+#define IS_IPV4(f) (f && f->net_hdr && ((((uint8_t *)(f->net_hdr))[0] & 0xf0) == 0x40))
+
+#define MAX_PROTOCOL_NAME 16
+
+struct pico_protocol {
+ char name[MAX_PROTOCOL_NAME];
+ uint32_t hash;
+ enum pico_layer layer;
+ uint16_t proto_number;
+ struct pico_queue *q_in;
+ struct pico_queue *q_out;
+ struct pico_frame *(*alloc)(struct pico_protocol *self, uint16_t size); /* Frame allocation. */
+ int (*push)(struct pico_protocol *self, struct pico_frame *p); /* Push function, for active outgoing pkts from above */
+ int (*process_out)(struct pico_protocol *self, struct pico_frame *p); /* Send loop. */
+ int (*process_in)(struct pico_protocol *self, struct pico_frame *p); /* Recv loop. */
+ uint16_t (*get_mtu)(struct pico_protocol *self);
+};
+
+int pico_protocols_loop(int loop_score);
+void pico_protocol_init(struct pico_protocol *p);
+
+int pico_protocol_datalink_loop(int loop_score, int direction);
+int pico_protocol_network_loop(int loop_score, int direction);
+int pico_protocol_transport_loop(int loop_score, int direction);
+int pico_protocol_socket_loop(int loop_score, int direction);
+
+#endif
diff --git a/net/picotcp/include/pico_queue.h b/net/picotcp/include/pico_queue.h
new file mode 100644
index 0000000..6cbb979
--- /dev/null
+++ b/net/picotcp/include/pico_queue.h
@@ -0,0 +1,166 @@
+/*********************************************************************
+ PicoTCP. Copyright (c) 2012-2015 Altran Intelligent Systems. Some rights reserved.
+ See LICENSE and COPYING for usage.
+
+ *********************************************************************/
+#ifndef INCLUDE_PICO_QUEUE
+#define INCLUDE_PICO_QUEUE
+#include "pico_config.h"
+#include "pico_frame.h"
+
+#define Q_LIMIT 0
+
+#ifndef NULL
+#define NULL ((void *)0)
+#endif
+
+void *pico_mutex_init(void);
+void pico_mutex_deinit(void *mutex);
+void pico_mutex_lock(void *mutex);
+int pico_mutex_lock_timeout(void *mutex, int timeout);
+void pico_mutex_unlock(void *mutex);
+void pico_mutex_unlock_ISR(void *mutex);
+
+struct pico_queue {
+ uint32_t frames;
+ uint32_t size;
+ uint32_t max_frames;
+ uint32_t max_size;
+ struct pico_frame *head;
+ struct pico_frame *tail;
+#ifdef PICO_SUPPORT_MUTEX
+ void *mutex;
+#endif
+ uint8_t shared;
+ uint16_t overhead;
+};
+
+#ifdef PICO_SUPPORT_MUTEX
+#define PICOTCP_MUTEX_LOCK(x) { \
+ if (x == NULL) \
+ x = pico_mutex_init(); \
+ pico_mutex_lock(x); \
+}
+#define PICOTCP_MUTEX_UNLOCK(x) pico_mutex_unlock(x)
+#define PICOTCP_MUTEX_DEL(x) pico_mutex_deinit(x)
+
+#else
+#define PICOTCP_MUTEX_LOCK(x) do {} while(0)
+#define PICOTCP_MUTEX_UNLOCK(x) do {} while(0)
+#define PICOTCP_MUTEX_DEL(x) do {} while(0)
+#endif
+
+#ifdef PICO_SUPPORT_DEBUG_TOOLS
+static void debug_q(struct pico_queue *q)
+{
+ struct pico_frame *p = q->head;
+ dbg("%d: ", q->frames);
+ while(p) {
+ dbg("(%p)-->", p);
+ p = p->next;
+ }
+ dbg("X\n");
+}
+
+#else
+
+#define debug_q(x) do {} while(0)
+#endif
+
+static inline int32_t pico_enqueue(struct pico_queue *q, struct pico_frame *p)
+{
+ if ((q->max_frames) && (q->max_frames <= q->frames))
+ return -1;
+
+#if (Q_LIMIT != 0)
+ if ((Q_LIMIT < p->buffer_len + q->size))
+ return -1;
+
+#endif
+
+ if ((q->max_size) && (q->max_size < (p->buffer_len + q->size)))
+ return -1;
+
+ if (q->shared)
+ PICOTCP_MUTEX_LOCK(q->mutex);
+
+ p->next = NULL;
+ if (!q->head) {
+ q->head = p;
+ q->tail = p;
+ q->size = 0;
+ q->frames = 0;
+ } else {
+ q->tail->next = p;
+ q->tail = p;
+ }
+
+ q->size += p->buffer_len + q->overhead;
+ q->frames++;
+ debug_q(q);
+
+ if (q->shared)
+ PICOTCP_MUTEX_UNLOCK(q->mutex);
+
+ return (int32_t)q->size;
+}
+
+static inline struct pico_frame *pico_dequeue(struct pico_queue *q)
+{
+ struct pico_frame *p = q->head;
+ if (!p)
+ return NULL;
+
+ if (q->frames < 1)
+ return NULL;
+
+ if (q->shared)
+ PICOTCP_MUTEX_LOCK(q->mutex);
+
+ q->head = p->next;
+ q->frames--;
+ q->size -= p->buffer_len - q->overhead;
+ if (q->head == NULL)
+ q->tail = NULL;
+
+ debug_q(q);
+
+ p->next = NULL;
+ if (q->shared)
+ PICOTCP_MUTEX_UNLOCK(q->mutex);
+
+ return p;
+}
+
+static inline struct pico_frame *pico_queue_peek(struct pico_queue *q)
+{
+ struct pico_frame *p = q->head;
+ if (q->frames < 1)
+ return NULL;
+
+ debug_q(q);
+ return p;
+}
+
+static inline void pico_queue_deinit(struct pico_queue *q)
+{
+ if (q->shared) {
+ PICOTCP_MUTEX_DEL(q->mutex);
+ }
+}
+
+static inline void pico_queue_empty(struct pico_queue *q)
+{
+ struct pico_frame *p = pico_dequeue(q);
+ while(p) {
+ pico_frame_discard(p);
+ p = pico_dequeue(q);
+ }
+}
+
+static inline void pico_queue_protect(struct pico_queue *q)
+{
+ q->shared = 1;
+}
+
+#endif
diff --git a/net/picotcp/include/pico_socket.h b/net/picotcp/include/pico_socket.h
new file mode 100644
index 0000000..a076654
--- /dev/null
+++ b/net/picotcp/include/pico_socket.h
@@ -0,0 +1,268 @@
+/*********************************************************************
+ PicoTCP. Copyright (c) 2012-2015 Altran Intelligent Systems. Some rights reserved.
+ See LICENSE and COPYING for usage.
+
+ *********************************************************************/
+#ifndef INCLUDE_PICO_SOCKET
+#define INCLUDE_PICO_SOCKET
+#include "pico_queue.h"
+#include "pico_addressing.h"
+#include "pico_config.h"
+#include "pico_protocol.h"
+#include "pico_tree.h"
+
+#ifdef __linux__
+ #define PICO_DEFAULT_SOCKETQ (16 * 1024) /* Linux host, so we want full throttle */
+#else
+ #define PICO_DEFAULT_SOCKETQ (6 * 1024) /* seems like an acceptable default for small embedded systems */
+#endif
+
+#define PICO_SHUT_RD 1
+#define PICO_SHUT_WR 2
+#define PICO_SHUT_RDWR 3
+
+#ifdef PICO_SUPPORT_IPV4
+# define IS_SOCK_IPV4(s) ((s->net == &pico_proto_ipv4))
+#else
+# define IS_SOCK_IPV4(s) (0)
+#endif
+
+#ifdef PICO_SUPPORT_IPV6
+# define IS_SOCK_IPV6(s) ((s->net == &pico_proto_ipv6))
+#else
+# define IS_SOCK_IPV6(s) (0)
+#endif
+
+
+struct pico_sockport
+{
+ struct pico_tree socks; /* how you make the connection ? */
+ uint16_t number;
+ uint16_t proto;
+};
+
+
+struct pico_socket {
+ struct pico_protocol *proto;
+ struct pico_protocol *net;
+
+ union pico_address local_addr;
+ union pico_address remote_addr;
+
+ uint16_t local_port;
+ uint16_t remote_port;
+
+ struct pico_queue q_in;
+ struct pico_queue q_out;
+
+ void (*wakeup)(uint16_t ev, struct pico_socket *s);
+
+
+#ifdef PICO_SUPPORT_TCP
+ /* For the TCP backlog queue */
+ struct pico_socket *backlog;
+ struct pico_socket *next;
+ struct pico_socket *parent;
+ uint16_t max_backlog;
+ uint16_t number_of_pending_conn;
+#endif
+#ifdef PICO_SUPPORT_MCAST
+ struct pico_tree *MCASTListen;
+#endif
+ uint16_t ev_pending;
+
+ struct pico_device *dev;
+
+ /* Private field. */
+ int id;
+ uint16_t state;
+ uint16_t opt_flags;
+ pico_time timestamp;
+ void *priv;
+};
+
+struct pico_remote_endpoint {
+ union pico_address remote_addr;
+ uint16_t remote_port;
+};
+
+
+/* request struct for multicast socket opt */
+struct pico_ip_mreq {
+ struct pico_ip4 mcast_group_addr;
+ struct pico_ip4 mcast_link_addr;
+};
+
+struct pico_ip_mreq_source {
+ struct pico_ip4 mcast_group_addr;
+ struct pico_ip4 mcast_source_addr;
+ struct pico_ip4 mcast_link_addr;
+};
+
+#ifdef PICO_SUPPORT_IPV6
+
+/* same as above, but ipv6 */
+struct pico_ipv6_mreq {
+ struct pico_ip6 mcast_group_addr;
+ struct pico_ip6 mcast_link_addr;
+};
+
+struct pico_ipv6_mreq_source {
+ struct pico_ip6 mcast_group_addr;
+ struct pico_ip6 mcast_source_addr;
+ struct pico_ip6 mcast_link_addr;
+};
+
+#endif
+
+#define PICO_SOCKET_STATE_UNDEFINED 0x0000u
+#define PICO_SOCKET_STATE_SHUT_LOCAL 0x0001u
+#define PICO_SOCKET_STATE_SHUT_REMOTE 0x0002u
+#define PICO_SOCKET_STATE_BOUND 0x0004u
+#define PICO_SOCKET_STATE_CONNECTED 0x0008u
+#define PICO_SOCKET_STATE_CLOSING 0x0010u
+#define PICO_SOCKET_STATE_CLOSED 0x0020u
+
+# define PICO_SOCKET_STATE_TCP 0xFF00u
+# define PICO_SOCKET_STATE_TCP_UNDEF 0x00FFu
+# define PICO_SOCKET_STATE_TCP_CLOSED 0x0100u
+# define PICO_SOCKET_STATE_TCP_LISTEN 0x0200u
+# define PICO_SOCKET_STATE_TCP_SYN_SENT 0x0300u
+# define PICO_SOCKET_STATE_TCP_SYN_RECV 0x0400u
+# define PICO_SOCKET_STATE_TCP_ESTABLISHED 0x0500u
+# define PICO_SOCKET_STATE_TCP_CLOSE_WAIT 0x0600u
+# define PICO_SOCKET_STATE_TCP_LAST_ACK 0x0700u
+# define PICO_SOCKET_STATE_TCP_FIN_WAIT1 0x0800u
+# define PICO_SOCKET_STATE_TCP_FIN_WAIT2 0x0900u
+# define PICO_SOCKET_STATE_TCP_CLOSING 0x0a00u
+# define PICO_SOCKET_STATE_TCP_TIME_WAIT 0x0b00u
+# define PICO_SOCKET_STATE_TCP_ARRAYSIZ 0x0cu
+
+
+/* Socket options */
+# define PICO_TCP_NODELAY 1
+# define PICO_SOCKET_OPT_TCPNODELAY 0x0000u
+
+# define PICO_IP_MULTICAST_EXCLUDE 0
+# define PICO_IP_MULTICAST_INCLUDE 1
+# define PICO_IP_MULTICAST_IF 32
+# define PICO_IP_MULTICAST_TTL 33
+# define PICO_IP_MULTICAST_LOOP 34
+# define PICO_IP_ADD_MEMBERSHIP 35
+# define PICO_IP_DROP_MEMBERSHIP 36
+# define PICO_IP_UNBLOCK_SOURCE 37
+# define PICO_IP_BLOCK_SOURCE 38
+# define PICO_IP_ADD_SOURCE_MEMBERSHIP 39
+# define PICO_IP_DROP_SOURCE_MEMBERSHIP 40
+
+# define PICO_SOCKET_OPT_MULTICAST_LOOP 1
+
+# define PICO_SOCKET_OPT_RCVBUF 52
+# define PICO_SOCKET_OPT_SNDBUF 53
+
+/* Constants */
+# define PICO_IP_DEFAULT_MULTICAST_TTL 1
+# define PICO_IP_DEFAULT_MULTICAST_LOOP 1
+
+#define PICO_SOCKET_TIMEOUT 90000u /* 90 seconds */
+#define PICO_SOCKET_BOUND_TIMEOUT 30000u /* 30 seconds */
+
+#define PICO_SOCKET_SHUTDOWN_WRITE 0x01u
+#define PICO_SOCKET_SHUTDOWN_READ 0x02u
+#define TCPSTATE(s) ((s)->state & PICO_SOCKET_STATE_TCP)
+
+#define PICO_SOCK_EV_RD 1u
+#define PICO_SOCK_EV_WR 2u
+#define PICO_SOCK_EV_CONN 4u
+#define PICO_SOCK_EV_CLOSE 8u
+#define PICO_SOCK_EV_FIN 0x10u
+#define PICO_SOCK_EV_ERR 0x80u
+
+struct pico_msginfo {
+ struct pico_device *dev;
+ uint8_t ttl;
+ uint8_t tos;
+};
+
+struct pico_socket *pico_socket_open(uint16_t net, uint16_t proto, void (*wakeup)(uint16_t ev, struct pico_socket *s));
+
+int pico_socket_read(struct pico_socket *s, void *buf, int len);
+int pico_socket_write(struct pico_socket *s, const void *buf, int len);
+
+int pico_socket_sendto(struct pico_socket *s, const void *buf, int len, void *dst, uint16_t remote_port);
+int pico_socket_sendto_extended(struct pico_socket *s, const void *buf, const int len,
+ void *dst, uint16_t remote_port, struct pico_msginfo *msginfo);
+
+int pico_socket_recvfrom(struct pico_socket *s, void *buf, int len, void *orig, uint16_t *local_port);
+int pico_socket_recvfrom_extended(struct pico_socket *s, void *buf, int len, void *orig,
+ uint16_t *remote_port, struct pico_msginfo *msginfo);
+
+int pico_socket_send(struct pico_socket *s, const void *buf, int len);
+int pico_socket_recv(struct pico_socket *s, void *buf, int len);
+
+int pico_socket_bind(struct pico_socket *s, void *local_addr, uint16_t *port);
+int pico_socket_getname(struct pico_socket *s, void *local_addr, uint16_t *port, uint16_t *proto);
+int pico_socket_getpeername(struct pico_socket *s, void *remote_addr, uint16_t *port, uint16_t *proto);
+
+int pico_socket_connect(struct pico_socket *s, const void *srv_addr, uint16_t remote_port);
+int pico_socket_listen(struct pico_socket *s, const int backlog);
+struct pico_socket *pico_socket_accept(struct pico_socket *s, void *orig, uint16_t *port);
+int8_t pico_socket_del(struct pico_socket *s);
+
+int pico_socket_setoption(struct pico_socket *s, int option, void *value);
+int pico_socket_getoption(struct pico_socket *s, int option, void *value);
+
+int pico_socket_shutdown(struct pico_socket *s, int mode);
+int pico_socket_close(struct pico_socket *s);
+
+struct pico_frame *pico_socket_frame_alloc(struct pico_socket *s, uint16_t len);
+
+#ifdef PICO_SUPPORT_IPV4
+# define is_sock_ipv4(x) (x->net == &pico_proto_ipv4)
+#else
+# define is_sock_ipv4(x) (0)
+#endif
+
+#ifdef PICO_SUPPORT_IPV6
+# define is_sock_ipv6(x) (x->net == &pico_proto_ipv6)
+#else
+# define is_sock_ipv6(x) (0)
+#endif
+
+#ifdef PICO_SUPPORT_UDP
+# define is_sock_udp(x) (x->proto == &pico_proto_udp)
+#else
+# define is_sock_udp(x) (0)
+#endif
+
+#ifdef PICO_SUPPORT_TCP
+# define is_sock_tcp(x) (x->proto == &pico_proto_tcp)
+#else
+# define is_sock_tcp(x) (0)
+#endif
+
+/* Interface towards transport protocol */
+int pico_transport_process_in(struct pico_protocol *self, struct pico_frame *f);
+struct pico_socket *pico_socket_clone(struct pico_socket *facsimile);
+int8_t pico_socket_add(struct pico_socket *s);
+int pico_transport_error(struct pico_frame *f, uint8_t proto, int code);
+
+/* Socket loop */
+int pico_sockets_loop(int loop_score);
+struct pico_socket*pico_sockets_find(uint16_t local, uint16_t remote);
+/* Port check */
+int pico_is_port_free(uint16_t proto, uint16_t port, void *addr, void *net);
+
+struct pico_sockport *pico_get_sockport(uint16_t proto, uint16_t port);
+
+uint32_t pico_socket_get_mss(struct pico_socket *s);
+int pico_socket_set_family(struct pico_socket *s, uint16_t family);
+
+int pico_count_sockets(uint8_t proto);
+
+#define PICO_SOCKET_SETOPT_EN(socket, index) (socket->opt_flags |= (1 << index))
+#define PICO_SOCKET_SETOPT_DIS(socket, index) (socket->opt_flags &= (uint16_t) ~(1 << index))
+#define PICO_SOCKET_GETOPT(socket, index) ((socket->opt_flags & (1u << index)) != 0)
+
+
+#endif
diff --git a/net/picotcp/include/pico_socket_multicast.h b/net/picotcp/include/pico_socket_multicast.h
new file mode 100644
index 0000000..44c30c5
--- /dev/null
+++ b/net/picotcp/include/pico_socket_multicast.h
@@ -0,0 +1,10 @@
+#ifndef PICO_SOCKET_MULTICAST_H
+#define PICO_SOCKET_MULTICAST_H
+int pico_socket_mcast_filter(struct pico_socket *s, union pico_address *mcast_group, union pico_address *src);
+void pico_multicast_delete(struct pico_socket *s);
+int pico_setsockopt_mcast(struct pico_socket *s, int option, void *value);
+int pico_getsockopt_mcast(struct pico_socket *s, int option, void *value);
+int pico_udp_get_mc_ttl(struct pico_socket *s, uint8_t *ttl);
+int pico_udp_set_mc_ttl(struct pico_socket *s, void *_ttl);
+
+#endif
diff --git a/net/picotcp/include/pico_stack.h b/net/picotcp/include/pico_stack.h
new file mode 100644
index 0000000..69b0bf1
--- /dev/null
+++ b/net/picotcp/include/pico_stack.h
@@ -0,0 +1,87 @@
+/*********************************************************************
+ PicoTCP. Copyright (c) 2012-2015 Altran Intelligent Systems. Some rights reserved.
+ See LICENSE and COPYING for usage.
+
+ *********************************************************************/
+#ifndef INCLUDE_PICO_STACK
+#define INCLUDE_PICO_STACK
+#include "pico_config.h"
+#include "pico_frame.h"
+
+#define PICO_MAX_TIMERS 20
+
+#define PICO_ETH_MRU (1514u)
+#define PICO_IP_MRU (1500u)
+
+/* ===== RECEIVING FUNCTIONS (from dev up to socket) ===== */
+
+/* TRANSPORT LEVEL */
+/* interface towards network */
+int32_t pico_transport_receive(struct pico_frame *f, uint8_t proto);
+
+/* NETWORK LEVEL */
+/* interface towards ethernet */
+int32_t pico_network_receive(struct pico_frame *f);
+
+
+/* LOWEST LEVEL: interface towards devices. */
+/* Device driver will call this function which returns immediately.
+ * Incoming packet will be processed later on in the dev loop.
+ * The zerocopy version will associate the current buffer to the newly created frame.
+ * Warning: the buffer used in the zerocopy version MUST have been allocated using PICO_ZALLOC()
+ */
+int32_t pico_stack_recv(struct pico_device *dev, uint8_t *buffer, uint32_t len);
+int32_t pico_stack_recv_zerocopy(struct pico_device *dev, uint8_t *buffer, uint32_t len);
+int32_t pico_stack_recv_zerocopy_ext_buffer(struct pico_device *dev, uint8_t *buffer, uint32_t len);
+int32_t pico_stack_recv_zerocopy_ext_buffer_notify(struct pico_device *dev, uint8_t *buffer, uint32_t len, void (*notify_free)(uint8_t *buffer));
+
+/* ===== SENDING FUNCTIONS (from socket down to dev) ===== */
+
+int32_t pico_network_send(struct pico_frame *f);
+int32_t pico_sendto_dev(struct pico_frame *f);
+
+#ifdef PICO_SUPPORT_ETH
+int32_t pico_ethernet_send(struct pico_frame *f);
+
+/* The pico_ethernet_receive() function is used by
+ * those devices supporting ETH in order to push packets up
+ * into the stack.
+ */
+/* DATALINK LEVEL */
+int32_t pico_ethernet_receive(struct pico_frame *f);
+#else
+/* When ETH is not supported by the stack... */
+# define pico_ethernet_send(f) (-1)
+# define pico_ethernet_receive(f) (-1)
+#endif
+
+/* ----- Initialization ----- */
+int pico_stack_init(void);
+
+/* ----- Loop Function. ----- */
+void pico_stack_tick(void);
+void pico_stack_loop(void);
+
+/* ---- Notifications for stack errors */
+int pico_notify_socket_unreachable(struct pico_frame *f);
+int pico_notify_proto_unreachable(struct pico_frame *f);
+int pico_notify_dest_unreachable(struct pico_frame *f);
+int pico_notify_ttl_expired(struct pico_frame *f);
+int pico_notify_frag_expired(struct pico_frame *f);
+int pico_notify_pkt_too_big(struct pico_frame *f);
+
+/* Various. */
+struct pico_timer;
+int pico_source_is_local(struct pico_frame *f);
+int pico_frame_dst_is_unicast(struct pico_frame *f);
+void pico_store_network_origin(void *src, struct pico_frame *f);
+struct pico_timer *pico_timer_add(pico_time expire, void (*timer)(pico_time, void *), void *arg);
+void pico_timer_cancel(struct pico_timer *t);
+pico_time pico_timer_get_expire(struct pico_timer *t);
+uint32_t pico_rand(void);
+void pico_rand_feed(uint32_t feed);
+void pico_to_lowercase(char *str);
+int pico_address_compare(union pico_address *a, union pico_address *b, uint16_t proto);
+int32_t pico_seq_compare(uint32_t a, uint32_t b);
+
+#endif
diff --git a/net/picotcp/include/pico_tree.h b/net/picotcp/include/pico_tree.h
new file mode 100644
index 0000000..8667a1f
--- /dev/null
+++ b/net/picotcp/include/pico_tree.h
@@ -0,0 +1,93 @@
+/*********************************************************************
+ PicoTCP. Copyright (c) 2012-2015 Altran Intelligent Systems. Some rights reserved.
+ See LICENSE and COPYING for usage.
+
+ Author: Andrei Carp <andrei.carp at tass.be>
+ *********************************************************************/
+
+#ifndef PICO_RBTREE_H
+#define PICO_RBTREE_H
+
+#include "pico_config.h"
+
+/* This is used to declare a new tree, leaf root by default */
+#define PICO_TREE_DECLARE(name, compareFunction) \
+ struct pico_tree name = \
+ { \
+ &LEAF, \
+ compareFunction \
+ }
+
+#define USE_PICO_PAGE0_ZALLOC (1)
+#define USE_PICO_ZALLOC (2)
+
+struct pico_tree_node
+{
+ void*keyValue; /* generic key */
+ struct pico_tree_node*parent;
+ struct pico_tree_node*leftChild;
+ struct pico_tree_node*rightChild;
+ uint8_t color;
+};
+
+struct pico_tree
+{
+ struct pico_tree_node *root; /* root of the tree */
+
+ /* this function directly provides the keys as parameters not the nodes. */
+ int (*compare)(void*keyA, void*keyB);
+};
+
+extern struct pico_tree_node LEAF; /* generic leaf node */
+
+#ifdef PICO_SUPPORT_MM
+void *pico_tree_insert_implementation(struct pico_tree *tree, void *key, uint8_t allocator);
+void *pico_tree_delete_implementation(struct pico_tree *tree, void *key, uint8_t allocator);
+#endif
+
+
+/*
+ * Manipulation functions
+ */
+void *pico_tree_insert(struct pico_tree *tree, void *key);
+void *pico_tree_delete(struct pico_tree *tree, void *key);
+void *pico_tree_findKey(struct pico_tree *tree, void *key);
+void pico_tree_drop(struct pico_tree *tree);
+int pico_tree_empty(struct pico_tree *tree);
+struct pico_tree_node *pico_tree_findNode(struct pico_tree *tree, void *key);
+
+void *pico_tree_first(struct pico_tree *tree);
+void *pico_tree_last(struct pico_tree *tree);
+/*
+ * Traverse functions
+ */
+struct pico_tree_node *pico_tree_lastNode(struct pico_tree_node *node);
+struct pico_tree_node *pico_tree_firstNode(struct pico_tree_node *node);
+struct pico_tree_node *pico_tree_next(struct pico_tree_node *node);
+struct pico_tree_node *pico_tree_prev(struct pico_tree_node *node);
+
+/*
+ * For each macros
+ */
+
+#define pico_tree_foreach(idx, tree) \
+ for ((idx) = pico_tree_firstNode((tree)->root); \
+ (idx) != &LEAF; \
+ (idx) = pico_tree_next(idx))
+
+#define pico_tree_foreach_reverse(idx, tree) \
+ for ((idx) = pico_tree_lastNode((tree)->root); \
+ (idx) != &LEAF; \
+ (idx) = pico_tree_prev(idx))
+
+#define pico_tree_foreach_safe(idx, tree, idx2) \
+ for ((idx) = pico_tree_firstNode((tree)->root); \
+ ((idx) != &LEAF) && ((idx2) = pico_tree_next(idx), 1); \
+ (idx) = (idx2))
+
+#define pico_tree_foreach_reverse_safe(idx, tree, idx2) \
+ for ((idx) = pico_tree_lastNode((tree)->root); \
+ ((idx) != &LEAF) && ((idx2) = pico_tree_prev(idx), 1); \
+ (idx) = (idx2))
+
+#endif
diff --git a/net/picotcp/modules/pico_aodv.h b/net/picotcp/modules/pico_aodv.h
new file mode 100644
index 0000000..a3e9b66
--- /dev/null
+++ b/net/picotcp/modules/pico_aodv.h
@@ -0,0 +1,131 @@
+/*********************************************************************
+ PicoTCP. Copyright (c) 2015 Altran Intelligent Systems. Some rights reserved.
+ See LICENSE and COPYING for usage.
+
+ .
+
+ Author: Daniele Lacamera <daniele.lacamera at altran.com>
+ *********************************************************************/
+#ifndef PICO_AODV_H_
+#define PICO_AODV_H_
+#include <stdint.h>
+
+/* RFC3561 */
+#define PICO_AODV_PORT (654)
+
+/* RFC3561 $10 */
+#define AODV_ACTIVE_ROUTE_TIMEOUT (8000u) /* Conservative value for link breakage detection */
+#define AODV_DELETE_PERIOD (5 * AODV_ACTIVE_ROUTE_TIMEOUT) /* Recommended value K = 5 */
+#define AODV_ALLOWED_HELLO_LOSS (4) /* conservative */
+#define AODV_NET_DIAMETER ((uint8_t)(35))
+#define AODV_RREQ_RETRIES (2)
+#define AODV_NODE_TRAVERSAL_TIME (40)
+#define AODV_HELLO_INTERVAL (1000)
+#define AODV_LOCAL_ADD_TTL 2
+#define AODV_RREQ_RATELIMIT (10)
+#define AODV_TIMEOUT_BUFFER (2)
+#define AODV_TTL_START ((uint8_t)(1))
+#define AODV_TTL_INCREMENT 2
+#define AODV_TTL_THRESHOLD ((uint8_t)(7))
+#define AODV_RERR_RATELIMIT (10)
+#define AODV_MAX_REPAIR_TTL ((uint8_t)(AODV_NET_DIAMETER / 3))
+#define AODV_MY_ROUTE_TIMEOUT (2 * AODV_ACTIVE_ROUTE_TIMEOUT)
+#define AODV_NET_TRAVERSAL_TIME (2 * AODV_NODE_TRAVERSAL_TIME * AODV_NET_DIAMETER)
+#define AODV_BLACKLIST_TIMEOUT (AODV_RREQ_RETRIES * AODV_NET_TRAVERSAL_TIME)
+#define AODV_NEXT_HOP_WAIT (AODV_NODE_TRAVERSAL_TIME + 10)
+#define AODV_PATH_DISCOVERY_TIME (2 * AODV_NET_TRAVERSAL_TIME)
+#define AODV_RING_TRAVERSAL_TIME(ttl) (2 * AODV_NODE_TRAVERSAL_TIME * (ttl + AODV_TIMEOUT_BUFFER))
+/* End section RFC3561 $10 */
+
+
+#define AODV_TYPE_RREQ 1
+#define AODV_TYPE_RREP 2
+#define AODV_TYPE_RERR 3
+#define AODV_TYPE_RACK 4
+
+PACKED_STRUCT_DEF pico_aodv_rreq
+{
+ uint8_t type;
+ uint16_t req_flags;
+ uint8_t hop_count;
+ uint32_t rreq_id;
+ uint32_t dest;
+ uint32_t dseq;
+ uint32_t orig;
+ uint32_t oseq;
+};
+
+#define AODV_RREQ_FLAG_J 0x8000
+#define AODV_RREQ_FLAG_R 0x4000
+#define AODV_RREQ_FLAG_G 0x2000
+#define AODV_RREQ_FLAG_D 0x1000
+#define AODV_RREQ_FLAG_U 0x0800
+#define AODV_RREQ_FLAG_RESERVED 0x07FF
+
+PACKED_STRUCT_DEF pico_aodv_rrep
+{
+ uint8_t type;
+ uint8_t rep_flags;
+ uint8_t prefix_sz;
+ uint8_t hop_count;
+ uint32_t dest;
+ uint32_t dseq;
+ uint32_t orig;
+ uint32_t lifetime;
+};
+
+#define AODV_RREP_MAX_PREFIX 0x1F
+#define AODV_RREP_FLAG_R 0x80
+#define AODV_RREP_FLAG_A 0x40
+#define AODV_RREP_FLAG_RESERVED 0x3F
+
+#define PICO_AODV_NODE_NEW 0x0000
+#define PICO_AODV_NODE_SYNC 0x0001
+#define PICO_AODV_NODE_REQUESTING 0x0002
+#define PICO_AODV_NODE_ROUTE_UP 0x0004
+#define PICO_AODV_NODE_ROUTE_DOWN 0x0008
+#define PICO_AODV_NODE_IDLING 0x0010
+#define PICO_AODV_NODE_UNREACH 0x0020
+
+#define PICO_AODV_ACTIVE(node) ((node->flags & PICO_AODV_NODE_ROUTE_UP) && (node->flags & PICO_AODV_NODE_ROUTE_DOWN))
+
+
+struct pico_aodv_node
+{
+ union pico_address dest;
+ pico_time last_seen;
+ pico_time fwd_time;
+ uint32_t dseq;
+ uint16_t flags;
+ uint8_t metric;
+ uint8_t ring_ttl;
+ uint8_t rreq_retry;
+};
+
+PACKED_STRUCT_DEF pico_aodv_unreachable
+{
+ uint32_t addr;
+ uint32_t dseq;
+};
+
+PACKED_STRUCT_DEF pico_aodv_rerr
+{
+ uint8_t type;
+ uint16_t rerr_flags;
+ uint8_t dst_count;
+ uint32_t unreach_addr;
+ uint32_t unreach_dseq;
+ struct pico_aodv_unreachable unreach[1]; /* unrechable nodes: must be at least 1. See dst_count field above */
+};
+
+PACKED_STRUCT_DEF pico_aodv_rack
+{
+ uint8_t type;
+ uint8_t reserved;
+};
+
+int pico_aodv_init(void);
+int pico_aodv_add(struct pico_device *dev);
+int pico_aodv_lookup(const union pico_address *addr);
+void pico_aodv_refresh(const union pico_address *addr);
+#endif
diff --git a/net/picotcp/modules/pico_arp.c b/net/picotcp/modules/pico_arp.c
new file mode 100644
index 0000000..f205bfe
--- /dev/null
+++ b/net/picotcp/modules/pico_arp.c
@@ -0,0 +1,531 @@
+/*********************************************************************
+ PicoTCP. Copyright (c) 2012-2015 Altran Intelligent Systems. Some rights reserved.
+ See LICENSE and COPYING for usage.
+
+ .
+
+ Authors: Daniele Lacamera
+ *********************************************************************/
+
+
+#include "pico_config.h"
+#include "pico_arp.h"
+#include "pico_tree.h"
+#include "pico_ipv4.h"
+#include "pico_device.h"
+#include "pico_stack.h"
+
+extern const uint8_t PICO_ETHADDR_ALL[6];
+#define PICO_ARP_TIMEOUT 600000llu
+#define PICO_ARP_RETRY 300lu
+#define PICO_ARP_MAX_PENDING 5
+
+#ifdef DEBUG_ARP
+ #define arp_dbg dbg
+#else
+ #define arp_dbg(...) do {} while(0)
+#endif
+
+static int max_arp_reqs = PICO_ARP_MAX_RATE;
+static struct pico_frame *frames_queued[PICO_ARP_MAX_PENDING] = { };
+
+static void pico_arp_queued_trigger(void)
+{
+ int i;
+ struct pico_frame *f;
+ for (i = 0; i < PICO_ARP_MAX_PENDING; i++)
+ {
+ f = frames_queued[i];
+ if (f) {
+ pico_ethernet_send(f);
+ frames_queued[i] = NULL;
+ }
+ }
+}
+
+static void update_max_arp_reqs(pico_time now, void *unused)
+{
+ IGNORE_PARAMETER(now);
+ IGNORE_PARAMETER(unused);
+ if (max_arp_reqs < PICO_ARP_MAX_RATE)
+ max_arp_reqs++;
+
+ pico_timer_add(PICO_ARP_INTERVAL / PICO_ARP_MAX_RATE, &update_max_arp_reqs, NULL);
+}
+
+void pico_arp_init(void)
+{
+ pico_timer_add(PICO_ARP_INTERVAL / PICO_ARP_MAX_RATE, &update_max_arp_reqs, NULL);
+}
+
+PACKED_STRUCT_DEF pico_arp_hdr
+{
+ uint16_t htype;
+ uint16_t ptype;
+ uint8_t hsize;
+ uint8_t psize;
+ uint16_t opcode;
+ uint8_t s_mac[PICO_SIZE_ETH];
+ struct pico_ip4 src;
+ uint8_t d_mac[PICO_SIZE_ETH];
+ struct pico_ip4 dst;
+};
+
+
+
+/* Callback handler for ip conflict service (e.g. IPv4 SLAAC)
+ * Whenever the IP address registered here is seen in the network,
+ * the callback is awaken to take countermeasures against IP collisions.
+ *
+ */
+
+struct arp_service_ipconflict {
+ struct pico_eth mac;
+ struct pico_ip4 ip;
+ void (*conflict)(void);
+};
+
+static struct arp_service_ipconflict conflict_ipv4;
+
+
+
+#define PICO_SIZE_ARPHDR ((sizeof(struct pico_arp_hdr)))
+
+/* Arp Entries for the tables. */
+struct pico_arp {
+/* CAREFUL MAN! ARP entry MUST begin with a pico_eth structure,
+ * due to in-place casting!!! */
+ struct pico_eth eth;
+ struct pico_ip4 ipv4;
+ int arp_status;
+ pico_time timestamp;
+ struct pico_device *dev;
+ struct pico_timer *timer;
+};
+
+
+
+/*****************/
+/** ARP TREE **/
+/*****************/
+
+/* Routing destination */
+
+static int arp_compare(void *ka, void *kb)
+{
+ struct pico_arp *a = ka, *b = kb;
+ return pico_ipv4_compare(&a->ipv4, &b->ipv4);
+}
+
+PICO_TREE_DECLARE(arp_tree, arp_compare);
+
+/*********************/
+/** END ARP TREE **/
+/*********************/
+
+struct pico_eth *pico_arp_lookup(struct pico_ip4 *dst)
+{
+ struct pico_arp search, *found;
+ search.ipv4.addr = dst->addr;
+ found = pico_tree_findKey(&arp_tree, &search);
+ if (found && (found->arp_status != PICO_ARP_STATUS_STALE))
+ return &found->eth;
+
+ return NULL;
+}
+
+struct pico_ip4 *pico_arp_reverse_lookup(struct pico_eth *dst)
+{
+ struct pico_arp*search;
+ struct pico_tree_node *index;
+ pico_tree_foreach(index, &arp_tree){
+ search = index->keyValue;
+ if(memcmp(&(search->eth.addr), &dst->addr, 6) == 0)
+ return &search->ipv4;
+ }
+ return NULL;
+}
+
+static void pico_arp_unreachable(struct pico_ip4 *a)
+{
+ int i;
+ struct pico_frame *f;
+ struct pico_ipv4_hdr *hdr;
+ struct pico_ip4 dst;
+ for (i = 0; i < PICO_ARP_MAX_PENDING; i++)
+ {
+ f = frames_queued[i];
+ if (f) {
+ hdr = (struct pico_ipv4_hdr *) f->net_hdr;
+ dst = pico_ipv4_route_get_gateway(&hdr->dst);
+ if (!dst.addr)
+ dst.addr = hdr->dst.addr;
+
+ if (dst.addr == a->addr) {
+ if (!pico_source_is_local(f)) {
+ pico_notify_dest_unreachable(f);
+ }
+
+ pico_frame_discard(f);
+ frames_queued[i] = NULL;
+ }
+ }
+ }
+}
+
+static void pico_arp_retry(struct pico_frame *f, struct pico_ip4 *where)
+{
+ if (++f->failure_count < 4) {
+ arp_dbg ("================= ARP REQUIRED: %d =============\n\n", f->failure_count);
+ /* check if dst is local (gateway = 0), or if to use gateway */
+ pico_arp_request(f->dev, where, PICO_ARP_QUERY);
+ } else {
+ pico_arp_unreachable(where);
+ }
+}
+
+struct pico_eth *pico_arp_get(struct pico_frame *f)
+{
+ struct pico_eth *a4;
+ struct pico_ip4 gateway;
+ struct pico_ip4 *where;
+ struct pico_ipv4_hdr *hdr = (struct pico_ipv4_hdr *) f->net_hdr;
+ struct pico_ipv4_link *l;
+ if (!hdr)
+ return NULL;
+
+ l = pico_ipv4_link_get(&hdr->dst);
+ if(l) {
+ /* address belongs to ourself */
+ return &l->dev->eth->mac;
+ }
+
+ gateway = pico_ipv4_route_get_gateway(&hdr->dst);
+ /* check if dst is local (gateway = 0), or if to use gateway */
+ if (gateway.addr != 0)
+ where = &gateway;
+ else
+ where = &hdr->dst;
+
+ a4 = pico_arp_lookup(where); /* check if dst ip mac in cache */
+
+ if (!a4)
+ pico_arp_retry(f, where);
+
+ return a4;
+}
+
+
+void pico_arp_postpone(struct pico_frame *f)
+{
+ int i;
+ for (i = 0; i < PICO_ARP_MAX_PENDING; i++)
+ {
+ if (!frames_queued[i]) {
+ frames_queued[i] = pico_frame_copy(f);
+ return;
+ }
+ }
+ /* Not possible to enqueue: caller will discard packet */
+}
+
+
+#ifdef DEBUG_ARP
+void dbg_arp(void)
+{
+ struct pico_arp *a;
+ struct pico_tree_node *index;
+
+ pico_tree_foreach(index, &arp_tree) {
+ a = index->keyValue;
+ arp_dbg("ARP to %08x, mac: %02x:%02x:%02x:%02x:%02x:%02x\n", a->ipv4.addr, a->eth.addr[0], a->eth.addr[1], a->eth.addr[2], a->eth.addr[3], a->eth.addr[4], a->eth.addr[5] );
+ }
+}
+#endif
+
+static void arp_expire(pico_time now, void *_stale)
+{
+ struct pico_arp *stale = (struct pico_arp *) _stale;
+ if (now >= (stale->timestamp + PICO_ARP_TIMEOUT)) {
+ stale->arp_status = PICO_ARP_STATUS_STALE;
+ arp_dbg("ARP: Setting arp_status to STALE\n");
+ pico_arp_request(stale->dev, &stale->ipv4, PICO_ARP_QUERY);
+ } else {
+ /* Timer must be rescheduled, ARP entry has been renewed lately.
+ * No action required to refresh the entry, will check on the next timeout */
+ pico_timer_add(PICO_ARP_TIMEOUT + stale->timestamp - now, arp_expire, stale);
+ }
+}
+
+static void pico_arp_add_entry(struct pico_arp *entry)
+{
+ entry->arp_status = PICO_ARP_STATUS_REACHABLE;
+ entry->timestamp = PICO_TIME();
+
+ pico_tree_insert(&arp_tree, entry);
+ arp_dbg("ARP ## reachable.\n");
+ pico_arp_queued_trigger();
+ pico_timer_add(PICO_ARP_TIMEOUT, arp_expire, entry);
+}
+
+int pico_arp_create_entry(uint8_t *hwaddr, struct pico_ip4 ipv4, struct pico_device *dev)
+{
+ struct pico_arp*arp = PICO_ZALLOC(sizeof(struct pico_arp));
+ if(!arp) {
+ pico_err = PICO_ERR_ENOMEM;
+ return -1;
+ }
+
+ memcpy(arp->eth.addr, hwaddr, 6);
+ arp->ipv4.addr = ipv4.addr;
+ arp->dev = dev;
+
+ pico_arp_add_entry(arp);
+
+ return 0;
+}
+
+static void pico_arp_check_conflict(struct pico_arp_hdr *hdr)
+{
+
+ if ((conflict_ipv4.conflict) &&
+ ((conflict_ipv4.ip.addr == hdr->src.addr) &&
+ (memcmp(hdr->s_mac, conflict_ipv4.mac.addr, PICO_SIZE_ETH) != 0)))
+ conflict_ipv4.conflict();
+}
+
+static struct pico_arp *pico_arp_lookup_entry(struct pico_frame *f)
+{
+ struct pico_arp search;
+ struct pico_arp *found = NULL;
+ struct pico_arp_hdr *hdr = (struct pico_arp_hdr *) f->net_hdr;
+ /* Populate a new arp entry */
+ search.ipv4.addr = hdr->src.addr;
+
+ /* Search for already existing entry */
+ found = pico_tree_findKey(&arp_tree, &search);
+ if (found) {
+ if (found->arp_status == PICO_ARP_STATUS_STALE) {
+ /* Replace if stale */
+ pico_tree_delete(&arp_tree, found);
+ pico_arp_add_entry(found);
+ } else {
+ /* Update mac address */
+ memcpy(found->eth.addr, hdr->s_mac, PICO_SIZE_ETH);
+ arp_dbg("ARP entry updated!\n");
+
+ /* Refresh timestamp, this will force a reschedule on the next timeout*/
+ found->timestamp = PICO_TIME();
+ }
+ }
+
+ return found;
+}
+
+
+static int pico_arp_check_incoming_hdr_type(struct pico_arp_hdr *h)
+{
+ /* Check the hardware type and protocol */
+ if ((h->htype != PICO_ARP_HTYPE_ETH) || (h->ptype != PICO_IDETH_IPV4))
+ return -1;
+
+ return 0;
+}
+
+static int pico_arp_check_incoming_hdr(struct pico_frame *f, struct pico_ip4 *dst_addr)
+{
+ struct pico_arp_hdr *hdr = (struct pico_arp_hdr *) f->net_hdr;
+ if (!hdr)
+ return -1;
+
+ dst_addr->addr = hdr->dst.addr;
+ if (pico_arp_check_incoming_hdr_type(hdr) < 0)
+ return -1;
+
+ /* The source mac address must not be a multicast or broadcast address */
+ if (hdr->s_mac[0] & 0x01)
+ return -1;
+
+ return 0;
+}
+
+static void pico_arp_reply_on_request(struct pico_frame *f, struct pico_ip4 me)
+{
+ struct pico_arp_hdr *hdr;
+ struct pico_eth_hdr *eh;
+
+ hdr = (struct pico_arp_hdr *) f->net_hdr;
+ eh = (struct pico_eth_hdr *)f->datalink_hdr;
+ if (hdr->opcode != PICO_ARP_REQUEST)
+ return;
+
+ hdr->opcode = PICO_ARP_REPLY;
+ memcpy(hdr->d_mac, hdr->s_mac, PICO_SIZE_ETH);
+ memcpy(hdr->s_mac, f->dev->eth->mac.addr, PICO_SIZE_ETH);
+ hdr->dst.addr = hdr->src.addr;
+ hdr->src.addr = me.addr;
+
+ /* Prepare eth header for arp reply */
+ memcpy(eh->daddr, eh->saddr, PICO_SIZE_ETH);
+ memcpy(eh->saddr, f->dev->eth->mac.addr, PICO_SIZE_ETH);
+ f->start = f->datalink_hdr;
+ f->len = PICO_SIZE_ETHHDR + PICO_SIZE_ARPHDR;
+ f->dev->send(f->dev, f->start, (int)f->len);
+}
+
+static int pico_arp_check_flooding(struct pico_frame *f, struct pico_ip4 me)
+{
+ struct pico_device *link_dev;
+ struct pico_arp_hdr *hdr;
+ hdr = (struct pico_arp_hdr *) f->net_hdr;
+
+ /* Prevent ARP flooding */
+ link_dev = pico_ipv4_link_find(&me);
+ if ((link_dev == f->dev) && (hdr->opcode == PICO_ARP_REQUEST)) {
+ if (max_arp_reqs == 0)
+ return -1;
+ else
+ max_arp_reqs--;
+ }
+
+ /* Check if we are the target IP address */
+ if (link_dev != f->dev)
+ return -1;
+
+ return 0;
+}
+
+static int pico_arp_process_in(struct pico_frame *f, struct pico_arp_hdr *hdr, struct pico_arp *found)
+{
+ struct pico_ip4 me;
+ if (pico_arp_check_incoming_hdr(f, &me) < 0) {
+ pico_frame_discard(f);
+ return -1;
+ }
+
+ if (pico_arp_check_flooding(f, me) < 0) {
+ pico_frame_discard(f);
+ return -1;
+ }
+
+ /* If no existing entry was found, create a new entry, or fail trying. */
+ if ((!found) && (pico_arp_create_entry(hdr->s_mac, hdr->src, f->dev) < 0)) {
+ pico_frame_discard(f);
+ return -1;
+ }
+
+ /* If the packet is a request, send a reply */
+ pico_arp_reply_on_request(f, me);
+
+#ifdef DEBUG_ARP
+ dbg_arp();
+#endif
+ pico_frame_discard(f);
+ return 0;
+}
+
+int pico_arp_receive(struct pico_frame *f)
+{
+ struct pico_arp_hdr *hdr;
+ struct pico_arp *found = NULL;
+
+ hdr = (struct pico_arp_hdr *) f->net_hdr;
+ if (!hdr)
+ return -1;
+
+ pico_arp_check_conflict(hdr);
+ found = pico_arp_lookup_entry(f);
+ return pico_arp_process_in(f, hdr, found);
+
+}
+
+static int32_t pico_arp_request_xmit(struct pico_device *dev, struct pico_frame *f, struct pico_ip4 *src, struct pico_ip4 *dst, uint8_t type)
+{
+ struct pico_arp_hdr *ah = (struct pico_arp_hdr *) (f->start + PICO_SIZE_ETHHDR);
+ int ret;
+
+ /* Fill arp header */
+ ah->htype = PICO_ARP_HTYPE_ETH;
+ ah->ptype = PICO_IDETH_IPV4;
+ ah->hsize = PICO_SIZE_ETH;
+ ah->psize = PICO_SIZE_IP4;
+ ah->opcode = PICO_ARP_REQUEST;
+ memcpy(ah->s_mac, dev->eth->mac.addr, PICO_SIZE_ETH);
+
+ switch (type) {
+ case PICO_ARP_ANNOUNCE:
+ ah->src.addr = dst->addr;
+ ah->dst.addr = dst->addr;
+ break;
+ case PICO_ARP_PROBE:
+ ah->src.addr = 0;
+ ah->dst.addr = dst->addr;
+ break;
+ case PICO_ARP_QUERY:
+ ah->src.addr = src->addr;
+ ah->dst.addr = dst->addr;
+ break;
+ default:
+ pico_frame_discard(f);
+ return -1;
+ }
+ arp_dbg("Sending arp request.\n");
+ ret = dev->send(dev, f->start, (int) f->len);
+ pico_frame_discard(f);
+ return ret;
+}
+
+int32_t pico_arp_request(struct pico_device *dev, struct pico_ip4 *dst, uint8_t type)
+{
+ struct pico_frame *q = pico_frame_alloc(PICO_SIZE_ETHHDR + PICO_SIZE_ARPHDR);
+ struct pico_eth_hdr *eh;
+ struct pico_ip4 *src = NULL;
+
+ if (!q)
+ return -1;
+
+ if (type == PICO_ARP_QUERY)
+ {
+ src = pico_ipv4_source_find(dst);
+ if (!src) {
+ pico_frame_discard(q);
+ return -1;
+ }
+ }
+
+ arp_dbg("QUERY: %08x\n", dst->addr);
+
+ eh = (struct pico_eth_hdr *)q->start;
+
+ /* Fill eth header */
+ memcpy(eh->saddr, dev->eth->mac.addr, PICO_SIZE_ETH);
+ memcpy(eh->daddr, PICO_ETHADDR_ALL, PICO_SIZE_ETH);
+ eh->proto = PICO_IDETH_ARP;
+
+ return pico_arp_request_xmit(dev, q, src, dst, type);
+}
+
+int pico_arp_get_neighbors(struct pico_device *dev, struct pico_ip4 *neighbors, int maxlen)
+{
+ struct pico_arp*search;
+ struct pico_tree_node *index;
+ int i = 0;
+ pico_tree_foreach(index, &arp_tree){
+ search = index->keyValue;
+ if (search->dev == dev) {
+ neighbors[i++].addr = search->ipv4.addr;
+ if (i >= maxlen)
+ return i;
+ }
+ }
+ return i;
+}
+
+void pico_arp_register_ipconflict(struct pico_ip4 *ip, struct pico_eth *mac, void (*cb)(void))
+{
+ conflict_ipv4.conflict = cb;
+ conflict_ipv4.ip.addr = ip->addr;
+ if (mac != NULL)
+ memcpy(conflict_ipv4.mac.addr, mac, 6);
+}
+
diff --git a/net/picotcp/modules/pico_arp.h b/net/picotcp/modules/pico_arp.h
new file mode 100644
index 0000000..18e1f69
--- /dev/null
+++ b/net/picotcp/modules/pico_arp.h
@@ -0,0 +1,32 @@
+/*********************************************************************
+ PicoTCP. Copyright (c) 2012-2015 Altran Intelligent Systems. Some rights reserved.
+ See LICENSE and COPYING for usage.
+
+ *********************************************************************/
+#ifndef INCLUDE_PICO_ARP
+#define INCLUDE_PICO_ARP
+#include "pico_eth.h"
+#include "pico_device.h"
+
+int pico_arp_receive(struct pico_frame *);
+
+
+struct pico_eth *pico_arp_get(struct pico_frame *f);
+int32_t pico_arp_request(struct pico_device *dev, struct pico_ip4 *dst, uint8_t type);
+
+#define PICO_ARP_STATUS_REACHABLE 0x00
+#define PICO_ARP_STATUS_PERMANENT 0x01
+#define PICO_ARP_STATUS_STALE 0x02
+
+#define PICO_ARP_QUERY 0x00
+#define PICO_ARP_PROBE 0x01
+#define PICO_ARP_ANNOUNCE 0x02
+
+struct pico_eth *pico_arp_lookup(struct pico_ip4 *dst);
+struct pico_ip4 *pico_arp_reverse_lookup(struct pico_eth *dst);
+int pico_arp_create_entry(uint8_t*hwaddr, struct pico_ip4 ipv4, struct pico_device*dev);
+int pico_arp_get_neighbors(struct pico_device *dev, struct pico_ip4 *neighbors, int maxlen);
+void pico_arp_register_ipconflict(struct pico_ip4 *ip, struct pico_eth *mac, void (*cb)(void));
+void pico_arp_postpone(struct pico_frame *f);
+void pico_arp_init(void);
+#endif
diff --git a/net/picotcp/modules/pico_dev_loop.c b/net/picotcp/modules/pico_dev_loop.c
new file mode 100644
index 0000000..4416d0b
--- /dev/null
+++ b/net/picotcp/modules/pico_dev_loop.c
@@ -0,0 +1,66 @@
+/*********************************************************************
+ PicoTCP. Copyright (c) 2012-2015 Altran Intelligent Systems. Some rights reserved.
+ See LICENSE and COPYING for usage.
+
+ Authors: Daniele Lacamera
+ *********************************************************************/
+
+
+#include "pico_device.h"
+#include "pico_dev_loop.h"
+#include "pico_stack.h"
+
+
+#define LOOP_MTU 1500
+static uint8_t l_buf[LOOP_MTU];
+static int l_bufsize = 0;
+
+
+static int pico_loop_send(struct pico_device *dev, void *buf, int len)
+{
+ IGNORE_PARAMETER(dev);
+ if (len > LOOP_MTU)
+ return 0;
+
+ if (l_bufsize == 0) {
+ memcpy(l_buf, buf, (size_t)len);
+ l_bufsize += len;
+ return len;
+ }
+
+ return 0;
+}
+
+static int pico_loop_poll(struct pico_device *dev, int loop_score)
+{
+ if (loop_score <= 0)
+ return 0;
+
+ if (l_bufsize > 0) {
+ pico_stack_recv(dev, l_buf, (uint32_t)l_bufsize);
+ l_bufsize = 0;
+ loop_score--;
+ }
+
+ return loop_score;
+}
+
+
+struct pico_device *pico_loop_create(void)
+{
+ struct pico_device *loop = PICO_ZALLOC(sizeof(struct pico_device));
+ if (!loop)
+ return NULL;
+
+ if( 0 != pico_device_init(loop, "loop", NULL)) {
+ dbg ("Loop init failed.\n");
+ pico_device_destroy(loop);
+ return NULL;
+ }
+
+ loop->send = pico_loop_send;
+ loop->poll = pico_loop_poll;
+ dbg("Device %s created.\n", loop->name);
+ return loop;
+}
+
diff --git a/net/picotcp/modules/pico_dev_loop.h b/net/picotcp/modules/pico_dev_loop.h
new file mode 100644
index 0000000..6cb8de1
--- /dev/null
+++ b/net/picotcp/modules/pico_dev_loop.h
@@ -0,0 +1,15 @@
+/*********************************************************************
+ PicoTCP. Copyright (c) 2012-2015 Altran Intelligent Systems. Some rights reserved.
+ See LICENSE and COPYING for usage.
+
+ *********************************************************************/
+#ifndef INCLUDE_PICO_LOOP
+#define INCLUDE_PICO_LOOP
+#include "pico_config.h"
+#include "pico_device.h"
+
+void pico_loop_destroy(struct pico_device *loop);
+struct pico_device *pico_loop_create(void);
+
+#endif
+
diff --git a/net/picotcp/modules/pico_dev_mock.h b/net/picotcp/modules/pico_dev_mock.h
new file mode 100644
index 0000000..dfc2cfc
--- /dev/null
+++ b/net/picotcp/modules/pico_dev_mock.h
@@ -0,0 +1,47 @@
+/*********************************************************************
+ PicoTCP. Copyright (c) 2012-2015 Altran Intelligent Systems. Some rights reserved.
+ See LICENSE and COPYING for usage.
+
+ *********************************************************************/
+#ifndef INCLUDE_PICO_MOCK
+#define INCLUDE_PICO_MOCK
+#include "pico_config.h"
+#include "pico_device.h"
+
+
+struct mock_frame {
+ uint8_t*buffer;
+ int len;
+ int read;
+
+ struct mock_frame*next;
+};
+
+struct mock_device {
+ struct pico_device*dev;
+ struct mock_frame*in_head;
+ struct mock_frame*in_tail;
+ struct mock_frame*out_head;
+ struct mock_frame*out_tail;
+
+ uint8_t*mac;
+
+};
+
+struct mock_device;
+/* A mockup-device for the purpose of testing. It provides a couple of extra "network"-functions, which represent the network-side of the device. A network_send will result in mock_poll reading something, a network_read will see if the stack has sent anything through our mock-device. */
+void pico_mock_destroy(struct pico_device *dev);
+struct mock_device *pico_mock_create(uint8_t*mac);
+
+int pico_mock_network_read(struct mock_device*mock, void *buf, int len);
+int pico_mock_network_write(struct mock_device*mock, const void *buf, int len);
+
+/* TODO */
+/* we could use a few checking functions, e.g. one to see if it's a valid IP packet, if it's TCP, if the IP-address matches,... */
+/* That would be useful to avoid having to manually create buffers of what you expect, probably with masks for things that are random,... */
+uint32_t mock_get_sender_ip4(struct mock_device*mock, void*buf, int len);
+
+int mock_ip_protocol(struct mock_device*mock, void*buf, int len);
+int mock_icmp_type(struct mock_device*mock, void*buf, int len);
+int mock_icmp_code(struct mock_device*mock, void*buf, int len);
+#endif
diff --git a/net/picotcp/modules/pico_dev_null.c b/net/picotcp/modules/pico_dev_null.c
new file mode 100644
index 0000000..5fed494
--- /dev/null
+++ b/net/picotcp/modules/pico_dev_null.c
@@ -0,0 +1,60 @@
+/*********************************************************************
+ PicoTCP. Copyright (c) 2012-2015 Altran Intelligent Systems. Some rights reserved.
+ See LICENSE and COPYING for usage.
+
+ Authors: Daniele Lacamera
+ *********************************************************************/
+
+
+#include "pico_device.h"
+#include "pico_dev_null.h"
+#include "pico_stack.h"
+
+struct pico_device_null {
+ struct pico_device dev;
+ int statistics_frames_out;
+};
+
+#define NULL_MTU 0
+
+static int pico_null_send(struct pico_device *dev, void *buf, int len)
+{
+ struct pico_device_null *null = (struct pico_device_null *) dev;
+ IGNORE_PARAMETER(buf);
+
+ /* Increase the statistic count */
+ null->statistics_frames_out++;
+
+ /* Discard the frame content silently. */
+ return len;
+}
+
+static int pico_null_poll(struct pico_device *dev, int loop_score)
+{
+ /* We never have packet to receive, no score is used. */
+ IGNORE_PARAMETER(dev);
+ return loop_score;
+}
+
+/* Public interface: create/destroy. */
+
+
+struct pico_device *pico_null_create(char *name)
+{
+ struct pico_device_null *null = PICO_ZALLOC(sizeof(struct pico_device_null));
+
+ if (!null)
+ return NULL;
+
+ if( 0 != pico_device_init((struct pico_device *)null, name, NULL)) {
+ return NULL;
+ }
+
+ null->dev.overhead = 0;
+ null->statistics_frames_out = 0;
+ null->dev.send = pico_null_send;
+ null->dev.poll = pico_null_poll;
+ dbg("Device %s created.\n", null->dev.name);
+ return (struct pico_device *)null;
+}
+
diff --git a/net/picotcp/modules/pico_dev_null.h b/net/picotcp/modules/pico_dev_null.h
new file mode 100644
index 0000000..a0eb98e
--- /dev/null
+++ b/net/picotcp/modules/pico_dev_null.h
@@ -0,0 +1,15 @@
+/*********************************************************************
+ PicoTCP. Copyright (c) 2012-2015 Altran Intelligent Systems. Some rights reserved.
+ See LICENSE and COPYING for usage.
+
+ *********************************************************************/
+#ifndef INCLUDE_PICO_NULL
+#define INCLUDE_PICO_NULL
+#include "pico_config.h"
+#include "pico_device.h"
+
+void pico_null_destroy(struct pico_device *null);
+struct pico_device *pico_null_create(char *name);
+
+#endif
+
diff --git a/net/picotcp/modules/pico_dhcp_client.c b/net/picotcp/modules/pico_dhcp_client.c
new file mode 100644
index 0000000..7f8df7f
--- /dev/null
+++ b/net/picotcp/modules/pico_dhcp_client.c
@@ -0,0 +1,960 @@
+/*********************************************************************
+ PicoTCP. Copyright (c) 2012-2015 Altran Intelligent Systems. Some rights reserved.
+ See LICENSE and COPYING for usage.
+
+ Authors: Kristof Roelants, Frederik Van Slycken
+ *********************************************************************/
+
+
+#include "pico_dhcp_client.h"
+#include "pico_stack.h"
+#include "pico_config.h"
+#include "pico_device.h"
+#include "pico_ipv4.h"
+#include "pico_socket.h"
+#include "pico_eth.h"
+
+#if (defined PICO_SUPPORT_DHCPC && defined PICO_SUPPORT_UDP)
+#define dhcpc_dbg(...) do {} while(0)
+/* #define dhcpc_dbg dbg */
+
+/* timer values */
+#define DHCP_CLIENT_REINIT 6000 /* msec */
+#define DHCP_CLIENT_RETRANS 4 /* sec */
+#define DHCP_CLIENT_RETRIES 3
+
+#define DHCP_CLIENT_TIMER_STOPPED 0
+#define DHCP_CLIENT_TIMER_STARTED 1
+
+/* maximum size of a DHCP message */
+#define DHCP_CLIENT_MAXMSGZISE (PICO_IP_MRU - PICO_SIZE_IP4HDR)
+
+enum dhcp_client_state {
+ DHCP_CLIENT_STATE_INIT_REBOOT = 0,
+ DHCP_CLIENT_STATE_REBOOTING,
+ DHCP_CLIENT_STATE_INIT,
+ DHCP_CLIENT_STATE_SELECTING,
+ DHCP_CLIENT_STATE_REQUESTING,
+ DHCP_CLIENT_STATE_BOUND,
+ DHCP_CLIENT_STATE_RENEWING,
+ DHCP_CLIENT_STATE_REBINDING
+};
+
+
+#define PICO_DHCPC_TIMER_INIT 0
+#define PICO_DHCPC_TIMER_REQUEST 1
+#define PICO_DHCPC_TIMER_RENEW 2
+#define PICO_DHCPC_TIMER_REBIND 3
+#define PICO_DHCPC_TIMER_T1 4
+#define PICO_DHCPC_TIMER_T2 5
+#define PICO_DHCPC_TIMER_LEASE 6
+#define PICO_DHCPC_TIMER_ARRAY_SIZE 7
+
+struct dhcp_client_timer
+{
+ uint8_t state;
+ unsigned int type;
+ uint32_t xid;
+};
+
+struct pico_dhcp_client_cookie
+{
+ uint8_t event;
+ uint8_t retry;
+ uint32_t xid;
+ uint32_t *uid;
+ enum dhcp_client_state state;
+ void (*cb)(void*dhcpc, int code);
+ pico_time init_timestamp;
+ struct pico_socket *s;
+ struct pico_ip4 address;
+ struct pico_ip4 netmask;
+ struct pico_ip4 gateway;
+ struct pico_ip4 nameserver[2];
+ struct pico_ip4 server_id;
+ struct pico_device *dev;
+ struct dhcp_client_timer *timer[PICO_DHCPC_TIMER_ARRAY_SIZE];
+ uint32_t t1_time;
+ uint32_t t2_time;
+ uint32_t lease_time;
+ uint32_t renew_time;
+ uint32_t rebind_time;
+};
+
+static int pico_dhcp_client_init(struct pico_dhcp_client_cookie *dhcpc);
+static int reset(struct pico_dhcp_client_cookie *dhcpc, uint8_t *buf);
+static int8_t pico_dhcp_client_msg(struct pico_dhcp_client_cookie *dhcpc, uint8_t msg_type);
+static void pico_dhcp_client_wakeup(uint16_t ev, struct pico_socket *s);
+static void pico_dhcp_state_machine(uint8_t event, struct pico_dhcp_client_cookie *dhcpc, uint8_t *buf);
+
+static const struct pico_ip4 bcast = {
+ .addr = 0xFFFFFFFF
+};
+
+static const struct pico_ip4 bcast_netmask = {
+ .addr = 0xFFFFFFFF
+};
+
+static struct pico_ip4 inaddr_any = {
+ 0
+};
+
+
+static int dhcp_cookies_cmp(void *ka, void *kb)
+{
+ struct pico_dhcp_client_cookie *a = ka, *b = kb;
+ if (a->xid == b->xid)
+ return 0;
+
+ return (a->xid < b->xid) ? (-1) : (1);
+}
+PICO_TREE_DECLARE(DHCPCookies, dhcp_cookies_cmp);
+
+static struct pico_dhcp_client_cookie *pico_dhcp_client_add_cookie(uint32_t xid, struct pico_device *dev, void (*cb)(void *dhcpc, int code), uint32_t *uid)
+{
+ struct pico_dhcp_client_cookie *dhcpc = NULL, *found = NULL, test = {
+ 0
+ };
+
+ test.xid = xid;
+ found = pico_tree_findKey(&DHCPCookies, &test);
+ if (found) {
+ pico_err = PICO_ERR_EAGAIN;
+ return NULL;
+ }
+
+ dhcpc = PICO_ZALLOC(sizeof(struct pico_dhcp_client_cookie));
+ if (!dhcpc) {
+ pico_err = PICO_ERR_ENOMEM;
+ return NULL;
+ }
+
+ dhcpc->state = DHCP_CLIENT_STATE_INIT;
+ dhcpc->xid = xid;
+ dhcpc->uid = uid;
+ *(dhcpc->uid) = 0;
+ dhcpc->cb = cb;
+ dhcpc->dev = dev;
+
+ pico_tree_insert(&DHCPCookies, dhcpc);
+ return dhcpc;
+}
+
+static void pico_dhcp_client_stop_timers(struct pico_dhcp_client_cookie *dhcpc);
+static int pico_dhcp_client_del_cookie(uint32_t xid)
+{
+ struct pico_dhcp_client_cookie test = {
+ 0
+ }, *found = NULL;
+
+ test.xid = xid;
+ found = pico_tree_findKey(&DHCPCookies, &test);
+ if (!found)
+ return -1;
+
+ pico_dhcp_client_stop_timers(found);
+ pico_socket_close(found->s);
+ found->s = NULL;
+ pico_ipv4_link_del(found->dev, found->address);
+ pico_tree_delete(&DHCPCookies, found);
+ PICO_FREE(found);
+ return 0;
+}
+
+static struct pico_dhcp_client_cookie *pico_dhcp_client_find_cookie(uint32_t xid)
+{
+ struct pico_dhcp_client_cookie test = {
+ 0
+ }, *found = NULL;
+
+ test.xid = xid;
+ found = pico_tree_findKey(&DHCPCookies, &test);
+ if (found)
+ return found;
+ else
+ return NULL;
+}
+
+static void pico_dhcp_client_timer_handler(pico_time now, void *arg);
+static void pico_dhcp_client_reinit(pico_time now, void *arg);
+static struct dhcp_client_timer *pico_dhcp_timer_add(uint8_t type, uint32_t time, struct pico_dhcp_client_cookie *ck)
+{
+ struct dhcp_client_timer *t;
+
+ t = PICO_ZALLOC(sizeof(struct dhcp_client_timer));
+ if (!t)
+ return NULL;
+
+ t->state = DHCP_CLIENT_TIMER_STARTED;
+ t->xid = ck->xid;
+ t->type = type;
+ pico_timer_add(time, pico_dhcp_client_timer_handler, t);
+ if (ck->timer[type]) {
+ ck->timer[type]->state = DHCP_CLIENT_TIMER_STOPPED;
+ }
+
+ ck->timer[type] = t;
+ return t;
+}
+
+static int dhcp_get_timer_event(struct pico_dhcp_client_cookie *dhcpc, unsigned int type)
+{
+ const int events[PICO_DHCPC_TIMER_ARRAY_SIZE] =
+ {
+ PICO_DHCP_EVENT_RETRANSMIT,
+ PICO_DHCP_EVENT_RETRANSMIT,
+ PICO_DHCP_EVENT_RETRANSMIT,
+ PICO_DHCP_EVENT_RETRANSMIT,
+ PICO_DHCP_EVENT_T1,
+ PICO_DHCP_EVENT_T2,
+ PICO_DHCP_EVENT_LEASE
+ };
+
+ if (type == PICO_DHCPC_TIMER_REQUEST) {
+ if (++dhcpc->retry > DHCP_CLIENT_RETRIES) {
+ reset(dhcpc, NULL);
+ return PICO_DHCP_EVENT_NONE;
+ }
+ } else if (type < PICO_DHCPC_TIMER_T1) {
+ dhcpc->retry++;
+ }
+
+ return events[type];
+}
+
+static void pico_dhcp_client_timer_handler(pico_time now, void *arg)
+{
+ struct dhcp_client_timer *t = (struct dhcp_client_timer *)arg;
+ struct pico_dhcp_client_cookie *dhcpc;
+
+ if (!t)
+ return;
+
+ (void) now;
+ if (t->state != DHCP_CLIENT_TIMER_STOPPED) {
+ dhcpc = pico_dhcp_client_find_cookie(t->xid);
+ if (dhcpc && dhcpc->timer) {
+ t->state = DHCP_CLIENT_TIMER_STOPPED;
+ if ((t->type == PICO_DHCPC_TIMER_INIT) && (dhcpc->state < DHCP_CLIENT_STATE_SELECTING)) {
+ pico_dhcp_client_reinit(now, dhcpc);
+ } else if (t->type != PICO_DHCPC_TIMER_INIT) {
+ dhcpc->event = (uint8_t)dhcp_get_timer_event(dhcpc, t->type);
+ if (dhcpc->event != PICO_DHCP_EVENT_NONE)
+ pico_dhcp_state_machine(dhcpc->event, dhcpc, NULL);
+ }
+ }
+ }
+}
+
+static void pico_dhcp_client_timer_stop(struct pico_dhcp_client_cookie *dhcpc, int type)
+{
+ if (dhcpc->timer[type]) {
+ dhcpc->timer[type]->state = DHCP_CLIENT_TIMER_STOPPED;
+ }
+
+}
+
+
+static void pico_dhcp_client_reinit(pico_time now, void *arg)
+{
+ struct pico_dhcp_client_cookie *dhcpc = (struct pico_dhcp_client_cookie *)arg;
+ (void) now;
+
+ if (dhcpc->s) {
+ pico_socket_close(dhcpc->s);
+ dhcpc->s = NULL;
+ }
+
+ if (++dhcpc->retry > DHCP_CLIENT_RETRIES) {
+ pico_err = PICO_ERR_EAGAIN;
+ if (dhcpc->cb)
+ dhcpc->cb(dhcpc, PICO_DHCP_ERROR);
+
+ pico_dhcp_client_del_cookie(dhcpc->xid);
+ return;
+ }
+
+ pico_dhcp_client_init(dhcpc);
+ return;
+}
+
+
+static void pico_dhcp_client_stop_timers(struct pico_dhcp_client_cookie *dhcpc)
+{
+ int i;
+ dhcpc->retry = 0;
+ for (i = 0; i < PICO_DHCPC_TIMER_ARRAY_SIZE; i++)
+ pico_dhcp_client_timer_stop(dhcpc, i);
+}
+
+static void pico_dhcp_client_start_init_timer(struct pico_dhcp_client_cookie *dhcpc)
+{
+ uint32_t time = 0;
+ /* timer value is doubled with every retry (exponential backoff) */
+ time = (uint32_t) (DHCP_CLIENT_RETRANS << dhcpc->retry);
+ pico_dhcp_timer_add(PICO_DHCPC_TIMER_INIT, time * 1000, dhcpc);
+}
+
+static void pico_dhcp_client_start_requesting_timer(struct pico_dhcp_client_cookie *dhcpc)
+{
+ uint32_t time = 0;
+
+ /* timer value is doubled with every retry (exponential backoff) */
+ time = (uint32_t)(DHCP_CLIENT_RETRANS << dhcpc->retry);
+ pico_dhcp_timer_add(PICO_DHCPC_TIMER_REQUEST, time * 1000, dhcpc);
+}
+
+static void pico_dhcp_client_start_renewing_timer(struct pico_dhcp_client_cookie *dhcpc)
+{
+ uint32_t halftime = 0;
+
+ /* wait one-half of the remaining time until T2, down to a minimum of 60 seconds */
+ /* (dhcpc->retry + 1): initial -> divide by 2, 1st retry -> divide by 4, 2nd retry -> divide by 8, etc */
+ pico_dhcp_client_stop_timers(dhcpc);
+ halftime = dhcpc->renew_time >> (dhcpc->retry + 1);
+ if (halftime < 60)
+ halftime = 60;
+
+ pico_dhcp_timer_add(PICO_DHCPC_TIMER_RENEW, halftime * 1000, dhcpc);
+
+ return;
+}
+
+static void pico_dhcp_client_start_rebinding_timer(struct pico_dhcp_client_cookie *dhcpc)
+{
+ uint32_t halftime = 0;
+
+ pico_dhcp_client_stop_timers(dhcpc);
+ halftime = dhcpc->rebind_time >> (dhcpc->retry + 1);
+ if (halftime < 60)
+ halftime = 60;
+
+ pico_dhcp_timer_add(PICO_DHCPC_TIMER_REBIND, halftime * 1000, dhcpc);
+
+ return;
+}
+
+static void pico_dhcp_client_start_reacquisition_timers(struct pico_dhcp_client_cookie *dhcpc)
+{
+
+ pico_dhcp_client_stop_timers(dhcpc);
+ pico_dhcp_timer_add(PICO_DHCPC_TIMER_T1, dhcpc->t1_time * 1000, dhcpc);
+ pico_dhcp_timer_add(PICO_DHCPC_TIMER_T2, dhcpc->t2_time * 1000, dhcpc);
+ pico_dhcp_timer_add(PICO_DHCPC_TIMER_LEASE, dhcpc->lease_time * 1000, dhcpc);
+}
+
+static int pico_dhcp_client_init(struct pico_dhcp_client_cookie *dhcpc)
+{
+ uint16_t port = PICO_DHCP_CLIENT_PORT;
+ if (!dhcpc)
+ return -1;
+
+ /* adding a link with address 0.0.0.0 and netmask 0.0.0.0,
+ * automatically adds a route for a global broadcast */
+ pico_ipv4_link_add(dhcpc->dev, inaddr_any, bcast_netmask);
+ if (!dhcpc->s)
+ dhcpc->s = pico_socket_open(PICO_PROTO_IPV4, PICO_PROTO_UDP, &pico_dhcp_client_wakeup);
+
+ if (!dhcpc->s) {
+ pico_dhcp_timer_add(PICO_DHCPC_TIMER_INIT, DHCP_CLIENT_REINIT, dhcpc);
+ return 0;
+ }
+
+ dhcpc->s->dev = dhcpc->dev;
+ if (pico_socket_bind(dhcpc->s, &inaddr_any, &port) < 0) {
+ pico_socket_close(dhcpc->s);
+ dhcpc->s = NULL;
+ pico_dhcp_timer_add(PICO_DHCPC_TIMER_INIT, DHCP_CLIENT_REINIT, dhcpc);
+ return 0;
+ }
+
+ if (pico_dhcp_client_msg(dhcpc, PICO_DHCP_MSG_DISCOVER) < 0) {
+ pico_socket_close(dhcpc->s);
+ dhcpc->s = NULL;
+ pico_dhcp_timer_add(PICO_DHCPC_TIMER_INIT, DHCP_CLIENT_REINIT, dhcpc);
+ return 0;
+ }
+
+ dhcpc->retry = 0;
+ dhcpc->init_timestamp = PICO_TIME_MS();
+ pico_dhcp_client_start_init_timer(dhcpc);
+ return 0;
+}
+
+int pico_dhcp_initiate_negotiation(struct pico_device *dev, void (*cb)(void *dhcpc, int code), uint32_t *uid)
+{
+ uint8_t retry = 32;
+ uint32_t xid = 0;
+ struct pico_dhcp_client_cookie *dhcpc = NULL;
+
+ if (!dev || !cb || !uid) {
+ pico_err = PICO_ERR_EINVAL;
+ return -1;
+ }
+
+ if (!dev->eth) {
+ pico_err = PICO_ERR_EOPNOTSUPP;
+ return -1;
+ }
+
+ /* attempt to generate a correct xid, else fail */
+ do {
+ xid = pico_rand();
+ } while (!xid && --retry);
+
+ if (!xid) {
+ pico_err = PICO_ERR_EAGAIN;
+ return -1;
+ }
+
+ dhcpc = pico_dhcp_client_add_cookie(xid, dev, cb, uid);
+ if (!dhcpc)
+ return -1;
+
+ dhcpc_dbg("DHCP client: cookie with xid %u\n", dhcpc->xid);
+ *uid = xid;
+ return pico_dhcp_client_init(dhcpc);
+}
+
+static void pico_dhcp_client_recv_params(struct pico_dhcp_client_cookie *dhcpc, struct pico_dhcp_opt *opt)
+{
+ do {
+ switch (opt->code)
+ {
+ case PICO_DHCP_OPT_PAD:
+ break;
+
+ case PICO_DHCP_OPT_END:
+ break;
+
+ case PICO_DHCP_OPT_MSGTYPE:
+ dhcpc->event = opt->ext.msg_type.type;
+ dhcpc_dbg("DHCP client: message type %u\n", dhcpc->event);
+ break;
+
+ case PICO_DHCP_OPT_LEASETIME:
+ dhcpc->lease_time = long_be(opt->ext.lease_time.time);
+ dhcpc_dbg("DHCP client: lease time %u\n", dhcpc->lease_time);
+ break;
+
+ case PICO_DHCP_OPT_RENEWALTIME:
+ dhcpc->t1_time = long_be(opt->ext.renewal_time.time);
+ dhcpc_dbg("DHCP client: renewal time %u\n", dhcpc->t1_time);
+ break;
+
+ case PICO_DHCP_OPT_REBINDINGTIME:
+ dhcpc->t2_time = long_be(opt->ext.rebinding_time.time);
+ dhcpc_dbg("DHCP client: rebinding time %u\n", dhcpc->t2_time);
+ break;
+
+ case PICO_DHCP_OPT_ROUTER:
+ dhcpc->gateway = opt->ext.router.ip;
+ dhcpc_dbg("DHCP client: router %08X\n", dhcpc->gateway.addr);
+ break;
+
+ case PICO_DHCP_OPT_DNS:
+ dhcpc->nameserver[0] = opt->ext.dns1.ip;
+ dhcpc_dbg("DHCP client: dns1 %08X\n", dhcpc->nameserver[0].addr);
+ if (opt->len >= 8) {
+ dhcpc->nameserver[1] = opt->ext.dns2.ip;
+ dhcpc_dbg("DHCP client: dns1 %08X\n", dhcpc->nameserver[1].addr);
+ }
+
+ break;
+
+ case PICO_DHCP_OPT_NETMASK:
+ dhcpc->netmask = opt->ext.netmask.ip;
+ dhcpc_dbg("DHCP client: netmask %08X\n", dhcpc->netmask.addr);
+ break;
+
+ case PICO_DHCP_OPT_SERVERID:
+ dhcpc->server_id = opt->ext.server_id.ip;
+ dhcpc_dbg("DHCP client: server ID %08X\n", dhcpc->server_id.addr);
+ break;
+
+ case PICO_DHCP_OPT_OPTOVERLOAD:
+ dhcpc_dbg("DHCP client: WARNING option overload present (not processed)");
+ break;
+
+ default:
+ dhcpc_dbg("DHCP client: WARNING unsupported option %u\n", opt->code);
+ break;
+ }
+ } while (pico_dhcp_next_option(&opt));
+
+ /* default values for T1 and T2 when not provided */
+ if (!dhcpc->t1_time)
+ dhcpc->t1_time = dhcpc->lease_time >> 1;
+
+ if (!dhcpc->t2_time)
+ dhcpc->t2_time = (dhcpc->lease_time * 875) / 1000;
+
+ return;
+}
+
+static int recv_offer(struct pico_dhcp_client_cookie *dhcpc, uint8_t *buf)
+{
+ struct pico_dhcp_hdr *hdr = (struct pico_dhcp_hdr *)buf;
+ struct pico_dhcp_opt *opt = (struct pico_dhcp_opt *)hdr->options;
+
+ pico_dhcp_client_recv_params(dhcpc, opt);
+ if ((dhcpc->event != PICO_DHCP_MSG_OFFER) || !dhcpc->server_id.addr || !dhcpc->netmask.addr || !dhcpc->lease_time)
+ return -1;
+
+ dhcpc->address.addr = hdr->yiaddr;
+
+ /* we skip state SELECTING, process first offer received */
+ dhcpc->state = DHCP_CLIENT_STATE_REQUESTING;
+ dhcpc->retry = 0;
+ pico_dhcp_client_msg(dhcpc, PICO_DHCP_MSG_REQUEST);
+ pico_dhcp_client_start_requesting_timer(dhcpc);
+ return 0;
+}
+
+static int recv_ack(struct pico_dhcp_client_cookie *dhcpc, uint8_t *buf)
+{
+ struct pico_dhcp_hdr *hdr = (struct pico_dhcp_hdr *)buf;
+ struct pico_dhcp_opt *opt = (struct pico_dhcp_opt *)hdr->options;
+ struct pico_ip4 address = {
+ 0
+ };
+ struct pico_ip4 any_address = {
+ 0
+ };
+
+ struct pico_ipv4_link *l;
+
+ pico_dhcp_client_recv_params(dhcpc, opt);
+ if ((dhcpc->event != PICO_DHCP_MSG_ACK) || !dhcpc->server_id.addr || !dhcpc->netmask.addr || !dhcpc->lease_time)
+ return -1;
+
+ /* Issue #20 the server can transmit on ACK a different IP than the one in OFFER */
+ /* RFC2131 ch 4.3.2 ... The client SHOULD use the parameters in the DHCPACK message for configuration */
+ if (dhcpc->state == DHCP_CLIENT_STATE_REQUESTING)
+ dhcpc->address.addr = hdr->yiaddr;
+
+
+ /* close the socket used for address (re)acquisition */
+ pico_socket_close(dhcpc->s);
+ dhcpc->s = NULL;
+
+ /* Delete all the links before adding the address */
+ pico_ipv4_link_del(dhcpc->dev, address);
+ l = pico_ipv4_link_by_dev(dhcpc->dev);
+ while(l) {
+ pico_ipv4_link_del(dhcpc->dev, l->address);
+ l = pico_ipv4_link_by_dev_next(dhcpc->dev, l);
+ }
+ pico_ipv4_link_add(dhcpc->dev, dhcpc->address, dhcpc->netmask);
+
+ dbg("DHCP client: renewal time (T1) %u\n", (unsigned int)dhcpc->t1_time);
+ dbg("DHCP client: rebinding time (T2) %u\n", (unsigned int)dhcpc->t2_time);
+ dbg("DHCP client: lease time %u\n", (unsigned int)dhcpc->lease_time);
+
+ /* If router option is received, use it as default gateway */
+ if (dhcpc->gateway.addr != 0U) {
+ pico_ipv4_route_add(any_address, any_address, dhcpc->gateway, 1, NULL);
+ }
+
+ dhcpc->retry = 0;
+ dhcpc->renew_time = dhcpc->t2_time - dhcpc->t1_time;
+ dhcpc->rebind_time = dhcpc->lease_time - dhcpc->t2_time;
+ pico_dhcp_client_start_reacquisition_timers(dhcpc);
+
+ *(dhcpc->uid) = dhcpc->xid;
+ if (dhcpc->cb)
+ dhcpc->cb(dhcpc, PICO_DHCP_SUCCESS);
+
+ dhcpc->state = DHCP_CLIENT_STATE_BOUND;
+ return 0;
+}
+
+static int renew(struct pico_dhcp_client_cookie *dhcpc, uint8_t *buf)
+{
+ uint16_t port = PICO_DHCP_CLIENT_PORT;
+ (void) buf;
+ dhcpc->state = DHCP_CLIENT_STATE_RENEWING;
+ dhcpc->s = pico_socket_open(PICO_PROTO_IPV4, PICO_PROTO_UDP, &pico_dhcp_client_wakeup);
+ if (!dhcpc->s) {
+ dhcpc_dbg("DHCP client ERROR: failure opening socket on renew, aborting DHCP! (%s)\n", strerror(pico_err));
+ if (dhcpc->cb)
+ dhcpc->cb(dhcpc, PICO_DHCP_ERROR);
+
+ return -1;
+ }
+
+ if (pico_socket_bind(dhcpc->s, &dhcpc->address, &port) != 0) {
+ dhcpc_dbg("DHCP client ERROR: failure binding socket on renew, aborting DHCP! (%s)\n", strerror(pico_err));
+ pico_socket_close(dhcpc->s);
+ dhcpc->s = NULL;
+ if (dhcpc->cb)
+ dhcpc->cb(dhcpc, PICO_DHCP_ERROR);
+
+ return -1;
+ }
+
+ dhcpc->retry = 0;
+ pico_dhcp_client_msg(dhcpc, PICO_DHCP_MSG_REQUEST);
+ pico_dhcp_client_start_renewing_timer(dhcpc);
+
+ return 0;
+}
+
+static int rebind(struct pico_dhcp_client_cookie *dhcpc, uint8_t *buf)
+{
+ (void) buf;
+
+ dhcpc->state = DHCP_CLIENT_STATE_REBINDING;
+ dhcpc->retry = 0;
+ pico_dhcp_client_msg(dhcpc, PICO_DHCP_MSG_REQUEST);
+ pico_dhcp_client_start_rebinding_timer(dhcpc);
+
+ return 0;
+}
+
+static int reset(struct pico_dhcp_client_cookie *dhcpc, uint8_t *buf)
+{
+ struct pico_ip4 address = {
+ 0
+ };
+ (void) buf;
+
+ if (dhcpc->state == DHCP_CLIENT_STATE_REQUESTING)
+ address.addr = PICO_IP4_ANY;
+ else
+ address.addr = dhcpc->address.addr;
+
+ /* close the socket used for address (re)acquisition */
+ pico_socket_close(dhcpc->s);
+ dhcpc->s = NULL;
+ /* delete the link with the currently in use address */
+ pico_ipv4_link_del(dhcpc->dev, address);
+
+ if (dhcpc->cb)
+ dhcpc->cb(dhcpc, PICO_DHCP_RESET);
+
+ if (dhcpc->state < DHCP_CLIENT_STATE_BOUND)
+ {
+ /* pico_dhcp_client_timer_stop(dhcpc, PICO_DHCPC_TIMER_INIT); */
+ }
+
+
+ dhcpc->state = DHCP_CLIENT_STATE_INIT;
+ pico_dhcp_client_stop_timers(dhcpc);
+ pico_dhcp_client_init(dhcpc);
+ return 0;
+}
+
+static int retransmit(struct pico_dhcp_client_cookie *dhcpc, uint8_t *buf)
+{
+ (void) buf;
+ switch (dhcpc->state)
+ {
+ case DHCP_CLIENT_STATE_INIT:
+ pico_dhcp_client_msg(dhcpc, PICO_DHCP_MSG_DISCOVER);
+ pico_dhcp_client_start_init_timer(dhcpc);
+ break;
+
+ case DHCP_CLIENT_STATE_REQUESTING:
+ pico_dhcp_client_msg(dhcpc, PICO_DHCP_MSG_REQUEST);
+ pico_dhcp_client_start_requesting_timer(dhcpc);
+ break;
+
+ case DHCP_CLIENT_STATE_RENEWING:
+ pico_dhcp_client_msg(dhcpc, PICO_DHCP_MSG_REQUEST);
+ pico_dhcp_client_start_renewing_timer(dhcpc);
+ break;
+
+ case DHCP_CLIENT_STATE_REBINDING:
+ pico_dhcp_client_msg(dhcpc, PICO_DHCP_MSG_DISCOVER);
+ pico_dhcp_client_start_rebinding_timer(dhcpc);
+ break;
+
+ default:
+ dhcpc_dbg("DHCP client WARNING: retransmit in incorrect state (%u)!\n", dhcpc->state);
+ return -1;
+ }
+ return 0;
+}
+
+struct dhcp_action_entry {
+ int (*offer)(struct pico_dhcp_client_cookie *dhcpc, uint8_t *buf);
+ int (*ack)(struct pico_dhcp_client_cookie *dhcpc, uint8_t *buf);
+ int (*nak)(struct pico_dhcp_client_cookie *dhcpc, uint8_t *buf);
+ int (*timer1)(struct pico_dhcp_client_cookie *dhcpc, uint8_t *buf);
+ int (*timer2)(struct pico_dhcp_client_cookie *dhcpc, uint8_t *buf);
+ int (*timer_lease)(struct pico_dhcp_client_cookie *dhcpc, uint8_t *buf);
+ int (*timer_retransmit)(struct pico_dhcp_client_cookie *dhcpc, uint8_t *buf);
+};
+
+static struct dhcp_action_entry dhcp_fsm[] =
+{ /* event |offer |ack |nak |T1 |T2 |lease |retransmit */
+/* state init-reboot */
+ { NULL, NULL, NULL, NULL, NULL, NULL, NULL },
+/* state rebooting */ { NULL, NULL, NULL, NULL, NULL, NULL, NULL },
+/* state init */ { recv_offer, NULL, NULL, NULL, NULL, NULL, retransmit },
+/* state selecting */ { NULL, NULL, NULL, NULL, NULL, NULL, NULL },
+/* state requesting */ { NULL, recv_ack, reset, NULL, NULL, NULL, retransmit },
+/* state bound */ { NULL, NULL, NULL, renew, NULL, NULL, NULL },
+/* state renewing */ { NULL, recv_ack, reset, NULL, rebind, NULL, retransmit },
+/* state rebinding */ { NULL, recv_ack, reset, NULL, NULL, reset, retransmit },
+};
+
+/* TIMERS REMARK:
+ * In state bound we have T1, T2 and the lease timer running. If T1 goes off, we attempt to renew.
+ * If the renew succeeds a new T1, T2 and lease timer is started. The former T2 and lease timer is
+ * still running though. This poses no concerns as the T2 and lease event in state bound have a NULL
+ * pointer in the fsm. If the former T2 or lease timer goes off, nothing happens. Same situation
+ * applies for T2 and a succesfull rebind. */
+
+static void pico_dhcp_state_machine(uint8_t event, struct pico_dhcp_client_cookie *dhcpc, uint8_t *buf)
+{
+ switch (event)
+ {
+ case PICO_DHCP_MSG_OFFER:
+ dhcpc_dbg("DHCP client: received OFFER\n");
+ if (dhcp_fsm[dhcpc->state].offer)
+ dhcp_fsm[dhcpc->state].offer(dhcpc, buf);
+
+ break;
+
+ case PICO_DHCP_MSG_ACK:
+ dhcpc_dbg("DHCP client: received ACK\n");
+ if (dhcp_fsm[dhcpc->state].ack)
+ dhcp_fsm[dhcpc->state].ack(dhcpc, buf);
+
+ break;
+
+ case PICO_DHCP_MSG_NAK:
+ dhcpc_dbg("DHCP client: received NAK\n");
+ if (dhcp_fsm[dhcpc->state].nak)
+ dhcp_fsm[dhcpc->state].nak(dhcpc, buf);
+
+ break;
+
+ case PICO_DHCP_EVENT_T1:
+ dhcpc_dbg("DHCP client: received T1 timeout\n");
+ if (dhcp_fsm[dhcpc->state].timer1)
+ dhcp_fsm[dhcpc->state].timer1(dhcpc, NULL);
+
+ break;
+
+ case PICO_DHCP_EVENT_T2:
+ dhcpc_dbg("DHCP client: received T2 timeout\n");
+ if (dhcp_fsm[dhcpc->state].timer2)
+ dhcp_fsm[dhcpc->state].timer2(dhcpc, NULL);
+
+ break;
+
+ case PICO_DHCP_EVENT_LEASE:
+ dhcpc_dbg("DHCP client: received LEASE timeout\n");
+ if (dhcp_fsm[dhcpc->state].timer_lease)
+ dhcp_fsm[dhcpc->state].timer_lease(dhcpc, NULL);
+
+ break;
+
+ case PICO_DHCP_EVENT_RETRANSMIT:
+ dhcpc_dbg("DHCP client: received RETRANSMIT timeout\n");
+ if (dhcp_fsm[dhcpc->state].timer_retransmit)
+ dhcp_fsm[dhcpc->state].timer_retransmit(dhcpc, NULL);
+
+ break;
+
+ default:
+ dhcpc_dbg("DHCP client WARNING: unrecognized event (%u)!\n", dhcpc->event);
+ return;
+ }
+ return;
+}
+
+static int16_t pico_dhcp_client_opt_parse(void *ptr, uint16_t len)
+{
+ uint32_t optlen = len - (uint32_t)sizeof(struct pico_dhcp_hdr);
+ struct pico_dhcp_hdr *hdr = (struct pico_dhcp_hdr *)ptr;
+ struct pico_dhcp_opt *opt = NULL;
+
+ if (hdr->dhcp_magic != PICO_DHCPD_MAGIC_COOKIE)
+ return -1;
+
+ if (!pico_dhcp_are_options_valid(hdr->options, (int32_t)optlen))
+ return -1;
+
+ opt = (struct pico_dhcp_opt *)hdr->options;
+ do {
+ if (opt->code == PICO_DHCP_OPT_MSGTYPE)
+ return opt->ext.msg_type.type;
+ } while (pico_dhcp_next_option(&opt));
+
+ return -1;
+}
+
+static int8_t pico_dhcp_client_msg(struct pico_dhcp_client_cookie *dhcpc, uint8_t msg_type)
+{
+ int32_t r = 0;
+ uint16_t optlen = 0, offset = 0;
+ struct pico_ip4 destination = {
+ .addr = 0xFFFFFFFF
+ };
+ struct pico_dhcp_hdr *hdr = NULL;
+
+
+ /* RFC 2131 3.1.3: Request is always BROADCAST */
+
+ /* Set again default route for the bcast request */
+ pico_ipv4_route_set_bcast_link(pico_ipv4_link_by_dev(dhcpc->dev));
+
+ switch (msg_type)
+ {
+ case PICO_DHCP_MSG_DISCOVER:
+ dhcpc_dbg("DHCP client: sent DHCPDISCOVER\n");
+ optlen = PICO_DHCP_OPTLEN_MSGTYPE + PICO_DHCP_OPTLEN_MAXMSGSIZE + PICO_DHCP_OPTLEN_PARAMLIST + PICO_DHCP_OPTLEN_END;
+ hdr = PICO_ZALLOC((size_t)(sizeof(struct pico_dhcp_hdr) + optlen));
+ if (!hdr) {
+ pico_err = PICO_ERR_ENOMEM;
+ return -1;
+ }
+
+ /* specific options */
+ offset = (uint16_t)(offset + pico_dhcp_opt_maxmsgsize(&hdr->options[offset], DHCP_CLIENT_MAXMSGZISE));
+ break;
+
+ case PICO_DHCP_MSG_REQUEST:
+ optlen = PICO_DHCP_OPTLEN_MSGTYPE + PICO_DHCP_OPTLEN_MAXMSGSIZE + PICO_DHCP_OPTLEN_PARAMLIST + PICO_DHCP_OPTLEN_REQIP + PICO_DHCP_OPTLEN_SERVERID
+ + PICO_DHCP_OPTLEN_END;
+ hdr = PICO_ZALLOC(sizeof(struct pico_dhcp_hdr) + optlen);
+ if (!hdr) {
+ pico_err = PICO_ERR_ENOMEM;
+ return -1;
+ }
+
+ /* specific options */
+ offset = (uint16_t)(offset + pico_dhcp_opt_maxmsgsize(&hdr->options[offset], DHCP_CLIENT_MAXMSGZISE));
+ if (dhcpc->state == DHCP_CLIENT_STATE_REQUESTING) {
+ offset = (uint16_t)(offset + pico_dhcp_opt_reqip(&hdr->options[offset], &dhcpc->address));
+ offset = (uint16_t)(offset + pico_dhcp_opt_serverid(&hdr->options[offset], &dhcpc->server_id));
+ }
+
+ break;
+
+ default:
+ return -1;
+ }
+
+ /* common options */
+ offset = (uint16_t)(offset + pico_dhcp_opt_msgtype(&hdr->options[offset], msg_type));
+ offset = (uint16_t)(offset + pico_dhcp_opt_paramlist(&hdr->options[offset]));
+ offset = (uint16_t)(offset + pico_dhcp_opt_end(&hdr->options[offset]));
+
+ switch (dhcpc->state)
+ {
+ case DHCP_CLIENT_STATE_BOUND:
+ destination.addr = dhcpc->server_id.addr;
+ hdr->ciaddr = dhcpc->address.addr;
+ break;
+
+ case DHCP_CLIENT_STATE_RENEWING:
+ destination.addr = dhcpc->server_id.addr;
+ hdr->ciaddr = dhcpc->address.addr;
+ break;
+
+ case DHCP_CLIENT_STATE_REBINDING:
+ hdr->ciaddr = dhcpc->address.addr;
+ break;
+
+ default:
+ /* do nothing */
+ break;
+ }
+
+ /* header information */
+ hdr->op = PICO_DHCP_OP_REQUEST;
+ hdr->htype = PICO_DHCP_HTYPE_ETH;
+ hdr->hlen = PICO_SIZE_ETH;
+ hdr->xid = dhcpc->xid;
+ /* hdr->flags = short_be(PICO_DHCP_FLAG_BROADCAST); / * Nope: see bug #96! * / */
+ hdr->dhcp_magic = PICO_DHCPD_MAGIC_COOKIE;
+ /* copy client hardware address */
+ memcpy(hdr->hwaddr, &dhcpc->dev->eth->mac, PICO_SIZE_ETH);
+
+ if (destination.addr == PICO_IP4_BCAST)
+ pico_ipv4_route_set_bcast_link(pico_ipv4_link_get(&dhcpc->address));
+
+ r = pico_socket_sendto(dhcpc->s, hdr, (int)(sizeof(struct pico_dhcp_hdr) + optlen), &destination, PICO_DHCPD_PORT);
+ PICO_FREE(hdr);
+ if (r < 0)
+ return -1;
+
+ return 0;
+}
+
+static void pico_dhcp_client_wakeup(uint16_t ev, struct pico_socket *s)
+{
+
+ uint8_t *buf;
+ int r = 0;
+ struct pico_dhcp_hdr *hdr = NULL;
+ struct pico_dhcp_client_cookie *dhcpc = NULL;
+
+ if ((ev & PICO_SOCK_EV_RD) == 0)
+ return;
+
+ buf = PICO_ZALLOC(DHCP_CLIENT_MAXMSGZISE);
+ if (!buf) {
+ return;
+ }
+
+ r = pico_socket_recvfrom(s, buf, DHCP_CLIENT_MAXMSGZISE, NULL, NULL);
+ if (r < 0)
+ goto out_discard_buf;
+
+ /* If the 'xid' of an arriving message does not match the 'xid'
+ * of the most recent transmitted message, the message must be
+ * silently discarded. */
+ hdr = (struct pico_dhcp_hdr *)buf;
+ dhcpc = pico_dhcp_client_find_cookie(hdr->xid);
+ if (!dhcpc)
+ goto out_discard_buf;
+
+ dhcpc->event = (uint8_t)pico_dhcp_client_opt_parse(buf, (uint16_t)r);
+ pico_dhcp_state_machine(dhcpc->event, dhcpc, buf);
+
+out_discard_buf:
+ PICO_FREE(buf);
+}
+
+void *pico_dhcp_get_identifier(uint32_t xid)
+{
+ return (void *)pico_dhcp_client_find_cookie(xid);
+}
+
+struct pico_ip4 pico_dhcp_get_address(void*dhcpc)
+{
+ return ((struct pico_dhcp_client_cookie*)dhcpc)->address;
+}
+
+struct pico_ip4 pico_dhcp_get_gateway(void*dhcpc)
+{
+ return ((struct pico_dhcp_client_cookie*)dhcpc)->gateway;
+}
+
+struct pico_ip4 pico_dhcp_get_netmask(void *dhcpc)
+{
+ return ((struct pico_dhcp_client_cookie*)dhcpc)->netmask;
+}
+
+struct pico_ip4 pico_dhcp_get_nameserver(void*dhcpc, int index)
+{
+ struct pico_ip4 fault = {
+ .addr = 0xFFFFFFFFU
+ };
+ if ((index != 0) && (index != 1))
+ return fault;
+
+ return ((struct pico_dhcp_client_cookie*)dhcpc)->nameserver[index];
+}
+
+int pico_dhcp_client_abort(uint32_t xid)
+{
+ return pico_dhcp_client_del_cookie(xid);
+}
+#endif
diff --git a/net/picotcp/modules/pico_dhcp_client.h b/net/picotcp/modules/pico_dhcp_client.h
new file mode 100644
index 0000000..2b5bbf9
--- /dev/null
+++ b/net/picotcp/modules/pico_dhcp_client.h
@@ -0,0 +1,30 @@
+/*********************************************************************
+ PicoTCP. Copyright (c) 2012-2015 Altran Intelligent Systems. Some rights reserved.
+ See LICENSE and COPYING for usage.
+
+ .
+
+ *********************************************************************/
+#ifndef INCLUDE_PICO_DHCP_CLIENT
+#define INCLUDE_PICO_DHCP_CLIENT
+#include "pico_defines.h"
+#ifdef PICO_SUPPORT_UDP
+#include "pico_dhcp_common.h"
+#include "pico_addressing.h"
+#include "pico_protocol.h"
+
+int pico_dhcp_initiate_negotiation(struct pico_device *device, void (*callback)(void*cli, int code), uint32_t *xid);
+void *pico_dhcp_get_identifier(uint32_t xid);
+struct pico_ip4 pico_dhcp_get_address(void *cli);
+struct pico_ip4 pico_dhcp_get_gateway(void *cli);
+struct pico_ip4 pico_dhcp_get_netmask(void *cli);
+struct pico_ip4 pico_dhcp_get_nameserver(void*cli, int index);
+int pico_dhcp_client_abort(uint32_t xid);
+
+/* possible codes for the callback */
+#define PICO_DHCP_SUCCESS 0
+#define PICO_DHCP_ERROR 1
+#define PICO_DHCP_RESET 2
+
+#endif
+#endif
diff --git a/net/picotcp/modules/pico_dhcp_common.c b/net/picotcp/modules/pico_dhcp_common.c
new file mode 100644
index 0000000..99701ba
--- /dev/null
+++ b/net/picotcp/modules/pico_dhcp_common.c
@@ -0,0 +1,189 @@
+/*********************************************************************
+ PicoTCP. Copyright (c) 2012-2015 Altran Intelligent Systems. Some rights reserved.
+ See LICENSE and COPYING for usage.
+
+ .
+
+ Authors: Frederik Van Slycken
+ *********************************************************************/
+
+#include "pico_config.h"
+#include "pico_stack.h"
+#include "pico_dhcp_common.h"
+
+#if defined (PICO_SUPPORT_DHCPC) || defined (PICO_SUPPORT_DHCPD)
+/* pico_dhcp_are_options_valid needs to be called first to prevent illegal memory access */
+/* The argument pointer is moved forward to the next option */
+struct pico_dhcp_opt *pico_dhcp_next_option(struct pico_dhcp_opt **ptr)
+{
+ uint8_t **p = (uint8_t **)ptr;
+ struct pico_dhcp_opt *opt = *ptr;
+
+ if (opt->code == PICO_DHCP_OPT_END)
+ return NULL;
+
+ if (opt->code == PICO_DHCP_OPT_PAD) {
+ *p += 1;
+ return *ptr;
+ }
+
+ *p += (opt->len + 2); /* (len + 2) to account for code and len octet */
+ return *ptr;
+}
+
+uint8_t pico_dhcp_are_options_valid(void *ptr, int32_t len)
+{
+ uint8_t optlen = 0, *p = ptr;
+
+ while (len > 0) {
+ switch (*p)
+ {
+ case PICO_DHCP_OPT_END:
+ return 1;
+
+ case PICO_DHCP_OPT_PAD:
+ p++;
+ len--;
+ break;
+
+ default:
+ p++; /* move pointer from code octet to len octet */
+ len--;
+ if ((len <= 0) || (len - (*p + 1) < 0)) /* (*p + 1) to account for len octet */
+ return 0;
+
+ optlen = *p;
+ p += optlen + 1;
+ len -= optlen;
+ break;
+ }
+ }
+ return 0;
+}
+
+uint8_t pico_dhcp_opt_netmask(void *ptr, struct pico_ip4 *ip)
+{
+ struct pico_dhcp_opt *opt = (struct pico_dhcp_opt *)ptr;
+
+ /* option: netmask */
+ opt->code = PICO_DHCP_OPT_NETMASK;
+ opt->len = PICO_DHCP_OPTLEN_NETMASK - PICO_DHCP_OPTLEN_HDR;
+ opt->ext.netmask.ip = *ip;
+ return PICO_DHCP_OPTLEN_NETMASK;
+}
+
+uint8_t pico_dhcp_opt_router(void *ptr, struct pico_ip4 *ip)
+{
+ struct pico_dhcp_opt *opt = (struct pico_dhcp_opt *)ptr;
+
+ /* option: router */
+ opt->code = PICO_DHCP_OPT_ROUTER;
+ opt->len = PICO_DHCP_OPTLEN_ROUTER - PICO_DHCP_OPTLEN_HDR;
+ opt->ext.router.ip = *ip;
+ return PICO_DHCP_OPTLEN_ROUTER;
+}
+
+uint8_t pico_dhcp_opt_dns(void *ptr, struct pico_ip4 *ip)
+{
+ struct pico_dhcp_opt *opt = (struct pico_dhcp_opt *)ptr;
+
+ /* option: dns */
+ opt->code = PICO_DHCP_OPT_DNS;
+ opt->len = PICO_DHCP_OPTLEN_DNS - PICO_DHCP_OPTLEN_HDR;
+ opt->ext.dns1.ip = *ip;
+ return PICO_DHCP_OPTLEN_DNS;
+}
+
+uint8_t pico_dhcp_opt_broadcast(void *ptr, struct pico_ip4 *ip)
+{
+ struct pico_dhcp_opt *opt = (struct pico_dhcp_opt *)ptr;
+
+ /* option: broadcast */
+ opt->code = PICO_DHCP_OPT_BROADCAST;
+ opt->len = PICO_DHCP_OPTLEN_BROADCAST - PICO_DHCP_OPTLEN_HDR;
+ opt->ext.broadcast.ip = *ip;
+ return PICO_DHCP_OPTLEN_BROADCAST;
+}
+
+uint8_t pico_dhcp_opt_reqip(void *ptr, struct pico_ip4 *ip)
+{
+ struct pico_dhcp_opt *opt = (struct pico_dhcp_opt *)ptr;
+
+ /* option: request IP address */
+ opt->code = PICO_DHCP_OPT_REQIP;
+ opt->len = PICO_DHCP_OPTLEN_REQIP - PICO_DHCP_OPTLEN_HDR;
+ opt->ext.req_ip.ip = *ip;
+ return PICO_DHCP_OPTLEN_REQIP;
+}
+
+uint8_t pico_dhcp_opt_leasetime(void *ptr, uint32_t time)
+{
+ struct pico_dhcp_opt *opt = (struct pico_dhcp_opt *)ptr;
+
+ /* option: lease time */
+ opt->code = PICO_DHCP_OPT_LEASETIME;
+ opt->len = PICO_DHCP_OPTLEN_LEASETIME - PICO_DHCP_OPTLEN_HDR;
+ opt->ext.lease_time.time = time;
+ return PICO_DHCP_OPTLEN_LEASETIME;
+}
+
+uint8_t pico_dhcp_opt_msgtype(void *ptr, uint8_t type)
+{
+ struct pico_dhcp_opt *opt = (struct pico_dhcp_opt *)ptr;
+
+ /* option: message type */
+ opt->code = PICO_DHCP_OPT_MSGTYPE;
+ opt->len = PICO_DHCP_OPTLEN_MSGTYPE - PICO_DHCP_OPTLEN_HDR;
+ opt->ext.msg_type.type = type;
+ return PICO_DHCP_OPTLEN_MSGTYPE;
+}
+
+uint8_t pico_dhcp_opt_serverid(void *ptr, struct pico_ip4 *ip)
+{
+ struct pico_dhcp_opt *opt = (struct pico_dhcp_opt *)ptr;
+
+ /* option: server identifier */
+ opt->code = PICO_DHCP_OPT_SERVERID;
+ opt->len = PICO_DHCP_OPTLEN_SERVERID - PICO_DHCP_OPTLEN_HDR;
+ opt->ext.server_id.ip = *ip;
+ return PICO_DHCP_OPTLEN_SERVERID;
+}
+
+uint8_t pico_dhcp_opt_paramlist(void *ptr)
+{
+ struct pico_dhcp_opt *opt = (struct pico_dhcp_opt *)ptr;
+
+ /* option: parameter list */
+ opt->code = PICO_DHCP_OPT_PARAMLIST;
+ opt->len = PICO_DHCP_OPTLEN_PARAMLIST - PICO_DHCP_OPTLEN_HDR;
+ opt->ext.param_list.code[0] = PICO_DHCP_OPT_NETMASK;
+ opt->ext.param_list.code[1] = PICO_DHCP_OPT_TIME;
+ opt->ext.param_list.code[2] = PICO_DHCP_OPT_ROUTER;
+ opt->ext.param_list.code[3] = PICO_DHCP_OPT_HOSTNAME;
+ opt->ext.param_list.code[4] = PICO_DHCP_OPT_RENEWALTIME;
+ opt->ext.param_list.code[5] = PICO_DHCP_OPT_REBINDINGTIME;
+ opt->ext.param_list.code[6] = PICO_DHCP_OPT_DNS;
+ return PICO_DHCP_OPTLEN_PARAMLIST;
+}
+
+uint8_t pico_dhcp_opt_maxmsgsize(void *ptr, uint16_t size)
+{
+ struct pico_dhcp_opt *opt = (struct pico_dhcp_opt *)ptr;
+
+ /* option: maximum message size */
+ opt->code = PICO_DHCP_OPT_MAXMSGSIZE;
+ opt->len = PICO_DHCP_OPTLEN_MAXMSGSIZE - PICO_DHCP_OPTLEN_HDR;
+ opt->ext.max_msg_size.size = short_be(size);
+ return PICO_DHCP_OPTLEN_MAXMSGSIZE;
+}
+
+uint8_t pico_dhcp_opt_end(void *ptr)
+{
+ uint8_t *opt = (uint8_t *)ptr;
+
+ /* option: end of options */
+ *opt = PICO_DHCP_OPT_END;
+ return PICO_DHCP_OPTLEN_END;
+}
+
+#endif
diff --git a/net/picotcp/modules/pico_dhcp_common.h b/net/picotcp/modules/pico_dhcp_common.h
new file mode 100644
index 0000000..cdf1bd1
--- /dev/null
+++ b/net/picotcp/modules/pico_dhcp_common.h
@@ -0,0 +1,186 @@
+/*********************************************************************
+ PicoTCP. Copyright (c) 2012-2015 Altran Intelligent Systems. Some rights reserved.
+ See LICENSE and COPYING for usage.
+
+ .
+
+ *********************************************************************/
+#ifndef INCLUDE_PICO_DHCP_COMMON
+#define INCLUDE_PICO_DHCP_COMMON
+#include "pico_config.h"
+#include "pico_addressing.h"
+
+#define PICO_DHCPD_PORT (short_be(67))
+#define PICO_DHCP_CLIENT_PORT (short_be(68))
+#define PICO_DHCPD_MAGIC_COOKIE (long_be(0x63825363))
+#define PICO_DHCP_HTYPE_ETH 1
+
+/* flags */
+#define PICO_DHCP_FLAG_BROADCAST 0x8000
+
+/* options */
+#define PICO_DHCP_OPT_PAD 0x00
+#define PICO_DHCP_OPT_NETMASK 0x01
+#define PICO_DHCP_OPT_TIME 0x02
+#define PICO_DHCP_OPT_ROUTER 0x03
+#define PICO_DHCP_OPT_DNS 0x06
+#define PICO_DHCP_OPT_HOSTNAME 0x0c
+#define PICO_DHCP_OPT_DOMAINNAME 0x0f
+#define PICO_DHCP_OPT_MTU 0x1a
+#define PICO_DHCP_OPT_BROADCAST 0x1c
+#define PICO_DHCP_OPT_NETBIOSNS 0x2c
+#define PICO_DHCP_OPT_NETBIOSSCOPE 0x2f
+#define PICO_DHCP_OPT_REQIP 0x32
+#define PICO_DHCP_OPT_LEASETIME 0x33
+#define PICO_DHCP_OPT_OPTOVERLOAD 0x34
+#define PICO_DHCP_OPT_MSGTYPE 0x35
+#define PICO_DHCP_OPT_SERVERID 0x36
+#define PICO_DHCP_OPT_PARAMLIST 0x37
+#define PICO_DHCP_OPT_MESSAGE 0x38
+#define PICO_DHCP_OPT_MAXMSGSIZE 0x39
+#define PICO_DHCP_OPT_RENEWALTIME 0x3a
+#define PICO_DHCP_OPT_REBINDINGTIME 0x3b
+#define PICO_DHCP_OPT_VENDORID 0x3c
+#define PICO_DHCP_OPT_CLIENTID 0x3d
+#define PICO_DHCP_OPT_DOMAINSEARCH 0x77
+#define PICO_DHCP_OPT_STATICROUTE 0x79
+#define PICO_DHCP_OPT_END 0xFF
+
+/* options len */
+#define PICO_DHCP_OPTLEN_HDR 2 /* account for code and len field */
+#define PICO_DHCP_OPTLEN_NETMASK 6
+#define PICO_DHCP_OPTLEN_ROUTER 6
+#define PICO_DHCP_OPTLEN_DNS 6
+#define PICO_DHCP_OPTLEN_BROADCAST 6
+#define PICO_DHCP_OPTLEN_REQIP 6
+#define PICO_DHCP_OPTLEN_LEASETIME 6
+#define PICO_DHCP_OPTLEN_OPTOVERLOAD 3
+#define PICO_DHCP_OPTLEN_MSGTYPE 3
+#define PICO_DHCP_OPTLEN_SERVERID 6
+#define PICO_DHCP_OPTLEN_PARAMLIST 9 /* PicoTCP specific */
+#define PICO_DHCP_OPTLEN_MAXMSGSIZE 4
+#define PICO_DHCP_OPTLEN_RENEWALTIME 6
+#define PICO_DHCP_OPTLEN_REBINDINGTIME 6
+#define PICO_DHCP_OPTLEN_END 1
+
+/* op codes */
+#define PICO_DHCP_OP_REQUEST 1
+#define PICO_DHCP_OP_REPLY 2
+
+/* rfc message types */
+#define PICO_DHCP_MSG_DISCOVER 1
+#define PICO_DHCP_MSG_OFFER 2
+#define PICO_DHCP_MSG_REQUEST 3
+#define PICO_DHCP_MSG_DECLINE 4
+#define PICO_DHCP_MSG_ACK 5
+#define PICO_DHCP_MSG_NAK 6
+#define PICO_DHCP_MSG_RELEASE 7
+#define PICO_DHCP_MSG_INFORM 8
+
+/* custom message types */
+#define PICO_DHCP_EVENT_T1 9
+#define PICO_DHCP_EVENT_T2 10
+#define PICO_DHCP_EVENT_LEASE 11
+#define PICO_DHCP_EVENT_RETRANSMIT 12
+#define PICO_DHCP_EVENT_NONE 0xff
+
+PACKED_STRUCT_DEF pico_dhcp_hdr
+{
+ uint8_t op;
+ uint8_t htype;
+ uint8_t hlen;
+ uint8_t hops; /* zero */
+ uint32_t xid; /* store this in the request */
+ uint16_t secs; /* ignore */
+ uint16_t flags;
+ uint32_t ciaddr; /* client address - if asking for renewal */
+ uint32_t yiaddr; /* your address (client) */
+ uint32_t siaddr; /* dhcp offered address */
+ uint32_t giaddr; /* relay agent, bootp. */
+ uint8_t hwaddr[6];
+ uint8_t hwaddr_padding[10];
+ char hostname[64];
+ char bootp_filename[128];
+ uint32_t dhcp_magic;
+ uint8_t options[0];
+};
+
+PACKED_STRUCT_DEF pico_dhcp_opt
+{
+ uint8_t code;
+ uint8_t len;
+ PACKED_UNION_DEF dhcp_opt_ext_u {
+ PEDANTIC_STRUCT_DEF netmask_s {
+ struct pico_ip4 ip;
+ } netmask;
+ PEDANTIC_STRUCT_DEF router_s {
+ struct pico_ip4 ip;
+ } router;
+ PEDANTIC_STRUCT_DEF dns_s {
+ struct pico_ip4 ip;
+ } dns1;
+ struct dns_s dns2;
+ PEDANTIC_STRUCT_DEF broadcast_s {
+ struct pico_ip4 ip;
+ } broadcast;
+ PEDANTIC_STRUCT_DEF req_ip_s {
+ struct pico_ip4 ip;
+ } req_ip;
+ PEDANTIC_STRUCT_DEF lease_time_s {
+ uint32_t time;
+ } lease_time;
+ PEDANTIC_STRUCT_DEF opt_overload_s {
+ uint8_t value;
+ } opt_overload;
+ PEDANTIC_STRUCT_DEF tftp_server_s {
+ char name[1];
+ } tftp_server;
+ PEDANTIC_STRUCT_DEF bootfile_s {
+ char name[1];
+ } bootfile;
+ PEDANTIC_STRUCT_DEF msg_type_s {
+ uint8_t type;
+ } msg_type;
+ PEDANTIC_STRUCT_DEF server_id_s {
+ struct pico_ip4 ip;
+ } server_id;
+ PEDANTIC_STRUCT_DEF param_list_s {
+ uint8_t code[1];
+ } param_list;
+ PEDANTIC_STRUCT_DEF message_s {
+ char error[1];
+ } message;
+ PEDANTIC_STRUCT_DEF max_msg_size_s {
+ uint16_t size;
+ } max_msg_size;
+ PEDANTIC_STRUCT_DEF renewal_time_s {
+ uint32_t time;
+ } renewal_time;
+ PEDANTIC_STRUCT_DEF rebinding_time_s {
+ uint32_t time;
+ } rebinding_time;
+ PEDANTIC_STRUCT_DEF vendor_id_s {
+ uint8_t id[1];
+ } vendor_id;
+ PEDANTIC_STRUCT_DEF client_id_s {
+ uint8_t id[1];
+ } client_id;
+ } ext;
+};
+
+uint8_t dhcp_get_next_option(uint8_t *begin, uint8_t *data, int *len, uint8_t **nextopt);
+struct pico_dhcp_opt *pico_dhcp_next_option(struct pico_dhcp_opt **ptr);
+uint8_t pico_dhcp_are_options_valid(void *ptr, int32_t len);
+
+uint8_t pico_dhcp_opt_netmask(void *ptr, struct pico_ip4 *ip);
+uint8_t pico_dhcp_opt_router(void *ptr, struct pico_ip4 *ip);
+uint8_t pico_dhcp_opt_dns(void *ptr, struct pico_ip4 *ip);
+uint8_t pico_dhcp_opt_broadcast(void *ptr, struct pico_ip4 *ip);
+uint8_t pico_dhcp_opt_reqip(void *ptr, struct pico_ip4 *ip);
+uint8_t pico_dhcp_opt_leasetime(void *ptr, uint32_t time);
+uint8_t pico_dhcp_opt_msgtype(void *ptr, uint8_t type);
+uint8_t pico_dhcp_opt_serverid(void *ptr, struct pico_ip4 *ip);
+uint8_t pico_dhcp_opt_paramlist(void *ptr);
+uint8_t pico_dhcp_opt_maxmsgsize(void *ptr, uint16_t size);
+uint8_t pico_dhcp_opt_end(void *ptr);
+#endif
diff --git a/net/picotcp/modules/pico_dns_client.h b/net/picotcp/modules/pico_dns_client.h
new file mode 100644
index 0000000..910cc92
--- /dev/null
+++ b/net/picotcp/modules/pico_dns_client.h
@@ -0,0 +1,46 @@
+/*********************************************************************
+ PicoTCP. Copyright (c) 2012 TASS Belgium NV. Some rights reserved.
+ See LICENSE and COPYING for usage.
+
+ .
+
+ Authors: Kristof Roelants
+ *********************************************************************/
+
+#ifndef INCLUDE_PICO_DNS_CLIENT
+#define INCLUDE_PICO_DNS_CLIENT
+
+#define PICO_DNS_NS_DEL 0
+#define PICO_DNS_NS_ADD 1
+#include "pico_config.h"
+
+/* Compression values */
+#define PICO_DNS_LABEL 0
+#define PICO_DNS_POINTER 3
+
+/* Label len */
+#define PICO_DNS_LABEL_INITIAL 1u
+#define PICO_DNS_LABEL_ROOT 1
+
+/* TTL values */
+#define PICO_DNS_MAX_TTL 604800 /* one week */
+
+/* Len of an IPv4 address string */
+#define PICO_DNS_IPV4_ADDR_LEN 16
+#define PICO_DNS_IPV6_ADDR_LEN 54
+
+/* Default nameservers + port */
+#define PICO_DNS_NS_DEFAULT "208.67.222.222"
+#define PICO_DNS_NS_PORT 53
+
+int pico_dns_client_init(void);
+/* flag is PICO_DNS_NS_DEL or PICO_DNS_NS_ADD */
+int pico_dns_client_nameserver(struct pico_ip4 *ns, uint8_t flag);
+int pico_dns_client_getaddr(const char *url, void (*callback)(char *ip, void *arg), void *arg);
+int pico_dns_client_getname(const char *ip, void (*callback)(char *url, void *arg), void *arg);
+#ifdef PICO_SUPPORT_IPV6
+int pico_dns_client_getaddr6(const char *url, void (*callback)(char *, void *), void *arg);
+int pico_dns_client_getname6(const char *url, void (*callback)(char *, void *), void *arg);
+#endif
+
+#endif /* _INCLUDE_PICO_DNS_CLIENT */
diff --git a/net/picotcp/modules/pico_dns_common.h b/net/picotcp/modules/pico_dns_common.h
new file mode 100644
index 0000000..9172696
--- /dev/null
+++ b/net/picotcp/modules/pico_dns_common.h
@@ -0,0 +1,521 @@
+
+/*********************************************************************
+ PicoTCP. Copyright (c) 2012 TASS Belgium NV. Some rights reserved.
+ See LICENSE and COPYING for usage.
+ .
+ Authors: Toon Stegen, Jelle De Vleeschouwer
+ *********************************************************************/
+
+#ifndef INCLUDE_PICO_DNS_COMMON
+#define INCLUDE_PICO_DNS_COMMON
+
+#include "pico_config.h"
+#include "pico_tree.h"
+
+/* TYPE values */
+#define PICO_DNS_TYPE_A 1
+#define PICO_DNS_TYPE_CNAME 5
+#define PICO_DNS_TYPE_PTR 12
+#define PICO_DNS_TYPE_TXT 16
+#define PICO_DNS_TYPE_AAAA 28
+#define PICO_DNS_TYPE_SRV 33
+#define PICO_DNS_TYPE_NSEC 47
+#define PICO_DNS_TYPE_ANY 255
+
+/* CLASS values */
+#define PICO_DNS_CLASS_IN 1
+
+/* FLAG values */
+#define PICO_DNS_QR_QUERY 0
+#define PICO_DNS_QR_RESPONSE 1
+#define PICO_DNS_OPCODE_QUERY 0
+#define PICO_DNS_OPCODE_IQUERY 1
+#define PICO_DNS_OPCODE_STATUS 2
+#define PICO_DNS_AA_NO_AUTHORITY 0
+#define PICO_DNS_AA_IS_AUTHORITY 1
+#define PICO_DNS_TC_NO_TRUNCATION 0
+#define PICO_DNS_TC_IS_TRUNCATED 1
+#define PICO_DNS_RD_NO_DESIRE 0
+#define PICO_DNS_RD_IS_DESIRED 1
+#define PICO_DNS_RA_NO_SUPPORT 0
+#define PICO_DNS_RA_IS_SUPPORTED 1
+#define PICO_DNS_RCODE_NO_ERROR 0
+#define PICO_DNS_RCODE_EFORMAT 1
+#define PICO_DNS_RCODE_ESERVER 2
+#define PICO_DNS_RCODE_ENAME 3
+#define PICO_DNS_RCODE_ENOIMP 4
+#define PICO_DNS_RCODE_EREFUSED 5
+
+#define PICO_ARPA_IPV4_SUFFIX ".in-addr.arpa"
+
+#ifdef PICO_SUPPORT_IPV6
+#define STRLEN_PTR_IP6 63
+#define PICO_ARPA_IPV6_SUFFIX ".IP6.ARPA"
+#endif
+
+#define PICO_DNS_NAMEBUF_SIZE (256)
+
+enum pico_dns_arpa
+{
+ PICO_DNS_ARPA4,
+ PICO_DNS_ARPA6,
+ PICO_DNS_NO_ARPA,
+};
+
+/* flags split in 2x uint8 due to endianness */
+PACKED_STRUCT_DEF pico_dns_header
+{
+ uint16_t id; /* Packet id */
+ uint8_t rd : 1; /* Recursion Desired */
+ uint8_t tc : 1; /* TrunCation */
+ uint8_t aa : 1; /* Authoritative Answer */
+ uint8_t opcode : 4; /* Opcode */
+ uint8_t qr : 1; /* Query/Response */
+ uint8_t rcode : 4; /* Response code */
+ uint8_t z : 3; /* Zero */
+ uint8_t ra : 1; /* Recursion Available */
+ uint16_t qdcount; /* Question count */
+ uint16_t ancount; /* Answer count */
+ uint16_t nscount; /* Authority count */
+ uint16_t arcount; /* Additional count */
+};
+typedef struct pico_dns_header pico_dns_packet;
+
+/* Question fixed-sized fields */
+PACKED_STRUCT_DEF pico_dns_question_suffix
+{
+ uint16_t qtype;
+ uint16_t qclass;
+};
+
+/* Resource record fixed-sized fields */
+PACKED_STRUCT_DEF pico_dns_record_suffix
+{
+ uint16_t rtype;
+ uint16_t rclass;
+ uint32_t rttl;
+ uint16_t rdlength;
+};
+
+/* DNS QUESTION */
+struct pico_dns_question
+{
+ char *qname;
+ struct pico_dns_question_suffix *qsuffix;
+ uint16_t qname_length;
+ uint8_t proto;
+};
+
+/* DNS RECORD */
+struct pico_dns_record
+{
+ char *rname;
+ struct pico_dns_record_suffix *rsuffix;
+ uint8_t *rdata;
+ uint16_t rname_length;
+};
+
+/* MARK: v NAME & IP FUNCTIONS */
+
+/* ****************************************************************************
+ * Checks if the DNS name doesn't exceed 256 bytes including zero-byte.
+ *
+ * @param namelen Length of the DNS name-string including zero-byte
+ * @return 0 when the length is correct
+ * ****************************************************************************/
+int
+pico_dns_check_namelen( uint16_t namelen );
+
+/* ****************************************************************************
+ * Returns the length of a name in a DNS-packet as if DNS name compression
+ * would be applied to the packet. If there's no compression present this
+ * returns the strlen. If there's compression present this returns the length
+ * until the compression-pointer + 1.
+ *
+ * @param name Compressed name you want the calculate the strlen from
+ * @return Returns strlen of a compressed name, takes the first byte of compr-
+ * ession pointer into account but not the second byte, which acts
+ * like a trailing zero-byte.
+ * ****************************************************************************/
+uint16_t
+pico_dns_namelen_comp( char *name );
+
+/* ****************************************************************************
+ * Returns the uncompressed name in DNS name format when DNS name compression
+ * is applied to the packet-buffer.
+ *
+ * @param name Compressed name, should be in the bounds of the actual packet
+ * @param packet Packet that contains the compressed name
+ * @return Returns the decompressed name, NULL on failure.
+ * ****************************************************************************/
+char *
+pico_dns_decompress_name( char *name, pico_dns_packet *packet );
+
+/* ****************************************************************************
+ * Converts a DNS name in DNS name format to a name in URL format. Provides
+ * space for the name in URL format as well. PICO_FREE() should be called on
+ * the returned string buffer that contains the name in URL format.
+ *
+ * @param qname DNS name in DNS name format to convert
+ * @return Returns a pointer to a string-buffer with the URL name on success.
+ * ****************************************************************************/
+char *
+pico_dns_qname_to_url( const char *qname );
+
+/* ****************************************************************************
+ * Converts a DNS name in URL format to name in DNS name format. Provides
+ * space for the DNS name as well. PICO_FREE() should be called on the returned
+ * string buffer that contains the DNS name.
+ *
+ * @param url DNS name in URL format to convert
+ * @return Returns a pointer to a string-buffer with the DNS name on success.
+ * ****************************************************************************/
+char *
+pico_dns_url_to_qname( const char *url );
+
+/* ****************************************************************************
+ * @param url String-buffer
+ * @return Length of string-buffer in an uint16_t
+ * ****************************************************************************/
+uint16_t
+pico_dns_strlen( const char *url );
+
+/* ****************************************************************************
+ * Replaces .'s in a DNS name in URL format by the label lengths. So it
+ * actually converts a name in URL format to a name in DNS name format.
+ * f.e. "*www.google.be" => "3www6google2be0"
+ *
+ * @param url Location to buffer with name in URL format. The URL needs to
+ * be +1 byte offset in the actual buffer. Size is should be
+ * strlen(url) + 2.
+ * @param maxlen Maximum length of buffer so it doesn't cause a buffer overflow
+ * @return 0 on success, something else on failure.
+ * ****************************************************************************/
+int pico_dns_name_to_dns_notation( char *url, unsigned int maxlen );
+
+/* ****************************************************************************
+ * Replaces the label lengths in a DNS-name by .'s. So it actually converts a
+ * name in DNS format to a name in URL format.
+ * f.e. 3www6google2be0 => .www.google.be
+ *
+ * @param ptr Location to buffer with name in DNS name format
+ * @param maxlen Maximum length of buffer so it doesn't cause a buffer overflow
+ * @return 0 on success, something else on failure.
+ * ****************************************************************************/
+int pico_dns_notation_to_name( char *ptr, unsigned int maxlen );
+
+/* ****************************************************************************
+ * Determines the length of the first label of a DNS name in URL-format
+ *
+ * @param url DNS name in URL-format
+ * @return Length of the first label of DNS name in URL-format
+ * ****************************************************************************/
+uint16_t
+pico_dns_first_label_length( const char *url );
+
+/* ****************************************************************************
+ * Mirrors a dotted IPv4-address string.
+ * f.e. 192.168.0.1 => 1.0.168.192
+ *
+ * @param ptr
+ * @return 0 on success, something else on failure.
+ * ****************************************************************************/
+int
+pico_dns_mirror_addr( char *ptr );
+
+/* ****************************************************************************
+ * Convert an IPv6-address in string-format to a IPv6-address in nibble-format.
+ * Doesn't add a IPv6 ARPA-suffix though.
+ *
+ * @param ip IPv6-address stored as a string
+ * @param dst Destination to store IPv6-address in nibble-format
+ * ****************************************************************************/
+void
+pico_dns_ipv6_set_ptr( const char *ip, char *dst );
+
+/* MARK: QUESTION FUNCTIONS */
+
+/* ****************************************************************************
+ * Deletes a single DNS Question.
+ *
+ * @param question Void-pointer to DNS Question. Can be used with pico_tree_-
+ * destroy.
+ * @return Returns 0 on success, something else on failure.
+ * ****************************************************************************/
+int
+pico_dns_question_delete( void **question);
+
+/* ****************************************************************************
+ * Fills in the DNS question suffix-fields with the correct values.
+ *
+ * todo: Update pico_dns_client to make the same mechanism possible as with
+ * filling DNS Resource Record-suffixes. This function shouldn't be an
+ * API-function.
+ *
+ * @param suf Pointer to the suffix member of the DNS question.
+ * @param qtype DNS type of the DNS question to be.
+ * @param qclass DNS class of the DNS question to be.
+ * @return Returns 0 on success, something else on failure.
+ * ****************************************************************************/
+int
+pico_dns_question_fill_suffix( struct pico_dns_question_suffix *suf,
+ uint16_t qtype,
+ uint16_t qclass );
+
+/* ****************************************************************************
+ * Creates a standalone DNS Question with a given name and type.
+ *
+ * @param url DNS question name in URL format. Will be converted to DNS
+ * name notation format.
+ * @param len Will be filled with the total length of the DNS question.
+ * @param proto Protocol for which you want to create a question. Can be
+ * either PICO_PROTO_IPV4 or PICO_PROTO_IPV6.
+ * @param qtype DNS type of the question to be.
+ * @param qclass DNS class of the question to be.
+ * @param reverse When this is true, a reverse resolution name will be gene-
+ * from the URL
+ * @return Returns pointer to the created DNS Question on success, NULL on
+ * failure.
+ * ****************************************************************************/
+struct pico_dns_question *
+pico_dns_question_create( const char *url,
+ uint16_t *len,
+ uint8_t proto,
+ uint16_t qtype,
+ uint16_t qclass,
+ uint8_t reverse );
+
+/* ****************************************************************************
+ * Decompresses the name of a single DNS question.
+ *
+ * @param question Question you want to decompress the name of
+ * @param packet Packet in which the DNS question is contained.
+ * @return Pointer to original name of the DNS question before decompressing.
+ * ****************************************************************************/
+char *
+pico_dns_question_decompress( struct pico_dns_question *question,
+ pico_dns_packet *packet );
+
+/* MARK: RESOURCE RECORD FUNCTIONS */
+
+/* ****************************************************************************
+ * Deletes a single DNS resource record.
+ *
+ * @param record Void-pointer to DNS record. Can be used with pico_tree_destroy
+ * @return Returns 0 on success, something else on failure.
+ * ****************************************************************************/
+int
+pico_dns_record_delete( void **record );
+
+/* ****************************************************************************
+ * Just makes a hardcopy from a single DNS Resource Record
+ *
+ * @param record DNS record you want to copy
+ * @return Pointer to copy of DNS record.
+ * ****************************************************************************/
+struct pico_dns_record *
+pico_dns_record_copy( struct pico_dns_record *record );
+
+/* ****************************************************************************
+ * Create a standalone DNS Resource Record with given name, type and data.
+ *
+ * @param url DNS rrecord name in URL format. Will be converted to DNS
+ * name notation format.
+ * @param _rdata Memory buffer with data to insert in the resource record. If
+ * data of record should contain a DNS name, the name in the
+ * databuffer needs to be in URL-format.
+ * @param datalen The exact length in bytes of the _rdata-buffer. If data of
+ * record should contain a DNS name, datalen needs to be
+ * pico_dns_strlen(_rdata).
+ * @param len Will be filled with the total length of the DNS rrecord.
+ * @param rtype DNS type of the resource record to be.
+ * @param rclass DNS class of the resource record to be.
+ * @param rttl DNS ttl of the resource record to be.
+ * @return Returns pointer to the created DNS Resource Record
+ * ****************************************************************************/
+struct pico_dns_record *
+pico_dns_record_create( const char *url,
+ void *_rdata,
+ uint16_t datalen,
+ uint16_t *len,
+ uint16_t rtype,
+ uint16_t rclass,
+ uint32_t rttl );
+
+/* ****************************************************************************
+ * Decompresses the name of single DNS record.
+ *
+ * @param record DNS record to decompress the name of.
+ * @param packet Packet in which is DNS record is present
+ * @return Pointer to original name of the DNS record before decompressing.
+ * ****************************************************************************/
+char *
+pico_dns_record_decompress( struct pico_dns_record *record,
+ pico_dns_packet *packet );
+
+/* MARK: COMPARING */
+
+/* ****************************************************************************
+ * Compares two databuffers against each other.
+ *
+ * @param a 1st Memory buffer to compare
+ * @param b 2nd Memory buffer to compare
+ * @param rdlength_a Length of 1st memory buffer
+ * @param rdlength_b Length of 2nd memory buffer
+ * @return 0 when the buffers are equal, returns difference when they're not.
+ * ****************************************************************************/
+int
+pico_dns_rdata_cmp( uint8_t *a, uint8_t *b,
+ uint16_t rdlength_a, uint16_t rdlength_b );
+
+/* ****************************************************************************
+ * Compares 2 DNS questions
+ *
+ * @param qa DNS question A as a void-pointer (for pico_tree)
+ * @param qb DNS question A as a void-pointer (for pico_tree)
+ * @return 0 when questions are equal, returns difference when they're not.
+ * ****************************************************************************/
+int
+pico_dns_question_cmp( void *qa,
+ void *qb );
+
+/* ****************************************************************************
+ * Compares 2 DNS records by type and name only
+ *
+ * @param ra DNS record A as a void-pointer (for pico_tree)
+ * @param rb DNS record B as a void-pointer (for pico_tree)
+ * @return 0 when name and type of records are equal, returns difference when
+ * they're not.
+ * ****************************************************************************/
+int
+pico_dns_record_cmp_name_type( void *ra,
+ void *rb );
+
+/* ****************************************************************************
+ * Compares 2 DNS records by type, name AND rdata for a truly unique result
+ *
+ * @param ra DNS record A as a void-pointer (for pico_tree)
+ * @param rb DNS record B as a void-pointer (for pico_tree)
+ * @return 0 when records are equal, returns difference when they're not
+ * ****************************************************************************/
+int
+pico_dns_record_cmp( void *ra,
+ void *rb );
+
+/* MARK: PICO_TREE */
+
+/* ****************************************************************************
+ * Erases a pico_tree entirely.
+ *
+ * @param tree Pointer to a pico_tree-instance
+ * @param node_delete Helper-function for type-specific deleting.
+ * @return Returns 0 on success, something else on failure.
+ * ****************************************************************************/
+int
+pico_tree_destroy( struct pico_tree *tree, int (*node_delete)(void **));
+
+/* ****************************************************************************
+ * Determines the amount of nodes in a pico_tree
+ *
+ * @param tree Pointer to pico_tree-instance
+ * @return Amount of items in the tree.
+ * ****************************************************************************/
+uint16_t
+pico_tree_count( struct pico_tree *tree );
+
+/* ****************************************************************************
+ * Definition of DNS question tree
+ * ****************************************************************************/
+typedef struct pico_tree pico_dns_qtree;
+#define PICO_DNS_QTREE_DECLARE(name) \
+ pico_dns_qtree (name) = {&LEAF, pico_dns_question_cmp}
+#define PICO_DNS_QTREE_DESTROY(qtree) \
+ pico_tree_destroy(qtree, pico_dns_question_delete)
+
+/* ****************************************************************************
+ * Deletes all the questions with given DNS name from a pico_tree
+ *
+ * @param qtree Pointer to pico_tree-instance which contains DNS questions
+ * @param name Name of the questions you want to delete
+ * @return Returns 0 on success, something else on failure.
+ * ****************************************************************************/
+int
+pico_dns_qtree_del_name( struct pico_tree *qtree,
+ const char *name );
+
+/* ****************************************************************************
+ * Checks whether a question with given name is in the tree or not.
+ *
+ * @param qtree Pointer to pico_tree-instance which contains DNS questions
+ * @param name Name you want to check for
+ * @return 1 when the name is present in the qtree, 0 when it's not.
+ * ****************************************************************************/
+int
+pico_dns_qtree_find_name( struct pico_tree *qtree,
+ const char *name );
+
+/* ****************************************************************************
+ * Definition of DNS record tree
+ * ****************************************************************************/
+typedef struct pico_tree pico_dns_rtree;
+#define PICO_DNS_RTREE_DECLARE(name) \
+ pico_dns_rtree (name) = {&LEAF, pico_dns_record_cmp}
+#define PICO_DNS_RTREE_DESTROY(rtree) \
+ pico_tree_destroy((rtree), pico_dns_record_delete)
+
+/* MARK: DNS PACKET FUNCTIONS */
+
+/* ****************************************************************************
+ * Fills the header section of a DNS packet with the correct flags and section
+ * -counts.
+ *
+ * @param hdr Header to fill in.
+ * @param qdcount Amount of questions added to the packet
+ * @param ancount Amount of answer records added to the packet
+ * @param nscount Amount of authority records added to the packet
+ * @param arcount Amount of additional records added to the packet
+ * ****************************************************************************/
+void
+pico_dns_fill_packet_header( struct pico_dns_header *hdr,
+ uint16_t qdcount,
+ uint16_t ancount,
+ uint16_t authcount,
+ uint16_t addcount );
+
+/* ****************************************************************************
+ * Creates a DNS Query packet with given question and resource records to put
+ * the Resource Record Sections. If a NULL-pointer is provided for a certain
+ * tree, no records will be added to that particular section of the packet.
+ *
+ * @param qtree DNS Questions to put in the Question Section
+ * @param antree DNS Records to put in the Answer Section
+ * @param nstree DNS Records to put in the Authority Section
+ * @param artree DNS Records to put in the Additional Section
+ * @param len Will get filled with the entire size of the packet
+ * @return Pointer to created DNS packet
+ * ****************************************************************************/
+pico_dns_packet *
+pico_dns_query_create( struct pico_tree *qtree,
+ struct pico_tree *antree,
+ struct pico_tree *nstree,
+ struct pico_tree *artree,
+ uint16_t *len );
+
+/* ****************************************************************************
+ * Creates a DNS Answer packet with given resource records to put in the
+ * Resource Record Sections. If a NULL-pointer is provided for a certain tree,
+ * no records will be added to that particular section of the packet.
+ *
+ * @param antree DNS Records to put in the Answer Section
+ * @param nstree DNS Records to put in the Authority Section
+ * @param artree DNS Records to put in the Additional Section
+ * @param len Will get filled with the entire size of the packet
+ * @return Pointer to created DNS packet.
+ * ****************************************************************************/
+pico_dns_packet *
+pico_dns_answer_create( struct pico_tree *antree,
+ struct pico_tree *nstree,
+ struct pico_tree *artree,
+ uint16_t *len );
+
+#endif /* _INCLUDE_PICO_DNS_COMMON */
diff --git a/net/picotcp/modules/pico_dns_sd.h b/net/picotcp/modules/pico_dns_sd.h
new file mode 100644
index 0000000..77f8ef2
--- /dev/null
+++ b/net/picotcp/modules/pico_dns_sd.h
@@ -0,0 +1,90 @@
+/* ****************************************************************************
+ * PicoTCP. Copyright (c) 2014 TASS Belgium NV. Some rights reserved.
+ * See LICENSE and COPYING for usage.
+ * .
+ * Author: Jelle De Vleeschouwer
+ * ****************************************************************************/
+#ifndef INCLUDE_PICO_DNS_SD
+#define INCLUDE_PICO_DNS_SD
+
+#include "pico_mdns.h"
+
+typedef struct
+{
+ char *key;
+ char *value;
+} key_value_pair_t;
+
+typedef struct
+{
+ key_value_pair_t **pairs;
+ uint16_t count;
+} kv_vector;
+
+#define PICO_DNS_SD_KV_VECTOR_DECLARE(name) \
+ kv_vector (name) = {0}
+
+/* ****************************************************************************
+ * Just calls pico_mdns_init in it's turn to initialise the mDNS-module.
+ * See pico_mdns.h for description.
+ * ****************************************************************************/
+int
+pico_dns_sd_init( const char *_hostname,
+ struct pico_ip4 address,
+ void (*callback)(pico_mdns_rtree *,
+ char *,
+ void *),
+ void *arg );
+
+/* ****************************************************************************
+ * Register a DNS-SD service via Multicast DNS on the local network.
+ *
+ * @param name Instance Name of the service, f.e. "Printer 2nd Floor".
+ * @param type ServiceType of the service, f.e. "_http._tcp".
+ * @param port Port number on which the service runs.
+ * @param txt_data TXT data to create TXT record with, need kv_vector-type,
+ * Declare such a type with PICO_DNS_SD_KV_VECTOR_DECLARE(*) &
+ * add key-value pairs with pico_dns_sd_kv_vector_add().
+ * @param ttl TTL
+ * @param callback Callback-function to call when the service is registered.
+ * @return
+ * ****************************************************************************/
+int
+pico_dns_sd_register_service( const char *name,
+ const char *type,
+ uint16_t port,
+ kv_vector *txt_data,
+ uint16_t ttl,
+ void (*callback)(pico_mdns_rtree *,
+ char *,
+ void *),
+ void *arg);
+
+/* ****************************************************************************
+ * Does nothing for now.
+ *
+ * @param type Type to browse for.
+ * @param callback Callback to call when something particular happens.
+ * @return When the module successfully started browsing the servicetype.
+ * ****************************************************************************/
+int
+pico_dns_sd_browse_service( const char *type,
+ void (*callback)(pico_mdns_rtree *,
+ char *,
+ void *),
+ void *arg );
+
+/* ****************************************************************************
+ * Add a key-value pair the a key-value pair vector.
+ *
+ * @param vector Vector to add the pair to.
+ * @param key Key of the pair, cannot be NULL.
+ * @param value Value of the pair, can be NULL, empty ("") or filled ("qkejq")
+ * @return Returns 0 when the pair is added successfully, something else on
+ * failure.
+ * ****************************************************************************/
+int
+pico_dns_sd_kv_vector_add( kv_vector *vector, char *key, char *value );
+
+
+#endif /* _INCLUDE_PICO_DNS_SD */
\ No newline at end of file
diff --git a/net/picotcp/modules/pico_fragments.c b/net/picotcp/modules/pico_fragments.c
new file mode 100644
index 0000000..e6fe44b
--- /dev/null
+++ b/net/picotcp/modules/pico_fragments.c
@@ -0,0 +1,345 @@
+/*********************************************************************
+ PicoTCP. Copyright (c) 2012 TASS Belgium NV. Some rights reserved.
+ See LICENSE and COPYING for usage.
+
+ Authors: Laurens Miers, Daniele Lacamera
+ *********************************************************************/
+
+
+#include "pico_config.h"
+#ifdef PICO_SUPPORT_IPV6
+#include "pico_ipv6.h"
+#include "pico_icmp6.h"
+#endif
+#ifdef PICO_SUPPORT_IPV4
+#include "pico_ipv4.h"
+#include "pico_icmp4.h"
+#endif
+#include "pico_stack.h"
+#include "pico_eth.h"
+#include "pico_udp.h"
+#include "pico_tcp.h"
+#include "pico_socket.h"
+#include "pico_device.h"
+#include "pico_tree.h"
+#include "pico_constants.h"
+#include "pico_fragments.h"
+#define frag_dbg(...) do {} while(0)
+
+#define IP6_FRAG_OFF(x) ((x & 0xFFF8u))
+#define IP6_FRAG_MORE(x) ((x & 0x0001))
+#define IP6_FRAG_ID(x) ((uint32_t)((x->ext.frag.id[0] << 24) + (x->ext.frag.id[1] << 16) + \
+ (x->ext.frag.id[2] << 8) + x->ext.frag.id[3]))
+
+#define IP4_FRAG_OFF(frag) (((uint32_t)frag & PICO_IPV4_FRAG_MASK) << 3ul)
+#define IP4_FRAG_MORE(frag) ((frag & PICO_IPV4_MOREFRAG) ? 1 : 0)
+#define IP4_FRAG_ID(hdr) (hdr->id)
+
+#define FRAG_OFF(net, frag) ((net == PICO_PROTO_IPV4) ? (IP4_FRAG_OFF(frag)) : (IP6_FRAG_OFF(frag)))
+#define FRAG_MORE(net, frag) ((net == PICO_PROTO_IPV4) ? (IP4_FRAG_MORE(frag)) : (IP6_FRAG_MORE(frag)))
+
+#define PICO_IPV6_FRAG_TIMEOUT 60000
+#define PICO_IPV4_FRAG_TIMEOUT 15000
+
+static int pico_ipv6_frag_compare(void *ka, void *kb);
+static int pico_ipv4_frag_compare(void *ka, void *kb);
+static void pico_ipv6_fragments_complete(unsigned int len, uint8_t proto);
+static void pico_ipv4_fragments_complete(unsigned int len, uint8_t proto);
+static void pico_fragments_complete(unsigned int bookmark, uint8_t proto, uint8_t net);
+static int pico_fragments_check_complete(uint8_t proto, uint8_t net);
+static void pico_frag_expire(pico_time now, void *arg);
+static void pico_ipv6_frag_timer_on(void);
+static void pico_ipv4_frag_timer_on(void);
+static int pico_ipv6_frag_match(struct pico_frame *a, struct pico_frame *b);
+static int pico_ipv4_frag_match(struct pico_frame *a, struct pico_frame *b);
+
+static uint32_t ipv6_cur_frag_id = 0u;
+static uint32_t ipv4_cur_frag_id = 0u;
+
+static int pico_ipv6_frag_compare(void *ka, void *kb)
+{
+ struct pico_frame *a = ka, *b = kb;
+ if (IP6_FRAG_OFF(a->frag) > IP6_FRAG_OFF(b->frag))
+ return 1;
+
+ if (IP6_FRAG_OFF(a->frag) < IP6_FRAG_OFF(b->frag))
+ return -1;
+
+ return 0;
+}
+PICO_TREE_DECLARE(ipv6_fragments, pico_ipv6_frag_compare);
+
+struct pico_timer *ipv6_fragments_timer = NULL;
+
+static int pico_ipv4_frag_compare(void *ka, void *kb)
+{
+ struct pico_frame *a = ka, *b = kb;
+ if (IP4_FRAG_OFF(a->frag) > IP4_FRAG_OFF(b->frag))
+ return 1;
+
+ if (IP4_FRAG_OFF(a->frag) < IP4_FRAG_OFF(b->frag))
+ return -1;
+
+ return 0;
+}
+PICO_TREE_DECLARE(ipv4_fragments, pico_ipv4_frag_compare);
+
+struct pico_timer *ipv4_fragments_timer = NULL;
+
+static void pico_ipv6_fragments_complete(unsigned int len, uint8_t proto)
+{
+ struct pico_tree_node *index, *tmp;
+ struct pico_frame *f;
+ unsigned int bookmark = 0;
+ struct pico_frame *full = NULL;
+ struct pico_frame *first = pico_tree_first(&ipv6_fragments);
+
+ full = pico_frame_alloc((uint16_t)(PICO_SIZE_IP6HDR + len));
+ if (full) {
+ full->net_hdr = full->buffer;
+ full->net_len = PICO_SIZE_IP6HDR;
+ memcpy(full->net_hdr, first->net_hdr, full->net_len);
+ full->transport_hdr = full->net_hdr + full->net_len;
+ full->transport_len = (uint16_t)len;
+ full->dev = first->dev;
+ pico_tree_foreach_safe(index, &ipv6_fragments, tmp) {
+ f = index->keyValue;
+ memcpy(full->transport_hdr + bookmark, f->transport_hdr, f->transport_len);
+ bookmark += f->transport_len;
+ pico_tree_delete(&ipv6_fragments, f);
+ pico_frame_discard(f);
+ }
+ pico_transport_receive(full, proto);
+ if (ipv6_fragments_timer) {
+ pico_timer_cancel(ipv6_fragments_timer);
+ ipv6_fragments_timer = NULL;
+ }
+ }
+}
+
+static void pico_ipv4_fragments_complete(unsigned int len, uint8_t proto)
+{
+ struct pico_tree_node *index, *tmp;
+ struct pico_frame *f;
+ unsigned int bookmark = 0;
+ struct pico_frame *full = NULL;
+ struct pico_frame *first = pico_tree_first(&ipv4_fragments);
+
+ full = pico_frame_alloc((uint16_t)(PICO_SIZE_IP4HDR + len));
+ if (full) {
+ full->net_hdr = full->buffer;
+ full->net_len = PICO_SIZE_IP4HDR;
+ memcpy(full->net_hdr, first->net_hdr, full->net_len);
+ full->transport_hdr = full->net_hdr + full->net_len;
+ full->transport_len = (uint16_t)len;
+ full->dev = first->dev;
+ pico_tree_foreach_safe(index, &ipv4_fragments, tmp) {
+ f = index->keyValue;
+ memcpy(full->transport_hdr + bookmark, f->transport_hdr, f->transport_len);
+ bookmark += f->transport_len;
+ pico_tree_delete(&ipv4_fragments, f);
+ pico_frame_discard(f);
+ }
+ pico_transport_receive(full, proto);
+ if (ipv4_fragments_timer) {
+ pico_timer_cancel(ipv4_fragments_timer);
+ ipv4_fragments_timer = NULL;
+ }
+ }
+}
+
+static void pico_fragments_complete(unsigned int bookmark, uint8_t proto, uint8_t net)
+{
+ if (net == PICO_PROTO_IPV4)
+ {
+ pico_ipv4_fragments_complete(bookmark, proto);
+ }
+ else
+ {
+ pico_ipv6_fragments_complete(bookmark, proto);
+ }
+}
+
+static int pico_fragments_check_complete(uint8_t proto, uint8_t net)
+{
+ struct pico_tree_node *index, *temp;
+ struct pico_frame *cur;
+ unsigned int bookmark = 0;
+ struct pico_tree *tree = NULL;
+
+ if (net == PICO_PROTO_IPV4)
+ {
+ tree = &ipv4_fragments;
+ }
+ else
+ {
+ tree = &ipv6_fragments;
+ }
+
+
+ pico_tree_foreach_safe(index, tree, temp) {
+ cur = index->keyValue;
+ if (FRAG_OFF(net, cur->frag) != bookmark)
+ return 0;
+
+ bookmark += cur->transport_len;
+ if (!FRAG_MORE(net, cur->frag)) {
+ pico_fragments_complete(bookmark, proto, net);
+ return 1;
+ }
+ }
+ return 0;
+}
+
+static void pico_frag_expire(pico_time now, void *arg)
+{
+ struct pico_tree_node *index, *tmp;
+ struct pico_frame *f = NULL;
+ struct pico_tree *tree = (struct pico_tree *) arg;
+ struct pico_frame *first = NULL;
+ uint8_t net = 0;
+ (void)now;
+
+ if (!tree)
+ {
+ frag_dbg("Expired packet but no tree supplied!\n");
+ return;
+ }
+
+ first = pico_tree_first(tree);
+
+ if (!first) {
+ frag_dbg("not first - not sending notify\n");
+ return;
+ }
+
+ if (IS_IPV4(first))
+ {
+ net = PICO_PROTO_IPV4;
+ frag_dbg("Packet expired! ID:%hu\n", ipv4_cur_frag_id);
+ }
+ else
+ {
+ net = PICO_PROTO_IPV6;
+ frag_dbg("Packet expired! ID:%hu\n", ipv6_cur_frag_id);
+ }
+
+ /* Empty the tree */
+ pico_tree_foreach_safe(index, tree, tmp) {
+ f = index->keyValue;
+ pico_tree_delete(tree, f);
+ if (f != first)
+ pico_frame_discard(f); /* Later, after ICMP notification...*/
+
+ }
+
+ if (((FRAG_OFF(net, first->frag) == 0) && (pico_frame_dst_is_unicast(first))))
+ {
+ frag_dbg("sending notify\n");
+ pico_notify_frag_expired(first);
+ }
+
+ if (f)
+ pico_tree_delete(tree, f);
+
+ pico_frame_discard(first);
+}
+
+static void pico_ipv6_frag_timer_on(void)
+{
+ ipv6_fragments_timer = pico_timer_add(PICO_IPV6_FRAG_TIMEOUT, pico_frag_expire, &ipv6_fragments);
+}
+
+static void pico_ipv4_frag_timer_on(void)
+{
+ ipv4_fragments_timer = pico_timer_add( PICO_IPV4_FRAG_TIMEOUT, pico_frag_expire, &ipv4_fragments);
+}
+
+
+static int pico_ipv6_frag_match(struct pico_frame *a, struct pico_frame *b)
+{
+ struct pico_ipv6_hdr *ha, *hb;
+ if (!a || !b)
+ return 0;
+
+ ha = (struct pico_ipv6_hdr *)a->net_hdr;
+ hb = (struct pico_ipv6_hdr *)b->net_hdr;
+ if (!ha || !hb)
+ return 0;
+
+ if (memcmp(ha->src.addr, hb->src.addr, PICO_SIZE_IP6) != 0)
+ return 0;
+
+ if (memcmp(ha->dst.addr, hb->dst.addr, PICO_SIZE_IP6) != 0)
+ return 0;
+
+ return 1;
+}
+
+static int pico_ipv4_frag_match(struct pico_frame *a, struct pico_frame *b)
+{
+ struct pico_ipv4_hdr *ha, *hb;
+ if (!a || !b)
+ return 0;
+
+ ha = (struct pico_ipv4_hdr *)a->net_hdr;
+ hb = (struct pico_ipv4_hdr *)b->net_hdr;
+ if (!ha || !hb)
+ return 0;
+
+ if (memcmp(&(ha->src.addr), &(hb->src.addr), PICO_SIZE_IP4) != 0)
+ return 0;
+
+ if (memcmp(&(ha->dst.addr), &(hb->dst.addr), PICO_SIZE_IP4) != 0)
+ return 0;
+
+ return 1;
+}
+
+
+void pico_ipv6_process_frag(struct pico_ipv6_exthdr *frag, struct pico_frame *f, uint8_t proto)
+{
+ struct pico_frame *first = pico_tree_first(&ipv6_fragments);
+
+ if (!first) {
+ if (ipv6_cur_frag_id && (IP6_FRAG_ID(frag) == ipv6_cur_frag_id)) {
+ /* Discard late arrivals, without firing the timer.
+ */
+ frag_dbg("discarded late arrival, exp:%hu found:%hu\n", ipv6_cur_frag_id, IP6_FRAG_ID(frag));
+ return;
+ }
+
+ pico_ipv6_frag_timer_on();
+ ipv6_cur_frag_id = IP6_FRAG_ID(frag);
+ frag_dbg("Started new reassembly, ID:%hu\n", ipv6_cur_frag_id);
+ }
+
+ if (!first || (pico_ipv6_frag_match(f, first) && (IP6_FRAG_ID(frag) == ipv6_cur_frag_id))) {
+ pico_tree_insert(&ipv6_fragments, pico_frame_copy(f));
+ }
+
+ pico_fragments_check_complete(proto, PICO_PROTO_IPV6);
+}
+
+void pico_ipv4_process_frag(struct pico_ipv4_hdr *hdr, struct pico_frame *f, uint8_t proto)
+{
+ struct pico_frame *first = pico_tree_first(&ipv4_fragments);
+
+ f->frag = short_be(hdr->frag);
+ if (!first) {
+ if (ipv4_cur_frag_id && (IP4_FRAG_ID(hdr) == ipv4_cur_frag_id)) {
+ /* Discard late arrivals, without firing the timer,
+ */
+ return;
+ }
+
+ pico_ipv4_frag_timer_on();
+ ipv4_cur_frag_id = IP4_FRAG_ID(hdr);
+ }
+
+ if (!first || (pico_ipv4_frag_match(f, first) && (IP4_FRAG_ID(hdr) == ipv4_cur_frag_id))) {
+ pico_tree_insert(&ipv4_fragments, pico_frame_copy(f));
+ }
+
+ pico_fragments_check_complete(proto, PICO_PROTO_IPV4);
+}
diff --git a/net/picotcp/modules/pico_fragments.h b/net/picotcp/modules/pico_fragments.h
new file mode 100644
index 0000000..e51ec44
--- /dev/null
+++ b/net/picotcp/modules/pico_fragments.h
@@ -0,0 +1,11 @@
+#ifndef PICO_FRAGMENTS_H
+#define PICO_FRAGMENTS_H
+#include "pico_ipv4.h"
+#include "pico_ipv6.h"
+#include "pico_addressing.h"
+#include "pico_frame.h"
+
+void pico_ipv6_process_frag(struct pico_ipv6_exthdr *frag, struct pico_frame *f, uint8_t proto);
+void pico_ipv4_process_frag(struct pico_ipv4_hdr *hdr, struct pico_frame *f, uint8_t proto);
+
+#endif
diff --git a/net/picotcp/modules/pico_icmp4.c b/net/picotcp/modules/pico_icmp4.c
new file mode 100644
index 0000000..da3d89c
--- /dev/null
+++ b/net/picotcp/modules/pico_icmp4.c
@@ -0,0 +1,395 @@
+/*********************************************************************
+ PicoTCP. Copyright (c) 2012-2015 Altran Intelligent Systems. Some rights reserved.
+ See LICENSE and COPYING for usage.
+
+ .
+
+ Authors: Daniele Lacamera
+ *********************************************************************/
+
+
+#include "pico_icmp4.h"
+#include "pico_config.h"
+#include "pico_ipv4.h"
+#include "pico_eth.h"
+#include "pico_device.h"
+#include "pico_stack.h"
+#include "pico_tree.h"
+
+/* Queues */
+static struct pico_queue icmp_in = {
+ 0
+};
+static struct pico_queue icmp_out = {
+ 0
+};
+
+
+/* Functions */
+
+static int pico_icmp4_checksum(struct pico_frame *f)
+{
+ struct pico_icmp4_hdr *hdr = (struct pico_icmp4_hdr *) f->transport_hdr;
+ if (!hdr) {
+ pico_err = PICO_ERR_EINVAL;
+ return -1;
+ }
+
+ hdr->crc = 0;
+ hdr->crc = short_be(pico_checksum(hdr, f->transport_len));
+ return 0;
+}
+
+#ifdef PICO_SUPPORT_PING
+static void ping_recv_reply(struct pico_frame *f);
+#endif
+
+static int pico_icmp4_process_in(struct pico_protocol *self, struct pico_frame *f)
+{
+ struct pico_icmp4_hdr *hdr = (struct pico_icmp4_hdr *) f->transport_hdr;
+ static int firstpkt = 1;
+ static uint16_t last_id = 0;
+ static uint16_t last_seq = 0;
+ IGNORE_PARAMETER(self);
+
+ if (hdr->type == PICO_ICMP_ECHO) {
+ hdr->type = PICO_ICMP_ECHOREPLY;
+ /* outgoing frames require a f->len without the ethernet header len */
+ if (f->dev && f->dev->eth)
+ f->len -= PICO_SIZE_ETHHDR;
+
+ if (!firstpkt && (hdr->hun.ih_idseq.idseq_id == last_id) && (last_seq == hdr->hun.ih_idseq.idseq_seq)) {
+ /* The network duplicated the echo. Do not reply. */
+ pico_frame_discard(f);
+ return 0;
+ }
+
+ firstpkt = 0;
+ last_id = hdr->hun.ih_idseq.idseq_id;
+ last_seq = hdr->hun.ih_idseq.idseq_seq;
+ pico_icmp4_checksum(f);
+ pico_ipv4_rebound(f);
+ } else if (hdr->type == PICO_ICMP_UNREACH) {
+ f->net_hdr = f->transport_hdr + PICO_ICMPHDR_UN_SIZE;
+ pico_ipv4_unreachable(f, hdr->code);
+ } else if (hdr->type == PICO_ICMP_ECHOREPLY) {
+#ifdef PICO_SUPPORT_PING
+ ping_recv_reply(f);
+#endif
+ pico_frame_discard(f);
+ } else {
+ pico_frame_discard(f);
+ }
+
+ return 0;
+}
+
+static int pico_icmp4_process_out(struct pico_protocol *self, struct pico_frame *f)
+{
+ IGNORE_PARAMETER(self);
+ IGNORE_PARAMETER(f);
+ dbg("Called %s\n", __FUNCTION__);
+ return 0;
+}
+
+/* Interface: protocol definition */
+struct pico_protocol pico_proto_icmp4 = {
+ .name = "icmp4",
+ .proto_number = PICO_PROTO_ICMP4,
+ .layer = PICO_LAYER_TRANSPORT,
+ .process_in = pico_icmp4_process_in,
+ .process_out = pico_icmp4_process_out,
+ .q_in = &icmp_in,
+ .q_out = &icmp_out,
+};
+
+static int pico_icmp4_notify(struct pico_frame *f, uint8_t type, uint8_t code)
+{
+ struct pico_frame *reply;
+ struct pico_icmp4_hdr *hdr;
+ struct pico_ipv4_hdr *info;
+ uint16_t f_tot_len;
+
+ f_tot_len = short_be(((struct pico_ipv4_hdr *)f->net_hdr)->len);
+
+ if (f_tot_len < (sizeof(struct pico_ipv4_hdr)))
+ return -1;
+
+ /* Truncate tot len to be at most 8 bytes + iphdr */
+ if (f_tot_len > (sizeof(struct pico_ipv4_hdr) + 8u)) {
+ f_tot_len = (sizeof(struct pico_ipv4_hdr) + 8u);
+ }
+
+ if (f == NULL) {
+ pico_err = PICO_ERR_EINVAL;
+ return -1;
+ }
+
+ reply = pico_proto_ipv4.alloc(&pico_proto_ipv4, (uint16_t) (f_tot_len + PICO_ICMPHDR_UN_SIZE));
+ info = (struct pico_ipv4_hdr*)(f->net_hdr);
+ hdr = (struct pico_icmp4_hdr *) reply->transport_hdr;
+ hdr->type = type;
+ hdr->code = code;
+ hdr->hun.ih_pmtu.ipm_nmtu = short_be(1500);
+ hdr->hun.ih_pmtu.ipm_void = 0;
+ reply->transport_len = (uint16_t)(f_tot_len + PICO_ICMPHDR_UN_SIZE);
+ reply->payload = reply->transport_hdr + PICO_ICMPHDR_UN_SIZE;
+ memcpy(reply->payload, f->net_hdr, f_tot_len);
+ pico_icmp4_checksum(reply);
+ pico_ipv4_frame_push(reply, &info->src, PICO_PROTO_ICMP4);
+ return 0;
+}
+
+int pico_icmp4_port_unreachable(struct pico_frame *f)
+{
+ /*Parameter check executed in pico_icmp4_notify*/
+ return pico_icmp4_notify(f, PICO_ICMP_UNREACH, PICO_ICMP_UNREACH_PORT);
+}
+
+int pico_icmp4_proto_unreachable(struct pico_frame *f)
+{
+ /*Parameter check executed in pico_icmp4_notify*/
+ return pico_icmp4_notify(f, PICO_ICMP_UNREACH, PICO_ICMP_UNREACH_PROTOCOL);
+}
+
+int pico_icmp4_dest_unreachable(struct pico_frame *f)
+{
+ /*Parameter check executed in pico_icmp4_notify*/
+ return pico_icmp4_notify(f, PICO_ICMP_UNREACH, PICO_ICMP_UNREACH_HOST);
+}
+
+int pico_icmp4_ttl_expired(struct pico_frame *f)
+{
+ /*Parameter check executed in pico_icmp4_notify*/
+ return pico_icmp4_notify(f, PICO_ICMP_TIME_EXCEEDED, PICO_ICMP_TIMXCEED_INTRANS);
+}
+
+MOCKABLE int pico_icmp4_frag_expired(struct pico_frame *f)
+{
+ /*Parameter check executed in pico_icmp4_notify*/
+ return pico_icmp4_notify(f, PICO_ICMP_TIME_EXCEEDED, PICO_ICMP_TIMXCEED_REASS);
+}
+
+int pico_icmp4_mtu_exceeded(struct pico_frame *f)
+{
+ /*Parameter check executed in pico_icmp4_notify*/
+ return pico_icmp4_notify(f, PICO_ICMP_UNREACH, PICO_ICMP_UNREACH_NEEDFRAG);
+}
+
+int pico_icmp4_packet_filtered(struct pico_frame *f)
+{
+ /*Parameter check executed in pico_icmp4_notify*/
+ /*Packet Filtered: type 3, code 13 (Communication Administratively Prohibited)*/
+ return pico_icmp4_notify(f, PICO_ICMP_UNREACH, PICO_ICMP_UNREACH_FILTER_PROHIB);
+}
+
+int pico_icmp4_param_problem(struct pico_frame *f, uint8_t code)
+{
+ return pico_icmp4_notify(f, PICO_ICMP_PARAMPROB, code);
+}
+
+/***********************/
+/* Ping implementation */
+/***********************/
+/***********************/
+/***********************/
+/***********************/
+
+
+#ifdef PICO_SUPPORT_PING
+
+
+struct pico_icmp4_ping_cookie
+{
+ struct pico_ip4 dst;
+ uint16_t err;
+ uint16_t id;
+ uint16_t seq;
+ uint16_t size;
+ int count;
+ pico_time timestamp;
+ int interval;
+ int timeout;
+ void (*cb)(struct pico_icmp4_stats*);
+};
+
+static int cookie_compare(void *ka, void *kb)
+{
+ struct pico_icmp4_ping_cookie *a = ka, *b = kb;
+ if (a->id < b->id)
+ return -1;
+
+ if (a->id > b->id)
+ return 1;
+
+ return (a->seq - b->seq);
+}
+
+PICO_TREE_DECLARE(Pings, cookie_compare);
+
+static int8_t pico_icmp4_send_echo(struct pico_icmp4_ping_cookie *cookie)
+{
+ struct pico_frame *echo = pico_proto_ipv4.alloc(&pico_proto_ipv4, (uint16_t)(PICO_ICMPHDR_UN_SIZE + cookie->size));
+ struct pico_icmp4_hdr *hdr;
+ if (!echo) {
+ return -1;
+ }
+
+ hdr = (struct pico_icmp4_hdr *) echo->transport_hdr;
+
+ hdr->type = PICO_ICMP_ECHO;
+ hdr->code = 0;
+ hdr->hun.ih_idseq.idseq_id = short_be(cookie->id);
+ hdr->hun.ih_idseq.idseq_seq = short_be(cookie->seq);
+ echo->transport_len = (uint16_t)(PICO_ICMPHDR_UN_SIZE + cookie->size);
+ echo->payload = echo->transport_hdr + PICO_ICMPHDR_UN_SIZE;
+ echo->payload_len = cookie->size;
+ /* XXX: Fill payload */
+ pico_icmp4_checksum(echo);
+ pico_ipv4_frame_push(echo, &cookie->dst, PICO_PROTO_ICMP4);
+ return 0;
+}
+
+
+static void ping_timeout(pico_time now, void *arg)
+{
+ struct pico_icmp4_ping_cookie *cookie = (struct pico_icmp4_ping_cookie *)arg;
+ IGNORE_PARAMETER(now);
+
+ if(pico_tree_findKey(&Pings, cookie)) {
+ if (cookie->err == PICO_PING_ERR_PENDING) {
+ struct pico_icmp4_stats stats;
+ stats.dst = cookie->dst;
+ stats.seq = cookie->seq;
+ stats.time = 0;
+ stats.size = cookie->size;
+ stats.err = PICO_PING_ERR_TIMEOUT;
+ dbg(" ---- Ping timeout!!!\n");
+ cookie->cb(&stats);
+ }
+
+ pico_tree_delete(&Pings, cookie);
+ PICO_FREE(cookie);
+ }
+}
+
+static void next_ping(pico_time now, void *arg);
+static inline void send_ping(struct pico_icmp4_ping_cookie *cookie)
+{
+ pico_icmp4_send_echo(cookie);
+ cookie->timestamp = pico_tick;
+ pico_timer_add((uint32_t)cookie->timeout, ping_timeout, cookie);
+ if (cookie->seq < (uint16_t)cookie->count)
+ pico_timer_add((uint32_t)cookie->interval, next_ping, cookie);
+}
+
+static void next_ping(pico_time now, void *arg)
+{
+ struct pico_icmp4_ping_cookie *newcookie, *cookie = (struct pico_icmp4_ping_cookie *)arg;
+ IGNORE_PARAMETER(now);
+
+ if(pico_tree_findKey(&Pings, cookie)) {
+ if (cookie->err == PICO_PING_ERR_ABORTED)
+ return;
+
+ if (cookie->seq < (uint16_t)cookie->count) {
+ newcookie = PICO_ZALLOC(sizeof(struct pico_icmp4_ping_cookie));
+ if (!newcookie)
+ return;
+
+ memcpy(newcookie, cookie, sizeof(struct pico_icmp4_ping_cookie));
+ newcookie->seq++;
+
+ pico_tree_insert(&Pings, newcookie);
+ send_ping(newcookie);
+ }
+ }
+}
+
+
+static void ping_recv_reply(struct pico_frame *f)
+{
+ struct pico_icmp4_ping_cookie test, *cookie;
+ struct pico_icmp4_hdr *hdr = (struct pico_icmp4_hdr *) f->transport_hdr;
+ test.id = short_be(hdr->hun.ih_idseq.idseq_id );
+ test.seq = short_be(hdr->hun.ih_idseq.idseq_seq);
+
+ cookie = pico_tree_findKey(&Pings, &test);
+ if (cookie) {
+ struct pico_icmp4_stats stats;
+ if (cookie->err == PICO_PING_ERR_ABORTED)
+ return;
+
+ cookie->err = PICO_PING_ERR_REPLIED;
+ stats.dst = ((struct pico_ipv4_hdr *)f->net_hdr)->src;
+ stats.seq = cookie->seq;
+ stats.size = cookie->size;
+ stats.time = pico_tick - cookie->timestamp;
+ stats.err = cookie->err;
+ stats.ttl = ((struct pico_ipv4_hdr *)f->net_hdr)->ttl;
+ if(cookie->cb != NULL)
+ cookie->cb(&stats);
+ } else {
+ dbg("Reply for seq=%d, not found.\n", test.seq);
+ }
+}
+
+int pico_icmp4_ping(char *dst, int count, int interval, int timeout, int size, void (*cb)(struct pico_icmp4_stats *))
+{
+ static uint16_t next_id = 0x91c0;
+ struct pico_icmp4_ping_cookie *cookie;
+
+ if((dst == NULL) || (interval == 0) || (timeout == 0) || (count == 0)) {
+ pico_err = PICO_ERR_EINVAL;
+ return -1;
+ }
+
+ cookie = PICO_ZALLOC(sizeof(struct pico_icmp4_ping_cookie));
+ if (!cookie) {
+ pico_err = PICO_ERR_ENOMEM;
+ return -1;
+ }
+
+ if (pico_string_to_ipv4(dst, (uint32_t *)&cookie->dst.addr) < 0) {
+ pico_err = PICO_ERR_EINVAL;
+ PICO_FREE(cookie);
+ return -1;
+ }
+
+ cookie->seq = 1;
+ cookie->id = next_id++;
+ cookie->err = PICO_PING_ERR_PENDING;
+ cookie->size = (uint16_t)size;
+ cookie->interval = interval;
+ cookie->timeout = timeout;
+ cookie->cb = cb;
+ cookie->count = count;
+
+ pico_tree_insert(&Pings, cookie);
+ send_ping(cookie);
+
+ return cookie->id;
+
+}
+
+int pico_icmp4_ping_abort(int id)
+{
+ struct pico_tree_node *node;
+ int found = 0;
+ pico_tree_foreach(node, &Pings)
+ {
+ struct pico_icmp4_ping_cookie *ck =
+ (struct pico_icmp4_ping_cookie *) node->keyValue;
+ if (ck->id == (uint16_t)id) {
+ ck->err = PICO_PING_ERR_ABORTED;
+ found++;
+ }
+ }
+ if (found > 0)
+ return 0; /* OK if at least one pending ping has been canceled */
+
+ pico_err = PICO_ERR_ENOENT;
+ return -1;
+}
+
+#endif
diff --git a/net/picotcp/modules/pico_icmp4.h b/net/picotcp/modules/pico_icmp4.h
new file mode 100644
index 0000000..45f0a62
--- /dev/null
+++ b/net/picotcp/modules/pico_icmp4.h
@@ -0,0 +1,162 @@
+/*********************************************************************
+ PicoTCP. Copyright (c) 2012-2015 Altran Intelligent Systems. Some rights reserved.
+ See LICENSE and COPYING for usage.
+
+ .
+
+ *********************************************************************/
+#ifndef INCLUDE_PICO_ICMP4
+#define INCLUDE_PICO_ICMP4
+#include "pico_defines.h"
+#include "pico_addressing.h"
+#include "pico_protocol.h"
+
+
+extern struct pico_protocol pico_proto_icmp4;
+
+PACKED_STRUCT_DEF pico_icmp4_hdr {
+ uint8_t type;
+ uint8_t code;
+ uint16_t crc;
+
+ /* hun */
+ PACKED_UNION_DEF hun_u {
+ uint8_t ih_pptr;
+ struct pico_ip4 ih_gwaddr;
+ PEDANTIC_STRUCT_DEF ih_idseq_s {
+ uint16_t idseq_id;
+ uint16_t idseq_seq;
+ } ih_idseq;
+ uint32_t ih_void;
+ PEDANTIC_STRUCT_DEF ih_pmtu_s {
+ uint16_t ipm_void;
+ uint16_t ipm_nmtu;
+ } ih_pmtu;
+ PEDANTIC_STRUCT_DEF ih_rta_s {
+ uint8_t rta_numgw;
+ uint8_t rta_wpa;
+ uint16_t rta_lifetime;
+ } ih_rta;
+ } hun;
+
+ /* dun */
+ PACKED_UNION_DEF dun_u {
+ PEDANTIC_STRUCT_DEF id_ts_s {
+ uint32_t ts_otime;
+ uint32_t ts_rtime;
+ uint32_t ts_ttime;
+ } id_ts;
+ PEDANTIC_STRUCT_DEF id_ip_s {
+ uint32_t ip_options;
+ uint32_t ip_data_hi;
+ uint32_t ip_data_lo;
+ } id_ip;
+ PEDANTIC_STRUCT_DEF id_ra_s {
+ uint32_t ira_addr;
+ uint32_t ira_pref;
+ } id_ra;
+ uint32_t id_mask;
+ uint8_t id_data[1];
+ } dun;
+};
+
+#define PICO_ICMPHDR_DRY_SIZE 4
+#define PICO_ICMPHDR_UN_SIZE 8u
+
+#define PICO_ICMP_ECHOREPLY 0
+#define PICO_ICMP_DEST_UNREACH 3
+#define PICO_ICMP_SOURCE_QUENCH 4
+#define PICO_ICMP_REDIRECT 5
+#define PICO_ICMP_ECHO 8
+#define PICO_ICMP_TIME_EXCEEDED 11
+#define PICO_ICMP_PARAMETERPROB 12
+#define PICO_ICMP_TIMESTAMP 13
+#define PICO_ICMP_TIMESTAMPREPLY 14
+#define PICO_ICMP_INFO_REQUEST 15
+#define PICO_ICMP_INFO_REPLY 16
+#define PICO_ICMP_ADDRESS 17
+#define PICO_ICMP_ADDRESSREPLY 18
+
+
+#define PICO_ICMP_UNREACH 3
+#define PICO_ICMP_SOURCEQUENCH 4
+#define PICO_ICMP_ROUTERADVERT 9
+#define PICO_ICMP_ROUTERSOLICIT 10
+#define PICO_ICMP_TIMXCEED 11
+#define PICO_ICMP_PARAMPROB 12
+#define PICO_ICMP_TSTAMP 13
+#define PICO_ICMP_TSTAMPREPLY 14
+#define PICO_ICMP_IREQ 15
+#define PICO_ICMP_IREQREPLY 16
+#define PICO_ICMP_MASKREQ 17
+#define PICO_ICMP_MASKREPLY 18
+
+#define PICO_ICMP_MAXTYPE 18
+
+
+#define PICO_ICMP_UNREACH_NET 0
+#define PICO_ICMP_UNREACH_HOST 1
+#define PICO_ICMP_UNREACH_PROTOCOL 2
+#define PICO_ICMP_UNREACH_PORT 3
+#define PICO_ICMP_UNREACH_NEEDFRAG 4
+#define PICO_ICMP_UNREACH_SRCFAIL 5
+#define PICO_ICMP_UNREACH_NET_UNKNOWN 6
+#define PICO_ICMP_UNREACH_HOST_UNKNOWN 7
+#define PICO_ICMP_UNREACH_ISOLATED 8
+#define PICO_ICMP_UNREACH_NET_PROHIB 9
+#define PICO_ICMP_UNREACH_HOST_PROHIB 10
+#define PICO_ICMP_UNREACH_TOSNET 11
+#define PICO_ICMP_UNREACH_TOSHOST 12
+#define PICO_ICMP_UNREACH_FILTER_PROHIB 13
+#define PICO_ICMP_UNREACH_HOST_PRECEDENCE 14
+#define PICO_ICMP_UNREACH_PRECEDENCE_CUTOFF 15
+
+
+#define PICO_ICMP_REDIRECT_NET 0
+#define PICO_ICMP_REDIRECT_HOST 1
+#define PICO_ICMP_REDIRECT_TOSNET 2
+#define PICO_ICMP_REDIRECT_TOSHOST 3
+
+
+#define PICO_ICMP_TIMXCEED_INTRANS 0
+#define PICO_ICMP_TIMXCEED_REASS 1
+
+
+#define PICO_ICMP_PARAMPROB_OPTABSENT 1
+
+#define PICO_SIZE_ICMP4HDR ((sizeof(struct pico_icmp4_hdr)))
+
+struct pico_icmp4_stats
+{
+ struct pico_ip4 dst;
+ unsigned long size;
+ unsigned long seq;
+ pico_time time;
+ unsigned long ttl;
+ int err;
+};
+
+int pico_icmp4_port_unreachable(struct pico_frame *f);
+int pico_icmp4_proto_unreachable(struct pico_frame *f);
+int pico_icmp4_dest_unreachable(struct pico_frame *f);
+int pico_icmp4_mtu_exceeded(struct pico_frame *f);
+int pico_icmp4_ttl_expired(struct pico_frame *f);
+int pico_icmp4_frag_expired(struct pico_frame *f);
+int pico_icmp4_ping(char *dst, int count, int interval, int timeout, int size, void (*cb)(struct pico_icmp4_stats *));
+int pico_icmp4_ping_abort(int id);
+
+#ifdef PICO_SUPPORT_ICMP4
+int pico_icmp4_packet_filtered(struct pico_frame *f);
+int pico_icmp4_param_problem(struct pico_frame *f, uint8_t code);
+#else
+# define pico_icmp4_packet_filtered(f) (-1)
+# define pico_icmp4_param_problem(f, c) (-1)
+#endif /* PICO_SUPPORT_ICMP4 */
+
+#define PICO_PING_ERR_REPLIED 0
+#define PICO_PING_ERR_TIMEOUT 1
+#define PICO_PING_ERR_UNREACH 2
+#define PICO_PING_ERR_ABORTED 3
+#define PICO_PING_ERR_PENDING 0xFFFF
+
+#endif
diff --git a/net/picotcp/modules/pico_icmp6.h b/net/picotcp/modules/pico_icmp6.h
new file mode 100644
index 0000000..90e8223
--- /dev/null
+++ b/net/picotcp/modules/pico_icmp6.h
@@ -0,0 +1,259 @@
+/*********************************************************************
+ PicoTCP. Copyright (c) 2012-2015 Altran Intelligent Systems. Some rights reserved.
+ See LICENSE and COPYING for usage.
+
+ .
+
+ *********************************************************************/
+#ifndef _INCLUDE_PICO_ICMP6
+#define _INCLUDE_PICO_ICMP6
+#include "pico_addressing.h"
+#include "pico_protocol.h"
+
+/* ICMP header sizes */
+#define PICO_ICMP6HDR_DRY_SIZE 4
+#define PICO_ICMP6HDR_ECHO_REQUEST_SIZE 8
+#define PICO_ICMP6HDR_DEST_UNREACH_SIZE 8
+#define PICO_ICMP6HDR_TIME_XCEEDED_SIZE 8
+#define PICO_ICMP6HDR_PARAM_PROBLEM_SIZE 8
+#define PICO_ICMP6HDR_NEIGH_SOL_SIZE 24
+#define PICO_ICMP6HDR_NEIGH_ADV_SIZE 24
+#define PICO_ICMP6HDR_ROUTER_SOL_SIZE 8
+#define PICO_ICMP6HDR_ROUTER_ADV_SIZE 16
+#define PICO_ICMP6HDR_REDIRECT_SIZE 40
+
+/* ICMP types */
+#define PICO_ICMP6_DEST_UNREACH 1
+#define PICO_ICMP6_PKT_TOO_BIG 2
+#define PICO_ICMP6_TIME_EXCEEDED 3
+#define PICO_ICMP6_PARAM_PROBLEM 4
+#define PICO_ICMP6_ECHO_REQUEST 128
+#define PICO_ICMP6_ECHO_REPLY 129
+#define PICO_ICMP6_ROUTER_SOL 133
+#define PICO_ICMP6_ROUTER_ADV 134
+#define PICO_ICMP6_NEIGH_SOL 135
+#define PICO_ICMP6_NEIGH_ADV 136
+#define PICO_ICMP6_REDIRECT 137
+
+/* destination unreachable codes */
+#define PICO_ICMP6_UNREACH_NOROUTE 0
+#define PICO_ICMP6_UNREACH_ADMIN 1
+#define PICO_ICMP6_UNREACH_SRCSCOPE 2
+#define PICO_ICMP6_UNREACH_ADDR 3
+#define PICO_ICMP6_UNREACH_PORT 4
+#define PICO_ICMP6_UNREACH_SRCFILTER 5
+#define PICO_ICMP6_UNREACH_REJROUTE 6
+
+/* time exceeded codes */
+#define PICO_ICMP6_TIMXCEED_INTRANS 0
+#define PICO_ICMP6_TIMXCEED_REASS 1
+
+/* parameter problem codes */
+#define PICO_ICMP6_PARAMPROB_HDRFIELD 0
+#define PICO_ICMP6_PARAMPROB_NXTHDR 1
+#define PICO_ICMP6_PARAMPROB_IPV6OPT 2
+
+/* ping error codes */
+#define PICO_PING6_ERR_REPLIED 0
+#define PICO_PING6_ERR_TIMEOUT 1
+#define PICO_PING6_ERR_UNREACH 2
+#define PICO_PING6_ERR_ABORTED 3
+#define PICO_PING6_ERR_PENDING 0xFFFF
+
+/* ND configuration */
+#define PICO_ND_MAX_FRAMES_QUEUED 4 /* max frames queued while awaiting address resolution */
+
+/* ND RFC constants */
+#define PICO_ND_MAX_SOLICIT 3
+#define PICO_ND_MAX_NEIGHBOR_ADVERT 3
+#define PICO_ND_DELAY_INCOMPLETE 1000 /* msec */
+#define PICO_ND_DELAY_FIRST_PROBE_TIME 5000 /* msec */
+
+/* neighbor discovery options */
+#define PICO_ND_OPT_LLADDR_SRC 1
+#define PICO_ND_OPT_LLADDR_TGT 2
+#define PICO_ND_OPT_PREFIX 3
+#define PICO_ND_OPT_REDIRECT 4
+#define PICO_ND_OPT_MTU 5
+#define PICO_ND_OPT_RDNSS 25 /* RFC 5006 */
+
+/* ND advertisement flags */
+#define PICO_ND_ROUTER 0x80000000
+#define PICO_ND_SOLICITED 0x40000000
+#define PICO_ND_OVERRIDE 0x20000000
+#define IS_ROUTER(x) (long_be(x->msg.info.neigh_adv.rsor) & (PICO_ND_ROUTER)) /* router flag set? */
+#define IS_SOLICITED(x) (long_be(x->msg.info.neigh_adv.rsor) & (PICO_ND_SOLICITED)) /* solicited flag set? */
+#define IS_OVERRIDE(x) (long_be(x->msg.info.neigh_adv.rsor) & (PICO_ND_OVERRIDE)) /* override flag set? */
+
+#define PICO_ND_PREFIX_LIFETIME_INF 0xFFFFFFFFu
+/* #define PICO_ND_DESTINATION_LRU_TIME 600000u / * msecs (10min) * / */
+
+/* custom defines */
+#define PICO_ICMP6_ND_UNICAST 0
+#define PICO_ICMP6_ND_ANYCAST 1
+#define PICO_ICMP6_ND_SOLICITED 2
+#define PICO_ICMP6_ND_DAD 3
+
+#define PICO_ICMP6_MAX_RTR_SOL_DELAY 1000
+
+#define PICO_SIZE_ICMP6HDR ((sizeof(struct pico_icmp6_hdr)))
+#define PICO_ICMP6_OPT_LLADDR_SIZE (8)
+
+extern struct pico_protocol pico_proto_icmp6;
+
+PACKED_STRUCT_DEF pico_icmp6_hdr {
+ uint8_t type;
+ uint8_t code;
+ uint16_t crc;
+
+ PACKED_UNION_DEF icmp6_msg_u {
+ /* error messages */
+ PACKED_UNION_DEF icmp6_err_u {
+ PEDANTIC_STRUCT_DEF dest_unreach_s {
+ uint32_t unused;
+ uint8_t data[0];
+ } dest_unreach;
+ PEDANTIC_STRUCT_DEF pkt_too_big_s {
+ uint32_t mtu;
+ uint8_t data[0];
+ } pkt_too_big;
+ PEDANTIC_STRUCT_DEF time_exceeded_s {
+ uint32_t unused;
+ uint8_t data[0];
+ } time_exceeded;
+ PEDANTIC_STRUCT_DEF param_problem_s {
+ uint32_t ptr;
+ uint8_t data[0];
+ } param_problem;
+ } err;
+
+ /* informational messages */
+ PACKED_UNION_DEF icmp6_info_u {
+ PEDANTIC_STRUCT_DEF echo_request_s {
+ uint16_t id;
+ uint16_t seq;
+ uint8_t data[0];
+ } echo_request;
+ PEDANTIC_STRUCT_DEF echo_reply_s {
+ uint16_t id;
+ uint16_t seq;
+ uint8_t data[0];
+ } echo_reply;
+ PEDANTIC_STRUCT_DEF router_sol_s {
+ uint32_t unused;
+ uint8_t options[0];
+ } router_sol;
+ PEDANTIC_STRUCT_DEF router_adv_s {
+ uint8_t hop;
+ uint8_t mor;
+ uint16_t life_time;
+ uint32_t reachable_time;
+ uint32_t retrans_time;
+ uint8_t options[0];
+ } router_adv;
+ PEDANTIC_STRUCT_DEF neigh_sol_s {
+ uint32_t unused;
+ struct pico_ip6 target;
+ uint8_t options[0];
+ } neigh_sol;
+ PEDANTIC_STRUCT_DEF neigh_adv_s {
+ uint32_t rsor;
+ struct pico_ip6 target;
+ uint8_t options[0];
+ } neigh_adv;
+ PEDANTIC_STRUCT_DEF redirect_s {
+ uint32_t reserved;
+ struct pico_ip6 target;
+ struct pico_ip6 dest;
+ uint8_t options[0];
+ } redirect;
+ } info;
+ } msg;
+};
+
+PACKED_STRUCT_DEF pico_icmp6_opt_lladdr
+{
+ uint8_t type;
+ uint8_t len;
+ PACKED_UNION_DEF icmp6_opt_hw_addr_u {
+ struct pico_eth mac;
+ } addr;
+};
+
+PACKED_STRUCT_DEF pico_icmp6_opt_prefix
+{
+ uint8_t type;
+ uint8_t len;
+ uint8_t prefix_len;
+ uint8_t res : 6;
+ uint8_t aac : 1;
+ uint8_t onlink : 1;
+ uint32_t val_lifetime;
+ uint32_t pref_lifetime;
+ uint32_t reserved;
+ struct pico_ip6 prefix;
+};
+
+PACKED_STRUCT_DEF pico_icmp6_opt_mtu
+{
+ uint8_t type;
+ uint8_t len;
+ uint16_t res;
+ uint32_t mtu;
+};
+
+PACKED_STRUCT_DEF pico_icmp6_opt_redirect
+{
+ uint8_t type;
+ uint8_t len;
+ uint16_t res0;
+ uint32_t res1;
+ uint8_t data[0];
+};
+
+PACKED_STRUCT_DEF pico_icmp6_opt_rdnss
+{
+ uint8_t type;
+ uint8_t len;
+ uint16_t res0;
+ uint32_t lifetime;
+ struct pico_ip6 addr[];
+};
+
+PACKED_STRUCT_DEF pico_icmp6_opt_na
+{
+ uint8_t type;
+ uint8_t len;
+ uint8_t options[0];
+};
+
+struct pico_icmp6_stats
+{
+ unsigned long size;
+ unsigned long seq;
+ pico_time time;
+ unsigned long ttl;
+ int err;
+ struct pico_ip6 dst;
+};
+
+int pico_icmp6_ping(char *dst, int count, int interval, int timeout, int size, void (*cb)(struct pico_icmp6_stats *), struct pico_device *dev);
+int pico_icmp6_ping_abort(int id);
+
+int pico_icmp6_neighbor_solicitation(struct pico_device *dev, struct pico_ip6 *dst, uint8_t type);
+int pico_icmp6_neighbor_advertisement(struct pico_frame *f, struct pico_ip6 *target);
+int pico_icmp6_router_solicitation(struct pico_device *dev, struct pico_ip6 *src);
+
+int pico_icmp6_port_unreachable(struct pico_frame *f);
+int pico_icmp6_proto_unreachable(struct pico_frame *f);
+int pico_icmp6_dest_unreachable(struct pico_frame *f);
+int pico_icmp6_ttl_expired(struct pico_frame *f);
+int pico_icmp6_packet_filtered(struct pico_frame *f);
+int pico_icmp6_parameter_problem(struct pico_frame *f, uint8_t problem, uint32_t ptr);
+int pico_icmp6_pkt_too_big(struct pico_frame *f);
+int pico_icmp6_frag_expired(struct pico_frame *f);
+
+uint16_t pico_icmp6_checksum(struct pico_frame *f);
+int pico_icmp6_router_advertisement(struct pico_device *dev, struct pico_ip6 *dst);
+
+#endif
diff --git a/net/picotcp/modules/pico_igmp.h b/net/picotcp/modules/pico_igmp.h
new file mode 100644
index 0000000..03d6102
--- /dev/null
+++ b/net/picotcp/modules/pico_igmp.h
@@ -0,0 +1,26 @@
+/*********************************************************************
+ PicoTCP. Copyright (c) 2012-2015 Altran Intelligent Systems. Some rights reserved.
+ See LICENSE and COPYING for usage.
+
+ .
+
+ Authors: Kristof Roelants, Simon Maes, Brecht Van Cauwenberghe
+ *********************************************************************/
+
+#ifndef INCLUDE_PICO_IGMP
+#define INCLUDE_PICO_IGMP
+
+#define PICO_IGMPV1 1
+#define PICO_IGMPV2 2
+#define PICO_IGMPV3 3
+
+#define PICO_IGMP_STATE_CREATE 1
+#define PICO_IGMP_STATE_UPDATE 2
+#define PICO_IGMP_STATE_DELETE 3
+
+#define PICO_IGMP_QUERY_INTERVAL 125
+
+extern struct pico_protocol pico_proto_igmp;
+
+int pico_igmp_state_change(struct pico_ip4 *mcast_link, struct pico_ip4 *mcast_group, uint8_t filter_mode, struct pico_tree *MCASTFilter, uint8_t state);
+#endif /* _INCLUDE_PICO_IGMP */
diff --git a/net/picotcp/modules/pico_ipfilter.h b/net/picotcp/modules/pico_ipfilter.h
new file mode 100644
index 0000000..fb92e67
--- /dev/null
+++ b/net/picotcp/modules/pico_ipfilter.h
@@ -0,0 +1,29 @@
+/*********************************************************************
+ PicoTCP. Copyright (c) 2012-2015 Altran Intelligent Systems. Some rights reserved.
+ See LICENSE and COPYING for usage.
+
+ Authors: Simon Maes
+ *********************************************************************/
+#ifndef INCLUDE_PICO_IPFILTER
+#define INCLUDE_PICO_IPFILTER
+
+#include "pico_device.h"
+
+enum filter_action {
+ FILTER_PRIORITY = 0,
+ FILTER_REJECT,
+ FILTER_DROP,
+ FILTER_COUNT
+};
+
+uint32_t pico_ipv4_filter_add(struct pico_device *dev, uint8_t proto,
+ struct pico_ip4 *out_addr, struct pico_ip4 *out_addr_netmask, struct pico_ip4 *in_addr,
+ struct pico_ip4 *in_addr_netmask, uint16_t out_port, uint16_t in_port,
+ int8_t priority, uint8_t tos, enum filter_action action);
+
+int pico_ipv4_filter_del(uint32_t filter_id);
+
+int ipfilter(struct pico_frame *f);
+
+#endif /* _INCLUDE_PICO_IPFILTER */
+
diff --git a/net/picotcp/modules/pico_ipv4.c b/net/picotcp/modules/pico_ipv4.c
new file mode 100644
index 0000000..f94d6e6
--- /dev/null
+++ b/net/picotcp/modules/pico_ipv4.c
@@ -0,0 +1,1574 @@
+/*********************************************************************
+ PicoTCP. Copyright (c) 2012-2015 Altran Intelligent Systems. Some rights reserved.
+ See LICENSE and COPYING for usage.
+
+ Authors: Daniele Lacamera, Markian Yskout
+ *********************************************************************/
+
+
+#include "pico_config.h"
+#include "pico_ipfilter.h"
+#include "pico_ipv4.h"
+#include "pico_icmp4.h"
+#include "pico_stack.h"
+#include "pico_eth.h"
+#include "pico_udp.h"
+#include "pico_tcp.h"
+#include "pico_socket.h"
+#include "pico_device.h"
+#include "pico_nat.h"
+#include "pico_igmp.h"
+#include "pico_tree.h"
+#include "pico_aodv.h"
+#include "pico_socket_multicast.h"
+#include "pico_fragments.h"
+
+#ifdef PICO_SUPPORT_IPV4
+
+#ifdef PICO_SUPPORT_MCAST
+# define ip_mcast_dbg(...) do {} while(0) /* so_mcast_dbg in pico_socket.c */
+/* #define ip_mcast_dbg dbg */
+# define PICO_MCAST_ALL_HOSTS long_be(0xE0000001) /* 224.0.0.1 */
+/* Default network interface for multicast transmission */
+static struct pico_ipv4_link *mcast_default_link = NULL;
+#endif
+#ifdef PICO_SUPPORT_IPFRAG
+/* # define reassembly_dbg dbg */
+# define reassembly_dbg(...) do {} while(0)
+#endif
+
+/* Queues */
+static struct pico_queue in = {
+ 0
+};
+static struct pico_queue out = {
+ 0
+};
+
+/* Functions */
+static int ipv4_route_compare(void *ka, void *kb);
+static struct pico_frame *pico_ipv4_alloc(struct pico_protocol *self, uint16_t size);
+
+
+int pico_ipv4_compare(struct pico_ip4 *a, struct pico_ip4 *b)
+{
+ if (a->addr < b->addr)
+ return -1;
+
+ if (a->addr > b->addr)
+ return 1;
+
+ return 0;
+}
+
+int pico_ipv4_to_string(char *ipbuf, const uint32_t ip)
+{
+ const unsigned char *addr = (const unsigned char *) &ip;
+ int i;
+
+ if (!ipbuf) {
+ pico_err = PICO_ERR_EINVAL;
+ return -1;
+ }
+
+ for(i = 0; i < 4; i++)
+ {
+ if (addr[i] > 99) {
+ *ipbuf++ = (char)('0' + (addr[i] / 100));
+ *ipbuf++ = (char)('0' + ((addr[i] % 100) / 10));
+ *ipbuf++ = (char)('0' + ((addr[i] % 100) % 10));
+ } else if (addr[i] > 9) {
+ *ipbuf++ = (char)('0' + (addr[i] / 10));
+ *ipbuf++ = (char)('0' + (addr[i] % 10));
+ } else {
+ *ipbuf++ = (char)('0' + addr[i]);
+ }
+
+ if (i < 3)
+ *ipbuf++ = '.';
+ }
+ *ipbuf = '\0';
+
+ return 0;
+}
+
+static int pico_string_check_null_args(const char *ipstr, uint32_t *ip)
+{
+
+ if (!ipstr || !ip) {
+ pico_err = PICO_ERR_EINVAL;
+ return -1;
+ }
+
+ return 0;
+
+}
+
+int pico_string_to_ipv4(const char *ipstr, uint32_t *ip)
+{
+ unsigned char buf[PICO_SIZE_IP4] = {
+ 0
+ };
+ int cnt = 0;
+ char p;
+
+ if (pico_string_check_null_args(ipstr, ip) < 0)
+ return -1;
+
+ while((p = *ipstr++) != 0 && cnt < PICO_SIZE_IP4)
+ {
+ if (pico_is_digit(p)) {
+ buf[cnt] = (uint8_t)((10 * buf[cnt]) + (p - '0'));
+ } else if (p == '.') {
+ cnt++;
+ } else {
+ return -1;
+ }
+ }
+ /* Handle short notation */
+ if (cnt == 1) {
+ buf[3] = buf[1];
+ buf[1] = 0;
+ buf[2] = 0;
+ } else if (cnt == 2) {
+ buf[3] = buf[2];
+ buf[2] = 0;
+ } else if (cnt != 3) {
+ /* String could not be parsed, return error */
+ return -1;
+ }
+
+ *ip = long_from(buf);
+
+ return 0;
+}
+
+int pico_ipv4_valid_netmask(uint32_t mask)
+{
+ int cnt = 0;
+ int end = 0;
+ int i;
+ uint32_t mask_swap = long_be(mask);
+
+ /*
+ * Swap bytes for convenient parsing
+ * e.g. 0x..f8ff will become 0xfff8..
+ * Then, we count the consecutive bits
+ *
+ * */
+
+ for(i = 0; i < 32; i++) {
+ if ((mask_swap << i) & 0x80000000) {
+ if (end) {
+ pico_err = PICO_ERR_EINVAL;
+ return -1;
+ }
+
+ cnt++;
+ } else {
+ end = 1;
+ }
+ }
+ return cnt;
+}
+
+int pico_ipv4_is_unicast(uint32_t address)
+{
+ const unsigned char *addr = (unsigned char *) &address;
+ if ((addr[0] & 0xe0) == 0xe0)
+ return 0; /* multicast */
+
+ return 1;
+}
+
+int pico_ipv4_is_multicast(uint32_t address)
+{
+ const unsigned char *addr = (unsigned char *) &address;
+ if ((addr[0] != 0xff) && ((addr[0] & 0xe0) == 0xe0))
+ return 1; /* multicast */
+
+ return 0;
+}
+
+int pico_ipv4_is_loopback(uint32_t address)
+{
+ const unsigned char *addr = (unsigned char *) &address;
+ if (addr[0] == 0x7f)
+ return 1;
+
+ return 0;
+}
+
+static int pico_ipv4_is_invalid_loopback(uint32_t address, struct pico_device *dev)
+{
+ return pico_ipv4_is_loopback(address) && ((!dev) || strcmp(dev->name, "loop"));
+}
+
+int pico_ipv4_is_valid_src(uint32_t address, struct pico_device *dev)
+{
+ if (pico_ipv4_is_broadcast(address)) {
+ dbg("Source is a broadcast address, discard packet\n");
+ return 0;
+ } else if ( pico_ipv4_is_multicast(address)) {
+ dbg("Source is a multicast address, discard packet\n");
+ return 0;
+ } else if (pico_ipv4_is_invalid_loopback(address, dev)) {
+ dbg("Source is a loopback address, discard packet\n");
+ return 0;
+ } else {
+#ifdef PICO_SUPPORT_AODV
+ union pico_address src;
+ src.ip4.addr = address;
+ pico_aodv_refresh(&src);
+#endif
+ return 1;
+ }
+}
+
+static int pico_ipv4_checksum(struct pico_frame *f)
+{
+ struct pico_ipv4_hdr *hdr = (struct pico_ipv4_hdr *) f->net_hdr;
+ if (!hdr)
+ return -1;
+
+ hdr->crc = 0;
+ hdr->crc = short_be(pico_checksum(hdr, f->net_len));
+ return 0;
+}
+
+
+#ifdef PICO_SUPPORT_CRC
+static inline int pico_ipv4_crc_check(struct pico_frame *f)
+{
+ uint16_t checksum_invalid = 1;
+ struct pico_ipv4_hdr *hdr = (struct pico_ipv4_hdr *) f->net_hdr;
+
+ checksum_invalid = short_be(pico_checksum(hdr, f->net_len));
+ if (checksum_invalid) {
+ dbg("IP: checksum failed!\n");
+ pico_frame_discard(f);
+ return 0;
+ }
+
+ return 1;
+}
+#else
+static inline int pico_ipv4_crc_check(struct pico_frame *f)
+{
+ IGNORE_PARAMETER(f);
+ return 1;
+}
+#endif /* PICO_SUPPORT_CRC */
+
+static int pico_ipv4_forward(struct pico_frame *f);
+#ifdef PICO_SUPPORT_MCAST
+static int pico_ipv4_mcast_filter(struct pico_frame *f);
+#endif
+
+static int ipv4_link_compare(void *ka, void *kb)
+{
+ struct pico_ipv4_link *a = ka, *b = kb;
+ int cmp = pico_ipv4_compare(&a->address, &b->address);
+ if (cmp)
+ return cmp;
+
+ /* zero can be assigned multiple times (e.g. for DHCP) */
+ if (a->dev != NULL && b->dev != NULL && a->address.addr == PICO_IP4_ANY && b->address.addr == PICO_IP4_ANY) {
+ if (a->dev < b->dev)
+ return -1;
+
+ if (a->dev > b->dev)
+ return 1;
+ }
+
+ return 0;
+}
+
+PICO_TREE_DECLARE(Tree_dev_link, ipv4_link_compare);
+
+static int pico_ipv4_process_bcast_in(struct pico_frame *f)
+{
+ struct pico_ipv4_hdr *hdr = (struct pico_ipv4_hdr *) f->net_hdr;
+#ifdef PICO_SUPPORT_UDP
+ if (pico_ipv4_is_broadcast(hdr->dst.addr) && (hdr->proto == PICO_PROTO_UDP)) {
+ /* Receiving UDP broadcast datagram */
+ f->flags |= PICO_FRAME_FLAG_BCAST;
+ pico_enqueue(pico_proto_udp.q_in, f);
+ return 1;
+ }
+
+#endif
+
+#ifdef PICO_SUPPORT_ICMP4
+ if (pico_ipv4_is_broadcast(hdr->dst.addr) && (hdr->proto == PICO_PROTO_ICMP4)) {
+ /* Receiving ICMP4 bcast packet */
+ f->flags |= PICO_FRAME_FLAG_BCAST;
+ pico_enqueue(pico_proto_icmp4.q_in, f);
+ return 1;
+ }
+
+#endif
+ return 0;
+}
+
+static int pico_ipv4_process_mcast_in(struct pico_frame *f)
+{
+ struct pico_ipv4_hdr *hdr = (struct pico_ipv4_hdr *) f->net_hdr;
+ if (pico_ipv4_is_multicast(hdr->dst.addr)) {
+#ifdef PICO_SUPPORT_MCAST
+ /* Receiving UDP multicast datagram TODO set f->flags? */
+ if (hdr->proto == PICO_PROTO_IGMP) {
+ ip_mcast_dbg("MCAST: received IGMP message\n");
+ pico_transport_receive(f, PICO_PROTO_IGMP);
+ return 1;
+ } else if ((pico_ipv4_mcast_filter(f) == 0) && (hdr->proto == PICO_PROTO_UDP)) {
+ pico_enqueue(pico_proto_udp.q_in, f);
+ return 1;
+ }
+
+#endif
+ pico_frame_discard(f);
+ return 1;
+ }
+
+ return 0;
+}
+
+static int pico_ipv4_process_local_unicast_in(struct pico_frame *f)
+{
+ struct pico_ipv4_hdr *hdr = (struct pico_ipv4_hdr *) f->net_hdr;
+ struct pico_ipv4_link test = {
+ .address = {.addr = PICO_IP4_ANY}, .dev = NULL
+ };
+ if (pico_ipv4_link_find(&hdr->dst)) {
+ if (pico_ipv4_nat_inbound(f, &hdr->dst) == 0)
+ pico_enqueue(pico_proto_ipv4.q_in, f); /* dst changed, reprocess */
+ else
+ pico_transport_receive(f, hdr->proto);
+
+ return 1;
+ } else if (pico_tree_findKey(&Tree_dev_link, &test)) {
+#ifdef PICO_SUPPORT_UDP
+ /* address of this device is apparently 0.0.0.0; might be a DHCP packet */
+ /* XXX KRO: is obsolete. Broadcast flag is set on outgoing DHCP messages.
+ * incomming DHCP messages are to be broadcasted. Our current DHCP server
+ * implementation does not take this flag into account yet though ... */
+ pico_enqueue(pico_proto_udp.q_in, f);
+ return 1;
+#endif
+ }
+
+ return 0;
+}
+
+static void pico_ipv4_process_finally_try_forward(struct pico_frame *f)
+{
+ struct pico_ipv4_hdr *hdr = (struct pico_ipv4_hdr *) f->net_hdr;
+ if ((pico_ipv4_is_broadcast(hdr->dst.addr))) {
+ /* don't forward broadcast frame, discard! */
+ pico_frame_discard(f);
+ } else if (pico_ipv4_forward(f) != 0) {
+ pico_frame_discard(f);
+ /* dbg("Forward failed.\n"); */
+ }
+}
+
+
+
+static int pico_ipv4_process_in(struct pico_protocol *self, struct pico_frame *f)
+{
+ uint8_t option_len = 0;
+ int ret = 0;
+ struct pico_ipv4_hdr *hdr = (struct pico_ipv4_hdr *) f->net_hdr;
+ uint16_t max_allowed = (uint16_t) ((int)f->buffer_len - (f->net_hdr - f->buffer) - (int)PICO_SIZE_IP4HDR);
+ uint16_t flag = short_be(hdr->frag);
+
+ (void)self;
+ /* NAT needs transport header information */
+ if (((hdr->vhl) & 0x0F) > 5) {
+ option_len = (uint8_t)(4 * (((hdr->vhl) & 0x0F) - 5));
+ }
+
+ f->transport_hdr = ((uint8_t *)f->net_hdr) + PICO_SIZE_IP4HDR + option_len;
+ f->transport_len = (uint16_t)(short_be(hdr->len) - PICO_SIZE_IP4HDR - option_len);
+ f->net_len = (uint16_t)(PICO_SIZE_IP4HDR + option_len);
+
+ if (f->transport_len > max_allowed) {
+ pico_frame_discard(f);
+ return 0; /* Packet is discarded due to unfeasible length */
+ }
+
+#ifdef PICO_SUPPORT_IPFILTER
+ if (ipfilter(f)) {
+ /*pico_frame is discarded as result of the filtering*/
+ return 0;
+ }
+
+#endif
+
+
+ /* ret == 1 indicates to continue the function */
+ ret = pico_ipv4_crc_check(f);
+ if (ret < 1)
+ return ret;
+
+ /* Validate source IP address. Discard quietly if invalid */
+ if (!pico_ipv4_is_valid_src(hdr->src.addr, f->dev)) {
+ pico_frame_discard(f);
+ return 0;
+ }
+
+ if (hdr->frag & short_be(PICO_IPV4_EVIL)) {
+ (void)pico_icmp4_param_problem(f, 0);
+ pico_frame_discard(f); /* RFC 3514 */
+ return 0;
+ }
+
+ if ((hdr->vhl & 0x0f) < 5) {
+ /* RFC 791: IHL minimum value is 5 */
+ (void)pico_icmp4_param_problem(f, 0);
+ pico_frame_discard(f);
+ return 0;
+ }
+
+ if ((flag & PICO_IPV4_MOREFRAG) || (flag & PICO_IPV4_FRAG_MASK))
+ {
+#ifdef PICO_SUPPORT_IPFRAG
+ pico_ipv4_process_frag(hdr, f, hdr ? hdr->proto : 0 );
+ /* Frame can be discarded, frag will handle its own copy */
+#endif
+ /* We do not support fragmentation, discard frame quietly */
+ pico_frame_discard(f);
+ return 0;
+ }
+
+ if (pico_ipv4_process_bcast_in(f) > 0)
+ return 0;
+
+ if (pico_ipv4_process_mcast_in(f) > 0)
+ return 0;
+
+ if (pico_ipv4_process_local_unicast_in(f) > 0)
+ return 0;
+
+ pico_ipv4_process_finally_try_forward(f);
+
+ return 0;
+}
+
+PICO_TREE_DECLARE(Routes, ipv4_route_compare);
+
+
+static int pico_ipv4_process_out(struct pico_protocol *self, struct pico_frame *f)
+{
+ IGNORE_PARAMETER(self);
+ f->start = (uint8_t*) f->net_hdr;
+#ifdef PICO_SUPPORT_IPFILTER
+ if (ipfilter(f)) {
+ /*pico_frame is discarded as result of the filtering*/
+ return 0;
+ }
+
+#endif
+ return pico_sendto_dev(f);
+}
+
+
+static struct pico_frame *pico_ipv4_alloc(struct pico_protocol *self, uint16_t size)
+{
+ struct pico_frame *f = pico_frame_alloc(size + PICO_SIZE_IP4HDR + PICO_SIZE_ETHHDR);
+ IGNORE_PARAMETER(self);
+
+ if (!f)
+ return NULL;
+
+ f->datalink_hdr = f->buffer;
+ f->net_hdr = f->buffer + PICO_SIZE_ETHHDR;
+ f->net_len = PICO_SIZE_IP4HDR;
+ f->transport_hdr = f->net_hdr + PICO_SIZE_IP4HDR;
+ f->transport_len = size;
+ f->len = size + PICO_SIZE_IP4HDR;
+ return f;
+}
+
+static int pico_ipv4_frame_sock_push(struct pico_protocol *self, struct pico_frame *f);
+
+/* Interface: protocol definition */
+struct pico_protocol pico_proto_ipv4 = {
+ .name = "ipv4",
+ .proto_number = PICO_PROTO_IPV4,
+ .layer = PICO_LAYER_NETWORK,
+ .alloc = pico_ipv4_alloc,
+ .process_in = pico_ipv4_process_in,
+ .process_out = pico_ipv4_process_out,
+ .push = pico_ipv4_frame_sock_push,
+ .q_in = &in,
+ .q_out = &out,
+};
+
+
+static int ipv4_route_compare(void *ka, void *kb)
+{
+ struct pico_ipv4_route *a = ka, *b = kb;
+ uint32_t a_nm, b_nm;
+ int cmp;
+
+ a_nm = long_be(a->netmask.addr);
+ b_nm = long_be(b->netmask.addr);
+
+ /* Routes are sorted by (host side) netmask len, then by addr, then by metric. */
+ if (a_nm < b_nm)
+ return -1;
+
+ if (b_nm < a_nm)
+ return 1;
+
+ cmp = pico_ipv4_compare(&a->dest, &b->dest);
+ if (cmp)
+ return cmp;
+
+ if (a->metric < b->metric)
+ return -1;
+
+ if (a->metric > b->metric)
+ return 1;
+
+ return 0;
+}
+
+
+static struct pico_ipv4_route default_bcast_route = {
+ .dest = {PICO_IP4_BCAST},
+ .netmask = {PICO_IP4_BCAST},
+ .gateway = { 0 },
+ .link = NULL,
+ .metric = 1000
+};
+
+static struct pico_ipv4_route *route_find_default_bcast(void)
+{
+ return &default_bcast_route;
+}
+
+
+static struct pico_ipv4_route *route_find(const struct pico_ip4 *addr)
+{
+ struct pico_ipv4_route *r;
+ struct pico_tree_node *index;
+
+ if (addr->addr != PICO_IP4_BCAST) {
+ pico_tree_foreach_reverse(index, &Routes) {
+ r = index->keyValue;
+ if ((addr->addr & (r->netmask.addr)) == (r->dest.addr)) {
+ return r;
+ }
+ }
+ return NULL;
+ }
+
+ return route_find_default_bcast();
+}
+
+struct pico_ip4 pico_ipv4_route_get_gateway(struct pico_ip4 *addr)
+{
+ struct pico_ip4 nullip;
+ struct pico_ipv4_route *route;
+ nullip.addr = 0U;
+
+ if (!addr) {
+ pico_err = PICO_ERR_EINVAL;
+ return nullip;
+ }
+
+ route = route_find(addr);
+ if (!route) {
+ pico_err = PICO_ERR_EHOSTUNREACH;
+ return nullip;
+ }
+ else
+ return route->gateway;
+}
+
+struct pico_ip4 *pico_ipv4_source_find(const struct pico_ip4 *dst)
+{
+ struct pico_ip4 *myself = NULL;
+ struct pico_ipv4_route *rt;
+#ifdef PICO_SUPPORT_AODV
+ union pico_address node_address;
+ node_address.ip4.addr = dst->addr;
+ if (dst->addr && pico_ipv4_is_unicast(dst->addr))
+ pico_aodv_lookup(&node_address);
+
+#endif
+
+ if (!dst) {
+ pico_err = PICO_ERR_EINVAL;
+ return NULL;
+ }
+
+ rt = route_find(dst);
+ if (rt && rt->link) {
+ myself = &rt->link->address;
+ } else {
+ pico_err = PICO_ERR_EHOSTUNREACH;
+ }
+
+ return myself;
+}
+
+struct pico_device *pico_ipv4_source_dev_find(const struct pico_ip4 *dst)
+{
+ struct pico_device *dev = NULL;
+ struct pico_ipv4_route *rt;
+
+ if (!dst) {
+ pico_err = PICO_ERR_EINVAL;
+ return NULL;
+ }
+
+ rt = route_find(dst);
+ if (rt && rt->link) {
+ dev = rt->link->dev;
+ } else {
+ pico_err = PICO_ERR_EHOSTUNREACH;
+ }
+
+ return dev;
+}
+
+
+#ifdef PICO_SUPPORT_MCAST
+/* link
+ * |
+ * MCASTGroups
+ * | | |
+ * ------------ | ------------
+ * | | |
+ * MCASTSources MCASTSources MCASTSources
+ * | | | | | | | | | | | |
+ * S S S S S S S S S S S S
+ *
+ * MCASTGroups: RBTree(mcast_group)
+ * MCASTSources: RBTree(source)
+ */
+static int ipv4_mcast_groups_cmp(void *ka, void *kb)
+{
+ struct pico_mcast_group *a = ka, *b = kb;
+ return pico_ipv4_compare(&a->mcast_addr, &b->mcast_addr);
+}
+
+static int ipv4_mcast_sources_cmp(void *ka, void *kb)
+{
+ struct pico_ip4 *a = ka, *b = kb;
+ return pico_ipv4_compare(a, b);
+}
+
+static void pico_ipv4_mcast_print_groups(struct pico_ipv4_link *mcast_link)
+{
+ uint16_t i = 0;
+ struct pico_mcast_group *g = NULL;
+ struct pico_ip4 *source = NULL;
+ struct pico_tree_node *index = NULL, *index2 = NULL;
+ (void) source;
+
+ ip_mcast_dbg("+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\n");
+ ip_mcast_dbg("+ MULTICAST list interface %-16s +\n", mcast_link->dev->name);
+ ip_mcast_dbg("+---------------------------------------------------------------------------------+\n");
+ ip_mcast_dbg("+ nr | interface | host group | reference count | filter mode | source +\n");
+ ip_mcast_dbg("+---------------------------------------------------------------------------------+\n");
+
+ pico_tree_foreach(index, mcast_link->MCASTGroups) {
+ g = index->keyValue;
+ ip_mcast_dbg("+ %04d | %16s | %08X | %05u | %u | %8s +\n", i, mcast_link->dev->name, g->mcast_addr.addr, g->reference_count, g->filter_mode, "");
+ pico_tree_foreach(index2, &g->MCASTSources) {
+ source = index2->keyValue;
+ ip_mcast_dbg("+ %4s | %16s | %8s | %5s | %s | %08X +\n", "", "", "", "", "", source->addr);
+ }
+ i++;
+ }
+ ip_mcast_dbg("+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\n");
+}
+
+static int mcast_group_update(struct pico_mcast_group *g, struct pico_tree *MCASTFilter, uint8_t filter_mode)
+{
+ struct pico_tree_node *index = NULL, *_tmp = NULL;
+ struct pico_ip4 *source = NULL;
+ /* cleanup filter */
+ pico_tree_foreach_safe(index, &g->MCASTSources, _tmp) {
+ source = index->keyValue;
+ pico_tree_delete(&g->MCASTSources, source);
+ PICO_FREE(source);
+ }
+ /* insert new filter */
+ if (MCASTFilter) {
+ pico_tree_foreach(index, MCASTFilter) {
+ if (index->keyValue) {
+ source = PICO_ZALLOC(sizeof(struct pico_ip4));
+ if (!source) {
+ pico_err = PICO_ERR_ENOMEM;
+ return -1;
+ }
+
+ source->addr = ((struct pico_ip4 *)index->keyValue)->addr;
+ pico_tree_insert(&g->MCASTSources, source);
+ }
+ }
+ }
+
+ g->filter_mode = filter_mode;
+ return 0;
+}
+
+int pico_ipv4_mcast_join(struct pico_ip4 *mcast_link, struct pico_ip4 *mcast_group, uint8_t reference_count, uint8_t filter_mode, struct pico_tree *MCASTFilter)
+{
+ struct pico_mcast_group *g = NULL, test = {
+ 0
+ };
+ struct pico_ipv4_link *link = NULL;
+
+ if (mcast_link)
+ link = pico_ipv4_link_get(mcast_link);
+
+ if (!link)
+ link = mcast_default_link;
+
+ test.mcast_addr = *mcast_group;
+ g = pico_tree_findKey(link->MCASTGroups, &test);
+ if (g) {
+ if (reference_count)
+ g->reference_count++;
+
+ pico_igmp_state_change(mcast_link, mcast_group, filter_mode, MCASTFilter, PICO_IGMP_STATE_UPDATE);
+ } else {
+ g = PICO_ZALLOC(sizeof(struct pico_mcast_group));
+ if (!g) {
+ pico_err = PICO_ERR_ENOMEM;
+ return -1;
+ }
+
+ /* "non-existent" state of filter mode INCLUDE and empty source list */
+ g->filter_mode = PICO_IP_MULTICAST_INCLUDE;
+ g->reference_count = 1;
+ g->mcast_addr = *mcast_group;
+ g->MCASTSources.root = &LEAF;
+ g->MCASTSources.compare = ipv4_mcast_sources_cmp;
+ pico_tree_insert(link->MCASTGroups, g);
+ pico_igmp_state_change(mcast_link, mcast_group, filter_mode, MCASTFilter, PICO_IGMP_STATE_CREATE);
+ }
+
+ if (mcast_group_update(g, MCASTFilter, filter_mode) < 0) {
+ dbg("Error in mcast_group update\n");
+ return -1;
+ }
+
+ pico_ipv4_mcast_print_groups(link);
+ return 0;
+}
+
+int pico_ipv4_mcast_leave(struct pico_ip4 *mcast_link, struct pico_ip4 *mcast_group, uint8_t reference_count, uint8_t filter_mode, struct pico_tree *MCASTFilter)
+{
+
+ struct pico_mcast_group *g = NULL, test = {
+ 0
+ };
+ struct pico_ipv4_link *link = NULL;
+ struct pico_tree_node *index = NULL, *_tmp = NULL;
+ struct pico_ip4 *source = NULL;
+
+ if (mcast_link)
+ link = pico_ipv4_link_get(mcast_link);
+
+ if (!link)
+ link = mcast_default_link;
+
+ test.mcast_addr = *mcast_group;
+ g = pico_tree_findKey(link->MCASTGroups, &test);
+ if (!g) {
+ pico_err = PICO_ERR_EINVAL;
+ return -1;
+ } else {
+ if (reference_count && (--(g->reference_count) < 1)) {
+ pico_igmp_state_change(mcast_link, mcast_group, filter_mode, MCASTFilter, PICO_IGMP_STATE_DELETE);
+ /* cleanup filter */
+ pico_tree_foreach_safe(index, &g->MCASTSources, _tmp) {
+ source = index->keyValue;
+ pico_tree_delete(&g->MCASTSources, source);
+ PICO_FREE(source);
+ }
+ pico_tree_delete(link->MCASTGroups, g);
+ PICO_FREE(g);
+ } else {
+ pico_igmp_state_change(mcast_link, mcast_group, filter_mode, MCASTFilter, PICO_IGMP_STATE_UPDATE);
+ if (mcast_group_update(g, MCASTFilter, filter_mode) < 0)
+ return -1;
+ }
+ }
+
+ pico_ipv4_mcast_print_groups(link);
+ return 0;
+}
+
+struct pico_ipv4_link *pico_ipv4_get_default_mcastlink(void)
+{
+ return mcast_default_link;
+}
+
+static int pico_ipv4_mcast_filter(struct pico_frame *f)
+{
+ struct pico_ipv4_link *link = NULL;
+ struct pico_tree_node *index = NULL, *index2 = NULL;
+ struct pico_mcast_group *g = NULL, test = {
+ 0
+ };
+ struct pico_ipv4_hdr *hdr = (struct pico_ipv4_hdr *) f->net_hdr;
+
+ test.mcast_addr = hdr->dst;
+
+ pico_tree_foreach(index, &Tree_dev_link) {
+ link = index->keyValue;
+ g = pico_tree_findKey(link->MCASTGroups, &test);
+ if (g) {
+ if (f->dev == link->dev) {
+ ip_mcast_dbg("MCAST: IP %08X is group member of current link %s\n", hdr->dst.addr, f->dev->name);
+ /* perform source filtering */
+ switch (g->filter_mode) {
+ case PICO_IP_MULTICAST_INCLUDE:
+ pico_tree_foreach(index2, &g->MCASTSources) {
+ if (hdr->src.addr == ((struct pico_ip4 *)index2->keyValue)->addr) {
+ ip_mcast_dbg("MCAST: IP %08X in included interface source list\n", hdr->src.addr);
+ return 0;
+ }
+ }
+ ip_mcast_dbg("MCAST: IP %08X NOT in included interface source list\n", hdr->src.addr);
+ return -1;
+
+ case PICO_IP_MULTICAST_EXCLUDE:
+ pico_tree_foreach(index2, &g->MCASTSources) {
+ if (hdr->src.addr == ((struct pico_ip4 *)index2->keyValue)->addr) {
+ ip_mcast_dbg("MCAST: IP %08X in excluded interface source list\n", hdr->src.addr);
+ return -1;
+ }
+ }
+ ip_mcast_dbg("MCAST: IP %08X NOT in excluded interface source list\n", hdr->src.addr);
+ return 0;
+
+ default:
+ return -1;
+ }
+ } else {
+ ip_mcast_dbg("MCAST: IP %08X is group member of different link %s\n", hdr->dst.addr, link->dev->name);
+ }
+ } else {
+ ip_mcast_dbg("MCAST: IP %08X is not a group member of link %s\n", hdr->dst.addr, f->dev->name);
+ }
+ }
+ return -1;
+}
+
+#else
+
+int pico_ipv4_mcast_join(struct pico_ip4 *mcast_link, struct pico_ip4 *mcast_group, uint8_t reference_count, uint8_t filter_mode, struct pico_tree *MCASTFilter)
+{
+ pico_err = PICO_ERR_EPROTONOSUPPORT;
+ return -1;
+}
+
+int pico_ipv4_mcast_leave(struct pico_ip4 *mcast_link, struct pico_ip4 *mcast_group, uint8_t reference_count, uint8_t filter_mode, struct pico_tree *MCASTFilter)
+{
+ pico_err = PICO_ERR_EPROTONOSUPPORT;
+ return -1;
+}
+
+struct pico_ipv4_link *pico_ipv4_get_default_mcastlink(void)
+{
+ pico_err = PICO_ERR_EPROTONOSUPPORT;
+ return NULL;
+}
+#endif /* PICO_SUPPORT_MCAST */
+
+/* #define DEBUG_ROUTE */
+#ifdef DEBUG_ROUTE
+void dbg_route(void)
+{
+ struct pico_ipv4_route *r;
+ struct pico_tree_node *index;
+ int count_hosts = 0;
+ dbg("==== ROUTING TABLE =====\n");
+ pico_tree_foreach(index, &Routes) {
+ r = index->keyValue;
+ dbg("Route to %08x/%08x, gw %08x, dev: %s, metric: %d\n", r->dest.addr, r->netmask.addr, r->gateway.addr, r->link->dev->name, r->metric);
+ if (r->netmask.addr == 0xFFFFFFFF)
+ count_hosts++;
+ }
+ dbg("================ total HOST nodes: %d ======\n\n\n", count_hosts);
+}
+#else
+#define dbg_route() do { } while(0)
+#endif
+
+int pico_ipv4_frame_push(struct pico_frame *f, struct pico_ip4 *dst, uint8_t proto)
+{
+
+ struct pico_ipv4_route *route;
+ struct pico_ipv4_link *link;
+ struct pico_ipv4_hdr *hdr;
+ uint8_t ttl = PICO_IPV4_DEFAULT_TTL;
+ uint8_t vhl = 0x45; /* version 4, header length 20 */
+ static uint16_t ipv4_progressive_id = 0x91c0;
+#ifdef PICO_SUPPORT_MCAST
+ struct pico_tree_node *index;
+#endif
+
+ if (!f || !dst) {
+ pico_err = PICO_ERR_EINVAL;
+ return -1;
+ }
+
+
+ hdr = (struct pico_ipv4_hdr *) f->net_hdr;
+ if (!hdr) {
+ dbg("IP header error\n");
+ pico_err = PICO_ERR_EINVAL;
+ goto drop;
+ }
+
+ if (dst->addr == 0) {
+ dbg("IP destination addr error\n");
+ pico_err = PICO_ERR_EINVAL;
+ goto drop;
+ }
+
+ route = route_find(dst);
+ if (!route) {
+ /* dbg("Route to %08x not found.\n", long_be(dst->addr)); */
+
+
+ pico_err = PICO_ERR_EHOSTUNREACH;
+ goto drop;
+ } else {
+ link = route->link;
+#ifdef PICO_SUPPORT_MCAST
+ if (pico_ipv4_is_multicast(dst->addr)) { /* if multicast */
+ switch (proto) {
+ case PICO_PROTO_UDP:
+ if (pico_udp_get_mc_ttl(f->sock, &ttl) < 0)
+ ttl = PICO_IP_DEFAULT_MULTICAST_TTL;
+
+ break;
+ case PICO_PROTO_IGMP:
+ vhl = 0x46; /* header length 24 */
+ ttl = 1;
+ /* router alert (RFC 2113) */
+ hdr->options[0] = 0x94;
+ hdr->options[1] = 0x04;
+ hdr->options[2] = 0x00;
+ hdr->options[3] = 0x00;
+ if (f->dev && link->dev != f->dev) { /* default link is not requested link */
+ pico_tree_foreach(index, &Tree_dev_link) {
+ link = index->keyValue;
+ if (link->dev == f->dev)
+ break;
+ }
+ }
+
+ break;
+ default:
+ ttl = PICO_IPV4_DEFAULT_TTL;
+ }
+ }
+
+#endif
+ }
+
+ hdr->vhl = vhl;
+ hdr->len = short_be((uint16_t)(f->transport_len + f->net_len));
+ if ((f->transport_hdr != f->payload) &&
+#ifdef PICO_SUPPORT_IPFRAG
+ (0 == (f->frag & PICO_IPV4_MOREFRAG)) &&
+ (0 == (f->frag & PICO_IPV4_FRAG_MASK)) &&
+#endif
+ 1 )
+ ipv4_progressive_id++;
+
+ if (f->send_ttl > 0) {
+ ttl = f->send_ttl;
+ }
+
+ hdr->id = short_be(ipv4_progressive_id);
+ hdr->dst.addr = dst->addr;
+ hdr->src.addr = link->address.addr;
+ hdr->ttl = ttl;
+ hdr->tos = f->send_tos;
+ hdr->proto = proto;
+ hdr->frag = short_be(PICO_IPV4_DONTFRAG);
+
+#ifdef PICO_SUPPORT_IPFRAG
+# ifdef PICO_SUPPORT_UDP
+ if (proto == PICO_PROTO_UDP) {
+ /* first fragment, can not use transport_len to calculate IP length */
+ if (f->transport_hdr != f->payload)
+ hdr->len = short_be((uint16_t)(f->payload_len + sizeof(struct pico_udp_hdr) + f->net_len));
+
+ /* set fragmentation flags and offset calculated in socket layer */
+ hdr->frag = short_be(f->frag);
+ }
+
+ if (proto == PICO_PROTO_ICMP4)
+ {
+ hdr->frag = short_be(f->frag);
+ }
+
+# endif
+#endif /* PICO_SUPPORT_IPFRAG */
+ pico_ipv4_checksum(f);
+
+ if (f->sock && f->sock->dev) {
+ /* if the socket has its device set, use that (currently used for DHCP) */
+ f->dev = f->sock->dev;
+ } else {
+ f->dev = link->dev;
+ if (f->sock)
+ f->sock->dev = f->dev;
+ }
+
+#ifdef PICO_SUPPORT_MCAST
+ if (pico_ipv4_is_multicast(hdr->dst.addr)) {
+ struct pico_frame *cpy;
+ /* Sending UDP multicast datagram, am I member? If so, loopback copy */
+ if ((proto != PICO_PROTO_IGMP) && (pico_ipv4_mcast_filter(f) == 0)) {
+ ip_mcast_dbg("MCAST: sender is member of group, loopback copy\n");
+ cpy = pico_frame_copy(f);
+ pico_enqueue(&in, cpy);
+ }
+ }
+
+#endif
+
+/* #ifdef PICO_SUPPORT_AODV */
+#if 0
+ {
+ union pico_address node_address;
+ node_address.ip4.addr = hdr->dst.addr;
+ if(hdr->dst.addr && pico_ipv4_is_unicast(hdr->dst.addr))
+ pico_aodv_lookup(&node_address);
+ }
+#endif
+
+ if (pico_ipv4_link_get(&hdr->dst)) {
+ /* it's our own IP */
+ return pico_enqueue(&in, f);
+ } else{
+ /* TODO: Check if there are members subscribed here */
+ return pico_enqueue(&out, f);
+ }
+
+drop:
+ pico_frame_discard(f);
+ return -1;
+}
+
+
+static int pico_ipv4_frame_sock_push(struct pico_protocol *self, struct pico_frame *f)
+{
+ struct pico_ip4 *dst;
+ struct pico_remote_endpoint *remote_endpoint = (struct pico_remote_endpoint *) f->info;
+ IGNORE_PARAMETER(self);
+
+ if (!f->sock) {
+ pico_frame_discard(f);
+ return -1;
+ }
+
+ if (remote_endpoint) {
+ dst = &remote_endpoint->remote_addr.ip4;
+ } else {
+ dst = &f->sock->remote_addr.ip4;
+ }
+
+ return pico_ipv4_frame_push(f, dst, (uint8_t)f->sock->proto->proto_number);
+}
+
+
+int MOCKABLE pico_ipv4_route_add(struct pico_ip4 address, struct pico_ip4 netmask, struct pico_ip4 gateway, int metric, struct pico_ipv4_link *link)
+{
+ struct pico_ipv4_route test, *new;
+ test.dest.addr = address.addr;
+ test.netmask.addr = netmask.addr;
+ test.metric = (uint32_t)metric;
+
+ if (pico_tree_findKey(&Routes, &test)) {
+ pico_err = PICO_ERR_EINVAL;
+ return -1;
+ }
+
+ new = PICO_ZALLOC(sizeof(struct pico_ipv4_route));
+ if (!new) {
+ pico_err = PICO_ERR_ENOMEM;
+ return -1;
+ }
+
+ new->dest.addr = address.addr;
+ new->netmask.addr = netmask.addr;
+ new->gateway.addr = gateway.addr;
+ new->metric = (uint32_t)metric;
+ if (gateway.addr == 0) {
+ /* No gateway provided, use the link */
+ new->link = link;
+ } else {
+ struct pico_ipv4_route *r = route_find(&gateway);
+ if (!r ) { /* Specified Gateway is unreachable */
+ pico_err = PICO_ERR_EHOSTUNREACH;
+ PICO_FREE(new);
+ return -1;
+ }
+
+ if (r->gateway.addr) { /* Specified Gateway is not a neighbor */
+ pico_err = PICO_ERR_ENETUNREACH;
+ PICO_FREE(new);
+ return -1;
+ }
+
+ new->link = r->link;
+ }
+
+ if (!new->link) {
+ pico_err = PICO_ERR_EINVAL;
+ PICO_FREE(new);
+ return -1;
+ }
+
+ pico_tree_insert(&Routes, new);
+ dbg_route();
+ return 0;
+}
+
+int pico_ipv4_route_del(struct pico_ip4 address, struct pico_ip4 netmask, int metric)
+{
+ struct pico_ipv4_route test, *found;
+
+ test.dest.addr = address.addr;
+ test.netmask.addr = netmask.addr;
+ test.metric = (uint32_t)metric;
+
+ found = pico_tree_findKey(&Routes, &test);
+ if (found) {
+
+ pico_tree_delete(&Routes, found);
+ PICO_FREE(found);
+
+ dbg_route();
+ return 0;
+ }
+
+ pico_err = PICO_ERR_EINVAL;
+ return -1;
+}
+
+
+int pico_ipv4_link_add(struct pico_device *dev, struct pico_ip4 address, struct pico_ip4 netmask)
+{
+ struct pico_ipv4_link test, *new;
+ struct pico_ip4 network, gateway;
+ char ipstr[30];
+
+ if (!dev) {
+ pico_err = PICO_ERR_EINVAL;
+ return -1;
+ }
+
+ test.address.addr = address.addr;
+ test.netmask.addr = netmask.addr;
+ test.dev = dev;
+ /** XXX: Valid netmask / unicast address test **/
+
+ if (pico_tree_findKey(&Tree_dev_link, &test)) {
+ pico_err = PICO_ERR_EADDRINUSE;
+ return -1;
+ }
+
+ /** XXX: Check for network already in use (e.g. trying to assign 10.0.0.1/24 where 10.1.0.1/8 is in use) **/
+ new = PICO_ZALLOC(sizeof(struct pico_ipv4_link));
+ if (!new) {
+ dbg("IPv4: Out of memory!\n");
+ pico_err = PICO_ERR_ENOMEM;
+ return -1;
+ }
+
+ new->address.addr = address.addr;
+ new->netmask.addr = netmask.addr;
+ new->dev = dev;
+#ifdef PICO_SUPPORT_MCAST
+ new->MCASTGroups = PICO_ZALLOC(sizeof(struct pico_tree));
+ if (!new->MCASTGroups) {
+ PICO_FREE(new);
+ dbg("IPv4: Out of memory!\n");
+ pico_err = PICO_ERR_ENOMEM;
+ return -1;
+ }
+
+ new->MCASTGroups->root = &LEAF;
+ new->MCASTGroups->compare = ipv4_mcast_groups_cmp;
+ new->mcast_compatibility = PICO_IGMPV3; /* default RFC 3376 $7.2.1 */
+ new->mcast_last_query_interval = PICO_IGMP_QUERY_INTERVAL;
+#endif
+
+ pico_tree_insert(&Tree_dev_link, new);
+#ifdef PICO_SUPPORT_MCAST
+ do {
+ struct pico_ip4 mcast_all_hosts, mcast_addr, mcast_nm, mcast_gw;
+ if (!mcast_default_link) {
+ mcast_addr.addr = long_be(0xE0000000); /* 224.0.0.0 */
+ mcast_nm.addr = long_be(0xF0000000); /* 15.0.0.0 */
+ mcast_gw.addr = long_be(0x00000000);
+ mcast_default_link = new;
+ pico_ipv4_route_add(mcast_addr, mcast_nm, mcast_gw, 1, new);
+ }
+
+ mcast_all_hosts.addr = PICO_MCAST_ALL_HOSTS;
+ pico_ipv4_mcast_join(&address, &mcast_all_hosts, 1, PICO_IP_MULTICAST_EXCLUDE, NULL);
+ } while(0);
+#endif
+
+ network.addr = address.addr & netmask.addr;
+ gateway.addr = 0U;
+ pico_ipv4_route_add(network, netmask, gateway, 1, new);
+ pico_ipv4_to_string(ipstr, new->address.addr);
+ dbg("Assigned ipv4 %s to device %s\n", ipstr, new->dev->name);
+ if (default_bcast_route.link == NULL)
+ default_bcast_route.link = new;
+
+ return 0;
+}
+
+static int pico_ipv4_cleanup_routes(struct pico_ipv4_link *link)
+{
+ struct pico_tree_node *index = NULL, *tmp = NULL;
+ struct pico_ipv4_route *route = NULL;
+
+ pico_tree_foreach_safe(index, &Routes, tmp) {
+ route = index->keyValue;
+ if (link == route->link)
+ pico_ipv4_route_del(route->dest, route->netmask, (int)route->metric);
+ }
+ return 0;
+}
+
+void MOCKABLE pico_ipv4_route_set_bcast_link(struct pico_ipv4_link *link)
+{
+ if (link)
+ default_bcast_route.link = link;
+}
+
+int pico_ipv4_link_del(struct pico_device *dev, struct pico_ip4 address)
+{
+ struct pico_ipv4_link test, *found;
+
+ if (!dev) {
+ pico_err = PICO_ERR_EINVAL;
+ return -1;
+ }
+
+ test.address.addr = address.addr;
+ test.dev = dev;
+ found = pico_tree_findKey(&Tree_dev_link, &test);
+ if (!found) {
+ pico_err = PICO_ERR_ENXIO;
+ return -1;
+ }
+
+#ifdef PICO_SUPPORT_MCAST
+ do {
+ struct pico_ip4 mcast_all_hosts, mcast_addr, mcast_nm;
+ struct pico_mcast_group *g = NULL;
+ struct pico_tree_node *index, *_tmp;
+ if (found == mcast_default_link) {
+ mcast_addr.addr = long_be(0xE0000000); /* 224.0.0.0 */
+ mcast_nm.addr = long_be(0xF0000000); /* 15.0.0.0 */
+ mcast_default_link = NULL;
+ pico_ipv4_route_del(mcast_addr, mcast_nm, 1);
+ }
+
+ mcast_all_hosts.addr = PICO_MCAST_ALL_HOSTS;
+ pico_ipv4_mcast_leave(&address, &mcast_all_hosts, 1, PICO_IP_MULTICAST_EXCLUDE, NULL);
+ pico_tree_foreach_safe(index, found->MCASTGroups, _tmp) {
+ g = index->keyValue;
+ pico_tree_delete(found->MCASTGroups, g);
+ PICO_FREE(g);
+ }
+ } while(0);
+#endif
+
+ pico_ipv4_cleanup_routes(found);
+ pico_tree_delete(&Tree_dev_link, found);
+ if (default_bcast_route.link == found)
+ default_bcast_route.link = NULL;
+
+ PICO_FREE(found);
+
+ return 0;
+}
+
+
+struct pico_ipv4_link *pico_ipv4_link_get(struct pico_ip4 *address)
+{
+ struct pico_ipv4_link test = {
+ 0
+ }, *found = NULL;
+ test.address.addr = address->addr;
+
+ found = pico_tree_findKey(&Tree_dev_link, &test);
+ if (!found)
+ return NULL;
+ else
+ return found;
+}
+
+struct pico_ipv4_link *MOCKABLE pico_ipv4_link_by_dev(struct pico_device *dev)
+{
+ struct pico_tree_node *index = NULL;
+ struct pico_ipv4_link *link = NULL;
+
+ pico_tree_foreach(index, &Tree_dev_link) {
+ link = index->keyValue;
+ if (link->dev == dev)
+ return link;
+ }
+ return NULL;
+}
+
+struct pico_ipv4_link *pico_ipv4_link_by_dev_next(struct pico_device *dev, struct pico_ipv4_link *last)
+{
+ struct pico_tree_node *index = NULL;
+ struct pico_ipv4_link *link = NULL;
+ int valid = 0;
+
+ if (last == NULL)
+ valid = 1;
+
+ pico_tree_foreach(index, &Tree_dev_link) {
+ link = index->keyValue;
+ if (link->dev == dev) {
+ if (last == link)
+ valid = 1;
+ else if (valid > 0)
+ return link;
+ }
+ }
+ return NULL;
+}
+
+struct pico_device *MOCKABLE pico_ipv4_link_find(struct pico_ip4 *address)
+{
+ struct pico_ipv4_link test, *found;
+ if (!address) {
+ pico_err = PICO_ERR_EINVAL;
+ return NULL;
+ }
+
+ test.dev = NULL;
+ test.address.addr = address->addr;
+ found = pico_tree_findKey(&Tree_dev_link, &test);
+ if (!found) {
+ pico_err = PICO_ERR_ENXIO;
+ return NULL;
+ }
+
+ return found->dev;
+}
+
+
+static int pico_ipv4_rebound_large(struct pico_frame *f)
+{
+#ifdef PICO_SUPPORT_IPFRAG
+ uint16_t total_payload_written = 0;
+ uint32_t len = f->transport_len;
+ struct pico_frame *fr;
+ struct pico_ip4 dst;
+ struct pico_ipv4_hdr *hdr;
+ hdr = (struct pico_ipv4_hdr *) f->net_hdr;
+ dst.addr = hdr->src.addr;
+
+ while(total_payload_written < len) {
+ uint32_t space = (uint32_t)len - total_payload_written;
+ if (space > PICO_IPV4_MAXPAYLOAD)
+ space = PICO_IPV4_MAXPAYLOAD;
+
+ fr = pico_ipv4_alloc(&pico_proto_ipv4, (uint16_t)space);
+ if (!fr) {
+ pico_err = PICO_ERR_ENOMEM;
+ return -1;
+ }
+
+ if (space + total_payload_written < len)
+ {
+ fr->frag |= PICO_IPV4_MOREFRAG;
+ }
+ else
+ {
+ fr->frag &= PICO_IPV4_FRAG_MASK;
+ }
+
+ fr->frag = (((total_payload_written) >> 3u) & 0xffffu) | fr->frag;
+
+ memcpy(fr->transport_hdr, f->transport_hdr + total_payload_written, fr->transport_len);
+ if (pico_ipv4_frame_push(fr, &dst, hdr->proto) > 0) {
+ total_payload_written = (uint16_t)((uint16_t)fr->transport_len + total_payload_written);
+ } else {
+ pico_frame_discard(fr);
+ break;
+ }
+ } /* while() */
+ return (int)total_payload_written;
+#else
+ (void)f;
+ return -1;
+#endif
+}
+
+int pico_ipv4_rebound(struct pico_frame *f)
+{
+ struct pico_ip4 dst;
+ struct pico_ipv4_hdr *hdr;
+ if (!f) {
+ pico_err = PICO_ERR_EINVAL;
+ return -1;
+ }
+
+ hdr = (struct pico_ipv4_hdr *) f->net_hdr;
+ if (!hdr) {
+ pico_err = PICO_ERR_EINVAL;
+ return -1;
+ }
+
+ dst.addr = hdr->src.addr;
+ if (f->transport_len > PICO_IPV4_MAXPAYLOAD) {
+ return pico_ipv4_rebound_large(f);
+ }
+
+ return pico_ipv4_frame_push(f, &dst, hdr->proto);
+}
+
+static int pico_ipv4_pre_forward_checks(struct pico_frame *f)
+{
+ static uint16_t last_id = 0;
+ static uint16_t last_proto = 0;
+ static struct pico_ip4 last_src = {
+ 0
+ };
+ static struct pico_ip4 last_dst = {
+ 0
+ };
+ struct pico_ipv4_hdr *hdr = (struct pico_ipv4_hdr *)f->net_hdr;
+
+ /* Decrease TTL, check if expired */
+ hdr->ttl = (uint8_t)(hdr->ttl - 1);
+ if (hdr->ttl < 1) {
+ pico_notify_ttl_expired(f);
+ dbg(" ------------------- TTL EXPIRED\n");
+ return -1;
+ }
+
+ /* HACK: increase crc to compensate decreased TTL */
+ hdr->crc++;
+
+ /* If source is local, discard anyway (packets bouncing back and forth) */
+ if (pico_ipv4_link_get(&hdr->src))
+ return -1;
+
+ /* If this was the last forwarded packet, silently discard to prevent duplications */
+ if ((last_src.addr == hdr->src.addr) && (last_id == hdr->id)
+ && (last_dst.addr == hdr->dst.addr) && (last_proto == hdr->proto)) {
+ return -1;
+ } else {
+ last_src.addr = hdr->src.addr;
+ last_dst.addr = hdr->dst.addr;
+ last_id = hdr->id;
+ last_proto = hdr->proto;
+ }
+
+ return 0;
+}
+
+static int pico_ipv4_forward_check_dev(struct pico_frame *f)
+{
+ if (f->dev->eth != NULL)
+ f->len -= PICO_SIZE_ETHHDR;
+
+ if (f->len > f->dev->mtu) {
+ pico_notify_pkt_too_big(f);
+ return -1;
+ }
+
+ return 0;
+}
+
+static int pico_ipv4_forward(struct pico_frame *f)
+{
+ struct pico_ipv4_hdr *hdr = (struct pico_ipv4_hdr *)f->net_hdr;
+ struct pico_ipv4_route *rt;
+ if (!hdr) {
+ return -1;
+ }
+
+ rt = route_find(&hdr->dst);
+ if (!rt) {
+ pico_notify_dest_unreachable(f);
+ return -1;
+ }
+
+ f->dev = rt->link->dev;
+
+ if (pico_ipv4_pre_forward_checks(f) < 0)
+ return -1;
+
+ pico_ipv4_nat_outbound(f, &rt->link->address);
+
+ f->start = f->net_hdr;
+
+ if (pico_ipv4_forward_check_dev(f) < 0)
+ return -1;
+
+ pico_sendto_dev(f);
+ return 0;
+
+}
+
+int pico_ipv4_is_broadcast(uint32_t addr)
+{
+ struct pico_ipv4_link *link;
+ struct pico_tree_node *index;
+ if (addr == PICO_IP4_BCAST)
+ return 1;
+
+ pico_tree_foreach(index, &Tree_dev_link) {
+ link = index->keyValue;
+ if ((link->address.addr | (~link->netmask.addr)) == addr)
+ return 1;
+ }
+ return 0;
+}
+
+void pico_ipv4_unreachable(struct pico_frame *f, int err)
+{
+ struct pico_ipv4_hdr *hdr = (struct pico_ipv4_hdr *) f->net_hdr;
+#if defined PICO_SUPPORT_TCP || defined PICO_SUPPORT_UDP
+ f->transport_hdr = ((uint8_t *)f->net_hdr) + PICO_SIZE_IP4HDR;
+ pico_transport_error(f, hdr->proto, err);
+#endif
+}
+
+int pico_ipv4_cleanup_links(struct pico_device *dev)
+{
+ struct pico_tree_node *index = NULL, *_tmp = NULL;
+ struct pico_ipv4_link *link = NULL;
+
+ pico_tree_foreach_safe(index, &Tree_dev_link, _tmp) {
+ link = index->keyValue;
+ if (dev == link->dev)
+ pico_ipv4_link_del(dev, link->address);
+ }
+ return 0;
+}
+
+
+#endif
diff --git a/net/picotcp/modules/pico_ipv4.h b/net/picotcp/modules/pico_ipv4.h
new file mode 100644
index 0000000..2429815
--- /dev/null
+++ b/net/picotcp/modules/pico_ipv4.h
@@ -0,0 +1,124 @@
+/*********************************************************************
+ PicoTCP. Copyright (c) 2012-2015 Altran Intelligent Systems. Some rights reserved.
+ See LICENSE and COPYING for usage.
+
+ .
+
+ *********************************************************************/
+#ifndef INCLUDE_PICO_IPV4
+#define INCLUDE_PICO_IPV4
+#include "pico_addressing.h"
+#include "pico_protocol.h"
+#include "pico_tree.h"
+#include "pico_device.h"
+
+#define PICO_IPV4_INADDR_ANY 0x00000000U
+
+#define PICO_IPV4_MTU (1500u)
+#define PICO_SIZE_IP4HDR (uint32_t)((sizeof(struct pico_ipv4_hdr)))
+#define PICO_IPV4_MAXPAYLOAD (PICO_IPV4_MTU - PICO_SIZE_IP4HDR)
+#define PICO_IPV4_DONTFRAG 0x4000U
+#define PICO_IPV4_MOREFRAG 0x2000U
+#define PICO_IPV4_EVIL 0x8000U
+#define PICO_IPV4_FRAG_MASK 0x1FFFU
+#define PICO_IPV4_DEFAULT_TTL 64
+#ifndef MBED
+ #define PICO_IPV4_FRAG_MAX_SIZE (uint32_t)(63 * 1024)
+#else
+ #define PICO_IPV4_FRAG_MAX_SIZE PICO_DEFAULT_SOCKETQ
+#endif
+
+extern struct pico_protocol pico_proto_ipv4;
+
+PACKED_STRUCT_DEF pico_ipv4_hdr {
+ uint8_t vhl;
+ uint8_t tos;
+ uint16_t len;
+ uint16_t id;
+ uint16_t frag;
+ uint8_t ttl;
+ uint8_t proto;
+ uint16_t crc;
+ struct pico_ip4 src;
+ struct pico_ip4 dst;
+ uint8_t options[];
+};
+
+PACKED_STRUCT_DEF pico_ipv4_pseudo_hdr
+{
+ struct pico_ip4 src;
+ struct pico_ip4 dst;
+ uint8_t zeros;
+ uint8_t proto;
+ uint16_t len;
+};
+
+/* Interface: link to device */
+struct pico_mcast_list;
+
+struct pico_ipv4_link
+{
+ struct pico_device *dev;
+ struct pico_ip4 address;
+ struct pico_ip4 netmask;
+#ifdef PICO_SUPPORT_MCAST
+ struct pico_tree *MCASTGroups;
+ uint8_t mcast_compatibility;
+ uint8_t mcast_last_query_interval;
+#endif
+};
+
+#ifdef PICO_SUPPORT_MCAST
+struct pico_mcast_group {
+ uint8_t filter_mode;
+ uint16_t reference_count;
+ struct pico_ip4 mcast_addr;
+ struct pico_tree MCASTSources;
+};
+#endif
+
+struct pico_ipv4_route
+{
+ struct pico_ip4 dest;
+ struct pico_ip4 netmask;
+ struct pico_ip4 gateway;
+ struct pico_ipv4_link *link;
+ uint32_t metric;
+};
+
+extern struct pico_tree Routes;
+
+
+int pico_ipv4_compare(struct pico_ip4 *a, struct pico_ip4 *b);
+int pico_ipv4_to_string(char *ipbuf, const uint32_t ip);
+int pico_string_to_ipv4(const char *ipstr, uint32_t *ip);
+int pico_ipv4_valid_netmask(uint32_t mask);
+int pico_ipv4_is_unicast(uint32_t address);
+int pico_ipv4_is_multicast(uint32_t address);
+int pico_ipv4_is_broadcast(uint32_t addr);
+int pico_ipv4_is_loopback(uint32_t addr);
+int pico_ipv4_is_valid_src(uint32_t addr, struct pico_device *dev);
+
+int pico_ipv4_link_add(struct pico_device *dev, struct pico_ip4 address, struct pico_ip4 netmask);
+int pico_ipv4_link_del(struct pico_device *dev, struct pico_ip4 address);
+int pico_ipv4_rebound(struct pico_frame *f);
+
+int pico_ipv4_frame_push(struct pico_frame *f, struct pico_ip4 *dst, uint8_t proto);
+struct pico_ipv4_link *pico_ipv4_link_get(struct pico_ip4 *address);
+struct pico_ipv4_link *pico_ipv4_link_by_dev(struct pico_device *dev);
+struct pico_ipv4_link *pico_ipv4_link_by_dev_next(struct pico_device *dev, struct pico_ipv4_link *last);
+struct pico_device *pico_ipv4_link_find(struct pico_ip4 *address);
+struct pico_ip4 *pico_ipv4_source_find(const struct pico_ip4 *dst);
+struct pico_device *pico_ipv4_source_dev_find(const struct pico_ip4 *dst);
+int pico_ipv4_route_add(struct pico_ip4 address, struct pico_ip4 netmask, struct pico_ip4 gateway, int metric, struct pico_ipv4_link *link);
+int pico_ipv4_route_del(struct pico_ip4 address, struct pico_ip4 netmask, int metric);
+struct pico_ip4 pico_ipv4_route_get_gateway(struct pico_ip4 *addr);
+void pico_ipv4_route_set_bcast_link(struct pico_ipv4_link *link);
+void pico_ipv4_unreachable(struct pico_frame *f, int err);
+
+int pico_ipv4_mcast_join(struct pico_ip4 *mcast_link, struct pico_ip4 *mcast_group, uint8_t reference_count, uint8_t filter_mode, struct pico_tree *MCASTFilter);
+int pico_ipv4_mcast_leave(struct pico_ip4 *mcast_link, struct pico_ip4 *mcast_group, uint8_t reference_count, uint8_t filter_mode, struct pico_tree *MCASTFilter);
+struct pico_ipv4_link *pico_ipv4_get_default_mcastlink(void);
+int pico_ipv4_cleanup_links(struct pico_device *dev);
+
+#endif /* _INCLUDE_PICO_IPV4 */
diff --git a/net/picotcp/modules/pico_ipv6.h b/net/picotcp/modules/pico_ipv6.h
new file mode 100644
index 0000000..a753531
--- /dev/null
+++ b/net/picotcp/modules/pico_ipv6.h
@@ -0,0 +1,153 @@
+/*********************************************************************
+ PicoTCP. Copyright (c) 2012-2015 Altran Intelligent Systems. Some rights reserved.
+ See LICENSE and COPYING for usage.
+
+ .
+
+ *********************************************************************/
+#ifndef _INCLUDE_PICO_IPV6
+#define _INCLUDE_PICO_IPV6
+#include "pico_addressing.h"
+#include "pico_protocol.h"
+
+#define PICO_SIZE_IP6HDR ((uint32_t)(sizeof(struct pico_ipv6_hdr)))
+#define PICO_IPV6_DEFAULT_HOP 64
+#define PICO_IPV6_MIN_MTU 1280
+
+
+#define PICO_IPV6_EXTHDR_HOPBYHOP 0
+#define PICO_IPV6_EXTHDR_ROUTING 43
+#define PICO_IPV6_EXTHDR_FRAG 44
+#define PICO_IPV6_EXTHDR_ESP 50
+#define PICO_IPV6_EXTHDR_AUTH 51
+#define PICO_IPV6_EXTHDR_NONE 59
+#define PICO_IPV6_EXTHDR_DESTOPT 60
+
+
+
+
+extern const uint8_t PICO_IP6_ANY[PICO_SIZE_IP6];
+extern struct pico_protocol pico_proto_ipv6;
+extern struct pico_tree IPV6Routes;
+
+PACKED_STRUCT_DEF pico_ipv6_hdr {
+ uint32_t vtf;
+ uint16_t len;
+ uint8_t nxthdr;
+ uint8_t hop;
+ struct pico_ip6 src;
+ struct pico_ip6 dst;
+ uint8_t extensions[0];
+};
+
+PACKED_STRUCT_DEF pico_ipv6_pseudo_hdr
+{
+ struct pico_ip6 src;
+ struct pico_ip6 dst;
+ uint32_t len;
+ uint8_t zero[3];
+ uint8_t nxthdr;
+};
+
+struct pico_ipv6_link
+{
+ struct pico_device *dev;
+ struct pico_ip6 address;
+ struct pico_ip6 netmask;
+ uint8_t istentative : 1;
+ uint8_t isduplicate : 1;
+ struct pico_timer *dad_timer;
+ uint16_t dup_detect_retrans;
+ pico_time expire_time;
+};
+
+struct pico_ipv6_hbhoption {
+ uint8_t type;
+ uint8_t len;
+ uint8_t options[0];
+};
+
+struct pico_ipv6_destoption {
+ uint8_t type;
+ uint8_t len;
+ uint8_t options[0];
+};
+
+struct pico_ipv6_route
+{
+ struct pico_ip6 dest;
+ struct pico_ip6 netmask;
+ struct pico_ip6 gateway;
+ struct pico_ipv6_link *link;
+ uint32_t metric;
+};
+
+PACKED_STRUCT_DEF pico_ipv6_exthdr {
+ uint8_t nxthdr;
+
+ PACKED_UNION_DEF ipv6_ext_u {
+ PEDANTIC_STRUCT_DEF hopbyhop_s {
+ uint8_t len;
+ uint8_t options[0];
+ } hopbyhop;
+
+ PEDANTIC_STRUCT_DEF destopt_s {
+ uint8_t len;
+ uint8_t options[0];
+ } destopt;
+
+ PEDANTIC_STRUCT_DEF routing_s {
+ uint8_t len;
+ uint8_t routtype;
+ uint8_t segleft;
+ } routing;
+
+ PEDANTIC_STRUCT_DEF fragmentation_s {
+ uint8_t res;
+ uint8_t om[2];
+ uint8_t id[4];
+ } frag;
+ } ext;
+};
+
+int pico_ipv6_compare(struct pico_ip6 *a, struct pico_ip6 *b);
+int pico_string_to_ipv6(const char *ipstr, uint8_t *ip);
+int pico_ipv6_to_string(char *ipbuf, const uint8_t ip[PICO_SIZE_IP6]);
+int pico_ipv6_is_unicast(struct pico_ip6 *a);
+int pico_ipv6_is_multicast(const uint8_t addr[PICO_SIZE_IP6]);
+int pico_ipv6_is_allhosts_multicast(const uint8_t addr[PICO_SIZE_IP6]);
+int pico_ipv6_is_solnode_multicast(const uint8_t addr[PICO_SIZE_IP6], struct pico_device *dev);
+int pico_ipv6_is_global(const uint8_t addr[PICO_SIZE_IP6]);
+int pico_ipv6_is_uniquelocal(const uint8_t addr[PICO_SIZE_IP6]);
+int pico_ipv6_is_sitelocal(const uint8_t addr[PICO_SIZE_IP6]);
+int pico_ipv6_is_linklocal(const uint8_t addr[PICO_SIZE_IP6]);
+int pico_ipv6_is_solicited(const uint8_t addr[PICO_SIZE_IP6]);
+int pico_ipv6_is_unspecified(const uint8_t addr[PICO_SIZE_IP6]);
+int pico_ipv6_is_localhost(const uint8_t addr[PICO_SIZE_IP6]);
+
+int pico_ipv6_frame_push(struct pico_frame *f, struct pico_ip6 *src, struct pico_ip6 *dst, uint8_t proto, int is_dad);
+int pico_ipv6_route_add(struct pico_ip6 address, struct pico_ip6 netmask, struct pico_ip6 gateway, int metric, struct pico_ipv6_link *link);
+int pico_ipv6_route_del(struct pico_ip6 address, struct pico_ip6 netmask, struct pico_ip6 gateway, int metric, struct pico_ipv6_link *link);
+void pico_ipv6_unreachable(struct pico_frame *f, uint8_t code);
+
+struct pico_ipv6_link *pico_ipv6_link_add(struct pico_device *dev, struct pico_ip6 address, struct pico_ip6 netmask);
+int pico_ipv6_link_del(struct pico_device *dev, struct pico_ip6 address);
+int pico_ipv6_cleanup_links(struct pico_device *dev);
+struct pico_ipv6_link *pico_ipv6_link_istentative(struct pico_ip6 *address);
+struct pico_ipv6_link *pico_ipv6_link_get(struct pico_ip6 *address);
+struct pico_device *pico_ipv6_link_find(struct pico_ip6 *address);
+struct pico_ip6 pico_ipv6_route_get_gateway(struct pico_ip6 *addr);
+struct pico_ip6 *pico_ipv6_source_find(const struct pico_ip6 *dst);
+struct pico_device *pico_ipv6_source_dev_find(const struct pico_ip6 *dst);
+struct pico_ipv6_link *pico_ipv6_link_by_dev(struct pico_device *dev);
+struct pico_ipv6_link *pico_ipv6_link_by_dev_next(struct pico_device *dev, struct pico_ipv6_link *last);
+struct pico_ipv6_link *pico_ipv6_global_get(struct pico_device *dev);
+struct pico_ipv6_link *pico_ipv6_linklocal_get(struct pico_device *dev);
+struct pico_ipv6_link *pico_ipv6_sitelocal_get(struct pico_device *dev);
+struct pico_ipv6_link *pico_ipv6_prefix_configured(struct pico_ip6 *prefix);
+int pico_ipv6_lifetime_set(struct pico_ipv6_link *l, pico_time expire);
+void pico_ipv6_check_lifetime_expired(pico_time now, void *arg);
+int pico_ipv6_dev_routing_enable(struct pico_device *dev);
+int pico_ipv6_dev_routing_disable(struct pico_device *dev);
+void pico_ipv6_router_down(struct pico_ip6 *address);
+#endif
diff --git a/net/picotcp/modules/pico_ipv6_nd.h b/net/picotcp/modules/pico_ipv6_nd.h
new file mode 100644
index 0000000..f709b1e
--- /dev/null
+++ b/net/picotcp/modules/pico_ipv6_nd.h
@@ -0,0 +1,26 @@
+/*********************************************************************
+ PicoTCP. Copyright (c) 2012-2015 Altran Intelligent Systems. Some rights reserved.
+ See LICENSE and COPYING for usage.
+
+ *********************************************************************/
+#ifndef _INCLUDE_PICO_ND
+#define _INCLUDE_PICO_ND
+#include "pico_frame.h"
+
+/* RFC constants */
+#define PICO_ND_REACHABLE_TIME 30000 /* msec */
+#define PICO_ND_RETRANS_TIMER 1000 /* msec */
+
+struct pico_nd_hostvars {
+ uint8_t routing;
+ uint8_t hoplimit;
+ pico_time basetime;
+ pico_time reachabletime;
+ pico_time retranstime;
+};
+
+void pico_ipv6_nd_init(void);
+struct pico_eth *pico_ipv6_get_neighbor(struct pico_frame *f);
+void pico_ipv6_nd_postpone(struct pico_frame *f);
+int pico_ipv6_nd_recv(struct pico_frame *f);
+#endif
diff --git a/net/picotcp/modules/pico_mm.h b/net/picotcp/modules/pico_mm.h
new file mode 100644
index 0000000..29366d0
--- /dev/null
+++ b/net/picotcp/modules/pico_mm.h
@@ -0,0 +1,98 @@
+/*********************************************************************
+ PicoTCP. Copyright (c) 2012-2015 Altran Intelligent Systems. Some rights reserved.
+ See LICENSE and COPYING for usage.
+
+ Authors: Gustav Janssens, Jonas Van Nieuwenberg, Sam Van Den Berge
+ *********************************************************************/
+
+
+#ifndef _INCLUDE_PICO_MM
+#define _INCLUDE_PICO_MM
+
+#include "pico_config.h"
+
+/*
+ * Memory init function, this will create a memory manager instance
+ * A memory_manager page will be created, along with one page of memory
+ * Memory can be asked for via the pico_mem_zalloc function
+ * More memory will be allocated to the memory manager according to its needs
+ * A maximum amount of memory of uint32_t memsize can be allocated
+ */
+void pico_mem_init(uint32_t memsize);
+/*
+ * Memory deinit function, this will free all memory occupied by the current
+ * memory manager instance.
+ */
+void pico_mem_deinit(void);
+/*
+ * Zero-initialized malloc function, will reserve a memory segment of length uint32_t len
+ * This memory will be quickly allocated in a slab of fixed size if possible
+ * or less optimally in the heap for a small variable size
+ * The fixed size of the slabs can be changed dynamically via a statistics engine
+ */
+void*pico_mem_zalloc(size_t len);
+/*
+ * Free function, free a block of memory pointed to by ptr.
+ * Unused memory is only returned to the system's control by pico_mem_cleanup
+ */
+void pico_mem_free(void*ptr);
+/*
+ * This cleanup function will be provided by the memory manager
+ * It can be called during processor downtime
+ * This function will return unused pages to the system's control
+ * Pages are unused if they no longer contain slabs or heap, and they have been idle for a longer time
+ */
+void pico_mem_cleanup(uint32_t timestamp);
+
+
+
+#ifdef PICO_SUPPORT_MM_PROFILING
+/***********************************************************************************************************************
+ ***********************************************************************************************************************
+ MEMORY PROFILING FUNCTIONS
+ ***********************************************************************************************************************
+ ***********************************************************************************************************************/
+/* General info struct */
+struct profiling_data
+{
+ uint32_t free_heap_space;
+ uint32_t free_slab_space;
+ uint32_t used_heap_space;
+ uint32_t used_slab_space;
+};
+
+/*
+ * This function fills up a struct with used and free slab and heap space in the memory manager
+ * The user is responsible for resource managment
+ */
+void pico_mem_profile_collect_data(struct profiling_data*profiling_page_struct);
+
+/*
+ * This function prints the general structure of the memory manager
+ * Printf in this function can be rerouted to send this data over a serial port, or to write it away to memory
+ */
+void pico_mem_profile_scan_data(void);
+
+/*
+ * This function returns the total size that the manager has received from the system
+ * This can give an indication of the total system resource commitment, but keep in mind that
+ * there can be many free blocks in this "used" size
+ * Together with pico_mem_profile_collect_data, this can give a good estimation of the total
+ * resource commitment
+ */
+uint32_t pico_mem_profile_used_size(void);
+
+/*
+ * This function returns a pointer to page 0, the main memory manager housekeeping (struct pico_mem_manager).
+ * This can be used to collect data about the memory in user defined functions.
+ * Use with care!
+ */
+void*pico_mem_profile_manager(void);
+
+/*
+ * paramter manager is a pointer to a struct pico_mem_manager
+ */
+void pico_mem_init_profiling(void*manager, uint32_t memsize);
+#endif /* PICO_SUPPORT_MM_PROFILING */
+
+#endif /* _INCLUDE_PICO_MM */
diff --git a/net/picotcp/modules/pico_nat.h b/net/picotcp/modules/pico_nat.h
new file mode 100644
index 0000000..5237501
--- /dev/null
+++ b/net/picotcp/modules/pico_nat.h
@@ -0,0 +1,90 @@
+/*********************************************************************
+ PicoTCP. Copyright (c) 2012-2015 Altran Intelligent Systems. Some rights reserved.
+ See LICENSE and COPYING for usage.
+
+ .
+
+ Authors: Kristof Roelants, Simon Maes, Brecht Van Cauwenberghe
+ *********************************************************************/
+
+#ifndef INCLUDE_PICO_NAT
+#define INCLUDE_PICO_NAT
+#include "pico_frame.h"
+
+#define PICO_NAT_PORT_FORWARD_DEL 0
+#define PICO_NAT_PORT_FORWARD_ADD 1
+
+#ifdef PICO_SUPPORT_NAT
+void pico_ipv4_nat_print_table(void);
+int pico_ipv4_nat_find(uint16_t nat_port, struct pico_ip4 *src_addr, uint16_t src_port, uint8_t proto);
+int pico_ipv4_port_forward(struct pico_ip4 nat_addr, uint16_t nat_port, struct pico_ip4 src_addr, uint16_t src_port, uint8_t proto, uint8_t flag);
+
+int pico_ipv4_nat_inbound(struct pico_frame *f, struct pico_ip4 *link_addr);
+int pico_ipv4_nat_outbound(struct pico_frame *f, struct pico_ip4 *link_addr);
+int pico_ipv4_nat_enable(struct pico_ipv4_link *link);
+int pico_ipv4_nat_disable(void);
+int pico_ipv4_nat_is_enabled(struct pico_ip4 *link_addr);
+#else
+
+#define pico_ipv4_nat_print_table() do {} while(0)
+static inline int pico_ipv4_nat_inbound(struct pico_frame *f, struct pico_ip4 *link_addr)
+{
+ (void)f;
+ (void)link_addr;
+ pico_err = PICO_ERR_EPROTONOSUPPORT;
+ return -1;
+}
+
+static inline int pico_ipv4_nat_outbound(struct pico_frame *f, struct pico_ip4 *link_addr)
+{
+ (void)f;
+ (void)link_addr;
+ pico_err = PICO_ERR_EPROTONOSUPPORT;
+ return -1;
+}
+
+static inline int pico_ipv4_nat_enable(struct pico_ipv4_link *link)
+{
+ (void)link;
+ pico_err = PICO_ERR_EPROTONOSUPPORT;
+ return -1;
+}
+
+static inline int pico_ipv4_nat_disable(void)
+{
+ pico_err = PICO_ERR_EPROTONOSUPPORT;
+ return -1;
+}
+
+static inline int pico_ipv4_nat_is_enabled(struct pico_ip4 *link_addr)
+{
+ (void)link_addr;
+ pico_err = PICO_ERR_EPROTONOSUPPORT;
+ return -1;
+}
+
+static inline int pico_ipv4_nat_find(uint16_t nat_port, struct pico_ip4 *src_addr, uint16_t src_port, uint8_t proto)
+{
+ (void)nat_port;
+ (void)src_addr;
+ (void)src_port;
+ (void)proto;
+ pico_err = PICO_ERR_EPROTONOSUPPORT;
+ return -1;
+}
+
+static inline int pico_ipv4_port_forward(struct pico_ip4 nat_addr, uint16_t nat_port, struct pico_ip4 src_addr, uint16_t src_port, uint8_t proto, uint8_t flag)
+{
+ (void)nat_addr;
+ (void)nat_port;
+ (void)src_addr;
+ (void)src_port;
+ (void)proto;
+ (void)flag;
+ pico_err = PICO_ERR_EPROTONOSUPPORT;
+ return -1;
+}
+#endif
+
+#endif /* _INCLUDE_PICO_NAT */
+
diff --git a/net/picotcp/modules/pico_olsr.h b/net/picotcp/modules/pico_olsr.h
new file mode 100644
index 0000000..11c3bf0
--- /dev/null
+++ b/net/picotcp/modules/pico_olsr.h
@@ -0,0 +1,32 @@
+/*********************************************************************
+ PicoTCP. Copyright (c) 2012-2015 Altran Intelligent Systems. Some rights reserved.
+ See LICENSE and COPYING for usage.
+
+ Authors: Daniele Lacamera
+ *********************************************************************/
+#ifndef PICO_OLSR_H
+#define PICO_OLSR_H
+
+
+/* Objects */
+struct olsr_route_entry
+{
+ struct olsr_route_entry *next;
+ uint32_t time_left;
+ struct pico_ip4 destination;
+ struct olsr_route_entry *gateway;
+ struct pico_device *iface;
+ uint16_t metric;
+ uint8_t link_type;
+ struct olsr_route_entry *children;
+ uint16_t ansn;
+ uint16_t seq;
+ uint8_t lq, nlq;
+ uint8_t *advertised_tc;
+};
+
+
+void pico_olsr_init(void);
+int pico_olsr_add(struct pico_device *dev);
+struct olsr_route_entry *olsr_get_ethentry(struct pico_device *vif);
+#endif
diff --git a/net/picotcp/modules/pico_socket_tcp.h b/net/picotcp/modules/pico_socket_tcp.h
new file mode 100644
index 0000000..6479103
--- /dev/null
+++ b/net/picotcp/modules/pico_socket_tcp.h
@@ -0,0 +1,33 @@
+#ifndef PICO_SOCKET_TCP_H
+#define PICO_SOCKET_TCP_H
+#include "pico_socket.h"
+
+#ifdef PICO_SUPPORT_TCP
+
+/* Functions/macros: conditional! */
+
+# define IS_NAGLE_ENABLED(s) (!(!(!(s->opt_flags & (1 << PICO_SOCKET_OPT_TCPNODELAY)))))
+int pico_setsockopt_tcp(struct pico_socket *s, int option, void *value);
+int pico_getsockopt_tcp(struct pico_socket *s, int option, void *value);
+int pico_socket_tcp_deliver(struct pico_sockport *sp, struct pico_frame *f);
+void pico_socket_tcp_delete(struct pico_socket *s);
+void pico_socket_tcp_cleanup(struct pico_socket *sock);
+struct pico_socket *pico_socket_tcp_open(uint16_t family);
+int pico_socket_tcp_read(struct pico_socket *s, void *buf, uint32_t len);
+void transport_flags_update(struct pico_frame *, struct pico_socket *);
+
+#else
+# define pico_getsockopt_tcp(...) (-1)
+# define pico_setsockopt_tcp(...) (-1)
+# define pico_socket_tcp_deliver(...) (-1)
+# define IS_NAGLE_ENABLED(s) (0)
+# define pico_socket_tcp_delete(...) do {} while(0)
+# define pico_socket_tcp_cleanup(...) do {} while(0)
+# define pico_socket_tcp_open(f) (NULL)
+# define pico_socket_tcp_read(...) (-1)
+# define transport_flags_update(...) do {} while(0)
+
+#endif
+
+
+#endif
diff --git a/net/picotcp/modules/pico_socket_udp.c b/net/picotcp/modules/pico_socket_udp.c
new file mode 100644
index 0000000..ea7e9e1
--- /dev/null
+++ b/net/picotcp/modules/pico_socket_udp.c
@@ -0,0 +1,250 @@
+#include "pico_config.h"
+#include "pico_socket.h"
+#include "pico_udp.h"
+#include "pico_socket_multicast.h"
+#include "pico_ipv4.h"
+#include "pico_ipv6.h"
+#include "pico_socket_udp.h"
+
+#define UDP_FRAME_OVERHEAD (sizeof(struct pico_frame))
+
+
+struct pico_socket *pico_socket_udp_open(void)
+{
+ struct pico_socket *s = NULL;
+#ifdef PICO_SUPPORT_UDP
+ s = pico_udp_open();
+ if (!s) {
+ pico_err = PICO_ERR_ENOMEM;
+ return NULL;
+ }
+
+ s->proto = &pico_proto_udp;
+ s->q_in.overhead = UDP_FRAME_OVERHEAD;
+ s->q_out.overhead = UDP_FRAME_OVERHEAD;
+#endif
+ return s;
+}
+
+
+#ifdef PICO_SUPPORT_IPV4
+static inline int pico_socket_udp_deliver_ipv4_mcast_initial_checks(struct pico_socket *s, struct pico_frame *f)
+{
+ struct pico_ip4 p_dst;
+ struct pico_ipv4_hdr *ip4hdr;
+
+ ip4hdr = (struct pico_ipv4_hdr*)(f->net_hdr);
+ p_dst.addr = ip4hdr->dst.addr;
+ if (pico_ipv4_is_multicast(p_dst.addr) && (pico_socket_mcast_filter(s, (union pico_address *)&ip4hdr->dst, (union pico_address *)&ip4hdr->src) < 0))
+ return -1;
+
+
+ if ((pico_ipv4_link_get(&ip4hdr->src)) && (PICO_SOCKET_GETOPT(s, PICO_SOCKET_OPT_MULTICAST_LOOP) == 0u)) {
+ /* Datagram from ourselves, Loop disabled, discarding. */
+ return -1;
+ }
+
+ return 0;
+}
+
+
+static int pico_socket_udp_deliver_ipv4_mcast(struct pico_socket *s, struct pico_frame *f)
+{
+ struct pico_ip4 s_local;
+ struct pico_frame *cpy;
+ struct pico_device *dev = pico_ipv4_link_find(&s->local_addr.ip4);
+
+ s_local.addr = s->local_addr.ip4.addr;
+
+ if (pico_socket_udp_deliver_ipv4_mcast_initial_checks(s, f) < 0)
+ return 0;
+
+
+
+ if ((s_local.addr == PICO_IPV4_INADDR_ANY) || /* If our local ip is ANY, or.. */
+ (dev == f->dev)) { /* the source of the bcast packet is a neighbor... */
+ cpy = pico_frame_copy(f);
+ if (!cpy)
+ return -1;
+
+ if (pico_enqueue(&s->q_in, cpy) > 0) {
+ if (s->wakeup)
+ s->wakeup(PICO_SOCK_EV_RD, s);
+ }
+ else
+ pico_frame_discard(cpy);
+ }
+
+ return 0;
+}
+
+static int pico_socket_udp_deliver_ipv4_unicast(struct pico_socket *s, struct pico_frame *f)
+{
+ struct pico_frame *cpy;
+ /* Either local socket is ANY, or matches dst */
+ cpy = pico_frame_copy(f);
+ if (!cpy)
+ return -1;
+
+ if (pico_enqueue(&s->q_in, cpy) > 0) {
+ if (s->wakeup)
+ s->wakeup(PICO_SOCK_EV_RD, s);
+ } else {
+ pico_frame_discard(cpy);
+ }
+
+ return 0;
+}
+
+
+static int pico_socket_udp_deliver_ipv4(struct pico_socket *s, struct pico_frame *f)
+{
+ int ret = 0;
+ struct pico_ip4 s_local, p_dst;
+ struct pico_ipv4_hdr *ip4hdr;
+ ip4hdr = (struct pico_ipv4_hdr*)(f->net_hdr);
+ s_local.addr = s->local_addr.ip4.addr;
+ p_dst.addr = ip4hdr->dst.addr;
+ if ((pico_ipv4_is_broadcast(p_dst.addr)) || pico_ipv4_is_multicast(p_dst.addr)) {
+ ret = pico_socket_udp_deliver_ipv4_mcast(s, f);
+ } else if ((s_local.addr == PICO_IPV4_INADDR_ANY) || (s_local.addr == p_dst.addr)) {
+ ret = pico_socket_udp_deliver_ipv4_unicast(s, f);
+ }
+
+ pico_frame_discard(f);
+ return ret;
+}
+#endif
+
+#ifdef PICO_SUPPORT_IPV6
+static inline int pico_socket_udp_deliver_ipv6_mcast(struct pico_socket *s, struct pico_frame *f)
+{
+ struct pico_ipv6_hdr *ip6hdr;
+ struct pico_frame *cpy;
+ struct pico_device *dev = pico_ipv6_link_find(&s->local_addr.ip6);
+
+ ip6hdr = (struct pico_ipv6_hdr*)(f->net_hdr);
+
+ if ((pico_ipv6_link_get(&ip6hdr->src)) && (PICO_SOCKET_GETOPT(s, PICO_SOCKET_OPT_MULTICAST_LOOP) == 0u)) {
+ /* Datagram from ourselves, Loop disabled, discarding. */
+ return 0;
+ }
+
+
+ if (pico_ipv6_is_unspecified(s->local_addr.ip6.addr) || /* If our local ip is ANY, or.. */
+ (dev == f->dev)) { /* the source of the bcast packet is a neighbor... */
+ cpy = pico_frame_copy(f);
+ if (!cpy)
+ return -1;
+
+ if (pico_enqueue(&s->q_in, cpy) > 0) {
+ if (s->wakeup)
+ s->wakeup(PICO_SOCK_EV_RD, s);
+ }
+ else
+ pico_frame_discard(cpy);
+ }
+
+ return 0;
+}
+
+static int pico_socket_udp_deliver_ipv6(struct pico_socket *s, struct pico_frame *f)
+{
+ struct pico_ip6 s_local, p_dst;
+ struct pico_ipv6_hdr *ip6hdr;
+ struct pico_frame *cpy;
+ ip6hdr = (struct pico_ipv6_hdr*)(f->net_hdr);
+ s_local = s->local_addr.ip6;
+ p_dst = ip6hdr->dst;
+ if ((pico_ipv6_is_multicast(p_dst.addr))) {
+ return pico_socket_udp_deliver_ipv6_mcast(s, f);
+ } else if (pico_ipv6_is_unspecified(s->local_addr.ip6.addr) || (pico_ipv6_compare(&s_local, &p_dst) == 0))
+ { /* Either local socket is ANY, or matches dst */
+ cpy = pico_frame_copy(f);
+ if (!cpy)
+ return -1;
+
+ if (pico_enqueue(&s->q_in, cpy) > 0) {
+ if (s->wakeup)
+ s->wakeup(PICO_SOCK_EV_RD, s);
+ }
+ }
+
+ pico_frame_discard(f);
+ return 0;
+}
+#endif
+
+
+int pico_socket_udp_deliver(struct pico_sockport *sp, struct pico_frame *f)
+{
+ struct pico_tree_node *index = NULL;
+ struct pico_tree_node *_tmp;
+ struct pico_socket *s = NULL;
+ pico_err = PICO_ERR_EPROTONOSUPPORT;
+ #ifdef PICO_SUPPORT_UDP
+ pico_err = PICO_ERR_NOERR;
+ pico_tree_foreach_safe(index, &sp->socks, _tmp){
+ s = index->keyValue;
+ if (IS_IPV4(f)) { /* IPV4 */
+#ifdef PICO_SUPPORT_IPV4
+ return pico_socket_udp_deliver_ipv4(s, f);
+#endif
+ } else if (IS_IPV6(f)) {
+#ifdef PICO_SUPPORT_IPV6
+ return pico_socket_udp_deliver_ipv6(s, f);
+#endif
+ } else {
+ /* something wrong in the packet header*/
+ }
+ } /* FOREACH */
+ pico_frame_discard(f);
+ if (s)
+ return 0;
+
+ pico_err = PICO_ERR_ENXIO;
+ #endif
+ return -1;
+}
+
+int pico_setsockopt_udp(struct pico_socket *s, int option, void *value)
+{
+ switch(option) {
+ case PICO_SOCKET_OPT_RCVBUF:
+ s->q_in.max_size = (*(uint32_t*)value);
+ return 0;
+ case PICO_SOCKET_OPT_SNDBUF:
+ s->q_out.max_size = (*(uint32_t*)value);
+ return 0;
+ }
+
+ /* switch's default */
+#ifdef PICO_SUPPORT_MCAST
+ return pico_setsockopt_mcast(s, option, value);
+#else
+ pico_err = PICO_ERR_EINVAL;
+ return -1;
+#endif
+}
+
+int pico_getsockopt_udp(struct pico_socket *s, int option, void *value)
+{
+ uint32_t *val = (uint32_t *)value;
+ switch(option) {
+ case PICO_SOCKET_OPT_RCVBUF:
+ *val = s->q_in.max_size;
+ return 0;
+ case PICO_SOCKET_OPT_SNDBUF:
+ *val = s->q_out.max_size;
+ return 0;
+ }
+
+ /* switch's default */
+#ifdef PICO_SUPPORT_MCAST
+ return pico_getsockopt_mcast(s, option, value);
+#else
+ pico_err = PICO_ERR_EINVAL;
+ return -1;
+#endif
+}
+
diff --git a/net/picotcp/modules/pico_socket_udp.h b/net/picotcp/modules/pico_socket_udp.h
new file mode 100644
index 0000000..6b3a4c9
--- /dev/null
+++ b/net/picotcp/modules/pico_socket_udp.h
@@ -0,0 +1,19 @@
+#ifndef PICO_SOCKET_UDP_H
+#define PICO_SOCKET_UDP_H
+
+struct pico_socket *pico_socket_udp_open(void);
+int pico_socket_udp_deliver(struct pico_sockport *sp, struct pico_frame *f);
+
+
+#ifdef PICO_SUPPORT_UDP
+int pico_setsockopt_udp(struct pico_socket *s, int option, void *value);
+int pico_getsockopt_udp(struct pico_socket *s, int option, void *value);
+# define pico_socket_udp_recv(s, buf, len, addr, port) pico_udp_recv(s, buf, len, addr, port, NULL)
+#else
+# define pico_socket_udp_recv(...) (0)
+# define pico_getsockopt_udp(...) (-1)
+# define pico_setsockopt_udp(...) (-1)
+#endif
+
+
+#endif
diff --git a/net/picotcp/modules/pico_tcp.h b/net/picotcp/modules/pico_tcp.h
new file mode 100644
index 0000000..d5003a8
--- /dev/null
+++ b/net/picotcp/modules/pico_tcp.h
@@ -0,0 +1,102 @@
+/*********************************************************************
+ PicoTCP. Copyright (c) 2012-2015 Altran Intelligent Systems. Some rights reserved.
+ See LICENSE and COPYING for usage.
+
+ .
+
+ *********************************************************************/
+#ifndef INCLUDE_PICO_TCP
+#define INCLUDE_PICO_TCP
+#include "pico_addressing.h"
+#include "pico_protocol.h"
+#include "pico_socket.h"
+
+extern struct pico_protocol pico_proto_tcp;
+
+PACKED_STRUCT_DEF pico_tcp_hdr {
+ struct pico_trans trans;
+ uint32_t seq;
+ uint32_t ack;
+ uint8_t len;
+ uint8_t flags;
+ uint16_t rwnd;
+ uint16_t crc;
+ uint16_t urgent;
+};
+
+PACKED_STRUCT_DEF tcp_pseudo_hdr_ipv4
+{
+ struct pico_ip4 src;
+ struct pico_ip4 dst;
+ uint16_t tcp_len;
+ uint8_t res;
+ uint8_t proto;
+};
+
+#define PICO_TCPHDR_SIZE 20
+#define PICO_SIZE_TCPOPT_SYN 20
+#define PICO_SIZE_TCPHDR (uint32_t)(sizeof(struct pico_tcp_hdr))
+
+/* TCP options */
+#define PICO_TCP_OPTION_END 0x00
+#define PICO_TCPOPTLEN_END 1u
+#define PICO_TCP_OPTION_NOOP 0x01
+#define PICO_TCPOPTLEN_NOOP 1
+#define PICO_TCP_OPTION_MSS 0x02
+#define PICO_TCPOPTLEN_MSS 4
+#define PICO_TCP_OPTION_WS 0x03
+#define PICO_TCPOPTLEN_WS 3u
+#define PICO_TCP_OPTION_SACK_OK 0x04
+#define PICO_TCPOPTLEN_SACK_OK 2
+#define PICO_TCP_OPTION_SACK 0x05
+#define PICO_TCPOPTLEN_SACK 2 /* Plus the block */
+#define PICO_TCP_OPTION_TIMESTAMP 0x08
+#define PICO_TCPOPTLEN_TIMESTAMP 10u
+
+/* TCP flags */
+#define PICO_TCP_FIN 0x01u
+#define PICO_TCP_SYN 0x02u
+#define PICO_TCP_RST 0x04u
+#define PICO_TCP_PSH 0x08u
+#define PICO_TCP_ACK 0x10u
+#define PICO_TCP_URG 0x20u
+#define PICO_TCP_ECN 0x40u
+#define PICO_TCP_CWR 0x80u
+
+#define PICO_TCP_SYNACK (PICO_TCP_SYN | PICO_TCP_ACK)
+#define PICO_TCP_PSHACK (PICO_TCP_PSH | PICO_TCP_ACK)
+#define PICO_TCP_FINACK (PICO_TCP_FIN | PICO_TCP_ACK)
+#define PICO_TCP_FINPSHACK (PICO_TCP_FIN | PICO_TCP_PSH | PICO_TCP_ACK)
+#define PICO_TCP_RSTACK (PICO_TCP_RST | PICO_TCP_ACK)
+
+
+PACKED_STRUCT_DEF pico_tcp_option
+{
+ uint8_t kind;
+ uint8_t len;
+};
+
+struct pico_socket *pico_tcp_open(uint16_t family);
+uint32_t pico_tcp_read(struct pico_socket *s, void *buf, uint32_t len);
+int pico_tcp_initconn(struct pico_socket *s);
+int pico_tcp_input(struct pico_socket *s, struct pico_frame *f);
+uint16_t pico_tcp_checksum(struct pico_frame *f);
+uint16_t pico_tcp_checksum_ipv4(struct pico_frame *f);
+#ifdef PICO_SUPPORT_IPV6
+uint16_t pico_tcp_checksum_ipv6(struct pico_frame *f);
+#endif
+uint16_t pico_tcp_overhead(struct pico_socket *s);
+int pico_tcp_output(struct pico_socket *s, int loop_score);
+int pico_tcp_queue_in_is_empty(struct pico_socket *s);
+int pico_tcp_reply_rst(struct pico_frame *f);
+void pico_tcp_cleanup_queues(struct pico_socket *sck);
+void pico_tcp_notify_closing(struct pico_socket *sck);
+void pico_tcp_flags_update(struct pico_frame *f, struct pico_socket *s);
+int pico_tcp_set_bufsize_in(struct pico_socket *s, uint32_t value);
+int pico_tcp_set_bufsize_out(struct pico_socket *s, uint32_t value);
+int pico_tcp_get_bufsize_in(struct pico_socket *s, uint32_t *value);
+int pico_tcp_get_bufsize_out(struct pico_socket *s, uint32_t *value);
+uint16_t pico_tcp_get_socket_mss(struct pico_socket *s);
+int pico_tcp_check_listen_close(struct pico_socket *s);
+
+#endif
diff --git a/net/picotcp/modules/pico_udp.c b/net/picotcp/modules/pico_udp.c
new file mode 100644
index 0000000..b7c61e4
--- /dev/null
+++ b/net/picotcp/modules/pico_udp.c
@@ -0,0 +1,216 @@
+/*********************************************************************
+ PicoTCP. Copyright (c) 2012-2015 Altran Intelligent Systems. Some rights reserved.
+ See LICENSE and COPYING for usage.
+
+ .
+
+ Authors: Daniele Lacamera
+ *********************************************************************/
+
+
+#include "pico_udp.h"
+#include "pico_config.h"
+#include "pico_eth.h"
+#include "pico_socket.h"
+#include "pico_stack.h"
+
+#define UDP_FRAME_OVERHEAD (sizeof(struct pico_frame))
+#define udp_dbg(...) do {} while(0)
+
+/* Queues */
+static struct pico_queue udp_in = {
+ 0
+};
+static struct pico_queue udp_out = {
+ 0
+};
+
+
+/* Functions */
+
+uint16_t pico_udp_checksum_ipv4(struct pico_frame *f)
+{
+ struct pico_ipv4_hdr *hdr = (struct pico_ipv4_hdr *) f->net_hdr;
+ struct pico_udp_hdr *udp_hdr = (struct pico_udp_hdr *) f->transport_hdr;
+ struct pico_socket *s = f->sock;
+ struct pico_ipv4_pseudo_hdr pseudo;
+
+ if (s) {
+ /* Case of outgoing frame */
+ udp_dbg("UDP CRC: on outgoing frame\n");
+ pseudo.src.addr = s->local_addr.ip4.addr;
+ pseudo.dst.addr = s->remote_addr.ip4.addr;
+ } else {
+ /* Case of incomming frame */
+ udp_dbg("UDP CRC: on incomming frame\n");
+ pseudo.src.addr = hdr->src.addr;
+ pseudo.dst.addr = hdr->dst.addr;
+ }
+
+ pseudo.zeros = 0;
+ pseudo.proto = PICO_PROTO_UDP;
+ pseudo.len = short_be(f->transport_len);
+
+ return pico_dualbuffer_checksum(&pseudo, sizeof(struct pico_ipv4_pseudo_hdr), udp_hdr, f->transport_len);
+}
+
+#ifdef PICO_SUPPORT_IPV6
+uint16_t pico_udp_checksum_ipv6(struct pico_frame *f)
+{
+ struct pico_ipv6_hdr *ipv6_hdr = (struct pico_ipv6_hdr *)f->net_hdr;
+ struct pico_udp_hdr *udp_hdr = (struct pico_udp_hdr *)f->transport_hdr;
+ struct pico_ipv6_pseudo_hdr pseudo = {
+ .src = {{0}}, .dst = {{0}}, .len = 0, .zero = {0}, .nxthdr = 0
+ };
+ struct pico_socket *s = f->sock;
+ struct pico_remote_endpoint *remote_endpoint = (struct pico_remote_endpoint *)f->info;
+
+ /* XXX If the IPv6 packet contains a Routing header, the Destination
+ * Address used in the pseudo-header is that of the final destination */
+ if (s) {
+ /* Case of outgoing frame */
+ pseudo.src = s->local_addr.ip6;
+ if (remote_endpoint)
+ pseudo.dst = remote_endpoint->remote_addr.ip6;
+ else
+ pseudo.dst = s->remote_addr.ip6;
+ } else {
+ /* Case of incomming frame */
+ pseudo.src = ipv6_hdr->src;
+ pseudo.dst = ipv6_hdr->dst;
+ }
+
+ pseudo.len = long_be(f->transport_len);
+ pseudo.nxthdr = PICO_PROTO_UDP;
+
+ return pico_dualbuffer_checksum(&pseudo, sizeof(struct pico_ipv6_pseudo_hdr), udp_hdr, f->transport_len);
+}
+#endif
+
+
+
+static int pico_udp_process_out(struct pico_protocol *self, struct pico_frame *f)
+{
+ IGNORE_PARAMETER(self);
+ return (int)pico_network_send(f);
+}
+
+static int pico_udp_push(struct pico_protocol *self, struct pico_frame *f)
+{
+ struct pico_udp_hdr *hdr = (struct pico_udp_hdr *) f->transport_hdr;
+ struct pico_remote_endpoint *remote_endpoint = (struct pico_remote_endpoint *) f->info;
+
+ /* this (fragmented) frame should contain a transport header */
+ if (f->transport_hdr != f->payload) {
+ hdr->trans.sport = f->sock->local_port;
+ if (remote_endpoint) {
+ hdr->trans.dport = remote_endpoint->remote_port;
+ } else {
+ hdr->trans.dport = f->sock->remote_port;
+ }
+
+ hdr->len = short_be(f->transport_len);
+
+ /* do not perform CRC validation. If you want to, a system needs to be
+ implemented to calculate the CRC over the total payload of a
+ fragmented payload
+ */
+ hdr->crc = 0;
+ }
+
+ if (pico_enqueue(self->q_out, f) > 0) {
+ return f->payload_len;
+ } else {
+ return 0;
+ }
+}
+
+/* Interface: protocol definition */
+struct pico_protocol pico_proto_udp = {
+ .name = "udp",
+ .proto_number = PICO_PROTO_UDP,
+ .layer = PICO_LAYER_TRANSPORT,
+ .process_in = pico_transport_process_in,
+ .process_out = pico_udp_process_out,
+ .push = pico_udp_push,
+ .q_in = &udp_in,
+ .q_out = &udp_out,
+};
+
+
+
+struct pico_socket *pico_udp_open(void)
+{
+ struct pico_socket_udp *u = PICO_ZALLOC(sizeof(struct pico_socket_udp));
+ if (!u)
+ return NULL;
+
+ u->mode = PICO_UDP_MODE_UNICAST;
+
+#ifdef PICO_SUPPORT_MCAST
+ u->mc_ttl = PICO_IP_DEFAULT_MULTICAST_TTL;
+ /* enable multicast loopback by default */
+ u->sock.opt_flags |= (1 << PICO_SOCKET_OPT_MULTICAST_LOOP);
+#endif
+
+ return &u->sock;
+}
+
+static void pico_udp_get_msginfo(struct pico_frame *f, struct pico_msginfo *msginfo)
+{
+ msginfo->dev = f->dev;
+ if (!msginfo || !f->net_hdr)
+ return;
+
+ if (IS_IPV4(f)) { /* IPV4 */
+#ifdef PICO_SUPPORT_IPV4
+ struct pico_ipv4_hdr *hdr = (struct pico_ipv4_hdr *)(f->net_hdr);
+ msginfo->ttl = hdr->ttl;
+ msginfo->tos = hdr->tos;
+#endif
+ } else {
+#ifdef PICO_SUPPORT_IPV6
+ struct pico_ipv6_hdr *hdr = (struct pico_ipv6_hdr *)(f->net_hdr);
+ msginfo->ttl = hdr->hop;
+ msginfo->tos = (hdr->vtf >> 20) & 0xFF; /* IPv6 traffic class */
+#endif
+ }
+}
+
+uint16_t pico_udp_recv(struct pico_socket *s, void *buf, uint16_t len, void *src, uint16_t *port, struct pico_msginfo *msginfo)
+{
+ struct pico_frame *f = pico_queue_peek(&s->q_in);
+ if (f) {
+ if(!f->payload_len) {
+ f->payload = f->transport_hdr + sizeof(struct pico_udp_hdr);
+ f->payload_len = (uint16_t)(f->transport_len - sizeof(struct pico_udp_hdr));
+ }
+
+ udp_dbg("expected: %d, got: %d\n", len, f->payload_len);
+ if (src)
+ pico_store_network_origin(src, f);
+
+ if (port) {
+ struct pico_trans *hdr = (struct pico_trans *)f->transport_hdr;
+ *port = hdr->sport;
+ }
+
+ if (msginfo) {
+ pico_udp_get_msginfo(f, msginfo);
+ }
+
+ if (f->payload_len > len) {
+ memcpy(buf, f->payload, len);
+ f->payload += len;
+ f->payload_len = (uint16_t)(f->payload_len - len);
+ return len;
+ } else {
+ uint16_t ret = f->payload_len;
+ memcpy(buf, f->payload, f->payload_len);
+ f = pico_dequeue(&s->q_in);
+ pico_frame_discard(f);
+ return ret;
+ }
+ } else return 0;
+}
+
diff --git a/net/picotcp/modules/pico_udp.h b/net/picotcp/modules/pico_udp.h
new file mode 100644
index 0000000..80b97a9
--- /dev/null
+++ b/net/picotcp/modules/pico_udp.h
@@ -0,0 +1,45 @@
+/*********************************************************************
+ PicoTCP. Copyright (c) 2012-2015 Altran Intelligent Systems. Some rights reserved.
+ See LICENSE and COPYING for usage.
+
+ .
+
+ *********************************************************************/
+#ifndef INCLUDE_PICO_UDP
+#define INCLUDE_PICO_UDP
+#include "pico_addressing.h"
+#include "pico_protocol.h"
+#include "pico_socket.h"
+#define PICO_UDP_MODE_UNICAST 0x01
+#define PICO_UDP_MODE_MULTICAST 0x02
+#define PICO_UDP_MODE_BROADCAST 0xFF
+
+struct pico_socket_udp
+{
+ struct pico_socket sock;
+ int mode;
+ uint8_t mc_ttl; /* Multicasting TTL */
+};
+
+
+extern struct pico_protocol pico_proto_udp;
+
+PACKED_STRUCT_DEF pico_udp_hdr {
+ struct pico_trans trans;
+ uint16_t len;
+ uint16_t crc;
+};
+#define PICO_UDPHDR_SIZE 8
+
+struct pico_socket *pico_udp_open(void);
+uint16_t pico_udp_recv(struct pico_socket *s, void *buf, uint16_t len, void *src, uint16_t *port, struct pico_msginfo *msginfo);
+uint16_t pico_udp_checksum_ipv4(struct pico_frame *f);
+
+#ifdef PICO_SUPPORT_IPV6
+uint16_t pico_udp_checksum_ipv6(struct pico_frame *f);
+#endif
+
+
+int pico_udp_setsockopt(struct pico_socket *s, int option, void *value);
+
+#endif
diff --git a/net/picotcp/stack/pico_device.c b/net/picotcp/stack/pico_device.c
new file mode 100644
index 0000000..224b37f
--- /dev/null
+++ b/net/picotcp/stack/pico_device.c
@@ -0,0 +1,408 @@
+/*********************************************************************
+ PicoTCP. Copyright (c) 2012-2015 Altran Intelligent Systems. Some rights reserved.
+ See LICENSE and COPYING for usage.
+
+ .
+
+ Authors: Daniele Lacamera
+ *********************************************************************/
+
+#include "pico_config.h"
+#include "pico_device.h"
+#include "pico_stack.h"
+#include "pico_protocol.h"
+#include "pico_tree.h"
+#include "pico_ipv6.h"
+#include "pico_ipv4.h"
+#include "pico_icmp6.h"
+#include "pico_eth.h"
+#define PICO_DEVICE_DEFAULT_MTU (1500)
+
+struct pico_devices_rr_info {
+ struct pico_tree_node *node_in, *node_out;
+};
+
+static struct pico_devices_rr_info Devices_rr_info = {
+ NULL, NULL
+};
+
+static int pico_dev_cmp(void *ka, void *kb)
+{
+ struct pico_device *a = ka, *b = kb;
+ if (a->hash < b->hash)
+ return -1;
+
+ if (a->hash > b->hash)
+ return 1;
+
+ return 0;
+}
+
+PICO_TREE_DECLARE(Device_tree, pico_dev_cmp);
+
+#ifdef PICO_SUPPORT_IPV6
+static void device_init_ipv6_final(struct pico_device *dev, struct pico_ip6 *linklocal)
+{
+ dev->hostvars.basetime = PICO_ND_REACHABLE_TIME;
+ /* RFC 4861 $6.3.2 value between 0.5 and 1.5 times basetime */
+ dev->hostvars.reachabletime = ((5 + (pico_rand() % 10)) * PICO_ND_REACHABLE_TIME) / 10;
+ dev->hostvars.retranstime = PICO_ND_RETRANS_TIMER;
+ pico_icmp6_router_solicitation(dev, linklocal);
+ dev->hostvars.hoplimit = PICO_IPV6_DEFAULT_HOP;
+}
+
+struct pico_ipv6_link *pico_ipv6_link_add_local(struct pico_device *dev, const struct pico_ip6 *prefix)
+{
+ struct pico_ip6 newaddr;
+ struct pico_ip6 netmask64 = {{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}};
+ struct pico_ipv6_link *link;
+ memcpy(newaddr.addr, prefix->addr, PICO_SIZE_IP6);
+ /* modified EUI-64 + invert universal/local bit */
+ newaddr.addr[8] = (dev->eth->mac.addr[0] ^ 0x02);
+ newaddr.addr[9] = dev->eth->mac.addr[1];
+ newaddr.addr[10] = dev->eth->mac.addr[2];
+ newaddr.addr[11] = 0xff;
+ newaddr.addr[12] = 0xfe;
+ newaddr.addr[13] = dev->eth->mac.addr[3];
+ newaddr.addr[14] = dev->eth->mac.addr[4];
+ newaddr.addr[15] = dev->eth->mac.addr[5];
+ link = pico_ipv6_link_add(dev, newaddr, netmask64);
+ if (link) {
+ device_init_ipv6_final(dev, &newaddr);
+ }
+
+ return link;
+}
+#endif
+
+static int device_init_mac(struct pico_device *dev, uint8_t *mac)
+{
+ #ifdef PICO_SUPPORT_IPV6
+ struct pico_ip6 linklocal = {{0xfe, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xaa, 0xaa, 0xaa, 0xff, 0xfe, 0xaa, 0xaa, 0xaa}};
+ #endif
+ dev->eth = PICO_ZALLOC(sizeof(struct pico_ethdev));
+ if (dev->eth) {
+ memcpy(dev->eth->mac.addr, mac, PICO_SIZE_ETH);
+ #ifdef PICO_SUPPORT_IPV6
+ if (pico_ipv6_link_add_local(dev, &linklocal) == NULL) {
+ PICO_FREE(dev->q_in);
+ PICO_FREE(dev->q_out);
+ PICO_FREE(dev->eth);
+ return -1;
+ }
+
+ #endif
+ } else {
+ pico_err = PICO_ERR_ENOMEM;
+ return -1;
+ }
+
+ return 0;
+}
+
+int pico_device_ipv6_random_ll(struct pico_device *dev)
+{
+ #ifdef PICO_SUPPORT_IPV6
+ struct pico_ip6 linklocal = {{0xfe, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xaa, 0xaa, 0xaa, 0xff, 0xfe, 0xaa, 0xaa, 0xaa}};
+ struct pico_ip6 netmask6 = {{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}};
+ uint32_t len = (uint32_t)strlen(dev->name);
+ if (strcmp(dev->name, "loop")) {
+ do {
+ /* privacy extension + unset universal/local and individual/group bit */
+ len = pico_rand();
+ linklocal.addr[8] = (uint8_t)((len & 0xffu) & (uint8_t)(~0x03));
+ linklocal.addr[9] = (uint8_t)(len >> 8);
+ linklocal.addr[10] = (uint8_t)(len >> 16);
+ linklocal.addr[11] = (uint8_t)(len >> 24);
+ len = pico_rand();
+ linklocal.addr[12] = (uint8_t)len;
+ linklocal.addr[13] = (uint8_t)(len >> 8);
+ linklocal.addr[14] = (uint8_t)(len >> 16);
+ linklocal.addr[15] = (uint8_t)(len >> 24);
+ pico_rand_feed(dev->hash);
+ } while (pico_ipv6_link_get(&linklocal));
+
+ if (pico_ipv6_link_add(dev, linklocal, netmask6) == NULL) {
+ return -1;
+ }
+ }
+
+ #endif
+ return 0;
+}
+
+static int device_init_nomac(struct pico_device *dev)
+{
+ if (pico_device_ipv6_random_ll(dev) < 0) {
+ PICO_FREE(dev->q_in);
+ PICO_FREE(dev->q_out);
+ return -1;
+ }
+
+ dev->eth = NULL;
+ return 0;
+}
+
+int pico_device_init(struct pico_device *dev, const char *name, uint8_t *mac)
+{
+
+ uint32_t len = (uint32_t)strlen(name);
+ int ret = 0;
+ if(len > MAX_DEVICE_NAME)
+ len = MAX_DEVICE_NAME;
+
+ memcpy(dev->name, name, len);
+ dev->hash = pico_hash(dev->name, len);
+
+ Devices_rr_info.node_in = NULL;
+ Devices_rr_info.node_out = NULL;
+ dev->q_in = PICO_ZALLOC(sizeof(struct pico_queue));
+ if (!dev->q_in)
+ return -1;
+
+ dev->q_out = PICO_ZALLOC(sizeof(struct pico_queue));
+ if (!dev->q_out) {
+ PICO_FREE(dev->q_in);
+ return -1;
+ }
+
+ pico_tree_insert(&Device_tree, dev);
+ if (!dev->mtu)
+ dev->mtu = PICO_DEVICE_DEFAULT_MTU;
+
+ if (mac) {
+ ret = device_init_mac(dev, mac);
+ } else {
+ ret = device_init_nomac(dev);
+ }
+
+ return ret;
+}
+
+static void pico_queue_destroy(struct pico_queue *q)
+{
+ if (q) {
+ pico_queue_empty(q);
+ PICO_FREE(q);
+ }
+}
+
+void pico_device_destroy(struct pico_device *dev)
+{
+ if (dev->destroy)
+ dev->destroy(dev);
+
+ pico_queue_destroy(dev->q_in);
+ pico_queue_destroy(dev->q_out);
+
+ if (dev->eth)
+ PICO_FREE(dev->eth);
+
+#ifdef PICO_SUPPORT_IPV4
+ pico_ipv4_cleanup_links(dev);
+#endif
+#ifdef PICO_SUPPORT_IPV6
+ pico_ipv6_cleanup_links(dev);
+#endif
+ pico_tree_delete(&Device_tree, dev);
+
+ Devices_rr_info.node_in = NULL;
+ Devices_rr_info.node_out = NULL;
+ PICO_FREE(dev);
+}
+
+static int check_dev_serve_interrupt(struct pico_device *dev, int loop_score)
+{
+ if ((dev->__serving_interrupt) && (dev->dsr)) {
+ /* call dsr routine */
+ loop_score = dev->dsr(dev, loop_score);
+ }
+
+ return loop_score;
+}
+
+static int check_dev_serve_polling(struct pico_device *dev, int loop_score)
+{
+ if (dev->poll) {
+ loop_score = dev->poll(dev, loop_score);
+ }
+
+ return loop_score;
+}
+
+static int devloop_in(struct pico_device *dev, int loop_score)
+{
+ struct pico_frame *f;
+ while(loop_score > 0) {
+ if (dev->q_in->frames <= 0)
+ break;
+
+ /* Receive */
+ f = pico_dequeue(dev->q_in);
+ if (f) {
+ if (dev->eth) {
+ f->datalink_hdr = f->buffer;
+ (void)pico_ethernet_receive(f);
+ } else {
+ f->net_hdr = f->buffer;
+ pico_network_receive(f);
+ }
+
+ loop_score--;
+ }
+ }
+ return loop_score;
+}
+
+static int devloop_sendto_dev(struct pico_device *dev, struct pico_frame *f)
+{
+
+ if (dev->eth) {
+ /* Ethernet: pass management of the frame to the pico_ethernet_send() rdv function */
+ return pico_ethernet_send(f);
+ } else {
+ /* non-ethernet: no post-processing needed */
+ return (dev->send(dev, f->start, (int)f->len) <= 0); /* Return 0 upon success, which is dev->send() > 0 */
+ }
+}
+
+static int devloop_out(struct pico_device *dev, int loop_score)
+{
+ struct pico_frame *f;
+ while(loop_score > 0) {
+ if (dev->q_out->frames <= 0)
+ break;
+
+ /* Device dequeue + send */
+ f = pico_queue_peek(dev->q_out);
+ if (!f)
+ break;
+
+ if (devloop_sendto_dev(dev, f) == 0) { /* success. */
+ f = pico_dequeue(dev->q_out);
+ pico_frame_discard(f); /* SINGLE POINT OF DISCARD for OUTGOING FRAMES */
+ loop_score--;
+ } else
+ break; /* Don't discard */
+
+ }
+ return loop_score;
+}
+
+static int devloop(struct pico_device *dev, int loop_score, int direction)
+{
+ /* If device supports interrupts, read the value of the condition and trigger the dsr */
+ loop_score = check_dev_serve_interrupt(dev, loop_score);
+
+ /* If device supports polling, give control. Loop score is managed internally,
+ * remaining loop points are returned. */
+ loop_score = check_dev_serve_polling(dev, loop_score);
+
+ if (direction == PICO_LOOP_DIR_OUT)
+ loop_score = devloop_out(dev, loop_score);
+ else
+ loop_score = devloop_in(dev, loop_score);
+
+ return loop_score;
+}
+
+
+static struct pico_tree_node *pico_dev_roundrobin_start(int direction)
+{
+ if (Devices_rr_info.node_in == NULL)
+ Devices_rr_info.node_in = pico_tree_firstNode(Device_tree.root);
+
+ if (Devices_rr_info.node_out == NULL)
+ Devices_rr_info.node_out = pico_tree_firstNode(Device_tree.root);
+
+ if (direction == PICO_LOOP_DIR_IN)
+ return Devices_rr_info.node_in;
+ else
+ return Devices_rr_info.node_out;
+}
+
+static void pico_dev_roundrobin_end(int direction, struct pico_tree_node *last)
+{
+ if (direction == PICO_LOOP_DIR_IN)
+ Devices_rr_info.node_in = last;
+ else
+ Devices_rr_info.node_out = last;
+}
+
+#define DEV_LOOP_MIN 16
+
+int pico_devices_loop(int loop_score, int direction)
+{
+ struct pico_device *start, *next;
+ struct pico_tree_node *next_node = pico_dev_roundrobin_start(direction);
+
+ if (!next_node)
+ return loop_score;
+
+ next = next_node->keyValue;
+ start = next;
+
+ /* round-robin all devices, break if traversed all devices */
+ while ((loop_score > DEV_LOOP_MIN) && (next != NULL)) {
+ loop_score = devloop(next, loop_score, direction);
+ next_node = pico_tree_next(next_node);
+ next = next_node->keyValue;
+ if (next == NULL)
+ {
+ next_node = pico_tree_firstNode(Device_tree.root);
+ next = next_node->keyValue;
+ }
+
+ if (next == start)
+ break;
+ }
+ pico_dev_roundrobin_end(direction, next_node);
+ return loop_score;
+}
+
+struct pico_device *pico_get_device(const char*name)
+{
+ struct pico_device *dev;
+ struct pico_tree_node *index;
+ pico_tree_foreach(index, &Device_tree){
+ dev = index->keyValue;
+ if(strcmp(name, dev->name) == 0)
+ return dev;
+ }
+ return NULL;
+}
+
+int32_t pico_device_broadcast(struct pico_frame *f)
+{
+ struct pico_tree_node *index;
+ int32_t ret = -1;
+
+ pico_tree_foreach(index, &Device_tree)
+ {
+ struct pico_device *dev = index->keyValue;
+ if(dev != f->dev)
+ {
+ struct pico_frame *copy = pico_frame_copy(f);
+
+ if(!copy)
+ break;
+
+ copy->dev = dev;
+ copy->dev->send(copy->dev, copy->start, (int)copy->len);
+ pico_frame_discard(copy);
+ }
+ else
+ {
+ ret = f->dev->send(f->dev, f->start, (int)f->len);
+ }
+ }
+ return ret;
+}
+
+int pico_device_link_state(struct pico_device *dev)
+{
+ if (!dev->link_state)
+ return 1; /* Not supported, assuming link is always up */
+
+ return dev->link_state(dev);
+}
diff --git a/net/picotcp/stack/pico_frame.c b/net/picotcp/stack/pico_frame.c
new file mode 100644
index 0000000..482edfe
--- /dev/null
+++ b/net/picotcp/stack/pico_frame.c
@@ -0,0 +1,286 @@
+/*********************************************************************
+ PicoTCP. Copyright (c) 2012-2015 Altran Intelligent Systems. Some rights reserved.
+ See LICENSE and COPYING for usage.
+
+ .
+
+ Authors: Daniele Lacamera
+ *********************************************************************/
+
+
+#include "pico_config.h"
+#include "pico_frame.h"
+#include "pico_protocol.h"
+#include "pico_stack.h"
+
+#ifdef PICO_SUPPORT_DEBUG_MEMORY
+static int n_frames_allocated;
+#endif
+
+/** frame alloc/dealloc/copy **/
+void pico_frame_discard(struct pico_frame *f)
+{
+ if (!f)
+ return;
+
+ (*f->usage_count)--;
+ if (*f->usage_count <= 0) {
+ if (f->flags & PICO_FRAME_FLAG_EXT_USAGE_COUNTER)
+ PICO_FREE(f->usage_count);
+
+#ifdef PICO_SUPPORT_DEBUG_MEMORY
+ dbg("Discarded buffer @%p, caller: %p\n", f->buffer, __builtin_return_address(3));
+ dbg("DEBUG MEMORY: %d frames in use.\n", --n_frames_allocated);
+#endif
+ if (!(f->flags & PICO_FRAME_FLAG_EXT_BUFFER))
+ PICO_FREE(f->buffer);
+ else if (f->notify_free)
+ f->notify_free(f->buffer);
+
+ if (f->info)
+ PICO_FREE(f->info);
+ }
+
+#ifdef PICO_SUPPORT_DEBUG_MEMORY
+ else {
+ dbg("Removed frame @%p(copy), usage count now: %d\n", f, *f->usage_count);
+ }
+#endif
+ PICO_FREE(f);
+}
+
+struct pico_frame *pico_frame_copy(struct pico_frame *f)
+{
+ struct pico_frame *new = PICO_ZALLOC(sizeof(struct pico_frame));
+ if (!new)
+ return NULL;
+
+ memcpy(new, f, sizeof(struct pico_frame));
+ *(new->usage_count) += 1;
+#ifdef PICO_SUPPORT_DEBUG_MEMORY
+ dbg("Copied frame @%p, into %p, usage count now: %d\n", f, new, *new->usage_count);
+#endif
+ new->next = NULL;
+ return new;
+}
+
+
+static struct pico_frame *pico_frame_do_alloc(uint32_t size, int zerocopy, int ext_buffer)
+{
+ struct pico_frame *p = PICO_ZALLOC(sizeof(struct pico_frame));
+ uint32_t frame_buffer_size = size;
+ if (!p)
+ return NULL;
+
+ if (ext_buffer && !zerocopy) {
+ /* external buffer implies zerocopy flag! */
+ PICO_FREE(p);
+ return NULL;
+ }
+
+ if (!zerocopy) {
+ unsigned int align = size % sizeof(uint32_t);
+ /* Ensure that usage_count starts on an aligned address */
+ if (align) {
+ frame_buffer_size += (uint32_t)sizeof(uint32_t) - align;
+ }
+
+ p->buffer = PICO_ZALLOC(frame_buffer_size + sizeof(uint32_t));
+ if (!p->buffer) {
+ PICO_FREE(p);
+ return NULL;
+ }
+
+ p->usage_count = (uint32_t *)(((uint8_t*)p->buffer) + frame_buffer_size);
+ } else {
+ p->buffer = NULL;
+ p->flags |= PICO_FRAME_FLAG_EXT_USAGE_COUNTER;
+ p->usage_count = PICO_ZALLOC(sizeof(uint32_t));
+ if (!p->usage_count) {
+ PICO_FREE(p);
+ return NULL;
+ }
+ }
+
+
+ p->buffer_len = size;
+
+ /* By default, frame content is the full buffer. */
+ p->start = p->buffer;
+ p->len = p->buffer_len;
+ *p->usage_count = 1;
+
+ if (ext_buffer)
+ p->flags |= PICO_FRAME_FLAG_EXT_BUFFER;
+
+#ifdef PICO_SUPPORT_DEBUG_MEMORY
+ dbg("Allocated buffer @%p, len= %d caller: %p\n", p->buffer, p->buffer_len, __builtin_return_address(2));
+ dbg("DEBUG MEMORY: %d frames in use.\n", ++n_frames_allocated);
+#endif
+ return p;
+}
+
+struct pico_frame *pico_frame_alloc(uint32_t size)
+{
+ return pico_frame_do_alloc(size, 0, 0);
+}
+
+int pico_frame_grow(struct pico_frame *f, uint32_t size)
+{
+ uint8_t *oldbuf;
+ uint32_t usage_count, *p_old_usage;
+ uint32_t frame_buffer_size;
+ uint32_t oldsize;
+ unsigned int align;
+ int addr_diff = 0;
+
+ if (!f || (size < f->buffer_len)) {
+ return -1;
+ }
+
+ align = size % sizeof(uint32_t);
+ frame_buffer_size = size;
+ if (align) {
+ frame_buffer_size += (uint32_t)sizeof(uint32_t) - align;
+ }
+
+ oldbuf = f->buffer;
+ oldsize = f->buffer_len;
+ usage_count = *(f->usage_count);
+ p_old_usage = f->usage_count;
+ f->buffer = PICO_ZALLOC(frame_buffer_size + sizeof(uint32_t));
+ if (!f->buffer) {
+ f->buffer = oldbuf;
+ return -1;
+ }
+
+ f->usage_count = (uint32_t *)(((uint8_t*)f->buffer) + frame_buffer_size);
+ *f->usage_count = usage_count;
+ f->buffer_len = size;
+ memcpy(f->buffer, oldbuf, oldsize);
+
+ /* Update hdr fields to new buffer*/
+ addr_diff = (int)(f->buffer - oldbuf);
+ f->net_hdr += addr_diff;
+ f->datalink_hdr += addr_diff;
+ f->transport_hdr += addr_diff;
+ f->app_hdr += addr_diff;
+ f->start += addr_diff;
+ f->payload += addr_diff;
+
+ if (f->flags & PICO_FRAME_FLAG_EXT_USAGE_COUNTER)
+ PICO_FREE(p_old_usage);
+
+ if (!(f->flags & PICO_FRAME_FLAG_EXT_BUFFER))
+ PICO_FREE(oldbuf);
+ else if (f->notify_free)
+ f->notify_free(oldbuf);
+
+ f->flags = 0;
+ /* Now, the frame is not zerocopy anymore, and the usage counter has been moved within it */
+ return 0;
+}
+
+struct pico_frame *pico_frame_alloc_skeleton(uint32_t size, int ext_buffer)
+{
+ return pico_frame_do_alloc(size, 1, ext_buffer);
+}
+
+int pico_frame_skeleton_set_buffer(struct pico_frame *f, void *buf)
+{
+ if (!buf)
+ return -1;
+
+ f->buffer = (uint8_t *) buf;
+ f->start = f->buffer;
+ return 0;
+}
+
+struct pico_frame *pico_frame_deepcopy(struct pico_frame *f)
+{
+ struct pico_frame *new = pico_frame_alloc(f->buffer_len);
+ int addr_diff;
+ unsigned char *buf;
+ uint32_t *uc;
+ if (!new)
+ return NULL;
+
+ /* Save the two key pointers... */
+ buf = new->buffer;
+ uc = new->usage_count;
+
+ /* Overwrite all fields with originals */
+ memcpy(new, f, sizeof(struct pico_frame));
+
+ /* ...restore the two key pointers */
+ new->buffer = buf;
+ new->usage_count = uc;
+
+ /* Update in-buffer pointers with offset */
+ addr_diff = (int)(new->buffer - f->buffer);
+ new->datalink_hdr += addr_diff;
+ new->net_hdr += addr_diff;
+ new->transport_hdr += addr_diff;
+ new->app_hdr += addr_diff;
+ new->start += addr_diff;
+ new->payload += addr_diff;
+
+#ifdef PICO_SUPPORT_DEBUG_MEMORY
+ dbg("Deep-Copied frame @%p, into %p, usage count now: %d\n", f, new, *new->usage_count);
+#endif
+ new->next = NULL;
+ return new;
+}
+
+
+static inline uint32_t pico_checksum_adder(uint32_t sum, void *data, uint32_t len)
+{
+ uint16_t *buf = (uint16_t *)data;
+ uint16_t *stop;
+
+ if (len & 0x01) {
+ --len;
+#ifdef PICO_BIGENDIAN
+ sum += (((uint8_t *)data)[len]) << 8;
+#else
+ sum += ((uint8_t *)data)[len];
+#endif
+ }
+
+ stop = (uint16_t *)(((uint8_t *)data) + len);
+
+ while (buf < stop) {
+ sum += *buf++;
+ }
+ return sum;
+}
+
+static inline uint16_t pico_checksum_finalize(uint32_t sum)
+{
+ while (sum >> 16) { /* a second carry is possible! */
+ sum = (sum & 0x0000FFFF) + (sum >> 16);
+ }
+ return short_be((uint16_t) ~sum);
+}
+
+/**
+ * Calculate checksum of a given string
+ */
+uint16_t pico_checksum(void *inbuf, uint32_t len)
+{
+ uint32_t sum;
+
+ sum = pico_checksum_adder(0, inbuf, len);
+ return pico_checksum_finalize(sum);
+}
+
+/* WARNING: len1 MUST be an EVEN number */
+uint16_t pico_dualbuffer_checksum(void *inbuf1, uint32_t len1, void *inbuf2, uint32_t len2)
+{
+ uint32_t sum;
+
+ sum = pico_checksum_adder(0, inbuf1, len1);
+ sum = pico_checksum_adder(sum, inbuf2, len2);
+ return pico_checksum_finalize(sum);
+}
+
diff --git a/net/picotcp/stack/pico_protocol.c b/net/picotcp/stack/pico_protocol.c
new file mode 100644
index 0000000..98d2a20
--- /dev/null
+++ b/net/picotcp/stack/pico_protocol.c
@@ -0,0 +1,214 @@
+/*********************************************************************
+ PicoTCP. Copyright (c) 2012-2015 Altran Intelligent Systems. Some rights reserved.
+ See LICENSE and COPYING for usage.
+
+ .
+
+ Authors: Daniele Lacamera
+ *********************************************************************/
+
+
+#include "pico_protocol.h"
+#include "pico_tree.h"
+
+struct pico_proto_rr
+{
+ struct pico_tree *t;
+ struct pico_tree_node *node_in, *node_out;
+};
+
+
+static int pico_proto_cmp(void *ka, void *kb)
+{
+ struct pico_protocol *a = ka, *b = kb;
+ if (a->hash < b->hash)
+ return -1;
+
+ if (a->hash > b->hash)
+ return 1;
+
+ return 0;
+}
+
+PICO_TREE_DECLARE(Datalink_proto_tree, pico_proto_cmp);
+PICO_TREE_DECLARE(Network_proto_tree, pico_proto_cmp);
+PICO_TREE_DECLARE(Transport_proto_tree, pico_proto_cmp);
+PICO_TREE_DECLARE(Socket_proto_tree, pico_proto_cmp);
+
+/* Static variables to keep track of the round robin loop */
+static struct pico_proto_rr proto_rr_datalink = {
+ &Datalink_proto_tree, NULL, NULL
+};
+static struct pico_proto_rr proto_rr_network = {
+ &Network_proto_tree, NULL, NULL
+};
+static struct pico_proto_rr proto_rr_transport = {
+ &Transport_proto_tree, NULL, NULL
+};
+static struct pico_proto_rr proto_rr_socket = {
+ &Socket_proto_tree, NULL, NULL
+};
+
+static int proto_loop_in(struct pico_protocol *proto, int loop_score)
+{
+ struct pico_frame *f;
+ while(loop_score > 0) {
+ if (proto->q_in->frames <= 0)
+ break;
+
+ f = pico_dequeue(proto->q_in);
+ if ((f) && (proto->process_in(proto, f) > 0)) {
+ loop_score--;
+ }
+ }
+ return loop_score;
+}
+
+static int proto_loop_out(struct pico_protocol *proto, int loop_score)
+{
+ struct pico_frame *f;
+ while(loop_score > 0) {
+ if (proto->q_out->frames <= 0)
+ break;
+
+ f = pico_dequeue(proto->q_out);
+ if ((f) && (proto->process_out(proto, f) > 0)) {
+ loop_score--;
+ }
+ }
+ return loop_score;
+}
+
+static int proto_loop(struct pico_protocol *proto, int loop_score, int direction)
+{
+
+ if (direction == PICO_LOOP_DIR_IN)
+ loop_score = proto_loop_in(proto, loop_score);
+ else if (direction == PICO_LOOP_DIR_OUT)
+ loop_score = proto_loop_out(proto, loop_score);
+
+ return loop_score;
+}
+
+static struct pico_tree_node *roundrobin_init(struct pico_proto_rr *rr, int direction)
+{
+ struct pico_tree_node *next_node = NULL;
+ /* Initialization (takes place only once) */
+ if (rr->node_in == NULL)
+ rr->node_in = pico_tree_firstNode(rr->t->root);
+
+ if (rr->node_out == NULL)
+ rr->node_out = pico_tree_firstNode(rr->t->root);
+
+ if (direction == PICO_LOOP_DIR_IN)
+ next_node = rr->node_in;
+ else
+ next_node = rr->node_out;
+
+ return next_node;
+}
+
+static void roundrobin_end(struct pico_proto_rr *rr, int direction, struct pico_tree_node *last)
+{
+ if (direction == PICO_LOOP_DIR_IN)
+ rr->node_in = last;
+ else
+ rr->node_out = last;
+}
+
+static int pico_protocol_generic_loop(struct pico_proto_rr *rr, int loop_score, int direction)
+{
+ struct pico_protocol *start, *next;
+ struct pico_tree_node *next_node = roundrobin_init(rr, direction);
+
+ if (!next_node)
+ return loop_score;
+
+ next = next_node->keyValue;
+
+ /* init start node */
+ start = next;
+
+ /* round-robin all layer protocols, break if traversed all protocols */
+ while (loop_score > 1 && next != NULL) {
+ loop_score = proto_loop(next, loop_score, direction);
+ next_node = pico_tree_next(next_node);
+ next = next_node->keyValue;
+ if (next == NULL)
+ {
+ next_node = pico_tree_firstNode(rr->t->root);
+ next = next_node->keyValue;
+ }
+
+ if (next == start)
+ break;
+ }
+ roundrobin_end(rr, direction, next_node);
+ return loop_score;
+}
+
+int pico_protocol_datalink_loop(int loop_score, int direction)
+{
+ return pico_protocol_generic_loop(&proto_rr_datalink, loop_score, direction);
+}
+
+int pico_protocol_network_loop(int loop_score, int direction)
+{
+ return pico_protocol_generic_loop(&proto_rr_network, loop_score, direction);
+}
+
+int pico_protocol_transport_loop(int loop_score, int direction)
+{
+ return pico_protocol_generic_loop(&proto_rr_transport, loop_score, direction);
+}
+
+int pico_protocol_socket_loop(int loop_score, int direction)
+{
+ return pico_protocol_generic_loop(&proto_rr_socket, loop_score, direction);
+}
+
+int pico_protocols_loop(int loop_score)
+{
+/*
+ loop_score = pico_protocol_datalink_loop(loop_score);
+ loop_score = pico_protocol_network_loop(loop_score);
+ loop_score = pico_protocol_transport_loop(loop_score);
+ loop_score = pico_protocol_socket_loop(loop_score);
+ */
+ return loop_score;
+}
+
+static void proto_layer_rr_reset(struct pico_proto_rr *rr)
+{
+ rr->node_in = NULL;
+ rr->node_out = NULL;
+}
+
+void pico_protocol_init(struct pico_protocol *p)
+{
+ if (!p)
+ return;
+
+ p->hash = pico_hash(p->name, (uint32_t)strlen(p->name));
+ switch (p->layer) {
+ case PICO_LAYER_DATALINK:
+ pico_tree_insert(&Datalink_proto_tree, p);
+ proto_layer_rr_reset(&proto_rr_datalink);
+ break;
+ case PICO_LAYER_NETWORK:
+ pico_tree_insert(&Network_proto_tree, p);
+ proto_layer_rr_reset(&proto_rr_network);
+ break;
+ case PICO_LAYER_TRANSPORT:
+ pico_tree_insert(&Transport_proto_tree, p);
+ proto_layer_rr_reset(&proto_rr_transport);
+ break;
+ case PICO_LAYER_SOCKET:
+ pico_tree_insert(&Socket_proto_tree, p);
+ proto_layer_rr_reset(&proto_rr_socket);
+ break;
+ }
+ dbg("Protocol %s registered (layer: %d).\n", p->name, p->layer);
+
+}
+
diff --git a/net/picotcp/stack/pico_socket.c b/net/picotcp/stack/pico_socket.c
new file mode 100644
index 0000000..cd0be1e
--- /dev/null
+++ b/net/picotcp/stack/pico_socket.c
@@ -0,0 +1,2213 @@
+/*********************************************************************
+ PicoTCP. Copyright (c) 2012-2015 Altran Intelligent Systems. Some rights reserved.
+ See LICENSE and COPYING for usage.
+
+
+ Authors: Daniele Lacamera
+ *********************************************************************/
+
+
+#include "pico_config.h"
+#include "pico_queue.h"
+#include "pico_socket.h"
+#include "pico_ipv4.h"
+#include "pico_ipv6.h"
+#include "pico_udp.h"
+#include "pico_tcp.h"
+#include "pico_stack.h"
+#include "pico_icmp4.h"
+#include "pico_nat.h"
+#include "pico_tree.h"
+#include "pico_device.h"
+#include "pico_socket_multicast.h"
+#include "pico_socket_tcp.h"
+#include "pico_socket_udp.h"
+
+#if defined (PICO_SUPPORT_IPV4) || defined (PICO_SUPPORT_IPV6)
+#if defined (PICO_SUPPORT_TCP) || defined (PICO_SUPPORT_UDP)
+
+
+#define PROTO(s) ((s)->proto->proto_number)
+#define PICO_MIN_MSS (1280)
+#define TCP_STATE(s) (s->state & PICO_SOCKET_STATE_TCP)
+
+#ifdef PICO_SUPPORT_MUTEX
+static void *Mutex = NULL;
+#endif
+
+
+#define PROTO(s) ((s)->proto->proto_number)
+
+#define PICO_SOCKET_MTU 1480 /* Ethernet MTU(1500) - IP header size(20) */
+
+# define frag_dbg(...) do {} while(0)
+
+
+static struct pico_sockport *sp_udp = NULL, *sp_tcp = NULL;
+
+struct pico_frame *pico_socket_frame_alloc(struct pico_socket *s, uint16_t len);
+
+static int socket_cmp_family(struct pico_socket *a, struct pico_socket *b)
+{
+ uint32_t a_is_ip6 = is_sock_ipv6(a);
+ uint32_t b_is_ip6 = is_sock_ipv6(b);
+ (void)a;
+ (void)b;
+ if (a_is_ip6 < b_is_ip6)
+ return -1;
+
+ if (a_is_ip6 > b_is_ip6)
+ return 1;
+
+ return 0;
+}
+
+
+static int socket_cmp_ipv6(struct pico_socket *a, struct pico_socket *b)
+{
+ int ret = 0;
+ (void)a;
+ (void)b;
+#ifdef PICO_SUPPORT_IPV6
+ if (!is_sock_ipv6(a) || !is_sock_ipv6(b))
+ return 0;
+
+ if ((memcmp(a->local_addr.ip6.addr, PICO_IP6_ANY, PICO_SIZE_IP6) == 0) || (memcmp(b->local_addr.ip6.addr, PICO_IP6_ANY, PICO_SIZE_IP6) == 0))
+ ret = 0;
+ else
+ ret = memcmp(a->local_addr.ip6.addr, b->local_addr.ip6.addr, PICO_SIZE_IP6);
+
+#endif
+ return ret;
+}
+
+static int socket_cmp_ipv4(struct pico_socket *a, struct pico_socket *b)
+{
+ int ret = 0;
+ (void)a;
+ (void)b;
+ if (!is_sock_ipv4(a) || !is_sock_ipv4(b))
+ return 0;
+
+#ifdef PICO_SUPPORT_IPV4
+ if ((a->local_addr.ip4.addr == PICO_IP4_ANY) || (b->local_addr.ip4.addr == PICO_IP4_ANY))
+ ret = 0;
+ else
+ ret = (int)(a->local_addr.ip4.addr - b->local_addr.ip4.addr);
+
+#endif
+ return ret;
+}
+
+static int socket_cmp_remotehost(struct pico_socket *a, struct pico_socket *b)
+{
+ int ret = 0;
+ if (is_sock_ipv6(a))
+ ret = memcmp(a->remote_addr.ip6.addr, b->remote_addr.ip6.addr, PICO_SIZE_IP6);
+ else
+ ret = (int)(a->remote_addr.ip4.addr - b->remote_addr.ip4.addr);
+
+ return ret;
+}
+
+static int socket_cmp_addresses(struct pico_socket *a, struct pico_socket *b)
+{
+ int ret = 0;
+ /* At this point, sort by local host */
+ ret = socket_cmp_ipv6(a, b);
+
+ if (ret == 0)
+ ret = socket_cmp_ipv4(a, b);
+
+ /* Sort by remote host */
+ if (ret == 0)
+ ret = socket_cmp_remotehost(a, b);
+
+ return 0;
+}
+
+static int socket_cmp(void *ka, void *kb)
+{
+ struct pico_socket *a = ka, *b = kb;
+ int ret = 0;
+
+ /* First, order by network family */
+ ret = socket_cmp_family(a, b);
+
+ /* Then, compare by source/destination addresses */
+ if (ret == 0)
+ ret = socket_cmp_addresses(a, b);
+
+ /* And finally by remote port. The two sockets are coincident if the quad is the same. */
+ if (ret == 0)
+ ret = b->remote_port - a->remote_port;
+
+ return ret;
+}
+
+
+#define INIT_SOCKPORT { {&LEAF, socket_cmp}, 0, 0 }
+
+static int sockport_cmp(void *ka, void *kb)
+{
+ struct pico_sockport *a = ka, *b = kb;
+ if (a->number < b->number)
+ return -1;
+
+ if (a->number > b->number)
+ return 1;
+
+ return 0;
+}
+
+PICO_TREE_DECLARE(UDPTable, sockport_cmp);
+PICO_TREE_DECLARE(TCPTable, sockport_cmp);
+
+struct pico_sockport *pico_get_sockport(uint16_t proto, uint16_t port)
+{
+ struct pico_sockport test = INIT_SOCKPORT;
+ test.number = port;
+
+ if (proto == PICO_PROTO_UDP)
+ return pico_tree_findKey(&UDPTable, &test);
+
+ else if (proto == PICO_PROTO_TCP)
+ return pico_tree_findKey(&TCPTable, &test);
+
+ else return NULL;
+}
+
+#ifdef PICO_SUPPORT_IPV4
+
+static int pico_port_in_use_by_nat(uint16_t proto, uint16_t port)
+{
+ int ret = 0;
+ (void) proto;
+ (void) port;
+#ifdef PICO_SUPPORT_NAT
+ if (pico_ipv4_nat_find(port, NULL, 0, (uint8_t)proto)) {
+ dbg("In use by nat....\n");
+ ret = 1;
+ }
+
+#endif
+ return ret;
+}
+
+static int pico_port_in_use_with_this_ipv4_address(struct pico_sockport *sp, struct pico_ip4 ip)
+{
+ if (sp) {
+ struct pico_ip4 *s_local;
+ struct pico_tree_node *idx;
+ struct pico_socket *s;
+ pico_tree_foreach(idx, &sp->socks) {
+ s = idx->keyValue;
+ if (s->net == &pico_proto_ipv4) {
+ s_local = (struct pico_ip4*) &s->local_addr;
+ if ((s_local->addr == PICO_IPV4_INADDR_ANY) || (s_local->addr == ip.addr)) {
+ return 1;
+ }
+ }
+ }
+ }
+
+ return 0;
+}
+
+
+static int pico_port_in_use_ipv4(struct pico_sockport *sp, void *addr)
+{
+ struct pico_ip4 ip;
+ /* IPv4 */
+ if (addr)
+ ip.addr = ((struct pico_ip4 *)addr)->addr;
+ else
+ ip.addr = PICO_IPV4_INADDR_ANY;
+
+ if (ip.addr == PICO_IPV4_INADDR_ANY) {
+ if (!sp)
+ return 0;
+ else {
+ dbg("In use, and asked for ANY\n");
+ return 1;
+ }
+ }
+
+ return pico_port_in_use_with_this_ipv4_address(sp, ip);
+}
+#endif
+
+#ifdef PICO_SUPPORT_IPV6
+static int pico_port_in_use_with_this_ipv6_address(struct pico_sockport *sp, struct pico_ip6 ip)
+{
+ if (sp) {
+ struct pico_ip6 *s_local;
+ struct pico_tree_node *idx;
+ struct pico_socket *s;
+ pico_tree_foreach(idx, &sp->socks) {
+ s = idx->keyValue;
+ if (s->net == &pico_proto_ipv6) {
+ s_local = (struct pico_ip6*) &s->local_addr;
+ if ((pico_ipv6_is_unspecified(s_local->addr)) || (!memcmp(s_local->addr, ip.addr, PICO_SIZE_IP6))) {
+ return 1;
+ }
+ }
+ }
+ }
+
+ return 0;
+}
+
+static int pico_port_in_use_ipv6(struct pico_sockport *sp, void *addr)
+{
+ struct pico_ip6 ip;
+ /* IPv6 */
+ if (addr)
+ memcpy(ip.addr, ((struct pico_ip6 *)addr)->addr, sizeof(struct pico_ip6));
+ else
+ memcpy(ip.addr, PICO_IP6_ANY, sizeof(struct pico_ip6));
+
+ if (memcmp(ip.addr, PICO_IP6_ANY, sizeof(struct pico_ip6)) == 0) {
+ if (!sp)
+ return 0;
+ else {
+ dbg("In use, and asked for ANY\n");
+ return 1;
+ }
+ }
+
+ return pico_port_in_use_with_this_ipv6_address(sp, ip);
+}
+#endif
+
+
+
+static int pico_generic_port_in_use(uint16_t proto, uint16_t port, struct pico_sockport *sp, void *addr, void *net)
+{
+#ifdef PICO_SUPPORT_IPV4
+ if (net == &pico_proto_ipv4)
+ {
+ if (pico_port_in_use_by_nat(proto, port)) {
+ return 1;
+ }
+
+ if (pico_port_in_use_ipv4(sp, addr)) {
+ return 1;
+ }
+ }
+
+#endif
+
+#ifdef PICO_SUPPORT_IPV6
+ if (net == &pico_proto_ipv6)
+ {
+ if (pico_port_in_use_ipv6(sp, addr)) {
+ return 1;
+ }
+ }
+
+#endif
+
+ return 0;
+}
+
+int pico_is_port_free(uint16_t proto, uint16_t port, void *addr, void *net)
+{
+ struct pico_sockport *sp;
+ sp = pico_get_sockport(proto, port);
+
+ if (pico_generic_port_in_use(proto, port, sp, addr, net))
+ return 0;
+
+ return 1;
+}
+
+static int pico_check_socket(struct pico_socket *s)
+{
+ struct pico_sockport *test;
+ struct pico_socket *found;
+ struct pico_tree_node *index;
+
+ test = pico_get_sockport(PROTO(s), s->local_port);
+
+ if (!test) {
+ return -1;
+ }
+
+ pico_tree_foreach(index, &test->socks){
+ found = index->keyValue;
+ if (s == found) {
+ return 0;
+ }
+ }
+
+ return -1;
+}
+
+struct pico_socket *pico_sockets_find(uint16_t local, uint16_t remote)
+{
+ struct pico_socket *sock = NULL;
+ struct pico_tree_node *index = NULL;
+ struct pico_sockport *sp = NULL;
+
+ sp = pico_get_sockport(PICO_PROTO_TCP, local);
+ if(sp)
+ {
+ pico_tree_foreach(index, &sp->socks)
+ {
+ if(((struct pico_socket *)index->keyValue)->remote_port == remote)
+ {
+ sock = (struct pico_socket *)index->keyValue;
+ break;
+ }
+ }
+ }
+
+ return sock;
+}
+
+
+int8_t pico_socket_add(struct pico_socket *s)
+{
+ struct pico_sockport *sp = pico_get_sockport(PROTO(s), s->local_port);
+ PICOTCP_MUTEX_LOCK(Mutex);
+ if (!sp) {
+ /* dbg("Creating sockport..%04x\n", s->local_port); / * In comment due to spam during test * / */
+ sp = PICO_ZALLOC(sizeof(struct pico_sockport));
+
+ if (!sp) {
+ pico_err = PICO_ERR_ENOMEM;
+ PICOTCP_MUTEX_UNLOCK(Mutex);
+ return -1;
+ }
+
+ sp->proto = PROTO(s);
+ sp->number = s->local_port;
+ sp->socks.root = &LEAF;
+ sp->socks.compare = socket_cmp;
+
+ if (PROTO(s) == PICO_PROTO_UDP)
+ {
+ pico_tree_insert(&UDPTable, sp);
+ }
+ else if (PROTO(s) == PICO_PROTO_TCP)
+ {
+ pico_tree_insert(&TCPTable, sp);
+ }
+ }
+
+ pico_tree_insert(&sp->socks, s);
+ s->state |= PICO_SOCKET_STATE_BOUND;
+ PICOTCP_MUTEX_UNLOCK(Mutex);
+#ifdef DEBUG_SOCKET_TREE
+ {
+ struct pico_tree_node *index;
+ /* RB_FOREACH(s, socket_tree, &sp->socks) { */
+ pico_tree_foreach(index, &sp->socks){
+ s = index->keyValue;
+ dbg(">>>> List Socket lc=%hu rm=%hu\n", short_be(s->local_port), short_be(s->remote_port));
+ }
+
+ }
+#endif
+ return 0;
+}
+
+
+static void socket_clean_queues(struct pico_socket *sock)
+{
+ struct pico_frame *f_in = pico_dequeue(&sock->q_in);
+ struct pico_frame *f_out = pico_dequeue(&sock->q_out);
+ while(f_in || f_out)
+ {
+ if(f_in)
+ {
+ pico_frame_discard(f_in);
+ f_in = pico_dequeue(&sock->q_in);
+ }
+
+ if(f_out)
+ {
+ pico_frame_discard(f_out);
+ f_out = pico_dequeue(&sock->q_out);
+ }
+ }
+ pico_queue_deinit(&sock->q_in);
+ pico_queue_deinit(&sock->q_out);
+ pico_socket_tcp_cleanup(sock);
+}
+
+static void socket_garbage_collect(pico_time now, void *arg)
+{
+ struct pico_socket *s = (struct pico_socket *) arg;
+ IGNORE_PARAMETER(now);
+
+ socket_clean_queues(s);
+ PICO_FREE(s);
+}
+
+
+static void pico_socket_check_empty_sockport(struct pico_socket *s, struct pico_sockport *sp)
+{
+ if(pico_tree_empty(&sp->socks)) {
+ if (PROTO(s) == PICO_PROTO_UDP)
+ {
+ pico_tree_delete(&UDPTable, sp);
+ }
+ else if (PROTO(s) == PICO_PROTO_TCP)
+ {
+ pico_tree_delete(&TCPTable, sp);
+ }
+
+ if(sp_tcp == sp)
+ sp_tcp = NULL;
+
+ if(sp_udp == sp)
+ sp_udp = NULL;
+
+ PICO_FREE(sp);
+ }
+}
+
+int8_t pico_socket_del(struct pico_socket *s)
+{
+ struct pico_sockport *sp = pico_get_sockport(PROTO(s), s->local_port);
+ if (!sp) {
+ pico_err = PICO_ERR_ENXIO;
+ return -1;
+ }
+
+ PICOTCP_MUTEX_LOCK(Mutex);
+ pico_tree_delete(&sp->socks, s);
+ pico_socket_check_empty_sockport(s, sp);
+ pico_multicast_delete(s);
+ pico_socket_tcp_delete(s);
+ s->state = PICO_SOCKET_STATE_CLOSED;
+ pico_timer_add(3000, socket_garbage_collect, s);
+ PICOTCP_MUTEX_UNLOCK(Mutex);
+ return 0;
+}
+
+static void pico_socket_update_tcp_state(struct pico_socket *s, uint16_t tcp_state)
+{
+ if (tcp_state) {
+ s->state &= 0x00FF;
+ s->state |= tcp_state;
+ }
+}
+
+static int8_t pico_socket_alter_state(struct pico_socket *s, uint16_t more_states, uint16_t less_states, uint16_t tcp_state)
+{
+ struct pico_sockport *sp;
+ if (more_states & PICO_SOCKET_STATE_BOUND)
+ return pico_socket_add(s);
+
+ if (less_states & PICO_SOCKET_STATE_BOUND)
+ return pico_socket_del(s);
+
+ sp = pico_get_sockport(PROTO(s), s->local_port);
+ if (!sp) {
+ pico_err = PICO_ERR_ENXIO;
+ return -1;
+ }
+
+ s->state |= more_states;
+ s->state = (uint16_t)(s->state & (~less_states));
+ pico_socket_update_tcp_state(s, tcp_state);
+ return 0;
+}
+
+
+static int pico_socket_transport_deliver(struct pico_protocol *p, struct pico_sockport *sp, struct pico_frame *f)
+{
+#ifdef PICO_SUPPORT_TCP
+ if (p->proto_number == PICO_PROTO_TCP)
+ return pico_socket_tcp_deliver(sp, f);
+
+#endif
+
+#ifdef PICO_SUPPORT_UDP
+ if (p->proto_number == PICO_PROTO_UDP)
+ return pico_socket_udp_deliver(sp, f);
+
+#endif
+
+ return -1;
+}
+
+
+static int pico_socket_deliver(struct pico_protocol *p, struct pico_frame *f, uint16_t localport)
+{
+ struct pico_sockport *sp = NULL;
+ struct pico_trans *tr = (struct pico_trans *) f->transport_hdr;
+
+ if (!tr)
+ return -1;
+
+ sp = pico_get_sockport(p->proto_number, localport);
+ if (!sp) {
+ dbg("No such port %d\n", short_be(localport));
+ return -1;
+ }
+
+ return pico_socket_transport_deliver(p, sp, f);
+}
+
+int pico_socket_set_family(struct pico_socket *s, uint16_t family)
+{
+ (void) family;
+
+ #ifdef PICO_SUPPORT_IPV4
+ if (family == PICO_PROTO_IPV4)
+ s->net = &pico_proto_ipv4;
+
+ #endif
+
+ #ifdef PICO_SUPPORT_IPV6
+ if (family == PICO_PROTO_IPV6)
+ s->net = &pico_proto_ipv6;
+
+ #endif
+
+ if (s->net == NULL)
+ return -1;
+
+ return 0;
+}
+
+static struct pico_socket *pico_socket_transport_open(uint16_t proto, uint16_t family)
+{
+ struct pico_socket *s = NULL;
+ (void)family;
+#ifdef PICO_SUPPORT_UDP
+ if (proto == PICO_PROTO_UDP)
+ s = pico_socket_udp_open();
+
+#endif
+
+#ifdef PICO_SUPPORT_TCP
+ if (proto == PICO_PROTO_TCP)
+ s = pico_socket_tcp_open(family);
+
+#endif
+
+ return s;
+
+}
+
+struct pico_socket *pico_socket_open(uint16_t net, uint16_t proto, void (*wakeup)(uint16_t ev, struct pico_socket *))
+{
+
+ struct pico_socket *s = NULL;
+
+ s = pico_socket_transport_open(proto, net);
+
+ if (!s) {
+ pico_err = PICO_ERR_EPROTONOSUPPORT;
+ return NULL;
+ }
+
+ if (pico_socket_set_family(s, net) != 0) {
+ PICO_FREE(s);
+ pico_err = PICO_ERR_ENETUNREACH;
+ return NULL;
+ }
+
+ s->q_in.max_size = PICO_DEFAULT_SOCKETQ;
+ s->q_out.max_size = PICO_DEFAULT_SOCKETQ;
+
+ s->wakeup = wakeup;
+ return s;
+}
+
+
+static void pico_socket_clone_assign_address(struct pico_socket *s, struct pico_socket *facsimile)
+{
+
+#ifdef PICO_SUPPORT_IPV4
+ if (facsimile->net == &pico_proto_ipv4) {
+ s->net = &pico_proto_ipv4;
+ memcpy(&s->local_addr, &facsimile->local_addr, sizeof(struct pico_ip4));
+ memcpy(&s->remote_addr, &facsimile->remote_addr, sizeof(struct pico_ip4));
+ }
+
+#endif
+
+#ifdef PICO_SUPPORT_IPV6
+ if (facsimile->net == &pico_proto_ipv6) {
+ s->net = &pico_proto_ipv6;
+ memcpy(&s->local_addr, &facsimile->local_addr, sizeof(struct pico_ip6));
+ memcpy(&s->remote_addr, &facsimile->remote_addr, sizeof(struct pico_ip6));
+ }
+
+#endif
+
+}
+
+struct pico_socket *pico_socket_clone(struct pico_socket *facsimile)
+{
+ struct pico_socket *s = NULL;
+
+ s = pico_socket_transport_open(facsimile->proto->proto_number, facsimile->net->proto_number);
+ if (!s) {
+ pico_err = PICO_ERR_EPROTONOSUPPORT;
+ return NULL;
+ }
+
+ s->local_port = facsimile->local_port;
+ s->remote_port = facsimile->remote_port;
+ s->state = facsimile->state;
+ pico_socket_clone_assign_address(s, facsimile);
+ if (!s->net) {
+ PICO_FREE(s);
+ pico_err = PICO_ERR_ENETUNREACH;
+ return NULL;
+ }
+
+ s->q_in.max_size = PICO_DEFAULT_SOCKETQ;
+ s->q_out.max_size = PICO_DEFAULT_SOCKETQ;
+ s->wakeup = NULL;
+ return s;
+}
+
+static int pico_socket_transport_read(struct pico_socket *s, void *buf, int len)
+{
+ if (PROTO(s) == PICO_PROTO_UDP)
+ {
+ /* make sure cast to uint16_t doesn't give unexpected results */
+ if(len > 0xFFFF) {
+ pico_err = PICO_ERR_EINVAL;
+ return -1;
+ }
+
+ return pico_socket_udp_recv(s, buf, (uint16_t)len, NULL, NULL);
+ }
+ else if (PROTO(s) == PICO_PROTO_TCP)
+ return pico_socket_tcp_read(s, buf, (uint32_t)len);
+ else return 0;
+}
+
+int pico_socket_read(struct pico_socket *s, void *buf, int len)
+{
+ if (!s || buf == NULL) {
+ pico_err = PICO_ERR_EINVAL;
+ return -1;
+ } else {
+ /* check if exists in tree */
+ /* See task #178 */
+ if (pico_check_socket(s) != 0) {
+ pico_err = PICO_ERR_EINVAL;
+ return -1;
+ }
+ }
+
+ if ((s->state & PICO_SOCKET_STATE_BOUND) == 0) {
+ pico_err = PICO_ERR_EIO;
+ return -1;
+ }
+
+ return pico_socket_transport_read(s, buf, len);
+}
+
+static int pico_socket_write_check_state(struct pico_socket *s)
+{
+ if ((s->state & PICO_SOCKET_STATE_BOUND) == 0) {
+ pico_err = PICO_ERR_EIO;
+ return -1;
+ }
+
+ if ((s->state & PICO_SOCKET_STATE_CONNECTED) == 0) {
+ pico_err = PICO_ERR_ENOTCONN;
+ return -1;
+ }
+
+ if (s->state & PICO_SOCKET_STATE_SHUT_LOCAL) { /* check if in shutdown state */
+ pico_err = PICO_ERR_ESHUTDOWN;
+ return -1;
+ }
+
+ return 0;
+}
+
+static int pico_socket_write_attempt(struct pico_socket *s, const void *buf, int len)
+{
+ if (pico_socket_write_check_state(s) < 0) {
+ return -1;
+ } else {
+ return pico_socket_sendto(s, buf, len, &s->remote_addr, s->remote_port);
+ }
+}
+
+int pico_socket_write(struct pico_socket *s, const void *buf, int len)
+{
+ if (!s || buf == NULL) {
+ pico_err = PICO_ERR_EINVAL;
+ return -1;
+ } else {
+ /* check if exists in tree */
+ /* See task #178 */
+ if (pico_check_socket(s) != 0) {
+ pico_err = PICO_ERR_EINVAL;
+ return -1;
+ }
+ }
+
+ return pico_socket_write_attempt(s, buf, len);
+}
+
+static uint16_t pico_socket_high_port(uint16_t proto)
+{
+ uint16_t port;
+ if (0 ||
+#ifdef PICO_SUPPORT_TCP
+ (proto == PICO_PROTO_TCP) ||
+#endif
+#ifdef PICO_SUPPORT_UDP
+ (proto == PICO_PROTO_UDP) ||
+#endif
+ 0) {
+ do {
+ uint32_t rand = pico_rand();
+ port = (uint16_t) (rand & 0xFFFFU);
+ port = (uint16_t)((port % (65535 - 1024)) + 1024U);
+ if (pico_is_port_free(proto, port, NULL, NULL)) {
+ return short_be(port);
+ }
+ } while(1);
+ }
+ else return 0U;
+}
+
+static void *pico_socket_sendto_get_ip4_src(struct pico_socket *s, struct pico_ip4 *dst)
+{
+ struct pico_ip4 *src4 = NULL;
+
+#ifdef PICO_SUPPORT_IPV4
+ /* Check if socket is connected: destination address MUST match the
+ * current connected endpoint
+ */
+ if ((s->state & PICO_SOCKET_STATE_CONNECTED)) {
+ src4 = &s->local_addr.ip4;
+ if (s->remote_addr.ip4.addr != ((struct pico_ip4 *)dst)->addr ) {
+ pico_err = PICO_ERR_EADDRNOTAVAIL;
+ return NULL;
+ }
+ } else {
+
+ src4 = pico_ipv4_source_find(dst);
+ if (!src4) {
+ pico_err = PICO_ERR_EHOSTUNREACH;
+ return NULL;
+ }
+
+ }
+
+ if (src4->addr != PICO_IPV4_INADDR_ANY)
+ s->local_addr.ip4.addr = src4->addr;
+
+#else
+ pico_err = PICO_ERR_EPROTONOSUPPORT;
+#endif
+ return src4;
+}
+
+static void *pico_socket_sendto_get_ip6_src(struct pico_socket *s, struct pico_ip6 *dst)
+{
+ struct pico_ip6 *src6 = NULL;
+ (void)s;
+ (void)dst;
+
+#ifdef PICO_SUPPORT_IPV6
+
+ /* Check if socket is connected: destination address MUST match the
+ * current connected endpoint
+ */
+ if ((s->state & PICO_SOCKET_STATE_CONNECTED)) {
+ src6 = &s->local_addr.ip6;
+ if (memcmp(&s->remote_addr, dst, PICO_SIZE_IP6)) {
+ pico_err = PICO_ERR_EADDRNOTAVAIL;
+ return NULL;
+ }
+ } else {
+ src6 = pico_ipv6_source_find(dst);
+ if (!src6) {
+ pico_err = PICO_ERR_EHOSTUNREACH;
+ return NULL;
+ }
+
+ if (!pico_ipv6_is_unspecified(src6->addr))
+ s->local_addr.ip6 = *src6;
+ }
+
+#else
+ pico_err = PICO_ERR_EPROTONOSUPPORT;
+#endif
+ return src6;
+}
+
+
+static int pico_socket_sendto_dest_check(struct pico_socket *s, void *dst, uint16_t port)
+{
+
+ /* For the sendto call to be valid,
+ * dst and remote_port should be always populated.
+ */
+ if (!dst || !port) {
+ pico_err = PICO_ERR_EADDRNOTAVAIL;
+ return -1;
+ }
+
+ /* When coming from pico_socket_send (or _write),
+ * the destination is automatically assigned to the currently connected endpoint.
+ * This check will ensure that there is no mismatch when sendto() is called directly
+ * on a connected socket
+ */
+ if ((s->state & PICO_SOCKET_STATE_CONNECTED) != 0) {
+ if (port != s->remote_port) {
+ pico_err = PICO_ERR_EINVAL;
+ return -1;
+ }
+ }
+
+ return 0;
+}
+
+static int pico_socket_sendto_initial_checks(struct pico_socket *s, const void *buf, const int len, void *dst, uint16_t remote_port)
+{
+ if (len < 0) {
+ pico_err = PICO_ERR_EINVAL;
+ return -1;
+ }
+
+ if (buf == NULL || s == NULL) {
+ pico_err = PICO_ERR_EINVAL;
+ return -1;
+ }
+
+ return pico_socket_sendto_dest_check(s, dst, remote_port);
+}
+
+static void *pico_socket_sendto_get_src(struct pico_socket *s, void *dst)
+{
+ void *src = NULL;
+ if (is_sock_ipv4(s))
+ src = pico_socket_sendto_get_ip4_src(s, (struct pico_ip4 *)dst);
+
+ if (is_sock_ipv6(s))
+ src = pico_socket_sendto_get_ip6_src(s, (struct pico_ip6 *)dst);
+
+ return src;
+}
+
+static struct pico_remote_endpoint *pico_socket_sendto_destination_ipv4(struct pico_socket *s, struct pico_ip4 *dst, uint16_t port)
+{
+ struct pico_remote_endpoint *ep = NULL;
+ (void)s;
+ ep = PICO_ZALLOC(sizeof(struct pico_remote_endpoint));
+ if (!ep) {
+ pico_err = PICO_ERR_ENOMEM;
+ return NULL;
+ }
+
+ ep->remote_addr.ip4.addr = ((struct pico_ip4 *)dst)->addr;
+ ep->remote_port = port;
+ return ep;
+}
+
+static void pico_endpoint_free(struct pico_remote_endpoint *ep)
+{
+ if (ep)
+ PICO_FREE(ep);
+}
+
+static struct pico_remote_endpoint *pico_socket_sendto_destination_ipv6(struct pico_socket *s, struct pico_ip6 *dst, uint16_t port)
+{
+ struct pico_remote_endpoint *ep = NULL;
+ (void)s;
+ (void)dst;
+ (void)port;
+#ifdef PICO_SUPPORT_IPV6
+ ep = PICO_ZALLOC(sizeof(struct pico_remote_endpoint));
+ if (!ep) {
+ pico_err = PICO_ERR_ENOMEM;
+ return NULL;
+ }
+
+ memcpy(&ep->remote_addr.ip6, dst, sizeof(struct pico_ip6));
+ ep->remote_port = port;
+#endif
+ return ep;
+}
+
+
+static struct pico_remote_endpoint *pico_socket_sendto_destination(struct pico_socket *s, void *dst, uint16_t port)
+{
+ struct pico_remote_endpoint *ep = NULL;
+ (void)pico_socket_sendto_destination_ipv6;
+ /* socket remote info could change in a consecutive call, make persistent */
+# ifdef PICO_SUPPORT_UDP
+ if (PROTO(s) == PICO_PROTO_UDP) {
+# ifdef PICO_SUPPORT_IPV6
+ if (is_sock_ipv6(s))
+ ep = pico_socket_sendto_destination_ipv6(s, (struct pico_ip6 *)dst, port);
+
+# endif
+# ifdef PICO_SUPPORT_IPV4
+ if (is_sock_ipv4(s))
+ ep = pico_socket_sendto_destination_ipv4(s, (struct pico_ip4 *)dst, port);
+
+# endif
+ }
+
+# endif
+ return ep;
+}
+
+static int32_t pico_socket_sendto_set_localport(struct pico_socket *s)
+{
+
+ if ((s->state & PICO_SOCKET_STATE_BOUND) == 0) {
+ s->local_port = pico_socket_high_port(s->proto->proto_number);
+ if (s->local_port == 0) {
+ pico_err = PICO_ERR_EINVAL;
+ return -1;
+ }
+
+ s->state |= PICO_SOCKET_STATE_BOUND;
+ }
+
+ return s->local_port;
+}
+
+static int pico_socket_sendto_transport_offset(struct pico_socket *s)
+{
+ int header_offset = -1;
+ #ifdef PICO_SUPPORT_TCP
+ if (PROTO(s) == PICO_PROTO_TCP)
+ header_offset = pico_tcp_overhead(s);
+
+ #endif
+
+ #ifdef PICO_SUPPORT_UDP
+ if (PROTO(s) == PICO_PROTO_UDP)
+ header_offset = sizeof(struct pico_udp_hdr);
+
+ #endif
+ return header_offset;
+}
+
+
+static struct pico_remote_endpoint *pico_socket_set_info(struct pico_remote_endpoint *ep)
+{
+ struct pico_remote_endpoint *info;
+ info = PICO_ZALLOC(sizeof(struct pico_remote_endpoint));
+ if (!info) {
+ pico_err = PICO_ERR_ENOMEM;
+ return NULL;
+ }
+
+ memcpy(info, ep, sizeof(struct pico_remote_endpoint));
+ return info;
+}
+
+static void pico_xmit_frame_set_nofrag(struct pico_frame *f)
+{
+#ifdef PICO_SUPPORT_IPFRAG
+ f->frag = PICO_IPV4_DONTFRAG;
+#else
+ (void)f;
+#endif
+}
+
+static int pico_socket_final_xmit(struct pico_socket *s, struct pico_frame *f)
+{
+ if (s->proto->push(s->proto, f) > 0) {
+ return f->payload_len;
+ } else {
+ pico_frame_discard(f);
+ return 0;
+ }
+}
+
+static int pico_socket_xmit_one(struct pico_socket *s, const void *buf, const int len, void *src,
+ struct pico_remote_endpoint *ep, struct pico_msginfo *msginfo)
+{
+ struct pico_frame *f;
+ uint16_t hdr_offset = (uint16_t)pico_socket_sendto_transport_offset(s);
+ int ret = 0;
+ (void)src;
+
+ f = pico_socket_frame_alloc(s, (uint16_t)(len + hdr_offset));
+ if (!f) {
+ pico_err = PICO_ERR_ENOMEM;
+ return -1;
+ }
+
+ f->payload += hdr_offset;
+ f->payload_len = (uint16_t)(len);
+ f->sock = s;
+ transport_flags_update(f, s);
+ pico_xmit_frame_set_nofrag(f);
+ if (ep && !f->info) {
+ f->info = pico_socket_set_info(ep);
+ if (!f->info) {
+ pico_frame_discard(f);
+ return -1;
+ }
+ }
+
+ if (msginfo) {
+ f->send_ttl = (uint8_t)msginfo->ttl;
+ f->send_tos = (uint8_t)msginfo->tos;
+ f->dev = msginfo->dev;
+ }
+
+ memcpy(f->payload, (const uint8_t *)buf, f->payload_len);
+ /* dbg("Pushing segment, hdr len: %d, payload_len: %d\n", header_offset, f->payload_len); */
+ ret = pico_socket_final_xmit(s, f);
+ return ret;
+}
+
+static int pico_socket_xmit_avail_space(struct pico_socket *s);
+
+#ifdef PICO_SUPPORT_IPFRAG
+static void pico_socket_xmit_first_fragment_setup(struct pico_frame *f, int space, int hdr_offset)
+{
+ frag_dbg("FRAG: first fragmented frame %p | len = %u offset = 0\n", f, f->payload_len);
+ /* transport header length field contains total length + header length */
+ f->transport_len = (uint16_t)(space);
+ f->frag = PICO_IPV4_MOREFRAG;
+ f->payload += hdr_offset;
+ f->payload_len = (uint16_t) space;
+}
+
+static void pico_socket_xmit_next_fragment_setup(struct pico_frame *f, int hdr_offset, int total_payload_written, int len)
+{
+ /* no transport header in fragmented IP */
+ f->payload = f->transport_hdr;
+ f->payload_len = (uint16_t)(f->payload_len - hdr_offset);
+ /* set offset in octets */
+ f->frag = (uint16_t)((total_payload_written + (uint16_t)hdr_offset) >> 3u);
+ if (total_payload_written + f->payload_len < len) {
+ frag_dbg("FRAG: intermediate fragmented frame %p | len = %u offset = %u\n", f, f->payload_len, short_be(f->frag));
+ f->frag |= PICO_IPV4_MOREFRAG;
+ } else {
+ frag_dbg("FRAG: last fragmented frame %p | len = %u offset = %u\n", f, f->payload_len, short_be(f->frag));
+ f->frag &= PICO_IPV4_FRAG_MASK;
+ }
+}
+#endif
+
+static int pico_socket_xmit_fragments(struct pico_socket *s, const void *buf, const int len,
+ void *src, struct pico_remote_endpoint *ep, struct pico_msginfo *msginfo)
+{
+ int space = pico_socket_xmit_avail_space(s);
+ int hdr_offset = pico_socket_sendto_transport_offset(s);
+ int total_payload_written = 0;
+ struct pico_frame *f = NULL;
+
+ if (space > len) {
+ return pico_socket_xmit_one(s, buf, len, src, ep, msginfo);
+ }
+
+#ifdef PICO_SUPPORT_IPV6
+ /* Can't fragment IPv6 */
+ if (is_sock_ipv6(s)) {
+ return pico_socket_xmit_one(s, buf, space, src, ep, msginfo);
+ }
+
+#endif
+
+#ifdef PICO_SUPPORT_IPFRAG
+ while(total_payload_written < len) {
+ /* Always allocate the max space available: space + offset */
+ if (len < space)
+ space = len;
+
+ if (space > len - total_payload_written)
+ space = len - total_payload_written;
+
+ f = pico_socket_frame_alloc(s, (uint16_t)(space + hdr_offset));
+ if (!f) {
+ pico_err = PICO_ERR_ENOMEM;
+ pico_endpoint_free(ep);
+ return -1;
+ }
+
+ f->sock = s;
+ if (ep) {
+ f->info = pico_socket_set_info(ep);
+ if (!f->info) {
+ pico_frame_discard(f);
+ pico_endpoint_free(ep);
+ return -1;
+ }
+ }
+
+ if (total_payload_written == 0) {
+ /* First fragment: no payload written yet! */
+ pico_socket_xmit_first_fragment_setup(f, space, hdr_offset);
+ } else {
+ /* Next fragment */
+ pico_socket_xmit_next_fragment_setup(f, hdr_offset, total_payload_written, len);
+ }
+
+ memcpy(f->payload, (const uint8_t *)buf + total_payload_written, f->payload_len);
+ transport_flags_update(f, s);
+ if (s->proto->push(s->proto, f) > 0) {
+ total_payload_written += f->payload_len;
+ } else {
+ pico_frame_discard(f);
+ break;
+ }
+ } /* while() */
+ pico_endpoint_free(ep);
+ return total_payload_written;
+
+#else
+ /* Careful with that axe, Eugene!
+ *
+ * cropping down datagrams to the MTU value.
+ */
+ (void) f;
+ (void) hdr_offset;
+ (void) total_payload_written;
+ return pico_socket_xmit_one(s, buf, space, src, ep, msginfo);
+
+#endif
+}
+
+static void get_sock_dev(struct pico_socket *s)
+{
+ if (0) {}
+
+#ifdef PICO_SUPPORT_IPV6
+ else if (is_sock_ipv6(s))
+ s->dev = pico_ipv6_source_dev_find(&s->remote_addr.ip6);
+#endif
+#ifdef PICO_SUPPORT_IPV4
+ else if (is_sock_ipv4(s))
+ s->dev = pico_ipv4_source_dev_find(&s->remote_addr.ip4);
+#endif
+
+}
+
+
+static uint32_t pico_socket_adapt_mss_to_proto(struct pico_socket *s, uint32_t mss)
+{
+#ifdef PICO_SUPPORT_IPV6
+ if (is_sock_ipv6(s))
+ mss -= PICO_SIZE_IP6HDR;
+ else
+#endif
+ mss -= PICO_SIZE_IP4HDR;
+ return mss;
+}
+
+uint32_t pico_socket_get_mss(struct pico_socket *s)
+{
+ uint32_t mss = PICO_MIN_MSS;
+ if (!s)
+ return mss;
+
+ if (!s->dev)
+ get_sock_dev(s);
+
+ if (!s->dev) {
+ mss = PICO_MIN_MSS;
+ } else {
+ mss = s->dev->mtu;
+ }
+
+ return pico_socket_adapt_mss_to_proto(s, mss);
+}
+
+
+static int pico_socket_xmit_avail_space(struct pico_socket *s)
+{
+ int transport_len;
+ int header_offset;
+
+#ifdef PICO_SUPPORT_TCP
+ if (PROTO(s) == PICO_PROTO_TCP) {
+ transport_len = (uint16_t)pico_tcp_get_socket_mss(s);
+ } else
+#endif
+ transport_len = (uint16_t)pico_socket_get_mss(s);
+ header_offset = pico_socket_sendto_transport_offset(s);
+ if (header_offset < 0) {
+ pico_err = PICO_ERR_EPROTONOSUPPORT;
+ return -1;
+ }
+
+ transport_len -= pico_socket_sendto_transport_offset(s);
+ return transport_len;
+}
+
+
+static int pico_socket_xmit(struct pico_socket *s, const void *buf, const int len, void *src,
+ struct pico_remote_endpoint *ep, struct pico_msginfo *msginfo)
+{
+ int space = pico_socket_xmit_avail_space(s);
+ int total_payload_written = 0;
+
+ if (space < 0) {
+ pico_err = PICO_ERR_EPROTONOSUPPORT;
+ pico_endpoint_free(ep);
+ return -1;
+ }
+
+ if ((PROTO(s) == PICO_PROTO_UDP) && (len > space)) {
+ total_payload_written = pico_socket_xmit_fragments(s, buf, len, src, ep, msginfo);
+ /* Implies ep discarding */
+ return total_payload_written;
+ }
+
+ while (total_payload_written < len) {
+ int w, chunk_len = len - total_payload_written;
+ if (chunk_len > space)
+ chunk_len = space;
+
+ w = pico_socket_xmit_one(s, (const void *)((const uint8_t *)buf + total_payload_written), chunk_len, src, ep, msginfo);
+ if (w <= 0) {
+ break;
+ }
+
+ total_payload_written += w;
+ if (PROTO(s) == PICO_PROTO_UDP) {
+ /* Break after the first datagram sent with at most MTU bytes. */
+ break;
+ }
+ }
+ pico_endpoint_free(ep);
+ return total_payload_written;
+}
+
+static void pico_socket_sendto_set_dport(struct pico_socket *s, uint16_t port)
+{
+ if ((s->state & PICO_SOCKET_STATE_CONNECTED) == 0) {
+ s->remote_port = port;
+ }
+}
+
+
+int MOCKABLE pico_socket_sendto_extended(struct pico_socket *s, const void *buf, const int len,
+ void *dst, uint16_t remote_port, struct pico_msginfo *msginfo)
+{
+ struct pico_remote_endpoint *remote_endpoint = NULL;
+ void *src = NULL;
+
+ if(len == 0)
+ return 0;
+
+ if (pico_socket_sendto_initial_checks(s, buf, len, dst, remote_port) < 0)
+ return -1;
+
+
+ src = pico_socket_sendto_get_src(s, dst);
+ if (!src) {
+#ifdef PICO_SUPPORT_IPV6
+ if((s->net->proto_number == PICO_PROTO_IPV6)
+ && msginfo && msginfo->dev
+ && pico_ipv6_is_linklocal(((struct pico_ip6 *)dst)->addr))
+ {
+ src = &(pico_ipv6_linklocal_get(msginfo->dev)->address);
+ if(!src)
+ return -1;
+ }
+ else
+#endif
+ return -1;
+ }
+
+ remote_endpoint = pico_socket_sendto_destination(s, dst, remote_port);
+ if (pico_socket_sendto_set_localport(s) < 0) {
+ pico_endpoint_free(remote_endpoint);
+ return -1;
+ }
+
+ pico_socket_sendto_set_dport(s, remote_port);
+ return pico_socket_xmit(s, buf, len, src, remote_endpoint, msginfo); /* Implies discarding the endpoint */
+}
+
+int MOCKABLE pico_socket_sendto(struct pico_socket *s, const void *buf, const int len, void *dst, uint16_t remote_port)
+{
+ return pico_socket_sendto_extended(s, buf, len, dst, remote_port, NULL);
+}
+
+int pico_socket_send(struct pico_socket *s, const void *buf, int len)
+{
+ if (!s || buf == NULL) {
+ pico_err = PICO_ERR_EINVAL;
+ return -1;
+ } else {
+ /* check if exists in tree */
+ /* See task #178 */
+ if (pico_check_socket(s) != 0) {
+ pico_err = PICO_ERR_EINVAL;
+ return -1;
+ }
+ }
+
+ if ((s->state & PICO_SOCKET_STATE_CONNECTED) == 0) {
+ pico_err = PICO_ERR_ENOTCONN;
+ return -1;
+ }
+
+ return pico_socket_sendto(s, buf, len, &s->remote_addr, s->remote_port);
+}
+
+int pico_socket_recvfrom_extended(struct pico_socket *s, void *buf, int len, void *orig,
+ uint16_t *remote_port, struct pico_msginfo *msginfo)
+{
+ if (!s || buf == NULL) { /* / || orig == NULL || remote_port == NULL) { */
+ pico_err = PICO_ERR_EINVAL;
+ return -1;
+ } else {
+ /* check if exists in tree */
+ if (pico_check_socket(s) != 0) {
+ pico_err = PICO_ERR_EINVAL;
+ /* See task #178 */
+ return -1;
+ }
+ }
+
+ if ((s->state & PICO_SOCKET_STATE_BOUND) == 0) {
+ pico_err = PICO_ERR_EADDRNOTAVAIL;
+ return -1;
+ }
+
+#ifdef PICO_SUPPORT_UDP
+ if (PROTO(s) == PICO_PROTO_UDP) {
+ /* make sure cast to uint16_t doesn't give unexpected results */
+ if(len > 0xFFFF) {
+ pico_err = PICO_ERR_EINVAL;
+ return -1;
+ }
+
+ return pico_udp_recv(s, buf, (uint16_t)len, orig, remote_port, msginfo);
+ }
+
+#endif
+#ifdef PICO_SUPPORT_TCP
+ if (PROTO(s) == PICO_PROTO_TCP) {
+ /* check if in shutdown state and if tcpq_in empty */
+ if ((s->state & PICO_SOCKET_STATE_SHUT_REMOTE) && pico_tcp_queue_in_is_empty(s)) {
+ pico_err = PICO_ERR_ESHUTDOWN;
+ return -1;
+ } else {
+ /* dbg("socket tcp recv\n"); */
+ return (int)pico_tcp_read(s, buf, (uint32_t)len);
+ }
+ }
+
+#endif
+ /* dbg("socket return 0\n"); */
+ return 0;
+}
+
+int pico_socket_recvfrom(struct pico_socket *s, void *buf, int len, void *orig,
+ uint16_t *remote_port)
+{
+ return pico_socket_recvfrom_extended(s, buf, len, orig, remote_port, NULL);
+
+}
+
+int pico_socket_recv(struct pico_socket *s, void *buf, int len)
+{
+ return pico_socket_recvfrom(s, buf, len, NULL, NULL);
+}
+
+
+int pico_socket_getname(struct pico_socket *s, void *local_addr, uint16_t *port, uint16_t *proto)
+{
+
+ if (!s || !local_addr || !port || !proto) {
+ pico_err = PICO_ERR_EINVAL;
+ return -1;
+ }
+
+ if (is_sock_ipv4(s)) {
+ #ifdef PICO_SUPPORT_IPV4
+ struct pico_ip4 *ip = (struct pico_ip4 *)local_addr;
+ ip->addr = s->local_addr.ip4.addr;
+ *proto = PICO_PROTO_IPV4;
+ #endif
+ } else if (is_sock_ipv6(s)) {
+ #ifdef PICO_SUPPORT_IPV6
+ struct pico_ip6 *ip = (struct pico_ip6 *)local_addr;
+ memcpy(ip->addr, s->local_addr.ip6.addr, PICO_SIZE_IP6);
+ *proto = PICO_PROTO_IPV6;
+ #endif
+ } else {
+ pico_err = PICO_ERR_EINVAL;
+ return -1;
+ }
+
+ *port = s->local_port;
+ return 0;
+}
+
+int pico_socket_getpeername(struct pico_socket *s, void *remote_addr, uint16_t *port, uint16_t *proto)
+{
+ if (!s || !remote_addr || !port || !proto) {
+ pico_err = PICO_ERR_EINVAL;
+ return -1;
+ }
+
+ if ((s->state & PICO_SOCKET_STATE_CONNECTED) == 0) {
+ pico_err = PICO_ERR_ENOTCONN;
+ return -1;
+ }
+
+ if (is_sock_ipv4(s)) {
+ #ifdef PICO_SUPPORT_IPV4
+ struct pico_ip4 *ip = (struct pico_ip4 *)remote_addr;
+ ip->addr = s->remote_addr.ip4.addr;
+ *proto = PICO_PROTO_IPV4;
+ #endif
+ } else if (is_sock_ipv6(s)) {
+ #ifdef PICO_SUPPORT_IPV6
+ struct pico_ip6 *ip = (struct pico_ip6 *)remote_addr;
+ memcpy(ip->addr, s->remote_addr.ip6.addr, PICO_SIZE_IP6);
+ *proto = PICO_PROTO_IPV6;
+ #endif
+ } else {
+ pico_err = PICO_ERR_EINVAL;
+ return -1;
+ }
+
+ *port = s->remote_port;
+ return 0;
+
+}
+
+int pico_socket_bind(struct pico_socket *s, void *local_addr, uint16_t *port)
+{
+ if (!s || !local_addr || !port) {
+ pico_err = PICO_ERR_EINVAL;
+ return -1;
+ }
+
+ if (is_sock_ipv4(s)) {
+ #ifdef PICO_SUPPORT_IPV4
+ struct pico_ip4 *ip = (struct pico_ip4 *)local_addr;
+ if (ip->addr != PICO_IPV4_INADDR_ANY) {
+ if (!pico_ipv4_link_find(local_addr)) {
+ pico_err = PICO_ERR_EINVAL;
+ return -1;
+ }
+ }
+
+ #endif
+ } else if (is_sock_ipv6(s)) {
+ #ifdef PICO_SUPPORT_IPV6
+ struct pico_ip6 *ip = (struct pico_ip6 *)local_addr;
+ if (!pico_ipv6_is_unspecified(ip->addr)) {
+ if (!pico_ipv6_link_find(local_addr)) {
+ pico_err = PICO_ERR_EINVAL;
+ return -1;
+ }
+ }
+
+ #endif
+ } else {
+ pico_err = PICO_ERR_EINVAL;
+ return -1;
+ }
+
+
+ /* When given port = 0, get a random high port to bind to. */
+ if (*port == 0) {
+ *port = pico_socket_high_port(PROTO(s));
+ if (*port == 0) {
+ pico_err = PICO_ERR_EINVAL;
+ return -1;
+ }
+ }
+
+ if (pico_is_port_free(PROTO(s), *port, local_addr, s->net) == 0) {
+ pico_err = PICO_ERR_EADDRINUSE;
+ return -1;
+ }
+
+ s->local_port = *port;
+
+ if (is_sock_ipv4(s)) {
+ #ifdef PICO_SUPPORT_IPV4
+ struct pico_ip4 *ip = (struct pico_ip4 *)local_addr;
+ s->local_addr.ip4 = *ip;
+ #endif
+ } else if (is_sock_ipv6(s)) {
+ #ifdef PICO_SUPPORT_IPV6
+ struct pico_ip6 *ip = (struct pico_ip6 *)local_addr;
+ s->local_addr.ip6 = *ip;
+ #endif
+ } else {
+ pico_err = PICO_ERR_EINVAL;
+ return -1;
+ }
+
+ return pico_socket_alter_state(s, PICO_SOCKET_STATE_BOUND, 0, 0);
+}
+
+
+int pico_socket_connect(struct pico_socket *s, const void *remote_addr, uint16_t remote_port)
+{
+ int ret = -1;
+ pico_err = PICO_ERR_EPROTONOSUPPORT;
+ if (!s || remote_addr == NULL || remote_port == 0) {
+ pico_err = PICO_ERR_EINVAL;
+ return -1;
+ }
+
+ s->remote_port = remote_port;
+
+ if (s->local_port == 0) {
+ s->local_port = pico_socket_high_port(PROTO(s));
+ if (!s->local_port) {
+ pico_err = PICO_ERR_EINVAL;
+ return -1;
+ }
+ }
+
+ if (is_sock_ipv4(s)) {
+ #ifdef PICO_SUPPORT_IPV4
+ struct pico_ip4 *local = NULL;
+ const struct pico_ip4 *ip = (const struct pico_ip4 *)remote_addr;
+ s->remote_addr.ip4 = *ip;
+ local = pico_ipv4_source_find(ip);
+ if (local) {
+ get_sock_dev(s);
+ s->local_addr.ip4 = *local;
+ } else {
+ pico_err = PICO_ERR_EHOSTUNREACH;
+ return -1;
+ }
+
+ #endif
+ } else if (is_sock_ipv6(s)) {
+ #ifdef PICO_SUPPORT_IPV6
+ struct pico_ip6 *local = NULL;
+ const struct pico_ip6 *ip = (const struct pico_ip6 *)remote_addr;
+ s->remote_addr.ip6 = *ip;
+ local = pico_ipv6_source_find(ip);
+ if (local) {
+ get_sock_dev(s);
+ s->local_addr.ip6 = *local;
+ } else {
+ pico_err = PICO_ERR_EHOSTUNREACH;
+ return -1;
+ }
+
+ #endif
+ } else {
+ pico_err = PICO_ERR_EINVAL;
+ return -1;
+ }
+
+ pico_socket_alter_state(s, PICO_SOCKET_STATE_BOUND, 0, 0);
+
+#ifdef PICO_SUPPORT_UDP
+ if (PROTO(s) == PICO_PROTO_UDP) {
+ pico_socket_alter_state(s, PICO_SOCKET_STATE_CONNECTED, 0, 0);
+ pico_err = PICO_ERR_NOERR;
+ ret = 0;
+ }
+
+#endif
+
+#ifdef PICO_SUPPORT_TCP
+ if (PROTO(s) == PICO_PROTO_TCP) {
+ if (pico_tcp_initconn(s) == 0) {
+ pico_socket_alter_state(s, PICO_SOCKET_STATE_CONNECTED | PICO_SOCKET_STATE_TCP_SYN_SENT, PICO_SOCKET_STATE_CLOSED, 0);
+ pico_err = PICO_ERR_NOERR;
+ ret = 0;
+ } else {
+ pico_err = PICO_ERR_EHOSTUNREACH;
+ }
+ }
+
+#endif
+
+ return ret;
+}
+
+
+#ifdef PICO_SUPPORT_TCP
+
+int pico_socket_listen(struct pico_socket *s, int backlog)
+{
+ if (!s || backlog < 1) {
+ pico_err = PICO_ERR_EINVAL;
+ return -1;
+ } else {
+ /* check if exists in tree */
+ /* See task #178 */
+ if (pico_check_socket(s) != 0) {
+ pico_err = PICO_ERR_EINVAL;
+ return -1;
+ }
+ }
+
+ if (PROTO(s) == PICO_PROTO_UDP) {
+ pico_err = PICO_ERR_EINVAL;
+ return -1;
+ }
+
+ if ((s->state & PICO_SOCKET_STATE_BOUND) == 0) {
+ pico_err = PICO_ERR_EISCONN;
+ return -1;
+ }
+
+ if (PROTO(s) == PICO_PROTO_TCP)
+ pico_socket_alter_state(s, PICO_SOCKET_STATE_TCP_SYN_SENT, 0, PICO_SOCKET_STATE_TCP_LISTEN);
+
+ s->max_backlog = (uint16_t)backlog;
+
+ return 0;
+}
+
+struct pico_socket *pico_socket_accept(struct pico_socket *s, void *orig, uint16_t *port)
+{
+ if (!s || !orig || !port) {
+ pico_err = PICO_ERR_EINVAL;
+ return NULL;
+ }
+
+ pico_err = PICO_ERR_EINVAL;
+
+ if ((s->state & PICO_SOCKET_STATE_BOUND) == 0) {
+ return NULL;
+ }
+
+ if (PROTO(s) == PICO_PROTO_UDP) {
+ return NULL;
+ }
+
+ if (TCPSTATE(s) == PICO_SOCKET_STATE_TCP_LISTEN) {
+ struct pico_sockport *sp = pico_get_sockport(PICO_PROTO_TCP, s->local_port);
+ struct pico_socket *found;
+ uint32_t socklen = sizeof(struct pico_ip4);
+ /* If at this point no incoming connection socket is found,
+ * the accept call is valid, but no connection is established yet.
+ */
+ pico_err = PICO_ERR_EAGAIN;
+ if (sp) {
+ struct pico_tree_node *index;
+ /* RB_FOREACH(found, socket_tree, &sp->socks) { */
+ pico_tree_foreach(index, &sp->socks){
+ found = index->keyValue;
+ if ((s == found->parent) && ((found->state & PICO_SOCKET_STATE_TCP) == PICO_SOCKET_STATE_TCP_ESTABLISHED)) {
+ found->parent = NULL;
+ pico_err = PICO_ERR_NOERR;
+ #ifdef PICO_SUPPORT_IPV6
+ if (is_sock_ipv6(s))
+ socklen = sizeof(struct pico_ip6);
+
+ #endif
+ memcpy(orig, &found->remote_addr, socklen);
+ *port = found->remote_port;
+ s->number_of_pending_conn--;
+ return found;
+ }
+ }
+ }
+ }
+
+ return NULL;
+}
+
+#else
+
+int pico_socket_listen(struct pico_socket *s, int backlog)
+{
+ IGNORE_PARAMETER(s);
+ IGNORE_PARAMETER(backlog);
+ pico_err = PICO_ERR_EINVAL;
+ return -1;
+}
+
+struct pico_socket *pico_socket_accept(struct pico_socket *s, void *orig, uint16_t *local_port)
+{
+ IGNORE_PARAMETER(s);
+ IGNORE_PARAMETER(orig);
+ IGNORE_PARAMETER(local_port);
+ pico_err = PICO_ERR_EINVAL;
+ return NULL;
+}
+
+#endif
+
+
+int pico_socket_setoption(struct pico_socket *s, int option, void *value)
+{
+
+ if (s == NULL) {
+ pico_err = PICO_ERR_EINVAL;
+ return -1;
+ }
+
+
+ if (PROTO(s) == PICO_PROTO_TCP)
+ return pico_setsockopt_tcp(s, option, value);
+
+ if (PROTO(s) == PICO_PROTO_UDP)
+ return pico_setsockopt_udp(s, option, value);
+
+ pico_err = PICO_ERR_EPROTONOSUPPORT;
+ return -1;
+}
+
+
+int pico_socket_getoption(struct pico_socket *s, int option, void *value)
+{
+ if (s == NULL) {
+ pico_err = PICO_ERR_EINVAL;
+ return -1;
+ }
+
+
+ if (PROTO(s) == PICO_PROTO_TCP)
+ return pico_getsockopt_tcp(s, option, value);
+
+ if (PROTO(s) == PICO_PROTO_UDP)
+ return pico_getsockopt_udp(s, option, value);
+
+ pico_err = PICO_ERR_EPROTONOSUPPORT;
+ return -1;
+}
+
+
+int pico_socket_shutdown(struct pico_socket *s, int mode)
+{
+ if (!s) {
+ pico_err = PICO_ERR_EINVAL;
+ return -1;
+ }
+
+ /* Check if the socket has already been closed */
+ if (s->state & PICO_SOCKET_STATE_CLOSED) {
+ pico_err = PICO_ERR_EINVAL;
+ return -1;
+ }
+
+#ifdef PICO_SUPPORT_UDP
+ if (PROTO(s) == PICO_PROTO_UDP) {
+ if ((mode & PICO_SHUT_RDWR) == PICO_SHUT_RDWR)
+ pico_socket_alter_state(s, PICO_SOCKET_STATE_CLOSED, PICO_SOCKET_STATE_CLOSING | PICO_SOCKET_STATE_BOUND | PICO_SOCKET_STATE_CONNECTED, 0);
+ else if (mode & PICO_SHUT_RD)
+ pico_socket_alter_state(s, 0, PICO_SOCKET_STATE_BOUND, 0);
+ }
+
+#endif
+#ifdef PICO_SUPPORT_TCP
+ if (PROTO(s) == PICO_PROTO_TCP) {
+ if ((mode & PICO_SHUT_RDWR) == PICO_SHUT_RDWR)
+ {
+ pico_socket_alter_state(s, PICO_SOCKET_STATE_SHUT_LOCAL | PICO_SOCKET_STATE_SHUT_REMOTE, 0, 0);
+ pico_tcp_notify_closing(s);
+ }
+ else if (mode & PICO_SHUT_WR)
+ pico_socket_alter_state(s, PICO_SOCKET_STATE_SHUT_LOCAL, 0, 0);
+ else if (mode & PICO_SHUT_RD)
+ pico_socket_alter_state(s, PICO_SOCKET_STATE_SHUT_REMOTE, 0, 0);
+
+ }
+
+#endif
+ return 0;
+}
+
+int MOCKABLE pico_socket_close(struct pico_socket *s)
+{
+ if (!s)
+ return -1;
+
+#ifdef PICO_SUPPORT_TCP
+ if (PROTO(s) == PICO_PROTO_TCP) {
+ if (pico_tcp_check_listen_close(s) == 0)
+ return 0;
+ }
+
+#endif
+ return pico_socket_shutdown(s, PICO_SHUT_RDWR);
+}
+
+#ifdef PICO_SUPPORT_CRC
+static inline int pico_transport_crc_check(struct pico_frame *f)
+{
+ struct pico_ipv4_hdr *net_hdr = (struct pico_ipv4_hdr *) f->net_hdr;
+ struct pico_udp_hdr *udp_hdr = NULL;
+ uint16_t checksum_invalid = 1;
+
+ switch (net_hdr->proto)
+ {
+#ifdef PICO_SUPPORT_TCP
+ case PICO_PROTO_TCP:
+ checksum_invalid = short_be(pico_tcp_checksum(f));
+ /* dbg("TCP CRC validation == %u\n", checksum_invalid); */
+ if (checksum_invalid) {
+ dbg("TCP CRC: validation failed!\n");
+ pico_frame_discard(f);
+ return 0;
+ }
+
+ break;
+#endif /* PICO_SUPPORT_TCP */
+
+#ifdef PICO_SUPPORT_UDP
+ case PICO_PROTO_UDP:
+ udp_hdr = (struct pico_udp_hdr *) f->transport_hdr;
+ if (short_be(udp_hdr->crc)) {
+#ifdef PICO_SUPPORT_IPV4
+ if (IS_IPV4(f))
+ checksum_invalid = short_be(pico_udp_checksum_ipv4(f));
+
+#endif
+#ifdef PICO_SUPPORT_IPV6
+ if (IS_IPV6(f))
+ checksum_invalid = short_be(pico_udp_checksum_ipv6(f));
+
+#endif
+ /* dbg("UDP CRC validation == %u\n", checksum_invalid); */
+ if (checksum_invalid) {
+ /* dbg("UDP CRC: validation failed!\n"); */
+ pico_frame_discard(f);
+ return 0;
+ }
+ }
+
+ break;
+#endif /* PICO_SUPPORT_UDP */
+
+ default:
+ /* Do nothing */
+ break;
+ }
+ return 1;
+}
+#else
+static inline int pico_transport_crc_check(struct pico_frame *f)
+{
+ IGNORE_PARAMETER(f);
+ return 1;
+}
+#endif /* PICO_SUPPORT_CRC */
+
+int pico_transport_process_in(struct pico_protocol *self, struct pico_frame *f)
+{
+ struct pico_trans *hdr = (struct pico_trans *) f->transport_hdr;
+ int ret = 0;
+
+ if (!hdr) {
+ pico_err = PICO_ERR_EFAULT;
+ return -1;
+ }
+
+ ret = pico_transport_crc_check(f);
+ if (ret < 1)
+ return ret;
+ else
+ ret = 0;
+
+ if ((hdr) && (pico_socket_deliver(self, f, hdr->dport) == 0))
+ return ret;
+
+ if (!IS_BCAST(f)) {
+ dbg("Socket not found... \n");
+ pico_notify_socket_unreachable(f);
+ ret = -1;
+ pico_err = PICO_ERR_ENOENT;
+ }
+
+ pico_frame_discard(f);
+ return ret;
+}
+
+#define SL_LOOP_MIN 1
+
+#ifdef PICO_SUPPORT_TCP
+static int checkSocketSanity(struct pico_socket *s)
+{
+
+ /* checking for pending connections */
+ if(TCP_STATE(s) == PICO_SOCKET_STATE_TCP_SYN_RECV) {
+ if((PICO_TIME_MS() - s->timestamp) >= PICO_SOCKET_BOUND_TIMEOUT)
+ return -1;
+ }
+
+ if((PICO_TIME_MS() - s->timestamp) >= PICO_SOCKET_TIMEOUT) {
+ /* checking for hanging sockets */
+ if((TCP_STATE(s) != PICO_SOCKET_STATE_TCP_LISTEN) && (TCP_STATE(s) != PICO_SOCKET_STATE_TCP_ESTABLISHED))
+ return -1;
+ }
+
+ return 0;
+}
+#endif
+
+
+static int pico_sockets_loop_udp(int loop_score)
+{
+
+#ifdef PICO_SUPPORT_UDP
+ static struct pico_tree_node *index_udp;
+ struct pico_sockport *start;
+ struct pico_socket *s;
+ struct pico_frame *f;
+
+ if (sp_udp == NULL)
+ {
+ index_udp = pico_tree_firstNode(UDPTable.root);
+ sp_udp = index_udp->keyValue;
+ }
+
+ /* init start node */
+ start = sp_udp;
+
+ /* round-robin all transport protocols, break if traversed all protocols */
+ while (loop_score > SL_LOOP_MIN && sp_udp != NULL) {
+ struct pico_tree_node *index;
+
+ pico_tree_foreach(index, &sp_udp->socks){
+ s = index->keyValue;
+ f = pico_dequeue(&s->q_out);
+ while (f && (loop_score > 0)) {
+ pico_proto_udp.push(&pico_proto_udp, f);
+ loop_score -= 1;
+ f = pico_dequeue(&s->q_out);
+ }
+ }
+
+ index_udp = pico_tree_next(index_udp);
+ sp_udp = index_udp->keyValue;
+
+ if (sp_udp == NULL)
+ {
+ index_udp = pico_tree_firstNode(UDPTable.root);
+ sp_udp = index_udp->keyValue;
+ }
+
+ if (sp_udp == start)
+ break;
+ }
+#endif
+ return loop_score;
+}
+
+static int pico_sockets_loop_tcp(int loop_score)
+{
+#ifdef PICO_SUPPORT_TCP
+ struct pico_sockport *start;
+ struct pico_socket *s;
+ static struct pico_tree_node *index_tcp;
+ if (sp_tcp == NULL)
+ {
+ index_tcp = pico_tree_firstNode(TCPTable.root);
+ sp_tcp = index_tcp->keyValue;
+ }
+
+ /* init start node */
+ start = sp_tcp;
+
+ while (loop_score > SL_LOOP_MIN && sp_tcp != NULL) {
+ struct pico_tree_node *index = NULL, *safe_index = NULL;
+ pico_tree_foreach_safe(index, &sp_tcp->socks, safe_index){
+ s = index->keyValue;
+ loop_score = pico_tcp_output(s, loop_score);
+ if ((s->ev_pending) && s->wakeup) {
+ s->wakeup(s->ev_pending, s);
+ if(!s->parent)
+ s->ev_pending = 0;
+ }
+
+ if (loop_score <= 0) {
+ loop_score = 0;
+ break;
+ }
+
+ if(checkSocketSanity(s) < 0)
+ {
+ pico_socket_del(s);
+ index_tcp = NULL; /* forcing the restart of loop */
+ sp_tcp = NULL;
+ break;
+ }
+ }
+
+ /* check if RB_FOREACH ended, if not, break to keep the cur sp_tcp */
+ if (!index_tcp || (index && index->keyValue))
+ break;
+
+ index_tcp = pico_tree_next(index_tcp);
+ sp_tcp = index_tcp->keyValue;
+
+ if (sp_tcp == NULL)
+ {
+ index_tcp = pico_tree_firstNode(TCPTable.root);
+ sp_tcp = index_tcp->keyValue;
+ }
+
+ if (sp_tcp == start)
+ break;
+ }
+#endif
+ return loop_score;
+
+
+}
+
+int pico_sockets_loop(int loop_score)
+{
+ loop_score = pico_sockets_loop_udp(loop_score);
+ loop_score = pico_sockets_loop_tcp(loop_score);
+ return loop_score;
+}
+
+int pico_count_sockets(uint8_t proto)
+{
+ struct pico_sockport *sp;
+ struct pico_tree_node *idx_sp, *idx_s;
+ int count = 0;
+
+ if ((proto == 0) || (proto == PICO_PROTO_TCP)) {
+ pico_tree_foreach(idx_sp, &TCPTable) {
+ sp = idx_sp->keyValue;
+ if (sp) {
+ pico_tree_foreach(idx_s, &sp->socks)
+ count++;
+ }
+ }
+ }
+
+ if ((proto == 0) || (proto == PICO_PROTO_UDP)) {
+ pico_tree_foreach(idx_sp, &UDPTable) {
+ sp = idx_sp->keyValue;
+ if (sp) {
+ pico_tree_foreach(idx_s, &sp->socks)
+ count++;
+ }
+ }
+ }
+
+ return count;
+}
+
+
+struct pico_frame *pico_socket_frame_alloc(struct pico_socket *s, uint16_t len)
+{
+ struct pico_frame *f = NULL;
+
+#ifdef PICO_SUPPORT_IPV6
+ if (is_sock_ipv6(s))
+ f = pico_proto_ipv6.alloc(&pico_proto_ipv6, len);
+
+#endif
+
+#ifdef PICO_SUPPORT_IPV4
+ if (is_sock_ipv4(s))
+ f = pico_proto_ipv4.alloc(&pico_proto_ipv4, len);
+
+#endif
+ if (!f) {
+ pico_err = PICO_ERR_ENOMEM;
+ return f;
+ }
+
+ f->payload = f->transport_hdr;
+ f->payload_len = len;
+ f->sock = s;
+ return f;
+}
+
+static void pico_transport_error_set_picoerr(int code)
+{
+ /* dbg("SOCKET ERROR FROM ICMP NOTIFICATION. (icmp code= %d)\n\n", code); */
+ switch(code) {
+ case PICO_ICMP_UNREACH_NET:
+ pico_err = PICO_ERR_ENETUNREACH;
+ break;
+
+ case PICO_ICMP_UNREACH_HOST:
+ pico_err = PICO_ERR_EHOSTUNREACH;
+ break;
+
+ case PICO_ICMP_UNREACH_PROTOCOL:
+ pico_err = PICO_ERR_ENOPROTOOPT;
+ break;
+
+ case PICO_ICMP_UNREACH_PORT:
+ pico_err = PICO_ERR_ECONNREFUSED;
+ break;
+
+ case PICO_ICMP_UNREACH_NET_UNKNOWN:
+ pico_err = PICO_ERR_ENETUNREACH;
+ break;
+
+ case PICO_ICMP_UNREACH_HOST_UNKNOWN:
+ pico_err = PICO_ERR_EHOSTDOWN;
+ break;
+
+ case PICO_ICMP_UNREACH_ISOLATED:
+ pico_err = PICO_ERR_ENONET;
+ break;
+
+ case PICO_ICMP_UNREACH_NET_PROHIB:
+ case PICO_ICMP_UNREACH_HOST_PROHIB:
+ pico_err = PICO_ERR_EHOSTUNREACH;
+ break;
+
+ default:
+ pico_err = PICO_ERR_EOPNOTSUPP;
+ }
+}
+
+int pico_transport_error(struct pico_frame *f, uint8_t proto, int code)
+{
+ int ret = -1;
+ struct pico_trans *trans = (struct pico_trans*) f->transport_hdr;
+ struct pico_sockport *port = NULL;
+ struct pico_socket *s = NULL;
+ switch (proto) {
+
+
+#ifdef PICO_SUPPORT_UDP
+ case PICO_PROTO_UDP:
+ port = pico_get_sockport(proto, trans->sport);
+ break;
+#endif
+
+#ifdef PICO_SUPPORT_TCP
+ case PICO_PROTO_TCP:
+ port = pico_get_sockport(proto, trans->sport);
+ break;
+#endif
+
+ default:
+ /* Protocol not available */
+ ret = -1;
+ }
+ if (port) {
+ struct pico_tree_node *index;
+ ret = 0;
+
+ pico_tree_foreach(index, &port->socks) {
+ s = index->keyValue;
+ if (trans->dport == s->remote_port) {
+ if (s->wakeup) {
+ pico_transport_error_set_picoerr(code);
+ s->state |= PICO_SOCKET_STATE_SHUT_REMOTE;
+ s->wakeup(PICO_SOCK_EV_ERR, s);
+ }
+
+ break;
+ }
+ }
+ }
+
+ pico_frame_discard(f);
+ return ret;
+}
+#endif
+#endif
diff --git a/net/picotcp/stack/pico_socket_multicast.c b/net/picotcp/stack/pico_socket_multicast.c
new file mode 100644
index 0000000..f23327d
--- /dev/null
+++ b/net/picotcp/stack/pico_socket_multicast.c
@@ -0,0 +1,956 @@
+#include "pico_config.h"
+#include "pico_stack.h"
+#include "pico_socket.h"
+#include "pico_socket_multicast.h"
+#include "pico_tree.h"
+#include "pico_ipv4.h"
+#include "pico_udp.h"
+
+#ifdef PICO_SUPPORT_MCAST
+# define so_mcast_dbg(...) do {} while(0) /* ip_mcast_dbg in pico_ipv4.c */
+/* #define so_mcast_dbg dbg */
+
+/* socket
+ * |
+ * MCASTListen
+ * | | |
+ * ------------ | ------------
+ * | | |
+ * MCASTSources MCASTSources MCASTSources
+ * | | | | | | | | | | | |
+ * S S S S S S S S S S S S
+ *
+ * MCASTListen: RBTree(mcast_link, mcast_group)
+ * MCASTSources: RBTree(source)
+ */
+struct pico_mcast_listen
+{
+ uint8_t filter_mode;
+ union pico_address mcast_link;
+ union pico_address mcast_group;
+ struct pico_tree MCASTSources;
+ uint16_t proto;
+};
+
+static int mcast_listen_link_cmp(struct pico_mcast_listen *a, struct pico_mcast_listen *b)
+{
+
+ if (a->proto < b->proto)
+ return -1;
+
+ if (a->proto > b->proto)
+ return 1;
+
+ return pico_address_compare(&a->mcast_link, &b->mcast_link, a->proto);
+}
+
+static int mcast_listen_grp_cmp(struct pico_mcast_listen *a, struct pico_mcast_listen *b)
+{
+ if (a->mcast_group.ip4.addr < b->mcast_group.ip4.addr)
+ return -1;
+
+ if (a->mcast_group.ip4.addr > b->mcast_group.ip4.addr)
+ return 1;
+
+ return mcast_listen_link_cmp(a, b);
+}
+
+static int mcast_listen_cmp(void *ka, void *kb)
+{
+ struct pico_mcast_listen *a = ka, *b = kb;
+ if (a->proto < b->proto)
+ return -1;
+
+ if (a->proto > b->proto)
+ return 1;
+
+ return mcast_listen_grp_cmp(a, b);
+}
+
+static int mcast_sources_cmp(void *ka, void *kb)
+{
+ union pico_address *a = ka, *b = kb;
+ if (a->ip4.addr < b->ip4.addr)
+ return -1;
+
+ if (a->ip4.addr > b->ip4.addr)
+ return 1;
+
+ return 0;
+}
+
+static int mcast_socket_cmp(void *ka, void *kb)
+{
+ struct pico_socket *a = ka, *b = kb;
+ if (a < b)
+ return -1;
+
+ if (a > b)
+ return 1;
+
+ return 0;
+}
+
+/* gather all multicast sockets to hasten filter aggregation */
+PICO_TREE_DECLARE(MCASTSockets, mcast_socket_cmp);
+
+static int mcast_filter_cmp(void *ka, void *kb)
+{
+ union pico_address *a = ka, *b = kb;
+ if (a->ip4.addr < b->ip4.addr)
+ return -1;
+
+ if (a->ip4.addr > b->ip4.addr)
+ return 1;
+
+ return 0;
+}
+/* gather sources to be filtered */
+PICO_TREE_DECLARE(MCASTFilter, mcast_filter_cmp);
+
+static struct pico_mcast_listen *listen_find(struct pico_socket *s, union pico_address *lnk, union pico_address *grp)
+{
+ struct pico_mcast_listen ltest = {
+ 0
+ };
+ ltest.mcast_link.ip4.addr = lnk->ip4.addr;
+ ltest.mcast_group.ip4.addr = grp->ip4.addr;
+ return pico_tree_findKey(s->MCASTListen, <est);
+}
+
+static uint8_t pico_mcast_filter_excl_excl(struct pico_mcast_listen *listen)
+{
+ /* filter = intersection of EXCLUDEs */
+ /* any record with filter mode EXCLUDE, causes the interface mode to be EXCLUDE */
+ /* remove from the interface EXCLUDE filter any source not in the socket EXCLUDE filter */
+ struct pico_tree_node *index = NULL, *_tmp = NULL;
+ union pico_address *source = NULL;
+ pico_tree_foreach_safe(index, &MCASTFilter, _tmp)
+ {
+ source = pico_tree_findKey(&listen->MCASTSources, index->keyValue);
+ if (!source)
+ pico_tree_delete(&MCASTFilter, index->keyValue);
+ }
+ return PICO_IP_MULTICAST_EXCLUDE;
+}
+
+static uint8_t pico_mcast_filter_excl_incl(struct pico_mcast_listen *listen)
+{
+ /* filter = EXCLUDE - INCLUDE */
+ /* any record with filter mode EXCLUDE, causes the interface mode to be EXCLUDE */
+ /* remove from the interface EXCLUDE filter any source in the socket INCLUDE filter */
+ struct pico_tree_node *index = NULL, *_tmp = NULL;
+ union pico_address *source = NULL;
+ pico_tree_foreach_safe(index, &listen->MCASTSources, _tmp)
+ {
+ source = pico_tree_findKey(&MCASTFilter, index->keyValue);
+ if (source)
+ pico_tree_delete(&MCASTFilter, source);
+ }
+ return PICO_IP_MULTICAST_EXCLUDE;
+}
+
+static uint8_t pico_mcast_filter_incl_excl(struct pico_mcast_listen *listen)
+{
+ /* filter = EXCLUDE - INCLUDE */
+ /* delete from the interface INCLUDE filter any source NOT in the socket EXCLUDE filter */
+ struct pico_tree_node *index = NULL, *_tmp = NULL, *index2 = NULL, *_tmp2 = NULL;
+ union pico_address *source = NULL;
+ pico_tree_foreach_safe(index2, &MCASTFilter, _tmp2)
+ {
+ source = pico_tree_findKey(&listen->MCASTSources, index2->keyValue);
+ if (!source)
+ pico_tree_delete(&MCASTFilter, index2->keyValue);
+ }
+ /* any record with filter mode EXCLUDE, causes the interface mode to be EXCLUDE */
+
+ /* add to the interface EXCLUDE filter any socket source NOT in the former interface INCLUDE filter */
+ pico_tree_foreach_safe(index, &listen->MCASTSources, _tmp)
+ {
+ source = pico_tree_insert(&MCASTFilter, index->keyValue);
+ if (source)
+ pico_tree_delete(&MCASTFilter, source);
+ }
+ return PICO_IP_MULTICAST_EXCLUDE;
+}
+
+static uint8_t pico_mcast_filter_incl_incl(struct pico_mcast_listen *listen)
+{
+ /* filter = summation of INCLUDEs */
+ /* mode stays INCLUDE, add all sources to filter */
+ struct pico_tree_node *index = NULL, *_tmp = NULL;
+ union pico_address *source = NULL;
+ pico_tree_foreach_safe(index, &listen->MCASTSources, _tmp)
+ {
+ source = index->keyValue;
+ pico_tree_insert(&MCASTFilter, source);
+ }
+ return PICO_IP_MULTICAST_INCLUDE;
+}
+
+struct pico_mcast_filter_aggregation
+{
+ uint8_t (*call)(struct pico_mcast_listen *);
+};
+
+static const struct pico_mcast_filter_aggregation mcast_filter_aggr_call[2][2] =
+{
+ {
+ /* EXCL + EXCL */ {.call = pico_mcast_filter_excl_excl},
+ /* EXCL + INCL */ {.call = pico_mcast_filter_excl_incl}
+ },
+
+ {
+ /* INCL + EXCL */ {.call = pico_mcast_filter_incl_excl},
+ /* INCL + INCL */ {.call = pico_mcast_filter_incl_incl}
+ }
+};
+
+static int mcast_aggr_validate(uint8_t fm, struct pico_mcast_listen *l)
+{
+ if (!l)
+ return -1;
+
+ if (fm > 1)
+ return -1;
+
+ if (l->filter_mode > 1)
+ return -1;
+
+ return 0;
+}
+
+
+/* MCASTFilter will be empty if no socket is listening on mcast_group on mcast_link anymore */
+static int pico_socket_aggregate_mcastfilters(union pico_address *mcast_link, union pico_address *mcast_group)
+{
+ uint8_t filter_mode = PICO_IP_MULTICAST_INCLUDE;
+ struct pico_mcast_listen *listen = NULL;
+ struct pico_socket *mcast_sock = NULL;
+ struct pico_tree_node *index = NULL, *_tmp = NULL;
+
+
+ /* cleanup old filter */
+ pico_tree_foreach_safe(index, &MCASTFilter, _tmp)
+ {
+ pico_tree_delete(&MCASTFilter, index->keyValue);
+ }
+
+ /* construct new filter */
+ pico_tree_foreach_safe(index, &MCASTSockets, _tmp)
+ {
+ mcast_sock = index->keyValue;
+ listen = listen_find(mcast_sock, mcast_link, mcast_group);
+ if (listen) {
+ if (mcast_aggr_validate(filter_mode, listen) < 0) {
+ pico_err = PICO_ERR_EINVAL;
+ return -1;
+ }
+
+ if (mcast_filter_aggr_call[filter_mode][listen->filter_mode].call) {
+ filter_mode = mcast_filter_aggr_call[filter_mode][listen->filter_mode].call(listen);
+ if (filter_mode > 1)
+ return -1;
+ }
+ }
+ }
+ return filter_mode;
+}
+
+static int pico_socket_mcast_filter_include(struct pico_mcast_listen *listen, union pico_address *src)
+{
+ struct pico_tree_node *index = NULL;
+ pico_tree_foreach(index, &listen->MCASTSources)
+ {
+ if (src->ip4.addr == ((union pico_address *)index->keyValue)->ip4.addr) {
+ so_mcast_dbg("MCAST: IP %08X in included socket source list\n", src->ip4.addr);
+ return 0;
+ }
+ }
+ so_mcast_dbg("MCAST: IP %08X NOT in included socket source list\n", src->ip4.addr);
+ return -1;
+
+}
+
+static int pico_socket_mcast_filter_exclude(struct pico_mcast_listen *listen, union pico_address *src)
+{
+ struct pico_tree_node *index = NULL;
+ pico_tree_foreach(index, &listen->MCASTSources)
+ {
+ if (src->ip4.addr == ((union pico_address *)index->keyValue)->ip4.addr) {
+ so_mcast_dbg("MCAST: IP %08X in excluded socket source list\n", src->ip4.addr);
+ return -1;
+ }
+ }
+ so_mcast_dbg("MCAST: IP %08X NOT in excluded socket source list\n", src->ip4.addr);
+ return 0;
+}
+
+static int pico_socket_mcast_source_filtering(struct pico_mcast_listen *listen, union pico_address *src)
+{
+ /* perform source filtering */
+ if (listen->filter_mode == PICO_IP_MULTICAST_INCLUDE)
+ return pico_socket_mcast_filter_include(listen, src);
+
+ if (listen->filter_mode == PICO_IP_MULTICAST_EXCLUDE)
+ return pico_socket_mcast_filter_exclude(listen, src);
+
+ return -1;
+}
+
+static struct pico_ipv4_link *pico_socket_mcast_filter_link_get(struct pico_socket *s)
+{
+ /* check if no multicast enabled on socket */
+ if (!s->MCASTListen)
+ return NULL;
+
+ if (!s->local_addr.ip4.addr)
+ return pico_ipv4_get_default_mcastlink();
+
+ return pico_ipv4_link_get(&s->local_addr.ip4);
+}
+
+int pico_socket_mcast_filter(struct pico_socket *s, union pico_address *mcast_group, union pico_address *src)
+{
+ struct pico_ipv4_link *mcast_link = NULL;
+ struct pico_mcast_listen *listen = NULL;
+
+ mcast_link = pico_socket_mcast_filter_link_get(s);
+ if (!mcast_link)
+ return -1;
+
+ listen = listen_find(s, (union pico_address *)&mcast_link->address, mcast_group);
+ if (!listen)
+ return -1;
+
+ return pico_socket_mcast_source_filtering(listen, src);
+}
+
+static struct pico_ipv4_link *get_mcast_link(union pico_address *a)
+{
+ if (!a->ip4.addr)
+ return pico_ipv4_get_default_mcastlink();
+
+ return pico_ipv4_link_get(&a->ip4);
+}
+
+
+static int pico_socket_setoption_pre_validation(struct pico_ip_mreq *mreq)
+{
+ if (!mreq)
+ return -1;
+
+ if (!mreq->mcast_group_addr.addr)
+ return -1;
+
+ return 0;
+}
+
+static struct pico_ipv4_link *pico_socket_setoption_validate_mreq(struct pico_ip_mreq *mreq)
+{
+ if (pico_socket_setoption_pre_validation(mreq) < 0)
+ return NULL;
+
+ if (pico_ipv4_is_unicast(mreq->mcast_group_addr.addr))
+ return NULL;
+
+ return get_mcast_link((union pico_address *)&mreq->mcast_link_addr);
+}
+
+static int pico_socket_setoption_pre_validation_s(struct pico_ip_mreq_source *mreq)
+{
+ if (!mreq)
+ return -1;
+
+ if (!mreq->mcast_group_addr.addr)
+ return -1;
+
+ return 0;
+}
+
+static struct pico_ipv4_link *pico_socket_setoption_validate_s_mreq(struct pico_ip_mreq_source *mreq)
+{
+ if (pico_socket_setoption_pre_validation_s(mreq) < 0)
+ return NULL;
+
+ if (pico_ipv4_is_unicast(mreq->mcast_group_addr.addr))
+ return NULL;
+
+ if (!pico_ipv4_is_unicast(mreq->mcast_source_addr.addr))
+ return NULL;
+
+ return get_mcast_link((union pico_address *)&mreq->mcast_link_addr);
+}
+
+
+static struct pico_ipv4_link *setop_multicast_link_search(void *value, int bysource)
+{
+
+ struct pico_ip_mreq *mreq = NULL;
+ struct pico_ipv4_link *mcast_link = NULL;
+ struct pico_ip_mreq_source *mreq_src = NULL;
+ if (!bysource) {
+ mreq = (struct pico_ip_mreq *) value;
+ mcast_link = pico_socket_setoption_validate_mreq(mreq);
+ if (!mcast_link)
+ return NULL;
+
+ if (!mreq->mcast_link_addr.addr)
+ mreq->mcast_link_addr.addr = mcast_link->address.addr;
+ } else {
+ mreq_src = (struct pico_ip_mreq_source *) value;
+ if (!mreq_src)
+ return NULL;
+
+ mcast_link = pico_socket_setoption_validate_s_mreq(mreq_src);
+ if (!mcast_link)
+ return NULL;
+
+ if (!mreq_src->mcast_link_addr.addr)
+ mreq_src->mcast_link_addr.addr = mcast_link->address.addr;
+ }
+
+ return mcast_link;
+}
+
+static int setop_verify_listen_tree(struct pico_socket *s, int alloc)
+{
+ if(!alloc)
+ return -1;
+
+ s->MCASTListen = PICO_ZALLOC(sizeof(struct pico_tree));
+ if (!s->MCASTListen) {
+ pico_err = PICO_ERR_ENOMEM;
+ return -1;
+ }
+
+ s->MCASTListen->root = &LEAF;
+ s->MCASTListen->compare = mcast_listen_cmp;
+ return 0;
+}
+
+
+static struct pico_ipv4_link *setopt_multicast_check(struct pico_socket *s, void *value, int alloc, int bysource)
+{
+ struct pico_ipv4_link *mcast_link = NULL;
+
+ if (!value) {
+ pico_err = PICO_ERR_EINVAL;
+ return NULL;
+ }
+
+ mcast_link = setop_multicast_link_search(value, bysource);
+
+ if (!mcast_link) {
+ pico_err = PICO_ERR_EINVAL;
+ return NULL;
+ }
+
+ if (!s->MCASTListen) { /* No RBTree allocated yet */
+ if (setop_verify_listen_tree(s, alloc) < 0)
+ return NULL;
+ }
+
+ return mcast_link;
+}
+
+
+void pico_multicast_delete(struct pico_socket *s)
+{
+ int filter_mode;
+ struct pico_tree_node *index = NULL, *_tmp = NULL, *index2 = NULL, *_tmp2 = NULL;
+ struct pico_mcast_listen *listen = NULL;
+ union pico_address *source = NULL;
+ if (s->MCASTListen) {
+ pico_tree_delete(&MCASTSockets, s);
+ pico_tree_foreach_safe(index, s->MCASTListen, _tmp)
+ {
+ listen = index->keyValue;
+ pico_tree_foreach_safe(index2, &listen->MCASTSources, _tmp2)
+ {
+ source = index->keyValue;
+ pico_tree_delete(&listen->MCASTSources, source);
+ PICO_FREE(source);
+ }
+ filter_mode = pico_socket_aggregate_mcastfilters((union pico_address *)&listen->mcast_link, (union pico_address *)&listen->mcast_group);
+ if (filter_mode >= 0)
+ pico_ipv4_mcast_leave(&listen->mcast_link.ip4, &listen->mcast_group.ip4, 1, (uint8_t)filter_mode, &MCASTFilter);
+
+ pico_tree_delete(s->MCASTListen, listen);
+ PICO_FREE(listen);
+ }
+ PICO_FREE(s->MCASTListen);
+ }
+}
+
+
+int pico_getsockopt_mcast(struct pico_socket *s, int option, void *value)
+{
+ switch(option) {
+ case PICO_IP_MULTICAST_IF:
+ pico_err = PICO_ERR_EOPNOTSUPP;
+ return -1;
+
+ case PICO_IP_MULTICAST_TTL:
+ if (s->proto->proto_number == PICO_PROTO_UDP) {
+ pico_udp_get_mc_ttl(s, (uint8_t *) value);
+ } else {
+ *(uint8_t *)value = 0;
+ pico_err = PICO_ERR_EINVAL;
+ return -1;
+ }
+
+ break;
+
+ case PICO_IP_MULTICAST_LOOP:
+ if (s->proto->proto_number == PICO_PROTO_UDP) {
+ *(uint8_t *)value = (uint8_t)PICO_SOCKET_GETOPT(s, PICO_SOCKET_OPT_MULTICAST_LOOP);
+ } else {
+ *(uint8_t *)value = 0;
+ pico_err = PICO_ERR_EINVAL;
+ return -1;
+ }
+
+ break;
+ default:
+ pico_err = PICO_ERR_EINVAL;
+ return -1;
+ }
+
+ return 0;
+}
+
+static int mcast_so_loop(struct pico_socket *s, void *value)
+{
+ uint8_t val = (*(uint8_t *)value);
+ if (val == 0u) {
+ PICO_SOCKET_SETOPT_DIS(s, PICO_SOCKET_OPT_MULTICAST_LOOP);
+ return 0;
+ } else if (val == 1u) {
+ PICO_SOCKET_SETOPT_EN(s, PICO_SOCKET_OPT_MULTICAST_LOOP);
+ return 0;
+ }
+
+ pico_err = PICO_ERR_EINVAL;
+ return -1;
+}
+
+static int mcast_so_addm(struct pico_socket *s, void *value)
+{
+ int filter_mode;
+ struct pico_mcast_listen *listen;
+ struct pico_ip_mreq *mreq = (struct pico_ip_mreq *)value;
+ struct pico_ipv4_link *mcast_link = setopt_multicast_check(s, value, 1, 0);
+ if (!mcast_link)
+ return -1;
+
+ listen = listen_find(s, (union pico_address *)&mreq->mcast_link_addr, (union pico_address *)&mreq->mcast_group_addr);
+ if (listen) {
+ if (listen->filter_mode != PICO_IP_MULTICAST_EXCLUDE) {
+ so_mcast_dbg("pico_socket_setoption: ERROR any-source multicast (exclude) on source-specific multicast (include)\n");
+ pico_err = PICO_ERR_EINVAL;
+ return -1;
+ } else {
+ so_mcast_dbg("pico_socket_setoption: ERROR duplicate PICO_IP_ADD_MEMBERSHIP\n");
+ pico_err = PICO_ERR_EINVAL;
+ return -1;
+ }
+ } else {
+ listen = PICO_ZALLOC(sizeof(struct pico_mcast_listen));
+ if (!listen) {
+ pico_err = PICO_ERR_ENOMEM;
+ return -1;
+ }
+
+ listen->filter_mode = PICO_IP_MULTICAST_EXCLUDE;
+ listen->mcast_link.ip4 = mreq->mcast_link_addr;
+ listen->mcast_group.ip4 = mreq->mcast_group_addr;
+ listen->MCASTSources.root = &LEAF;
+ listen->MCASTSources.compare = mcast_sources_cmp;
+ listen->proto = s->net->proto_number;
+ pico_tree_insert(s->MCASTListen, listen);
+ }
+
+ pico_tree_insert(&MCASTSockets, s);
+ filter_mode = pico_socket_aggregate_mcastfilters((union pico_address *)&mcast_link->address, (union pico_address *)&mreq->mcast_group_addr);
+ if (filter_mode < 0)
+ return -1;
+
+ so_mcast_dbg("PICO_IP_ADD_MEMBERSHIP - success, added %p\n", s);
+ return pico_ipv4_mcast_join(&mreq->mcast_link_addr, &mreq->mcast_group_addr, 1, (uint8_t)filter_mode, &MCASTFilter);
+}
+
+static int mcast_so_dropm(struct pico_socket *s, void *value)
+{
+ int filter_mode = 0;
+ struct pico_mcast_listen *listen;
+ struct pico_ip_mreq *mreq = (struct pico_ip_mreq *)value;
+ union pico_address *source = NULL;
+ struct pico_tree_node *index, *_tmp;
+ struct pico_ipv4_link *mcast_link = setopt_multicast_check(s, value, 0, 0);
+ if (!mcast_link)
+ return -1;
+
+ listen = listen_find(s, (union pico_address *)&mreq->mcast_link_addr, (union pico_address *)&mreq->mcast_group_addr);
+ if (!listen) {
+ so_mcast_dbg("pico_socket_setoption: ERROR PICO_IP_DROP_MEMBERSHIP before PICO_IP_ADD_MEMBERSHIP/SOURCE_MEMBERSHIP\n");
+ pico_err = PICO_ERR_EADDRNOTAVAIL;
+ return -1;
+ } else {
+ pico_tree_foreach_safe(index, &listen->MCASTSources, _tmp)
+ {
+ source = index->keyValue;
+ pico_tree_delete(&listen->MCASTSources, source);
+ }
+ pico_tree_delete(s->MCASTListen, listen);
+ PICO_FREE(listen);
+ if (pico_tree_empty(s->MCASTListen)) {
+ PICO_FREE(s->MCASTListen);
+ s->MCASTListen = NULL;
+ pico_tree_delete(&MCASTSockets, s);
+ }
+ }
+
+ filter_mode = pico_socket_aggregate_mcastfilters((union pico_address *)&mcast_link->address, (union pico_address *)&mreq->mcast_group_addr);
+ if (filter_mode < 0)
+ return -1;
+
+ return pico_ipv4_mcast_leave(&mreq->mcast_link_addr, &mreq->mcast_group_addr, 1, (uint8_t)filter_mode, &MCASTFilter);
+}
+
+static int mcast_so_unblock_src(struct pico_socket *s, void *value)
+{
+ int filter_mode = 0;
+ struct pico_ip_mreq_source *mreq = (struct pico_ip_mreq_source *)value;
+ struct pico_mcast_listen *listen = NULL;
+ union pico_address *source = NULL, stest;
+ struct pico_ipv4_link *mcast_link = setopt_multicast_check(s, value, 0, 1);
+
+ memset(&stest, 0, sizeof(union pico_address));
+ if (!mcast_link)
+ return -1;
+
+
+ listen = listen_find(s, (union pico_address *) &mreq->mcast_link_addr, (union pico_address *) &mreq->mcast_group_addr);
+ if (!listen) {
+ so_mcast_dbg("pico_socket_setoption: ERROR PICO_IP_UNBLOCK_SOURCE before PICO_IP_ADD_MEMBERSHIP\n");
+ pico_err = PICO_ERR_EINVAL;
+ return -1;
+ } else {
+ if (listen->filter_mode != PICO_IP_MULTICAST_EXCLUDE) {
+ so_mcast_dbg("pico_socket_setoption: ERROR any-source multicast (exclude) on source-specific multicast (include)\n");
+ pico_err = PICO_ERR_EINVAL;
+ return -1;
+ }
+
+ stest.ip4.addr = mreq->mcast_source_addr.addr;
+ source = pico_tree_findKey(&listen->MCASTSources, &stest);
+ if (!source) {
+ so_mcast_dbg("pico_socket_setoption: ERROR address to unblock not in source list\n");
+ pico_err = PICO_ERR_EADDRNOTAVAIL;
+ return -1;
+ } else {
+ pico_tree_delete(&listen->MCASTSources, source);
+ }
+ }
+
+ filter_mode = pico_socket_aggregate_mcastfilters((union pico_address *)&mcast_link->address, (union pico_address *)&mreq->mcast_group_addr);
+ if (filter_mode < 0)
+ return -1;
+
+ return pico_ipv4_mcast_leave(&mreq->mcast_link_addr, &mreq->mcast_group_addr, 0, (uint8_t)filter_mode, &MCASTFilter);
+}
+
+static int mcast_so_block_src(struct pico_socket *s, void *value)
+{
+ int filter_mode = 0;
+ struct pico_ip_mreq_source *mreq = (struct pico_ip_mreq_source *)value;
+ struct pico_mcast_listen *listen;
+ union pico_address *source, stest;
+ struct pico_ipv4_link *mcast_link = setopt_multicast_check(s, value, 0, 1);
+ if (!mcast_link)
+ return -1;
+
+ memset(&stest, 0, sizeof(union pico_address));
+
+ listen = listen_find(s, (union pico_address *)&mreq->mcast_link_addr, (union pico_address *)&mreq->mcast_group_addr);
+ if (!listen) {
+ dbg("pico_socket_setoption: ERROR PICO_IP_BLOCK_SOURCE before PICO_IP_ADD_MEMBERSHIP\n");
+ pico_err = PICO_ERR_EINVAL;
+ return -1;
+ } else {
+ if (listen->filter_mode != PICO_IP_MULTICAST_EXCLUDE) {
+ so_mcast_dbg("pico_socket_setoption: ERROR any-source multicast (exclude) on source-specific multicast (include)\n");
+ pico_err = PICO_ERR_EINVAL;
+ return -1;
+ }
+
+ stest.ip4.addr = mreq->mcast_source_addr.addr;
+ source = pico_tree_findKey(&listen->MCASTSources, &stest);
+ if (source) {
+ so_mcast_dbg("pico_socket_setoption: ERROR address to block already in source list\n");
+ pico_err = PICO_ERR_EADDRNOTAVAIL;
+ return -1;
+ } else {
+ source = PICO_ZALLOC(sizeof(union pico_address));
+ if (!source) {
+ pico_err = PICO_ERR_ENOMEM;
+ return -1;
+ }
+
+ source->ip4.addr = mreq->mcast_source_addr.addr;
+ pico_tree_insert(&listen->MCASTSources, source);
+ }
+ }
+
+ filter_mode = pico_socket_aggregate_mcastfilters((union pico_address *)&mcast_link->address, (union pico_address *)&mreq->mcast_group_addr);
+ if (filter_mode < 0)
+ return -1;
+
+ return pico_ipv4_mcast_join(&mreq->mcast_link_addr, &mreq->mcast_group_addr, 0, (uint8_t)filter_mode, &MCASTFilter);
+}
+
+static int mcast_so_addsrcm(struct pico_socket *s, void *value)
+{
+ int filter_mode = 0, reference_count = 0;
+ struct pico_ip_mreq_source *mreq = (struct pico_ip_mreq_source *)value;
+ struct pico_mcast_listen *listen = NULL;
+ union pico_address *source = NULL, stest;
+ struct pico_ipv4_link *mcast_link = setopt_multicast_check(s, value, 1, 1);
+ if (!mcast_link)
+ return -1;
+
+ memset(&stest, 0, sizeof(union pico_address));
+
+ listen = listen_find(s, (union pico_address *)&mreq->mcast_link_addr, (union pico_address *) &mreq->mcast_group_addr);
+ if (listen) {
+ if (listen->filter_mode != PICO_IP_MULTICAST_INCLUDE) {
+ so_mcast_dbg("pico_socket_setoption: ERROR source-specific multicast (include) on any-source multicast (exclude)\n");
+ pico_err = PICO_ERR_EINVAL;
+ return -1;
+ }
+
+ stest.ip4.addr = mreq->mcast_source_addr.addr;
+ source = pico_tree_findKey(&listen->MCASTSources, &stest);
+ if (source) {
+ so_mcast_dbg("pico_socket_setoption: ERROR source address to allow already in source list\n");
+ pico_err = PICO_ERR_EADDRNOTAVAIL;
+ return -1;
+ } else {
+ source = PICO_ZALLOC(sizeof(union pico_address));
+ if (!source) {
+ pico_err = PICO_ERR_ENOMEM;
+ return -1;
+ }
+
+ source->ip4.addr = mreq->mcast_source_addr.addr;
+ pico_tree_insert(&listen->MCASTSources, source);
+ }
+ } else {
+ listen = PICO_ZALLOC(sizeof(struct pico_mcast_listen));
+ if (!listen) {
+ pico_err = PICO_ERR_ENOMEM;
+ return -1;
+ }
+
+ listen->filter_mode = PICO_IP_MULTICAST_INCLUDE;
+ listen->mcast_link.ip4 = mreq->mcast_link_addr;
+ listen->mcast_group.ip4 = mreq->mcast_group_addr;
+ listen->MCASTSources.root = &LEAF;
+ listen->MCASTSources.compare = mcast_sources_cmp;
+ source = PICO_ZALLOC(sizeof(union pico_address));
+ if (!source) {
+ PICO_FREE(listen);
+ pico_err = PICO_ERR_ENOMEM;
+ return -1;
+ }
+
+ source->ip4.addr = mreq->mcast_source_addr.addr;
+ pico_tree_insert(&listen->MCASTSources, source);
+ pico_tree_insert(s->MCASTListen, listen);
+ reference_count = 1;
+ }
+
+ pico_tree_insert(&MCASTSockets, s);
+ filter_mode = pico_socket_aggregate_mcastfilters((union pico_address *)&mcast_link->address, (union pico_address *)&mreq->mcast_group_addr);
+ if (filter_mode < 0)
+ return -1;
+
+ return pico_ipv4_mcast_join(&mreq->mcast_link_addr, &mreq->mcast_group_addr, (uint8_t)reference_count, (uint8_t)filter_mode, &MCASTFilter);
+}
+
+static int mcast_so_dropsrcm(struct pico_socket *s, void *value)
+{
+ int filter_mode = 0, reference_count = 0;
+ struct pico_ip_mreq_source *mreq = (struct pico_ip_mreq_source *)value;
+ struct pico_mcast_listen *listen;
+ union pico_address *source, stest;
+ struct pico_ipv4_link *mcast_link = setopt_multicast_check(s, value, 0, 1);
+ if (!mcast_link)
+ return -1;
+
+ memset(&stest, 0, sizeof(union pico_address));
+
+ listen = listen_find(s, (union pico_address *)&mreq->mcast_link_addr, (union pico_address *)&mreq->mcast_group_addr);
+ if (!listen) {
+ so_mcast_dbg("pico_socket_setoption: ERROR PICO_IP_DROP_SOURCE_MEMBERSHIP before PICO_IP_ADD_SOURCE_MEMBERSHIP\n");
+ pico_err = PICO_ERR_EADDRNOTAVAIL;
+ return -1;
+ } else {
+ if (listen->filter_mode != PICO_IP_MULTICAST_INCLUDE) {
+ so_mcast_dbg("pico_socket_setoption: ERROR source-specific multicast (include) on any-source multicast (exclude)\n");
+ pico_err = PICO_ERR_EINVAL;
+ return -1;
+ }
+
+ stest.ip4.addr = mreq->mcast_source_addr.addr;
+ source = pico_tree_findKey(&listen->MCASTSources, &stest);
+ if (!source) {
+ so_mcast_dbg("pico_socket_setoption: ERROR address to drop not in source list\n");
+ pico_err = PICO_ERR_EADDRNOTAVAIL;
+ return -1;
+ } else {
+ pico_tree_delete(&listen->MCASTSources, source);
+ if (pico_tree_empty(&listen->MCASTSources)) { /* 1 if empty, 0 otherwise */
+ reference_count = 1;
+ pico_tree_delete(s->MCASTListen, listen);
+ PICO_FREE(listen);
+ if (pico_tree_empty(s->MCASTListen)) {
+ PICO_FREE(s->MCASTListen);
+ s->MCASTListen = NULL;
+ pico_tree_delete(&MCASTSockets, s);
+ }
+ }
+ }
+ }
+
+ filter_mode = pico_socket_aggregate_mcastfilters((union pico_address *)&mcast_link->address, (union pico_address *)&mreq->mcast_group_addr);
+ if (filter_mode < 0)
+ return -1;
+
+ return pico_ipv4_mcast_leave(&mreq->mcast_link_addr, &mreq->mcast_group_addr, (uint8_t)reference_count, (uint8_t)filter_mode, &MCASTFilter);
+}
+
+struct pico_setsockopt_mcast_call
+{
+ int option;
+ int (*call)(struct pico_socket *, void *);
+};
+
+static const struct pico_setsockopt_mcast_call mcast_so_calls[1 + PICO_IP_DROP_SOURCE_MEMBERSHIP - PICO_IP_MULTICAST_IF] =
+{
+ { PICO_IP_MULTICAST_IF, NULL },
+ { PICO_IP_MULTICAST_TTL, pico_udp_set_mc_ttl },
+ { PICO_IP_MULTICAST_LOOP, mcast_so_loop },
+ { PICO_IP_ADD_MEMBERSHIP, mcast_so_addm },
+ { PICO_IP_DROP_MEMBERSHIP, mcast_so_dropm },
+ { PICO_IP_UNBLOCK_SOURCE, mcast_so_unblock_src },
+ { PICO_IP_BLOCK_SOURCE, mcast_so_block_src },
+ { PICO_IP_ADD_SOURCE_MEMBERSHIP, mcast_so_addsrcm },
+ { PICO_IP_DROP_SOURCE_MEMBERSHIP, mcast_so_dropsrcm }
+};
+
+
+static int mcast_so_check_socket(struct pico_socket *s)
+{
+ pico_err = PICO_ERR_EINVAL;
+ if (!s)
+ return -1;
+
+ if (!s->proto)
+ return -1;
+
+ if (s->proto->proto_number != PICO_PROTO_UDP)
+ return -1;
+
+ pico_err = PICO_ERR_NOERR;
+ return 0;
+}
+
+int pico_setsockopt_mcast(struct pico_socket *s, int option, void *value)
+{
+ int arrayn = option - PICO_IP_MULTICAST_IF;
+ if (option < PICO_IP_MULTICAST_IF || option > PICO_IP_DROP_SOURCE_MEMBERSHIP) {
+ pico_err = PICO_ERR_EOPNOTSUPP;
+ return -1;
+ }
+
+ if (mcast_so_check_socket(s) < 0)
+ return -1;
+
+ if (!mcast_so_calls[arrayn].call) {
+ pico_err = PICO_ERR_EOPNOTSUPP;
+ return -1;
+ }
+
+ return (mcast_so_calls[arrayn].call(s, value));
+}
+
+int pico_udp_set_mc_ttl(struct pico_socket *s, void *_ttl)
+{
+ struct pico_socket_udp *u;
+ uint8_t ttl = *(uint8_t *)_ttl;
+ if(!s) {
+ pico_err = PICO_ERR_EINVAL;
+ return -1;
+ }
+
+ u = (struct pico_socket_udp *) s;
+ u->mc_ttl = ttl;
+ return 0;
+}
+
+int pico_udp_get_mc_ttl(struct pico_socket *s, uint8_t *ttl)
+{
+ struct pico_socket_udp *u;
+ if(!s)
+ return -1;
+
+ u = (struct pico_socket_udp *) s;
+ *ttl = u->mc_ttl;
+ return 0;
+}
+#else
+int pico_udp_set_mc_ttl(struct pico_socket *s, void *_ttl)
+{
+ pico_err = PICO_ERR_EPROTONOSUPPORT;
+ return -1;
+}
+
+int pico_udp_get_mc_ttl(struct pico_socket *s, uint8_t *ttl)
+{
+ pico_err = PICO_ERR_EPROTONOSUPPORT;
+ return -1;
+}
+
+int pico_socket_mcast_filter(struct pico_socket *s, union pico_address *mcast_group, union pico_address *src)
+{
+ pico_err = PICO_ERR_EPROTONOSUPPORT;
+ return -1;
+}
+
+void pico_multicast_delete(struct pico_socket *s)
+{
+ (void)s;
+}
+
+int pico_getsockopt_mcast(struct pico_socket *s, int option, void *value)
+{
+ (void)s;
+ (void)option;
+ (void)value;
+ pico_err = PICO_ERR_EPROTONOSUPPORT;
+ return -1;
+}
+
+int pico_setsockopt_mcast(struct pico_socket *s, int option, void *value)
+{
+ (void)s;
+ (void)option;
+ (void)value;
+ pico_err = PICO_ERR_EPROTONOSUPPORT;
+ return -1;
+
+}
+#endif /* PICO_SUPPORT_MCAST */
+
diff --git a/net/picotcp/stack/pico_stack.c b/net/picotcp/stack/pico_stack.c
new file mode 100644
index 0000000..b4fcdd6
--- /dev/null
+++ b/net/picotcp/stack/pico_stack.c
@@ -0,0 +1,1157 @@
+/*********************************************************************
+ PicoTCP. Copyright (c) 2012-2015 Altran Intelligent Systems. Some rights reserved.
+ See LICENSE and COPYING for usage.
+
+ .
+
+ Authors: Daniele Lacamera
+ *********************************************************************/
+
+
+#include "pico_config.h"
+#include "pico_frame.h"
+#include "pico_device.h"
+#include "pico_protocol.h"
+#include "pico_stack.h"
+#include "pico_addressing.h"
+#include "pico_dns_client.h"
+
+#include "pico_olsr.h"
+#include "pico_aodv.h"
+#include "pico_eth.h"
+#include "pico_arp.h"
+#include "pico_ipv4.h"
+#include "pico_ipv6.h"
+#include "pico_icmp4.h"
+#include "pico_icmp6.h"
+#include "pico_igmp.h"
+#include "pico_udp.h"
+#include "pico_tcp.h"
+#include "pico_socket.h"
+#include "heap.h"
+
+#define IS_LIMITED_BCAST(f) (((struct pico_ipv4_hdr *) f->net_hdr)->dst.addr == PICO_IP4_BCAST)
+
+const uint8_t PICO_ETHADDR_ALL[6] = {
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
+};
+
+# define PICO_SIZE_MCAST 3
+const uint8_t PICO_ETHADDR_MCAST[6] = {
+ 0x01, 0x00, 0x5e, 0x00, 0x00, 0x00
+};
+
+#ifdef PICO_SUPPORT_IPV6
+# define PICO_SIZE_MCAST6 2
+const uint8_t PICO_ETHADDR_MCAST6[6] = {
+ 0x33, 0x33, 0x00, 0x00, 0x00, 0x00
+};
+#endif
+
+
+volatile pico_time pico_tick;
+volatile pico_err_t pico_err;
+
+static uint32_t _rand_seed;
+
+void WEAK pico_rand_feed(uint32_t feed)
+{
+ if (!feed)
+ return;
+
+ _rand_seed *= 1664525;
+ _rand_seed += 1013904223;
+ _rand_seed ^= ~(feed);
+}
+
+uint32_t WEAK pico_rand(void)
+{
+ pico_rand_feed((uint32_t)pico_tick);
+ return _rand_seed;
+}
+
+void pico_to_lowercase(char *str)
+{
+ int i = 0;
+ if (!str)
+ return;
+
+ while(str[i]) {
+ if ((str[i] <= 'Z') && (str[i] >= 'A'))
+ str[i] = (char) (str[i] - (char)('A' - 'a'));
+
+ i++;
+ }
+}
+
+/* NOTIFICATIONS: distributed notifications for stack internal errors.
+ */
+
+int pico_notify_socket_unreachable(struct pico_frame *f)
+{
+ if (0) {}
+
+#ifdef PICO_SUPPORT_ICMP4
+ else if (IS_IPV4(f)) {
+ pico_icmp4_port_unreachable(f);
+ }
+#endif
+#ifdef PICO_SUPPORT_ICMP6
+ else if (IS_IPV6(f)) {
+ pico_icmp6_port_unreachable(f);
+ }
+#endif
+
+ return 0;
+}
+
+int pico_notify_proto_unreachable(struct pico_frame *f)
+{
+ if (0) {}
+
+#ifdef PICO_SUPPORT_ICMP4
+ else if (IS_IPV4(f)) {
+ pico_icmp4_proto_unreachable(f);
+ }
+#endif
+#ifdef PICO_SUPPORT_ICMP6
+ else if (IS_IPV6(f)) {
+ pico_icmp6_proto_unreachable(f);
+ }
+#endif
+ return 0;
+}
+
+int pico_notify_dest_unreachable(struct pico_frame *f)
+{
+ if (0) {}
+
+#ifdef PICO_SUPPORT_ICMP4
+ else if (IS_IPV4(f)) {
+ pico_icmp4_dest_unreachable(f);
+ }
+#endif
+#ifdef PICO_SUPPORT_ICMP6
+ else if (IS_IPV6(f)) {
+ pico_icmp6_dest_unreachable(f);
+ }
+#endif
+ return 0;
+}
+
+int pico_notify_ttl_expired(struct pico_frame *f)
+{
+ if (0) {}
+
+#ifdef PICO_SUPPORT_ICMP4
+ else if (IS_IPV4(f)) {
+ pico_icmp4_ttl_expired(f);
+ }
+#endif
+#ifdef PICO_SUPPORT_ICMP6
+ else if (IS_IPV6(f)) {
+ pico_icmp6_ttl_expired(f);
+ }
+#endif
+ return 0;
+}
+
+int pico_notify_frag_expired(struct pico_frame *f)
+{
+ if (0) {}
+
+#ifdef PICO_SUPPORT_ICMP4
+ else if (IS_IPV4(f)) {
+ pico_icmp4_frag_expired(f);
+ }
+#endif
+#ifdef PICO_SUPPORT_ICMP6
+ else if (IS_IPV6(f)) {
+ pico_icmp6_frag_expired(f);
+ }
+#endif
+ return 0;
+}
+
+int pico_notify_pkt_too_big(struct pico_frame *f)
+{
+ if (0) {}
+
+#ifdef PICO_SUPPORT_ICMP4
+ else if (IS_IPV4(f)) {
+ pico_icmp4_mtu_exceeded(f);
+ }
+#endif
+#ifdef PICO_SUPPORT_ICMP6
+ else if (IS_IPV6(f)) {
+ pico_icmp6_pkt_too_big(f);
+ }
+#endif
+ return 0;
+}
+
+
+/* Transport layer */
+MOCKABLE int32_t pico_transport_receive(struct pico_frame *f, uint8_t proto)
+{
+ int32_t ret = -1;
+ switch (proto) {
+
+#ifdef PICO_SUPPORT_ICMP4
+ case PICO_PROTO_ICMP4:
+ ret = pico_enqueue(pico_proto_icmp4.q_in, f);
+ break;
+#endif
+
+#ifdef PICO_SUPPORT_ICMP6
+ case PICO_PROTO_ICMP6:
+ ret = pico_enqueue(pico_proto_icmp6.q_in, f);
+ break;
+#endif
+
+
+#ifdef PICO_SUPPORT_IGMP
+ case PICO_PROTO_IGMP:
+ ret = pico_enqueue(pico_proto_igmp.q_in, f);
+ break;
+#endif
+
+#ifdef PICO_SUPPORT_UDP
+ case PICO_PROTO_UDP:
+ ret = pico_enqueue(pico_proto_udp.q_in, f);
+ break;
+#endif
+
+#ifdef PICO_SUPPORT_TCP
+ case PICO_PROTO_TCP:
+ ret = pico_enqueue(pico_proto_tcp.q_in, f);
+ break;
+#endif
+
+ default:
+ /* Protocol not available */
+ dbg("pkt: no such protocol (%d)\n", proto);
+ pico_notify_proto_unreachable(f);
+ pico_frame_discard(f);
+ ret = -1;
+ }
+ return ret;
+}
+
+int32_t pico_network_receive(struct pico_frame *f)
+{
+ if (0) {}
+
+#ifdef PICO_SUPPORT_IPV4
+ else if (IS_IPV4(f)) {
+ pico_enqueue(pico_proto_ipv4.q_in, f);
+ }
+#endif
+#ifdef PICO_SUPPORT_IPV6
+ else if (IS_IPV6(f)) {
+ pico_enqueue(pico_proto_ipv6.q_in, f);
+ }
+#endif
+ else {
+ dbg("Network not found.\n");
+ pico_frame_discard(f);
+ return -1;
+ }
+ return (int32_t)f->buffer_len;
+}
+
+/* Network layer: interface towards socket for frame sending */
+int32_t pico_network_send(struct pico_frame *f)
+{
+ if (!f || !f->sock || !f->sock->net) {
+ pico_frame_discard(f);
+ return -1;
+ }
+
+ return f->sock->net->push(f->sock->net, f);
+}
+
+int pico_source_is_local(struct pico_frame *f)
+{
+ if (0) { }
+
+#ifdef PICO_SUPPORT_IPV4
+ else if (IS_IPV4(f)) {
+ struct pico_ipv4_hdr *hdr = (struct pico_ipv4_hdr *)f->net_hdr;
+ if (hdr->src.addr == PICO_IPV4_INADDR_ANY)
+ return 1;
+
+ if (pico_ipv4_link_find(&hdr->src))
+ return 1;
+ }
+#endif
+#ifdef PICO_SUPPORT_IPV6
+ else if (IS_IPV6(f)) {
+ struct pico_ipv6_hdr *hdr = (struct pico_ipv6_hdr *)f->net_hdr;
+ if (pico_ipv6_is_unspecified(hdr->src.addr) || pico_ipv6_link_find(&hdr->src))
+ return 1;
+ }
+#endif
+ return 0;
+}
+
+#ifdef PICO_SUPPORT_ETH
+/* DATALINK LEVEL: interface from network to the device
+ * and vice versa.
+ */
+
+/* The pico_ethernet_receive() function is used by
+ * those devices supporting ETH in order to push packets up
+ * into the stack.
+ */
+
+static int destination_is_bcast(struct pico_frame *f)
+{
+ if (!f)
+ return 0;
+
+ if (IS_IPV6(f))
+ return 0;
+
+#ifdef PICO_SUPPORT_IPV4
+ else {
+ struct pico_ipv4_hdr *hdr = (struct pico_ipv4_hdr *) f->net_hdr;
+ return pico_ipv4_is_broadcast(hdr->dst.addr);
+ }
+#else
+ return 0;
+#endif
+}
+
+static int destination_is_mcast(struct pico_frame *f)
+{
+ int ret = 0;
+ if (!f)
+ return 0;
+
+#ifdef PICO_SUPPORT_IPV6
+ if (IS_IPV6(f)) {
+ struct pico_ipv6_hdr *hdr = (struct pico_ipv6_hdr *) f->net_hdr;
+ ret = pico_ipv6_is_multicast(hdr->dst.addr);
+ }
+
+#endif
+#ifdef PICO_SUPPORT_IPV4
+ else {
+ struct pico_ipv4_hdr *hdr = (struct pico_ipv4_hdr *) f->net_hdr;
+ ret = pico_ipv4_is_multicast(hdr->dst.addr);
+ }
+#endif
+
+ return ret;
+}
+
+#ifdef PICO_SUPPORT_IPV4
+static int32_t pico_ipv4_ethernet_receive(struct pico_frame *f)
+{
+ if (IS_IPV4(f)) {
+ pico_enqueue(pico_proto_ipv4.q_in, f);
+ } else {
+ (void)pico_icmp4_param_problem(f, 0);
+ pico_frame_discard(f);
+ return -1;
+ }
+
+ return (int32_t)f->buffer_len;
+}
+#endif
+
+#ifdef PICO_SUPPORT_IPV6
+static int32_t pico_ipv6_ethernet_receive(struct pico_frame *f)
+{
+ if (IS_IPV6(f)) {
+ pico_enqueue(pico_proto_ipv6.q_in, f);
+ } else {
+ /* Wrong version for link layer type */
+ pico_frame_discard(f);
+ return -1;
+ }
+
+ return (int32_t)f->buffer_len;
+}
+#endif
+
+static int32_t pico_ll_receive(struct pico_frame *f)
+{
+ struct pico_eth_hdr *hdr = (struct pico_eth_hdr *) f->datalink_hdr;
+ f->net_hdr = f->datalink_hdr + sizeof(struct pico_eth_hdr);
+
+#if (defined PICO_SUPPORT_IPV4) && (defined PICO_SUPPORT_ETH)
+ if (hdr->proto == PICO_IDETH_ARP)
+ return pico_arp_receive(f);
+
+#endif
+
+#if defined (PICO_SUPPORT_IPV4)
+ if (hdr->proto == PICO_IDETH_IPV4)
+ return pico_ipv4_ethernet_receive(f);
+
+#endif
+
+#if defined (PICO_SUPPORT_IPV6)
+ if (hdr->proto == PICO_IDETH_IPV6)
+ return pico_ipv6_ethernet_receive(f);
+
+#endif
+
+ pico_frame_discard(f);
+ return -1;
+}
+
+static void pico_ll_check_bcast(struct pico_frame *f)
+{
+ struct pico_eth_hdr *hdr = (struct pico_eth_hdr *) f->datalink_hdr;
+ /* Indicate a link layer broadcast packet */
+ if (memcmp(hdr->daddr, PICO_ETHADDR_ALL, PICO_SIZE_ETH) == 0)
+ f->flags |= PICO_FRAME_FLAG_BCAST;
+}
+
+int32_t pico_ethernet_receive(struct pico_frame *f)
+{
+ struct pico_eth_hdr *hdr;
+ if (!f || !f->dev || !f->datalink_hdr)
+ {
+ pico_frame_discard(f);
+ return -1;
+ }
+
+ hdr = (struct pico_eth_hdr *) f->datalink_hdr;
+ if ((memcmp(hdr->daddr, f->dev->eth->mac.addr, PICO_SIZE_ETH) != 0) &&
+ (memcmp(hdr->daddr, PICO_ETHADDR_MCAST, PICO_SIZE_MCAST) != 0) &&
+#ifdef PICO_SUPPORT_IPV6
+ (memcmp(hdr->daddr, PICO_ETHADDR_MCAST6, PICO_SIZE_MCAST6) != 0) &&
+#endif
+ (memcmp(hdr->daddr, PICO_ETHADDR_ALL, PICO_SIZE_ETH) != 0))
+ {
+ pico_frame_discard(f);
+ return -1;
+ }
+
+ pico_ll_check_bcast(f);
+ return pico_ll_receive(f);
+}
+
+static struct pico_eth *pico_ethernet_mcast_translate(struct pico_frame *f, uint8_t *pico_mcast_mac)
+{
+ struct pico_ipv4_hdr *hdr = (struct pico_ipv4_hdr *) f->net_hdr;
+
+ /* place 23 lower bits of IP in lower 23 bits of MAC */
+ pico_mcast_mac[5] = (long_be(hdr->dst.addr) & 0x000000FFu);
+ pico_mcast_mac[4] = (uint8_t)((long_be(hdr->dst.addr) & 0x0000FF00u) >> 8u);
+ pico_mcast_mac[3] = (uint8_t)((long_be(hdr->dst.addr) & 0x007F0000u) >> 16u);
+
+ return (struct pico_eth *)pico_mcast_mac;
+}
+
+
+#ifdef PICO_SUPPORT_IPV6
+static struct pico_eth *pico_ethernet_mcast6_translate(struct pico_frame *f, uint8_t *pico_mcast6_mac)
+{
+ struct pico_ipv6_hdr *hdr = (struct pico_ipv6_hdr *)f->net_hdr;
+
+ /* first 2 octets are 0x33, last four are the last four of dst */
+ pico_mcast6_mac[5] = hdr->dst.addr[PICO_SIZE_IP6 - 1];
+ pico_mcast6_mac[4] = hdr->dst.addr[PICO_SIZE_IP6 - 2];
+ pico_mcast6_mac[3] = hdr->dst.addr[PICO_SIZE_IP6 - 3];
+ pico_mcast6_mac[2] = hdr->dst.addr[PICO_SIZE_IP6 - 4];
+
+ return (struct pico_eth *)pico_mcast6_mac;
+}
+#endif
+
+static int pico_ethernet_ipv6_dst(struct pico_frame *f, struct pico_eth *const dstmac)
+{
+ int retval = -1;
+ if (!dstmac)
+ return -1;
+
+ #ifdef PICO_SUPPORT_IPV6
+ if (destination_is_mcast(f)) {
+ uint8_t pico_mcast6_mac[6] = {
+ 0x33, 0x33, 0x00, 0x00, 0x00, 0x00
+ };
+ pico_ethernet_mcast6_translate(f, pico_mcast6_mac);
+ memcpy(dstmac, pico_mcast6_mac, PICO_SIZE_ETH);
+ retval = 0;
+ } else {
+ struct pico_eth *neighbor = pico_ipv6_get_neighbor(f);
+ if (neighbor)
+ {
+ memcpy(dstmac, neighbor, PICO_SIZE_ETH);
+ retval = 0;
+ }
+ }
+
+ #else
+ (void)f;
+ pico_err = PICO_ERR_EPROTONOSUPPORT;
+ #endif
+ return retval;
+}
+
+
+/* Ethernet send, first attempt: try our own address.
+ * Returns 0 if the packet is not for us.
+ * Returns 1 if the packet is cloned to our own receive queue, so the caller can discard the original frame.
+ * */
+static int32_t pico_ethsend_local(struct pico_frame *f, struct pico_eth_hdr *hdr)
+{
+ if (!hdr)
+ return 0;
+
+ /* Check own mac */
+ if(!memcmp(hdr->daddr, hdr->saddr, PICO_SIZE_ETH)) {
+ struct pico_frame *clone = pico_frame_copy(f);
+ dbg("sending out packet destined for our own mac\n");
+ (void)pico_ethernet_receive(clone);
+ return 1;
+ }
+
+ return 0;
+}
+
+/* Ethernet send, second attempt: try bcast.
+ * Returns 0 if the packet is not bcast, so it will be handled somewhere else.
+ * Returns 1 if the packet is handled by the pico_device_broadcast() function, so it can be discarded.
+ * */
+static int32_t pico_ethsend_bcast(struct pico_frame *f)
+{
+ if (IS_LIMITED_BCAST(f)) {
+ (void)pico_device_broadcast(f); /* We can discard broadcast even if it's not sent. */
+ return 1;
+ }
+
+ return 0;
+}
+
+/* Ethernet send, third attempt: try unicast.
+ * If the device driver is busy, we return 0, so the stack won't discard the frame.
+ * In case of success, we can safely return 1.
+ */
+static int32_t pico_ethsend_dispatch(struct pico_frame *f)
+{
+ int ret = f->dev->send(f->dev, f->start, (int) f->len);
+ if (ret <= 0)
+ return 0; /* Failure to deliver! */
+ else {
+ return 1; /* Frame is in flight by now. */
+ }
+}
+
+
+
+
+/* This function looks for the destination mac address
+ * in order to send the frame being processed.
+ */
+
+int32_t MOCKABLE pico_ethernet_send(struct pico_frame *f)
+{
+ struct pico_eth dstmac;
+ uint8_t dstmac_valid = 0;
+ uint16_t proto = PICO_IDETH_IPV4;
+
+#ifdef PICO_SUPPORT_IPV6
+ /* Step 1: If the frame has an IPv6 packet,
+ * destination address is taken from the ND tables
+ */
+ if (IS_IPV6(f)) {
+ if (pico_ethernet_ipv6_dst(f, &dstmac) < 0)
+ {
+ pico_ipv6_nd_postpone(f);
+ return 0; /* I don't care if frame was actually postponed. If there is no room in the ND table, discard safely. */
+ }
+
+ dstmac_valid = 1;
+ proto = PICO_IDETH_IPV6;
+ }
+ else
+#endif
+
+ /* In case of broadcast (IPV4 only), dst mac is FF:FF:... */
+ if (IS_BCAST(f) || destination_is_bcast(f))
+ {
+ memcpy(&dstmac, PICO_ETHADDR_ALL, PICO_SIZE_ETH);
+ dstmac_valid = 1;
+ }
+
+ /* In case of multicast, dst mac is translated from the group address */
+ else if (destination_is_mcast(f)) {
+ uint8_t pico_mcast_mac[6] = {
+ 0x01, 0x00, 0x5e, 0x00, 0x00, 0x00
+ };
+ pico_ethernet_mcast_translate(f, pico_mcast_mac);
+ memcpy(&dstmac, pico_mcast_mac, PICO_SIZE_ETH);
+ dstmac_valid = 1;
+ }
+
+#if (defined PICO_SUPPORT_IPV4)
+ else {
+ struct pico_eth *arp_get;
+ arp_get = pico_arp_get(f);
+ if (arp_get) {
+ memcpy(&dstmac, arp_get, PICO_SIZE_ETH);
+ dstmac_valid = 1;
+ } else {
+ /* At this point, ARP will discard the frame in any case.
+ * It is safe to return without discarding.
+ */
+ pico_arp_postpone(f);
+ return 0;
+ /* Same case as for IPv6 ... */
+ }
+
+ }
+#endif
+
+ /* This sets destination and source address, then pushes the packet to the device. */
+ if (dstmac_valid) {
+ struct pico_eth_hdr *hdr;
+ hdr = (struct pico_eth_hdr *) f->datalink_hdr;
+ if ((f->start > f->buffer) && ((f->start - f->buffer) >= PICO_SIZE_ETHHDR))
+ {
+ f->start -= PICO_SIZE_ETHHDR;
+ f->len += PICO_SIZE_ETHHDR;
+ f->datalink_hdr = f->start;
+ hdr = (struct pico_eth_hdr *) f->datalink_hdr;
+ memcpy(hdr->saddr, f->dev->eth->mac.addr, PICO_SIZE_ETH);
+ memcpy(hdr->daddr, &dstmac, PICO_SIZE_ETH);
+ hdr->proto = proto;
+ }
+
+ if (pico_ethsend_local(f, hdr) || pico_ethsend_bcast(f) || pico_ethsend_dispatch(f)) {
+ /* one of the above functions has delivered the frame accordingly. (returned != 0)
+ * It is safe to directly return success.
+ * */
+ return 0;
+ }
+ }
+
+ /* Failure: do not dequeue the frame, keep it for later. */
+ return -1;
+}
+
+#endif /* PICO_SUPPORT_ETH */
+
+
+void pico_store_network_origin(void *src, struct pico_frame *f)
+{
+ #ifdef PICO_SUPPORT_IPV4
+ struct pico_ip4 *ip4;
+ #endif
+
+ #ifdef PICO_SUPPORT_IPV6
+ struct pico_ip6 *ip6;
+ #endif
+
+ #ifdef PICO_SUPPORT_IPV4
+ if (IS_IPV4(f)) {
+ struct pico_ipv4_hdr *hdr;
+ hdr = (struct pico_ipv4_hdr *) f->net_hdr;
+ ip4 = (struct pico_ip4 *) src;
+ ip4->addr = hdr->src.addr;
+ }
+
+ #endif
+ #ifdef PICO_SUPPORT_IPV6
+ if (IS_IPV6(f)) {
+ struct pico_ipv6_hdr *hdr;
+ hdr = (struct pico_ipv6_hdr *) f->net_hdr;
+ ip6 = (struct pico_ip6 *) src;
+ memcpy(ip6->addr, hdr->src.addr, PICO_SIZE_IP6);
+ }
+
+ #endif
+}
+
+int pico_address_compare(union pico_address *a, union pico_address *b, uint16_t proto)
+{
+ #ifdef PICO_SUPPORT_IPV6
+ if (proto == PICO_PROTO_IPV6) {
+ return pico_ipv6_compare(&a->ip6, &b->ip6);
+ }
+
+ #endif
+ #ifdef PICO_SUPPORT_IPV4
+ if (proto == PICO_PROTO_IPV4) {
+ return pico_ipv4_compare(&a->ip4, &b->ip4);
+ }
+
+ #endif
+ return 0;
+
+}
+
+int pico_frame_dst_is_unicast(struct pico_frame *f)
+{
+ if (0) {
+ return 0;
+ }
+
+#ifdef PICO_SUPPORT_IPV4
+ if (IS_IPV4(f)) {
+ struct pico_ipv4_hdr *hdr = (struct pico_ipv4_hdr *)f->net_hdr;
+ if (pico_ipv4_is_multicast(hdr->dst.addr) || pico_ipv4_is_broadcast(hdr->dst.addr))
+ return 0;
+
+ return 1;
+ }
+
+#endif
+
+#ifdef PICO_SUPPORT_IPV6
+ if (IS_IPV6(f)) {
+ struct pico_ipv6_hdr *hdr = (struct pico_ipv6_hdr *)f->net_hdr;
+ if (pico_ipv6_is_multicast(hdr->dst.addr) || pico_ipv6_is_unspecified(hdr->dst.addr))
+ return 0;
+
+ return 1;
+ }
+
+#endif
+ else return 0;
+}
+
+
+/* LOWEST LEVEL: interface towards devices. */
+/* Device driver will call this function which returns immediately.
+ * Incoming packet will be processed later on in the dev loop.
+ */
+int32_t pico_stack_recv(struct pico_device *dev, uint8_t *buffer, uint32_t len)
+{
+ struct pico_frame *f;
+ int32_t ret;
+ if (len <= 0)
+ return -1;
+
+ f = pico_frame_alloc(len);
+ if (!f)
+ {
+ dbg("Cannot alloc incoming frame!\n");
+ return -1;
+ }
+
+ /* Association to the device that just received the frame. */
+ f->dev = dev;
+
+ /* Setup the start pointer, length. */
+ f->start = f->buffer;
+ f->len = f->buffer_len;
+ if (f->len > 8) {
+ uint32_t rand, mid_frame = (f->buffer_len >> 2) << 1;
+ mid_frame -= (mid_frame % 4);
+ memcpy(&rand, f->buffer + mid_frame, sizeof(uint32_t));
+ pico_rand_feed(rand);
+ }
+
+ memcpy(f->buffer, buffer, len);
+ ret = pico_enqueue(dev->q_in, f);
+ if (ret <= 0) {
+ pico_frame_discard(f);
+ }
+
+ return ret;
+}
+
+static int32_t _pico_stack_recv_zerocopy(struct pico_device *dev, uint8_t *buffer, uint32_t len, int ext_buffer, void (*notify_free)(uint8_t *))
+{
+ struct pico_frame *f;
+ int ret;
+ if (len <= 0)
+ return -1;
+
+ f = pico_frame_alloc_skeleton(len, ext_buffer);
+ if (!f)
+ {
+ dbg("Cannot alloc incoming frame!\n");
+ return -1;
+ }
+
+ if (pico_frame_skeleton_set_buffer(f, buffer) < 0)
+ {
+ dbg("Invalid zero-copy buffer!\n");
+ PICO_FREE(f->usage_count);
+ PICO_FREE(f);
+ return -1;
+ }
+
+ if (notify_free) {
+ f->notify_free = notify_free;
+ }
+
+ f->dev = dev;
+ ret = pico_enqueue(dev->q_in, f);
+ if (ret <= 0) {
+ pico_frame_discard(f);
+ }
+
+ return ret;
+}
+
+int32_t pico_stack_recv_zerocopy(struct pico_device *dev, uint8_t *buffer, uint32_t len)
+{
+ return _pico_stack_recv_zerocopy(dev, buffer, len, 0, NULL);
+}
+
+int32_t pico_stack_recv_zerocopy_ext_buffer(struct pico_device *dev, uint8_t *buffer, uint32_t len)
+{
+ return _pico_stack_recv_zerocopy(dev, buffer, len, 1, NULL);
+}
+
+int32_t pico_stack_recv_zerocopy_ext_buffer_notify(struct pico_device *dev, uint8_t *buffer, uint32_t len, void (*notify_free)(uint8_t *buffer))
+{
+ return _pico_stack_recv_zerocopy(dev, buffer, len, 1, notify_free);
+}
+
+int32_t pico_sendto_dev(struct pico_frame *f)
+{
+ if (!f->dev) {
+ pico_frame_discard(f);
+ return -1;
+ } else {
+ if (f->len > 8) {
+ uint32_t rand, mid_frame = (f->buffer_len >> 2) << 1;
+ mid_frame -= (mid_frame % 4);
+ memcpy(&rand, f->buffer + mid_frame, sizeof(uint32_t));
+ pico_rand_feed(rand);
+ }
+
+ return pico_enqueue(f->dev->q_out, f);
+ }
+}
+
+struct pico_timer
+{
+ void *arg;
+ void (*timer)(pico_time timestamp, void *arg);
+};
+
+struct pico_timer_ref
+{
+ pico_time expire;
+ struct pico_timer *tmr;
+};
+
+typedef struct pico_timer_ref pico_timer_ref;
+
+DECLARE_HEAP(pico_timer_ref, expire);
+
+static heap_pico_timer_ref *Timers;
+
+int32_t pico_seq_compare(uint32_t a, uint32_t b)
+{
+ uint32_t thresh = ((uint32_t)(-1)) >> 1;
+
+ if (a > b) /* return positive number, if not wrapped */
+ {
+ if ((a - b) > thresh) /* b wrapped */
+ return -(int32_t)(b - a); /* b = very small, a = very big */
+ else
+ return (int32_t)(a - b); /* a = biggest, b = a bit smaller */
+
+ }
+
+ if (a < b) /* return negative number, if not wrapped */
+ {
+ if ((b - a) > thresh) /* a wrapped */
+ return (int32_t)(a - b); /* a = very small, b = very big */
+ else
+ return -(int32_t)(b - a); /* b = biggest, a = a bit smaller */
+
+ }
+
+ return 0;
+}
+
+static void pico_check_timers(void)
+{
+ struct pico_timer *t;
+ struct pico_timer_ref tref_unused, *tref = heap_first(Timers);
+ pico_tick = PICO_TIME_MS();
+ while((tref) && (tref->expire < pico_tick)) {
+ t = tref->tmr;
+ if (t && t->timer)
+ t->timer(pico_tick, t->arg);
+
+ if (t)
+ {
+ PICO_FREE(t);
+ }
+
+ t = NULL;
+ heap_peek(Timers, &tref_unused);
+ tref = heap_first(Timers);
+ }
+}
+
+void MOCKABLE pico_timer_cancel(struct pico_timer *t)
+{
+ uint32_t i;
+ struct pico_timer_ref *tref = Timers->top;
+ if (!t)
+ return;
+
+ for (i = 1; i <= Timers->n; i++) {
+ if (tref[i].tmr == t) {
+ Timers->top[i].tmr = NULL;
+ PICO_FREE(t);
+ break;
+ }
+ }
+}
+
+#define PROTO_DEF_NR 11
+#define PROTO_DEF_AVG_NR 4
+#define PROTO_DEF_SCORE 32
+#define PROTO_MIN_SCORE 32
+#define PROTO_MAX_SCORE 128
+#define PROTO_LAT_IND 3 /* latency indication 0-3 (lower is better latency performance), x1, x2, x4, x8 */
+#define PROTO_MAX_LOOP (PROTO_MAX_SCORE << PROTO_LAT_IND) /* max global loop score, so per tick */
+
+static int calc_score(int *score, int *index, int avg[][PROTO_DEF_AVG_NR], int *ret)
+{
+ int temp, i, j, sum;
+ int max_total = PROTO_MAX_LOOP, total = 0;
+
+ /* dbg("USED SCORES> "); */
+
+ for (i = 0; i < PROTO_DEF_NR; i++) {
+
+ /* if used looped score */
+ if (ret[i] < score[i]) {
+ temp = score[i] - ret[i]; /* remaining loop score */
+
+ /* dbg("%3d - ",temp); */
+
+ if (index[i] >= PROTO_DEF_AVG_NR)
+ index[i] = 0; /* reset index */
+
+ j = index[i];
+ avg[i][j] = temp;
+
+ index[i]++;
+
+ if (ret[i] == 0 && ((score[i] * 2) <= PROTO_MAX_SCORE) && ((total + (score[i] * 2)) < max_total)) { /* used all loop score -> increase next score directly */
+ score[i] *= 2;
+ total += score[i];
+ continue;
+ }
+
+ sum = 0;
+ for (j = 0; j < PROTO_DEF_AVG_NR; j++)
+ sum += avg[i][j]; /* calculate sum */
+
+ sum /= 4; /* divide by 4 to get average used score */
+
+ /* criterion to increase next loop score */
+ if (sum > (score[i] - (score[i] / 4)) && ((score[i] * 2) <= PROTO_MAX_SCORE) && ((total + (score[i] / 2)) < max_total)) { /* > 3/4 */
+ score[i] *= 2; /* double loop score */
+ total += score[i];
+ continue;
+ }
+
+ /* criterion to decrease next loop score */
+ if ((sum < (score[i] / 4)) && ((score[i] / 2) >= PROTO_MIN_SCORE)) { /* < 1/4 */
+ score[i] /= 2; /* half loop score */
+ total += score[i];
+ continue;
+ }
+
+ /* also add non-changed scores */
+ total += score[i];
+ }
+ else if (ret[i] == score[i]) {
+ /* no used loop score - gradually decrease */
+
+ /* dbg("%3d - ",0); */
+
+ if (index[i] >= PROTO_DEF_AVG_NR)
+ index[i] = 0; /* reset index */
+
+ j = index[i];
+ avg[i][j] = 0;
+
+ index[i]++;
+
+ sum = 0;
+ for (j = 0; j < PROTO_DEF_AVG_NR; j++)
+ sum += avg[i][j]; /* calculate sum */
+
+ sum /= 2; /* divide by 4 to get average used score */
+
+ if ((sum == 0) && ((score[i] / 2) >= PROTO_MIN_SCORE)) {
+ score[i] /= 2; /* half loop score */
+ total += score[i];
+ for (j = 0; j < PROTO_DEF_AVG_NR; j++)
+ avg[i][j] = score[i];
+ }
+
+ }
+ }
+ /* dbg("\n"); */
+
+ return 0;
+}
+
+void pico_stack_tick(void)
+{
+ static int score[PROTO_DEF_NR] = {
+ PROTO_DEF_SCORE, PROTO_DEF_SCORE, PROTO_DEF_SCORE, PROTO_DEF_SCORE, PROTO_DEF_SCORE, PROTO_DEF_SCORE, PROTO_DEF_SCORE, PROTO_DEF_SCORE, PROTO_DEF_SCORE, PROTO_DEF_SCORE, PROTO_DEF_SCORE
+ };
+ static int index[PROTO_DEF_NR] = {
+ 0, 0, 0, 0, 0, 0
+ };
+ static int avg[PROTO_DEF_NR][PROTO_DEF_AVG_NR];
+ static int ret[PROTO_DEF_NR] = {
+ 0
+ };
+
+ pico_check_timers();
+
+ /* dbg("LOOP_SCORES> %3d - %3d - %3d - %3d - %3d - %3d - %3d - %3d - %3d - %3d - %3d\n",score[0],score[1],score[2],score[3],score[4],score[5],score[6],score[7],score[8],score[9],score[10]); */
+
+ /* score = pico_protocols_loop(100); */
+
+ ret[0] = pico_devices_loop(score[0], PICO_LOOP_DIR_IN);
+ pico_rand_feed((uint32_t)ret[0]);
+
+ ret[1] = pico_protocol_datalink_loop(score[1], PICO_LOOP_DIR_IN);
+ pico_rand_feed((uint32_t)ret[1]);
+
+ ret[2] = pico_protocol_network_loop(score[2], PICO_LOOP_DIR_IN);
+ pico_rand_feed((uint32_t)ret[2]);
+
+ ret[3] = pico_protocol_transport_loop(score[3], PICO_LOOP_DIR_IN);
+ pico_rand_feed((uint32_t)ret[3]);
+
+
+ ret[5] = score[5];
+#if defined (PICO_SUPPORT_IPV4) || defined (PICO_SUPPORT_IPV6)
+#if defined (PICO_SUPPORT_TCP) || defined (PICO_SUPPORT_UDP)
+ ret[5] = pico_sockets_loop(score[5]); /* swapped */
+ pico_rand_feed((uint32_t)ret[5]);
+#endif
+#endif
+
+ ret[4] = pico_protocol_socket_loop(score[4], PICO_LOOP_DIR_IN);
+ pico_rand_feed((uint32_t)ret[4]);
+
+
+ ret[6] = pico_protocol_socket_loop(score[6], PICO_LOOP_DIR_OUT);
+ pico_rand_feed((uint32_t)ret[6]);
+
+ ret[7] = pico_protocol_transport_loop(score[7], PICO_LOOP_DIR_OUT);
+ pico_rand_feed((uint32_t)ret[7]);
+
+ ret[8] = pico_protocol_network_loop(score[8], PICO_LOOP_DIR_OUT);
+ pico_rand_feed((uint32_t)ret[8]);
+
+ ret[9] = pico_protocol_datalink_loop(score[9], PICO_LOOP_DIR_OUT);
+ pico_rand_feed((uint32_t)ret[9]);
+
+ ret[10] = pico_devices_loop(score[10], PICO_LOOP_DIR_OUT);
+ pico_rand_feed((uint32_t)ret[10]);
+
+ /* calculate new loop scores for next iteration */
+ calc_score(score, index, (int (*)[])avg, ret);
+}
+
+void pico_stack_loop(void)
+{
+ while(1) {
+ pico_stack_tick();
+ PICO_IDLE();
+ }
+}
+
+MOCKABLE struct pico_timer *pico_timer_add(pico_time expire, void (*timer)(pico_time, void *), void *arg)
+{
+ struct pico_timer *t = PICO_ZALLOC(sizeof(struct pico_timer));
+ struct pico_timer_ref tref;
+ if (!t) {
+ pico_err = PICO_ERR_ENOMEM;
+ return NULL;
+ }
+
+ tref.expire = PICO_TIME_MS() + expire;
+ t->arg = arg;
+ t->timer = timer;
+ tref.tmr = t;
+ heap_insert(Timers, &tref);
+ if (Timers->n > PICO_MAX_TIMERS) {
+ dbg("Warning: I have %d timers\n", (int)Timers->n);
+ }
+
+ return t;
+}
+
+int pico_stack_init(void)
+{
+
+#ifdef PICO_SUPPORT_IPV4
+ pico_protocol_init(&pico_proto_ipv4);
+#endif
+
+#ifdef PICO_SUPPORT_IPV6
+ pico_protocol_init(&pico_proto_ipv6);
+#endif
+
+#ifdef PICO_SUPPORT_ICMP4
+ pico_protocol_init(&pico_proto_icmp4);
+#endif
+
+#ifdef PICO_SUPPORT_ICMP6
+ pico_protocol_init(&pico_proto_icmp6);
+#endif
+
+#ifdef PICO_SUPPORT_IGMP
+ pico_protocol_init(&pico_proto_igmp);
+#endif
+
+#ifdef PICO_SUPPORT_UDP
+ pico_protocol_init(&pico_proto_udp);
+#endif
+
+#ifdef PICO_SUPPORT_TCP
+ pico_protocol_init(&pico_proto_tcp);
+#endif
+
+#ifdef PICO_SUPPORT_DNS_CLIENT
+ pico_dns_client_init();
+#endif
+
+ pico_rand_feed(123456);
+
+ /* Initialize timer heap */
+ Timers = heap_init();
+ if (!Timers)
+ return -1;
+
+#if ((defined PICO_SUPPORT_IPV4) && (defined PICO_SUPPORT_ETH))
+ /* Initialize ARP module */
+ pico_arp_init();
+#endif
+
+#ifdef PICO_SUPPORT_IPV6
+ /* Initialize Neighbor discovery module */
+ pico_ipv6_nd_init();
+#endif
+
+#ifdef PICO_SUPPORT_OLSR
+ pico_olsr_init();
+#endif
+#ifdef PICO_SUPPORT_AODV
+ pico_aodv_init();
+#endif
+
+ pico_stack_tick();
+ pico_stack_tick();
+ pico_stack_tick();
+ return 0;
+}
+
diff --git a/net/picotcp/stack/pico_tree.c b/net/picotcp/stack/pico_tree.c
new file mode 100644
index 0000000..76eaf2f
--- /dev/null
+++ b/net/picotcp/stack/pico_tree.c
@@ -0,0 +1,575 @@
+/*********************************************************************
+ PicoTCP. Copyright (c) 2012-2015 Altran Intelligent Systems. Some rights reserved.
+ See LICENSE and COPYING for usage.
+
+ Author: Andrei Carp <andrei.carp at tass.be>
+ *********************************************************************/
+
+#include "pico_tree.h"
+#include "pico_config.h"
+#include "pico_protocol.h"
+#include "pico_mm.h"
+
+#define RED 0
+#define BLACK 1
+
+/* By default the null leafs are black */
+struct pico_tree_node LEAF = {
+ NULL, /* key */
+ &LEAF, &LEAF, &LEAF, /* parent, left,right */
+ BLACK, /* color */
+};
+
+#define IS_LEAF(x) (x == &LEAF)
+#define IS_NOT_LEAF(x) (x != &LEAF)
+#define INIT_LEAF (&LEAF)
+
+#define AM_I_LEFT_CHILD(x) (x == x->parent->leftChild)
+#define AM_I_RIGHT_CHILD(x) (x == x->parent->rightChild)
+
+#define PARENT(x) (x->parent)
+#define GRANPA(x) (x->parent->parent)
+
+/*
+ * Local Functions
+ */
+static struct pico_tree_node *create_node(struct pico_tree *tree, void *key, uint8_t allocator);
+static void rotateToLeft(struct pico_tree*tree, struct pico_tree_node*node);
+static void rotateToRight(struct pico_tree*root, struct pico_tree_node*node);
+static void fix_insert_collisions(struct pico_tree*tree, struct pico_tree_node*node);
+static void fix_delete_collisions(struct pico_tree*tree, struct pico_tree_node *node);
+static void switchNodes(struct pico_tree*tree, struct pico_tree_node*nodeA, struct pico_tree_node*nodeB);
+void *pico_tree_insert_implementation(struct pico_tree *tree, void *key, uint8_t allocator);
+void *pico_tree_delete_implementation(struct pico_tree *tree, void *key, uint8_t allocator);
+
+#ifdef PICO_SUPPORT_MM
+/* The memory manager also uses the pico_tree to keep track of all the different slab sizes it has.
+ * These nodes should be placed in the manager page which is in a different memory region then the nodes
+ * which are used for the pico stack in general.
+ * Therefore the following 2 functions are created so that pico_tree can use them to to put these nodes
+ * into the correct memory regions.
+ * If pico_tree_insert is called from the memory manager module, then create_node should use
+ * pico_mem_page0_zalloc to create a node. The same for pico_tree_delete.
+ */
+extern void*pico_mem_page0_zalloc(size_t len);
+extern void pico_mem_page0_free(void*ptr);
+#endif /* PICO_SUPPORT_MM */
+
+/*
+ * Exported functions
+ */
+
+struct pico_tree_node *pico_tree_firstNode(struct pico_tree_node *node)
+{
+ while(IS_NOT_LEAF(node->leftChild))
+ node = node->leftChild;
+ return node;
+}
+
+struct pico_tree_node *pico_tree_lastNode(struct pico_tree_node *node)
+{
+ while(IS_NOT_LEAF(node->rightChild))
+ node = node->rightChild;
+ return node;
+}
+
+struct pico_tree_node *pico_tree_next(struct pico_tree_node *node)
+{
+ if(IS_NOT_LEAF(node->rightChild))
+ {
+ node = node->rightChild;
+ while(IS_NOT_LEAF(node->leftChild))
+ node = node->leftChild;
+ }
+ else
+ {
+ if (IS_NOT_LEAF(node->parent) && AM_I_LEFT_CHILD(node))
+ node = node->parent;
+ else {
+ while (IS_NOT_LEAF(node->parent) && AM_I_RIGHT_CHILD(node))
+ node = node->parent;
+ node = node->parent;
+ }
+ }
+
+ return node;
+}
+
+struct pico_tree_node *pico_tree_prev(struct pico_tree_node *node)
+{
+ if (IS_NOT_LEAF(node->leftChild)) {
+ node = node->leftChild;
+ while (IS_NOT_LEAF(node->rightChild))
+ node = node->rightChild;
+ } else {
+ if (IS_NOT_LEAF(node->parent) && AM_I_RIGHT_CHILD(node))
+ node = node->parent;
+ else {
+ while (IS_NOT_LEAF(node) && AM_I_LEFT_CHILD(node))
+ node = node->parent;
+ node = node->parent;
+ }
+ }
+
+ return node;
+}
+
+/* The memory manager also uses the pico_tree to keep track of all the different slab sizes it has.
+ * These nodes should be placed in the manager page which is in a different memory region then the nodes
+ * which are used for the pico stack in general.
+ * Therefore the following wrapper for pico_tree_insert is created.
+ * The actual implementation can be found in pico_tree_insert_implementation.
+ */
+void *pico_tree_insert(struct pico_tree *tree, void *key)
+{
+ return pico_tree_insert_implementation(tree, key, USE_PICO_ZALLOC);
+}
+
+void *pico_tree_insert_implementation(struct pico_tree*tree, void *key, uint8_t allocator)
+{
+ struct pico_tree_node *last_node = INIT_LEAF;
+ struct pico_tree_node *temp = tree->root;
+ struct pico_tree_node *insert;
+ void *LocalKey;
+ int result = 0;
+
+ LocalKey = (IS_NOT_LEAF(tree->root) ? pico_tree_findKey(tree, key) : NULL);
+ /* if node already in, bail out */
+ if(LocalKey)
+ return LocalKey;
+ else
+ {
+ if(allocator == USE_PICO_PAGE0_ZALLOC)
+ insert = create_node(tree, key, USE_PICO_PAGE0_ZALLOC);
+ else
+ insert = create_node(tree, key, USE_PICO_ZALLOC);
+
+ if(!insert)
+ {
+ pico_err = PICO_ERR_ENOMEM;
+ /* to let the user know that it couldn't insert */
+ return (void *)&LEAF;
+ }
+ }
+
+ /* search for the place to insert the new node */
+ while(IS_NOT_LEAF(temp))
+ {
+ last_node = temp;
+ result = tree->compare(insert->keyValue, temp->keyValue);
+
+ temp = (result < 0) ? (temp->leftChild) : (temp->rightChild);
+ }
+ /* make the needed connections */
+ insert->parent = last_node;
+
+ if(IS_LEAF(last_node))
+ tree->root = insert;
+ else{
+ result = tree->compare(insert->keyValue, last_node->keyValue);
+ if(result < 0)
+ last_node->leftChild = insert;
+ else
+ last_node->rightChild = insert;
+ }
+
+ /* fix colour issues */
+ fix_insert_collisions(tree, insert);
+
+ return NULL;
+}
+
+struct pico_tree_node *pico_tree_findNode(struct pico_tree *tree, void *key)
+{
+ struct pico_tree_node *found;
+
+ found = tree->root;
+
+ while(IS_NOT_LEAF(found))
+ {
+ int result;
+ result = tree->compare(found->keyValue, key);
+ if(result == 0)
+ {
+ return found;
+ }
+ else if(result < 0)
+ found = found->rightChild;
+ else
+ found = found->leftChild;
+ }
+ return NULL;
+}
+
+void *pico_tree_findKey(struct pico_tree *tree, void *key)
+{
+ struct pico_tree_node *found;
+
+
+ found = tree->root;
+
+ while(IS_NOT_LEAF(found))
+ {
+ int result;
+
+ result = tree->compare(found->keyValue, key);
+ if(result == 0)
+ return found->keyValue;
+ else if(result < 0)
+ found = found->rightChild;
+ else
+ found = found->leftChild;
+
+ }
+ return NULL;
+}
+
+void *pico_tree_first(struct pico_tree *tree)
+{
+ return pico_tree_firstNode(tree->root)->keyValue;
+}
+
+void *pico_tree_last(struct pico_tree *tree)
+{
+ return pico_tree_lastNode(tree->root)->keyValue;
+}
+
+static uint8_t pico_tree_delete_node(struct pico_tree *tree, struct pico_tree_node *d, struct pico_tree_node **temp)
+{
+ struct pico_tree_node *min;
+ struct pico_tree_node *ltemp = d;
+ uint8_t nodeColor;
+ min = pico_tree_firstNode(d->rightChild);
+ nodeColor = min->color;
+
+ *temp = min->rightChild;
+ if(min->parent == ltemp && IS_NOT_LEAF(*temp))
+ (*temp)->parent = min;
+ else{
+ switchNodes(tree, min, min->rightChild);
+ min->rightChild = ltemp->rightChild;
+ if(IS_NOT_LEAF(min->rightChild)) min->rightChild->parent = min;
+ }
+
+ switchNodes(tree, ltemp, min);
+ min->leftChild = ltemp->leftChild;
+
+ if(IS_NOT_LEAF(min->leftChild))
+ min->leftChild->parent = min;
+
+ min->color = ltemp->color;
+ return nodeColor;
+}
+
+static uint8_t pico_tree_delete_check_switch(struct pico_tree *tree, struct pico_tree_node *delete, struct pico_tree_node **temp)
+{
+ struct pico_tree_node *ltemp = delete;
+ uint8_t nodeColor = delete->color;
+ if(IS_LEAF(delete->leftChild))
+ {
+ *temp = ltemp->rightChild;
+ switchNodes(tree, ltemp, ltemp->rightChild);
+ }
+ else
+ if(IS_LEAF(delete->rightChild))
+ {
+ struct pico_tree_node *_ltemp = delete;
+ *temp = _ltemp->leftChild;
+ switchNodes(tree, _ltemp, _ltemp->leftChild);
+ }
+ else{
+ nodeColor = pico_tree_delete_node(tree, delete, temp);
+ }
+
+ return nodeColor;
+
+}
+
+/* The memory manager also uses the pico_tree to keep track of all the different slab sizes it has.
+ * These nodes should be placed in the manager page which is in a different memory region then the nodes
+ * which are used for the pico stack in general.
+ * Therefore the following wrapper for pico_tree_delete is created.
+ * The actual implementation can be found in pico_tree_delete_implementation.
+ */
+void *pico_tree_delete(struct pico_tree *tree, void *key)
+{
+ return pico_tree_delete_implementation(tree, key, USE_PICO_ZALLOC);
+}
+
+static inline void if_nodecolor_black_fix_collisions(struct pico_tree *tree, struct pico_tree_node *temp, uint8_t nodeColor)
+{
+ /* deleted node is black, this will mess up the black path property */
+ if(nodeColor == BLACK)
+ fix_delete_collisions(tree, temp);
+
+}
+
+void *pico_tree_delete_implementation(struct pico_tree *tree, void *key, uint8_t allocator)
+{
+ struct pico_tree_node *temp;
+ uint8_t nodeColor; /* keeps the color of the node to be deleted */
+ void *lkey; /* keeps a copy of the key which will be removed */
+ struct pico_tree_node *delete; /* keeps a copy of the node to be extracted */
+
+ if (!key)
+ return NULL;
+
+ delete = pico_tree_findNode(tree, key);
+
+ /* this key isn't in the tree, bail out */
+ if(!delete)
+ return NULL;
+
+ lkey = delete->keyValue;
+ nodeColor = pico_tree_delete_check_switch(tree, delete, &temp);
+
+ if_nodecolor_black_fix_collisions(tree, temp, nodeColor);
+
+ if(allocator == USE_PICO_ZALLOC)
+ PICO_FREE(delete);
+
+#ifdef PICO_SUPPORT_MM
+ else
+ pico_mem_page0_free(delete);
+#endif
+ return lkey;
+}
+
+int pico_tree_empty(struct pico_tree *tree)
+{
+ return (!tree->root || IS_LEAF(tree->root));
+}
+
+/*
+ * Private functions
+ */
+static void rotateToLeft(struct pico_tree*tree, struct pico_tree_node*node)
+{
+ struct pico_tree_node*temp;
+
+ temp = node->rightChild;
+
+ if(temp == &LEAF) return;
+
+ node->rightChild = temp->leftChild;
+
+ if(IS_NOT_LEAF(temp->leftChild))
+ temp->leftChild->parent = node;
+
+ temp->parent = node->parent;
+
+ if(IS_LEAF(node->parent))
+ tree->root = temp;
+ else
+ if(node == node->parent->leftChild)
+ node->parent->leftChild = temp;
+ else
+ node->parent->rightChild = temp;
+
+ temp->leftChild = node;
+ node->parent = temp;
+}
+
+
+static void rotateToRight(struct pico_tree *tree, struct pico_tree_node *node)
+{
+ struct pico_tree_node*temp;
+
+ temp = node->leftChild;
+ node->leftChild = temp->rightChild;
+
+ if(temp == &LEAF) return;
+
+ if(IS_NOT_LEAF(temp->rightChild))
+ temp->rightChild->parent = node;
+
+ temp->parent = node->parent;
+
+ if(IS_LEAF(node->parent))
+ tree->root = temp;
+ else
+ if(node == node->parent->rightChild)
+ node->parent->rightChild = temp;
+ else
+ node->parent->leftChild = temp;
+
+ temp->rightChild = node;
+ node->parent = temp;
+ return;
+}
+
+static struct pico_tree_node *create_node(struct pico_tree *tree, void*key, uint8_t allocator)
+{
+ struct pico_tree_node *temp = NULL;
+ IGNORE_PARAMETER(tree);
+ if(allocator == USE_PICO_ZALLOC)
+ temp = (struct pico_tree_node *)PICO_ZALLOC(sizeof(struct pico_tree_node));
+
+#ifdef PICO_SUPPORT_MM
+ else
+ temp = (struct pico_tree_node *)pico_mem_page0_zalloc(sizeof(struct pico_tree_node));
+#endif
+
+ if(!temp)
+ return NULL;
+
+ temp->keyValue = key;
+ temp->parent = &LEAF;
+ temp->leftChild = &LEAF;
+ temp->rightChild = &LEAF;
+ /* by default every new node is red */
+ temp->color = RED;
+ return temp;
+}
+
+/*
+ * This function fixes the possible collisions in the tree.
+ * Eg. if a node is red his children must be black !
+ */
+static void fix_insert_collisions(struct pico_tree*tree, struct pico_tree_node*node)
+{
+ struct pico_tree_node*temp;
+
+ while(node->parent->color == RED && IS_NOT_LEAF(GRANPA(node)))
+ {
+ if(AM_I_RIGHT_CHILD(node->parent))
+ {
+ temp = GRANPA(node)->leftChild;
+ if(temp->color == RED) {
+ node->parent->color = BLACK;
+ temp->color = BLACK;
+ GRANPA(node)->color = RED;
+ node = GRANPA(node);
+ }
+ else if(temp->color == BLACK) {
+ if(node == node->parent->leftChild) {
+ node = node->parent;
+ rotateToRight(tree, node);
+ }
+
+ node->parent->color = BLACK;
+ GRANPA(node)->color = RED;
+ rotateToLeft(tree, GRANPA(node));
+ }
+ }
+ else if(AM_I_LEFT_CHILD(node->parent))
+ {
+ temp = GRANPA(node)->rightChild;
+ if(temp->color == RED) {
+ node->parent->color = BLACK;
+ temp->color = BLACK;
+ GRANPA(node)->color = RED;
+ node = GRANPA(node);
+ }
+ else if(temp->color == BLACK) {
+ if(AM_I_RIGHT_CHILD(node)) {
+ node = node->parent;
+ rotateToLeft(tree, node);
+ }
+
+ node->parent->color = BLACK;
+ GRANPA(node)->color = RED;
+ rotateToRight(tree, GRANPA(node));
+ }
+ }
+ }
+ /* make sure that the root of the tree stays black */
+ tree->root->color = BLACK;
+}
+
+static void switchNodes(struct pico_tree*tree, struct pico_tree_node*nodeA, struct pico_tree_node*nodeB)
+{
+
+ if(IS_LEAF(nodeA->parent))
+ tree->root = nodeB;
+ else
+ if(IS_NOT_LEAF(nodeA))
+ {
+ if(AM_I_LEFT_CHILD(nodeA))
+ nodeA->parent->leftChild = nodeB;
+ else
+ nodeA->parent->rightChild = nodeB;
+ }
+
+ if(IS_NOT_LEAF(nodeB)) nodeB->parent = nodeA->parent;
+
+}
+
+/*
+ * This function fixes the possible collisions in the tree.
+ * Eg. if a node is red his children must be black !
+ * In this case the function fixes the constant black path property.
+ */
+static void fix_delete_collisions(struct pico_tree*tree, struct pico_tree_node *node)
+{
+ struct pico_tree_node*temp;
+
+ while( node != tree->root && node->color == BLACK && IS_NOT_LEAF(node))
+ {
+ if(AM_I_LEFT_CHILD(node)) {
+
+ temp = node->parent->rightChild;
+ if(temp->color == RED)
+ {
+ temp->color = BLACK;
+ node->parent->color = RED;
+ rotateToLeft(tree, node->parent);
+ temp = node->parent->rightChild;
+ }
+
+ if(temp->leftChild->color == BLACK && temp->rightChild->color == BLACK)
+ {
+ temp->color = RED;
+ node = node->parent;
+ }
+ else
+ {
+ if(temp->rightChild->color == BLACK)
+ {
+ temp->leftChild->color = BLACK;
+ temp->color = RED;
+ rotateToRight(tree, temp);
+ temp = temp->parent->rightChild;
+ }
+
+ temp->color = node->parent->color;
+ node->parent->color = BLACK;
+ temp->rightChild->color = BLACK;
+ rotateToLeft(tree, node->parent);
+ node = tree->root;
+ }
+ }
+ else{
+ temp = node->parent->leftChild;
+ if(temp->color == RED)
+ {
+ temp->color = BLACK;
+ node->parent->color = RED;
+ rotateToRight(tree, node->parent);
+ temp = node->parent->leftChild;
+ }
+
+ if(temp->rightChild->color == BLACK && temp->leftChild->color == BLACK)
+ {
+ temp->color = RED;
+ node = node->parent;
+ }
+ else{
+ if(temp->leftChild->color == BLACK)
+ {
+ temp->rightChild->color = BLACK;
+ temp->color = RED;
+ rotateToLeft(tree, temp);
+ temp = temp->parent->leftChild;
+ }
+
+ temp->color = node->parent->color;
+ node->parent->color = BLACK;
+ temp->leftChild->color = BLACK;
+ rotateToRight(tree, node->parent);
+ node = tree->root;
+ }
+ }
+ }
+ node->color = BLACK;
+}
--
2.1.4
More information about the barebox
mailing list