picotcp/lwip ipv4/ipv6 fully functional, needs stress testing0.6.1

16 files changed, 719 insertions, 549 deletions

diff --git a/ext/lwipopts.h b/ext/lwipopts.h
index 91dafe0..f5df284 100644
--- a/ext/lwipopts.h
+++ b/ext/lwipopts.h
@@ -1,491 +1,2 @@
-/**
- * @file
- *
- * lwIP Options Configuration
- */
-
-/*
- * Copyright (c) 2001-2004 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]>
- *
- */
-#ifndef __LWIPOPTS_H__
-#define __LWIPOPTS_H__
-
-/*
- * Include user defined options first. Anything not defined in these files
- * will be set to standard values. Override anything you dont like!
- */
-#include "lwip/debug.h"
-
-// IPV6 Related
-//#if defined(SDK_IPV6)
-	#define LWIP_IPV6   0
-//#endif
-//#if defined(SDK_IPV4) 
-	#define LWIP_IPV4   1
-//#endif
-
-#define LWIP_TCP 1
-#define IP6_DEBUG       1
-#define LWIP_DEBUG      1
-#define IP_DEBUG        LWIP_DBG_ON
-#define LWIP_ETHERNET   1
-
-#define LWIP_DBG_TYPES_ON LWIP_DBG_TRACE | LWIP_DBG_STATE | LWIP_DBG_FRESH
-
-#define LWIP_CHKSUM_ALGORITHM 2
-
-#undef TCP_MSS
-#define TCP_MSS 1460
-
-/*
-The TCP window size can be adjusted by changing the define TCP_WND. However,
-do keep in mind that this should be at least twice the size of TCP_MSS (thus
-on ethernet, where TCP_MSS is 1460, it should be set to at least 2920). If
-memory allows it, set this as high as possible (16-bit, so 0xFFFF is the highest
-value), but keep in mind that for every active connection, the full window may
-have to be buffered until it is acknowledged by the remote side (although this
-buffer size can still be controlled by TCP_SND_BUF and TCP_SND_QUEUELEN). The
-reason for "twice" are both the nagle algorithm and delayed ACK from the
-remote peer.
-*/
-
-#define TCP_WND TCP_MSS*10 // max = 0xffff
-
-//#define LWIP_NOASSERT 1
-#define TCP_LISTEN_BACKLOG   0
-
-/*------------------------------------------------------------------------------
----------------------------------- Timers --------------------------------------
-------------------------------------------------------------------------------*/
-/*
-Be careful about setting this too small.  lwIP just counts the number
-of times its timer is called and uses this to control time sensitive
-operations (such as TCP retransmissions), rather than actually
-measuring time using something more accurate.  If you call the timer
-functions very frequently you may see things (such as retransmissions)
-happening sooner than they should.
-*/
-/* these are originally defined in tcp_impl.h */
-#ifndef TCP_TMR_INTERVAL
-/* The TCP timer interval in milliseconds. */
-#define TCP_TMR_INTERVAL       250
-#endif /* TCP_TMR_INTERVAL */
-
-#ifndef TCP_FAST_INTERVAL
-/* the fine grained timeout in milliseconds */
-#define TCP_FAST_INTERVAL      TCP_TMR_INTERVAL
-#endif /* TCP_FAST_INTERVAL */
-
-#ifndef TCP_SLOW_INTERVALs
-/* the coarse grained timeout in milliseconds */
-#define TCP_SLOW_INTERVAL      (2*TCP_TMR_INTERVAL)
-#endif /* TCP_SLOW_INTERVAL */
-
-
-/*------------------------------------------------------------------------------
---------------------------- Platform specific locking -------------------------
-------------------------------------------------------------------------------*/
-
-/**
- * SYS_LIGHTWEIGHT_PROT==1: if you want inter-task protection for certain
- * critical regions during buffer allocation, deallocation and memory
- * allocation and deallocation.
- */
-#define SYS_LIGHTWEIGHT_PROT            0
-
-/**
- * NO_SYS==1: Provides VERY minimal functionality. Otherwise,
- * use lwIP facilities.
- */
-
-/* set to 1 so we have no thread behaviour */
-#define NO_SYS                          1
-
-/* set to 1 so we can use our own timers */
-#define NO_SYS_NO_TIMERS                1
-
-
-/*------------------------------------------------------------------------------
--------------------------------- Memory options --------------------------------
-------------------------------------------------------------------------------*/
-
-
-
-/* Misc */
-#define MEM_LIBC_MALLOC 1
-#define MEMP_MEM_MALLOC 1
-
-
-
-/**
- * MEM_ALIGNMENT: should be set to the alignment of the CPU
- *    4 byte alignment -> #define MEM_ALIGNMENT 4
- *    2 byte alignment -> #define MEM_ALIGNMENT 2
- */
-#define MEM_ALIGNMENT                   1
-
-/**
- * MEM_SIZE: the size of the heap memory. If the application will send
- * a lot of data that needs to be copied, this should be set high.
- */
-#define MEM_SIZE                        1024 * 1024 * 64
-#define TCP_SND_BUF                     1024 * 63
-//#define TCP_OVERSIZE                    TCP_MSS
-
-#define TCP_SND_QUEUELEN                1024
-
-/*------------------------------------------------------------------------------
--------------------------------- Pbuf Options ----------------------------------
-------------------------------------------------------------------------------*/
-
-/**
- * PBUF_LINK_HLEN: the number of bytes that should be allocated for a
- * link level header. The default is 14, the standard value for
- * Ethernet.
- */
-#define PBUF_LINK_HLEN                  16
-
-/**
- * PBUF_POOL_BUFSIZE: the size of each pbuf in the pbuf pool. The default is
- * designed to accomodate single full size TCP frame in one pbuf, including
- * TCP_MSS, IP header, and link header.
-*
- */
-#define PBUF_POOL_BUFSIZE               LWIP_MEM_ALIGN_SIZE(TCP_MSS+40+PBUF_LINK_HLEN)
-
-
-/*------------------------------------------------------------------------------
--------------------------- Internal Memory Pool Sizes --------------------------
-------------------------------------------------------------------------------*/
-
-/**
- * MEMP_NUM_PBUF: the number of memp struct pbufs (used for PBUF_ROM and PBUF_REF).
- * If the application sends a lot of data out of ROM (or other static memory),
- * this should be set high.
- */
-#define MEMP_NUM_PBUF                   256
-
-/**
- * MEMP_NUM_RAW_PCB: Number of raw connection PCBs
- * (requires the LWIP_RAW option)
- */
-#define MEMP_NUM_RAW_PCB                128
-
-/**
- * MEMP_NUM_UDP_PCB: the number of UDP protocol control blocks. One
- * per active UDP "connection".
- * (requires the LWIP_UDP option)
- */
-#define MEMP_NUM_UDP_PCB                4
-
-/**
- * MEMP_NUM_TCP_PCB: the number of simulatenously active TCP connections.
- * (requires the LWIP_TCP option)
- */
-#define MEMP_NUM_TCP_PCB                128
-
-/**
- * MEMP_NUM_TCP_PCB_LISTEN: the number of listening TCP connections.
- * (requires the LWIP_TCP option)
- */
-#define MEMP_NUM_TCP_PCB_LISTEN         128
-
-/**
- * MEMP_NUM_TCP_SEG: the number of simultaneously queued TCP segments.
- * (requires the LWIP_TCP option)
- */
-#define MEMP_NUM_TCP_SEG                1024
-
-/**
- * MEMP_NUM_REASSDATA: the number of simultaneously IP packets queued for
- * reassembly (whole packets, not fragments!)
- */
-#define MEMP_NUM_REASSDATA              1
-
-/**
- * MEMP_NUM_ARP_QUEUE: the number of simulateously queued outgoing
- * packets (pbufs) that are waiting for an ARP request (to resolve
- * their destination address) to finish.
- * (requires the ARP_QUEUEING option)
- */
-#define MEMP_NUM_ARP_QUEUE              2
-
-/**
- * MEMP_NUM_SYS_TIMEOUT: the number of simulateously active timeouts.
- * (requires NO_SYS==0)
- */
-#define MEMP_NUM_SYS_TIMEOUT            3
-
-/**
- * MEMP_NUM_NETBUF: the number of struct netbufs.
- * (only needed if you use the sequential API, like api_lib.c)
- */
-#define MEMP_NUM_NETBUF                 2
-
-/**
- * MEMP_NUM_NETCONN: the number of struct netconns.
- * (only needed if you use the sequential API, like api_lib.c)
- */
-#define MEMP_NUM_NETCONN                4
-
-/**
- * MEMP_NUM_TCPIP_MSG_API: the number of struct tcpip_msg, which are used
- * for callback/timeout API communication.
- * (only needed if you use tcpip.c)
- */
-#define MEMP_NUM_TCPIP_MSG_API          8
-
-/**
- * MEMP_NUM_TCPIP_MSG_INPKT: the number of struct tcpip_msg, which are used
- * for incoming packets.
- * (only needed if you use tcpip.c)
- */
-#define MEMP_NUM_TCPIP_MSG_INPKT        8
-
-/**
- * PBUF_POOL_SIZE: the number of buffers in the pbuf pool.
- */
-#define PBUF_POOL_SIZE                  2048 /* was 32 */
-
-
-/*------------------------------------------------------------------------------
------------------------------------ ARP options --------------------------------
-------------------------------------------------------------------------------*/
-
-/**
- * LWIP_ARP==1: Enable ARP functionality.
- */
-#define LWIP_ARP                        1
-
-
-/*------------------------------------------------------------------------------
------------------------------------- IP options---------------------------------
-------------------------------------------------------------------------------*/
-
-/**
- * IP_FORWARD==1: Enables the ability to forward IP packets across network
- * interfaces. If you are going to run lwIP on a device with only one network
- * interface, define this to 0.
- */
-#define IP_FORWARD                      0
-
-/**
- * IP_OPTIONS: Defines the behavior for IP options.
- *      IP_OPTIONS_ALLOWED==0: All packets with IP options are dropped.
- *      IP_OPTIONS_ALLOWED==1: IP options are allowed (but not parsed).
- */
-#define IP_OPTIONS_ALLOWED              1
-
-/**
- * IP_REASSEMBLY==1: Reassemble incoming fragmented IP packets. Note that
- * this option does not affect outgoing packet sizes, which can be controlled
- * via IP_FRAG.
- */
-#define IP_REASSEMBLY                   1
-
-/**
- * IP_FRAG==1: Fragment outgoing IP packets if their size exceeds MTU. Note
- * that this option does not affect incoming packet sizes, which can be
- * controlled via IP_REASSEMBLY.
- */
-#define IP_FRAG                         1
-
-/**
- * IP_REASS_MAXAGE: Maximum time (in multiples of IP_TMR_INTERVAL - so seconds, normally)
- * a fragmented IP packet waits for all fragments to arrive. If not all fragments arrived
- * in this time, the whole packet is discarded.
- */
-#define IP_REASS_MAXAGE                 3
-
-/**
- * IP_REASS_MAX_PBUFS: Total maximum amount of pbufs waiting to be reassembled.
- * Since the received pbufs are enqueued, be sure to configure
- * PBUF_POOL_SIZE > IP_REASS_MAX_PBUFS so that the stack is still able to receive
- * packets even if the maximum amount of fragments is enqueued for reassembly!
- */
-#define IP_REASS_MAX_PBUFS              4
-
-/**
- * IP_FRAG_USES_STATIC_BUF==1: Use a static MTU-sized buffer for IP
- * fragmentation. Otherwise pbufs are allocated and reference the original
-    * packet data to be fragmented.
-*/
-#define IP_FRAG_USES_STATIC_BUF         0
-
-/**
- * IP_DEFAULT_TTL: Default value for Time-To-Live used by transport layers.
- */
-#define IP_DEFAULT_TTL                  255
-
-
-/*------------------------------------------------------------------------------
-------------------------------- ICMP Options -----------------------------------
-------------------------------------------------------------------------------*/
-
-/**
- * LWIP_ICMP==1: Enable ICMP module inside the IP stack.
- * Be careful, disable that make your product non-compliant to RFC1122
- */
-#define LWIP_ICMP                       1
-
-
-/*------------------------------------------------------------------------------
-------------------------------- RAW Options ------------------------------------
-------------------------------------------------------------------------------*/
-
-/**
- * LWIP_RAW==1: Enable application layer to hook into the IP layer itself.
- */
-#define LWIP_RAW                        1
-
-
-/*------------------------------------------------------------------------------
-------------------------------- DHCP Options -----------------------------------
-------------------------------------------------------------------------------*/
-
-/**
- * LWIP_DHCP==1: Enable DHCP module.
- */
-#define LWIP_DHCP                       0
-
-
-/*------------------------------------------------------------------------------
------------------------------- AUTOIP Options ----------------------------------
-------------------------------------------------------------------------------*/
-
-/**
- * LWIP_AUTOIP==1: Enable AUTOIP module.
- */
-#define LWIP_AUTOIP                     0
-
-
-/*------------------------------------------------------------------------------
-------------------------------- SNMP Options -----------------------------------
-------------------------------------------------------------------------------*/
-
-/**
- * LWIP_SNMP==1: Turn on SNMP module. UDP must be available for SNMP
- * transport.
- */
-#define LWIP_SNMP                       0
-
-
-/*------------------------------------------------------------------------------
-------------------------------- IGMP Options -----------------------------------
-------------------------------------------------------------------------------*/
-
-/**
- * LWIP_IGMP==1: Turn on IGMP module.
- */
-#define LWIP_IGMP                       0
-
-
-/*------------------------------------------------------------------------------
--------------------------------- DNS Options -----------------------------------
-------------------------------------------------------------------------------*/
-
-/**
- * LWIP_DNS==1: Turn on DNS module. UDP must be available for DNS
- * transport.
- */
-#define LWIP_DNS                        0
-
-
-/*------------------------------------------------------------------------------
--------------------------------- UDP Options -----------------------------------
-------------------------------------------------------------------------------*/
-
-/**
- * LWIP_UDP==1: Turn on UDP.
- */
-#define LWIP_UDP                        1
-
-
-/*------------------------------------------------------------------------------
--------------------------------- TCP Options -----------------------------------
-------------------------------------------------------------------------------*/
-
-/**
- * LWIP_TCP==1: Turn on TCP.
- */
-#define LWIP_TCP                        1
-
-#define LWIP_LISTEN_BACKLOG             0
-
-
-/*------------------------------------------------------------------------------
---------------------------------- LOOPIF Options -------------------------------
-------------------------------------------------------------------------------*/
-
-/**
- * LWIP_HAVE_LOOPIF==1: Support loop interface (127.0.0.1) and loopif.c
- */
-#define LWIP_HAVE_LOOPIF                0
-
-
-/*------------------------------------------------------------------------------
----------------------------- Sequential Layer Options --------------------------
-------------------------------------------------------------------------------*/
-
-/**
- * LWIP_NETCONN==1: Enable Netconn API (require to use api_lib.c)
- */
-#define LWIP_NETCONN                    0
-
-
-/*------------------------------------------------------------------------------
---------------------------------- Socket Options -------------------------------
-------------------------------------------------------------------------------*/
-/**
- * LWIP_SOCKET==1: Enable Socket API (require to use sockets.c)
- */
-#define LWIP_SOCKET                     0
-
-
-/*------------------------------------------------------------------------------
------------------------------- Statistics Options ------------------------------
-------------------------------------------------------------------------------*/
-
-/**
- * LWIP_STATS==1: Enable statistics collection in lwip_stats.
- */
-#define LWIP_STATS                      0
-
-/*------------------------------------------------------------------------------
---------------------------------- PPP Options ----------------------------------
-------------------------------------------------------------------------------*/
-
-/**
- * PPP_SUPPORT==1: Enable PPP.
- */
-#define PPP_SUPPORT                     0
-
-#endif /* __LWIPOPTS_H__ */
+// Refers to the actual lwIP stack driver location
+#include "../src/stack_drivers/lwip/lwipopts.h"
\ No newline at end of file
diff --git a/make-liblwip.mk b/make-liblwip.mk
index d41214c..ca52b9c 100644
--- a/make-liblwip.mk
+++ b/make-liblwip.mk
@@ -48,7 +48,7 @@ endif
 
 CFLAGS:=$(CFLAGS) \
 	-I$(LWIPDIR)/include -I$(LWIPARCH)/include -I$(LWIPDIR)/include/ipv4 \
