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