/* SPDX-License-Identifier: GPL-2.0 */ /* * TCP Support with SACK for file transfer. * * Copyright 2017 Duncan Hare, All rights reserved. */ #define TCP_ACTIVITY 127 /* Number of packets received */ /* before console progress mark */ /** * struct ip_tcp_hdr - IP and TCP header * @ip_hl_v: header length and version * @ip_tos: type of service * @ip_len: total length * @ip_id: identification * @ip_off: fragment offset field * @ip_ttl: time to live * @ip_p: protocol * @ip_sum: checksum * @ip_src: Source IP address * @ip_dst: Destination IP address * @tcp_src: TCP source port * @tcp_dst: TCP destination port * @tcp_seq: TCP sequence number * @tcp_ack: TCP Acknowledgment number * @tcp_hlen: 4 bits TCP header Length/4, 4 bits reserved, 2 more bits reserved * @tcp_flag: flags of TCP * @tcp_win: TCP windows size * @tcp_xsum: Checksum * @tcp_ugr: Pointer to urgent data */ struct ip_tcp_hdr { u8 ip_hl_v; u8 ip_tos; u16 ip_len; u16 ip_id; u16 ip_off; u8 ip_ttl; u8 ip_p; u16 ip_sum; struct in_addr ip_src; struct in_addr ip_dst; u16 tcp_src; u16 tcp_dst; u32 tcp_seq; u32 tcp_ack; u8 tcp_hlen; u8 tcp_flags; u16 tcp_win; u16 tcp_xsum; u16 tcp_ugr; } __packed; #define IP_TCP_HDR_SIZE (sizeof(struct ip_tcp_hdr)) #define TCP_HDR_SIZE (IP_TCP_HDR_SIZE - IP_HDR_SIZE) #define TCP_DATA 0x00 /* Data Packet - internal use only */ #define TCP_FIN 0x01 /* Finish flag */ #define TCP_SYN 0x02 /* Synch (start) flag */ #define TCP_RST 0x04 /* reset flag */ #define TCP_PUSH 0x08 /* Push - Notify app */ #define TCP_ACK 0x10 /* Acknowledgment of data received */ #define TCP_URG 0x20 /* Urgent */ #define TCP_ECE 0x40 /* Congestion control */ #define TCP_CWR 0x80 /* Congestion Control */ /* * TCP header options, Seq, MSS, and SACK */ #define TCP_SACK 32 /* Number of packets analyzed */ /* on leading edge of stream */ #define TCP_O_END 0x00 /* End of option list */ #define TCP_1_NOP 0x01 /* Single padding NOP */ #define TCP_O_NOP 0x01010101 /* NOPs pad to 32 bit boundary */ #define TCP_O_MSS 0x02 /* MSS Size option */ #define TCP_O_SCL 0x03 /* Window Scale option */ #define TCP_P_SACK 0x04 /* SACK permitted */ #define TCP_V_SACK 0x05 /* SACK values */ #define TCP_O_TS 0x08 /* Timestamp option */ #define TCP_OPT_LEN_2 0x02 #define TCP_OPT_LEN_3 0x03 #define TCP_OPT_LEN_4 0x04 #define TCP_OPT_LEN_6 0x06 #define TCP_OPT_LEN_8 0x08 #define TCP_OPT_LEN_A 0x0a /* Timestamp Length */ #define TCP_MSS 1460 /* Max segment size */ #define TCP_SCALE 0x01 /* Scale */ /** * struct tcp_mss - TCP option structure for MSS (Max segment size) * @kind: Field ID * @len: Field length * @mss: Segment size value */ struct tcp_mss { u8 kind; u8 len; u16 mss; } __packed; /** * struct tcp_scale - TCP option structure for Windows scale * @kind: Field ID * @len: Field length * @scale: windows shift value used for networks with many hops. * Typically 4 or more hops */ struct tcp_scale { u8 kind; u8 len; u8 scale; } __packed; /** * struct tcp_sack_p - TCP option structure for SACK permitted * @kind: Field ID * @len: Field length */ struct tcp_sack_p { u8 kind; u8 len; } __packed; /** * struct sack_edges - structure for SACK edges * @l: Left edge of stream * @r: right edge of stream */ struct sack_edges { u32 l; u32 r; } __packed; #define TCP_SACK_SIZE (sizeof(struct sack_edges)) /* * A TCP stream has holes when packets are missing or disordered. * A hill is the inverse of a hole, and is data received. * TCP received hills (a sequence of data), and inferrs Holes * from the "hills" or packets received. */ #define TCP_SACK_HILLS 4 /** * struct tcp_sack_v - TCP option structure for SACK * @kind: Field ID * @len: Field length * @hill: L & R window edges */ struct tcp_sack_v { u8 kind; u8 len; struct sack_edges hill[TCP_SACK_HILLS]; } __packed; /** * struct tcp_t_opt - TCP option structure for time stamps * @kind: Field ID * @len: Field length * @t_snd: Sender timestamp * @t_rcv: Receiver timestamp */ struct tcp_t_opt { u8 kind; u8 len; u32 t_snd; u32 t_rcv; } __packed; #define TCP_TSOPT_SIZE (sizeof(struct tcp_t_opt)) /* * ip tcp structure with options */ /** * struct ip_tcp_hdr_o - IP + TCP header + TCP options * @hdr: IP + TCP header * @mss: TCP MSS Option * @scale: TCP Windows Scale Option * @sack_p: TCP Sack-Permitted Option * @t_opt: TCP Timestamp Option * @end: end of 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 - IP + TCP header + TCP options * @hdr: IP + TCP header * @t_opt: TCP Timestamp Option * @sack_v: TCP SACK Option * @end: end of options */ 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 - Pseudo Header * @padding: pseudo hdr size = ip_tcp hdr size * @p_src: Source IP address * @p_dst: Destination IP address * @rsvd: reserved * @p: protocol * @len: length of header */ struct pseudo_hdr { u8 padding[PSEUDO_PAD_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 tcp_build_pkt - union for building TCP/IP packet. * @ph: pseudo header * @ip: IP and TCP header plus TCP options * @sack: IP and TCP header plus SACK options * @raw: buffer * * 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; /** * enum tcp_state - TCP State machine states for connection * @TCP_CLOSED: Need to send SYN to connect * @TCP_SYN_SENT: Trying to connect, waiting for SYN ACK * @TCP_SYN_RECEIVED: Initial SYN received, waiting for 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 * @TCP_LAST_ACK: Waiting for ACK of the connection termination */ enum tcp_state { TCP_CLOSED, TCP_SYN_SENT, TCP_SYN_RECEIVED, TCP_ESTABLISHED, TCP_CLOSE_WAIT, TCP_CLOSING, TCP_FIN_WAIT_1, TCP_FIN_WAIT_2, TCP_LAST_ACK, }; /** * enum tcp_status - TCP stream status for connection * @TCP_ERR_OK: no rx/tx errors * @TCP_ERR_TOUT: rx/tx timeout happened * @TCP_ERR_RST: connection was reset * @TCP_ERR_IO: input/output error */ enum tcp_status { TCP_ERR_OK = 0, TCP_ERR_TOUT, TCP_ERR_RST, TCP_ERR_IO }; /** * struct tcp_stream - TCP data stream structure * @rhost: Remote host, network byte order * @rport: Remote port, host byte order * @lport: Local port, host byte order * * @priv: User private data (not used by tcp module) * * @max_retry_count: Maximum retransmit attempts (default 3) * @initial_timeout: Timeout from initial TX to reTX (default 2 sec) * @rx_inactiv_timeout: Maximum time from last rx till connection drop * (default 30 sec) * * @on_closed: User callback, called just before destroying TCP stream * @on_established: User callback, called when TCP stream enters * TCP_ESTABLISHED state * @on_rcv_nxt_update: User callback, called when all data in the segment * [0..rx_bytes - 1] was received * @on_snd_una_update: User callback, called when all data in the segment * [0..tx_bytes - 1] were transferred and acknowledged * @rx: User callback, called on receive of segment * [rx_offs..rx_offs+len-1]. If NULL -- all incoming data * will be ignored. User SHOULD store the segment and * return the number of accepted bytes or negative value * on error. * WARNING: Previous segmengs may not be received yet * @tx: User callback, called on transmit/retransmit of segment * [tx_offs..tx_offs+maxlen-1]. If NULL -- no data will * be transmitted. User SHOULD fill provided buffer and * return the number of bytes in the buffer or negative * value on error. * WARNING: do not use tcp_stream_close() from this * callback (it will break stream). Better use * on_snd_una_update() callback for such purposes. * * @time_last_rx: Arrival time of last valid incoming package (ticks) * @time_start: Timeout start time (ticks) * @time_delta: Timeout duration (ticks) * @time_handler Timeout handler for a stream * * @state: TCP connection state * @status: TCP stream status (OK or ERR) * @rx_packets: total number of received packets * @tx_packets: total number of transmitted packets * * @fin_rx: Non-zero if TCP_FIN was received * @fin_rx_seq: TCP sequence of rx FIN bit * @fin_tx: Non-zero if TCP_FIN was sent (or planned to send) * @fin_tx_seq: TCP sequence of tx FIN bit * * @iss: Initial send sequence number * @snd_una: Send unacknowledged * @snd_nxt: Send next * @snd_wnd: Send window (in bytes) * @snd_wl1: Segment sequence number used for last window update * @snd_wl2: Segment acknowledgment number used for last window update * * @irs: Initial receive sequence number * @rcv_nxt: Receive next * @rcv_wnd: Receive window (in bytes) * * @loc_timestamp: Local timestamp * @rmt_timestamp: Remote timestamp * * @rmt_win_scale: Remote window scale factor * * @lost: Used for SACK * * @retry_cnt: Number of retry attempts remaining. Only SYN, FIN * or DATA segments are tried to retransmit. * @retry_timeout: Current retry timeout (ms) * @retry_action: TCP flags used for sending * @retry_seq_num: TCP sequence for retransmit * retry_tx_len: Number of data to transmit * @retry_tx_offs: Position in the TX stream */ struct tcp_stream { struct in_addr rhost; u16 rport; u16 lport; void *priv; int max_retry_count; int initial_timeout; int rx_inactiv_timeout; void (*on_closed)(struct tcp_stream *tcp); void (*on_established)(struct tcp_stream *tcp); void (*on_rcv_nxt_update)(struct tcp_stream *tcp, u32 rx_bytes); void (*on_snd_una_update)(struct tcp_stream *tcp, u32 tx_bytes); int (*rx)(struct tcp_stream *tcp, u32 rx_offs, void *buf, int len); int (*tx)(struct tcp_stream *tcp, u32 tx_offs, void *buf, int maxlen); ulong time_last_rx; ulong time_start; ulong time_delta; void (*time_handler)(struct tcp_stream *tcp); enum tcp_state state; enum tcp_status status; u32 rx_packets; u32 tx_packets; int fin_rx; u32 fin_rx_seq; int fin_tx; u32 fin_tx_seq; u32 iss; u32 snd_una; u32 snd_nxt; u32 snd_wnd; u32 snd_wl1; u32 snd_wl2; u32 irs; u32 rcv_nxt; u32 rcv_wnd; /* TCP option timestamp */ u32 loc_timestamp; u32 rmt_timestamp; /* TCP window scale */ u8 rmt_win_scale; /* TCP sliding window control used to request re-TX */ struct tcp_sack_v lost; /* used for data retransmission */ int retry_cnt; int retry_timeout; u8 retry_action; u32 retry_seq_num; u32 retry_tx_len; u32 retry_tx_offs; }; void tcp_init(void); /* * This function sets user callback called on TCP stream creation. * Callback should: * + Check TCP stream endpoint and make connection verdict * - return non-zero value to accept connection * - return zero to drop connection * + Setup TCP stream callbacks like: on_closed(), on_established(), * n_rcv_nxt_update(), on_snd_una_update(), rx() and tx(). * + Setup other stream related data * * WARNING: User MUST setup TCP stream on_create handler. Without it * no connection (including outgoung) will be created. */ void tcp_stream_set_on_create_handler(int (*on_create)(struct tcp_stream *)); /* * tcp_stream_get -- Get or create TCP stream * @is_new: if non-zero and no stream found, then create a new one * @rhost: Remote host, network byte order * @rport: Remote port, host byte order * @lport: Local port, host byte order * * Returns: TCP stream structure or NULL (if not found/created) */ struct tcp_stream *tcp_stream_get(int is_new, struct in_addr rhost, u16 rport, u16 lport); /* * tcp_stream_connect -- Create new TCP stream for remote connection. * @rhost: Remote host, network byte order * @rport: Remote port, host byte order * * Returns: TCP new stream structure or NULL (if not created). * Random local port will be used. */ struct tcp_stream *tcp_stream_connect(struct in_addr rhost, u16 rport); /* * tcp_stream_put -- Return stream to a TCP subsystem. Subsystem will * check stream and destroy it (if stream was already * closed). Otherwize no stream change will happen. * @tcp: TCP stream to put */ void tcp_stream_put(struct tcp_stream *tcp); /* * tcp_stream_restart_rx_timer -- Restart RX inactivity timer. Usually there * is no needs to call this function. Timer * will be restarted on receiving of any valid * tcp packet belonging to a stream. * * This function may be used to prevent connection * break in the following case: * - u-boot is busy with very long data processing * - remote side waits for u-boot reply * * @tcp: TCP stream to put */ void tcp_stream_restart_rx_timer(struct tcp_stream *tcp); enum tcp_state tcp_stream_get_state(struct tcp_stream *tcp); enum tcp_status tcp_stream_get_status(struct tcp_stream *tcp); /* * tcp_stream_rx_offs(), * tcp_stream_tx_offs() -- Returns offset of first unacknowledged byte * in receive/transmit stream correspondingly. * The result is NOT affected by sin/fin flags. * @tcp: TCP stream */ u32 tcp_stream_rx_offs(struct tcp_stream *tcp); u32 tcp_stream_tx_offs(struct tcp_stream *tcp); /* reset tcp stream */ void tcp_stream_reset(struct tcp_stream *tcp); /* force TCP stream closing, do NOT use from tcp->tx callback */ void tcp_stream_close(struct tcp_stream *tcp); void tcp_streams_poll(void); int tcp_set_tcp_header(struct tcp_stream *tcp, uchar *pkt, int payload_len, u8 action, u32 tcp_seq_num, u32 tcp_ack_num); void rxhand_tcp_f(union tcp_build_pkt *b, unsigned int len); u16 tcp_set_pseudo_header(uchar *pkt, struct in_addr src, struct in_addr dest, int tcp_len, int pkt_len);