-	-I$(LWIPDIR) -I. -Iext
+	-I$(LWIPDIR) -I. -Iext -Isrc/stack_drivers/lwip
 
 # COREFILES, CORE4FILES: The minimum set of files needed for lwIP.
 COREFILES=$(LWIPDIR)/core/init.c \
@@ -123,7 +123,7 @@ LWIPOBJS=$(notdir $(LWIPFILESW:.c=.o))
 LWIPLIB=liblwip.so
 
 %.o:
-	$(CC) $(CFLAGS) -c $(<:.o=.c)
+	$(CC) $(CFLAGS) -Isrc/stack_drivers/lwip -c $(<:.o=.c)
 
 all: $(LWIPLIB)
 .PHONY: all
@@ -137,7 +137,7 @@ include .depend
 
 $(LWIPLIB): $(LWIPOBJS)
 	mkdir -p build
-	$(CC) -g -nostartfiles -shared -o build/$@ $^
+	$(CC) -Isrc/stack_drivers/lwip -g -nostartfiles -shared -o build/$@ $^
 
 .depend: $(LWIPFILES)
 	$(CCDEP) $(CFLAGS) -MM $^ > .depend || rm -f .depend
\ No newline at end of file
diff --git a/make-linux.mk b/make-linux.mk
index ca8b1a7..41f5441 100644
--- a/make-linux.mk
+++ b/make-linux.mk
@@ -85,7 +85,8 @@ INCLUDES+= -Iext \
 	-I$(LWIP_DIR)/src/include/ipv4 \
 	-I$(LWIP_DIR)/src/include/ipv6 \
 	-I$(PICOTCP_DIR)/include \
