Skip to contentSkip to conversation

TCP code. All is new.

PATCH New DH at synoia.com 2 participants 2 messages Feb 24, 2018 – Feb 26, 2018 Networking

lore
Share & tools
lore
#0 lore raw

PATCH 2/3 TCP code. All is new.

From: Duncan Hare <[email protected]>

Passed through patman, which does not like packed headers. But, packed headers are a requirement to meet protocol header standards.

---

 net/Makefile |   3 +-
 net/tcp.c    | 723 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 net/tcp.h    | 219 ++++++++++++++++++
 3 files changed, 944 insertions(+), 1 deletion(-)
 create mode 100644 net/tcp.c
 create mode 100644 net/tcp.h
net/Makefile +2 -1
index ae54eee5af..f83df5b728 100644
@@ -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.
net/tcp.c new file +723 -0

723 lines not on this page · raw message

net/tcp.h new file +219 -0

219 lines not on this page · raw message

Signature · 1 line
2.11.0
#1 lore raw

PATCH 2/3 TCP code. All is new.

Quoted 4 lines · -On Sat, Feb 24, 2018 at 4:41 PM, <[email protected]> wrote:

From: Duncan Hare <[email protected]>

Passed through patman, which does not like packed headers. But, packed headers are a requirement to meet protocol header standards.

This should be in a notes section for patman. It is acceptable to ignore that checkpatch warning about packed structs.

Quoted 7 lines

---

 net/Makefile |   3 +-
 net/tcp.c    | 723 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 net/tcp.h    | 219 ++++++++++++++++++

How about moving this to include/net/tcp.h?

Quoted 9 lines
 3 files changed, 944 insertions(+), 1 deletion(-)
 create mode 100644 net/tcp.c
 create mode 100644 net/tcp.h
net/Makefile +0 -0
index ae54eee5af..f83df5b728 100644

net/Makefile obj-$(CONFIG_CMD_PING) += ping.o · line 29

Quoted 6 lines
net/Makefile +2 -1
@@ -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

Don't enable the wget build in this patch.

net/tcp.c line 2

Quoted 11 lines
net/Makefile +0 -0
 # Disable this warning as it is triggered by:
 # sprintf(buf, index ? "foo%d" : "foo", index)
 # and this is intentional usage.
net/tcp.c new file +2 -0
new file mode 100644
index 0000000000..22f43e110c
@@ -0,0 +1,723 @@
+/*
+ *     Copyright 2017 Duncan Hare, all rights reserved.

Please also include a SPDX-License-Identifier:.

net/tcp.c line 15

Quoted 13 lines
net/tcp.c new file +13 -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
+ *                      - HTP client

Huh? Typo at least - maybe you mean server here? Unclear.

net/tcp.c line 16

Quoted 1 line
net/tcp.c new file +1 -0
+ *                      - Bootfile path & name

It would be better if you referenced literal U-Boot variables that need to be populated instead of loose naming of them.

net/tcp.c line 17

Quoted 1 line
net/tcp.c new file +1 -0
+ *      We want:        - Load the Boot file

Seems like something that would happen only with wget. Maybe this should be moved there.

net/tcp.c line 26

Quoted 9 lines
net/tcp.c new file +9 -0
+ *      Next Step       HTTPS?
+ */
+#include <common.h>
+#include <command.h>
+#include <console.h>
+#include <environment.h>
+#include <errno.h>
+#include <net.h>
+#include "tcp.h"

When moved, this could instead be #include <net/tcp.h>

net/tcp.c line 27

Quoted 1 line
net/tcp.c new file +1 -0
+#include "wget.h"

This doesn't exist yet.

net/tcp.c line 30

Quoted 3 lines
net/tcp.c new file +3 -0
+
+/* TCP sliding window  control  */
+/* used by us to request re-TX */

Please use multi-line comment format:

/*
* my comment...
* continued
*/

Quoted 4 lines
net/tcp.c new file +4 -0
+
+static struct tcp_sack_v tcp_lost;
+
+/* TCP option timestamp */

net/tcp.c line 44

