diff --git a/examples/node/binding.cc b/examples/node/binding.cc
index da561ed..b5ab3c8 100644
--- a/examples/node/binding.cc
+++ b/examples/node/binding.cc
@@ -23,8 +23,8 @@ struct ZT {
   }
 
   static char* getIpV4Address(const char *nwid) {
-    char* addr_str = new char [ZT_MAX_IPADDR_LEN];
-    zts_get_ipv4_address(nwid, addr_str, ZT_MAX_IPADDR_LEN);
+    char* addr_str = new char [INET_ADDRSTRLEN];
+    zts_get_ipv4_address(nwid, addr_str, INET_ADDRSTRLEN);
     return addr_str;
   }
 
diff --git a/ext/picotcp/modules/pico_dns_client.h b/ext/picotcp/modules/pico_dns_client.h
index da3f313..dea234c 100644
--- a/ext/picotcp/modules/pico_dns_client.h
+++ b/ext/picotcp/modules/pico_dns_client.h
@@ -37,6 +37,9 @@
 #define PICO_DNS_RR_A_RDLENGTH 4
 #define PICO_DNS_RR_AAAA_RDLENGTH 16
 
+#ifdef __cplusplus
+extern "C" {
+#endif
 int pico_dns_client_init(void);
 /* flag is PICO_DNS_NS_DEL or PICO_DNS_NS_ADD */
 int pico_dns_client_nameserver(struct pico_ip4 *ns, uint8_t flag);
@@ -46,5 +49,8 @@ int pico_dns_client_getname(const char *ip, void (*callback)(char *url, void *ar
 int pico_dns_client_getaddr6(const char *url, void (*callback)(char *, void *), void *arg);
 int pico_dns_client_getname6(const char *url, void (*callback)(char *, void *), void *arg);
 #endif
+#ifdef __cplusplus
+}
+#endif
 
 #endif /* _INCLUDE_PICO_DNS_CLIENT */
diff --git a/include/libzt.h b/include/libzt.h
index 576e1eb..6300ad6 100644
--- a/include/libzt.h
+++ b/include/libzt.h
@@ -97,6 +97,11 @@ struct zts_ifreq {
 /****************************************************************************/
 
 #define ZT_SDK_MTU                         ZT_MAX_MTU
+#define ZT_LEN_SZ                          4
+#define ZT_ADDR_SZ                         128
+#define ZT_SOCKET_MSG_BUF_SZ               ZT_SDK_MTU + ZT_LEN_SZ + ZT_ADDR_SZ
+
+
 #define ZT_PHY_POLL_INTERVAL               2 // ms
 #define ZT_ACCEPT_RECHECK_DELAY            100 // ms (for blocking zts_accept() calls)
 #define ZT_CONNECT_RECHECK_DELAY           100 // ms (for blocking zts_connect() calls)
@@ -130,10 +135,10 @@ struct zts_ifreq {
 #define ZT_LIB_VERSION_MINOR               1
 #define ZT_LIB_VERSION_REVISION            4
 
-#define ZT_MAX_IPADDR_LEN                  64
-#define ZT_ID_LEN                          10
+#define ZT_ID_LEN                          16
 #define ZT_VER_STR_LEN                     6
 #define ZT_HOME_PATH_MAX_LEN               128
+#define ZT_MAC_ADDRSTRLEN                  18
 
 #define ZT_SOCK_STATE_NONE                 100
 #define ZT_SOCK_STATE_UNHANDLED_CONNECTED  101
@@ -503,7 +508,7 @@ int zts_add_dns_nameserver(struct sockaddr *addr);
 /*
  * Removes a DNS nameserver
  */
-int zts_remove_dns_nameserver(struct sockaddr *addr);
+int zts_del_dns_nameserver(struct sockaddr *addr);
 
 /****************************************************************************/
 /* SDK Socket API Helper functions/objects --- DONT CALL THESE DIRECTLY     */
@@ -558,6 +563,7 @@ ZeroTier::VirtualTap *getTapByNWID(uint64_t nwid);
 ZeroTier::VirtualTap *getTapByAddr(ZeroTier::InetAddress *addr);
 ZeroTier::VirtualTap *getTapByName(char *ifname);
 ZeroTier::VirtualTap *getTapByIndex(int index);
+ZeroTier::VirtualTap *getAnyTap();
 
 /*
  * Returns a pointer to a VirtualSocket for a given fd
diff --git a/make-linux.mk b/make-linux.mk
index c191dab..8ff44a8 100644
--- a/make-linux.mk
+++ b/make-linux.mk
@@ -64,12 +64,16 @@ ifeq ($(ZT_DEBUG),1)
 else
 	CFLAGS?=-Ofast -g -fstack-protector
 	CFLAGS+=-Wall -fPIE -fvisibility=hidden -pthread $(INCLUDES) $(DEFS)
-	#CFLAGS+=$(ARCH_FLAGS) -Wall -flto -fPIC -pthread -mmacosx-version-min=10.7 -DNDEBUG -Wno-unused-private-field $(INCLUDES) $(DEFS)
 	STRIP=strip
 endif
 
 CXXFLAGS=$(CFLAGS) -Wno-format -fno-rtti -std=c++11 -DZT_SOFTWARE_UPDATE_DEFAULT="\"disable\""
 
+# Build against address sanitization library for advanced debugging (clang)
+ifeq ($(ZT_SANITIZE),1)
+	CXXFLAGS+=-x c++ -O -g -fsanitize=address -DASAN_OPTIONS=symbolize=1 -DASAN_SYMBOLIZER_PATH=$(shell which llvm-symbolizer)
+endif
+
 INCLUDES+= -Iext \
 	-I$(ZTO)/osdep \
 	-I$(ZTO)/node \
diff --git a/make-mac.mk b/make-mac.mk
index 4925032..cfc4a29 100644
--- a/make-mac.mk
+++ b/make-mac.mk
@@ -70,6 +70,11 @@ endif
 
 CXXFLAGS=$(CFLAGS) -Wno-format -fno-rtti -std=c++11 -DZT_SOFTWARE_UPDATE_DEFAULT="\"disable\""
 
+# Build against address sanitization library for advanced debugging (clang)
+ifeq ($(ZT_SANITIZE),1)
+	CXXFLAGS+=-x c++ -O -g -fsanitize=address -DASAN_OPTIONS=symbolize=1 -DASAN_SYMBOLIZER_PATH=$(shell which llvm-symbolizer)
+endif
+
 INCLUDES+= -Iext \
 	-I$(ZTO)/osdep \
 	-I$(ZTO)/node \
@@ -209,7 +214,7 @@ static_lib: picotcp $(ZTO_OBJS)
 	$(CXX) $(CXXFLAGS) $(LIBZT_FILES) $(STACK_DRIVER_FILES) -c
 	mv *.o obj
 	#mv ext/picotcp/build/lib/*.o obj
-	mv ext/picotcp/build/modules/*.o obj
+	#mv ext/picotcp/build/modules/*.o obj
 	libtool -static -o $(STATIC_LIB) obj/*.o $(STACK_LIB)
 endif
 ifeq ($(STACK_LWIP),1)
diff --git a/src/VirtualTap.cpp b/src/VirtualTap.cpp
index af84bac..6db45c3 100644
--- a/src/VirtualTap.cpp
+++ b/src/VirtualTap.cpp
@@ -62,7 +62,7 @@ class VirtualTap;
 
 extern std::vector<void*> vtaps;
 
-static bool picodev_initialized;
+// static bool picodev_initialized;
 
 namespace ZeroTier {
 
@@ -96,12 +96,19 @@ namespace ZeroTier {
 			_phy(this,false,true)
 	{
 		vtaps.push_back((void*)this);
-		// set interface name
-		char tmp3[64];
+
+		// set virtual tap interface name (full)
+		memset(vtap_full_name, 0, sizeof(vtap_full_name));
 		ifindex = devno;
-		snprintf(tmp3, 64, "libzt%d-%lx", devno++, _nwid);
-		_dev = tmp3;
+		snprintf(vtap_full_name, sizeof(vtap_full_name), "libzt%d-%lx", devno++, _nwid);
+		_dev = vtap_full_name;
 		DEBUG_INFO("set VirtualTap interface name to: %s", _dev.c_str());
+
+		// set virtual tap interface name (abbreviated)
+		memset(vtap_abbr_name, 0, sizeof(vtap_abbr_name));
+		snprintf(vtap_abbr_name, sizeof(vtap_abbr_name), "libzt%d", devno);
+		
+		// start vtap thread and stack I/O loops
 		_thread = Thread::start(this);
 	}
 
@@ -143,14 +150,14 @@ namespace ZeroTier {
 	bool VirtualTap::addIp(const InetAddress &ip)
 	{
 #if defined(NO_STACK)
-		char ipbuf[64];
+		char ipbuf[INET6_ADDRSTRLEN];
 		DEBUG_INFO("addIp (%s)", ip.toString(ipbuf));
 		_ips.push_back(ip);
 		std::sort(_ips.begin(),_ips.end());
 		return true;
 #endif
 #if defined(STACK_PICO) || defined(STACK_LWIP)
-		char ipbuf[64];
+		char ipbuf[INET6_ADDRSTRLEN];
 		DEBUG_INFO("addIp (%s)", ip.toString(ipbuf));
 		if(registerIpWithStack(ip)) {
 			if (std::find(_ips.begin(),_ips.end(),ip) == _ips.end()) {
@@ -207,7 +214,8 @@ namespace ZeroTier {
 	{
 		// TODO: This is inefficient and awkward, should be replaced with something more elegant
 		if(zt1ServiceRef) {
-			char id[ZT_ID_LEN+1];
+			char id[ZT_ID_LEN];
+			memset(id, 0, sizeof(id));
 			sprintf(id, "%lx",((ZeroTier::OneService *)zt1ServiceRef)->getNode()->address());
 			return std::string(id);
 		}
@@ -260,6 +268,10 @@ namespace ZeroTier {
 		if(picostack){
 			picostack->pico_init_interface(this);
 			if(should_start_stack) {
+				// Add link to ipv4_link_add
+				//ZeroTier::InetAddress localhost;
+				//localhost.fromString("127.0.0.1");
+				//addIp(localhost); // Add a single link to localhost to the picoTCP device (TODO: should be placed elsewhere)
 				picostack->pico_loop(this);
 			}
 		}
@@ -353,6 +365,31 @@ namespace ZeroTier {
 		}
 	}
 
+
+	/****************************************************************************/
+	/* DNS                                                                      */
+	/****************************************************************************/
+
+	int VirtualTap::add_DNS_Nameserver(struct sockaddr *addr)
+	{
+#if defined(STACK_PICO)
+		return picostack->pico_add_dns_nameserver(addr);
+#endif
+#if defined(STACK_LWIP)
+		return lwipstack->lwip_add_dns_nameserver(addr);
+#endif
+	}
+
+	int VirtualTap::del_DNS_Nameserver(struct sockaddr *addr)
+	{
+#if defined(STACK_PICO)
+		return picostack->pico_del_dns_nameserver(addr);
+#endif
+#if defined(STACK_LWIP)
+		return lwipstack->lwip_del_dns_nameserver(addr);
+#endif
+	}
+
 	/****************************************************************************/
 	/* SDK Socket API                                                           */
 	/****************************************************************************/
@@ -532,20 +569,21 @@ namespace ZeroTier {
 	}
 
 	void VirtualTap::Housekeeping()
-	{
+	{/*
 		Mutex::Lock _l(_tcpconns_m);
 		std::time_t current_ts = std::time(nullptr);
 		if(current_ts > last_housekeeping_ts + ZT_HOUSEKEEPING_INTERVAL) {
-			// update managed routes (add/del from network stacks)		
-			if(zt1ServiceRef) {
-				std::vector<ZT_VirtualNetworkRoute> *managed_routes = ((ZeroTier::OneService *)zt1ServiceRef)->getRoutes(this->_nwid);
+			// update managed routes (add/del from network stacks)	
+			ZeroTier::OneService *service = ((ZeroTier::OneService *)zt1ServiceRef);	
+			if(service) {
+				std::vector<ZT_VirtualNetworkRoute> *managed_routes = service->getRoutes(this->_nwid);
 				ZeroTier::InetAddress target_addr;
 				ZeroTier::InetAddress via_addr;
 				ZeroTier::InetAddress null_addr;
 				ZeroTier::InetAddress nm;
 				null_addr.fromString("");
 				bool found;
-				char ipbuf[64], ipbuf2[64], ipbuf3[64];
+				char ipbuf[INET6_ADDRSTRLEN], ipbuf2[INET6_ADDRSTRLEN], ipbuf3[INET6_ADDRSTRLEN];
 				// TODO: Rework this when we have time
 				// check if pushed route exists in tap (add)
 				for(int i=0; i<ZT_MAX_NETWORK_ROUTES; i++) {
@@ -592,7 +630,9 @@ namespace ZeroTier {
 			// TODO: Clean up VirtualSocket objects
 
 			last_housekeeping_ts = std::time(nullptr);
+		
 		}
+		*/
 	}
 
 	/****************************************************************************/
diff --git a/src/VirtualTap.hpp b/src/VirtualTap.hpp
index 0234dc5..315a1f1 100644
--- a/src/VirtualTap.hpp
+++ b/src/VirtualTap.hpp
@@ -180,12 +180,25 @@ namespace ZeroTier {
 		 */
 		void removeVirtualSocket(VirtualSocket *vs);
 
+		/****************************************************************************/
+		/* DNS                                                                      */
+		/****************************************************************************/
+
+		/*
+		 * Registers a DNS nameserver with the network stack
+		 */
+		int add_DNS_Nameserver(struct sockaddr *addr);
+
+		/*
+		 * Un-registers a DNS nameserver from the network stack
+		 */
+		int del_DNS_Nameserver(struct sockaddr *addr);
+
 		/****************************************************************************/
 		/* Vars                                                                     */
 		/****************************************************************************/
 
 #if defined(STACK_PICO)
-
 		bool should_start_stack = false;
 		struct pico_device *picodev = NULL;
 
@@ -206,6 +219,9 @@ namespace ZeroTier {
 		std::vector<std::pair<ZeroTier::InetAddress, ZeroTier::InetAddress>> routes;
 		void *zt1ServiceRef = NULL;
 
+		char vtap_full_name[64];
+		char vtap_abbr_name[16];
+
 		static int devno;
 		int ifindex = 0;
 
diff --git a/src/libzt.cpp b/src/libzt.cpp
index ad09e07..5b906c0 100644
--- a/src/libzt.cpp
+++ b/src/libzt.cpp
@@ -35,6 +35,7 @@ for applications to use. See also: include/libzt.h */
 #include <unistd.h>
 #include <errno.h>
 #include <time.h>
+#include <stdint.h>
 
 #if defined(__APPLE__)
 #include <net/ethernet.h>
@@ -130,7 +131,7 @@ void zts_start(const char *path)
 	if(path)
 		ZeroTier::homeDir = path;
 	pthread_t service_thread;
-	pthread_create(&service_thread, NULL, zts_start_service, (void *)(path));
+	pthread_create(&service_thread, NULL, zts_start_service, NULL);
 }
 
 void zts_simple_start(const char *path, const char *nwid)
@@ -138,11 +139,9 @@ void zts_simple_start(const char *path, const char *nwid)
 	zts_start(path);
 	while(!zts_running()) {
 		nanosleep((const struct timespec[]){{0, (ZT_API_CHECK_INTERVAL * 1000000)}}, NULL);
-		//usleep(ZT_API_CHECK_INTERVAL * 1000);
 	}
 	zts_join(nwid);
 	while(!zts_has_address(nwid)) {
-		//usleep(ZT_API_CHECK_INTERVAL * 1000);
 		nanosleep((const struct timespec[]){{0, (ZT_API_CHECK_INTERVAL * 1000000)}}, NULL);
 	}
 }
@@ -219,9 +218,9 @@ void zts_lib_version(char *ver) {
 
 int zts_get_device_id(char *devID) { 
 	if(ZeroTier::zt1Service) {
-		char id[ZT_ID_LEN+1];
+		char id[ZT_ID_LEN];
 		sprintf(id, "%lx",ZeroTier::zt1Service->getNode()->address());
-		memcpy(devID, id, ZT_ID_LEN+1);
+		memcpy(devID, id, ZT_ID_LEN);
 		return 0;
 	}
 	else // Service isn't online, try to read ID from file
@@ -245,17 +244,17 @@ int zts_running() {
 
 int zts_has_ipv4_address(const char *nwid)
 {
-	char ipv4_addr[ZT_MAX_IPADDR_LEN];
-	memset(ipv4_addr, 0, ZT_MAX_IPADDR_LEN);
-	zts_get_ipv4_address(nwid, ipv4_addr, ZT_MAX_IPADDR_LEN);
+	char ipv4_addr[INET_ADDRSTRLEN];
+	memset(ipv4_addr, 0, INET_ADDRSTRLEN);
+	zts_get_ipv4_address(nwid, ipv4_addr, INET_ADDRSTRLEN);
 	return strcmp(ipv4_addr, "\0");
 }
 
 int zts_has_ipv6_address(const char *nwid)
 {
-	char ipv6_addr[ZT_MAX_IPADDR_LEN];
-	memset(ipv6_addr, 0, ZT_MAX_IPADDR_LEN);
-	zts_get_ipv6_address(nwid, ipv6_addr, ZT_MAX_IPADDR_LEN);
+	char ipv6_addr[INET6_ADDRSTRLEN];
+	memset(ipv6_addr, 0, INET6_ADDRSTRLEN);
+	zts_get_ipv6_address(nwid, ipv6_addr, INET6_ADDRSTRLEN);
 	return strcmp(ipv6_addr, "\0");
 }
 
@@ -272,7 +271,7 @@ void zts_get_ipv4_address(const char *nwid, char *addrstr, const int addrlen)
 		if(tap && tap->_ips.size()){ 
 			for(int i=0; i<tap->_ips.size(); i++) {
 				if(tap->_ips[i].isV4()) {
-					char ipbuf[64];
+					char ipbuf[INET_ADDRSTRLEN];
 					std::string addr = tap->_ips[i].toString(ipbuf);
 					int len = addrlen < addr.length() ? addrlen : addr.length();
 					memset(addrstr, 0, len);
@@ -294,7 +293,7 @@ void zts_get_ipv6_address(const char *nwid, char *addrstr, const int addrlen)
 		if(tap && tap->_ips.size()){ 
 			for(int i=0; i<tap->_ips.size(); i++) {
 				if(tap->_ips[i].isV6()) {
-					char ipbuf[64];
+					char ipbuf[INET6_ADDRSTRLEN];
 					std::string addr = tap->_ips[i].toString(ipbuf);
 					int len = addrlen < addr.length() ? addrlen : addr.length();
 					memset(addrstr, 0, len);
@@ -312,7 +311,7 @@ void zts_get_6plane_addr(char *addr, const char *nwid, const char *devID)
 {
 	ZeroTier::InetAddress _6planeAddr = ZeroTier::InetAddress::makeIpv66plane(
 		ZeroTier::Utils::hexStrToU64(nwid),ZeroTier::Utils::hexStrToU64(devID));
-	char ipbuf[64];
+	char ipbuf[INET6_ADDRSTRLEN];
 	memcpy(addr, _6planeAddr.toIpString(ipbuf), 40);
 }
 
@@ -320,7 +319,7 @@ void zts_get_rfc4193_addr(char *addr, const char *nwid, const char *devID)
 {
 	ZeroTier::InetAddress _6planeAddr = ZeroTier::InetAddress::makeIpv6rfc4193(
 		ZeroTier::Utils::hexStrToU64(nwid),ZeroTier::Utils::hexStrToU64(devID));
-	char ipbuf[64];
+	char ipbuf[INET6_ADDRSTRLEN];
 	memcpy(addr, _6planeAddr.toIpString(ipbuf), 40);
 }
 
@@ -576,7 +575,6 @@ int zts_connect(ZT_CONNECT_SIG) {
 		{
 			// FIXME: locking and unlocking so often might cause a performance bottleneck while outgoing VirtualSockets
 			// are being established (also applies to accept())
-			//usleep(ZT_CONNECT_RECHECK_DELAY * 1000);
 			nanosleep((const struct timespec[]){{0, (ZT_CONNECT_RECHECK_DELAY * 1000000)}}, NULL);
 			tap->_tcpconns_m.lock();
 			for(int i=0; i<tap->_VirtualSockets.size(); i++)
@@ -619,7 +617,6 @@ Darwin:
 							address space.
 */
 int zts_bind(ZT_BIND_SIG) {
-	DEBUG_INFO();
 	int err = errno = 0;
 	if(fd < 0) {
 		errno = EBADF;
@@ -643,26 +640,31 @@ int zts_bind(ZT_BIND_SIG) {
 	if(vs->socket_family == AF_INET) {
 		struct sockaddr_in *in4 = (struct sockaddr_in *)addr;
 		if(in4->sin_addr.s_addr == INADDR_ANY) {
-			DEBUG_INFO("AF_INET, INADDR_ANY, binding to all interfaces");
+			DEBUG_EXTRA("AF_INET, INADDR_ANY, binding to all interfaces");
 			// grab first vtap
 			if(ZeroTier::vtaps.size()) {
-				tap = (ZeroTier::VirtualTap*)(ZeroTier::vtaps[0]);
+				tap = (ZeroTier::VirtualTap*)(ZeroTier::vtaps[0]); // pick any vtap
+			}
+		}
+		if(in4->sin_addr.s_addr == 0x7f000001) {
+			DEBUG_EXTRA("127.0.0.1, will bind to appropriate vtap when connection is inbound");
+			if(ZeroTier::vtaps.size()) {
+				tap = (ZeroTier::VirtualTap*)(ZeroTier::vtaps[0]); // pick any vtap
 			}
 		}
 	}
 	if(vs->socket_family == AF_INET6) {
 		struct sockaddr_in6 *in6 = (struct sockaddr_in6 *)addr;
 		if(memcmp((void*)&(in6->sin6_addr), (void*)&(in6addr_any), sizeof(in6addr_any)) == 0) {
-			DEBUG_INFO("AF_INET6, in6addr_any, binding to all interfaces");
+			DEBUG_EXTRA("AF_INET6, in6addr_any, binding to all interfaces");
 			if(ZeroTier::vtaps.size()) {
-				tap = (ZeroTier::VirtualTap*)(ZeroTier::vtaps[0]);
+				tap = (ZeroTier::VirtualTap*)(ZeroTier::vtaps[0]);  // pick any vtap
 			}
 		}
 	}
 
 	ZeroTier::InetAddress inet;
 	sockaddr2inet(vs->socket_family, addr, &inet);
-	char buf3[64];
 	if(!tap)
 		tap = getTapByAddr(&inet);
 
@@ -793,7 +795,6 @@ int zts_accept(ZT_ACCEPT_SIG) {
 			}
 			else { // blocking
 				while(true) {
-					//usleep(ZT_ACCEPT_RECHECK_DELAY * 1000);
 					nanosleep((const struct timespec[]){{0, (ZT_ACCEPT_RECHECK_DELAY * 1000000)}}, NULL);
 					accepted_vs = tap->Accept(vs);
 					if(accepted_vs)
@@ -1036,7 +1037,7 @@ Linux / Darwin:
 int zts_close(ZT_CLOSE_SIG)
 {
 	int err = errno = 0;
-	DEBUG_EXTRA("fd=%d", fd);
+	//DEBUG_EXTRA("fd=%d", fd);
 	if(fd < 0) {
 		errno = EBADF;
 		return -1;
@@ -1192,7 +1193,7 @@ Linux:
 */
 ssize_t zts_sendto(ZT_SENDTO_SIG)
 {
-	//DEBUG_INFO();
+	DEBUG_TRANS("fd=%d", fd);
 	int err = errno = 0;
 	if(fd < 0) {
 		errno = EBADF;
@@ -1208,26 +1209,27 @@ ssize_t zts_sendto(ZT_SENDTO_SIG)
 
 	ZeroTier::InetAddress iaddr;
 	ZeroTier::VirtualTap *tap;
-	char ipstr[INET6_ADDRSTRLEN];
-	// int port;
-	memset(ipstr, 0, INET6_ADDRSTRLEN);
 
-	if(vs->socket_type == SOCK_DGRAM) {
-		// form addresses
-		if(vs->socket_family == AF_INET) {
+	if(vs->socket_type == SOCK_DGRAM) 
+	{
+		if(vs->socket_family == AF_INET) 
+		{
+			char ipstr[INET_ADDRSTRLEN];
+			memset(ipstr, 0, INET_ADDRSTRLEN);
 			inet_ntop(AF_INET, 
 				(const void *)&((struct sockaddr_in *)addr)->sin_addr.s_addr, ipstr, INET_ADDRSTRLEN);
 			iaddr.fromString(ipstr);
-			// port = ((struct sockaddr_in*)addr)->sin_port;
 		}
-		if(vs->socket_family == AF_INET6) {
+		if(vs->socket_family == AF_INET6) 
+		{
+			char ipstr[INET6_ADDRSTRLEN];
+			memset(ipstr, 0, INET6_ADDRSTRLEN);
 			inet_ntop(AF_INET6, 
 				(const void *)&((struct sockaddr_in6 *)addr)->sin6_addr.s6_addr, ipstr, INET6_ADDRSTRLEN);
 			// TODO: This is a hack, determine a proper way to do this
-			char addrstr[64];
+			char addrstr[INET6_ADDRSTRLEN];
 			sprintf(addrstr, "%s%s", ipstr, std::string("/40").c_str());
 			iaddr.fromString(addrstr);
-			// port = ((struct sockaddr_in6*)addr)->sin6_port;
 		}
 		// get tap
 		tap = getTapByAddr(&iaddr);
@@ -1242,7 +1244,8 @@ ssize_t zts_sendto(ZT_SENDTO_SIG)
 			errno = EINVAL; // TODO: Not correct, but what else could we use?
 		}
 	}
-	if(vs->socket_type == SOCK_RAW) {
+	if(vs->socket_type == SOCK_RAW) 
+	{
 		struct sockaddr_ll *socket_address = (struct sockaddr_ll *)addr;
 		ZeroTier::VirtualTap *tap = getTapByIndex(socket_address->sll_ifindex);
 		if(tap) {
@@ -1308,6 +1311,7 @@ ssize_t zts_sendto(ZT_SENDTO_SIG)
 */
 ssize_t zts_send(ZT_SEND_SIG)
 {
+	DEBUG_TRANS("fd=%d", fd);
 	int err = errno = 0;
 	ZeroTier::VirtualSocket *vs = get_virtual_socket(fd);
 	if(!vs) {
@@ -1375,7 +1379,7 @@ ssize_t zts_send(ZT_SEND_SIG)
 // TODO
 ssize_t zts_sendmsg(ZT_SENDMSG_SIG)
 {
-	DEBUG_INFO("fd = %d", fd);
+	DEBUG_TRANS("fd=%d", fd);	
 	int err = errno = 0;
 	if(fd < 0) {
 		errno = EBADF;
@@ -1413,6 +1417,7 @@ ssize_t zts_sendmsg(ZT_SENDMSG_SIG)
 */
 ssize_t zts_recv(ZT_RECV_SIG)
 {
+	DEBUG_TRANS("fd=%d", fd);
 	int err = errno = 0;
 	ZeroTier::VirtualSocket *vs = get_virtual_socket(fd);
 	if(!vs) {
@@ -1500,21 +1505,31 @@ ssize_t zts_recv(ZT_RECV_SIG)
 */
 ssize_t zts_recvfrom(ZT_RECVFROM_SIG)
 {
-	//DEBUG_INFO();
-	int r = 0, err = errno = 0;
+	DEBUG_TRANS("fd=%d", fd);
+	int32_t r = 0;
+	errno = 0;
 	if(fd < 0) {
 		errno = EBADF;
 		return -1;
 	}
-	char udp_msg_buf[ZT_MAX_MTU];
-	r = read(fd, udp_msg_buf, sizeof(udp_msg_buf));
+	char udp_msg_buf[ZT_SOCKET_MSG_BUF_SZ];
+	char *msg_ptr = udp_msg_buf;
+	r = read(fd, msg_ptr, sizeof(udp_msg_buf));
 	if(r > 0) {
-		int udp_msg_len = 0;
-		memcpy(&udp_msg_len, udp_msg_buf, sizeof(udp_msg_len));
-		memcpy(addr, udp_msg_buf + sizeof(int), sizeof(struct sockaddr_in));
-		*addrlen = sizeof(struct sockaddr_in);
-		int payload_sz = udp_msg_len - sizeof(struct sockaddr_in);
-		memcpy(buf, udp_msg_buf + sizeof(int) + sizeof(struct sockaddr_in), payload_sz);
+		*addrlen = sizeof(struct sockaddr_storage);
+
+		// get message length
+		int32_t udp_msg_len = 0;
+		memcpy(&udp_msg_len, msg_ptr, sizeof(udp_msg_len));
+		msg_ptr+=sizeof(int32_t);
+
+		// get address
+		memcpy(addr, msg_ptr, *addrlen);
+		msg_ptr+=*addrlen;
+		
+		// get payload
+		int32_t payload_sz = udp_msg_len - *addrlen;
+		memcpy(buf, msg_ptr, payload_sz);
 		r = payload_sz;
 	}
 	return r;
@@ -1523,7 +1538,7 @@ ssize_t zts_recvfrom(ZT_RECVFROM_SIG)
 // TODO
 ssize_t zts_recvmsg(ZT_RECVMSG_SIG)
 {
-	DEBUG_INFO("fd=%d", fd);
+	DEBUG_TRANS("fd=%d", fd);
 	int err = errno = 0;
 	if(fd < 0) {
 		errno = EBADF;
@@ -1536,12 +1551,12 @@ ssize_t zts_recvmsg(ZT_RECVMSG_SIG)
 }
 
 int zts_read(ZT_READ_SIG) {
-	//DEBUG_INFO("fd = %d", fd);
+	DEBUG_TRANS("fd=%d", fd);
 	return read(fd, buf, len);
 }
 
 int zts_write(ZT_WRITE_SIG) {
-	// DEBUG_INFO("fd = %d", fd);
+	DEBUG_TRANS("fd=%d", fd);
 	return write(fd, buf, len);
 }
 
@@ -1616,7 +1631,6 @@ int zts_shutdown(ZT_SHUTDOWN_SIG)
 						for(int i=0; i<ZT_SDK_CLTIME; i++) {
 							if(vs->TXbuf->count() == 0)
 								break;
-							//usleep(ZT_API_CHECK_INTERVAL * 1000);
 							nanosleep((const struct timespec[]){{0, (ZT_API_CHECK_INTERVAL * 1000000)}}, NULL);
 
 						}
@@ -1635,21 +1649,29 @@ int zts_shutdown(ZT_SHUTDOWN_SIG)
 	return 0;
 }
 
-
 int zts_add_dns_nameserver(struct sockaddr *addr)
 {
-	errno = 0;
-	return 0;
+	ZeroTier::VirtualTap *vtap = getAnyTap();
+	if(vtap){
+		return vtap->add_DNS_Nameserver(addr);
+	}
+	DEBUG_ERROR("unable to locate virtual tap to add DNS nameserver");
+	return -1;
 }
 
-int zts_remove_dns_nameserver(struct sockaddr *addr)
+int zts_del_dns_nameserver(struct sockaddr *addr)
 {
-	errno = 0;
-	return 0;
+	ZeroTier::VirtualTap *vtap = getAnyTap();
+	if(vtap){
+		return vtap->del_DNS_Nameserver(addr);
+	}
+	DEBUG_ERROR("unable to locate virtual tap to remove DNS nameserver");
+	return -1;
 }
 
 /****************************************************************************/
-/* SDK Socket API (Java Native Interface JNI)                               /* JNI naming convention: Java_PACKAGENAME_CLASSNAME_METHODNAME             */
+/* SDK Socket API (Java Native Interface JNI)                               */
+/* JNI naming convention: Java_PACKAGENAME_CLASSNAME_METHODNAME             */
 /****************************************************************************/
 
 
@@ -1659,7 +1681,7 @@ namespace ZeroTier {
 
 	#include <jni.h>
 
-	JNIEXPORT int JNICALL Java_zerotier_ZeroTier_ztjni_1start(JNIEnv *env, jobject thisObj, jstring path) {
+	JNIEXPORT void JNICALL Java_zerotier_ZeroTier_ztjni_1start(JNIEnv *env, jobject thisObj, jstring path) {
 		if(path) {
 			homeDir = env->GetStringUTFChars(path, NULL);
 			zts_start(homeDir.c_str());
@@ -1711,9 +1733,9 @@ namespace ZeroTier {
 		JNIEnv *env, jobject thisObj, jstring nwid) 
 	{
 		const char *nwid_str = env->GetStringUTFChars(nwid, NULL);
-		char address_string[32];
-		memset(address_string, 0, 32);
-		zts_get_ipv4_address(nwid_str, address_string, ZT_MAX_IPADDR_LEN);
+		char address_string[INET_ADDRSTRLEN];
+		memset(address_string, 0, INET_ADDRSTRLEN);
+		zts_get_ipv4_address(nwid_str, address_string, INET_ADDRSTRLEN);
 		jclass clazz = (*env).FindClass("java/util/ArrayList");
 		jobject addresses = (*env).NewObject(clazz, (*env).GetMethodID(clazz, "<init>", "()V"));        
 		jstring _str = (*env).NewStringUTF(address_string);
@@ -1725,9 +1747,9 @@ namespace ZeroTier {
 		JNIEnv *env, jobject thisObj, jstring nwid) 
 	{
 		const char *nwid_str = env->GetStringUTFChars(nwid, NULL);
-		char address_string[32];
-		memset(address_string, 0, 32);
-		zts_get_ipv6_address(nwid_str, address_string, ZT_MAX_IPADDR_LEN);
+		char address_string[INET6_ADDRSTRLEN];
+		memset(address_string, 0, INET6_ADDRSTRLEN);
+		zts_get_ipv6_address(nwid_str, address_string, INET6_ADDRSTRLEN);
 		jclass clazz = (*env).FindClass("java/util/ArrayList");
 		jobject addresses = (*env).NewObject(clazz, (*env).GetMethodID(clazz, "<init>", "()V"));        
 		jstring _str = (*env).NewStringUTF(address_string);
@@ -1778,7 +1800,7 @@ namespace ZeroTier {
 		struct sockaddr_in addr;
 		jbyte *body = (*env).GetByteArrayElements( buf, 0);
 		unsigned char buffer[ZT_SDK_MTU];
-		int payload_offset = sizeof(int) + sizeof(struct sockaddr_storage);
+		int payload_offset = sizeof(int32_t) + sizeof(struct sockaddr_storage);
 		int rxbytes = zts_recvfrom(fd, &buffer, len, flags, (struct sockaddr *)&addr, (socklen_t *)sizeof(struct sockaddr_storage));
 		if(rxbytes > 0)
 			memcpy(body, (jbyte*)buffer + payload_offset, rxbytes);
@@ -1909,18 +1931,6 @@ namespace ZeroTier {
 /* SDK Socket API Helper functions --- DON'T CALL THESE DIRECTLY            */
 /****************************************************************************/
 
-void zts_start_dns_client()
-{
-	// Coming soon
-
-	/*
-	struct pico_ip4 *ns;
-	uint8_t flag = PICO_DNS_NS_ADD; // PICO_DNS_NS_DEL, PICO_DNS_NS_ADD
-	pico_dns_client_nameserver(ns, flag);
-	*/
-}
-
-
 #if defined(STACK_PICO)
 int zts_get_pico_socket(int fd, struct pico_socket **s)
 {
@@ -2025,7 +2035,7 @@ ZeroTier::VirtualTap *getTapByAddr(ZeroTier::InetAddress *addr)
 {
 	ZeroTier::_vtaps_lock.lock();
 	ZeroTier::VirtualTap *s, *tap = nullptr; 
-	char ipbuf[64], ipbuf2[64], ipbuf3[64];
+	//char ipbuf[64], ipbuf2[64], ipbuf3[64];
 	for(int i=0; i<ZeroTier::vtaps.size(); i++) {
 		s = (ZeroTier::VirtualTap*)ZeroTier::vtaps[i];
 		// check address schemes
@@ -2092,6 +2102,17 @@ ZeroTier::VirtualTap *getTapByIndex(int index)
 	return tap;
 }
 
+ZeroTier::VirtualTap *getAnyTap()
+{
+	ZeroTier::_vtaps_lock.lock();
+	ZeroTier::VirtualTap *vtap = NULL;
+	if(ZeroTier::vtaps.size()) {
+		vtap = (ZeroTier::VirtualTap *)ZeroTier::vtaps[0];
+	}
+	ZeroTier::_vtaps_lock.unlock();
+	return vtap;
+}
+
 /****************************************************************************/
 /* VirtualSocket / VirtualTap helper functions - DON'T CALL THESE DIRECTLY  */
 /****************************************************************************/
diff --git a/src/picoTCP.cpp b/src/picoTCP.cpp
index 364de0e..2da9cc4 100644
--- a/src/picoTCP.cpp
+++ b/src/picoTCP.cpp
@@ -25,6 +25,7 @@
  */
 
 #include <ctime>
+#include <stdint.h>
 
 #include "pico_eth.h"
 #include "pico_stack.h"
@@ -36,6 +37,7 @@
 #include "pico_device.h"
 #include "pico_ipv6.h"
 #include "pico_tcp.h"
+#include "pico_dns_client.h"
 
 #include "libzt.h"
 #include "Utilities.hpp"
@@ -65,6 +67,7 @@ extern "C" int pico_socket_listen(PICO_SOCKET_LISTEN_SIG);
 extern "C" int pico_socket_write(PICO_SOCKET_WRITE_SIG);
 extern "C" int pico_socket_close(PICO_SOCKET_CLOSE_SIG);
 extern "C" struct pico_ipv6_link * pico_ipv6_link_add(PICO_IPV6_LINK_ADD_SIG);
+extern "C" int pico_dns_client_nameserver(PICO_DNS_CLIENT_NAMESERVER_SIG);
 
 /*
 int pico_stack_recv(PICO_STACK_RECV_SIG);
@@ -106,7 +109,7 @@ namespace ZeroTier {
 			picodev.tap = tap;
 			uint8_t mac[PICO_SIZE_ETH];
 			tap->_mac.copyTo(mac, PICO_SIZE_ETH);
-			if(pico_device_init(&picodev, tap->_dev.c_str(), mac) != 0) {
+			if(pico_device_init(&picodev, tap->vtap_abbr_name, mac) != 0) {
 				DEBUG_ERROR("dev init failed");
 				handle_general_failure();
 				err = false;
@@ -122,7 +125,7 @@ namespace ZeroTier {
 	{
 		_picostack_driver_lock.lock();
 		bool err = false;
-		char ipbuf[64];
+		char ipbuf[INET6_ADDRSTRLEN];
 		uint8_t hwaddr[6];	
 		// register addresses
 		if(ip.isV4()) {
@@ -132,8 +135,8 @@ namespace ZeroTier {
 			pico_ipv4_link_add(&picodev, ipaddr, netmask);
 			DEBUG_INFO("addr=%s", ip.toString(ipbuf));
 			tap->_mac.copyTo(hwaddr, 6);
-			char macbuf[18];
-			mac2str(macbuf, sizeof(macbuf), hwaddr);
+			char macbuf[ZT_MAC_ADDRSTRLEN];
+			mac2str(macbuf, ZT_MAC_ADDRSTRLEN, hwaddr);
 			DEBUG_INFO("mac=%s", macbuf);
 			err = true;
 		}
@@ -147,8 +150,8 @@ namespace ZeroTier {
 			pico_ipv6_link_add(&picodev, ipaddr, netmask);
 			DEBUG_INFO("addr=%s", ipv6_str);
 			tap->_mac.copyTo(hwaddr, 6);
-			char macbuf[18];
-			mac2str(macbuf, sizeof(macbuf), hwaddr);
+			char macbuf[ZT_MAC_ADDRSTRLEN];
+			mac2str(macbuf, ZT_MAC_ADDRSTRLEN, hwaddr);
 			DEBUG_INFO("mac=%s", macbuf);
 			err = true;    
 		}
@@ -188,7 +191,46 @@ namespace ZeroTier {
 		}
 		return err;
 	}
+
+	int picoTCP::pico_add_dns_nameserver(struct sockaddr *addr)
+	{
+		int err = errno = 0; 
+		// TODO: De-complexify this
+		struct pico_ip4 ns;
+		memset(&ns, 0, sizeof (struct pico_ip4));
+		struct sockaddr_in *in4 = (struct sockaddr_in*)addr;
+		char ipv4_str[INET_ADDRSTRLEN];
+		inet_ntop(AF_INET, (const void *)&in4->sin_addr.s_addr, ipv4_str, INET_ADDRSTRLEN);
+		uint32_t ipval = 0;
+		pico_string_to_ipv4(ipv4_str, &ipval);
+		ns.addr = ipval;
+		if((err = pico_dns_client_nameserver(&ns, PICO_DNS_NS_ADD)) < 0) {
+			DEBUG_ERROR("error while adding DNS nameserver, err=%d, pico_err=%d, %s", 
+				err, pico_err, beautify_pico_error(pico_err));
+			map_pico_err_to_errno(pico_err);
+		}
+		return err;
+	}
 	
+	int picoTCP::pico_del_dns_nameserver(struct sockaddr *addr)
+	{
+		int err = errno = 0; 
+		// TODO: De-complexify this
+		struct pico_ip4 ns;
+		memset(&ns, 0, sizeof (struct pico_ip4));
+		struct sockaddr_in *in4 = (struct sockaddr_in*)addr;
+		char ipv4_str[INET_ADDRSTRLEN];
+		inet_ntop(AF_INET, (const void *)&in4->sin_addr.s_addr, ipv4_str, INET_ADDRSTRLEN);
+		uint32_t ipval = 0;
+		pico_string_to_ipv4(ipv4_str, &ipval);
+		ns.addr = ipval;
+		if((err = pico_dns_client_nameserver(&ns, PICO_DNS_NS_DEL)) < 0) {
+			DEBUG_ERROR("error while removing DNS nameserver, err=%d, pico_err=%d, %s", 
+				err, pico_err, beautify_pico_error(pico_err));
+		}
+		return err;
+	}
+
 	void picoTCP::pico_loop(VirtualTap *tap)
 	{
 		while(tap->_run)
@@ -232,28 +274,17 @@ namespace ZeroTier {
 
 		do {
 			n = 0;
-			//DEBUG_INFO("RXbuf->count() = %d", vs->RXbuf->count());
 			int avail = ZT_TCP_RX_BUF_SZ - vs->RXbuf->count();
 			if(avail) {
-				DEBUG_INFO("vs->RXbuf->get_buf()= %p", vs->RXbuf->get_buf());
-				DEBUG_INFO("vs->RXbuf->count()  = %d", vs->RXbuf->count());
-				DEBUG_INFO("s                   = %p", s); 
-				DEBUG_INFO("avail               = %d", avail);
-				DEBUG_INFO("tap                 = %p", tap);
-				DEBUG_INFO("peer.ip4.addr       = %p", peer.ip4.addr);
 				r = pico_socket_recvfrom(s, vs->RXbuf->get_buf(), ZT_STACK_SOCKET_RD_MAX, 
 					(void *)&peer.ip4.addr, &port);
 				if (r > 0)
 				{
 					vs->RXbuf->produce(r);
-					//DEBUG_INFO("RXbuf->count() = %d", vs->RXbuf->count());
 					n = tap->_phy.streamSend(vs->sock, vs->RXbuf->get_buf(), r);
 
 					if(n>0)
 						vs->RXbuf->consume(n);
-					//DEBUG_INFO("pico_recv = %d, streamSend = %d, rxsz = %d, tot = %d", r, n, vs->RXbuf->count(), vs->tot);
-
-					//DEBUG_TRANS("[ TCP RX <- STACK] :: vs = %p, len = %d", vs, n);
 				}
 				if(vs->RXbuf->count() == 0) {
 					tap->_phy.setNotifyWritable(vs->sock, false);
@@ -311,12 +342,12 @@ namespace ZeroTier {
 			in4.sin_port = port;
 			// immediately attempt to write addr and payload to app socket. The idea is that the zts_recvfrom() has
 			// been called and will pick this up and correctly handle it
-			char udp_msg_buf[ZT_MAX_MTU]; // [sz : addr : payload]
-			int len = sizeof(struct sockaddr_in) + r;
-			int tot_len = sizeof(len) + len;
-			memcpy(udp_msg_buf, &len, sizeof(len)); // len: sockaddr+payload
-			memcpy(udp_msg_buf + sizeof(len), &in4, sizeof(in4)); // sockaddr
-			memcpy(udp_msg_buf + sizeof(len) + sizeof(in4), &udp_payload_buf, r); // payload
+			char udp_msg_buf[ZT_SOCKET_MSG_BUF_SZ]; // [sz : addr : payload]
+			int32_t len = sizeof(struct sockaddr_storage) + r;
+			int32_t tot_len = sizeof(int32_t) + len;
+			memcpy(udp_msg_buf, &len, sizeof(int32_t)); // len: sockaddr+payload
+			memcpy(udp_msg_buf + sizeof(int32_t), &in4, sizeof(struct sockaddr_storage)); // sockaddr
+			memcpy(udp_msg_buf + sizeof(int32_t) + sizeof(struct sockaddr_storage), &udp_payload_buf, r); // payload
 			if((w = write(vs->sdk_fd, udp_msg_buf, tot_len)) < 0) {
 				DEBUG_ERROR("write()=%d, errno=%d", w, errno);
 			}
@@ -331,12 +362,12 @@ namespace ZeroTier {
 			in6.sin6_port = port;
 			// immediately attempt to write addr and payload to app socket. The idea is that the zts_recvfrom() has
 			// been called and will pick this up and correctly handle it
-			char udp_msg_buf[ZT_MAX_MTU]; // [sz : addr : payload]
-			int len = sizeof(struct sockaddr_in6) + r;
-			int tot_len = sizeof(len) + len;
-			memcpy(udp_msg_buf, &len, sizeof(len)); // len: sockaddr+payload
-			memcpy(udp_msg_buf + sizeof(len), &in6, sizeof(in6)); // sockaddr
-			memcpy(udp_msg_buf + sizeof(len) + sizeof(in6), &udp_payload_buf, r); // payload
+			char udp_msg_buf[ZT_SOCKET_MSG_BUF_SZ]; // [sz : addr : payload]
+			int32_t len = sizeof(struct sockaddr_storage) + r;
+			int32_t tot_len = sizeof(int32_t) + len;
+			memcpy(udp_msg_buf, &len, sizeof(int32_t)); // len: sockaddr+payload
+			memcpy(udp_msg_buf + sizeof(int32_t), &in6, sizeof(struct sockaddr_storage)); // sockaddr
+			memcpy(udp_msg_buf + sizeof(int32_t) + sizeof(struct sockaddr_storage), &udp_payload_buf, r); // payload
 			if((w = write(vs->sdk_fd, udp_msg_buf, tot_len)) < 0) {
 				DEBUG_ERROR("write()=%d, errno=%d", w, errno);
 			}
@@ -364,17 +395,16 @@ namespace ZeroTier {
 
 		int r, max_write_len = std::min(std::min(txsz, ZT_SDK_MTU),ZT_STACK_SOCKET_WR_MAX);
 		if((r = pico_socket_write(vs->picosock, vs->TXbuf->get_buf(), max_write_len)) < 0) {
-			DEBUG_ERROR("unable to write to picosock=%p, r=%d", vs->picosock, r);
+			DEBUG_ERROR("unable to write to pico_socket=%p, err=%d, pico_err=%d, %s", 
+				vs->picosock, r, pico_err, beautify_pico_error(pico_err));
 			handle_general_failure();
 			return;
 		}
 		if(vs->socket_type == SOCK_STREAM) {
-			//DEBUG_TRANS("[ TCP TX -> STACK] :: vs = %p, len = %d", vs, r);
-		}
-		if(vs->socket_type == SOCK_DGRAM) {
-			//DEBUG_TRANS("[ UDP TX -> STACK] :: vs = %p, len = %d", vs, r);
+			DEBUG_TRANS("len=%5d, [app(buf) --> network_stack(vs=%p)] proto=0x%04x (TCP)", r, vs, PICO_PROTO_TCP);
 		}
 		if(r == 0) {
+			// DEBUG_ERROR("err=%d, pico_err=%d, %s", r, pico_err, beautify_pico_error(pico_err));
 			// This is a peciliarity of the picoTCP network stack, if we receive no error code, and the size of 
 			// the byte stream written is 0, this is an indication that the buffer for this pico_socket is too small
 			// DEBUG_ERROR("pico_socket buffer is too small (adjust ZT_STACK_SOCKET_TX_SZ, ZT_STACK_SOCKET_RX_SZ)");
@@ -386,7 +416,44 @@ namespace ZeroTier {
 
 	void picoTCP::pico_cb_socket_ev(uint16_t ev, struct pico_socket *s)
 	{
+		int err = 0;
 		//DEBUG_EXTRA("s=%p, s->state=%d %s", s, s->state, beautify_pico_state(s->state));
+
+		// --- handle error events ---
+
+		// PICO_SOCK_EV_FIN - triggered when the socket is closed. No further communication is
+		// possible from this point on the socket.
+		if (ev & PICO_SOCK_EV_FIN) {
+			DEBUG_EXTRA("PICO_SOCK_EV_FIN (socket closed), picosock=%p", s);
+			//DEBUG_EXTRA("PICO_SOCK_EV_FIN (socket closed), picosock=%p, vs=%p, app_fd=%d, sdk_fd=%d", s, vs, vs->app_fd, vs->sdk_fd);
+			//vs->closure_ts = std::time(nullptr);	
+		}
+
+		// PICO_SOCK_EV_ERR - triggered when an error occurs.
+		if (ev & PICO_SOCK_EV_ERR) {
+			if(pico_err == PICO_ERR_ECONNRESET) {
+				DEBUG_ERROR("PICO_ERR_ECONNRESET");
+			}
+			//DEBUG_ERROR("PICO_SOCK_EV_ERR, err=%s, picosock=%p, app_fd=%d, sdk_fd=%d", 
+			//	beautify_pico_error(pico_err), s, vs->app_fd, vs->sdk_fd); 
+		}
+		// PICO_SOCK_EV_CLOSE - triggered when a FIN segment is received (TCP only). This event
+		// indicates that the oher endpont has closed the VirtualSocket, so the local TCP layer is only
+		// allowed to send new data until a local shutdown or close is initiated. PicoTCP is able to
+		// keep the VirtualSocket half-open (only for sending) after the FIN packet has been received,
+		// allowing new data to be sent in the TCP CLOSE WAIT state.
+		if (ev & PICO_SOCK_EV_CLOSE) {
+			if((err = pico_socket_close(s)) < 0) {
+				DEBUG_ERROR("pico_socket_close()=%d, pico_err=%d, %s", err, pico_err, beautify_pico_error(pico_err));
+			}
+			DEBUG_EXTRA("PICO_SOCK_EV_CLOSE (socket closure) err=%d (%s), picosock=%p", pico_err, beautify_pico_error(pico_err), s);
+			//DEBUG_EXTRA("PICO_SOCK_EV_CLOSE (socket closure) err = %d, picosock=%p, vs=%p, app_fd=%d, sdk_fd=%d", err, s, vs, vs->app_fd, vs->sdk_fd);            
+			//vs->closure_ts = std::time(nullptr);	
+			return;
+		}
+
+		// --- handle non-error events ---
+
 		VirtualBindingPair *vbp = (VirtualBindingPair*)(s->priv);
 		if(!vbp) {
 			DEBUG_ERROR("s->priv yielded no valid VirtualBindingPair");
@@ -395,7 +462,6 @@ namespace ZeroTier {
 		}
 		VirtualTap *tap = static_cast<VirtualTap*>(vbp->tap);
 		VirtualSocket *vs = static_cast<VirtualSocket*>(vbp->vs);
-		int err = 0;
 		if(!vs) {
 			DEBUG_ERROR("invalid VirtualSocket");
 			handle_general_failure();
@@ -406,7 +472,7 @@ namespace ZeroTier {
 		// has been established, or on a listening socket, indicating that a call to pico socket accept
 		// may now be issued in order to accept the incoming VirtualSocket from a remote host.
 		if (ev & PICO_SOCK_EV_CONN) {
-			//DEBUG_EXTRA("PICO_SOCK_EV_CONN");
+			DEBUG_EXTRA("PICO_SOCK_EV_CONN");
 			if(vs->state == ZT_SOCK_STATE_LISTENING)
 			{
 				uint16_t port;
@@ -420,9 +486,8 @@ namespace ZeroTier {
 				if(vs->socket_family == AF_INET6) { // NOTE: p->net->proto_number == PICO_PROTO_IPV4
 					client_psock = pico_socket_accept(s, &orig6, &port);
 				}
-
 				if(!client_psock) {
-					DEBUG_ERROR("pico_err=%s, picosock=%p", beautify_pico_error(pico_err), s);
+					DEBUG_ERROR("pico_socket_accept(): pico_socket=%p, pico_err=%d, %s", s, pico_err, beautify_pico_error(pico_err));
 					return;
 				}	
 
@@ -435,19 +500,21 @@ namespace ZeroTier {
 				new_vs->picosock = client_psock;
 				
 				// TODO: Condense this
-				char addrstr[INET6_ADDRSTRLEN];
 				if(vs->socket_family == AF_INET) {
-					struct sockaddr_in in4;
-					in4.sin_addr.s_addr = orig4.addr;
-					in4.sin_port = Utils::hton(port);
-					memcpy(&(new_vs->peer_addr), &in4, sizeof(new_vs->peer_addr));
-					inet_ntop(AF_INET, &(in4.sin_addr), addrstr, INET6_ADDRSTRLEN);
+					char addrstr[INET_ADDRSTRLEN];
+					struct sockaddr_storage ss4;
+					struct sockaddr_in *in4 = (struct sockaddr_in *)&ss4;
+					in4->sin_addr.s_addr = orig4.addr;
+					in4->sin_port = Utils::hton(port);
+					memcpy(&(new_vs->peer_addr), in4, sizeof(new_vs->peer_addr));
+					inet_ntop(AF_INET, &(in4->sin_addr), addrstr, INET_ADDRSTRLEN);
 					DEBUG_EXTRA("accepted connection from: %s : %d", addrstr, port);
 					ZeroTier::InetAddress inet;
 					inet.fromString(addrstr);
 					new_vs->tap = getTapByAddr(&inet); // assign to tap based on incoming address
 				}
 				if(vs->socket_family == AF_INET6) {
+					char addrstr[INET6_ADDRSTRLEN];
 					struct sockaddr_in6 in6;
 					memcpy(&(in6.sin6_addr.s6_addr), &orig6, sizeof(in6.sin6_addr.s6_addr));
 					in6.sin6_port = Utils::hton(port);
@@ -459,7 +526,7 @@ namespace ZeroTier {
 					new_vs->tap = getTapByAddr(&inet); // assign to tap based on incoming address
 				}
 				if(!new_vs->tap) {
-					DEBUG_ERROR("no valid VirtualTap could be found for this incoming connect address <%s>", addrstr);
+					DEBUG_ERROR("no valid VirtualTap could be found");
 					handle_general_failure();
 					return;
 				}
@@ -474,36 +541,6 @@ namespace ZeroTier {
 				vs->state = ZT_SOCK_STATE_UNHANDLED_CONNECTED;
 			}
 		}
-
-		// PICO_SOCK_EV_FIN - triggered when the socket is closed. No further communication is
-		// possible from this point on the socket.
-		if (ev & PICO_SOCK_EV_FIN) {
-			//DEBUG_EXTRA("PICO_SOCK_EV_FIN (socket closed), picosock=%p, vs=%p, app_fd=%d, sdk_fd=%d", s, vs, vs->app_fd, vs->sdk_fd);
-			vs->closure_ts = std::time(nullptr);	
-		}
-
-		// PICO_SOCK_EV_ERR - triggered when an error occurs.
-		if (ev & PICO_SOCK_EV_ERR) {
-			if(pico_err == PICO_ERR_ECONNRESET) {
-				DEBUG_ERROR("PICO_ERR_ECONNRESET");
-				vs->state = PICO_ERR_ECONNRESET;
-			}
-			DEBUG_ERROR("PICO_SOCK_EV_ERR, err=%s, picosock=%p, app_fd=%d, sdk_fd=%d", 
-				beautify_pico_error(pico_err), s, vs->app_fd, vs->sdk_fd); 
-		}
-		// PICO_SOCK_EV_CLOSE - triggered when a FIN segment is received (TCP only). This event
-		// indicates that the oher endpont has closed the VirtualSocket, so the local TCP layer is only
-		// allowed to send new data until a local shutdown or close is initiated. PicoTCP is able to
-		// keep the VirtualSocket half-open (only for sending) after the FIN packet has been received,
-		// allowing new data to be sent in the TCP CLOSE WAIT state.
-		if (ev & PICO_SOCK_EV_CLOSE) {
-			if((err = pico_socket_close(s)) < 0) {
-				DEBUG_ERROR("pico_socket_close()=%d, %s", err, beautify_pico_error(pico_err));
-			}
-			//DEBUG_INFO("PICO_SOCK_EV_CLOSE (socket closure) err = %d, picosock=%p, vs=%p, app_fd=%d, sdk_fd=%d", err, s, vs, vs->app_fd, vs->sdk_fd);            
-			vs->closure_ts = std::time(nullptr);	
-			return;
-		}
 		// PICO_SOCK_EV_RD - triggered when new data arrives on the socket. A new receive action
 		// can be taken by the socket owner because this event indicates there is new data to receive.
 		if (ev & PICO_SOCK_EV_RD) {
@@ -522,7 +559,6 @@ namespace ZeroTier {
 	int pico_eth_tx(struct pico_device *dev, void *buf, int len)
 	{
 		//_picostack_driver_lock.lock();
-		//DEBUG_INFO("len = %d", len);
 		VirtualTap *tap = static_cast<VirtualTap*>(dev->tap);
 		if(!tap) {
 			DEBUG_ERROR("invalid dev->tap");
@@ -536,8 +572,8 @@ namespace ZeroTier {
 		src_mac.setTo(ethhdr->saddr, 6);
 		dest_mac.setTo(ethhdr->daddr, 6);
 		if(ZT_DEBUG_LEVEL >= ZT_MSG_TRANSFER) {
-			char macBuf[18], nodeBuf[11];
-			mac2str(macBuf, sizeof(macBuf), ethhdr->daddr);
+			char macBuf[ZT_MAC_ADDRSTRLEN], nodeBuf[ZT_ID_LEN];
+			mac2str(macBuf, ZT_MAC_ADDRSTRLEN, ethhdr->daddr);
 			ZeroTier::MAC mac;
 			mac.setTo(ethhdr->daddr, 6);
 			mac.toAddress(tap->_nwid).toString(nodeBuf);
@@ -564,31 +600,34 @@ namespace ZeroTier {
 					ext/picotcp/build/include/pico_tcp.h:#define PICO_TCP_RSTACK    (PICO_TCP_RST | PICO_TCP_ACK)
 				*/
 				
-				char *flag_ptr = flagbuf;
+				if(hdr) {
+	 				char *flag_ptr = flagbuf;
 
-				if (hdr->flags & PICO_TCP_PSH) {
-					sprintf(flag_ptr, "PSH ");
-					flag_ptr+=4;
-				}
-				if (hdr->flags & PICO_TCP_SYN) {
-					sprintf(flag_ptr, "SYN ");
-					flag_ptr+=4;
-				}
-				if (hdr->flags & PICO_TCP_ACK) {
-					sprintf(flag_ptr, "ACK ");
-					flag_ptr+=4;				
-				}
-				if (hdr->flags & PICO_TCP_FIN) {
-					sprintf(flag_ptr, "FIN ");
-					flag_ptr+=4;
-				}
-				if (hdr->flags & PICO_TCP_RST) {
-					sprintf(flag_ptr, "RST ");
-					flag_ptr+=4;
+					if (hdr->flags & PICO_TCP_PSH) {
+						sprintf(flag_ptr, "PSH ");
+						flag_ptr+=4;
+					}
+					if (hdr->flags & PICO_TCP_SYN) {
+						sprintf(flag_ptr, "SYN ");
+						flag_ptr+=4;
+					}
+					if (hdr->flags & PICO_TCP_ACK) {
+						sprintf(flag_ptr, "ACK ");
+						flag_ptr+=4;				
+					}
+					if (hdr->flags & PICO_TCP_FIN) {
+						sprintf(flag_ptr, "FIN ");
+						flag_ptr+=4;
+					}
+					if (hdr->flags & PICO_TCP_RST) {
+						sprintf(flag_ptr, "RST ");
+						flag_ptr+=4;
+					}
 				}
 			}
 
-			//DEBUG_TRANS("len=%5d dst=%s [%s TX <-- %s] proto=0x%04x %s %s", len, macBuf, nodeBuf, tap->nodeId().c_str(), Utils::ntoh(ethhdr->proto), beautify_eth_proto_nums(Utils::ntoh(ethhdr->proto)), flagbuf);
+			DEBUG_TRANS("len=%5d dst=%s [%s TX <-- %s] proto=0x%04x %s %s", len, macBuf, nodeBuf, tap->nodeId().c_str(), 
+				Utils::ntoh(ethhdr->proto), beautify_eth_proto_nums(Utils::ntoh(ethhdr->proto)), flagbuf);
 		}
 		tap->_handler(tap->_arg,NULL,tap->_nwid,src_mac,dest_mac,
 			Utils::ntoh((uint16_t)ethhdr->proto),0, ((char*)buf) 
@@ -615,10 +654,10 @@ namespace ZeroTier {
 		from.copyTo(ethhdr.saddr, 6);
 		to.copyTo(ethhdr.daddr, 6);
 		ethhdr.proto = Utils::hton((uint16_t)etherType);
-		int newlen = len + sizeof(int) + sizeof(struct pico_eth_hdr);
+		int32_t msg_len = len + sizeof(int32_t) + sizeof(struct pico_eth_hdr);
 		
 		if(ZT_DEBUG_LEVEL >= ZT_MSG_TRANSFER) {
-			char macBuf[18], nodeBuf[11];
+			char macBuf[ZT_MAC_ADDRSTRLEN], nodeBuf[ZT_ID_LEN];
 			mac2str(macBuf, sizeof(macBuf), ethhdr.saddr);
 			ZeroTier::MAC mac;
 			mac.setTo(ethhdr.saddr, 6);
@@ -637,37 +676,39 @@ namespace ZeroTier {
 			{				
 				tcp_hdr_ptr = &ethhdr + PICO_SIZE_ETHHDR + PICO_SIZE_IP4HDR;
 				hdr = (struct pico_tcp_hdr *)tcp_hdr_ptr;
-
-				char *flag_ptr = flagbuf;
-				
-				if (hdr->flags & PICO_TCP_PSH) {
-					sprintf(flag_ptr, "PSH ");
-					flag_ptr+=4;
-				}
-				if (hdr->flags & PICO_TCP_SYN) {
-					sprintf(flag_ptr, "SYN ");
-					flag_ptr+=4;
-				}
-				if (hdr->flags & PICO_TCP_ACK) {
-					sprintf(flag_ptr, "ACK ");
-					flag_ptr+=4;				
-				}
-				if (hdr->flags & PICO_TCP_FIN) {
-					sprintf(flag_ptr, "FIN ");
-					flag_ptr+=4;
-				}
-				if (hdr->flags & PICO_TCP_RST) {
-					sprintf(flag_ptr, "RST ");
-					flag_ptr+=4;
+				if(hdr) {
+					char *flag_ptr = flagbuf;
+					
+					if (hdr->flags & PICO_TCP_PSH) {
+						sprintf(flag_ptr, "PSH ");
+						flag_ptr+=4;
+					}
+					if (hdr->flags & PICO_TCP_SYN) {
+						sprintf(flag_ptr, "SYN ");
+						flag_ptr+=4;
+					}
+					if (hdr->flags & PICO_TCP_ACK) {
+						sprintf(flag_ptr, "ACK ");
+						flag_ptr+=4;				
+					}
+					if (hdr->flags & PICO_TCP_FIN) {
+						sprintf(flag_ptr, "FIN ");
+						flag_ptr+=4;
+					}
+					if (hdr->flags & PICO_TCP_RST) {
+						sprintf(flag_ptr, "RST ");
+						flag_ptr+=4;
+					}
 				}
 			}
-			//DEBUG_TRANS("len=%5d src=%s [%s RX --> %s] proto=0x%04x %s %s", len, macBuf, nodeBuf, tap->nodeId().c_str(), etherType, beautify_eth_proto_nums(etherType), flagbuf);
+			DEBUG_TRANS("len=%5d src=%s [%s RX --> %s] proto=0x%04x %s %s", len, macBuf, nodeBuf, tap->nodeId().c_str(), 
+				etherType, beautify_eth_proto_nums(etherType), flagbuf);
 		}
 		// write virtual ethernet frame to guarded buffer (emptied by pico_eth_poll())
-		memcpy(tap->pico_frame_rxbuf + tap->pico_frame_rxbuf_tot, &newlen, sizeof(newlen));                      // size of frame + meta		
-		memcpy(tap->pico_frame_rxbuf + tap->pico_frame_rxbuf_tot + sizeof(newlen), &ethhdr, sizeof(ethhdr));     // new eth header
-		memcpy(tap->pico_frame_rxbuf + tap->pico_frame_rxbuf_tot + sizeof(newlen) + sizeof(ethhdr), data, len);  // frame data
-		tap->pico_frame_rxbuf_tot += newlen;
+		memcpy(tap->pico_frame_rxbuf + tap->pico_frame_rxbuf_tot, &msg_len, sizeof(int32_t));                     // size of frame + meta		
+		memcpy(tap->pico_frame_rxbuf + tap->pico_frame_rxbuf_tot + sizeof(int32_t), &ethhdr, sizeof(ethhdr));     // new eth header
+		memcpy(tap->pico_frame_rxbuf + tap->pico_frame_rxbuf_tot + sizeof(int32_t) + sizeof(ethhdr), data, len);  // frame data
+		tap->pico_frame_rxbuf_tot += msg_len;
 		//_picostack_driver_lock.unlock();
 	}
 
@@ -680,22 +721,21 @@ namespace ZeroTier {
 			handle_general_failure();
 			return ZT_ERR_GENERAL_FAILURE;
 		}
-		// TODO: Optimize
+		// TODO: Optimize (use Ringbuffer)
 		Mutex::Lock _l(tap->_pico_frame_rxbuf_m);
 		unsigned char frame[ZT_SDK_MTU];
-		int len, err = 0;
+		int32_t len, err = 0;
 		while (tap->pico_frame_rxbuf_tot > 0 && loop_score > 0) {
-			//DEBUG_FLOW(" [   FBUF -> STACK] Frame buffer SZ=%d", tap->pico_frame_rxbuf_tot);
 			memset(frame, 0, sizeof(frame));
 			len = 0;
-			memcpy(&len, tap->pico_frame_rxbuf, sizeof(len)); // get frame len
-			if(len > sizeof(len)) { // meaning, since we package the len in the msg, we don't want to recv a 0-(sizeof(int)) sized frame
-				//DEBUG_FLOW(" [   FBUF -> STACK]   Moving FRAME of size (%d) from FBUF(sz=%d) into stack",len, tap->pico_frame_rxbuf_tot-len);
-				memcpy(frame, tap->pico_frame_rxbuf + sizeof(len), len-(sizeof(len)) ); // get frame data
+			// get frame len
+			memcpy(&len, tap->pico_frame_rxbuf, sizeof(int32_t));
+			if(len > sizeof(int32_t)) { // meaning, since we package the len in the msg, we don't want to recv a 0-(sizeof(int32_t)) sized frame
+				memcpy(frame, tap->pico_frame_rxbuf + sizeof(int32_t), len-(sizeof(int32_t)) ); // get frame data
 				memmove(tap->pico_frame_rxbuf, tap->pico_frame_rxbuf + len, MAX_PICO_FRAME_RX_BUF_SZ-len); // shift buffer
-				if((err = pico_stack_recv(dev, (uint8_t*)frame, (len-sizeof(len)))) < 0) {
+				if((err = pico_stack_recv(dev, (uint8_t*)frame, (len-sizeof(int32_t)))) < 0) {
 					if(picostack) {
-						DEBUG_ERROR("pico_stack_recv()=%d, %s", err, picostack->beautify_pico_error(pico_err));
+						DEBUG_ERROR("pico_stack_recv(), err=%d, pico_err=%d, %s", err, pico_err, picostack->beautify_pico_error(pico_err));
 					}
 				}
 				tap->pico_frame_rxbuf_tot-=len;
@@ -727,33 +767,37 @@ namespace ZeroTier {
 				protocol_version = PICO_PROTO_IPV6;
 			
 			if(socket_type == SOCK_DGRAM) {
-				DEBUG_INFO("SOCK_DGRAM");
 				psock = pico_socket_open(
 					protocol_version, PICO_PROTO_UDP, &ZeroTier::picoTCP::pico_cb_socket_ev);
-				if(psock) { // configure size of UDP SND/RCV buffers
+				if(psock) { 
+					// configure size of UDP SND/RCV buffers
 					// TODO
 				}
 			}
-			if(socket_type == SOCK_STREAM) {		    	
+			if(socket_type == SOCK_STREAM) {	
 				psock = pico_socket_open(
 					protocol_version, PICO_PROTO_TCP, &ZeroTier::picoTCP::pico_cb_socket_ev);
-				if(psock) { // configure size of TCP SND/RCV buffers
+				if(psock) { 
+					// configure size of TCP SND/RCV buffers
 					int tx_buf_sz = ZT_STACK_TCP_SOCKET_TX_SZ;
 					int rx_buf_sz = ZT_STACK_TCP_SOCKET_RX_SZ;
 					int t_err = 0;
 
-					//int value = 1;
+					// int value = 1;
 					// pico_socket_setoption(psock, PICO_TCP_NODELAY, &value);
 
 					if((t_err = pico_socket_setoption(psock, PICO_SOCKET_OPT_SNDBUF, &tx_buf_sz)) < 0)
-						DEBUG_ERROR("unable to set SNDBUF size, err=%d, pico_err=%d", t_err, pico_err);
+						DEBUG_ERROR("unable to set SNDBUF size, err=%d, pico_err=%d, %s", 
+							t_err, pico_err, beautify_pico_error(pico_err));
 					if((t_err = pico_socket_setoption(psock, PICO_SOCKET_OPT_RCVBUF, &rx_buf_sz)) < 0)
-						DEBUG_ERROR("unable to set RCVBUF size, err=%d, pico_err=%d", t_err, pico_err);
-				   
+						DEBUG_ERROR("unable to set RCVBUF size, err=%d, pico_err=%d, %s", 
+							t_err, pico_err, beautify_pico_error(pico_err));
+
 					if(ZT_SOCK_BEHAVIOR_LINGER) {
 						int linger_time_ms = ZT_SOCK_BEHAVIOR_LINGER_TIME;
 						if((t_err = pico_socket_setoption(psock, PICO_SOCKET_OPT_LINGER, &linger_time_ms)) < 0)
-							DEBUG_ERROR("unable to set LINGER, err=%d, pico_err=%d", t_err, pico_err);
+							DEBUG_ERROR("unable to set LINGER, err=%d, pico_err=%d, %s", 
+								t_err, pico_err, beautify_pico_error(pico_err));
 					}
 				}
 			}
@@ -779,7 +823,9 @@ namespace ZeroTier {
 			uint32_t ipval = 0;
 			pico_string_to_ipv4(ipv4_str, &ipval);
 			zaddr.addr = ipval;
-			//DEBUG_EXTRA("connecting to addr=%s port=%d", ipv4_str, Utils::ntoh(in4->sin_port));
+			if(vs->socket_type == SOCK_STREAM) { // connect is an implicit call for non-connection-based VirtualSockets
+				DEBUG_EXTRA("connecting to addr=%s port=%d", ipv4_str, Utils::ntoh(in4->sin_port));
+			}
 			err = pico_socket_connect(vs->picosock, &zaddr, in4->sin_port);
 		}
 		if(vs->socket_family == AF_INET6) {
@@ -788,26 +834,22 @@ namespace ZeroTier {
 			char ipv6_str[INET6_ADDRSTRLEN];
 			inet_ntop(AF_INET6, &(in6->sin6_addr), ipv6_str, INET6_ADDRSTRLEN);
 			pico_string_to_ipv6(ipv6_str, zaddr.addr);
-			//DEBUG_EXTRA("connecting to addr=%s port=%d", ipv6_str, Utils::ntoh(in6->sin6_port));
+			if(vs->socket_type == SOCK_STREAM) {
+				DEBUG_EXTRA("connecting to addr=%s port=%d", ipv6_str, Utils::ntoh(in6->sin6_port));
+			}
 			err = pico_socket_connect(vs->picosock, &zaddr, in6->sin6_port);
 		}
 		if(err) {
-			DEBUG_ERROR("err=%d, %s", err, beautify_pico_error(pico_err));
+			DEBUG_ERROR("error connecting pico_socket=%p, err=%d, pico_err=%d, %s", 
+				vs->picosock, err, pico_err, beautify_pico_error(pico_err));
+			return map_pico_err_to_errno(pico_err);
 		}
 		memcpy(&(vs->peer_addr), &addr, sizeof(struct sockaddr_storage));
-
-		if(err == PICO_ERR_EPROTONOSUPPORT)
-			DEBUG_ERROR("PICO_ERR_EPROTONOSUPPORT");
-		if(err == PICO_ERR_EINVAL)
-			DEBUG_ERROR("PICO_ERR_EINVAL");
-		if(err == PICO_ERR_EHOSTUNREACH)
-			DEBUG_ERROR("PICO_ERR_EHOSTUNREACH");
 		return err;
 	}
 
 	int picoTCP::pico_Bind(VirtualSocket *vs, const struct sockaddr *addr, socklen_t addrlen)
 	{
-		//DEBUG_INFO();
 		if(!vs || !vs->picosock) {
 			DEBUG_ERROR("invalid vs or vs->picosock");
 			handle_general_failure();
@@ -837,49 +879,25 @@ namespace ZeroTier {
 			err = pico_socket_bind(vs->picosock, &pip6, (uint16_t *)&(in6->sin6_port));
 		}
 		if(err < 0) {
-			if(pico_err < 0)
-				DEBUG_ERROR("pico_err = %d", pico_err);
-			DEBUG_ERROR("unable to bind pico_socket(%p), err=%d", (vs->picosock), err);
-			if(err == PICO_ERR_EINVAL) {
-				DEBUG_ERROR("PICO_ERR_EINVAL - invalid argument");
-				errno = EINVAL;
-				return -1;
-			} 
-			if(err == PICO_ERR_ENOMEM) {
-				DEBUG_ERROR("PICO_ERR_ENOMEM - not enough space");
-				errno = ENOMEM;
-				return -1;			
-			} 
-			if(err == PICO_ERR_ENXIO) {
-				DEBUG_ERROR("PICO_ERR_ENXIO - no such device or address");
-				errno = ENXIO;
-				return -1;
-			}
+			DEBUG_ERROR("unable to bind pico_socket=%p, err=%d, pico_err=%d, %s", 
+				(vs->picosock), err, pico_err, beautify_pico_error(pico_err));
+			return map_pico_err_to_errno(pico_err);
 		}
 		return err;
 	}
 
 	int picoTCP::pico_Listen(VirtualSocket *vs, int backlog)
 	{
-		//DEBUG_INFO();
 		if(!vs || !vs->picosock) {
 			DEBUG_ERROR("invalid vs or vs->picosock");
 			handle_general_failure();
 			return ZT_ERR_GENERAL_FAILURE;
 		}
 		int err = 0;
-		if((err = pico_socket_listen(vs->picosock, backlog)) < 0)
-		{
-			if(err == PICO_ERR_EINVAL) {
-				DEBUG_ERROR("PICO_ERR_EINVAL");
-				errno = EINVAL;
-				return -1;
-			}
-			if(err == PICO_ERR_EISCONN) {
-				DEBUG_ERROR("PICO_ERR_EISCONN");
-				errno = EISCONN;
-				return -1;
-			}
+		if((err = pico_socket_listen(vs->picosock, backlog)) < 0) {
+			DEBUG_ERROR("error putting pico_socket=%p into listening state. err=%d, pico_err=%d, %s", 
+				vs->picosock, err, pico_err, beautify_pico_error(pico_err));
+			return map_pico_err_to_errno(pico_err);
 		}
 		vs->state = ZT_SOCK_STATE_LISTENING;
 		return ZT_ERR_OK;
@@ -936,7 +954,7 @@ namespace ZeroTier {
 		if(vs->socket_type == SOCK_DGRAM) {
 			int r;
 			if((r = pico_socket_write(vs->picosock, data, len)) < 0) {
-				DEBUG_ERROR("unable to write to picosock=%p, err=%d (%s)", 
+				DEBUG_ERROR("unable to write to picosock=%p, err=%d, pico_err=%d, %s", 
 					vs->picosock, r, pico_err, beautify_pico_error(pico_err));
 				err = -1;
 			}
@@ -962,7 +980,8 @@ namespace ZeroTier {
 			int txsz = vs->TXbuf->count();
 			int r, max_write_len = std::min(std::min(txsz, ZT_SDK_MTU),ZT_STACK_SOCKET_WR_MAX);			
 			if((r = pico_socket_write(vs->picosock, vs->TXbuf->get_buf(), max_write_len)) < 0) {
-				DEBUG_ERROR("unable to write to picosock=%p, r=%d", vs->picosock, r);
+				DEBUG_ERROR("unable to write to picosock=%p, err=%d, pico_err=%d, %s", 
+					vs->picosock, r, pico_err, beautify_pico_error(pico_err));
 				err = -1;
 			}
 			else {
@@ -971,7 +990,12 @@ namespace ZeroTier {
 			if(r>0){
 				vs->TXbuf->consume(r);
 			}
-			DEBUG_TRANS("[ TCP TX -> STACK] :: vs=%p, len=%d", vs, r);
+			if(vs->socket_type == SOCK_STREAM) {
+				DEBUG_TRANS("len=%5d, [app(buf) --> network_stack(vs=%p)] proto=0x%04x (TCP)", r, vs, PICO_PROTO_TCP);
+			}
+			if(vs->socket_type == SOCK_DGRAM) {
+				DEBUG_TRANS("len=%5d, [app(buf) --> network_stack(vs=%p)] proto=0x%04x (TCP)", r, vs, PICO_PROTO_UDP);
+			}
 		}
 		return err;
 	}
@@ -983,7 +1007,7 @@ namespace ZeroTier {
 			handle_general_failure();
 			return ZT_ERR_GENERAL_FAILURE;		
 		}
-		DEBUG_INFO("vs=%p, picosock=%p, fd=%d", vs, vs->picosock, vs->app_fd);
+		DEBUG_EXTRA("vs=%p, picosock=%p, fd=%d", vs, vs->picosock, vs->app_fd);
 		if(!vs || !vs->picosock)
 			return ZT_ERR_GENERAL_FAILURE;
 		int err = 0;
@@ -992,11 +1016,47 @@ namespace ZeroTier {
 			return ZT_ERR_OK;
 		if((err = pico_socket_close(vs->picosock)) < 0) {
 			errno = pico_err;
-			DEBUG_ERROR("error closing pico_socket(%p)", (void*)(vs->picosock));
+			DEBUG_ERROR("error closing pico_socket(%p), err=%d, pico_err=%s, %s", 
+				(void*)(vs->picosock), err, pico_err, beautify_pico_error(pico_err));
 		}
 		return err;
 	}
 
+	int picoTCP::map_pico_err_to_errno(int err)
+	{
+		if(err == PICO_ERR_NOERR) { errno = 0; return 0; } //
+		if(err == PICO_ERR_EPERM) { errno = ENXIO; }
+		if(err == PICO_ERR_ENOENT) { errno = ENXIO; }
+		if(err == PICO_ERR_EINTR) { errno = ENXIO; }
+		if(err == PICO_ERR_EIO) { errno = ENXIO; }
+		if(err == PICO_ERR_ENXIO) { errno = ENXIO; } //
+		if(err == PICO_ERR_EAGAIN) { errno = ENXIO; }
+		if(err == PICO_ERR_ENOMEM) { errno = ENOMEM; } //
+		if(err == PICO_ERR_EACCESS) { errno = ENXIO; }
+		if(err == PICO_ERR_EFAULT) { errno = ENXIO; }
+		if(err == PICO_ERR_EBUSY) { errno = ENXIO; }
+		if(err == PICO_ERR_EEXIST) { errno = ENXIO; }
+		if(err == PICO_ERR_EINVAL) { errno = EINVAL; } //
+		if(err == PICO_ERR_ENONET) { errno = ENXIO; }
+		if(err == PICO_ERR_EPROTO) { errno = ENXIO; }
+		if(err == PICO_ERR_ENOPROTOOPT) { errno = ENXIO; }
+		if(err == PICO_ERR_EPROTONOSUPPORT) { errno = ENXIO; }
+		if(err == PICO_ERR_EOPNOTSUPP) { errno = ENXIO; }
+		if(err == PICO_ERR_EADDRINUSE) { errno = ENXIO; }
+		if(err == PICO_ERR_EADDRNOTAVAIL) { errno = ENXIO; }
+		if(err == PICO_ERR_ENETDOWN) { errno = ENXIO; }
+		if(err == PICO_ERR_ENETUNREACH) { errno = ENXIO; }
+		if(err == PICO_ERR_ECONNRESET) { errno = ENXIO; }
+		if(err == PICO_ERR_EISCONN) { errno = ENXIO; }
+		if(err == PICO_ERR_ENOTCONN) { errno = ENXIO; }
+		if(err == PICO_ERR_ESHUTDOWN) { errno = ENXIO; }
+		if(err == PICO_ERR_ETIMEDOUT) { errno = ENXIO; }
+		if(err == PICO_ERR_ECONNREFUSED) { errno = ENXIO; }
+		if(err == PICO_ERR_EHOSTDOWN) { errno = ENXIO; }
+		if(err == PICO_ERR_EHOSTUNREACH) { errno = ENXIO; }
+		return -1;
+	}
+
 	char *picoTCP::beautify_pico_error(int err)
 	{
 		if(err==  0) return (char*)"PICO_ERR_NOERR";
@@ -1005,17 +1065,17 @@ namespace ZeroTier {
 		// ...
 		if(err==  4) return (char*)"PICO_ERR_EINTR";
 		if(err==  5) return (char*)"PICO_ERR_EIO";
-		if(err==  6) return (char*)"PICO_ERR_ENXIO";
+		if(err==  6) return (char*)"PICO_ERR_ENXIO (no such device or address)";
 		// ...
 		if(err== 11) return (char*)"PICO_ERR_EAGAIN";
-		if(err== 12) return (char*)"PICO_ERR_ENOMEM";
+		if(err== 12) return (char*)"PICO_ERR_ENOMEM (not enough space)";
 		if(err== 13) return (char*)"PICO_ERR_EACCESS";
 		if(err== 14) return (char*)"PICO_ERR_EFAULT";
 		// ...
 		if(err== 16) return (char*)"PICO_ERR_EBUSY";
 		if(err== 17) return (char*)"PICO_ERR_EEXIST";
 		// ...
-		if(err== 22) return (char*)"PICO_ERR_EINVAL";
+		if(err== 22) return (char*)"PICO_ERR_EINVAL (invalid argument)";
 		// ...
 		if(err== 64) return (char*)"PICO_ERR_ENONET";
 		// ...
diff --git a/src/picoTCP.hpp b/src/picoTCP.hpp
index 846fa31..09d51de 100644
--- a/src/picoTCP.hpp
+++ b/src/picoTCP.hpp
@@ -71,6 +71,7 @@
 #define PICO_IPV4_ROUTE_DEL_SIG struct pico_ip4 address, struct pico_ip4 netmask, int metric
 #define PICO_IPV6_ROUTE_ADD_SIG struct pico_ip6 address, struct pico_ip6 netmask, struct pico_ip6 gateway, int metric, struct pico_ipv6_link *link
 #define PICO_IPV6_ROUTE_DEL_SIG struct pico_ip6 address, struct pico_ip6 netmask, struct pico_ip6 gateway, int metric, struct pico_ipv6_link *link
+#define PICO_DNS_CLIENT_NAMESERVER_SIG pico_ip4*, unsigned char
 
 namespace ZeroTier
 {
@@ -111,6 +112,16 @@ namespace ZeroTier
 		 */
 		bool pico_route_del(VirtualTap *tap, const InetAddress &addr, const InetAddress &nm, int metric);
 		
+		/*
+		 * Registers a DNS nameserver with the network stack
+		 */
+		int pico_add_dns_nameserver(struct sockaddr *addr);
+
+		/*
+		 * Un-registers a DNS nameserver from the network stack
+		 */
+		int pico_del_dns_nameserver(struct sockaddr *addr);
+
 		/*
 		 * Main stack loop
 		 */
@@ -181,6 +192,11 @@ namespace ZeroTier
 		 */
 		int pico_Close(VirtualSocket *vs);
 
+		/*
+		 * Converts a pico_err to its most closely-related errno, and sets errno
+		 */
+		static int map_pico_err_to_errno(int err);
+
 		/*
 		 * Converts picoTCP error codes to pretty string
 		 */
diff --git a/test/selftest.cpp b/test/selftest.cpp
index df27d68..019e1ac 100644
--- a/test/selftest.cpp
+++ b/test/selftest.cpp
@@ -240,8 +240,9 @@ void RECORD_RESULTS(int *test_number, bool passed, char *details, std::vector<st
 // 
 void tcp_client_4(TCP_UNIT_TEST_SIG_4)
 {
-	std::string msg = "tcp_client_4";
-	fprintf(stderr, "\n\n%s\n\n", msg.c_str());
+	std::string testname = "tcp_client_4";
+	std::string msg = "tcp_cs_4";
+	fprintf(stderr, "\n\n%s\n\n", testname.c_str());
 	int r, w, sockfd, err, len = strlen(msg.c_str());
 	char rbuf[STR_SIZE];
 	memset(rbuf, 0, sizeof rbuf);
@@ -249,7 +250,6 @@ void tcp_client_4(TCP_UNIT_TEST_SIG_4)
 		DEBUG_ERROR("error creating ZeroTier socket");
 	if((err = zts_connect(sockfd, (const struct sockaddr *)addr, sizeof(addr))) < 0)
 		DEBUG_ERROR("error connecting to remote host (%d)", err);
-
 	// TODO: Put this test in the general API section
 	struct sockaddr_storage peer_addr;
 	struct sockaddr_in *in4 = (struct sockaddr_in*)&peer_addr;
@@ -263,15 +263,16 @@ void tcp_client_4(TCP_UNIT_TEST_SIG_4)
 	DEBUG_TEST("Received : %s", rbuf);
 	sleep(WAIT_FOR_TRANSMISSION_TO_COMPLETE);
 	err = zts_close(sockfd);
-	sprintf(details, "%s, n=%d, err=%d, r=%d, w=%d", msg.c_str(), count, err, r, w);
+	sprintf(details, "%s, n=%d, err=%d, r=%d, w=%d", testname.c_str(), count, err, r, w);
 	*passed = (w == len && r == len && !err) && !strcmp(rbuf, msg.c_str());
 }
 
 //
 void tcp_server_4(TCP_UNIT_TEST_SIG_4)
 {
-	std::string msg = "tcp_server_4";
-	fprintf(stderr, "\n\n%s\n\n", msg.c_str());	
+	std::string testname = "tcp_server_4";
+	std::string msg = "tcp_cs_4";
+	fprintf(stderr, "\n\n%s\n\n", testname.c_str());	
 	int w=0, r=0, sockfd, accfd, err, len = strlen(msg.c_str());
 	char rbuf[STR_SIZE];
 	memset(rbuf, 0, sizeof rbuf);
@@ -283,7 +284,6 @@ void tcp_server_4(TCP_UNIT_TEST_SIG_4)
 		printf("error placing socket in LISTENING state (%d)", err);
 	if((accfd = zts_accept(sockfd, (struct sockaddr *)&addr, (socklen_t *)sizeof(addr))) < 0)
 		DEBUG_ERROR("error accepting connection (%d)", err);
-
 	// TODO: Put this test in the general API section
 	struct sockaddr_storage peer_addr;
 	struct sockaddr_in *in4 = (struct sockaddr_in*)&peer_addr;
@@ -297,15 +297,16 @@ void tcp_server_4(TCP_UNIT_TEST_SIG_4)
 	sleep(WAIT_FOR_TRANSMISSION_TO_COMPLETE);
 	err = zts_close(sockfd);
 	err = zts_close(accfd);
-	sprintf(details, "%s, n=%d, err=%d, r=%d, w=%d", msg.c_str(), count, err, r, w);
+	sprintf(details, "%s, n=%d, err=%d, r=%d, w=%d", testname.c_str(), count, err, r, w);
 	*passed = (w == len && r == len && !err) && !strcmp(rbuf, msg.c_str());
 }
 
 // 
 void tcp_client_6(TCP_UNIT_TEST_SIG_6)
 {
-	std::string msg = "tcp_client_6";
-	fprintf(stderr, "\n\n%s\n\n", msg.c_str());
+	std::string testname = "tcp_client_6";
+	std::string msg = "tcp_cs_6";
+	fprintf(stderr, "\n\n%s\n\n", testname.c_str());
 	int r, w, sockfd, err, len = strlen(msg.c_str());
 	char rbuf[STR_SIZE];
 	memset(rbuf, 0, sizeof rbuf);
@@ -313,7 +314,6 @@ void tcp_client_6(TCP_UNIT_TEST_SIG_6)
 		DEBUG_ERROR("error creating ZeroTier socket");
 	if((err = zts_connect(sockfd, (const struct sockaddr *)addr, sizeof(addr))) < 0)
 		DEBUG_ERROR("error connecting to remote host (%d)", err);
-
 	// TODO: Put this test in the general API section
 	struct sockaddr_storage peer_addr;
 	struct sockaddr_in6 *p6 = (struct sockaddr_in6*)&peer_addr;
@@ -327,7 +327,7 @@ void tcp_client_6(TCP_UNIT_TEST_SIG_6)
 	r = zts_read(sockfd, rbuf, len);
 	sleep(WAIT_FOR_TRANSMISSION_TO_COMPLETE);
 	err = zts_close(sockfd);
-	sprintf(details, "%s, n=%d, err=%d, r=%d, w=%d", msg.c_str(), count, err, r, w);
+	sprintf(details, "%s, n=%d, err=%d, r=%d, w=%d", testname.c_str(), count, err, r, w);
 	DEBUG_TEST("Sent     : %s", msg.c_str());
 	DEBUG_TEST("Received : %s", rbuf);
 	*passed = (w == len && r == len && !err) && !strcmp(rbuf, msg.c_str());
@@ -336,8 +336,9 @@ void tcp_client_6(TCP_UNIT_TEST_SIG_6)
 //
 void tcp_server_6(TCP_UNIT_TEST_SIG_6)
 {
-	std::string msg = "tcp_sever_6";
-	fprintf(stderr, "\n\n%s\n\n", msg.c_str());	
+	std::string testname = "tcp_sever_6";
+	std::string msg = "tcp_cs_6";
+	fprintf(stderr, "\n\n%s\n\n", testname.c_str());	
 	int w=0, r=0, sockfd, accfd, err, len = strlen(msg.c_str());
 	char rbuf[STR_SIZE];
 	memset(rbuf, 0, sizeof rbuf);
@@ -349,7 +350,6 @@ void tcp_server_6(TCP_UNIT_TEST_SIG_6)
 		DEBUG_ERROR("error placing socket in LISTENING state (%d)", err);
 	if((accfd = zts_accept(sockfd, (struct sockaddr *)&addr, (socklen_t *)sizeof(addr))) < 0)
 		DEBUG_ERROR("error accepting connection (%d)", err);
-	
 	// TODO: Put this test in the general API section
 	struct sockaddr_storage peer_addr;
 	struct sockaddr_in6 *p6 = (struct sockaddr_in6*)&peer_addr;
@@ -365,7 +365,7 @@ void tcp_server_6(TCP_UNIT_TEST_SIG_6)
 	sleep(WAIT_FOR_TRANSMISSION_TO_COMPLETE);
 	err = zts_close(sockfd);
 	err = zts_close(accfd);
-	sprintf(details, "%s, n=%d, err=%d, r=%d, w=%d", msg.c_str(), count, err, r, w);
+	sprintf(details, "%s, n=%d, err=%d, r=%d, w=%d", testname.c_str(), count, err, r, w);
 	*passed = (w == len && r == len && !err) && !strcmp(rbuf, msg.c_str());
 }
 
@@ -374,8 +374,9 @@ void tcp_server_6(TCP_UNIT_TEST_SIG_6)
 //
 void udp_client_4(UDP_UNIT_TEST_SIG_4)
 {
-	std::string msg = "udp_client_4";
-	fprintf(stderr, "\n\n%s\n\n", msg.c_str());	
+	std::string testname = "udp_client_4";
+	std::string msg = "udp_cs_4";
+	fprintf(stderr, "\n\n%s\n\n", testname.c_str());	
 	int r, w, sockfd, err, len = strlen(msg.c_str());
 	char rbuf[STR_SIZE];
 	memset(rbuf, 0, sizeof rbuf);
@@ -384,11 +385,11 @@ void udp_client_4(UDP_UNIT_TEST_SIG_4)
 		DEBUG_ERROR("error creating ZeroTier socket");
 	if((err = zts_fcntl(sockfd, F_SETFL, O_NONBLOCK) < 0))
 		std::cout << "error setting O_NONBLOCK (errno=" << strerror(errno) << ")" << std::endl;
-	fprintf(stderr, "sending UDP packets until I get a single response...\n");
+	DEBUG_INFO("sending UDP packets until I get a single response...\n");
 	if((err = zts_bind(sockfd, (struct sockaddr *)local_addr, sizeof(struct sockaddr_in)) < 0))
 		DEBUG_ERROR("error binding to interface (%d)", err);
 
-	struct sockaddr_in saddr;
+	struct sockaddr_storage saddr;
 	while(1) {
 		// tx
 		if((w = zts_sendto(sockfd, msg.c_str(), strlen(msg.c_str()), 0, (struct sockaddr *)remote_addr, sizeof(remote_addr))) < 0) {
@@ -402,8 +403,8 @@ void udp_client_4(UDP_UNIT_TEST_SIG_4)
     	if(r == strlen(msg.c_str())) {
     		sleep(WAIT_FOR_TRANSMISSION_TO_COMPLETE);
 			err = zts_close(sockfd);
-			DEBUG_INFO("%s, n=%d, err=%d, r=%d, w=%d\n", msg.c_str(), count, err, r, w);
-			sprintf(details, "%s, n=%d, err=%d, r=%d, w=%d", msg.c_str(), count, err, r, w);
+			DEBUG_INFO("%s, n=%d, err=%d, r=%d, w=%d\n", testname.c_str(), count, err, r, w);
+			sprintf(details, "%s, n=%d, err=%d, r=%d, w=%d", testname.c_str(), count, err, r, w);
 			DEBUG_TEST("Sent     : %s", msg.c_str());
 			DEBUG_TEST("Received : %s", rbuf);
 			*passed = (w == len && r == len && !err) && !strcmp(rbuf, msg.c_str());
@@ -414,8 +415,9 @@ void udp_client_4(UDP_UNIT_TEST_SIG_4)
 
 void udp_server_4(UDP_UNIT_TEST_SIG_4)
 {
-	std::string msg = "udp_server_4";
-	fprintf(stderr, "\n\n%s\n\n", msg.c_str());	
+	std::string testname = "udp_server_4";
+	std::string msg = "udp_cs_4";
+	fprintf(stderr, "\n\n%s\n\n", testname.c_str());	
 	int r, w, sockfd, err, len = strlen(msg.c_str());
 	char rbuf[STR_SIZE];
 	memset(rbuf, 0, sizeof rbuf);
@@ -426,32 +428,33 @@ void udp_server_4(UDP_UNIT_TEST_SIG_4)
 		DEBUG_ERROR("error binding to interface (%d)", err);    
     // rx
     DEBUG_INFO("waiting for UDP packet...");
-    struct sockaddr_in saddr;
+    struct sockaddr_storage saddr;
+    struct sockaddr_in *in4 = (struct sockaddr_in*)&saddr;
     int serverlen = sizeof(saddr);
     memset(&saddr, 0, sizeof(saddr));
-    r = zts_recvfrom(sockfd, rbuf, STR_SIZE, 0, (struct sockaddr *)&saddr, (socklen_t *)&serverlen);
+    r = zts_recvfrom(sockfd, rbuf, STR_SIZE, 0, (struct sockaddr *)in4, (socklen_t *)&serverlen);
     char addrstr[INET_ADDRSTRLEN];
-    inet_ntop(AF_INET, &(saddr.sin_addr), addrstr, INET_ADDRSTRLEN);
+    inet_ntop(AF_INET, &(in4->sin_addr), addrstr, INET_ADDRSTRLEN);
     // once we receive a UDP packet, spend 10 seconds sending responses in the hopes that the client will see
-    DEBUG_INFO("received DGRAM from %s : %d", inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
+    DEBUG_INFO("received DGRAM from %s : %d", inet_ntoa(in4->sin_addr), ntohs(in4->sin_port));
     DEBUG_INFO("sending DGRAM(s) to %s : %d", inet_ntoa(remote_addr->sin_addr), ntohs(remote_addr->sin_port));
     // tx
     long int tx_ti = get_now_ts();	
     while(1) {
     	sleep(1);
     	//DEBUG_INFO("sending UDP packet");
-		if((w = zts_sendto(sockfd, msg.c_str(), strlen(msg.c_str()), 0, (struct sockaddr *)remote_addr, sizeof(remote_addr))) < 0) {
+		if((w = zts_sendto(sockfd, msg.c_str(), len, 0, (struct sockaddr *)remote_addr, sizeof(remote_addr))) < 0) {
 			DEBUG_ERROR("error sending packet, err=%d", errno);
 		}
 		if(get_now_ts() >= tx_ti + 20000) {
-			DEBUG_INFO("get_now_ts()-tx_ti=%d\n", get_now_ts()-tx_ti);
+			DEBUG_INFO("get_now_ts()-tx_ti=%d", get_now_ts()-tx_ti);
 			break;
 		}
 	}
 	sleep(WAIT_FOR_TRANSMISSION_TO_COMPLETE);
 	//err = zts_close(sockfd);
-	DEBUG_INFO("%s, n=%d, err=%d, r=%d, w=%d\n", msg.c_str(), count, err, r, w);
-	sprintf(details, "%s, n=%d, err=%d, r=%d, w=%d", msg.c_str(), count, err, r, w);
+	DEBUG_INFO("%s, n=%d, err=%d, r=%d, w=%d\n", testname.c_str(), count, err, r, w);
+	sprintf(details, "%s, n=%d, err=%d, r=%d, w=%d", testname.c_str(), count, err, r, w);
 	DEBUG_TEST("Sent     : %s", msg.c_str());
 	DEBUG_TEST("Received : %s", rbuf);
 	*passed = (w == len && r == len && !err) && !strcmp(rbuf, msg.c_str());
@@ -460,8 +463,9 @@ void udp_server_4(UDP_UNIT_TEST_SIG_4)
 //
 void udp_client_6(UDP_UNIT_TEST_SIG_6)
 {
-	std::string msg = "udp_client_6";
-	fprintf(stderr, "\n\n%s\n\n", msg.c_str());
+	std::string testname = "udp_client_6";
+	std::string msg = "udp_cs_6";
+	fprintf(stderr, "\n\n%s\n\n", testname.c_str());
 	int r, w, sockfd, err, len = strlen(msg.c_str());
 	char rbuf[STR_SIZE];
 	memset(rbuf, 0, sizeof rbuf);
@@ -470,28 +474,29 @@ void udp_client_6(UDP_UNIT_TEST_SIG_6)
 		DEBUG_ERROR("error creating ZeroTier socket");
 	if((err = zts_fcntl(sockfd, F_SETFL, O_NONBLOCK) < 0))
 		std::cout << "error setting O_NONBLOCK (errno=" << strerror(errno) << ")" << std::endl;
-	DEBUG_INFO("[1] sending UDP packets until I get a single response...\n");
+	
+	DEBUG_INFO("[1] binding and sending UDP packets until I get a single response...");
 	if((err = zts_bind(sockfd, (struct sockaddr *)local_addr, sizeof(struct sockaddr_in6)) < 0))
 		DEBUG_ERROR("error binding to interface (%d)", err);
 
 	// start sending UDP packets in the hopes that at least one will be picked up by the server
-	struct sockaddr_in saddr;
+	struct sockaddr_storage saddr;
 	while(1) {
 		// tx
-		if((w = zts_sendto(sockfd, msg.c_str(), strlen(msg.c_str()), 0, (struct sockaddr *)remote_addr, sizeof(remote_addr))) < 0) {
+		if((w = zts_sendto(sockfd, msg.c_str(), len, 0, (struct sockaddr *)remote_addr, sizeof(remote_addr))) < 0) {
 			DEBUG_ERROR("error sending packet, err=%d", errno);
 		}
 		usleep(100000);
 		memset(rbuf, 0, sizeof(rbuf));
 		int serverlen = sizeof(remote_addr);
 		// rx
-    	r = zts_recvfrom(sockfd, rbuf, STR_SIZE, 0, (struct sockaddr *)&saddr, (socklen_t *)&serverlen);
-    	if(r == strlen(msg.c_str())) {
+    	r = zts_recvfrom(sockfd, rbuf, len, 0, (struct sockaddr *)&saddr, (socklen_t *)&serverlen);
+    	if(r == len) {
     		DEBUG_INFO("[2] complete");
     		sleep(WAIT_FOR_TRANSMISSION_TO_COMPLETE);
 			err = zts_close(sockfd);
-			DEBUG_INFO("%s, n=%d, err=%d, r=%d, w=%d\n", msg.c_str(), count, err, r, w);
-			sprintf(details, "%s, n=%d, err=%d, r=%d, w=%d", msg.c_str(), count, err, r, w);
+			DEBUG_INFO("%s, n=%d, err=%d, r=%d, w=%d", testname.c_str(), count, err, r, w);
+			sprintf(details, "%s, n=%d, err=%d, r=%d, w=%d", testname.c_str(), count, err, r, w);
 			DEBUG_TEST("Sent     : %s", msg.c_str());
 			DEBUG_TEST("Received : %s", rbuf);
 			*passed = (w == len && r == len && !err) && !strcmp(rbuf, msg.c_str());
@@ -502,8 +507,9 @@ void udp_client_6(UDP_UNIT_TEST_SIG_6)
 
 void udp_server_6(UDP_UNIT_TEST_SIG_6)
 {
-	std::string msg = "udp_server_6";
-	fprintf(stderr, "\n\n%s\n\n", msg.c_str());
+	std::string testname = "udp_server_6";
+	std::string msg = "udp_cs_6";
+	fprintf(stderr, "\n\n%s\n\n", testname.c_str());
 	int r, w, sockfd, err, len = strlen(msg.c_str());
 	char rbuf[STR_SIZE];
 	memset(rbuf, 0, sizeof rbuf);
@@ -513,16 +519,17 @@ void udp_server_6(UDP_UNIT_TEST_SIG_6)
 	if((err = zts_bind(sockfd, (struct sockaddr *)local_addr, sizeof(struct sockaddr_in6)) < 0))
 		DEBUG_ERROR("error binding to interface (%d)", err);    
     // rx
-    DEBUG_INFO("[1/4] waiting for UDP packet...\n");
-    struct sockaddr_in6 saddr;
+    DEBUG_INFO("[1/4] waiting for UDP packet to start test...");
+    struct sockaddr_storage saddr;
+    struct sockaddr_in6 *in6 = (struct sockaddr_in6*)&saddr;
     int serverlen = sizeof(saddr);
     memset(&saddr, 0, sizeof(saddr));
-    r = zts_recvfrom(sockfd, rbuf, STR_SIZE, 0, (struct sockaddr *)&saddr, (socklen_t *)&serverlen);
+    r = zts_recvfrom(sockfd, rbuf, len, 0, (struct sockaddr *)&saddr, (socklen_t *)&serverlen);
  
     char addrstr[INET6_ADDRSTRLEN], remote_addrstr[INET6_ADDRSTRLEN];
-    inet_ntop(AF_INET6, &(saddr.sin6_addr), addrstr, INET6_ADDRSTRLEN);
+    inet_ntop(AF_INET6, &(in6->sin6_addr), addrstr, INET6_ADDRSTRLEN);
     inet_ntop(AF_INET6, &(remote_addr->sin6_addr), remote_addrstr, INET6_ADDRSTRLEN);
-    DEBUG_INFO("[2/4] received DGRAM from %s : %d", addrstr, ntohs(saddr.sin6_port));
+    DEBUG_INFO("[2/4] received DGRAM from %s : %d", addrstr, ntohs(in6->sin6_port));
     DEBUG_INFO("[2/4] sending DGRAM(s) to %s : %d", remote_addrstr, ntohs(remote_addr->sin6_port));
     // once we receive a UDP packet, spend 10 seconds sending responses in the hopes that the client will see
     // tx
@@ -530,19 +537,18 @@ void udp_server_6(UDP_UNIT_TEST_SIG_6)
     while(1) {
     	usleep(100000);
     	//DEBUG_INFO("sending UDP packet");
-		if((w = zts_sendto(sockfd, msg.c_str(), strlen(msg.c_str()), 0, (struct sockaddr *)remote_addr, sizeof(remote_addr))) < 0) {
+		if((w = zts_sendto(sockfd, msg.c_str(), len, 0, (struct sockaddr *)remote_addr, sizeof(remote_addr))) < 0) {
 			DEBUG_ERROR("error sending packet, err=%d", errno);
 		}
 		if(get_now_ts() >= tx_ti + 20000) {
-			DEBUG_INFO("[3/4] get_now_ts()-tx_ti=%d\n", get_now_ts()-tx_ti);
+			DEBUG_INFO("[3/4] get_now_ts()-tx_ti=%d", get_now_ts()-tx_ti);
 			break;
 		}
 	}
-	DEBUG_INFO("[4/4] complete");
 	sleep(WAIT_FOR_TRANSMISSION_TO_COMPLETE);
 	//err = zts_close(sockfd);
-	DEBUG_INFO("%s, n=%d, err=%d, r=%d, w=%d\n", msg.c_str(), count, err, r, w);
-	sprintf(details, "%s, n=%d, err=%d, r=%d, w=%d", msg.c_str(), count, err, r, w);
+	DEBUG_INFO("[4/4] complete, %s, n=%d, err=%d, r=%d, w=%d\n", testname.c_str(), count, err, r, w);
+	sprintf(details, "%s, n=%d, err=%d, r=%d, w=%d", testname.c_str(), count, err, r, w);
 	DEBUG_TEST("Sent     : %s", msg.c_str());
 	DEBUG_TEST("Received : %s", rbuf);
 	*passed = (w == len && r == len && !err) && !strcmp(rbuf, msg.c_str());
@@ -557,8 +563,9 @@ void udp_server_6(UDP_UNIT_TEST_SIG_6)
 // Maintain transfer for count OR count
 void tcp_client_sustained_4(TCP_UNIT_TEST_SIG_4)
 {
-	std::string msg = "tcp_client_sustained_4";
-	fprintf(stderr, "\n\n%s\n\n", msg.c_str());
+	std::string testname = "tcp_client_sustained_4";
+	std::string msg = "tcp_sustained_4";
+	fprintf(stderr, "\n\n%s\n\n", testname.c_str());
 	int n=0, w=0, r=0, sockfd, err;	
 	char *rxbuf = (char*)malloc(count*sizeof(char));
 	char *txbuf = (char*)malloc(count*sizeof(char));
@@ -621,7 +628,7 @@ void tcp_client_sustained_4(TCP_UNIT_TEST_SIG_4)
 		float rx_rate = (float)count / (float)rx_dt;
 
 		sprintf(details, "%s, match=%d, n=%d, tx_dt=%.2f, rx_dt=%.2f, r=%d, w=%d, tx_rate=%.2f MB/s, rx_rate=%.2f MB/s", 
-			msg.c_str(), match, count, tx_dt, rx_dt, r, w, (tx_rate / float(ONE_MEGABYTE) ), (rx_rate / float(ONE_MEGABYTE) ));	
+			testname.c_str(), match, count, tx_dt, rx_dt, r, w, (tx_rate / float(ONE_MEGABYTE) ), (rx_rate / float(ONE_MEGABYTE) ));	
 
 		*passed = (r == count && w == count && match && err>=0);
 	}
@@ -634,11 +641,13 @@ void tcp_client_sustained_4(TCP_UNIT_TEST_SIG_4)
 // Maintain transfer for count OR count
 void tcp_client_sustained_6(TCP_UNIT_TEST_SIG_6)
 {
-	std::string msg = "tcp_server_sustained_6";
-	fprintf(stderr, "\n\n%s\n\n", msg.c_str());
+	std::string testname = "tcp_client_sustained_6";
+	std::string msg = "tcp_sustained_6";
+	fprintf(stderr, "\n\n%s\n\n", testname.c_str());
 	int n=0, w=0, r=0, sockfd, err;	
 	char *rxbuf = (char*)malloc(count*sizeof(char));
 	char *txbuf = (char*)malloc(count*sizeof(char));
+
 	generate_random_data(txbuf, count);
 
 	if((sockfd = zts_socket(AF_INET6, SOCK_STREAM, 0)) < 0)
@@ -699,7 +708,7 @@ void tcp_client_sustained_6(TCP_UNIT_TEST_SIG_6)
 		float rx_rate = (float)count / (float)rx_dt;
 
 		sprintf(details, "%s, match=%d, n=%d, tx_dt=%.2f, rx_dt=%.2f, r=%d, w=%d, tx_rate=%.2f MB/s, rx_rate=%.2f MB/s", 
-			msg.c_str(), msg.c_str(), match, count, tx_dt, rx_dt, r, w, (tx_rate / float(ONE_MEGABYTE) ), (rx_rate / float(ONE_MEGABYTE) ));	
+			testname.c_str(), msg.c_str(), match, count, tx_dt, rx_dt, r, w, (tx_rate / float(ONE_MEGABYTE) ), (rx_rate / float(ONE_MEGABYTE) ));	
 
 		*passed = (r == count && w == count && match && err>=0);
 	}
@@ -711,15 +720,16 @@ void tcp_client_sustained_6(TCP_UNIT_TEST_SIG_6)
 // Maintain transfer for count OR count
 void tcp_server_sustained_4(TCP_UNIT_TEST_SIG_4)
 {
-	std::string msg = "tcp_server_sustained_4";
-	fprintf(stderr, "\n\n%s\n\n", msg.c_str());
+	std::string testname = "tcp_server_sustained_4";
+	std::string msg = "tcp_sustained_4";
+	fprintf(stderr, "\n\n%s\n\n", testname.c_str());
 	int n=0, w=0, r=0, sockfd, accfd, err;
 	char *rxbuf = (char*)malloc(count*sizeof(char));
 	memset(rxbuf, 0, count);
 
 	if((sockfd = zts_socket(AF_INET, SOCK_STREAM, 0)) < 0)
 		DEBUG_ERROR("error creating ZeroTier socket");
-	if((err = zts_bind(sockfd, (struct sockaddr *)addr, (socklen_t)sizeof(struct sockaddr_in)) < 0))
+	if((err = zts_bind(sockfd, (struct sockaddr *)addr, (socklen_t)sizeof(addr)) < 0))
 		DEBUG_ERROR("error binding to interface (%d)", err);
 	if((err = zts_listen(sockfd, 1)) < 0)
 		DEBUG_ERROR("error placing socket in LISTENING state (%d)", err);
@@ -767,7 +777,7 @@ void tcp_server_sustained_4(TCP_UNIT_TEST_SIG_4)
 		float rx_rate = (float)count / (float)rx_dt;
 
 		sprintf(details, "%s, n=%d, tx_dt=%.2f, rx_dt=%.2f, r=%d, w=%d, tx_rate=%.2f MB/s, rx_rate=%.2f MB/s", 
-			msg.c_str(), count, tx_dt, rx_dt, r, w, (tx_rate / float(ONE_MEGABYTE) ), (rx_rate / float(ONE_MEGABYTE) ));
+			testname.c_str(), count, tx_dt, rx_dt, r, w, (tx_rate / float(ONE_MEGABYTE) ), (rx_rate / float(ONE_MEGABYTE) ));
 
 		*passed = (r == count && w == count && err>=0);
 	}
@@ -778,8 +788,9 @@ void tcp_server_sustained_4(TCP_UNIT_TEST_SIG_4)
 // Maintain transfer for count OR count
 void tcp_server_sustained_6(TCP_UNIT_TEST_SIG_6)
 {
-	std::string msg = "tcp_server_sustained_6";
-	fprintf(stderr, "\n\n%s\n\n", msg.c_str());
+	std::string testname = "tcp_server_sustained_6";
+	std::string msg = "tcp_sustained_6";
+	fprintf(stderr, "\n\n%s\n\n", testname.c_str());
 	int n=0, w=0, r=0, sockfd, accfd, err;
 	char *rxbuf = (char*)malloc(count*sizeof(char));
 	memset(rxbuf, 0, count);
@@ -832,7 +843,7 @@ void tcp_server_sustained_6(TCP_UNIT_TEST_SIG_6)
 		float rx_rate = (float)count / (float)rx_dt;
 
 		sprintf(details, "%s, n=%d, tx_dt=%.2f, rx_dt=%.2f, r=%d, w=%d, tx_rate=%.2f MB/s, rx_rate=%.2f MB/s", 
-			msg.c_str(), count, tx_dt, rx_dt, r, w, (tx_rate / float(ONE_MEGABYTE) ), (rx_rate / float(ONE_MEGABYTE) ));
+			testname.c_str(), count, tx_dt, rx_dt, r, w, (tx_rate / float(ONE_MEGABYTE) ), (rx_rate / float(ONE_MEGABYTE) ));
 
 		*passed = (r == count && w == count && err>=0);
 	}
@@ -841,8 +852,9 @@ void tcp_server_sustained_6(TCP_UNIT_TEST_SIG_6)
 
 void udp_client_sustained_4(TCP_UNIT_TEST_SIG_4)
 {
-	std::string msg = "udp_client_sustained_4";
-	fprintf(stderr, "\n\n%s\n\n", msg.c_str());
+	std::string testname = "udp_client_sustained_4";
+	std::string msg = "udp_sustained_4";
+	fprintf(stderr, "\n\n%s\n\n", testname.c_str());
 	int r, w, sockfd, err, len = strlen(msg.c_str());
 	char rbuf[STR_SIZE];
 	memset(rbuf, 0, sizeof rbuf);
@@ -858,7 +870,7 @@ void udp_client_sustained_4(TCP_UNIT_TEST_SIG_4)
 
 	sleep(WAIT_FOR_TRANSMISSION_TO_COMPLETE);
 	err = zts_close(sockfd);
-	sprintf(details, "%s, n=%d, err=%d, r=%d, w=%d", msg.c_str(), count, err, r, w);
+	sprintf(details, "%s, n=%d, err=%d, r=%d, w=%d", testname.c_str(), count, err, r, w);
 	DEBUG_TEST("Sent     : %s", msg.c_str());
 	DEBUG_TEST("Received : %s", rbuf);
 	*passed = (w == len && r == len && !err) && !strcmp(rbuf, msg.c_str());
@@ -866,8 +878,9 @@ void udp_client_sustained_4(TCP_UNIT_TEST_SIG_4)
 
 void udp_server_sustained_4(TCP_UNIT_TEST_SIG_4)
 {
-	std::string msg = "udp_server_sustained_4";
-	fprintf(stderr, "\n\n%s\n\n", msg.c_str());	
+	std::string testname = "udp_server_sustained_4";
+	std::string msg = "udp_sustained_4";
+	fprintf(stderr, "\n\n%s\n\n", testname.c_str());	
 	int r, w, sockfd, err, len = strlen(msg.c_str());
 	char rbuf[STR_SIZE];
 	memset(rbuf, 0, sizeof rbuf);
@@ -888,7 +901,7 @@ void udp_server_sustained_4(TCP_UNIT_TEST_SIG_4)
     w = r;
 	//sleep(WAIT_FOR_TRANSMISSION_TO_COMPLETE);
 	//err = zts_close(sockfd);
-	sprintf(details, "%s, n=%d, err=%d, r=%d, w=%d", msg.c_str(), count, err, r, w);
+	sprintf(details, "%s, n=%d, err=%d, r=%d, w=%d", testname.c_str(), count, err, r, w);
 	DEBUG_TEST("Sent     : %s", msg.c_str());
 	DEBUG_TEST("Received : %s", rbuf);
 	*passed = (w == len && r == len && !err) && !strcmp(rbuf, msg.c_str());
@@ -1524,11 +1537,19 @@ void test_bad_args()
 	DEBUG_TEST("SOCK_DGRAM = %d", SOCK_DGRAM);
 }
 
-void close_while_writing_test()
+void dns_test(struct sockaddr *addr)
 {
-	// TODO: Close a socket while another thread is writing to it or reading from it
+	fprintf(stderr, "\n\ndns_test\n\n");
+	zts_add_dns_nameserver(addr);
+	// resolve
+	zts_del_dns_nameserver(addr);
 }
 
+void close_while_writing_test()
+{
+	fprintf(stderr, "\n\nclose_while_writing_test\n\n");
+	// TODO: Close a socket while another thread is writing to it or reading from it
+}
 
 void* create_socket(void *arg)
 {
@@ -1553,6 +1574,7 @@ void* create_socket(void *arg)
 
 void multithread_socket_creation()
 {
+	fprintf(stderr, "\n\nmultithread_socket_creation\n\n");
 	/*
 	pthread_t tid[2];
 
@@ -1567,12 +1589,14 @@ void multithread_socket_creation()
 
 void multithread_rw()
 {
+	fprintf(stderr, "\n\nmultithread_rw\n\n");
 	// TODO: Test read/writes from multiple threads
 }
 
 // Tests rapid opening and closure of sockets
 void close_test(struct sockaddr *bind_addr)
 {
+	fprintf(stderr, "\n\nclose_test\n\n");
 	// BUG: While running an extended test of unassigned closures, the 
 	// stack may crash at: `pico_check_timers at pico_stack.c:608, this appears
 	// to be a bad pointer to a timer within the stack. 
@@ -1583,7 +1607,7 @@ void close_test(struct sockaddr *bind_addr)
 	{
 		int fd;
 		if((fd = zts_socket(AF_INET, SOCK_STREAM, 0)) < 0) {
-			DEBUG_INFO("error creating socket. sleeping until timers are released");
+			DEBUG_ERROR("error creating socket. sleeping until timers are released");
 			sleep(30);
 		}
 		if((err = zts_bind(fd, (struct sockaddr *)bind_addr, sizeof(struct sockaddr_in)) < 0)) { 
@@ -1600,10 +1624,10 @@ void close_test(struct sockaddr *bind_addr)
 
 void bind_to_localhost_test(int port)
 {
+	fprintf(stderr, "\n\nbind_to_localhost_test\n\n");
 	int fd, err = 0;
-
 	// ipv4, 0.0.0.0
-	struct sockaddr bind_addr;
+	struct sockaddr_storage bind_addr;
 	DEBUG_INFO("binding to 0.0.0.0");
 	create_addr("0.0.0.0", port, 4, (struct sockaddr *)&bind_addr);
 	if((fd = zts_socket(AF_INET, SOCK_STREAM, 0)) > 0) {
@@ -1623,6 +1647,7 @@ void bind_to_localhost_test(int port)
 
 	port++;
 
+	/*
 	// ipv4, 127.0.0.1
 	DEBUG_INFO("binding to 127.0.0.1");
 	create_addr("127.0.0.1", port, 4, (struct sockaddr *)&bind_addr);
@@ -1642,6 +1667,7 @@ void bind_to_localhost_test(int port)
 	}
 
 	port++;
+	*/
 
 	// ipv6, [::]
 	DEBUG_INFO("binding to [::]");
@@ -1670,7 +1696,7 @@ int main(int argc , char *argv[])
 {
 	if(argc < 5) {
 		fprintf(stderr, "usage: selftest <selftest.conf> <alice|bob|ted|carol> to <bob|alice|ted|carol>\n");
-		fprintf(stderr, "e.g. : selftest test/selftest.conf alice to bob\n");
+		fprintf(stderr, "e.g. : selftest test/test.conf alice to bob\n");
 		return 1;
 	}
 
@@ -1693,7 +1719,7 @@ int main(int argc , char *argv[])
 	std::string nwid, stype, path = argv[1];
 	std::string ipstr, ipstr6, local_ipstr, local_ipstr6, remote_ipstr, remote_ipstr6;
 
-	// loaf config file
+	// load config file
 	if(path.find(".conf") == std::string::npos) {
 		fprintf(stderr, "Possibly invalid conf file. Exiting...\n");
 		exit(0);
@@ -1734,7 +1760,7 @@ int main(int argc , char *argv[])
 
 	DEBUG_TEST("Waiting for libzt to come online...\n");
 	zts_simple_start(path.c_str(), nwid.c_str());
-	char device_id[11];
+	char device_id[ZT_ID_LEN];
 	zts_get_device_id(device_id);
 	DEBUG_TEST("I am %s, %s", device_id, me.c_str());
 	if(mode == TEST_MODE_SERVER)
@@ -1767,6 +1793,7 @@ int main(int argc , char *argv[])
 	struct sockaddr_storage local_addr;
 	struct sockaddr_storage remote_addr;
 
+
 // closure test
 
 /*
@@ -1775,17 +1802,35 @@ int main(int argc , char *argv[])
 	DEBUG_INFO("testing closures by binding to: %s", local_ipstr.c_str());
 	create_addr(local_ipstr, port, 4, (struct sockaddr *)&in4);
 	close_test((struct sockaddr*)&in4);
+	port++;
 */
 
-	close_while_writing_test();
+// Test adding, resolving, and removing a DNS server
+
+	ipv = 4;
+	create_addr(remote_ipstr, port, ipv, (struct sockaddr *)&remote_addr);
+	dns_test((struct sockaddr *)&remote_addr);
+
+//	close_while_writing_test();
 
 // localhost bind test
 
-	//bind_to_localhost_test(1000);
-
+//	bind_to_localhost_test(port);
 
 // Transmission Tests
 
+// RANDOM API TEST
+		//random_api_test();
+
+// SLAM API TEST
+		//slam_api_test();
+
+// BAD ARGS API TEST
+		//test_bad_args();
+
+// OBSCURE API TEST
+		//obscure_api_test();
+
 	port      = start_port;
 	delay     = 0;
 	count     = 1024*128;
@@ -1793,7 +1838,6 @@ int main(int argc , char *argv[])
 
 // ipv4 client/server (UDP)
 
-/*
 	ipv = 4;
 	if(mode == TEST_MODE_SERVER) {
 		create_addr(local_ipstr, port, ipv, (struct sockaddr *)&local_addr);
@@ -1822,8 +1866,6 @@ int main(int argc , char *argv[])
 	}
 	RECORD_RESULTS(&test_number, passed, details, &results);
 	port++;
-*/
-
 
 // ipv6 client/server (UDP)
 	ipv = 6;
@@ -1855,7 +1897,6 @@ int main(int argc , char *argv[])
 	RECORD_RESULTS(&test_number, passed, details, &results);
 	port++;
 
-exit(0);
 
 // ipv4 sustained transfer (UDP)
 	ipv = 4;		
@@ -1910,6 +1951,7 @@ exit(0);
 	port++;
 
 // ipv4 sustained transfer (TCP)
+	
 	ipv = 4;	
 	if(mode == TEST_MODE_SERVER) {
 		create_addr(local_ipstr, port, ipv, (struct sockaddr *)&local_addr);
@@ -2016,19 +2058,6 @@ exit(0);
 	}
 	*/
 
-// RANDOM API TEST
-		//random_api_test();
-
-// SLAM API TEST
-		//slam_api_test();
-
-// BAD ARGS API TEST
-		//test_bad_args();
-
-// OBSCURE API TEST
-		//obscure_api_test();
-
-
 	// Print results of all tests
 	printf("--------------------------------------------------------------------------------\n");
 	for(int i=0;i<results.size(); i++) {