Warning, cross-references for /kernel/lwip/core/tcp.c need to be fixed.
0001
0002
0003
0004
0005
0006
0007
0008
0009
0010
0011
0012
0013
0014
0015
0016
0017
0018
0019
0020
0021
0022
0023
0024
0025
0026
0027
0028
0029
0030
0031
0032
0033
0034
0035
0036
0037
0038
0039
0040
0041
0042
0043 #include "lwip/opt.h"
0044
0045 #if LWIP_TCP
0046
0047 #include "lwip/def.h"
0048 #include "lwip/mem.h"
0049 #include "lwip/memp.h"
0050 #include "lwip/snmp.h"
0051 #include "lwip/tcp.h"
0052 #include "lwip/debug.h"
0053 #include "lwip/stats.h"
0054
0055 #include <string.h>
0056
0057 const char *tcp_state_str[] = {
0058 "CLOSED",
0059 "LISTEN",
0060 "SYN_SENT",
0061 "SYN_RCVD",
0062 "ESTABLISHED",
0063 "FIN_WAIT_1",
0064 "FIN_WAIT_2",
0065 "CLOSE_WAIT",
0066 "CLOSING",
0067 "LAST_ACK",
0068 "TIME_WAIT"
0069 };
0070
0071
0072 u32_t tcp_ticks;
0073 const u8_t tcp_backoff[13] =
0074 { 1, 2, 3, 4, 5, 6, 7, 7, 7, 7, 7, 7, 7};
0075
0076 const u8_t tcp_persist_backoff[7] = { 3, 6, 12, 24, 48, 96, 120 };
0077
0078
0079
0080
0081 struct tcp_pcb *tcp_bound_pcbs;
0082
0083 union tcp_listen_pcbs_t tcp_listen_pcbs;
0084
0085
0086 struct tcp_pcb *tcp_active_pcbs;
0087
0088 struct tcp_pcb *tcp_tw_pcbs;
0089
0090 struct tcp_pcb *tcp_tmp_pcb;
0091
0092 static u8_t tcp_timer;
0093 static u16_t tcp_new_port(void);
0094
0095
0096
0097
0098
0099 void
0100 tcp_tmr(void)
0101 {
0102
0103 tcp_fasttmr();
0104
0105 if (++tcp_timer & 1) {
0106
0107
0108 tcp_slowtmr();
0109 }
0110 }
0111
0112
0113
0114
0115
0116
0117
0118
0119
0120
0121
0122
0123
0124
0125
0126 err_t
0127 tcp_close(struct tcp_pcb *pcb)
0128 {
0129 err_t err;
0130
0131 #if TCP_DEBUG
0132 LWIP_DEBUGF(TCP_DEBUG, ("tcp_close: closing in "));
0133 tcp_debug_print_state(pcb->state);
0134 #endif
0135
0136 switch (pcb->state) {
0137 case CLOSED:
0138
0139
0140
0141
0142
0143
0144
0145 err = ERR_OK;
0146 TCP_RMV(&tcp_bound_pcbs, pcb);
0147 memp_free(MEMP_TCP_PCB, pcb);
0148 pcb = NULL;
0149 break;
0150 case LISTEN:
0151 err = ERR_OK;
0152 tcp_pcb_remove((struct tcp_pcb **)&tcp_listen_pcbs.pcbs, pcb);
0153 memp_free(MEMP_TCP_PCB_LISTEN, pcb);
0154 pcb = NULL;
0155 break;
0156 case SYN_SENT:
0157 err = ERR_OK;
0158 tcp_pcb_remove(&tcp_active_pcbs, pcb);
0159 memp_free(MEMP_TCP_PCB, pcb);
0160 pcb = NULL;
0161 snmp_inc_tcpattemptfails();
0162 break;
0163 case SYN_RCVD:
0164 err = tcp_send_ctrl(pcb, TCP_FIN);
0165 if (err == ERR_OK) {
0166 snmp_inc_tcpattemptfails();
0167 pcb->state = FIN_WAIT_1;
0168 }
0169 break;
0170 case ESTABLISHED:
0171 err = tcp_send_ctrl(pcb, TCP_FIN);
0172 if (err == ERR_OK) {
0173 snmp_inc_tcpestabresets();
0174 pcb->state = FIN_WAIT_1;
0175 }
0176 break;
0177 case CLOSE_WAIT:
0178 err = tcp_send_ctrl(pcb, TCP_FIN);
0179 if (err == ERR_OK) {
0180 snmp_inc_tcpestabresets();
0181 pcb->state = LAST_ACK;
0182 }
0183 break;
0184 default:
0185
0186 err = ERR_OK;
0187 pcb = NULL;
0188 break;
0189 }
0190
0191 if (pcb != NULL && err == ERR_OK) {
0192
0193
0194
0195
0196
0197
0198
0199 tcp_output(pcb);
0200 }
0201 return err;
0202 }
0203
0204
0205
0206
0207
0208
0209
0210
0211
0212 void
0213 tcp_abandon(struct tcp_pcb *pcb, int reset)
0214 {
0215 u32_t seqno, ackno;
0216 u16_t remote_port, local_port;
0217 struct ip_addr remote_ip, local_ip;
0218 #if LWIP_CALLBACK_API
0219 void (* errf)(void *arg, err_t err);
0220 #endif
0221 void *errf_arg;
0222
0223
0224
0225
0226
0227 if (pcb->state == TIME_WAIT) {
0228 tcp_pcb_remove(&tcp_tw_pcbs, pcb);
0229 memp_free(MEMP_TCP_PCB, pcb);
0230 } else {
0231 seqno = pcb->snd_nxt;
0232 ackno = pcb->rcv_nxt;
0233 ip_addr_set(&local_ip, &(pcb->local_ip));
0234 ip_addr_set(&remote_ip, &(pcb->remote_ip));
0235 local_port = pcb->local_port;
0236 remote_port = pcb->remote_port;
0237 #if LWIP_CALLBACK_API
0238 errf = pcb->errf;
0239 #endif
0240 errf_arg = pcb->callback_arg;
0241 tcp_pcb_remove(&tcp_active_pcbs, pcb);
0242 if (pcb->unacked != NULL) {
0243 tcp_segs_free(pcb->unacked);
0244 }
0245 if (pcb->unsent != NULL) {
0246 tcp_segs_free(pcb->unsent);
0247 }
0248 #if TCP_QUEUE_OOSEQ
0249 if (pcb->ooseq != NULL) {
0250 tcp_segs_free(pcb->ooseq);
0251 }
0252 #endif
0253 memp_free(MEMP_TCP_PCB, pcb);
0254 TCP_EVENT_ERR(errf, errf_arg, ERR_ABRT);
0255 if (reset) {
0256 LWIP_DEBUGF(TCP_RST_DEBUG, ("tcp_abandon: sending RST\n"));
0257 tcp_rst(seqno, ackno, &local_ip, &remote_ip, local_port, remote_port);
0258 }
0259 }
0260 }
0261
0262
0263
0264
0265
0266
0267
0268
0269
0270
0271
0272
0273
0274
0275 err_t
0276 tcp_bind(struct tcp_pcb *pcb, struct ip_addr *ipaddr, u16_t port)
0277 {
0278 struct tcp_pcb *cpcb;
0279
0280 LWIP_ERROR("tcp_bind: can only bind in state CLOSED", pcb->state == CLOSED, return ERR_ISCONN);
0281
0282 if (port == 0) {
0283 port = tcp_new_port();
0284 }
0285
0286
0287 for(cpcb = (struct tcp_pcb *)tcp_listen_pcbs.pcbs;
0288 cpcb != NULL; cpcb = cpcb->next) {
0289 if (cpcb->local_port == port) {
0290 if (ip_addr_isany(&(cpcb->local_ip)) ||
0291 ip_addr_isany(ipaddr) ||
0292 ip_addr_cmp(&(cpcb->local_ip), ipaddr)) {
0293 return ERR_USE;
0294 }
0295 }
0296 }
0297
0298 for(cpcb = tcp_active_pcbs;
0299 cpcb != NULL; cpcb = cpcb->next) {
0300 if (cpcb->local_port == port) {
0301 if (ip_addr_isany(&(cpcb->local_ip)) ||
0302 ip_addr_isany(ipaddr) ||
0303 ip_addr_cmp(&(cpcb->local_ip), ipaddr)) {
0304 return ERR_USE;
0305 }
0306 }
0307 }
0308
0309 for(cpcb = tcp_bound_pcbs; cpcb != NULL; cpcb = cpcb->next) {
0310 if (cpcb->local_port == port) {
0311 if (ip_addr_isany(&(cpcb->local_ip)) ||
0312 ip_addr_isany(ipaddr) ||
0313 ip_addr_cmp(&(cpcb->local_ip), ipaddr)) {
0314 return ERR_USE;
0315 }
0316 }
0317 }
0318
0319
0320 for(cpcb = tcp_tw_pcbs; cpcb != NULL; cpcb = cpcb->next) {
0321 if (cpcb->local_port == port) {
0322 if (ip_addr_cmp(&(cpcb->local_ip), ipaddr)) {
0323 return ERR_USE;
0324 }
0325 }
0326 }
0327
0328 if (!ip_addr_isany(ipaddr)) {
0329 pcb->local_ip = *ipaddr;
0330 }
0331 pcb->local_port = port;
0332 TCP_REG(&tcp_bound_pcbs, pcb);
0333 LWIP_DEBUGF(TCP_DEBUG, ("tcp_bind: bind to port %"U16_F"\n", port));
0334 return ERR_OK;
0335 }
0336 #if LWIP_CALLBACK_API
0337
0338
0339
0340 static err_t
0341 tcp_accept_null(void *arg, struct tcp_pcb *pcb, err_t err)
0342 {
0343 LWIP_UNUSED_ARG(arg);
0344 LWIP_UNUSED_ARG(pcb);
0345 LWIP_UNUSED_ARG(err);
0346
0347 return ERR_ABRT;
0348 }
0349 #endif
0350
0351
0352
0353
0354
0355
0356
0357
0358
0359
0360
0361
0362
0363
0364
0365 struct tcp_pcb *
0366 tcp_listen_with_backlog(struct tcp_pcb *pcb, u8_t backlog)
0367 {
0368 struct tcp_pcb_listen *lpcb;
0369
0370 LWIP_UNUSED_ARG(backlog);
0371 LWIP_ERROR("tcp_listen: pcb already connected", pcb->state == CLOSED, return NULL);
0372
0373
0374 if (pcb->state == LISTEN) {
0375 return pcb;
0376 }
0377 lpcb = memp_malloc(MEMP_TCP_PCB_LISTEN);
0378 if (lpcb == NULL) {
0379 return NULL;
0380 }
0381 lpcb->callback_arg = pcb->callback_arg;
0382 lpcb->local_port = pcb->local_port;
0383 lpcb->state = LISTEN;
0384 lpcb->so_options = pcb->so_options;
0385 lpcb->so_options |= SOF_ACCEPTCONN;
0386 lpcb->ttl = pcb->ttl;
0387 lpcb->tos = pcb->tos;
0388 ip_addr_set(&lpcb->local_ip, &pcb->local_ip);
0389 TCP_RMV(&tcp_bound_pcbs, pcb);
0390 memp_free(MEMP_TCP_PCB, pcb);
0391 #if LWIP_CALLBACK_API
0392 lpcb->accept = tcp_accept_null;
0393 #endif
0394 #if TCP_LISTEN_BACKLOG
0395 lpcb->accepts_pending = 0;
0396 lpcb->backlog = (backlog ? backlog : 1);
0397 #endif
0398 TCP_REG(&tcp_listen_pcbs.listen_pcbs, lpcb);
0399 return (struct tcp_pcb *)lpcb;
0400 }
0401
0402
0403
0404
0405
0406
0407
0408 u32_t tcp_update_rcv_ann_wnd(struct tcp_pcb *pcb)
0409 {
0410 u32_t new_right_edge = pcb->rcv_nxt + pcb->rcv_wnd;
0411
0412 if (TCP_SEQ_GEQ(new_right_edge, pcb->rcv_ann_right_edge + LWIP_MIN((TCP_WND / 2), pcb->mss))) {
0413
0414 pcb->rcv_ann_wnd = pcb->rcv_wnd;
0415 return new_right_edge - pcb->rcv_ann_right_edge;
0416 } else {
0417 if (TCP_SEQ_GT(pcb->rcv_nxt, pcb->rcv_ann_right_edge)) {
0418
0419
0420 pcb->rcv_ann_wnd = 0;
0421 } else {
0422
0423 pcb->rcv_ann_wnd = pcb->rcv_ann_right_edge - pcb->rcv_nxt;
0424 }
0425 return 0;
0426 }
0427 }
0428
0429
0430
0431
0432
0433
0434
0435
0436
0437 void
0438 tcp_recved(struct tcp_pcb *pcb, u16_t len)
0439 {
0440 int wnd_inflation;
0441
0442 LWIP_ASSERT("tcp_recved: len would wrap rcv_wnd\n",
0443 len <= 0xffff - pcb->rcv_wnd );
0444
0445 pcb->rcv_wnd += len;
0446 if (pcb->rcv_wnd > TCP_WND)
0447 pcb->rcv_wnd = TCP_WND;
0448
0449 wnd_inflation = tcp_update_rcv_ann_wnd(pcb);
0450
0451
0452
0453
0454
0455 if (wnd_inflation >= TCP_WND_UPDATE_THRESHOLD)
0456 tcp_ack_now(pcb);
0457
0458 LWIP_DEBUGF(TCP_DEBUG, ("tcp_recved: recveived %"U16_F" bytes, wnd %"U16_F" (%"U16_F").\n",
0459 len, pcb->rcv_wnd, TCP_WND - pcb->rcv_wnd));
0460 }
0461
0462
0463
0464
0465
0466
0467
0468 static u16_t
0469 tcp_new_port(void)
0470 {
0471 struct tcp_pcb *pcb;
0472 #ifndef TCP_LOCAL_PORT_RANGE_START
0473 #define TCP_LOCAL_PORT_RANGE_START 4096
0474 #define TCP_LOCAL_PORT_RANGE_END 0x7fff
0475 #endif
0476 static u16_t port = TCP_LOCAL_PORT_RANGE_START;
0477
0478 again:
0479 if (++port > TCP_LOCAL_PORT_RANGE_END) {
0480 port = TCP_LOCAL_PORT_RANGE_START;
0481 }
0482
0483 for(pcb = tcp_active_pcbs; pcb != NULL; pcb = pcb->next) {
0484 if (pcb->local_port == port) {
0485 goto again;
0486 }
0487 }
0488 for(pcb = tcp_tw_pcbs; pcb != NULL; pcb = pcb->next) {
0489 if (pcb->local_port == port) {
0490 goto again;
0491 }
0492 }
0493 for(pcb = (struct tcp_pcb *)tcp_listen_pcbs.pcbs; pcb != NULL; pcb = pcb->next) {
0494 if (pcb->local_port == port) {
0495 goto again;
0496 }
0497 }
0498 return port;
0499 }
0500
0501
0502
0503
0504
0505
0506
0507
0508
0509
0510
0511
0512
0513 err_t
0514 tcp_connect(struct tcp_pcb *pcb, struct ip_addr *ipaddr, u16_t port,
0515 err_t (* connected)(void *arg, struct tcp_pcb *tpcb, err_t err))
0516 {
0517 err_t ret;
0518 u32_t iss;
0519
0520 LWIP_ERROR("tcp_connect: can only connected from state CLOSED", pcb->state == CLOSED, return ERR_ISCONN);
0521
0522 LWIP_DEBUGF(TCP_DEBUG, ("tcp_connect to port %"U16_F"\n", port));
0523 if (ipaddr != NULL) {
0524 pcb->remote_ip = *ipaddr;
0525 } else {
0526 return ERR_VAL;
0527 }
0528 pcb->remote_port = port;
0529 if (pcb->local_port == 0) {
0530 pcb->local_port = tcp_new_port();
0531 }
0532 iss = tcp_next_iss();
0533 pcb->rcv_nxt = 0;
0534 pcb->snd_nxt = iss;
0535 pcb->lastack = iss - 1;
0536 pcb->snd_lbb = iss - 1;
0537 pcb->rcv_wnd = TCP_WND;
0538 pcb->rcv_ann_wnd = TCP_WND;
0539 pcb->rcv_ann_right_edge = pcb->rcv_nxt;
0540 pcb->snd_wnd = TCP_WND;
0541
0542
0543 pcb->mss = (TCP_MSS > 536) ? 536 : TCP_MSS;
0544 #if TCP_CALCULATE_EFF_SEND_MSS
0545 pcb->mss = tcp_eff_send_mss(pcb->mss, ipaddr);
0546 #endif
0547 pcb->cwnd = 1;
0548 pcb->ssthresh = pcb->mss * 10;
0549 pcb->state = SYN_SENT;
0550 #if LWIP_CALLBACK_API
0551 pcb->connected = connected;
0552 #endif
0553 TCP_RMV(&tcp_bound_pcbs, pcb);
0554 TCP_REG(&tcp_active_pcbs, pcb);
0555
0556 snmp_inc_tcpactiveopens();
0557
0558 ret = tcp_enqueue(pcb, NULL, 0, TCP_SYN, 0, TF_SEG_OPTS_MSS
0559 #if LWIP_TCP_TIMESTAMPS
0560 | TF_SEG_OPTS_TS
0561 #endif
0562 );
0563 if (ret == ERR_OK) {
0564 tcp_output(pcb);
0565 }
0566 return ret;
0567 }
0568
0569
0570
0571
0572
0573
0574
0575
0576 void
0577 tcp_slowtmr(void)
0578 {
0579 struct tcp_pcb *pcb, *pcb2, *prev;
0580 u16_t eff_wnd;
0581 u8_t pcb_remove;
0582 u8_t pcb_reset;
0583 err_t err;
0584
0585 err = ERR_OK;
0586
0587 ++tcp_ticks;
0588
0589
0590 prev = NULL;
0591 pcb = tcp_active_pcbs;
0592 if (pcb == NULL) {
0593 LWIP_DEBUGF(TCP_DEBUG, ("tcp_slowtmr: no active pcbs\n"));
0594 }
0595 while (pcb != NULL) {
0596 LWIP_DEBUGF(TCP_DEBUG, ("tcp_slowtmr: processing active pcb\n"));
0597 LWIP_ASSERT("tcp_slowtmr: active pcb->state != CLOSED\n", pcb->state != CLOSED);
0598 LWIP_ASSERT("tcp_slowtmr: active pcb->state != LISTEN\n", pcb->state != LISTEN);
0599 LWIP_ASSERT("tcp_slowtmr: active pcb->state != TIME-WAIT\n", pcb->state != TIME_WAIT);
0600
0601 pcb_remove = 0;
0602 pcb_reset = 0;
0603
0604 if (pcb->state == SYN_SENT && pcb->nrtx == TCP_SYNMAXRTX) {
0605 ++pcb_remove;
0606 LWIP_DEBUGF(TCP_DEBUG, ("tcp_slowtmr: max SYN retries reached\n"));
0607 }
0608 else if (pcb->nrtx == TCP_MAXRTX) {
0609 ++pcb_remove;
0610 LWIP_DEBUGF(TCP_DEBUG, ("tcp_slowtmr: max DATA retries reached\n"));
0611 } else {
0612 if (pcb->persist_backoff > 0) {
0613
0614
0615 pcb->persist_cnt++;
0616 if (pcb->persist_cnt >= tcp_persist_backoff[pcb->persist_backoff-1]) {
0617 pcb->persist_cnt = 0;
0618 if (pcb->persist_backoff < sizeof(tcp_persist_backoff)) {
0619 pcb->persist_backoff++;
0620 }
0621 tcp_zero_window_probe(pcb);
0622 }
0623 } else {
0624
0625 if(pcb->rtime >= 0)
0626 ++pcb->rtime;
0627
0628 if (pcb->unacked != NULL && pcb->rtime >= pcb->rto) {
0629
0630 LWIP_DEBUGF(TCP_RTO_DEBUG, ("tcp_slowtmr: rtime %"S16_F
0631 " pcb->rto %"S16_F"\n",
0632 pcb->rtime, pcb->rto));
0633
0634
0635
0636 if (pcb->state != SYN_SENT) {
0637 pcb->rto = ((pcb->sa >> 3) + pcb->sv) << tcp_backoff[pcb->nrtx];
0638 }
0639
0640
0641 pcb->rtime = 0;
0642
0643
0644 eff_wnd = LWIP_MIN(pcb->cwnd, pcb->snd_wnd);
0645 pcb->ssthresh = eff_wnd >> 1;
0646 if (pcb->ssthresh < pcb->mss) {
0647 pcb->ssthresh = pcb->mss * 2;
0648 }
0649 pcb->cwnd = pcb->mss;
0650 LWIP_DEBUGF(TCP_CWND_DEBUG, ("tcp_slowtmr: cwnd %"U16_F
0651 " ssthresh %"U16_F"\n",
0652 pcb->cwnd, pcb->ssthresh));
0653
0654
0655
0656 tcp_rexmit_rto(pcb);
0657 }
0658 }
0659 }
0660
0661 if (pcb->state == FIN_WAIT_2) {
0662 if ((u32_t)(tcp_ticks - pcb->tmr) >
0663 TCP_FIN_WAIT_TIMEOUT / TCP_SLOW_INTERVAL) {
0664 ++pcb_remove;
0665 LWIP_DEBUGF(TCP_DEBUG, ("tcp_slowtmr: removing pcb stuck in FIN-WAIT-2\n"));
0666 }
0667 }
0668
0669
0670 if((pcb->so_options & SOF_KEEPALIVE) &&
0671 ((pcb->state == ESTABLISHED) ||
0672 (pcb->state == CLOSE_WAIT))) {
0673 #if LWIP_TCP_KEEPALIVE
0674 if((u32_t)(tcp_ticks - pcb->tmr) >
0675 (pcb->keep_idle + (pcb->keep_cnt*pcb->keep_intvl))
0676 / TCP_SLOW_INTERVAL)
0677 #else
0678 if((u32_t)(tcp_ticks - pcb->tmr) >
0679 (pcb->keep_idle + TCP_MAXIDLE) / TCP_SLOW_INTERVAL)
0680 #endif
0681 {
0682 LWIP_DEBUGF(TCP_DEBUG, ("tcp_slowtmr: KEEPALIVE timeout. Aborting connection to %"U16_F".%"U16_F".%"U16_F".%"U16_F".\n",
0683 ip4_addr1(&pcb->remote_ip), ip4_addr2(&pcb->remote_ip),
0684 ip4_addr3(&pcb->remote_ip), ip4_addr4(&pcb->remote_ip)));
0685
0686 ++pcb_remove;
0687 ++pcb_reset;
0688 }
0689 #if LWIP_TCP_KEEPALIVE
0690 else if((u32_t)(tcp_ticks - pcb->tmr) >
0691 (pcb->keep_idle + pcb->keep_cnt_sent * pcb->keep_intvl)
0692 / TCP_SLOW_INTERVAL)
0693 #else
0694 else if((u32_t)(tcp_ticks - pcb->tmr) >
0695 (pcb->keep_idle + pcb->keep_cnt_sent * TCP_KEEPINTVL_DEFAULT)
0696 / TCP_SLOW_INTERVAL)
0697 #endif
0698 {
0699 tcp_keepalive(pcb);
0700 pcb->keep_cnt_sent++;
0701 }
0702 }
0703
0704
0705
0706
0707 #if TCP_QUEUE_OOSEQ
0708 if (pcb->ooseq != NULL &&
0709 (u32_t)tcp_ticks - pcb->tmr >= pcb->rto * TCP_OOSEQ_TIMEOUT) {
0710 tcp_segs_free(pcb->ooseq);
0711 pcb->ooseq = NULL;
0712 LWIP_DEBUGF(TCP_CWND_DEBUG, ("tcp_slowtmr: dropping OOSEQ queued data\n"));
0713 }
0714 #endif
0715
0716
0717 if (pcb->state == SYN_RCVD) {
0718 if ((u32_t)(tcp_ticks - pcb->tmr) >
0719 TCP_SYN_RCVD_TIMEOUT / TCP_SLOW_INTERVAL) {
0720 ++pcb_remove;
0721 LWIP_DEBUGF(TCP_DEBUG, ("tcp_slowtmr: removing pcb stuck in SYN-RCVD\n"));
0722 }
0723 }
0724
0725
0726 if (pcb->state == LAST_ACK) {
0727 if ((u32_t)(tcp_ticks - pcb->tmr) > 2 * TCP_MSL / TCP_SLOW_INTERVAL) {
0728 ++pcb_remove;
0729 LWIP_DEBUGF(TCP_DEBUG, ("tcp_slowtmr: removing pcb stuck in LAST-ACK\n"));
0730 }
0731 }
0732
0733
0734 if (pcb_remove) {
0735 tcp_pcb_purge(pcb);
0736
0737 if (prev != NULL) {
0738 LWIP_ASSERT("tcp_slowtmr: middle tcp != tcp_active_pcbs", pcb != tcp_active_pcbs);
0739 prev->next = pcb->next;
0740 } else {
0741
0742 LWIP_ASSERT("tcp_slowtmr: first pcb == tcp_active_pcbs", tcp_active_pcbs == pcb);
0743 tcp_active_pcbs = pcb->next;
0744 }
0745
0746 TCP_EVENT_ERR(pcb->errf, pcb->callback_arg, ERR_ABRT);
0747 if (pcb_reset) {
0748 tcp_rst(pcb->snd_nxt, pcb->rcv_nxt, &pcb->local_ip, &pcb->remote_ip,
0749 pcb->local_port, pcb->remote_port);
0750 }
0751
0752 pcb2 = pcb->next;
0753 memp_free(MEMP_TCP_PCB, pcb);
0754 pcb = pcb2;
0755 } else {
0756
0757
0758 ++pcb->polltmr;
0759 if (pcb->polltmr >= pcb->pollinterval) {
0760 pcb->polltmr = 0;
0761 LWIP_DEBUGF(TCP_DEBUG, ("tcp_slowtmr: polling application\n"));
0762 TCP_EVENT_POLL(pcb, err);
0763 if (err == ERR_OK) {
0764 tcp_output(pcb);
0765 }
0766 }
0767
0768 prev = pcb;
0769 pcb = pcb->next;
0770 }
0771 }
0772
0773
0774
0775 prev = NULL;
0776 pcb = tcp_tw_pcbs;
0777 while (pcb != NULL) {
0778 LWIP_ASSERT("tcp_slowtmr: TIME-WAIT pcb->state == TIME-WAIT", pcb->state == TIME_WAIT);
0779 pcb_remove = 0;
0780
0781
0782 if ((u32_t)(tcp_ticks - pcb->tmr) > 2 * TCP_MSL / TCP_SLOW_INTERVAL) {
0783 ++pcb_remove;
0784 }
0785
0786
0787
0788
0789 if (pcb_remove) {
0790 tcp_pcb_purge(pcb);
0791
0792 if (prev != NULL) {
0793 LWIP_ASSERT("tcp_slowtmr: middle tcp != tcp_tw_pcbs", pcb != tcp_tw_pcbs);
0794 prev->next = pcb->next;
0795 } else {
0796
0797 LWIP_ASSERT("tcp_slowtmr: first pcb == tcp_tw_pcbs", tcp_tw_pcbs == pcb);
0798 tcp_tw_pcbs = pcb->next;
0799 }
0800 pcb2 = pcb->next;
0801 memp_free(MEMP_TCP_PCB, pcb);
0802 pcb = pcb2;
0803 } else {
0804 prev = pcb;
0805 pcb = pcb->next;
0806 }
0807 }
0808 }
0809
0810
0811
0812
0813
0814
0815
0816 void
0817 tcp_fasttmr(void)
0818 {
0819 struct tcp_pcb *pcb;
0820
0821 for(pcb = tcp_active_pcbs; pcb != NULL; pcb = pcb->next) {
0822
0823 if (pcb->refused_data != NULL) {
0824
0825 err_t err;
0826 LWIP_DEBUGF(TCP_INPUT_DEBUG, ("tcp_fasttmr: notify kept packet\n"));
0827 TCP_EVENT_RECV(pcb, pcb->refused_data, ERR_OK, err);
0828 if (err == ERR_OK) {
0829 pcb->refused_data = NULL;
0830 }
0831 }
0832
0833
0834 if (pcb->flags & TF_ACK_DELAY) {
0835 LWIP_DEBUGF(TCP_DEBUG, ("tcp_fasttmr: delayed ACK\n"));
0836 tcp_ack_now(pcb);
0837 pcb->flags &= ~(TF_ACK_DELAY | TF_ACK_NOW);
0838 }
0839 }
0840 }
0841
0842
0843
0844
0845
0846
0847
0848 u8_t
0849 tcp_segs_free(struct tcp_seg *seg)
0850 {
0851 u8_t count = 0;
0852 struct tcp_seg *next;
0853 while (seg != NULL) {
0854 next = seg->next;
0855 count += tcp_seg_free(seg);
0856 seg = next;
0857 }
0858 return count;
0859 }
0860
0861
0862
0863
0864
0865
0866
0867 u8_t
0868 tcp_seg_free(struct tcp_seg *seg)
0869 {
0870 u8_t count = 0;
0871
0872 if (seg != NULL) {
0873 if (seg->p != NULL) {
0874 count = pbuf_free(seg->p);
0875 #if TCP_DEBUG
0876 seg->p = NULL;
0877 #endif
0878 }
0879 memp_free(MEMP_TCP_SEG, seg);
0880 }
0881 return count;
0882 }
0883
0884
0885
0886
0887
0888
0889
0890 void
0891 tcp_setprio(struct tcp_pcb *pcb, u8_t prio)
0892 {
0893 pcb->prio = prio;
0894 }
0895 #if TCP_QUEUE_OOSEQ
0896
0897
0898
0899
0900
0901
0902
0903
0904 struct tcp_seg *
0905 tcp_seg_copy(struct tcp_seg *seg)
0906 {
0907 struct tcp_seg *cseg;
0908
0909 cseg = memp_malloc(MEMP_TCP_SEG);
0910 if (cseg == NULL) {
0911 return NULL;
0912 }
0913 SMEMCPY((u8_t *)cseg, (const u8_t *)seg, sizeof(struct tcp_seg));
0914 pbuf_ref(cseg->p);
0915 return cseg;
0916 }
0917 #endif
0918
0919 #if LWIP_CALLBACK_API
0920
0921
0922
0923
0924 err_t
0925 tcp_recv_null(void *arg, struct tcp_pcb *pcb, struct pbuf *p, err_t err)
0926 {
0927 LWIP_UNUSED_ARG(arg);
0928 if (p != NULL) {
0929 tcp_recved(pcb, p->tot_len);
0930 pbuf_free(p);
0931 } else if (err == ERR_OK) {
0932 return tcp_close(pcb);
0933 }
0934 return ERR_OK;
0935 }
0936 #endif
0937
0938
0939
0940
0941
0942
0943 static void
0944 tcp_kill_prio(u8_t prio)
0945 {
0946 struct tcp_pcb *pcb, *inactive;
0947 u32_t inactivity;
0948 u8_t mprio;
0949
0950
0951 mprio = TCP_PRIO_MAX;
0952
0953
0954 inactivity = 0;
0955 inactive = NULL;
0956 for(pcb = tcp_active_pcbs; pcb != NULL; pcb = pcb->next) {
0957 if (pcb->prio <= prio &&
0958 pcb->prio <= mprio &&
0959 (u32_t)(tcp_ticks - pcb->tmr) >= inactivity) {
0960 inactivity = tcp_ticks - pcb->tmr;
0961 inactive = pcb;
0962 mprio = pcb->prio;
0963 }
0964 }
0965 if (inactive != NULL) {
0966 LWIP_DEBUGF(TCP_DEBUG, ("tcp_kill_prio: killing oldest PCB %p (%"S32_F")\n",
0967 (void *)inactive, inactivity));
0968 tcp_abort(inactive);
0969 }
0970 }
0971
0972
0973
0974
0975
0976 static void
0977 tcp_kill_timewait(void)
0978 {
0979 struct tcp_pcb *pcb, *inactive;
0980 u32_t inactivity;
0981
0982 inactivity = 0;
0983 inactive = NULL;
0984
0985 for(pcb = tcp_tw_pcbs; pcb != NULL; pcb = pcb->next) {
0986 if ((u32_t)(tcp_ticks - pcb->tmr) >= inactivity) {
0987 inactivity = tcp_ticks - pcb->tmr;
0988 inactive = pcb;
0989 }
0990 }
0991 if (inactive != NULL) {
0992 LWIP_DEBUGF(TCP_DEBUG, ("tcp_kill_timewait: killing oldest TIME-WAIT PCB %p (%"S32_F")\n",
0993 (void *)inactive, inactivity));
0994 tcp_abort(inactive);
0995 }
0996 }
0997
0998
0999
1000
1001
1002
1003
1004 struct tcp_pcb *
1005 tcp_alloc(u8_t prio)
1006 {
1007 struct tcp_pcb *pcb;
1008 u32_t iss;
1009
1010 pcb = memp_malloc(MEMP_TCP_PCB);
1011 if (pcb == NULL) {
1012
1013 LWIP_DEBUGF(TCP_DEBUG, ("tcp_alloc: killing off oldest TIME-WAIT connection\n"));
1014 tcp_kill_timewait();
1015
1016 pcb = memp_malloc(MEMP_TCP_PCB);
1017 if (pcb == NULL) {
1018
1019 LWIP_DEBUGF(TCP_DEBUG, ("tcp_alloc: killing connection with prio lower than %d\n", prio));
1020 tcp_kill_prio(prio);
1021
1022 pcb = memp_malloc(MEMP_TCP_PCB);
1023 if (pcb != NULL) {
1024
1025 MEMP_STATS_DEC(err, MEMP_TCP_PCB);
1026 }
1027 }
1028 if (pcb != NULL) {
1029
1030 MEMP_STATS_DEC(err, MEMP_TCP_PCB);
1031 }
1032 }
1033 if (pcb != NULL) {
1034 memset(pcb, 0, sizeof(struct tcp_pcb));
1035 pcb->prio = TCP_PRIO_NORMAL;
1036 pcb->snd_buf = TCP_SND_BUF;
1037 pcb->snd_queuelen = 0;
1038 pcb->rcv_wnd = TCP_WND;
1039 pcb->rcv_ann_wnd = TCP_WND;
1040 pcb->tos = 0;
1041 pcb->ttl = TCP_TTL;
1042
1043
1044 pcb->mss = (TCP_MSS > 536) ? 536 : TCP_MSS;
1045 pcb->rto = 3000 / TCP_SLOW_INTERVAL;
1046 pcb->sa = 0;
1047 pcb->sv = 3000 / TCP_SLOW_INTERVAL;
1048 pcb->rtime = -1;
1049 pcb->cwnd = 1;
1050 iss = tcp_next_iss();
1051 pcb->snd_wl2 = iss;
1052 pcb->snd_nxt = iss;
1053 pcb->lastack = iss;
1054 pcb->snd_lbb = iss;
1055 pcb->tmr = tcp_ticks;
1056
1057 pcb->polltmr = 0;
1058
1059 #if LWIP_CALLBACK_API
1060 pcb->recv = tcp_recv_null;
1061 #endif
1062
1063
1064 pcb->keep_idle = TCP_KEEPIDLE_DEFAULT;
1065
1066 #if LWIP_TCP_KEEPALIVE
1067 pcb->keep_intvl = TCP_KEEPINTVL_DEFAULT;
1068 pcb->keep_cnt = TCP_KEEPCNT_DEFAULT;
1069 #endif
1070
1071 pcb->keep_cnt_sent = 0;
1072 }
1073 return pcb;
1074 }
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088 struct tcp_pcb *
1089 tcp_new(void)
1090 {
1091 return tcp_alloc(TCP_PRIO_NORMAL);
1092 }
1093
1094
1095
1096
1097
1098
1099
1100
1101 void
1102 tcp_arg(struct tcp_pcb *pcb, void *arg)
1103 {
1104 pcb->callback_arg = arg;
1105 }
1106 #if LWIP_CALLBACK_API
1107
1108
1109
1110
1111
1112
1113
1114
1115 void
1116 tcp_recv(struct tcp_pcb *pcb,
1117 err_t (* recv)(void *arg, struct tcp_pcb *tpcb, struct pbuf *p, err_t err))
1118 {
1119 pcb->recv = recv;
1120 }
1121
1122
1123
1124
1125
1126
1127
1128
1129 void
1130 tcp_sent(struct tcp_pcb *pcb,
1131 err_t (* sent)(void *arg, struct tcp_pcb *tpcb, u16_t len))
1132 {
1133 pcb->sent = sent;
1134 }
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144 void
1145 tcp_err(struct tcp_pcb *pcb,
1146 void (* errf)(void *arg, err_t err))
1147 {
1148 pcb->errf = errf;
1149 }
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159 void
1160 tcp_accept(struct tcp_pcb *pcb,
1161 err_t (* accept)(void *arg, struct tcp_pcb *newpcb, err_t err))
1162 {
1163 pcb->accept = accept;
1164 }
1165 #endif
1166
1167
1168
1169
1170
1171
1172
1173
1174 void
1175 tcp_poll(struct tcp_pcb *pcb,
1176 err_t (* poll)(void *arg, struct tcp_pcb *tpcb), u8_t interval)
1177 {
1178 #if LWIP_CALLBACK_API
1179 pcb->poll = poll;
1180 #endif
1181 pcb->pollinterval = interval;
1182 }
1183
1184
1185
1186
1187
1188
1189
1190 void
1191 tcp_pcb_purge(struct tcp_pcb *pcb)
1192 {
1193 if (pcb->state != CLOSED &&
1194 pcb->state != TIME_WAIT &&
1195 pcb->state != LISTEN) {
1196
1197 LWIP_DEBUGF(TCP_DEBUG, ("tcp_pcb_purge\n"));
1198
1199 #if TCP_LISTEN_BACKLOG
1200 if (pcb->state == SYN_RCVD) {
1201
1202 struct tcp_pcb_listen *lpcb;
1203 LWIP_ASSERT("tcp_pcb_purge: pcb->state == SYN_RCVD but tcp_listen_pcbs is NULL",
1204 tcp_listen_pcbs.listen_pcbs != NULL);
1205 for (lpcb = tcp_listen_pcbs.listen_pcbs; lpcb != NULL; lpcb = lpcb->next) {
1206 if ((lpcb->local_port == pcb->local_port) &&
1207 (ip_addr_isany(&lpcb->local_ip) ||
1208 ip_addr_cmp(&pcb->local_ip, &lpcb->local_ip))) {
1209
1210 LWIP_ASSERT("tcp_pcb_purge: listen pcb does not have accepts pending",
1211 lpcb->accepts_pending > 0);
1212 lpcb->accepts_pending--;
1213 break;
1214 }
1215 }
1216 }
1217 #endif
1218
1219
1220 if (pcb->refused_data != NULL) {
1221 LWIP_DEBUGF(TCP_DEBUG, ("tcp_pcb_purge: data left on ->refused_data\n"));
1222 pbuf_free(pcb->refused_data);
1223 pcb->refused_data = NULL;
1224 }
1225 if (pcb->unsent != NULL) {
1226 LWIP_DEBUGF(TCP_DEBUG, ("tcp_pcb_purge: not all data sent\n"));
1227 }
1228 if (pcb->unacked != NULL) {
1229 LWIP_DEBUGF(TCP_DEBUG, ("tcp_pcb_purge: data left on ->unacked\n"));
1230 }
1231 #if TCP_QUEUE_OOSEQ
1232 if (pcb->ooseq != NULL) {
1233 LWIP_DEBUGF(TCP_DEBUG, ("tcp_pcb_purge: data left on ->ooseq\n"));
1234 }
1235
1236
1237
1238 pcb->rtime = -1;
1239
1240 tcp_segs_free(pcb->ooseq);
1241 pcb->ooseq = NULL;
1242 #endif
1243 tcp_segs_free(pcb->unsent);
1244 tcp_segs_free(pcb->unacked);
1245 pcb->unacked = pcb->unsent = NULL;
1246 }
1247 }
1248
1249
1250
1251
1252
1253
1254
1255 void
1256 tcp_pcb_remove(struct tcp_pcb **pcblist, struct tcp_pcb *pcb)
1257 {
1258 TCP_RMV(pcblist, pcb);
1259
1260 tcp_pcb_purge(pcb);
1261
1262
1263 if (pcb->state != TIME_WAIT &&
1264 pcb->state != LISTEN &&
1265 pcb->flags & TF_ACK_DELAY) {
1266 pcb->flags |= TF_ACK_NOW;
1267 tcp_output(pcb);
1268 }
1269
1270 if (pcb->state != LISTEN) {
1271 LWIP_ASSERT("unsent segments leaking", pcb->unsent == NULL);
1272 LWIP_ASSERT("unacked segments leaking", pcb->unacked == NULL);
1273 #if TCP_QUEUE_OOSEQ
1274 LWIP_ASSERT("ooseq segments leaking", pcb->ooseq == NULL);
1275 #endif
1276 }
1277
1278 pcb->state = CLOSED;
1279
1280 LWIP_ASSERT("tcp_pcb_remove: tcp_pcbs_sane()", tcp_pcbs_sane());
1281 }
1282
1283
1284
1285
1286
1287
1288 u32_t
1289 tcp_next_iss(void)
1290 {
1291 static u32_t iss = 6510;
1292
1293 iss += tcp_ticks;
1294 return iss;
1295 }
1296
1297 #if TCP_CALCULATE_EFF_SEND_MSS
1298
1299
1300
1301
1302
1303 u16_t
1304 tcp_eff_send_mss(u16_t sendmss, struct ip_addr *addr)
1305 {
1306 u16_t mss_s;
1307 struct netif *outif;
1308
1309 outif = ip_route(addr);
1310 if ((outif != NULL) && (outif->mtu != 0)) {
1311 mss_s = outif->mtu - IP_HLEN - TCP_HLEN;
1312
1313
1314
1315
1316
1317 sendmss = LWIP_MIN(sendmss, mss_s);
1318 }
1319 return sendmss;
1320 }
1321 #endif
1322
1323 const char*
1324 tcp_debug_state_str(enum tcp_state s)
1325 {
1326 return tcp_state_str[s];
1327 }
1328
1329 #if TCP_DEBUG || TCP_INPUT_DEBUG || TCP_OUTPUT_DEBUG
1330
1331
1332
1333
1334
1335 void
1336 tcp_debug_print(struct tcp_hdr *tcphdr)
1337 {
1338 LWIP_DEBUGF(TCP_DEBUG, ("TCP header:\n"));
1339 LWIP_DEBUGF(TCP_DEBUG, ("+-------------------------------+\n"));
1340 LWIP_DEBUGF(TCP_DEBUG, ("| %5"U16_F" | %5"U16_F" | (src port, dest port)\n",
1341 ntohs(tcphdr->src), ntohs(tcphdr->dest)));
1342 LWIP_DEBUGF(TCP_DEBUG, ("+-------------------------------+\n"));
1343 LWIP_DEBUGF(TCP_DEBUG, ("| %010"U32_F" | (seq no)\n",
1344 ntohl(tcphdr->seqno)));
1345 LWIP_DEBUGF(TCP_DEBUG, ("+-------------------------------+\n"));
1346 LWIP_DEBUGF(TCP_DEBUG, ("| %010"U32_F" | (ack no)\n",
1347 ntohl(tcphdr->ackno)));
1348 LWIP_DEBUGF(TCP_DEBUG, ("+-------------------------------+\n"));
1349 LWIP_DEBUGF(TCP_DEBUG, ("| %2"U16_F" | |%"U16_F"%"U16_F"%"U16_F"%"U16_F"%"U16_F"%"U16_F"| %5"U16_F" | (hdrlen, flags (",
1350 TCPH_HDRLEN(tcphdr),
1351 TCPH_FLAGS(tcphdr) >> 5 & 1,
1352 TCPH_FLAGS(tcphdr) >> 4 & 1,
1353 TCPH_FLAGS(tcphdr) >> 3 & 1,
1354 TCPH_FLAGS(tcphdr) >> 2 & 1,
1355 TCPH_FLAGS(tcphdr) >> 1 & 1,
1356 TCPH_FLAGS(tcphdr) & 1,
1357 ntohs(tcphdr->wnd)));
1358 tcp_debug_print_flags(TCPH_FLAGS(tcphdr));
1359 LWIP_DEBUGF(TCP_DEBUG, ("), win)\n"));
1360 LWIP_DEBUGF(TCP_DEBUG, ("+-------------------------------+\n"));
1361 LWIP_DEBUGF(TCP_DEBUG, ("| 0x%04"X16_F" | %5"U16_F" | (chksum, urgp)\n",
1362 ntohs(tcphdr->chksum), ntohs(tcphdr->urgp)));
1363 LWIP_DEBUGF(TCP_DEBUG, ("+-------------------------------+\n"));
1364 }
1365
1366
1367
1368
1369
1370
1371 void
1372 tcp_debug_print_state(enum tcp_state s)
1373 {
1374 LWIP_DEBUGF(TCP_DEBUG, ("State: %s\n", tcp_state_str[s]));
1375 }
1376
1377
1378
1379
1380
1381
1382 void
1383 tcp_debug_print_flags(u8_t flags)
1384 {
1385 if (flags & TCP_FIN) {
1386 LWIP_DEBUGF(TCP_DEBUG, ("FIN "));
1387 }
1388 if (flags & TCP_SYN) {
1389 LWIP_DEBUGF(TCP_DEBUG, ("SYN "));
1390 }
1391 if (flags & TCP_RST) {
1392 LWIP_DEBUGF(TCP_DEBUG, ("RST "));
1393 }
1394 if (flags & TCP_PSH) {
1395 LWIP_DEBUGF(TCP_DEBUG, ("PSH "));
1396 }
1397 if (flags & TCP_ACK) {
1398 LWIP_DEBUGF(TCP_DEBUG, ("ACK "));
1399 }
1400 if (flags & TCP_URG) {
1401 LWIP_DEBUGF(TCP_DEBUG, ("URG "));
1402 }
1403 if (flags & TCP_ECE) {
1404 LWIP_DEBUGF(TCP_DEBUG, ("ECE "));
1405 }
1406 if (flags & TCP_CWR) {
1407 LWIP_DEBUGF(TCP_DEBUG, ("CWR "));
1408 }
1409 LWIP_DEBUGF(TCP_DEBUG, ("\n"));
1410 }
1411
1412
1413
1414
1415 void
1416 tcp_debug_print_pcbs(void)
1417 {
1418 struct tcp_pcb *pcb;
1419 LWIP_DEBUGF(TCP_DEBUG, ("Active PCB states:\n"));
1420 for(pcb = tcp_active_pcbs; pcb != NULL; pcb = pcb->next) {
1421 LWIP_DEBUGF(TCP_DEBUG, ("Local port %"U16_F", foreign port %"U16_F" snd_nxt %"U32_F" rcv_nxt %"U32_F" ",
1422 pcb->local_port, pcb->remote_port,
1423 pcb->snd_nxt, pcb->rcv_nxt));
1424 tcp_debug_print_state(pcb->state);
1425 }
1426 LWIP_DEBUGF(TCP_DEBUG, ("Listen PCB states:\n"));
1427 for(pcb = (struct tcp_pcb *)tcp_listen_pcbs.pcbs; pcb != NULL; pcb = pcb->next) {
1428 LWIP_DEBUGF(TCP_DEBUG, ("Local port %"U16_F", foreign port %"U16_F" snd_nxt %"U32_F" rcv_nxt %"U32_F" ",
1429 pcb->local_port, pcb->remote_port,
1430 pcb->snd_nxt, pcb->rcv_nxt));
1431 tcp_debug_print_state(pcb->state);
1432 }
1433 LWIP_DEBUGF(TCP_DEBUG, ("TIME-WAIT PCB states:\n"));
1434 for(pcb = tcp_tw_pcbs; pcb != NULL; pcb = pcb->next) {
1435 LWIP_DEBUGF(TCP_DEBUG, ("Local port %"U16_F", foreign port %"U16_F" snd_nxt %"U32_F" rcv_nxt %"U32_F" ",
1436 pcb->local_port, pcb->remote_port,
1437 pcb->snd_nxt, pcb->rcv_nxt));
1438 tcp_debug_print_state(pcb->state);
1439 }
1440 }
1441
1442
1443
1444
1445 s16_t
1446 tcp_pcbs_sane(void)
1447 {
1448 struct tcp_pcb *pcb;
1449 for(pcb = tcp_active_pcbs; pcb != NULL; pcb = pcb->next) {
1450 LWIP_ASSERT("tcp_pcbs_sane: active pcb->state != CLOSED", pcb->state != CLOSED);
1451 LWIP_ASSERT("tcp_pcbs_sane: active pcb->state != LISTEN", pcb->state != LISTEN);
1452 LWIP_ASSERT("tcp_pcbs_sane: active pcb->state != TIME-WAIT", pcb->state != TIME_WAIT);
1453 }
1454 for(pcb = tcp_tw_pcbs; pcb != NULL; pcb = pcb->next) {
1455 LWIP_ASSERT("tcp_pcbs_sane: tw pcb->state == TIME-WAIT", pcb->state == TIME_WAIT);
1456 }
1457 return 1;
1458 }
1459 #endif
1460
1461 #endif