/** * @file * * Transmission Control Protocol for IP * * This file contains common functions for the TCP implementation, such as functinos * for manipulating the data structures and the TCP timer functions. TCP functions * related to input and output is found in tcp_in.c and tcp_out.c respectively. * *//* * Copyright (c) 2001-2004 Swedish Institute of Computer Science. * All rights reserved.  *  * Redistribution and use in source and binary forms, with or without modification,  * are permitted provided that the following conditions are met: * * 1. Redistributions of source code must retain the above copyright notice, *    this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright notice, *    this list of conditions and the following disclaimer in the documentation *    and/or other materials provided with the distribution. * 3. The name of the author may not be used to endorse or promote products *    derived from this software without specific prior written permission.  * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT  * SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT  * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY  * OF SUCH DAMAGE. * * This file is part of the lwIP TCP/IP stack. *  * Author: Adam Dunkels <adam@sics.se> * */#include <string.h>#include "lwip/opt.h"#include "lwip/def.h"#include "lwip/mem.h"#include "lwip/memp.h"#include "lwip/tcp.h"#if LWIP_TCP/* Incremented every coarse grained timer shot   (typically every 500 ms, determined by TCP_COARSE_TIMEOUT). */u32_t tcp_ticks;const u8_t tcp_backoff[13] =    { 1, 2, 3, 4, 5, 6, 7, 7, 7, 7, 7, 7, 7};/* The TCP PCB lists. *//** List of all TCP PCBs in LISTEN state */union tcp_listen_pcbs_t tcp_listen_pcbs;/** List of all TCP PCBs that are in a state in which * they accept or send data. */struct tcp_pcb *tcp_active_pcbs;  /** List of all TCP PCBs in TIME-WAIT state */struct tcp_pcb *tcp_tw_pcbs;struct tcp_pcb *tcp_tmp_pcb;static u8_t tcp_timer;static u16_t tcp_new_port(void);/** * Initializes the TCP layer. */voidtcp_init(void){  /* Clear globals. */  tcp_listen_pcbs.listen_pcbs = NULL;  tcp_active_pcbs = NULL;  tcp_tw_pcbs = NULL;  tcp_tmp_pcb = NULL;    /* initialize timer */  tcp_ticks = 0;  tcp_timer = 0;  }/** * Called periodically to dispatch TCP timers. * */voidtcp_tmr(void){  /* Call tcp_fasttmr() every 250 ms */  tcp_fasttmr();  if (++tcp_timer & 1) {    /* Call tcp_tmr() every 500 ms, i.e., every other timer       tcp_tmr() is called. */    tcp_slowtmr();  }}/** * Closes the connection held by the PCB. * */err_ttcp_close(struct tcp_pcb *pcb){  err_t err;#if TCP_DEBUG  LWIP_DEBUGF(TCP_DEBUG, ("tcp_close: closing in state "));  tcp_debug_print_state(pcb->state);  LWIP_DEBUGF(TCP_DEBUG, ("\n"));#endif /* TCP_DEBUG */  switch (pcb->state) {  case CLOSED:    /* Closing a pcb in the CLOSED state might seem erroneous,     * however, it is in this state once allocated and as yet unused     * and the user needs some way to free it should the need arise.     * Calling tcp_close() with a pcb that has already been closed, (i.e. twice)     * or for a pcb that has been used and then entered the CLOSED state      * is erroneous, but this should never happen as the pcb has in those cases     * been freed, and so any remaining handles are bogus. */    err = ERR_OK;    memp_free(MEMP_TCP_PCB, pcb);    pcb = NULL;    break;  case LISTEN:    err = ERR_OK;    tcp_pcb_remove((struct tcp_pcb **)&tcp_listen_pcbs.pcbs, pcb);    memp_free(MEMP_TCP_PCB_LISTEN, pcb);    pcb = NULL;    break;  case SYN_SENT:    err = ERR_OK;    tcp_pcb_remove(&tcp_active_pcbs, pcb);    memp_free(MEMP_TCP_PCB, pcb);    pcb = NULL;    break;  case SYN_RCVD:  case ESTABLISHED:    err = tcp_send_ctrl(pcb, TCP_FIN);    if (err == ERR_OK) {      pcb->state = FIN_WAIT_1;    }    break;  case CLOSE_WAIT:    err = tcp_send_ctrl(pcb, TCP_FIN);    if (err == ERR_OK) {      pcb->state = LAST_ACK;    }    break;  default:    /* Has already been closed, do nothing. */    err = ERR_OK;    pcb = NULL;    break;  }  if (pcb != NULL && err == ERR_OK) {    err = tcp_output(pcb);  }  return err;}/** * Aborts a connection by sending a RST to the remote host and deletes * the local protocol control block. This is done when a connection is * killed because of shortage of memory. * */voidtcp_abort(struct tcp_pcb *pcb){  u32_t seqno, ackno;  u16_t remote_port, local_port;  struct ip_addr remote_ip, local_ip;#if LWIP_CALLBACK_API    void (* errf)(void *arg, err_t err);#endif /* LWIP_CALLBACK_API */  void *errf_arg;    /* Figure out on which TCP PCB list we are, and remove us. If we     are in an active state, call the receive function associated with     the PCB with a NULL argument, and send an RST to the remote end. */  if (pcb->state == TIME_WAIT) {    tcp_pcb_remove(&tcp_tw_pcbs, pcb);    memp_free(MEMP_TCP_PCB, pcb);  } else {    seqno = pcb->snd_nxt;    ackno = pcb->rcv_nxt;    ip_addr_set(&local_ip, &(pcb->local_ip));    ip_addr_set(&remote_ip, &(pcb->remote_ip));    local_port = pcb->local_port;    remote_port = pcb->remote_port;#if LWIP_CALLBACK_API    errf = pcb->errf;#endif /* LWIP_CALLBACK_API */    errf_arg = pcb->callback_arg;    tcp_pcb_remove(&tcp_active_pcbs, pcb);    if (pcb->unacked != NULL) {      tcp_segs_free(pcb->unacked);    }    if (pcb->unsent != NULL) {      tcp_segs_free(pcb->unsent);    }#if TCP_QUEUE_OOSEQ        if (pcb->ooseq != NULL) {      tcp_segs_free(pcb->ooseq);    }#endif /* TCP_QUEUE_OOSEQ */    memp_free(MEMP_TCP_PCB, pcb);    TCP_EVENT_ERR(errf, errf_arg, ERR_ABRT);    LWIP_DEBUGF(TCP_RST_DEBUG, ("tcp_abort: sending RST\n"));    tcp_rst(seqno, ackno, &local_ip, &remote_ip, local_port, remote_port);  }}/** * Binds the connection to a local portnumber and IP address. If the * IP address is not given (i.e., ipaddr == NULL), the IP address of * the outgoing network interface is used instead. * */err_ttcp_bind(struct tcp_pcb *pcb, struct ip_addr *ipaddr, u16_t port){  struct tcp_pcb *cpcb;  if (port == 0) {    port = tcp_new_port();  }  /* Check if the address already is in use. */  for(cpcb = (struct tcp_pcb *)tcp_listen_pcbs.pcbs;      cpcb != NULL; cpcb = cpcb->next) {    if (cpcb->local_port == port) {      if (ip_addr_isany(&(cpcb->local_ip)) ||        ip_addr_isany(ipaddr) ||        ip_addr_cmp(&(cpcb->local_ip), ipaddr)) {          return ERR_USE;      }    }  }  for(cpcb = tcp_active_pcbs;      cpcb != NULL; cpcb = cpcb->next) {    if (cpcb->local_port == port) {      if (ip_addr_isany(&(cpcb->local_ip)) ||   ip_addr_isany(ipaddr) ||   ip_addr_cmp(&(cpcb->local_ip), ipaddr)) {  return ERR_USE;      }    }  }  if (!ip_addr_isany(ipaddr)) {    pcb->local_ip = *ipaddr;  }  pcb->local_port = port;  LWIP_DEBUGF(TCP_DEBUG, ("tcp_bind: bind to port %"U16_F"\n", port));  return ERR_OK;}#if LWIP_CALLBACK_APIstatic err_ttcp_accept_null(void *arg, struct tcp_pcb *pcb, err_t err){  (void)arg;  (void)pcb;  (void)err;  return ERR_ABRT;}#endif /* LWIP_CALLBACK_API *//** * Set the state of the connection to be LISTEN, which means that it * is able to accept incoming connections. The protocol control block * is reallocated in order to consume less memory. Setting the * connection to LISTEN is an irreversible process. * */struct tcp_pcb *tcp_listen(struct tcp_pcb *pcb){  struct tcp_pcb_listen *lpcb;  /* already listening? */  if (pcb->state == LISTEN) {    return pcb;  }  lpcb = memp_malloc(MEMP_TCP_PCB_LISTEN);  if (lpcb == NULL) {    return NULL;  }  lpcb->callback_arg = pcb->callback_arg;  lpcb->local_port = pcb->local_port;  lpcb->state = LISTEN;  lpcb->so_options = pcb->so_options;  lpcb->so_options |= SOF_ACCEPTCONN;  lpcb->ttl = pcb->ttl;  lpcb->tos = pcb->tos;  ip_addr_set(&lpcb->local_ip, &pcb->local_ip);  memp_free(MEMP_TCP_PCB, pcb);#if LWIP_CALLBACK_API  lpcb->accept = tcp_accept_null;#endif /* LWIP_CALLBACK_API */  TCP_REG(&tcp_listen_pcbs.listen_pcbs, lpcb);  return (struct tcp_pcb *)lpcb;}/** * This function should be called by the application when it has * processed the data. The purpose is to advertise a larger window * when the data has been processed. * */voidtcp_recved(struct tcp_pcb *pcb, u16_t len){  if ((u32_t)pcb->rcv_wnd + len > TCP_WND) {    pcb->rcv_wnd = TCP_WND;  } else {    pcb->rcv_wnd += len;  }  if (!(pcb->flags & TF_ACK_DELAY) &&     !(pcb->flags & TF_ACK_NOW)) {    /*     * We send an ACK here (if one is not already pending, hence     * the above tests) as tcp_recved() implies that the application     * has processed some data, and so we can open the receiver's     * window to allow more to be transmitted.  This could result in     * two ACKs being sent for each received packet in some limited cases     * (where the application is only receiving data, and is slow to     * process it) but it is necessary to guarantee that the sender can     * continue to transmit.     */    tcp_ack(pcb);  }   else if (pcb->flags & TF_ACK_DELAY && pcb->rcv_wnd >= TCP_WND/2) {    /* If we can send a window update such that there is a full     * segment available in the window, do so now.  This is sort of     * nagle-like in its goals, and tries to hit a compromise between     * sending acks each time the window is updated, and only sending     * window updates when a timer expires.  The "threshold" used     * above (currently TCP_WND/2) can be tuned to be more or less     * aggressive  */    tcp_ack_now(pcb);  }  LWIP_DEBUGF(TCP_DEBUG, ("tcp_recved: recveived %"U16_F" bytes, wnd %"U16_F" (%"U16_F").\n",         len, pcb->rcv_wnd, TCP_WND - pcb->rcv_wnd));}/** * A nastly hack featuring 'goto' statements that allocates a * new TCP local port. */static u16_ttcp_new_port(void){  struct tcp_pcb *pcb;#ifndef TCP_LOCAL_PORT_RANGE_START#define TCP_LOCAL_PORT_RANGE_START 4096#define TCP_LOCAL_PORT_RANGE_END   0x7fff#endif  static u16_t port = TCP_LOCAL_PORT_RANGE_START;   again:  if (++port > TCP_LOCAL_PORT_RANGE_END) {    port = TCP_LOCAL_PORT_RANGE_START;  }    for(pcb = tcp_active_pcbs; pcb != NULL; pcb = pcb->next) {    if (pcb->local_port == port) {      goto again;    }  }  for(pcb = tcp_tw_pcbs; pcb != NULL; pcb = pcb->next) {    if (pcb->local_port == port) {      goto again;    }