/*
     Tcp.h
 */
#ifndef   _TCP_H__
#define   _TCP_H__

#include "lwdef.h"
#include "err.h"
#include "pbuf.h"
#include "netif.h"
#include "stats.h"
#include "../ip.h"
#include "ip_addr.h"

struct tcp_pcb;

/* Functions for interfacing with TCP: */

/* Lower layer interface to TCP: */
void       tcp_init    (void);     /* Must be called first to
                                            initialize TCP.         */
                                         
void       tcp_tmr     (void);     /* Must be called every
                                            TCP_TMR_INTERVAL
                                            ms. (Typically 250 ms). */
                                            
/* Application program's interface: */
struct tcp_pcb * tcp_new     (void);
struct tcp_pcb * tcp_alloc   (u8_t prio);

void       tcp_arg(struct tcp_pcb *pcb, void *arg);
void       tcp_accept(struct tcp_pcb *pcb,err_t (* accept)(void *arg, struct tcp_pcb *newpcb,err_t err));
void       tcp_recv(struct tcp_pcb *pcb,err_t (* recv)(void *arg, struct tcp_pcb *tpcb,struct pbuf *p, err_t err));
void       tcp_sent(struct tcp_pcb *pcb,err_t (* sent)(void *arg, struct tcp_pcb *tpcb,u16_t len));
void       tcp_poll(struct tcp_pcb *pcb,err_t (* poll)(void *arg, struct tcp_pcb *tpcb),u8_t interval);
void       tcp_err(struct tcp_pcb *pcb,void (* err)(void *arg, err_t err));

#define    tcp_mss(pcb)      ((pcb)->mss)
#define    tcp_sndbuf(pcb)   ((pcb)->snd_buf)

void       tcp_recved(struct tcp_pcb *pcb, u16_t len);
err_t      tcp_bind(struct tcp_pcb *pcb, Uint32 *ipaddr,u16_t port);
err_t      tcp_connect (struct tcp_pcb *pcb, Uint32 *ipaddr,u16_t port, err_t (* connected)(void *arg,struct tcp_pcb *tpcb,err_t err));
struct     tcp_pcb * tcp_listen  (struct tcp_pcb *pcb);
void       tcp_abort   (struct tcp_pcb *pcb);
err_t      tcp_close   (struct tcp_pcb *pcb);
err_t      tcp_write   (struct tcp_pcb *pcb, const void *dataptr, u16_t len,u8_t copy);
void       tcp_setprio (struct tcp_pcb *pcb, u8_t prio);

#define TCP_PRIO_MIN    1
#define TCP_PRIO_NORMAL 64
#define TCP_PRIO_MAX    127

/* It is also possible to call these two functions at the right
   intervals (instead of calling tcp_tmr()). */
void             tcp_slowtmr (void);
void             tcp_fasttmr (void);


/* Only used by IP to pass a TCP segment to TCP: */
void             tcp_input   (struct pbuf *p);//struct netif *inp);
/* Used within the TCP code only: */
err_t            tcp_output  (struct tcp_pcb *pcb);
void             tcp_rexmit  (struct tcp_pcb *pcb);



#define TCP_SEQ_LT(a,b)     ((s32_t)((a)-(b)) < 0)
#define TCP_SEQ_LEQ(a,b)    ((s32_t)((a)-(b)) <= 0)
#define TCP_SEQ_GT(a,b)     ((s32_t)((a)-(b)) > 0)
#define TCP_SEQ_GEQ(a,b)    ((s32_t)((a)-(b)) >= 0)

#define TCP_FIN 0x01U
#define TCP_SYN 0x02U
#define TCP_RST 0x04U
#define TCP_PSH 0x08U
#define TCP_ACK 0x10U
#define TCP_URG 0x20U
#define TCP_ECE 0x40U
#define TCP_CWR 0x80U

#define TCP_FLAGS 0x3fU

/* Length of the TCP header, excluding options. */
#define TCP_HLEN 20

#ifndef TCP_TMR_INTERVAL
#define TCP_TMR_INTERVAL       250  /* The TCP timer interval in
                                       milliseconds. */
#endif /* TCP_TMR_INTERVAL */

#ifndef TCP_FAST_INTERVAL
#define TCP_FAST_INTERVAL      TCP_TMR_INTERVAL /* the fine grained timeout in
                                       milliseconds */
#endif /* TCP_FAST_INTERVAL */

#ifndef TCP_SLOW_INTERVAL
#define TCP_SLOW_INTERVAL      (2*TCP_TMR_INTERVAL)  /* the coarse grained timeout in
                                       milliseconds */
#endif /* TCP_SLOW_INTERVAL */

#define TCP_FIN_WAIT_TIMEOUT 20000 /* milliseconds */
#define TCP_SYN_RCVD_TIMEOUT 20000 /* milliseconds */

#define TCP_OOSEQ_TIMEOUT        6 /* x RTO */

#define TCP_MSL 60000  /* The maximum segment lifetime in microseconds */

/*
 * User-settable options (used with setsockopt).
 */
#define	TCP_NODELAY	   0x01	   /* don't delay send to coalesce packets */
#define TCP_KEEPALIVE  0x02    /* send KEEPALIVE probes when idle for pcb->keepalive miliseconds */

/* Keepalive values */
#define  TCP_KEEPDEFAULT   7200000                       /* KEEPALIVE timer in miliseconds */
#define  TCP_KEEPINTVL     75000                         /* Time between KEEPALIVE probes in miliseconds */
#define  TCP_KEEPCNT       9                             /* Counter for KEEPALIVE probes */
#define  TCP_MAXIDLE       TCP_KEEPCNT * TCP_KEEPINTVL   /* Maximum KEEPALIVE probe time */

