From patchwork Sun Jun 24 22:40:42 2018 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Duncan Hare X-Patchwork-Id: 934008 X-Patchwork-Delegate: joe.hershberger@gmail.com Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Authentication-Results: ozlabs.org; spf=none (mailfrom) smtp.mailfrom=lists.denx.de (client-ip=81.169.180.215; helo=lists.denx.de; envelope-from=u-boot-bounces@lists.denx.de; receiver=) Authentication-Results: ozlabs.org; dmarc=none (p=none dis=none) header.from=synoia.com Authentication-Results: ozlabs.org; dkim=fail reason="signature verification failed" (2048-bit key; unprotected) header.d=yahoo.com header.i=@yahoo.com header.b="EHZ8jWnZ"; dkim-atps=neutral Received: from lists.denx.de (dione.denx.de [81.169.180.215]) by ozlabs.org (Postfix) with ESMTP id 41DS435TX3z9ry1 for ; Mon, 25 Jun 2018 08:42:27 +1000 (AEST) Received: by lists.denx.de (Postfix, from userid 105) id 310DAC21E16; Sun, 24 Jun 2018 22:42:13 +0000 (UTC) X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on lists.denx.de X-Spam-Level: X-Spam-Status: No, score=0.0 required=5.0 tests=T_DKIM_INVALID autolearn=unavailable autolearn_force=no version=3.4.0 Received: from lists.denx.de (localhost [IPv6:::1]) by lists.denx.de (Postfix) with ESMTP id 904C3C21DE8; Sun, 24 Jun 2018 22:41:20 +0000 (UTC) Received: by lists.denx.de (Postfix, from userid 105) id 908D2C21DFD; Sun, 24 Jun 2018 22:41:08 +0000 (UTC) Received: from sonic316-15.consmr.mail.gq1.yahoo.com (sonic316-15.consmr.mail.gq1.yahoo.com [98.137.69.39]) by lists.denx.de (Postfix) with ESMTPS id 35A90C21DFA for ; Sun, 24 Jun 2018 22:41:03 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=yahoo.com; s=s2048; t=1529880061; bh=NwRmBIbuM/n4F4zZzqbx3RxPLk8cigDIVWslgAzaSM8=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From:Subject; b=EHZ8jWnZHdcX19u3CBKgsEwtzmzYMMl/2bh8Dg4KPGNXhQPkYjQznRrVSVcLvIjuyZ5TPrpWaaH1pWxgmYmz8knpfOkp9hGjF//LD1B+dVTEZmCgXLF5fgRPb+p8LNyb2fKqpAgp8JkB3tuvrMb7n0aQqHqzDu3UFNhGKvLUH1/ZZwKJvwOFvvL9PmCYB28PEufFCCkRI4nWojKHoDLj/LEsl8UohW+N/r0Dq4gllHhCTk7ogseeT8WKKqGC7TPTSC3+ei+YA+VbQEUwtwC/tL0TZq34QhuKDin7NvzZ+CU6yUqcCMJPRM6TSRKYrrfatmPGjv+JCVM9ggxezEwb6A== X-YMail-OSG: xx4ZSDcVM1ms6LXCWoKVZ6z3i71Qw3PaHusl9pYepdjlfxzDr7r9IxrZWNMUrDR lODScbW.P7Ps25WeXi4HWiQqTsGDWWQLJyrPbcuYBeuBjQKLDW3Pld_.TQpWqxP2uJ__XYJG7NIS x6ktONrmFDpXzv76lcuM8uZ5RlOwqpHe8zhl4Y2b.jVbgB0CDB7TT9fAfUpTjk6ssuz7VTSVpJk2 nOAlSVQKzwfYla5mYLiseJ3FDKPvwy39tlfDI1.pFUhVpes5OjIqkdCZAgUBG13K1VcnBgXoBbCk XVugwDdkPcMSq3YVs_vPuKVbHrRegIDwhN64ruaqYT.Z_7SLowkjr7WbOyK9KZOuuuzyfJMZkYzZ kF61Su7wN0rCW8rciGXotxgiIlpcKUVmh_6YWZ0VqfaQecQHx7nHPGZJv00_wVdHlqI9SzqW9EaW bv1LD3pKXAvFlUg1ZrL0.OThnwwvPmUkh8YlAH5QO5HHeFAag07YAOta6kueBmbI_MCvcwyc2Bry .ZlF9Xbc4G8bPjnv9CavXdUeTQsRkfAcU1Lrf4L0crTDIzSTJvzy1IAO.qu9wk7P8tRbrvLIjKSL 6HeQ3BjdK0d2TdHTGXG2NQTqc9EveQNoARv7IZxTrNgz0f78KsgcTj_XJupC8AT40aMHO.gQTgEP GEzNQ7WmsUxZr.8D.YB4RitCME1b45MHddhLT0W8IwQxMgtzU_yD9poDdj3NiIQkxLqukD7XrT4f 0jjmO8Y6Q1eRwOBK9PXQHjIb3dVhfycEhaZ_j4WbA34n6_G9JXrRfDZj5yUkCOgSMUv2svDA0UuV TNfSSbJQfWzFkithvvrYnAiqxSlqOr8fcojNdAKrNTDZzlyj2HryK5TTAmREKRWDjQQIJNKHRgsL rFHO4B91hov.gz5QwlQVb8Mc_KDjvZ92yFZXEt6E_43yWgoixYA_8rvnAoESsJhkSl.hZNIjm_wJ 1bm_6GwJzz2Q4M78.AC.OMsXm7mOByUrR_o97_VBqXOEi Received: from sonic.gate.mail.ne1.yahoo.com by sonic316.consmr.mail.gq1.yahoo.com with HTTP; Sun, 24 Jun 2018 22:41:01 +0000 Received: from 68-95-124-113.lightspeed.irvnca.sbcglobal.net (EHLO raspberrypi.Danum.local) ([68.95.124.113]) by smtp402.mail.gq1.yahoo.com (Oath Hermes SMTP Server) with ESMTPA ID f29df259cf5e3dfe6ff6ef53a971ed9f; Sun, 24 Jun 2018 22:40:56 +0000 (UTC) From: DH@synoia.com To: DuncanCHare@yahoo.com Date: Sun, 24 Jun 2018 15:40:42 -0700 Message-Id: <20180624224043.31503-2-DH@synoia.com> X-Mailer: git-send-email 2.11.0 In-Reply-To: <20180624224043.31503-1-DH@synoia.com> References: <20180624224043.31503-1-DH@synoia.com> Cc: Duncan Hare , Joe Hershberger , u-boot@lists.denx.de, Jason Kridner Subject: [U-Boot] [PATCH v12 2/3] Add TCP X-BeenThere: u-boot@lists.denx.de X-Mailman-Version: 2.1.18 Precedence: list List-Id: U-Boot discussion List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , MIME-Version: 1.0 Errors-To: u-boot-bounces@lists.denx.de Sender: "U-Boot" From: Duncan Hare Currently file transfers are done using tftp or NFS both over udp. This requires a request to be sent from client (u-boot) to the boot server. The current standard is TCP with selective acknowledgment. In our testing we have reduce kernel transmission time to around 0.4 seconds for a 4Mbyte kernel, with a 100 Mbps downlink. Series-Changes 11 - Add TCP with SACK - Clean formatting - Remove buffer search and print routines Series-Changes 12 - Fix License statement Signed-off-by: Duncan Hare Signed-off-by: Duncan Hare --- include/net.h | 11 +- include/net/tcp.h | 227 ++++++++++++++++++ net/Kconfig | 6 + net/Makefile | 1 + net/net.c | 33 +++ net/tcp.c | 700 ++++++++++++++++++++++++++++++++++++++++++++++++++++++ 6 files changed, 977 insertions(+), 1 deletion(-) create mode 100644 include/net/tcp.h create mode 100644 net/tcp.c diff --git a/include/net.h b/include/net.h index a54160fff6..ba96267eb8 100644 --- a/include/net.h +++ b/include/net.h @@ -26,6 +26,9 @@ * */ +#if defined(CONFIG_TCP) /* Protected UDP uses less bufferes than TCP */ +#define CONFIG_SYS_RX_ETH_BUFFER 12 +#endif #ifdef CONFIG_SYS_RX_ETH_BUFFER # define PKTBUFSRX CONFIG_SYS_RX_ETH_BUFFER #else @@ -350,6 +353,7 @@ struct vlan_ethernet_hdr { #define PROT_PPP_SES 0x8864 /* PPPoE session messages */ #define IPPROTO_ICMP 1 /* Internet Control Message Protocol */ +#define IPPROTO_TCP 6 /* Transmission Control Protocol */ #define IPPROTO_UDP 17 /* User Datagram Protocol */ /* @@ -659,7 +663,7 @@ static inline void net_send_packet(uchar *pkt, int len) } /* - * Transmit "net_tx_packet" as UDP packet, performing ARP request if needed + * Transmit "net_tx_packet" as UDP or TCPpacket, send ARP request if needed * (ether will be populated) * * @param ether Raw packet buffer @@ -667,10 +671,15 @@ static inline void net_send_packet(uchar *pkt, int len) * @param dport Destination UDP port * @param sport Source UDP port * @param payload_len Length of data after the UDP header + * @param action TCP action to be performed + * @param tcp_seq_num TCP sequence number of this transmission + * @param tcp_ack_num TCP stream acknolegement number */ int net_send_ip_packet(uchar *ether, struct in_addr dest, int dport, int sport, int payload_len, int proto, u8 action, u32 tcp_seq_num, u32 tcp_ack_num); +int net_send_tcp_packet(int payload_len, int dport, int sport, u8 action, + u32 tcp_seq_num, u32 tcp_ack_num); int net_send_udp_packet(uchar *ether, struct in_addr dest, int dport, int sport, int payload_len); diff --git a/include/net/tcp.h b/include/net/tcp.h new file mode 100644 index 0000000000..d0e90e07dd --- /dev/null +++ b/include/net/tcp.h @@ -0,0 +1,227 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +/* + * TCP Support with SACK for file transfer. + * + * Copyright 2017 Duncan Hare, All rights reserved. + */ + +#define TCP_ACTIVITY 127 /* Number of packets received */ + /* before console progress mark */ + +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_SACK 32 /* Number of packets analyzed */ + /* on leading edge of stream */ + +#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 /* Timestamp 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 review the warning in net.c about these two parameters. + * They are part of a promise of RX buffer size to the sending TCP + */ + +#define TCP_MSS 1460 /* Max segment size */ +#define TCP_SCALE 0x01 /* Scale */ + +struct tcp_mss { /* TCP Max Segment size */ + u8 kind; /* Field ID */ + u8 len; /* Field length */ + u16 mss; /* Segment size value */ +} __packed; + +struct tcp_scale { /* TCP Windows Scale */ + u8 kind; /* Field ID */ + u8 len; /* Filed length */ + u8 scale; /* windows shift value used for */ + /* networks with many hops */ + /* Typically 4 or more hops */ + +} __packed; + +struct tcp_sack_p { /* SACK permitted */ + u8 kind; /* Field Id */ + u8 len; /* Field length */ +} __packed; + + /* Terse definitions used */ + /* long definitions make the */ + /* indented code overflow line */ + /* length linits */ +struct sack_edges { + u32 l; /* Left edge of stream */ + u32 r; /* right edge of stream */ +} __packed; + +#define TCP_SACK_SIZE (sizeof(struct sack_edges)) + +/* + * A TCP stream has holes when packets are missing or disordered. + * A hill is the inverese of a hole, and is data received. + * TCP receiveds hills (a sequence of data), and inferrs Holes + * from the "hills" or packets received. + */ + +#define TCP_SACK_HILLS 4 + +struct tcp_sack_v { + u8 kind; /* Field ID */ + u8 len; /* Field Length */ + struct sack_edges hill[TCP_SACK_HILLS]; /* L & R window edges */ +} __packed; + +struct tcp_t_opt { /* TCP time stamps option */ + u8 kind; /* Field id */ + u8 len; /* Field length */ + 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 TCP/IP packet. Build Pseudo header in packed buffer + * first, calculate TCP checksum, then build IP header in packed 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 connection + */ + +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, /* Sent FIN waiting for response */ + TCP_FIN_WAIT_2 /* Rec ACK from FIN sent, waiting for FIN */ +}; + +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 dynamic function pointer for TCP based commands 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); diff --git a/net/Kconfig b/net/Kconfig index f2363e5256..77ab683eb8 100644 --- a/net/Kconfig +++ b/net/Kconfig @@ -22,4 +22,10 @@ config NETCONSOLE Support the 'nc' input/output device for networked console. See README.NetConsole for details. +config TCP + bool "TCP stack" + help + TCP protocol support with SACK for wget. Selecting this will provide + the fastest file transfer possible. + endif # if NET diff --git a/net/Makefile b/net/Makefile index 07466879f5..237023407f 100644 --- a/net/Makefile +++ b/net/Makefile @@ -24,6 +24,7 @@ obj-$(CONFIG_CMD_RARP) += rarp.o obj-$(CONFIG_CMD_SNTP) += sntp.o obj-$(CONFIG_CMD_TFTPBOOT) += tftp.o obj-$(CONFIG_UDP_FUNCTION_FASTBOOT) += fastboot.o +obj-$(CONFIG_TCP) += tcp.o # Disable this warning as it is triggered by: # sprintf(buf, index ? "foo%d" : "foo", index) diff --git a/net/net.c b/net/net.c index f831c34599..8ac1ff050f 100644 --- a/net/net.c +++ b/net/net.c @@ -108,6 +108,7 @@ #if defined(CONFIG_CMD_SNTP) #include "sntp.h" #endif +#include /** BOOTP EXTENTIONS **/ @@ -380,6 +381,9 @@ void net_init(void) /* Only need to setup buffer pointers once. */ first_call = 0; +#if defined(CONFIG_TCP) + tcp_set_tcp_state(TCP_CLOSED); +#endif } net_init_loop(); @@ -790,6 +794,16 @@ return net_send_ip_packet(ether, dest, dport, sport, payload_len, IPPROTO_UDP, 0, 0, 0); } +#if defined(CONFIG_TCP) +int net_send_tcp_packet(int payload_len, int dport, int sport, u8 action, + u32 tcp_seq_num, u32 tcp_ack_num) +{ + return net_send_ip_packet(net_server_ethaddr, net_server_ip, dport, + sport, payload_len, IPPROTO_TCP, action, + tcp_seq_num, tcp_ack_num); +} +#endif + int net_send_ip_packet(uchar *ether, struct in_addr dest, int dport, int sport, int payload_len, int proto, u8 action, u32 tcp_seq_num, u32 tcp_ack_num) @@ -821,6 +835,15 @@ int net_send_ip_packet(uchar *ether, struct in_addr dest, int dport, int sport, dport, sport, payload_len); pkt_hdr_size = eth_hdr_size + IP_UDP_HDR_SIZE; break; +#if defined(CONFIG_TCP) + case IPPROTO_TCP: + pkt_hdr_size = eth_hdr_size + + tcp_set_tcp_header(pkt + eth_hdr_size, dport, sport, + payload_len, action, tcp_seq_num, + tcp_ack_num); + break; +#endif + default: return -EINVAL; } @@ -1229,6 +1252,16 @@ void net_process_received_packet(uchar *in_packet, int len) if (ip->ip_p == IPPROTO_ICMP) { receive_icmp(ip, len, src_ip, et); return; +#if defined(CONFIG_TCP) + } else if (ip->ip_p == IPPROTO_TCP) { + debug_cond(DEBUG_DEV_PKT, + "TCP PH (to=%pI4, from=%pI4, len=%d)\n", + &dst_ip, &src_ip, len); + + rxhand_tcp_f((union tcp_build_pkt *)ip, len); + return; +#endif + } else if (ip->ip_p != IPPROTO_UDP) { /* Only UDP packets */ return; } diff --git a/net/tcp.c b/net/tcp.c new file mode 100644 index 0000000000..12fa0a72cd --- /dev/null +++ b/net/tcp.c @@ -0,0 +1,700 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * 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 + * - Server with TCP + * - TCP application (eg wget) + * Next Step HTTPS? + */ +#include +#include +#include +#include +#include +#include +#include + +/* + * 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; + +u32 tcp_seq_init; +u32 tcp_ack_edge; +u32 tcp_seq_max; + +int tcp_activity_count; + +/* + * Search for TCP_SACK and review the comments before the code section + * TCP_SACK is the number of packets at the front of the stream + */ + +enum pkt_state {PKT, NOPKT}; +struct sack_r { + struct sack_edges se; + enum pkt_state st; +}; + +struct sack_r edge_a[TCP_SACK]; +unsigned int sack_idx; +unsigned int prev_len; + +/* TCP connection state */ +static enum TCP_STATE tcp_state; + +/* + * An incoming TCP packet handler for the TCP protocol. + * There is also a dynamic function pointer for TCP based commands 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; +} + +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 = TCP_1_NOP; + 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[0].l); + b->sack.sack_v.hill[0].r = htonl(tcp_lost.hill[0].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[1].l); + b->sack.sack_v.hill[1].r = htonl(tcp_lost.hill[1].r); + b->sack.sack_v.hill[2].l = htonl(tcp_lost.hill[2].l); + b->sack.sack_v.hill[2].r = htonl(tcp_lost.hill[2].r); + b->sack.sack_v.hill[3].l = TCP_O_NOP; + b->sack.sack_v.hill[3].r = TCP_O_NOP; + } + + /* + * TCP lengths are stored as a rounded up number of 32 bit words + * Add 3 to length round up, rounded, then divided into the length + * in 32 bit words. + */ + + b->sack.hdr.tcp_hlen = (((TCP_HDR_SIZE + TCP_TSOPT_SIZE + + tcp_lost.len + 3) >> 2) << 4); + + /* + * This returns the actual rounded up length of the + * TCP header to add to the total packet length + */ + + 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(); + 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; + +/* + * Header: 5 32 bit words. 4 bits TCP header Length, 4 bits reserved options + */ + b->ip.hdr.tcp_flags = action; + pkt_hdr_len = IP_TCP_HDR_SIZE; + b->ip.hdr.tcp_hlen = 0x50; + + 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); + tcp_activity_count = 0; + 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 SYNs */ + 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_edge++; + 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_edge, 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_edge); + 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 + * overrun, 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 length. + * 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); + + 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) + */ + +void tcp_hole(u32 tcp_seq_num, u32 len, u32 tcp_seq_max) +{ + unsigned int idx_sack; + unsigned int sack_end = TCP_SACK - 1; + unsigned int sack_in; + unsigned int hill = 0; + enum pkt_state expect = PKT; + + u32 seq = tcp_seq_num - tcp_seq_init; + u32 hol_l = tcp_ack_edge - tcp_seq_init; + u32 hol_r = 0; + + /* Place new seq number in correct place in receive array */ + + if (prev_len == 0) + prev_len = len; + idx_sack = sack_idx + ((tcp_seq_num - tcp_ack_edge) / prev_len); + if (idx_sack < TCP_SACK) { + edge_a[idx_sack].se.l = tcp_seq_num; + edge_a[idx_sack].se.r = tcp_seq_num + len; + edge_a[idx_sack].st = PKT; + +/* + * The fin (last) packet is not the same length as data packets, and if it's + * length is recorded and used for array index calculation, calculation breaks. + */ + if (prev_len < len) + prev_len = len; + } + + debug_cond(DEBUG_DEV_PKT, + "TCP 1 seq %d, edg %d, len %d, sack_idx %d, sack_end %d\n", + seq, hol_l, len, sack_idx, sack_end); + + /* Right edge of contiguous stream, is the left edge of first hill */ + + hol_l = tcp_seq_num - tcp_seq_init; + hol_r = hol_l + len; + + tcp_lost.len = TCP_OPT_LEN_2; + + debug_cond(DEBUG_DEV_PKT, + "TCP 1 in %d, seq %d, pkt_l %d, pkt_r %d, sack_idx %d, sack_end %d\n", + idx_sack, seq, hol_l, hol_r, sack_idx, sack_end); + + for (sack_in = sack_idx; sack_in < sack_end && hill < TCP_SACK_HILLS; + sack_in++) { + switch (expect) { + case NOPKT: + switch (edge_a[sack_in].st) { + case NOPKT: + debug_cond(DEBUG_INT_STATE, "N"); + break; + case PKT: + debug_cond(DEBUG_INT_STATE, "n"); + tcp_lost.hill[hill].l = + edge_a[sack_in].se.l; + tcp_lost.hill[hill].r = + edge_a[sack_in].se.r; + expect = PKT; + break; + } + break; + case PKT: + switch (edge_a[sack_in].st) { + case NOPKT: + debug_cond(DEBUG_INT_STATE, "p"); + if (sack_in > sack_idx && + hill < TCP_SACK_HILLS) { + hill++; + tcp_lost.len += TCP_OPT_LEN_8; + } + expect = NOPKT; + break; + case PKT: + debug_cond(DEBUG_INT_STATE, "P"); + + if (tcp_ack_edge == edge_a[sack_in].se.l) { + tcp_ack_edge = edge_a[sack_in].se.r; + edge_a[sack_in].st = NOPKT; + sack_idx++; + } else { + if (hill < TCP_SACK_HILLS) + tcp_lost.hill[hill].r = + edge_a[sack_in].se.r; + if (sack_in == sack_end - 1) + tcp_lost.hill[hill].r = + edge_a[sack_in].se.r; + } + break; + } + break; + } + } + debug_cond(DEBUG_INT_STATE, "\n"); + if (tcp_lost.len <= TCP_OPT_LEN_2) + sack_idx = 0; +} + +void tcp_parse_options(uchar *o, int o_len) +{ + struct tcp_t_opt *tsopt; + uchar *p = o; +/* + * NOPs are options with a zero length, and thus are special. + * All other options have length fields. + */ + + for (p = o; p < (o + o_len); p = p + p[1]) { + if (p[1] != 0) { + switch (p[0]) { + case TCP_O_END: + return; /* Finished processing options */ + case TCP_O_MSS: + case TCP_O_SCL: + case TCP_P_SACK: + case TCP_V_SACK: + break; /* Continue to process options */ + case TCP_O_TS: + tsopt = (struct tcp_t_opt *)p; + rmt_timestamp = tsopt->t_snd; + return; + break; + } /* End switch, process optional NOPs */ + + if (p[0] == TCP_O_NOP) + p++; + } else { + return; /* Finished processing options */ + } + } +} + +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; + int i; + + /* + * tcp_flags are examined to determine TX action in a given state + * tcp_push is interpreted 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_init = *tcp_seq_num; + *tcp_seq_num = *tcp_seq_num + 1; + tcp_seq_max = *tcp_seq_num; + tcp_ack_edge = *tcp_seq_num; + sack_idx = 0; + edge_a[sack_idx].se.l = *tcp_seq_num; + edge_a[sack_idx].se.r = *tcp_seq_num; + prev_len = 0; + tcp_state = TCP_ESTABLISHED; + for (i = 0; i < TCP_SACK; i++) + edge_a[i].st = NOPKT; + } + } else { + if (tcp_ack) + action = TCP_DATA; + } + break; + case TCP_ESTABLISHED: + debug_cond(DEBUG_INT_STATE, + "TCP_ESTABLISHED %x\n", tcp_flags); + if (*tcp_seq_num > tcp_seq_max) + tcp_seq_max = *tcp_seq_num; + if (payload_len > 0) { + tcp_hole(*tcp_seq_num, payload_len, tcp_seq_max); + tcp_fin = TCP_DATA; /* cause standalone FIN */ + } + + if ((tcp_fin) && tcp_lost.len <= TCP_OPT_LEN_2) { + 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; + puts("\n"); + } + 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; + puts("\n"); + } + 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 xSum 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); + + /* Packets are not ordered. Send to app as received. */ + + 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 data 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. + * + * In the typedef + * void rxhand_tcp(uchar *pkt, unsigned int dport, + * struct in_addr sip, unsigned int sport, + * unsigned int len); + * *pkt is the pointer to the payload + * dport is used for tcp_seg_num + * action_and_state.s_addr is used for TCP state + * sport is used for tcp_ack_num (which is unused by the app) + * pkt_ length is the payload length. + * + * TCP_PUSH from the state machine with a payload length of 0 is a + * connect or disconnect event + */ + + tcp_activity_count++; + if (tcp_activity_count > TCP_ACTIVITY) { + puts("| "); + tcp_activity_count = 0; + } + + 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 Ack & Seq 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); + } +}