Added liblwip.so and libintercept build files

ext/lwip/doc/FILES

@@ -1,6 +0,0 @@
-savannah.txt   - How to obtain the current development source code.
-contrib.txt    - How to contribute to lwIP as a developer.
-rawapi.txt     - The documentation for the core API of lwIP.
-                 Also provides an overview about the other APIs and multithreading.
-snmp_agent.txt - The documentation for the lwIP SNMP agent.
-sys_arch.txt   - The documentation for a system abstraction layer of lwIP.

ext/lwip/doc/contrib.txt

@@ -1,63 +0,0 @@
-1 Introduction
-
-This document describes some guidelines for people participating
-in lwIP development.
-
-2 How to contribute to lwIP
-
-Here is a short list of suggestions to anybody working with lwIP and 
-trying to contribute bug reports, fixes, enhancements, platform ports etc.
-First of all as you may already know lwIP is a volunteer project so feedback
-to fixes or questions might often come late. Hopefully the bug and patch tracking 
-features of Savannah help us not lose users' input.
-
-2.1 Source code style:
-
-1. do not use tabs.
-2. indentation is two spaces per level (i.e. per tab).
-3. end debug messages with a trailing newline (\n).
-4. one space between keyword and opening bracket.
-5. no space between function and opening bracket.
-6. one space and no newline before opening curly braces of a block.
-7. closing curly brace on a single line.
-8. spaces surrounding assignment and comparisons.
-9. don't initialize static and/or global variables to zero, the compiler takes care of that.
-10. use current source code style as further reference.
-
-2.2 Source code documentation style:
-
-1. JavaDoc compliant and Doxygen compatible.
-2. Function documentation above functions in .c files, not .h files.
-   (This forces you to synchronize documentation and implementation.)
-3. Use current documentation style as further reference.
- 
-2.3 Bug reports and patches:
-
-1. Make sure you are reporting bugs or send patches against the latest
-   sources. (From the latest release and/or the current CVS sources.)
-2. If you think you found a bug make sure it's not already filed in the
-   bugtracker at Savannah.
-3. If you have a fix put the patch on Savannah. If it is a patch that affects
-   both core and arch specific stuff please separate them so that the core can
-   be applied separately while leaving the other patch 'open'. The prefered way
-   is to NOT touch archs you can't test and let maintainers take care of them.
-   This is a good way to see if they are used at all - the same goes for unix
-   netifs except tapif.
-4. Do not file a bug and post a fix to it to the patch area. Either a bug report
-   or a patch will be enough.
-   If you correct an existing bug then attach the patch to the bug rather than creating a new entry in the patch area.
-5. Trivial patches (compiler warning, indentation and spelling fixes or anything obvious which takes a line or two)
-   can go to the lwip-users list. This is still the fastest way of interaction and the list is not so crowded
-   as to allow for loss of fixes. Putting bugs on Savannah and subsequently closing them is too much an overhead
-   for reporting a compiler warning fix.
-6. Patches should be specific to a single change or to related changes.Do not mix bugfixes with spelling and other
-   trivial fixes unless the bugfix is trivial too.Do not reorganize code and rename identifiers in the same patch you
-   change behaviour if not necessary.A patch is easier to read and understand if it's to the point and short than
-   if it's not to the point and long :) so the chances for it to be applied are greater. 
-
-2.4 Platform porters:
-
-1. If you have ported lwIP to a platform (an OS, a uC/processor or a combination of these) and
-   you think it could benefit others[1] you might want discuss this on the mailing list. You
-   can also ask for CVS access to submit and maintain your port in the contrib CVS module.
-   

ext/lwip/doc/rawapi.txt

