/* 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. */  err_t (* recv)(void *arg, struct tcp_pcb *pcb, struct pbuf *p, err_t err);  /* Function to be called when a connection has been set up. */  err_t (* connected)(void *arg, struct tcp_pcb *pcb, err_t err);  /* Function to call when a listener has been connected. */  err_t (* accept)(void *arg, struct tcp_pcb *newpcb, err_t err);  /* Function which is called periodically. */  err_t (* poll)(void *arg, struct tcp_pcb *pcb);  /* Function to be called whenever a fatal error occurs. */  void (* errf)(void *arg, err_t err);#endif /* LWIP_CALLBACK_API */  /* idle time before KEEPALIVE is sent */  u32_t keepalive;    /* KEEPALIVE counter */  u8_t keep_cnt;};struct tcp_pcb_listen {  /* Common members of all PCB types */  IP_PCB;/* Protocol specific PCB members */  struct tcp_pcb_listen *next;   /* for the linked list */    /* Even if state is obviously LISTEN this is here for   * field compatibility with tpc_pcb to which it is cast sometimes   * Until a cleaner solution emerges this is here.FIXME   */   enum tcp_state state;   /* TCP state */  u8_t prio;  void *callback_arg;    u16_t local_port; #if LWIP_CALLBACK_API  /* Function to call when a listener has been connected. */  err_t (* accept)(void *arg, struct tcp_pcb *newpcb, err_t err);#endif /* LWIP_CALLBACK_API */};#if LWIP_EVENT_APIenum lwip_event {  LWIP_EVENT_ACCEPT,  LWIP_EVENT_SENT,  LWIP_EVENT_RECV,  LWIP_EVENT_CONNECTED,  LWIP_EVENT_POLL,  LWIP_EVENT_ERR};err_t lwip_tcp_event(void *arg, struct tcp_pcb *pcb,         enum lwip_event,         struct pbuf *p,         u16_t size,         err_t err);#define TCP_EVENT_ACCEPT(pcb,err,ret)    ret = lwip_tcp_event((pcb)->callback_arg, (pcb),\                LWIP_EVENT_ACCEPT, NULL, 0, err)#define TCP_EVENT_SENT(pcb,space,ret) ret = lwip_tcp_event((pcb)->callback_arg, (pcb),\                   LWIP_EVENT_SENT, NULL, space, ERR_OK)#define TCP_EVENT_RECV(pcb,p,err,ret) ret = lwip_tcp_event((pcb)->callback_arg, (pcb),\                LWIP_EVENT_RECV, (p), 0, (err))#define TCP_EVENT_CONNECTED(pcb,err,ret) ret = lwip_tcp_event((pcb)->callback_arg, (pcb),\                LWIP_EVENT_CONNECTED, NULL, 0, (err))#define TCP_EVENT_POLL(pcb,ret)       ret = lwip_tcp_event((pcb)->callback_arg, (pcb),\                LWIP_EVENT_POLL, NULL, 0, ERR_OK)#define TCP_EVENT_ERR(errf,arg,err)  lwip_tcp_event((arg), NULL, \                LWIP_EVENT_ERR, NULL, 0, (err))#else /* LWIP_EVENT_API */#define TCP_EVENT_ACCEPT(pcb,err,ret)     \                        if((pcb)->accept != NULL) \                        (ret = (pcb)->accept((pcb)->callback_arg,(pcb),(err)))#define TCP_EVENT_SENT(pcb,space,ret) \                        if((pcb)->sent != NULL) \                        (ret = (pcb)->sent((pcb)->callback_arg,(pcb),(space)))#define TCP_EVENT_RECV(pcb,p,err,ret) \                        if((pcb)->recv != NULL) \                        { ret = (pcb)->recv((pcb)->callback_arg,(pcb),(p),(err)); } else { \            pbuf_free(p); }#define TCP_EVENT_CONNECTED(pcb,err,ret) \                        if((pcb)->connected != NULL) \                        (ret = (pcb)->connected((pcb)->callback_arg,(pcb),(err)))#define TCP_EVENT_POLL(pcb,ret) \                        if((pcb)->poll != NULL) \                        (ret = (pcb)->poll((pcb)->callback_arg,(pcb)))#define TCP_EVENT_ERR(errf,arg,err) \                        if((errf) != NULL) \                        (errf)((arg),(err))#endif /* LWIP_EVENT_API *//* This structure is used to repressent TCP segments when queued. */struct tcp_seg {  struct tcp_seg *next;    /* used when putting segements on a queue */  struct pbuf *p;          /* buffer containing data + TCP header */  void *dataptr;           /* pointer to the TCP data in the pbuf */  u16_t len;               /* the TCP length of this segment */  struct tcp_hdr *tcphdr;  /* the TCP header */};/* Internal functions and global variables: */struct tcp_pcb *tcp_pcb_copy(struct tcp_pcb *pcb);void tcp_pcb_purge(struct tcp_pcb *pcb);void tcp_pcb_remove(struct tcp_pcb **pcblist, struct tcp_pcb *pcb);u8_t tcp_segs_free(struct tcp_seg *seg);u8_t tcp_seg_free(struct tcp_seg *seg);struct tcp_seg *tcp_seg_copy(struct tcp_seg *seg);#define tcp_ack(pcb)     if((pcb)->flags & TF_ACK_DELAY) { \                            (pcb)->flags &= ~TF_ACK_DELAY; \                            (pcb)->flags |= TF_ACK_NOW; \                            tcp_output(pcb); \                         } else { \                            (pcb)->flags |= TF_ACK_DELAY; \                         }#define tcp_ack_now(pcb) (pcb)->flags |= TF_ACK_NOW; \                         tcp_output(pcb)err_t tcp_send_ctrl(struct tcp_pcb *pcb, u8_t flags);err_t tcp_enqueue(struct tcp_pcb *pcb, void *dataptr, u16_t len,    u8_t flags, u8_t copy,                u8_t *optdata, u8_t optlen);void tcp_rexmit_seg(struct tcp_pcb *pcb, struct tcp_seg *seg);void tcp_rst(u32_t seqno, u32_t ackno,       struct ip_addr *local_ip, struct ip_addr *remote_ip,       u16_t local_port, u16_t remote_port);u32_t tcp_next_iss(void);void tcp_keepalive(struct tcp_pcb *pcb);extern struct tcp_pcb *tcp_input_pcb;extern u32_t tcp_ticks;#if TCP_DEBUG || TCP_INPUT_DEBUG || TCP_OUTPUT_DEBUGvoid tcp_debug_print(struct tcp_hdr *tcphdr);void tcp_debug_print_flags(u8_t flags);void tcp_debug_print_state(enum tcp_state s);void tcp_debug_print_pcbs(void);int tcp_pcbs_sane(void);#else#  define tcp_debug_print(tcphdr)#  define tcp_debug_print_flags(flags)#  define tcp_debug_print_state(s)#  define tcp_debug_print_pcbs()#  define tcp_pcbs_sane() 1#endif /* TCP_DEBUG */#if NO_SYS#define tcp_timer_needed()#elsevoid tcp_timer_needed(void);#endif/* The TCP PCB lists. */union tcp_listen_pcbs_t { /* List of all TCP PCBs in LISTEN state. */	struct tcp_pcb_listen *listen_pcbs; 	struct tcp_pcb *pcbs;};extern union tcp_listen_pcbs_t tcp_listen_pcbs;extern struct tcp_pcb *tcp_active_pcbs;  /* List of all TCP PCBs that are in a              state in which they accept or send              data. */extern struct tcp_pcb *tcp_tw_pcbs;      /* List of all TCP PCBs in TIME-WAIT. */extern struct tcp_pcb *tcp_tmp_pcb;      /* Only used for temporary storage. *//* Axioms about the above lists:      1) Every TCP PCB that is not CLOSED is in one of the lists.   2) A PCB is only in one of the lists.   3) All PCBs in the tcp_listen_pcbs list is in LISTEN state.   4) All PCBs in the tcp_tw_pcbs list is in TIME-WAIT state.*//* Define two macros, TCP_REG and TCP_RMV that registers a TCP PCB   with a PCB list or removes a PCB from a list, respectively. */#if 0#define TCP_REG(pcbs, npcb) do {\                            LWIP_DEBUGF(TCP_DEBUG, ("TCP_REG %p local port %d\n", npcb, npcb->local_port)); \                            for(tcp_tmp_pcb = *pcbs; \          tcp_tmp_pcb != NULL; \        tcp_tmp_pcb = tcp_tmp_pcb->next) { \                                LWIP_ASSERT("TCP_REG: already registered\n", tcp_tmp_pcb != npcb); \                            } \                            LWIP_ASSERT("TCP_REG: pcb->state != CLOSED", npcb->state != CLOSED); \                            npcb->next = *pcbs; \                            LWIP_ASSERT("TCP_REG: npcb->next != npcb", npcb->next != npcb); \                            *(pcbs) = npcb; \                            LWIP_ASSERT("TCP_RMV: tcp_pcbs sane", tcp_pcbs_sane()); \              tcp_timer_needed(); \                            } while(0)#define TCP_RMV(pcbs, npcb) do { \                            LWIP_ASSERT("TCP_RMV: pcbs != NULL", *pcbs != NULL); \                            LWIP_DEBUGF(TCP_DEBUG, ("TCP_RMV: removing %p from %p\n", npcb, *pcbs)); \                            if(*pcbs == npcb) { \                               *pcbs = (*pcbs)->next; \                            } else for(tcp_tmp_pcb = *pcbs; tcp_tmp_pcb != NULL; tcp_tmp_pcb = tcp_tmp_pcb->next) { \                               if(tcp_tmp_pcb->next != NULL && tcp_tmp_pcb->next == npcb) { \                                  tcp_tmp_pcb->next = npcb->next; \                                  break; \                               } \                            } \                            npcb->next = NULL; \                            LWIP_ASSERT("TCP_RMV: tcp_pcbs sane", tcp_pcbs_sane()); \                            LWIP_DEBUGF(TCP_DEBUG, ("TCP_RMV: removed %p from %p\n", npcb, *pcbs)); \                            } while(0)#else /* LWIP_DEBUG */#define TCP_REG(pcbs, npcb) do { \                            npcb->next = *pcbs; \                            *(pcbs) = npcb; \              tcp_timer_needed(); \                            } while(0)#define TCP_RMV(pcbs, npcb) do { \                            if(*(pcbs) == npcb) { \                               (*(pcbs)) = (*pcbs)->next; \                            } else for(tcp_tmp_pcb = *pcbs; tcp_tmp_pcb != NULL; tcp_tmp_pcb = tcp_tmp_pcb->next) { \                               if(tcp_tmp_pcb->next != NULL && tcp_tmp_pcb->next == npcb) { \                                  tcp_tmp_pcb->next = npcb->next; \                                  break; \                               } \                            } \                            npcb->next = NULL; \                            } while(0)#endif /* LWIP_DEBUG */#endif /* __LWIP_TCP_H__ */