struct tcp_hdr 
{
  u16_t  src;
  u16_t  dest;
  u32_t  seqno;
  u32_t  ackno;
  u16_t  _hdrlen_rsvd_flags;
  u16_t  wnd;
  u16_t  chksum;
  u16_t  urgp;
};


#define TCPH_OFFSET(phdr) (ntohs((phdr)->_hdrlen_rsvd_flags) >> 8)
#define TCPH_HDRLEN(phdr) (ntohs((phdr)->_hdrlen_rsvd_flags) >> 12)
#define TCPH_FLAGS(phdr)  (ntohs((phdr)->_hdrlen_rsvd_flags) & TCP_FLAGS)

#define TCPH_OFFSET_SET(phdr, offset) (phdr)->_hdrlen_rsvd_flags = htons(((offset) << 8) | TCPH_FLAGS(phdr))
#define TCPH_HDRLEN_SET(phdr, len) (phdr)->_hdrlen_rsvd_flags = htons(((len) << 12) | TCPH_FLAGS(phdr))
#define TCPH_FLAGS_SET(phdr, flags) (phdr)->_hdrlen_rsvd_flags = htons((ntohs((phdr)->_hdrlen_rsvd_flags) & ~TCP_FLAGS) | (flags))
#define TCPH_SET_FLAG(phdr, flags ) (phdr)->_hdrlen_rsvd_flags = htons(ntohs((phdr)->_hdrlen_rsvd_flags) | (flags))
#define TCPH_UNSET_FLAG(phdr, flags) (phdr)->_hdrlen_rsvd_flags = htons(ntohs((phdr)->_hdrlen_rsvd_flags) | (TCPH_FLAGS(phdr) & ~(flags)) )

#define TCP_TCPLEN(seg) ((seg)->len + ((TCPH_FLAGS((seg)->tcphdr) & TCP_FIN || \
          TCPH_FLAGS((seg)->tcphdr) & TCP_SYN)? 1: 0))

enum tcp_state 
{
     CLOSED      = 0,
     LISTEN      = 1,
     SYN_SENT    = 2,
     SYN_RCVD    = 3,
     ESTABLISHED = 4,
     FIN_WAIT_1  = 5,
     FIN_WAIT_2  = 6,
     CLOSE_WAIT  = 7,
     CLOSING     = 8,
     LAST_ACK    = 9,
     TIME_WAIT   = 10
};


/* the TCP protocol control block */
struct tcp_pcb 
{
	    /* Protocol specific PCB members */
	
	    struct tcp_pcb *next;   /* for the linked list */
	
	    enum   tcp_state state;   /* TCP state */
	
	    u8_t   prio;
	    void   *callback_arg;
	    Uint32 local_ip;
        u16_t  local_port;
        Uint32 dest_ip;
	    u16_t  remote_port;
	  
	    u8_t    flags;
	    #define TF_ACK_DELAY (u8_t)0x01U   /* Delayed ACK. */
	    #define TF_ACK_NOW   (u8_t)0x02U   /* Immediate ACK. */
	    #define TF_INFR      (u8_t)0x04U   /* In fast recovery. */
	    #define TF_RESET     (u8_t)0x08U   /* Connection was reset. */
	    #define TF_CLOSED    (u8_t)0x10U   /* Connection was sucessfully closed. */
	    #define TF_GOT_FIN   (u8_t)0x20U   /* Connection was closed by the remote end. */
	    #define TF_NODELAY   (u8_t)0x40U   /* Disable Nagle algorithm */
	
	    /* receiver varables */
	    u32_t rcv_nxt;   /* next seqno expected */
	    u16_t rcv_wnd;   /* receiver window */
	  
	    /* Timers */
	    u32_t tmr;
	    u8_t  polltmr, pollinterval;
	  
	    /* Retransmission timer. */
	    u16_t rtime;
	  
	    u16_t mss;   /* maximum segment size */
	  
	    /* RTT estimation variables. */
	    u16_t rttest; /* RTT estimate in 500ms ticks */
	    u32_t rtseq;  /* sequence number being timed */
	    s16_t sa, sv;
	
	    u16_t rto;    /* retransmission time-out */
	    u8_t  nrtx;    /* number of retransmissions */
	
	    /* fast retransmit/recovery */
	    u32_t lastack; /* Highest acknowledged seqno. */
	    u8_t  dupacks;
	  
	    /* congestion avoidance/control variables */
	    u16_t cwnd;  
	    u16_t ssthresh;
	
	    /* sender variables */
	    u32_t snd_nxt,       /* next seqno to be sent */
	    snd_max,             /* Highest seqno sent. */
	    snd_wnd,             /* sender window */
	    snd_wl1, snd_wl2,    /* Sequence and acknowledgement numbers of last
	                            window update. */
	    snd_lbb;             /* Sequence number of next byte to be buffered. */
	
	    u16_t acked;
	  
	    u16_t snd_buf;       /* Available buffer space for sending (in bytes). */
	    u8_t snd_queuelen;   /* Available buffer space for sending (in tcp_segs). */
	  
	    /* These are ordered by sequence number: */
	    struct tcp_seg *unsent;   /* Unsent (queued) segments. */
	    struct tcp_seg *unacked;  /* Sent but unacknowledged segments. */
	    #if TCP_QUEUE_OOSEQ  
	    struct tcp_seg *ooseq;    /* Received out of sequence segments. */
	    #endif /* TCP_QUEUE_OOSEQ */
	
//	    #if LWIP_CALLBACK_API
	    /* Function to be called when more send buffer space is available. */
	    err_t (* sent)(void *arg, struct tcp_pcb *pcb, u16_t space);
	    /* Function to be called when (in-sequence) data has arrived. */