开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 查看源码
tcp.c
资源名称：LWIP+GTM900+LPC2104.rar　[点击查看]
上传用户：yyhongfa
上传日期：2013-01-18
资源大小：267k
文件大小：38k
源码类别：

嵌入式/单片机编程

开发平台：

C/C++

tcp.c：源码内容
  1. /**
  2.  * @file
  3.  *
  4.  * Transmission Control Protocol for IP
  5.  *
  6.  * This file contains common functions for the TCP implementation, such as functinos
  7.  * for manipulating the data structures and the TCP timer functions. TCP functions
  8.  * related to input and output is found in tcp_in.c and tcp_out.c respectively.
  9.  *
  10.  */
  12. /*
  13.  * Copyright (c) 2001-2004 Swedish Institute of Computer Science.
  14.  * All rights reserved. 
  15.  * 
  16.  * Redistribution and use in source and binary forms, with or without modification, 
  17.  * are permitted provided that the following conditions are met:
  18.  *
  19.  * 1. Redistributions of source code must retain the above copyright notice,
  20.  *    this list of conditions and the following disclaimer.
  21.  * 2. Redistributions in binary form must reproduce the above copyright notice,
  22.  *    this list of conditions and the following disclaimer in the documentation
  23.  *    and/or other materials provided with the distribution.
  24.  * 3. The name of the author may not be used to endorse or promote products
  25.  *    derived from this software without specific prior written permission. 
  26.  *
  27.  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED 
  28.  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 
  29.  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT 
  30.  * SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, 
  31.  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT 
  32.  * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 
  33.  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 
  34.  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING 
  35.  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY 
  36.  * OF SUCH DAMAGE.
  37.  *
  38.  * This file is part of the lwIP TCP/IP stack.
  39.  * 
  40.  * Author: Adam Dunkels <adam@sics.se>
  41.  *
  42.  */
  44. #include <string.h>
  46. #include "lwip/opt.h"
  47. #include "lwip/def.h"
  48. #include "lwip/mem.h"
  49. #include "lwip/memp.h"
  51. #include "lwip/tcp.h"
  53. #include "uart.h"
  54. #if LWIP_TCP
  56. /* Incremented every coarse grained timer shot
  57.    (typically every 500 ms, determined by TCP_COARSE_TIMEOUT). */
  58. u32_t tcp_ticks;
  59. const u8_t tcp_backoff[13] =
  60.     { 1, 2, 3, 4, 5, 6, 7, 7, 7, 7, 7, 7, 7};
  62. /* The TCP PCB lists. */
  64. /** List of all TCP PCBs in LISTEN state */
  65. union tcp_listen_pcbs_t tcp_listen_pcbs;
  66. /** List of all TCP PCBs that are in a state in which
  67.  * they accept or send data. */
  68. struct tcp_pcb *tcp_active_pcbs;  
  69. /** List of all TCP PCBs in TIME-WAIT state */
  70. struct tcp_pcb *tcp_tw_pcbs;
  72. struct tcp_pcb *tcp_tmp_pcb;
  74. static u8_t tcp_timer;
  75. static u16_t tcp_new_port(void);
  77. /**
  78.  * Initializes the TCP layer.
  79.  */
  80. void
  81. tcp_init(void)
  82. {
  83.   /* Clear globals. */
  84.   tcp_listen_pcbs.listen_pcbs = NULL;
  85.   tcp_active_pcbs = NULL;
  86.   tcp_tw_pcbs = NULL;
  87.   tcp_tmp_pcb = NULL;
  88.   
  89.   /* initialize timer */
  90.   tcp_ticks = 0;
  91.   tcp_timer = 0;
  92.   
  93. }
  95. /*
  96. *this fun will be called ,when some EVENT happed to TCP CONNECT
  97. * created by skier 2006.01.30
  98. */
  99. #if LWIP_EVENT_API
  101. typedef enum
  102. {
  103.     PPP_DEAD = 0,
  104.     PPP_ESTABLISHED,
  105.     UDP_ESTABLISHED,
  106.     TCP_CONNECTING,
  107.     TCP_ESTABLISHED,
  108.     TCP_CLOSING,
  109.     
  110.     TCPIP_STATE_UNKNOWN, 
  111. }MY_TCPIP_STATE;
  112. extern void set_Mytcpip_state(MY_TCPIP_STATE state);
  113. extern void tcp_data_ind(u8_t *buf, u16_t len);
  114. extern void clear_sys_err(void);
  115. extern void add_sys_err(void);
  117. /*
  118. *create by skier 2006.01.31
  119. *this func will be called when the state of TCP Connect is changed.
  120. *this fun is very simple, you shuold complete it very carefully.
  121. */
  122. err_t lwip_tcp_event(void *arg, struct tcp_pcb *pcb,
  123.          LWIP_STATE lwip_event,
  124.          struct pbuf *p,
  125.          u16_t size,
  126.          err_t err)
  127. {
  128.      struct pbuf *temp = p;
  130.      //DEBUG_FUNCTION("lwip_tcp_event()");
  132.      switch(lwip_event)
  133.      {
  134.           case LWIP_EVENT_ACCEPT:
  135.      //tcp listen. accept a TCP Connect.
  136.                    DEBUG_EVENT("LWIP_EVENT_ACCEPT");
  137.      break;
  139.           case LWIP_EVENT_SENT:
  140.       //receive the ACK from TCP Peer.
  141.       //Data send successful!
  142.                    DEBUG_EVENT("LWIP_EVENT_SENT");
  143.      clear_sys_err();
  144.      break;
  146.   /*
  147.   *receive some data from TCP Peer
  148.   */
  149.           case LWIP_EVENT_RECV:
  150.      DEBUG_EVENT("LWIP_EVENT_RECV");
  151.  
  152.      while(temp != NULL)
  153.                    {
  154.                           tcp_data_ind((u8_t *)temp->payload, temp->len);
  155.                    temp = temp->next;
  156.                    }
  157.      clear_sys_err();
  158.  
  159.      break;
  161.           case LWIP_EVENT_CONNECTED:
  162.      //I this the connect of My TCP connect successful!
  163.      DEBUG_EVENT("LWIP_EVENT_CONNECTED");
  164.      set_Mytcpip_state(TCP_ESTABLISHED);
  165.      break;
  166.   
  167.           case LWIP_EVENT_POLL:
  168.                     // DEBUG_EVENT("LWIP_EVENT_POLL");
  169. break;
  171.           case LWIP_EVENT_ERR:
  172.      DEBUG_EVENT("LWIP_EVENT_ERR");                
  173.      set_Mytcpip_state(PPP_ESTABLISHED);
  174.      add_sys_err();
  175.     break;
  177.    default : 
  178.     break;
  179.      }
  181.    return ERR_OK;  
  182. }
  183. #endif
  185. #if LWIP_TCP
  186. static int tcpip_tcp_timer_active = 0;
  188. static void
  189. tcpip_tcp_timer(void *arg)
  190. {
  191.   (void)arg;
  193.   /* call TCP timer handler */
  194.   tcp_tmr();
  195.   /* timer still needed? */
  196.   if (tcp_active_pcbs || tcp_tw_pcbs) {
  197.     /* restart timer */
  198.     //TIMEOUT(TCP_TMR_INTERVAL, tcpip_tcp_timer, NULL);
  199.       TCP_TIMER_START(TCP_TMR_INTERVAL, tcpip_tcp_timer, NULL);
  200.   } else {
  201.     /* disable timer */
  202.     tcpip_tcp_timer_active = 0;
  203. /*
  204. *new added by skier 2006.01.29
  205. */
  206.     TCP_TIMER_STOP(tcpip_tcp_timer, NULL);
  207.   }
  208. }
  210. #if !NO_SYS
  211. void
  212. tcp_timer_needed(void)
  213. {
  214.   /* timer is off but needed again? */
  215.   if (!tcpip_tcp_timer_active && (tcp_active_pcbs || tcp_tw_pcbs)) {
  216.     /* enable and start timer */
  217.     tcpip_tcp_timer_active = 1;
  218.     TCP_TIMER_START(TCP_TMR_INTERVAL, tcpip_tcp_timer, NULL);
  219.   }
  220. }
  221. #endif /* !NO_SYS */
  222. #endif /* LWIP_TCP */
  225. /**
  226.  * Called periodically to dispatch TCP timers.
  227.  *
  228.  */
  229. void
  230. tcp_tmr(void)
  231. {
  232.   /* Call tcp_fasttmr() every 250 ms */
  233.   tcp_fasttmr();
  235.   if (++tcp_timer & 1) {
  236.     /* Call tcp_tmr() every 500 ms, i.e., every other timer
  237.        tcp_tmr() is called. */
  238.     tcp_slowtmr();
  239.   }
  240. }
  242. /**
  243.  * Closes the connection held by the PCB.
  244.  *
  245.  */
  246. err_t
  247. tcp_close(struct tcp_pcb *pcb)
  248. {
  249.   err_t err;
  251. #if TCP_DEBUG
  252.   LWIP_DEBUGF(TCP_DEBUG, ("tcp_close: closing in state "));
  253.   tcp_debug_print_state(pcb->state);
  254.   LWIP_DEBUGF(TCP_DEBUG, ("n"));
  255. #endif /* TCP_DEBUG */
  256.   switch (pcb->state) {
  257.   case CLOSED:
  258.     /* Closing a pcb in the CLOSED state might seem erroneous,
  259.      * however, it is in this state once allocated and as yet unused
  260.      * and the user needs some way to free it should the need arise.
  261.      * Calling tcp_close() with a pcb that has already been closed, (i.e. twice)
  262.      * or for a pcb that has been used and then entered the CLOSED state 
  263.      * is erroneous, but this should never happen as the pcb has in those cases
  264.      * been freed, and so any remaining handles are bogus. */
  265.     err = ERR_OK;
  266.     memp_free(MEMP_TCP_PCB, pcb);
  267.     pcb = NULL;
  268.     break;
  269.   case LISTEN:
  270.     err = ERR_OK;
  271.     tcp_pcb_remove((struct tcp_pcb **)&tcp_listen_pcbs.pcbs, pcb);
  272.     memp_free(MEMP_TCP_PCB_LISTEN, pcb);
  273.     pcb = NULL;
  274.     break;
  275.   case SYN_SENT:
  276.     err = ERR_OK;
  277.     tcp_pcb_remove(&tcp_active_pcbs, pcb);
  278.     memp_free(MEMP_TCP_PCB, pcb);
  279.     pcb = NULL;
  280.     break;
  281.   case SYN_RCVD:
  282.   case ESTABLISHED:
  283.     err = tcp_send_ctrl(pcb, TCP_FIN);
  284.     if (err == ERR_OK) {
  285.       pcb->state = FIN_WAIT_1;
  286.     }
  287.     break;
  288.   case CLOSE_WAIT:
  289.     err = tcp_send_ctrl(pcb, TCP_FIN);
  290.     if (err == ERR_OK) {
  291.       pcb->state = LAST_ACK;
  292.     }
  293.     break;
  294.   default:
  295.     /* Has already been closed, do nothing. */
  296.     err = ERR_OK;
  297.     pcb = NULL;
  298.     break;
  299.   }
  301.   if (pcb != NULL && err == ERR_OK) {
  302.     err = tcp_output(pcb);
  303.   }
  304.   return err;
  305. }
  307. /**
  308.  * Aborts a connection by sending a RST to the remote host and deletes
  309.  * the local protocol control block. This is done when a connection is
  310.  * killed because of shortage of memory.
  311.  *
  312.  */
  313. void
  314. tcp_abort(struct tcp_pcb *pcb)
  315. {
  316.   u32_t seqno, ackno;
  317.   u16_t remote_port, local_port;
  318.   struct ip_addr remote_ip, local_ip;
  319. #if LWIP_CALLBACK_API  
  320.   void (* errf)(void *arg, err_t err);
  321. #endif /* LWIP_CALLBACK_API */
  322.   void *errf_arg;
  324.   
  325.   /* Figure out on which TCP PCB list we are, and remove us. If we
  326.      are in an active state, call the receive function associated with
  327.      the PCB with a NULL argument, and send an RST to the remote end. */
  328.   if (pcb->state == TIME_WAIT) {
  329.     tcp_pcb_remove(&tcp_tw_pcbs, pcb);
  330.     memp_free(MEMP_TCP_PCB, pcb);
  331.   } else {
  332.     seqno = pcb->snd_nxt;
  333.     ackno = pcb->rcv_nxt;
  334.     ip_addr_set(&local_ip, &(pcb->local_ip));
  335.     ip_addr_set(&remote_ip, &(pcb->remote_ip));
  336.     local_port = pcb->local_port;
  337.     remote_port = pcb->remote_port;
  338. #if LWIP_CALLBACK_API
  339.     errf = pcb->errf;
  340. #endif /* LWIP_CALLBACK_API */
  341.     errf_arg = pcb->callback_arg;
  342.     tcp_pcb_remove(&tcp_active_pcbs, pcb);
  343.     if (pcb->unacked != NULL) {
  344.       tcp_segs_free(pcb->unacked);
  345.     }
  346.     if (pcb->unsent != NULL) {
  347.       tcp_segs_free(pcb->unsent);
  348.     }
  349. #if TCP_QUEUE_OOSEQ    
  350.     if (pcb->ooseq != NULL) {
  351.       tcp_segs_free(pcb->ooseq);
  352.     }
  353. #endif /* TCP_QUEUE_OOSEQ */
  354.     memp_free(MEMP_TCP_PCB, pcb);
  355.     TCP_EVENT_ERR(errf, errf_arg, ERR_ABRT);
  356.     LWIP_DEBUGF(TCP_RST_DEBUG, ("tcp_abort: sending RSTn"));
  357.     tcp_rst(seqno, ackno, &local_ip, &remote_ip, local_port, remote_port);
  358.   }
  359. }
  361. /**
  362.  * Binds the connection to a local portnumber and IP address. If the
  363.  * IP address is not given (i.e., ipaddr == NULL), the IP address of
  364.  * the outgoing network interface is used instead.
  365.  *
  366.  */
  368. err_t
  369. tcp_bind(struct tcp_pcb *pcb, struct ip_addr *ipaddr, u16_t port)
  370. {
  371.   struct tcp_pcb *cpcb;
  372. #if SO_REUSE
  373.   int reuse_port_all_set = 1;
  374. #endif /* SO_REUSE */
  376.   if (port == 0) {
  377.     port = tcp_new_port();
  378.   }
  379. #if SO_REUSE == 0
  380.   /* Check if the address already is in use. */
  381.   for(cpcb = (struct tcp_pcb *)tcp_listen_pcbs.pcbs;
  382.       cpcb != NULL; cpcb = cpcb->next) {
  383.     if (cpcb->local_port == port) {
  384.       if (ip_addr_isany(&(cpcb->local_ip)) ||
  385.         ip_addr_isany(ipaddr) ||
  386.         ip_addr_cmp(&(cpcb->local_ip), ipaddr)) {
  387.           return ERR_USE;
  388.       }
  389.     }
  390.   }
  391.   for(cpcb = tcp_active_pcbs;
  392.       cpcb != NULL; cpcb = cpcb->next) {
  393.     if (cpcb->local_port == port) {
  394.       if (ip_addr_isany(&(cpcb->local_ip)) ||
  395.    ip_addr_isany(ipaddr) ||
  396.    ip_addr_cmp(&(cpcb->local_ip), ipaddr)) {
  397.   return ERR_USE;
  398.       }
  399.     }
  400.   }
  401. #else /* SO_REUSE */
  402.   /* Search through list of PCB's in LISTEN state. 
  403.      
  404.   If there is a PCB bound to specified port and IP_ADDR_ANY another PCB can be bound to the interface IP
  405.   or to the loopback address on the same port if SOF_REUSEADDR is set. Any combination of PCB's bound to 
  406.   the same local port, but to one address out of {IP_ADDR_ANY, 127.0.0.1, interface IP} at a time is valid.
  407.   But no two PCB's bound to same local port and same local address is valid.
  408.   
  409.   If SOF_REUSEPORT is set several PCB's can be bound to same local port and same local address also. But then 
  410.   all PCB's must have the SOF_REUSEPORT option set.
  411.   
  412.   When the two options aren't set and specified port is already bound, ERR_USE is returned saying that 
  413.   address is already in use. */
  414.   for(cpcb = (struct tcp_pcb *)tcp_listen_pcbs.pcbs; cpcb != NULL; cpcb = cpcb->next) {
  415.     if(cpcb->local_port == port) {
  416.       if(ip_addr_cmp(&(cpcb->local_ip), ipaddr)) {
  417.         if(pcb->so_options & SOF_REUSEPORT) {
  418.           LWIP_DEBUGF(TCP_DEBUG, ("tcp_bind: in listening PCB's: SO_REUSEPORT set and same address.n"));
  419.           reuse_port_all_set = (reuse_port_all_set && (cpcb->so_options & SOF_REUSEPORT));
  420.         }
  421.         else {
  422.           LWIP_DEBUGF(TCP_DEBUG, ("tcp_bind: in listening PCB's: SO_REUSEPORT not set and same address.n"));
  423.           return ERR_USE;
  424.         }
  425.       }
  426.       else if((ip_addr_isany(ipaddr) && !ip_addr_isany(&(cpcb->local_ip))) ||
  427.               (!ip_addr_isany(ipaddr) && ip_addr_isany(&(cpcb->local_ip)))) {
  428.         if(!(pcb->so_options & SOF_REUSEADDR) && !(pcb->so_options & SOF_REUSEPORT)) {
  429.           LWIP_DEBUGF(TCP_DEBUG, ("tcp_bind: in listening PCB's SO_REUSEPORT or SO_REUSEADDR not set and not the same address.n"));
  430.           return ERR_USE;
  431.         }      
  432.         else {
  433.           LWIP_DEBUGF(TCP_DEBUG, ("tcp_bind: in listening PCB's SO_REUSEPORT or SO_REUSEADDR set and not the same address.n"));
  434.         }     
  435.       }
  436.     }
  437.   }
  439.   /* Search through list of PCB's in a state in which they can accept or send data. Same decription as for 
  440.      PCB's in state LISTEN applies to this PCB's regarding the options SOF_REUSEADDR and SOF_REUSEPORT. */
  441.   for(cpcb = tcp_active_pcbs; cpcb != NULL; cpcb = cpcb->next) {
  442.     if(cpcb->local_port == port) {
  443.       if(ip_addr_cmp(&(cpcb->local_ip), ipaddr)) {
  444.         if(pcb->so_options & SOF_REUSEPORT) {
  445.           LWIP_DEBUGF(TCP_DEBUG, ("tcp_bind: in active PCB's SO_REUSEPORT set and same address.n"));
  446.           reuse_port_all_set = (reuse_port_all_set && (cpcb->so_options & SOF_REUSEPORT));
  447.         }
  448.         else {
  449.           LWIP_DEBUGF(TCP_DEBUG, ("tcp_bind: in active PCB's SO_REUSEPORT not set and same address.n"));
  450.           return ERR_USE;
  451.         }
  452.       }
  453.       else if((ip_addr_isany(ipaddr) && !ip_addr_isany(&(cpcb->local_ip))) ||
  454.               (!ip_addr_isany(ipaddr) && ip_addr_isany(&(cpcb->local_ip)))) {
  455.         if(!(pcb->so_options & SOF_REUSEADDR) && !(pcb->so_options & SOF_REUSEPORT)) {
  456.           LWIP_DEBUGF(TCP_DEBUG, ("tcp_bind: in active PCB's SO_REUSEPORT or SO_REUSEADDR not set and not the same address.n"));
  457.           return ERR_USE;
  458.         }   
  459.         else {
  460.           LWIP_DEBUGF(TCP_DEBUG, ("tcp_bind: in active PCB's SO_REUSEPORT or SO_REUSEADDR set and not the same address.n"));
  461.         }        
  462.       }
  463.     }
  464.   }
  466.   /* Search through list of PCB's in TIME_WAIT state. If SO_REUSEADDR is set a bound combination [IP, port} 
  467.      can be rebound. The same applies when SOF_REUSEPORT is set. 
  468.      
  469.      If SOF_REUSEPORT is set several PCB's can be bound to same local port and same local address also. But then 
  470.      all PCB's must have the SOF_REUSEPORT option set.
  471.      
  472.      When the two options aren't set and specified port is already bound, ERR_USE is returned saying that 
  473.      address is already in use. */
  474.   for(cpcb = tcp_tw_pcbs; cpcb != NULL; cpcb = cpcb->next) {
  475.     if(cpcb->local_port == port) {
  476.       if(ip_addr_cmp(&(cpcb->local_ip), ipaddr)) {
  477.         if(!(pcb->so_options & SOF_REUSEADDR) && !(pcb->so_options & SOF_REUSEPORT)) {
  478.           LWIP_DEBUGF(TCP_DEBUG, ("tcp_bind: in TIME_WAIT PCB's SO_REUSEPORT or SO_REUSEADDR not set and same address.n"));
  479.           return ERR_USE;
  480.         }
  481.         else if(pcb->so_options & SOF_REUSEPORT) {
  482.           LWIP_DEBUGF(TCP_DEBUG, ("tcp_bind: in TIME_WAIT PCB's SO_REUSEPORT set and same address.n"));
  483.           reuse_port_all_set = (reuse_port_all_set && (cpcb->so_options & SOF_REUSEPORT));
  484.         }
  485.       }
  486.     }
  487.   }
  489.   /* If SOF_REUSEPORT isn't set in all PCB's bound to specified port and local address specified then 
  490.      {IP, port} can't be reused. */
  491.   if(!reuse_port_all_set) {
  492.     LWIP_DEBUGF(TCP_DEBUG, ("tcp_bind: not all sockets have SO_REUSEPORT set.n"));
  493.     return ERR_USE;
  494.   }
  495. #endif /* SO_REUSE */
  497.   if (!ip_addr_isany(ipaddr)) {
  498.     pcb->local_ip = *ipaddr;
  499.   }
  500.   pcb->local_port = port;
  501.   LWIP_DEBUGF(TCP_DEBUG, ("tcp_bind: bind to port %un", port));
  502.   return ERR_OK;
  503. }
  504. #if LWIP_CALLBACK_API
  505. static err_t
  506. tcp_accept_null(void *arg, struct tcp_pcb *pcb, err_t err)
  507. {
  508.   (void)arg;
  509.   (void)pcb;
  510.   (void)err;
  512.   return ERR_ABRT;
  513. }
  514. #endif /* LWIP_CALLBACK_API */
  516. /**
  517.  * Set the state of the connection to be LISTEN, which means that it
  518.  * is able to accept incoming connections. The protocol control block
  519.  * is reallocated in order to consume less memory. Setting the
  520.  * connection to LISTEN is an irreversible process.
  521.  *
  522.  */
  523. struct tcp_pcb *
  524. tcp_listen(struct tcp_pcb *pcb)
  525. {
  526.   struct tcp_pcb_listen *lpcb;
  528.   /* already listening? */
  529.   if (pcb->state == LISTEN) {
  530.     return pcb;
  531.   }
  532.   lpcb = memp_malloc(MEMP_TCP_PCB_LISTEN);
  533.   if (lpcb == NULL) {
  534.     return NULL;
  535.   }
  536.   lpcb->callback_arg = pcb->callback_arg;
  537.   lpcb->local_port = pcb->local_port;
  538.   lpcb->state = LISTEN;
  539.   lpcb->so_options = pcb->so_options;
  540.   lpcb->so_options |= SOF_ACCEPTCONN;
  541.   lpcb->ttl = pcb->ttl;
  542.   lpcb->tos = pcb->tos;
  543.   ip_addr_set(&lpcb->local_ip, &pcb->local_ip);
  544.   memp_free(MEMP_TCP_PCB, pcb);
  545. #if LWIP_CALLBACK_API
  546.   lpcb->accept = tcp_accept_null;
  547. #endif /* LWIP_CALLBACK_API */
  548.   TCP_REG(&tcp_listen_pcbs.listen_pcbs, lpcb);
  549.   return (struct tcp_pcb *)lpcb;
  550. }
  552. /**
  553.  * This function should be called by the application when it has
  554.  * processed the data. The purpose is to advertise a larger window
  555.  * when the data has been processed.
  556.  *
  557.  */
  558. void
  559. tcp_recved(struct tcp_pcb *pcb, u16_t len)
  560. {
  561.   if ((u32_t)pcb->rcv_wnd + len > TCP_WND) {
  562.     pcb->rcv_wnd = TCP_WND;
  563.   } else {
  564.     pcb->rcv_wnd += len;
  565.   }
  566.   if (!(pcb->flags & TF_ACK_DELAY) &&
  567.      !(pcb->flags & TF_ACK_NOW)) {
  568.     /*
  569.      * We send an ACK here (if one is not already pending, hence
  570.      * the above tests) as tcp_recved() implies that the application
  571.      * has processed some data, and so we can open the receiver's
  572.      * window to allow more to be transmitted.  This could result in
  573.      * two ACKs being sent for each received packet in some limited cases
  574.      * (where the application is only receiving data, and is slow to
  575.      * process it) but it is necessary to guarantee that the sender can
  576.      * continue to transmit.
  577.      */
  578.     tcp_ack(pcb);
  579.   } 
  580.   else if (pcb->flags & TF_ACK_DELAY && pcb->rcv_wnd >= TCP_WND/2) {
  581.     /* If we can send a window update such that there is a full
  582.      * segment available in the window, do so now.  This is sort of
  583.      * nagle-like in its goals, and tries to hit a compromise between
  584.      * sending acks each time the window is updated, and only sending
  585.      * window updates when a timer expires.  The "threshold" used
  586.      * above (currently TCP_WND/2) can be tuned to be more or less
  587.      * aggressive  */
  588.     tcp_ack_now(pcb);
  589.   }
  591.   LWIP_DEBUGF(TCP_DEBUG, ("tcp_recved: recveived %u bytes, wnd %u (%u).n",
  592.          len, pcb->rcv_wnd, TCP_WND - pcb->rcv_wnd));
  593. }
  595. /**
  596.  * A nastly hack featuring 'goto' statements that allocates a
  597.  * new TCP local port.
  598.  */
  599. static u16_t
  600. tcp_new_port(void)
  601. {
  602.   struct tcp_pcb *pcb;
  603. #ifndef TCP_LOCAL_PORT_RANGE_START
  604. #define TCP_LOCAL_PORT_RANGE_START 4096
  605. #define TCP_LOCAL_PORT_RANGE_END   0x7fff
  606. #endif
  607.   static u16_t port = TCP_LOCAL_PORT_RANGE_START;
  608.   
  609.  again:
  610.   if (++port > TCP_LOCAL_PORT_RANGE_END) {
  611.     port = TCP_LOCAL_PORT_RANGE_START;
  612.   }
  613.   
  614.   for(pcb = tcp_active_pcbs; pcb != NULL; pcb = pcb->next) {
  615.     if (pcb->local_port == port) {
  616.       goto again;
  617.     }
  618.   }
  619.   for(pcb = tcp_tw_pcbs; pcb != NULL; pcb = pcb->next) {
  620.     if (pcb->local_port == port) {
  621.       goto again;
  622.     }
  623.   }
  624.   for(pcb = (struct tcp_pcb *)tcp_listen_pcbs.pcbs; pcb != NULL; pcb = pcb->next) {
  625.     if (pcb->local_port == port) {
  626.       goto again;
  627.     }
  628.   }
  629.   return port;
  630. }
  632. /**
  633.  * Connects to another host. The function given as the "connected"
  634.  * argument will be called when the connection has been established.
  635.  *
  636.  */
  637. err_t
  638. tcp_connect(struct tcp_pcb *pcb, struct ip_addr *ipaddr, u16_t port,
  639.       err_t (* connected)(void *arg, struct tcp_pcb *tpcb, err_t err))
  640. {
  641.   u32_t optdata;
  642.   err_t ret;
  643.   u32_t iss;
  645.   LWIP_DEBUGF(TCP_DEBUG, ("tcp_connect to port %un", port));
  646.   if (ipaddr != NULL) {
  647.     pcb->remote_ip = *ipaddr;
  648.   } else {
  649.     return ERR_VAL;
  650.   }
  651.   pcb->remote_port = port;
  652.   if (pcb->local_port == 0) {
  653.     pcb->local_port = tcp_new_port();
  654.   }
  655.   iss = tcp_next_iss();
  656.   pcb->rcv_nxt = 0;
  657.   pcb->snd_nxt = iss;
  658.   pcb->lastack = iss - 1;
  659.   pcb->snd_lbb = iss - 1;
  660.   pcb->rcv_wnd = TCP_WND;
  661.   pcb->snd_wnd = TCP_WND;
  662.   pcb->mss = TCP_MSS;
  663.   pcb->cwnd = 1;
  664.   pcb->ssthresh = pcb->mss * 10;
  665.   pcb->state = SYN_SENT;
  666. #if LWIP_CALLBACK_API  
  667.   pcb->connected = connected;
  668. #endif /* LWIP_CALLBACK_API */  
  669.   TCP_REG(&tcp_active_pcbs, pcb);
  670.   
  671.   /* Build an MSS option */
  672.   optdata = htonl(((u32_t)2 << 24) | 
  673.       ((u32_t)4 << 16) | 
  674.       (((u32_t)pcb->mss / 256) << 8) |
  675.       (pcb->mss & 255));
  677.   ret = tcp_enqueue(pcb, NULL, 0, TCP_SYN, 0, (u8_t *)&optdata, 4);
  678.   if (ret == ERR_OK) { 
  679.     tcp_output(pcb);
  680.   }
  681.   return ret;
  682. } 
  684. /**
  685.  * Called every 500 ms and implements the retransmission timer and the timer that
  686.  * removes PCBs that have been in TIME-WAIT for enough time. It also increments
  687.  * various timers such as the inactivity timer in each PCB.
  688.  */
  689. void
  690. tcp_slowtmr(void)
  691. {
  692.   struct tcp_pcb *pcb, *pcb2, *prev;
  693.   u32_t eff_wnd;
  694.   u8_t pcb_remove;      /* flag if a PCB should be removed */
  695.   err_t err;
  697.   err = ERR_OK;
  699.   ++tcp_ticks;
  701.   /* Steps through all of the active PCBs. */
  702.   prev = NULL;
  703.   pcb = tcp_active_pcbs;
  704.   if (pcb == NULL) {
  705.     LWIP_DEBUGF(TCP_DEBUG, ("tcp_slowtmr: no active pcbsn"));
  706.   }
  707.   while (pcb != NULL) {
  708.     LWIP_DEBUGF(TCP_DEBUG, ("tcp_slowtmr: processing active pcbn"));
  709.     LWIP_ASSERT("tcp_slowtmr: active pcb->state != CLOSEDn", pcb->state != CLOSED);
  710.     LWIP_ASSERT("tcp_slowtmr: active pcb->state != LISTENn", pcb->state != LISTEN);
  711.     LWIP_ASSERT("tcp_slowtmr: active pcb->state != TIME-WAITn", pcb->state != TIME_WAIT);
  713.     pcb_remove = 0;
  715.     if (pcb->state == SYN_SENT && pcb->nrtx == TCP_SYNMAXRTX) {
  716.       ++pcb_remove;
  717.       LWIP_DEBUGF(TCP_DEBUG, ("tcp_slowtmr: max SYN retries reachedn"));
  718.     }
  719.     else if (pcb->nrtx == TCP_MAXRTX) {
  720.       ++pcb_remove;
  721.       LWIP_DEBUGF(TCP_DEBUG, ("tcp_slowtmr: max DATA retries reachedn"));
  722.     } else {
  723.       ++pcb->rtime;
  724.       if (pcb->unacked != NULL && pcb->rtime >= pcb->rto) {
  726.         /* Time for a retransmission. */
  727.         LWIP_DEBUGF(TCP_RTO_DEBUG, ("tcp_slowtmr: rtime %u pcb->rto %un",
  728.           pcb->rtime, pcb->rto));
  730.         /* Double retransmission time-out unless we are trying to
  731.          * connect to somebody (i.e., we are in SYN_SENT). */
  732.         if (pcb->state != SYN_SENT) {
  733.           pcb->rto = ((pcb->sa >> 3) + pcb->sv) << tcp_backoff[pcb->nrtx];
  734.         }
  735.         /* Reduce congestion window and ssthresh. */
  736.         eff_wnd = LWIP_MIN(pcb->cwnd, pcb->snd_wnd);
  737.         pcb->ssthresh = eff_wnd >> 1;
  738.         if (pcb->ssthresh < pcb->mss) {
  739.           pcb->ssthresh = pcb->mss * 2;
  740.         }
  741.         pcb->cwnd = pcb->mss;
  742.         LWIP_DEBUGF(TCP_CWND_DEBUG, ("tcp_slowtmr: cwnd %u ssthresh %un",
  743.                                 pcb->cwnd, pcb->ssthresh));
  744.  
  745.         /* The following needs to be called AFTER cwnd is set to one mss - STJ */
  746.         tcp_rexmit_rto(pcb);
  747.      }
  748.     }
  749.     /* Check if this PCB has stayed too long in FIN-WAIT-2 */
  750.     if (pcb->state == FIN_WAIT_2) {
  751.       if ((u32_t)(tcp_ticks - pcb->tmr) >
  752.         TCP_FIN_WAIT_TIMEOUT / TCP_SLOW_INTERVAL) {
  753.         ++pcb_remove;
  754.         LWIP_DEBUGF(TCP_DEBUG, ("tcp_slowtmr: removing pcb stuck in FIN-WAIT-2n"));
  755.       }
  756.     }
  758.    /* Check if KEEPALIVE should be sent */
  759.    if((pcb->so_options & SOF_KEEPALIVE) && ((pcb->state == ESTABLISHED) || (pcb->state == CLOSE_WAIT))) {
  760.       if((u32_t)(tcp_ticks - pcb->tmr) > (pcb->keepalive + TCP_MAXIDLE) / TCP_SLOW_INTERVAL)  {
  761.          LWIP_DEBUGF(TCP_DEBUG, ("tcp_slowtmr: KEEPALIVE timeout. Aborting connection to %u.%u.%u.%u.n",
  762.                                  ip4_addr1(&pcb->remote_ip), ip4_addr2(&pcb->remote_ip),
  763.                                  ip4_addr3(&pcb->remote_ip), ip4_addr4(&pcb->remote_ip)));
  765.          tcp_abort(pcb);
  766.       }
  767.       else if((u32_t)(tcp_ticks - pcb->tmr) > (pcb->keepalive + pcb->keep_cnt * TCP_KEEPINTVL) / TCP_SLOW_INTERVAL) {
  768.          tcp_keepalive(pcb);
  769.          pcb->keep_cnt++;
  770.       }
  771.    }
  773.     /* If this PCB has queued out of sequence data, but has been
  774.        inactive for too long, will drop the data (it will eventually
  775.        be retransmitted). */
  776. #if TCP_QUEUE_OOSEQ    
  777.     if (pcb->ooseq != NULL &&
  778.        (u32_t)tcp_ticks - pcb->tmr >=
  779.        pcb->rto * TCP_OOSEQ_TIMEOUT) {
  780.       tcp_segs_free(pcb->ooseq);
  781.       pcb->ooseq = NULL;
  782.       LWIP_DEBUGF(TCP_CWND_DEBUG, ("tcp_slowtmr: dropping OOSEQ queued datan"));
  783.     }
  784. #endif /* TCP_QUEUE_OOSEQ */
  786.     /* Check if this PCB has stayed too long in SYN-RCVD */
  787.     if (pcb->state == SYN_RCVD) {
  788.       if ((u32_t)(tcp_ticks - pcb->tmr) >
  789.    TCP_SYN_RCVD_TIMEOUT / TCP_SLOW_INTERVAL) {
  790.         ++pcb_remove;
  791.         LWIP_DEBUGF(TCP_DEBUG, ("tcp_slowtmr: removing pcb stuck in SYN-RCVDn"));
  792.       }
  793.     }
  796.     /* If the PCB should be removed, do it. */
  797.     if (pcb_remove) {
  798.       tcp_pcb_purge(pcb);      
  799.       /* Remove PCB from tcp_active_pcbs list. */
  800.       if (prev != NULL) {
  801.   LWIP_ASSERT("tcp_slowtmr: middle tcp != tcp_active_pcbs", pcb != tcp_active_pcbs);
  802.         prev->next = pcb->next;
  803.       } else {
  804.         /* This PCB was the first. */
  805.         LWIP_ASSERT("tcp_slowtmr: first pcb == tcp_active_pcbs", tcp_active_pcbs == pcb);
  806.         tcp_active_pcbs = pcb->next;
  807.       }
  809.       TCP_EVENT_ERR(pcb->errf, pcb->callback_arg, ERR_ABRT);
  811.       pcb2 = pcb->next;
  812.       memp_free(MEMP_TCP_PCB, pcb);
  813.       pcb = pcb2;
  814.     } else {
  816.       /* We check if we should poll the connection. */
  817.       ++pcb->polltmr;
  818.       if (pcb->polltmr >= pcb->pollinterval) {
  819.         pcb->polltmr = 0;
  820.         LWIP_DEBUGF(TCP_DEBUG, ("tcp_slowtmr: polling applicationn"));
  821.         TCP_EVENT_POLL(pcb, err);
  822.         if (err == ERR_OK) {
  823.           tcp_output(pcb);
  824.         }
  825.       }
  826.       
  827.       prev = pcb;
  828.       pcb = pcb->next;
  829.     }
  830.   }
  832.   
  833.   /* Steps through all of the TIME-WAIT PCBs. */
  834.   prev = NULL;    
  835.   pcb = tcp_tw_pcbs;
  836.   while (pcb != NULL) {
  837.     LWIP_ASSERT("tcp_slowtmr: TIME-WAIT pcb->state == TIME-WAIT", pcb->state == TIME_WAIT);
  838.     pcb_remove = 0;
  840.     /* Check if this PCB has stayed long enough in TIME-WAIT */
  841.     if ((u32_t)(tcp_ticks - pcb->tmr) > 2 * TCP_MSL / TCP_SLOW_INTERVAL) {
  842.       ++pcb_remove;
  843.     }
  844.     
  847.     /* If the PCB should be removed, do it. */
  848.     if (pcb_remove) {
  849.       tcp_pcb_purge(pcb);      
  850.       /* Remove PCB from tcp_tw_pcbs list. */
  851.       if (prev != NULL) {
  852.   LWIP_ASSERT("tcp_slowtmr: middle tcp != tcp_tw_pcbs", pcb != tcp_tw_pcbs);
  853.         prev->next = pcb->next;
  854.       } else {
  855.         /* This PCB was the first. */
  856.         LWIP_ASSERT("tcp_slowtmr: first pcb == tcp_tw_pcbs", tcp_tw_pcbs == pcb);
  857.         tcp_tw_pcbs = pcb->next;
  858.       }
  859.       pcb2 = pcb->next;
  860.       memp_free(MEMP_TCP_PCB, pcb);
  861.       pcb = pcb2;
  862.     } else {
  863.       prev = pcb;
  864.       pcb = pcb->next;
  865.     }
  866.   }
  867. }
  869. /**
  870.  * Is called every TCP_FAST_INTERVAL (250 ms) and sends delayed ACKs.
  871.  */
  872. void
  873. tcp_fasttmr(void)
  874. {
  875.   struct tcp_pcb *pcb;
  877.   /* send delayed ACKs */  
  878.   for(pcb = tcp_active_pcbs; pcb != NULL; pcb = pcb->next) {
  879.     if (pcb->flags & TF_ACK_DELAY) {
  880.       LWIP_DEBUGF(TCP_DEBUG, ("tcp_fasttmr: delayed ACKn"));
  881.       tcp_ack_now(pcb);
  882.       pcb->flags &= ~(TF_ACK_DELAY | TF_ACK_NOW);
  883.     }
  884.   }
  885. }
  887. /**
  888.  * Deallocates a list of TCP segments (tcp_seg structures).
  889.  *
  890.  */
  891. u8_t
  892. tcp_segs_free(struct tcp_seg *seg)
  893. {
  894.   u8_t count = 0;
  895.   struct tcp_seg *next;
  896.   while (seg != NULL) {
  897.     next = seg->next;
  898.     count += tcp_seg_free(seg);
  899.     seg = next;
  900.   }
  901.   return count;
  902. }
  904. /**
  905.  * Frees a TCP segment.
  906.  *
  907.  */
  908. u8_t
  909. tcp_seg_free(struct tcp_seg *seg)
  910. {
  911.   u8_t count = 0;
  912.   
  913.   if (seg != NULL) {
  914.     if (seg->p != NULL) {
  915.       count = pbuf_free(seg->p);
  916. #if TCP_DEBUG
  917.       seg->p = NULL;
  918. #endif /* TCP_DEBUG */
  919.     }
  920.     memp_free(MEMP_TCP_SEG, seg);
  921.   }
  922.   return count;
  923. }
  925. /**
  926.  * Sets the priority of a connection.
  927.  *
  928.  */
  929. void
  930. tcp_setprio(struct tcp_pcb *pcb, u8_t prio)
  931. {
  932.   pcb->prio = prio;
  933. }
  934. #if TCP_QUEUE_OOSEQ
  936. /**
  937.  * Returns a copy of the given TCP segment.
  938.  *
  939.  */ 
  940. struct tcp_seg *
  941. tcp_seg_copy(struct tcp_seg *seg)
  942. {
  943.   struct tcp_seg *cseg;
  945.   cseg = memp_malloc(MEMP_TCP_SEG);
  946.   if (cseg == NULL) {
  947.     return NULL;
  948.   }
  949.   memcpy((char *)cseg, (const char *)seg, sizeof(struct tcp_seg)); 
  950.   pbuf_ref(cseg->p);
  951.   return cseg;
  952. }
  953. #endif
  955. #if LWIP_CALLBACK_API
  956. static err_t
  957. tcp_recv_null(void *arg, struct tcp_pcb *pcb, struct pbuf *p, err_t err)
  958. {
  959.   arg = arg;
  960.   if (p != NULL) {
  961.     pbuf_free(p);
  962.   } else if (err == ERR_OK) {
  963.     return tcp_close(pcb);
  964.   }
  965.   return ERR_OK;
  966. }
  967. #endif /* LWIP_CALLBACK_API */
  969. static void
  970. tcp_kill_prio(u8_t prio)
  971. {
  972.   struct tcp_pcb *pcb, *inactive;
  973.   u32_t inactivity;
  974.   u8_t mprio;
  977.   mprio = TCP_PRIO_MAX;
  978.   
  979.   /* We kill the oldest active connection that has lower priority than
  980.      prio. */
  981.   inactivity = 0;
  982.   inactive = NULL;
  983.   for(pcb = tcp_active_pcbs; pcb != NULL; pcb = pcb->next) {
  984.     if (pcb->prio <= prio &&
  985.        pcb->prio <= mprio &&
  986.        (u32_t)(tcp_ticks - pcb->tmr) >= inactivity) {
  987.       inactivity = tcp_ticks - pcb->tmr;
  988.       inactive = pcb;
  989.       mprio = pcb->prio;
  990.     }
  991.   }
  992.   if (inactive != NULL) {
  993.     LWIP_DEBUGF(TCP_DEBUG, ("tcp_kill_prio: killing oldest PCB %p (%ld)n",
  994.            (void *)inactive, inactivity));
  995.     tcp_abort(inactive);
  996.   }      
  997. }
  1000. static void
  1001. tcp_kill_timewait(void)
  1002. {
  1003.   struct tcp_pcb *pcb, *inactive;
  1004.   u32_t inactivity;
  1006.   inactivity = 0;
  1007.   inactive = NULL;
  1008.   for(pcb = tcp_tw_pcbs; pcb != NULL; pcb = pcb->next) {
  1009.     if ((u32_t)(tcp_ticks - pcb->tmr) >= inactivity) {
  1010.       inactivity = tcp_ticks - pcb->tmr;
  1011.       inactive = pcb;
  1012.     }
  1013.   }
  1014.   if (inactive != NULL) {
  1015.     LWIP_DEBUGF(TCP_DEBUG, ("tcp_kill_timewait: killing oldest TIME-WAIT PCB %p (%ld)n",
  1016.            (void *)inactive, inactivity));
  1017.     tcp_abort(inactive);
  1018.   }      
  1019. }
  1023. struct tcp_pcb *
  1024. tcp_alloc(u8_t prio)
  1025. {
  1026.   struct tcp_pcb *pcb;
  1027.   u32_t iss;
  1028.   
  1029.   pcb = memp_malloc(MEMP_TCP_PCB);
  1030.   if (pcb == NULL) {
  1031.     /* Try killing oldest connection in TIME-WAIT. */
  1032.     LWIP_DEBUGF(TCP_DEBUG, ("tcp_alloc: killing off oldest TIME-WAIT connectionn"));
  1033.     tcp_kill_timewait();
  1034.     pcb = memp_malloc(MEMP_TCP_PCB);
  1035.     if (pcb == NULL) {
  1036.       tcp_kill_prio(prio);    
  1037.       pcb = memp_malloc(MEMP_TCP_PCB);
  1038.     }
  1039.   }
  1040.   if (pcb != NULL) {
  1041.     memset(pcb, 0, sizeof(struct tcp_pcb));
  1042.     pcb->prio = TCP_PRIO_NORMAL;
  1043.     pcb->snd_buf = TCP_SND_BUF;
  1044.     pcb->snd_queuelen = 0;
  1045.     pcb->rcv_wnd = TCP_WND;
  1046.     pcb->tos = 0;
  1047.     pcb->ttl = TCP_TTL;
  1048.     pcb->mss = TCP_MSS;
  1049.     pcb->rto = 3000 / TCP_SLOW_INTERVAL;
  1050.     pcb->sa = 0;
  1051.     pcb->sv = 3000 / TCP_SLOW_INTERVAL;
  1052.     pcb->rtime = 0;
  1053.     pcb->cwnd = 1;
  1054.     iss = tcp_next_iss();
  1055.     pcb->snd_wl2 = iss;
  1056.     pcb->snd_nxt = iss;
  1057.     pcb->snd_max = iss;
  1058.     pcb->lastack = iss;
  1059.     pcb->snd_lbb = iss;   
  1060.     pcb->tmr = tcp_ticks;
  1062.     pcb->polltmr = 0;
  1063.    /*new added by skier 2006.01.31*/
  1064.     pcb->pollinterval = 10;
  1065.    //end:skier
  1066. #if LWIP_CALLBACK_API
  1067.     pcb->recv = tcp_recv_null;
  1068. #endif /* LWIP_CALLBACK_API */  
  1069.     
  1070.     /* Init KEEPALIVE timer */
  1071.     pcb->keepalive = TCP_KEEPDEFAULT;
  1072.     pcb->keep_cnt = 0;
  1073.   }
  1074.   return pcb;
  1075. }
  1077. /**
  1078.  * Creates a new TCP protocol control block but doesn't place it on
  1079.  * any of the TCP PCB lists.
  1080.  *
  1081.  * @internal: Maybe there should be a idle TCP PCB list where these
  1082.  * PCBs are put on. We can then implement port reservation using
  1083.  * tcp_bind(). Currently, we lack this (BSD socket type of) feature.
  1084.  */
  1086. struct tcp_pcb *
  1087. tcp_new(void)
  1088. {
  1089.   return tcp_alloc(TCP_PRIO_NORMAL);
  1090. }
  1092. /*
  1093.  * tcp_arg():
  1094.  *
  1095.  * Used to specify the argument that should be passed callback
  1096.  * functions.
  1097.  *
  1098.  */ 
  1100. void
  1101. tcp_arg(struct tcp_pcb *pcb, void *arg)
  1102. {  
  1103.   pcb->callback_arg = arg;
  1104. }
  1105. #if LWIP_CALLBACK_API
  1107. /**
  1108.  * Used to specify the function that should be called when a TCP
  1109.  * connection receives data.
  1110.  *
  1111.  */ 
  1112. void
  1113. tcp_recv(struct tcp_pcb *pcb,
  1114.    err_t (* recv)(void *arg, struct tcp_pcb *tpcb, struct pbuf *p, err_t err))
  1115. {
  1116.   pcb->recv = recv;
  1117. }
  1119. /**
  1120.  * Used to specify the function that should be called when TCP data
  1121.  * has been successfully delivered to the remote host.
  1122.  *
  1123.  */ 
  1125. void
  1126. tcp_sent(struct tcp_pcb *pcb,
  1127.    err_t (* sent)(void *arg, struct tcp_pcb *tpcb, u16_t len))
  1128. {
  1129.   pcb->sent = sent;
  1130. }
  1132. /**
  1133.  * Used to specify the function that should be called when a fatal error
  1134.  * has occured on the connection.
  1135.  *
  1136.  */ 
  1137. void
  1138. tcp_err(struct tcp_pcb *pcb,
  1139.    void (* errf)(void *arg, err_t err))
  1140. {
  1141.   pcb->errf = errf;
  1142. }
  1144. /**
  1145.  * Used for specifying the function that should be called when a
  1146.  * LISTENing connection has been connected to another host.
  1147.  *
  1148.  */ 
  1149. void
  1150. tcp_accept(struct tcp_pcb *pcb,
  1151.      err_t (* accept)(void *arg, struct tcp_pcb *newpcb, err_t err))
  1152. {
  1153.   ((struct tcp_pcb_listen *)pcb)->accept = accept;
  1154. }
  1155. #endif /* LWIP_CALLBACK_API */
  1158. /**
  1159.  * Used to specify the function that should be called periodically
  1160.  * from TCP. The interval is specified in terms of the TCP coarse
  1161.  * timer interval, which is called twice a second.
  1162.  *
  1163.  */ 
  1164. void
  1165. tcp_poll(struct tcp_pcb *pcb,
  1166.    err_t (* poll)(void *arg, struct tcp_pcb *tpcb), u8_t interval)
  1167. {
  1168. #if LWIP_CALLBACK_API
  1169.   pcb->poll = poll;
  1170. #endif /* LWIP_CALLBACK_API */  
  1171.   pcb->pollinterval = interval;
  1172. }
  1174. /**
  1175.  * Purges a TCP PCB. Removes any buffered data and frees the buffer memory.
  1176.  *
  1177.  */
  1178. void
  1179. tcp_pcb_purge(struct tcp_pcb *pcb)
  1180. {
  1181.   if (pcb->state != CLOSED &&
  1182.      pcb->state != TIME_WAIT &&
  1183.      pcb->state != LISTEN) {
  1185.     LWIP_DEBUGF(TCP_DEBUG, ("tcp_pcb_purgen"));
  1186.     
  1187.     if (pcb->unsent != NULL) {    
  1188.       LWIP_DEBUGF(TCP_DEBUG, ("tcp_pcb_purge: not all data sentn"));
  1189.     }
  1190.     if (pcb->unacked != NULL) {    
  1191.       LWIP_DEBUGF(TCP_DEBUG, ("tcp_pcb_purge: data left on ->unackedn"));
  1192.     }
  1193. #if TCP_QUEUE_OOSEQ /* LW */
  1194.     if (pcb->ooseq != NULL) {    
  1195.       LWIP_DEBUGF(TCP_DEBUG, ("tcp_pcb_purge: data left on ->ooseqn"));
  1196.     }
  1197.     
  1198.     tcp_segs_free(pcb->ooseq);
  1199.     pcb->ooseq = NULL;
  1200. #endif /* TCP_QUEUE_OOSEQ */
  1201.     tcp_segs_free(pcb->unsent);
  1202.     tcp_segs_free(pcb->unacked);
  1203.     pcb->unacked = pcb->unsent = NULL;
  1204.   }
  1205. }
  1207. /**
  1208.  * Purges the PCB and removes it from a PCB list. Any delayed ACKs are sent first.
  1209.  *
  1210.  */
  1211. void
  1212. tcp_pcb_remove(struct tcp_pcb **pcblist, struct tcp_pcb *pcb)
  1213. {
  1214.   TCP_RMV(pcblist, pcb);
  1216.   tcp_pcb_purge(pcb);
  1217.   
  1218.   /* if there is an outstanding delayed ACKs, send it */
  1219.   if (pcb->state != TIME_WAIT &&
  1220.      pcb->state != LISTEN &&
  1221.      pcb->flags & TF_ACK_DELAY) {
  1222.     pcb->flags |= TF_ACK_NOW;
  1223.     tcp_output(pcb);
  1224.   }  
  1225.   pcb->state = CLOSED;
  1227.   LWIP_ASSERT("tcp_pcb_remove: tcp_pcbs_sane()", tcp_pcbs_sane());
  1228. }
  1230. /**
  1231.  * Calculates a new initial sequence number for new connections.
  1232.  *
  1233.  */
  1234. u32_t
  1235. tcp_next_iss(void)
  1236. {
  1237.   static u32_t iss = 6510;
  1238.   
  1239.   iss += tcp_ticks;       /* XXX */
  1240.   return iss;
  1241. }
  1243. #if TCP_DEBUG || TCP_INPUT_DEBUG || TCP_OUTPUT_DEBUG
  1244. void
  1245. tcp_debug_print(struct tcp_hdr *tcphdr)
  1246. {
  1247.   LWIP_DEBUGF(TCP_DEBUG, ("TCP header:n"));
  1248.   LWIP_DEBUGF(TCP_DEBUG, ("+-------------------------------+n"));
  1249.   LWIP_DEBUGF(TCP_DEBUG, ("|    %5u      |    %5u      | (src port, dest port)n",
  1250.          ntohs(tcphdr->src), ntohs(tcphdr->dest)));
  1251.   LWIP_DEBUGF(TCP_DEBUG, ("+-------------------------------+n"));
  1252.   LWIP_DEBUGF(TCP_DEBUG, ("|           %010lu          | (seq no)n",
  1253.           ntohl(tcphdr->seqno)));
  1254.   LWIP_DEBUGF(TCP_DEBUG, ("+-------------------------------+n"));
  1255.   LWIP_DEBUGF(TCP_DEBUG, ("|           %010lu          | (ack no)n",
  1256.          ntohl(tcphdr->ackno)));
  1257.   LWIP_DEBUGF(TCP_DEBUG, ("+-------------------------------+n"));
  1258.   LWIP_DEBUGF(TCP_DEBUG, ("| %2u |   |%u%u%u%u%u%u|     %5u     | (hdrlen, flags (",
  1259.        TCPH_HDRLEN(tcphdr),
  1260.          TCPH_FLAGS(tcphdr) >> 5 & 1,
  1261.          TCPH_FLAGS(tcphdr) >> 4 & 1,
  1262.          TCPH_FLAGS(tcphdr) >> 3 & 1,
  1263.          TCPH_FLAGS(tcphdr) >> 2 & 1,
  1264.          TCPH_FLAGS(tcphdr) >> 1 & 1,
  1265.          TCPH_FLAGS(tcphdr) & 1,
  1266.          ntohs(tcphdr->wnd)));
  1267.   tcp_debug_print_flags(TCPH_FLAGS(tcphdr));
  1268.   LWIP_DEBUGF(TCP_DEBUG, ("), win)n"));
  1269.   LWIP_DEBUGF(TCP_DEBUG, ("+-------------------------------+n"));
  1270.   LWIP_DEBUGF(TCP_DEBUG, ("|    0x%04x     |     %5u     | (chksum, urgp)n",
  1271.          ntohs(tcphdr->chksum), ntohs(tcphdr->urgp)));
  1272.   LWIP_DEBUGF(TCP_DEBUG, ("+-------------------------------+n"));
  1273. }
  1275. void
  1276. tcp_debug_print_state(enum tcp_state s)
  1277. {
  1278.   LWIP_DEBUGF(TCP_DEBUG, ("State: "));
  1279.   switch (s) {
  1280.   case CLOSED:
  1281.     LWIP_DEBUGF(TCP_DEBUG, ("CLOSEDn"));
  1282.     break;
  1283.  case LISTEN:
  1284.    LWIP_DEBUGF(TCP_DEBUG, ("LISTENn"));
  1285.    break;
  1286.   case SYN_SENT:
  1287.     LWIP_DEBUGF(TCP_DEBUG, ("SYN_SENTn"));
  1288.     break;
  1289.   case SYN_RCVD:
  1290.     LWIP_DEBUGF(TCP_DEBUG, ("SYN_RCVDn"));
  1291.     break;
  1292.   case ESTABLISHED:
  1293.     LWIP_DEBUGF(TCP_DEBUG, ("ESTABLISHEDn"));
  1294.     break;
  1295.   case FIN_WAIT_1:
  1296.     LWIP_DEBUGF(TCP_DEBUG, ("FIN_WAIT_1n"));
  1297.     break;
  1298.   case FIN_WAIT_2:
  1299.     LWIP_DEBUGF(TCP_DEBUG, ("FIN_WAIT_2n"));
  1300.     break;
  1301.   case CLOSE_WAIT:
  1302.     LWIP_DEBUGF(TCP_DEBUG, ("CLOSE_WAITn"));
  1303.     break;
  1304.   case CLOSING:
  1305.     LWIP_DEBUGF(TCP_DEBUG, ("CLOSINGn"));
  1306.     break;
  1307.   case LAST_ACK:
  1308.     LWIP_DEBUGF(TCP_DEBUG, ("LAST_ACKn"));
  1309.     break;
  1310.   case TIME_WAIT:
  1311.     LWIP_DEBUGF(TCP_DEBUG, ("TIME_WAITn"));
  1312.    break;
  1313.   }
  1314. }
  1316. void
  1317. tcp_debug_print_flags(u8_t flags)
  1318. {
  1319.   if (flags & TCP_FIN) {
  1320.     LWIP_DEBUGF(TCP_DEBUG, ("FIN "));
  1321.   }
  1322.   if (flags & TCP_SYN) {
  1323.     LWIP_DEBUGF(TCP_DEBUG, ("SYN "));
  1324.   }
  1325.   if (flags & TCP_RST) {
  1326.     LWIP_DEBUGF(TCP_DEBUG, ("RST "));
  1327.   }
  1328.   if (flags & TCP_PSH) {
  1329.     LWIP_DEBUGF(TCP_DEBUG, ("PSH "));
  1330.   }
  1331.   if (flags & TCP_ACK) {
  1332.     LWIP_DEBUGF(TCP_DEBUG, ("ACK "));
  1333.   }
  1334.   if (flags & TCP_URG) {
  1335.     LWIP_DEBUGF(TCP_DEBUG, ("URG "));
  1336.   }
  1337.   if (flags & TCP_ECE) {
  1338.     LWIP_DEBUGF(TCP_DEBUG, ("ECE "));
  1339.   }
  1340.   if (flags & TCP_CWR) {
  1341.     LWIP_DEBUGF(TCP_DEBUG, ("CWR "));
  1342.   }
  1343. }
  1345. void
  1346. tcp_debug_print_pcbs(void)
  1347. {
  1348.   struct tcp_pcb *pcb;
  1349.   LWIP_DEBUGF(TCP_DEBUG, ("Active PCB states:n"));
  1350.   for(pcb = tcp_active_pcbs; pcb != NULL; pcb = pcb->next) {
  1351.     LWIP_DEBUGF(TCP_DEBUG, ("Local port %u, foreign port %u snd_nxt %lu rcv_nxt %lu ",
  1352.                        pcb->local_port, pcb->remote_port,
  1353.                        pcb->snd_nxt, pcb->rcv_nxt));
  1354.     tcp_debug_print_state(pcb->state);
  1355.   }    
  1356.   LWIP_DEBUGF(TCP_DEBUG, ("Listen PCB states:n"));
  1357.   for(pcb = (struct tcp_pcb *)tcp_listen_pcbs.pcbs; pcb != NULL; pcb = pcb->next) {
  1358.     LWIP_DEBUGF(TCP_DEBUG, ("Local port %u, foreign port %u snd_nxt %lu rcv_nxt %lu ",
  1359.                        pcb->local_port, pcb->remote_port,
  1360.                        pcb->snd_nxt, pcb->rcv_nxt));
  1361.     tcp_debug_print_state(pcb->state);
  1362.   }    
  1363.   LWIP_DEBUGF(TCP_DEBUG, ("TIME-WAIT PCB states:n"));
  1364.   for(pcb = tcp_tw_pcbs; pcb != NULL; pcb = pcb->next) {
  1365.     LWIP_DEBUGF(TCP_DEBUG, ("Local port %u, foreign port %u snd_nxt %lu rcv_nxt %lu ",
  1366.                        pcb->local_port, pcb->remote_port,
  1367.                        pcb->snd_nxt, pcb->rcv_nxt));
  1368.     tcp_debug_print_state(pcb->state);
  1369.   }    
  1370. }
  1372. int
  1373. tcp_pcbs_sane(void)
  1374. {
  1375.   struct tcp_pcb *pcb;
  1376.   for(pcb = tcp_active_pcbs; pcb != NULL; pcb = pcb->next) {
  1377.     LWIP_ASSERT("tcp_pcbs_sane: active pcb->state != CLOSED", pcb->state != CLOSED);
  1378.     LWIP_ASSERT("tcp_pcbs_sane: active pcb->state != LISTEN", pcb->state != LISTEN);
  1379.     LWIP_ASSERT("tcp_pcbs_sane: active pcb->state != TIME-WAIT", pcb->state != TIME_WAIT);
  1380.   }
  1381.   for(pcb = tcp_tw_pcbs; pcb != NULL; pcb = pcb->next) {
  1382.     LWIP_ASSERT("tcp_pcbs_sane: tw pcb->state == TIME-WAIT", pcb->state == TIME_WAIT);
  1383.   }
  1384.   return 1;
  1385. }
  1386. #endif /* TCP_DEBUG */
  1387. #endif /* LWIP_TCP */