/* 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);