-	-I$(PICOTCP_DIR)/build/include
+	-I$(PICOTCP_DIR)/build/include \
+	-Isrc/stack_drivers/lwip
 
 
 # Stack selection / parameters
@@ -177,11 +178,16 @@ linux_intercept:
 	cd src ; gcc $(DEFS) $(INCLUDES) -g -O2 -Wall -std=c99 -fPIC -DVERBOSE -D_GNU_SOURCE -DSDK_INTERCEPT -nostdlib -nostdlib -shared -o ../$(INTERCEPT) sockets.c intercept.c rpc.c -ldl
 
 # Build only the SDK service
-linux_sdk_service: pico lwip $(OBJS)
+ifeq ($(SDK_LWIP),1)
+linux_sdk_service: lwip $(OBJS)
+else
+linux_sdk_service: pico $(OBJS)
+endif
 	$(CXX) $(CXXFLAGS) $(LDFLAGS) $(STACK_FLAGS) $(DEFS) $(INCLUDES) -DSDK -DZT_ONE_NO_ROOT_CHECK -o $(SDK_SERVICE) $(OBJS) $(ZT1)/service/OneService.cpp src/tap.cpp src/proxy.cpp $(ZT1)/one.cpp src/rpc.c $(LDLIBS) -ldl
 	ln -sf $(SDK_SERVICE_NAME) $(BUILD)/zerotier-cli
 	ln -sf $(SDK_SERVICE_NAME) $(BUILD)/zerotier-idtool
 
+
 # Build both intercept library and SDK service (separate)
 linux_service_and_intercept: linux_intercept linux_sdk_service
 