Quoted 10 lines
net/tcp.c new file +10 -0
+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

Please use an empty /* line to begin a multi-line comment.

Quoted 29 lines
net/tcp.c new file +29 -0
+ * 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)
+{

net/tcp.c line 83

Quoted 10 lines
net/tcp.c new file +10 -0
+       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)

Should this function only be available with a debug flag?

Quoted 62 lines
net/tcp.c new file +62 -0
+{
+       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.
+        */
+

net/tcp.c line 155

Quoted 10 lines
net/tcp.c new file +10 -0
+       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,

Bad indent level.

net/tcp.c line 164

Quoted 9 lines
net/tcp.c new file +9 -0
+                          "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;

Please add a comment about the alignment you are trying to achieve.

Quoted 98 lines
net/tcp.c new file +98 -0
+
+       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;
+       }
+
+       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);
+               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);

net/tcp.c line 272

Quoted 10 lines
net/tcp.c new file +10 -0
+       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 */

Why is this comment on the same like as the break? How does break accomplish this?

net/tcp.c line 282

Quoted 10 lines
net/tcp.c new file +10 -0
+       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 */

Indent this the same as the default: label.

Quoted 6 lines
net/tcp.c new file +6 -0
+       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/tcp.c line 298

Quoted 10 lines
net/tcp.c new file +10 -0
+                          &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
+        */

Use single-line comment.

net/tcp.c line 308

Quoted 10 lines
net/tcp.c new file +10 -0
+       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
+        * overruun, congestion, TCP segment sizes, TCP windows, TCP scale,

overruun -> overrun

net/tcp.c line 312

Quoted 4 lines
net/tcp.c new file +4 -0
+        * 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.

langth -> length

net/tcp.c line 317

Quoted 5 lines
net/tcp.c new file +5 -0
+        * 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

thEn -> then

Quoted 15 lines
net/tcp.c new file +15 -0
+        * 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/tcp.c line 342

Quoted 10 lines
net/tcp.c new file +10 -0
+       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 theis section of code, which the author found difficult

theis -> this

net/tcp.c line 351

Quoted 9 lines
net/tcp.c new file +9 -0
+ * 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;

Use a single space between hill and =.

Quoted 7 lines
net/tcp.c new file +7 -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 */

net/tcp.c line 368

Quoted 10 lines
net/tcp.c new file +10 -0
+
+       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 lanegth as data packets,

lanegth -> length

net/tcp.c line 369

Quoted 1 line
net/tcp.c new file +1 -0
+        * and if it's length is recorded ad used for array index

ad -> and

net/tcp.c line 370

Quoted 1 line
net/tcp.c new file +1 -0
+        * the arrary index calculations break.

arrary -> array

net/tcp.c line 371

Quoted 1 line
net/tcp.c new file +1 -0
+        */

Fix indentation of this comment block.

Quoted 10 lines
net/tcp.c new file +10 -0
+               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 */
+

net/tcp.c line 391

Quoted 10 lines
net/tcp.c new file +10 -0
+       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);

Parenthesis around these conditions are not needed.

Quoted 71 lines
net/tcp.c new file +71 -0
+                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;

net/tcp.c line 472

Quoted 10 lines
net/tcp.c new file +10 -0
+                       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; }

Put the closing brace on its own line.

Quoted 6 lines
net/tcp.c new file +6 -0
+       }
+}
+
+u8 tcp_state_machine(u8 tcp_flags, u32 *tcp_seq_num, int payload_len)
+{
+       u8  tcp_fin  = tcp_flags & TCP_FIN;

net/tcp.c line 488

Quoted 10 lines
net/tcp.c new file +10 -0
+       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 intrepreted to mean "inform the app"

intrepreted -> interpreted

Quoted 124 lines
net/tcp.c new file +124 -0
+        * 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;

net/tcp.c line 622

Quoted 10 lines
net/tcp.c new file +10 -0
+       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

ip -> IP

Quoted 4 lines
net/tcp.c new file +4 -0
+        */
+               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);

net/tcp.c line 636

Quoted 10 lines
net/tcp.c new file +10 -0
+
+               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",

