[U-Boot] [PATCH v8 2/3] Adding TCP
Joe Hershberger
joe.hershberger at ni.com
Thu Mar 8 18:53:00 UTC 2018
Hi Duncan,
The subject should be "net: Add TCP". Subjects should be completing
the sentence, "This patch is intended to _____." It should also be
prefixed by the a tag for what area of the project it is touching.
On Wed, Mar 7, 2018 at 10:43 PM, <DH at synoia.com> wrote:
> From: Duncan Hare <DuncanCHare at yahoo.com>
>
> All the code is new, and not copied from any source.
>
>>>>>>
> <<<<
>
> Signed-off-by: Duncan Hare <DH at Synoia.com>
> ---
>
> Routine tcp_print_buffer() is used to print portions of
> non zero terminated buffers. If there is an existing routine
> please let me know. I'm from the world of length fields
> not zero terminated strings (zOS).
>
> Added
> include/net.h
> net/tcp.c
>
> added CONFIG_TCP Kconfig parameter in networking to
> Kconfig
> Makefile
> include/net.h
> net/net.c
>
> In net.c added procedure
> int net_send_tcp_packet
>
> Modified procedures
> net_init - set tcp initial state
> net_send_ip_packet - debug messages
> net_send_ip_packet - for tcp packet header creation
> net_process_received_packet - rxhand_tcp_f
>
>
> Changes in v8:
> Adding TCP
>
> include/net.h | 8 +-
> include/net/tcp.h | 218 ++++++++++++++++
> net/Kconfig | 35 +--
> net/Makefile | 2 +-
> net/net.c | 51 +++-
> net/tcp.c | 749 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
> 6 files changed, 1024 insertions(+), 39 deletions(-)
> create mode 100644 include/net/tcp.h
> create mode 100644 net/tcp.c
>
> diff --git a/include/net.h b/include/net.h
> index 7e5f5a6a5b..e29d804a23 100644
> --- a/include/net.h
> +++ b/include/net.h
> @@ -548,7 +548,7 @@ extern int net_restart_wrap; /* Tried all network devices */
>
> enum proto_t {
> BOOTP, RARP, ARP, TFTPGET, DHCP, PING, DNS, NFS, CDP, NETCONS, SNTP,
> - TFTPSRV, TFTPPUT, LINKLOCAL
> + TFTPSRV, TFTPPUT, LINKLOCAL, WGET
> };
>
> extern char net_boot_file_name[1024];/* Boot File name */
> @@ -681,11 +681,15 @@ static inline void net_send_packet(uchar *pkt, int len)
> * @param payload_len Length of data after the UDP header
> */
> int net_send_ip_packet(uchar *ether, struct in_addr dest, int dport, int sport,
> - int payload_len, int proto);
> + int payload_len, int proto, 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);
>
> +int net_send_tcp_packet(int payload_len, int dport, int sport, u8 action,
> + u32 tcp_seq_num, u32 tcp_ack_num);
> +
> /* Processes a received packet */
> void net_process_received_packet(uchar *in_packet, int len);
>
> diff --git a/include/net/tcp.h b/include/net/tcp.h
> new file mode 100644
> index 0000000000..81f263351e
> --- /dev/null
> +++ b/include/net/tcp.h
> @@ -0,0 +1,218 @@
> +/*
> + * TCP Support for file transfer.
> + *
> + * Copyright 2017 Duncan Hare, All rights reserved.
> + *
> + * SPDX-License-Identifier: GPL-2.0
> + */
> +
> +#define TCP_ACTIVITY 127 /* Activity on downloading */
> +
> +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 /* 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 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 - 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 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 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, /* Sent FIN waiting for response */
> + TCP_FIN_WAIT_2 /* Rec ACK from FIN sent, waiting 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 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 143c4416cd..895b93dea9 100644
> --- a/net/Kconfig
> +++ b/net/Kconfig
> @@ -4,12 +4,12 @@
>
> menuconfig NET
> bool "Networking support"
> - default y
>
> if NET
>
> config NET_RANDOM_ETHADDR
> bool "Random ethaddr if unset"
> + select LIB_RAND
> help
> Selecting this will allow the Ethernet interface to function
> even when the ethaddr variable for that interface is unset.
> @@ -24,7 +24,6 @@ config NETCONSOLE
>
> config NET_TFTP_VARS
> bool "Control TFTP timeout and count through environment"
> - depends on CMD_NET
> default y
> help
> If set, allows controlling the TFTP timeout through the
> @@ -33,44 +32,22 @@ config NET_TFTP_VARS
> If unset, timeout and maximum are hard-defined as 1 second
> and 10 timouts per TFTP transfer.
>
> -config BOOTP_BOOTPATH
> - bool "Enable BOOTP BOOTPATH"
> - depends on CMD_NET
> -
> -config BOOTP_DNS
> - bool "Enable bootp DNS"
> - depends on CMD_NET
> -
> -config BOOTP_GATEWAY
> - bool "Enable BOOTP gateway"
> - depends on CMD_NET
> -
> -config BOOTP_HOSTNAME
> - bool "Enable BOOTP hostname"
> - depends on CMD_NET
> -
> -config BOOTP_PXE
> - bool "Enable BOOTP PXE"
> - depends on CMD_NET
> -
> -config BOOTP_SUBNETMASK
> - bool "Enable BOOTP subnetmask"
> - depends on CMD_NET
> - depends on CMD_NET
> -
> config BOOTP_PXE_CLIENTARCH
> hex
> - depends on CMD_NET
> default 0x16 if ARM64
> default 0x15 if ARM
> default 0 if X86
>
> config BOOTP_VCI_STRING
> string
> - depends on CMD_NET
> default "U-Boot.armv7" if CPU_V7 || CPU_V7M
> default "U-Boot.armv8" if ARM64
> default "U-Boot.arm" if ARM
> default "U-Boot"
>
> +config TCP
> + bool "Include TCP for receiving files"
> + help
> + TCP support for receiving files.
> +
> endif # if NET
> diff --git a/net/Makefile b/net/Makefile
> index ae54eee5af..25729ebeeb 100644
> --- a/net/Makefile
> +++ b/net/Makefile
> @@ -25,7 +25,7 @@ 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
> # Disable this warning as it is triggered by:
> # sprintf(buf, index ? "foo%d" : "foo", index)
> # and this is intentional usage.
> diff --git a/net/net.c b/net/net.c
> index df4e7317e7..7adc4b472c 100644
> --- a/net/net.c
> +++ b/net/net.c
> @@ -107,6 +107,9 @@
> #if defined(CONFIG_CMD_SNTP)
> #include "sntp.h"
> #endif
> +#if defined(CONFIG_TCP)
> +#include <net/tcp.h>
> +#endif
>
> DECLARE_GLOBAL_DATA_PTR;
>
> @@ -382,6 +385,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();
> @@ -781,11 +787,22 @@ int net_send_udp_packet(uchar *ether, struct in_addr dest, int dport, int sport,
> int payload_len)
> {
> return net_send_ip_packet(ether, dest, dport, sport, payload_len,
> - IPPROTO_UDP);
> + 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)
> + int payload_len, int proto, u8 action, u32 tcp_seq_num,
> + u32 tcp_ack_num)
> {
> uchar *pkt;
> int eth_hdr_size;
> @@ -794,6 +811,13 @@ int net_send_ip_packet(uchar *ether, struct in_addr dest, int dport, int sport,
> debug_cond(DEBUG_DEV_PKT,
> "UDP Send (to=%pI4, from=%pI4, len=%d)\n",
> &dest, &net_ip, payload_len);
> +#if defined(CONFIG_TCP)
> +
> + } else {
> + debug_cond(DEBUG_DEV_PKT,
> + "TCP Send (%pI4, %pI4, len=%d, A=%x)\n",
> + &dest, &net_ip, payload_len, action);
> +#endif
> }
>
> /* make sure the net_tx_packet is initialized (net_init() was called) */
> @@ -812,15 +836,19 @@ int net_send_ip_packet(uchar *ether, struct in_addr dest, int dport, int sport,
> pkt = (uchar *)net_tx_packet;
>
> eth_hdr_size = net_set_ether(pkt, ether, PROT_IP);
> - switch (proto) {
> - case IPPROTO_UDP:
> + if (proto == IPPROTO_UDP) {
> net_set_udp_header(pkt + eth_hdr_size, dest,
> dport, sport, payload_len);
> pkt_hdr_size = eth_hdr_size + IP_UDP_HDR_SIZE;
> - break;
> - default:
> - return -1;
> +
> +#if defined(CONFIG_TCP)
> + } else {
> + 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);
> }
> +#endif
>
> /* if MAC address was not discovered yet, do an ARP request */
> if (memcmp(ether, net_null_ethaddr, 6) == 0) {
> @@ -1225,6 +1253,15 @@ 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..9f4fc9fc20
> --- /dev/null
> +++ b/net/tcp.c
> @@ -0,0 +1,749 @@
> +/*
> + * Copyright 2017 Duncan Hare, all rights reserved.
> + * SPDX-License-Identifier: GPL-2.0
> + */
> +
> +/*
> + * 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 <common.h>
> +#include <command.h>
> +#include <console.h>
> +#include <environment.h>
> +#include <errno.h>
> +#include <net.h>
> +#include <net/tcp.h>
> +#if defined(CONFIG_CMD_WGET)
> +#include <net/wget.h>
> +#endif
> +
> +/*
> + * 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 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[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() % 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);
> + 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 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_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);
> +
> + /*
> + * 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)
> + *
> + * Before modifying this section of code, which the author found difficult
> + * to write, please be familiar with the SACK (Selective Acknowledgment) RFCs.
> + */
> +
> +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 seq number in correct place */
> +
> + 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
> + * the array index calculations break.
> + */
> + 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;
> +
> + 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;
> + 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);
> +
> + /*
> + * Sent 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 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 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);
> + }
> +}
> --
> 2.11.0
>
> _______________________________________________
> U-Boot mailing list
> U-Boot at lists.denx.de
> https://lists.denx.de/listinfo/u-boot
More information about the U-Boot
mailing list