[U-Boot] Subject: [PATCH 2/3] TCP and wget implementation. Patch V5, 2 of 3.

[Duncan Hare <dh@synoia.com>]

This is the TCP and Kconfig files for introducing TCP and wget
into u-boot.

All the code is new, and not copied from any source.

Makefile in the net directory is modified by hand. It appears not to be
generated by Kconfig.

 

Signed-off-by: Duncan Hare <DuncanCHare@yahoo.com>
---

 net/Makefile |   3 +-
 net/tcp.c    | 689 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 net/tcp.h    | 214 +++++++++++++++++++
 3 files changed, 905 insertions(+), 1 deletion(-)
 create mode 100644 net/tcp.c
 create mode 100644 net/tcp.h

diff --git a/net/Makefile b/net/Makefile
index ae54eee5af..f83df5b728 100644
--- a/net/Makefile
+++ b/net/Makefile
@@ -25,7 +25,8 @@ obj-$(CONFIG_CMD_PING) += ping.o
 obj-$(CONFIG_CMD_RARP) += rarp.o
 obj-$(CONFIG_CMD_SNTP) += sntp.o
 obj-$(CONFIG_CMD_NET)  += tftp.o
-
+obj-$(CONFIG_TCP)      += tcp.o
+obj-$(CONFIG_CMD_WGET) += wget.o
 # Disable this warning as it is triggered by:
 # sprintf(buf, index ? "foo%d" : "foo", index)
 # and this is intentional usage.
