User | Revision | Line number | New contents of line |
mbed714 |
0:d616ece2d859
|
1
|
/**
|
mbed714 |
0:d616ece2d859
|
2
|
* @file
|
mbed714 |
0:d616ece2d859
|
3
|
* Transmission Control Protocol, incoming traffic
|
mbed714 |
0:d616ece2d859
|
4
|
*
|
mbed714 |
0:d616ece2d859
|
5
|
* The input processing functions of the TCP layer.
|
mbed714 |
0:d616ece2d859
|
6
|
*
|
mbed714 |
0:d616ece2d859
|
7
|
* These functions are generally called in the order (ip_input() ->)
|
mbed714 |
0:d616ece2d859
|
8
|
* tcp_input() -> * tcp_process() -> tcp_receive() (-> application).
|
mbed714 |
0:d616ece2d859
|
9
|
*
|
mbed714 |
0:d616ece2d859
|
10
|
*/
|
mbed714 |
0:d616ece2d859
|
11
|
|
mbed714 |
0:d616ece2d859
|
12
|
/*
|
mbed714 |
0:d616ece2d859
|
13
|
* Copyright (c) 2001-2004 Swedish Institute of Computer Science.
|
mbed714 |
0:d616ece2d859
|
14
|
* All rights reserved.
|
mbed714 |
0:d616ece2d859
|
15
|
*
|
mbed714 |
0:d616ece2d859
|
16
|
* Redistribution and use in source and binary forms, with or without modification,
|
mbed714 |
0:d616ece2d859
|
17
|
* are permitted provided that the following conditions are met:
|
mbed714 |
0:d616ece2d859
|
18
|
*
|
mbed714 |
0:d616ece2d859
|
19
|
* 1. Redistributions of source code must retain the above copyright notice,
|
mbed714 |
0:d616ece2d859
|
20
|
* this list of conditions and the following disclaimer.
|
mbed714 |
0:d616ece2d859
|
21
|
* 2. Redistributions in binary form must reproduce the above copyright notice,
|
mbed714 |
0:d616ece2d859
|
22
|
* this list of conditions and the following disclaimer in the documentation
|
mbed714 |
0:d616ece2d859
|
23
|
* and/or other materials provided with the distribution.
|
mbed714 |
0:d616ece2d859
|
24
|
* 3. The name of the author may not be used to endorse or promote products
|
mbed714 |
0:d616ece2d859
|
25
|
* derived from this software without specific prior written permission.
|
mbed714 |
0:d616ece2d859
|
26
|
*
|
mbed714 |
0:d616ece2d859
|
27
|
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
|
mbed714 |
0:d616ece2d859
|
28
|
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
|
mbed714 |
0:d616ece2d859
|
29
|
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
|
mbed714 |
0:d616ece2d859
|
30
|
* SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
|
mbed714 |
0:d616ece2d859
|
31
|
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
|
mbed714 |
0:d616ece2d859
|
32
|
* OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
mbed714 |
0:d616ece2d859
|
33
|
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
mbed714 |
0:d616ece2d859
|
34
|
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
|
mbed714 |
0:d616ece2d859
|
35
|
* IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
|
mbed714 |
0:d616ece2d859
|
36
|
* OF SUCH DAMAGE.
|
mbed714 |
0:d616ece2d859
|
37
|
*
|
mbed714 |
0:d616ece2d859
|
38
|
* This file is part of the lwIP TCP/IP stack.
|
mbed714 |
0:d616ece2d859
|
39
|
*
|
mbed714 |
0:d616ece2d859
|
40
|
* Author: Adam Dunkels <adam@sics.se>
|
mbed714 |
0:d616ece2d859
|
41
|
*
|
mbed714 |
0:d616ece2d859
|
42
|
*/
|
mbed714 |
0:d616ece2d859
|
43
|
|
mbed714 |
0:d616ece2d859
|
44
|
#include "lwip/opt.h"
|
mbed714 |
0:d616ece2d859
|
45
|
|
mbed714 |
0:d616ece2d859
|
46
|
#if LWIP_TCP /* don't build if not configured for use in lwipopts.h */
|
mbed714 |
0:d616ece2d859
|
47
|
|
mbed714 |
0:d616ece2d859
|
48
|
#include "lwip/tcp_impl.h"
|
mbed714 |
0:d616ece2d859
|
49
|
#include "lwip/def.h"
|
mbed714 |
0:d616ece2d859
|
50
|
#include "lwip/ip_addr.h"
|
mbed714 |
0:d616ece2d859
|
51
|
#include "lwip/netif.h"
|
mbed714 |
0:d616ece2d859
|
52
|
#include "lwip/mem.h"
|
mbed714 |
0:d616ece2d859
|
53
|
#include "lwip/memp.h"
|
mbed714 |
0:d616ece2d859
|
54
|
#include "lwip/inet_chksum.h"
|
mbed714 |
0:d616ece2d859
|
55
|
#include "lwip/stats.h"
|
mbed714 |
0:d616ece2d859
|
56
|
#include "lwip/snmp.h"
|
mbed714 |
0:d616ece2d859
|
57
|
#include "arch/perf.h"
|
mbed714 |
0:d616ece2d859
|
58
|
|
mbed714 |
0:d616ece2d859
|
59
|
/* These variables are global to all functions involved in the input
|
mbed714 |
0:d616ece2d859
|
60
|
processing of TCP segments. They are set by the tcp_input()
|
mbed714 |
0:d616ece2d859
|
61
|
function. */
|
mbed714 |
0:d616ece2d859
|
62
|
static struct tcp_seg inseg;
|
mbed714 |
0:d616ece2d859
|
63
|
static struct tcp_hdr *tcphdr;
|
mbed714 |
0:d616ece2d859
|
64
|
static struct ip_hdr *iphdr;
|
mbed714 |
0:d616ece2d859
|
65
|
static u32_t seqno, ackno;
|
mbed714 |
0:d616ece2d859
|
66
|
static u8_t flags;
|
mbed714 |
0:d616ece2d859
|
67
|
static u16_t tcplen;
|
mbed714 |
0:d616ece2d859
|
68
|
|
mbed714 |
0:d616ece2d859
|
69
|
static u8_t recv_flags;
|
mbed714 |
0:d616ece2d859
|
70
|
static struct pbuf *recv_data;
|
mbed714 |
0:d616ece2d859
|
71
|
|
mbed714 |
0:d616ece2d859
|
72
|
struct tcp_pcb *tcp_input_pcb;
|
mbed714 |
0:d616ece2d859
|
73
|
|
mbed714 |
0:d616ece2d859
|
74
|
/* Forward declarations. */
|
mbed714 |
0:d616ece2d859
|
75
|
static err_t tcp_process(struct tcp_pcb *pcb);
|
mbed714 |
0:d616ece2d859
|
76
|
static void tcp_receive(struct tcp_pcb *pcb);
|
mbed714 |
0:d616ece2d859
|
77
|
static void tcp_parseopt(struct tcp_pcb *pcb);
|
mbed714 |
0:d616ece2d859
|
78
|
|
mbed714 |
0:d616ece2d859
|
79
|
static err_t tcp_listen_input(struct tcp_pcb_listen *pcb);
|
mbed714 |
0:d616ece2d859
|
80
|
static err_t tcp_timewait_input(struct tcp_pcb *pcb);
|
mbed714 |
0:d616ece2d859
|
81
|
|
mbed714 |
0:d616ece2d859
|
82
|
/**
|
mbed714 |
0:d616ece2d859
|
83
|
* The initial input processing of TCP. It verifies the TCP header, demultiplexes
|
mbed714 |
0:d616ece2d859
|
84
|
* the segment between the PCBs and passes it on to tcp_process(), which implements
|
mbed714 |
0:d616ece2d859
|
85
|
* the TCP finite state machine. This function is called by the IP layer (in
|
mbed714 |
0:d616ece2d859
|
86
|
* ip_input()).
|
mbed714 |
0:d616ece2d859
|
87
|
*
|
mbed714 |
0:d616ece2d859
|
88
|
* @param p received TCP segment to process (p->payload pointing to the IP header)
|
mbed714 |
0:d616ece2d859
|
89
|
* @param inp network interface on which this segment was received
|
mbed714 |
0:d616ece2d859
|
90
|
*/
|
mbed714 |
0:d616ece2d859
|
91
|
void
|
mbed714 |
0:d616ece2d859
|
92
|
tcp_input(struct pbuf *p, struct netif *inp)
|
mbed714 |
0:d616ece2d859
|
93
|
{
|
mbed714 |
0:d616ece2d859
|
94
|
struct tcp_pcb *pcb, *prev;
|
mbed714 |
0:d616ece2d859
|
95
|
struct tcp_pcb_listen *lpcb;
|
mbed714 |
0:d616ece2d859
|
96
|
#if SO_REUSE
|
mbed714 |
0:d616ece2d859
|
97
|
struct tcp_pcb *lpcb_prev = NULL;
|
mbed714 |
0:d616ece2d859
|
98
|
struct tcp_pcb_listen *lpcb_any = NULL;
|
mbed714 |
0:d616ece2d859
|
99
|
#endif /* SO_REUSE */
|
mbed714 |
0:d616ece2d859
|
100
|
u8_t hdrlen;
|
mbed714 |
0:d616ece2d859
|
101
|
err_t err;
|
mbed714 |
0:d616ece2d859
|
102
|
|
mbed714 |
0:d616ece2d859
|
103
|
PERF_START;
|
mbed714 |
0:d616ece2d859
|
104
|
|
mbed714 |
0:d616ece2d859
|
105
|
TCP_STATS_INC(tcp.recv);
|
mbed714 |
0:d616ece2d859
|
106
|
snmp_inc_tcpinsegs();
|
mbed714 |
0:d616ece2d859
|
107
|
|
mbed714 |
0:d616ece2d859
|
108
|
iphdr = (struct ip_hdr *)p->payload;
|
mbed714 |
0:d616ece2d859
|
109
|
tcphdr = (struct tcp_hdr *)((u8_t *)p->payload + IPH_HL(iphdr) * 4);
|
mbed714 |
0:d616ece2d859
|
110
|
|
mbed714 |
0:d616ece2d859
|
111
|
#if TCP_INPUT_DEBUG
|
mbed714 |
0:d616ece2d859
|
112
|
tcp_debug_print(tcphdr);
|
mbed714 |
0:d616ece2d859
|
113
|
#endif
|
mbed714 |
0:d616ece2d859
|
114
|
|
mbed714 |
0:d616ece2d859
|
115
|
/* remove header from payload */
|
mbed714 |
0:d616ece2d859
|
116
|
if (pbuf_header(p, -((s16_t)(IPH_HL(iphdr) * 4))) || (p->tot_len < sizeof(struct tcp_hdr))) {
|
mbed714 |
0:d616ece2d859
|
117
|
/* drop short packets */
|
mbed714 |
0:d616ece2d859
|
118
|
LWIP_DEBUGF(TCP_INPUT_DEBUG, ("tcp_input: short packet (%"U16_F" bytes) discarded\n", p->tot_len));
|
mbed714 |
0:d616ece2d859
|
119
|
TCP_STATS_INC(tcp.lenerr);
|
mbed714 |
0:d616ece2d859
|
120
|
TCP_STATS_INC(tcp.drop);
|
mbed714 |
0:d616ece2d859
|
121
|
snmp_inc_tcpinerrs();
|
mbed714 |
0:d616ece2d859
|
122
|
pbuf_free(p);
|
mbed714 |
0:d616ece2d859
|
123
|
return;
|
mbed714 |
0:d616ece2d859
|
124
|
}
|
mbed714 |
0:d616ece2d859
|
125
|
|
mbed714 |
0:d616ece2d859
|
126
|
/* Don't even process incoming broadcasts/multicasts. */
|
mbed714 |
0:d616ece2d859
|
127
|
if (ip_addr_isbroadcast(¤t_iphdr_dest, inp) ||
|
mbed714 |
0:d616ece2d859
|
128
|
ip_addr_ismulticast(¤t_iphdr_dest)) {
|
mbed714 |
0:d616ece2d859
|
129
|
TCP_STATS_INC(tcp.proterr);
|
mbed714 |
0:d616ece2d859
|
130
|
TCP_STATS_INC(tcp.drop);
|
mbed714 |
0:d616ece2d859
|
131
|
snmp_inc_tcpinerrs();
|
mbed714 |
0:d616ece2d859
|
132
|
pbuf_free(p);
|
mbed714 |
0:d616ece2d859
|
133
|
return;
|
mbed714 |
0:d616ece2d859
|
134
|
}
|
mbed714 |
0:d616ece2d859
|
135
|
|
mbed714 |
0:d616ece2d859
|
136
|
#if CHECKSUM_CHECK_TCP
|
mbed714 |
0:d616ece2d859
|
137
|
/* Verify TCP checksum. */
|
mbed714 |
0:d616ece2d859
|
138
|
if (inet_chksum_pseudo(p, ip_current_src_addr(), ip_current_dest_addr(),
|
mbed714 |
0:d616ece2d859
|
139
|
IP_PROTO_TCP, p->tot_len) != 0) {
|
mbed714 |
0:d616ece2d859
|
140
|
LWIP_DEBUGF(TCP_INPUT_DEBUG, ("tcp_input: packet discarded due to failing checksum 0x%04"X16_F"\n",
|
mbed714 |
0:d616ece2d859
|
141
|
inet_chksum_pseudo(p, ip_current_src_addr(), ip_current_dest_addr(),
|
mbed714 |
0:d616ece2d859
|
142
|
IP_PROTO_TCP, p->tot_len)));
|
mbed714 |
0:d616ece2d859
|
143
|
#if TCP_DEBUG
|
mbed714 |
0:d616ece2d859
|
144
|
tcp_debug_print(tcphdr);
|
mbed714 |
0:d616ece2d859
|
145
|
#endif /* TCP_DEBUG */
|
mbed714 |
0:d616ece2d859
|
146
|
TCP_STATS_INC(tcp.chkerr);
|
mbed714 |
0:d616ece2d859
|
147
|
TCP_STATS_INC(tcp.drop);
|
mbed714 |
0:d616ece2d859
|
148
|
snmp_inc_tcpinerrs();
|
mbed714 |
0:d616ece2d859
|
149
|
pbuf_free(p);
|
mbed714 |
0:d616ece2d859
|
150
|
return;
|
mbed714 |
0:d616ece2d859
|
151
|
}
|
mbed714 |
0:d616ece2d859
|
152
|
#endif
|
mbed714 |
0:d616ece2d859
|
153
|
|
mbed714 |
0:d616ece2d859
|
154
|
/* Move the payload pointer in the pbuf so that it points to the
|
mbed714 |
0:d616ece2d859
|
155
|
TCP data instead of the TCP header. */
|
mbed714 |
0:d616ece2d859
|
156
|
hdrlen = TCPH_HDRLEN(tcphdr);
|
mbed714 |
0:d616ece2d859
|
157
|
if(pbuf_header(p, -(hdrlen * 4))){
|
mbed714 |
0:d616ece2d859
|
158
|
/* drop short packets */
|
mbed714 |
0:d616ece2d859
|
159
|
LWIP_DEBUGF(TCP_INPUT_DEBUG, ("tcp_input: short packet\n"));
|
mbed714 |
0:d616ece2d859
|
160
|
TCP_STATS_INC(tcp.lenerr);
|
mbed714 |
0:d616ece2d859
|
161
|
TCP_STATS_INC(tcp.drop);
|
mbed714 |
0:d616ece2d859
|
162
|
snmp_inc_tcpinerrs();
|
mbed714 |
0:d616ece2d859
|
163
|
pbuf_free(p);
|
mbed714 |
0:d616ece2d859
|
164
|
return;
|
mbed714 |
0:d616ece2d859
|
165
|
}
|
mbed714 |
0:d616ece2d859
|
166
|
|
mbed714 |
0:d616ece2d859
|
167
|
/* Convert fields in TCP header to host byte order. */
|
mbed714 |
0:d616ece2d859
|
168
|
tcphdr->src = ntohs(tcphdr->src);
|
mbed714 |
0:d616ece2d859
|
169
|
tcphdr->dest = ntohs(tcphdr->dest);
|
mbed714 |
0:d616ece2d859
|
170
|
seqno = tcphdr->seqno = ntohl(tcphdr->seqno);
|
mbed714 |
0:d616ece2d859
|
171
|
ackno = tcphdr->ackno = ntohl(tcphdr->ackno);
|
mbed714 |
0:d616ece2d859
|
172
|
tcphdr->wnd = ntohs(tcphdr->wnd);
|
mbed714 |
0:d616ece2d859
|
173
|
|
mbed714 |
0:d616ece2d859
|
174
|
flags = TCPH_FLAGS(tcphdr);
|
mbed714 |
0:d616ece2d859
|
175
|
tcplen = p->tot_len + ((flags & (TCP_FIN | TCP_SYN)) ? 1 : 0);
|
mbed714 |
0:d616ece2d859
|
176
|
|
mbed714 |
0:d616ece2d859
|
177
|
/* Demultiplex an incoming segment. First, we check if it is destined
|
mbed714 |
0:d616ece2d859
|
178
|
for an active connection. */
|
mbed714 |
0:d616ece2d859
|
179
|
prev = NULL;
|
mbed714 |
0:d616ece2d859
|
180
|
|
mbed714 |
0:d616ece2d859
|
181
|
|
mbed714 |
0:d616ece2d859
|
182
|
for(pcb = tcp_active_pcbs; pcb != NULL; pcb = pcb->next) {
|
mbed714 |
0:d616ece2d859
|
183
|
LWIP_ASSERT("tcp_input: active pcb->state != CLOSED", pcb->state != CLOSED);
|
mbed714 |
0:d616ece2d859
|
184
|
LWIP_ASSERT("tcp_input: active pcb->state != TIME-WAIT", pcb->state != TIME_WAIT);
|
mbed714 |
0:d616ece2d859
|
185
|
LWIP_ASSERT("tcp_input: active pcb->state != LISTEN", pcb->state != LISTEN);
|
mbed714 |
0:d616ece2d859
|
186
|
if (pcb->remote_port == tcphdr->src &&
|
mbed714 |
0:d616ece2d859
|
187
|
pcb->local_port == tcphdr->dest &&
|
mbed714 |
0:d616ece2d859
|
188
|
ip_addr_cmp(&(pcb->remote_ip), ¤t_iphdr_src) &&
|
mbed714 |
0:d616ece2d859
|
189
|
ip_addr_cmp(&(pcb->local_ip), ¤t_iphdr_dest)) {
|
mbed714 |
0:d616ece2d859
|
190
|
|
mbed714 |
0:d616ece2d859
|
191
|
/* Move this PCB to the front of the list so that subsequent
|
mbed714 |
0:d616ece2d859
|
192
|
lookups will be faster (we exploit locality in TCP segment
|
mbed714 |
0:d616ece2d859
|
193
|
arrivals). */
|
mbed714 |
0:d616ece2d859
|
194
|
LWIP_ASSERT("tcp_input: pcb->next != pcb (before cache)", pcb->next != pcb);
|
mbed714 |
0:d616ece2d859
|
195
|
if (prev != NULL) {
|
mbed714 |
0:d616ece2d859
|
196
|
prev->next = pcb->next;
|
mbed714 |
0:d616ece2d859
|
197
|
pcb->next = tcp_active_pcbs;
|
mbed714 |
0:d616ece2d859
|
198
|
tcp_active_pcbs = pcb;
|
mbed714 |
0:d616ece2d859
|
199
|
}
|
mbed714 |
0:d616ece2d859
|
200
|
LWIP_ASSERT("tcp_input: pcb->next != pcb (after cache)", pcb->next != pcb);
|
mbed714 |
0:d616ece2d859
|
201
|
break;
|
mbed714 |
0:d616ece2d859
|
202
|
}
|
mbed714 |
0:d616ece2d859
|
203
|
prev = pcb;
|
mbed714 |
0:d616ece2d859
|
204
|
}
|
mbed714 |
0:d616ece2d859
|
205
|
|
mbed714 |
0:d616ece2d859
|
206
|
if (pcb == NULL) {
|
mbed714 |
0:d616ece2d859
|
207
|
/* If it did not go to an active connection, we check the connections
|
mbed714 |
0:d616ece2d859
|
208
|
in the TIME-WAIT state. */
|
mbed714 |
0:d616ece2d859
|
209
|
for(pcb = tcp_tw_pcbs; pcb != NULL; pcb = pcb->next) {
|
mbed714 |
0:d616ece2d859
|
210
|
LWIP_ASSERT("tcp_input: TIME-WAIT pcb->state == TIME-WAIT", pcb->state == TIME_WAIT);
|
mbed714 |
0:d616ece2d859
|
211
|
if (pcb->remote_port == tcphdr->src &&
|
mbed714 |
0:d616ece2d859
|
212
|
pcb->local_port == tcphdr->dest &&
|
mbed714 |
0:d616ece2d859
|
213
|
ip_addr_cmp(&(pcb->remote_ip), ¤t_iphdr_src) &&
|
mbed714 |
0:d616ece2d859
|
214
|
ip_addr_cmp(&(pcb->local_ip), ¤t_iphdr_dest)) {
|
mbed714 |
0:d616ece2d859
|
215
|
/* We don't really care enough to move this PCB to the front
|
mbed714 |
0:d616ece2d859
|
216
|
of the list since we are not very likely to receive that
|
mbed714 |
0:d616ece2d859
|
217
|
many segments for connections in TIME-WAIT. */
|
mbed714 |
0:d616ece2d859
|
218
|
LWIP_DEBUGF(TCP_INPUT_DEBUG, ("tcp_input: packed for TIME_WAITing connection.\n"));
|
mbed714 |
0:d616ece2d859
|
219
|
tcp_timewait_input(pcb);
|
mbed714 |
0:d616ece2d859
|
220
|
pbuf_free(p);
|
mbed714 |
0:d616ece2d859
|
221
|
return;
|
mbed714 |
0:d616ece2d859
|
222
|
}
|
mbed714 |
0:d616ece2d859
|
223
|
}
|
mbed714 |
0:d616ece2d859
|
224
|
|
mbed714 |
0:d616ece2d859
|
225
|
/* Finally, if we still did not get a match, we check all PCBs that
|
mbed714 |
0:d616ece2d859
|
226
|
are LISTENing for incoming connections. */
|
mbed714 |
0:d616ece2d859
|
227
|
prev = NULL;
|
mbed714 |
0:d616ece2d859
|
228
|
for(lpcb = tcp_listen_pcbs.listen_pcbs; lpcb != NULL; lpcb = lpcb->next) {
|
mbed714 |
0:d616ece2d859
|
229
|
if (lpcb->local_port == tcphdr->dest) {
|
mbed714 |
0:d616ece2d859
|
230
|
#if SO_REUSE
|
mbed714 |
0:d616ece2d859
|
231
|
if (ip_addr_cmp(&(lpcb->local_ip), ¤t_iphdr_dest)) {
|
mbed714 |
0:d616ece2d859
|
232
|
/* found an exact match */
|
mbed714 |
0:d616ece2d859
|
233
|
break;
|
mbed714 |
0:d616ece2d859
|
234
|
} else if(ip_addr_isany(&(lpcb->local_ip))) {
|
mbed714 |
0:d616ece2d859
|
235
|
/* found an ANY-match */
|
mbed714 |
0:d616ece2d859
|
236
|
lpcb_any = lpcb;
|
mbed714 |
0:d616ece2d859
|
237
|
lpcb_prev = prev;
|
mbed714 |
0:d616ece2d859
|
238
|
}
|
mbed714 |
0:d616ece2d859
|
239
|
#else /* SO_REUSE */
|
mbed714 |
0:d616ece2d859
|
240
|
if (ip_addr_cmp(&(lpcb->local_ip), ¤t_iphdr_dest) ||
|
mbed714 |
0:d616ece2d859
|
241
|
ip_addr_isany(&(lpcb->local_ip))) {
|
mbed714 |
0:d616ece2d859
|
242
|
/* found a match */
|
mbed714 |
0:d616ece2d859
|
243
|
break;
|
mbed714 |
0:d616ece2d859
|
244
|
}
|
mbed714 |
0:d616ece2d859
|
245
|
#endif /* SO_REUSE */
|
mbed714 |
0:d616ece2d859
|
246
|
}
|
mbed714 |
0:d616ece2d859
|
247
|
prev = (struct tcp_pcb *)lpcb;
|
mbed714 |
0:d616ece2d859
|
248
|
}
|
mbed714 |
0:d616ece2d859
|
249
|
#if SO_REUSE
|
mbed714 |
0:d616ece2d859
|
250
|
/* first try specific local IP */
|
mbed714 |
0:d616ece2d859
|
251
|
if (lpcb == NULL) {
|
mbed714 |
0:d616ece2d859
|
252
|
/* only pass to ANY if no specific local IP has been found */
|
mbed714 |
0:d616ece2d859
|
253
|
lpcb = lpcb_any;
|
mbed714 |
0:d616ece2d859
|
254
|
prev = lpcb_prev;
|
mbed714 |
0:d616ece2d859
|
255
|
}
|
mbed714 |
0:d616ece2d859
|
256
|
#endif /* SO_REUSE */
|
mbed714 |
0:d616ece2d859
|
257
|
if (lpcb != NULL) {
|
mbed714 |
0:d616ece2d859
|
258
|
/* Move this PCB to the front of the list so that subsequent
|
mbed714 |
0:d616ece2d859
|
259
|
lookups will be faster (we exploit locality in TCP segment
|
mbed714 |
0:d616ece2d859
|
260
|
arrivals). */
|
mbed714 |
0:d616ece2d859
|
261
|
if (prev != NULL) {
|
mbed714 |
0:d616ece2d859
|
262
|
((struct tcp_pcb_listen *)prev)->next = lpcb->next;
|
mbed714 |
0:d616ece2d859
|
263
|
/* our successor is the remainder of the listening list */
|
mbed714 |
0:d616ece2d859
|
264
|
lpcb->next = tcp_listen_pcbs.listen_pcbs;
|
mbed714 |
0:d616ece2d859
|
265
|
/* put this listening pcb at the head of the listening list */
|
mbed714 |
0:d616ece2d859
|
266
|
tcp_listen_pcbs.listen_pcbs = lpcb;
|
mbed714 |
0:d616ece2d859
|
267
|
}
|
mbed714 |
0:d616ece2d859
|
268
|
|
mbed714 |
0:d616ece2d859
|
269
|
LWIP_DEBUGF(TCP_INPUT_DEBUG, ("tcp_input: packed for LISTENing connection.\n"));
|
mbed714 |
0:d616ece2d859
|
270
|
tcp_listen_input(lpcb);
|
mbed714 |
0:d616ece2d859
|
271
|
pbuf_free(p);
|
mbed714 |
0:d616ece2d859
|
272
|
return;
|
mbed714 |
0:d616ece2d859
|
273
|
}
|
mbed714 |
0:d616ece2d859
|
274
|
}
|
mbed714 |
0:d616ece2d859
|
275
|
|
mbed714 |
0:d616ece2d859
|
276
|
#if TCP_INPUT_DEBUG
|
mbed714 |
0:d616ece2d859
|
277
|
LWIP_DEBUGF(TCP_INPUT_DEBUG, ("+-+-+-+-+-+-+-+-+-+-+-+-+-+- tcp_input: flags "));
|
mbed714 |
0:d616ece2d859
|
278
|
tcp_debug_print_flags(TCPH_FLAGS(tcphdr));
|
mbed714 |
0:d616ece2d859
|
279
|
LWIP_DEBUGF(TCP_INPUT_DEBUG, ("-+-+-+-+-+-+-+-+-+-+-+-+-+-+\n"));
|
mbed714 |
0:d616ece2d859
|
280
|
#endif /* TCP_INPUT_DEBUG */
|
mbed714 |
0:d616ece2d859
|
281
|
|
mbed714 |
0:d616ece2d859
|
282
|
|
mbed714 |
0:d616ece2d859
|
283
|
if (pcb != NULL) {
|
mbed714 |
0:d616ece2d859
|
284
|
/* The incoming segment belongs to a connection. */
|
mbed714 |
0:d616ece2d859
|
285
|
#if TCP_INPUT_DEBUG
|
mbed714 |
0:d616ece2d859
|
286
|
#if TCP_DEBUG
|
mbed714 |
0:d616ece2d859
|
287
|
tcp_debug_print_state(pcb->state);
|
mbed714 |
0:d616ece2d859
|
288
|
#endif /* TCP_DEBUG */
|
mbed714 |
0:d616ece2d859
|
289
|
#endif /* TCP_INPUT_DEBUG */
|
mbed714 |
0:d616ece2d859
|
290
|
|
mbed714 |
0:d616ece2d859
|
291
|
/* Set up a tcp_seg structure. */
|
mbed714 |
0:d616ece2d859
|
292
|
inseg.next = NULL;
|
mbed714 |
0:d616ece2d859
|
293
|
inseg.len = p->tot_len;
|
mbed714 |
0:d616ece2d859
|
294
|
inseg.dataptr = p->payload;
|
mbed714 |
0:d616ece2d859
|
295
|
inseg.p = p;
|
mbed714 |
0:d616ece2d859
|
296
|
inseg.tcphdr = tcphdr;
|
mbed714 |
0:d616ece2d859
|
297
|
|
mbed714 |
0:d616ece2d859
|
298
|
recv_data = NULL;
|
mbed714 |
0:d616ece2d859
|
299
|
recv_flags = 0;
|
mbed714 |
0:d616ece2d859
|
300
|
|
mbed714 |
0:d616ece2d859
|
301
|
/* If there is data which was previously "refused" by upper layer */
|
mbed714 |
0:d616ece2d859
|
302
|
if (pcb->refused_data != NULL) {
|
mbed714 |
0:d616ece2d859
|
303
|
/* Notify again application with data previously received. */
|
mbed714 |
0:d616ece2d859
|
304
|
LWIP_DEBUGF(TCP_INPUT_DEBUG, ("tcp_input: notify kept packet\n"));
|
mbed714 |
0:d616ece2d859
|
305
|
TCP_EVENT_RECV(pcb, pcb->refused_data, ERR_OK, err);
|
mbed714 |
0:d616ece2d859
|
306
|
if (err == ERR_OK) {
|
mbed714 |
0:d616ece2d859
|
307
|
pcb->refused_data = NULL;
|
mbed714 |
0:d616ece2d859
|
308
|
} else {
|
mbed714 |
0:d616ece2d859
|
309
|
/* if err == ERR_ABRT, 'pcb' is already deallocated */
|
mbed714 |
0:d616ece2d859
|
310
|
/* drop incoming packets, because pcb is "full" */
|
mbed714 |
0:d616ece2d859
|
311
|
LWIP_DEBUGF(TCP_INPUT_DEBUG, ("tcp_input: drop incoming packets, because pcb is \"full\"\n"));
|
mbed714 |
0:d616ece2d859
|
312
|
TCP_STATS_INC(tcp.drop);
|
mbed714 |
0:d616ece2d859
|
313
|
snmp_inc_tcpinerrs();
|
mbed714 |
0:d616ece2d859
|
314
|
pbuf_free(p);
|
mbed714 |
0:d616ece2d859
|
315
|
return;
|
mbed714 |
0:d616ece2d859
|
316
|
}
|
mbed714 |
0:d616ece2d859
|
317
|
}
|
mbed714 |
0:d616ece2d859
|
318
|
tcp_input_pcb = pcb;
|
mbed714 |
0:d616ece2d859
|
319
|
err = tcp_process(pcb);
|
mbed714 |
0:d616ece2d859
|
320
|
/* A return value of ERR_ABRT means that tcp_abort() was called
|
mbed714 |
0:d616ece2d859
|
321
|
and that the pcb has been freed. If so, we don't do anything. */
|
mbed714 |
0:d616ece2d859
|
322
|
if (err != ERR_ABRT) {
|
mbed714 |
0:d616ece2d859
|
323
|
if (recv_flags & TF_RESET) {
|
mbed714 |
0:d616ece2d859
|
324
|
/* TF_RESET means that the connection was reset by the other
|
mbed714 |
0:d616ece2d859
|
325
|
end. We then call the error callback to inform the
|
mbed714 |
0:d616ece2d859
|
326
|
application that the connection is dead before we
|
mbed714 |
0:d616ece2d859
|
327
|
deallocate the PCB. */
|
mbed714 |
0:d616ece2d859
|
328
|
TCP_EVENT_ERR(pcb->errf, pcb->callback_arg, ERR_RST);
|
mbed714 |
0:d616ece2d859
|
329
|
tcp_pcb_remove(&tcp_active_pcbs, pcb);
|
mbed714 |
0:d616ece2d859
|
330
|
memp_free(MEMP_TCP_PCB, pcb);
|
mbed714 |
0:d616ece2d859
|
331
|
} else if (recv_flags & TF_CLOSED) {
|
mbed714 |
0:d616ece2d859
|
332
|
/* The connection has been closed and we will deallocate the
|
mbed714 |
0:d616ece2d859
|
333
|
PCB. */
|
mbed714 |
0:d616ece2d859
|
334
|
tcp_pcb_remove(&tcp_active_pcbs, pcb);
|
mbed714 |
0:d616ece2d859
|
335
|
memp_free(MEMP_TCP_PCB, pcb);
|
mbed714 |
0:d616ece2d859
|
336
|
} else {
|
mbed714 |
0:d616ece2d859
|
337
|
err = ERR_OK;
|
mbed714 |
0:d616ece2d859
|
338
|
/* If the application has registered a "sent" function to be
|
mbed714 |
0:d616ece2d859
|
339
|
called when new send buffer space is available, we call it
|
mbed714 |
0:d616ece2d859
|
340
|
now. */
|
mbed714 |
0:d616ece2d859
|
341
|
if (pcb->acked > 0) {
|
mbed714 |
0:d616ece2d859
|
342
|
TCP_EVENT_SENT(pcb, pcb->acked, err);
|
mbed714 |
0:d616ece2d859
|
343
|
if (err == ERR_ABRT) {
|
mbed714 |
0:d616ece2d859
|
344
|
goto aborted;
|
mbed714 |
0:d616ece2d859
|
345
|
}
|
mbed714 |
0:d616ece2d859
|
346
|
}
|
mbed714 |
0:d616ece2d859
|
347
|
|
mbed714 |
0:d616ece2d859
|
348
|
if (recv_data != NULL) {
|
mbed714 |
0:d616ece2d859
|
349
|
if (pcb->flags & TF_RXCLOSED) {
|
mbed714 |
0:d616ece2d859
|
350
|
/* received data although already closed -> abort (send RST) to
|
mbed714 |
0:d616ece2d859
|
351
|
notify the remote host that not all data has been processed */
|
mbed714 |
0:d616ece2d859
|
352
|
pbuf_free(recv_data);
|
mbed714 |
0:d616ece2d859
|
353
|
tcp_abort(pcb);
|
mbed714 |
0:d616ece2d859
|
354
|
goto aborted;
|
mbed714 |
0:d616ece2d859
|
355
|
}
|
mbed714 |
0:d616ece2d859
|
356
|
if (flags & TCP_PSH) {
|
mbed714 |
0:d616ece2d859
|
357
|
recv_data->flags |= PBUF_FLAG_PUSH;
|
mbed714 |
0:d616ece2d859
|
358
|
}
|
mbed714 |
0:d616ece2d859
|
359
|
|
mbed714 |
0:d616ece2d859
|
360
|
/* Notify application that data has been received. */
|
mbed714 |
0:d616ece2d859
|
361
|
TCP_EVENT_RECV(pcb, recv_data, ERR_OK, err);
|
mbed714 |
0:d616ece2d859
|
362
|
if (err == ERR_ABRT) {
|
mbed714 |
0:d616ece2d859
|
363
|
goto aborted;
|
mbed714 |
0:d616ece2d859
|
364
|
}
|
mbed714 |
0:d616ece2d859
|
365
|
|
mbed714 |
0:d616ece2d859
|
366
|
/* If the upper layer can't receive this data, store it */
|
mbed714 |
0:d616ece2d859
|
367
|
if (err != ERR_OK) {
|
mbed714 |
0:d616ece2d859
|
368
|
pcb->refused_data = recv_data;
|
mbed714 |
0:d616ece2d859
|
369
|
LWIP_DEBUGF(TCP_INPUT_DEBUG, ("tcp_input: keep incoming packet, because pcb is \"full\"\n"));
|
mbed714 |
0:d616ece2d859
|
370
|
}
|
mbed714 |
0:d616ece2d859
|
371
|
}
|
mbed714 |
0:d616ece2d859
|
372
|
|
mbed714 |
0:d616ece2d859
|
373
|
/* If a FIN segment was received, we call the callback
|
mbed714 |
0:d616ece2d859
|
374
|
function with a NULL buffer to indicate EOF. */
|
mbed714 |
0:d616ece2d859
|
375
|
if (recv_flags & TF_GOT_FIN) {
|
mbed714 |
0:d616ece2d859
|
376
|
/* correct rcv_wnd as the application won't call tcp_recved()
|
mbed714 |
0:d616ece2d859
|
377
|
for the FIN's seqno */
|
mbed714 |
0:d616ece2d859
|
378
|
if (pcb->rcv_wnd != TCP_WND) {
|
mbed714 |
0:d616ece2d859
|
379
|
pcb->rcv_wnd++;
|
mbed714 |
0:d616ece2d859
|
380
|
}
|
mbed714 |
0:d616ece2d859
|
381
|
TCP_EVENT_CLOSED(pcb, err);
|
mbed714 |
0:d616ece2d859
|
382
|
if (err == ERR_ABRT) {
|
mbed714 |
0:d616ece2d859
|
383
|
goto aborted;
|
mbed714 |
0:d616ece2d859
|
384
|
}
|
mbed714 |
0:d616ece2d859
|
385
|
}
|
mbed714 |
0:d616ece2d859
|
386
|
|
mbed714 |
0:d616ece2d859
|
387
|
tcp_input_pcb = NULL;
|
mbed714 |
0:d616ece2d859
|
388
|
/* Try to send something out. */
|
mbed714 |
0:d616ece2d859
|
389
|
tcp_output(pcb);
|
mbed714 |
0:d616ece2d859
|
390
|
#if TCP_INPUT_DEBUG
|
mbed714 |
0:d616ece2d859
|
391
|
#if TCP_DEBUG
|
mbed714 |
0:d616ece2d859
|
392
|
tcp_debug_print_state(pcb->state);
|
mbed714 |
0:d616ece2d859
|
393
|
#endif /* TCP_DEBUG */
|
mbed714 |
0:d616ece2d859
|
394
|
#endif /* TCP_INPUT_DEBUG */
|
mbed714 |
0:d616ece2d859
|
395
|
}
|
mbed714 |
0:d616ece2d859
|
396
|
}
|
mbed714 |
0:d616ece2d859
|
397
|
/* Jump target if pcb has been aborted in a callback (by calling tcp_abort()).
|
mbed714 |
0:d616ece2d859
|
398
|
Below this line, 'pcb' may not be dereferenced! */
|
mbed714 |
0:d616ece2d859
|
399
|
aborted:
|
mbed714 |
0:d616ece2d859
|
400
|
tcp_input_pcb = NULL;
|
mbed714 |
0:d616ece2d859
|
401
|
recv_data = NULL;
|
mbed714 |
0:d616ece2d859
|
402
|
|
mbed714 |
0:d616ece2d859
|
403
|
/* give up our reference to inseg.p */
|
mbed714 |
0:d616ece2d859
|
404
|
if (inseg.p != NULL)
|
mbed714 |
0:d616ece2d859
|
405
|
{
|
mbed714 |
0:d616ece2d859
|
406
|
pbuf_free(inseg.p);
|
mbed714 |
0:d616ece2d859
|
407
|
inseg.p = NULL;
|
mbed714 |
0:d616ece2d859
|
408
|
}
|
mbed714 |
0:d616ece2d859
|
409
|
} else {
|
mbed714 |
0:d616ece2d859
|
410
|
|
mbed714 |
0:d616ece2d859
|
411
|
/* If no matching PCB was found, send a TCP RST (reset) to the
|
mbed714 |
0:d616ece2d859
|
412
|
sender. */
|
mbed714 |
0:d616ece2d859
|
413
|
LWIP_DEBUGF(TCP_RST_DEBUG, ("tcp_input: no PCB match found, resetting.\n"));
|
mbed714 |
0:d616ece2d859
|
414
|
if (!(TCPH_FLAGS(tcphdr) & TCP_RST)) {
|
mbed714 |
0:d616ece2d859
|
415
|
TCP_STATS_INC(tcp.proterr);
|
mbed714 |
0:d616ece2d859
|
416
|
TCP_STATS_INC(tcp.drop);
|
mbed714 |
0:d616ece2d859
|
417
|
tcp_rst(ackno, seqno + tcplen,
|
mbed714 |
0:d616ece2d859
|
418
|
ip_current_dest_addr(), ip_current_src_addr(),
|
mbed714 |
0:d616ece2d859
|
419
|
tcphdr->dest, tcphdr->src);
|
mbed714 |
0:d616ece2d859
|
420
|
}
|
mbed714 |
0:d616ece2d859
|
421
|
pbuf_free(p);
|
mbed714 |
0:d616ece2d859
|
422
|
}
|
mbed714 |
0:d616ece2d859
|
423
|
|
mbed714 |
0:d616ece2d859
|
424
|
LWIP_ASSERT("tcp_input: tcp_pcbs_sane()", tcp_pcbs_sane());
|
mbed714 |
0:d616ece2d859
|
425
|
PERF_STOP("tcp_input");
|
mbed714 |
0:d616ece2d859
|
426
|
}
|
mbed714 |
0:d616ece2d859
|
427
|
|
mbed714 |
0:d616ece2d859
|
428
|
/**
|
mbed714 |
0:d616ece2d859
|
429
|
* Called by tcp_input() when a segment arrives for a listening
|
mbed714 |
0:d616ece2d859
|
430
|
* connection (from tcp_input()).
|
mbed714 |
0:d616ece2d859
|
431
|
*
|
mbed714 |
0:d616ece2d859
|
432
|
* @param pcb the tcp_pcb_listen for which a segment arrived
|
mbed714 |
0:d616ece2d859
|
433
|
* @return ERR_OK if the segment was processed
|
mbed714 |
0:d616ece2d859
|
434
|
* another err_t on error
|
mbed714 |
0:d616ece2d859
|
435
|
*
|
mbed714 |
0:d616ece2d859
|
436
|
* @note the return value is not (yet?) used in tcp_input()
|
mbed714 |
0:d616ece2d859
|
437
|
* @note the segment which arrived is saved in global variables, therefore only the pcb
|
mbed714 |
0:d616ece2d859
|
438
|
* involved is passed as a parameter to this function
|
mbed714 |
0:d616ece2d859
|
439
|
*/
|
mbed714 |
0:d616ece2d859
|
440
|
static err_t
|
mbed714 |
0:d616ece2d859
|
441
|
tcp_listen_input(struct tcp_pcb_listen *pcb)
|
mbed714 |
0:d616ece2d859
|
442
|
{
|
mbed714 |
0:d616ece2d859
|
443
|
struct tcp_pcb *npcb;
|
mbed714 |
0:d616ece2d859
|
444
|
err_t rc;
|
mbed714 |
0:d616ece2d859
|
445
|
|
mbed714 |
0:d616ece2d859
|
446
|
/* In the LISTEN state, we check for incoming SYN segments,
|
mbed714 |
0:d616ece2d859
|
447
|
creates a new PCB, and responds with a SYN|ACK. */
|
mbed714 |
0:d616ece2d859
|
448
|
if (flags & TCP_ACK) {
|
mbed714 |
0:d616ece2d859
|
449
|
/* For incoming segments with the ACK flag set, respond with a
|
mbed714 |
0:d616ece2d859
|
450
|
RST. */
|
mbed714 |
0:d616ece2d859
|
451
|
LWIP_DEBUGF(TCP_RST_DEBUG, ("tcp_listen_input: ACK in LISTEN, sending reset\n"));
|
mbed714 |
0:d616ece2d859
|
452
|
tcp_rst(ackno + 1, seqno + tcplen,
|
mbed714 |
0:d616ece2d859
|
453
|
ip_current_dest_addr(), ip_current_src_addr(),
|
mbed714 |
0:d616ece2d859
|
454
|
tcphdr->dest, tcphdr->src);
|
mbed714 |
0:d616ece2d859
|
455
|
} else if (flags & TCP_SYN) {
|
mbed714 |
0:d616ece2d859
|
456
|
LWIP_DEBUGF(TCP_DEBUG, ("TCP connection request %"U16_F" -> %"U16_F".\n", tcphdr->src, tcphdr->dest));
|
mbed714 |
0:d616ece2d859
|
457
|
#if TCP_LISTEN_BACKLOG
|
mbed714 |
0:d616ece2d859
|
458
|
if (pcb->accepts_pending >= pcb->backlog) {
|
mbed714 |
0:d616ece2d859
|
459
|
LWIP_DEBUGF(TCP_DEBUG, ("tcp_listen_input: listen backlog exceeded for port %"U16_F"\n", tcphdr->dest));
|
mbed714 |
0:d616ece2d859
|
460
|
return ERR_ABRT;
|
mbed714 |
0:d616ece2d859
|
461
|
}
|
mbed714 |
0:d616ece2d859
|
462
|
#endif /* TCP_LISTEN_BACKLOG */
|
mbed714 |
0:d616ece2d859
|
463
|
npcb = tcp_alloc(pcb->prio);
|
mbed714 |
0:d616ece2d859
|
464
|
/* If a new PCB could not be created (probably due to lack of memory),
|
mbed714 |
0:d616ece2d859
|
465
|
we don't do anything, but rely on the sender will retransmit the
|
mbed714 |
0:d616ece2d859
|
466
|
SYN at a time when we have more memory available. */
|
mbed714 |
0:d616ece2d859
|
467
|
if (npcb == NULL) {
|
mbed714 |
0:d616ece2d859
|
468
|
LWIP_DEBUGF(TCP_DEBUG, ("tcp_listen_input: could not allocate PCB\n"));
|
mbed714 |
0:d616ece2d859
|
469
|
TCP_STATS_INC(tcp.memerr);
|
mbed714 |
0:d616ece2d859
|
470
|
return ERR_MEM;
|
mbed714 |
0:d616ece2d859
|
471
|
}
|
mbed714 |
0:d616ece2d859
|
472
|
#if TCP_LISTEN_BACKLOG
|
mbed714 |
0:d616ece2d859
|
473
|
pcb->accepts_pending++;
|
mbed714 |
0:d616ece2d859
|
474
|
#endif /* TCP_LISTEN_BACKLOG */
|
mbed714 |
0:d616ece2d859
|
475
|
/* Set up the new PCB. */
|
mbed714 |
0:d616ece2d859
|
476
|
ip_addr_copy(npcb->local_ip, current_iphdr_dest);
|
mbed714 |
0:d616ece2d859
|
477
|
npcb->local_port = pcb->local_port;
|
mbed714 |
0:d616ece2d859
|
478
|
ip_addr_copy(npcb->remote_ip, current_iphdr_src);
|
mbed714 |
0:d616ece2d859
|
479
|
npcb->remote_port = tcphdr->src;
|
mbed714 |
0:d616ece2d859
|
480
|
npcb->state = SYN_RCVD;
|
mbed714 |
0:d616ece2d859
|
481
|
npcb->rcv_nxt = seqno + 1;
|
mbed714 |
0:d616ece2d859
|
482
|
npcb->rcv_ann_right_edge = npcb->rcv_nxt;
|
mbed714 |
0:d616ece2d859
|
483
|
npcb->snd_wnd = tcphdr->wnd;
|
mbed714 |
0:d616ece2d859
|
484
|
npcb->ssthresh = npcb->snd_wnd;
|
mbed714 |
0:d616ece2d859
|
485
|
npcb->snd_wl1 = seqno - 1;/* initialise to seqno-1 to force window update */
|
mbed714 |
0:d616ece2d859
|
486
|
npcb->callback_arg = pcb->callback_arg;
|
mbed714 |
0:d616ece2d859
|
487
|
#if LWIP_CALLBACK_API
|
mbed714 |
0:d616ece2d859
|
488
|
npcb->accept = pcb->accept;
|
mbed714 |
0:d616ece2d859
|
489
|
#endif /* LWIP_CALLBACK_API */
|
mbed714 |
0:d616ece2d859
|
490
|
/* inherit socket options */
|
mbed714 |
0:d616ece2d859
|
491
|
npcb->so_options = pcb->so_options & SOF_INHERITED;
|
mbed714 |
0:d616ece2d859
|
492
|
/* Register the new PCB so that we can begin receiving segments
|
mbed714 |
0:d616ece2d859
|
493
|
for it. */
|
mbed714 |
0:d616ece2d859
|
494
|
TCP_REG(&tcp_active_pcbs, npcb);
|
mbed714 |
0:d616ece2d859
|
495
|
|
mbed714 |
0:d616ece2d859
|
496
|
/* Parse any options in the SYN. */
|
mbed714 |
0:d616ece2d859
|
497
|
tcp_parseopt(npcb);
|
mbed714 |
0:d616ece2d859
|
498
|
#if TCP_CALCULATE_EFF_SEND_MSS
|
mbed714 |
0:d616ece2d859
|
499
|
npcb->mss = tcp_eff_send_mss(npcb->mss, &(npcb->remote_ip));
|
mbed714 |
0:d616ece2d859
|
500
|
#endif /* TCP_CALCULATE_EFF_SEND_MSS */
|
mbed714 |
0:d616ece2d859
|
501
|
|
mbed714 |
0:d616ece2d859
|
502
|
snmp_inc_tcppassiveopens();
|
mbed714 |
0:d616ece2d859
|
503
|
|
mbed714 |
0:d616ece2d859
|
504
|
/* Send a SYN|ACK together with the MSS option. */
|
mbed714 |
0:d616ece2d859
|
505
|
rc = tcp_enqueue_flags(npcb, TCP_SYN | TCP_ACK);
|
mbed714 |
0:d616ece2d859
|
506
|
if (rc != ERR_OK) {
|
mbed714 |
0:d616ece2d859
|
507
|
tcp_abandon(npcb, 0);
|
mbed714 |
0:d616ece2d859
|
508
|
return rc;
|
mbed714 |
0:d616ece2d859
|
509
|
}
|
mbed714 |
0:d616ece2d859
|
510
|
return tcp_output(npcb);
|
mbed714 |
0:d616ece2d859
|
511
|
}
|
mbed714 |
0:d616ece2d859
|
512
|
return ERR_OK;
|
mbed714 |
0:d616ece2d859
|
513
|
}
|
mbed714 |
0:d616ece2d859
|
514
|
|
mbed714 |
0:d616ece2d859
|
515
|
/**
|
mbed714 |
0:d616ece2d859
|
516
|
* Called by tcp_input() when a segment arrives for a connection in
|
mbed714 |
0:d616ece2d859
|
517
|
* TIME_WAIT.
|
mbed714 |
0:d616ece2d859
|
518
|
*
|
mbed714 |
0:d616ece2d859
|
519
|
* @param pcb the tcp_pcb for which a segment arrived
|
mbed714 |
0:d616ece2d859
|
520
|
*
|
mbed714 |
0:d616ece2d859
|
521
|
* @note the segment which arrived is saved in global variables, therefore only the pcb
|
mbed714 |
0:d616ece2d859
|
522
|
* involved is passed as a parameter to this function
|
mbed714 |
0:d616ece2d859
|
523
|
*/
|
mbed714 |
0:d616ece2d859
|
524
|
static err_t
|
mbed714 |
0:d616ece2d859
|
525
|
tcp_timewait_input(struct tcp_pcb *pcb)
|
mbed714 |
0:d616ece2d859
|
526
|
{
|
mbed714 |
0:d616ece2d859
|
527
|
/* RFC 1337: in TIME_WAIT, ignore RST and ACK FINs + any 'acceptable' segments */
|
mbed714 |
0:d616ece2d859
|
528
|
/* RFC 793 3.9 Event Processing - Segment Arrives:
|
mbed714 |
0:d616ece2d859
|
529
|
* - first check sequence number - we skip that one in TIME_WAIT (always
|
mbed714 |
0:d616ece2d859
|
530
|
* acceptable since we only send ACKs)
|
mbed714 |
0:d616ece2d859
|
531
|
* - second check the RST bit (... return) */
|
mbed714 |
0:d616ece2d859
|
532
|
if (flags & TCP_RST) {
|
mbed714 |
0:d616ece2d859
|
533
|
return ERR_OK;
|
mbed714 |
0:d616ece2d859
|
534
|
}
|
mbed714 |
0:d616ece2d859
|
535
|
/* - fourth, check the SYN bit, */
|
mbed714 |
0:d616ece2d859
|
536
|
if (flags & TCP_SYN) {
|
mbed714 |
0:d616ece2d859
|
537
|
/* If an incoming segment is not acceptable, an acknowledgment
|
mbed714 |
0:d616ece2d859
|
538
|
should be sent in reply */
|
mbed714 |
0:d616ece2d859
|
539
|
if (TCP_SEQ_BETWEEN(seqno, pcb->rcv_nxt, pcb->rcv_nxt+pcb->rcv_wnd)) {
|
mbed714 |
0:d616ece2d859
|
540
|
/* If the SYN is in the window it is an error, send a reset */
|
mbed714 |
0:d616ece2d859
|
541
|
tcp_rst(ackno, seqno + tcplen, ip_current_dest_addr(), ip_current_src_addr(),
|
mbed714 |
0:d616ece2d859
|
542
|
tcphdr->dest, tcphdr->src);
|
mbed714 |
0:d616ece2d859
|
543
|
return ERR_OK;
|
mbed714 |
0:d616ece2d859
|
544
|
}
|
mbed714 |
0:d616ece2d859
|
545
|
} else if (flags & TCP_FIN) {
|
mbed714 |
0:d616ece2d859
|
546
|
/* - eighth, check the FIN bit: Remain in the TIME-WAIT state.
|
mbed714 |
0:d616ece2d859
|
547
|
Restart the 2 MSL time-wait timeout.*/
|
mbed714 |
0:d616ece2d859
|
548
|
pcb->tmr = tcp_ticks;
|
mbed714 |
0:d616ece2d859
|
549
|
}
|
mbed714 |
0:d616ece2d859
|
550
|
|
mbed714 |
0:d616ece2d859
|
551
|
if ((tcplen > 0)) {
|
mbed714 |
0:d616ece2d859
|
552
|
/* Acknowledge data, FIN or out-of-window SYN */
|
mbed714 |
0:d616ece2d859
|
553
|
pcb->flags |= TF_ACK_NOW;
|
mbed714 |
0:d616ece2d859
|
554
|
return tcp_output(pcb);
|
mbed714 |
0:d616ece2d859
|
555
|
}
|
mbed714 |
0:d616ece2d859
|
556
|
return ERR_OK;
|
mbed714 |
0:d616ece2d859
|
557
|
}
|
mbed714 |
0:d616ece2d859
|
558
|
|
mbed714 |
0:d616ece2d859
|
559
|
/**
|
mbed714 |
0:d616ece2d859
|
560
|
* Implements the TCP state machine. Called by tcp_input. In some
|
mbed714 |
0:d616ece2d859
|
561
|
* states tcp_receive() is called to receive data. The tcp_seg
|
mbed714 |
0:d616ece2d859
|
562
|
* argument will be freed by the caller (tcp_input()) unless the
|
mbed714 |
0:d616ece2d859
|
563
|
* recv_data pointer in the pcb is set.
|
mbed714 |
0:d616ece2d859
|
564
|
*
|
mbed714 |
0:d616ece2d859
|
565
|
* @param pcb the tcp_pcb for which a segment arrived
|
mbed714 |
0:d616ece2d859
|
566
|
*
|
mbed714 |
0:d616ece2d859
|
567
|
* @note the segment which arrived is saved in global variables, therefore only the pcb
|
mbed714 |
0:d616ece2d859
|
568
|
* involved is passed as a parameter to this function
|
mbed714 |
0:d616ece2d859
|
569
|
*/
|
mbed714 |
0:d616ece2d859
|
570
|
static err_t
|
mbed714 |
0:d616ece2d859
|
571
|
tcp_process(struct tcp_pcb *pcb)
|
mbed714 |
0:d616ece2d859
|
572
|
{
|
mbed714 |
0:d616ece2d859
|
573
|
struct tcp_seg *rseg;
|
mbed714 |
0:d616ece2d859
|
574
|
u8_t acceptable = 0;
|
mbed714 |
0:d616ece2d859
|
575
|
err_t err;
|
mbed714 |
0:d616ece2d859
|
576
|
|
mbed714 |
0:d616ece2d859
|
577
|
err = ERR_OK;
|
mbed714 |
0:d616ece2d859
|
578
|
|
mbed714 |
0:d616ece2d859
|
579
|
/* Process incoming RST segments. */
|
mbed714 |
0:d616ece2d859
|
580
|
if (flags & TCP_RST) {
|
mbed714 |
0:d616ece2d859
|
581
|
/* First, determine if the reset is acceptable. */
|
mbed714 |
0:d616ece2d859
|
582
|
if (pcb->state == SYN_SENT) {
|
mbed714 |
0:d616ece2d859
|
583
|
if (ackno == pcb->snd_nxt) {
|
mbed714 |
0:d616ece2d859
|
584
|
acceptable = 1;
|
mbed714 |
0:d616ece2d859
|
585
|
}
|
mbed714 |
0:d616ece2d859
|
586
|
} else {
|
mbed714 |
0:d616ece2d859
|
587
|
if (TCP_SEQ_BETWEEN(seqno, pcb->rcv_nxt,
|
mbed714 |
0:d616ece2d859
|
588
|
pcb->rcv_nxt+pcb->rcv_wnd)) {
|
mbed714 |
0:d616ece2d859
|
589
|
acceptable = 1;
|
mbed714 |
0:d616ece2d859
|
590
|
}
|
mbed714 |
0:d616ece2d859
|
591
|
}
|
mbed714 |
0:d616ece2d859
|
592
|
|
mbed714 |
0:d616ece2d859
|
593
|
if (acceptable) {
|
mbed714 |
0:d616ece2d859
|
594
|
LWIP_DEBUGF(TCP_INPUT_DEBUG, ("tcp_process: Connection RESET\n"));
|
mbed714 |
0:d616ece2d859
|
595
|
LWIP_ASSERT("tcp_input: pcb->state != CLOSED", pcb->state != CLOSED);
|
mbed714 |
0:d616ece2d859
|
596
|
recv_flags |= TF_RESET;
|
mbed714 |
0:d616ece2d859
|
597
|
pcb->flags &= ~TF_ACK_DELAY;
|
mbed714 |
0:d616ece2d859
|
598
|
return ERR_RST;
|
mbed714 |
0:d616ece2d859
|
599
|
} else {
|
mbed714 |
0:d616ece2d859
|
600
|
LWIP_DEBUGF(TCP_INPUT_DEBUG, ("tcp_process: unacceptable reset seqno %"U32_F" rcv_nxt %"U32_F"\n",
|
mbed714 |
0:d616ece2d859
|
601
|
seqno, pcb->rcv_nxt));
|
mbed714 |
0:d616ece2d859
|
602
|
LWIP_DEBUGF(TCP_DEBUG, ("tcp_process: unacceptable reset seqno %"U32_F" rcv_nxt %"U32_F"\n",
|
mbed714 |
0:d616ece2d859
|
603
|
seqno, pcb->rcv_nxt));
|
mbed714 |
0:d616ece2d859
|
604
|
return ERR_OK;
|
mbed714 |
0:d616ece2d859
|
605
|
}
|
mbed714 |
0:d616ece2d859
|
606
|
}
|
mbed714 |
0:d616ece2d859
|
607
|
|
mbed714 |
0:d616ece2d859
|
608
|
if ((flags & TCP_SYN) && (pcb->state != SYN_SENT && pcb->state != SYN_RCVD)) {
|
mbed714 |
0:d616ece2d859
|
609
|
/* Cope with new connection attempt after remote end crashed */
|
mbed714 |
0:d616ece2d859
|
610
|
tcp_ack_now(pcb);
|
mbed714 |
0:d616ece2d859
|
611
|
return ERR_OK;
|
mbed714 |
0:d616ece2d859
|
612
|
}
|
mbed714 |
0:d616ece2d859
|
613
|
|
mbed714 |
0:d616ece2d859
|
614
|
if ((pcb->flags & TF_RXCLOSED) == 0) {
|
mbed714 |
0:d616ece2d859
|
615
|
/* Update the PCB (in)activity timer unless rx is closed (see tcp_shutdown) */
|
mbed714 |
0:d616ece2d859
|
616
|
pcb->tmr = tcp_ticks;
|
mbed714 |
0:d616ece2d859
|
617
|
}
|
mbed714 |
0:d616ece2d859
|
618
|
pcb->keep_cnt_sent = 0;
|
mbed714 |
0:d616ece2d859
|
619
|
|
mbed714 |
0:d616ece2d859
|
620
|
tcp_parseopt(pcb);
|
mbed714 |
0:d616ece2d859
|
621
|
|
mbed714 |
0:d616ece2d859
|
622
|
/* Do different things depending on the TCP state. */
|
mbed714 |
0:d616ece2d859
|
623
|
switch (pcb->state) {
|
mbed714 |
0:d616ece2d859
|
624
|
case SYN_SENT:
|
mbed714 |
0:d616ece2d859
|
625
|
LWIP_DEBUGF(TCP_INPUT_DEBUG, ("SYN-SENT: ackno %"U32_F" pcb->snd_nxt %"U32_F" unacked %"U32_F"\n", ackno,
|
mbed714 |
0:d616ece2d859
|
626
|
pcb->snd_nxt, ntohl(pcb->unacked->tcphdr->seqno)));
|
mbed714 |
0:d616ece2d859
|
627
|
/* received SYN ACK with expected sequence number? */
|
mbed714 |
0:d616ece2d859
|
628
|
if ((flags & TCP_ACK) && (flags & TCP_SYN)
|
mbed714 |
0:d616ece2d859
|
629
|
&& ackno == ntohl(pcb->unacked->tcphdr->seqno) + 1) {
|
mbed714 |
0:d616ece2d859
|
630
|
pcb->snd_buf++;
|
mbed714 |
0:d616ece2d859
|
631
|
pcb->rcv_nxt = seqno + 1;
|
mbed714 |
0:d616ece2d859
|
632
|
pcb->rcv_ann_right_edge = pcb->rcv_nxt;
|
mbed714 |
0:d616ece2d859
|
633
|
pcb->lastack = ackno;
|
mbed714 |
0:d616ece2d859
|
634
|
pcb->snd_wnd = tcphdr->wnd;
|
mbed714 |
0:d616ece2d859
|
635
|
pcb->snd_wl1 = seqno - 1; /* initialise to seqno - 1 to force window update */
|
mbed714 |
0:d616ece2d859
|
636
|
pcb->state = ESTABLISHED;
|
mbed714 |
0:d616ece2d859
|
637
|
|
mbed714 |
0:d616ece2d859
|
638
|
#if TCP_CALCULATE_EFF_SEND_MSS
|
mbed714 |
0:d616ece2d859
|
639
|
pcb->mss = tcp_eff_send_mss(pcb->mss, &(pcb->remote_ip));
|
mbed714 |
0:d616ece2d859
|
640
|
#endif /* TCP_CALCULATE_EFF_SEND_MSS */
|
mbed714 |
0:d616ece2d859
|
641
|
|
mbed714 |
0:d616ece2d859
|
642
|
/* Set ssthresh again after changing pcb->mss (already set in tcp_connect
|
mbed714 |
0:d616ece2d859
|
643
|
* but for the default value of pcb->mss) */
|
mbed714 |
0:d616ece2d859
|
644
|
pcb->ssthresh = pcb->mss * 10;
|
mbed714 |
0:d616ece2d859
|
645
|
|
mbed714 |
0:d616ece2d859
|
646
|
pcb->cwnd = ((pcb->cwnd == 1) ? (pcb->mss * 2) : pcb->mss);
|
mbed714 |
0:d616ece2d859
|
647
|
LWIP_ASSERT("pcb->snd_queuelen > 0", (pcb->snd_queuelen > 0));
|
mbed714 |
0:d616ece2d859
|
648
|
--pcb->snd_queuelen;
|
mbed714 |
0:d616ece2d859
|
649
|
LWIP_DEBUGF(TCP_QLEN_DEBUG, ("tcp_process: SYN-SENT --queuelen %"U16_F"\n", (u16_t)pcb->snd_queuelen));
|
mbed714 |
0:d616ece2d859
|
650
|
rseg = pcb->unacked;
|
mbed714 |
0:d616ece2d859
|
651
|
pcb->unacked = rseg->next;
|
mbed714 |
0:d616ece2d859
|
652
|
|
mbed714 |
0:d616ece2d859
|
653
|
/* If there's nothing left to acknowledge, stop the retransmit
|
mbed714 |
0:d616ece2d859
|
654
|
timer, otherwise reset it to start again */
|
mbed714 |
0:d616ece2d859
|
655
|
if(pcb->unacked == NULL)
|
mbed714 |
0:d616ece2d859
|
656
|
pcb->rtime = -1;
|
mbed714 |
0:d616ece2d859
|
657
|
else {
|
mbed714 |
0:d616ece2d859
|
658
|
pcb->rtime = 0;
|
mbed714 |
0:d616ece2d859
|
659
|
pcb->nrtx = 0;
|
mbed714 |
0:d616ece2d859
|
660
|
}
|
mbed714 |
0:d616ece2d859
|
661
|
|
mbed714 |
0:d616ece2d859
|
662
|
tcp_seg_free(rseg);
|
mbed714 |
0:d616ece2d859
|
663
|
|
mbed714 |
0:d616ece2d859
|
664
|
/* Call the user specified function to call when sucessfully
|
mbed714 |
0:d616ece2d859
|
665
|
* connected. */
|
mbed714 |
0:d616ece2d859
|
666
|
TCP_EVENT_CONNECTED(pcb, ERR_OK, err);
|
mbed714 |
0:d616ece2d859
|
667
|
if (err == ERR_ABRT) {
|
mbed714 |
0:d616ece2d859
|
668
|
return ERR_ABRT;
|
mbed714 |
0:d616ece2d859
|
669
|
}
|
mbed714 |
0:d616ece2d859
|
670
|
tcp_ack_now(pcb);
|
mbed714 |
0:d616ece2d859
|
671
|
}
|
mbed714 |
0:d616ece2d859
|
672
|
/* received ACK? possibly a half-open connection */
|
mbed714 |
0:d616ece2d859
|
673
|
else if (flags & TCP_ACK) {
|
mbed714 |
0:d616ece2d859
|
674
|
/* send a RST to bring the other side in a non-synchronized state. */
|
mbed714 |
0:d616ece2d859
|
675
|
tcp_rst(ackno, seqno + tcplen, ip_current_dest_addr(), ip_current_src_addr(),
|
mbed714 |
0:d616ece2d859
|
676
|
tcphdr->dest, tcphdr->src);
|
mbed714 |
0:d616ece2d859
|
677
|
}
|
mbed714 |
0:d616ece2d859
|
678
|
break;
|
mbed714 |
0:d616ece2d859
|
679
|
case SYN_RCVD:
|
mbed714 |
0:d616ece2d859
|
680
|
if (flags & TCP_ACK) {
|
mbed714 |
0:d616ece2d859
|
681
|
/* expected ACK number? */
|
mbed714 |
0:d616ece2d859
|
682
|
if (TCP_SEQ_BETWEEN(ackno, pcb->lastack+1, pcb->snd_nxt)) {
|
mbed714 |
0:d616ece2d859
|
683
|
u16_t old_cwnd;
|
mbed714 |
0:d616ece2d859
|
684
|
pcb->state = ESTABLISHED;
|
mbed714 |
0:d616ece2d859
|
685
|
LWIP_DEBUGF(TCP_DEBUG, ("TCP connection established %"U16_F" -> %"U16_F".\n", inseg.tcphdr->src, inseg.tcphdr->dest));
|
mbed714 |
0:d616ece2d859
|
686
|
#if LWIP_CALLBACK_API
|
mbed714 |
0:d616ece2d859
|
687
|
LWIP_ASSERT("pcb->accept != NULL", pcb->accept != NULL);
|
mbed714 |
0:d616ece2d859
|
688
|
#endif
|
mbed714 |
0:d616ece2d859
|
689
|
/* Call the accept function. */
|
mbed714 |
0:d616ece2d859
|
690
|
TCP_EVENT_ACCEPT(pcb, ERR_OK, err);
|
mbed714 |
0:d616ece2d859
|
691
|
if (err != ERR_OK) {
|
mbed714 |
0:d616ece2d859
|
692
|
/* If the accept function returns with an error, we abort
|
mbed714 |
0:d616ece2d859
|
693
|
* the connection. */
|
mbed714 |
0:d616ece2d859
|
694
|
/* Already aborted? */
|
mbed714 |
0:d616ece2d859
|
695
|
if (err != ERR_ABRT) {
|
mbed714 |
0:d616ece2d859
|
696
|
tcp_abort(pcb);
|
mbed714 |
0:d616ece2d859
|
697
|
}
|
mbed714 |
0:d616ece2d859
|
698
|
return ERR_ABRT;
|
mbed714 |
0:d616ece2d859
|
699
|
}
|
mbed714 |
0:d616ece2d859
|
700
|
old_cwnd = pcb->cwnd;
|
mbed714 |
0:d616ece2d859
|
701
|
/* If there was any data contained within this ACK,
|
mbed714 |
0:d616ece2d859
|
702
|
* we'd better pass it on to the application as well. */
|
mbed714 |
0:d616ece2d859
|
703
|
tcp_receive(pcb);
|
mbed714 |
0:d616ece2d859
|
704
|
|
mbed714 |
0:d616ece2d859
|
705
|
/* Prevent ACK for SYN to generate a sent event */
|
mbed714 |
0:d616ece2d859
|
706
|
if (pcb->acked != 0) {
|
mbed714 |
0:d616ece2d859
|
707
|
pcb->acked--;
|
mbed714 |
0:d616ece2d859
|
708
|
}
|
mbed714 |
0:d616ece2d859
|
709
|
|
mbed714 |
0:d616ece2d859
|
710
|
pcb->cwnd = ((old_cwnd == 1) ? (pcb->mss * 2) : pcb->mss);
|
mbed714 |
0:d616ece2d859
|
711
|
|
mbed714 |
0:d616ece2d859
|
712
|
if (recv_flags & TF_GOT_FIN) {
|
mbed714 |
0:d616ece2d859
|
713
|
tcp_ack_now(pcb);
|
mbed714 |
0:d616ece2d859
|
714
|
pcb->state = CLOSE_WAIT;
|
mbed714 |
0:d616ece2d859
|
715
|
}
|
mbed714 |
0:d616ece2d859
|
716
|
} else {
|
mbed714 |
0:d616ece2d859
|
717
|
/* incorrect ACK number, send RST */
|
mbed714 |
0:d616ece2d859
|
718
|
tcp_rst(ackno, seqno + tcplen, ip_current_dest_addr(), ip_current_src_addr(),
|
mbed714 |
0:d616ece2d859
|
719
|
tcphdr->dest, tcphdr->src);
|
mbed714 |
0:d616ece2d859
|
720
|
}
|
mbed714 |
0:d616ece2d859
|
721
|
} else if ((flags & TCP_SYN) && (seqno == pcb->rcv_nxt - 1)) {
|
mbed714 |
0:d616ece2d859
|
722
|
/* Looks like another copy of the SYN - retransmit our SYN-ACK */
|
mbed714 |
0:d616ece2d859
|
723
|
tcp_rexmit(pcb);
|
mbed714 |
0:d616ece2d859
|
724
|
}
|
mbed714 |
0:d616ece2d859
|
725
|
break;
|
mbed714 |
0:d616ece2d859
|
726
|
case CLOSE_WAIT:
|
mbed714 |
0:d616ece2d859
|
727
|
/* FALLTHROUGH */
|
mbed714 |
0:d616ece2d859
|
728
|
case ESTABLISHED:
|
mbed714 |
0:d616ece2d859
|
729
|
tcp_receive(pcb);
|
mbed714 |
0:d616ece2d859
|
730
|
if (recv_flags & TF_GOT_FIN) { /* passive close */
|
mbed714 |
0:d616ece2d859
|
731
|
tcp_ack_now(pcb);
|
mbed714 |
0:d616ece2d859
|
732
|
pcb->state = CLOSE_WAIT;
|
mbed714 |
0:d616ece2d859
|
733
|
}
|
mbed714 |
0:d616ece2d859
|
734
|
break;
|
mbed714 |
0:d616ece2d859
|
735
|
case FIN_WAIT_1:
|
mbed714 |
0:d616ece2d859
|
736
|
tcp_receive(pcb);
|
mbed714 |
0:d616ece2d859
|
737
|
if (recv_flags & TF_GOT_FIN) {
|
mbed714 |
0:d616ece2d859
|
738
|
if ((flags & TCP_ACK) && (ackno == pcb->snd_nxt)) {
|
mbed714 |
0:d616ece2d859
|
739
|
LWIP_DEBUGF(TCP_DEBUG,
|
mbed714 |
0:d616ece2d859
|
740
|
("TCP connection closed: FIN_WAIT_1 %"U16_F" -> %"U16_F".\n", inseg.tcphdr->src, inseg.tcphdr->dest));
|
mbed714 |
0:d616ece2d859
|
741
|
tcp_ack_now(pcb);
|
mbed714 |
0:d616ece2d859
|
742
|
tcp_pcb_purge(pcb);
|
mbed714 |
0:d616ece2d859
|
743
|
TCP_RMV(&tcp_active_pcbs, pcb);
|
mbed714 |
0:d616ece2d859
|
744
|
pcb->state = TIME_WAIT;
|
mbed714 |
0:d616ece2d859
|
745
|
TCP_REG(&tcp_tw_pcbs, pcb);
|
mbed714 |
0:d616ece2d859
|
746
|
} else {
|
mbed714 |
0:d616ece2d859
|
747
|
tcp_ack_now(pcb);
|
mbed714 |
0:d616ece2d859
|
748
|
pcb->state = CLOSING;
|
mbed714 |
0:d616ece2d859
|
749
|
}
|
mbed714 |
0:d616ece2d859
|
750
|
} else if ((flags & TCP_ACK) && (ackno == pcb->snd_nxt)) {
|
mbed714 |
0:d616ece2d859
|
751
|
pcb->state = FIN_WAIT_2;
|
mbed714 |
0:d616ece2d859
|
752
|
}
|
mbed714 |
0:d616ece2d859
|
753
|
break;
|
mbed714 |
0:d616ece2d859
|
754
|
case FIN_WAIT_2:
|
mbed714 |
0:d616ece2d859
|
755
|
tcp_receive(pcb);
|
mbed714 |
0:d616ece2d859
|
756
|
if (recv_flags & TF_GOT_FIN) {
|
mbed714 |
0:d616ece2d859
|
757
|
LWIP_DEBUGF(TCP_DEBUG, ("TCP connection closed: FIN_WAIT_2 %"U16_F" -> %"U16_F".\n", inseg.tcphdr->src, inseg.tcphdr->dest));
|
mbed714 |
0:d616ece2d859
|
758
|
tcp_ack_now(pcb);
|
mbed714 |
0:d616ece2d859
|
759
|
tcp_pcb_purge(pcb);
|
mbed714 |
0:d616ece2d859
|
760
|
TCP_RMV(&tcp_active_pcbs, pcb);
|
mbed714 |
0:d616ece2d859
|
761
|
pcb->state = TIME_WAIT;
|
mbed714 |
0:d616ece2d859
|
762
|
TCP_REG(&tcp_tw_pcbs, pcb);
|
mbed714 |
0:d616ece2d859
|
763
|
}
|
mbed714 |
0:d616ece2d859
|
764
|
break;
|
mbed714 |
0:d616ece2d859
|
765
|
case CLOSING:
|
mbed714 |
0:d616ece2d859
|
766
|
tcp_receive(pcb);
|
mbed714 |
0:d616ece2d859
|
767
|
if (flags & TCP_ACK && ackno == pcb->snd_nxt) {
|
mbed714 |
0:d616ece2d859
|
768
|
LWIP_DEBUGF(TCP_DEBUG, ("TCP connection closed: CLOSING %"U16_F" -> %"U16_F".\n", inseg.tcphdr->src, inseg.tcphdr->dest));
|
mbed714 |
0:d616ece2d859
|
769
|
tcp_pcb_purge(pcb);
|
mbed714 |
0:d616ece2d859
|
770
|
TCP_RMV(&tcp_active_pcbs, pcb);
|
mbed714 |
0:d616ece2d859
|
771
|
pcb->state = TIME_WAIT;
|
mbed714 |
0:d616ece2d859
|
772
|
TCP_REG(&tcp_tw_pcbs, pcb);
|
mbed714 |
0:d616ece2d859
|
773
|
}
|
mbed714 |
0:d616ece2d859
|
774
|
break;
|
mbed714 |
0:d616ece2d859
|
775
|
case LAST_ACK:
|
mbed714 |
0:d616ece2d859
|
776
|
tcp_receive(pcb);
|
mbed714 |
0:d616ece2d859
|
777
|
if (flags & TCP_ACK && ackno == pcb->snd_nxt) {
|
mbed714 |
0:d616ece2d859
|
778
|
LWIP_DEBUGF(TCP_DEBUG, ("TCP connection closed: LAST_ACK %"U16_F" -> %"U16_F".\n", inseg.tcphdr->src, inseg.tcphdr->dest));
|
mbed714 |
0:d616ece2d859
|
779
|
/* bugfix #21699: don't set pcb->state to CLOSED here or we risk leaking segments */
|
mbed714 |
0:d616ece2d859
|
780
|
recv_flags |= TF_CLOSED;
|
mbed714 |
0:d616ece2d859
|
781
|
}
|
mbed714 |
0:d616ece2d859
|
782
|
break;
|
mbed714 |
0:d616ece2d859
|
783
|
default:
|
mbed714 |
0:d616ece2d859
|
784
|
break;
|
mbed714 |
0:d616ece2d859
|
785
|
}
|
mbed714 |
0:d616ece2d859
|
786
|
return ERR_OK;
|
mbed714 |
0:d616ece2d859
|
787
|
}
|
mbed714 |
0:d616ece2d859
|
788
|
|
mbed714 |
0:d616ece2d859
|
789
|
#if TCP_QUEUE_OOSEQ
|
mbed714 |
0:d616ece2d859
|
790
|
/**
|
mbed714 |
0:d616ece2d859
|
791
|
* Insert segment into the list (segments covered with new one will be deleted)
|
mbed714 |
0:d616ece2d859
|
792
|
*
|
mbed714 |
0:d616ece2d859
|
793
|
* Called from tcp_receive()
|
mbed714 |
0:d616ece2d859
|
794
|
*/
|
mbed714 |
0:d616ece2d859
|
795
|
static void
|
mbed714 |
0:d616ece2d859
|
796
|
tcp_oos_insert_segment(struct tcp_seg *cseg, struct tcp_seg *next)
|
mbed714 |
0:d616ece2d859
|
797
|
{
|
mbed714 |
0:d616ece2d859
|
798
|
struct tcp_seg *old_seg;
|
mbed714 |
0:d616ece2d859
|
799
|
|
mbed714 |
0:d616ece2d859
|
800
|
if (TCPH_FLAGS(cseg->tcphdr) & TCP_FIN) {
|
mbed714 |
0:d616ece2d859
|
801
|
/* received segment overlaps all following segments */
|
mbed714 |
0:d616ece2d859
|
802
|
tcp_segs_free(next);
|
mbed714 |
0:d616ece2d859
|
803
|
next = NULL;
|
mbed714 |
0:d616ece2d859
|
804
|
}
|
mbed714 |
0:d616ece2d859
|
805
|
else {
|
mbed714 |
0:d616ece2d859
|
806
|
/* delete some following segments
|
mbed714 |
0:d616ece2d859
|
807
|
oos queue may have segments with FIN flag */
|
mbed714 |
0:d616ece2d859
|
808
|
while (next &&
|
mbed714 |
0:d616ece2d859
|
809
|
TCP_SEQ_GEQ((seqno + cseg->len),
|
mbed714 |
0:d616ece2d859
|
810
|
(next->tcphdr->seqno + next->len))) {
|
mbed714 |
0:d616ece2d859
|
811
|
/* cseg with FIN already processed */
|
mbed714 |
0:d616ece2d859
|
812
|
if (TCPH_FLAGS(next->tcphdr) & TCP_FIN) {
|
mbed714 |
0:d616ece2d859
|
813
|
TCPH_SET_FLAG(cseg->tcphdr, TCP_FIN);
|
mbed714 |
0:d616ece2d859
|
814
|
}
|
mbed714 |
0:d616ece2d859
|
815
|
old_seg = next;
|
mbed714 |
0:d616ece2d859
|
816
|
next = next->next;
|
mbed714 |
0:d616ece2d859
|
817
|
tcp_seg_free(old_seg);
|
mbed714 |
0:d616ece2d859
|
818
|
}
|
mbed714 |
0:d616ece2d859
|
819
|
if (next &&
|
mbed714 |
0:d616ece2d859
|
820
|
TCP_SEQ_GT(seqno + cseg->len, next->tcphdr->seqno)) {
|
mbed714 |
0:d616ece2d859
|
821
|
/* We need to trim the incoming segment. */
|
mbed714 |
0:d616ece2d859
|
822
|
cseg->len = (u16_t)(next->tcphdr->seqno - seqno);
|
mbed714 |
0:d616ece2d859
|
823
|
pbuf_realloc(cseg->p, cseg->len);
|
mbed714 |
0:d616ece2d859
|
824
|
}
|
mbed714 |
0:d616ece2d859
|
825
|
}
|
mbed714 |
0:d616ece2d859
|
826
|
cseg->next = next;
|
mbed714 |
0:d616ece2d859
|
827
|
}
|
mbed714 |
0:d616ece2d859
|
828
|
#endif /* TCP_QUEUE_OOSEQ */
|
mbed714 |
0:d616ece2d859
|
829
|
|
mbed714 |
0:d616ece2d859
|
830
|
/**
|
mbed714 |
0:d616ece2d859
|
831
|
* Called by tcp_process. Checks if the given segment is an ACK for outstanding
|
mbed714 |
0:d616ece2d859
|
832
|
* data, and if so frees the memory of the buffered data. Next, is places the
|
mbed714 |
0:d616ece2d859
|
833
|
* segment on any of the receive queues (pcb->recved or pcb->ooseq). If the segment
|
mbed714 |
0:d616ece2d859
|
834
|
* is buffered, the pbuf is referenced by pbuf_ref so that it will not be freed until
|
mbed714 |
0:d616ece2d859
|
835
|
* i it has been removed from the buffer.
|
mbed714 |
0:d616ece2d859
|
836
|
*
|
mbed714 |
0:d616ece2d859
|
837
|
* If the incoming segment constitutes an ACK for a segment that was used for RTT
|
mbed714 |
0:d616ece2d859
|
838
|
* estimation, the RTT is estimated here as well.
|
mbed714 |
0:d616ece2d859
|
839
|
*
|
mbed714 |
0:d616ece2d859
|
840
|
* Called from tcp_process().
|
mbed714 |
0:d616ece2d859
|
841
|
*/
|
mbed714 |
0:d616ece2d859
|
842
|
static void
|
mbed714 |
0:d616ece2d859
|
843
|
tcp_receive(struct tcp_pcb *pcb)
|
mbed714 |
0:d616ece2d859
|
844
|
{
|
mbed714 |
0:d616ece2d859
|
845
|
struct tcp_seg *next;
|
mbed714 |
0:d616ece2d859
|
846
|
#if TCP_QUEUE_OOSEQ
|
mbed714 |
0:d616ece2d859
|
847
|
struct tcp_seg *prev, *cseg;
|
mbed714 |
0:d616ece2d859
|
848
|
#endif /* TCP_QUEUE_OOSEQ */
|
mbed714 |
0:d616ece2d859
|
849
|
struct pbuf *p;
|
mbed714 |
0:d616ece2d859
|
850
|
s32_t off;
|
mbed714 |
0:d616ece2d859
|
851
|
s16_t m;
|
mbed714 |
0:d616ece2d859
|
852
|
u32_t right_wnd_edge;
|
mbed714 |
0:d616ece2d859
|
853
|
u16_t new_tot_len;
|
mbed714 |
0:d616ece2d859
|
854
|
int found_dupack = 0;
|
mbed714 |
0:d616ece2d859
|
855
|
|
mbed714 |
0:d616ece2d859
|
856
|
if (flags & TCP_ACK) {
|
mbed714 |
0:d616ece2d859
|
857
|
right_wnd_edge = pcb->snd_wnd + pcb->snd_wl2;
|
mbed714 |
0:d616ece2d859
|
858
|
|
mbed714 |
0:d616ece2d859
|
859
|
/* Update window. */
|
mbed714 |
0:d616ece2d859
|
860
|
if (TCP_SEQ_LT(pcb->snd_wl1, seqno) ||
|
mbed714 |
0:d616ece2d859
|
861
|
(pcb->snd_wl1 == seqno && TCP_SEQ_LT(pcb->snd_wl2, ackno)) ||
|
mbed714 |
0:d616ece2d859
|
862
|
(pcb->snd_wl2 == ackno && tcphdr->wnd > pcb->snd_wnd)) {
|
mbed714 |
0:d616ece2d859
|
863
|
pcb->snd_wnd = tcphdr->wnd;
|
mbed714 |
0:d616ece2d859
|
864
|
pcb->snd_wl1 = seqno;
|
mbed714 |
0:d616ece2d859
|
865
|
pcb->snd_wl2 = ackno;
|
mbed714 |
0:d616ece2d859
|
866
|
if (pcb->snd_wnd > 0 && pcb->persist_backoff > 0) {
|
mbed714 |
0:d616ece2d859
|
867
|
pcb->persist_backoff = 0;
|
mbed714 |
0:d616ece2d859
|
868
|
}
|
mbed714 |
0:d616ece2d859
|
869
|
LWIP_DEBUGF(TCP_WND_DEBUG, ("tcp_receive: window update %"U16_F"\n", pcb->snd_wnd));
|
mbed714 |
0:d616ece2d859
|
870
|
#if TCP_WND_DEBUG
|
mbed714 |
0:d616ece2d859
|
871
|
} else {
|
mbed714 |
0:d616ece2d859
|
872
|
if (pcb->snd_wnd != tcphdr->wnd) {
|
mbed714 |
0:d616ece2d859
|
873
|
LWIP_DEBUGF(TCP_WND_DEBUG,
|
mbed714 |
0:d616ece2d859
|
874
|
("tcp_receive: no window update lastack %"U32_F" ackno %"
|
mbed714 |
0:d616ece2d859
|
875
|
U32_F" wl1 %"U32_F" seqno %"U32_F" wl2 %"U32_F"\n",
|
mbed714 |
0:d616ece2d859
|
876
|
pcb->lastack, ackno, pcb->snd_wl1, seqno, pcb->snd_wl2));
|
mbed714 |
0:d616ece2d859
|
877
|
}
|
mbed714 |
0:d616ece2d859
|
878
|
#endif /* TCP_WND_DEBUG */
|
mbed714 |
0:d616ece2d859
|
879
|
}
|
mbed714 |
0:d616ece2d859
|
880
|
|
mbed714 |
0:d616ece2d859
|
881
|
/* (From Stevens TCP/IP Illustrated Vol II, p970.) Its only a
|
mbed714 |
0:d616ece2d859
|
882
|
* duplicate ack if:
|
mbed714 |
0:d616ece2d859
|
883
|
* 1) It doesn't ACK new data
|
mbed714 |
0:d616ece2d859
|
884
|
* 2) length of received packet is zero (i.e. no payload)
|
mbed714 |
0:d616ece2d859
|
885
|
* 3) the advertised window hasn't changed
|
mbed714 |
0:d616ece2d859
|
886
|
* 4) There is outstanding unacknowledged data (retransmission timer running)
|
mbed714 |
0:d616ece2d859
|
887
|
* 5) The ACK is == biggest ACK sequence number so far seen (snd_una)
|
mbed714 |
0:d616ece2d859
|
888
|
*
|
mbed714 |
0:d616ece2d859
|
889
|
* If it passes all five, should process as a dupack:
|
mbed714 |
0:d616ece2d859
|
890
|
* a) dupacks < 3: do nothing
|
mbed714 |
0:d616ece2d859
|
891
|
* b) dupacks == 3: fast retransmit
|
mbed714 |
0:d616ece2d859
|
892
|
* c) dupacks > 3: increase cwnd
|
mbed714 |
0:d616ece2d859
|
893
|
*
|
mbed714 |
0:d616ece2d859
|
894
|
* If it only passes 1-3, should reset dupack counter (and add to
|
mbed714 |
0:d616ece2d859
|
895
|
* stats, which we don't do in lwIP)
|
mbed714 |
0:d616ece2d859
|
896
|
*
|
mbed714 |
0:d616ece2d859
|
897
|
* If it only passes 1, should reset dupack counter
|
mbed714 |
0:d616ece2d859
|
898
|
*
|
mbed714 |
0:d616ece2d859
|
899
|
*/
|
mbed714 |
0:d616ece2d859
|
900
|
|
mbed714 |
0:d616ece2d859
|
901
|
/* Clause 1 */
|
mbed714 |
0:d616ece2d859
|
902
|
if (TCP_SEQ_LEQ(ackno, pcb->lastack)) {
|
mbed714 |
0:d616ece2d859
|
903
|
pcb->acked = 0;
|
mbed714 |
0:d616ece2d859
|
904
|
/* Clause 2 */
|
mbed714 |
0:d616ece2d859
|
905
|
if (tcplen == 0) {
|
mbed714 |
0:d616ece2d859
|
906
|
/* Clause 3 */
|
mbed714 |
0:d616ece2d859
|
907
|
if (pcb->snd_wl2 + pcb->snd_wnd == right_wnd_edge){
|
mbed714 |
0:d616ece2d859
|
908
|
/* Clause 4 */
|
mbed714 |
0:d616ece2d859
|
909
|
if (pcb->rtime >= 0) {
|
mbed714 |
0:d616ece2d859
|
910
|
/* Clause 5 */
|
mbed714 |
0:d616ece2d859
|
911
|
if (pcb->lastack == ackno) {
|
mbed714 |
0:d616ece2d859
|
912
|
found_dupack = 1;
|
mbed714 |
0:d616ece2d859
|
913
|
if (pcb->dupacks + 1 > pcb->dupacks)
|
mbed714 |
0:d616ece2d859
|
914
|
++pcb->dupacks;
|
mbed714 |
0:d616ece2d859
|
915
|
if (pcb->dupacks > 3) {
|
mbed714 |
0:d616ece2d859
|
916
|
/* Inflate the congestion window, but not if it means that
|
mbed714 |
0:d616ece2d859
|
917
|
the value overflows. */
|
mbed714 |
0:d616ece2d859
|
918
|
if ((u16_t)(pcb->cwnd + pcb->mss) > pcb->cwnd) {
|
mbed714 |
0:d616ece2d859
|
919
|
pcb->cwnd += pcb->mss;
|
mbed714 |
0:d616ece2d859
|
920
|
}
|
mbed714 |
0:d616ece2d859
|
921
|
} else if (pcb->dupacks == 3) {
|
mbed714 |
0:d616ece2d859
|
922
|
/* Do fast retransmit */
|
mbed714 |
0:d616ece2d859
|
923
|
tcp_rexmit_fast(pcb);
|
mbed714 |
0:d616ece2d859
|
924
|
}
|
mbed714 |
0:d616ece2d859
|
925
|
}
|
mbed714 |
0:d616ece2d859
|
926
|
}
|
mbed714 |
0:d616ece2d859
|
927
|
}
|
mbed714 |
0:d616ece2d859
|
928
|
}
|
mbed714 |
0:d616ece2d859
|
929
|
/* If Clause (1) or more is true, but not a duplicate ack, reset
|
mbed714 |
0:d616ece2d859
|
930
|
* count of consecutive duplicate acks */
|
mbed714 |
0:d616ece2d859
|
931
|
if (!found_dupack) {
|
mbed714 |
0:d616ece2d859
|
932
|
pcb->dupacks = 0;
|
mbed714 |
0:d616ece2d859
|
933
|
}
|
mbed714 |
0:d616ece2d859
|
934
|
} else if (TCP_SEQ_BETWEEN(ackno, pcb->lastack+1, pcb->snd_nxt)){
|
mbed714 |
0:d616ece2d859
|
935
|
/* We come here when the ACK acknowledges new data. */
|
mbed714 |
0:d616ece2d859
|
936
|
|
mbed714 |
0:d616ece2d859
|
937
|
/* Reset the "IN Fast Retransmit" flag, since we are no longer
|
mbed714 |
0:d616ece2d859
|
938
|
in fast retransmit. Also reset the congestion window to the
|
mbed714 |
0:d616ece2d859
|
939
|
slow start threshold. */
|
mbed714 |
0:d616ece2d859
|
940
|
if (pcb->flags & TF_INFR) {
|
mbed714 |
0:d616ece2d859
|
941
|
pcb->flags &= ~TF_INFR;
|
mbed714 |
0:d616ece2d859
|
942
|
pcb->cwnd = pcb->ssthresh;
|
mbed714 |
0:d616ece2d859
|
943
|
}
|
mbed714 |
0:d616ece2d859
|
944
|
|
mbed714 |
0:d616ece2d859
|
945
|
/* Reset the number of retransmissions. */
|
mbed714 |
0:d616ece2d859
|
946
|
pcb->nrtx = 0;
|
mbed714 |
0:d616ece2d859
|
947
|
|
mbed714 |
0:d616ece2d859
|
948
|
/* Reset the retransmission time-out. */
|
mbed714 |
0:d616ece2d859
|
949
|
pcb->rto = (pcb->sa >> 3) + pcb->sv;
|
mbed714 |
0:d616ece2d859
|
950
|
|
mbed714 |
0:d616ece2d859
|
951
|
/* Update the send buffer space. Diff between the two can never exceed 64K? */
|
mbed714 |
0:d616ece2d859
|
952
|
pcb->acked = (u16_t)(ackno - pcb->lastack);
|
mbed714 |
0:d616ece2d859
|
953
|
|
mbed714 |
0:d616ece2d859
|
954
|
pcb->snd_buf += pcb->acked;
|
mbed714 |
0:d616ece2d859
|
955
|
|
mbed714 |
0:d616ece2d859
|
956
|
/* Reset the fast retransmit variables. */
|
mbed714 |
0:d616ece2d859
|
957
|
pcb->dupacks = 0;
|
mbed714 |
0:d616ece2d859
|
958
|
pcb->lastack = ackno;
|
mbed714 |
0:d616ece2d859
|
959
|
|
mbed714 |
0:d616ece2d859
|
960
|
/* Update the congestion control variables (cwnd and
|
mbed714 |
0:d616ece2d859
|
961
|
ssthresh). */
|
mbed714 |
0:d616ece2d859
|
962
|
if (pcb->state >= ESTABLISHED) {
|
mbed714 |
0:d616ece2d859
|
963
|
if (pcb->cwnd < pcb->ssthresh) {
|
mbed714 |
0:d616ece2d859
|
964
|
if ((u16_t)(pcb->cwnd + pcb->mss) > pcb->cwnd) {
|
mbed714 |
0:d616ece2d859
|
965
|
pcb->cwnd += pcb->mss;
|
mbed714 |
0:d616ece2d859
|
966
|
}
|
mbed714 |
0:d616ece2d859
|
967
|
LWIP_DEBUGF(TCP_CWND_DEBUG, ("tcp_receive: slow start cwnd %"U16_F"\n", pcb->cwnd));
|
mbed714 |
0:d616ece2d859
|
968
|
} else {
|
mbed714 |
0:d616ece2d859
|
969
|
u16_t new_cwnd = (pcb->cwnd + pcb->mss * pcb->mss / pcb->cwnd);
|
mbed714 |
0:d616ece2d859
|
970
|
if (new_cwnd > pcb->cwnd) {
|
mbed714 |
0:d616ece2d859
|
971
|
pcb->cwnd = new_cwnd;
|
mbed714 |
0:d616ece2d859
|
972
|
}
|
mbed714 |
0:d616ece2d859
|
973
|
LWIP_DEBUGF(TCP_CWND_DEBUG, ("tcp_receive: congestion avoidance cwnd %"U16_F"\n", pcb->cwnd));
|
mbed714 |
0:d616ece2d859
|
974
|
}
|
mbed714 |
0:d616ece2d859
|
975
|
}
|
mbed714 |
0:d616ece2d859
|
976
|
LWIP_DEBUGF(TCP_INPUT_DEBUG, ("tcp_receive: ACK for %"U32_F", unacked->seqno %"U32_F":%"U32_F"\n",
|
mbed714 |
0:d616ece2d859
|
977
|
ackno,
|
mbed714 |
0:d616ece2d859
|
978
|
pcb->unacked != NULL?
|
mbed714 |
0:d616ece2d859
|
979
|
ntohl(pcb->unacked->tcphdr->seqno): 0,
|
mbed714 |
0:d616ece2d859
|
980
|
pcb->unacked != NULL?
|
mbed714 |
0:d616ece2d859
|
981
|
ntohl(pcb->unacked->tcphdr->seqno) + TCP_TCPLEN(pcb->unacked): 0));
|
mbed714 |
0:d616ece2d859
|
982
|
|
mbed714 |
0:d616ece2d859
|
983
|
/* Remove segment from the unacknowledged list if the incoming
|
mbed714 |
0:d616ece2d859
|
984
|
ACK acknowlegdes them. */
|
mbed714 |
0:d616ece2d859
|
985
|
while (pcb->unacked != NULL &&
|
mbed714 |
0:d616ece2d859
|
986
|
TCP_SEQ_LEQ(ntohl(pcb->unacked->tcphdr->seqno) +
|
mbed714 |
0:d616ece2d859
|
987
|
TCP_TCPLEN(pcb->unacked), ackno)) {
|
mbed714 |
0:d616ece2d859
|
988
|
LWIP_DEBUGF(TCP_INPUT_DEBUG, ("tcp_receive: removing %"U32_F":%"U32_F" from pcb->unacked\n",
|
mbed714 |
0:d616ece2d859
|
989
|
ntohl(pcb->unacked->tcphdr->seqno),
|
mbed714 |
0:d616ece2d859
|
990
|
ntohl(pcb->unacked->tcphdr->seqno) +
|
mbed714 |
0:d616ece2d859
|
991
|
TCP_TCPLEN(pcb->unacked)));
|
mbed714 |
0:d616ece2d859
|
992
|
|
mbed714 |
0:d616ece2d859
|
993
|
next = pcb->unacked;
|
mbed714 |
0:d616ece2d859
|
994
|
pcb->unacked = pcb->unacked->next;
|
mbed714 |
0:d616ece2d859
|
995
|
|
mbed714 |
0:d616ece2d859
|
996
|
LWIP_DEBUGF(TCP_QLEN_DEBUG, ("tcp_receive: queuelen %"U16_F" ... ", (u16_t)pcb->snd_queuelen));
|
mbed714 |
0:d616ece2d859
|
997
|
LWIP_ASSERT("pcb->snd_queuelen >= pbuf_clen(next->p)", (pcb->snd_queuelen >= pbuf_clen(next->p)));
|
mbed714 |
0:d616ece2d859
|
998
|
/* Prevent ACK for FIN to generate a sent event */
|
mbed714 |
0:d616ece2d859
|
999
|
if ((pcb->acked != 0) && ((TCPH_FLAGS(next->tcphdr) & TCP_FIN) != 0)) {
|
mbed714 |
0:d616ece2d859
|
1000
|
pcb->acked--;
|
mbed714 |
0:d616ece2d859
|
1001
|
}
|
mbed714 |
0:d616ece2d859
|
1002
|
|
mbed714 |
0:d616ece2d859
|
1003
|
pcb->snd_queuelen -= pbuf_clen(next->p);
|
mbed714 |
0:d616ece2d859
|
1004
|
tcp_seg_free(next);
|
mbed714 |
0:d616ece2d859
|
1005
|
|
mbed714 |
0:d616ece2d859
|
1006
|
LWIP_DEBUGF(TCP_QLEN_DEBUG, ("%"U16_F" (after freeing unacked)\n", (u16_t)pcb->snd_queuelen));
|
mbed714 |
0:d616ece2d859
|
1007
|
if (pcb->snd_queuelen != 0) {
|
mbed714 |
0:d616ece2d859
|
1008
|
LWIP_ASSERT("tcp_receive: valid queue length", pcb->unacked != NULL ||
|
mbed714 |
0:d616ece2d859
|
1009
|
pcb->unsent != NULL);
|
mbed714 |
0:d616ece2d859
|
1010
|
}
|
mbed714 |
0:d616ece2d859
|
1011
|
}
|
mbed714 |
0:d616ece2d859
|
1012
|
|
mbed714 |
0:d616ece2d859
|
1013
|
/* If there's nothing left to acknowledge, stop the retransmit
|
mbed714 |
0:d616ece2d859
|
1014
|
timer, otherwise reset it to start again */
|
mbed714 |
0:d616ece2d859
|
1015
|
if(pcb->unacked == NULL)
|
mbed714 |
0:d616ece2d859
|
1016
|
pcb->rtime = -1;
|
mbed714 |
0:d616ece2d859
|
1017
|
else
|
mbed714 |
0:d616ece2d859
|
1018
|
pcb->rtime = 0;
|
mbed714 |
0:d616ece2d859
|
1019
|
|
mbed714 |
0:d616ece2d859
|
1020
|
pcb->polltmr = 0;
|
mbed714 |
0:d616ece2d859
|
1021
|
} else {
|
mbed714 |
0:d616ece2d859
|
1022
|
/* Fix bug bug #21582: out of sequence ACK, didn't really ack anything */
|
mbed714 |
0:d616ece2d859
|
1023
|
pcb->acked = 0;
|
mbed714 |
0:d616ece2d859
|
1024
|
}
|
mbed714 |
0:d616ece2d859
|
1025
|
|
mbed714 |
0:d616ece2d859
|
1026
|
/* We go through the ->unsent list to see if any of the segments
|
mbed714 |
0:d616ece2d859
|
1027
|
on the list are acknowledged by the ACK. This may seem
|
mbed714 |
0:d616ece2d859
|
1028
|
strange since an "unsent" segment shouldn't be acked. The
|
mbed714 |
0:d616ece2d859
|
1029
|
rationale is that lwIP puts all outstanding segments on the
|
mbed714 |
0:d616ece2d859
|
1030
|
->unsent list after a retransmission, so these segments may
|
mbed714 |
0:d616ece2d859
|
1031
|
in fact have been sent once. */
|
mbed714 |
0:d616ece2d859
|
1032
|
while (pcb->unsent != NULL &&
|
mbed714 |
0:d616ece2d859
|
1033
|
TCP_SEQ_BETWEEN(ackno, ntohl(pcb->unsent->tcphdr->seqno) +
|
mbed714 |
0:d616ece2d859
|
1034
|
TCP_TCPLEN(pcb->unsent), pcb->snd_nxt)) {
|
mbed714 |
0:d616ece2d859
|
1035
|
LWIP_DEBUGF(TCP_INPUT_DEBUG, ("tcp_receive: removing %"U32_F":%"U32_F" from pcb->unsent\n",
|
mbed714 |
0:d616ece2d859
|
1036
|
ntohl(pcb->unsent->tcphdr->seqno), ntohl(pcb->unsent->tcphdr->seqno) +
|
mbed714 |
0:d616ece2d859
|
1037
|
TCP_TCPLEN(pcb->unsent)));
|
mbed714 |
0:d616ece2d859
|
1038
|
|
mbed714 |
0:d616ece2d859
|
1039
|
next = pcb->unsent;
|
mbed714 |
0:d616ece2d859
|
1040
|
pcb->unsent = pcb->unsent->next;
|
mbed714 |
0:d616ece2d859
|
1041
|
LWIP_DEBUGF(TCP_QLEN_DEBUG, ("tcp_receive: queuelen %"U16_F" ... ", (u16_t)pcb->snd_queuelen));
|
mbed714 |
0:d616ece2d859
|
1042
|
LWIP_ASSERT("pcb->snd_queuelen >= pbuf_clen(next->p)", (pcb->snd_queuelen >= pbuf_clen(next->p)));
|
mbed714 |
0:d616ece2d859
|
1043
|
/* Prevent ACK for FIN to generate a sent event */
|
mbed714 |
0:d616ece2d859
|
1044
|
if ((pcb->acked != 0) && ((TCPH_FLAGS(next->tcphdr) & TCP_FIN) != 0)) {
|
mbed714 |
0:d616ece2d859
|
1045
|
pcb->acked--;
|
mbed714 |
0:d616ece2d859
|
1046
|
}
|
mbed714 |
0:d616ece2d859
|
1047
|
pcb->snd_queuelen -= pbuf_clen(next->p);
|
mbed714 |
0:d616ece2d859
|
1048
|
tcp_seg_free(next);
|
mbed714 |
0:d616ece2d859
|
1049
|
LWIP_DEBUGF(TCP_QLEN_DEBUG, ("%"U16_F" (after freeing unsent)\n", (u16_t)pcb->snd_queuelen));
|
mbed714 |
0:d616ece2d859
|
1050
|
if (pcb->snd_queuelen != 0) {
|
mbed714 |
0:d616ece2d859
|
1051
|
LWIP_ASSERT("tcp_receive: valid queue length",
|
mbed714 |
0:d616ece2d859
|
1052
|
pcb->unacked != NULL || pcb->unsent != NULL);
|
mbed714 |
0:d616ece2d859
|
1053
|
}
|
mbed714 |
0:d616ece2d859
|
1054
|
}
|
mbed714 |
0:d616ece2d859
|
1055
|
/* End of ACK for new data processing. */
|
mbed714 |
0:d616ece2d859
|
1056
|
|
mbed714 |
0:d616ece2d859
|
1057
|
LWIP_DEBUGF(TCP_RTO_DEBUG, ("tcp_receive: pcb->rttest %"U32_F" rtseq %"U32_F" ackno %"U32_F"\n",
|
mbed714 |
0:d616ece2d859
|
1058
|
pcb->rttest, pcb->rtseq, ackno));
|
mbed714 |
0:d616ece2d859
|
1059
|
|
mbed714 |
0:d616ece2d859
|
1060
|
/* RTT estimation calculations. This is done by checking if the
|
mbed714 |
0:d616ece2d859
|
1061
|
incoming segment acknowledges the segment we use to take a
|
mbed714 |
0:d616ece2d859
|
1062
|
round-trip time measurement. */
|
mbed714 |
0:d616ece2d859
|
1063
|
if (pcb->rttest && TCP_SEQ_LT(pcb->rtseq, ackno)) {
|
mbed714 |
0:d616ece2d859
|
1064
|
/* diff between this shouldn't exceed 32K since this are tcp timer ticks
|
mbed714 |
0:d616ece2d859
|
1065
|
and a round-trip shouldn't be that long... */
|
mbed714 |
0:d616ece2d859
|
1066
|
m = (s16_t)(tcp_ticks - pcb->rttest);
|
mbed714 |
0:d616ece2d859
|
1067
|
|
mbed714 |
0:d616ece2d859
|
1068
|
LWIP_DEBUGF(TCP_RTO_DEBUG, ("tcp_receive: experienced rtt %"U16_F" ticks (%"U16_F" msec).\n",
|
mbed714 |
0:d616ece2d859
|
1069
|
m, m * TCP_SLOW_INTERVAL));
|
mbed714 |
0:d616ece2d859
|
1070
|
|
mbed714 |
0:d616ece2d859
|
1071
|
/* This is taken directly from VJs original code in his paper */
|
mbed714 |
0:d616ece2d859
|
1072
|
m = m - (pcb->sa >> 3);
|
mbed714 |
0:d616ece2d859
|
1073
|
pcb->sa += m;
|
mbed714 |
0:d616ece2d859
|
1074
|
if (m < 0) {
|
mbed714 |
0:d616ece2d859
|
1075
|
m = -m;
|
mbed714 |
0:d616ece2d859
|
1076
|
}
|
mbed714 |
0:d616ece2d859
|
1077
|
m = m - (pcb->sv >> 2);
|
mbed714 |
0:d616ece2d859
|
1078
|
pcb->sv += m;
|
mbed714 |
0:d616ece2d859
|
1079
|
pcb->rto = (pcb->sa >> 3) + pcb->sv;
|
mbed714 |
0:d616ece2d859
|
1080
|
|
mbed714 |
0:d616ece2d859
|
1081
|
LWIP_DEBUGF(TCP_RTO_DEBUG, ("tcp_receive: RTO %"U16_F" (%"U16_F" milliseconds)\n",
|
mbed714 |
0:d616ece2d859
|
1082
|
pcb->rto, pcb->rto * TCP_SLOW_INTERVAL));
|
mbed714 |
0:d616ece2d859
|
1083
|
|
mbed714 |
0:d616ece2d859
|
1084
|
pcb->rttest = 0;
|
mbed714 |
0:d616ece2d859
|
1085
|
}
|
mbed714 |
0:d616ece2d859
|
1086
|
}
|
mbed714 |
0:d616ece2d859
|
1087
|
|
mbed714 |
0:d616ece2d859
|
1088
|
/* If the incoming segment contains data, we must process it
|
mbed714 |
0:d616ece2d859
|
1089
|
further. */
|
mbed714 |
0:d616ece2d859
|
1090
|
if (tcplen > 0) {
|
mbed714 |
0:d616ece2d859
|
1091
|
/* This code basically does three things:
|
mbed714 |
0:d616ece2d859
|
1092
|
|
mbed714 |
0:d616ece2d859
|
1093
|
+) If the incoming segment contains data that is the next
|
mbed714 |
0:d616ece2d859
|
1094
|
in-sequence data, this data is passed to the application. This
|
mbed714 |
0:d616ece2d859
|
1095
|
might involve trimming the first edge of the data. The rcv_nxt
|
mbed714 |
0:d616ece2d859
|
1096
|
variable and the advertised window are adjusted.
|
mbed714 |
0:d616ece2d859
|
1097
|
|
mbed714 |
0:d616ece2d859
|
1098
|
+) If the incoming segment has data that is above the next
|
mbed714 |
0:d616ece2d859
|
1099
|
sequence number expected (->rcv_nxt), the segment is placed on
|
mbed714 |
0:d616ece2d859
|
1100
|
the ->ooseq queue. This is done by finding the appropriate
|
mbed714 |
0:d616ece2d859
|
1101
|
place in the ->ooseq queue (which is ordered by sequence
|
mbed714 |
0:d616ece2d859
|
1102
|
number) and trim the segment in both ends if needed. An
|
mbed714 |
0:d616ece2d859
|
1103
|
immediate ACK is sent to indicate that we received an
|
mbed714 |
0:d616ece2d859
|
1104
|
out-of-sequence segment.
|
mbed714 |
0:d616ece2d859
|
1105
|
|
mbed714 |
0:d616ece2d859
|
1106
|
+) Finally, we check if the first segment on the ->ooseq queue
|
mbed714 |
0:d616ece2d859
|
1107
|
now is in sequence (i.e., if rcv_nxt >= ooseq->seqno). If
|
mbed714 |
0:d616ece2d859
|
1108
|
rcv_nxt > ooseq->seqno, we must trim the first edge of the
|
mbed714 |
0:d616ece2d859
|
1109
|
segment on ->ooseq before we adjust rcv_nxt. The data in the
|
mbed714 |
0:d616ece2d859
|
1110
|
segments that are now on sequence are chained onto the
|
mbed714 |
0:d616ece2d859
|
1111
|
incoming segment so that we only need to call the application
|
mbed714 |
0:d616ece2d859
|
1112
|
once.
|
mbed714 |
0:d616ece2d859
|
1113
|
*/
|
mbed714 |
0:d616ece2d859
|
1114
|
|
mbed714 |
0:d616ece2d859
|
1115
|
/* First, we check if we must trim the first edge. We have to do
|
mbed714 |
0:d616ece2d859
|
1116
|
this if the sequence number of the incoming segment is less
|
mbed714 |
0:d616ece2d859
|
1117
|
than rcv_nxt, and the sequence number plus the length of the
|
mbed714 |
0:d616ece2d859
|
1118
|
segment is larger than rcv_nxt. */
|
mbed714 |
0:d616ece2d859
|
1119
|
/* if (TCP_SEQ_LT(seqno, pcb->rcv_nxt)){
|
mbed714 |
0:d616ece2d859
|
1120
|
if (TCP_SEQ_LT(pcb->rcv_nxt, seqno + tcplen)) {*/
|
mbed714 |
0:d616ece2d859
|
1121
|
if (TCP_SEQ_BETWEEN(pcb->rcv_nxt, seqno + 1, seqno + tcplen - 1)){
|
mbed714 |
0:d616ece2d859
|
1122
|
/* Trimming the first edge is done by pushing the payload
|
mbed714 |
0:d616ece2d859
|
1123
|
pointer in the pbuf downwards. This is somewhat tricky since
|
mbed714 |
0:d616ece2d859
|
1124
|
we do not want to discard the full contents of the pbuf up to
|
mbed714 |
0:d616ece2d859
|
1125
|
the new starting point of the data since we have to keep the
|
mbed714 |
0:d616ece2d859
|
1126
|
TCP header which is present in the first pbuf in the chain.
|
mbed714 |
0:d616ece2d859
|
1127
|
|
mbed714 |
0:d616ece2d859
|
1128
|
What is done is really quite a nasty hack: the first pbuf in
|
mbed714 |
0:d616ece2d859
|
1129
|
the pbuf chain is pointed to by inseg.p. Since we need to be
|
mbed714 |
0:d616ece2d859
|
1130
|
able to deallocate the whole pbuf, we cannot change this
|
mbed714 |
0:d616ece2d859
|
1131
|
inseg.p pointer to point to any of the later pbufs in the
|
mbed714 |
0:d616ece2d859
|
1132
|
chain. Instead, we point the ->payload pointer in the first
|
mbed714 |
0:d616ece2d859
|
1133
|
pbuf to data in one of the later pbufs. We also set the
|
mbed714 |
0:d616ece2d859
|
1134
|
inseg.data pointer to point to the right place. This way, the
|
mbed714 |
0:d616ece2d859
|
1135
|
->p pointer will still point to the first pbuf, but the
|
mbed714 |
0:d616ece2d859
|
1136
|
->p->payload pointer will point to data in another pbuf.
|
mbed714 |
0:d616ece2d859
|
1137
|
|
mbed714 |
0:d616ece2d859
|
1138
|
After we are done with adjusting the pbuf pointers we must
|
mbed714 |
0:d616ece2d859
|
1139
|
adjust the ->data pointer in the seg and the segment
|
mbed714 |
0:d616ece2d859
|
1140
|
length.*/
|
mbed714 |
0:d616ece2d859
|
1141
|
|
mbed714 |
0:d616ece2d859
|
1142
|
off = pcb->rcv_nxt - seqno;
|
mbed714 |
0:d616ece2d859
|
1143
|
p = inseg.p;
|
mbed714 |
0:d616ece2d859
|
1144
|
LWIP_ASSERT("inseg.p != NULL", inseg.p);
|
mbed714 |
0:d616ece2d859
|
1145
|
LWIP_ASSERT("insane offset!", (off < 0x7fff));
|
mbed714 |
0:d616ece2d859
|
1146
|
if (inseg.p->len < off) {
|
mbed714 |
0:d616ece2d859
|
1147
|
LWIP_ASSERT("pbuf too short!", (((s32_t)inseg.p->tot_len) >= off));
|
mbed714 |
0:d616ece2d859
|
1148
|
new_tot_len = (u16_t)(inseg.p->tot_len - off);
|
mbed714 |
0:d616ece2d859
|
1149
|
while (p->len < off) {
|
mbed714 |
0:d616ece2d859
|
1150
|
off -= p->len;
|
mbed714 |
0:d616ece2d859
|
1151
|
/* KJM following line changed (with addition of new_tot_len var)
|
mbed714 |
0:d616ece2d859
|
1152
|
to fix bug #9076
|
mbed714 |
0:d616ece2d859
|
1153
|
inseg.p->tot_len -= p->len; */
|
mbed714 |
0:d616ece2d859
|
1154
|
p->tot_len = new_tot_len;
|
mbed714 |
0:d616ece2d859
|
1155
|
p->len = 0;
|
mbed714 |
0:d616ece2d859
|
1156
|
p = p->next;
|
mbed714 |
0:d616ece2d859
|
1157
|
}
|
mbed714 |
0:d616ece2d859
|
1158
|
if(pbuf_header(p, (s16_t)-off)) {
|
mbed714 |
0:d616ece2d859
|
1159
|
/* Do we need to cope with this failing? Assert for now */
|
mbed714 |
0:d616ece2d859
|
1160
|
LWIP_ASSERT("pbuf_header failed", 0);
|
mbed714 |
0:d616ece2d859
|
1161
|
}
|
mbed714 |
0:d616ece2d859
|
1162
|
} else {
|
mbed714 |
0:d616ece2d859
|
1163
|
if(pbuf_header(inseg.p, (s16_t)-off)) {
|
mbed714 |
0:d616ece2d859
|
1164
|
/* Do we need to cope with this failing? Assert for now */
|
mbed714 |
0:d616ece2d859
|
1165
|
LWIP_ASSERT("pbuf_header failed", 0);
|
mbed714 |
0:d616ece2d859
|
1166
|
}
|
mbed714 |
0:d616ece2d859
|
1167
|
}
|
mbed714 |
0:d616ece2d859
|
1168
|
/* KJM following line changed to use p->payload rather than inseg->p->payload
|
mbed714 |
0:d616ece2d859
|
1169
|
to fix bug #9076 */
|
mbed714 |
0:d616ece2d859
|
1170
|
inseg.dataptr = p->payload;
|
mbed714 |
0:d616ece2d859
|
1171
|
inseg.len -= (u16_t)(pcb->rcv_nxt - seqno);
|
mbed714 |
0:d616ece2d859
|
1172
|
inseg.tcphdr->seqno = seqno = pcb->rcv_nxt;
|
mbed714 |
0:d616ece2d859
|
1173
|
}
|
mbed714 |
0:d616ece2d859
|
1174
|
else {
|
mbed714 |
0:d616ece2d859
|
1175
|
if (TCP_SEQ_LT(seqno, pcb->rcv_nxt)){
|
mbed714 |
0:d616ece2d859
|
1176
|
/* the whole segment is < rcv_nxt */
|
mbed714 |
0:d616ece2d859
|
1177
|
/* must be a duplicate of a packet that has already been correctly handled */
|
mbed714 |
0:d616ece2d859
|
1178
|
|
mbed714 |
0:d616ece2d859
|
1179
|
LWIP_DEBUGF(TCP_INPUT_DEBUG, ("tcp_receive: duplicate seqno %"U32_F"\n", seqno));
|
mbed714 |
0:d616ece2d859
|
1180
|
tcp_ack_now(pcb);
|
mbed714 |
0:d616ece2d859
|
1181
|
}
|
mbed714 |
0:d616ece2d859
|
1182
|
}
|
mbed714 |
0:d616ece2d859
|
1183
|
|
mbed714 |
0:d616ece2d859
|
1184
|
/* The sequence number must be within the window (above rcv_nxt
|
mbed714 |
0:d616ece2d859
|
1185
|
and below rcv_nxt + rcv_wnd) in order to be further
|
mbed714 |
0:d616ece2d859
|
1186
|
processed. */
|
mbed714 |
0:d616ece2d859
|
1187
|
if (TCP_SEQ_BETWEEN(seqno, pcb->rcv_nxt,
|
mbed714 |
0:d616ece2d859
|
1188
|
pcb->rcv_nxt + pcb->rcv_wnd - 1)){
|
mbed714 |
0:d616ece2d859
|
1189
|
if (pcb->rcv_nxt == seqno) {
|
mbed714 |
0:d616ece2d859
|
1190
|
/* The incoming segment is the next in sequence. We check if
|
mbed714 |
0:d616ece2d859
|
1191
|
we have to trim the end of the segment and update rcv_nxt
|
mbed714 |
0:d616ece2d859
|
1192
|
and pass the data to the application. */
|
mbed714 |
0:d616ece2d859
|
1193
|
tcplen = TCP_TCPLEN(&inseg);
|
mbed714 |
0:d616ece2d859
|
1194
|
|
mbed714 |
0:d616ece2d859
|
1195
|
if (tcplen > pcb->rcv_wnd) {
|
mbed714 |
0:d616ece2d859
|
1196
|
LWIP_DEBUGF(TCP_INPUT_DEBUG,
|
mbed714 |
0:d616ece2d859
|
1197
|
("tcp_receive: other end overran receive window"
|
mbed714 |
0:d616ece2d859
|
1198
|
"seqno %"U32_F" len %"U16_F" right edge %"U32_F"\n",
|
mbed714 |
0:d616ece2d859
|
1199
|
seqno, tcplen, pcb->rcv_nxt + pcb->rcv_wnd));
|
mbed714 |
0:d616ece2d859
|
1200
|
if (TCPH_FLAGS(inseg.tcphdr) & TCP_FIN) {
|
mbed714 |
0:d616ece2d859
|
1201
|
/* Must remove the FIN from the header as we're trimming
|
mbed714 |
0:d616ece2d859
|
1202
|
* that byte of sequence-space from the packet */
|
mbed714 |
0:d616ece2d859
|
1203
|
TCPH_FLAGS_SET(inseg.tcphdr, TCPH_FLAGS(inseg.tcphdr) &~ TCP_FIN);
|
mbed714 |
0:d616ece2d859
|
1204
|
}
|
mbed714 |
0:d616ece2d859
|
1205
|
/* Adjust length of segment to fit in the window. */
|
mbed714 |
0:d616ece2d859
|
1206
|
inseg.len = pcb->rcv_wnd;
|
mbed714 |
0:d616ece2d859
|
1207
|
if (TCPH_FLAGS(inseg.tcphdr) & TCP_SYN) {
|
mbed714 |
0:d616ece2d859
|
1208
|
inseg.len -= 1;
|
mbed714 |
0:d616ece2d859
|
1209
|
}
|
mbed714 |
0:d616ece2d859
|
1210
|
pbuf_realloc(inseg.p, inseg.len);
|
mbed714 |
0:d616ece2d859
|
1211
|
tcplen = TCP_TCPLEN(&inseg);
|
mbed714 |
0:d616ece2d859
|
1212
|
LWIP_ASSERT("tcp_receive: segment not trimmed correctly to rcv_wnd\n",
|
mbed714 |
0:d616ece2d859
|
1213
|
(seqno + tcplen) == (pcb->rcv_nxt + pcb->rcv_wnd));
|
mbed714 |
0:d616ece2d859
|
1214
|
}
|
mbed714 |
0:d616ece2d859
|
1215
|
#if TCP_QUEUE_OOSEQ
|
mbed714 |
0:d616ece2d859
|
1216
|
/* Received in-sequence data, adjust ooseq data if:
|
mbed714 |
0:d616ece2d859
|
1217
|
- FIN has been received or
|
mbed714 |
0:d616ece2d859
|
1218
|
- inseq overlaps with ooseq */
|
mbed714 |
0:d616ece2d859
|
1219
|
if (pcb->ooseq != NULL) {
|
mbed714 |
0:d616ece2d859
|
1220
|
if (TCPH_FLAGS(inseg.tcphdr) & TCP_FIN) {
|
mbed714 |
0:d616ece2d859
|
1221
|
LWIP_DEBUGF(TCP_INPUT_DEBUG,
|
mbed714 |
0:d616ece2d859
|
1222
|
("tcp_receive: received in-order FIN, binning ooseq queue\n"));
|
mbed714 |
0:d616ece2d859
|
1223
|
/* Received in-order FIN means anything that was received
|
mbed714 |
0:d616ece2d859
|
1224
|
* out of order must now have been received in-order, so
|
mbed714 |
0:d616ece2d859
|
1225
|
* bin the ooseq queue */
|
mbed714 |
0:d616ece2d859
|
1226
|
while (pcb->ooseq != NULL) {
|
mbed714 |
0:d616ece2d859
|
1227
|
struct tcp_seg *old_ooseq = pcb->ooseq;
|
mbed714 |
0:d616ece2d859
|
1228
|
pcb->ooseq = pcb->ooseq->next;
|
mbed714 |
0:d616ece2d859
|
1229
|
tcp_seg_free(old_ooseq);
|
mbed714 |
0:d616ece2d859
|
1230
|
}
|
mbed714 |
0:d616ece2d859
|
1231
|
}
|
mbed714 |
0:d616ece2d859
|
1232
|
else {
|
mbed714 |
0:d616ece2d859
|
1233
|
next = pcb->ooseq;
|
mbed714 |
0:d616ece2d859
|
1234
|
/* Remove all segments on ooseq that are covered by inseg already.
|
mbed714 |
0:d616ece2d859
|
1235
|
* FIN is copied from ooseq to inseg if present. */
|
mbed714 |
0:d616ece2d859
|
1236
|
while (next &&
|
mbed714 |
0:d616ece2d859
|
1237
|
TCP_SEQ_GEQ(seqno + tcplen,
|
mbed714 |
0:d616ece2d859
|
1238
|
next->tcphdr->seqno + next->len)) {
|
mbed714 |
0:d616ece2d859
|
1239
|
/* inseg cannot have FIN here (already processed above) */
|
mbed714 |
0:d616ece2d859
|
1240
|
if (TCPH_FLAGS(next->tcphdr) & TCP_FIN &&
|
mbed714 |
0:d616ece2d859
|
1241
|
(TCPH_FLAGS(inseg.tcphdr) & TCP_SYN) == 0) {
|
mbed714 |
0:d616ece2d859
|
1242
|
TCPH_SET_FLAG(inseg.tcphdr, TCP_FIN);
|
mbed714 |
0:d616ece2d859
|
1243
|
tcplen = TCP_TCPLEN(&inseg);
|
mbed714 |
0:d616ece2d859
|
1244
|
}
|
mbed714 |
0:d616ece2d859
|
1245
|
prev = next;
|
mbed714 |
0:d616ece2d859
|
1246
|
next = next->next;
|
mbed714 |
0:d616ece2d859
|
1247
|
tcp_seg_free(prev);
|
mbed714 |
0:d616ece2d859
|
1248
|
}
|
mbed714 |
0:d616ece2d859
|
1249
|
/* Now trim right side of inseg if it overlaps with the first
|
mbed714 |
0:d616ece2d859
|
1250
|
* segment on ooseq */
|
mbed714 |
0:d616ece2d859
|
1251
|
if (next &&
|
mbed714 |
0:d616ece2d859
|
1252
|
TCP_SEQ_GT(seqno + tcplen,
|
mbed714 |
0:d616ece2d859
|
1253
|
next->tcphdr->seqno)) {
|
mbed714 |
0:d616ece2d859
|
1254
|
/* inseg cannot have FIN here (already processed above) */
|
mbed714 |
0:d616ece2d859
|
1255
|
inseg.len = (u16_t)(next->tcphdr->seqno - seqno);
|
mbed714 |
0:d616ece2d859
|
1256
|
if (TCPH_FLAGS(inseg.tcphdr) & TCP_SYN) {
|
mbed714 |
0:d616ece2d859
|
1257
|
inseg.len -= 1;
|
mbed714 |
0:d616ece2d859
|
1258
|
}
|
mbed714 |
0:d616ece2d859
|
1259
|
pbuf_realloc(inseg.p, inseg.len);
|
mbed714 |
0:d616ece2d859
|
1260
|
tcplen = TCP_TCPLEN(&inseg);
|
mbed714 |
0:d616ece2d859
|
1261
|
LWIP_ASSERT("tcp_receive: segment not trimmed correctly to ooseq queue\n",
|
mbed714 |
0:d616ece2d859
|
1262
|
(seqno + tcplen) == next->tcphdr->seqno);
|
mbed714 |
0:d616ece2d859
|
1263
|
}
|
mbed714 |
0:d616ece2d859
|
1264
|
pcb->ooseq = next;
|
mbed714 |
0:d616ece2d859
|
1265
|
}
|
mbed714 |
0:d616ece2d859
|
1266
|
}
|
mbed714 |
0:d616ece2d859
|
1267
|
#endif /* TCP_QUEUE_OOSEQ */
|
mbed714 |
0:d616ece2d859
|
1268
|
|
mbed714 |
0:d616ece2d859
|
1269
|
pcb->rcv_nxt = seqno + tcplen;
|
mbed714 |
0:d616ece2d859
|
1270
|
|
mbed714 |
0:d616ece2d859
|
1271
|
/* Update the receiver's (our) window. */
|
mbed714 |
0:d616ece2d859
|
1272
|
LWIP_ASSERT("tcp_receive: tcplen > rcv_wnd\n", pcb->rcv_wnd >= tcplen);
|
mbed714 |
0:d616ece2d859
|
1273
|
pcb->rcv_wnd -= tcplen;
|
mbed714 |
0:d616ece2d859
|
1274
|
|
mbed714 |
0:d616ece2d859
|
1275
|
tcp_update_rcv_ann_wnd(pcb);
|
mbed714 |
0:d616ece2d859
|
1276
|
|
mbed714 |
0:d616ece2d859
|
1277
|
/* If there is data in the segment, we make preparations to
|
mbed714 |
0:d616ece2d859
|
1278
|
pass this up to the application. The ->recv_data variable
|
mbed714 |
0:d616ece2d859
|
1279
|
is used for holding the pbuf that goes to the
|
mbed714 |
0:d616ece2d859
|
1280
|
application. The code for reassembling out-of-sequence data
|
mbed714 |
0:d616ece2d859
|
1281
|
chains its data on this pbuf as well.
|
mbed714 |
0:d616ece2d859
|
1282
|
|
mbed714 |
0:d616ece2d859
|
1283
|
If the segment was a FIN, we set the TF_GOT_FIN flag that will
|
mbed714 |
0:d616ece2d859
|
1284
|
be used to indicate to the application that the remote side has
|
mbed714 |
0:d616ece2d859
|
1285
|
closed its end of the connection. */
|
mbed714 |
0:d616ece2d859
|
1286
|
if (inseg.p->tot_len > 0) {
|
mbed714 |
0:d616ece2d859
|
1287
|
recv_data = inseg.p;
|
mbed714 |
0:d616ece2d859
|
1288
|
/* Since this pbuf now is the responsibility of the
|
mbed714 |
0:d616ece2d859
|
1289
|
application, we delete our reference to it so that we won't
|
mbed714 |
0:d616ece2d859
|
1290
|
(mistakingly) deallocate it. */
|
mbed714 |
0:d616ece2d859
|
1291
|
inseg.p = NULL;
|
mbed714 |
0:d616ece2d859
|
1292
|
}
|
mbed714 |
0:d616ece2d859
|
1293
|
if (TCPH_FLAGS(inseg.tcphdr) & TCP_FIN) {
|
mbed714 |
0:d616ece2d859
|
1294
|
LWIP_DEBUGF(TCP_INPUT_DEBUG, ("tcp_receive: received FIN.\n"));
|
mbed714 |
0:d616ece2d859
|
1295
|
recv_flags |= TF_GOT_FIN;
|
mbed714 |
0:d616ece2d859
|
1296
|
}
|
mbed714 |
0:d616ece2d859
|
1297
|
|
mbed714 |
0:d616ece2d859
|
1298
|
#if TCP_QUEUE_OOSEQ
|
mbed714 |
0:d616ece2d859
|
1299
|
/* We now check if we have segments on the ->ooseq queue that
|
mbed714 |
0:d616ece2d859
|
1300
|
are now in sequence. */
|
mbed714 |
0:d616ece2d859
|
1301
|
while (pcb->ooseq != NULL &&
|
mbed714 |
0:d616ece2d859
|
1302
|
pcb->ooseq->tcphdr->seqno == pcb->rcv_nxt) {
|
mbed714 |
0:d616ece2d859
|
1303
|
|
mbed714 |
0:d616ece2d859
|
1304
|
cseg = pcb->ooseq;
|
mbed714 |
0:d616ece2d859
|
1305
|
seqno = pcb->ooseq->tcphdr->seqno;
|
mbed714 |
0:d616ece2d859
|
1306
|
|
mbed714 |
0:d616ece2d859
|
1307
|
pcb->rcv_nxt += TCP_TCPLEN(cseg);
|
mbed714 |
0:d616ece2d859
|
1308
|
LWIP_ASSERT("tcp_receive: ooseq tcplen > rcv_wnd\n",
|
mbed714 |
0:d616ece2d859
|
1309
|
pcb->rcv_wnd >= TCP_TCPLEN(cseg));
|
mbed714 |
0:d616ece2d859
|
1310
|
pcb->rcv_wnd -= TCP_TCPLEN(cseg);
|
mbed714 |
0:d616ece2d859
|
1311
|
|
mbed714 |
0:d616ece2d859
|
1312
|
tcp_update_rcv_ann_wnd(pcb);
|
mbed714 |
0:d616ece2d859
|
1313
|
|
mbed714 |
0:d616ece2d859
|
1314
|
if (cseg->p->tot_len > 0) {
|
mbed714 |
0:d616ece2d859
|
1315
|
/* Chain this pbuf onto the pbuf that we will pass to
|
mbed714 |
0:d616ece2d859
|
1316
|
the application. */
|
mbed714 |
0:d616ece2d859
|
1317
|
if (recv_data) {
|
mbed714 |
0:d616ece2d859
|
1318
|
pbuf_cat(recv_data, cseg->p);
|
mbed714 |
0:d616ece2d859
|
1319
|
} else {
|
mbed714 |
0:d616ece2d859
|
1320
|
recv_data = cseg->p;
|
mbed714 |
0:d616ece2d859
|
1321
|
}
|
mbed714 |
0:d616ece2d859
|
1322
|
cseg->p = NULL;
|
mbed714 |
0:d616ece2d859
|
1323
|
}
|
mbed714 |
0:d616ece2d859
|
1324
|
if (TCPH_FLAGS(cseg->tcphdr) & TCP_FIN) {
|
mbed714 |
0:d616ece2d859
|
1325
|
LWIP_DEBUGF(TCP_INPUT_DEBUG, ("tcp_receive: dequeued FIN.\n"));
|
mbed714 |
0:d616ece2d859
|
1326
|
recv_flags |= TF_GOT_FIN;
|
mbed714 |
0:d616ece2d859
|
1327
|
if (pcb->state == ESTABLISHED) { /* force passive close or we can move to active close */
|
mbed714 |
0:d616ece2d859
|
1328
|
pcb->state = CLOSE_WAIT;
|
mbed714 |
0:d616ece2d859
|
1329
|
}
|
mbed714 |
0:d616ece2d859
|
1330
|
}
|
mbed714 |
0:d616ece2d859
|
1331
|
|
mbed714 |
0:d616ece2d859
|
1332
|
pcb->ooseq = cseg->next;
|
mbed714 |
0:d616ece2d859
|
1333
|
tcp_seg_free(cseg);
|
mbed714 |
0:d616ece2d859
|
1334
|
}
|
mbed714 |
0:d616ece2d859
|
1335
|
#endif /* TCP_QUEUE_OOSEQ */
|
mbed714 |
0:d616ece2d859
|
1336
|
|
mbed714 |
0:d616ece2d859
|
1337
|
|
mbed714 |
0:d616ece2d859
|
1338
|
/* Acknowledge the segment(s). */
|
mbed714 |
0:d616ece2d859
|
1339
|
tcp_ack(pcb);
|
mbed714 |
0:d616ece2d859
|
1340
|
|
mbed714 |
0:d616ece2d859
|
1341
|
} else {
|
mbed714 |
0:d616ece2d859
|
1342
|
/* We get here if the incoming segment is out-of-sequence. */
|
mbed714 |
0:d616ece2d859
|
1343
|
tcp_send_empty_ack(pcb);
|
mbed714 |
0:d616ece2d859
|
1344
|
#if TCP_QUEUE_OOSEQ
|
mbed714 |
0:d616ece2d859
|
1345
|
/* We queue the segment on the ->ooseq queue. */
|
mbed714 |
0:d616ece2d859
|
1346
|
if (pcb->ooseq == NULL) {
|
mbed714 |
0:d616ece2d859
|
1347
|
pcb->ooseq = tcp_seg_copy(&inseg);
|
mbed714 |
0:d616ece2d859
|
1348
|
} else {
|
mbed714 |
0:d616ece2d859
|
1349
|
/* If the queue is not empty, we walk through the queue and
|
mbed714 |
0:d616ece2d859
|
1350
|
try to find a place where the sequence number of the
|
mbed714 |
0:d616ece2d859
|
1351
|
incoming segment is between the sequence numbers of the
|
mbed714 |
0:d616ece2d859
|
1352
|
previous and the next segment on the ->ooseq queue. That is
|
mbed714 |
0:d616ece2d859
|
1353
|
the place where we put the incoming segment. If needed, we
|
mbed714 |
0:d616ece2d859
|
1354
|
trim the second edges of the previous and the incoming
|
mbed714 |
0:d616ece2d859
|
1355
|
segment so that it will fit into the sequence.
|
mbed714 |
0:d616ece2d859
|
1356
|
|
mbed714 |
0:d616ece2d859
|
1357
|
If the incoming segment has the same sequence number as a
|
mbed714 |
0:d616ece2d859
|
1358
|
segment on the ->ooseq queue, we discard the segment that
|
mbed714 |
0:d616ece2d859
|
1359
|
contains less data. */
|
mbed714 |
0:d616ece2d859
|
1360
|
|
mbed714 |
0:d616ece2d859
|
1361
|
prev = NULL;
|
mbed714 |
0:d616ece2d859
|
1362
|
for(next = pcb->ooseq; next != NULL; next = next->next) {
|
mbed714 |
0:d616ece2d859
|
1363
|
if (seqno == next->tcphdr->seqno) {
|
mbed714 |
0:d616ece2d859
|
1364
|
/* The sequence number of the incoming segment is the
|
mbed714 |
0:d616ece2d859
|
1365
|
same as the sequence number of the segment on
|
mbed714 |
0:d616ece2d859
|
1366
|
->ooseq. We check the lengths to see which one to
|
mbed714 |
0:d616ece2d859
|
1367
|
discard. */
|
mbed714 |
0:d616ece2d859
|
1368
|
if (inseg.len > next->len) {
|
mbed714 |
0:d616ece2d859
|
1369
|
/* The incoming segment is larger than the old
|
mbed714 |
0:d616ece2d859
|
1370
|
segment. We replace some segments with the new
|
mbed714 |
0:d616ece2d859
|
1371
|
one. */
|
mbed714 |
0:d616ece2d859
|
1372
|
cseg = tcp_seg_copy(&inseg);
|
mbed714 |
0:d616ece2d859
|
1373
|
if (cseg != NULL) {
|
mbed714 |
0:d616ece2d859
|
1374
|
if (prev != NULL) {
|
mbed714 |
0:d616ece2d859
|
1375
|
prev->next = cseg;
|
mbed714 |
0:d616ece2d859
|
1376
|
} else {
|
mbed714 |
0:d616ece2d859
|
1377
|
pcb->ooseq = cseg;
|
mbed714 |
0:d616ece2d859
|
1378
|
}
|
mbed714 |
0:d616ece2d859
|
1379
|
tcp_oos_insert_segment(cseg, next);
|
mbed714 |
0:d616ece2d859
|
1380
|
}
|
mbed714 |
0:d616ece2d859
|
1381
|
break;
|
mbed714 |
0:d616ece2d859
|
1382
|
} else {
|
mbed714 |
0:d616ece2d859
|
1383
|
/* Either the lenghts are the same or the incoming
|
mbed714 |
0:d616ece2d859
|
1384
|
segment was smaller than the old one; in either
|
mbed714 |
0:d616ece2d859
|
1385
|
case, we ditch the incoming segment. */
|
mbed714 |
0:d616ece2d859
|
1386
|
break;
|
mbed714 |
0:d616ece2d859
|
1387
|
}
|
mbed714 |
0:d616ece2d859
|
1388
|
} else {
|
mbed714 |
0:d616ece2d859
|
1389
|
if (prev == NULL) {
|
mbed714 |
0:d616ece2d859
|
1390
|
if (TCP_SEQ_LT(seqno, next->tcphdr->seqno)) {
|
mbed714 |
0:d616ece2d859
|
1391
|
/* The sequence number of the incoming segment is lower
|
mbed714 |
0:d616ece2d859
|
1392
|
than the sequence number of the first segment on the
|
mbed714 |
0:d616ece2d859
|
1393
|
queue. We put the incoming segment first on the
|
mbed714 |
0:d616ece2d859
|
1394
|
queue. */
|
mbed714 |
0:d616ece2d859
|
1395
|
cseg = tcp_seg_copy(&inseg);
|
mbed714 |
0:d616ece2d859
|
1396
|
if (cseg != NULL) {
|
mbed714 |
0:d616ece2d859
|
1397
|
pcb->ooseq = cseg;
|
mbed714 |
0:d616ece2d859
|
1398
|
tcp_oos_insert_segment(cseg, next);
|
mbed714 |
0:d616ece2d859
|
1399
|
}
|
mbed714 |
0:d616ece2d859
|
1400
|
break;
|
mbed714 |
0:d616ece2d859
|
1401
|
}
|
mbed714 |
0:d616ece2d859
|
1402
|
} else {
|
mbed714 |
0:d616ece2d859
|
1403
|
/*if (TCP_SEQ_LT(prev->tcphdr->seqno, seqno) &&
|
mbed714 |
0:d616ece2d859
|
1404
|
TCP_SEQ_LT(seqno, next->tcphdr->seqno)) {*/
|
mbed714 |
0:d616ece2d859
|
1405
|
if (TCP_SEQ_BETWEEN(seqno, prev->tcphdr->seqno+1, next->tcphdr->seqno-1)) {
|
mbed714 |
0:d616ece2d859
|
1406
|
/* The sequence number of the incoming segment is in
|
mbed714 |
0:d616ece2d859
|
1407
|
between the sequence numbers of the previous and
|
mbed714 |
0:d616ece2d859
|
1408
|
the next segment on ->ooseq. We trim trim the previous
|
mbed714 |
0:d616ece2d859
|
1409
|
segment, delete next segments that included in received segment
|
mbed714 |
0:d616ece2d859
|
1410
|
and trim received, if needed. */
|
mbed714 |
0:d616ece2d859
|
1411
|
cseg = tcp_seg_copy(&inseg);
|
mbed714 |
0:d616ece2d859
|
1412
|
if (cseg != NULL) {
|
mbed714 |
0:d616ece2d859
|
1413
|
if (TCP_SEQ_GT(prev->tcphdr->seqno + prev->len, seqno)) {
|
mbed714 |
0:d616ece2d859
|
1414
|
/* We need to trim the prev segment. */
|
mbed714 |
0:d616ece2d859
|
1415
|
prev->len = (u16_t)(seqno - prev->tcphdr->seqno);
|
mbed714 |
0:d616ece2d859
|
1416
|
pbuf_realloc(prev->p, prev->len);
|
mbed714 |
0:d616ece2d859
|
1417
|
}
|
mbed714 |
0:d616ece2d859
|
1418
|
prev->next = cseg;
|
mbed714 |
0:d616ece2d859
|
1419
|
tcp_oos_insert_segment(cseg, next);
|
mbed714 |
0:d616ece2d859
|
1420
|
}
|
mbed714 |
0:d616ece2d859
|
1421
|
break;
|
mbed714 |
0:d616ece2d859
|
1422
|
}
|
mbed714 |
0:d616ece2d859
|
1423
|
}
|
mbed714 |
0:d616ece2d859
|
1424
|
/* If the "next" segment is the last segment on the
|
mbed714 |
0:d616ece2d859
|
1425
|
ooseq queue, we add the incoming segment to the end
|
mbed714 |
0:d616ece2d859
|
1426
|
of the list. */
|
mbed714 |
0:d616ece2d859
|
1427
|
if (next->next == NULL &&
|
mbed714 |
0:d616ece2d859
|
1428
|
TCP_SEQ_GT(seqno, next->tcphdr->seqno)) {
|
mbed714 |
0:d616ece2d859
|
1429
|
if (TCPH_FLAGS(next->tcphdr) & TCP_FIN) {
|
mbed714 |
0:d616ece2d859
|
1430
|
/* segment "next" already contains all data */
|
mbed714 |
0:d616ece2d859
|
1431
|
break;
|
mbed714 |
0:d616ece2d859
|
1432
|
}
|
mbed714 |
0:d616ece2d859
|
1433
|
next->next = tcp_seg_copy(&inseg);
|
mbed714 |
0:d616ece2d859
|
1434
|
if (next->next != NULL) {
|
mbed714 |
0:d616ece2d859
|
1435
|
if (TCP_SEQ_GT(next->tcphdr->seqno + next->len, seqno)) {
|
mbed714 |
0:d616ece2d859
|
1436
|
/* We need to trim the last segment. */
|
mbed714 |
0:d616ece2d859
|
1437
|
next->len = (u16_t)(seqno - next->tcphdr->seqno);
|
mbed714 |
0:d616ece2d859
|
1438
|
pbuf_realloc(next->p, next->len);
|
mbed714 |
0:d616ece2d859
|
1439
|
}
|
mbed714 |
0:d616ece2d859
|
1440
|
/* check if the remote side overruns our receive window */
|
mbed714 |
0:d616ece2d859
|
1441
|
if ((u32_t)tcplen + seqno > pcb->rcv_nxt + (u32_t)pcb->rcv_wnd) {
|
mbed714 |
0:d616ece2d859
|
1442
|
LWIP_DEBUGF(TCP_INPUT_DEBUG,
|
mbed714 |
0:d616ece2d859
|
1443
|
("tcp_receive: other end overran receive window"
|
mbed714 |
0:d616ece2d859
|
1444
|
"seqno %"U32_F" len %"U16_F" right edge %"U32_F"\n",
|
mbed714 |
0:d616ece2d859
|
1445
|
seqno, tcplen, pcb->rcv_nxt + pcb->rcv_wnd));
|
mbed714 |
0:d616ece2d859
|
1446
|
if (TCPH_FLAGS(next->next->tcphdr) & TCP_FIN) {
|
mbed714 |
0:d616ece2d859
|
1447
|
/* Must remove the FIN from the header as we're trimming
|
mbed714 |
0:d616ece2d859
|
1448
|
* that byte of sequence-space from the packet */
|
mbed714 |
0:d616ece2d859
|
1449
|
TCPH_FLAGS_SET(next->next->tcphdr, TCPH_FLAGS(next->next->tcphdr) &~ TCP_FIN);
|
mbed714 |
0:d616ece2d859
|
1450
|
}
|
mbed714 |
0:d616ece2d859
|
1451
|
/* Adjust length of segment to fit in the window. */
|
mbed714 |
0:d616ece2d859
|
1452
|
next->next->len = pcb->rcv_nxt + pcb->rcv_wnd - seqno;
|
mbed714 |
0:d616ece2d859
|
1453
|
pbuf_realloc(next->next->p, next->next->len);
|
mbed714 |
0:d616ece2d859
|
1454
|
tcplen = TCP_TCPLEN(next->next);
|
mbed714 |
0:d616ece2d859
|
1455
|
LWIP_ASSERT("tcp_receive: segment not trimmed correctly to rcv_wnd\n",
|
mbed714 |
0:d616ece2d859
|
1456
|
(seqno + tcplen) == (pcb->rcv_nxt + pcb->rcv_wnd));
|
mbed714 |
0:d616ece2d859
|
1457
|
}
|
mbed714 |
0:d616ece2d859
|
1458
|
}
|
mbed714 |
0:d616ece2d859
|
1459
|
break;
|
mbed714 |
0:d616ece2d859
|
1460
|
}
|
mbed714 |
0:d616ece2d859
|
1461
|
}
|
mbed714 |
0:d616ece2d859
|
1462
|
prev = next;
|
mbed714 |
0:d616ece2d859
|
1463
|
}
|
mbed714 |
0:d616ece2d859
|
1464
|
}
|
mbed714 |
0:d616ece2d859
|
1465
|
#endif /* TCP_QUEUE_OOSEQ */
|
mbed714 |
0:d616ece2d859
|
1466
|
|
mbed714 |
0:d616ece2d859
|
1467
|
}
|
mbed714 |
0:d616ece2d859
|
1468
|
} else {
|
mbed714 |
0:d616ece2d859
|
1469
|
/* The incoming segment is not withing the window. */
|
mbed714 |
0:d616ece2d859
|
1470
|
tcp_send_empty_ack(pcb);
|
mbed714 |
0:d616ece2d859
|
1471
|
}
|
mbed714 |
0:d616ece2d859
|
1472
|
} else {
|
mbed714 |
0:d616ece2d859
|
1473
|
/* Segments with length 0 is taken care of here. Segments that
|
mbed714 |
0:d616ece2d859
|
1474
|
fall out of the window are ACKed. */
|
mbed714 |
0:d616ece2d859
|
1475
|
/*if (TCP_SEQ_GT(pcb->rcv_nxt, seqno) ||
|
mbed714 |
0:d616ece2d859
|
1476
|
TCP_SEQ_GEQ(seqno, pcb->rcv_nxt + pcb->rcv_wnd)) {*/
|
mbed714 |
0:d616ece2d859
|
1477
|
if(!TCP_SEQ_BETWEEN(seqno, pcb->rcv_nxt, pcb->rcv_nxt + pcb->rcv_wnd-1)){
|
mbed714 |
0:d616ece2d859
|
1478
|
tcp_ack_now(pcb);
|
mbed714 |
0:d616ece2d859
|
1479
|
}
|
mbed714 |
0:d616ece2d859
|
1480
|
}
|
mbed714 |
0:d616ece2d859
|
1481
|
}
|
mbed714 |
0:d616ece2d859
|
1482
|
|
mbed714 |
0:d616ece2d859
|
1483
|
/**
|
mbed714 |
0:d616ece2d859
|
1484
|
* Parses the options contained in the incoming segment.
|
mbed714 |
0:d616ece2d859
|
1485
|
*
|
mbed714 |
0:d616ece2d859
|
1486
|
* Called from tcp_listen_input() and tcp_process().
|
mbed714 |
0:d616ece2d859
|
1487
|
* Currently, only the MSS option is supported!
|
mbed714 |
0:d616ece2d859
|
1488
|
*
|
mbed714 |
0:d616ece2d859
|
1489
|
* @param pcb the tcp_pcb for which a segment arrived
|
mbed714 |
0:d616ece2d859
|
1490
|
*/
|
mbed714 |
0:d616ece2d859
|
1491
|
static void
|
mbed714 |
0:d616ece2d859
|
1492
|
tcp_parseopt(struct tcp_pcb *pcb)
|
mbed714 |
0:d616ece2d859
|
1493
|
{
|
mbed714 |
0:d616ece2d859
|
1494
|
u16_t c, max_c;
|
mbed714 |
0:d616ece2d859
|
1495
|
u16_t mss;
|
mbed714 |
0:d616ece2d859
|
1496
|
u8_t *opts, opt;
|
mbed714 |
0:d616ece2d859
|
1497
|
#if LWIP_TCP_TIMESTAMPS
|
mbed714 |
0:d616ece2d859
|
1498
|
u32_t tsval;
|
mbed714 |
0:d616ece2d859
|
1499
|
#endif
|
mbed714 |
0:d616ece2d859
|
1500
|
|
mbed714 |
0:d616ece2d859
|
1501
|
opts = (u8_t *)tcphdr + TCP_HLEN;
|
mbed714 |
0:d616ece2d859
|
1502
|
|
mbed714 |
0:d616ece2d859
|
1503
|
/* Parse the TCP MSS option, if present. */
|
mbed714 |
0:d616ece2d859
|
1504
|
if(TCPH_HDRLEN(tcphdr) > 0x5) {
|
mbed714 |
0:d616ece2d859
|
1505
|
max_c = (TCPH_HDRLEN(tcphdr) - 5) << 2;
|
mbed714 |
0:d616ece2d859
|
1506
|
for (c = 0; c < max_c; ) {
|
mbed714 |
0:d616ece2d859
|
1507
|
opt = opts[c];
|
mbed714 |
0:d616ece2d859
|
1508
|
switch (opt) {
|
mbed714 |
0:d616ece2d859
|
1509
|
case 0x00:
|
mbed714 |
0:d616ece2d859
|
1510
|
/* End of options. */
|
mbed714 |
0:d616ece2d859
|
1511
|
LWIP_DEBUGF(TCP_INPUT_DEBUG, ("tcp_parseopt: EOL\n"));
|
mbed714 |
0:d616ece2d859
|
1512
|
return;
|
mbed714 |
0:d616ece2d859
|
1513
|
case 0x01:
|
mbed714 |
0:d616ece2d859
|
1514
|
/* NOP option. */
|
mbed714 |
0:d616ece2d859
|
1515
|
++c;
|
mbed714 |
0:d616ece2d859
|
1516
|
LWIP_DEBUGF(TCP_INPUT_DEBUG, ("tcp_parseopt: NOP\n"));
|
mbed714 |
0:d616ece2d859
|
1517
|
break;
|
mbed714 |
0:d616ece2d859
|
1518
|
case 0x02:
|
mbed714 |
0:d616ece2d859
|
1519
|
LWIP_DEBUGF(TCP_INPUT_DEBUG, ("tcp_parseopt: MSS\n"));
|
mbed714 |
0:d616ece2d859
|
1520
|
if (opts[c + 1] != 0x04 || c + 0x04 > max_c) {
|
mbed714 |
0:d616ece2d859
|
1521
|
/* Bad length */
|
mbed714 |
0:d616ece2d859
|
1522
|
LWIP_DEBUGF(TCP_INPUT_DEBUG, ("tcp_parseopt: bad length\n"));
|
mbed714 |
0:d616ece2d859
|
1523
|
return;
|
mbed714 |
0:d616ece2d859
|
1524
|
}
|
mbed714 |
0:d616ece2d859
|
1525
|
/* An MSS option with the right option length. */
|
mbed714 |
0:d616ece2d859
|
1526
|
mss = (opts[c + 2] << 8) | opts[c + 3];
|
mbed714 |
0:d616ece2d859
|
1527
|
/* Limit the mss to the configured TCP_MSS and prevent division by zero */
|
mbed714 |
0:d616ece2d859
|
1528
|
pcb->mss = ((mss > TCP_MSS) || (mss == 0)) ? TCP_MSS : mss;
|
mbed714 |
0:d616ece2d859
|
1529
|
/* Advance to next option */
|
mbed714 |
0:d616ece2d859
|
1530
|
c += 0x04;
|
mbed714 |
0:d616ece2d859
|
1531
|
break;
|
mbed714 |
0:d616ece2d859
|
1532
|
#if LWIP_TCP_TIMESTAMPS
|
mbed714 |
0:d616ece2d859
|
1533
|
case 0x08:
|
mbed714 |
0:d616ece2d859
|
1534
|
LWIP_DEBUGF(TCP_INPUT_DEBUG, ("tcp_parseopt: TS\n"));
|
mbed714 |
0:d616ece2d859
|
1535
|
if (opts[c + 1] != 0x0A || c + 0x0A > max_c) {
|
mbed714 |
0:d616ece2d859
|
1536
|
/* Bad length */
|
mbed714 |
0:d616ece2d859
|
1537
|
LWIP_DEBUGF(TCP_INPUT_DEBUG, ("tcp_parseopt: bad length\n"));
|
mbed714 |
0:d616ece2d859
|
1538
|
return;
|
mbed714 |
0:d616ece2d859
|
1539
|
}
|
mbed714 |
0:d616ece2d859
|
1540
|
/* TCP timestamp option with valid length */
|
mbed714 |
0:d616ece2d859
|
1541
|
tsval = (opts[c+2]) | (opts[c+3] << 8) |
|
mbed714 |
0:d616ece2d859
|
1542
|
(opts[c+4] << 16) | (opts[c+5] << 24);
|
mbed714 |
0:d616ece2d859
|
1543
|
if (flags & TCP_SYN) {
|
mbed714 |
0:d616ece2d859
|
1544
|
pcb->ts_recent = ntohl(tsval);
|
mbed714 |
0:d616ece2d859
|
1545
|
pcb->flags |= TF_TIMESTAMP;
|
mbed714 |
0:d616ece2d859
|
1546
|
} else if (TCP_SEQ_BETWEEN(pcb->ts_lastacksent, seqno, seqno+tcplen)) {
|
mbed714 |
0:d616ece2d859
|
1547
|
pcb->ts_recent = ntohl(tsval);
|
mbed714 |
0:d616ece2d859
|
1548
|
}
|
mbed714 |
0:d616ece2d859
|
1549
|
/* Advance to next option */
|
mbed714 |
0:d616ece2d859
|
1550
|
c += 0x0A;
|
mbed714 |
0:d616ece2d859
|
1551
|
break;
|
mbed714 |
0:d616ece2d859
|
1552
|
#endif
|
mbed714 |
0:d616ece2d859
|
1553
|
default:
|
mbed714 |
0:d616ece2d859
|
1554
|
LWIP_DEBUGF(TCP_INPUT_DEBUG, ("tcp_parseopt: other\n"));
|
mbed714 |
0:d616ece2d859
|
1555
|
if (opts[c + 1] == 0) {
|
mbed714 |
0:d616ece2d859
|
1556
|
LWIP_DEBUGF(TCP_INPUT_DEBUG, ("tcp_parseopt: bad length\n"));
|
mbed714 |
0:d616ece2d859
|
1557
|
/* If the length field is zero, the options are malformed
|
mbed714 |
0:d616ece2d859
|
1558
|
and we don't process them further. */
|
mbed714 |
0:d616ece2d859
|
1559
|
return;
|
mbed714 |
0:d616ece2d859
|
1560
|
}
|
mbed714 |
0:d616ece2d859
|
1561
|
/* All other options have a length field, so that we easily
|
mbed714 |
0:d616ece2d859
|
1562
|
can skip past them. */
|
mbed714 |
0:d616ece2d859
|
1563
|
c += opts[c + 1];
|
mbed714 |
0:d616ece2d859
|
1564
|
}
|
mbed714 |
0:d616ece2d859
|
1565
|
}
|
mbed714 |
0:d616ece2d859
|
1566
|
}
|
mbed714 |
0:d616ece2d859
|
1567
|
}
|
mbed714 |
0:d616ece2d859
|
1568
|
|
mbed714 |
0:d616ece2d859
|
1569
|
#endif /* LWIP_TCP */
|