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