diff --git a/net/tcp.c b/net/tcp.c
new file mode 100644
index 0000000000..2ea6459c0b
--- /dev/null
+++ b/net/tcp.c
@@ -0,0 +1,689 @@
+/*
+ *	Copyright 2017 Duncan Hare, all rights reserved.
+ */
+
+/*
+ * General Desription:
+ *
+ * TCP support for the wget command, for fast file downloading.
+ *
+ * HTTP/TCP Receiver:
+ *
+ *      Prequeisites:   - own ethernet address
+ *                      - own IP address
+ *                      - Server IP address
+ *                      - HTP client
+ *                      - Bootfile path & name
+ *      We want:        - Load the Boot file
+ *      Next Step       HTTPS?
+ */
+#include <common.h>
+#include <command.h>
+#include <console.h>
+#include <environment.h>
+#include <errno.h>
+#include <net.h>
+#include "tcp.h"
+#include "wget.h"
+
+/* TCP sliding window  control  */
+/* used by us to request re-TX	*/
+
+static struct tcp_sack_v tcp_lost;
+
+/* TCP option timestamp */
+static u32 loc_timestamp;
+static u32 rmt_timestamp;
+
+/* Search for TCP_SACK and review the
+ * comments before the code section
+ */
+
+#define TCP_SACK u8
+TCP_SACK tcp_edge;
+
+/* TCP connection state */
+static enum TCP_STATE tcp_state;
+
+/*
+ * An incoming TCP packet handler for the TCP protocol.
+ * There is also a dymanic function pointer for TCP based commads to
+ * receive incoming traffic after the TCP protocol code has done its work.
+ */
+
+/* Current TCP RX packet handler */
+static rxhand_tcp *tcp_packet_handler;
+
+enum TCP_STATE tcp_get_tcp_state(void)
+{
+	return tcp_state;
+}
+
+void tcp_set_tcp_state(enum TCP_STATE new_state)
+{
+	tcp_state = new_state;
+}
+
+void tcp_print_buffer(uchar raw[], int pkt_len, int payload_len,
+		      int hdr_len, bool hide)
+{
+	int i;
+
+	for (i = pkt_len - payload_len; i < pkt_len; i++) {
+		if (i <= hdr_len)
+			printf("%02X", raw[i]);
+		else if ((raw[i] > 0x19) && (raw[i] < 0x7f))
+			putc(raw[i]);
+		else if (hide == 0)
+			putc(raw[i]);
+		else
+			printf("%02X", raw[i]);
+	}
+	printf("%s", "\n");
+}
+
+int tcp_find_in_buffer(uchar raw[], int payload_len, uchar field[],
+		       int field_len)
+{
+	int i, j;
+
+	for (i = 0; i < payload_len; i++) {
+		if (raw[i] == field[0]) {
+			for (j = 1; j < field_len; j++) {
+				if (raw[i + j] != field[j])
+					break;
+			if (j == field_len)
+				return i;
+			}
+		}
+	}
+	return 0;
+}
+
+static void dummy_handler(uchar *pkt, unsigned int dport,
+			  struct in_addr sip, unsigned int sport,
+			  unsigned int len)
+{
+}
+
+void tcp_set_tcp_handler(rxhand_tcp *f)
+{
+	debug_cond(DEBUG_INT_STATE, "--- net_loop TCP handler set (%p)\n", f);
+	if (!f)
+		tcp_packet_handler = dummy_handler;
+	else
+		tcp_packet_handler = f;
+}
+
+u16 tcp_set_pseudo_header(uchar *pkt, struct in_addr src, struct in_addr dest,
+			  int tcp_len, int pkt_len)
+{
+	union tcp_build_pkt *b = (union tcp_build_pkt *)pkt;
+	int checksum_len;
+
+	/*
+	 * Pseudo header
+	 *
+	 * Zero the byte after the last byte so that the header checksum
+	 * will always work.
+	 */
+
+	pkt[pkt_len] = 0x00;
+
+	net_copy_ip((void *)&b->ph.p_src, &src);
+	net_copy_ip((void *)&b->ph.p_dst, &dest);
+	b->ph.rsvd	= 0x00;
+	b->ph.p		= IPPROTO_TCP;
+	b->ph.len	= htons(tcp_len);
+	checksum_len	= tcp_len + PSEUDO_HDR_SIZE;
+
+		debug_cond(DEBUG_DEV_PKT,
+			   "TCP Pesudo  Header  (to=%pI4, from=%pI4, Len=%d)\n",
+			   &b->ph.p_dst, &b->ph.p_src, checksum_len);
+
+	return compute_ip_checksum(pkt + PSEUDO_PAD_SIZE, checksum_len);
+}
+
+int net_set_ack_options(union tcp_build_pkt *b)
+{
+	b->sack.hdr.tcp_hlen  = (TCP_HDR_SIZE >> 2) << 4;
+
+	b->sack.t_opt.kind		= TCP_O_TS;
+	b->sack.t_opt.len		= TCP_OPT_LEN_A;
+	b->sack.t_opt.t_snd		= htons(loc_timestamp);
+	b->sack.t_opt.t_rcv		= rmt_timestamp;
+	b->sack.sack_v.kind             = 0x01;
+	b->sack.sack_v.len		= 0x00;
+
+	if (tcp_lost.len > TCP_OPT_LEN_2) {
+		debug_cond(DEBUG_DEV_PKT, "TCP ack opt lost.len %x\n",
+			   tcp_lost.len);
+		b->sack.sack_v.len              = tcp_lost.len;
+		b->sack.sack_v.kind		= TCP_V_SACK;
+		b->sack.sack_v.hill[0].l = htonl(tcp_lost.hill[1].l);
+		b->sack.sack_v.hill[0].r = htonl(tcp_lost.hill[1].r);
+
+		/*
+		 * These SACK structures are initialized with NOPs to
+		 * provide TCP header alignment padding. There are 4
+		 * SACK structures used for both header padding and
+		 * internally.
+		 */
+
+		b->sack.sack_v.hill[1].l = htonl(tcp_lost.hill[2].l);
+		b->sack.sack_v.hill[1].r = htonl(tcp_lost.hill[2].r);
+		b->sack.sack_v.hill[2].l = htonl(tcp_lost.hill[3].l);
+		b->sack.sack_v.hill[2].r = htonl(tcp_lost.hill[3].r);
+		b->sack.sack_v.hill[3].l = TCP_O_NOP;
+		b->sack.sack_v.hill[3].r = TCP_O_NOP;
+	}
+
+	b->sack.hdr.tcp_hlen = (((TCP_HDR_SIZE + TCP_TSOPT_SIZE
+				+ tcp_lost.len + 3)  >> 2) << 4);
+	return b->sack.hdr.tcp_hlen >> 2;
+}
+
+void net_set_syn_options(union tcp_build_pkt *b)
+{
+	tcp_lost.len		= 0;
+	b->ip.hdr.tcp_hlen      = 0xa0;
+
+	b->ip.mss.kind          = TCP_O_MSS;
+	b->ip.mss.len           = TCP_OPT_LEN_4;
+	b->ip.mss.mss           = htons(TCP_MSS);
+	b->ip.scale.kind        = TCP_O_SCL;
+	b->ip.scale.scale       = TCP_SCALE;
+	b->ip.scale.len         = TCP_OPT_LEN_3;
+	b->ip.sack_p.kind       = TCP_P_SACK;
+	b->ip.sack_p.len        = TCP_OPT_LEN_2;
+	b->ip.t_opt.kind        = TCP_O_TS;
+	b->ip.t_opt.len         = TCP_OPT_LEN_A;
+	loc_timestamp           = get_ticks() % 3072;
+	rmt_timestamp           = 0x00000000;
+	b->ip.t_opt.t_snd       = 0;
+	b->ip.t_opt.t_rcv       = 0x00000000;
+	b->ip.end               = TCP_O_END;
+}
+
+int tcp_set_tcp_header(uchar *pkt, int dport, int sport, int payload_len,
+		       u8 action, u32 tcp_seq_num, u32 tcp_ack_num)
+{
+	union tcp_build_pkt *b = (union tcp_build_pkt *)pkt;
+	int	pkt_hdr_len;
+	int	pkt_len;
+	int	tcp_len;
+
+	b->ip.hdr.tcp_flags	= action;
+	pkt_hdr_len		= IP_TCP_HDR_SIZE;
+	b->ip.hdr.tcp_hlen      = 0x50;		/* Header is 5 32 bit words  */
+						/* 4 bits TCP header Length/4*/
+						/* 4 bits Reserved           */
+						/* For options		     */
+	switch (action) {
+	case TCP_SYN:
+		debug_cond(DEBUG_DEV_PKT,
+			   "TCP Hdr:SYN (%pI4, %pI4, sq=%d, ak=%d)\n",
+			   &net_server_ip, &net_ip,
+			   tcp_seq_num, tcp_ack_num);
+
+		net_set_syn_options(b);
+		tcp_seq_num = 0;
+		tcp_ack_num = 0;
+		pkt_hdr_len = IP_TCP_O_SIZE;
+		if (tcp_state == TCP_SYN_SENT) {  /* Too many sins */
+			action    = TCP_FIN;
+			tcp_state = TCP_FIN_WAIT_1;
+		} else {
+			tcp_state = TCP_SYN_SENT;
+		}
+	break;
+	case TCP_ACK:
+		pkt_hdr_len         = IP_HDR_SIZE + net_set_ack_options(b);
+		b->ip.hdr.tcp_flags = action;
+		debug_cond(DEBUG_DEV_PKT,
+			   "TCP Hdr:ACK (%pI4, %pI4, s=%d, a=%d, A=%x)\n",
+			   &net_server_ip, &net_ip, tcp_seq_num, tcp_ack_num,
+			   action);
+	break;
+	case TCP_FIN:
+		debug_cond(DEBUG_DEV_PKT,
+			   "TCP Hdr:FIN  (%pI4, %pI4, s=%d, a=%d)\n",
+			   &net_server_ip, &net_ip, tcp_seq_num, tcp_ack_num);
+		payload_len = 0;
+		pkt_hdr_len = IP_TCP_HDR_SIZE;
+		tcp_state   = TCP_FIN_WAIT_1;
+
+	break;				 /* Notify connection closing */
+	case (TCP_FIN | TCP_ACK):
+	case ((TCP_FIN | TCP_ACK) | TCP_PUSH):
+		if (tcp_state == TCP_CLOSE_WAIT)
+			tcp_state = TCP_CLOSING;
+		tcp_ack_num++;
+		debug_cond(DEBUG_DEV_PKT,
+			   "TCP Hdr:FIN ACK PSH  (%pI4, %pI4, s=%d, a=%d, A=%x)\n",
+			   &net_server_ip, &net_ip,
+			   tcp_seq_num, tcp_ack_num, action);
+					/* FALLTHRU */
+	default:
+		pkt_hdr_len         = IP_HDR_SIZE + net_set_ack_options(b);
+		b->ip.hdr.tcp_flags = action | TCP_PUSH | TCP_ACK;
+		debug_cond(DEBUG_DEV_PKT,
+			   "TCP Hdr:dft  (%pI4, %pI4, s=%d, a=%d, A=%x)\n",
+			   &net_server_ip, &net_ip,
+			   tcp_seq_num, tcp_ack_num, action);
+	}
+
+	pkt_len	= pkt_hdr_len + payload_len;
+	tcp_len	= pkt_len - IP_HDR_SIZE;
+
+	/*
+	 * TCP Header
+	 */
+	b->ip.hdr.tcp_ack       = htonl(tcp_ack_num);
+	b->ip.hdr.tcp_src	= htons(sport);
+	b->ip.hdr.tcp_dst	= htons(dport);
+	b->ip.hdr.tcp_seq	= htonl(tcp_seq_num);
+	tcp_seq_num		= tcp_seq_num + payload_len;
+
+	/*
+	 * TCP window size - TCP header variable tcp_win.
+	 * Change tcp_win only if you have an understanding of network
+	 * overruun, congestion, TCP segment sizes, TCP windows, TCP scale,
+	 * queuing theory  and packet buffering. If there are too few buffers,
+	 * there will be data loss, recovery may work or the sending TCP,
+	 * the server, could abort the stream transmission.
+	 * MSS is governed by maximum Ethernet frame langth.
+	 * The number of buffers is governed by the desire to have a queue of
+	 * full buffers to be processed at the destination to maximize
+	 * throughput. Temporary memory use for the boot phase on modern
+	 * SOCs is may not be considered a constraint to buffer space, if
+	 * it is, thEn the u-boot tftp or nfs kernel netboot should be
+	 * considered.
+	 */
+
+	b->ip.hdr.tcp_win	= htons(PKTBUFSRX * TCP_MSS >> TCP_SCALE);
+
+	b->ip.hdr.tcp_xsum	= 0x0000;
+	b->ip.hdr.tcp_ugr	= 0x0000;
+
+	b->ip.hdr.tcp_xsum = tcp_set_pseudo_header(pkt, net_ip, net_server_ip,
+						   tcp_len, pkt_len);
+
+	/*
+	 * IP Header
+	 */
+
+	net_set_ip_header((uchar *)&b->ip, net_server_ip, net_ip,
+			  pkt_len, IPPROTO_TCP);
+
+	return pkt_hdr_len;
+}
+
+/*
+ * Selective Acknowledgment (Essential for fast stream transfer)
+ *
+ * tcp_edge is a bit map of the leading edge of the tcp stream and is
+ * initially defined as 8 bits.
+ * It can be increased as desired to a 16, 32 or 64 bit
+ * UNSIGNED data type if the leading edge of the TCP stream is very
+ * disordered and overflows an 8 bit tcp_edge.
+ *
+ * TCP_SACK is the sack data type, and must be an UNSIGNED type,
+ *
+ * Assumption: All packets (except the first & last) are equal length.
+ * Variable length packes in the middle of the stream will break the
+ * currect sack function, and require the leading edge of the TCP stream
+ * to be managed by adding an array of lengths indexed by a bit in tcp_edge.
+ *
+ * Before modifying theis section of code, which the author found difficult
+ * to write, please be familiar with the SACK (Selective Acknowledgment) RFCs.
+ */
+
+int tcp_hole(u32 tcp_seq_num, u32 len)
+{
+	int tcp_new;
+	int i;
+
+	int tcp_edge_sz = sizeof(tcp_edge) * 8;
+	int tcp_sack = 0;
+	TCP_SACK tcp_edge_s;
+	int hill;
+	char lr;
+
+	if (len == 0)
+		return 0;
+
+	tcp_new = (tcp_seq_num - tcp_lost.hill[0].r) / len;
+	debug_cond(DEBUG_INT_STATE, "TCP seq %x, hill.r %x, new %x, len %x\n",
+		   tcp_seq_num, tcp_lost.hill[0].r, tcp_new, len);
+
+	if (tcp_new < 2) {
+		tcp_edge = tcp_edge | 0x01;
+	/*
+	 * Find and calculate ending sequence num and
+	 *  contiguous set of packets in tcp_edge
+	 */
+
+		debug_cond(DEBUG_INT_STATE, "TCP Hole setup stream %x\n",
+			   tcp_edge);
+		for (i = 0; ((tcp_edge && 0x01 == 0x01) && (i < tcp_edge_sz));
+		    i++) {
+			tcp_lost.hill[0].r += len;
+			tcp_edge = tcp_edge >> 1;
+		}
+	} else {	/* Make new or Fill hole   */
+		tcp_new--;
+		tcp_new = 0x01 << tcp_new;      /* tcp_new bit mask of pkt */
+		tcp_edge = tcp_edge | tcp_new;
+		debug_cond(DEBUG_INT_STATE, "TCP make %x new %x\n",
+			   tcp_edge, tcp_new);
+		tcp_sack = 1;
+	}
+
+	if (tcp_edge == 0) {
+		tcp_lost.len = 0;
+	} else {
+		tcp_edge_s = tcp_edge;
+
+		for (i = 1; i == TCP_SACK_HILLS; i++) {
+			tcp_lost.hill[i].l = ntohl(TCP_O_NOP);
+			tcp_lost.hill[i].r = ntohl(TCP_O_NOP);
+		}
+
+		tcp_lost.len = TCP_OPT_LEN_2;
+		hill = 1;	     /* Hill number            */
+		tcp_lost.hill[hill].l = tcp_lost.hill[0].r;
+		lr = 'r';            /* previous, hill         */
+
+		for (i = 0; ((i < tcp_edge_sz) && (hill < TCP_SACK_HILLS));
+		    i++) {
+			if ((lr == 'l') && ((tcp_edge_s ^ 0x01) == 0x03)) {
+				lr = 'r';
+				tcp_lost.hill[hill].l =
+					tcp_lost.hill[0].l + (len * i);
+				tcp_lost.hill[hill].r =
+					tcp_lost.hill[hill].l;
+			}
+			if ((lr == 'r') && ((tcp_edge_s ^ 0x02) == 0x03)) {
+				lr = 'l';
+				tcp_lost.hill[hill].r =
+					tcp_lost.hill[0].r + (len * (i + 1));
+				tcp_lost.len += TCP_SACK_SIZE;
+			}
+			tcp_edge_s = tcp_edge_s >> 1;
+		}
+	}
+	if (tcp_lost.len > 0)
+		debug_cond(DEBUG_INT_STATE,
+			   "TCP hole exit lost.len %x, sack len %x\n",
+			   tcp_lost.len, TCP_SACK_SIZE);
+
+	return tcp_sack;
+}
+
+void tcp_parse_options(uchar *o, int o_len)
+{
+	struct tcp_t_opt  *tsopt;
+	uchar *p = o;
+
+	for (p = o; p < (o + o_len); p = p + p[1]) {
+		if (p[1] != 0) {
+			switch (p[0]) {
+			case TCP_O_END:
+				return;
+			case TCP_O_MSS:
+			break;
+			case TCP_O_SCL:
+			break;
+			case TCP_P_SACK:
+			break;
+			case TCP_V_SACK:
+			break;
+			case TCP_O_TS:
+				tsopt = (struct tcp_t_opt *)p;
+				rmt_timestamp = tsopt->t_snd;
+				return;
+			break;
+			}
+			if (p[0] == TCP_O_NOP)
+				p++;
+		} else {
+			return; }
+	}
+}
+
+u8 tcp_state_machine(u8 tcp_flags, u32 *tcp_seq_num, int payload_len)
+{
+	u8  tcp_fin  = tcp_flags & TCP_FIN;
+	u8  tcp_syn  = tcp_flags & TCP_SYN;
+	u8  tcp_rst  = tcp_flags & TCP_RST;
+	u8  tcp_push = tcp_flags & TCP_PUSH;
+	u8  tcp_ack  = tcp_flags & TCP_ACK;
+	u8  action   = TCP_DATA;
+
+	/*
+	 * tcp_flags are examined to determine TX action in a given state
+	 * tcp_push is intrepreted to mean "inform the app"
+	 * urg, ece, cer and nonce flags are not supported.
+	 *
+	 * exe and crw are use to signal and confirm knowledge of congestion.
+	 * This TCP only sends a file request and acks. If it generates
+	 * congestion, the network is broken.
+	 */
+
+	debug_cond(DEBUG_INT_STATE, "TCP STATE ENTRY (%x)\n", action);
+	if (tcp_rst) {
+		action    = TCP_DATA;
+		tcp_state = TCP_CLOSED;
+		net_set_state(NETLOOP_FAIL);
+		debug_cond(DEBUG_INT_STATE, "TCP Reset (%x)\n", tcp_flags);
+		return TCP_RST;
+	}
+
+	switch  (tcp_state) {
+	case TCP_CLOSED:
+	debug_cond(DEBUG_INT_STATE, "TCP CLOSED (%x)\n", tcp_flags);
+		if (tcp_fin)
+			action = TCP_DATA;
+		if (tcp_syn)
+			action = TCP_RST;
+		if (tcp_ack)
+			action = TCP_DATA;
+	break;
+	case TCP_SYN_SENT:
+		debug_cond(DEBUG_INT_STATE, "TCP_SYN_SENT (%x), %d\n",
+			   tcp_flags, *tcp_seq_num);
+		if (tcp_fin) {
+			action = action | TCP_PUSH;
+			tcp_state = TCP_CLOSE_WAIT;
+		}
+		if (tcp_syn) {
+			action = action |  TCP_ACK | TCP_PUSH;
+			if (tcp_ack) {
+				*tcp_seq_num  = *tcp_seq_num + 1;
+				tcp_lost.hill[0].l = *tcp_seq_num;
+				tcp_lost.hill[0].r = *tcp_seq_num;
+				tcp_state     = TCP_ESTABLISHED;
+				tcp_edge      = 0;
+			}
+		} else {
+			if (tcp_ack)
+				action = TCP_DATA;
+		}
+	break;
+	case TCP_ESTABLISHED:
+		debug_cond(DEBUG_INT_STATE,
+			   "TCP_ESTABLISHED %x\n", tcp_flags);
+		if (tcp_hole(*tcp_seq_num, payload_len) > 0) {
+			/* Disable FIN flags if there is a hole  */
+			if (tcp_fin)
+				action -= TCP_FIN;
+		}
+
+		debug_cond(DEBUG_INT_STATE, "TCP_ESTABLISHED (%x), %x, %x\n",
+			   action, *tcp_seq_num, tcp_lost.hill[0].r);
+
+		if (tcp_fin) {
+			action    = action | TCP_FIN | TCP_PUSH | TCP_ACK;
+			tcp_state = TCP_CLOSE_WAIT;
+		} else {
+			if (tcp_ack)
+				action = TCP_DATA;
+		}
+		if (tcp_push)
+			action = action | TCP_PUSH;
+		if (tcp_syn)
+			action = TCP_ACK + TCP_RST;
+	break;
+	case TCP_CLOSE_WAIT:
+		debug_cond(DEBUG_INT_STATE, "TCP_CLOSE_WAIT (%x)\n", tcp_flags);
+		action = TCP_DATA;			/* Wait for app	*/
+	break;
+	case TCP_FIN_WAIT_2:
+		debug_cond(DEBUG_INT_STATE, "TCP_FIN_WAIT_2 (%x)\n", tcp_flags);
+		if (tcp_fin)
+			action =  TCP_DATA;
+		if (tcp_syn)
+			action =  TCP_DATA;
+		if (tcp_ack) {
+			action =  TCP_PUSH | TCP_ACK;
+			tcp_state = TCP_CLOSED;
+		}
+	break;
+	case TCP_FIN_WAIT_1:
+		debug_cond(DEBUG_INT_STATE, "TCP_FIN_WAIT_1 (%x)\n", tcp_flags);
+		if (tcp_fin) {
+			action = TCP_ACK | TCP_FIN;
+			 tcp_state = TCP_FIN_WAIT_2;
+		}
+		if (tcp_syn)
+			action =  TCP_RST;
+		if (tcp_ack) {
+			tcp_state = TCP_CLOSED;
+			tcp_seq_num = tcp_seq_num + 1;
+		}
+	break;
+	case TCP_CLOSING:
+		debug_cond(DEBUG_INT_STATE, "TCP_CLOSING (%x)\n", tcp_flags);
+		if (tcp_fin)
+			action = TCP_DATA;
+		if (tcp_syn)
+			action = TCP_RST;
+		if (tcp_ack) {
+			action = TCP_PUSH;
+			tcp_state = TCP_CLOSED;
+		}
+	break;
+	}
+	return action;
+}
+
+void rxhand_tcp_f(union tcp_build_pkt *b, unsigned int pkt_len)
+{
+	int tcp_len     = pkt_len - IP_HDR_SIZE;
+	u16 tcp_rx_xsum = b->ip.hdr.ip_sum;
+	u8  tcp_action  = TCP_DATA;
+	u32 tcp_seq_num;
+	u32 tcp_ack_num;
+	struct in_addr action_and_state;
+
+	int tcp_hdr_len;
+	int payload_len;
+
+	/*
+	 * Verify ip header
+	 */
+		debug_cond(DEBUG_DEV_PKT,
+			   "TCP RX in RX Sum (to=%pI4, from=%pI4, len=%d)\n",
+			   &b->ip.hdr.ip_src, &b->ip.hdr.ip_dst, pkt_len);
+
+		debug_cond(DEBUG_DEV_PKT,
+			   "In__________________________________________\n");
+
+	b->ip.hdr.ip_src	= net_server_ip;
+	b->ip.hdr.ip_dst	= net_ip;
+	b->ip.hdr.ip_sum	= 0x0000;
+	if (tcp_rx_xsum != compute_ip_checksum(b, IP_HDR_SIZE)) {
+		debug_cond(DEBUG_DEV_PKT,
+			   "TCP RX IP xum Error (%pI4, =%pI4, len=%d)\n",
+			   &net_ip, &net_server_ip, pkt_len);
+		return;
+	}
+
+	/*
+	 * Build Pseudo header and Verify TCP header
+	 */
+	tcp_rx_xsum = b->ip.hdr.tcp_xsum;
+	b->ip.hdr.tcp_xsum = 0x0000;
+	if (tcp_rx_xsum != tcp_set_pseudo_header((uchar *)b, b->ip.hdr.ip_src,
+						 b->ip.hdr.ip_dst, tcp_len,
+						 pkt_len)) {
+		debug_cond(DEBUG_DEV_PKT,
+			   "TCP RX TCP xSum Error (%pI4, %pI4, len=%d)\n",
+			   &net_ip, &net_server_ip, tcp_len);
+		return;
+	}
+
+	tcp_hdr_len = (b->ip.hdr.tcp_hlen >> 2);
+	payload_len = tcp_len - tcp_hdr_len;
+
+	if (tcp_hdr_len > TCP_HDR_SIZE)
+		tcp_parse_options((uchar *)b + IP_TCP_HDR_SIZE,
+				  tcp_hdr_len - TCP_HDR_SIZE);
+	/*
+	 * Incoming sequence and ack numbers are server's view of the numbers.
+	 * The app must swap the numbers when responding.
+	 */
+
+	tcp_seq_num = ntohl(b->ip.hdr.tcp_seq);
+	tcp_ack_num = ntohl(b->ip.hdr.tcp_ack);
+
+	/*
+	 * Send first packet send from server as first to app
+	 * Other packets could be ordered, but are currently not ordered.
+	 */
+
+	tcp_action  = tcp_state_machine(b->ip.hdr.tcp_flags,
+					&tcp_seq_num, payload_len);
+
+	/*
+	 * State altering command to be sent.
+	 * The packet sequence and ack numbers are in the tcp_seq_num
+	 * and tcp_ack_num variables. The current packet, its position
+	 * in the date stream, is the in the range of those variables.
+	 *
+	 * In the "application push" invocation the TCP header with all
+	 * its information is pointed to by the packet pointer, and the
+	 * other variable "repurposed" (or misused) to carry sequence numbers
+	 * and  TCP state.
+	 *
+	 * TCP_PUSH from the state machine with a payload length of 0 is a
+	 * connect or disconnect event
+	 */
+
+	if ((tcp_action && TCP_PUSH) || (payload_len > 0)) {
+		debug_cond(DEBUG_DEV_PKT,
+			   "TCP Notify (action=%x, Seq=%d,Ack=%d,Pay%d)\n",
+			   tcp_action, tcp_seq_num, tcp_ack_num, payload_len);
+
+		action_and_state.s_addr = tcp_action;
+		(*tcp_packet_handler) ((uchar *)b + pkt_len - payload_len,
+				       tcp_seq_num, action_and_state,
+				       tcp_ack_num, payload_len);
+
+	} else if (tcp_action != TCP_DATA) {
+		debug_cond(DEBUG_DEV_PKT,
+			   "TCP Action (action=%x,Seq=%d,Ack=%d,Pay=%d)\n",
+			   tcp_action, tcp_seq_num, tcp_ack_num, payload_len);
+
+	/*
+	 * Warning: Incoming Seq & Ack  sequence numbers are transposed here
+	 * to outgoing Seq & Ack sequence numbers
+	 */
+
+		net_send_tcp_packet(0, ntohs(b->ip.hdr.tcp_src),
+				    ntohs(b->ip.hdr.tcp_dst),
+				    (tcp_action & (~TCP_PUSH)),
+				    tcp_seq_num, tcp_ack_num);
+	}
+}
diff --git a/net/tcp.h b/net/tcp.h
new file mode 100644
index 0000000000..81ee087282
--- /dev/null
+++ b/net/tcp.h
@@ -0,0 +1,214 @@
+/*
+ *	TCP Support for file transfer.
+ *
+ *	Copyright 2017 Duncan Hare, All rights reserved.
+ *
+ * History
+ *	10/2017	  Initial code
+ */
+
+struct ip_tcp_hdr {
+	u8		ip_hl_v;	/* header length and version	*/
+	u8		ip_tos;		/* type of service		*/
+	u16		ip_len;		/* total length			*/
+	u16		ip_id;		/* identification		*/
+	u16		ip_off;		/* fragment offset field	*/
+	u8		ip_ttl;		/* time to live			*/
+	u8		ip_p;		/* protocol			*/
+	u16		ip_sum;		/* checksum			*/
+	struct in_addr	ip_src;		/* Source IP address		*/
+	struct in_addr	ip_dst;		/* Destination IP address	*/
+	u16		tcp_src;	/* TCP source port		*/
+	u16		tcp_dst;	/* TCP destination port		*/
+	u32		tcp_seq;	/* TCP sequence number		*/
+	u32		tcp_ack;	/* TCP Acknowledgment number	*/
+	u8		tcp_hlen;	/* 4 bits TCP header Length/4	*/
+					/* 4 bits Reserved		*/
+					/* 2 more bits reserved		*/
+	u8		tcp_flags;	/* see defines			*/
+	u16		tcp_win;	/* TCP windows size		*/
+	u16		tcp_xsum;	/* Checksum			*/
+	u16		tcp_ugr;	/* Pointer to urgent data	*/
+} __packed;
+
+#define IP_TCP_HDR_SIZE		(sizeof(struct ip_tcp_hdr))
+#define TCP_HDR_SIZE		(IP_TCP_HDR_SIZE  - IP_HDR_SIZE)
+
+#define TCP_DATA	0x00	/* Data Packet - internal use only	*/
+#define TCP_FIN		0x01	/* Finish flag				*/
+#define TCP_SYN		0x02	/* Synch (start) flag			*/
+#define TCP_RST		0x04	/* reset flag				*/
+#define TCP_PUSH	0x08	/* Push - Notify app			*/
+#define TCP_ACK		0x10	/* Acknowledgment of data received	*/
+#define TCP_URG		0x20	/* Urgent				*/
+#define TCP_ECE		0x40	/* Congestion control			*/
+#define TCP_CWR		0x80	/* Congestion Control			*/
+
+/*
+ * TCP header options, Seq, MSS, and SACK
+ */
+
+#define TCP_O_END	0x00		/* End of option list		*/
+#define TCP_1_NOP	0x01		/* Single padding NOP		*/
+#define TCP_O_NOP	0x01010101	/* NOPs pad to 32 bit boundary	*/
+#define TCP_O_MSS	0x02		/* MSS Size option		*/
+#define TCP_O_SCL	0x03		/* Window Scale option		*/
+#define TCP_P_SACK	0x04		/* SACK permitted		*/
+#define TCP_V_SACK	0x05		/* SACK values			*/
+#define TCP_O_TS	0x08		/* Timestanp option		*/
+#define TCP_OPT_LEN_2	0x02
+#define TCP_OPT_LEN_3	0x03
+#define TCP_OPT_LEN_4	0x04
+#define TCP_OPT_LEN_6	0x06
+#define TCP_OPT_LEN_8	0x08
+#define TCP_OPT_LEN_A	0x0a		/* Timestamp Length		*/
+
+/*
+ * Please reviw the warning in net.c about these two paraeters.
+ * They are part of a promise of RX buffer size to the sending TCP
+ */
+
+#define TCP_MSS		1460		/* Max segment size - 1460	*/
+#define TCP_SCALE	0x01		/* Scale 1			*/
+
+struct tcp_mss {			/* TCP Mex Segment size		*/
+	u8	kind;			/* 0x02				*/
+	u8	len;			/* 0x04				*/
+	u16	mss;			/* 1460 - Max segment size	*/
+} __packed;
+
+struct tcp_scale {			/* TCP Windows Scale		*/
+	u8	kind;			/* 0x03				*/
+	u8	len;			/* 0x03				*/
+	u8	scale;			/* win shift fat fast networks	*/
+} __packed;
+
+struct tcp_sack_p {			/* SACK permitted		*/
+	u8	kind;			/* 0x04				*/
+	u8	len;			/* Length			*/
+} __packed;
+
+struct sack_edges {
+	u32	l;
+	u32	r;
+} __packed;
+
+#define TCP_SACK_SIZE (sizeof(struct sack_edges))
+
+#define TCP_SACK_HILLS	4
+
+struct tcp_sack_v {
+	u8	kind;			/* 0x05			*/
+	u8	len;				/* Length		*/
+	struct	sack_edges hill[TCP_SACK_HILLS]; /* L & R widow edges	*/
+} __packed;
+
+struct tcp_t_opt {			/* TCP time stamps option	*/
+	u8	kind;			/* 0x08				*/
+	u8	len;			/* 0x0a				*/
+	u32	t_snd;			/* Sender timestamp		*/
+	u32	t_rcv;			/* Receiver timestamp		*/
+} __packed;
+
+#define TCP_TSOPT_SIZE	(sizeof(struct tcp_t_opt))
+
+/*
+ * ip tcp  structure with options
+ */
+
+struct ip_tcp_hdr_o {
+	struct	ip_tcp_hdr	hdr;
+	struct	tcp_mss		mss;
+	struct	tcp_scale	scale;
+	struct	tcp_sack_p	sack_p;
+	struct	tcp_t_opt	t_opt;
+	u8	end;
+} __packed;
+
+#define IP_TCP_O_SIZE		(sizeof(struct ip_tcp_hdr_o))
+
+struct ip_tcp_hdr_s {
+	struct	ip_tcp_hdr	hdr;
+	struct	tcp_t_opt	t_opt;
+	struct	tcp_sack_v	sack_v;
+	u8	end;
+} __packed;
+
+#define IP_TCP_SACK_SIZE	(sizeof(struct ip_tcp_hdr_s))
+
+/*
+ * TCP pseudo header definitions
+ */
+#define PSEUDO_PAD_SIZE	8
+
+struct pseudo_hdr {
+	u8 padding[PSEUDO_PAD_SIZE];	/* pseudo hdr size = ip_tcp hdr size */
+	struct in_addr p_src;
+	struct in_addr p_dst;
+	u8      rsvd;
+	u8      p;
+	u16     len;
+} __packed;
+
+#define PSEUDO_HDR_SIZE	(sizeof(struct pseudo_hdr)) - PSEUDO_PAD_SIZE
+
+/*
+ * union for building IP/TCP packet.
+ * build Pseudo header in packed bufferfirst, calculate TCP checksum
+ * then build IP header in packe buffer.
+ */
+
+union tcp_build_pkt {
+	struct pseudo_hdr ph;
+	struct ip_tcp_hdr_o ip;
+	struct ip_tcp_hdr_s sack;
+	uchar  raw[1600];
+} __packed;
+
+/*
+ * TCP STATE MACHINE STATES FOR SOCKET
+ */
+
+enum TCP_STATE {
+	TCP_CLOSED,		/* Need to send SYN to connect		  */
+	TCP_SYN_SENT,		/* Trying to connect, waiting for SYN ACK */
+	TCP_ESTABLISHED,	/* both server & client have a connection */
+	TCP_CLOSE_WAIT,		/* Rec FIN, passed to app for FIN, ACK rsp*/
+	TCP_CLOSING,		/* Rec FIN, sent FIN, ACK waiting for ACK */
+	TCP_FIN_WAIT_1,		/* Sendt FIN waiting for response	  */
+	TCP_FIN_WAIT_2		/* Rec ACK from FIN sent, waitng for FIN  */
+};
+
+int tcp_find_in_buffer(uchar raw[], int payload_len, uchar field[],
+		       int field_len);
+void tcp_print_buffer(uchar raw[], int pkt_len, int payload_len,
+		      int hdr_len, bool hide);
+enum TCP_STATE tcp_get_tcp_state(void);
+void tcp_set_tcp_state(enum TCP_STATE new_state);
+int tcp_set_tcp_header(uchar *pkt, int dport, int sport, int payload_len,
+		       u8 action, u32 tcp_seq_num, u32 tcp_ack_num);
+
+/*
+ * An incoming packet handler.
+ * @param pkt    pointer to the application packet
+ * @param dport  destination UDP port
+ * @param sip    source IP address
+ * @param sport  source UDP port
+ * @param len    packet length
+ */
+typedef void rxhand_tcp(uchar *pkt, unsigned int dport,
+			struct in_addr sip, unsigned int sport,
+			unsigned int len);
+void tcp_set_tcp_handler(rxhand_tcp *f);
+
+void rxhand_tcp_f(union tcp_build_pkt *b, unsigned int len);
+
+/*
+ * An incoming TCP packet handler for the TCP protocol.
+ * There is also a dymanic function pointer for TCP based commads to
+ * receive incoming traffic after the TCP protocol code has done its work.
+ */
+
+void rxhand_action(u8 tcp_action, int payload_len, u32 tcp_seq_num,
+		   u32 tcp_ack_num, unsigned int pkt_len,
+		   union tcp_build_pkt *b);
-- 
2.11.0