diff --git a/src/stack_drivers/lwip.hpp b/src/stack_drivers/lwip.hpp
index bfc0df8..411f468 100644
--- a/src/stack_drivers/lwip.hpp
+++ b/src/stack_drivers/lwip.hpp
@@ -157,7 +157,6 @@ namespace ZeroTier {
         struct tcp_pcb * (*_tcp_new)(TCP_NEW_SIG);
         u16_t (*_tcp_sndbuf)(TCP_SNDBUF_SIG);
         err_t (*_tcp_connect)(TCP_CONNECT_SIG);
-        
         struct udp_pcb * (*_udp_new)(UDP_NEW_SIG);
         err_t (*_udp_connect)(UDP_CONNECT_SIG);
         err_t (*_udp_send)(UDP_SEND_SIG);
@@ -166,7 +165,6 @@ namespace ZeroTier {
         void (*_udp_recved)(UDP_RECVED_SIG);
         err_t (*_udp_bind)(UDP_BIND_SIG);
         void (*_udp_remove)(UDP_REMOVE_SIG);
-
         void (*_tcp_recv)(TCP_RECV_SIG);
         void (*_tcp_recved)(TCP_RECVED_SIG);
         void (*_tcp_err)(TCP_ERR_SIG);
@@ -240,7 +238,6 @@ namespace ZeroTier {
             _tcp_write = (err_t(*)(TCP_WRITE_SIG))&tcp_write;
             _tcp_sent = (void(*)(TCP_SENT_SIG))&tcp_sent;
             _tcp_new = (struct tcp_pcb*(*)(TCP_NEW_SIG))&tcp_new;
-            
             _udp_new = (struct udp_pcb*(*)(UDP_NEW_SIG))&udp_new;
             _udp_connect = (err_t(*)(UDP_CONNECT_SIG))&udp_connect;
             _udp_send = (err_t(*)(UDP_SEND_SIG))&udp_send;
@@ -248,7 +245,6 @@ namespace ZeroTier {
             _udp_recv = (void(*)(UDP_RECV_SIG))&udp_recv;
             _udp_bind = (err_t(*)(UDP_BIND_SIG))&udp_bind;
             _udp_remove = (void(*)(UDP_REMOVE_SIG))&udp_remove;
-
             _tcp_connect = (err_t(*)(TCP_CONNECT_SIG))&tcp_connect;
             _tcp_recv = (void(*)(TCP_RECV_SIG))&tcp_recv;
             _tcp_recved = (void(*)(TCP_RECVED_SIG))&tcp_recved;
@@ -299,7 +295,6 @@ namespace ZeroTier {
             _tcp_write = (err_t(*)(TCP_WRITE_SIG))dlsym(_libref, "tcp_write");
             _tcp_sent = (void(*)(TCP_SENT_SIG))dlsym(_libref, "tcp_sent");
             _tcp_new = (struct tcp_pcb*(*)(TCP_NEW_SIG))dlsym(_libref, "tcp_new");
-            
             _udp_new = (struct udp_pcb*(*)(UDP_NEW_SIG))dlsym(_libref, "udp_new");
             _udp_connect = (err_t(*)(UDP_CONNECT_SIG))dlsym(_libref, "udp_connect");
             _udp_send = (err_t(*)(UDP_SEND_SIG))dlsym(_libref, "udp_send");
@@ -307,7 +302,6 @@ namespace ZeroTier {
             _udp_recv = (void(*)(UDP_RECV_SIG))dlsym(_libref, "udp_recv");
             _udp_bind = (err_t(*)(UDP_BIND_SIG))dlsym(_libref, "udp_bind");
             _udp_remove = (void(*)(UDP_REMOVE_SIG))dlsym(_libref, "udp_remove");
-
             _tcp_sndbuf = (u16_t(*)(TCP_SNDBUF_SIG))dlsym(_libref, "tcp_sndbuf");
             _tcp_connect = (err_t(*)(TCP_CONNECT_SIG))dlsym(_libref, "tcp_connect");
             _tcp_recv = (void(*)(TCP_RECV_SIG))dlsym(_libref, "tcp_recv");
@@ -357,12 +351,10 @@ namespace ZeroTier {
         
         inline void __netif_init(void) throw() { Mutex::Lock _l(_lock); _netif_init(); }
         // inline void __netif_set_addr(NETIF_SET_ADDR_SIG) throw() { Mutex::Lock _l(_lock); _netif_set_addr(netif, ipaddr, netmask, gw); }
-
         inline void __lwip_init() throw() { DEBUG_STACK(); Mutex::Lock _l(_lock); return _lwip_init(); }
         inline err_t __tcp_write(TCP_WRITE_SIG) throw() { DEBUG_STACK(); Mutex::Lock _l(_lock); return _tcp_write(pcb,arg,len,apiflags); }
         inline void __tcp_sent(TCP_SENT_SIG) throw() { DEBUG_STACK(); Mutex::Lock _l(_lock); return _tcp_sent(pcb,sent); }
         inline struct tcp_pcb * __tcp_new(TCP_NEW_SIG) throw() { DEBUG_STACK(); Mutex::Lock _l(_lock); return _tcp_new(); }
-        
         inline struct udp_pcb * __udp_new(UDP_NEW_SIG) throw() { DEBUG_STACK(); Mutex::Lock _l(_lock); return _udp_new(); }
         inline err_t __udp_connect(UDP_CONNECT_SIG) throw() { DEBUG_STACK(); Mutex::Lock _l(_lock); return _udp_connect(pcb,ipaddr,port); }
         inline err_t __udp_send(UDP_SEND_SIG) throw() { DEBUG_STACK(); Mutex::Lock _l(_lock); return _udp_send(pcb,p); }
@@ -370,14 +362,13 @@ namespace ZeroTier {
         inline void __udp_recv(UDP_RECV_SIG) throw() { DEBUG_STACK(); Mutex::Lock _l(_lock); return _udp_recv(pcb,recv,recv_arg); }
         inline err_t __udp_bind(UDP_BIND_SIG) throw() { DEBUG_STACK(); Mutex::Lock _l(_lock); return _udp_bind(pcb,ipaddr,port); }
         inline void __udp_remove(UDP_REMOVE_SIG) throw() { DEBUG_STACK(); Mutex::Lock _l(_lock); return _udp_remove(pcb); }
-
         inline u16_t __tcp_sndbuf(TCP_SNDBUF_SIG) throw() { DEBUG_STACK(); Mutex::Lock _l(_lock); return _tcp_sndbuf(pcb); }
         inline err_t __tcp_connect(TCP_CONNECT_SIG) throw() { DEBUG_STACK(); Mutex::Lock _l(_lock); return _tcp_connect(pcb,ipaddr,port,connected); }
         inline void __tcp_recv(TCP_RECV_SIG) throw() { DEBUG_STACK(); Mutex::Lock _l(_lock); return _tcp_recv(pcb,recv); }
         inline void __tcp_recved(TCP_RECVED_SIG) throw() { DEBUG_STACK(); Mutex::Lock _l(_lock); return _tcp_recved(pcb,len); }
         inline void __tcp_err(TCP_ERR_SIG) throw() { DEBUG_STACK(); Mutex::Lock _l(_lock); return _tcp_err(pcb,err); }
         inline void __tcp_poll(TCP_POLL_SIG) throw() { DEBUG_STACK(); Mutex::Lock _l(_lock); return _tcp_poll(pcb,poll,interval); }
-        inline void __tcp_arg(TCP_ARG_SIG) throw() { DEBUG_STACK(); Mutex::Lock _l(_lock); return _tcp_arg(pcb,arg); }
+        inline void __tcp_arg(TCP_ARG_SIG) throw() { /*DEBUG_STACK();*/ Mutex::Lock _l(_lock); return _tcp_arg(pcb,arg); }
         inline err_t __tcp_close(TCP_CLOSE_SIG) throw() { DEBUG_STACK(); Mutex::Lock _l(_lock); return _tcp_close(pcb); }
         inline void __tcp_abort(TCP_ABORT_SIG) throw() { DEBUG_STACK(); Mutex::Lock _l(_lock); return _tcp_abort(pcb); }
         inline err_t __tcp_output(TCP_OUTPUT_SIG) throw() { DEBUG_STACK(); Mutex::Lock _l(_lock); return _tcp_output(pcb); }
@@ -389,11 +380,9 @@ namespace ZeroTier {
         inline void __tcp_tmr(void) throw() { /*DEBUG_STACK();*/ Mutex::Lock _l(_lock); return _tcp_tmr(); }
         inline u8_t __pbuf_free(PBUF_FREE_SIG) throw() { DEBUG_STACK(); Mutex::Lock _l(_lock); return _pbuf_free(p); }
         inline struct pbuf * __pbuf_alloc(PBUF_ALLOC_SIG) throw() { /*DEBUG_STACK();*/ Mutex::Lock _l(_lock_mem); return _pbuf_alloc(layer,length,type); }
-        inline u16_t __lwip_htons(LWIP_HTONS_SIG) throw() { DEBUG_STACK(); Mutex::Lock _l(_lock); return _lwip_htons(x); }
-        inline u16_t __lwip_ntohs(LWIP_NTOHS_SIG) throw() { DEBUG_STACK(); Mutex::Lock _l(_lock); return _lwip_ntohs(x); }
-
+        inline u16_t __lwip_htons(LWIP_HTONS_SIG) throw() { /*DEBUG_STACK();*/ Mutex::Lock _l(_lock); return _lwip_htons(x); }
+        inline u16_t __lwip_ntohs(LWIP_NTOHS_SIG) throw() { /*DEBUG_STACK();*/ Mutex::Lock _l(_lock); return _lwip_ntohs(x); }
         //inline err_t __etharp_output(ETHARP_OUTPUT_SIG) throw() { Mutex::Lock _l(_lock); return _etharp_output(netif,q,ipaddr); }
-
         inline err_t __ethernet_input(ETHERNET_INPUT_SIG) throw() { DEBUG_STACK(); Mutex::Lock _l(_lock); return _ethernet_input(p,netif); }
         inline void __tcp_input(TCP_INPUT_SIG) throw() { DEBUG_STACK(); Mutex::Lock _l(_lock); return _tcp_input(p,inp); }
         inline err_t __ip_input(IP_INPUT_SIG) throw() { DEBUG_STACK(); Mutex::Lock _l(_lock); return _ip_input(p,inp); }
diff --git a/src/stack_drivers/lwip/lwipopts.h b/src/stack_drivers/lwip/lwipopts.h
new file mode 100644
index 0000000..cf4a1d3
--- /dev/null
+++ b/src/stack_drivers/lwip/lwipopts.h
@@ -0,0 +1,496 @@
+/**
+ * @file
+ *
+ * lwIP Options Configuration
+ */
+
+/*
+ * Copyright (c) 2001-2004 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]>
+ *
+ */
+#ifndef __LWIPOPTS_H__
+#define __LWIPOPTS_H__
+
+/*
+ * Include user defined options first. Anything not defined in these files
+ * will be set to standard values. Override anything you dont like!
+ */
+#include "lwip/debug.h"
+
+// IP Protocol version 
+// It seems using ipv6/ipv4 in the same stack is problematic, for this reason we 
+// compile for only one or the other using the SDK_IPV4=1/SDK_IPV6=1 flags for now
+#if defined(SDK_IPV6)
+	#define LWIP_IPV6   1
+ 	#define LWIP_IPV4   0
+
+#endif
+#if defined(SDK_IPV4) 
+	#define LWIP_IPV4   1
+ 	#define LWIP_IPV6   0
+#endif
+
+#define LWIP_TCP        1
+#define IP6_DEBUG       1
+#define LWIP_DEBUG      1
+#define IP_DEBUG        LWIP_DBG_ON
+#define LWIP_ETHERNET   1
+
+#define LWIP_DBG_TYPES_ON LWIP_DBG_TRACE | LWIP_DBG_STATE | LWIP_DBG_FRESH
+
+#define LWIP_CHKSUM_ALGORITHM 2
+
+#undef TCP_MSS
+#define TCP_MSS 1460
+
+/*
+The TCP window size can be adjusted by changing the define TCP_WND. However,
+do keep in mind that this should be at least twice the size of TCP_MSS (thus
+on ethernet, where TCP_MSS is 1460, it should be set to at least 2920). If
+memory allows it, set this as high as possible (16-bit, so 0xFFFF is the highest
+value), but keep in mind that for every active connection, the full window may
+have to be buffered until it is acknowledged by the remote side (although this
+buffer size can still be controlled by TCP_SND_BUF and TCP_SND_QUEUELEN). The
+reason for "twice" are both the nagle algorithm and delayed ACK from the
+remote peer.
+*/
+
+#define TCP_WND TCP_MSS*10 // max = 0xffff
+
+//#define LWIP_NOASSERT 1
+#define TCP_LISTEN_BACKLOG   0
+
+/*------------------------------------------------------------------------------
+---------------------------------- Timers --------------------------------------
+------------------------------------------------------------------------------*/
+/*
+Be careful about setting this too small.  lwIP just counts the number
+of times its timer is called and uses this to control time sensitive
+operations (such as TCP retransmissions), rather than actually
+measuring time using something more accurate.  If you call the timer
+functions very frequently you may see things (such as retransmissions)
+happening sooner than they should.
+*/
+/* these are originally defined in tcp_impl.h */
+#ifndef TCP_TMR_INTERVAL
+/* The TCP timer interval in milliseconds. */
+#define TCP_TMR_INTERVAL       250
+#endif /* TCP_TMR_INTERVAL */
+
+#ifndef TCP_FAST_INTERVAL
+/* the fine grained timeout in milliseconds */
+#define TCP_FAST_INTERVAL      TCP_TMR_INTERVAL
+#endif /* TCP_FAST_INTERVAL */
+
+#ifndef TCP_SLOW_INTERVALs
+/* the coarse grained timeout in milliseconds */
+#define TCP_SLOW_INTERVAL      (2*TCP_TMR_INTERVAL)
+#endif /* TCP_SLOW_INTERVAL */
+
+
+/*------------------------------------------------------------------------------
+--------------------------- Platform specific locking -------------------------
+------------------------------------------------------------------------------*/
+
+/**
+ * SYS_LIGHTWEIGHT_PROT==1: if you want inter-task protection for certain
+ * critical regions during buffer allocation, deallocation and memory
+ * allocation and deallocation.
+ */
+#define SYS_LIGHTWEIGHT_PROT            0
+
+/**
+ * NO_SYS==1: Provides VERY minimal functionality. Otherwise,
+ * use lwIP facilities.
+ */
+
+/* set to 1 so we have no thread behaviour */
+#define NO_SYS                          1
+
+/* set to 1 so we can use our own timers */
+#define NO_SYS_NO_TIMERS                1
+
+
+/*------------------------------------------------------------------------------
+-------------------------------- Memory options --------------------------------
+------------------------------------------------------------------------------*/
+
+
+
+/* Misc */
+#define MEM_LIBC_MALLOC 1
+#define MEMP_MEM_MALLOC 1
+
+
+
+/**
+ * MEM_ALIGNMENT: should be set to the alignment of the CPU
+ *    4 byte alignment -> #define MEM_ALIGNMENT 4
+ *    2 byte alignment -> #define MEM_ALIGNMENT 2
+ */
+#define MEM_ALIGNMENT                   1
+
+/**
+ * MEM_SIZE: the size of the heap memory. If the application will send
+ * a lot of data that needs to be copied, this should be set high.
+ */
+#define MEM_SIZE                        1024 * 1024 * 64
+#define TCP_SND_BUF                     1024 * 63
+//#define TCP_OVERSIZE                    TCP_MSS
+
+#define TCP_SND_QUEUELEN                1024
+
+/*------------------------------------------------------------------------------
+-------------------------------- Pbuf Options ----------------------------------
+------------------------------------------------------------------------------*/
+
+/**
+ * PBUF_LINK_HLEN: the number of bytes that should be allocated for a
+ * link level header. The default is 14, the standard value for
+ * Ethernet.
+ */
+#define PBUF_LINK_HLEN                  16
+
+/**
+ * PBUF_POOL_BUFSIZE: the size of each pbuf in the pbuf pool. The default is
+ * designed to accomodate single full size TCP frame in one pbuf, including
+ * TCP_MSS, IP header, and link header.
+*
+ */
+#define PBUF_POOL_BUFSIZE               LWIP_MEM_ALIGN_SIZE(TCP_MSS+40+PBUF_LINK_HLEN)
+
+
+/*------------------------------------------------------------------------------
+-------------------------- Internal Memory Pool Sizes --------------------------
+------------------------------------------------------------------------------*/
+
+/**
+ * MEMP_NUM_PBUF: the number of memp struct pbufs (used for PBUF_ROM and PBUF_REF).
+ * If the application sends a lot of data out of ROM (or other static memory),
+ * this should be set high.
+ */
+#define MEMP_NUM_PBUF                   256
+
+/**
+ * MEMP_NUM_RAW_PCB: Number of raw connection PCBs
+ * (requires the LWIP_RAW option)
+ */
+#define MEMP_NUM_RAW_PCB                128
+
+/**
+ * MEMP_NUM_UDP_PCB: the number of UDP protocol control blocks. One
+ * per active UDP "connection".
+ * (requires the LWIP_UDP option)
+ */
+#define MEMP_NUM_UDP_PCB                4
+
+/**
+ * MEMP_NUM_TCP_PCB: the number of simulatenously active TCP connections.
+ * (requires the LWIP_TCP option)
+ */
+#define MEMP_NUM_TCP_PCB                128
+
+/**
+ * MEMP_NUM_TCP_PCB_LISTEN: the number of listening TCP connections.
+ * (requires the LWIP_TCP option)
+ */
+#define MEMP_NUM_TCP_PCB_LISTEN         128
+
+/**
+ * MEMP_NUM_TCP_SEG: the number of simultaneously queued TCP segments.
+ * (requires the LWIP_TCP option)
+ */
+#define MEMP_NUM_TCP_SEG                1024
+
+/**
+ * MEMP_NUM_REASSDATA: the number of simultaneously IP packets queued for
+ * reassembly (whole packets, not fragments!)
+ */
+#define MEMP_NUM_REASSDATA              1
+
+/**
+ * MEMP_NUM_ARP_QUEUE: the number of simulateously queued outgoing
+ * packets (pbufs) that are waiting for an ARP request (to resolve
+ * their destination address) to finish.
+ * (requires the ARP_QUEUEING option)
+ */
+#define MEMP_NUM_ARP_QUEUE              2
+
+/**
+ * MEMP_NUM_SYS_TIMEOUT: the number of simulateously active timeouts.
+ * (requires NO_SYS==0)
+ */
+#define MEMP_NUM_SYS_TIMEOUT            3
+
+/**
+ * MEMP_NUM_NETBUF: the number of struct netbufs.
+ * (only needed if you use the sequential API, like api_lib.c)
+ */
+#define MEMP_NUM_NETBUF                 2
+
+/**
+ * MEMP_NUM_NETCONN: the number of struct netconns.
+ * (only needed if you use the sequential API, like api_lib.c)
+ */
+#define MEMP_NUM_NETCONN                4
+
+/**
+ * MEMP_NUM_TCPIP_MSG_API: the number of struct tcpip_msg, which are used
+ * for callback/timeout API communication.
+ * (only needed if you use tcpip.c)
+ */
+#define MEMP_NUM_TCPIP_MSG_API          8
+
+/**
+ * MEMP_NUM_TCPIP_MSG_INPKT: the number of struct tcpip_msg, which are used
+ * for incoming packets.
+ * (only needed if you use tcpip.c)
+ */
+#define MEMP_NUM_TCPIP_MSG_INPKT        8
+
+/**
+ * PBUF_POOL_SIZE: the number of buffers in the pbuf pool.
+ */
+#define PBUF_POOL_SIZE                  2048 /* was 32 */
+
+
+/*------------------------------------------------------------------------------
+----------------------------------- ARP options --------------------------------
+------------------------------------------------------------------------------*/
+
+/**
+ * LWIP_ARP==1: Enable ARP functionality.
+ */
+#define LWIP_ARP                        1
+
+
+/*------------------------------------------------------------------------------
+------------------------------------ IP options---------------------------------
+------------------------------------------------------------------------------*/
+
+/**
+ * IP_FORWARD==1: Enables the ability to forward IP packets across network
+ * interfaces. If you are going to run lwIP on a device with only one network
+ * interface, define this to 0.
+ */
+#define IP_FORWARD                      0
+
+/**
+ * IP_OPTIONS: Defines the behavior for IP options.
+ *      IP_OPTIONS_ALLOWED==0: All packets with IP options are dropped.
+ *      IP_OPTIONS_ALLOWED==1: IP options are allowed (but not parsed).
+ */
+#define IP_OPTIONS_ALLOWED              1
+
+/**
+ * IP_REASSEMBLY==1: Reassemble incoming fragmented IP packets. Note that
+ * this option does not affect outgoing packet sizes, which can be controlled
+ * via IP_FRAG.
+ */
+#define IP_REASSEMBLY                   1
+
+/**
+ * IP_FRAG==1: Fragment outgoing IP packets if their size exceeds MTU. Note
+ * that this option does not affect incoming packet sizes, which can be
+ * controlled via IP_REASSEMBLY.
+ */
+#define IP_FRAG                         1
+
+/**
+ * IP_REASS_MAXAGE: Maximum time (in multiples of IP_TMR_INTERVAL - so seconds, normally)
+ * a fragmented IP packet waits for all fragments to arrive. If not all fragments arrived
+ * in this time, the whole packet is discarded.
+ */
+#define IP_REASS_MAXAGE                 3
+
+/**
+ * IP_REASS_MAX_PBUFS: Total maximum amount of pbufs waiting to be reassembled.
+ * Since the received pbufs are enqueued, be sure to configure
+ * PBUF_POOL_SIZE > IP_REASS_MAX_PBUFS so that the stack is still able to receive
+ * packets even if the maximum amount of fragments is enqueued for reassembly!
+ */
+#define IP_REASS_MAX_PBUFS              4
+
+/**
+ * IP_FRAG_USES_STATIC_BUF==1: Use a static MTU-sized buffer for IP
+ * fragmentation. Otherwise pbufs are allocated and reference the original
+    * packet data to be fragmented.
+*/
+#define IP_FRAG_USES_STATIC_BUF         0
+
+/**
+ * IP_DEFAULT_TTL: Default value for Time-To-Live used by transport layers.
+ */
+#define IP_DEFAULT_TTL                  255
+
+
+/*------------------------------------------------------------------------------
+------------------------------- ICMP Options -----------------------------------
+------------------------------------------------------------------------------*/
+
+/**
+ * LWIP_ICMP==1: Enable ICMP module inside the IP stack.
+ * Be careful, disable that make your product non-compliant to RFC1122
+ */
+#define LWIP_ICMP                       1
+
+
+/*------------------------------------------------------------------------------
+------------------------------- RAW Options ------------------------------------
+------------------------------------------------------------------------------*/
+
+/**
+ * LWIP_RAW==1: Enable application layer to hook into the IP layer itself.
+ */
+#define LWIP_RAW                        1
+
+
+/*------------------------------------------------------------------------------
+------------------------------- DHCP Options -----------------------------------
+------------------------------------------------------------------------------*/
+
+/**
+ * LWIP_DHCP==1: Enable DHCP module.
+ */
+#define LWIP_DHCP                       0
+
+
+/*------------------------------------------------------------------------------
+------------------------------ AUTOIP Options ----------------------------------
+------------------------------------------------------------------------------*/
+
+/**
+ * LWIP_AUTOIP==1: Enable AUTOIP module.
+ */
+#define LWIP_AUTOIP                     0
+
+
+/*------------------------------------------------------------------------------
+------------------------------- SNMP Options -----------------------------------
+------------------------------------------------------------------------------*/
+
+/**
+ * LWIP_SNMP==1: Turn on SNMP module. UDP must be available for SNMP
+ * transport.
+ */
+#define LWIP_SNMP                       0
+
+
+/*------------------------------------------------------------------------------
+------------------------------- IGMP Options -----------------------------------
+------------------------------------------------------------------------------*/
+
+/**
+ * LWIP_IGMP==1: Turn on IGMP module.
+ */
+#define LWIP_IGMP                       0
+
+
+/*------------------------------------------------------------------------------
+-------------------------------- DNS Options -----------------------------------
+------------------------------------------------------------------------------*/
+
+/**
+ * LWIP_DNS==1: Turn on DNS module. UDP must be available for DNS
+ * transport.
+ */
+#define LWIP_DNS                        0
+
+
+/*------------------------------------------------------------------------------
+-------------------------------- UDP Options -----------------------------------
+------------------------------------------------------------------------------*/
+
+/**
+ * LWIP_UDP==1: Turn on UDP.
+ */
+#define LWIP_UDP                        1
+
+
+/*------------------------------------------------------------------------------
+-------------------------------- TCP Options -----------------------------------
+------------------------------------------------------------------------------*/
+
+/**
+ * LWIP_TCP==1: Turn on TCP.
+ */
+#define LWIP_TCP                        1
+
+#define LWIP_LISTEN_BACKLOG             0
+
+
+/*------------------------------------------------------------------------------
+--------------------------------- LOOPIF Options -------------------------------
+------------------------------------------------------------------------------*/
+
+/**
+ * LWIP_HAVE_LOOPIF==1: Support loop interface (127.0.0.1) and loopif.c
+ */
+#define LWIP_HAVE_LOOPIF                0
+
+
+/*------------------------------------------------------------------------------
+---------------------------- Sequential Layer Options --------------------------
+------------------------------------------------------------------------------*/
+
+/**
+ * LWIP_NETCONN==1: Enable Netconn API (require to use api_lib.c)
+ */
+#define LWIP_NETCONN                    0
+
+
+/*------------------------------------------------------------------------------
+--------------------------------- Socket Options -------------------------------
+------------------------------------------------------------------------------*/
+/**
+ * LWIP_SOCKET==1: Enable Socket API (require to use sockets.c)
+ */
+#define LWIP_SOCKET                     0
+
+
+/*------------------------------------------------------------------------------
+------------------------------ Statistics Options ------------------------------
+------------------------------------------------------------------------------*/
+
+/**
+ * LWIP_STATS==1: Enable statistics collection in lwip_stats.
+ */
+#define LWIP_STATS                      0
+
+/*------------------------------------------------------------------------------
+--------------------------------- PPP Options ----------------------------------
+------------------------------------------------------------------------------*/
+
+/**
+ * PPP_SUPPORT==1: Enable PPP.
+ */
+#define PPP_SUPPORT                     0
+
+#endif /* __LWIPOPTS_H__ */
diff --git a/src/stack_drivers/picotcp.hpp b/src/stack_drivers/picotcp.hpp
index b0e58c3..de754f1 100644
--- a/src/stack_drivers/picotcp.hpp
+++ b/src/stack_drivers/picotcp.hpp
@@ -234,10 +234,10 @@ namespace ZeroTier {
         
         // SIP-
         inline void __pico_stack_init(void) throw() { DEBUG_STACK(); Mutex::Lock _l(_lock); _pico_stack_init(); }
-        inline void __pico_stack_tick(void) throw() { DEBUG_STACK(); /*Mutex::Lock _l(_lock);*/ _pico_stack_tick(); }
+        inline void __pico_stack_tick(void) throw() { /*DEBUG_STACK();*/ Mutex::Lock _l(_lock); _pico_stack_tick(); }
         inline struct pico_device * __pico_tap_create(PICO_TAP_CREATE_SIG) throw() { DEBUG_STACK(); Mutex::Lock _l(_lock); return _pico_tap_create(name); }
         inline int __pico_ipv4_to_string(PICO_IPV4_TO_STRING_SIG) throw() { DEBUG_STACK(); Mutex::Lock _l(_lock); return _pico_ipv4_to_string(ipbuf, ip); }
-        inline int __pico_ipv4_link_add(PICO_IPV4_LINK_ADD_SIG) throw() { DEBUG_STACK(); Mutex::Lock _l(_lock); return _pico_ipv4_link_add(dev, address, netmask); }
+        inline int __pico_ipv4_link_add(PICO_IPV4_LINK_ADD_SIG) throw() { DEBUG_STACK(); /*Mutex::Lock _l(_lock);*/ return _pico_ipv4_link_add(dev, address, netmask); }
         inline int __pico_device_init(PICO_DEVICE_INIT_SIG) throw() { DEBUG_STACK(); Mutex::Lock _l(_lock); return _pico_device_init(dev, name, mac); }
         inline int __pico_stack_recv(PICO_STACK_RECV_SIG) throw() { DEBUG_STACK(); /*Mutex::Lock _l(_lock);*/ return _pico_stack_recv(dev, buffer, len); }
         inline int __pico_icmp4_ping(PICO_ICMP4_PING_SIG) throw() { DEBUG_STACK(); Mutex::Lock _l(_lock); return _pico_icmp4_ping(dst, count, interval, timeout, size, cb); }
diff --git a/src/tap.cpp b/src/tap.cpp
index a940aa4..c72ec87 100644
--- a/src/tap.cpp
+++ b/src/tap.cpp
@@ -76,7 +76,6 @@
 #include "lwip/udp.h"
 #include "lwip/tcp.h"
 
-
 //#if !defined(__IOS__) && !defined(__ANDROID__) && !defined(__UNITY_3D__) && !defined(__XCODE__)
 //    const ip_addr_t ip_addr_any = { IPADDR_ANY };
 //#endif
@@ -90,6 +89,8 @@ namespace ZeroTier {
 
 #if defined(SDK_PICOTCP)
     
+    static struct pico_device picodev;
+
 	// Reference to the tap interface
 	// This is needed due to the fact that there's a lot going on in the tap interface
 	// that needs to be updated on each of the network stack's callbacks and not every
@@ -116,16 +117,17 @@ namespace ZeroTier {
 			    struct pico_ip4 ipaddr, netmask;
 			    ipaddr.addr = *((u32_t *)ip.rawIpData());
 			    netmask.addr = *((u32_t *)ip.netmask().rawIpData());
-			    stack->__pico_ipv4_link_add(&(picotap->picodev), ipaddr, netmask);
-			    picotap->picodev.send = pico_eth_send; // tx
-			    picotap->picodev.poll = pico_eth_poll; // rx
 			    uint8_t mac[PICO_SIZE_ETH];
 			    picotap->_mac.copyTo(mac, PICO_SIZE_ETH);
 			    DEBUG_ATTN("mac = %s", picotap->_mac.toString().c_str());
-			    if( 0 != stack->__pico_device_init(&(picotap->picodev), "p0", mac)) {
+			    picodev.send = pico_eth_send; // tx
+			    picodev.poll = pico_eth_poll; // rx
+			    picodev.mtu = picotap->_mtu;
+			    if( 0 != stack->__pico_device_init(&(picodev), "p0", mac)) {
 			        DEBUG_ERROR("device init failed");
 			        return;
 			    }
+			    stack->__pico_ipv4_link_add(&(picodev), ipaddr, netmask);
 			    // DEBUG_INFO("device initialized as ipv4_addr = %s", ipv4_str);
 			   	// picostack->__pico_icmp4_ping("10.8.8.1", 20, 1000, 10000, 64, cb_ping);
 			}
@@ -138,13 +140,13 @@ namespace ZeroTier {
 				inet_ntop(AF_INET6, ip.netmask().rawIpData(), nm_str, INET6_ADDRSTRLEN);
 		    	stack->__pico_string_to_ipv6(ipv6_str, ipaddr.addr);
 		    	stack->__pico_string_to_ipv6(nm_str, netmask.addr);
-			    stack->__pico_ipv6_link_add(&(picotap->picodev), ipaddr, netmask);
-			    picotap->picodev.send = pico_eth_send; // tx
-			    picotap->picodev.poll = pico_eth_poll; // rx
+			    stack->__pico_ipv6_link_add(&(picodev), ipaddr, netmask);
+			    picodev.send = pico_eth_send; // tx
+			    picodev.poll = pico_eth_poll; // rx
 			    uint8_t mac[PICO_SIZE_ETH];
 			    picotap->_mac.copyTo(mac, PICO_SIZE_ETH);
 			    DEBUG_ATTN("mac = %s", picotap->_mac.toString().c_str());
-			    if( 0 != stack->__pico_device_init(&(picotap->picodev), "p0", mac)) {
+			    if( 0 != stack->__pico_device_init(&(picodev), "p0", mac)) {
 			        DEBUG_ERROR("device init failed");
 			        return;
 			    }
@@ -775,18 +777,17 @@ void NetconEthernetTap::lwIP_init_interface(const InetAddress &ip)
 			interface.flags = NETIF_FLAG_BROADCAST | NETIF_FLAG_ETHARP | NETIF_FLAG_IGMP | NETIF_FLAG_LINK_UP | NETIF_FLAG_UP;
 			lwipstack->__netif_set_default(&interface);
 			lwipstack->__netif_set_up(&interface);
+			DEBUG_INFO("addr=%s, netmask=%s", ip.toString().c_str(), ip.netmask().toString().c_str());
 		}
 	#endif
 
 	#if defined(SDK_IPV6)
 		if(ip.isV6()) {
 			DEBUG_INFO("local_addr=%s", ip.toString().c_str());
-			// convert address
 			static ip6_addr_t addr6;
 		    struct sockaddr_in6 in6;
 		    memcpy(in6.sin6_addr.s6_addr,ip.rawIpData(),16);
 		    in6_to_ip6((ip6_addr *)&addr6, &in6);
-		    // initialize netif
 			interface6.mtu = _mtu;
 			interface6.name[0] = 'l';
 			interface6.name[1] = '6';
@@ -803,6 +804,7 @@ void NetconEthernetTap::lwIP_init_interface(const InetAddress &ip)
 			interface6.output_ip6 = lwipstack->_ethip6_output;
 			interface6.state = this;
 			interface6.flags = NETIF_FLAG_LINK_UP | NETIF_FLAG_UP;
+			DEBUG_INFO("addr=%s, netmask=%s", ip.toString().c_str(), ip.netmask().toString().c_str());
 		}	
 	#endif	
 	}
@@ -1102,7 +1104,7 @@ void NetconEthernetTap::closeConnection(PhySocket *sock)
 				DEBUG_EXTRA("ignoring close request. invalid PCB state for this operation. sock=%p", (void*)&sock);
 				return;
 			}	
-			DEBUG_BLANK("__tcp_close(...)");
+			// DEBUG_BLANK("__tcp_close(...)");
 			if(lwipstack->__tcp_close(conn->TCP_pcb) == ERR_OK) {
 				// Unregister callbacks for this PCB
 				lwipstack->__tcp_arg(conn->TCP_pcb, NULL);
@@ -1237,7 +1239,7 @@ void NetconEthernetTap::phyOnUnixData(PhySocket *sock, void **uptr, void *data,
 		// DEBUG_EXTRA(" RPC: sock=%p, (pid=%d, tid=%d, timestamp=%s, cmd=%d)", (void*)&sock, pid, tid, timestamp, cmd);
 
 		if(cmd == RPC_SOCKET) {				
-			DEBUG_INFO("  RPC_SOCKET, sock=%p", (void*)&sock);
+			DEBUG_INFO("RPC_SOCKET, sock=%p", (void*)&sock);
 			// Create new lwip socket and associate it with this sock
 			struct socket_st socket_rpc;
 			memcpy(&socket_rpc, &buf[IDX_PAYLOAD+STRUCT_IDX], sizeof(struct socket_st));
@@ -1265,7 +1267,7 @@ void NetconEthernetTap::phyOnUnixData(PhySocket *sock, void **uptr, void *data,
 				// Find job
 				sockdata = jobmap[CANARY_num];
 				if(!sockdata.first) {
-					DEBUG_ERROR(" unable to locate job entry for %lu, sock=%p", CANARY_num, (void*)&sock);
+					DEBUG_ERROR("unable to locate job entry for %lu, sock=%p", CANARY_num, (void*)&sock);
 					return;
 				}  else
 					foundJob = true;
@@ -1331,31 +1333,31 @@ void NetconEthernetTap::phyOnUnixData(PhySocket *sock, void **uptr, void *data,
 
 		switch(cmd) {
 			case RPC_BIND:
-				DEBUG_INFO("  RPC_BIND, sock=%p", (void*)&sock);
+				DEBUG_INFO("RPC_BIND, sock=%p", (void*)&sock);
 			    struct bind_st bind_rpc;
 			    memcpy(&bind_rpc,  &buf[IDX_PAYLOAD+STRUCT_IDX], sizeof(struct bind_st));
 			    handleBind(sock, rpcSock, uptr, &bind_rpc);
 				break;
 		  	case RPC_LISTEN:
-		  		DEBUG_INFO("  RPC_LISTEN, sock=%p", (void*)&sock);
+		  		DEBUG_INFO("RPC_LISTEN, sock=%p", (void*)&sock);
 			    struct listen_st listen_rpc;
 			    memcpy(&listen_rpc,  &buf[IDX_PAYLOAD+STRUCT_IDX], sizeof(struct listen_st));
 			    handleListen(sock, rpcSock, uptr, &listen_rpc);
 				break;
 		  	case RPC_GETSOCKNAME:
-		  		DEBUG_INFO("  RPC_GETSOCKNAME, sock=%p", (void*)&sock);
+		  		DEBUG_INFO("RPC_GETSOCKNAME, sock=%p", (void*)&sock);
 		  		struct getsockname_st getsockname_rpc;
 		    	memcpy(&getsockname_rpc,  &buf[IDX_PAYLOAD+STRUCT_IDX], sizeof(struct getsockname_st));
 		  		handleGetsockname(sock, rpcSock, uptr, &getsockname_rpc);
 		  		break;
 			case RPC_GETPEERNAME:
-		  		DEBUG_INFO("  RPC_GETPEERNAME, sock=%p", (void*)&sock);
+		  		DEBUG_INFO("RPC_GETPEERNAME, sock=%p", (void*)&sock);
 		  		struct getsockname_st getpeername_rpc;
 		    	memcpy(&getpeername_rpc,  &buf[IDX_PAYLOAD+STRUCT_IDX], sizeof(struct getsockname_st));
 		  		handleGetpeername(sock, rpcSock, uptr, &getpeername_rpc);
 		  		break;
 			case RPC_CONNECT:
-				DEBUG_INFO("  RPC_CONNECT, sock=%p", (void*)&sock);
+				DEBUG_INFO("RPC_CONNECT, sock=%p", (void*)&sock);
 			    struct connect_st connect_rpc;
 			    memcpy(&connect_rpc,  &buf[IDX_PAYLOAD+STRUCT_IDX], sizeof(struct connect_st));
 			    handleConnect(sock, rpcSock, conn, &connect_rpc);
@@ -1718,6 +1720,12 @@ void NetconEthernetTap::handleGetpeername(PhySocket *sock, PhySocket *rpcSock, v
 void NetconEthernetTap::handleBind(PhySocket *sock, PhySocket *rpcSock, void **uptr, struct bind_st *bind_rpc)
 {
 	Mutex::Lock _l(_tcpconns_m);
+	if(!_ips.size()) {
+		// We haven't been given an address yet. Binding at this stage is premature
+		DEBUG_ERROR("cannot bind yet. ZT address hasn't been provided");
+		sendReturnValue(rpcSock, -1, ENOMEM);
+		return;
+	}
 
 	// picoTCP
 	#if defined(SDK_PICOTCP)
@@ -1726,13 +1734,6 @@ void NetconEthernetTap::handleBind(PhySocket *sock, PhySocket *rpcSock, void **u
 
 	// lwIP
 	#if defined(SDK_LWIP)
-		if(!_ips.size()) {
-			// We haven't been given an address yet. Binding at this stage is premature
-			DEBUG_ERROR("cannot bind yet. ZT address hasn't been provided");
-			sendReturnValue(rpcSock, -1, ENOMEM);
-			return;
-		}
-
 		ip_addr_t ba;
 	    char addrstr[INET6_ADDRSTRLEN];
 	    struct sockaddr_in6 *rawAddr = (struct sockaddr_in6 *) &bind_rpc->addr;
@@ -1746,11 +1747,9 @@ void NetconEthernetTap::handleBind(PhySocket *sock, PhySocket *rpcSock, void **u
 		        inet_ntop(AF_INET, &(connaddr->sin_addr), addrstr, INET_ADDRSTRLEN);    
 		        sprintf(addrstr, "%s:%d", addrstr, lwipstack->__lwip_ntohs(connaddr->sin_port));
 		    }
-		    
 		    struct sockaddr_in *rawAddr4 = (struct sockaddr_in *) &bind_rpc->addr;
 		    ba = convert_ip(rawAddr4); 
 		    port = lwipstack->__lwip_ntohs(rawAddr4->sin_port);
-
 		#endif
 
 		// ipv6
@@ -1765,7 +1764,7 @@ void NetconEthernetTap::handleBind(PhySocket *sock, PhySocket *rpcSock, void **u
 		#endif
 		
 		Connection *conn = getConnection(sock);
-	    DEBUG_ATTN(" sock=%p, fd=%d, port=%d", (void*)&sock, bind_rpc->fd, port);
+	    DEBUG_ATTN(" addr=%s, sock=%p, fd=%d", addrstr, (void*)&sock, bind_rpc->fd);
 	    if(conn) {
 	        if(conn->type == SOCK_DGRAM) {
 	       		#if defined(__ANDROID__)
diff --git a/src/tap.hpp b/src/tap.hpp
index 02d86b0..9f9aa8f 100644
--- a/src/tap.hpp
+++ b/src/tap.hpp
@@ -181,7 +181,6 @@ namespace ZeroTier {
 
 		// picoTCP
         #if defined(SDK_PICOTCP)
-            struct pico_device picodev;
             unsigned char pico_frame_rxbuf[MAX_PICO_FRAME_RX_BUF_SZ];
             int pico_frame_rxbuf_tot = 0;
             Mutex _pico_frame_rxbuf_m;
@@ -497,9 +496,6 @@ namespace ZeroTier {
 	 	 */
 		void closeConnection(PhySocket *sock);
 
-    void pico_init_interface(const InetAddress &ip);
-
-
 
 	#if defined(SDK_IPV4)
 		ip_addr_t convert_ip(struct sockaddr_in * addr)
diff --git a/tests/api_test/tcp_client.c b/tests/api_test/tcpclient4.c
index c8ec00c..c8ec00c 100644
--- a/tests/api_test/tcp_client.c
+++ b/tests/api_test/tcpclient4.c
diff --git a/tests/api_test/client6.c b/tests/api_test/tcpclient6.c
index a4aadd4..a4aadd4 100644
--- a/tests/api_test/client6.c
+++ b/tests/api_test/tcpclient6.c
diff --git a/tests/api_test/tcp_server.c b/tests/api_test/tcpserver4.c
index a501964..295a9ea 100644
--- a/tests/api_test/tcp_server.c
+++ b/tests/api_test/tcpserver4.c
@@ -11,13 +11,11 @@ int atoi(const char *str);
 int main(int argc , char *argv[])
 {
     if(argc < 2) {
-       printf("usage: tcp_server <4/6> <port>\n");
-       printf("\t - where 4/6 represent IP version\n");
+       printf("usage: tcp_server <port>\n");
        return 0;
     }
-   
 
-    int sock, client_sock, c, read_size, ipv = atoi(argv[1]), port = atoi(argv[2]);
+    int sock, client_sock, c, read_size, port = atoi(argv[1]);
     char client_message[2000];
      
     char str[100];
diff --git a/tests/api_test/server6.c b/tests/api_test/tcpserver6.c
index 740b04c..740b04c 100644
--- a/tests/api_test/server6.c
+++ b/tests/api_test/tcpserver6.c
diff --git a/tests/api_test/udp_server.c b/tests/api_test/udp_server6.c
index c6bd4b3..c6bd4b3 100755
--- a/tests/api_test/udp_server.c
+++ b/tests/api_test/udp_server6.c
diff --git a/tests/api_test/udp_client.c b/tests/api_test/udpclient.c
index c8cc4c1..c8cc4c1 100755
--- a/tests/api_test/udp_client.c
+++ b/tests/api_test/udpclient.c
diff --git a/tests/api_test/udpclient4.c b/tests/api_test/udpclient4.c
new file mode 100755
index 0000000..c8cc4c1
--- /dev/null
+++ b/tests/api_test/udpclient4.c
@@ -0,0 +1,92 @@
+/* 
+ * udpclient.c - A simple UDP client
+ * usage: udpclient <host> <port>
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <netdb.h> 
+#include <fcntl.h>
+
+#define BUFSIZE 1024
+
+/* 
+ * error - wrapper for perror
+ */
+void error(char *msg) {
+    perror(msg);
+    exit(0);
+}
+
+int main(int argc, char **argv) {
+    int sockfd, portno, n;
+    int serverlen;
+    struct sockaddr_in serveraddr;
+    struct hostent *server;
+    char *hostname;
+    char buf[BUFSIZE];
+
+    /* check command line arguments */
+    if (argc != 3) {
+       fprintf(stderr,"usage: %s <hostname> <port>\n", argv[0]);
+       exit(0);
+    }
+    hostname = argv[1];
+    portno = atoi(argv[2]);
+
+    /* socket: create the socket */
+    sockfd = socket(AF_INET, SOCK_DGRAM, 0);
+    if (sockfd < 0) 
+        error("ERROR opening socket");
+
+    /* gethostbyname: get the server's DNS entry */
+    server = gethostbyname(hostname);
+    if (server == NULL) {
+        fprintf(stderr,"ERROR, no such host as %s\n", hostname);
+        exit(0);
+    }
+
+    /* build the server's Internet address */
+    bzero((char *) &serveraddr, sizeof(serveraddr));
+    serveraddr.sin_family = AF_INET;
+    bcopy((char *)server->h_addr, 
+      (char *)&serveraddr.sin_addr.s_addr, server->h_length);
+    serveraddr.sin_port = htons(portno);
+
+    /* get a message from the user */
+    char *msg = "A message to the server!\0";
+    fcntl(sockfd, F_SETFL, O_NONBLOCK); 
+    long count = 0;
+    while(1)
+    {
+        count++;
+        printf("\nTX(%lu)...\n", count);
+        usleep(10000);
+        //bzero(buf, BUFSIZE);
+        //printf("\nPlease enter msg: ");
+        //fgets(buf, BUFSIZE, stdin);
+
+        /* send the message to the server */
+        serverlen = sizeof(serveraddr);
+        printf("A\n");
+        n = sendto(sockfd, msg, strlen(msg), 0, (struct sockaddr *)&serveraddr, serverlen);
+        printf("B\n");
+        //if (n < 0) 
+        //    error("ERROR in sendto");
+        
+        /* print the server's reply */
+        printf("C\n");
+        memset(buf, 0, sizeof(buf));
+        printf("D\n");
+        n = recvfrom(sockfd, buf, BUFSIZE, 0, (struct sockaddr *)&serveraddr, (socklen_t *)&serverlen);
+        printf("E\n");
+        //if (n < 0) 
+        //    printf("ERROR in recvfrom: %d", n);
+        printf("Echo from server: %s", buf);
+    }
+    return 0;
+}
diff --git a/tests/api_test/udpserver.c b/tests/api_test/udpserver.c
new file mode 100755
index 0000000..c6bd4b3
--- /dev/null
+++ b/tests/api_test/udpserver.c
@@ -0,0 +1,83 @@
+// UDP Server test program
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <netinet/in.h> 
+#include <arpa/inet.h>
+#include <netdb.h>
+
+#define MAXBUF 1024*1024
+
+void echo( int sd ) {
+  char bufin[MAXBUF];
+  struct sockaddr_in remote;
+  int n;
+  socklen_t len = sizeof(remote);
+  long count = 0;
+
+  while (1) {
+    usleep(50);
+    count++;
+    // read a datagram from the socket (put result in bufin)
+    n=recvfrom(sd,bufin,MAXBUF,0,(struct sockaddr *)&remote,&len);
+    // print out the address of the sender
+    printf("DGRAM from %s:%d\n", inet_ntoa(remote.sin_addr), ntohs(remote.sin_port));
+
+    if (n<0) {
+      perror("Error receiving data");
+    } else {
+      printf("GOT %d BYTES (count = %ld)\n", n, count);
+      // Got something, just send it back
+      // sendto(sd,bufin,n,0,(struct sockaddr *)&remote,len);
+    }
+  }
+}
+
+int main(int argc, char *argv[]) {
+
+  if(argc < 2) {
+    printf("usage: udp_server <port>\n");
+    return 0;
+  }
+  int ld, port = atoi(argv[1]);
+  socklen_t len;
+  struct sockaddr_in skaddr;
+  struct sockaddr_in skaddr2;
+
+  // Create socket
+  if ((ld = socket( PF_INET, SOCK_DGRAM, 0)) < 0) {
+    printf("error creating socket\n");
+    return 0;
+  }
+  // Create address
+  skaddr.sin_family = AF_INET;
+  skaddr.sin_addr.s_addr = htonl(INADDR_ANY);
+  skaddr.sin_port = htons(port);
+  // Bind to address
+  if (bind(ld, (struct sockaddr *) &skaddr, sizeof(skaddr))<0) {
+    printf("error binding\n");
+    return 0;
+  }
+  // find out what port we were assigned
+  len = sizeof( skaddr2 );
+  if (getsockname(ld, (struct sockaddr *) &skaddr2, &len)<0) {
+    printf("error getsockname\n");
+    return 0;
+  }
+  // Display address:port to verify it was sent over RPC correctly
+  port = ntohs(skaddr2.sin_port);
+  int ip = skaddr2.sin_addr.s_addr;
+  unsigned char d[4];
+  d[0] = ip & 0xFF;
+  d[1] = (ip >>  8) & 0xFF;
+  d[2] = (ip >> 16) & 0xFF;
+  d[3] = (ip >> 24) & 0xFF;
+  printf("bound to address: %d.%d.%d.%d : %d\n", d[0],d[1],d[2],d[3], port);
+          
+  // RX
+  echo(ld);
+  return(0);
+}