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