设为首页收藏本站
开启辅助访问 切换到宽版

 找回密码
 立即注册

QQ登录

只需一步，快速开始

热门： 51单片机 | 24小时必答区 | 单片机教程 | 单片机DIY制作 | STM32 | Cortex M3 | 模数电子 | 电子DIY制作 | 音响/功放 | 拆机乐园 | Arduino | 嵌入式OS | 程序设计

搜索
»论坛 › 非技术区 › 电子工程师杂谈 › 有时候看描述也是一件很幸福的事情！二并快乐者，呵呵！
返回列表 发新帖
查看: 3686|回复: 0
收起左侧

有时候看描述也是一件很幸福的事情！二并快乐者，呵呵！

[复制链接]
ID:82781 发表于 2015-6-13 15:59 | 显示全部楼层 |阅读模式


闲言少叙！直接代码的干活！
  1. const char *tcp_state_str[] = {
  2.   "CLOSED",     
  3.   "LISTEN",     
  4.   "SYN_SENT",   
  5.   "SYN_RCVD",   
  6.   "ESTABLISHED",
  7.   "FIN_WAIT_1",
  8.   "FIN_WAIT_2",
  9.   "CLOSE_WAIT",
  10.   "CLOSING",   
  11.   "LAST_ACK",   
  12.   "TIME_WAIT"  
  13. };
  14. /* Incremented every coarse grained timer shot (typically every 500 ms). */
  15. u32_t tcp_ticks;
  16. const u8_t tcp_backoff[13] =
  17.     { 1, 2, 3, 4, 5, 6, 7, 7, 7, 7, 7, 7, 7};
  18. /* Times per slowtmr hits */
  19. const u8_t tcp_persist_backoff[7] = { 3, 6, 12, 24, 48, 96, 120 };
  20. /* The TCP PCB lists. */
  21. /** List of all TCP PCBs bound but not yet (connected || listening) */
  22. struct tcp_pcb *tcp_bound_pcbs;
  23. /** List of all TCP PCBs in LISTEN state */
  24. union tcp_listen_pcbs_t tcp_listen_pcbs;
  25. /** List of all TCP PCBs that are in a state in which
  26. * they accept or send data. */
  27. struct tcp_pcb *tcp_active_pcbs;
  28. /** List of all TCP PCBs in TIME-WAIT state */
  29. struct tcp_pcb *tcp_tw_pcbs;
  30. struct tcp_pcb *tcp_tmp_pcb;
  31. static u8_t tcp_timer;
  32. static u16_t tcp_new_port(void);
  33. /**
  34. * Called periodically to dispatch TCP timers.
  35. *
  36. */
  37. void
  38. tcp_tmr(void)
  39. {
  40.   /* Call tcp_fasttmr() every 250 ms */
  41.   tcp_fasttmr();
  42.   if (++tcp_timer & 1) {
  43.     /* Call tcp_tmr() every 500 ms, i.e., every other timer
  44.        tcp_tmr() is called. */
  45.     tcp_slowtmr();
  46.   }
  47. }
  48. /**
  49. * Closes the connection held by the PCB.
  50. *
  51. * Listening pcbs are freed and may not be referenced any more.
  52. * Connection pcbs are freed if not yet connected and may not be referenced
  53. * any more. If a connection is established (at least SYN received or in
  54. * a closing state), the connection is closed, and put in a closing state.
  55. * The pcb is then automatically freed in tcp_slowtmr(). It is therefore
  56. * unsafe to reference it.
  57. *
  58. * @param pcb the tcp_pcb to close
  59. * @return ERR_OK if connection has been closed
  60. *         another err_t if closing failed and pcb is not freed
  61. */
  62. err_t
  63. tcp_close(struct tcp_pcb *pcb)
  64. {
  65.   err_t err;
  66. #if TCP_DEBUG
  67.   LWIP_DEBUGF(TCP_DEBUG, ("tcp_close: closing in "));
  68.   tcp_debug_print_state(pcb->state);
  69. #endif /* TCP_DEBUG */
  70.   switch (pcb->state) {
  71.   case CLOSED:
  72.     /* Closing a pcb in the CLOSED state might seem erroneous,
  73.      * however, it is in this state once allocated and as yet unused
  74.      * and the user needs some way to free it should the need arise.
  75.      * Calling tcp_close() with a pcb that has already been closed, (i.e. twice)
  76.      * or for a pcb that has been used and then entered the CLOSED state
  77.      * is erroneous, but this should never happen as the pcb has in those cases
  78.      * been freed, and so any remaining handles are bogus. */
  79.     err = ERR_OK;
  80.     TCP_RMV(&tcp_bound_pcbs, pcb);
  81.     memp_free(MEMP_TCP_PCB, pcb);
  82.     pcb = NULL;
  83.     break;
  84.   case LISTEN:
  85.     err = ERR_OK;
  86.     tcp_pcb_remove((struct tcp_pcb **)&tcp_listen_pcbs.pcbs, pcb);
  87.     memp_free(MEMP_TCP_PCB_LISTEN, pcb);
  88.     pcb = NULL;
  89.     break;
  90.   case SYN_SENT:
  91.     err = ERR_OK;
  92.     tcp_pcb_remove(&tcp_active_pcbs, pcb);
  93.     memp_free(MEMP_TCP_PCB, pcb);
  94.     pcb = NULL;
  95.     snmp_inc_tcpattemptfails();
  96.     break;
  97.   case SYN_RCVD:
  98.     err = tcp_send_ctrl(pcb, TCP_FIN);
  99.     if (err == ERR_OK) {
  100.       snmp_inc_tcpattemptfails();
  101.       pcb->state = FIN_WAIT_1;
  102.     }
  103.     break;
  104.   case ESTABLISHED:
  105.     err = tcp_send_ctrl(pcb, TCP_FIN);
  106.     if (err == ERR_OK) {
  107.       snmp_inc_tcpestabresets();
  108.       pcb->state = FIN_WAIT_1;
  109.     }
  110.     break;
  111.   case CLOSE_WAIT:
  112.     err = tcp_send_ctrl(pcb, TCP_FIN);
  113.     if (err == ERR_OK) {
  114.       snmp_inc_tcpestabresets();
  115.       pcb->state = LAST_ACK;
  116.     }
  117.     break;
  118.   default:
  119.     /* Has already been closed, do nothing. */
  120.     err = ERR_OK;
  121.     pcb = NULL;
  122.     break;
  123.   }
  124.   if (pcb != NULL && err == ERR_OK) {
  125.     /* To ensure all data has been sent when tcp_close returns, we have
  126.        to make sure tcp_output doesn't fail.
  127.        Since we don't really have to ensure all data has been sent when tcp_close
  128.        returns (unsent data is sent from tcp timer functions, also), we don't care
  129.        for the return value of tcp_output for now. */
  130.     /* @todo: When implementing SO_LINGER, this must be changed somehow:
  131.        If SOF_LINGER is set, the data should be sent when tcp_close returns. */
  132.     tcp_output(pcb);
  133.   }
  134.   return err;
  135. }
  136. /**
  137. * Abandons a connection and optionally sends a RST to the remote
  138. * host.  Deletes the local protocol control block. This is done when
  139. * a connection is killed because of shortage of memory.
  140. *
  141. * @param pcb the tcp_pcb to abort
  142. * @param reset boolean to indicate whether a reset should be sent
  143. */
  144. void
  145. tcp_abandon(struct tcp_pcb *pcb, int reset)
  146. {
  147.   u32_t seqno, ackno;
  148.   u16_t remote_port, local_port;
  149.   struct ip_addr remote_ip, local_ip;
  150. #if LWIP_CALLBACK_API
  151.   void (* errf)(void *arg, err_t err);
  152. #endif /* LWIP_CALLBACK_API */
  153.   void *errf_arg;

  155.   /* Figure out on which TCP PCB list we are, and remove us. If we
  156.      are in an active state, call the receive function associated with
  157.      the PCB with a NULL argument, and send an RST to the remote end. */
  158.   if (pcb->state == TIME_WAIT) {
  159.     tcp_pcb_remove(&tcp_tw_pcbs, pcb);
  160.     memp_free(MEMP_TCP_PCB, pcb);
  161.   } else {
  162.     seqno = pcb->snd_nxt;
  163.     ackno = pcb->rcv_nxt;
  164.     ip_addr_set(&local_ip, &(pcb->local_ip));
  165.     ip_addr_set(&remote_ip, &(pcb->remote_ip));
  166.     local_port = pcb->local_port;
  167.     remote_port = pcb->remote_port;
  168. #if LWIP_CALLBACK_API
  169.     errf = pcb->errf;
  170. #endif /* LWIP_CALLBACK_API */
  171.     errf_arg = pcb->callback_arg;
  172.     tcp_pcb_remove(&tcp_active_pcbs, pcb);
  173.     if (pcb->unacked != NULL) {
  174.       tcp_segs_free(pcb->unacked);
  175.     }
  176.     if (pcb->unsent != NULL) {
  177.       tcp_segs_free(pcb->unsent);
  178.     }
  179. #if TCP_QUEUE_OOSEQ   
  180.     if (pcb->ooseq != NULL) {
  181.       tcp_segs_free(pcb->ooseq);
  182.     }
  183. #endif /* TCP_QUEUE_OOSEQ */
  184.     memp_free(MEMP_TCP_PCB, pcb);
  185.     TCP_EVENT_ERR(errf, errf_arg, ERR_ABRT);
  186.     if (reset) {
  187.       LWIP_DEBUGF(TCP_RST_DEBUG, ("tcp_abandon: sending RST\n"));
  188.       tcp_rst(seqno, ackno, &local_ip, &remote_ip, local_port, remote_port);
  189.     }
  190.   }
  191. }
  192. /**
  193. * Binds the connection to a local portnumber and IP address. If the
  194. * IP address is not given (i.e., ipaddr == NULL), the IP address of
  195. * the outgoing network interface is used instead.
  196. *
  197. * @param pcb the tcp_pcb to bind (no check is done whether this pcb is
  198. *        already bound!)
  199. * @param ipaddr the local ip address to bind to (use IP_ADDR_ANY to bind
  200. *        to any local address
  201. * @param port the local port to bind to
  202. * @return ERR_USE if the port is already in use
  203. *         ERR_OK if bound
  204. */
  205. err_t
  206. tcp_bind(struct tcp_pcb *pcb, struct ip_addr *ipaddr, u16_t port)
  207. {
  208.   struct tcp_pcb *cpcb;
  209.   LWIP_ERROR("tcp_bind: can only bind in state CLOSED", pcb->state == CLOSED, return ERR_ISCONN);
  210.   if (port == 0) {
  211.     port = tcp_new_port();
  212.   }
  213.   /* Check if the address already is in use. */
  214.   /* Check the listen pcbs. */
  215.   for(cpcb = (struct tcp_pcb *)tcp_listen_pcbs.pcbs;
  216.       cpcb != NULL; cpcb = cpcb->next) {
  217.     if (cpcb->local_port == port) {
  218.       if (ip_addr_isany(&(cpcb->local_ip)) ||
  219.           ip_addr_isany(ipaddr) ||
  220.           ip_addr_cmp(&(cpcb->local_ip), ipaddr)) {
  221.         return ERR_USE;
  222.       }
  223.     }
  224.   }
  225.   /* Check the connected pcbs. */
  226.   for(cpcb = tcp_active_pcbs;
  227.       cpcb != NULL; cpcb = cpcb->next) {
  228.     if (cpcb->local_port == port) {
  229.       if (ip_addr_isany(&(cpcb->local_ip)) ||
  230.           ip_addr_isany(ipaddr) ||
  231.           ip_addr_cmp(&(cpcb->local_ip), ipaddr)) {
  232.         return ERR_USE;
  233.       }
  234.     }
  235.   }
  236.   /* Check the bound, not yet connected pcbs. */
  237.   for(cpcb = tcp_bound_pcbs; cpcb != NULL; cpcb = cpcb->next) {
  238.     if (cpcb->local_port == port) {
  239.       if (ip_addr_isany(&(cpcb->local_ip)) ||
  240.           ip_addr_isany(ipaddr) ||
  241.           ip_addr_cmp(&(cpcb->local_ip), ipaddr)) {
  242.         return ERR_USE;
  243.       }
  244.     }
  245.   }
  246.   /* @todo: until SO_REUSEADDR is implemented (see task #6995 on savannah),
  247.    * we have to check the pcbs in TIME-WAIT state, also: */
  248.   for(cpcb = tcp_tw_pcbs; cpcb != NULL; cpcb = cpcb->next) {
  249.     if (cpcb->local_port == port) {
  250.       if (ip_addr_cmp(&(cpcb->local_ip), ipaddr)) {
  251.         return ERR_USE;
  252.       }
  253.     }
  254.   }
  255.   if (!ip_addr_isany(ipaddr)) {
  256.     pcb->local_ip = *ipaddr;
  257.   }
  258.   pcb->local_port = port;
  259.   TCP_REG(&tcp_bound_pcbs, pcb);
  260.   LWIP_DEBUGF(TCP_DEBUG, ("tcp_bind: bind to port %"U16_F"\n", port));
  261.   return ERR_OK;
  262. }
  263. #if LWIP_CALLBACK_API
  264. /**
  265. * Default accept callback if no accept callback is specified by the user.
  266. */
  267. static err_t
  268. tcp_accept_null(void *arg, struct tcp_pcb *pcb, err_t err)
  269. {
  270.   LWIP_UNUSED_ARG(arg);
  271.   LWIP_UNUSED_ARG(pcb);
  272.   LWIP_UNUSED_ARG(err);
  273.   return ERR_ABRT;
  274. }
  275. #endif /* LWIP_CALLBACK_API */
  276. /**
  277. * Set the state of the connection to be LISTEN, which means that it
  278. * is able to accept incoming connections. The protocol control block
  279. * is reallocated in order to consume less memory. Setting the
  280. * connection to LISTEN is an irreversible process.
  281. *
  282. * @param pcb the original tcp_pcb
  283. * @param backlog the incoming connections queue limit
  284. * @return tcp_pcb used for listening, consumes less memory.
  285. *
  286. * @note The original tcp_pcb is freed. This function therefore has to be
  287. *       called like this:
  288. *             tpcb = tcp_listen(tpcb);
  289. */
  290. struct tcp_pcb *
  291. tcp_listen_with_backlog(struct tcp_pcb *pcb, u8_t backlog)
  292. {
  293.   struct tcp_pcb_listen *lpcb;
  294.   LWIP_UNUSED_ARG(backlog);
  295.   LWIP_ERROR("tcp_listen: pcb already connected", pcb->state == CLOSED, return NULL);
  296.   /* already listening? */
  297.   if (pcb->state == LISTEN) {
  298.     return pcb;
  299.   }
  300.   lpcb = memp_malloc(MEMP_TCP_PCB_LISTEN);
  301.   if (lpcb == NULL) {
  302.     return NULL;
  303.   }
  304.   lpcb->callback_arg = pcb->callback_arg;
  305.   lpcb->local_port = pcb->local_port;
  306.   lpcb->state = LISTEN;
  307.   lpcb->so_options = pcb->so_options;
  308.   lpcb->so_options |= SOF_ACCEPTCONN;
  309.   lpcb->ttl = pcb->ttl;
  310.   lpcb->tos = pcb->tos;
  311.   ip_addr_set(&lpcb->local_ip, &pcb->local_ip);
  312.   TCP_RMV(&tcp_bound_pcbs, pcb);
  313.   memp_free(MEMP_TCP_PCB, pcb);
  314. #if LWIP_CALLBACK_API
  315.   lpcb->accept = tcp_accept_null;
  316. #endif /* LWIP_CALLBACK_API */
  317. #if TCP_LISTEN_BACKLOG
  318.   lpcb->accepts_pending = 0;
  319.   lpcb->backlog = (backlog ? backlog : 1);
  320. #endif /* TCP_LISTEN_BACKLOG */
  321.   TCP_REG(&tcp_listen_pcbs.listen_pcbs, lpcb);
  322.   return (struct tcp_pcb *)lpcb;
  323. }
  324. /**
  325. * Update the state that tracks the available window space to advertise.
  326. *
  327. * Returns how much extra window would be advertised if we sent an
  328. * update now.
  329. */
  330. u32_t tcp_update_rcv_ann_wnd(struct tcp_pcb *pcb)
  331. {
  332.   u32_t new_right_edge = pcb->rcv_nxt + pcb->rcv_wnd;
  333.   if (TCP_SEQ_GEQ(new_right_edge, pcb->rcv_ann_right_edge + LWIP_MIN((TCP_WND / 2), pcb->mss))) {
  334.     /* we can advertise more window */
  335.     pcb->rcv_ann_wnd = pcb->rcv_wnd;
  336.     return new_right_edge - pcb->rcv_ann_right_edge;
  337.   } else {
  338.     if (TCP_SEQ_GT(pcb->rcv_nxt, pcb->rcv_ann_right_edge)) {
  339.       /* Can happen due to other end sending out of advertised window,
  340.        * but within actual available (but not yet advertised) window */
  341.       pcb->rcv_ann_wnd = 0;
  342.     } else {
  343.       /* keep the right edge of window constant */
  344.       pcb->rcv_ann_wnd = pcb->rcv_ann_right_edge - pcb->rcv_nxt;
  345.     }
  346.     return 0;
  347.   }
  348. }
  349. /**
  350. * This function should be called by the application when it has
  351. * processed the data. The purpose is to advertise a larger window
  352. * when the data has been processed.
  353. *
  354. * @param pcb the tcp_pcb for which data is read
  355. * @param len the amount of bytes that have been read by the application
  356. */
  357. void
  358. tcp_recved(struct tcp_pcb *pcb, u16_t len)
  359. {
  360.   int wnd_inflation;
  361.   LWIP_ASSERT("tcp_recved: len would wrap rcv_wnd\n",
  362.               len <= 0xffff - pcb->rcv_wnd );
  363.   pcb->rcv_wnd += len;
  364.   if (pcb->rcv_wnd > TCP_WND)
  365.     pcb->rcv_wnd = TCP_WND;
  366.   wnd_inflation = tcp_update_rcv_ann_wnd(pcb);
  367.   /* If the change in the right edge of window is significant (default
  368.    * watermark is TCP_WND/2), then send an explicit update now.
  369.    * Otherwise wait for a packet to be sent in the normal course of
  370.    * events (or more window to be available later) */
  371.   if (wnd_inflation >= TCP_WND_UPDATE_THRESHOLD)
  372.     tcp_ack_now(pcb);
  373.   LWIP_DEBUGF(TCP_DEBUG, ("tcp_recved: recveived %"U16_F" bytes, wnd %"U16_F" (%"U16_F").\n",
  374.          len, pcb->rcv_wnd, TCP_WND - pcb->rcv_wnd));
  375. }
  376. /**
  377. * A nastly hack featuring 'goto' statements that allocates a
  378. * new TCP local port.
  379. *
  380. * @return a new (free) local TCP port number
  381. */
  382. static u16_t
  383. tcp_new_port(void)
  384. {
  385.   struct tcp_pcb *pcb;
  386. #ifndef TCP_LOCAL_PORT_RANGE_START
  387. #define TCP_LOCAL_PORT_RANGE_START 4096
  388. #define TCP_LOCAL_PORT_RANGE_END   0x7fff
  389. #endif
  390.   static u16_t port = TCP_LOCAL_PORT_RANGE_START;

  392. again:
  393.   if (++port > TCP_LOCAL_PORT_RANGE_END) {
  394.     port = TCP_LOCAL_PORT_RANGE_START;
  395.   }

  397.   for(pcb = tcp_active_pcbs; pcb != NULL; pcb = pcb->next) {
  398.     if (pcb->local_port == port) {
  399.       goto again;
  400.     }
  401.   }
  402.   for(pcb = tcp_tw_pcbs; pcb != NULL; pcb = pcb->next) {
  403.     if (pcb->local_port == port) {
  404.       goto again;
  405.     }
  406.   }
  407.   for(pcb = (struct tcp_pcb *)tcp_listen_pcbs.pcbs; pcb != NULL; pcb = pcb->next) {
  408.     if (pcb->local_port == port) {
  409.       goto again;
  410.     }
  411.   }
  412.   return port;
  413. }
  414. /**
  415. * Connects to another host. The function given as the "connected"
  416. * argument will be called when the connection has been established.
  417. *
  418. * @param pcb the tcp_pcb used to establish the connection
  419. * @param ipaddr the remote ip address to connect to
  420. * @param port the remote tcp port to connect to
  421. * @param connected callback function to call when connected (or on error)
  422. * @return ERR_VAL if invalid arguments are given
  423. *         ERR_OK if connect request has been sent
  424. *         other err_t values if connect request couldn't be sent
  425. */
  426. err_t
  427. tcp_connect(struct tcp_pcb *pcb, struct ip_addr *ipaddr, u16_t port,
  428.       err_t (* connected)(void *arg, struct tcp_pcb *tpcb, err_t err))
  429. {
  430.   err_t ret;
  431.   u32_t iss;
  432.   LWIP_ERROR("tcp_connect: can only connected from state CLOSED", pcb->state == CLOSED, return ERR_ISCONN);
  433.   LWIP_DEBUGF(TCP_DEBUG, ("tcp_connect to port %"U16_F"\n", port));
  434.   if (ipaddr != NULL) {
  435.     pcb->remote_ip = *ipaddr;
  436.   } else {
  437.     return ERR_VAL;
  438.   }
  439.   pcb->remote_port = port;
  440.   if (pcb->local_port == 0) {
  441.     pcb->local_port = tcp_new_port();
  442.   }
  443.   iss = tcp_next_iss();
  444.   pcb->rcv_nxt = 0;
  445.   pcb->snd_nxt = iss;
  446.   pcb->lastack = iss - 1;
  447.   pcb->snd_lbb = iss - 1;
  448.   pcb->rcv_wnd = TCP_WND;
  449.   pcb->rcv_ann_wnd = TCP_WND;
  450.   pcb->rcv_ann_right_edge = pcb->rcv_nxt;
  451.   pcb->snd_wnd = TCP_WND;
  452.   /* As initial send MSS, we use TCP_MSS but limit it to 536.
  453.      The send MSS is updated when an MSS option is received. */
  454.   pcb->mss = (TCP_MSS > 536) ? 536 : TCP_MSS;
  455. #if TCP_CALCULATE_EFF_SEND_MSS
  456.   pcb->mss = tcp_eff_send_mss(pcb->mss, ipaddr);
  457. #endif /* TCP_CALCULATE_EFF_SEND_MSS */
  458.   pcb->cwnd = 1;
  459.   pcb->ssthresh = pcb->mss * 10;
  460.   pcb->state = SYN_SENT;
  461. #if LWIP_CALLBACK_API
  462.   pcb->connected = connected;
  463. #endif /* LWIP_CALLBACK_API */
  464.   TCP_RMV(&tcp_bound_pcbs, pcb);
  465.   TCP_REG(&tcp_active_pcbs, pcb);
  466.   snmp_inc_tcpactiveopens();

  468.   ret = tcp_enqueue(pcb, NULL, 0, TCP_SYN, 0, TF_SEG_OPTS_MSS
  469. #if LWIP_TCP_TIMESTAMPS
  470.                     | TF_SEG_OPTS_TS
  471. #endif
  472.                     );
  473.   if (ret == ERR_OK) {
  474.     tcp_output(pcb);
  475.   }
  476.   return ret;
  477. }
  478. /**
  479. * Called every 500 ms and implements the retransmission timer and the timer that
  480. * removes PCBs that have been in TIME-WAIT for enough time. It also increments
  481. * various timers such as the inactivity timer in each PCB.
  482. *
  483. * Automatically called from tcp_tmr().
  484. */
  485. void
  486. tcp_slowtmr(void)
  487. {
  488.   struct tcp_pcb *pcb, *pcb2, *prev;
  489.   u16_t eff_wnd;
  490.   u8_t pcb_remove;      /* flag if a PCB should be removed */
  491.   u8_t pcb_reset;       /* flag if a RST should be sent when removing */
  492.   err_t err;
  493.   err = ERR_OK;
  494.   ++tcp_ticks;
  495.   /* Steps through all of the active PCBs. */
  496.   prev = NULL;
  497.   pcb = tcp_active_pcbs;
  498.   if (pcb == NULL) {
  499.     LWIP_DEBUGF(TCP_DEBUG, ("tcp_slowtmr: no active pcbs\n"));
  500.   }
  501.   while (pcb != NULL) {
  502.     LWIP_DEBUGF(TCP_DEBUG, ("tcp_slowtmr: processing active pcb\n"));
  503.     LWIP_ASSERT("tcp_slowtmr: active pcb->state != CLOSED\n", pcb->state != CLOSED);
  504.     LWIP_ASSERT("tcp_slowtmr: active pcb->state != LISTEN\n", pcb->state != LISTEN);
  505.     LWIP_ASSERT("tcp_slowtmr: active pcb->state != TIME-WAIT\n", pcb->state != TIME_WAIT);
  506.     pcb_remove = 0;
  507.     pcb_reset = 0;
  508.     if (pcb->state == SYN_SENT && pcb->nrtx == TCP_SYNMAXRTX) {
  509.       ++pcb_remove;
  510.       LWIP_DEBUGF(TCP_DEBUG, ("tcp_slowtmr: max SYN retries reached\n"));
  511.     }
  512.     else if (pcb->nrtx == TCP_MAXRTX) {
  513.       ++pcb_remove;
  514.       LWIP_DEBUGF(TCP_DEBUG, ("tcp_slowtmr: max DATA retries reached\n"));
  515.     } else {
  516.       if (pcb->persist_backoff > 0) {
  517.         /* If snd_wnd is zero, use persist timer to send 1 byte probes
  518.          * instead of using the standard retransmission mechanism. */
  519.         pcb->persist_cnt++;
  520.         if (pcb->persist_cnt >= tcp_persist_backoff[pcb->persist_backoff-1]) {
  521.           pcb->persist_cnt = 0;
  522.           if (pcb->persist_backoff < sizeof(tcp_persist_backoff)) {
  523.             pcb->persist_backoff++;
  524.           }
  525.           tcp_zero_window_probe(pcb);
  526.         }
  527.       } else {
  528.         /* Increase the retransmission timer if it is running */
  529.         if(pcb->rtime >= 0)
  530.           ++pcb->rtime;
  531.         if (pcb->unacked != NULL && pcb->rtime >= pcb->rto) {
  532.           /* Time for a retransmission. */
  533.           LWIP_DEBUGF(TCP_RTO_DEBUG, ("tcp_slowtmr: rtime %"S16_F
  534.                                       " pcb->rto %"S16_F"\n",
  535.                                       pcb->rtime, pcb->rto));
  536.           /* Double retransmission time-out unless we are trying to
  537.            * connect to somebody (i.e., we are in SYN_SENT). */
  538.           if (pcb->state != SYN_SENT) {
  539.             pcb->rto = ((pcb->sa >> 3) + pcb->sv) << tcp_backoff[pcb->nrtx];
  540.           }
  541.           /* Reset the retransmission timer. */
  542.           pcb->rtime = 0;
  543.           /* Reduce congestion window and ssthresh. */
  544.           eff_wnd = LWIP_MIN(pcb->cwnd, pcb->snd_wnd);
  545.           pcb->ssthresh = eff_wnd >> 1;
  546.           if (pcb->ssthresh < pcb->mss) {
  547.             pcb->ssthresh = pcb->mss * 2;
  548.           }
  549.           pcb->cwnd = pcb->mss;
  550.           LWIP_DEBUGF(TCP_CWND_DEBUG, ("tcp_slowtmr: cwnd %"U16_F
  551.                                        " ssthresh %"U16_F"\n",
  552.                                        pcb->cwnd, pcb->ssthresh));

  554.           /* The following needs to be called AFTER cwnd is set to one
  555.              mss - STJ */
  556.           tcp_rexmit_rto(pcb);
  557.         }
  558.       }
  559.     }
  560.     /* Check if this PCB has stayed too long in FIN-WAIT-2 */
  561.     if (pcb->state == FIN_WAIT_2) {
  562.       if ((u32_t)(tcp_ticks - pcb->tmr) >
  563.           TCP_FIN_WAIT_TIMEOUT / TCP_SLOW_INTERVAL) {
  564.         ++pcb_remove;
  565.         LWIP_DEBUGF(TCP_DEBUG, ("tcp_slowtmr: removing pcb stuck in FIN-WAIT-2\n"));
  566.       }
  567.     }
  568.     /* Check if KEEPALIVE should be sent */
  569.     if((pcb->so_options & SOF_KEEPALIVE) &&
  570.        ((pcb->state == ESTABLISHED) ||
  571.         (pcb->state == CLOSE_WAIT))) {
  572. #if LWIP_TCP_KEEPALIVE
  573.       if((u32_t)(tcp_ticks - pcb->tmr) >
  574.          (pcb->keep_idle + (pcb->keep_cnt*pcb->keep_intvl))
  575.          / TCP_SLOW_INTERVAL)
  576. #else     
  577.       if((u32_t)(tcp_ticks - pcb->tmr) >
  578.          (pcb->keep_idle + TCP_MAXIDLE) / TCP_SLOW_INTERVAL)
  579. #endif /* LWIP_TCP_KEEPALIVE */
  580.       {
  581.         LWIP_DEBUGF(TCP_DEBUG, ("tcp_slowtmr: KEEPALIVE timeout. Aborting connection to %"U16_F".%"U16_F".%"U16_F".%"U16_F".\n",
  582.                                 ip4_addr1(&pcb->remote_ip), ip4_addr2(&pcb->remote_ip),
  583.                                 ip4_addr3(&pcb->remote_ip), ip4_addr4(&pcb->remote_ip)));
  584.       
  585.         ++pcb_remove;
  586.         ++pcb_reset;
  587.       }
  588. #if LWIP_TCP_KEEPALIVE
  589.       else if((u32_t)(tcp_ticks - pcb->tmr) >
  590.               (pcb->keep_idle + pcb->keep_cnt_sent * pcb->keep_intvl)
  591.               / TCP_SLOW_INTERVAL)
  592. #else
  593.       else if((u32_t)(tcp_ticks - pcb->tmr) >
  594.               (pcb->keep_idle + pcb->keep_cnt_sent * TCP_KEEPINTVL_DEFAULT)
  595.               / TCP_SLOW_INTERVAL)
  596. #endif /* LWIP_TCP_KEEPALIVE */
  597.       {
  598.         tcp_keepalive(pcb);
  599.         pcb->keep_cnt_sent++;
  600.       }
  601.     }
  602.     /* If this PCB has queued out of sequence data, but has been
  603.        inactive for too long, will drop the data (it will eventually
  604.        be retransmitted). */
  605. #if TCP_QUEUE_OOSEQ   
  606.     if (pcb->ooseq != NULL &&
  607.         (u32_t)tcp_ticks - pcb->tmr >= pcb->rto * TCP_OOSEQ_TIMEOUT) {
  608.       tcp_segs_free(pcb->ooseq);
  609.       pcb->ooseq = NULL;
  610.       LWIP_DEBUGF(TCP_CWND_DEBUG, ("tcp_slowtmr: dropping OOSEQ queued data\n"));
  611.     }
  612. #endif /* TCP_QUEUE_OOSEQ */
  613.     /* Check if this PCB has stayed too long in SYN-RCVD */
  614.     if (pcb->state == SYN_RCVD) {
  615.       if ((u32_t)(tcp_ticks - pcb->tmr) >
  616.           TCP_SYN_RCVD_TIMEOUT / TCP_SLOW_INTERVAL) {
  617.         ++pcb_remove;
  618.         LWIP_DEBUGF(TCP_DEBUG, ("tcp_slowtmr: removing pcb stuck in SYN-RCVD\n"));
  619.       }
  620.     }
  621.     /* Check if this PCB has stayed too long in LAST-ACK */
  622.     if (pcb->state == LAST_ACK) {
  623.       if ((u32_t)(tcp_ticks - pcb->tmr) > 2 * TCP_MSL / TCP_SLOW_INTERVAL) {
  624.         ++pcb_remove;
  625.         LWIP_DEBUGF(TCP_DEBUG, ("tcp_slowtmr: removing pcb stuck in LAST-ACK\n"));
  626.       }
  627.     }
  628.     /* If the PCB should be removed, do it. */
  629.     if (pcb_remove) {
  630.       tcp_pcb_purge(pcb);     
  631.       /* Remove PCB from tcp_active_pcbs list. */
  632.       if (prev != NULL) {
  633.         LWIP_ASSERT("tcp_slowtmr: middle tcp != tcp_active_pcbs", pcb != tcp_active_pcbs);
  634.         prev->next = pcb->next;
  635.       } else {
  636.         /* This PCB was the first. */
  637.         LWIP_ASSERT("tcp_slowtmr: first pcb == tcp_active_pcbs", tcp_active_pcbs == pcb);
  638.         tcp_active_pcbs = pcb->next;
  639.       }
  640.       TCP_EVENT_ERR(pcb->errf, pcb->callback_arg, ERR_ABRT);
  641.       if (pcb_reset) {
  642.         tcp_rst(pcb->snd_nxt, pcb->rcv_nxt, &pcb->local_ip, &pcb->remote_ip,
  643.           pcb->local_port, pcb->remote_port);
  644.       }
  645.       pcb2 = pcb->next;
  646.       memp_free(MEMP_TCP_PCB, pcb);
  647.       pcb = pcb2;
  648.     } else {
  649.       /* We check if we should poll the connection. */
  650.       ++pcb->polltmr;
  651.       if (pcb->polltmr >= pcb->pollinterval) {
  652.         pcb->polltmr = 0;
  653.         LWIP_DEBUGF(TCP_DEBUG, ("tcp_slowtmr: polling application\n"));
  654.         TCP_EVENT_POLL(pcb, err);
  655.         if (err == ERR_OK) {
  656.           tcp_output(pcb);
  657.         }
  658.       }
  659.      
  660.       prev = pcb;
  661.       pcb = pcb->next;
  662.     }
  663.   }

  665.   /* Steps through all of the TIME-WAIT PCBs. */
  666.   prev = NULL;   
  667.   pcb = tcp_tw_pcbs;
  668.   while (pcb != NULL) {
  669.     LWIP_ASSERT("tcp_slowtmr: TIME-WAIT pcb->state == TIME-WAIT", pcb->state == TIME_WAIT);
  670.     pcb_remove = 0;
  671.     /* Check if this PCB has stayed long enough in TIME-WAIT */
  672.     if ((u32_t)(tcp_ticks - pcb->tmr) > 2 * TCP_MSL / TCP_SLOW_INTERVAL) {
  673.       ++pcb_remove;
  674.     }
  675.    

  677.     /* If the PCB should be removed, do it. */
  678.     if (pcb_remove) {
  679.       tcp_pcb_purge(pcb);     
  680.       /* Remove PCB from tcp_tw_pcbs list. */
  681.       if (prev != NULL) {
  682.         LWIP_ASSERT("tcp_slowtmr: middle tcp != tcp_tw_pcbs", pcb != tcp_tw_pcbs);
  683.         prev->next = pcb->next;
  684.       } else {
  685.         /* This PCB was the first. */
  686.         LWIP_ASSERT("tcp_slowtmr: first pcb == tcp_tw_pcbs", tcp_tw_pcbs == pcb);
  687.         tcp_tw_pcbs = pcb->next;
  688.       }
  689.       pcb2 = pcb->next;
  690.       memp_free(MEMP_TCP_PCB, pcb);
  691.       pcb = pcb2;
  692.     } else {
  693.       prev = pcb;
  694.       pcb = pcb->next;
  695.     }
  696.   }
  697. }
  698. /**
  699. * Is called every TCP_FAST_INTERVAL (250 ms) and process data previously
  700. * "refused" by upper layer (application) and sends delayed ACKs.
  701. *
  702. * Automatically called from tcp_tmr().
  703. */
  704. void
  705. tcp_fasttmr(void)
  706. {
  707.   struct tcp_pcb *pcb;
  708.   for(pcb = tcp_active_pcbs; pcb != NULL; pcb = pcb->next) {
  709.     /* If there is data which was previously "refused" by upper layer */
  710.     if (pcb->refused_data != NULL) {
  711.       /* Notify again application with data previously received. */
  712.       err_t err;
  713.       LWIP_DEBUGF(TCP_INPUT_DEBUG, ("tcp_fasttmr: notify kept packet\n"));
  714.       TCP_EVENT_RECV(pcb, pcb->refused_data, ERR_OK, err);
  715.       if (err == ERR_OK) {
  716.         pcb->refused_data = NULL;
  717.       }
  718.     }
  719.     /* send delayed ACKs */
  720.     if (pcb->flags & TF_ACK_DELAY) {
  721.       LWIP_DEBUGF(TCP_DEBUG, ("tcp_fasttmr: delayed ACK\n"));
  722.       tcp_ack_now(pcb);
  723.       pcb->flags &= ~(TF_ACK_DELAY | TF_ACK_NOW);
  724.     }
  725.   }
  726. }
  727. /**
  728. * Deallocates a list of TCP segments (tcp_seg structures).
  729. *
  730. * @param seg tcp_seg list of TCP segments to free
  731. * @return the number of pbufs that were deallocated
  732. */
  733. u8_t
  734. tcp_segs_free(struct tcp_seg *seg)
  735. {
  736.   u8_t count = 0;
  737.   struct tcp_seg *next;
  738.   while (seg != NULL) {
  739.     next = seg->next;
  740.     count += tcp_seg_free(seg);
  741.     seg = next;
  742.   }
  743.   return count;
  744. }
  745. /**
  746. * Frees a TCP segment (tcp_seg structure).
  747. *
  748. * @param seg single tcp_seg to free
  749. * @return the number of pbufs that were deallocated
  750. */
  751. u8_t
  752. tcp_seg_free(struct tcp_seg *seg)
  753. {
  754.   u8_t count = 0;

  756.   if (seg != NULL) {
  757.     if (seg->p != NULL) {
  758.       count = pbuf_free(seg->p);
  759. #if TCP_DEBUG
  760.       seg->p = NULL;
  761. #endif /* TCP_DEBUG */
  762.     }
  763.     memp_free(MEMP_TCP_SEG, seg);
  764.   }
  765.   return count;
  766. }
  767. /**
  768. * Sets the priority of a connection.
  769. *
  770. * @param pcb the tcp_pcb to manipulate
  771. * @param prio new priority
  772. */
  773. void
  774. tcp_setprio(struct tcp_pcb *pcb, u8_t prio)
  775. {
  776.   pcb->prio = prio;
  777. }
  778. #if TCP_QUEUE_OOSEQ
  779. /**
  780. * Returns a copy of the given TCP segment.
  781. * The pbuf and data are not copied, only the pointers
  782. *
  783. * @param seg the old tcp_seg
  784. * @return a copy of seg
  785. */
  786. struct tcp_seg *
  787. tcp_seg_copy(struct tcp_seg *seg)
  788. {
  789.   struct tcp_seg *cseg;
  790.   cseg = memp_malloc(MEMP_TCP_SEG);
  791.   if (cseg == NULL) {
  792.     return NULL;
  793.   }
  794.   SMEMCPY((u8_t *)cseg, (const u8_t *)seg, sizeof(struct tcp_seg));
  795.   pbuf_ref(cseg->p);
  796.   return cseg;
  797. }
  798. #endif
  799. #if LWIP_CALLBACK_API
  800. /**
  801. * Default receive callback that is called if the user didn't register
  802. * a recv callback for the pcb.
  803. */
  804. err_t
  805. tcp_recv_null(void *arg, struct tcp_pcb *pcb, struct pbuf *p, err_t err)
  806. {
  807.   LWIP_UNUSED_ARG(arg);
  808.   if (p != NULL) {
  809.     tcp_recved(pcb, p->tot_len);
  810.     pbuf_free(p);
  811.   } else if (err == ERR_OK) {
  812.     return tcp_close(pcb);
  813.   }
  814.   return ERR_OK;
  815. }
  816. #endif /* LWIP_CALLBACK_API */
  817. /**
  818. * Kills the oldest active connection that has lower priority than prio.
  819. *
  820. * @param prio minimum priority
  821. */
  822. static void
  823. tcp_kill_prio(u8_t prio)
  824. {
  825.   struct tcp_pcb *pcb, *inactive;
  826.   u32_t inactivity;
  827.   u8_t mprio;

  829.   mprio = TCP_PRIO_MAX;

  831.   /* We kill the oldest active connection that has lower priority than prio. */
  832.   inactivity = 0;
  833.   inactive = NULL;
  834.   for(pcb = tcp_active_pcbs; pcb != NULL; pcb = pcb->next) {
  835.     if (pcb->prio <= prio &&
  836.        pcb->prio <= mprio &&
  837.        (u32_t)(tcp_ticks - pcb->tmr) >= inactivity) {
  838.       inactivity = tcp_ticks - pcb->tmr;
  839.       inactive = pcb;
  840.       mprio = pcb->prio;
  841.     }
  842.   }
  843.   if (inactive != NULL) {
  844.     LWIP_DEBUGF(TCP_DEBUG, ("tcp_kill_prio: killing oldest PCB %p (%"S32_F")\n",
  845.            (void *)inactive, inactivity));
  846.     tcp_abort(inactive);
  847.   }     
  848. }
  849. /**
  850. * Kills the oldest connection that is in TIME_WAIT state.
  851. * Called from tcp_alloc() if no more connections are available.
  852. */
  853. static void
  854. tcp_kill_timewait(void)
  855. {
  856.   struct tcp_pcb *pcb, *inactive;
  857.   u32_t inactivity;
  858.   inactivity = 0;
  859.   inactive = NULL;
  860.   /* Go through the list of TIME_WAIT pcbs and get the oldest pcb. */
  861.   for(pcb = tcp_tw_pcbs; pcb != NULL; pcb = pcb->next) {
  862.     if ((u32_t)(tcp_ticks - pcb->tmr) >= inactivity) {
  863.       inactivity = tcp_ticks - pcb->tmr;
  864.       inactive = pcb;
  865.     }
  866.   }
  867.   if (inactive != NULL) {
  868.     LWIP_DEBUGF(TCP_DEBUG, ("tcp_kill_timewait: killing oldest TIME-WAIT PCB %p (%"S32_F")\n",
  869.            (void *)inactive, inactivity));
  870.     tcp_abort(inactive);
  871.   }     
  872. }
  873. /**
  874. * Allocate a new tcp_pcb structure.
  875. *
  876. * @param prio priority for the new pcb
  877. * @return a new tcp_pcb that initially is in state CLOSED
  878. */
  879. struct tcp_pcb *
  880. tcp_alloc(u8_t prio)
  881. {
  882.   struct tcp_pcb *pcb;
  883.   u32_t iss;

  885.   pcb = memp_malloc(MEMP_TCP_PCB);
  886.   if (pcb == NULL) {
  887.     /* Try killing oldest connection in TIME-WAIT. */
  888.     LWIP_DEBUGF(TCP_DEBUG, ("tcp_alloc: killing off oldest TIME-WAIT connection\n"));
  889.     tcp_kill_timewait();
  890.     /* Try to allocate a tcp_pcb again. */
  891.     pcb = memp_malloc(MEMP_TCP_PCB);
  892.     if (pcb == NULL) {
  893.       /* Try killing active connections with lower priority than the new one. */
  894.       LWIP_DEBUGF(TCP_DEBUG, ("tcp_alloc: killing connection with prio lower than %d\n", prio));
  895.       tcp_kill_prio(prio);
  896.       /* Try to allocate a tcp_pcb again. */
  897.       pcb = memp_malloc(MEMP_TCP_PCB);
  898.       if (pcb != NULL) {
  899.         /* adjust err stats: memp_malloc failed twice before */
  900.         MEMP_STATS_DEC(err, MEMP_TCP_PCB);
  901.       }
  902.     }
  903.     if (pcb != NULL) {
  904.       /* adjust err stats: timewait PCB was freed above */
  905.       MEMP_STATS_DEC(err, MEMP_TCP_PCB);
  906.     }
  907.   }
  908.   if (pcb != NULL) {
  909.     memset(pcb, 0, sizeof(struct tcp_pcb));
  910.     pcb->prio = TCP_PRIO_NORMAL;
  911.     pcb->snd_buf = TCP_SND_BUF;
  912.     pcb->snd_queuelen = 0;
  913.     pcb->rcv_wnd = TCP_WND;
  914.     pcb->rcv_ann_wnd = TCP_WND;
  915.     pcb->tos = 0;
  916.     pcb->ttl = TCP_TTL;
  917.     /* As initial send MSS, we use TCP_MSS but limit it to 536.
  918.        The send MSS is updated when an MSS option is received. */
  919.     pcb->mss = (TCP_MSS > 536) ? 536 : TCP_MSS;
  920.     pcb->rto = 3000 / TCP_SLOW_INTERVAL;
  921.     pcb->sa = 0;
  922.     pcb->sv = 3000 / TCP_SLOW_INTERVAL;
  923.     pcb->rtime = -1;
  924.     pcb->cwnd = 1;
  925.     iss = tcp_next_iss();
  926.     pcb->snd_wl2 = iss;
  927.     pcb->snd_nxt = iss;
  928.     pcb->lastack = iss;
  929.     pcb->snd_lbb = iss;  
  930.     pcb->tmr = tcp_ticks;
  931.     pcb->polltmr = 0;
  932. #if LWIP_CALLBACK_API
  933.     pcb->recv = tcp_recv_null;
  934. #endif /* LWIP_CALLBACK_API */
  935.    
  936.     /* Init KEEPALIVE timer */
  937.     pcb->keep_idle  = TCP_KEEPIDLE_DEFAULT;
  938.    
  939. #if LWIP_TCP_KEEPALIVE
  940.     pcb->keep_intvl = TCP_KEEPINTVL_DEFAULT;
  941.     pcb->keep_cnt   = TCP_KEEPCNT_DEFAULT;
  942. #endif /* LWIP_TCP_KEEPALIVE */
  943.     pcb->keep_cnt_sent = 0;
  944.   }
  945.   return pcb;
  946. }
  947. /**
  948. * Creates a new TCP protocol control block but doesn't place it on
  949. * any of the TCP PCB lists.
  950. * The pcb is not put on any list until binding using tcp_bind().
  951. *
  952. * @internal: Maybe there should be a idle TCP PCB list where these
  953. * PCBs are put on. Port reservation using tcp_bind() is implemented but
  954. * allocated pcbs that are not bound can't be killed automatically if wanting
  955. * to allocate a pcb with higher prio (@see tcp_kill_prio())
  956. *
  957. * @return a new tcp_pcb that initially is in state CLOSED
  958. */
  959. struct tcp_pcb *
  960. tcp_new(void)
  961. {
  962.   return tcp_alloc(TCP_PRIO_NORMAL);
  963. }
  964. /**
  965. * Used to specify the argument that should be passed callback
  966. * functions.
  967. *
  968. * @param pcb tcp_pcb to set the callback argument
  969. * @param arg void pointer argument to pass to callback functions
  970. */
  971. void
  972. tcp_arg(struct tcp_pcb *pcb, void *arg)
  973. {
  974.   pcb->callback_arg = arg;
  975. }
  976. #if LWIP_CALLBACK_API
  977. /**
  978. * Used to specify the function that should be called when a TCP
  979. * connection receives data.
  980. *
  981. * @param pcb tcp_pcb to set the recv callback
  982. * @param recv callback function to call for this pcb when data is received
  983. */
  984. void
  985. tcp_recv(struct tcp_pcb *pcb,
  986.    err_t (* recv)(void *arg, struct tcp_pcb *tpcb, struct pbuf *p, err_t err))
  987. {
  988.   pcb->recv = recv;
  989. }
  990. /**
  991. * Used to specify the function that should be called when TCP data
  992. * has been successfully delivered to the remote host.
  993. *
  994. * @param pcb tcp_pcb to set the sent callback
  995. * @param sent callback function to call for this pcb when data is successfully sent
  996. */
  997. void
  998. tcp_sent(struct tcp_pcb *pcb,
  999.    err_t (* sent)(void *arg, struct tcp_pcb *tpcb, u16_t len))
  1000. {
  1001.   pcb->sent = sent;
  1002. }
  1003. /**
  1004. * Used to specify the function that should be called when a fatal error
  1005. * has occured on the connection.
  1006. *
  1007. * @param pcb tcp_pcb to set the err callback
  1008. * @param errf callback function to call for this pcb when a fatal error
  1009. *        has occured on the connection
  1010. */
  1011. void
  1012. tcp_err(struct tcp_pcb *pcb,
  1013.    void (* errf)(void *arg, err_t err))
  1014. {
  1015.   pcb->errf = errf;
  1016. }
  1017. /**
  1018. * Used for specifying the function that should be called when a
  1019. * LISTENing connection has been connected to another host.
  1020. *
  1021. * @param pcb tcp_pcb to set the accept callback
  1022. * @param accept callback function to call for this pcb when LISTENing
  1023. *        connection has been connected to another host
  1024. */
  1025. void
  1026. tcp_accept(struct tcp_pcb *pcb,
  1027.      err_t (* accept)(void *arg, struct tcp_pcb *newpcb, err_t err))
  1028. {
  1029.   pcb->accept = accept;
  1030. }
  1031. #endif /* LWIP_CALLBACK_API */

  1033. /**
  1034. * Used to specify the function that should be called periodically
  1035. * from TCP. The interval is specified in terms of the TCP coarse
  1036. * timer interval, which is called twice a second.
  1037. *
  1038. */
  1039. void
  1040. tcp_poll(struct tcp_pcb *pcb,
  1041.    err_t (* poll)(void *arg, struct tcp_pcb *tpcb), u8_t interval)
  1042. {
  1043. #if LWIP_CALLBACK_API
  1044.   pcb->poll = poll;
  1045. #endif /* LWIP_CALLBACK_API */
  1046.   pcb->pollinterval = interval;
  1047. }
  1048. /**
  1049. * Purges a TCP PCB. Removes any buffered data and frees the buffer memory
  1050. * (pcb->ooseq, pcb->unsent and pcb->unacked are freed).
  1051. *
  1052. * @param pcb tcp_pcb to purge. The pcb itself is not deallocated!
  1053. */
  1054. void
  1055. tcp_pcb_purge(struct tcp_pcb *pcb)
  1056. {
  1057.   if (pcb->state != CLOSED &&
  1058.      pcb->state != TIME_WAIT &&
  1059.      pcb->state != LISTEN) {
  1060.     LWIP_DEBUGF(TCP_DEBUG, ("tcp_pcb_purge\n"));
  1061. #if TCP_LISTEN_BACKLOG
  1062.     if (pcb->state == SYN_RCVD) {
  1063.       /* Need to find the corresponding listen_pcb and decrease its accepts_pending */
  1064.       struct tcp_pcb_listen *lpcb;
  1065.       LWIP_ASSERT("tcp_pcb_purge: pcb->state == SYN_RCVD but tcp_listen_pcbs is NULL",
  1066.         tcp_listen_pcbs.listen_pcbs != NULL);
  1067.       for (lpcb = tcp_listen_pcbs.listen_pcbs; lpcb != NULL; lpcb = lpcb->next) {
  1068.         if ((lpcb->local_port == pcb->local_port) &&
  1069.             (ip_addr_isany(&lpcb->local_ip) ||
  1070.              ip_addr_cmp(&pcb->local_ip, &lpcb->local_ip))) {
  1071.             /* port and address of the listen pcb match the timed-out pcb */
  1072.             LWIP_ASSERT("tcp_pcb_purge: listen pcb does not have accepts pending",
  1073.               lpcb->accepts_pending > 0);
  1074.             lpcb->accepts_pending--;
  1075.             break;
  1076.           }
  1077.       }
  1078.     }
  1079. #endif /* TCP_LISTEN_BACKLOG */

  1081.     if (pcb->refused_data != NULL) {
  1082.       LWIP_DEBUGF(TCP_DEBUG, ("tcp_pcb_purge: data left on ->refused_data\n"));
  1083.       pbuf_free(pcb->refused_data);
  1084.       pcb->refused_data = NULL;
  1085.     }
  1086.     if (pcb->unsent != NULL) {
  1087.       LWIP_DEBUGF(TCP_DEBUG, ("tcp_pcb_purge: not all data sent\n"));
  1088.     }
  1089.     if (pcb->unacked != NULL) {
  1090.       LWIP_DEBUGF(TCP_DEBUG, ("tcp_pcb_purge: data left on ->unacked\n"));
  1091.     }
  1092. #if TCP_QUEUE_OOSEQ /* LW */
  1093.     if (pcb->ooseq != NULL) {
  1094.       LWIP_DEBUGF(TCP_DEBUG, ("tcp_pcb_purge: data left on ->ooseq\n"));
  1095.     }
  1096.     /* Stop the retransmission timer as it will expect data on unacked
  1097.        queue if it fires */
  1098.     pcb->rtime = -1;
  1099.     tcp_segs_free(pcb->ooseq);
  1100.     pcb->ooseq = NULL;
  1101. #endif /* TCP_QUEUE_OOSEQ */
  1102.     tcp_segs_free(pcb->unsent);
  1103.     tcp_segs_free(pcb->unacked);
  1104.     pcb->unacked = pcb->unsent = NULL;
  1105.   }
  1106. }
  1107. /**
  1108. * Purges the PCB and removes it from a PCB list. Any delayed ACKs are sent first.
  1109. *
  1110. * @param pcblist PCB list to purge.
  1111. * @param pcb tcp_pcb to purge. The pcb itself is NOT deallocated!
  1112. */
  1113. void
  1114. tcp_pcb_remove(struct tcp_pcb **pcblist, struct tcp_pcb *pcb)
  1115. {
  1116.   TCP_RMV(pcblist, pcb);
  1117.   tcp_pcb_purge(pcb);

  1119.   /* if there is an outstanding delayed ACKs, send it */
  1120.   if (pcb->state != TIME_WAIT &&
  1121.      pcb->state != LISTEN &&
  1122.      pcb->flags & TF_ACK_DELAY) {
  1123.     pcb->flags |= TF_ACK_NOW;
  1124.     tcp_output(pcb);
  1125.   }
  1126.   if (pcb->state != LISTEN) {
  1127.     LWIP_ASSERT("unsent segments leaking", pcb->unsent == NULL);
  1128.     LWIP_ASSERT("unacked segments leaking", pcb->unacked == NULL);
  1129. #if TCP_QUEUE_OOSEQ
  1130.     LWIP_ASSERT("ooseq segments leaking", pcb->ooseq == NULL);
  1131. #endif /* TCP_QUEUE_OOSEQ */
  1132.   }
  1133.   pcb->state = CLOSED;
  1134.   LWIP_ASSERT("tcp_pcb_remove: tcp_pcbs_sane()", tcp_pcbs_sane());
  1135. }
  1136. /**
  1137. * Calculates a new initial sequence number for new connections.
  1138. //calculate ['k?lkjuleit]
  1139. vt.
  1140. 1. 计算；核算：
  1141. * @return u32_t pseudo random sequence number
  1142. */
  1143. u32_t
  1144. tcp_next_iss(void)
  1145. {
  1146.   static u32_t iss = 6510;

  1148.   iss += tcp_ticks;       /* XXX */
  1149.   return iss;
  1150. }
  1151. #if TCP_CALCULATE_EFF_SEND_MSS
  1152. /**
  1153. * Calcluates the effective send mss that can be used for a specific IP address
  1154. * by using ip_route to determin the netif used to send to the address and
  1155. * calculating the minimum of TCP_MSS and that netif's mtu (if set).
  1156. */
  1157. u16_t
  1158. tcp_eff_send_mss(u16_t sendmss, struct ip_addr *addr)
  1159. {
  1160.   u16_t mss_s;
  1161.   struct netif *outif;
  1162.   outif = ip_route(addr);
  1163.   if ((outif != NULL) && (outif->mtu != 0)) {
  1164.     mss_s = outif->mtu - IP_HLEN - TCP_HLEN;
  1165.     /* RFC 1122, chap 4.2.2.6:
  1166.      * Eff.snd.MSS = min(SendMSS+20, MMS_S) - TCPhdrsize - IPoptionsize
  1167.      * We correct for TCP options in tcp_enqueue(), and don't support
  1168.      * IP options
  1169.      */
  1170.     sendmss = LWIP_MIN(sendmss, mss_s);
  1171.   }
  1172.   return sendmss;
  1173. }
  1174. #endif /* TCP_CALCULATE_EFF_SEND_MSS */
  1175. const char*
  1176. tcp_debug_state_str(enum tcp_state s)
  1177. {
  1178.   return tcp_state_str[s];
  1179. }
  1180. #if TCP_DEBUG || TCP_INPUT_DEBUG || TCP_OUTPUT_DEBUG
  1181. /**
  1182. * Print a tcp header for debugging purposes.
  1183. *
  1184. * @param tcphdr pointer to a struct tcp_hdr
  1185. */
  1186. void
  1187. tcp_debug_print(struct tcp_hdr *tcphdr)
  1188. {
  1189.   LWIP_DEBUGF(TCP_DEBUG, ("TCP header:\n"));
  1190.   LWIP_DEBUGF(TCP_DEBUG, ("+-------------------------------+\n"));
  1191.   LWIP_DEBUGF(TCP_DEBUG, ("|    %5"U16_F"      |    %5"U16_F"      | (src port, dest port)\n",
  1192.          ntohs(tcphdr->src), ntohs(tcphdr->dest)));
  1193.   LWIP_DEBUGF(TCP_DEBUG, ("+-------------------------------+\n"));
  1194.   LWIP_DEBUGF(TCP_DEBUG, ("|           %010"U32_F"          | (seq no)\n",
  1195.           ntohl(tcphdr->seqno)));
  1196.   LWIP_DEBUGF(TCP_DEBUG, ("+-------------------------------+\n"));
  1197.   LWIP_DEBUGF(TCP_DEBUG, ("|           %010"U32_F"          | (ack no)\n",
  1198.          ntohl(tcphdr->ackno)));
  1199.   LWIP_DEBUGF(TCP_DEBUG, ("+-------------------------------+\n"));
  1200.   LWIP_DEBUGF(TCP_DEBUG, ("| %2"U16_F" |   |%"U16_F"%"U16_F"%"U16_F"%"U16_F"%"U16_F"%"U16_F"|     %5"U16_F"     | (hdrlen, flags (",
  1201.        TCPH_HDRLEN(tcphdr),
  1202.          TCPH_FLAGS(tcphdr) >> 5 & 1,
  1203.          TCPH_FLAGS(tcphdr) >> 4 & 1,
  1204.          TCPH_FLAGS(tcphdr) >> 3 & 1,
  1205.          TCPH_FLAGS(tcphdr) >> 2 & 1,
  1206.          TCPH_FLAGS(tcphdr) >> 1 & 1,
  1207.          TCPH_FLAGS(tcphdr) & 1,
  1208.          ntohs(tcphdr->wnd)));
  1209.   tcp_debug_print_flags(TCPH_FLAGS(tcphdr));
  1210.   LWIP_DEBUGF(TCP_DEBUG, ("), win)\n"));
  1211.   LWIP_DEBUGF(TCP_DEBUG, ("+-------------------------------+\n"));
  1212.   LWIP_DEBUGF(TCP_DEBUG, ("|    0x%04"X16_F"     |     %5"U16_F"     | (chksum, urgp)\n",
  1213.          ntohs(tcphdr->chksum), ntohs(tcphdr->urgp)));
  1214.   LWIP_DEBUGF(TCP_DEBUG, ("+-------------------------------+\n"));
  1215. }
  1216. /**
  1217. * Print a tcp state for debugging purposes.
  1218. *
  1219. * @param s enum tcp_state to print
  1220. */
  1221. void
  1222. tcp_debug_print_state(enum tcp_state s)
  1223. {
  1224.   LWIP_DEBUGF(TCP_DEBUG, ("State: %s\n", tcp_state_str[s]));
  1225. }
  1226. /**
  1227. * Print tcp flags for debugging purposes.
  1228. *
  1229. * @param flags tcp flags, all active flags are printed
  1230. */
  1231. void
  1232. tcp_debug_print_flags(u8_t flags)
  1233. {
  1234.   if (flags & TCP_FIN) {
  1235.     LWIP_DEBUGF(TCP_DEBUG, ("FIN "));
  1236.   }
  1237.   if (flags & TCP_SYN) {
  1238.     LWIP_DEBUGF(TCP_DEBUG, ("SYN "));
  1239.   }
  1240.   if (flags & TCP_RST) {
  1241.     LWIP_DEBUGF(TCP_DEBUG, ("RST "));
  1242.   }
  1243.   if (flags & TCP_PSH) {
  1244.     LWIP_DEBUGF(TCP_DEBUG, ("PSH "));
  1245.   }
  1246.   if (flags & TCP_ACK) {
  1247.     LWIP_DEBUGF(TCP_DEBUG, ("ACK "));
  1248.   }
  1249.   if (flags & TCP_URG) {
  1250.     LWIP_DEBUGF(TCP_DEBUG, ("URG "));
  1251.   }
  1252.   if (flags & TCP_ECE) {
  1253.     LWIP_DEBUGF(TCP_DEBUG, ("ECE "));
  1254.   }
  1255.   if (flags & TCP_CWR) {
  1256.     LWIP_DEBUGF(TCP_DEBUG, ("CWR "));
  1257.   }
  1258.   LWIP_DEBUGF(TCP_DEBUG, ("\n"));
  1259. }
  1260. /**
  1261. * Print all tcp_pcbs in every list for debugging purposes.
  1262. */
  1263. void
  1264. tcp_debug_print_pcbs(void)
  1265. {
  1266.   struct tcp_pcb *pcb;
  1267.   LWIP_DEBUGF(TCP_DEBUG, ("Active PCB states:\n"));
  1268.   for(pcb = tcp_active_pcbs; pcb != NULL; pcb = pcb->next) {
  1269.     LWIP_DEBUGF(TCP_DEBUG, ("Local port %"U16_F", foreign port %"U16_F" snd_nxt %"U32_F" rcv_nxt %"U32_F" ",
  1270.                        pcb->local_port, pcb->remote_port,
  1271.                        pcb->snd_nxt, pcb->rcv_nxt));
  1272.     tcp_debug_print_state(pcb->state);
  1273.   }   
  1274.   LWIP_DEBUGF(TCP_DEBUG, ("Listen PCB states:\n"));
  1275.   for(pcb = (struct tcp_pcb *)tcp_listen_pcbs.pcbs; pcb != NULL; pcb = pcb->next) {
  1276.     LWIP_DEBUGF(TCP_DEBUG, ("Local port %"U16_F", foreign port %"U16_F" snd_nxt %"U32_F" rcv_nxt %"U32_F" ",
  1277.                        pcb->local_port, pcb->remote_port,
  1278.                        pcb->snd_nxt, pcb->rcv_nxt));
  1279.     tcp_debug_print_state(pcb->state);
  1280.   }   
  1281.   LWIP_DEBUGF(TCP_DEBUG, ("TIME-WAIT PCB states:\n"));
  1282.   for(pcb = tcp_tw_pcbs; pcb != NULL; pcb = pcb->next) {
  1283.     LWIP_DEBUGF(TCP_DEBUG, ("Local port %"U16_F", foreign port %"U16_F" snd_nxt %"U32_F" rcv_nxt %"U32_F" ",
  1284.                        pcb->local_port, pcb->remote_port,
  1285.                        pcb->snd_nxt, pcb->rcv_nxt));
  1286.     tcp_debug_print_state(pcb->state);
  1287.   }   
  1288. }
  1289. /**
  1290. * Check state consistency of the tcp_pcb lists.
  1291. */
  1292. s16_t
  1293. tcp_pcbs_sane(void)
  1294. {
  1295.   struct tcp_pcb *pcb;
  1296.   for(pcb = tcp_active_pcbs; pcb != NULL; pcb = pcb->next) {
  1297.     LWIP_ASSERT("tcp_pcbs_sane: active pcb->state != CLOSED", pcb->state != CLOSED);
  1298.     LWIP_ASSERT("tcp_pcbs_sane: active pcb->state != LISTEN", pcb->state != LISTEN);
  1299.     LWIP_ASSERT("tcp_pcbs_sane: active pcb->state != TIME-WAIT", pcb->state != TIME_WAIT);
  1300.   }
  1301.   for(pcb = tcp_tw_pcbs; pcb != NULL; pcb = pcb->next) {
  1302.     LWIP_ASSERT("tcp_pcbs_sane: tw pcb->state == TIME-WAIT", pcb->state == TIME_WAIT);
  1303.   }
  1304.   return 1;
  1305. }
  1306. #endif /* TCP_DEBUG */
  1307. #endif /* LWIP_TCP */
复制代码





connected, listening

相关帖子
回复

使用道具 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

手机版|小黑屋|51黑电子论坛 |51黑电子论坛6群 QQ 管理员QQ:125739409;技术交流QQ群281945664

Powered by 单片机教程网

快速回复 返回顶部 返回列表