added lwip unix port lib files

13 files changed, 774 insertions, 91 deletions

diff --git a/ext/contrib/README.md b/ext/contrib/README.md
new file mode 100644
index 00000000..feb9ae64
--- /dev/null
+++ b/ext/contrib/README.md
@@ -0,0 +1,15 @@
+You are reading this file because you want to build a new copy of the LwIP library for
+use in ZeroTier.
+
+Subdirectories:
+
+ ports/ -- contains ports for various architectures (for our purposes, unix)
+
+In order for the Network Containers feature to work in ZeroTier, a copy of the LwIP libary
+is needed since we dynamically load it into memory. You can build a new copy of the libary 
+by going to /contrib/ports/unix/proj/lib and running make.
+
+This will generate: liblwip.so
+
+You can enable LwIP debug traces by adding the flag -DLWIP_DEBUG
+See additional debug info here: http://lwip.wikia.com/wiki/Debugging_lwIP 
diff --git a/ext/contrib/ports/unix/proj/lib/Makefile b/ext/contrib/ports/unix/proj/lib/Makefile
new file mode 100644
index 00000000..5bb6a1f3
--- /dev/null
+++ b/ext/contrib/ports/unix/proj/lib/Makefile
@@ -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 <adam@sics.se>
+#
+
+CONTRIBDIR=../../../..
+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=$(CONTRIBDIR)/../lwip/src
+
+
+CCDEP=gcc
+CC=gcc
+CFLAGS=-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) unixlib.o
+	$(CC) -g -nostartfiles -shared -o $@ $^
+
+.depend: unixlib.c $(LWIPFILES)
+	$(CCDEP) $(CFLAGS) -MM $^ > .depend || rm -f .depend
diff --git a/ext/contrib/ports/unix/proj/lib/README b/ext/contrib/ports/unix/proj/lib/README
new file mode 100644
index 00000000..cd6cc7b7
--- /dev/null
+++ b/ext/contrib/ports/unix/proj/lib/README
@@ -0,0 +1,31 @@
+This directory contains an example of how to compile lwIP as a self
+initialising shared library on Linux.
+
+Some brief instructions:
+ 
+* Compile the code:
+
+ > make clean all
+
+ This should produce liblwip4unixlib.so.  This is the shared library.
+
+* Link an application against the shared library
+
+ If you're using gcc you can do this by including -llwip4unixlib in
+your link command. 
+
+* Run your application
+ 
+ Ensure that LD_LIBRARY_PATH includes the directory that contains
+liblwip4unixlib.so (ie. this directory)
+
+
+
+If you are unsure about shared libraries and libraries on linux in
+general, you might find this HOWTO useful:
+
+<http://www.tldp.org/HOWTO/Program-Library-HOWTO/>
+
+
+
+Kieran Mansley, October 2002.
\ No newline at end of file
diff --git a/ext/contrib/ports/unix/proj/lib/lwipopts.h b/ext/contrib/ports/unix/proj/lib/lwipopts.h
new file mode 100644
index 00000000..48d35f3d
--- /dev/null
+++ b/ext/contrib/ports/unix/proj/lib/lwipopts.h
@@ -0,0 +1,468 @@
+/**
+ * @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 <adam@sics.se>
+ *
+ */
+#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 "lwipopts.h"
+#include "lwip/debug.h"
+
+
+//#define LWIP_DEBUG 0
+//#define TCP_DEBUG LWIP_DBG_OFF
+
+/*
+
+#define LWIP_MALLOC_MEMPOOL 1
+*/
+
+/*
+#define LWIP_CHECKSUM_ON_COPY 1
+
+#define TCP_OVERSIZE TCP_MSS
+*/
+
+#ifndef TCP_SND_QUEUELEN
+#define TCP_SND_QUEUELEN                ((4 * (TCP_SND_BUF) + (TCP_MSS - 1))/(TCP_MSS))
+#endif
+
+//#define TCP_WND
+
+
+//#define PBUF_POOL_BUFSIZE 2048
+
+/*------------------------------------------------------------------------------
+---------------------------------- Timers --------------------------------------
+------------------------------------------------------------------------------*/
+
+/* these are originally defined in tcp_impl.h */
+#ifndef TCP_TMR_INTERVAL
+/* The TCP timer interval in milliseconds. */
+#define TCP_TMR_INTERVAL       25
+#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 --------------------------------
+------------------------------------------------------------------------------*/
+
+
+#define LWIP_CHKSUM_ALGORITHM 2
+
+
+/**
+ * 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
+
+
+/*------------------------------------------------------------------------------
+-------------------------- 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                32
+
+/**
+ * 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                TCP_SND_QUEUELEN
+
+/**
+ * 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                  128 /* 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
+
+
+/*------------------------------------------------------------------------------
+-------------------------------- 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)
+
+
+/*------------------------------------------------------------------------------
+--------------------------------- 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                      1
+
+/*------------------------------------------------------------------------------
+--------------------------------- PPP Options ----------------------------------
+------------------------------------------------------------------------------*/
+
+/**
+ * PPP_SUPPORT==1: Enable PPP.
+ */
+#define PPP_SUPPORT                     0
+
+
+/* Misc */
+
+#endif /* __LWIPOPTS_H__ */
diff --git a/ext/contrib/ports/unix/proj/lib/unixlib.c b/ext/contrib/ports/unix/proj/lib/unixlib.c
new file mode 100644
index 00000000..950ae1ca
--- /dev/null
+++ b/ext/contrib/ports/unix/proj/lib/unixlib.c
@@ -0,0 +1,73 @@
+/*
+ * 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.
+ *
+ * Author: Kieran Mansley <kjm25@cam.ac.uk>
+ *
+ * $Id: unixlib.c,v 1.10 2010/02/17 16:52:30 goldsimon Exp $
+ */
+
+/*-----------------------------------------------------------------------------------*/
+/* unixlib.c
+ *
+ * The initialisation functions for a shared library
+ *
+ * You may need to configure this file to your own needs - it is only an example
+ * of how lwIP can be used as a self initialising shared library.
+ *
+ * In particular, you should change the gateway, ipaddr, and netmask to be the values
+ * you would like the stack to use.
+ */
+/*-----------------------------------------------------------------------------------*/
+
+/*
+#include "lwip/init.h"
+#include "lwip/sys.h"
+#include "lwip/mem.h"
+#include "lwip/memp.h"
+#include "lwip/pbuf.h"
+#include "lwip/tcp.h"
+#include "lwip/tcpip.h"
+#include "lwip/netif.h"
+#include "lwip/stats.h"
+#include "lwip/sockets.h"
+
+#include "netif/tapif.h"
+
+struct netif netif;
+*/
+
+static void
+tcpip_init_done(void *arg)
+{
+
+}
+
+void _init(void){
+
+}
+
+void _fini(void){
+}
diff --git a/ext/lwip/src/api/tcpip.c b/ext/lwip/src/api/tcpip.c
index 2bb28149..18d5f679 100644
--- a/ext/lwip/src/api/tcpip.c
+++ b/ext/lwip/src/api/tcpip.c
@@ -160,7 +160,6 @@ tcpip_thread(void *arg)
 err_t
 tcpip_input(struct pbuf *p, struct netif *inp)
 {
-  printf("------TCPIP_INPUT()\n");
 #if LWIP_TCPIP_CORE_LOCKING_INPUT
   err_t ret;
   LWIP_DEBUGF(TCPIP_DEBUG, ("tcpip_input: PACKET %p/%p\n", (void *)p, (void *)inp));
@@ -311,7 +310,7 @@ tcpip_apimsg(struct api_msg *apimsg)
   /* catch functions that don't set err */
   apimsg->msg.err = ERR_VAL;
 #endif
-
+  
   if (sys_mbox_valid(&mbox)) {
     msg.type = TCPIP_MSG_API;
     msg.msg.apimsg = apimsg;
@@ -361,14 +360,14 @@ err_t
 tcpip_netifapi(struct netifapi_msg* netifapimsg)
 {
   struct tcpip_msg msg;
-
+  
   if (sys_mbox_valid(&mbox)) {
     err_t err = sys_sem_new(&netifapimsg->msg.sem, 0);
     if (err != ERR_OK) {
       netifapimsg->msg.err = err;
       return err;
     }
-
+    
     msg.type = TCPIP_MSG_NETIFAPI;
     msg.msg.netifapimsg = netifapimsg;
     sys_mbox_post(&mbox, &msg);
@@ -390,7 +389,7 @@ tcpip_netifapi(struct netifapi_msg* netifapimsg)
 err_t
 tcpip_netifapi_lock(struct netifapi_msg* netifapimsg)
 {
-  LOCK_TCPIP_CORE();
+  LOCK_TCPIP_CORE();  
   netifapimsg->function(&(netifapimsg->msg));
   UNLOCK_TCPIP_CORE();
   return netifapimsg->msg.err;
diff --git a/ext/lwip/src/core/ipv4/ip.c b/ext/lwip/src/core/ipv4/ip.c
index baf19505..0e09b3c0 100644
--- a/ext/lwip/src/core/ipv4/ip.c
+++ b/ext/lwip/src/core/ipv4/ip.c
@@ -304,7 +304,6 @@ return_noroute:
 err_t
 ip_input(struct pbuf *p, struct netif *inp)
 {
-  printf("--------IP INPUT()\n");
   struct ip_hdr *iphdr;
   struct netif *netif;
   u16_t iphdr_hlen;
diff --git a/ext/lwip/src/core/tcp_in.c b/ext/lwip/src/core/tcp_in.c
index ce6c5eab..4ec971ac 100644
--- a/ext/lwip/src/core/tcp_in.c
+++ b/ext/lwip/src/core/tcp_in.c
@@ -6,7 +6,7 @@
  *
  * These functions are generally called in the order (ip_input() ->)
  * tcp_input() -> * tcp_process() -> tcp_receive() (-> application).
- *
+ * 
  */
 
 /*
@@ -91,7 +91,6 @@ static err_t tcp_timewait_input(struct tcp_pcb *pcb);
 void
 tcp_input(struct pbuf *p, struct netif *inp)
 {
-  printf("----TCP_INPUT()\n");
   struct tcp_pcb *pcb, *prev;
   struct tcp_pcb_listen *lpcb;
 #if SO_REUSE
@@ -167,7 +166,7 @@ tcp_input(struct pbuf *p, struct netif *inp)
      for an active connection. */
   prev = NULL;
 
-
+  
   for(pcb = tcp_active_pcbs; pcb != NULL; pcb = pcb->next) {
     LWIP_ASSERT("tcp_input: active pcb->state != CLOSED", pcb->state != CLOSED);
     LWIP_ASSERT("tcp_input: active pcb->state != TIME-WAIT", pcb->state != TIME_WAIT);
@@ -254,7 +253,7 @@ tcp_input(struct pbuf *p, struct netif *inp)
               /* put this listening pcb at the head of the listening list */
         tcp_listen_pcbs.listen_pcbs = lpcb;
       }
-
+    
       LWIP_DEBUGF(TCP_INPUT_DEBUG, ("tcp_input: packed for LISTENing connection.\n"));
       tcp_listen_input(lpcb);
       pbuf_free(p);
@@ -268,10 +267,7 @@ tcp_input(struct pbuf *p, struct netif *inp)
   LWIP_DEBUGF(TCP_INPUT_DEBUG, ("-+-+-+-+-+-+-+-+-+-+-+-+-+-+\n"));
 #endif /* TCP_INPUT_DEBUG */
 
-  if(pcb == NULL)
-  {
-    printf ("--------------PCB == NULL!\n");
-  }
+
   if (pcb != NULL) {
     /* The incoming segment belongs to a connection. */
 #if TCP_INPUT_DEBUG
@@ -305,7 +301,6 @@ tcp_input(struct pbuf *p, struct netif *inp)
       }
     }
     tcp_input_pcb = pcb;
-    printf("    > TCP_PROCESS()\n");
     err = tcp_process(pcb);
     /* A return value of ERR_ABRT means that tcp_abort() was called
        and that the pcb has been freed. If so, we don't do anything. */
@@ -579,7 +574,6 @@ tcp_timewait_input(struct tcp_pcb *pcb)
 static err_t
 tcp_process(struct tcp_pcb *pcb)
 {
-  printf("------TCP_PROCESS()\n");
   struct tcp_seg *rseg;
   u8_t acceptable = 0;
   err_t err;
@@ -594,7 +588,7 @@ tcp_process(struct tcp_pcb *pcb)
         acceptable = 1;
       }
     } else {
-      if (TCP_SEQ_BETWEEN(seqno, pcb->rcv_nxt,
+      if (TCP_SEQ_BETWEEN(seqno, pcb->rcv_nxt, 
                           pcb->rcv_nxt+pcb->rcv_wnd)) {
         acceptable = 1;
       }
@@ -615,12 +609,12 @@ tcp_process(struct tcp_pcb *pcb)
     }
   }
 
-  if ((flags & TCP_SYN) && (pcb->state != SYN_SENT && pcb->state != SYN_RCVD)) {
+  if ((flags & TCP_SYN) && (pcb->state != SYN_SENT && pcb->state != SYN_RCVD)) { 
     /* Cope with new connection attempt after remote end crashed */
     tcp_ack_now(pcb);
     return ERR_OK;
   }
-
+  
   if ((pcb->flags & TF_RXCLOSED) == 0) {
     /* Update the PCB (in)activity timer unless rx is closed (see tcp_shutdown) */
     pcb->tmr = tcp_ticks;
@@ -629,8 +623,6 @@ tcp_process(struct tcp_pcb *pcb)
 
   tcp_parseopt(pcb);
 
-printf("------TCP_PROCESS(): pcb->state = %d\n", pcb->state);
-
   /* Do different things depending on the TCP state. */
   switch (pcb->state) {
   case SYN_SENT:
@@ -900,7 +892,7 @@ tcp_receive(struct tcp_pcb *pcb)
 #if TCP_WND_DEBUG
     } else {
       if (pcb->snd_wnd != tcphdr->wnd) {
-        LWIP_DEBUGF(TCP_WND_DEBUG,
+        LWIP_DEBUGF(TCP_WND_DEBUG, 
                     ("tcp_receive: no window update lastack %"U32_F" ackno %"
                      U32_F" wl1 %"U32_F" seqno %"U32_F" wl2 %"U32_F"\n",
                      pcb->lastack, ackno, pcb->snd_wl1, seqno, pcb->snd_wl2));
@@ -910,17 +902,17 @@ tcp_receive(struct tcp_pcb *pcb)
 
     /* (From Stevens TCP/IP Illustrated Vol II, p970.) Its only a
      * duplicate ack if:
-     * 1) It doesn't ACK new data
-     * 2) length of received packet is zero (i.e. no payload)
-     * 3) the advertised window hasn't changed
+     * 1) It doesn't ACK new data 
+     * 2) length of received packet is zero (i.e. no payload) 
+     * 3) the advertised window hasn't changed 
      * 4) There is outstanding unacknowledged data (retransmission timer running)
      * 5) The ACK is == biggest ACK sequence number so far seen (snd_una)
-     *
-     * If it passes all five, should process as a dupack:
-     * a) dupacks < 3: do nothing
-     * b) dupacks == 3: fast retransmit
-     * c) dupacks > 3: increase cwnd
-     *
+     * 
+     * If it passes all five, should process as a dupack: 
+     * a) dupacks < 3: do nothing 
+     * b) dupacks == 3: fast retransmit 
+     * c) dupacks > 3: increase cwnd 
+     * 
      * If it only passes 1-3, should reset dupack counter (and add to
      * stats, which we don't do in lwIP)
      *
@@ -1036,8 +1028,8 @@ tcp_receive(struct tcp_pcb *pcb)
 
         LWIP_DEBUGF(TCP_QLEN_DEBUG, ("%"U16_F" (after freeing unacked)\n", (u16_t)pcb->snd_queuelen));
         if (pcb->snd_queuelen != 0) {
-          //LWIP_ASSERT("tcp_receive: valid queue length", pcb->unacked != NULL ||
-          //            pcb->unsent != NULL);
+          LWIP_ASSERT("tcp_receive: valid queue length", pcb->unacked != NULL ||
+                      pcb->unsent != NULL);
         }
       }
 
@@ -1061,7 +1053,7 @@ tcp_receive(struct tcp_pcb *pcb)
        ->unsent list after a retransmission, so these segments may
        in fact have been sent once. */
     while (pcb->unsent != NULL &&
-           TCP_SEQ_BETWEEN(ackno, ntohl(pcb->unsent->tcphdr->seqno) +
+           TCP_SEQ_BETWEEN(ackno, ntohl(pcb->unsent->tcphdr->seqno) + 
                            TCP_TCPLEN(pcb->unsent), pcb->snd_nxt)) {
       LWIP_DEBUGF(TCP_INPUT_DEBUG, ("tcp_receive: removing %"U32_F":%"U32_F" from pcb->unsent\n",
                                     ntohl(pcb->unsent->tcphdr->seqno), ntohl(pcb->unsent->tcphdr->seqno) +
@@ -1073,7 +1065,7 @@ tcp_receive(struct tcp_pcb *pcb)
       if (pcb->unsent == NULL) {
         pcb->unsent_oversize = 0;
       }
-#endif /* TCP_OVERSIZE */
+#endif /* TCP_OVERSIZE */ 
       LWIP_DEBUGF(TCP_QLEN_DEBUG, ("tcp_receive: queuelen %"U16_F" ... ", (u16_t)pcb->snd_queuelen));
       LWIP_ASSERT("pcb->snd_queuelen >= pbuf_clen(next->p)", (pcb->snd_queuelen >= pbuf_clen(next->p)));
       /* Prevent ACK for FIN to generate a sent event */
@@ -1219,7 +1211,7 @@ tcp_receive(struct tcp_pcb *pcb)
     /* The sequence number must be within the window (above rcv_nxt
        and below rcv_nxt + rcv_wnd) in order to be further
        processed. */
-    if (TCP_SEQ_BETWEEN(seqno, pcb->rcv_nxt,
+    if (TCP_SEQ_BETWEEN(seqno, pcb->rcv_nxt, 
                         pcb->rcv_nxt + pcb->rcv_wnd - 1)){
       if (pcb->rcv_nxt == seqno) {
         /* The incoming segment is the next in sequence. We check if
@@ -1228,12 +1220,12 @@ tcp_receive(struct tcp_pcb *pcb)
         tcplen = TCP_TCPLEN(&inseg);
 
         if (tcplen > pcb->rcv_wnd) {
-          LWIP_DEBUGF(TCP_INPUT_DEBUG,
+          LWIP_DEBUGF(TCP_INPUT_DEBUG, 
                       ("tcp_receive: other end overran receive window"
                        "seqno %"U32_F" len %"U16_F" right edge %"U32_F"\n",
                        seqno, tcplen, pcb->rcv_nxt + pcb->rcv_wnd));
           if (TCPH_FLAGS(inseg.tcphdr) & TCP_FIN) {
-            /* Must remove the FIN from the header as we're trimming
+            /* Must remove the FIN from the header as we're trimming 
              * that byte of sequence-space from the packet */
             TCPH_FLAGS_SET(inseg.tcphdr, TCPH_FLAGS(inseg.tcphdr) &~ TCP_FIN);
           }
@@ -1253,7 +1245,7 @@ tcp_receive(struct tcp_pcb *pcb)
            - inseq overlaps with ooseq */
         if (pcb->ooseq != NULL) {
           if (TCPH_FLAGS(inseg.tcphdr) & TCP_FIN) {
-            LWIP_DEBUGF(TCP_INPUT_DEBUG,
+            LWIP_DEBUGF(TCP_INPUT_DEBUG, 
                         ("tcp_receive: received in-order FIN, binning ooseq queue\n"));
             /* Received in-order FIN means anything that was received
              * out of order must now have been received in-order, so
@@ -1360,7 +1352,7 @@ tcp_receive(struct tcp_pcb *pcb)
             recv_flags |= TF_GOT_FIN;
             if (pcb->state == ESTABLISHED) { /* force passive close or we can move to active close */
               pcb->state = CLOSE_WAIT;
-            }
+            } 
           }
 
           pcb->ooseq = cseg->next;
@@ -1473,12 +1465,12 @@ tcp_receive(struct tcp_pcb *pcb)
                   }
                   /* check if the remote side overruns our receive window */
                   if ((u32_t)tcplen + seqno > pcb->rcv_nxt + (u32_t)pcb->rcv_wnd) {
-                    LWIP_DEBUGF(TCP_INPUT_DEBUG,
+                    LWIP_DEBUGF(TCP_INPUT_DEBUG, 
                                 ("tcp_receive: other end overran receive window"
                                  "seqno %"U32_F" len %"U16_F" right edge %"U32_F"\n",
                                  seqno, tcplen, pcb->rcv_nxt + pcb->rcv_wnd));
                     if (TCPH_FLAGS(next->next->tcphdr) & TCP_FIN) {
-                      /* Must remove the FIN from the header as we're trimming
+                      /* Must remove the FIN from the header as we're trimming 
                        * that byte of sequence-space from the packet */
                       TCPH_FLAGS_SET(next->next->tcphdr, TCPH_FLAGS(next->next->tcphdr) &~ TCP_FIN);
                     }
@@ -1539,7 +1531,7 @@ tcp_receive(struct tcp_pcb *pcb)
 }
 
 /**
- * Parses the options contained in the incoming segment.
+ * Parses the options contained in the incoming segment. 
  *
  * Called from tcp_listen_input() and tcp_process().
  * Currently, only the MSS option is supported!
@@ -1596,7 +1588,7 @@ tcp_parseopt(struct tcp_pcb *pcb)
           return;
         }
         /* TCP timestamp option with valid length */
-        tsval = (opts[c+2]) | (opts[c+3] << 8) |
+        tsval = (opts[c+2]) | (opts[c+3] << 8) | 
           (opts[c+4] << 16) | (opts[c+5] << 24);
         if (flags & TCP_SYN) {
           pcb->ts_recent = ntohl(tsval);
diff --git a/ext/lwip/src/core/tcp_out.c b/ext/lwip/src/core/tcp_out.c
index d0b71d19..ee19fe06 100644
--- a/ext/lwip/src/core/tcp_out.c
+++ b/ext/lwip/src/core/tcp_out.c
@@ -197,7 +197,7 @@ tcp_create_segment(struct tcp_pcb *pcb, struct pbuf *p, u8_t flags, u32_t seqno,
   /* wnd and chksum are set in tcp_output */
   seg->tcphdr->urgp = 0;
   return seg;
-}
+} 
 
 /**
  * Allocate a PBUF_RAM pbuf, perhaps with extra space at the end.
@@ -212,7 +212,7 @@ tcp_create_segment(struct tcp_pcb *pcb, struct pbuf *p, u8_t flags, u32_t seqno,
  * @param pcb The TCP connection that willo enqueue the pbuf.
  * @param apiflags API flags given to tcp_write.
  * @param first_seg true when this pbuf will be used in the first enqueued segment.
- * @param
+ * @param 
  */
 #if TCP_OVERSIZE
 static struct pbuf *
@@ -324,7 +324,6 @@ tcp_write_checks(struct tcp_pcb *pcb, u16_t len)
     pcb->flags |= TF_NAGLEMEMERR;
     return ERR_MEM;
   }
-  /*
   if (pcb->snd_queuelen != 0) {
     LWIP_ASSERT("tcp_write: pbufs on queue => at least one queue non-empty",
       pcb->unacked != NULL || pcb->unsent != NULL);
@@ -332,7 +331,6 @@ tcp_write_checks(struct tcp_pcb *pcb, u16_t len)
     LWIP_ASSERT("tcp_write: no pbufs on queue => both queues empty",
       pcb->unacked == NULL && pcb->unsent == NULL);
   }
-  */
   return ERR_OK;
 }
 
@@ -381,7 +379,7 @@ tcp_write(struct tcp_pcb *pcb, const void *arg, u16_t len, u8_t apiflags)
 
   LWIP_DEBUGF(TCP_OUTPUT_DEBUG, ("tcp_write(pcb=%p, data=%p, len=%"U16_F", apiflags=%"U16_F")\n",
     (void *)pcb, arg, len, (u16_t)apiflags));
-  LWIP_ERROR("tcp_write: arg == NULL (programmer violates API)",
+  LWIP_ERROR("tcp_write: arg == NULL (programmer violates API)", 
              arg != NULL, return ERR_ARG;);
 
   err = tcp_write_checks(pcb, len);
@@ -859,7 +857,7 @@ tcp_send_empty_ack(struct tcp_pcb *pcb)
     return ERR_BUF;
   }
   tcphdr = (struct tcp_hdr *)p->payload;
-  LWIP_DEBUGF(TCP_OUTPUT_DEBUG,
+  LWIP_DEBUGF(TCP_OUTPUT_DEBUG, 
               ("tcp_output: sending ACK for %"U32_F"\n", pcb->rcv_nxt));
   /* remove ACK flags from the PCB, as we send an empty ACK now */
   pcb->flags &= ~(TF_ACK_DELAY | TF_ACK_NOW);
@@ -871,7 +869,7 @@ tcp_send_empty_ack(struct tcp_pcb *pcb)
   if (pcb->flags & TF_TIMESTAMP) {
     tcp_build_timestamp_option(pcb, (u32_t *)(tcphdr + 1));
   }
-#endif
+#endif 
 
 #if CHECKSUM_GEN_TCP
   tcphdr->chksum = inet_chksum_pseudo(p, &(pcb->local_ip), &(pcb->remote_ip),
@@ -952,7 +950,7 @@ tcp_output(struct tcp_pcb *pcb)
                                  ", seg == NULL, ack %"U32_F"\n",
                                  pcb->snd_wnd, pcb->cwnd, wnd, pcb->lastack));
   } else {
-    LWIP_DEBUGF(TCP_CWND_DEBUG,
+    LWIP_DEBUGF(TCP_CWND_DEBUG, 
                 ("tcp_output: snd_wnd %"U16_F", cwnd %"U16_F", wnd %"U32_F
                  ", effwnd %"U32_F", seq %"U32_F", ack %"U32_F"\n",
                  pcb->snd_wnd, pcb->cwnd, wnd,
@@ -963,7 +961,7 @@ tcp_output(struct tcp_pcb *pcb)
   /* data available and window allows it to be sent? */
   while (seg != NULL &&
          ntohl(seg->tcphdr->seqno) - pcb->lastack + seg->len <= wnd) {
-    LWIP_ASSERT("RST not expected here!",
+    LWIP_ASSERT("RST not expected here!", 
                 (TCPH_FLAGS(seg->tcphdr) & TCP_RST) == 0);
     /* Stop sending if the nagle algorithm would prevent it
      * Don't stop:
@@ -1088,7 +1086,7 @@ tcp_output_segment(struct tcp_seg *seg, struct tcp_pcb *pcb)
   }
 #endif
 
-  /* Set retransmission timer running if it is not currently enabled
+  /* Set retransmission timer running if it is not currently enabled 
      This must be set before checking the route. */
   if (pcb->rtime == -1) {
     pcb->rtime = 0;
@@ -1319,12 +1317,12 @@ tcp_rexmit(struct tcp_pcb *pcb)
  *
  * @param pcb the tcp_pcb for which to retransmit the first unacked segment
  */
-void
+void 
 tcp_rexmit_fast(struct tcp_pcb *pcb)
 {
   if (pcb->unacked != NULL && !(pcb->flags & TF_INFR)) {
     /* This is fast retransmit. Retransmit the first unacked segment. */
-    LWIP_DEBUGF(TCP_FR_DEBUG,
+    LWIP_DEBUGF(TCP_FR_DEBUG, 
                 ("tcp_receive: dupacks %"U16_F" (%"U32_F
                  "), fast retransmit %"U32_F"\n",
                  (u16_t)pcb->dupacks, pcb->lastack,
@@ -1338,19 +1336,19 @@ tcp_rexmit_fast(struct tcp_pcb *pcb)
     } else {
       pcb->ssthresh = pcb->cwnd / 2;
     }
-
+    
     /* The minimum value for ssthresh should be 2 MSS */
     if (pcb->ssthresh < 2*pcb->mss) {
-      LWIP_DEBUGF(TCP_FR_DEBUG,
+      LWIP_DEBUGF(TCP_FR_DEBUG, 
                   ("tcp_receive: The minimum value for ssthresh %"U16_F
                    " should be min 2 mss %"U16_F"...\n",
                    pcb->ssthresh, 2*pcb->mss));
       pcb->ssthresh = 2*pcb->mss;
     }
-
+    
     pcb->cwnd = pcb->ssthresh + 3 * pcb->mss;
     pcb->flags |= TF_INFR;
-  }
+  } 
 }
 
 
@@ -1372,12 +1370,12 @@ tcp_keepalive(struct tcp_pcb *pcb)
                           ip4_addr1_16(&pcb->remote_ip), ip4_addr2_16(&pcb->remote_ip),
                           ip4_addr3_16(&pcb->remote_ip), ip4_addr4_16(&pcb->remote_ip)));
 
-  LWIP_DEBUGF(TCP_DEBUG, ("tcp_keepalive: tcp_ticks %"U32_F"   pcb->tmr %"U32_F" pcb->keep_cnt_sent %"U16_F"\n",
+  LWIP_DEBUGF(TCP_DEBUG, ("tcp_keepalive: tcp_ticks %"U32_F"   pcb->tmr %"U32_F" pcb->keep_cnt_sent %"U16_F"\n", 
                           tcp_ticks, pcb->tmr, pcb->keep_cnt_sent));
-
+   
   p = tcp_output_alloc_header(pcb, 0, 0, htonl(pcb->snd_nxt - 1));
   if(p == NULL) {
-    LWIP_DEBUGF(TCP_DEBUG,
+    LWIP_DEBUGF(TCP_DEBUG, 
                 ("tcp_keepalive: could not allocate memory for pbuf\n"));
     return;
   }
@@ -1421,15 +1419,15 @@ tcp_zero_window_probe(struct tcp_pcb *pcb)
   u16_t len;
   u8_t is_fin;
 
-  LWIP_DEBUGF(TCP_DEBUG,
+  LWIP_DEBUGF(TCP_DEBUG, 
               ("tcp_zero_window_probe: sending ZERO WINDOW probe to %"
                U16_F".%"U16_F".%"U16_F".%"U16_F"\n",
                ip4_addr1_16(&pcb->remote_ip), ip4_addr2_16(&pcb->remote_ip),
                ip4_addr3_16(&pcb->remote_ip), ip4_addr4_16(&pcb->remote_ip)));
 
-  LWIP_DEBUGF(TCP_DEBUG,
+  LWIP_DEBUGF(TCP_DEBUG, 
               ("tcp_zero_window_probe: tcp_ticks %"U32_F
-               "   pcb->tmr %"U32_F" pcb->keep_cnt_sent %"U16_F"\n",
+               "   pcb->tmr %"U32_F" pcb->keep_cnt_sent %"U16_F"\n", 
                tcp_ticks, pcb->tmr, pcb->keep_cnt_sent));
 
   seg = pcb->unacked;
diff --git a/ext/lwip/src/netif/etharp.c b/ext/lwip/src/netif/etharp.c
index 561fd505..5e382d1d 100644
--- a/ext/lwip/src/netif/etharp.c
+++ b/ext/lwip/src/netif/etharp.c
@@ -42,7 +42,7 @@
  * This file is part of the lwIP TCP/IP stack.
  *
  */
-
+ 
 #include "lwip/opt.h"
 
 #if LWIP_ARP || LWIP_ETHERNET
@@ -84,7 +84,7 @@ const struct eth_addr ethzero = {{0,0,0,0,0,0}};
 /** the time an ARP entry stays pending after first request,
  *  for ARP_TMR_INTERVAL = 5000, this is
  *  (2 * 5) seconds = 10 seconds.
- *
+ * 
  *  @internal Keep this number at least 2, otherwise it might
  *  run out instantly if the timeout occurs directly after a request.
  */
@@ -243,14 +243,14 @@ etharp_tmr(void)
 
 /**
  * Search the ARP table for a matching or new entry.
- *
+ * 
  * If an IP address is given, return a pending or stable ARP entry that matches
  * the address. If no match is found, create a new entry with this address set,
  * but in state ETHARP_EMPTY. The caller must check and possibly change the
  * state of the returned entry.
- *
+ * 
  * If ipaddr is NULL, return a initialized new entry in state ETHARP_EMPTY.
- *
+ * 
  * In all cases, attempt to create new entries from an empty entry. If no
  * empty entries are available and ETHARP_FLAG_TRY_HARD flag is set, recycle
  * old entries. Heuristic choose the least important entry for recycling.
@@ -258,7 +258,7 @@ etharp_tmr(void)
  * @param ipaddr IP address to find in ARP cache, or to add if not found.
  * @param flags @see definition of ETHARP_FLAG_*
  * @param netif netif related to this address (used for NETIF_HWADDRHINT)
- *
+ *  
  * @return The ARP entry index that matched or is created, ERR_MEM if no
  * entry is found or could be recycled.
  */
@@ -337,7 +337,7 @@ etharp_find_entry(ip_addr_t *ipaddr, u8_t flags)
     }
   }
   /* { we have no match } => try to create a new entry */
-
+   
   /* don't create new entry, only search? */
   if (((flags & ETHARP_FLAG_FIND_ONLY) != 0) ||
       /* or no empty entry found and not allowed to recycle? */
@@ -345,15 +345,15 @@ etharp_find_entry(ip_addr_t *ipaddr, u8_t flags)
     LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, ("etharp_find_entry: no empty entry found and not allowed to recycle\n"));
     return (s8_t)ERR_MEM;
   }
-
+  
   /* b) choose the least destructive entry to recycle:
    * 1) empty entry
    * 2) oldest stable entry
    * 3) oldest pending entry without queued packets
    * 4) oldest pending entry with queued packets
-   *
+   * 
    * { ETHARP_FLAG_TRY_HARD is set at this point }
-   */
+   */ 
 
   /* 1) empty entry available? */
   if (empty < ARP_TABLE_SIZE) {
@@ -431,7 +431,7 @@ etharp_send_ip(struct netif *netif, struct pbuf *p, struct eth_addr *src, struct
  *
  * If a pending entry is resolved, any queued packets will be sent
  * at this point.
- *
+ * 
  * @param netif netif related to this entry (used for NETIF_ADDRHINT)
  * @param ipaddr IP address of the inserted ARP entry.
  * @param ethaddr Ethernet address of the inserted ARP entry.
@@ -670,7 +670,7 @@ etharp_ip_input(struct netif *netif, struct pbuf *p)
 #endif /* ETHARP_TRUST_IP_MAC */
 
 /**
- * Responds to ARP requests to us. Upon ARP replies to us, add entry to cache
+ * Responds to ARP requests to us. Upon ARP replies to us, add entry to cache  
  * send out queued IP packets. Updates cache with snooped address pairs.
  *
  * Should be called for incoming ARP packets. The pbuf in the argument
@@ -846,13 +846,13 @@ etharp_output_to_arp_index(struct netif *netif, struct pbuf *q, u8_t arp_idx)
   /* if arp table entry is about to expire: re-request it,
      but only if its state is ETHARP_STATE_STABLE to prevent flooding the
      network with ARP requests if this address is used frequently. */
-  if ((arp_table[arp_idx].state == ETHARP_STATE_STABLE) &&
+  if ((arp_table[arp_idx].state == ETHARP_STATE_STABLE) && 
       (arp_table[arp_idx].ctime >= ARP_AGE_REREQUEST_USED)) {
     if (etharp_request(netif, &arp_table[arp_idx].ipaddr) == ERR_OK) {
       arp_table[arp_idx].state = ETHARP_STATE_STABLE_REREQUESTING;
     }
   }
-
+  
   return etharp_send_ip(netif, q, (struct eth_addr*)(netif->hwaddr),
     &arp_table[arp_idx].ethaddr);
 }
@@ -990,11 +990,11 @@ etharp_output(struct netif *netif, struct pbuf *q, ip_addr_t *ipaddr)
  * is sent for the given address. The packet is queued on this entry.
  *
  * If the IP address was already stable in the cache, and a packet is
- * given, it is directly sent and no ARP request is sent out.
- *
+ * given, it is directly sent and no ARP request is sent out. 
+ * 
  * If the IP address was already stable in the cache, and no packet is
  * given, an ARP request is sent out.
- *
+ * 
  * @param netif The lwIP network interface on which ipaddr
  * must be queried for.
  * @param ipaddr The IP address to be resolved.
@@ -1079,7 +1079,7 @@ etharp_query(struct netif *netif, ip_addr_t *ipaddr, struct pbuf *q)
     struct pbuf *p;
     int copy_needed = 0;
     /* IF q includes a PBUF_REF, PBUF_POOL or PBUF_RAM, we have no choice but
-     * to copy the whole queue into a new PBUF_RAM (see bug #11400)
+     * to copy the whole queue into a new PBUF_RAM (see bug #11400) 
      * PBUF_ROMs can be left as they are, since ROM must not get changed. */
     p = q;
     while (p) {
@@ -1224,7 +1224,7 @@ etharp_raw(struct netif *netif, const struct eth_addr *ethsrc_addr,
 #endif /* LWIP_AUTOIP */
   ETHADDR16_COPY(&ethhdr->src, ethsrc_addr);
   /* Copy struct ip_addr2 to aligned ip_addr, to support compilers without
-   * structure packing. */
+   * structure packing. */ 
   IPADDR2_COPY(&hdr->sipaddr, ipsrc_addr);
   IPADDR2_COPY(&hdr->dipaddr, ipdst_addr);
 
@@ -1276,7 +1276,6 @@ etharp_request(struct netif *netif, ip_addr_t *ipaddr)
 err_t
 ethernet_input(struct pbuf *p, struct netif *netif)
 {
-  printf("------ETHERNET_INPUT()\n");
   struct eth_hdr* ethhdr;
   u16_t type;
 #if LWIP_ARP || ETHARP_SUPPORT_VLAN
@@ -1364,7 +1363,7 @@ ethernet_input(struct pbuf *p, struct netif *netif)
         ip_input(p, netif);
       }
       break;
-
+      
     case PP_HTONS(ETHTYPE_ARP):
       if (!(netif->flags & NETIF_FLAG_ETHARP)) {
         goto free_and_return;
diff --git a/netcon/NetconEthernetTap.cpp b/netcon/NetconEthernetTap.cpp
index 6ca9d5df..976e018e 100644
--- a/netcon/NetconEthernetTap.cpp
+++ b/netcon/NetconEthernetTap.cpp
@@ -78,7 +78,7 @@ NetconEthernetTap::NetconEthernetTap(
 	Utils::snprintf(sockPath,sizeof(sockPath),"/tmp/.ztnc_%.16llx",(unsigned long long)nwid);
 	_dev = sockPath;
 
-	lwipstack = new LWIPStack("/root/dev/netcon/liblwip.so");
+	lwipstack = new LWIPStack("netcon/liblwip.so");
 	if(!lwipstack) // TODO double check this check
 		throw std::runtime_error("unable to load lwip lib.");
 	lwipstack->lwip_init();
@@ -340,6 +340,10 @@ void NetconEthernetTap::threadMain()
 	fprintf(stderr, "- IP_TMR_INTERVAL  = %d\n", IP_TMR_INTERVAL);
 	fprintf(stderr, "- DEFAULT_READ_BUFFER_SIZE  = %d\n", DEFAULT_READ_BUFFER_SIZE);
 	*/
+
+	//fprintf(stderr, "- LWIP_DEBUG = %d\n", LWIP_DEBUG);
+	fprintf(stderr, "- TCP_DEBUG = %d\n", TCP_DEBUG);
+
 	// Main timer loop
 	while (_run) {
 		uint64_t now = OSUtils::now();
@@ -520,7 +524,7 @@ err_t NetconEthernetTap::nc_poll(void* arg, struct tcp_pcb *tpcb)
 	NetconConnection *c = l->tap->getConnectionByPCB(tpcb);
 	NetconEthernetTap *tap = l->tap;
 	if(c && c->idx > 0){
-		fprintf(stderr, "nc_poll(): calling handle_Write()\n");
+		fprintf(stderr, "nc_poll(): calling handle_write()\n");
 		tap->handle_write(c);
 	}
 	return ERR_OK;
@@ -563,7 +567,7 @@ err_t NetconEthernetTap::nc_accept(void *arg, struct tcp_pcb *newpcb, err_t err)
 		int send_fd = tap->_phy.getDescriptor(client->rpc->sock);
 		int n = write(larg_fd, "z", 1);
     if(n > 0) {
-			if(sock_fd_write(send_fd, fds[1]) < 0) {
+			if(sock_fd_write(send_fd, fds[1]) > 0) {
 				client->unmapped_conn = new_conn;
 			}
 			else {
@@ -628,7 +632,6 @@ err_t NetconEthernetTap::nc_recved(void *arg, struct tcp_pcb *tpcb, struct pbuf
   }
   q = p;
   while(p != NULL) { // Cycle through pbufs and write them to the socket
-		fprintf(stderr, "nc_recved(): writing pbufs to socket\n");
     if(p->len <= 0)
       break; // ?
     if((n = tap->_phy.streamSend(c->sock,p->payload, p->len)) > 0) {
diff --git a/netcon/liblwip.so b/netcon/liblwip.so
index 86c36665..9c129959 100755
--- a/netcon/liblwip.so
+++ b/netcon/liblwip.so
diff --git a/netcon/liblwip.so.debug b/netcon/liblwip.so.debug
new file mode 100755
index 00000000..86c36665
--- /dev/null
+++ b/netcon/liblwip.so.debug