@@ -1,511 +0,0 @@
-Raw TCP/IP interface for lwIP
-
-Authors: Adam Dunkels, Leon Woestenberg, Christiaan Simons
-
-lwIP provides three Application Program's Interfaces (APIs) for programs
-to use for communication with the TCP/IP code:
-* low-level "core" / "callback" or "raw" API.
-* higher-level "sequential" API.
-* BSD-style socket API.
-
-The sequential API provides a way for ordinary, sequential, programs
-to use the lwIP stack. It is quite similar to the BSD socket API. The
-model of execution is based on the blocking open-read-write-close
-paradigm. Since the TCP/IP stack is event based by nature, the TCP/IP
-code and the application program must reside in different execution
-contexts (threads).
-
-The socket API is a compatibility API for existing applications,
-currently it is built on top of the sequential API. It is meant to
-provide all functions needed to run socket API applications running
-on other platforms (e.g. unix / windows etc.). However, due to limitations
-in the specification of this API, there might be incompatibilities
-that require small modifications of existing programs.
-
-** Threading
-
-lwIP started targeting single-threaded environments. When adding multi-
-threading support, instead of making the core thread-safe, another
-approach was chosen: there is one main thread running the lwIP core
-(also known as the "tcpip_thread"). The raw API may only be used from
-this thread! Application threads using the sequential- or socket API
-communicate with this main thread through message passing.
-
-      As such, the list of functions that may be called from
-      other threads or an ISR is very limited! Only functions
-      from these API header files are thread-safe:
-      - api.h
-      - netbuf.h
-      - netdb.h
-      - netifapi.h
-      - sockets.h
-      - sys.h
-
-      Additionaly, memory (de-)allocation functions may be
-      called from multiple threads (not ISR!) with NO_SYS=0
-      since they are protected by SYS_LIGHTWEIGHT_PROT and/or
-      semaphores.
-
-      Only since 1.3.0, if SYS_LIGHTWEIGHT_PROT is set to 1
-      and LWIP_ALLOW_MEM_FREE_FROM_OTHER_CONTEXT is set to 1,
-      pbuf_free() may also be called from another thread or
-      an ISR (since only then, mem_free - for PBUF_RAM - may
-      be called from an ISR: otherwise, the HEAP is only
-      protected by semaphores).
-      
-
-** The remainder of this document discusses the "raw" API. **
-
-The raw TCP/IP interface allows the application program to integrate
-better with the TCP/IP code. Program execution is event based by
-having callback functions being called from within the TCP/IP
-code. The TCP/IP code and the application program both run in the same
-thread. The sequential API has a much higher overhead and is not very
-well suited for small systems since it forces a multithreaded paradigm
-on the application.
-
-The raw TCP/IP interface is not only faster in terms of code execution
-time but is also less memory intensive. The drawback is that program
-development is somewhat harder and application programs written for
-the raw TCP/IP interface are more difficult to understand. Still, this
-is the preferred way of writing applications that should be small in
-code size and memory usage.
-
-Both APIs can be used simultaneously by different application
-programs. In fact, the sequential API is implemented as an application
-program using the raw TCP/IP interface.
-
---- Callbacks
-
-Program execution is driven by callbacks. Each callback is an ordinary
-C function that is called from within the TCP/IP code. Every callback
-function is passed the current TCP or UDP connection state as an
-argument. Also, in order to be able to keep program specific state,
-the callback functions are called with a program specified argument
-that is independent of the TCP/IP state.
-
-The function for setting the application connection state is:
-
-- void tcp_arg(struct tcp_pcb *pcb, void *arg)
-
-  Specifies the program specific state that should be passed to all
-  other callback functions. The "pcb" argument is the current TCP
-  connection control block, and the "arg" argument is the argument
-  that will be passed to the callbacks.
-
-  
---- TCP connection setup
-
-The functions used for setting up connections is similar to that of
-the sequential API and of the BSD socket API. A new TCP connection
-identifier (i.e., a protocol control block - PCB) is created with the
-tcp_new() function. This PCB can then be either set to listen for new
-incoming connections or be explicitly connected to another host.
-
-- struct tcp_pcb *tcp_new(void)
-
-  Creates a new connection identifier (PCB). If memory is not
-  available for creating the new pcb, NULL is returned.
-
-- err_t tcp_bind(struct tcp_pcb *pcb, ip_addr_t *ipaddr,
-                 u16_t port)
-
-  Binds the pcb to a local IP address and port number. The IP address
-  can be specified as IP_ADDR_ANY in order to bind the connection to
-  all local IP addresses.
-
-  If another connection is bound to the same port, the function will
-  return ERR_USE, otherwise ERR_OK is returned.
-
-- struct tcp_pcb *tcp_listen(struct tcp_pcb *pcb)
-
-  Commands a pcb to start listening for incoming connections. When an
-  incoming connection is accepted, the function specified with the
-  tcp_accept() function will be called. The pcb will have to be bound
-  to a local port with the tcp_bind() function.
-
-  The tcp_listen() function returns a new connection identifier, and
-  the one passed as an argument to the function will be
-  deallocated. The reason for this behavior is that less memory is
-  needed for a connection that is listening, so tcp_listen() will
-  reclaim the memory needed for the original connection and allocate a
-  new smaller memory block for the listening connection.
-
-  tcp_listen() may return NULL if no memory was available for the
-  listening connection. If so, the memory associated with the pcb
-  passed as an argument to tcp_listen() will not be deallocated.
-
-- struct tcp_pcb *tcp_listen_with_backlog(struct tcp_pcb *pcb, u8_t backlog)
-
-  Same as tcp_listen, but limits the number of outstanding connections
-  in the listen queue to the value specified by the backlog argument.
-  To use it, your need to set TCP_LISTEN_BACKLOG=1 in your lwipopts.h.
-
-- void tcp_accepted(struct tcp_pcb *pcb)
-
-  Inform lwIP that an incoming connection has been accepted. This would
-  usually be called from the accept callback. This allows lwIP to perform
-  housekeeping tasks, such as allowing further incoming connections to be
-  queued in the listen backlog.
-  ATTENTION: the PCB passed in must be the listening pcb, not the pcb passed
-  into the accept callback!
-
-- void tcp_accept(struct tcp_pcb *pcb,
-                  err_t (* accept)(void *arg, struct tcp_pcb *newpcb,
-                                   err_t err))
-
-  Specified the callback function that should be called when a new
-  connection arrives on a listening connection.
-
-- err_t tcp_connect(struct tcp_pcb *pcb, ip_addr_t *ipaddr,
-                    u16_t port, err_t (* connected)(void *arg,
-                                                    struct tcp_pcb *tpcb,
-                                                    err_t err));
-
-  Sets up the pcb to connect to the remote host and sends the
-  initial SYN segment which opens the connection. 
-
-  The tcp_connect() function returns immediately; it does not wait for
-  the connection to be properly setup. Instead, it will call the
-  function specified as the fourth argument (the "connected" argument)
-  when the connection is established. If the connection could not be
-  properly established, either because the other host refused the
-  connection or because the other host didn't answer, the "err"
-  callback function of this pcb (registered with tcp_err, see below)
-  will be called.
-
-  The tcp_connect() function can return ERR_MEM if no memory is
-  available for enqueueing the SYN segment. If the SYN indeed was
-  enqueued successfully, the tcp_connect() function returns ERR_OK.
-
-
---- Sending TCP data
-
-TCP data is sent by enqueueing the data with a call to
-tcp_write(). When the data is successfully transmitted to the remote
-host, the application will be notified with a call to a specified
-callback function.
-
-- err_t tcp_write(struct tcp_pcb *pcb, const void *dataptr, u16_t len,
-                  u8_t apiflags)
-
-  Enqueues the data pointed to by the argument dataptr. The length of
-  the data is passed as the len parameter. The apiflags can be one or more of:
-  - TCP_WRITE_FLAG_COPY: indicates whether the new memory should be allocated
-    for the data to be copied into. If this flag is not given, no new memory
-    should be allocated and the data should only be referenced by pointer. This
-    also means that the memory behind dataptr must not change until the data is
-    ACKed by the remote host
-  - TCP_WRITE_FLAG_MORE: indicates that more data follows. If this is given,
-    the PSH flag is set in the last segment created by this call to tcp_write.
-    If this flag is given, the PSH flag is not set.
-
-  The tcp_write() function will fail and return ERR_MEM if the length
-  of the data exceeds the current send buffer size or if the length of
-  the queue of outgoing segment is larger than the upper limit defined
-  in lwipopts.h. The number of bytes available in the output queue can
-  be retrieved with the tcp_sndbuf() function.
-
-  The proper way to use this function is to call the function with at
-  most tcp_sndbuf() bytes of data. If the function returns ERR_MEM,
-  the application should wait until some of the currently enqueued
-  data has been successfully received by the other host and try again.
-
-- void tcp_sent(struct tcp_pcb *pcb,
-                err_t (* sent)(void *arg, struct tcp_pcb *tpcb,
-                u16_t len))
-
-  Specifies the callback function that should be called when data has
-  successfully been received (i.e., acknowledged) by the remote
-  host. The len argument passed to the callback function gives the
-  amount bytes that was acknowledged by the last acknowledgment.
-
-  
---- Receiving TCP data
-
-TCP data reception is callback based - an application specified
-callback function is called when new data arrives. When the
-application has taken the data, it has to call the tcp_recved()
-function to indicate that TCP can advertise increase the receive
-window.
-
-- void tcp_recv(struct tcp_pcb *pcb,
-                err_t (* recv)(void *arg, struct tcp_pcb *tpcb,
-                               struct pbuf *p, err_t err))
-
-  Sets the callback function that will be called when new data
-  arrives. The callback function will be passed a NULL pbuf to
-  indicate that the remote host has closed the connection. If
-  there are no errors and the callback function is to return
-  ERR_OK, then it must free the pbuf. Otherwise, it must not
-  free the pbuf so that lwIP core code can store it.
-
-- void tcp_recved(struct tcp_pcb *pcb, u16_t len)
-
-  Must be called when the application has received the data. The len
-  argument indicates the length of the received data.
-
-
---- Application polling
-
-When a connection is idle (i.e., no data is either transmitted or
-received), lwIP will repeatedly poll the application by calling a
-specified callback function. This can be used either as a watchdog
-timer for killing connections that have stayed idle for too long, or
-as a method of waiting for memory to become available. For instance,
-if a call to tcp_write() has failed because memory wasn't available,
-the application may use the polling functionality to call tcp_write()
-again when the connection has been idle for a while.
-
-- void tcp_poll(struct tcp_pcb *pcb, 
-                err_t (* poll)(void *arg, struct tcp_pcb *tpcb),
-                u8_t interval)
-
-  Specifies the polling interval and the callback function that should
-  be called to poll the application. The interval is specified in
-  number of TCP coarse grained timer shots, which typically occurs
-  twice a second. An interval of 10 means that the application would
-  be polled every 5 seconds.
-
-
---- Closing and aborting connections
-
-- err_t tcp_close(struct tcp_pcb *pcb)
-
-  Closes the connection. The function may return ERR_MEM if no memory
-  was available for closing the connection. If so, the application
-  should wait and try again either by using the acknowledgment
-  callback or the polling functionality. If the close succeeds, the
-  function returns ERR_OK.
-
-  The pcb is deallocated by the TCP code after a call to tcp_close(). 
-
-- void tcp_abort(struct tcp_pcb *pcb)
-
-  Aborts the connection by sending a RST (reset) segment to the remote
-  host. The pcb is deallocated. This function never fails.
-
-  ATTENTION: When calling this from one of the TCP callbacks, make
-  sure you always return ERR_ABRT (and never return ERR_ABRT otherwise
-  or you will risk accessing deallocated memory or memory leaks!
-
-
-If a connection is aborted because of an error, the application is
-alerted of this event by the err callback. Errors that might abort a
-connection are when there is a shortage of memory. The callback
-function to be called is set using the tcp_err() function.
-
-- void tcp_err(struct tcp_pcb *pcb, void (* err)(void *arg,
-       err_t err))
-
-  The error callback function does not get the pcb passed to it as a
-  parameter since the pcb may already have been deallocated.
-
-
---- Lower layer TCP interface
-
-TCP provides a simple interface to the lower layers of the
-system. During system initialization, the function tcp_init() has
-to be called before any other TCP function is called. When the system
-is running, the two timer functions tcp_fasttmr() and tcp_slowtmr()
-must be called with regular intervals. The tcp_fasttmr() should be
-called every TCP_FAST_INTERVAL milliseconds (defined in tcp.h) and
-tcp_slowtmr() should be called every TCP_SLOW_INTERVAL milliseconds. 
-
-
---- UDP interface
-
-The UDP interface is similar to that of TCP, but due to the lower
-level of complexity of UDP, the interface is significantly simpler.
-
-- struct udp_pcb *udp_new(void)
-
-  Creates a new UDP pcb which can be used for UDP communication. The
-  pcb is not active until it has either been bound to a local address
-  or connected to a remote address.
-
-- void udp_remove(struct udp_pcb *pcb)
-
-  Removes and deallocates the pcb.  
-  
-- err_t udp_bind(struct udp_pcb *pcb, ip_addr_t *ipaddr,
-                 u16_t port)
-
-  Binds the pcb to a local address. The IP-address argument "ipaddr"
-  can be IP_ADDR_ANY to indicate that it should listen to any local IP
-  address. The function currently always return ERR_OK.
-
-- err_t udp_connect(struct udp_pcb *pcb, ip_addr_t *ipaddr,
-                    u16_t port)
-
-  Sets the remote end of the pcb. This function does not generate any
-  network traffic, but only set the remote address of the pcb.
-
-- err_t udp_disconnect(struct udp_pcb *pcb)
-
-  Remove the remote end of the pcb. This function does not generate
-  any network traffic, but only removes the remote address of the pcb.
-
-- err_t udp_send(struct udp_pcb *pcb, struct pbuf *p)
-
-  Sends the pbuf p. The pbuf is not deallocated.
-
-- void udp_recv(struct udp_pcb *pcb,
-                void (* recv)(void *arg, struct udp_pcb *upcb,
-                                         struct pbuf *p,
-                                         ip_addr_t *addr,
-                                         u16_t port),
-                              void *recv_arg)
-
-  Specifies a callback function that should be called when a UDP
-  datagram is received.
-  
-
---- System initalization
-
-A truly complete and generic sequence for initializing the lwip stack
-cannot be given because it depends on the build configuration (lwipopts.h)
-and additional initializations for your runtime environment (e.g. timers).
-
-We can give you some idea on how to proceed when using the raw API.
-We assume a configuration using a single Ethernet netif and the
-UDP and TCP transport layers, IPv4 and the DHCP client.
-
-Call these functions in the order of appearance:
-
-- stats_init()
-
-  Clears the structure where runtime statistics are gathered.
-
-- sys_init()
-  
-  Not of much use since we set the NO_SYS 1 option in lwipopts.h,
-  to be called for easy configuration changes.
-
-- mem_init()
-
-  Initializes the dynamic memory heap defined by MEM_SIZE.
-
-- memp_init()
-
-  Initializes the memory pools defined by MEMP_NUM_x.
-
-- pbuf_init()
-
-  Initializes the pbuf memory pool defined by PBUF_POOL_SIZE.
-  
-- etharp_init()
-
-  Initializes the ARP table and queue.
-  Note: you must call etharp_tmr at a ARP_TMR_INTERVAL (5 seconds) regular interval
-  after this initialization.
-
-- ip_init()
-
-  Doesn't do much, it should be called to handle future changes.
-
-- udp_init()
-
-  Clears the UDP PCB list.
-
-- tcp_init()
-
-  Clears the TCP PCB list and clears some internal TCP timers.
-  Note: you must call tcp_fasttmr() and tcp_slowtmr() at the
-  predefined regular intervals after this initialization. 
-  
-- netif_add(struct netif *netif, ip_addr_t *ipaddr,
-            ip_addr_t *netmask, ip_addr_t *gw,
-            void *state, err_t (* init)(struct netif *netif),
-            err_t (* input)(struct pbuf *p, struct netif *netif))
-
-  Adds your network interface to the netif_list. Allocate a struct
-  netif and pass a pointer to this structure as the first argument.
-  Give pointers to cleared ip_addr structures when using DHCP,
-  or fill them with sane numbers otherwise. The state pointer may be NULL.
-
-  The init function pointer must point to a initialization function for
-  your ethernet netif interface. The following code illustrates it's use.
-  
-  err_t netif_if_init(struct netif *netif)
-  {
-    u8_t i;
-    
-    for(i = 0; i < ETHARP_HWADDR_LEN; i++) netif->hwaddr[i] = some_eth_addr[i];
-    init_my_eth_device();
-    return ERR_OK;
-  }
-  
-  For ethernet drivers, the input function pointer must point to the lwip
-  function ethernet_input() declared in "netif/etharp.h". Other drivers
-  must use ip_input() declared in "lwip/ip.h".
-  
-- netif_set_default(struct netif *netif)
-
-  Registers the default network interface.
-
-- netif_set_up(struct netif *netif)
-
-  When the netif is fully configured this function must be called.
-
-- dhcp_start(struct netif *netif)
-
-  Creates a new DHCP client for this interface on the first call.
-  Note: you must call dhcp_fine_tmr() and dhcp_coarse_tmr() at
-  the predefined regular intervals after starting the client.
-  
-  You can peek in the netif->dhcp struct for the actual DHCP status.
-
-
---- Optimalization hints
-
-The first thing you want to optimize is the lwip_standard_checksum()
-routine from src/core/inet.c. You can override this standard
-function with the #define LWIP_CHKSUM <your_checksum_routine>.
-
-There are C examples given in inet.c or you might want to
-craft an assembly function for this. RFC1071 is a good
-introduction to this subject.
-
-Other significant improvements can be made by supplying
-assembly or inline replacements for htons() and htonl()
-if you're using a little-endian architecture.
-#define LWIP_PLATFORM_BYTESWAP 1
-#define LWIP_PLATFORM_HTONS(x) <your_htons>
-#define LWIP_PLATFORM_HTONL(x) <your_htonl>
-
-Check your network interface driver if it reads at
-a higher speed than the maximum wire-speed. If the
-hardware isn't serviced frequently and fast enough
-buffer overflows are likely to occur.
-
-E.g. when using the cs8900 driver, call cs8900if_service(ethif)
-as frequently as possible. When using an RTOS let the cs8900 interrupt
-wake a high priority task that services your driver using a binary
-semaphore or event flag. Some drivers might allow additional tuning
-to match your application and network.
-
-For a production release it is recommended to set LWIP_STATS to 0.
-Note that speed performance isn't influenced much by simply setting
-high values to the memory options.
-
-For more optimization hints take a look at the lwIP wiki.
-
---- Zero-copy MACs
-
-To achieve zero-copy on transmit, the data passed to the raw API must
-remain unchanged until sent. Because the send- (or write-)functions return
-when the packets have been enqueued for sending, data must be kept stable
-after that, too.
-
-This implies that PBUF_RAM/PBUF_POOL pbufs passed to raw-API send functions
-must *not* be reused by the application unless their ref-count is 1.
-
-For no-copy pbufs (PBUF_ROM/PBUF_REF), data must be kept unchanged, too,
-but the stack/driver will/must copy PBUF_REF'ed data when enqueueing, while
-PBUF_ROM-pbufs are just enqueued (as ROM-data is expected to never change).
-
-Also, data passed to tcp_write without the copy-flag must not be changed!
-
-Therefore, be careful which type of PBUF you use and if you copy TCP data
-or not!

ext/lwip/doc/savannah.txt

@@ -1,135 +0,0 @@
-Daily Use Guide for using Savannah for lwIP
-
-Table of Contents:
-
-1 - Obtaining lwIP from the CVS repository
-2 - Committers/developers CVS access using SSH (to be written)
-3 - Merging from DEVEL branch to main trunk (stable branch)
-4 - How to release lwIP
-
-
-
-1 Obtaining lwIP from the CVS repository
-----------------------------------------
-
-To perform an anonymous CVS checkout of the main trunk (this is where
-bug fixes and incremental enhancements occur), do this:
-
-cvs -z3 -d:pserver:[email protected]:/sources/lwip checkout lwip
- 
-Or, obtain a stable branch (updated with bug fixes only) as follows:
-cvs -z3 -d:pserver:[email protected]:/sources/lwip checkout \
-  -r STABLE-0_7 -d lwip-0.7 lwip
-
-Or, obtain a specific (fixed) release as follows:
-cvs -z3 -d:pserver:[email protected]:/sources/lwip checkout \
-  -r STABLE-0_7_0 -d lwip-0.7.0 lwip
-
-3 Committers/developers CVS access using SSH
---------------------------------------------
-
-The Savannah server uses SSH (Secure Shell) protocol 2 authentication and encryption.
-As such, CVS commits to the server occur through a SSH tunnel for project members.
-To create a SSH2 key pair in UNIX-like environments, do this:
-
-ssh-keygen -t dsa
-
-Under Windows, a recommended SSH client is "PuTTY", freely available with good
-documentation and a graphic user interface. Use its key generator.
-
-Now paste the id_dsa.pub contents into your Savannah account public key list. Wait
-a while so that Savannah can update its configuration (This can take minutes).
-
-Try to login using SSH:
-
-ssh -v [email protected]
-
-If it tells you:
-
-Authenticating with public key "your_key_name"...
-Server refused to allocate pty
-
-then you could login; Savannah refuses to give you a shell - which is OK, as we
-are allowed to use SSH for CVS only. Now, you should be able to do this:
-
-export CVS_RSH=ssh
-cvs -z3 -d:ext:[email protected]:/sources/lwip co lwip
- 
-after which you can edit your local files with bug fixes or new features and
-commit them. Make sure you know what you are doing when using CVS to make
-changes on the repository. If in doubt, ask on the lwip-members mailing list.
-
-(If SSH asks about authenticity of the host, you can check the key
- fingerprint against http://savannah.nongnu.org/cvs/?group=lwip)
-
-
-3 Merging from DEVEL branch to main trunk (stable)
---------------------------------------------------
-
-Merging is a delicate process in CVS and requires the
-following disciplined steps in order to prevent conflicts
-in the future. Conflicts can be hard to solve!
-
-Merging from branch A to branch B requires that the A branch
-has a tag indicating the previous merger. This tag is called
-'merged_from_A_to_B'. After merging, the tag is moved in the
-A branch to remember this merger for future merge actions.
-
-IMPORTANT: AFTER COMMITTING A SUCCESFUL MERGE IN THE
-REPOSITORY, THE TAG MUST BE SET ON THE SOURCE BRANCH OF THE
-MERGE ACTION (REPLACING EXISTING TAGS WITH THE SAME NAME).
-
-Merge all changes in DEVEL since our last merge to main:
-
-In the working copy of the main trunk:
-cvs update -P -jmerged_from_DEVEL_to_main -jDEVEL 
-
-(This will apply the changes between 'merged_from_DEVEL_to_main'
-and 'DEVEL' to your work set of files)
-
-We can now commit the merge result.
-cvs commit -R -m "Merged from DEVEL to main." 
-
-If this worked out OK, we now move the tag in the DEVEL branch
-to this merge point, so we can use this point for future merges:
-
-cvs rtag -F -r DEVEL merged_from_DEVEL_to_main lwip 
-
-4 How to release lwIP
----------------------
-
-First, checkout a clean copy of the branch to be released. Tag this set with
-tag name "STABLE-0_6_3". (I use release number 0.6.3 throughout this example).
-
-Login CVS using pserver authentication, then export a clean copy of the
-tagged tree. Export is similar to a checkout, except that the CVS metadata
-is not created locally. 
-
-export CVS_RSH=ssh
-cvs -z3 -d:pserver:[email protected]:/sources/lwip checkout \
-  -r STABLE-0_6_3 -d lwip-0.6.3 lwip
-
-Archive this directory using tar, gzip'd, bzip2'd and zip'd.
-
-tar czvf lwip-0.6.3.tar.gz lwip-0.6.3
-tar cjvf lwip-0.6.3.tar.bz2 lwip-0.6.3
-zip -r lwip-0.6.3.zip lwip-0.6.3
-
-Now, sign the archives with a detached GPG binary signature as follows:
-
-gpg -b lwip-0.6.3.tar.gz
-gpg -b lwip-0.6.3.tar.bz2
-gpg -b lwip-0.6.3.zip
-
-Upload these files using anonymous FTP:
-ncftp ftp://savannah.gnu.org/incoming/savannah/lwip
-
-ncftp>mput *0.6.3.*
-
-Additionally, you may post a news item on Savannah, like this:
-
-A new 0.6.3 release is now available here:
-http://savannah.nongnu.org/files/?group=lwip&highlight=0.6.3
-
-You will have to submit this via the user News interface, then approve
-this via the Administrator News interface.

ext/lwip/doc/snmp_agent.txt

@@ -1,181 +0,0 @@
-SNMPv1 agent for lwIP
-
-Author: Christiaan Simons
-
-This is a brief introduction how to use and configure the SNMP agent.
-Note the agent uses the raw-API UDP interface so you may also want to
-read rawapi.txt to gain a better understanding of the SNMP message handling.
-
-0 Agent Capabilities
-====================
-
-SNMPv1 per RFC1157
-  This is an old(er) standard but is still widely supported.
-  For SNMPv2c and v3 have a greater complexity and need many
-  more lines of code. IMHO this breaks the idea of "lightweight IP".
-
-  Note the S in SNMP stands for "Simple". Note that "Simple" is
-  relative. SNMP is simple compared to the complex ISO network
-  management protocols CMIP (Common Management Information Protocol)
-  and CMOT (CMip Over Tcp).
-
-MIB II per RFC1213
-  The standard lwIP stack management information base.
-  This is a required MIB, so this is always enabled.
-  When builing lwIP without TCP, the mib-2.tcp group is omitted.
-  The groups EGP, CMOT and transmission are disabled by default.
-  
-  Most mib-2 objects are not writable except:
-  sysName, sysLocation, sysContact, snmpEnableAuthenTraps.
-  Writing to or changing the ARP and IP address and route
-  tables is not possible.
- 
-  Note lwIP has a very limited notion of IP routing. It currently
-  doen't have a route table and doesn't have a notion of the U,G,H flags.
-  Instead lwIP uses the interface list with only one default interface
-  acting as a single gateway interface (G) for the default route.
-
-  The agent returns a "virtual table" with the default route 0.0.0.0
-  for the default interface and network routes (no H) for each
-  network interface in the netif_list.
-  All routes are considered to be up (U).
-
-Loading additional MIBs
-  MIBs can only be added in compile-time, not in run-time.
-  There is no MIB compiler thus additional MIBs must be hand coded.
-
-Large SNMP message support
-  The packet decoding and encoding routines are designed
-  to use pbuf-chains. Larger payloads than the minimum
-  SNMP requirement of 484 octets are supported if the 
-  PBUF_POOL_SIZE and IP_REASS_BUFSIZE are set to match your
-  local requirement.
-
-1 Building the Agent
-====================
-
-First of all you'll need to add the following define
-to your local lwipopts.h:
-
-#define LWIP_SNMP               1
-
-and add the source files in lwip/src/core/snmp
-and some snmp headers in lwip/src/include/lwip to your makefile.
-
-Note you'll might need to adapt you network driver to update
-the mib2 variables for your interface.
-
-2 Running the Agent
-===================
-
-The following function calls must be made in your program to
-actually get the SNMP agent running.
-
-Before starting the agent you should supply pointers
-to non-volatile memory for sysContact, sysLocation,
-and snmpEnableAuthenTraps. You can do this by calling
-
-snmp_set_syscontact()
-snmp_set_syslocation()
-snmp_set_snmpenableauthentraps()
-
-Additionally you may want to set
-
-snmp_set_sysdescr()
-snmp_set_sysobjid() (if you have a private MIB)
-snmp_set_sysname()
-
-Also before starting the agent you need to setup
-one or more trap destinations using these calls:
-
-snmp_trap_dst_enable();
-snmp_trap_dst_ip_set();
-
-In the lwIP initialisation sequence call snmp_init() just after
-the call to udp_init().
-
-Exactly every 10 msec the SNMP uptime timestamp must be updated with
-snmp_inc_sysuptime(). You should call this from a timer interrupt
-or a timer signal handler depending on your runtime environment.
-
-An alternative way to update the SNMP uptime timestamp is to do a call like
-snmp_add_sysuptime(100) each 1000ms (which is bigger "step", but call to
-a lower frequency). Another one is to not call snmp_inc_sysuptime() or
-snmp_add_sysuptime(), and to define the SNMP_GET_SYSUPTIME(sysuptime) macro.
-This one is undefined by default in mib2.c. SNMP_GET_SYSUPTIME is called inside
-snmp_get_sysuptime(u32_t *value), and enable to change "sysuptime" value only
-when it's queried (any function which need "sysuptime" have to call
-snmp_get_sysuptime).
-
-
-3 Private MIBs
-==============
-
-If want to extend the agent with your own private MIB you'll need to
-add the following define to your local lwipopts.h:
-
-#define SNMP_PRIVATE_MIB        1
-
-You must provide the private_mib.h and associated files yourself.
-Note we don't have a "MIB compiler" that generates C source from a MIB,
-so you're required to do some serious coding if you enable this!
-
-Note the lwIP enterprise ID (26381) is assigned to the lwIP project,
-ALL OBJECT IDENTIFIERS LIVING UNDER THIS ID ARE ASSIGNED BY THE lwIP
-MAINTAINERS!
-
-If you need to create your own private MIB you'll need
-to apply for your own enterprise ID with IANA: http://www.iana.org/numbers.html 
-
-You can set it by passing a struct snmp_obj_id to the agent
-using snmp_set_sysobjid(&my_object_id), just before snmp_init().
-
-Note the object identifiers for thes MIB-2 and your private MIB
-tree must be kept in sorted ascending (lexicographical) order.
-This to ensure correct getnext operation.
-
-An example for a private MIB is part of the "minimal Unix" project:
-contrib/ports/unix/proj/minimal/lwip_prvmib.c
-
-The next chapter gives a more detailed description of the
-MIB-2 tree and the optional private MIB.
-
-4 The Gory Details
-==================
-
-4.0 Object identifiers and the MIB tree.
-
-We have three distinct parts for all object identifiers:
-
-The prefix
-  .iso.org.dod.internet
-
-the middle part 
-  .mgmt.mib-2.ip.ipNetToMediaTable.ipNetToMediaEntry.ipNetToMediaPhysAddress
-
-and the index part
-  .1.192.168.0.1
-
-Objects located above the .internet hierarchy aren't supported.
-Currently only the .mgmt sub-tree is available and
-when the SNMP_PRIVATE_MIB is enabled the .private tree
-becomes available too.
-
-Object identifiers from incoming requests are checked
-for a matching prefix, middle part and index part
-or are expanded(*) for GetNext requests with short
-or inexisting names in the request.
-(* we call this "expansion" but this also
-resembles the "auto-completion" operation)
-
-The middle part is usually located in ROM (const)
-to preserve precious RAM on small microcontrollers.
-However RAM location is possible for a dynamically
-changing private tree.
-
-The index part is handled by functions which in
-turn use dynamically allocated index trees from RAM.
-These trees are updated by e.g. the etharp code
-when new entries are made or removed form the ARP cache.
-
-/** @todo more gory details */

ext/lwip/doc/sys_arch.txt

@@ -1,267 +0,0 @@
-sys_arch interface for lwIP 0.6++
-
-Author: Adam Dunkels
-
-The operating system emulation layer provides a common interface
-between the lwIP code and the underlying operating system kernel. The
-general idea is that porting lwIP to new architectures requires only
-small changes to a few header files and a new sys_arch
-implementation. It is also possible to do a sys_arch implementation
-that does not rely on any underlying operating system.
-
-The sys_arch provides semaphores and mailboxes to lwIP. For the full
-lwIP functionality, multiple threads support can be implemented in the
-sys_arch, but this is not required for the basic lwIP
-functionality. Previous versions of lwIP required the sys_arch to
-implement timer scheduling as well but as of lwIP 0.5 this is
-implemented in a higher layer.
-
-In addition to the source file providing the functionality of sys_arch,
-the OS emulation layer must provide several header files defining
-macros used throughout lwip.  The files required and the macros they
-must define are listed below the sys_arch description.
-
-Semaphores can be either counting or binary - lwIP works with both
-kinds. Mailboxes are used for message passing and can be implemented
-either as a queue which allows multiple messages to be posted to a
-mailbox, or as a rendez-vous point where only one message can be
-posted at a time. lwIP works with both kinds, but the former type will
-be more efficient. A message in a mailbox is just a pointer, nothing
-more. 
-
-Semaphores are represented by the type "sys_sem_t" which is typedef'd
-in the sys_arch.h file. Mailboxes are equivalently represented by the
-type "sys_mbox_t". lwIP does not place any restrictions on how
-sys_sem_t or sys_mbox_t are represented internally.
-
-Since lwIP 1.4.0, semaphore and mailbox functions are prototyped in a way that
-allows both using pointers or actual OS structures to be used. This way, memory
-required for such types can be either allocated in place (globally or on the
-stack) or on the heap (allocated internally in the "*_new()" functions).
-
-The following functions must be implemented by the sys_arch:
-
-- void sys_init(void)
-
-  Is called to initialize the sys_arch layer.
-
-- err_t sys_sem_new(sys_sem_t *sem, u8_t count)
-
-  Creates a new semaphore. The semaphore is allocated to the memory that 'sem'
-  points to (which can be both a pointer or the actual OS structure).
-  The "count" argument specifies the initial state of the semaphore (which is
-  either 0 or 1).
-  If the semaphore has been created, ERR_OK should be returned. Returning any
-  other error will provide a hint what went wrong, but except for assertions,
-  no real error handling is implemented.
-
-- void sys_sem_free(sys_sem_t *sem)
-
-  Deallocates a semaphore.
-
-- void sys_sem_signal(sys_sem_t *sem)
-
-  Signals a semaphore.
-
-- u32_t sys_arch_sem_wait(sys_sem_t *sem, u32_t timeout)
-
-  Blocks the thread while waiting for the semaphore to be
-  signaled. If the "timeout" argument is non-zero, the thread should
-  only be blocked for the specified time (measured in
-  milliseconds). If the "timeout" argument is zero, the thread should be
-  blocked until the semaphore is signalled.
-
-  If the timeout argument is non-zero, the return value is the number of
-  milliseconds spent waiting for the semaphore to be signaled. If the
-  semaphore wasn't signaled within the specified time, the return value is
-  SYS_ARCH_TIMEOUT. If the thread didn't have to wait for the semaphore
-  (i.e., it was already signaled), the function may return zero.
-
-  Notice that lwIP implements a function with a similar name,
-  sys_sem_wait(), that uses the sys_arch_sem_wait() function.
-
-- int sys_sem_valid(sys_sem_t *sem)
-
-  Returns 1 if the semaphore is valid, 0 if it is not valid.
-  When using pointers, a simple way is to check the pointer for != NULL.
-  When directly using OS structures, implementing this may be more complex.
-  This may also be a define, in which case the function is not prototyped.
-
-- void sys_sem_set_invalid(sys_sem_t *sem)
-
-  Invalidate a semaphore so that sys_sem_valid() returns 0.
-  ATTENTION: This does NOT mean that the semaphore shall be deallocated:
-  sys_sem_free() is always called before calling this function!
-  This may also be a define, in which case the function is not prototyped.
-
-- err_t sys_mbox_new(sys_mbox_t *mbox, int size)
-
-  Creates an empty mailbox for maximum "size" elements. Elements stored
-  in mailboxes are pointers. You have to define macros "_MBOX_SIZE"
-  in your lwipopts.h, or ignore this parameter in your implementation
-  and use a default size.
-  If the mailbox has been created, ERR_OK should be returned. Returning any
-  other error will provide a hint what went wrong, but except for assertions,
-  no real error handling is implemented.
-
-- void sys_mbox_free(sys_mbox_t *mbox)
-
-  Deallocates a mailbox. If there are messages still present in the
-  mailbox when the mailbox is deallocated, it is an indication of a
-  programming error in lwIP and the developer should be notified.
-
-- void sys_mbox_post(sys_mbox_t *mbox, void *msg)
-
-  Posts the "msg" to the mailbox. This function have to block until
-  the "msg" is really posted.
-
-- err_t sys_mbox_trypost(sys_mbox_t *mbox, void *msg)
-
-  Try to post the "msg" to the mailbox. Returns ERR_MEM if this one
-  is full, else, ERR_OK if the "msg" is posted.
-
-- u32_t sys_arch_mbox_fetch(sys_mbox_t *mbox, void **msg, u32_t timeout)
-
-  Blocks the thread until a message arrives in the mailbox, but does
-  not block the thread longer than "timeout" milliseconds (similar to
-  the sys_arch_sem_wait() function). If "timeout" is 0, the thread should
-  be blocked until a message arrives. The "msg" argument is a result
-  parameter that is set by the function (i.e., by doing "*msg =
-  ptr"). The "msg" parameter maybe NULL to indicate that the message
-  should be dropped.
-
-  The return values are the same as for the sys_arch_sem_wait() function:
-  Number of milliseconds spent waiting or SYS_ARCH_TIMEOUT if there was a
-  timeout.
-
-  Note that a function with a similar name, sys_mbox_fetch(), is
-  implemented by lwIP. 
-
-- u32_t sys_arch_mbox_tryfetch(sys_mbox_t *mbox, void **msg)
-
-  This is similar to sys_arch_mbox_fetch, however if a message is not
-  present in the mailbox, it immediately returns with the code
-  SYS_MBOX_EMPTY. On success 0 is returned.
-
-  To allow for efficient implementations, this can be defined as a
-  function-like macro in sys_arch.h instead of a normal function. For
-  example, a naive implementation could be:
-    #define sys_arch_mbox_tryfetch(mbox,msg) \
-      sys_arch_mbox_fetch(mbox,msg,1)
-  although this would introduce unnecessary delays.
-
-- int sys_mbox_valid(sys_mbox_t *mbox)
-
-  Returns 1 if the mailbox is valid, 0 if it is not valid.
-  When using pointers, a simple way is to check the pointer for != NULL.
-  When directly using OS structures, implementing this may be more complex.
-  This may also be a define, in which case the function is not prototyped.
-
-- void sys_mbox_set_invalid(sys_mbox_t *mbox)
-
-  Invalidate a mailbox so that sys_mbox_valid() returns 0.
-  ATTENTION: This does NOT mean that the mailbox shall be deallocated:
-  sys_mbox_free() is always called before calling this function!
-  This may also be a define, in which case the function is not prototyped.
-
-If threads are supported by the underlying operating system and if
-such functionality is needed in lwIP, the following function will have
-to be implemented as well:
-
-- sys_thread_t sys_thread_new(char *name, void (* thread)(void *arg), void *arg, int stacksize, int prio)
-
-  Starts a new thread named "name" with priority "prio" that will begin its
-  execution in the function "thread()". The "arg" argument will be passed as an
-  argument to the thread() function. The stack size to used for this thread is
-  the "stacksize" parameter. The id of the new thread is returned. Both the id
-  and the priority are system dependent.
-
-- sys_prot_t sys_arch_protect(void)
-
-  This optional function does a "fast" critical region protection and returns
-  the previous protection level. This function is only called during very short
-  critical regions. An embedded system which supports ISR-based drivers might
-  want to implement this function by disabling interrupts. Task-based systems
-  might want to implement this by using a mutex or disabling tasking. This
-  function should support recursive calls from the same task or interrupt. In
-  other words, sys_arch_protect() could be called while already protected. In
-  that case the return value indicates that it is already protected.
-
-  sys_arch_protect() is only required if your port is supporting an operating
-  system.
-
-- void sys_arch_unprotect(sys_prot_t pval)
-
-  This optional function does a "fast" set of critical region protection to the
-  value specified by pval. See the documentation for sys_arch_protect() for
-  more information. This function is only required if your port is supporting
-  an operating system.
-
-For some configurations, you also need:
-
-- u32_t sys_now(void)
-
-  This optional function returns the current time in milliseconds (don't care
-  for wraparound, this is only used for time diffs).
-  Not implementing this function means you cannot use some modules (e.g. TCP
-  timestamps, internal timeouts for NO_SYS==1).
-
-
-Note:
-
-Be carefull with using mem_malloc() in sys_arch. When malloc() refers to
-mem_malloc() you can run into a circular function call problem. In mem.c
-mem_init() tries to allcate a semaphore using mem_malloc, which of course
-can't be performed when sys_arch uses mem_malloc.
-
--------------------------------------------------------------------------------
-Additional files required for the "OS support" emulation layer:
--------------------------------------------------------------------------------
-
-cc.h       - Architecture environment, some compiler specific, some
-             environment specific (probably should move env stuff 
-             to sys_arch.h.)
-
-  Typedefs for the types used by lwip -
-    u8_t, s8_t, u16_t, s16_t, u32_t, s32_t, mem_ptr_t
-
-  Compiler hints for packing lwip's structures -
-    PACK_STRUCT_FIELD(x)
-    PACK_STRUCT_STRUCT
-    PACK_STRUCT_BEGIN
-    PACK_STRUCT_END
-
-  Platform specific diagnostic output -
-    LWIP_PLATFORM_DIAG(x)    - non-fatal, print a message.
-    LWIP_PLATFORM_ASSERT(x)  - fatal, print message and abandon execution.
-    Portability defines for printf formatters:
-    U16_F, S16_F, X16_F, U32_F, S32_F, X32_F, SZT_F
-
-  "lightweight" synchronization mechanisms -
-    SYS_ARCH_DECL_PROTECT(x) - declare a protection state variable.
-    SYS_ARCH_PROTECT(x)      - enter protection mode.
-    SYS_ARCH_UNPROTECT(x)    - leave protection mode.
-
-  If the compiler does not provide memset() this file must include a
-  definition of it, or include a file which defines it.
-
-  This file must either include a system-local <errno.h> which defines
-  the standard *nix error codes, or it should #define LWIP_PROVIDE_ERRNO
-  to make lwip/arch.h define the codes which are used throughout.
-
-
-perf.h     - Architecture specific performance measurement.
-  Measurement calls made throughout lwip, these can be defined to nothing.
-    PERF_START               - start measuring something.
-    PERF_STOP(x)             - stop measuring something, and record the result.
-
-sys_arch.h - Tied to sys_arch.c
-
-  Arch dependent types for the following objects:
-    sys_sem_t, sys_mbox_t, sys_thread_t,
-  And, optionally:
-    sys_prot_t
-
-  Defines to set vars of sys_mbox_t and sys_sem_t to NULL.
-    SYS_MBOX_NULL NULL
-    SYS_SEM_NULL NULL

ext/lwip/test/unit/core/test_mem.c

@@ -1,73 +0,0 @@
-#include "test_mem.h"
-
-#include "lwip/mem.h"
-#include "lwip/stats.h"
-
-#if !LWIP_STATS || !MEM_STATS
-#error "This tests needs MEM-statistics enabled"
-#endif
-#if LWIP_DNS
-#error "This test needs DNS turned off (as it mallocs on init)"
-#endif
-
-/* Setups/teardown functions */
-
-static void
-mem_setup(void)
-{
-}
-
-static void
-mem_teardown(void)
-{
-}
-
-
-/* Test functions */
-
-/** Call mem_malloc, mem_free and mem_trim and check stats */
-START_TEST(test_mem_one)
-{
-#define SIZE1   16
-#define SIZE1_2 12
-#define SIZE2   16
-  void *p1, *p2;
-  mem_size_t s1, s2;
-  LWIP_UNUSED_ARG(_i);
-
-#if LWIP_DNS
-  fail("This test needs DNS turned off (as it mallocs on init)");
-#endif
-
-  fail_unless(lwip_stats.mem.used == 0);
-
-  p1 = mem_malloc(SIZE1);
-  fail_unless(p1 != NULL);
-  fail_unless(lwip_stats.mem.used >= SIZE1);
-  s1 = lwip_stats.mem.used;
-
-  p2 = mem_malloc(SIZE2);
-  fail_unless(p2 != NULL);
-  fail_unless(lwip_stats.mem.used >= SIZE2 + s1);
-  s2 = lwip_stats.mem.used;
-
-  mem_trim(p1, SIZE1_2);
-
-  mem_free(p2);
-  fail_unless(lwip_stats.mem.used <= s2 - SIZE2);
-
-  mem_free(p1);
-  fail_unless(lwip_stats.mem.used == 0);
-}
-END_TEST
-
-
-/** Create the suite including all tests for this module */
-Suite *
-mem_suite(void)
-{
-  TFun tests[] = {
-    test_mem_one
-  };
-  return create_suite("MEM", tests, sizeof(tests)/sizeof(TFun), mem_setup, mem_teardown);
-}

ext/lwip/test/unit/core/test_mem.h

@@ -1,8 +0,0 @@
-#ifndef __TEST_MEM_H__
-#define __TEST_MEM_H__
-
-#include "../lwip_check.h"
-
-Suite *mem_suite(void);
-
-#endif

ext/lwip/test/unit/etharp/test_etharp.c

@@ -1,262 +0,0 @@
-#include "test_etharp.h"
-
-#include "lwip/udp.h"
-#include "netif/etharp.h"
-#include "lwip/stats.h"
-
-#if !LWIP_STATS || !UDP_STATS || !MEMP_STATS || !ETHARP_STATS
-#error "This tests needs UDP-, MEMP- and ETHARP-statistics enabled"
-#endif
-#if !ETHARP_SUPPORT_STATIC_ENTRIES
-#error "This test needs ETHARP_SUPPORT_STATIC_ENTRIES enabled"
-#endif
-
-static struct netif test_netif;
-static ip_addr_t test_ipaddr, test_netmask, test_gw;
-struct eth_addr test_ethaddr = {1,1,1,1,1,1};
-struct eth_addr test_ethaddr2 = {1,1,1,1,1,2};
-struct eth_addr test_ethaddr3 = {1,1,1,1,1,3};
-struct eth_addr test_ethaddr4 = {1,1,1,1,1,4};
-static int linkoutput_ctr;
-
-/* Helper functions */
-static void
-etharp_remove_all(void)
-{
-  int i;
-  /* call etharp_tmr often enough to have all entries cleaned */
-  for(i = 0; i < 0xff; i++) {
-    etharp_tmr();
-  }
-}
-
-static err_t
-default_netif_linkoutput(struct netif *netif, struct pbuf *p)
-{
-  fail_unless(netif == &test_netif);
-  fail_unless(p != NULL);
-  linkoutput_ctr++;
-  return ERR_OK;
-}
-
-static err_t
-default_netif_init(struct netif *netif)
-{
-  fail_unless(netif != NULL);
-  netif->linkoutput = default_netif_linkoutput;
-  netif->output = etharp_output;
-  netif->mtu = 1500;
-  netif->flags = NETIF_FLAG_BROADCAST | NETIF_FLAG_ETHARP | NETIF_FLAG_LINK_UP;
-  netif->hwaddr_len = ETHARP_HWADDR_LEN;
-  return ERR_OK;
-}
-
-static void
-default_netif_add(void)
-{
-  IP4_ADDR(&test_gw, 192,168,0,1);
-  IP4_ADDR(&test_ipaddr, 192,168,0,1);
-  IP4_ADDR(&test_netmask, 255,255,0,0);
-
-  fail_unless(netif_default == NULL);
-  netif_set_default(netif_add(&test_netif, &test_ipaddr, &test_netmask,
-                              &test_gw, NULL, default_netif_init, NULL));
-  netif_set_up(&test_netif);
-}
-
-static void
-default_netif_remove(void)
-{
-  fail_unless(netif_default == &test_netif);
-  netif_remove(&test_netif);
-}
-
-static void
-create_arp_response(ip_addr_t *adr)
-{
-  int k;
-  struct eth_hdr *ethhdr;
-  struct etharp_hdr *etharphdr;
-  struct pbuf *p = pbuf_alloc(PBUF_RAW, sizeof(struct eth_hdr) + sizeof(struct etharp_hdr), PBUF_RAM);
-  if(p == NULL) {
-    FAIL_RET();
-  }
-  ethhdr = (struct eth_hdr*)p->payload;
-  etharphdr = (struct etharp_hdr*)(ethhdr + 1);
-
-  ethhdr->dest = test_ethaddr;
-  ethhdr->src = test_ethaddr2;
-  ethhdr->type = htons(ETHTYPE_ARP);
-
-  etharphdr->hwtype = htons(/*HWTYPE_ETHERNET*/ 1);
-  etharphdr->proto = htons(ETHTYPE_IP);
-  etharphdr->hwlen = ETHARP_HWADDR_LEN;
-  etharphdr->protolen = sizeof(ip_addr_t);
-  etharphdr->opcode = htons(ARP_REPLY);
-
-  SMEMCPY(&etharphdr->sipaddr, adr, sizeof(ip_addr_t));
-  SMEMCPY(&etharphdr->dipaddr, &test_ipaddr, sizeof(ip_addr_t));
-
-  k = 6;
-  while(k > 0) {
-    k--;
-    /* Write the ARP MAC-Addresses */
-    etharphdr->shwaddr.addr[k] = test_ethaddr2.addr[k];
-    etharphdr->dhwaddr.addr[k] = test_ethaddr.addr[k];
-    /* Write the Ethernet MAC-Addresses */
-    ethhdr->dest.addr[k] = test_ethaddr.addr[k];
-    ethhdr->src.addr[k]  = test_ethaddr2.addr[k];
-  }
-
-  ethernet_input(p, &test_netif);
-}
-
-/* Setups/teardown functions */
-
-static void
-etharp_setup(void)
-{
-  etharp_remove_all();
-  default_netif_add();
-}
-
-static void
-etharp_teardown(void)
-{
-  etharp_remove_all();
-  default_netif_remove();
-}
-
-
-/* Test functions */
-
-START_TEST(test_etharp_table)
-{
-#if ETHARP_SUPPORT_STATIC_ENTRIES
-  err_t err;
-#endif /* ETHARP_SUPPORT_STATIC_ENTRIES */
-  s8_t idx;
-  ip_addr_t *unused_ipaddr;
-  struct eth_addr *unused_ethaddr;
-  struct udp_pcb* pcb;
-  LWIP_UNUSED_ARG(_i);
-
-  if (netif_default != &test_netif) {
-    fail("This test needs a default netif");
-  }
-
-  linkoutput_ctr = 0;
-
-  pcb = udp_new();
-  fail_unless(pcb != NULL);
-  if (pcb != NULL) {
-    ip_addr_t adrs[ARP_TABLE_SIZE + 2];
-    int i;
-    for(i = 0; i < ARP_TABLE_SIZE + 2; i++) {
-      IP4_ADDR(&adrs[i], 192,168,0,i+2);
-    }
-    /* fill ARP-table with dynamic entries */
-    for(i = 0; i < ARP_TABLE_SIZE; i++) {
-      struct pbuf *p = pbuf_alloc(PBUF_TRANSPORT, 10, PBUF_RAM);
-      fail_unless(p != NULL);
-      if (p != NULL) {
-        err_t err = udp_sendto(pcb, p, &adrs[i], 123);
-        fail_unless(err == ERR_OK);
-        /* etharp request sent? */
-        fail_unless(linkoutput_ctr == (2*i) + 1);
-        pbuf_free(p);
-
-        /* create an ARP response */
-        create_arp_response(&adrs[i]);
-        /* queued UDP packet sent? */
-        fail_unless(linkoutput_ctr == (2*i) + 2);
-
-        idx = etharp_find_addr(NULL, &adrs[i], &unused_ethaddr, &unused_ipaddr);
-        fail_unless(idx == i);
-        etharp_tmr();
-      }
-    }
-    linkoutput_ctr = 0;
-#if ETHARP_SUPPORT_STATIC_ENTRIES
-    /* create one static entry */
-    err = etharp_add_static_entry(&adrs[ARP_TABLE_SIZE], &test_ethaddr3);
-    fail_unless(err == ERR_OK);
-    idx = etharp_find_addr(NULL, &adrs[ARP_TABLE_SIZE], &unused_ethaddr, &unused_ipaddr);
-    fail_unless(idx == 0);
-    fail_unless(linkoutput_ctr == 0);
-#endif /* ETHARP_SUPPORT_STATIC_ENTRIES */
-
-    linkoutput_ctr = 0;
-    /* fill ARP-table with dynamic entries */
-    for(i = 0; i < ARP_TABLE_SIZE; i++) {
-      struct pbuf *p = pbuf_alloc(PBUF_TRANSPORT, 10, PBUF_RAM);
-      fail_unless(p != NULL);
-      if (p != NULL) {
-        err_t err = udp_sendto(pcb, p, &adrs[i], 123);
-        fail_unless(err == ERR_OK);
-        /* etharp request sent? */
-        fail_unless(linkoutput_ctr == (2*i) + 1);
-        pbuf_free(p);
-
-        /* create an ARP response */
-        create_arp_response(&adrs[i]);
-        /* queued UDP packet sent? */
-        fail_unless(linkoutput_ctr == (2*i) + 2);
-
-        idx = etharp_find_addr(NULL, &adrs[i], &unused_ethaddr, &unused_ipaddr);
-        if (i < ARP_TABLE_SIZE - 1) {
-          fail_unless(idx == i+1);
-        } else {
-          /* the last entry must not overwrite the static entry! */
-          fail_unless(idx == 1);
-        }
-        etharp_tmr();
-      }
-    }
-#if ETHARP_SUPPORT_STATIC_ENTRIES
-    /* create a second static entry */
-    err = etharp_add_static_entry(&adrs[ARP_TABLE_SIZE+1], &test_ethaddr4);
-    fail_unless(err == ERR_OK);
-    idx = etharp_find_addr(NULL, &adrs[ARP_TABLE_SIZE], &unused_ethaddr, &unused_ipaddr);
-    fail_unless(idx == 0);
-    idx = etharp_find_addr(NULL, &adrs[ARP_TABLE_SIZE+1], &unused_ethaddr, &unused_ipaddr);
-    fail_unless(idx == 2);
-    /* and remove it again */
-    err = etharp_remove_static_entry(&adrs[ARP_TABLE_SIZE+1]);
-    fail_unless(err == ERR_OK);
-    idx = etharp_find_addr(NULL, &adrs[ARP_TABLE_SIZE], &unused_ethaddr, &unused_ipaddr);
-    fail_unless(idx == 0);
-    idx = etharp_find_addr(NULL, &adrs[ARP_TABLE_SIZE+1], &unused_ethaddr, &unused_ipaddr);
-    fail_unless(idx == -1);
-#endif /* ETHARP_SUPPORT_STATIC_ENTRIES */
-
-    /* check that static entries don't time out */
-    etharp_remove_all();
-    idx = etharp_find_addr(NULL, &adrs[ARP_TABLE_SIZE], &unused_ethaddr, &unused_ipaddr);
-    fail_unless(idx == 0);
-
-#if ETHARP_SUPPORT_STATIC_ENTRIES
-    /* remove the first static entry */
-    err = etharp_remove_static_entry(&adrs[ARP_TABLE_SIZE]);
-    fail_unless(err == ERR_OK);
-    idx = etharp_find_addr(NULL, &adrs[ARP_TABLE_SIZE], &unused_ethaddr, &unused_ipaddr);
-    fail_unless(idx == -1);
-    idx = etharp_find_addr(NULL, &adrs[ARP_TABLE_SIZE+1], &unused_ethaddr, &unused_ipaddr);
-    fail_unless(idx == -1);
-#endif /* ETHARP_SUPPORT_STATIC_ENTRIES */
-
-    udp_remove(pcb);
-  }
-}
-END_TEST
-
-
-/** Create the suite including all tests for this module */
-Suite *
-etharp_suite(void)
-{
-  TFun tests[] = {
-    test_etharp_table
-  };
-  return create_suite("ETHARP", tests, sizeof(tests)/sizeof(TFun), etharp_setup, etharp_teardown);
-}

ext/lwip/test/unit/etharp/test_etharp.h

@@ -1,8 +0,0 @@
-#ifndef __TEST_ETHARP_H__
-#define __TEST_ETHARP_H__
-
-#include "../lwip_check.h"
-
-Suite* etharp_suite(void);
-
-#endif

ext/lwip/test/unit/lwip_check.h

@@ -1,37 +0,0 @@
-#ifndef __LWIP_CHECK_H__
-#define __LWIP_CHECK_H__
-
-/* Common header file for lwIP unit tests using the check framework */
-
-#include <config.h>
-#include <check.h>
-#include <stdlib.h>
-
-#define FAIL_RET() do { fail(); return; } while(0)
-#define EXPECT(x) fail_unless(x)
-#define EXPECT_RET(x) do { fail_unless(x); if(!(x)) { return; }} while(0)
-#define EXPECT_RETX(x, y) do { fail_unless(x); if(!(x)) { return y; }} while(0)
-#define EXPECT_RETNULL(x) EXPECT_RETX(x, NULL)
-
-/** typedef for a function returning a test suite */
-typedef Suite* (suite_getter_fn)(void);
-
-/** Create a test suite */
-static Suite* create_suite(const char* name, TFun *tests, size_t num_tests, SFun setup, SFun teardown)
-{
-  size_t i;
-  Suite *s = suite_create(name);
-
-  for(i = 0; i < num_tests; i++) {
-    /* Core test case */
-    TCase *tc_core = tcase_create("Core");
-    if ((setup != NULL) || (teardown != NULL)) {
-      tcase_add_checked_fixture(tc_core, setup, teardown);
-    }
-    tcase_add_test(tc_core, tests[i]);
-    suite_add_tcase(s, tc_core);
-  }
-  return s;
-}
-
-#endif /* __LWIP_CHECK_H__ */

ext/lwip/test/unit/lwip_unittests.c

@@ -1,45 +0,0 @@
-#include "lwip_check.h"
-
-#include "udp/test_udp.h"
-#include "tcp/test_tcp.h"
-#include "tcp/test_tcp_oos.h"
-#include "core/test_mem.h"
-#include "etharp/test_etharp.h"
-
-#include "lwip/init.h"
-
-
-int main()
-{
-  int number_failed;
-  SRunner *sr;
-  size_t i;
-  suite_getter_fn* suites[] = {
-    udp_suite,
-    tcp_suite,
-    tcp_oos_suite,
-    mem_suite,
-    etharp_suite
-  };
-  size_t num = sizeof(suites)/sizeof(void*);
-  LWIP_ASSERT("No suites defined", num > 0);
-
-  lwip_init();
-
-  sr = srunner_create((suites[0])());
-  for(i = 1; i < num; i++) {
-    srunner_add_suite(sr, ((suite_getter_fn*)suites[i])());
-  }
-
-#ifdef LWIP_UNITTESTS_NOFORK
-  srunner_set_fork_status(sr, CK_NOFORK);
-#endif
-#ifdef LWIP_UNITTESTS_FORK
-  srunner_set_fork_status(sr, CK_FORK);
-#endif
-
-  srunner_run_all(sr, CK_NORMAL);
-  number_failed = srunner_ntests_failed(sr);
-  srunner_free(sr);
-  return (number_failed == 0) ? EXIT_SUCCESS : EXIT_FAILURE;
-}

ext/lwip/test/unit/lwipopts.h

@@ -1,50 +0,0 @@
-/*
- * Copyright (c) 2001-2003 Swedish Institute of Computer Science.
- * All rights reserved. 
- * 
- * Redistribution and use in source and binary forms, with or without modification, 
- * are permitted provided that the following conditions are met:
- *
- * 1. Redistributions of source code must retain the above copyright notice,
- *    this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright notice,
- *    this list of conditions and the following disclaimer in the documentation
- *    and/or other materials provided with the distribution.
- * 3. The name of the author may not be used to endorse or promote products
- *    derived from this software without specific prior written permission. 
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED 
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 
- * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT 
- * SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, 
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT 
- * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 
- * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING 
- * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY 
- * OF SUCH DAMAGE.
- *
- * This file is part of the lwIP TCP/IP stack.
- * 
- * Author: Simon Goldschmidt
- *
- */
-#ifndef __LWIPOPTS_H__
-#define __LWIPOPTS_H__
-
-/* Prevent having to link sys_arch.c (we don't test the API layers in unit tests) */
-#define NO_SYS                          1
-#define LWIP_NETCONN                    0
-#define LWIP_SOCKET                     0
-
-/* Minimal changes to opt.h required for tcp unit tests: */
-#define MEM_SIZE                        16000
-#define TCP_SND_QUEUELEN                40
-#define MEMP_NUM_TCP_SEG                TCP_SND_QUEUELEN
-#define TCP_SND_BUF                     (12 * TCP_MSS)
-#define TCP_WND                         (10 * TCP_MSS)
-
-/* Minimal changes to opt.h required for etharp unit tests: */
-#define ETHARP_SUPPORT_STATIC_ENTRIES   1
-
-#endif /* __LWIPOPTS_H__ */

ext/lwip/test/unit/tcp/tcp_helper.c

@@ -1,294 +0,0 @@
-#include "tcp_helper.h"
-
-#include "lwip/tcp_impl.h"
-#include "lwip/stats.h"
-#include "lwip/pbuf.h"
-#include "lwip/inet_chksum.h"
-
-#if !LWIP_STATS || !TCP_STATS || !MEMP_STATS
-#error "This tests needs TCP- and MEMP-statistics enabled"
-#endif
-
-/** Remove all pcbs on the given list. */
-static void
-tcp_remove(struct tcp_pcb* pcb_list)
-{
-  struct tcp_pcb *pcb = pcb_list;
-  struct tcp_pcb *pcb2;
-
-  while(pcb != NULL) {
-    pcb2 = pcb;
-    pcb = pcb->next;
-    tcp_abort(pcb2);
-  }
-}
-
-/** Remove all pcbs on listen-, active- and time-wait-list (bound- isn't exported). */
-void
-tcp_remove_all(void)
-{
-  tcp_remove(tcp_listen_pcbs.pcbs);
-  tcp_remove(tcp_active_pcbs);
-  tcp_remove(tcp_tw_pcbs);
-  fail_unless(lwip_stats.memp[MEMP_TCP_PCB].used == 0);
-  fail_unless(lwip_stats.memp[MEMP_TCP_PCB_LISTEN].used == 0);
-  fail_unless(lwip_stats.memp[MEMP_TCP_SEG].used == 0);
-  fail_unless(lwip_stats.memp[MEMP_PBUF_POOL].used == 0);
-}
-
-/** Create a TCP segment usable for passing to tcp_input */
-static struct pbuf*
-tcp_create_segment_wnd(ip_addr_t* src_ip, ip_addr_t* dst_ip,
-                   u16_t src_port, u16_t dst_port, void* data, size_t data_len,
-                   u32_t seqno, u32_t ackno, u8_t headerflags, u16_t wnd)
-{
-  struct pbuf *p, *q;
-  struct ip_hdr* iphdr;
-  struct tcp_hdr* tcphdr;
-  u16_t pbuf_len = (u16_t)(sizeof(struct ip_hdr) + sizeof(struct tcp_hdr) + data_len);
-
-  p = pbuf_alloc(PBUF_RAW, pbuf_len, PBUF_POOL);
-  EXPECT_RETNULL(p != NULL);
-  /* first pbuf must be big enough to hold the headers */
-  EXPECT_RETNULL(p->len >= (sizeof(struct ip_hdr) + sizeof(struct tcp_hdr)));
-  if (data_len > 0) {
-    /* first pbuf must be big enough to hold at least 1 data byte, too */
-    EXPECT_RETNULL(p->len > (sizeof(struct ip_hdr) + sizeof(struct tcp_hdr)));
-  }
-
-  for(q = p; q != NULL; q = q->next) {
-    memset(q->payload, 0, q->len);
-  }
-
-  iphdr = p->payload;
-  /* fill IP header */
-  iphdr->dest.addr = dst_ip->addr;
-  iphdr->src.addr = src_ip->addr;
-  IPH_VHL_SET(iphdr, 4, IP_HLEN / 4);
-  IPH_TOS_SET(iphdr, 0);
-  IPH_LEN_SET(iphdr, htons(p->tot_len));
-  IPH_CHKSUM_SET(iphdr, inet_chksum(iphdr, IP_HLEN));
-
-  /* let p point to TCP header */
-  pbuf_header(p, -(s16_t)sizeof(struct ip_hdr));
-
-  tcphdr = p->payload;
-  tcphdr->src   = htons(src_port);
-  tcphdr->dest  = htons(dst_port);
-  tcphdr->seqno = htonl(seqno);
-  tcphdr->ackno = htonl(ackno);
-  TCPH_HDRLEN_SET(tcphdr, sizeof(struct tcp_hdr)/4);
-  TCPH_FLAGS_SET(tcphdr, headerflags);
-  tcphdr->wnd   = htons(wnd);
-
-  if (data_len > 0) {
-    /* let p point to TCP data */
-    pbuf_header(p, -(s16_t)sizeof(struct tcp_hdr));
-    /* copy data */
-    pbuf_take(p, data, data_len);
-    /* let p point to TCP header again */
-    pbuf_header(p, sizeof(struct tcp_hdr));
-  }
-
-  /* calculate checksum */
-
-  tcphdr->chksum = inet_chksum_pseudo(p, src_ip, dst_ip,
-          IP_PROTO_TCP, p->tot_len);
-
-  pbuf_header(p, sizeof(struct ip_hdr));
-
-  return p;
-}
-
-/** Create a TCP segment usable for passing to tcp_input */
-struct pbuf*
-tcp_create_segment(ip_addr_t* src_ip, ip_addr_t* dst_ip,
-                   u16_t src_port, u16_t dst_port, void* data, size_t data_len,
-                   u32_t seqno, u32_t ackno, u8_t headerflags)
-{
-  return tcp_create_segment_wnd(src_ip, dst_ip, src_port, dst_port, data,
-    data_len, seqno, ackno, headerflags, TCP_WND);
-}
-
-/** Create a TCP segment usable for passing to tcp_input
- * - IP-addresses, ports, seqno and ackno are taken from pcb
- * - seqno and ackno can be altered with an offset
- */
-struct pbuf*
-tcp_create_rx_segment(struct tcp_pcb* pcb, void* data, size_t data_len, u32_t seqno_offset,
-                      u32_t ackno_offset, u8_t headerflags)
-{
-  return tcp_create_segment(&pcb->remote_ip, &pcb->local_ip, pcb->remote_port, pcb->local_port,
-    data, data_len, pcb->rcv_nxt + seqno_offset, pcb->lastack + ackno_offset, headerflags);
-}
-
-/** Create a TCP segment usable for passing to tcp_input
- * - IP-addresses, ports, seqno and ackno are taken from pcb
- * - seqno and ackno can be altered with an offset
- * - TCP window can be adjusted
- */
-struct pbuf* tcp_create_rx_segment_wnd(struct tcp_pcb* pcb, void* data, size_t data_len,
-                   u32_t seqno_offset, u32_t ackno_offset, u8_t headerflags, u16_t wnd)
-{
-  return tcp_create_segment_wnd(&pcb->remote_ip, &pcb->local_ip, pcb->remote_port, pcb->local_port,
-    data, data_len, pcb->rcv_nxt + seqno_offset, pcb->lastack + ackno_offset, headerflags, wnd);
-}
-
-/** Safely bring a tcp_pcb into the requested state */
-void
-tcp_set_state(struct tcp_pcb* pcb, enum tcp_state state, ip_addr_t* local_ip,
-                   ip_addr_t* remote_ip, u16_t local_port, u16_t remote_port)
-{
-  /* @todo: are these all states? */
-  /* @todo: remove from previous list */
-  pcb->state = state;
-  if (state == ESTABLISHED) {
-    TCP_REG(&tcp_active_pcbs, pcb);
-    pcb->local_ip.addr = local_ip->addr;
-    pcb->local_port = local_port;
-    pcb->remote_ip.addr = remote_ip->addr;
-    pcb->remote_port = remote_port;
-  } else if(state == LISTEN) {
-    TCP_REG(&tcp_listen_pcbs.pcbs, pcb);
-    pcb->local_ip.addr = local_ip->addr;
-    pcb->local_port = local_port;
-  } else if(state == TIME_WAIT) {
-    TCP_REG(&tcp_tw_pcbs, pcb);
-    pcb->local_ip.addr = local_ip->addr;
-    pcb->local_port = local_port;
-    pcb->remote_ip.addr = remote_ip->addr;
-    pcb->remote_port = remote_port;
-  } else {
-    fail();
-  }
-}
-
-void
-test_tcp_counters_err(void* arg, err_t err)
-{
-  struct test_tcp_counters* counters = arg;
-  EXPECT_RET(arg != NULL);
-  counters->err_calls++;
-  counters->last_err = err;
-}
-
-static void
-test_tcp_counters_check_rxdata(struct test_tcp_counters* counters, struct pbuf* p)
-{
-  struct pbuf* q;
-  u32_t i, received;
-  if(counters->expected_data == NULL) {
-    /* no data to compare */
-    return;
-  }
-  EXPECT_RET(counters->recved_bytes + p->tot_len <= counters->expected_data_len);
-  received = counters->recved_bytes;
-  for(q = p; q != NULL; q = q->next) {
-    char *data = q->payload;
-    for(i = 0; i < q->len; i++) {
-      EXPECT_RET(data[i] == counters->expected_data[received]);
-      received++;
-    }
-  }
-  EXPECT(received == counters->recved_bytes + p->tot_len);
-}
-
-err_t
-test_tcp_counters_recv(void* arg, struct tcp_pcb* pcb, struct pbuf* p, err_t err)
-{
-  struct test_tcp_counters* counters = arg;
-  EXPECT_RETX(arg != NULL, ERR_OK);
-  EXPECT_RETX(pcb != NULL, ERR_OK);
-  EXPECT_RETX(err == ERR_OK, ERR_OK);
-
-  if (p != NULL) {
-    if (counters->close_calls == 0) {
-      counters->recv_calls++;
-      test_tcp_counters_check_rxdata(counters, p);
-      counters->recved_bytes += p->tot_len;
-    } else {
-      counters->recv_calls_after_close++;
-      counters->recved_bytes_after_close += p->tot_len;
-    }
-    pbuf_free(p);
-  } else {
-    counters->close_calls++;
-  }
-  EXPECT(counters->recv_calls_after_close == 0 && counters->recved_bytes_after_close == 0);
-  return ERR_OK;
-}
-
-/** Allocate a pcb and set up the test_tcp_counters_* callbacks */
-struct tcp_pcb*
-test_tcp_new_counters_pcb(struct test_tcp_counters* counters)
-{
-  struct tcp_pcb* pcb = tcp_new();
-  if (pcb != NULL) {
-    /* set up args and callbacks */
-    tcp_arg(pcb, counters);
-    tcp_recv(pcb, test_tcp_counters_recv);
-    tcp_err(pcb, test_tcp_counters_err);
-    pcb->snd_wnd = TCP_WND;
-    pcb->snd_wnd_max = TCP_WND;
-  }
-  return pcb;
-}
-
-/** Calls tcp_input() after adjusting current_iphdr_dest */
-void test_tcp_input(struct pbuf *p, struct netif *inp)
-{
-  struct ip_hdr *iphdr = (struct ip_hdr*)p->payload;
-  ip_addr_copy(current_iphdr_dest, iphdr->dest);
-  ip_addr_copy(current_iphdr_src, iphdr->src);
-  current_netif = inp;
-  current_header = iphdr;
-
-  tcp_input(p, inp);
-
-  current_iphdr_dest.addr = 0;
-  current_iphdr_src.addr = 0;
-  current_netif = NULL;
-  current_header = NULL;
-}
-
-static err_t test_tcp_netif_output(struct netif *netif, struct pbuf *p,
-       ip_addr_t *ipaddr)
-{
-  struct test_tcp_txcounters *txcounters = (struct test_tcp_txcounters*)netif->state;
-  LWIP_UNUSED_ARG(ipaddr);
-  txcounters->num_tx_calls++;
-  txcounters->num_tx_bytes += p->tot_len;
-  if (txcounters->copy_tx_packets) {
-    struct pbuf *p_copy = pbuf_alloc(PBUF_LINK, p->tot_len, PBUF_RAM);
-    err_t err;
-    EXPECT(p_copy != NULL);
-    err = pbuf_copy(p_copy, p);
-    EXPECT(err == ERR_OK);
-    if (txcounters->tx_packets == NULL) {
-      txcounters->tx_packets = p_copy;
-    } else {
-      pbuf_cat(txcounters->tx_packets, p_copy);
-    }
-  }
-  return ERR_OK;
-}
-
-void test_tcp_init_netif(struct netif *netif, struct test_tcp_txcounters *txcounters,
-                         ip_addr_t *ip_addr, ip_addr_t *netmask)
-{
-  struct netif *n;
-  memset(netif, 0, sizeof(struct netif));
-  memset(txcounters, 0, sizeof(struct test_tcp_txcounters));
-  netif->output = test_tcp_netif_output;
-  netif->state = txcounters;
-  netif->flags |= NETIF_FLAG_UP;
-  ip_addr_copy(netif->netmask, *netmask);
-  ip_addr_copy(netif->ip_addr, *ip_addr);
-  for (n = netif_list; n != NULL; n = n->next) {
-    if (n == netif) {
-      return;
-    }
-  }
-  netif->next = NULL;
-  netif_list = netif;
-}

ext/lwip/test/unit/tcp/tcp_helper.h

@@ -1,52 +0,0 @@
-#ifndef __TCP_HELPER_H__
-#define __TCP_HELPER_H__
-
-#include "../lwip_check.h"
-#include "lwip/arch.h"
-#include "lwip/tcp.h"
-#include "lwip/netif.h"
-
-/* counters used for test_tcp_counters_* callback functions */
-struct test_tcp_counters {
-  u32_t recv_calls;
-  u32_t recved_bytes;
-  u32_t recv_calls_after_close;
-  u32_t recved_bytes_after_close;
-  u32_t close_calls;
-  u32_t err_calls;
-  err_t last_err;
-  char* expected_data;
-  u32_t expected_data_len;
-};
-
-struct test_tcp_txcounters {
-  u32_t num_tx_calls;
-  u32_t num_tx_bytes;
-  u8_t  copy_tx_packets;
-  struct pbuf *tx_packets;
-};
-
-/* Helper functions */
-void tcp_remove_all(void);
-
-struct pbuf* tcp_create_segment(ip_addr_t* src_ip, ip_addr_t* dst_ip,
-                   u16_t src_port, u16_t dst_port, void* data, size_t data_len,
-                   u32_t seqno, u32_t ackno, u8_t headerflags);
-struct pbuf* tcp_create_rx_segment(struct tcp_pcb* pcb, void* data, size_t data_len,
-                   u32_t seqno_offset, u32_t ackno_offset, u8_t headerflags);
-struct pbuf* tcp_create_rx_segment_wnd(struct tcp_pcb* pcb, void* data, size_t data_len,
-                   u32_t seqno_offset, u32_t ackno_offset, u8_t headerflags, u16_t wnd);
-void tcp_set_state(struct tcp_pcb* pcb, enum tcp_state state, ip_addr_t* local_ip,
-                   ip_addr_t* remote_ip, u16_t local_port, u16_t remote_port);
-void test_tcp_counters_err(void* arg, err_t err);
-err_t test_tcp_counters_recv(void* arg, struct tcp_pcb* pcb, struct pbuf* p, err_t err);
-
-struct tcp_pcb* test_tcp_new_counters_pcb(struct test_tcp_counters* counters);
-
-void test_tcp_input(struct pbuf *p, struct netif *inp);
-
-void test_tcp_init_netif(struct netif *netif, struct test_tcp_txcounters *txcounters,
-                         ip_addr_t *ip_addr, ip_addr_t *netmask);
-
-
-#endif

ext/lwip/test/unit/tcp/test_tcp.c

@@ -1,667 +0,0 @@
-#include "test_tcp.h"
-
-#include "lwip/tcp_impl.h"
-#include "lwip/stats.h"
-#include "tcp_helper.h"
-
-#ifdef _MSC_VER
-#pragma warning(disable: 4307) /* we explicitly wrap around TCP seqnos */
-#endif
-
-#if !LWIP_STATS || !TCP_STATS || !MEMP_STATS
-#error "This tests needs TCP- and MEMP-statistics enabled"
-#endif
-#if TCP_SND_BUF <= TCP_WND
-#error "This tests needs TCP_SND_BUF to be > TCP_WND"
-#endif
-
-static u8_t test_tcp_timer;
-
-/* our own version of tcp_tmr so we can reset fast/slow timer state */
-static void
-test_tcp_tmr(void)
-{
-  tcp_fasttmr();
-  if (++test_tcp_timer & 1) {
-    tcp_slowtmr();
-  }
-}
-
-/* Setups/teardown functions */
-
-static void
-tcp_setup(void)
-{
-  /* reset iss to default (6510) */
-  tcp_ticks = 0;
-  tcp_ticks = 0 - (tcp_next_iss() - 6510);
-  tcp_next_iss();
-  tcp_ticks = 0;
-
-  test_tcp_timer = 0;
-  tcp_remove_all();
-}
-
-static void
-tcp_teardown(void)
-{
-  netif_list = NULL;
-  tcp_remove_all();
-}
-
-
-/* Test functions */
-
-/** Call tcp_new() and tcp_abort() and test memp stats */
-START_TEST(test_tcp_new_abort)
-{
-  struct tcp_pcb* pcb;
-  LWIP_UNUSED_ARG(_i);
-
-  fail_unless(lwip_stats.memp[MEMP_TCP_PCB].used == 0);
-
-  pcb = tcp_new();
-  fail_unless(pcb != NULL);
-  if (pcb != NULL) {
-    fail_unless(lwip_stats.memp[MEMP_TCP_PCB].used == 1);
-    tcp_abort(pcb);
-    fail_unless(lwip_stats.memp[MEMP_TCP_PCB].used == 0);
-  }
-}
-END_TEST
-
-/** Create an ESTABLISHED pcb and check if receive callback is called */
-START_TEST(test_tcp_recv_inseq)
-{
-  struct test_tcp_counters counters;
-  struct tcp_pcb* pcb;
-  struct pbuf* p;
-  char data[] = {1, 2, 3, 4};
-  ip_addr_t remote_ip, local_ip;
-  u16_t data_len;
-  u16_t remote_port = 0x100, local_port = 0x101;
-  struct netif netif;
-  LWIP_UNUSED_ARG(_i);
-
-  /* initialize local vars */
-  memset(&netif, 0, sizeof(netif));
-  IP4_ADDR(&local_ip, 192, 168, 1, 1);
-  IP4_ADDR(&remote_ip, 192, 168, 1, 2);
-  data_len = sizeof(data);
-  /* initialize counter struct */
-  memset(&counters, 0, sizeof(counters));
-  counters.expected_data_len = data_len;
-  counters.expected_data = data;
-
-  /* create and initialize the pcb */
-  pcb = test_tcp_new_counters_pcb(&counters);
-  EXPECT_RET(pcb != NULL);
-  tcp_set_state(pcb, ESTABLISHED, &local_ip, &remote_ip, local_port, remote_port);
-
-  /* create a segment */
-  p = tcp_create_rx_segment(pcb, counters.expected_data, data_len, 0, 0, 0);
-  EXPECT(p != NULL);
-  if (p != NULL) {
-    /* pass the segment to tcp_input */
-    test_tcp_input(p, &netif);
-    /* check if counters are as expected */
-    EXPECT(counters.close_calls == 0);
-    EXPECT(counters.recv_calls == 1);
-    EXPECT(counters.recved_bytes == data_len);
-    EXPECT(counters.err_calls == 0);
-  }
-
-  /* make sure the pcb is freed */
-  EXPECT(lwip_stats.memp[MEMP_TCP_PCB].used == 1);
-  tcp_abort(pcb);
-  EXPECT(lwip_stats.memp[MEMP_TCP_PCB].used == 0);
-}
-END_TEST
-
-/** Provoke fast retransmission by duplicate ACKs and then recover by ACKing all sent data.
- * At the end, send more data. */
-START_TEST(test_tcp_fast_retx_recover)
-{
-  struct netif netif;
-  struct test_tcp_txcounters txcounters;
-  struct test_tcp_counters counters;
-  struct tcp_pcb* pcb;
-  struct pbuf* p;
-  char data1[] = { 1,  2,  3,  4};
-  char data2[] = { 5,  6,  7,  8};
-  char data3[] = { 9, 10, 11, 12};
-  char data4[] = {13, 14, 15, 16};
-  char data5[] = {17, 18, 19, 20};
-  char data6[] = {21, 22, 23, 24};
-  ip_addr_t remote_ip, local_ip, netmask;
-  u16_t remote_port = 0x100, local_port = 0x101;
-  err_t err;
-  LWIP_UNUSED_ARG(_i);
-
-  /* initialize local vars */
-  IP4_ADDR(&local_ip,  192, 168,   1, 1);
-  IP4_ADDR(&remote_ip, 192, 168,   1, 2);
-  IP4_ADDR(&netmask,   255, 255, 255, 0);
-  test_tcp_init_netif(&netif, &txcounters, &local_ip, &netmask);
-  memset(&counters, 0, sizeof(counters));
-
-  /* create and initialize the pcb */
-  pcb = test_tcp_new_counters_pcb(&counters);
-  EXPECT_RET(pcb != NULL);
-  tcp_set_state(pcb, ESTABLISHED, &local_ip, &remote_ip, local_port, remote_port);
-  pcb->mss = TCP_MSS;
-  /* disable initial congestion window (we don't send a SYN here...) */
-  pcb->cwnd = pcb->snd_wnd;
-
-  /* send data1 */
-  err = tcp_write(pcb, data1, sizeof(data1), TCP_WRITE_FLAG_COPY);
-  EXPECT_RET(err == ERR_OK);
-  err = tcp_output(pcb);
-  EXPECT_RET(err == ERR_OK);
-  EXPECT_RET(txcounters.num_tx_calls == 1);
-  EXPECT_RET(txcounters.num_tx_bytes == sizeof(data1) + sizeof(struct tcp_hdr) + sizeof(struct ip_hdr));
-  memset(&txcounters, 0, sizeof(txcounters));
- /* "recv" ACK for data1 */
-  p = tcp_create_rx_segment(pcb, NULL, 0, 0, 4, TCP_ACK);
-  EXPECT_RET(p != NULL);
-  test_tcp_input(p, &netif);
-  EXPECT_RET(txcounters.num_tx_calls == 0);
-  EXPECT_RET(pcb->unacked == NULL);
-  /* send data2 */
-  err = tcp_write(pcb, data2, sizeof(data2), TCP_WRITE_FLAG_COPY);
-  EXPECT_RET(err == ERR_OK);
-  err = tcp_output(pcb);
-  EXPECT_RET(err == ERR_OK);
-  EXPECT_RET(txcounters.num_tx_calls == 1);
-  EXPECT_RET(txcounters.num_tx_bytes == sizeof(data2) + sizeof(struct tcp_hdr) + sizeof(struct ip_hdr));
-  memset(&txcounters, 0, sizeof(txcounters));
-  /* duplicate ACK for data1 (data2 is lost) */
-  p = tcp_create_rx_segment(pcb, NULL, 0, 0, 0, TCP_ACK);
-  EXPECT_RET(p != NULL);
-  test_tcp_input(p, &netif);
-  EXPECT_RET(txcounters.num_tx_calls == 0);
-  EXPECT_RET(pcb->dupacks == 1);
-  /* send data3 */
-  err = tcp_write(pcb, data3, sizeof(data3), TCP_WRITE_FLAG_COPY);
-  EXPECT_RET(err == ERR_OK);
-  err = tcp_output(pcb);
-  EXPECT_RET(err == ERR_OK);
-  /* nagle enabled, no tx calls */
-  EXPECT_RET(txcounters.num_tx_calls == 0);
-  EXPECT_RET(txcounters.num_tx_bytes == 0);
-  memset(&txcounters, 0, sizeof(txcounters));
-  /* 2nd duplicate ACK for data1 (data2 and data3 are lost) */
-  p = tcp_create_rx_segment(pcb, NULL, 0, 0, 0, TCP_ACK);
-  EXPECT_RET(p != NULL);
-  test_tcp_input(p, &netif);
-  EXPECT_RET(txcounters.num_tx_calls == 0);
-  EXPECT_RET(pcb->dupacks == 2);
-  /* queue data4, don't send it (unsent-oversize is != 0) */
-  err = tcp_write(pcb, data4, sizeof(data4), TCP_WRITE_FLAG_COPY);
-  EXPECT_RET(err == ERR_OK);
-  /* 3nd duplicate ACK for data1 (data2 and data3 are lost) -> fast retransmission */
-  p = tcp_create_rx_segment(pcb, NULL, 0, 0, 0, TCP_ACK);
-  EXPECT_RET(p != NULL);
-  test_tcp_input(p, &netif);
-  /*EXPECT_RET(txcounters.num_tx_calls == 1);*/
-  EXPECT_RET(pcb->dupacks == 3);
-  memset(&txcounters, 0, sizeof(txcounters));
-  /* TODO: check expected data?*/
-  
-  /* send data5, not output yet */
-  err = tcp_write(pcb, data5, sizeof(data5), TCP_WRITE_FLAG_COPY);
-  EXPECT_RET(err == ERR_OK);
-  /*err = tcp_output(pcb);
-  EXPECT_RET(err == ERR_OK);*/
-  EXPECT_RET(txcounters.num_tx_calls == 0);
-  EXPECT_RET(txcounters.num_tx_bytes == 0);
-  memset(&txcounters, 0, sizeof(txcounters));
-  {
-    int i = 0;
-    do
-    {
-      err = tcp_write(pcb, data6, TCP_MSS, TCP_WRITE_FLAG_COPY);
-      i++;
-    }while(err == ERR_OK);
-    EXPECT_RET(err != ERR_OK);
-  }
-  err = tcp_output(pcb);
-  EXPECT_RET(err == ERR_OK);
-  /*EXPECT_RET(txcounters.num_tx_calls == 0);
-  EXPECT_RET(txcounters.num_tx_bytes == 0);*/
-  memset(&txcounters, 0, sizeof(txcounters));
-
-  /* send even more data */
-  err = tcp_write(pcb, data5, sizeof(data5), TCP_WRITE_FLAG_COPY);
-  EXPECT_RET(err == ERR_OK);
-  err = tcp_output(pcb);
-  EXPECT_RET(err == ERR_OK);
-  /* ...and even more data */
-  err = tcp_write(pcb, data5, sizeof(data5), TCP_WRITE_FLAG_COPY);
-  EXPECT_RET(err == ERR_OK);
-  err = tcp_output(pcb);
-  EXPECT_RET(err == ERR_OK);
-  /* ...and even more data */
-  err = tcp_write(pcb, data5, sizeof(data5), TCP_WRITE_FLAG_COPY);
-  EXPECT_RET(err == ERR_OK);
-  err = tcp_output(pcb);
-  EXPECT_RET(err == ERR_OK);
-  /* ...and even more data */
-  err = tcp_write(pcb, data5, sizeof(data5), TCP_WRITE_FLAG_COPY);
-  EXPECT_RET(err == ERR_OK);
-  err = tcp_output(pcb);
-  EXPECT_RET(err == ERR_OK);
-
-  /* send ACKs for data2 and data3 */
-  p = tcp_create_rx_segment(pcb, NULL, 0, 0, 12, TCP_ACK);
-  EXPECT_RET(p != NULL);
-  test_tcp_input(p, &netif);
-  /*EXPECT_RET(txcounters.num_tx_calls == 0);*/
-
-  /* ...and even more data */
-  err = tcp_write(pcb, data5, sizeof(data5), TCP_WRITE_FLAG_COPY);
-  EXPECT_RET(err == ERR_OK);
-  err = tcp_output(pcb);
-  EXPECT_RET(err == ERR_OK);
-  /* ...and even more data */
-  err = tcp_write(pcb, data5, sizeof(data5), TCP_WRITE_FLAG_COPY);
-  EXPECT_RET(err == ERR_OK);
-  err = tcp_output(pcb);
-  EXPECT_RET(err == ERR_OK);
-
-#if 0
-  /* create expected segment */
-  p1 = tcp_create_rx_segment(pcb, counters.expected_data, data_len, 0, 0, 0);
-  EXPECT_RET(p != NULL);
-  if (p != NULL) {
-    /* pass the segment to tcp_input */
-    test_tcp_input(p, &netif);
-    /* check if counters are as expected */
-    EXPECT_RET(counters.close_calls == 0);
-    EXPECT_RET(counters.recv_calls == 1);
-    EXPECT_RET(counters.recved_bytes == data_len);
-    EXPECT_RET(counters.err_calls == 0);
-  }
-#endif
-  /* make sure the pcb is freed */
-  EXPECT_RET(lwip_stats.memp[MEMP_TCP_PCB].used == 1);
-  tcp_abort(pcb);
-  EXPECT_RET(lwip_stats.memp[MEMP_TCP_PCB].used == 0);
-}
-END_TEST
-
-static u8_t tx_data[TCP_WND*2];
-
-static void
-check_seqnos(struct tcp_seg *segs, int num_expected, u32_t *seqnos_expected)
-{
-  struct tcp_seg *s = segs;
-  int i;
-  for (i = 0; i < num_expected; i++, s = s->next) {
-    EXPECT_RET(s != NULL);
-    EXPECT(s->tcphdr->seqno == htonl(seqnos_expected[i]));
-  }
-  EXPECT(s == NULL);
-}
-
-/** Send data with sequence numbers that wrap around the u32_t range.
- * Then, provoke fast retransmission by duplicate ACKs and check that all
- * segment lists are still properly sorted. */
-START_TEST(test_tcp_fast_rexmit_wraparound)
-{
-  struct netif netif;
-  struct test_tcp_txcounters txcounters;
-  struct test_tcp_counters counters;
-  struct tcp_pcb* pcb;
-  struct pbuf* p;
-  ip_addr_t remote_ip, local_ip, netmask;
-  u16_t remote_port = 0x100, local_port = 0x101;
-  err_t err;
-#define SEQNO1 (0xFFFFFF00 - TCP_MSS)
-#define ISS    6510
-  u16_t i, sent_total = 0;
-  u32_t seqnos[] = {
-    SEQNO1,
-    SEQNO1 + (1 * TCP_MSS),
-    SEQNO1 + (2 * TCP_MSS),
-    SEQNO1 + (3 * TCP_MSS),
-    SEQNO1 + (4 * TCP_MSS),
-    SEQNO1 + (5 * TCP_MSS)};
-  LWIP_UNUSED_ARG(_i);
-
-  for (i = 0; i < sizeof(tx_data); i++) {
-    tx_data[i] = (u8_t)i;
-  }
-
-  /* initialize local vars */
-  IP4_ADDR(&local_ip,  192, 168,   1, 1);
-  IP4_ADDR(&remote_ip, 192, 168,   1, 2);
-  IP4_ADDR(&netmask,   255, 255, 255, 0);
-  test_tcp_init_netif(&netif, &txcounters, &local_ip, &netmask);
-  memset(&counters, 0, sizeof(counters));
-
-  /* create and initialize the pcb */
-  tcp_ticks = SEQNO1 - ISS;
-  pcb = test_tcp_new_counters_pcb(&counters);
-  EXPECT_RET(pcb != NULL);
-  EXPECT(pcb->lastack == SEQNO1);
-  tcp_set_state(pcb, ESTABLISHED, &local_ip, &remote_ip, local_port, remote_port);
-  pcb->mss = TCP_MSS;
-  /* disable initial congestion window (we don't send a SYN here...) */
-  pcb->cwnd = 2*TCP_MSS;
-
-  /* send 6 mss-sized segments */
-  for (i = 0; i < 6; i++) {
-    err = tcp_write(pcb, &tx_data[sent_total], TCP_MSS, TCP_WRITE_FLAG_COPY);
-    EXPECT_RET(err == ERR_OK);
-    sent_total += TCP_MSS;
-  }
-  check_seqnos(pcb->unsent, 6, seqnos);
-  EXPECT(pcb->unacked == NULL);
-  err = tcp_output(pcb);
-  EXPECT(txcounters.num_tx_calls == 2);
-  EXPECT(txcounters.num_tx_bytes == 2 * (TCP_MSS + 40U));
-  memset(&txcounters, 0, sizeof(txcounters));
-
-  check_seqnos(pcb->unacked, 2, seqnos);
-  check_seqnos(pcb->unsent, 4, &seqnos[2]);
-
-  /* ACK the first segment */
-  p = tcp_create_rx_segment(pcb, NULL, 0, 0, TCP_MSS, TCP_ACK);
-  test_tcp_input(p, &netif);
-  /* ensure this didn't trigger a retransmission */
-  EXPECT(txcounters.num_tx_calls == 1);
-  EXPECT(txcounters.num_tx_bytes == TCP_MSS + 40U);
-  memset(&txcounters, 0, sizeof(txcounters));
-  check_seqnos(pcb->unacked, 2, &seqnos[1]);
-  check_seqnos(pcb->unsent, 3, &seqnos[3]);
-
-  /* 3 dupacks */
-  EXPECT(pcb->dupacks == 0);
-  p = tcp_create_rx_segment(pcb, NULL, 0, 0, 0, TCP_ACK);
-  test_tcp_input(p, &netif);
-  EXPECT(txcounters.num_tx_calls == 0);
-  EXPECT(pcb->dupacks == 1);
-  p = tcp_create_rx_segment(pcb, NULL, 0, 0, 0, TCP_ACK);
-  test_tcp_input(p, &netif);
-  EXPECT(txcounters.num_tx_calls == 0);
-  EXPECT(pcb->dupacks == 2);
-  /* 3rd dupack -> fast rexmit */
-  p = tcp_create_rx_segment(pcb, NULL, 0, 0, 0, TCP_ACK);
-  test_tcp_input(p, &netif);
-  EXPECT(pcb->dupacks == 3);
-  EXPECT(txcounters.num_tx_calls == 4);
-  memset(&txcounters, 0, sizeof(txcounters));
-  EXPECT(pcb->unsent == NULL);
-  check_seqnos(pcb->unacked, 5, &seqnos[1]);
-
-  /* make sure the pcb is freed */
-  EXPECT_RET(lwip_stats.memp[MEMP_TCP_PCB].used == 1);
-  tcp_abort(pcb);
-  EXPECT_RET(lwip_stats.memp[MEMP_TCP_PCB].used == 0);
-}
-END_TEST
-
-/** Send data with sequence numbers that wrap around the u32_t range.
- * Then, provoke RTO retransmission and check that all
- * segment lists are still properly sorted. */
-START_TEST(test_tcp_rto_rexmit_wraparound)
-{
-  struct netif netif;
-  struct test_tcp_txcounters txcounters;
-  struct test_tcp_counters counters;
-  struct tcp_pcb* pcb;
-  ip_addr_t remote_ip, local_ip, netmask;
-  u16_t remote_port = 0x100, local_port = 0x101;
-  err_t err;
-#define SEQNO1 (0xFFFFFF00 - TCP_MSS)
-#define ISS    6510
-  u16_t i, sent_total = 0;
-  u32_t seqnos[] = {
-    SEQNO1,
-    SEQNO1 + (1 * TCP_MSS),
-    SEQNO1 + (2 * TCP_MSS),
-    SEQNO1 + (3 * TCP_MSS),
-    SEQNO1 + (4 * TCP_MSS),
-    SEQNO1 + (5 * TCP_MSS)};
-  LWIP_UNUSED_ARG(_i);
-
-  for (i = 0; i < sizeof(tx_data); i++) {
-    tx_data[i] = (u8_t)i;
-  }
-
-  /* initialize local vars */
-  IP4_ADDR(&local_ip,  192, 168,   1, 1);
-  IP4_ADDR(&remote_ip, 192, 168,   1, 2);
-  IP4_ADDR(&netmask,   255, 255, 255, 0);
-  test_tcp_init_netif(&netif, &txcounters, &local_ip, &netmask);
-  memset(&counters, 0, sizeof(counters));
-
-  /* create and initialize the pcb */
-  tcp_ticks = 0;
-  tcp_ticks = 0 - tcp_next_iss();
-  tcp_ticks = SEQNO1 - tcp_next_iss();
-  pcb = test_tcp_new_counters_pcb(&counters);
-  EXPECT_RET(pcb != NULL);
-  EXPECT(pcb->lastack == SEQNO1);
-  tcp_set_state(pcb, ESTABLISHED, &local_ip, &remote_ip, local_port, remote_port);
-  pcb->mss = TCP_MSS;
-  /* disable initial congestion window (we don't send a SYN here...) */
-  pcb->cwnd = 2*TCP_MSS;
-
-  /* send 6 mss-sized segments */
-  for (i = 0; i < 6; i++) {
-    err = tcp_write(pcb, &tx_data[sent_total], TCP_MSS, TCP_WRITE_FLAG_COPY);
-    EXPECT_RET(err == ERR_OK);
-    sent_total += TCP_MSS;
-  }
-  check_seqnos(pcb->unsent, 6, seqnos);
-  EXPECT(pcb->unacked == NULL);
-  err = tcp_output(pcb);
-  EXPECT(txcounters.num_tx_calls == 2);
-  EXPECT(txcounters.num_tx_bytes == 2 * (TCP_MSS + 40U));
-  memset(&txcounters, 0, sizeof(txcounters));
-
-  check_seqnos(pcb->unacked, 2, seqnos);
-  check_seqnos(pcb->unsent, 4, &seqnos[2]);
-
-  /* call the tcp timer some times */
-  for (i = 0; i < 10; i++) {
-    test_tcp_tmr();
-    EXPECT(txcounters.num_tx_calls == 0);
-  }
-  /* 11th call to tcp_tmr: RTO rexmit fires */
-  test_tcp_tmr();
-  EXPECT(txcounters.num_tx_calls == 1);
-  check_seqnos(pcb->unacked, 1, seqnos);
-  check_seqnos(pcb->unsent, 5, &seqnos[1]);
-
-  /* fake greater cwnd */
-  pcb->cwnd = pcb->snd_wnd;
-  /* send more data */
-  err = tcp_output(pcb);
-  EXPECT(err == ERR_OK);
-  /* check queues are sorted */
-  EXPECT(pcb->unsent == NULL);
-  check_seqnos(pcb->unacked, 6, seqnos);
-
-  /* make sure the pcb is freed */
-  EXPECT_RET(lwip_stats.memp[MEMP_TCP_PCB].used == 1);
-  tcp_abort(pcb);
-  EXPECT_RET(lwip_stats.memp[MEMP_TCP_PCB].used == 0);
-}
-END_TEST
-
-/** Provoke fast retransmission by duplicate ACKs and then recover by ACKing all sent data.
- * At the end, send more data. */
-static void test_tcp_tx_full_window_lost(u8_t zero_window_probe_from_unsent)
-{
-  struct netif netif;
-  struct test_tcp_txcounters txcounters;
-  struct test_tcp_counters counters;
-  struct tcp_pcb* pcb;
-  struct pbuf *p;
-  ip_addr_t remote_ip, local_ip, netmask;
-  u16_t remote_port = 0x100, local_port = 0x101;
-  err_t err;
-  u16_t sent_total, i;
-  u8_t expected = 0xFE;
-
-  for (i = 0; i < sizeof(tx_data); i++) {
-    u8_t d = (u8_t)i;
-    if (d == 0xFE) {
-      d = 0xF0;
-    }
-    tx_data[i] = d;
-  }
-  if (zero_window_probe_from_unsent) {
-    tx_data[TCP_WND] = expected;
-  } else {
-    tx_data[0] = expected;
-  }
-
-  /* initialize local vars */
-  IP4_ADDR(&local_ip,  192, 168,   1, 1);
-  IP4_ADDR(&remote_ip, 192, 168,   1, 2);
-  IP4_ADDR(&netmask,   255, 255, 255, 0);
-  test_tcp_init_netif(&netif, &txcounters, &local_ip, &netmask);
-  memset(&counters, 0, sizeof(counters));
-  memset(&txcounters, 0, sizeof(txcounters));
-
-  /* create and initialize the pcb */
-  pcb = test_tcp_new_counters_pcb(&counters);
-  EXPECT_RET(pcb != NULL);
-  tcp_set_state(pcb, ESTABLISHED, &local_ip, &remote_ip, local_port, remote_port);
-  pcb->mss = TCP_MSS;
-  /* disable initial congestion window (we don't send a SYN here...) */
-  pcb->cwnd = pcb->snd_wnd;
-
-  /* send a full window (minus 1 packets) of TCP data in MSS-sized chunks */
-  sent_total = 0;
-  if ((TCP_WND - TCP_MSS) % TCP_MSS != 0) {
-    u16_t initial_data_len = (TCP_WND - TCP_MSS) % TCP_MSS;
-    err = tcp_write(pcb, &tx_data[sent_total], initial_data_len, TCP_WRITE_FLAG_COPY);
-    EXPECT_RET(err == ERR_OK);
-    err = tcp_output(pcb);
-    EXPECT_RET(err == ERR_OK);
-    EXPECT(txcounters.num_tx_calls == 1);
-    EXPECT(txcounters.num_tx_bytes == initial_data_len + 40U);
-    memset(&txcounters, 0, sizeof(txcounters));
-    sent_total += initial_data_len;
-  }
-  for (; sent_total < (TCP_WND - TCP_MSS); sent_total += TCP_MSS) {
-    err = tcp_write(pcb, &tx_data[sent_total], TCP_MSS, TCP_WRITE_FLAG_COPY);
-    EXPECT_RET(err == ERR_OK);
-    err = tcp_output(pcb);
-    EXPECT_RET(err == ERR_OK);
-    EXPECT(txcounters.num_tx_calls == 1);
-    EXPECT(txcounters.num_tx_bytes == TCP_MSS + 40U);
-    memset(&txcounters, 0, sizeof(txcounters));
-  }
-  EXPECT(sent_total == (TCP_WND - TCP_MSS));
-
-  /* now ACK the packet before the first */
-  p = tcp_create_rx_segment(pcb, NULL, 0, 0, 0, TCP_ACK);
-  test_tcp_input(p, &netif);
-  /* ensure this didn't trigger a retransmission */
-  EXPECT(txcounters.num_tx_calls == 0);
-  EXPECT(txcounters.num_tx_bytes == 0);
-
-  EXPECT(pcb->persist_backoff == 0);
-  /* send the last packet, now a complete window has been sent */
-  err = tcp_write(pcb, &tx_data[sent_total], TCP_MSS, TCP_WRITE_FLAG_COPY);
-  sent_total += TCP_MSS;
-  EXPECT_RET(err == ERR_OK);
-  err = tcp_output(pcb);
-  EXPECT_RET(err == ERR_OK);
-  EXPECT(txcounters.num_tx_calls == 1);
-  EXPECT(txcounters.num_tx_bytes == TCP_MSS + 40U);
-  memset(&txcounters, 0, sizeof(txcounters));
-  EXPECT(pcb->persist_backoff == 0);
-
-  if (zero_window_probe_from_unsent) {
-    /* ACK all data but close the TX window */
-    p = tcp_create_rx_segment_wnd(pcb, NULL, 0, 0, TCP_WND, TCP_ACK, 0);
-    test_tcp_input(p, &netif);
-    /* ensure this didn't trigger any transmission */
-    EXPECT(txcounters.num_tx_calls == 0);
-    EXPECT(txcounters.num_tx_bytes == 0);
-    EXPECT(pcb->persist_backoff == 1);
-  }
-
-  /* send one byte more (out of window) -> persist timer starts */
-  err = tcp_write(pcb, &tx_data[sent_total], 1, TCP_WRITE_FLAG_COPY);
-  EXPECT_RET(err == ERR_OK);
-  err = tcp_output(pcb);
-  EXPECT_RET(err == ERR_OK);
-  EXPECT(txcounters.num_tx_calls == 0);
-  EXPECT(txcounters.num_tx_bytes == 0);
-  memset(&txcounters, 0, sizeof(txcounters));
-  if (!zero_window_probe_from_unsent) {
-    /* no persist timer unless a zero window announcement has been received */
-    EXPECT(pcb->persist_backoff == 0);
-  } else {
-    EXPECT(pcb->persist_backoff == 1);
-
-    /* call tcp_timer some more times to let persist timer count up */
-    for (i = 0; i < 4; i++) {
-      test_tcp_tmr();
-      EXPECT(txcounters.num_tx_calls == 0);
-      EXPECT(txcounters.num_tx_bytes == 0);
-    }
-
-    /* this should trigger the zero-window-probe */
-    txcounters.copy_tx_packets = 1;
-    test_tcp_tmr();
-    txcounters.copy_tx_packets = 0;
-    EXPECT(txcounters.num_tx_calls == 1);
-    EXPECT(txcounters.num_tx_bytes == 1 + 40U);
-    EXPECT(txcounters.tx_packets != NULL);
-    if (txcounters.tx_packets != NULL) {
-      u8_t sent;
-      u16_t ret;
-      ret = pbuf_copy_partial(txcounters.tx_packets, &sent, 1, 40U);
-      EXPECT(ret == 1);
-      EXPECT(sent == expected);
-    }
-    if (txcounters.tx_packets != NULL) {
-      pbuf_free(txcounters.tx_packets);
-      txcounters.tx_packets = NULL;
-    }
-  }
-
-  /* make sure the pcb is freed */
-  EXPECT_RET(lwip_stats.memp[MEMP_TCP_PCB].used == 1);
-  tcp_abort(pcb);
-  EXPECT_RET(lwip_stats.memp[MEMP_TCP_PCB].used == 0);
-}
-
-START_TEST(test_tcp_tx_full_window_lost_from_unsent)
-{
-  LWIP_UNUSED_ARG(_i);
-  test_tcp_tx_full_window_lost(1);
-}
-END_TEST
-
-START_TEST(test_tcp_tx_full_window_lost_from_unacked)
-{
-  LWIP_UNUSED_ARG(_i);
-  test_tcp_tx_full_window_lost(0);
-}
-END_TEST
-
-/** Create the suite including all tests for this module */
-Suite *
-tcp_suite(void)
-{
-  TFun tests[] = {
-    test_tcp_new_abort,
-    test_tcp_recv_inseq,
-    test_tcp_fast_retx_recover,
-    test_tcp_fast_rexmit_wraparound,
-    test_tcp_rto_rexmit_wraparound,
-    test_tcp_tx_full_window_lost_from_unacked,
-    test_tcp_tx_full_window_lost_from_unsent
-  };
-  return create_suite("TCP", tests, sizeof(tests)/sizeof(TFun), tcp_setup, tcp_teardown);
-}

ext/lwip/test/unit/tcp/test_tcp.h

@@ -1,8 +0,0 @@
-#ifndef __TEST_TCP_H__
-#define __TEST_TCP_H__
-
-#include "../lwip_check.h"
-
-Suite *tcp_suite(void);
-
-#endif

ext/lwip/test/unit/tcp/test_tcp_oos.c

@@ -1,944 +0,0 @@
-#include "test_tcp_oos.h"
-
-#include "lwip/tcp_impl.h"
-#include "lwip/stats.h"
-#include "tcp_helper.h"
-
-#if !LWIP_STATS || !TCP_STATS || !MEMP_STATS
-#error "This tests needs TCP- and MEMP-statistics enabled"
-#endif
-#if !TCP_QUEUE_OOSEQ
-#error "This tests needs TCP_QUEUE_OOSEQ enabled"
-#endif
-
-/** CHECK_SEGMENTS_ON_OOSEQ:
- * 1: check count, seqno and len of segments on pcb->ooseq (strict)
- * 0: only check that bytes are received in correct order (less strict) */
-#define CHECK_SEGMENTS_ON_OOSEQ 1
-
-#if CHECK_SEGMENTS_ON_OOSEQ
-#define EXPECT_OOSEQ(x) EXPECT(x)
-#else
-#define EXPECT_OOSEQ(x)
-#endif
-
-/* helper functions */
-
-/** Get the numbers of segments on the ooseq list */
-static int tcp_oos_count(struct tcp_pcb* pcb)
-{
-  int num = 0;
-  struct tcp_seg* seg = pcb->ooseq;
-  while(seg != NULL) {
-    num++;
-    seg = seg->next;
-  }
-  return num;
-}
-
-/** Get the numbers of pbufs on the ooseq list */
-static int tcp_oos_pbuf_count(struct tcp_pcb* pcb)
-{
-  int num = 0;
-  struct tcp_seg* seg = pcb->ooseq;
-  while(seg != NULL) {
-    num += pbuf_clen(seg->p);
-    seg = seg->next;
-  }
-  return num;
-}
-
-/** Get the seqno of a segment (by index) on the ooseq list
- *
- * @param pcb the pcb to check for ooseq segments
- * @param seg_index index of the segment on the ooseq list
- * @return seqno of the segment
- */
-static u32_t
-tcp_oos_seg_seqno(struct tcp_pcb* pcb, int seg_index)
-{
-  int num = 0;
-  struct tcp_seg* seg = pcb->ooseq;
-
-  /* then check the actual segment */
-  while(seg != NULL) {
-    if(num == seg_index) {
-      return seg->tcphdr->seqno;
-    }
-    num++;
-    seg = seg->next;
-  }
-  fail();
-  return 0;
-}
-
-/** Get the tcplen (datalen + SYN/FIN) of a segment (by index) on the ooseq list
- *
- * @param pcb the pcb to check for ooseq segments
- * @param seg_index index of the segment on the ooseq list
- * @return tcplen of the segment
- */
-static int
-tcp_oos_seg_tcplen(struct tcp_pcb* pcb, int seg_index)
-{
-  int num = 0;
-  struct tcp_seg* seg = pcb->ooseq;
-
-  /* then check the actual segment */
-  while(seg != NULL) {
-    if(num == seg_index) {
-      return TCP_TCPLEN(seg);
-    }
-    num++;
-    seg = seg->next;
-  }
-  fail();
-  return -1;
-}
-
-/** Get the tcplen (datalen + SYN/FIN) of all segments on the ooseq list
- *
- * @param pcb the pcb to check for ooseq segments
- * @return tcplen of all segment
- */
-static int
-tcp_oos_tcplen(struct tcp_pcb* pcb)
-{
-  int len = 0;
-  struct tcp_seg* seg = pcb->ooseq;
-
-  /* then check the actual segment */
-  while(seg != NULL) {
-    len += TCP_TCPLEN(seg);
-    seg = seg->next;
-  }
-  return len;
-}
-
-/* Setup/teardown functions */
-
-static void
-tcp_oos_setup(void)
-{
-  tcp_remove_all();
-}
-
-static void
-tcp_oos_teardown(void)
-{
-  tcp_remove_all();
-}
-
-
-
-/* Test functions */
-
-/** create multiple segments and pass them to tcp_input in a wrong
- * order to see if ooseq-caching works correctly
- * FIN is received in out-of-sequence segments only */
-START_TEST(test_tcp_recv_ooseq_FIN_OOSEQ)
-{
-  struct test_tcp_counters counters;
-  struct tcp_pcb* pcb;
-  struct pbuf *p_8_9, *p_4_8, *p_4_10, *p_2_14, *p_fin, *pinseq;
-  char data[] = {
-     1,  2,  3,  4,
-     5,  6,  7,  8,
-     9, 10, 11, 12,
-    13, 14, 15, 16};
-  ip_addr_t remote_ip, local_ip;
-  u16_t data_len;
-  u16_t remote_port = 0x100, local_port = 0x101;
-  struct netif netif;
-  LWIP_UNUSED_ARG(_i);
-
-  /* initialize local vars */
-  memset(&netif, 0, sizeof(netif));
-  IP4_ADDR(&local_ip, 192, 168, 1, 1);
-  IP4_ADDR(&remote_ip, 192, 168, 1, 2);
-  data_len = sizeof(data);
-  /* initialize counter struct */
-  memset(&counters, 0, sizeof(counters));
-  counters.expected_data_len = data_len;
-  counters.expected_data = data;
-
-  /* create and initialize the pcb */
-  pcb = test_tcp_new_counters_pcb(&counters);
-  EXPECT_RET(pcb != NULL);
-  tcp_set_state(pcb, ESTABLISHED, &local_ip, &remote_ip, local_port, remote_port);
-
-  /* create segments */
-  /* pinseq is sent as last segment! */
-  pinseq = tcp_create_rx_segment(pcb, &data[0],  4, 0, 0, TCP_ACK);
-  /* p1: 8 bytes before FIN */
-  /*     seqno: 8..16 */
-  p_8_9  = tcp_create_rx_segment(pcb, &data[8],  8, 8, 0, TCP_ACK|TCP_FIN);
-  /* p2: 4 bytes before p1, including the first 4 bytes of p1 (partly duplicate) */
-  /*     seqno: 4..11 */
-  p_4_8  = tcp_create_rx_segment(pcb, &data[4],  8, 4, 0, TCP_ACK);
-  /* p3: same as p2 but 2 bytes longer */
-  /*     seqno: 4..13 */
-  p_4_10 = tcp_create_rx_segment(pcb, &data[4], 10, 4, 0, TCP_ACK);
-  /* p4: 14 bytes before FIN, includes data from p1 and p2, plus partly from pinseq */
-  /*     seqno: 2..15 */
-  p_2_14 = tcp_create_rx_segment(pcb, &data[2], 14, 2, 0, TCP_ACK);
-  /* FIN, seqno 16 */
-  p_fin  = tcp_create_rx_segment(pcb,     NULL,  0,16, 0, TCP_ACK|TCP_FIN);
-  EXPECT(pinseq != NULL);
-  EXPECT(p_8_9 != NULL);
-  EXPECT(p_4_8 != NULL);
-  EXPECT(p_4_10 != NULL);
-  EXPECT(p_2_14 != NULL);
-  EXPECT(p_fin != NULL);
-  if ((pinseq != NULL) && (p_8_9 != NULL) && (p_4_8 != NULL) && (p_4_10 != NULL) && (p_2_14 != NULL) && (p_fin != NULL)) {
-    /* pass the segment to tcp_input */
-    test_tcp_input(p_8_9, &netif);
-    /* check if counters are as expected */
-    EXPECT(counters.close_calls == 0);
-    EXPECT(counters.recv_calls == 0);
-    EXPECT(counters.recved_bytes == 0);
-    EXPECT(counters.err_calls == 0);
-    /* check ooseq queue */
-    EXPECT_OOSEQ(tcp_oos_count(pcb) == 1);
-    EXPECT_OOSEQ(tcp_oos_seg_seqno(pcb, 0) == 8);
-    EXPECT_OOSEQ(tcp_oos_seg_tcplen(pcb, 0) == 9); /* includes FIN */
-
-    /* pass the segment to tcp_input */
-    test_tcp_input(p_4_8, &netif);
-    /* check if counters are as expected */
-    EXPECT(counters.close_calls == 0);
-    EXPECT(counters.recv_calls == 0);
-    EXPECT(counters.recved_bytes == 0);
-    EXPECT(counters.err_calls == 0);
-    /* check ooseq queue */
-    EXPECT_OOSEQ(tcp_oos_count(pcb) == 2);
-    EXPECT_OOSEQ(tcp_oos_seg_seqno(pcb, 0) == 4);
-    EXPECT_OOSEQ(tcp_oos_seg_tcplen(pcb, 0) == 4);
-    EXPECT_OOSEQ(tcp_oos_seg_seqno(pcb, 1) == 8);
-    EXPECT_OOSEQ(tcp_oos_seg_tcplen(pcb, 1) == 9); /* includes FIN */
-
-    /* pass the segment to tcp_input */
-    test_tcp_input(p_4_10, &netif);
-    /* check if counters are as expected */
-    EXPECT(counters.close_calls == 0);
-    EXPECT(counters.recv_calls == 0);
-    EXPECT(counters.recved_bytes == 0);
-    EXPECT(counters.err_calls == 0);
-    /* ooseq queue: unchanged */
-    EXPECT_OOSEQ(tcp_oos_count(pcb) == 2);
-    EXPECT_OOSEQ(tcp_oos_seg_seqno(pcb, 0) == 4);
-    EXPECT_OOSEQ(tcp_oos_seg_tcplen(pcb, 0) == 4);
-    EXPECT_OOSEQ(tcp_oos_seg_seqno(pcb, 1) == 8);
-    EXPECT_OOSEQ(tcp_oos_seg_tcplen(pcb, 1) == 9); /* includes FIN */
-
-    /* pass the segment to tcp_input */
-    test_tcp_input(p_2_14, &netif);
-    /* check if counters are as expected */
-    EXPECT(counters.close_calls == 0);
-    EXPECT(counters.recv_calls == 0);
-    EXPECT(counters.recved_bytes == 0);
-    EXPECT(counters.err_calls == 0);
-    /* check ooseq queue */
-    EXPECT_OOSEQ(tcp_oos_count(pcb) == 1);
-    EXPECT_OOSEQ(tcp_oos_seg_seqno(pcb, 0) == 2);
-    EXPECT_OOSEQ(tcp_oos_seg_tcplen(pcb, 0) == 15); /* includes FIN */
-
-    /* pass the segment to tcp_input */
-    test_tcp_input(p_fin, &netif);
-    /* check if counters are as expected */
-    EXPECT(counters.close_calls == 0);
-    EXPECT(counters.recv_calls == 0);
-    EXPECT(counters.recved_bytes == 0);
-    EXPECT(counters.err_calls == 0);
-    /* ooseq queue: unchanged */
-    EXPECT_OOSEQ(tcp_oos_count(pcb) == 1);
-    EXPECT_OOSEQ(tcp_oos_seg_seqno(pcb, 0) == 2);
-    EXPECT_OOSEQ(tcp_oos_seg_tcplen(pcb, 0) == 15); /* includes FIN */
-
-    /* pass the segment to tcp_input */
-    test_tcp_input(pinseq, &netif);
-    /* check if counters are as expected */
-    EXPECT(counters.close_calls == 1);
-    EXPECT(counters.recv_calls == 1);
-    EXPECT(counters.recved_bytes == data_len);
-    EXPECT(counters.err_calls == 0);
-    EXPECT(pcb->ooseq == NULL);
-  }
-
-  /* make sure the pcb is freed */
-  EXPECT(lwip_stats.memp[MEMP_TCP_PCB].used == 1);
-  tcp_abort(pcb);
-  EXPECT(lwip_stats.memp[MEMP_TCP_PCB].used == 0);
-}
-END_TEST
-
-
-/** create multiple segments and pass them to tcp_input in a wrong
- * order to see if ooseq-caching works correctly
- * FIN is received IN-SEQUENCE at the end */
-START_TEST(test_tcp_recv_ooseq_FIN_INSEQ)
-{
-  struct test_tcp_counters counters;
-  struct tcp_pcb* pcb;
-  struct pbuf *p_1_2, *p_4_8, *p_3_11, *p_2_12, *p_15_1, *p_15_1a, *pinseq, *pinseqFIN;
-  char data[] = {
-     1,  2,  3,  4,
-     5,  6,  7,  8,
-     9, 10, 11, 12,
-    13, 14, 15, 16};
-  ip_addr_t remote_ip, local_ip;
-  u16_t data_len;
-  u16_t remote_port = 0x100, local_port = 0x101;
-  struct netif netif;
-  LWIP_UNUSED_ARG(_i);
-
-  /* initialize local vars */
-  memset(&netif, 0, sizeof(netif));
-  IP4_ADDR(&local_ip, 192, 168, 1, 1);
-  IP4_ADDR(&remote_ip, 192, 168, 1, 2);
-  data_len = sizeof(data);
-  /* initialize counter struct */
-  memset(&counters, 0, sizeof(counters));
-  counters.expected_data_len = data_len;
-  counters.expected_data = data;
-
-  /* create and initialize the pcb */
-  pcb = test_tcp_new_counters_pcb(&counters);
-  EXPECT_RET(pcb != NULL);
-  tcp_set_state(pcb, ESTABLISHED, &local_ip, &remote_ip, local_port, remote_port);
-
-  /* create segments */
-  /* p1: 7 bytes - 2 before FIN */
-  /*     seqno: 1..2 */
-  p_1_2  = tcp_create_rx_segment(pcb, &data[1],  2, 1, 0, TCP_ACK);
-  /* p2: 4 bytes before p1, including the first 4 bytes of p1 (partly duplicate) */
-  /*     seqno: 4..11 */
-  p_4_8  = tcp_create_rx_segment(pcb, &data[4],  8, 4, 0, TCP_ACK);
-  /* p3: same as p2 but 2 bytes longer and one byte more at the front */
-  /*     seqno: 3..13 */
-  p_3_11 = tcp_create_rx_segment(pcb, &data[3], 11, 3, 0, TCP_ACK);
-  /* p4: 13 bytes - 2 before FIN - should be ignored as contained in p1 and p3 */
-  /*     seqno: 2..13 */
-  p_2_12 = tcp_create_rx_segment(pcb, &data[2], 12, 2, 0, TCP_ACK);
-  /* pinseq is the first segment that is held back to create ooseq! */
-  /*     seqno: 0..3 */
-  pinseq = tcp_create_rx_segment(pcb, &data[0],  4, 0, 0, TCP_ACK);
-  /* p5: last byte before FIN */
-  /*     seqno: 15 */
-  p_15_1 = tcp_create_rx_segment(pcb, &data[15], 1, 15, 0, TCP_ACK);
-  /* p6: same as p5, should be ignored */
-  p_15_1a= tcp_create_rx_segment(pcb, &data[15], 1, 15, 0, TCP_ACK);
-  /* pinseqFIN: last 2 bytes plus FIN */
-  /*     only segment containing seqno 14 and FIN */
-  pinseqFIN = tcp_create_rx_segment(pcb,  &data[14], 2, 14, 0, TCP_ACK|TCP_FIN);
-  EXPECT(pinseq != NULL);
-  EXPECT(p_1_2 != NULL);
-  EXPECT(p_4_8 != NULL);
-  EXPECT(p_3_11 != NULL);
-  EXPECT(p_2_12 != NULL);
-  EXPECT(p_15_1 != NULL);
-  EXPECT(p_15_1a != NULL);
-  EXPECT(pinseqFIN != NULL);
-  if ((pinseq != NULL) && (p_1_2 != NULL) && (p_4_8 != NULL) && (p_3_11 != NULL) && (p_2_12 != NULL)
-    && (p_15_1 != NULL) && (p_15_1a != NULL) && (pinseqFIN != NULL)) {
-    /* pass the segment to tcp_input */
-    test_tcp_input(p_1_2, &netif);
-    /* check if counters are as expected */
-    EXPECT(counters.close_calls == 0);
-    EXPECT(counters.recv_calls == 0);
-    EXPECT(counters.recved_bytes == 0);
-    EXPECT(counters.err_calls == 0);
-    /* check ooseq queue */
-    EXPECT_OOSEQ(tcp_oos_count(pcb) == 1);
-    EXPECT_OOSEQ(tcp_oos_seg_seqno(pcb, 0) == 1);
-    EXPECT_OOSEQ(tcp_oos_seg_tcplen(pcb, 0) == 2);
-
-    /* pass the segment to tcp_input */
-    test_tcp_input(p_4_8, &netif);
-    /* check if counters are as expected */
-    EXPECT(counters.close_calls == 0);
-    EXPECT(counters.recv_calls == 0);
-    EXPECT(counters.recved_bytes == 0);
-    EXPECT(counters.err_calls == 0);
-    /* check ooseq queue */
-    EXPECT_OOSEQ(tcp_oos_count(pcb) == 2);
-    EXPECT_OOSEQ(tcp_oos_seg_seqno(pcb, 0) == 1);
-    EXPECT_OOSEQ(tcp_oos_seg_tcplen(pcb, 0) == 2);
-    EXPECT_OOSEQ(tcp_oos_seg_seqno(pcb, 1) == 4);
-    EXPECT_OOSEQ(tcp_oos_seg_tcplen(pcb, 1) == 8);
-
-    /* pass the segment to tcp_input */
-    test_tcp_input(p_3_11, &netif);
-    /* check if counters are as expected */
-    EXPECT(counters.close_calls == 0);
-    EXPECT(counters.recv_calls == 0);
-    EXPECT(counters.recved_bytes == 0);
-    EXPECT(counters.err_calls == 0);
-    /* check ooseq queue */
-    EXPECT_OOSEQ(tcp_oos_count(pcb) == 2);
-    EXPECT_OOSEQ(tcp_oos_seg_seqno(pcb, 0) == 1);
-    EXPECT_OOSEQ(tcp_oos_seg_tcplen(pcb, 0) == 2);
-    /* p_3_11 has removed p_4_8 from ooseq */
-    EXPECT_OOSEQ(tcp_oos_seg_seqno(pcb, 1) == 3);
-    EXPECT_OOSEQ(tcp_oos_seg_tcplen(pcb, 1) == 11);
-
-    /* pass the segment to tcp_input */
-    test_tcp_input(p_2_12, &netif);
-    /* check if counters are as expected */
-    EXPECT(counters.close_calls == 0);
-    EXPECT(counters.recv_calls == 0);
-    EXPECT(counters.recved_bytes == 0);
-    EXPECT(counters.err_calls == 0);
-    /* check ooseq queue */
-    EXPECT_OOSEQ(tcp_oos_count(pcb) == 2);
-    EXPECT_OOSEQ(tcp_oos_seg_seqno(pcb, 0) == 1);
-    EXPECT_OOSEQ(tcp_oos_seg_tcplen(pcb, 0) == 1);
-    EXPECT_OOSEQ(tcp_oos_seg_seqno(pcb, 1) == 2);
-    EXPECT_OOSEQ(tcp_oos_seg_tcplen(pcb, 1) == 12);
-
-    /* pass the segment to tcp_input */
-    test_tcp_input(pinseq, &netif);
-    /* check if counters are as expected */
-    EXPECT(counters.close_calls == 0);
-    EXPECT(counters.recv_calls == 1);
-    EXPECT(counters.recved_bytes == 14);
-    EXPECT(counters.err_calls == 0);
-    EXPECT(pcb->ooseq == NULL);
-
-    /* pass the segment to tcp_input */
-    test_tcp_input(p_15_1, &netif);
-    /* check if counters are as expected */
-    EXPECT(counters.close_calls == 0);
-    EXPECT(counters.recv_calls == 1);
-    EXPECT(counters.recved_bytes == 14);
-    EXPECT(counters.err_calls == 0);
-    /* check ooseq queue */
-    EXPECT_OOSEQ(tcp_oos_count(pcb) == 1);
-    EXPECT_OOSEQ(tcp_oos_seg_seqno(pcb, 0) == 15);
-    EXPECT_OOSEQ(tcp_oos_seg_tcplen(pcb, 0) == 1);
-
-    /* pass the segment to tcp_input */
-    test_tcp_input(p_15_1a, &netif);
-    /* check if counters are as expected */
-    EXPECT(counters.close_calls == 0);
-    EXPECT(counters.recv_calls == 1);
-    EXPECT(counters.recved_bytes == 14);
-    EXPECT(counters.err_calls == 0);
-    /* check ooseq queue: unchanged */
-    EXPECT_OOSEQ(tcp_oos_count(pcb) == 1);
-    EXPECT_OOSEQ(tcp_oos_seg_seqno(pcb, 0) == 15);
-    EXPECT_OOSEQ(tcp_oos_seg_tcplen(pcb, 0) == 1);
-
-    /* pass the segment to tcp_input */
-    test_tcp_input(pinseqFIN, &netif);
-    /* check if counters are as expected */
-    EXPECT(counters.close_calls == 1);
-    EXPECT(counters.recv_calls == 2);
-    EXPECT(counters.recved_bytes == data_len);
-    EXPECT(counters.err_calls == 0);
-    EXPECT(pcb->ooseq == NULL);
-  }
-
-  /* make sure the pcb is freed */
-  EXPECT(lwip_stats.memp[MEMP_TCP_PCB].used == 1);
-  tcp_abort(pcb);
-  EXPECT(lwip_stats.memp[MEMP_TCP_PCB].used == 0);
-}
-END_TEST
-
-static char data_full_wnd[TCP_WND];
-
-/** create multiple segments and pass them to tcp_input with the first segment missing
- * to simulate overruning the rxwin with ooseq queueing enabled */
-START_TEST(test_tcp_recv_ooseq_overrun_rxwin)
-{
-#if !TCP_OOSEQ_MAX_BYTES && !TCP_OOSEQ_MAX_PBUFS
-  int i, k;
-  struct test_tcp_counters counters;
-  struct tcp_pcb* pcb;
-  struct pbuf *pinseq, *p_ovr;
-  ip_addr_t remote_ip, local_ip;
-  u16_t remote_port = 0x100, local_port = 0x101;
-  struct netif netif;
-  int datalen = 0;
-  int datalen2;
-
-  for(i = 0; i < sizeof(data_full_wnd); i++) {
-    data_full_wnd[i] = (char)i;
-  }
-
-  /* initialize local vars */
-  memset(&netif, 0, sizeof(netif));
-  IP4_ADDR(&local_ip, 192, 168, 1, 1);
-  IP4_ADDR(&remote_ip, 192, 168, 1, 2);
-  /* initialize counter struct */
-  memset(&counters, 0, sizeof(counters));
-  counters.expected_data_len = TCP_WND;
-  counters.expected_data = data_full_wnd;
-
-  /* create and initialize the pcb */
-  pcb = test_tcp_new_counters_pcb(&counters);
-  EXPECT_RET(pcb != NULL);
-  tcp_set_state(pcb, ESTABLISHED, &local_ip, &remote_ip, local_port, remote_port);
-  pcb->rcv_nxt = 0x8000;
-
-  /* create segments */
-  /* pinseq is sent as last segment! */
-  pinseq = tcp_create_rx_segment(pcb, &data_full_wnd[0],  TCP_MSS, 0, 0, TCP_ACK);
-
-  for(i = TCP_MSS, k = 0; i < TCP_WND; i += TCP_MSS, k++) {
-    int count, expected_datalen;
-    struct pbuf *p = tcp_create_rx_segment(pcb, &data_full_wnd[TCP_MSS*(k+1)],
-                                           TCP_MSS, TCP_MSS*(k+1), 0, TCP_ACK);
-    EXPECT_RET(p != NULL);
-    /* pass the segment to tcp_input */
-    test_tcp_input(p, &netif);
-    /* check if counters are as expected */
-    EXPECT(counters.close_calls == 0);
-    EXPECT(counters.recv_calls == 0);
-    EXPECT(counters.recved_bytes == 0);
-    EXPECT(counters.err_calls == 0);
-    /* check ooseq queue */
-    count = tcp_oos_count(pcb);
-    EXPECT_OOSEQ(count == k+1);
-    datalen = tcp_oos_tcplen(pcb);
-    if (i + TCP_MSS < TCP_WND) {
-      expected_datalen = (k+1)*TCP_MSS;
-    } else {
-      expected_datalen = TCP_WND - TCP_MSS;
-    }
-    if (datalen != expected_datalen) {
-      EXPECT_OOSEQ(datalen == expected_datalen);
-    }
-  }
-
-  /* pass in one more segment, cleary overrunning the rxwin */
-  p_ovr = tcp_create_rx_segment(pcb, &data_full_wnd[TCP_MSS*(k+1)], TCP_MSS, TCP_MSS*(k+1), 0, TCP_ACK);
-  EXPECT_RET(p_ovr != NULL);
-  /* pass the segment to tcp_input */
-  test_tcp_input(p_ovr, &netif);
-  /* check if counters are as expected */
-  EXPECT(counters.close_calls == 0);
-  EXPECT(counters.recv_calls == 0);
-  EXPECT(counters.recved_bytes == 0);
-  EXPECT(counters.err_calls == 0);
-  /* check ooseq queue */
-  EXPECT_OOSEQ(tcp_oos_count(pcb) == k);
-  datalen2 = tcp_oos_tcplen(pcb);
-  EXPECT_OOSEQ(datalen == datalen2);
-
-  /* now pass inseq */
-  test_tcp_input(pinseq, &netif);
-  EXPECT(pcb->ooseq == NULL);
-
-  /* make sure the pcb is freed */
-  EXPECT(lwip_stats.memp[MEMP_TCP_PCB].used == 1);
-  tcp_abort(pcb);
-  EXPECT(lwip_stats.memp[MEMP_TCP_PCB].used == 0);
-#endif /* !TCP_OOSEQ_MAX_BYTES && !TCP_OOSEQ_MAX_PBUFS */
-  LWIP_UNUSED_ARG(_i);
-}
-END_TEST
-
-START_TEST(test_tcp_recv_ooseq_max_bytes)
-{
-#if TCP_OOSEQ_MAX_BYTES && (TCP_OOSEQ_MAX_BYTES < (TCP_WND + 1)) && (PBUF_POOL_BUFSIZE >= (TCP_MSS + PBUF_LINK_HLEN + PBUF_IP_HLEN + PBUF_TRANSPORT_HLEN))
-  int i, k;
-  struct test_tcp_counters counters;
-  struct tcp_pcb* pcb;
-  struct pbuf *p_ovr;
-  ip_addr_t remote_ip, local_ip;
-  u16_t remote_port = 0x100, local_port = 0x101;
-  struct netif netif;
-  int datalen = 0;
-  int datalen2;
-
-  for(i = 0; i < sizeof(data_full_wnd); i++) {
-    data_full_wnd[i] = (char)i;
-  }
-
-  /* initialize local vars */
-  memset(&netif, 0, sizeof(netif));
-  IP4_ADDR(&local_ip, 192, 168, 1, 1);
-  IP4_ADDR(&remote_ip, 192, 168, 1, 2);
-  /* initialize counter struct */
-  memset(&counters, 0, sizeof(counters));
-  counters.expected_data_len = TCP_WND;
-  counters.expected_data = data_full_wnd;
-
-  /* create and initialize the pcb */
-  pcb = test_tcp_new_counters_pcb(&counters);
-  EXPECT_RET(pcb != NULL);
-  tcp_set_state(pcb, ESTABLISHED, &local_ip, &remote_ip, local_port, remote_port);
-  pcb->rcv_nxt = 0x8000;
-
-  /* don't 'recv' the first segment (1 byte) so that all other segments will be ooseq */
-
-  /* create segments and 'recv' them */
-  for(k = 1, i = 1; k < TCP_OOSEQ_MAX_BYTES; k += TCP_MSS, i++) {
-    int count;
-    struct pbuf *p = tcp_create_rx_segment(pcb, &data_full_wnd[k],
-                                           TCP_MSS, k, 0, TCP_ACK);
-    EXPECT_RET(p != NULL);
-    EXPECT_RET(p->next == NULL);
-    /* pass the segment to tcp_input */
-    test_tcp_input(p, &netif);
-    /* check if counters are as expected */
-    EXPECT(counters.close_calls == 0);
-    EXPECT(counters.recv_calls == 0);
-    EXPECT(counters.recved_bytes == 0);
-    EXPECT(counters.err_calls == 0);
-    /* check ooseq queue */
-    count = tcp_oos_pbuf_count(pcb);
-    EXPECT_OOSEQ(count == i);
-    datalen = tcp_oos_tcplen(pcb);
-    EXPECT_OOSEQ(datalen == (i * TCP_MSS));
-  }
-
-  /* pass in one more segment, overrunning the limit */
-  p_ovr = tcp_create_rx_segment(pcb, &data_full_wnd[k+1], 1, k+1, 0, TCP_ACK);
-  EXPECT_RET(p_ovr != NULL);
-  /* pass the segment to tcp_input */
-  test_tcp_input(p_ovr, &netif);
-  /* check if counters are as expected */
-  EXPECT(counters.close_calls == 0);
-  EXPECT(counters.recv_calls == 0);
-  EXPECT(counters.recved_bytes == 0);
-  EXPECT(counters.err_calls == 0);
-  /* check ooseq queue (ensure the new segment was not accepted) */
-  EXPECT_OOSEQ(tcp_oos_count(pcb) == (i-1));
-  datalen2 = tcp_oos_tcplen(pcb);
-  EXPECT_OOSEQ(datalen2 == ((i-1) * TCP_MSS));
-
-  /* make sure the pcb is freed */
-  EXPECT(lwip_stats.memp[MEMP_TCP_PCB].used == 1);
-  tcp_abort(pcb);
-  EXPECT(lwip_stats.memp[MEMP_TCP_PCB].used == 0);
-#endif /* TCP_OOSEQ_MAX_BYTES && (TCP_OOSEQ_MAX_BYTES < (TCP_WND + 1)) && (PBUF_POOL_BUFSIZE >= (TCP_MSS + PBUF_LINK_HLEN + PBUF_IP_HLEN + PBUF_TRANSPORT_HLEN)) */
-  LWIP_UNUSED_ARG(_i);
-}
-END_TEST
-
-START_TEST(test_tcp_recv_ooseq_max_pbufs)
-{
-#if TCP_OOSEQ_MAX_PBUFS && (TCP_OOSEQ_MAX_PBUFS < ((TCP_WND / TCP_MSS) + 1)) && (PBUF_POOL_BUFSIZE >= (TCP_MSS + PBUF_LINK_HLEN + PBUF_IP_HLEN + PBUF_TRANSPORT_HLEN))
-  int i;
-  struct test_tcp_counters counters;
-  struct tcp_pcb* pcb;
-  struct pbuf *p_ovr;
-  ip_addr_t remote_ip, local_ip;
-  u16_t remote_port = 0x100, local_port = 0x101;
-  struct netif netif;
-  int datalen = 0;
-  int datalen2;
-
-  for(i = 0; i < sizeof(data_full_wnd); i++) {
-    data_full_wnd[i] = (char)i;
-  }
-
-  /* initialize local vars */
-  memset(&netif, 0, sizeof(netif));
-  IP4_ADDR(&local_ip, 192, 168, 1, 1);
-  IP4_ADDR(&remote_ip, 192, 168, 1, 2);
-  /* initialize counter struct */
-  memset(&counters, 0, sizeof(counters));
-  counters.expected_data_len = TCP_WND;
-  counters.expected_data = data_full_wnd;
-
-  /* create and initialize the pcb */
-  pcb = test_tcp_new_counters_pcb(&counters);
-  EXPECT_RET(pcb != NULL);
-  tcp_set_state(pcb, ESTABLISHED, &local_ip, &remote_ip, local_port, remote_port);
-  pcb->rcv_nxt = 0x8000;
-
-  /* don't 'recv' the first segment (1 byte) so that all other segments will be ooseq */
-
-  /* create segments and 'recv' them */
-  for(i = 1; i <= TCP_OOSEQ_MAX_PBUFS; i++) {
-    int count;
-    struct pbuf *p = tcp_create_rx_segment(pcb, &data_full_wnd[i],
-                                           1, i, 0, TCP_ACK);
-    EXPECT_RET(p != NULL);
-    EXPECT_RET(p->next == NULL);
-    /* pass the segment to tcp_input */
-    test_tcp_input(p, &netif);
-    /* check if counters are as expected */
-    EXPECT(counters.close_calls == 0);
-    EXPECT(counters.recv_calls == 0);
-    EXPECT(counters.recved_bytes == 0);
-    EXPECT(counters.err_calls == 0);
-    /* check ooseq queue */
-    count = tcp_oos_pbuf_count(pcb);
-    EXPECT_OOSEQ(count == i);
-    datalen = tcp_oos_tcplen(pcb);
-    EXPECT_OOSEQ(datalen == i);
-  }
-
-  /* pass in one more segment, overrunning the limit */
-  p_ovr = tcp_create_rx_segment(pcb, &data_full_wnd[i+1], 1, i+1, 0, TCP_ACK);
-  EXPECT_RET(p_ovr != NULL);
-  /* pass the segment to tcp_input */
-  test_tcp_input(p_ovr, &netif);
-  /* check if counters are as expected */
-  EXPECT(counters.close_calls == 0);
-  EXPECT(counters.recv_calls == 0);
-  EXPECT(counters.recved_bytes == 0);
-  EXPECT(counters.err_calls == 0);
-  /* check ooseq queue (ensure the new segment was not accepted) */
-  EXPECT_OOSEQ(tcp_oos_count(pcb) == (i-1));
-  datalen2 = tcp_oos_tcplen(pcb);
-  EXPECT_OOSEQ(datalen2 == (i-1));
-
-  /* make sure the pcb is freed */
-  EXPECT(lwip_stats.memp[MEMP_TCP_PCB].used == 1);
-  tcp_abort(pcb);
-  EXPECT(lwip_stats.memp[MEMP_TCP_PCB].used == 0);
-#endif /* TCP_OOSEQ_MAX_PBUFS && (TCP_OOSEQ_MAX_BYTES < (TCP_WND + 1)) && (PBUF_POOL_BUFSIZE >= (TCP_MSS + PBUF_LINK_HLEN + PBUF_IP_HLEN + PBUF_TRANSPORT_HLEN)) */
-  LWIP_UNUSED_ARG(_i);
-}
-END_TEST
-
-static void
-check_rx_counters(struct tcp_pcb *pcb, struct test_tcp_counters *counters, u32_t exp_close_calls, u32_t exp_rx_calls,
-                  u32_t exp_rx_bytes, u32_t exp_err_calls, int exp_oos_count, int exp_oos_len)
-{
-  int oos_len;
-  EXPECT(counters->close_calls == exp_close_calls);
-  EXPECT(counters->recv_calls == exp_rx_calls);
-  EXPECT(counters->recved_bytes == exp_rx_bytes);
-  EXPECT(counters->err_calls == exp_err_calls);
-  /* check that pbuf is queued in ooseq */
-  EXPECT_OOSEQ(tcp_oos_count(pcb) == exp_oos_count);
-  oos_len = tcp_oos_tcplen(pcb);
-  EXPECT_OOSEQ(exp_oos_len == oos_len);
-}
-
-/* this test uses 4 packets:
- * - data (len=TCP_MSS)
- * - FIN
- * - data after FIN (len=1) (invalid)
- * - 2nd FIN (invalid)
- *
- * the parameter 'delay_packet' is a bitmask that choses which on these packets is ooseq
- */
-static void test_tcp_recv_ooseq_double_FINs(int delay_packet)
-{
-  int i, k;
-  struct test_tcp_counters counters;
-  struct tcp_pcb* pcb;
-  struct pbuf *p_normal_fin, *p_data_after_fin, *p, *p_2nd_fin_ooseq;
-  ip_addr_t remote_ip, local_ip;
-  u16_t remote_port = 0x100, local_port = 0x101;
-  struct netif netif;
-  u32_t exp_rx_calls = 0, exp_rx_bytes = 0, exp_close_calls = 0, exp_oos_pbufs = 0, exp_oos_tcplen = 0;
-  int first_dropped = 0xff;
-  int last_dropped = 0;
-
-  for(i = 0; i < sizeof(data_full_wnd); i++) {
-    data_full_wnd[i] = (char)i;
-  }
-
-  /* initialize local vars */
-  memset(&netif, 0, sizeof(netif));
-  IP4_ADDR(&local_ip, 192, 168, 1, 1);
-  IP4_ADDR(&remote_ip, 192, 168, 1, 2);
-  /* initialize counter struct */
-  memset(&counters, 0, sizeof(counters));
-  counters.expected_data_len = TCP_WND;
-  counters.expected_data = data_full_wnd;
-
-  /* create and initialize the pcb */
-  pcb = test_tcp_new_counters_pcb(&counters);
-  EXPECT_RET(pcb != NULL);
-  tcp_set_state(pcb, ESTABLISHED, &local_ip, &remote_ip, local_port, remote_port);
-  pcb->rcv_nxt = 0x8000;
-
-  /* create segments */
-  p = tcp_create_rx_segment(pcb, &data_full_wnd[0], TCP_MSS, 0, 0, TCP_ACK);
-  p_normal_fin = tcp_create_rx_segment(pcb, NULL, 0, TCP_MSS, 0, TCP_ACK|TCP_FIN);
-  k = 1;
-  p_data_after_fin = tcp_create_rx_segment(pcb, &data_full_wnd[TCP_MSS+1], k, TCP_MSS+1, 0, TCP_ACK);
-  p_2nd_fin_ooseq = tcp_create_rx_segment(pcb, NULL, 0, TCP_MSS+1+k, 0, TCP_ACK|TCP_FIN);
-
-  if(delay_packet & 1) {
-    /* drop normal data */
-    first_dropped = 1;
-    last_dropped = 1;
-  } else {
-    /* send normal data */
-    test_tcp_input(p, &netif);
-    exp_rx_calls++;
-    exp_rx_bytes += TCP_MSS;
-  }
-  /* check if counters are as expected */
-  check_rx_counters(pcb, &counters, exp_close_calls, exp_rx_calls, exp_rx_bytes, 0, exp_oos_pbufs, exp_oos_tcplen);
-
-  if(delay_packet & 2) {
-    /* drop FIN */
-    if(first_dropped > 2) {
-      first_dropped = 2;
-    }
-    last_dropped = 2;
-  } else {
-    /* send FIN */
-    test_tcp_input(p_normal_fin, &netif);
-    if (first_dropped < 2) {
-      /* already dropped packets, this one is ooseq */
-      exp_oos_pbufs++;
-      exp_oos_tcplen++;
-    } else {
-      /* inseq */
-      exp_close_calls++;
-    }
-  }
-  /* check if counters are as expected */
-  check_rx_counters(pcb, &counters, exp_close_calls, exp_rx_calls, exp_rx_bytes, 0, exp_oos_pbufs, exp_oos_tcplen);
-
-  if(delay_packet & 4) {
-    /* drop data-after-FIN */
-    if(first_dropped > 3) {
-      first_dropped = 3;
-    }
-    last_dropped = 3;
-  } else {
-    /* send data-after-FIN */
-    test_tcp_input(p_data_after_fin, &netif);
-    if (first_dropped < 3) {
-      /* already dropped packets, this one is ooseq */
-      if (delay_packet & 2) {
-        /* correct FIN was ooseq */
-        exp_oos_pbufs++;
-        exp_oos_tcplen += k;
-      }
-    } else {
-      /* inseq: no change */
-    }
-  }
-  /* check if counters are as expected */
-  check_rx_counters(pcb, &counters, exp_close_calls, exp_rx_calls, exp_rx_bytes, 0, exp_oos_pbufs, exp_oos_tcplen);
-
-  if(delay_packet & 8) {
-    /* drop 2nd-FIN */
-    if(first_dropped > 4) {
-      first_dropped = 4;
-    }
-    last_dropped = 4;
-  } else {
-    /* send 2nd-FIN */
-    test_tcp_input(p_2nd_fin_ooseq, &netif);
-    if (first_dropped < 3) {
-      /* already dropped packets, this one is ooseq */
-      if (delay_packet & 2) {
-        /* correct FIN was ooseq */
-        exp_oos_pbufs++;
-        exp_oos_tcplen++;
-      }
-    } else {
-      /* inseq: no change */
-    }
-  }
-  /* check if counters are as expected */
-  check_rx_counters(pcb, &counters, exp_close_calls, exp_rx_calls, exp_rx_bytes, 0, exp_oos_pbufs, exp_oos_tcplen);
-
-  if(delay_packet & 1) {
-    /* dropped normal data before */
-    test_tcp_input(p, &netif);
-    exp_rx_calls++;
-    exp_rx_bytes += TCP_MSS;
-    if((delay_packet & 2) == 0) {
-      /* normal FIN was NOT delayed */
-      exp_close_calls++;
-      exp_oos_pbufs = exp_oos_tcplen = 0;
-    }
-  }
-  /* check if counters are as expected */
-  check_rx_counters(pcb, &counters, exp_close_calls, exp_rx_calls, exp_rx_bytes, 0, exp_oos_pbufs, exp_oos_tcplen);
-
-  if(delay_packet & 2) {
-    /* dropped normal FIN before */
-    test_tcp_input(p_normal_fin, &netif);
-    exp_close_calls++;
-    exp_oos_pbufs = exp_oos_tcplen = 0;
-  }
-  /* check if counters are as expected */
-  check_rx_counters(pcb, &counters, exp_close_calls, exp_rx_calls, exp_rx_bytes, 0, exp_oos_pbufs, exp_oos_tcplen);
-
-  if(delay_packet & 4) {
-    /* dropped data-after-FIN before */
-    test_tcp_input(p_data_after_fin, &netif);
-  }
-  /* check if counters are as expected */
-  check_rx_counters(pcb, &counters, exp_close_calls, exp_rx_calls, exp_rx_bytes, 0, exp_oos_pbufs, exp_oos_tcplen);
-
-  if(delay_packet & 8) {
-    /* dropped 2nd-FIN before */
-    test_tcp_input(p_2nd_fin_ooseq, &netif);
-  }
-  /* check if counters are as expected */
-  check_rx_counters(pcb, &counters, exp_close_calls, exp_rx_calls, exp_rx_bytes, 0, exp_oos_pbufs, exp_oos_tcplen);
-
-  /* check that ooseq data has been dumped */
-  EXPECT(pcb->ooseq == NULL);
-
-  /* make sure the pcb is freed */
-  EXPECT(lwip_stats.memp[MEMP_TCP_PCB].used == 1);
-  tcp_abort(pcb);
-  EXPECT(lwip_stats.memp[MEMP_TCP_PCB].used == 0);
-}
-
-/** create multiple segments and pass them to tcp_input with the first segment missing
- * to simulate overruning the rxwin with ooseq queueing enabled */
-#define FIN_TEST(name, num) \
-  START_TEST(name) \
-  { \
-    LWIP_UNUSED_ARG(_i); \
-    test_tcp_recv_ooseq_double_FINs(num); \
-  } \
-  END_TEST
-FIN_TEST(test_tcp_recv_ooseq_double_FIN_0, 0)
-FIN_TEST(test_tcp_recv_ooseq_double_FIN_1, 1)
-FIN_TEST(test_tcp_recv_ooseq_double_FIN_2, 2)
-FIN_TEST(test_tcp_recv_ooseq_double_FIN_3, 3)
-FIN_TEST(test_tcp_recv_ooseq_double_FIN_4, 4)
-FIN_TEST(test_tcp_recv_ooseq_double_FIN_5, 5)
-FIN_TEST(test_tcp_recv_ooseq_double_FIN_6, 6)
-FIN_TEST(test_tcp_recv_ooseq_double_FIN_7, 7)
-FIN_TEST(test_tcp_recv_ooseq_double_FIN_8, 8)
-FIN_TEST(test_tcp_recv_ooseq_double_FIN_9, 9)
-FIN_TEST(test_tcp_recv_ooseq_double_FIN_10, 10)
-FIN_TEST(test_tcp_recv_ooseq_double_FIN_11, 11)
-FIN_TEST(test_tcp_recv_ooseq_double_FIN_12, 12)
-FIN_TEST(test_tcp_recv_ooseq_double_FIN_13, 13)
-FIN_TEST(test_tcp_recv_ooseq_double_FIN_14, 14)
-FIN_TEST(test_tcp_recv_ooseq_double_FIN_15, 15)
-
-
-/** Create the suite including all tests for this module */
-Suite *
-tcp_oos_suite(void)
-{
-  TFun tests[] = {
-    test_tcp_recv_ooseq_FIN_OOSEQ,
-    test_tcp_recv_ooseq_FIN_INSEQ,
-    test_tcp_recv_ooseq_overrun_rxwin,
-    test_tcp_recv_ooseq_max_bytes,
-    test_tcp_recv_ooseq_max_pbufs,
-    test_tcp_recv_ooseq_double_FIN_0,
-    test_tcp_recv_ooseq_double_FIN_1,
-    test_tcp_recv_ooseq_double_FIN_2,
-    test_tcp_recv_ooseq_double_FIN_3,
-    test_tcp_recv_ooseq_double_FIN_4,
-    test_tcp_recv_ooseq_double_FIN_5,
-    test_tcp_recv_ooseq_double_FIN_6,
-    test_tcp_recv_ooseq_double_FIN_7,
-    test_tcp_recv_ooseq_double_FIN_8,
-    test_tcp_recv_ooseq_double_FIN_9,
-    test_tcp_recv_ooseq_double_FIN_10,
-    test_tcp_recv_ooseq_double_FIN_11,
-    test_tcp_recv_ooseq_double_FIN_12,
-    test_tcp_recv_ooseq_double_FIN_13,
-    test_tcp_recv_ooseq_double_FIN_14,
-    test_tcp_recv_ooseq_double_FIN_15
-  };
-  return create_suite("TCP_OOS", tests, sizeof(tests)/sizeof(TFun), tcp_oos_setup, tcp_oos_teardown);
-}

ext/lwip/test/unit/tcp/test_tcp_oos.h

@@ -1,8 +0,0 @@
-#ifndef __TEST_TCP_OOS_H__
-#define __TEST_TCP_OOS_H__
-
-#include "../lwip_check.h"
-
-Suite *tcp_oos_suite(void);
-
-#endif

ext/lwip/test/unit/udp/test_udp.c

@@ -1,68 +0,0 @@
-#include "test_udp.h"
-
-#include "lwip/udp.h"
-#include "lwip/stats.h"
-
-#if !LWIP_STATS || !UDP_STATS || !MEMP_STATS
-#error "This tests needs UDP- and MEMP-statistics enabled"
-#endif
-
-/* Helper functions */
-static void
-udp_remove_all(void)
-{
-  struct udp_pcb *pcb = udp_pcbs;
-  struct udp_pcb *pcb2;
-
-  while(pcb != NULL) {
-    pcb2 = pcb;
-    pcb = pcb->next;
-    udp_remove(pcb2);
-  }
-  fail_unless(lwip_stats.memp[MEMP_UDP_PCB].used == 0);
-}
-
-/* Setups/teardown functions */
-
-static void
-udp_setup(void)
-{
-  udp_remove_all();
-}
-
-static void
-udp_teardown(void)
-{
-  udp_remove_all();
-}
-
-
-/* Test functions */
-
-START_TEST(test_udp_new_remove)
-{
-  struct udp_pcb* pcb;
-  LWIP_UNUSED_ARG(_i);
-
-  fail_unless(lwip_stats.memp[MEMP_UDP_PCB].used == 0);
-
-  pcb = udp_new();
-  fail_unless(pcb != NULL);
-  if (pcb != NULL) {
-    fail_unless(lwip_stats.memp[MEMP_UDP_PCB].used == 1);
-    udp_remove(pcb);
-    fail_unless(lwip_stats.memp[MEMP_UDP_PCB].used == 0);
-  }
-}
-END_TEST
-
-
-/** Create the suite including all tests for this module */
-Suite *
-udp_suite(void)
-{
-  TFun tests[] = {
-    test_udp_new_remove,
-  };
-  return create_suite("UDP", tests, sizeof(tests)/sizeof(TFun), udp_setup, udp_teardown);
-}

ext/lwip/test/unit/udp/test_udp.h

@@ -1,8 +0,0 @@
-#ifndef __TEST_UDP_H__
-#define __TEST_UDP_H__
-
-#include "../lwip_check.h"
-
-Suite* udp_suite(void);
-
-#endif

ext/lwipopts.h

@@ -42,31 +42,11 @@
  * Include user defined options first. Anything not defined in these files
  * will be set to standard values. Override anything you dont like!
  */
-#include "lwipopts.h"
 #include "lwip/debug.h"
 
 
-
-/*
-
-#define LWIP_MALLOC_MEMPOOL 1
-*/
-
-/*
-#define LWIP_CHECKSUM_ON_COPY 1
-
-#define TCP_OVERSIZE TCP_MSS
-*/
-//#define TCP_SND_QUEUELEN 128
-
-//#define TCP_WND
-
-
-//#define PBUF_POOL_BUFSIZE 2048
-
-
-#define TCP_MSS 2048
-#define TCP_WND 512
+//#define TCP_MSS 2048
+//#define TCP_WND 512
 
 /*------------------------------------------------------------------------------
 ---------------------------------- Timers --------------------------------------

make-linux.mk

@@ -111,7 +111,9 @@ installer: one FORCE
 	./ext/installfiles/linux/buildinstaller.sh
 
 clean:
-	rm -rf *.o netcon/*.o node/*.o controller/*.o osdep/*.o service/*.o ext/http-parser/*.o ext/lz4/*.o ext/json-parser/*.o zerotier-one zerotier-idtool zerotier-cli zerotier-selftest build-* ZeroTierOneInstaller-* *.deb *.rpm
+	rm -rf *.o
+	rm -rf netcon/*.o netcon/*.so netcon/*.1.0
+	rm -rf node/*.o controller/*.o osdep/*.o service/*.o ext/http-parser/*.o ext/lz4/*.o ext/json-parser/*.o zerotier-one zerotier-idtool zerotier-cli zerotier-selftest build-* ZeroTierOneInstaller-* *.deb *.rpm
 
 debug:	FORCE
 	make ZT_DEBUG=1 one

netcon/intercept.c

@@ -72,7 +72,6 @@ char *progname = "";
 #include "intercept.h"
 #include "common.h"
 #include "defs.h"
-#include "utils.c"
 
 /* Global Declarations */
 #ifdef USE_SOCKS_DNS

netcon/make-intercept.mk

@@ -0,0 +1,29 @@
+SHCC=gcc
+
+# intercept-specific
+intercept_CFLAGS = -c -fPIC -g -O2 -Wall -std=c99 -D_GNU_SOURCE -DNETCON_INTERCEPT
+LIB_NAME = intercept
+SHLIB_EXT=dylib
+SHLIB_MAJOR = 1
+SHLIB_MINOR = 8
+COMMON = common
+OBJS= intercept.o
+SHLIB = ${LIB_NAME}.${SHLIB_EXT}.${SHLIB_MAJOR}.${SHLIB_MINOR}
+SHLDFLAGS = -g -O2 -Wall -I. -nostdlib -shared
+LIBS = -ldl -lc -lrt -lpthread
+
+lib:
+	${SHCC} $(intercept_CFLAGS) -I. intercept.c -o intercept.o
+	${SHCC} $(intercept_CFLAGS) -I. common.c -o common.o
+	${SHCC} $(intercept_CFLAGS) -I. sendfd.c -o sendfd.o
+	${SHCC} $(SHLDFLAGS) intercept.o common.o sendfd.o -o libintercept.so.1.0 $(LIBS)
+
+install:
+	cp libintercept.so.1.0 /lib/libintercept.so.1.0
+	ln -sf /lib/libintercept.so.1.0 /lib/libintercept
+	/usr/bin/install -c netcon/intercept /usr/bin
+
+uninstall:
+	rm -r /lib/libintercept.so.1.0
+	rm -r /lib/libintercept
+	rm -r /usr/bin/intercept

netcon/make-liblwip.mk

@@ -0,0 +1,106 @@
+#
+# Copyright (c) 2001, 2002 Swedish Institute of Computer Science.
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without modification,
+# are permitted provided that the following conditions are met:
+#
+# 1. Redistributions of source code must retain the above copyright notice,
+#    this list of conditions and the following disclaimer.
+# 2. Redistributions in binary form must reproduce the above copyright notice,
+#    this list of conditions and the following disclaimer in the documentation
+#    and/or other materials provided with the distribution.
+# 3. The name of the author may not be used to endorse or promote products
+#    derived from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
+# WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+# MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
+# SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+# EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
+# OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+# IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
+# OF SUCH DAMAGE.
+#
+# This file is part of the lwIP TCP/IP stack.
+#
+# Author: Adam Dunkels <[email protected]>
+#
+
+CONTRIBDIR=../ext/contrib
+LWIPARCH=$(CONTRIBDIR)/ports/unix
+
+#Set this to where you have the lwip core module checked out from CVS
+#default assumes it's a dir named lwip at the same level as the contrib module
+LWIPDIR=../ext/lwip/src
+
+
+CCDEP=gcc
+CC=gcc
+CFLAGS=-O3 -g -Wall -DIPv4 -fPIC
+
+CFLAGS:=$(CFLAGS) \
+	-I$(LWIPDIR)/include -I$(LWIPARCH)/include -I$(LWIPDIR)/include/ipv4 \
+	-I$(LWIPDIR) -I.
+
+
+# COREFILES, CORE4FILES: The minimum set of files needed for lwIP.
+COREFILES=$(LWIPDIR)/core/mem.c $(LWIPDIR)/core/memp.c $(LWIPDIR)/core/netif.c \
+	$(LWIPDIR)/core/pbuf.c $(LWIPDIR)/core/raw.c $(LWIPDIR)/core/stats.c \
+	$(LWIPDIR)/core/sys.c $(LWIPDIR)/core/tcp.c $(LWIPDIR)/core/tcp_in.c \
+	$(LWIPDIR)/core/tcp_out.c $(LWIPDIR)/core/udp.c $(LWIPDIR)/core/dhcp.c \
+	$(LWIPDIR)/core/init.c $(LWIPDIR)/core/timers.c $(LWIPDIR)/core/def.c
+CORE4FILES=$(wildcard $(LWIPDIR)/core/ipv4/*.c) $(LWIPDIR)/core/ipv4/inet.c \
+	$(LWIPDIR)/core/ipv4/inet_chksum.c
+
+# SNMPFILES: Extra SNMPv1 agent
+SNMPFILES=$(LWIPDIR)/core/snmp/asn1_dec.c $(LWIPDIR)/core/snmp/asn1_enc.c \
+	$(LWIPDIR)/core/snmp/mib2.c $(LWIPDIR)/core/snmp/mib_structs.c \
+	$(LWIPDIR)/core/snmp/msg_in.c $(LWIPDIR)/core/snmp/msg_out.c
+
+# APIFILES: The files which implement the sequential and socket APIs.
+APIFILES=$(LWIPDIR)/api/api_lib.c $(LWIPDIR)/api/api_msg.c $(LWIPDIR)/api/tcpip.c \
+	$(LWIPDIR)/api/err.c $(LWIPDIR)/api/sockets.c $(LWIPDIR)/api/netbuf.c $(LWIPDIR)/api/netdb.c
+
+# NETIFFILES: Files implementing various generic network interface functions.'
+NETIFFILES=$(LWIPDIR)/netif/etharp.c $(LWIPDIR)/netif/slipif.c
+
+# NETIFFILES: Add PPP netif
+NETIFFILES+=$(LWIPDIR)/netif/ppp/auth.c $(LWIPDIR)/netif/ppp/chap.c \
+	$(LWIPDIR)/netif/ppp/chpms.c $(LWIPDIR)/netif/ppp/fsm.c \
+	$(LWIPDIR)/netif/ppp/ipcp.c $(LWIPDIR)/netif/ppp/lcp.c \
+	$(LWIPDIR)/netif/ppp/magic.c $(LWIPDIR)/netif/ppp/md5.c \
+	$(LWIPDIR)/netif/ppp/pap.c $(LWIPDIR)/netif/ppp/ppp.c \
+	$(LWIPDIR)/netif/ppp/randm.c $(LWIPDIR)/netif/ppp/vj.c
+
+# ARCHFILES: Architecture specific files.
+ARCHFILES=$(wildcard $(LWIPARCH)/*.c $(LWIPARCH)tapif.c $(LWIPARCH)/netif/list.c $(LWIPARCH)/netif/tcpdump.c)
+
+
+# LWIPFILES: All the above.
+LWIPFILES=$(COREFILES) $(CORE4FILES) $(SNMPFILES) $(APIFILES) $(NETIFFILES) $(ARCHFILES)
+LWIPFILESW=$(wildcard $(LWIPFILES))
+LWIPOBJS=$(notdir $(LWIPFILESW:.c=.o))
+
+LWIPLIB=liblwip.so
+
+%.o:
+	$(CC) $(CFLAGS) -c $(<:.o=.c)
+
+all: $(LWIPLIB)
+.PHONY: all
+
+clean:
+	rm -f *.o $(LWIPLIB) *.s .depend* *.core core
+
+depend dep: .depend
+
+include .depend
+
+$(LWIPLIB): $(LWIPOBJS)
+	$(CC) -g -nostartfiles -shared -o $@ $^
+
+.depend: $(LWIPFILES)
+	$(CCDEP) $(CFLAGS) -MM $^ > .depend || rm -f .depend

netcon/utils.c

@@ -1,93 +0,0 @@
-/*
- * ZeroTier One - Network Virtualization Everywhere
- * Copyright (C) 2011-2015  ZeroTier, Inc.
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- * --
- *
- * ZeroTier may be used and distributed under the terms of the GPLv3, which
- * are available at: http://www.gnu.org/licenses/gpl-3.0.html
- *
- * If you would like to embed ZeroTier into a commercial application or
- * redistribute it in a modified binary form, please contact ZeroTier Networks
- * LLC. Start here: http://www.zerotier.com/
- */
-
-void get_path_from_pid(char* dest, int pid)
-{
-  char ppath[50];
-  sprintf(ppath, "/proc/%d/exe", pid);
-  if (readlink (ppath, dest, 50) != -1){
-  }
-}
-
-void print_ip(int ip)
-{
-  unsigned char bytes[4];
-  bytes[0] = ip & 0xFF;
-  bytes[1] = (ip >> 8) & 0xFF;
-  bytes[2] = (ip >> 16) & 0xFF;
-  bytes[3] = (ip >> 24) & 0xFF;
-  printf("%d.%d.%d.%d\n", bytes[0], bytes[1], bytes[2], bytes[3]);
-  //return buf;
-}
-
-
-/* --- */
-
-
-#ifdef NETCON_SERVICE
-ip_addr_t convert_ip(struct sockaddr_in * addr)
-{
-  ip_addr_t conn_addr;
-  struct sockaddr_in *ipv4 = addr;
-  short a = ip4_addr1(&(ipv4->sin_addr));
-  short b = ip4_addr2(&(ipv4->sin_addr));
-  short c = ip4_addr3(&(ipv4->sin_addr));
-  short d = ip4_addr4(&(ipv4->sin_addr));
-  IP4_ADDR(&conn_addr, a,b,c,d);
-  return conn_addr;
-}
-
-ip_addr_t ip_addr_sin(register struct sockaddr_in *sin) {
-   ip_addr_t ip;
-   *((struct sockaddr_in*) &ip) = *sin;
-   return ip;
-}
-#endif
-
-
-/* --- */
-
-
-#ifdef NETCON_INTERCEPT
-
-typedef unsigned char u8_t;
-
-#define 	ip4_addr1(ipaddr)   (((u8_t*)(ipaddr))[0])
-#define 	ip4_addr2(ipaddr)   (((u8_t*)(ipaddr))[1])
-#define 	ip4_addr3(ipaddr)   (((u8_t*)(ipaddr))[2])
-#define 	ip4_addr4(ipaddr)   (((u8_t*)(ipaddr))[3])
-
-int is_local(struct sockaddr_in* addr)
-{
-  struct sockaddr_in *ipv4 = addr;
-  short a = ip4_addr1(&(ipv4->sin_addr));
-  short b = ip4_addr2(&(ipv4->sin_addr));
-  short c = ip4_addr3(&(ipv4->sin_addr));
-  short d = ip4_addr4(&(ipv4->sin_addr));
-  return (a==127 && b == 0 && c == 0 && d == 1);
-}
-#endif