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

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

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

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

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

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