xum -> xSum

Quoted 24 lines
net/tcp.c new file +24 -0
+                          &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);

net/tcp.c line 670

Quoted 10 lines
net/tcp.c new file +10 -0
+       /*
+        * 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

send -> sent

net/tcp.c line 681

Quoted 11 lines
net/tcp.c new file +11 -0
+        * 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.

date -> data

net/tcp.c line 683

Quoted 2 lines
net/tcp.c new file +2 -0
+        *
+        * In the "application push" invocation the TCP header with all

invocation,

net/tcp.c line 685

Quoted 2 lines
net/tcp.c new file +2 -0
+        * its information is pointed to by the packet pointer, and the
+        * other variable "repurposed" (or misused) to carry sequence numbers

What other variable. Call it out explicitly.

Quoted 21 lines
net/tcp.c new file +21 -0
+        * and  TCP state.
+        *
+        * 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);

net/tcp.c line 716

Quoted 10 lines
net/tcp.c new file +10 -0
+
+       } 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
+        */

Fix indentation.

net/tcp.c line 717

Quoted 1 line
net/tcp.c new file +1 -0
+

Remove this blank line.

Quoted 12 lines
net/tcp.c new file +6 -0
+               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);
+       }
+}
net/tcp.h new file +0 -0
new file mode 100644
index 0000000000..4d50390c6d

net/tcp.h line 4

Quoted 4 lines
net/tcp.h new file +4 -0
@@ -0,0 +1,219 @@
+/*
+ *     TCP Support for file transfer.
+ *
+ *     Copyright 2017 Duncan Hare, All rights reserved.

Include a SPDX-License-Identifier.

net/tcp.h line 7

Quoted 3 lines
net/tcp.h new file +3 -0
+ *
+ * History
+ *     10/2017   Initial code

Git already keeps the history - drop this section.

net/tcp.h line 10

Quoted 3 lines
net/tcp.h new file +3 -0
+ */
+
+#define TCP_ACTIVITY 127               /* Activity on down loading     */

down loading -> downloading

Quoted 43 lines
net/tcp.h new file +43 -0
+
+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   */

net/tcp.h line 63

Quoted 10 lines
net/tcp.h new file +10 -0
+                                       /* 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             */

Timestanp -> Timestamp

net/tcp.h line 72

Quoted 9 lines
net/tcp.h new file +9 -0
+#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.

reviw -> review , paraeters ->parameters

Quoted 6 lines
net/tcp.h new file +6 -0
+ * 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                      */
+

net/tcp.h line 88

Quoted 10 lines
net/tcp.h new file +10 -0
+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  */

fat -> for?

Quoted 64 lines
net/tcp.h new file +64 -0
+} __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;

net/tcp.h line 162

Quoted 10 lines
net/tcp.h new file +10 -0
+       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

bufferfirst -> buffer first

net/tcp.h line 163

Quoted 1 line
net/tcp.h new file +1 -0
+ * then build IP header in packe buffer.

packe -> packed

Quoted 10 lines
net/tcp.h new file +10 -0
+ */
+
+union tcp_build_pkt {
+       struct pseudo_hdr ph;
+       struct ip_tcp_hdr_o ip;
+       struct ip_tcp_hdr_s sack;
+       uchar  raw[1600];
+} __packed;
+
+/*

net/tcp.h line 183

Quoted 10 lines
net/tcp.h new file +10 -0
+ * 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         */

Sendt -> Sent

net/tcp.h line 184

Quoted 1 line
net/tcp.h new file +1 -0
+       TCP_FIN_WAIT_2          /* Rec ACK from FIN sent, waitng for FIN  */

waitng -> waiting

Quoted 19 lines
net/tcp.h new file +19 -0
+};
+
+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
+ */

net/tcp.h line 213

Quoted 10 lines
net/tcp.h new file +10 -0
+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

dymanic -> dynamic , commads -> commands

Quoted 13 lines
net/tcp.h new file +6 -1
+ * 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

_______________________________________________
U-Boot mailing list
U-Boot at lists.denx.de
https://lists.denx.de/listinfo/u-boot