lwip_tcp.c

00001 /**
00002  * @file 
00003  * Transmission Control Protocol for IP
00004  * See also @ref tcp_raw
00005  *
00006  * @defgroup tcp_raw TCP
00007  * @ingroup callbackstyle_api
00008  * Transmission Control Protocol for IP\n
00009  * @see @ref raw_api and @ref netconn
00010  *
00011  * Common functions for the TCP implementation, such as functinos
00012  * for manipulating the data structures and the TCP timer functions. TCP functions
00013  * related to input and output is found in tcp_in.c and tcp_out.c respectively.\n
00014  */
00015 
00016 /*
00017  * Copyright (c) 2001-2004 Swedish Institute of Computer Science.
00018  * All rights reserved.
00019  *
00020  * Redistribution and use in source and binary forms, with or without modification,
00021  * are permitted provided that the following conditions are met:
00022  *
00023  * 1. Redistributions of source code must retain the above copyright notice,
00024  *    this list of conditions and the following disclaimer.
00025  * 2. Redistributions in binary form must reproduce the above copyright notice,
00026  *    this list of conditions and the following disclaimer in the documentation
00027  *    and/or other materials provided with the distribution.
00028  * 3. The name of the author may not be used to endorse or promote products
00029  *    derived from this software without specific prior written permission.
00030  *
00031  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
00032  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
00033  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
00034  * SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
00035  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
00036  * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
00037  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
00038  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
00039  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
00040  * OF SUCH DAMAGE.
00041  *
00042  * This file is part of the lwIP TCP/IP stack.
00043  *
00044  * Author: Adam Dunkels <adam@sics.se>
00045  *
00046  */
00047 
00048 #include "lwip/opt.h"
00049 
00050 #if LWIP_TCP /* don't build if not configured for use in lwipopts.h */
00051 
00052 #include "lwip/def.h"
00053 #include "lwip/mem.h"
00054 #include "lwip/memp.h"
00055 #include "lwip/tcp.h"
00056 #include "lwip/priv/tcp_priv.h"
00057 #include "lwip/debug.h"
00058 #include "lwip/stats.h"
00059 #include "lwip/ip6.h"
00060 #include "lwip/ip6_addr.h"
00061 #include "lwip/nd6.h"
00062 
00063 #include <string.h>
00064 
00065 #ifdef LWIP_HOOK_FILENAME
00066 #include LWIP_HOOK_FILENAME
00067 #endif
00068 
00069 #ifndef TCP_LOCAL_PORT_RANGE_START
00070 /* From http://www.iana.org/assignments/port-numbers:
00071    "The Dynamic and/or Private Ports are those from 49152 through 65535" */
00072 #define TCP_LOCAL_PORT_RANGE_START        0xc000
00073 #define TCP_LOCAL_PORT_RANGE_END          0xffff
00074 #define TCP_ENSURE_LOCAL_PORT_RANGE(port) ((u16_t)(((port) & ~TCP_LOCAL_PORT_RANGE_START) + TCP_LOCAL_PORT_RANGE_START))
00075 #endif
00076 
00077 #if LWIP_TCP_KEEPALIVE
00078 #define TCP_KEEP_DUR(pcb)   ((pcb)->keep_cnt * (pcb)->keep_intvl)
00079 #define TCP_KEEP_INTVL(pcb) ((pcb)->keep_intvl)
00080 #else /* LWIP_TCP_KEEPALIVE */
00081 #define TCP_KEEP_DUR(pcb)   TCP_MAXIDLE
00082 #define TCP_KEEP_INTVL(pcb) TCP_KEEPINTVL_DEFAULT
00083 #endif /* LWIP_TCP_KEEPALIVE */
00084 
00085 /* As initial send MSS, we use TCP_MSS but limit it to 536. */
00086 #if TCP_MSS > 536
00087 #define INITIAL_MSS 536
00088 #else
00089 #define INITIAL_MSS TCP_MSS
00090 #endif
00091 
00092 static const char * const tcp_state_str[] = {
00093   "CLOSED",
00094   "LISTEN",
00095   "SYN_SENT",
00096   "SYN_RCVD",
00097   "ESTABLISHED",
00098   "FIN_WAIT_1",
00099   "FIN_WAIT_2",
00100   "CLOSE_WAIT",
00101   "CLOSING",
00102   "LAST_ACK",
00103   "TIME_WAIT"
00104 };
00105 
00106 /* last local TCP port */
00107 static u16_t tcp_port = TCP_LOCAL_PORT_RANGE_START;
00108 
00109 /* Incremented every coarse grained timer shot (typically every 500 ms). */
00110 u32_t tcp_ticks;
00111 static const u8_t tcp_backoff[13] =
00112     { 1, 2, 3, 4, 5, 6, 7, 7, 7, 7, 7, 7, 7};
00113  /* Times per slowtmr hits */
00114 static const u8_t tcp_persist_backoff[7] = { 3, 6, 12, 24, 48, 96, 120 };
00115 
00116 /* The TCP PCB lists. */
00117 
00118 /** List of all TCP PCBs bound but not yet (connected || listening) */
00119 struct tcp_pcb *tcp_bound_pcbs;
00120 /** List of all TCP PCBs in LISTEN state */
00121 union tcp_listen_pcbs_t tcp_listen_pcbs;
00122 /** List of all TCP PCBs that are in a state in which
00123  * they accept or send data. */
00124 struct tcp_pcb *tcp_active_pcbs;
00125 /** List of all TCP PCBs in TIME-WAIT state */
00126 struct tcp_pcb *tcp_tw_pcbs;
00127 
00128 /** An array with all (non-temporary) PCB lists, mainly used for smaller code size */
00129 struct tcp_pcb ** const tcp_pcb_lists[] = {&tcp_listen_pcbs.pcbs, &tcp_bound_pcbs,
00130   &tcp_active_pcbs, &tcp_tw_pcbs};
00131 
00132 u8_t tcp_active_pcbs_changed;
00133 
00134 /** Timer counter to handle calling slow-timer from tcp_tmr() */
00135 static u8_t tcp_timer;
00136 static u8_t tcp_timer_ctr;
00137 static u16_t tcp_new_port(void);
00138 
00139 static err_t tcp_close_shutdown_fin(struct tcp_pcb *pcb);
00140 
00141 /**
00142  * Initialize this module.
00143  */
00144 void
00145 tcp_init(void)
00146 {
00147 #if LWIP_RANDOMIZE_INITIAL_LOCAL_PORTS && defined(LWIP_RAND)
00148   tcp_port = TCP_ENSURE_LOCAL_PORT_RANGE(LWIP_RAND());
00149 #endif /* LWIP_RANDOMIZE_INITIAL_LOCAL_PORTS && defined(LWIP_RAND) */
00150 }
00151 
00152 /**
00153  * Called periodically to dispatch TCP timers.
00154  */
00155 void
00156 tcp_tmr(void)
00157 {
00158   /* Call tcp_fasttmr() every 250 ms */
00159   tcp_fasttmr();
00160 
00161   if (++tcp_timer & 1) {
00162     /* Call tcp_slowtmr() every 500 ms, i.e., every other timer
00163        tcp_tmr() is called. */
00164     tcp_slowtmr();
00165   }
00166 }
00167 
00168 #if LWIP_CALLBACK_API || TCP_LISTEN_BACKLOG
00169 /** Called when a listen pcb is closed. Iterates one pcb list and removes the
00170  * closed listener pcb from pcb->listener if matching.
00171  */
00172 static void
00173 tcp_remove_listener(struct tcp_pcb *list, struct tcp_pcb_listen *lpcb)
00174 {
00175    struct tcp_pcb *pcb;
00176    for (pcb = list; pcb != NULL; pcb = pcb->next) {
00177       if (pcb->listener == lpcb) {
00178          pcb->listener = NULL;
00179       }
00180    }
00181 }
00182 #endif
00183 
00184 /** Called when a listen pcb is closed. Iterates all pcb lists and removes the
00185  * closed listener pcb from pcb->listener if matching.
00186  */
00187 static void
00188 tcp_listen_closed(struct tcp_pcb *pcb)
00189 {
00190 #if LWIP_CALLBACK_API || TCP_LISTEN_BACKLOG
00191   size_t i;
00192   LWIP_ASSERT("pcb != NULL", pcb != NULL);
00193   LWIP_ASSERT("pcb->state == LISTEN", pcb->state == LISTEN);
00194   for (i = 1; i < LWIP_ARRAYSIZE(tcp_pcb_lists); i++) {
00195     tcp_remove_listener(*tcp_pcb_lists[i], (struct tcp_pcb_listen*)pcb);
00196   }
00197 #endif
00198   LWIP_UNUSED_ARG(pcb);
00199 }
00200 
00201 #if TCP_LISTEN_BACKLOG
00202 /** @ingroup tcp_raw
00203  * Delay accepting a connection in respect to the listen backlog:
00204  * the number of outstanding connections is increased until
00205  * tcp_backlog_accepted() is called.
00206  *
00207  * ATTENTION: the caller is responsible for calling tcp_backlog_accepted()
00208  * or else the backlog feature will get out of sync!
00209  *
00210  * @param pcb the connection pcb which is not fully accepted yet
00211  */
00212 void
00213 tcp_backlog_delayed(struct tcp_pcb* pcb)
00214 {
00215   LWIP_ASSERT("pcb != NULL", pcb != NULL);
00216   if ((pcb->flags & TF_BACKLOGPEND) == 0) {
00217     if (pcb->listener != NULL) {
00218       pcb->listener->accepts_pending++;
00219       LWIP_ASSERT("accepts_pending != 0", pcb->listener->accepts_pending != 0);
00220       pcb->flags |= TF_BACKLOGPEND;
00221     }
00222   }
00223 }
00224 
00225 /** @ingroup tcp_raw
00226  * A delayed-accept a connection is accepted (or closed/aborted): decreases
00227  * the number of outstanding connections after calling tcp_backlog_delayed().
00228  *
00229  * ATTENTION: the caller is responsible for calling tcp_backlog_accepted()
00230  * or else the backlog feature will get out of sync!
00231  *
00232  * @param pcb the connection pcb which is now fully accepted (or closed/aborted)
00233  */
00234 void
00235 tcp_backlog_accepted(struct tcp_pcb* pcb)
00236 {
00237   LWIP_ASSERT("pcb != NULL", pcb != NULL);
00238   if ((pcb->flags & TF_BACKLOGPEND) != 0) {
00239     if (pcb->listener != NULL) {
00240       LWIP_ASSERT("accepts_pending != 0", pcb->listener->accepts_pending != 0);
00241       pcb->listener->accepts_pending--;
00242       pcb->flags &= ~TF_BACKLOGPEND;
00243     }
00244   }
00245 }
00246 #endif /* TCP_LISTEN_BACKLOG */
00247 
00248 /**
00249  * Closes the TX side of a connection held by the PCB.
00250  * For tcp_close(), a RST is sent if the application didn't receive all data
00251  * (tcp_recved() not called for all data passed to recv callback).
00252  *
00253  * Listening pcbs are freed and may not be referenced any more.
00254  * Connection pcbs are freed if not yet connected and may not be referenced
00255  * any more. If a connection is established (at least SYN received or in
00256  * a closing state), the connection is closed, and put in a closing state.
00257  * The pcb is then automatically freed in tcp_slowtmr(). It is therefore
00258  * unsafe to reference it.
00259  *
00260  * @param pcb the tcp_pcb to close
00261  * @return ERR_OK if connection has been closed
00262  *         another err_t if closing failed and pcb is not freed
00263  */
00264 static err_t
00265 tcp_close_shutdown(struct tcp_pcb *pcb, u8_t rst_on_unacked_data)
00266 {
00267   if (rst_on_unacked_data && ((pcb->state == ESTABLISHED) || (pcb->state == CLOSE_WAIT))) {
00268     if ((pcb->refused_data != NULL) || (pcb->rcv_wnd != TCP_WND_MAX(pcb))) {
00269       /* Not all data received by application, send RST to tell the remote
00270          side about this. */
00271       LWIP_ASSERT("pcb->flags & TF_RXCLOSED", pcb->flags & TF_RXCLOSED);
00272 
00273       /* don't call tcp_abort here: we must not deallocate the pcb since
00274          that might not be expected when calling tcp_close */
00275       tcp_rst(pcb->snd_nxt, pcb->rcv_nxt, &pcb->local_ip, &pcb->remote_ip,
00276                pcb->local_port, pcb->remote_port);
00277 
00278       tcp_pcb_purge(pcb);
00279       TCP_RMV_ACTIVE(pcb);
00280       if (pcb->state == ESTABLISHED) {
00281         /* move to TIME_WAIT since we close actively */
00282         pcb->state = TIME_WAIT;
00283         TCP_REG(&tcp_tw_pcbs, pcb);
00284       } else {
00285         /* CLOSE_WAIT: deallocate the pcb since we already sent a RST for it */
00286         if (tcp_input_pcb == pcb) {
00287           /* prevent using a deallocated pcb: free it from tcp_input later */
00288           tcp_trigger_input_pcb_close();
00289         } else {
00290           memp_free(MEMP_TCP_PCB, pcb);
00291         }
00292       }
00293       return ERR_OK;
00294     }
00295   }
00296 
00297   /* - states which free the pcb are handled here,
00298      - states which send FIN and change state are handled in tcp_close_shutdown_fin() */
00299   switch (pcb->state) {
00300   case CLOSED:
00301     /* Closing a pcb in the CLOSED state might seem erroneous,
00302      * however, it is in this state once allocated and as yet unused
00303      * and the user needs some way to free it should the need arise.
00304      * Calling tcp_close() with a pcb that has already been closed, (i.e. twice)
00305      * or for a pcb that has been used and then entered the CLOSED state
00306      * is erroneous, but this should never happen as the pcb has in those cases
00307      * been freed, and so any remaining handles are bogus. */
00308     if (pcb->local_port != 0) {
00309       TCP_RMV(&tcp_bound_pcbs, pcb);
00310     }
00311     memp_free(MEMP_TCP_PCB, pcb);
00312     break;
00313   case LISTEN:
00314     tcp_listen_closed(pcb);
00315     tcp_pcb_remove(&tcp_listen_pcbs.pcbs, pcb);
00316     memp_free(MEMP_TCP_PCB_LISTEN, pcb);
00317     break;
00318   case SYN_SENT:
00319     TCP_PCB_REMOVE_ACTIVE(pcb);
00320     memp_free(MEMP_TCP_PCB, pcb);
00321     MIB2_STATS_INC(mib2.tcpattemptfails);
00322     break;
00323   default:
00324     return tcp_close_shutdown_fin(pcb);
00325   }
00326   return ERR_OK;
00327 }
00328 
00329 static err_t
00330 tcp_close_shutdown_fin(struct tcp_pcb *pcb)
00331 {
00332   err_t err;
00333   LWIP_ASSERT("pcb != NULL", pcb != NULL);
00334 
00335   switch (pcb->state) {
00336   case SYN_RCVD:
00337     err = tcp_send_fin(pcb);
00338     if (err == ERR_OK) {
00339       tcp_backlog_accepted(pcb);
00340       MIB2_STATS_INC(mib2.tcpattemptfails);
00341       pcb->state = FIN_WAIT_1;
00342     }
00343     break;
00344   case ESTABLISHED:
00345     err = tcp_send_fin(pcb);
00346     if (err == ERR_OK) {
00347       MIB2_STATS_INC(mib2.tcpestabresets);
00348       pcb->state = FIN_WAIT_1;
00349     }
00350     break;
00351   case CLOSE_WAIT:
00352     err = tcp_send_fin(pcb);
00353     if (err == ERR_OK) {
00354       MIB2_STATS_INC(mib2.tcpestabresets);
00355       pcb->state = LAST_ACK;
00356     }
00357     break;
00358   default:
00359     /* Has already been closed, do nothing. */
00360     return ERR_OK;
00361   }
00362 
00363   if (err == ERR_OK) {
00364     /* To ensure all data has been sent when tcp_close returns, we have
00365        to make sure tcp_output doesn't fail.
00366        Since we don't really have to ensure all data has been sent when tcp_close
00367        returns (unsent data is sent from tcp timer functions, also), we don't care
00368        for the return value of tcp_output for now. */
00369     tcp_output(pcb);
00370   } else if (err == ERR_MEM) {
00371     /* Mark this pcb for closing. Closing is retried from tcp_tmr. */
00372     pcb->flags |= TF_CLOSEPEND;
00373   }
00374   return err;
00375 }
00376 
00377 /**
00378  * @ingroup tcp_raw
00379  * Closes the connection held by the PCB.
00380  *
00381  * Listening pcbs are freed and may not be referenced any more.
00382  * Connection pcbs are freed if not yet connected and may not be referenced
00383  * any more. If a connection is established (at least SYN received or in
00384  * a closing state), the connection is closed, and put in a closing state.
00385  * The pcb is then automatically freed in tcp_slowtmr(). It is therefore
00386  * unsafe to reference it (unless an error is returned).
00387  *
00388  * @param pcb the tcp_pcb to close
00389  * @return ERR_OK if connection has been closed
00390  *         another err_t if closing failed and pcb is not freed
00391  */
00392 err_t
00393 tcp_close(struct tcp_pcb *pcb)
00394 {
00395   LWIP_DEBUGF(TCP_DEBUG, ("tcp_close: closing in "));
00396   tcp_debug_print_state(pcb->state);
00397 
00398   if (pcb->state != LISTEN) {
00399     /* Set a flag not to receive any more data... */
00400     pcb->flags |= TF_RXCLOSED;
00401   }
00402   /* ... and close */
00403   return tcp_close_shutdown(pcb, 1);
00404 }
00405 
00406 /**
00407  * @ingroup tcp_raw
00408  * Causes all or part of a full-duplex connection of this PCB to be shut down.
00409  * This doesn't deallocate the PCB unless shutting down both sides!
00410  * Shutting down both sides is the same as calling tcp_close, so if it succeds,
00411  * the PCB should not be referenced any more.
00412  *
00413  * @param pcb PCB to shutdown
00414  * @param shut_rx shut down receive side if this is != 0
00415  * @param shut_tx shut down send side if this is != 0
00416  * @return ERR_OK if shutdown succeeded (or the PCB has already been shut down)
00417  *         another err_t on error.
00418  */
00419 err_t
00420 tcp_shutdown(struct tcp_pcb *pcb, int shut_rx, int shut_tx)
00421 {
00422   if (pcb->state == LISTEN) {
00423     return ERR_CONN;
00424   }
00425   if (shut_rx) {
00426     /* shut down the receive side: set a flag not to receive any more data... */
00427     pcb->flags |= TF_RXCLOSED;
00428     if (shut_tx) {
00429       /* shutting down the tx AND rx side is the same as closing for the raw API */
00430       return tcp_close_shutdown(pcb, 1);
00431     }
00432     /* ... and free buffered data */
00433     if (pcb->refused_data != NULL) {
00434       pbuf_free(pcb->refused_data);
00435       pcb->refused_data = NULL;
00436     }
00437   }
00438   if (shut_tx) {
00439     /* This can't happen twice since if it succeeds, the pcb's state is changed.
00440        Only close in these states as the others directly deallocate the PCB */
00441     switch (pcb->state) {
00442     case SYN_RCVD:
00443     case ESTABLISHED:
00444     case CLOSE_WAIT:
00445       return tcp_close_shutdown(pcb, (u8_t)shut_rx);
00446     default:
00447       /* Not (yet?) connected, cannot shutdown the TX side as that would bring us
00448         into CLOSED state, where the PCB is deallocated. */
00449       return ERR_CONN;
00450     }
00451   }
00452   return ERR_OK;
00453 }
00454 
00455 /**
00456  * Abandons a connection and optionally sends a RST to the remote
00457  * host.  Deletes the local protocol control block. This is done when
00458  * a connection is killed because of shortage of memory.
00459  *
00460  * @param pcb the tcp_pcb to abort
00461  * @param reset boolean to indicate whether a reset should be sent
00462  */
00463 void
00464 tcp_abandon(struct tcp_pcb *pcb, int reset)
00465 {
00466   u32_t seqno, ackno;
00467 #if LWIP_CALLBACK_API
00468   tcp_err_fn errf;
00469 #endif /* LWIP_CALLBACK_API */
00470   void *errf_arg;
00471 
00472   /* pcb->state LISTEN not allowed here */
00473   LWIP_ASSERT("don't call tcp_abort/tcp_abandon for listen-pcbs",
00474     pcb->state != LISTEN);
00475   /* Figure out on which TCP PCB list we are, and remove us. If we
00476      are in an active state, call the receive function associated with
00477      the PCB with a NULL argument, and send an RST to the remote end. */
00478   if (pcb->state == TIME_WAIT) {
00479     tcp_pcb_remove(&tcp_tw_pcbs, pcb);
00480     memp_free(MEMP_TCP_PCB, pcb);
00481   } else {
00482     int send_rst = 0;
00483     u16_t local_port = 0;
00484     enum tcp_state last_state;
00485     seqno = pcb->snd_nxt;
00486     ackno = pcb->rcv_nxt;
00487 #if LWIP_CALLBACK_API
00488     errf = pcb->errf;
00489 #endif /* LWIP_CALLBACK_API */
00490     errf_arg = pcb->callback_arg;
00491     if (pcb->state == CLOSED) {
00492       if (pcb->local_port != 0) {
00493         /* bound, not yet opened */
00494         TCP_RMV(&tcp_bound_pcbs, pcb);
00495       }
00496     } else {
00497       send_rst = reset;
00498       local_port = pcb->local_port;
00499       TCP_PCB_REMOVE_ACTIVE(pcb);
00500     }
00501     if (pcb->unacked != NULL) {
00502       tcp_segs_free(pcb->unacked);
00503     }
00504     if (pcb->unsent != NULL) {
00505       tcp_segs_free(pcb->unsent);
00506     }
00507 #if TCP_QUEUE_OOSEQ
00508     if (pcb->ooseq != NULL) {
00509       tcp_segs_free(pcb->ooseq);
00510     }
00511 #endif /* TCP_QUEUE_OOSEQ */
00512     tcp_backlog_accepted(pcb);
00513     if (send_rst) {
00514       LWIP_DEBUGF(TCP_RST_DEBUG, ("tcp_abandon: sending RST\n"));
00515       tcp_rst(seqno, ackno, &pcb->local_ip, &pcb->remote_ip, local_port, pcb->remote_port);
00516     }
00517     last_state = pcb->state;
00518     memp_free(MEMP_TCP_PCB, pcb);
00519     TCP_EVENT_ERR(last_state, errf, errf_arg, ERR_ABRT);
00520   }
00521 }
00522 
00523 /**
00524  * @ingroup tcp_raw
00525  * Aborts the connection by sending a RST (reset) segment to the remote
00526  * host. The pcb is deallocated. This function never fails.
00527  *
00528  * ATTENTION: When calling this from one of the TCP callbacks, make
00529  * sure you always return ERR_ABRT (and never return ERR_ABRT otherwise
00530  * or you will risk accessing deallocated memory or memory leaks!
00531  *
00532  * @param pcb the tcp pcb to abort
00533  */
00534 void
00535 tcp_abort(struct tcp_pcb *pcb)
00536 {
00537   tcp_abandon(pcb, 1);
00538 }
00539 
00540 /**
00541  * @ingroup tcp_raw
00542  * Binds the connection to a local port number and IP address. If the
00543  * IP address is not given (i.e., ipaddr == NULL), the IP address of
00544  * the outgoing network interface is used instead.
00545  *
00546  * @param pcb the tcp_pcb to bind (no check is done whether this pcb is
00547  *        already bound!)
00548  * @param ipaddr the local ip address to bind to (use IP4_ADDR_ANY to bind
00549  *        to any local address
00550  * @param port the local port to bind to
00551  * @return ERR_USE if the port is already in use
00552  *         ERR_VAL if bind failed because the PCB is not in a valid state
00553  *         ERR_OK if bound
00554  */
00555 err_t
00556 tcp_bind(struct tcp_pcb *pcb, const ip_addr_t *ipaddr, u16_t port)
00557 {
00558   int i;
00559   int max_pcb_list = NUM_TCP_PCB_LISTS;
00560   struct tcp_pcb *cpcb;
00561 
00562 #if LWIP_IPV4
00563   /* Don't propagate NULL pointer (IPv4 ANY) to subsequent functions */
00564   if (ipaddr == NULL) {
00565     ipaddr = IP4_ADDR_ANY;
00566   }
00567 #endif /* LWIP_IPV4 */
00568 
00569   /* still need to check for ipaddr == NULL in IPv6 only case */
00570   if ((pcb == NULL) || (ipaddr == NULL)) {
00571     return ERR_VAL;
00572   }
00573 
00574   LWIP_ERROR("tcp_bind: can only bind in state CLOSED", pcb->state == CLOSED, return ERR_VAL);
00575 
00576 #if SO_REUSE
00577   /* Unless the REUSEADDR flag is set,
00578      we have to check the pcbs in TIME-WAIT state, also.
00579      We do not dump TIME_WAIT pcb's; they can still be matched by incoming
00580      packets using both local and remote IP addresses and ports to distinguish.
00581    */
00582   if (ip_get_option(pcb, SOF_REUSEADDR)) {
00583     max_pcb_list = NUM_TCP_PCB_LISTS_NO_TIME_WAIT;
00584   }
00585 #endif /* SO_REUSE */
00586 
00587   if (port == 0) {
00588     port = tcp_new_port();
00589     if (port == 0) {
00590       return ERR_BUF;
00591     }
00592   } else {
00593     /* Check if the address already is in use (on all lists) */
00594     for (i = 0; i < max_pcb_list; i++) {
00595       for (cpcb = *tcp_pcb_lists[i]; cpcb != NULL; cpcb = cpcb->next) {
00596         if (cpcb->local_port == port) {
00597 #if SO_REUSE
00598           /* Omit checking for the same port if both pcbs have REUSEADDR set.
00599              For SO_REUSEADDR, the duplicate-check for a 5-tuple is done in
00600              tcp_connect. */
00601           if (!ip_get_option(pcb, SOF_REUSEADDR) ||
00602               !ip_get_option(cpcb, SOF_REUSEADDR))
00603 #endif /* SO_REUSE */
00604           {
00605             /* @todo: check accept_any_ip_version */
00606             if ((IP_IS_V6(ipaddr) == IP_IS_V6_VAL(cpcb->local_ip)) &&
00607                 (ip_addr_isany(&cpcb->local_ip) ||
00608                 ip_addr_isany(ipaddr) ||
00609                 ip_addr_cmp(&cpcb->local_ip, ipaddr))) {
00610               return ERR_USE;
00611             }
00612           }
00613         }
00614       }
00615     }
00616   }
00617 
00618   if (!ip_addr_isany(ipaddr)) {
00619     ip_addr_set(&pcb->local_ip, ipaddr);
00620   }
00621   pcb->local_port = port;
00622   TCP_REG(&tcp_bound_pcbs, pcb);
00623   LWIP_DEBUGF(TCP_DEBUG, ("tcp_bind: bind to port %"U16_F"\n", port));
00624   return ERR_OK;
00625 }
00626 #if LWIP_CALLBACK_API
00627 /**
00628  * Default accept callback if no accept callback is specified by the user.
00629  */
00630 static err_t
00631 tcp_accept_null(void *arg, struct tcp_pcb *pcb, err_t err)
00632 {
00633   LWIP_UNUSED_ARG(arg);
00634   LWIP_UNUSED_ARG(err);
00635 
00636   tcp_abort(pcb);
00637 
00638   return ERR_ABRT;
00639 }
00640 #endif /* LWIP_CALLBACK_API */
00641 
00642 /**
00643  * @ingroup tcp_raw
00644  * Set the state of the connection to be LISTEN, which means that it
00645  * is able to accept incoming connections. The protocol control block
00646  * is reallocated in order to consume less memory. Setting the
00647  * connection to LISTEN is an irreversible process.
00648  *
00649  * @param pcb the original tcp_pcb
00650  * @param backlog the incoming connections queue limit
00651  * @return tcp_pcb used for listening, consumes less memory.
00652  *
00653  * @note The original tcp_pcb is freed. This function therefore has to be
00654  *       called like this:
00655  *             tpcb = tcp_listen_with_backlog(tpcb, backlog);
00656  */
00657 struct tcp_pcb *
00658 tcp_listen_with_backlog(struct tcp_pcb *pcb, u8_t backlog)
00659 {
00660   return tcp_listen_with_backlog_and_err(pcb, backlog, NULL);
00661 }
00662 
00663 /**
00664  * @ingroup tcp_raw
00665  * Set the state of the connection to be LISTEN, which means that it
00666  * is able to accept incoming connections. The protocol control block
00667  * is reallocated in order to consume less memory. Setting the
00668  * connection to LISTEN is an irreversible process.
00669  *
00670  * @param pcb the original tcp_pcb
00671  * @param backlog the incoming connections queue limit
00672  * @param err when NULL is returned, this contains the error reason
00673  * @return tcp_pcb used for listening, consumes less memory.
00674  *
00675  * @note The original tcp_pcb is freed. This function therefore has to be
00676  *       called like this:
00677  *             tpcb = tcp_listen_with_backlog_and_err(tpcb, backlog, &err);
00678  */
00679 struct tcp_pcb *
00680 tcp_listen_with_backlog_and_err(struct tcp_pcb *pcb, u8_t backlog, err_t *err)
00681 {
00682   struct tcp_pcb_listen *lpcb = NULL;
00683   err_t res;
00684 
00685   LWIP_UNUSED_ARG(backlog);
00686   LWIP_ERROR("tcp_listen: pcb already connected", pcb->state == CLOSED, res = ERR_CLSD; goto done);
00687 
00688   /* already listening? */
00689   if (pcb->state == LISTEN) {
00690     lpcb = (struct tcp_pcb_listen*)pcb;
00691     res = ERR_ALREADY;
00692     goto done;
00693   }
00694 #if SO_REUSE
00695   if (ip_get_option(pcb, SOF_REUSEADDR)) {
00696     /* Since SOF_REUSEADDR allows reusing a local address before the pcb's usage
00697        is declared (listen-/connection-pcb), we have to make sure now that
00698        this port is only used once for every local IP. */
00699     for (lpcb = tcp_listen_pcbs.listen_pcbs; lpcb != NULL; lpcb = lpcb->next) {
00700       if ((lpcb->local_port == pcb->local_port) &&
00701           ip_addr_cmp(&lpcb->local_ip, &pcb->local_ip)) {
00702         /* this address/port is already used */
00703         lpcb = NULL;
00704         res = ERR_USE;
00705         goto done;
00706       }
00707     }
00708   }
00709 #endif /* SO_REUSE */
00710   lpcb = (struct tcp_pcb_listen *)memp_malloc(MEMP_TCP_PCB_LISTEN);
00711   if (lpcb == NULL) {
00712     res = ERR_MEM;
00713     goto done;
00714   }
00715   lpcb->callback_arg = pcb->callback_arg;
00716   lpcb->local_port = pcb->local_port;
00717   lpcb->state = LISTEN;
00718   lpcb->prio = pcb->prio;
00719   lpcb->so_options = pcb->so_options;
00720   lpcb->ttl = pcb->ttl;
00721   lpcb->tos = pcb->tos;
00722 #if LWIP_IPV4 && LWIP_IPV6
00723   IP_SET_TYPE_VAL(lpcb->remote_ip, pcb->local_ip.type);
00724 #endif /* LWIP_IPV4 && LWIP_IPV6 */
00725   ip_addr_copy(lpcb->local_ip, pcb->local_ip);
00726   if (pcb->local_port != 0) {
00727     TCP_RMV(&tcp_bound_pcbs, pcb);
00728   }
00729   memp_free(MEMP_TCP_PCB, pcb);
00730 #if LWIP_CALLBACK_API
00731   lpcb->accept = tcp_accept_null;
00732 #endif /* LWIP_CALLBACK_API */
00733 #if TCP_LISTEN_BACKLOG
00734   lpcb->accepts_pending = 0;
00735   tcp_backlog_set(lpcb, backlog);
00736 #endif /* TCP_LISTEN_BACKLOG */
00737   TCP_REG(&tcp_listen_pcbs.pcbs, (struct tcp_pcb *)lpcb);
00738   res = ERR_OK;
00739 done:
00740   if (err != NULL) {
00741     *err = res;
00742   }
00743   return (struct tcp_pcb *)lpcb;
00744 }
00745 
00746 /**
00747  * Update the state that tracks the available window space to advertise.
00748  *
00749  * Returns how much extra window would be advertised if we sent an
00750  * update now.
00751  */
00752 u32_t
00753 tcp_update_rcv_ann_wnd(struct tcp_pcb *pcb)
00754 {
00755   u32_t new_right_edge = pcb->rcv_nxt + pcb->rcv_wnd;
00756 
00757   if (TCP_SEQ_GEQ(new_right_edge, pcb->rcv_ann_right_edge + LWIP_MIN((TCP_WND / 2), pcb->mss))) {
00758     /* we can advertise more window */
00759     pcb->rcv_ann_wnd = pcb->rcv_wnd;
00760     return new_right_edge - pcb->rcv_ann_right_edge;
00761   } else {
00762     if (TCP_SEQ_GT(pcb->rcv_nxt, pcb->rcv_ann_right_edge)) {
00763       /* Can happen due to other end sending out of advertised window,
00764        * but within actual available (but not yet advertised) window */
00765       pcb->rcv_ann_wnd = 0;
00766     } else {
00767       /* keep the right edge of window constant */
00768       u32_t new_rcv_ann_wnd = pcb->rcv_ann_right_edge - pcb->rcv_nxt;
00769 #if !LWIP_WND_SCALE
00770       LWIP_ASSERT("new_rcv_ann_wnd <= 0xffff", new_rcv_ann_wnd <= 0xffff);
00771 #endif
00772       pcb->rcv_ann_wnd = (tcpwnd_size_t)new_rcv_ann_wnd;
00773     }
00774     return 0;
00775   }
00776 }
00777 
00778 /**
00779  * @ingroup tcp_raw
00780  * This function should be called by the application when it has
00781  * processed the data. The purpose is to advertise a larger window
00782  * when the data has been processed.
00783  *
00784  * @param pcb the tcp_pcb for which data is read
00785  * @param len the amount of bytes that have been read by the application
00786  */
00787 void
00788 tcp_recved(struct tcp_pcb *pcb, u16_t len)
00789 {
00790   int wnd_inflation;
00791 
00792   /* pcb->state LISTEN not allowed here */
00793   LWIP_ASSERT("don't call tcp_recved for listen-pcbs",
00794     pcb->state != LISTEN);
00795 
00796   pcb->rcv_wnd += len;
00797   if (pcb->rcv_wnd > TCP_WND_MAX(pcb)) {
00798     pcb->rcv_wnd = TCP_WND_MAX(pcb);
00799   } else if (pcb->rcv_wnd == 0) {
00800     /* rcv_wnd overflowed */
00801     if ((pcb->state == CLOSE_WAIT) || (pcb->state == LAST_ACK)) {
00802       /* In passive close, we allow this, since the FIN bit is added to rcv_wnd
00803          by the stack itself, since it is not mandatory for an application
00804          to call tcp_recved() for the FIN bit, but e.g. the netconn API does so. */
00805       pcb->rcv_wnd = TCP_WND_MAX(pcb);
00806     } else {
00807       LWIP_ASSERT("tcp_recved: len wrapped rcv_wnd\n", 0);
00808     }
00809   }
00810 
00811   wnd_inflation = tcp_update_rcv_ann_wnd(pcb);
00812 
00813   /* If the change in the right edge of window is significant (default
00814    * watermark is TCP_WND/4), then send an explicit update now.
00815    * Otherwise wait for a packet to be sent in the normal course of
00816    * events (or more window to be available later) */
00817   if (wnd_inflation >= TCP_WND_UPDATE_THRESHOLD) {
00818     tcp_ack_now(pcb);
00819     tcp_output(pcb);
00820   }
00821 
00822   LWIP_DEBUGF(TCP_DEBUG, ("tcp_recved: received %"U16_F" bytes, wnd %"TCPWNDSIZE_F" (%"TCPWNDSIZE_F").\n",
00823          len, pcb->rcv_wnd, (u16_t)(TCP_WND_MAX(pcb) - pcb->rcv_wnd)));
00824 }
00825 
00826 /**
00827  * Allocate a new local TCP port.
00828  *
00829  * @return a new (free) local TCP port number
00830  */
00831 static u16_t
00832 tcp_new_port(void)
00833 {
00834   u8_t i;
00835   u16_t n = 0;
00836   struct tcp_pcb *pcb;
00837 
00838 again:
00839   if (tcp_port++ == TCP_LOCAL_PORT_RANGE_END) {
00840     tcp_port = TCP_LOCAL_PORT_RANGE_START;
00841   }
00842   /* Check all PCB lists. */
00843   for (i = 0; i < NUM_TCP_PCB_LISTS; i++) {
00844     for (pcb = *tcp_pcb_lists[i]; pcb != NULL; pcb = pcb->next) {
00845       if (pcb->local_port == tcp_port) {
00846         if (++n > (TCP_LOCAL_PORT_RANGE_END - TCP_LOCAL_PORT_RANGE_START)) {
00847           return 0;
00848         }
00849         goto again;
00850       }
00851     }
00852   }
00853   return tcp_port;
00854 }
00855 
00856 /**
00857  * @ingroup tcp_raw
00858  * Connects to another host. The function given as the "connected"
00859  * argument will be called when the connection has been established.
00860  *
00861  * @param pcb the tcp_pcb used to establish the connection
00862  * @param ipaddr the remote ip address to connect to
00863  * @param port the remote tcp port to connect to
00864  * @param connected callback function to call when connected (on error,
00865                     the err calback will be called)
00866  * @return ERR_VAL if invalid arguments are given
00867  *         ERR_OK if connect request has been sent
00868  *         other err_t values if connect request couldn't be sent
00869  */
00870 err_t
00871 tcp_connect(struct tcp_pcb *pcb, const ip_addr_t *ipaddr, u16_t port,
00872       tcp_connected_fn connected)
00873 {
00874   err_t ret;
00875   u32_t iss;
00876   u16_t old_local_port;
00877 
00878   if ((pcb == NULL) || (ipaddr == NULL)) {
00879     return ERR_VAL;
00880   }
00881 
00882   LWIP_ERROR("tcp_connect: can only connect from state CLOSED", pcb->state == CLOSED, return ERR_ISCONN);
00883 
00884   LWIP_DEBUGF(TCP_DEBUG, ("tcp_connect to port %"U16_F"\n", port));
00885   ip_addr_set(&pcb->remote_ip, ipaddr);
00886   pcb->remote_port = port;
00887 
00888   /* check if we have a route to the remote host */
00889   if (ip_addr_isany(&pcb->local_ip)) {
00890     /* no local IP address set, yet. */
00891     struct netif *netif;
00892     const ip_addr_t *local_ip;
00893     ip_route_get_local_ip(&pcb->local_ip, &pcb->remote_ip, netif, local_ip);
00894     if ((netif == NULL) || (local_ip == NULL)) {
00895       /* Don't even try to send a SYN packet if we have no route
00896          since that will fail. */
00897       return ERR_RTE;
00898     }
00899     /* Use the address as local address of the pcb. */
00900     ip_addr_copy(pcb->local_ip, *local_ip);
00901   }
00902 
00903   old_local_port = pcb->local_port;
00904   if (pcb->local_port == 0) {
00905     pcb->local_port = tcp_new_port();
00906     if (pcb->local_port == 0) {
00907       return ERR_BUF;
00908     }
00909   } else {
00910 #if SO_REUSE
00911     if (ip_get_option(pcb, SOF_REUSEADDR)) {
00912       /* Since SOF_REUSEADDR allows reusing a local address, we have to make sure
00913          now that the 5-tuple is unique. */
00914       struct tcp_pcb *cpcb;
00915       int i;
00916       /* Don't check listen- and bound-PCBs, check active- and TIME-WAIT PCBs. */
00917       for (i = 2; i < NUM_TCP_PCB_LISTS; i++) {
00918         for (cpcb = *tcp_pcb_lists[i]; cpcb != NULL; cpcb = cpcb->next) {
00919           if ((cpcb->local_port == pcb->local_port) &&
00920               (cpcb->remote_port == port) &&
00921               ip_addr_cmp(&cpcb->local_ip, &pcb->local_ip) &&
00922               ip_addr_cmp(&cpcb->remote_ip, ipaddr)) {
00923             /* linux returns EISCONN here, but ERR_USE should be OK for us */
00924             return ERR_USE;
00925           }
00926         }
00927       }
00928     }
00929 #endif /* SO_REUSE */
00930   }
00931 
00932   iss = tcp_next_iss(pcb);
00933   pcb->rcv_nxt = 0;
00934   pcb->snd_nxt = iss;
00935   pcb->lastack = iss - 1;
00936   pcb->snd_wl2 = iss - 1;
00937   pcb->snd_lbb = iss - 1;
00938   /* Start with a window that does not need scaling. When window scaling is
00939      enabled and used, the window is enlarged when both sides agree on scaling. */
00940   pcb->rcv_wnd = pcb->rcv_ann_wnd = TCPWND_MIN16(TCP_WND);
00941   pcb->rcv_ann_right_edge = pcb->rcv_nxt;
00942   pcb->snd_wnd = TCP_WND;
00943   /* As initial send MSS, we use TCP_MSS but limit it to 536.
00944      The send MSS is updated when an MSS option is received. */
00945   pcb->mss = INITIAL_MSS;
00946 #if TCP_CALCULATE_EFF_SEND_MSS
00947   pcb->mss = tcp_eff_send_mss(pcb->mss, &pcb->local_ip, &pcb->remote_ip);
00948 #endif /* TCP_CALCULATE_EFF_SEND_MSS */
00949   pcb->cwnd = 1;
00950 #if LWIP_CALLBACK_API
00951   pcb->connected = connected;
00952 #else /* LWIP_CALLBACK_API */
00953   LWIP_UNUSED_ARG(connected);
00954 #endif /* LWIP_CALLBACK_API */
00955 
00956   /* Send a SYN together with the MSS option. */
00957   ret = tcp_enqueue_flags(pcb, TCP_SYN);
00958   if (ret == ERR_OK) {
00959     /* SYN segment was enqueued, changed the pcbs state now */
00960     pcb->state = SYN_SENT;
00961     if (old_local_port != 0) {
00962       TCP_RMV(&tcp_bound_pcbs, pcb);
00963     }
00964     TCP_REG_ACTIVE(pcb);
00965     MIB2_STATS_INC(mib2.tcpactiveopens);
00966 
00967     tcp_output(pcb);
00968   }
00969   return ret;
00970 }
00971 
00972 /**
00973  * Called every 500 ms and implements the retransmission timer and the timer that
00974  * removes PCBs that have been in TIME-WAIT for enough time. It also increments
00975  * various timers such as the inactivity timer in each PCB.
00976  *
00977  * Automatically called from tcp_tmr().
00978  */
00979 void
00980 tcp_slowtmr(void)
00981 {
00982   struct tcp_pcb *pcb, *prev;
00983   tcpwnd_size_t eff_wnd;
00984   u8_t pcb_remove;      /* flag if a PCB should be removed */
00985   u8_t pcb_reset;       /* flag if a RST should be sent when removing */
00986   err_t err;
00987 
00988   err = ERR_OK;
00989 
00990   ++tcp_ticks;
00991   ++tcp_timer_ctr;
00992 
00993 tcp_slowtmr_start:
00994   /* Steps through all of the active PCBs. */
00995   prev = NULL;
00996   pcb = tcp_active_pcbs;
00997   if (pcb == NULL) {
00998     LWIP_DEBUGF(TCP_DEBUG, ("tcp_slowtmr: no active pcbs\n"));
00999   }
01000   while (pcb != NULL) {
01001     LWIP_DEBUGF(TCP_DEBUG, ("tcp_slowtmr: processing active pcb\n"));
01002     LWIP_ASSERT("tcp_slowtmr: active pcb->state != CLOSED\n", pcb->state != CLOSED);
01003     LWIP_ASSERT("tcp_slowtmr: active pcb->state != LISTEN\n", pcb->state != LISTEN);
01004     LWIP_ASSERT("tcp_slowtmr: active pcb->state != TIME-WAIT\n", pcb->state != TIME_WAIT);
01005     if (pcb->last_timer == tcp_timer_ctr) {
01006       /* skip this pcb, we have already processed it */
01007       pcb = pcb->next;
01008       continue;
01009     }
01010     pcb->last_timer = tcp_timer_ctr;
01011 
01012     pcb_remove = 0;
01013     pcb_reset = 0;
01014 
01015     if (pcb->state == SYN_SENT && pcb->nrtx >= TCP_SYNMAXRTX) {
01016       ++pcb_remove;
01017       LWIP_DEBUGF(TCP_DEBUG, ("tcp_slowtmr: max SYN retries reached\n"));
01018     }
01019     else if (pcb->nrtx >= TCP_MAXRTX) {
01020       ++pcb_remove;
01021       LWIP_DEBUGF(TCP_DEBUG, ("tcp_slowtmr: max DATA retries reached\n"));
01022     } else {
01023       if (pcb->persist_backoff > 0) {
01024         /* If snd_wnd is zero, use persist timer to send 1 byte probes
01025          * instead of using the standard retransmission mechanism. */
01026         u8_t backoff_cnt = tcp_persist_backoff[pcb->persist_backoff-1];
01027         if (pcb->persist_cnt < backoff_cnt) {
01028           pcb->persist_cnt++;
01029         }
01030         if (pcb->persist_cnt >= backoff_cnt) {
01031           if (tcp_zero_window_probe(pcb) == ERR_OK) {
01032             pcb->persist_cnt = 0;
01033             if (pcb->persist_backoff < sizeof(tcp_persist_backoff)) {
01034               pcb->persist_backoff++;
01035             }
01036           }
01037         }
01038       } else {
01039         /* Increase the retransmission timer if it is running */
01040         if (pcb->rtime >= 0) {
01041           ++pcb->rtime;
01042         }
01043 
01044         if (pcb->unacked != NULL && pcb->rtime >= pcb->rto) {
01045           /* Time for a retransmission. */
01046           LWIP_DEBUGF(TCP_RTO_DEBUG, ("tcp_slowtmr: rtime %"S16_F
01047                                       " pcb->rto %"S16_F"\n",
01048                                       pcb->rtime, pcb->rto));
01049 
01050           /* Double retransmission time-out unless we are trying to
01051            * connect to somebody (i.e., we are in SYN_SENT). */
01052           if (pcb->state != SYN_SENT) {
01053             u8_t backoff_idx = LWIP_MIN(pcb->nrtx, sizeof(tcp_backoff)-1);
01054             pcb->rto = ((pcb->sa >> 3) + pcb->sv) << tcp_backoff[backoff_idx];
01055           }
01056 
01057           /* Reset the retransmission timer. */
01058           pcb->rtime = 0;
01059 
01060           /* Reduce congestion window and ssthresh. */
01061           eff_wnd = LWIP_MIN(pcb->cwnd, pcb->snd_wnd);
01062           pcb->ssthresh = eff_wnd >> 1;
01063           if (pcb->ssthresh < (tcpwnd_size_t)(pcb->mss << 1)) {
01064             pcb->ssthresh = (pcb->mss << 1);
01065           }
01066           pcb->cwnd = pcb->mss;
01067           LWIP_DEBUGF(TCP_CWND_DEBUG, ("tcp_slowtmr: cwnd %"TCPWNDSIZE_F
01068                                        " ssthresh %"TCPWNDSIZE_F"\n",
01069                                        pcb->cwnd, pcb->ssthresh));
01070 
01071           /* The following needs to be called AFTER cwnd is set to one
01072              mss - STJ */
01073           tcp_rexmit_rto(pcb);
01074         }
01075       }
01076     }
01077     /* Check if this PCB has stayed too long in FIN-WAIT-2 */
01078     if (pcb->state == FIN_WAIT_2) {
01079       /* If this PCB is in FIN_WAIT_2 because of SHUT_WR don't let it time out. */
01080       if (pcb->flags & TF_RXCLOSED) {
01081         /* PCB was fully closed (either through close() or SHUT_RDWR):
01082            normal FIN-WAIT timeout handling. */
01083         if ((u32_t)(tcp_ticks - pcb->tmr) >
01084             TCP_FIN_WAIT_TIMEOUT / TCP_SLOW_INTERVAL) {
01085           ++pcb_remove;
01086           LWIP_DEBUGF(TCP_DEBUG, ("tcp_slowtmr: removing pcb stuck in FIN-WAIT-2\n"));
01087         }
01088       }
01089     }
01090 
01091     /* Check if KEEPALIVE should be sent */
01092     if (ip_get_option(pcb, SOF_KEEPALIVE) &&
01093        ((pcb->state == ESTABLISHED) ||
01094         (pcb->state == CLOSE_WAIT))) {
01095       if ((u32_t)(tcp_ticks - pcb->tmr) >
01096          (pcb->keep_idle + TCP_KEEP_DUR(pcb)) / TCP_SLOW_INTERVAL)
01097       {
01098         LWIP_DEBUGF(TCP_DEBUG, ("tcp_slowtmr: KEEPALIVE timeout. Aborting connection to "));
01099         ip_addr_debug_print(TCP_DEBUG, &pcb->remote_ip);
01100         LWIP_DEBUGF(TCP_DEBUG, ("\n"));
01101 
01102         ++pcb_remove;
01103         ++pcb_reset;
01104       } else if ((u32_t)(tcp_ticks - pcb->tmr) >
01105                 (pcb->keep_idle + pcb->keep_cnt_sent * TCP_KEEP_INTVL(pcb))
01106                 / TCP_SLOW_INTERVAL)
01107       {
01108         err = tcp_keepalive(pcb);
01109         if (err == ERR_OK) {
01110           pcb->keep_cnt_sent++;
01111         }
01112       }
01113     }
01114 
01115     /* If this PCB has queued out of sequence data, but has been
01116        inactive for too long, will drop the data (it will eventually
01117        be retransmitted). */
01118 #if TCP_QUEUE_OOSEQ
01119     if (pcb->ooseq != NULL &&
01120         (u32_t)tcp_ticks - pcb->tmr >= pcb->rto * TCP_OOSEQ_TIMEOUT) {
01121       tcp_segs_free(pcb->ooseq);
01122       pcb->ooseq = NULL;
01123       LWIP_DEBUGF(TCP_CWND_DEBUG, ("tcp_slowtmr: dropping OOSEQ queued data\n"));
01124     }
01125 #endif /* TCP_QUEUE_OOSEQ */
01126 
01127     /* Check if this PCB has stayed too long in SYN-RCVD */
01128     if (pcb->state == SYN_RCVD) {
01129       if ((u32_t)(tcp_ticks - pcb->tmr) >
01130           TCP_SYN_RCVD_TIMEOUT / TCP_SLOW_INTERVAL) {
01131         ++pcb_remove;
01132         LWIP_DEBUGF(TCP_DEBUG, ("tcp_slowtmr: removing pcb stuck in SYN-RCVD\n"));
01133       }
01134     }
01135 
01136     /* Check if this PCB has stayed too long in LAST-ACK */
01137     if (pcb->state == LAST_ACK) {
01138       if ((u32_t)(tcp_ticks - pcb->tmr) > 2 * TCP_MSL / TCP_SLOW_INTERVAL) {
01139         ++pcb_remove;
01140         LWIP_DEBUGF(TCP_DEBUG, ("tcp_slowtmr: removing pcb stuck in LAST-ACK\n"));
01141       }
01142     }
01143 
01144     /* If the PCB should be removed, do it. */
01145     if (pcb_remove) {
01146       struct tcp_pcb *pcb2;
01147 #if LWIP_CALLBACK_API
01148       tcp_err_fn err_fn = pcb->errf;
01149 #endif /* LWIP_CALLBACK_API */
01150       void *err_arg;
01151       enum tcp_state last_state;
01152       tcp_pcb_purge(pcb);
01153       /* Remove PCB from tcp_active_pcbs list. */
01154       if (prev != NULL) {
01155         LWIP_ASSERT("tcp_slowtmr: middle tcp != tcp_active_pcbs", pcb != tcp_active_pcbs);
01156         prev->next = pcb->next;
01157       } else {
01158         /* This PCB was the first. */
01159         LWIP_ASSERT("tcp_slowtmr: first pcb == tcp_active_pcbs", tcp_active_pcbs == pcb);
01160         tcp_active_pcbs = pcb->next;
01161       }
01162 
01163       if (pcb_reset) {
01164         tcp_rst(pcb->snd_nxt, pcb->rcv_nxt, &pcb->local_ip, &pcb->remote_ip,
01165                  pcb->local_port, pcb->remote_port);
01166       }
01167 
01168       err_arg = pcb->callback_arg;
01169       last_state = pcb->state;
01170       pcb2 = pcb;
01171       pcb = pcb->next;
01172       memp_free(MEMP_TCP_PCB, pcb2);
01173 
01174       tcp_active_pcbs_changed = 0;
01175       TCP_EVENT_ERR(last_state, err_fn, err_arg, ERR_ABRT);
01176       if (tcp_active_pcbs_changed) {
01177         goto tcp_slowtmr_start;
01178       }
01179     } else {
01180       /* get the 'next' element now and work with 'prev' below (in case of abort) */
01181       prev = pcb;
01182       pcb = pcb->next;
01183 
01184       /* We check if we should poll the connection. */
01185       ++prev->polltmr;
01186       if (prev->polltmr >= prev->pollinterval) {
01187         prev->polltmr = 0;
01188         LWIP_DEBUGF(TCP_DEBUG, ("tcp_slowtmr: polling application\n"));
01189         tcp_active_pcbs_changed = 0;
01190         TCP_EVENT_POLL(prev, err);
01191         if (tcp_active_pcbs_changed) {
01192           goto tcp_slowtmr_start;
01193         }
01194         /* if err == ERR_ABRT, 'prev' is already deallocated */
01195         if (err == ERR_OK) {
01196           tcp_output(prev);
01197         }
01198       }
01199     }
01200   }
01201 
01202 
01203   /* Steps through all of the TIME-WAIT PCBs. */
01204   prev = NULL;
01205   pcb = tcp_tw_pcbs;
01206   while (pcb != NULL) {
01207     LWIP_ASSERT("tcp_slowtmr: TIME-WAIT pcb->state == TIME-WAIT", pcb->state == TIME_WAIT);
01208     pcb_remove = 0;
01209 
01210     /* Check if this PCB has stayed long enough in TIME-WAIT */
01211     if ((u32_t)(tcp_ticks - pcb->tmr) > 2 * TCP_MSL / TCP_SLOW_INTERVAL) {
01212       ++pcb_remove;
01213     }
01214 
01215     /* If the PCB should be removed, do it. */
01216     if (pcb_remove) {
01217       struct tcp_pcb *pcb2;
01218       tcp_pcb_purge(pcb);
01219       /* Remove PCB from tcp_tw_pcbs list. */
01220       if (prev != NULL) {
01221         LWIP_ASSERT("tcp_slowtmr: middle tcp != tcp_tw_pcbs", pcb != tcp_tw_pcbs);
01222         prev->next = pcb->next;
01223       } else {
01224         /* This PCB was the first. */
01225         LWIP_ASSERT("tcp_slowtmr: first pcb == tcp_tw_pcbs", tcp_tw_pcbs == pcb);
01226         tcp_tw_pcbs = pcb->next;
01227       }
01228       pcb2 = pcb;
01229       pcb = pcb->next;
01230       memp_free(MEMP_TCP_PCB, pcb2);
01231     } else {
01232       prev = pcb;
01233       pcb = pcb->next;
01234     }
01235   }
01236 }
01237 
01238 /**
01239  * Is called every TCP_FAST_INTERVAL (250 ms) and process data previously
01240  * "refused" by upper layer (application) and sends delayed ACKs.
01241  *
01242  * Automatically called from tcp_tmr().
01243  */
01244 void
01245 tcp_fasttmr(void)
01246 {
01247   struct tcp_pcb *pcb;
01248 
01249   ++tcp_timer_ctr;
01250 
01251 tcp_fasttmr_start:
01252   pcb = tcp_active_pcbs;
01253 
01254   while (pcb != NULL) {
01255     if (pcb->last_timer != tcp_timer_ctr) {
01256       struct tcp_pcb *next;
01257       pcb->last_timer = tcp_timer_ctr;
01258       /* send delayed ACKs */
01259       if (pcb->flags & TF_ACK_DELAY) {
01260         LWIP_DEBUGF(TCP_DEBUG, ("tcp_fasttmr: delayed ACK\n"));
01261         tcp_ack_now(pcb);
01262         tcp_output(pcb);
01263         pcb->flags &= ~(TF_ACK_DELAY | TF_ACK_NOW);
01264       }
01265       /* send pending FIN */
01266       if (pcb->flags & TF_CLOSEPEND) {
01267         LWIP_DEBUGF(TCP_DEBUG, ("tcp_fasttmr: pending FIN\n"));
01268         pcb->flags &= ~(TF_CLOSEPEND);
01269         tcp_close_shutdown_fin(pcb);
01270       }
01271 
01272       next = pcb->next;
01273 
01274       /* If there is data which was previously "refused" by upper layer */
01275       if (pcb->refused_data != NULL) {
01276         tcp_active_pcbs_changed = 0;
01277         tcp_process_refused_data(pcb);
01278         if (tcp_active_pcbs_changed) {
01279           /* application callback has changed the pcb list: restart the loop */
01280           goto tcp_fasttmr_start;
01281         }
01282       }
01283       pcb = next;
01284     } else {
01285       pcb = pcb->next;
01286     }
01287   }
01288 }
01289 
01290 /** Call tcp_output for all active pcbs that have TF_NAGLEMEMERR set */
01291 void
01292 tcp_txnow(void)
01293 {
01294   struct tcp_pcb *pcb;
01295 
01296   for (pcb = tcp_active_pcbs; pcb != NULL; pcb = pcb->next) {
01297     if (pcb->flags & TF_NAGLEMEMERR) {
01298       tcp_output(pcb);
01299     }
01300   }
01301 }
01302 
01303 /** Pass pcb->refused_data to the recv callback */
01304 err_t
01305 tcp_process_refused_data(struct tcp_pcb *pcb)
01306 {
01307 #if TCP_QUEUE_OOSEQ && LWIP_WND_SCALE
01308   struct pbuf *rest;
01309   while (pcb->refused_data != NULL)
01310 #endif /* TCP_QUEUE_OOSEQ && LWIP_WND_SCALE */
01311   {
01312     err_t err;
01313     u8_t refused_flags = pcb->refused_data->flags;
01314     /* set pcb->refused_data to NULL in case the callback frees it and then
01315        closes the pcb */
01316     struct pbuf *refused_data = pcb->refused_data;
01317 #if TCP_QUEUE_OOSEQ && LWIP_WND_SCALE
01318     pbuf_split_64k(refused_data, &rest);
01319     pcb->refused_data = rest;
01320 #else /* TCP_QUEUE_OOSEQ && LWIP_WND_SCALE */
01321     pcb->refused_data = NULL;
01322 #endif /* TCP_QUEUE_OOSEQ && LWIP_WND_SCALE */
01323     /* Notify again application with data previously received. */
01324     LWIP_DEBUGF(TCP_INPUT_DEBUG, ("tcp_input: notify kept packet\n"));
01325     TCP_EVENT_RECV(pcb, refused_data, ERR_OK, err);
01326     if (err == ERR_OK) {
01327       /* did refused_data include a FIN? */
01328       if (refused_flags & PBUF_FLAG_TCP_FIN
01329 #if TCP_QUEUE_OOSEQ && LWIP_WND_SCALE
01330           && (rest == NULL)
01331 #endif /* TCP_QUEUE_OOSEQ && LWIP_WND_SCALE */
01332          ) {
01333         /* correct rcv_wnd as the application won't call tcp_recved()
01334            for the FIN's seqno */
01335         if (pcb->rcv_wnd != TCP_WND_MAX(pcb)) {
01336           pcb->rcv_wnd++;
01337         }
01338         TCP_EVENT_CLOSED(pcb, err);
01339         if (err == ERR_ABRT) {
01340           return ERR_ABRT;
01341         }
01342       }
01343     } else if (err == ERR_ABRT) {
01344       /* if err == ERR_ABRT, 'pcb' is already deallocated */
01345       /* Drop incoming packets because pcb is "full" (only if the incoming
01346          segment contains data). */
01347       LWIP_DEBUGF(TCP_INPUT_DEBUG, ("tcp_input: drop incoming packets, because pcb is \"full\"\n"));
01348       return ERR_ABRT;
01349     } else {
01350       /* data is still refused, pbuf is still valid (go on for ACK-only packets) */
01351 #if TCP_QUEUE_OOSEQ && LWIP_WND_SCALE
01352       if (rest != NULL) {
01353         pbuf_cat(refused_data, rest);
01354       }
01355 #endif /* TCP_QUEUE_OOSEQ && LWIP_WND_SCALE */
01356       pcb->refused_data = refused_data;
01357       return ERR_INPROGRESS;
01358     }
01359   }
01360   return ERR_OK;
01361 }
01362 
01363 /**
01364  * Deallocates a list of TCP segments (tcp_seg structures).
01365  *
01366  * @param seg tcp_seg list of TCP segments to free
01367  */
01368 void
01369 tcp_segs_free(struct tcp_seg *seg)
01370 {
01371   while (seg != NULL) {
01372     struct tcp_seg *next = seg->next;
01373     tcp_seg_free(seg);
01374     seg = next;
01375   }
01376 }
01377 
01378 /**
01379  * Frees a TCP segment (tcp_seg structure).
01380  *
01381  * @param seg single tcp_seg to free
01382  */
01383 void
01384 tcp_seg_free(struct tcp_seg *seg)
01385 {
01386   if (seg != NULL) {
01387     if (seg->p != NULL) {
01388       pbuf_free(seg->p);
01389 #if TCP_DEBUG
01390       seg->p = NULL;
01391 #endif /* TCP_DEBUG */
01392     }
01393     memp_free(MEMP_TCP_SEG, seg);
01394   }
01395 }
01396 
01397 /**
01398  * Sets the priority of a connection.
01399  *
01400  * @param pcb the tcp_pcb to manipulate
01401  * @param prio new priority
01402  */
01403 void
01404 tcp_setprio(struct tcp_pcb *pcb, u8_t prio)
01405 {
01406   pcb->prio = prio;
01407 }
01408 
01409 #if TCP_QUEUE_OOSEQ
01410 /**
01411  * Returns a copy of the given TCP segment.
01412  * The pbuf and data are not copied, only the pointers
01413  *
01414  * @param seg the old tcp_seg
01415  * @return a copy of seg
01416  */
01417 struct tcp_seg *
01418 tcp_seg_copy(struct tcp_seg *seg)
01419 {
01420   struct tcp_seg *cseg;
01421 
01422   cseg = (struct tcp_seg *)memp_malloc(MEMP_TCP_SEG);
01423   if (cseg == NULL) {
01424     return NULL;
01425   }
01426   SMEMCPY((u8_t *)cseg, (const u8_t *)seg, sizeof(struct tcp_seg));
01427   pbuf_ref(cseg->p);
01428   return cseg;
01429 }
01430 #endif /* TCP_QUEUE_OOSEQ */
01431 
01432 #if LWIP_CALLBACK_API
01433 /**
01434  * Default receive callback that is called if the user didn't register
01435  * a recv callback for the pcb.
01436  */
01437 err_t
01438 tcp_recv_null(void *arg, struct tcp_pcb *pcb, struct pbuf *p, err_t err)
01439 {
01440   LWIP_UNUSED_ARG(arg);
01441   if (p != NULL) {
01442     tcp_recved(pcb, p->tot_len);
01443     pbuf_free(p);
01444   } else if (err == ERR_OK) {
01445     return tcp_close(pcb);
01446   }
01447   return ERR_OK;
01448 }
01449 #endif /* LWIP_CALLBACK_API */
01450 
01451 /**
01452  * Kills the oldest active connection that has the same or lower priority than
01453  * 'prio'.
01454  *
01455  * @param prio minimum priority
01456  */
01457 static void
01458 tcp_kill_prio(u8_t prio)
01459 {
01460   struct tcp_pcb *pcb, *inactive;
01461   u32_t inactivity;
01462   u8_t mprio;
01463 
01464   mprio = LWIP_MIN(TCP_PRIO_MAX, prio);
01465 
01466   /* We kill the oldest active connection that has lower priority than prio. */
01467   inactivity = 0;
01468   inactive = NULL;
01469   for (pcb = tcp_active_pcbs; pcb != NULL; pcb = pcb->next) {
01470     if (pcb->prio <= mprio &&
01471        (u32_t)(tcp_ticks - pcb->tmr) >= inactivity) {
01472       inactivity = tcp_ticks - pcb->tmr;
01473       inactive = pcb;
01474       mprio = pcb->prio;
01475     }
01476   }
01477   if (inactive != NULL) {
01478     LWIP_DEBUGF(TCP_DEBUG, ("tcp_kill_prio: killing oldest PCB %p (%"S32_F")\n",
01479            (void *)inactive, inactivity));
01480     tcp_abort(inactive);
01481   }
01482 }
01483 
01484 /**
01485  * Kills the oldest connection that is in specific state.
01486  * Called from tcp_alloc() for LAST_ACK and CLOSING if no more connections are available.
01487  */
01488 static void
01489 tcp_kill_state(enum tcp_state state)
01490 {
01491   struct tcp_pcb *pcb, *inactive;
01492   u32_t inactivity;
01493 
01494   LWIP_ASSERT("invalid state", (state == CLOSING) || (state == LAST_ACK));
01495 
01496   inactivity = 0;
01497   inactive = NULL;
01498   /* Go through the list of active pcbs and get the oldest pcb that is in state
01499      CLOSING/LAST_ACK. */
01500   for (pcb = tcp_active_pcbs; pcb != NULL; pcb = pcb->next) {
01501     if (pcb->state == state) {
01502       if ((u32_t)(tcp_ticks - pcb->tmr) >= inactivity) {
01503         inactivity = tcp_ticks - pcb->tmr;
01504         inactive = pcb;
01505       }
01506     }
01507   }
01508   if (inactive != NULL) {
01509     LWIP_DEBUGF(TCP_DEBUG, ("tcp_kill_closing: killing oldest %s PCB %p (%"S32_F")\n",
01510            tcp_state_str[state], (void *)inactive, inactivity));
01511     /* Don't send a RST, since no data is lost. */
01512     tcp_abandon(inactive, 0);
01513   }
01514 }
01515 
01516 /**
01517  * Kills the oldest connection that is in TIME_WAIT state.
01518  * Called from tcp_alloc() if no more connections are available.
01519  */
01520 static void
01521 tcp_kill_timewait(void)
01522 {
01523   struct tcp_pcb *pcb, *inactive;
01524   u32_t inactivity;
01525 
01526   inactivity = 0;
01527   inactive = NULL;
01528   /* Go through the list of TIME_WAIT pcbs and get the oldest pcb. */
01529   for (pcb = tcp_tw_pcbs; pcb != NULL; pcb = pcb->next) {
01530     if ((u32_t)(tcp_ticks - pcb->tmr) >= inactivity) {
01531       inactivity = tcp_ticks - pcb->tmr;
01532       inactive = pcb;
01533     }
01534   }
01535   if (inactive != NULL) {
01536     LWIP_DEBUGF(TCP_DEBUG, ("tcp_kill_timewait: killing oldest TIME-WAIT PCB %p (%"S32_F")\n",
01537            (void *)inactive, inactivity));
01538     tcp_abort(inactive);
01539   }
01540 }
01541 
01542 /**
01543  * Allocate a new tcp_pcb structure.
01544  *
01545  * @param prio priority for the new pcb
01546  * @return a new tcp_pcb that initially is in state CLOSED
01547  */
01548 struct tcp_pcb *
01549 tcp_alloc(u8_t prio)
01550 {
01551   struct tcp_pcb *pcb;
01552 
01553   pcb = (struct tcp_pcb *)memp_malloc(MEMP_TCP_PCB);
01554   if (pcb == NULL) {
01555     /* Try killing oldest connection in TIME-WAIT. */
01556     LWIP_DEBUGF(TCP_DEBUG, ("tcp_alloc: killing off oldest TIME-WAIT connection\n"));
01557     tcp_kill_timewait();
01558     /* Try to allocate a tcp_pcb again. */
01559     pcb = (struct tcp_pcb *)memp_malloc(MEMP_TCP_PCB);
01560     if (pcb == NULL) {
01561       /* Try killing oldest connection in LAST-ACK (these wouldn't go to TIME-WAIT). */
01562       LWIP_DEBUGF(TCP_DEBUG, ("tcp_alloc: killing off oldest LAST-ACK connection\n"));
01563       tcp_kill_state(LAST_ACK);
01564       /* Try to allocate a tcp_pcb again. */
01565       pcb = (struct tcp_pcb *)memp_malloc(MEMP_TCP_PCB);
01566       if (pcb == NULL) {
01567         /* Try killing oldest connection in CLOSING. */
01568         LWIP_DEBUGF(TCP_DEBUG, ("tcp_alloc: killing off oldest CLOSING connection\n"));
01569         tcp_kill_state(CLOSING);
01570         /* Try to allocate a tcp_pcb again. */
01571         pcb = (struct tcp_pcb *)memp_malloc(MEMP_TCP_PCB);
01572         if (pcb == NULL) {
01573           /* Try killing active connections with lower priority than the new one. */
01574           LWIP_DEBUGF(TCP_DEBUG, ("tcp_alloc: killing connection with prio lower than %d\n", prio));
01575           tcp_kill_prio(prio);
01576           /* Try to allocate a tcp_pcb again. */
01577           pcb = (struct tcp_pcb *)memp_malloc(MEMP_TCP_PCB);
01578           if (pcb != NULL) {
01579             /* adjust err stats: memp_malloc failed multiple times before */
01580             MEMP_STATS_DEC(err, MEMP_TCP_PCB);
01581           }
01582         }
01583         if (pcb != NULL) {
01584           /* adjust err stats: memp_malloc failed multiple times before */
01585           MEMP_STATS_DEC(err, MEMP_TCP_PCB);
01586         }
01587       }
01588       if (pcb != NULL) {
01589         /* adjust err stats: memp_malloc failed multiple times before */
01590         MEMP_STATS_DEC(err, MEMP_TCP_PCB);
01591       }
01592     }
01593     if (pcb != NULL) {
01594       /* adjust err stats: memp_malloc failed above */
01595       MEMP_STATS_DEC(err, MEMP_TCP_PCB);
01596     }
01597   }
01598   if (pcb != NULL) {
01599     /* zero out the whole pcb, so there is no need to initialize members to zero */
01600     memset(pcb, 0, sizeof(struct tcp_pcb));
01601     pcb->prio = prio;
01602     pcb->snd_buf = TCP_SND_BUF;
01603     /* Start with a window that does not need scaling. When window scaling is
01604        enabled and used, the window is enlarged when both sides agree on scaling. */
01605     pcb->rcv_wnd = pcb->rcv_ann_wnd = TCPWND_MIN16(TCP_WND);
01606     pcb->ttl = TCP_TTL;
01607     /* As initial send MSS, we use TCP_MSS but limit it to 536.
01608        The send MSS is updated when an MSS option is received. */
01609     pcb->mss = INITIAL_MSS;
01610     pcb->rto = 3000 / TCP_SLOW_INTERVAL;
01611     pcb->sv = 3000 / TCP_SLOW_INTERVAL;
01612     pcb->rtime = -1;
01613     pcb->cwnd = 1;
01614     pcb->tmr = tcp_ticks;
01615     pcb->last_timer = tcp_timer_ctr;
01616 
01617     /* RFC 5681 recommends setting ssthresh abritrarily high and gives an example
01618     of using the largest advertised receive window.  We've seen complications with
01619     receiving TCPs that use window scaling and/or window auto-tuning where the
01620     initial advertised window is very small and then grows rapidly once the
01621     connection is established. To avoid these complications, we set ssthresh to the
01622     largest effective cwnd (amount of in-flight data) that the sender can have. */
01623     pcb->ssthresh = TCP_SND_BUF;
01624 
01625 #if LWIP_CALLBACK_API
01626     pcb->recv = tcp_recv_null;
01627 #endif /* LWIP_CALLBACK_API */
01628 
01629     /* Init KEEPALIVE timer */
01630     pcb->keep_idle  = TCP_KEEPIDLE_DEFAULT;
01631 
01632 #if LWIP_TCP_KEEPALIVE
01633     pcb->keep_intvl = TCP_KEEPINTVL_DEFAULT;
01634     pcb->keep_cnt   = TCP_KEEPCNT_DEFAULT;
01635 #endif /* LWIP_TCP_KEEPALIVE */
01636   }
01637   return pcb;
01638 }
01639 
01640 /**
01641  * @ingroup tcp_raw
01642  * Creates a new TCP protocol control block but doesn't place it on
01643  * any of the TCP PCB lists.
01644  * The pcb is not put on any list until binding using tcp_bind().
01645  *
01646  * @internal: Maybe there should be a idle TCP PCB list where these
01647  * PCBs are put on. Port reservation using tcp_bind() is implemented but
01648  * allocated pcbs that are not bound can't be killed automatically if wanting
01649  * to allocate a pcb with higher prio (@see tcp_kill_prio())
01650  *
01651  * @return a new tcp_pcb that initially is in state CLOSED
01652  */
01653 struct tcp_pcb *
01654 tcp_new(void)
01655 {
01656   return tcp_alloc(TCP_PRIO_NORMAL);
01657 }
01658 
01659 /**
01660  * @ingroup tcp_raw
01661  * Creates a new TCP protocol control block but doesn't
01662  * place it on any of the TCP PCB lists.
01663  * The pcb is not put on any list until binding using tcp_bind().
01664  *
01665  * @param type IP address type, see @ref lwip_ip_addr_type definitions.
01666  * If you want to listen to IPv4 and IPv6 (dual-stack) connections,
01667  * supply @ref IPADDR_TYPE_ANY as argument and bind to @ref IP_ANY_TYPE.
01668  * @return a new tcp_pcb that initially is in state CLOSED
01669  */
01670 struct tcp_pcb *
01671 tcp_new_ip_type(u8_t type)
01672 {
01673   struct tcp_pcb * pcb;
01674   pcb = tcp_alloc(TCP_PRIO_NORMAL);
01675 #if LWIP_IPV4 && LWIP_IPV6
01676   if (pcb != NULL) {
01677     IP_SET_TYPE_VAL(pcb->local_ip, type);
01678     IP_SET_TYPE_VAL(pcb->remote_ip, type);
01679   }
01680 #else
01681   LWIP_UNUSED_ARG(type);
01682 #endif /* LWIP_IPV4 && LWIP_IPV6 */
01683   return pcb;
01684 }
01685 
01686 /**
01687  * @ingroup tcp_raw
01688  * Used to specify the argument that should be passed callback
01689  * functions.
01690  *
01691  * @param pcb tcp_pcb to set the callback argument
01692  * @param arg void pointer argument to pass to callback functions
01693  */
01694 void
01695 tcp_arg(struct tcp_pcb *pcb, void *arg)
01696 {
01697   /* This function is allowed to be called for both listen pcbs and
01698      connection pcbs. */
01699   if (pcb != NULL) {
01700     pcb->callback_arg = arg;
01701   }
01702 }
01703 #if LWIP_CALLBACK_API
01704 
01705 /**
01706  * @ingroup tcp_raw
01707  * Used to specify the function that should be called when a TCP
01708  * connection receives data.
01709  *
01710  * @param pcb tcp_pcb to set the recv callback
01711  * @param recv callback function to call for this pcb when data is received
01712  */
01713 void
01714 tcp_recv(struct tcp_pcb *pcb, tcp_recv_fn recv)
01715 {
01716   if (pcb != NULL) {
01717     LWIP_ASSERT("invalid socket state for recv callback", pcb->state != LISTEN);
01718     pcb->recv = recv;
01719   }
01720 }
01721 
01722 /**
01723  * @ingroup tcp_raw
01724  * Used to specify the function that should be called when TCP data
01725  * has been successfully delivered to the remote host.
01726  *
01727  * @param pcb tcp_pcb to set the sent callback
01728  * @param sent callback function to call for this pcb when data is successfully sent
01729  */
01730 void
01731 tcp_sent(struct tcp_pcb *pcb, tcp_sent_fn sent)
01732 {
01733   if (pcb != NULL) {
01734     LWIP_ASSERT("invalid socket state for sent callback", pcb->state != LISTEN);
01735     pcb->sent = sent;
01736   }
01737 }
01738 
01739 /**
01740  * @ingroup tcp_raw
01741  * Used to specify the function that should be called when a fatal error
01742  * has occurred on the connection.
01743  *
01744  * @note The corresponding pcb is already freed when this callback is called!
01745  * 
01746  * @param pcb tcp_pcb to set the err callback
01747  * @param err callback function to call for this pcb when a fatal error
01748  *        has occurred on the connection
01749  */
01750 void
01751 tcp_err(struct tcp_pcb *pcb, tcp_err_fn err)
01752 {
01753   if (pcb != NULL) {
01754     LWIP_ASSERT("invalid socket state for err callback", pcb->state != LISTEN);
01755     pcb->errf = err;
01756   }
01757 }
01758 
01759 /**
01760  * @ingroup tcp_raw
01761  * Used for specifying the function that should be called when a
01762  * LISTENing connection has been connected to another host.
01763  *
01764  * @param pcb tcp_pcb to set the accept callback
01765  * @param accept callback function to call for this pcb when LISTENing
01766  *        connection has been connected to another host
01767  */
01768 void
01769 tcp_accept(struct tcp_pcb *pcb, tcp_accept_fn accept)
01770 {
01771   if ((pcb != NULL) && (pcb->state == LISTEN)) {
01772     struct tcp_pcb_listen *lpcb = (struct tcp_pcb_listen*)pcb;
01773     lpcb->accept = accept;
01774   }
01775 }
01776 #endif /* LWIP_CALLBACK_API */
01777 
01778 
01779 /**
01780  * @ingroup tcp_raw
01781  * Used to specify the function that should be called periodically
01782  * from TCP. The interval is specified in terms of the TCP coarse
01783  * timer interval, which is called twice a second.
01784  *
01785  */
01786 void
01787 tcp_poll(struct tcp_pcb *pcb, tcp_poll_fn poll, u8_t interval)
01788 {
01789   LWIP_ASSERT("invalid socket state for poll", pcb->state != LISTEN);
01790 #if LWIP_CALLBACK_API
01791   pcb->poll = poll;
01792 #else /* LWIP_CALLBACK_API */
01793   LWIP_UNUSED_ARG(poll);
01794 #endif /* LWIP_CALLBACK_API */
01795   pcb->pollinterval = interval;
01796 }
01797 
01798 /**
01799  * Purges a TCP PCB. Removes any buffered data and frees the buffer memory
01800  * (pcb->ooseq, pcb->unsent and pcb->unacked are freed).
01801  *
01802  * @param pcb tcp_pcb to purge. The pcb itself is not deallocated!
01803  */
01804 void
01805 tcp_pcb_purge(struct tcp_pcb *pcb)
01806 {
01807   if (pcb->state != CLOSED &&
01808      pcb->state != TIME_WAIT &&
01809      pcb->state != LISTEN) {
01810 
01811     LWIP_DEBUGF(TCP_DEBUG, ("tcp_pcb_purge\n"));
01812 
01813     tcp_backlog_accepted(pcb);
01814 
01815     if (pcb->refused_data != NULL) {
01816       LWIP_DEBUGF(TCP_DEBUG, ("tcp_pcb_purge: data left on ->refused_data\n"));
01817       pbuf_free(pcb->refused_data);
01818       pcb->refused_data = NULL;
01819     }
01820     if (pcb->unsent != NULL) {
01821       LWIP_DEBUGF(TCP_DEBUG, ("tcp_pcb_purge: not all data sent\n"));
01822     }
01823     if (pcb->unacked != NULL) {
01824       LWIP_DEBUGF(TCP_DEBUG, ("tcp_pcb_purge: data left on ->unacked\n"));
01825     }
01826 #if TCP_QUEUE_OOSEQ
01827     if (pcb->ooseq != NULL) {
01828       LWIP_DEBUGF(TCP_DEBUG, ("tcp_pcb_purge: data left on ->ooseq\n"));
01829     }
01830     tcp_segs_free(pcb->ooseq);
01831     pcb->ooseq = NULL;
01832 #endif /* TCP_QUEUE_OOSEQ */
01833 
01834     /* Stop the retransmission timer as it will expect data on unacked
01835        queue if it fires */
01836     pcb->rtime = -1;
01837 
01838     tcp_segs_free(pcb->unsent);
01839     tcp_segs_free(pcb->unacked);
01840     pcb->unacked = pcb->unsent = NULL;
01841 #if TCP_OVERSIZE
01842     pcb->unsent_oversize = 0;
01843 #endif /* TCP_OVERSIZE */
01844   }
01845 }
01846 
01847 /**
01848  * Purges the PCB and removes it from a PCB list. Any delayed ACKs are sent first.
01849  *
01850  * @param pcblist PCB list to purge.
01851  * @param pcb tcp_pcb to purge. The pcb itself is NOT deallocated!
01852  */
01853 void
01854 tcp_pcb_remove(struct tcp_pcb **pcblist, struct tcp_pcb *pcb)
01855 {
01856   TCP_RMV(pcblist, pcb);
01857 
01858   tcp_pcb_purge(pcb);
01859 
01860   /* if there is an outstanding delayed ACKs, send it */
01861   if (pcb->state != TIME_WAIT &&
01862      pcb->state != LISTEN &&
01863      pcb->flags & TF_ACK_DELAY) {
01864     pcb->flags |= TF_ACK_NOW;
01865     tcp_output(pcb);
01866   }
01867 
01868   if (pcb->state != LISTEN) {
01869     LWIP_ASSERT("unsent segments leaking", pcb->unsent == NULL);
01870     LWIP_ASSERT("unacked segments leaking", pcb->unacked == NULL);
01871 #if TCP_QUEUE_OOSEQ
01872     LWIP_ASSERT("ooseq segments leaking", pcb->ooseq == NULL);
01873 #endif /* TCP_QUEUE_OOSEQ */
01874   }
01875 
01876   pcb->state = CLOSED;
01877   /* reset the local port to prevent the pcb from being 'bound' */
01878   pcb->local_port = 0;
01879 
01880   LWIP_ASSERT("tcp_pcb_remove: tcp_pcbs_sane()", tcp_pcbs_sane());
01881 }
01882 
01883 /**
01884  * Calculates a new initial sequence number for new connections.
01885  *
01886  * @return u32_t pseudo random sequence number
01887  */
01888 u32_t
01889 tcp_next_iss(struct tcp_pcb *pcb)
01890 {
01891 #ifdef LWIP_HOOK_TCP_ISN
01892   return LWIP_HOOK_TCP_ISN(&pcb->local_ip, pcb->local_port, &pcb->remote_ip, pcb->remote_port);
01893 #else /* LWIP_HOOK_TCP_ISN */
01894   static u32_t iss = 6510;
01895 
01896   LWIP_UNUSED_ARG(pcb);
01897 
01898   iss += tcp_ticks;       /* XXX */
01899   return iss;
01900 #endif /* LWIP_HOOK_TCP_ISN */
01901 }
01902 
01903 #if TCP_CALCULATE_EFF_SEND_MSS
01904 /**
01905  * Calculates the effective send mss that can be used for a specific IP address
01906  * by using ip_route to determine the netif used to send to the address and
01907  * calculating the minimum of TCP_MSS and that netif's mtu (if set).
01908  */
01909 u16_t
01910 tcp_eff_send_mss_impl(u16_t sendmss, const ip_addr_t *dest
01911 #if LWIP_IPV6 || LWIP_IPV4_SRC_ROUTING
01912                      , const ip_addr_t *src
01913 #endif /* LWIP_IPV6 || LWIP_IPV4_SRC_ROUTING */
01914                      )
01915 {
01916   u16_t mss_s;
01917   struct netif *outif;
01918   s16_t mtu;
01919 
01920   outif = ip_route(src, dest);
01921 #if LWIP_IPV6
01922 #if LWIP_IPV4
01923   if (IP_IS_V6(dest))
01924 #endif /* LWIP_IPV4 */
01925   {
01926     /* First look in destination cache, to see if there is a Path MTU. */
01927     mtu = nd6_get_destination_mtu(ip_2_ip6(dest), outif);
01928   }
01929 #if LWIP_IPV4
01930   else
01931 #endif /* LWIP_IPV4 */
01932 #endif /* LWIP_IPV6 */
01933 #if LWIP_IPV4
01934   {
01935     if (outif == NULL) {
01936       return sendmss;
01937     }
01938     mtu = outif->mtu;
01939   }
01940 #endif /* LWIP_IPV4 */
01941 
01942   if (mtu != 0) {
01943 #if LWIP_IPV6
01944 #if LWIP_IPV4
01945     if (IP_IS_V6(dest))
01946 #endif /* LWIP_IPV4 */
01947     {
01948       mss_s = mtu - IP6_HLEN - TCP_HLEN;
01949     }
01950 #if LWIP_IPV4
01951     else
01952 #endif /* LWIP_IPV4 */
01953 #endif /* LWIP_IPV6 */
01954 #if LWIP_IPV4
01955     {
01956       mss_s = mtu - IP_HLEN - TCP_HLEN;
01957     }
01958 #endif /* LWIP_IPV4 */
01959     /* RFC 1122, chap 4.2.2.6:
01960      * Eff.snd.MSS = min(SendMSS+20, MMS_S) - TCPhdrsize - IPoptionsize
01961      * We correct for TCP options in tcp_write(), and don't support IP options.
01962      */
01963     sendmss = LWIP_MIN(sendmss, mss_s);
01964   }
01965   return sendmss;
01966 }
01967 #endif /* TCP_CALCULATE_EFF_SEND_MSS */
01968 
01969 /** Helper function for tcp_netif_ip_addr_changed() that iterates a pcb list */
01970 static void
01971 tcp_netif_ip_addr_changed_pcblist(const ip_addr_t* old_addr, struct tcp_pcb* pcb_list)
01972 {
01973   struct tcp_pcb *pcb;
01974   pcb = pcb_list;
01975   while (pcb != NULL) {
01976     /* PCB bound to current local interface address? */
01977     if (ip_addr_cmp(&pcb->local_ip, old_addr)
01978 #if LWIP_AUTOIP
01979       /* connections to link-local addresses must persist (RFC3927 ch. 1.9) */
01980       && (!IP_IS_V4_VAL(pcb->local_ip) || !ip4_addr_islinklocal(ip_2_ip4(&pcb->local_ip)))
01981 #endif /* LWIP_AUTOIP */
01982       ) {
01983       /* this connection must be aborted */
01984       struct tcp_pcb *next = pcb->next;
01985       LWIP_DEBUGF(NETIF_DEBUG | LWIP_DBG_STATE, ("netif_set_ipaddr: aborting TCP pcb %p\n", (void *)pcb));
01986       tcp_abort(pcb);
01987       pcb = next;
01988     } else {
01989       pcb = pcb->next;
01990     }
01991   }
01992 }
01993 
01994 /** This function is called from netif.c when address is changed or netif is removed
01995  *
01996  * @param old_addr IP address of the netif before change
01997  * @param new_addr IP address of the netif after change or NULL if netif has been removed
01998  */
01999 void
02000 tcp_netif_ip_addr_changed(const ip_addr_t* old_addr, const ip_addr_t* new_addr)
02001 {
02002   struct tcp_pcb_listen *lpcb, *next;
02003 
02004   if (!ip_addr_isany(old_addr)) {
02005     tcp_netif_ip_addr_changed_pcblist(old_addr, tcp_active_pcbs);
02006     tcp_netif_ip_addr_changed_pcblist(old_addr, tcp_bound_pcbs);
02007 
02008     if (!ip_addr_isany(new_addr)) {
02009       /* PCB bound to current local interface address? */
02010       for (lpcb = tcp_listen_pcbs.listen_pcbs; lpcb != NULL; lpcb = next) {
02011         next = lpcb->next;
02012         /* PCB bound to current local interface address? */
02013         if (ip_addr_cmp(&lpcb->local_ip, old_addr)) {
02014           /* The PCB is listening to the old ipaddr and
02015             * is set to listen to the new one instead */
02016           ip_addr_copy(lpcb->local_ip, *new_addr);
02017         }
02018       }
02019     }
02020   }
02021 }
02022 
02023 const char*
02024 tcp_debug_state_str(enum tcp_state s)
02025 {
02026   return tcp_state_str[s];
02027 }
02028 
02029 #if TCP_DEBUG || TCP_INPUT_DEBUG || TCP_OUTPUT_DEBUG
02030 /**
02031  * Print a tcp header for debugging purposes.
02032  *
02033  * @param tcphdr pointer to a struct tcp_hdr
02034  */
02035 void
02036 tcp_debug_print(struct tcp_hdr *tcphdr)
02037 {
02038   LWIP_DEBUGF(TCP_DEBUG, ("TCP header:\n"));
02039   LWIP_DEBUGF(TCP_DEBUG, ("+-------------------------------+\n"));
02040   LWIP_DEBUGF(TCP_DEBUG, ("|    %5"U16_F"      |    %5"U16_F"      | (src port, dest port)\n",
02041          lwip_ntohs(tcphdr->src), lwip_ntohs(tcphdr->dest)));
02042   LWIP_DEBUGF(TCP_DEBUG, ("+-------------------------------+\n"));
02043   LWIP_DEBUGF(TCP_DEBUG, ("|           %010"U32_F"          | (seq no)\n",
02044           lwip_ntohl(tcphdr->seqno)));
02045   LWIP_DEBUGF(TCP_DEBUG, ("+-------------------------------+\n"));
02046   LWIP_DEBUGF(TCP_DEBUG, ("|           %010"U32_F"          | (ack no)\n",
02047          lwip_ntohl(tcphdr->ackno)));
02048   LWIP_DEBUGF(TCP_DEBUG, ("+-------------------------------+\n"));
02049   LWIP_DEBUGF(TCP_DEBUG, ("| %2"U16_F" |   |%"U16_F"%"U16_F"%"U16_F"%"U16_F"%"U16_F"%"U16_F"|     %5"U16_F"     | (hdrlen, flags (",
02050        TCPH_HDRLEN(tcphdr),
02051          (u16_t)(TCPH_FLAGS(tcphdr) >> 5 & 1),
02052          (u16_t)(TCPH_FLAGS(tcphdr) >> 4 & 1),
02053          (u16_t)(TCPH_FLAGS(tcphdr) >> 3 & 1),
02054          (u16_t)(TCPH_FLAGS(tcphdr) >> 2 & 1),
02055          (u16_t)(TCPH_FLAGS(tcphdr) >> 1 & 1),
02056          (u16_t)(TCPH_FLAGS(tcphdr)      & 1),
02057          lwip_ntohs(tcphdr->wnd)));
02058   tcp_debug_print_flags(TCPH_FLAGS(tcphdr));
02059   LWIP_DEBUGF(TCP_DEBUG, ("), win)\n"));
02060   LWIP_DEBUGF(TCP_DEBUG, ("+-------------------------------+\n"));
02061   LWIP_DEBUGF(TCP_DEBUG, ("|    0x%04"X16_F"     |     %5"U16_F"     | (chksum, urgp)\n",
02062          lwip_ntohs(tcphdr->chksum), lwip_ntohs(tcphdr->urgp)));
02063   LWIP_DEBUGF(TCP_DEBUG, ("+-------------------------------+\n"));
02064 }
02065 
02066 /**
02067  * Print a tcp state for debugging purposes.
02068  *
02069  * @param s enum tcp_state to print
02070  */
02071 void
02072 tcp_debug_print_state(enum tcp_state s)
02073 {
02074   LWIP_DEBUGF(TCP_DEBUG, ("State: %s\n", tcp_state_str[s]));
02075 }
02076 
02077 /**
02078  * Print tcp flags for debugging purposes.
02079  *
02080  * @param flags tcp flags, all active flags are printed
02081  */
02082 void
02083 tcp_debug_print_flags(u8_t flags)
02084 {
02085   if (flags & TCP_FIN) {
02086     LWIP_DEBUGF(TCP_DEBUG, ("FIN "));
02087   }
02088   if (flags & TCP_SYN) {
02089     LWIP_DEBUGF(TCP_DEBUG, ("SYN "));
02090   }
02091   if (flags & TCP_RST) {
02092     LWIP_DEBUGF(TCP_DEBUG, ("RST "));
02093   }
02094   if (flags & TCP_PSH) {
02095     LWIP_DEBUGF(TCP_DEBUG, ("PSH "));
02096   }
02097   if (flags & TCP_ACK) {
02098     LWIP_DEBUGF(TCP_DEBUG, ("ACK "));
02099   }
02100   if (flags & TCP_URG) {
02101     LWIP_DEBUGF(TCP_DEBUG, ("URG "));
02102   }
02103   if (flags & TCP_ECE) {
02104     LWIP_DEBUGF(TCP_DEBUG, ("ECE "));
02105   }
02106   if (flags & TCP_CWR) {
02107     LWIP_DEBUGF(TCP_DEBUG, ("CWR "));
02108   }
02109   LWIP_DEBUGF(TCP_DEBUG, ("\n"));
02110 }
02111 
02112 /**
02113  * Print all tcp_pcbs in every list for debugging purposes.
02114  */
02115 void
02116 tcp_debug_print_pcbs(void)
02117 {
02118   struct tcp_pcb *pcb;
02119   struct tcp_pcb_listen *pcbl;
02120 
02121   LWIP_DEBUGF(TCP_DEBUG, ("Active PCB states:\n"));
02122   for (pcb = tcp_active_pcbs; pcb != NULL; pcb = pcb->next) {
02123     LWIP_DEBUGF(TCP_DEBUG, ("Local port %"U16_F", foreign port %"U16_F" snd_nxt %"U32_F" rcv_nxt %"U32_F" ",
02124                        pcb->local_port, pcb->remote_port,
02125                        pcb->snd_nxt, pcb->rcv_nxt));
02126     tcp_debug_print_state(pcb->state);
02127   }
02128 
02129   LWIP_DEBUGF(TCP_DEBUG, ("Listen PCB states:\n"));
02130   for (pcbl = tcp_listen_pcbs.listen_pcbs; pcbl != NULL; pcbl = pcbl->next) {
02131     LWIP_DEBUGF(TCP_DEBUG, ("Local port %"U16_F" ", pcbl->local_port));
02132     tcp_debug_print_state(pcbl->state);
02133   }
02134 
02135   LWIP_DEBUGF(TCP_DEBUG, ("TIME-WAIT PCB states:\n"));
02136   for (pcb = tcp_tw_pcbs; pcb != NULL; pcb = pcb->next) {
02137     LWIP_DEBUGF(TCP_DEBUG, ("Local port %"U16_F", foreign port %"U16_F" snd_nxt %"U32_F" rcv_nxt %"U32_F" ",
02138                        pcb->local_port, pcb->remote_port,
02139                        pcb->snd_nxt, pcb->rcv_nxt));
02140     tcp_debug_print_state(pcb->state);
02141   }
02142 }
02143 
02144 /**
02145  * Check state consistency of the tcp_pcb lists.
02146  */
02147 s16_t
02148 tcp_pcbs_sane(void)
02149 {
02150   struct tcp_pcb *pcb;
02151   for (pcb = tcp_active_pcbs; pcb != NULL; pcb = pcb->next) {
02152     LWIP_ASSERT("tcp_pcbs_sane: active pcb->state != CLOSED", pcb->state != CLOSED);
02153     LWIP_ASSERT("tcp_pcbs_sane: active pcb->state != LISTEN", pcb->state != LISTEN);
02154     LWIP_ASSERT("tcp_pcbs_sane: active pcb->state != TIME-WAIT", pcb->state != TIME_WAIT);
02155   }
02156   for (pcb = tcp_tw_pcbs; pcb != NULL; pcb = pcb->next) {
02157     LWIP_ASSERT("tcp_pcbs_sane: tw pcb->state == TIME-WAIT", pcb->state == TIME_WAIT);
02158   }
02159   return 1;
02160 }
02161 #endif /* TCP_DEBUG */
02162 
02163 #endif /* LWIP_TCP */