1 /**
2 * @file
3 * Transmission Control Protocol, outgoing traffic
4 *
5 * The output functions of TCP.
6 *
7 */
8
9 /*
10 * Copyright (c) 2001-2004 Swedish Institute of Computer Science.
11 * All rights reserved.
12 *
13 * Redistribution and use in source and binary forms, with or without modification,
14 * are permitted provided that the following conditions are met:
15 *
16 * 1. Redistributions of source code must retain the above copyright notice,
17 * this list of conditions and the following disclaimer.
18 * 2. Redistributions in binary form must reproduce the above copyright notice,
19 * this list of conditions and the following disclaimer in the documentation
20 * and/or other materials provided with the distribution.
21 * 3. The name of the author may not be used to endorse or promote products
22 * derived from this software without specific prior written permission.
23 *
24 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
25 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
26 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
27 * SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
28 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
29 * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
30 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
31 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
32 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
33 * OF SUCH DAMAGE.
34 *
35 * This file is part of the lwIP TCP/IP stack.
36 *
37 * Author: Adam Dunkels <adam@sics.se>
38 *
39 */
40
41 #include "lwip/opt.h"
42
43 #if LWIP_TCP /* don't build if not configured for use in lwipopts.h */
44
45 #include "lwip/tcp_impl.h"
46 #include "lwip/def.h"
47 #include "lwip/mem.h"
48 #include "lwip/memp.h"
49 #include "lwip/sys.h"
50 #include "lwip/ip_addr.h"
51 #include "lwip/netif.h"
52 #include "lwip/inet_chksum.h"
53 #include "lwip/stats.h"
54 #include "lwip/snmp.h"
55
56 #include <string.h>
57
58 /* Define some copy-macros for checksum-on-copy so that the code looks
59 nicer by preventing too many ifdef's. */
60 #if TCP_CHECKSUM_ON_COPY
61 #define TCP_DATA_COPY(dst, src, len, seg) do { \
62 tcp_seg_add_chksum(LWIP_CHKSUM_COPY(dst, src, len), \
63 len, &seg->chksum, &seg->chksum_swapped); \
64 seg->flags |= TF_SEG_DATA_CHECKSUMMED; } while(0)
65 #define TCP_DATA_COPY2(dst, src, len, chksum, chksum_swapped) \
66 tcp_seg_add_chksum(LWIP_CHKSUM_COPY(dst, src, len), len, chksum, chksum_swapped);
67 #else /* TCP_CHECKSUM_ON_COPY*/
68 #define TCP_DATA_COPY(dst, src, len, seg) MEMCPY(dst, src, len)
69 #define TCP_DATA_COPY2(dst, src, len, chksum, chksum_swapped) MEMCPY(dst, src, len)
70 #endif /* TCP_CHECKSUM_ON_COPY*/
71
72 /** Define this to 1 for an extra check that the output checksum is valid
73 * (usefule when the checksum is generated by the application, not the stack) */
74 #ifndef TCP_CHECKSUM_ON_COPY_SANITY_CHECK
75 #define TCP_CHECKSUM_ON_COPY_SANITY_CHECK 0
76 #endif
77
78 /* Forward declarations.*/
79 static void tcp_output_segment(struct tcp_seg *seg, struct tcp_pcb *pcb);
80
81 /** Allocate a pbuf and create a tcphdr at p->payload, used for output
82 * functions other than the default tcp_output -> tcp_output_segment
83 * (e.g. tcp_send_empty_ack, etc.)
84 *
85 * @param pcb tcp pcb for which to send a packet (used to initialize tcp_hdr)
86 * @param optlen length of header-options
87 * @param datalen length of tcp data to reserve in pbuf
88 * @param seqno_be seqno in network byte order (big-endian)
89 * @return pbuf with p->payload being the tcp_hdr
90 */
91 static struct pbuf *
tcp_output_alloc_header(struct tcp_pcb * pcb,u16_t optlen,u16_t datalen,u32_t seqno_be)92 tcp_output_alloc_header(struct tcp_pcb *pcb, u16_t optlen, u16_t datalen,
93 u32_t seqno_be /* already in network byte order */)
94 {
95 struct tcp_hdr *tcphdr;
96 struct pbuf *p = pbuf_alloc(PBUF_IP, TCP_HLEN + optlen + datalen, PBUF_RAM);
97 if (p != NULL) {
98 LWIP_ASSERT("check that first pbuf can hold struct tcp_hdr",
99 (p->len >= TCP_HLEN + optlen));
100 tcphdr = (struct tcp_hdr *)p->payload;
101 tcphdr->src = htons(pcb->local_port);
102 tcphdr->dest = htons(pcb->remote_port);
103 tcphdr->seqno = seqno_be;
104 tcphdr->ackno = htonl(pcb->rcv_nxt);
105 TCPH_HDRLEN_FLAGS_SET(tcphdr, (5 + optlen / 4), TCP_ACK);
106 tcphdr->wnd = htons(pcb->rcv_ann_wnd);
107 tcphdr->chksum = 0;
108 tcphdr->urgp = 0;
109
110 /* If we're sending a packet, update the announced right window edge */
111 pcb->rcv_ann_right_edge = pcb->rcv_nxt + pcb->rcv_ann_wnd;
112 }
113 return p;
114 }
115
116 /**
117 * Called by tcp_close() to send a segment including FIN flag but not data.
118 *
119 * @param pcb the tcp_pcb over which to send a segment
120 * @return ERR_OK if sent, another err_t otherwise
121 */
122 err_t
tcp_send_fin(struct tcp_pcb * pcb)123 tcp_send_fin(struct tcp_pcb *pcb)
124 {
125 /* first, try to add the fin to the last unsent segment */
126 if (pcb->unsent != NULL) {
127 struct tcp_seg *last_unsent;
128 for (last_unsent = pcb->unsent; last_unsent->next != NULL;
129 last_unsent = last_unsent->next);
130
131 if ((TCPH_FLAGS(last_unsent->tcphdr) & (TCP_SYN | TCP_FIN | TCP_RST)) == 0) {
132 /* no SYN/FIN/RST flag in the header, we can add the FIN flag */
133 TCPH_SET_FLAG(last_unsent->tcphdr, TCP_FIN);
134 return ERR_OK;
135 }
136 }
137 /* no data, no length, flags, copy=1, no optdata */
138 return tcp_enqueue_flags(pcb, TCP_FIN);
139 }
140
141 /**
142 * Create a TCP segment with prefilled header.
143 *
144 * Called by tcp_write and tcp_enqueue_flags.
145 *
146 * @param pcb Protocol control block for the TCP connection.
147 * @param p pbuf that is used to hold the TCP header.
148 * @param flags TCP flags for header.
149 * @param seqno TCP sequence number of this packet
150 * @param optflags options to include in TCP header
151 * @return a new tcp_seg pointing to p, or NULL.
152 * The TCP header is filled in except ackno and wnd.
153 * p is freed on failure.
154 */
155 static struct tcp_seg *
tcp_create_segment(struct tcp_pcb * pcb,struct pbuf * p,u8_t flags,u32_t seqno,u8_t optflags)156 tcp_create_segment(struct tcp_pcb *pcb, struct pbuf *p, u8_t flags, u32_t seqno, u8_t optflags)
157 {
158 struct tcp_seg *seg;
159 u8_t optlen = LWIP_TCP_OPT_LENGTH(optflags);
160
161 if ((seg = (struct tcp_seg *)memp_malloc(MEMP_TCP_SEG)) == NULL) {
162 LWIP_DEBUGF(TCP_OUTPUT_DEBUG | 2, ("tcp_create_segment: no memory.\n"));
163 pbuf_free(p);
164 return NULL;
165 }
166 seg->flags = optflags;
167 seg->next = NULL;
168 seg->p = p;
169 seg->len = p->tot_len - optlen;
170 #if TCP_OVERSIZE_DBGCHECK
171 seg->oversize_left = 0;
172 #endif /* TCP_OVERSIZE_DBGCHECK */
173 #if TCP_CHECKSUM_ON_COPY
174 seg->chksum = 0;
175 seg->chksum_swapped = 0;
176 /* check optflags */
177 LWIP_ASSERT("invalid optflags passed: TF_SEG_DATA_CHECKSUMMED",
178 (optflags & TF_SEG_DATA_CHECKSUMMED) == 0);
179 #endif /* TCP_CHECKSUM_ON_COPY */
180
181 /* build TCP header */
182 if (pbuf_header(p, TCP_HLEN)) {
183 LWIP_DEBUGF(TCP_OUTPUT_DEBUG | 2, ("tcp_create_segment: no room for TCP header in pbuf.\n"));
184 TCP_STATS_INC(tcp.err);
185 tcp_seg_free(seg);
186 return NULL;
187 }
188 seg->tcphdr = (struct tcp_hdr *)seg->p->payload;
189 seg->tcphdr->src = htons(pcb->local_port);
190 seg->tcphdr->dest = htons(pcb->remote_port);
191 seg->tcphdr->seqno = htonl(seqno);
192 /* ackno is set in tcp_output */
193 TCPH_HDRLEN_FLAGS_SET(seg->tcphdr, (5 + optlen / 4), flags);
194 /* wnd and chksum are set in tcp_output */
195 seg->tcphdr->urgp = 0;
196 return seg;
197 }
198
199 /**
200 * Allocate a PBUF_RAM pbuf, perhaps with extra space at the end.
201 *
202 * This function is like pbuf_alloc(layer, length, PBUF_RAM) except
203 * there may be extra bytes available at the end.
204 *
205 * @param layer flag to define header size.
206 * @param length size of the pbuf's payload.
207 * @param max_length maximum usable size of payload+oversize.
208 * @param oversize pointer to a u16_t that will receive the number of usable tail bytes.
209 * @param pcb The TCP connection that willo enqueue the pbuf.
210 * @param apiflags API flags given to tcp_write.
211 * @param first_seg true when this pbuf will be used in the first enqueued segment.
212 * @param
213 */
214 #if TCP_OVERSIZE
215 static struct pbuf *
tcp_pbuf_prealloc(pbuf_layer layer,u16_t length,u16_t max_length,u16_t * oversize,struct tcp_pcb * pcb,u8_t apiflags,u8_t first_seg)216 tcp_pbuf_prealloc(pbuf_layer layer, u16_t length, u16_t max_length,
217 u16_t *oversize, struct tcp_pcb *pcb, u8_t apiflags,
218 u8_t first_seg)
219 {
220 struct pbuf *p;
221 u16_t alloc = length;
222
223 #if LWIP_NETIF_TX_SINGLE_PBUF
224 LWIP_UNUSED_ARG(max_length);
225 LWIP_UNUSED_ARG(pcb);
226 LWIP_UNUSED_ARG(apiflags);
227 LWIP_UNUSED_ARG(first_seg);
228 /* always create MSS-sized pbufs */
229 alloc = TCP_MSS;
230 #else /* LWIP_NETIF_TX_SINGLE_PBUF */
231 if (length < max_length) {
232 /* Should we allocate an oversized pbuf, or just the minimum
233 * length required? If tcp_write is going to be called again
234 * before this segment is transmitted, we want the oversized
235 * buffer. If the segment will be transmitted immediately, we can
236 * save memory by allocating only length. We use a simple
237 * heuristic based on the following information:
238 *
239 * Did the user set TCP_WRITE_FLAG_MORE?
240 *
241 * Will the Nagle algorithm defer transmission of this segment?
242 */
243 if ((apiflags & TCP_WRITE_FLAG_MORE) ||
244 (!(pcb->flags & TF_NODELAY) &&
245 (!first_seg ||
246 pcb->unsent != NULL ||
247 pcb->unacked != NULL))) {
248 alloc = LWIP_MIN(max_length, LWIP_MEM_ALIGN_SIZE(length + TCP_OVERSIZE));
249 }
250 }
251 #endif /* LWIP_NETIF_TX_SINGLE_PBUF */
252 p = pbuf_alloc(layer, alloc, PBUF_RAM);
253 if (p == NULL) {
254 return NULL;
255 }
256 LWIP_ASSERT("need unchained pbuf", p->next == NULL);
257 *oversize = p->len - length;
258 /* trim p->len to the currently used size */
259 p->len = p->tot_len = length;
260 return p;
261 }
262 #else /* TCP_OVERSIZE */
263 #define tcp_pbuf_prealloc(layer, length, mx, os, pcb, api, fst) pbuf_alloc((layer), (length), PBUF_RAM)
264 #endif /* TCP_OVERSIZE */
265
266 #if TCP_CHECKSUM_ON_COPY
267 /** Add a checksum of newly added data to the segment */
268 static void
tcp_seg_add_chksum(u16_t chksum,u16_t len,u16_t * seg_chksum,u8_t * seg_chksum_swapped)269 tcp_seg_add_chksum(u16_t chksum, u16_t len, u16_t *seg_chksum,
270 u8_t *seg_chksum_swapped)
271 {
272 u32_t helper;
273 /* add chksum to old chksum and fold to u16_t */
274 helper = chksum + *seg_chksum;
275 chksum = FOLD_U32T(helper);
276 if ((len & 1) != 0) {
277 *seg_chksum_swapped = 1 - *seg_chksum_swapped;
278 chksum = SWAP_BYTES_IN_WORD(chksum);
279 }
280 *seg_chksum = chksum;
281 }
282 #endif /* TCP_CHECKSUM_ON_COPY */
283
284 /** Checks if tcp_write is allowed or not (checks state, snd_buf and snd_queuelen).
285 *
286 * @param pcb the tcp pcb to check for
287 * @param len length of data to send (checked agains snd_buf)
288 * @return ERR_OK if tcp_write is allowed to proceed, another err_t otherwise
289 */
290 static err_t
tcp_write_checks(struct tcp_pcb * pcb,u16_t len)291 tcp_write_checks(struct tcp_pcb *pcb, u16_t len)
292 {
293 /* connection is in invalid state for data transmission? */
294 if ((pcb->state != ESTABLISHED) &&
295 (pcb->state != CLOSE_WAIT) &&
296 (pcb->state != SYN_SENT) &&
297 (pcb->state != SYN_RCVD)) {
298 LWIP_DEBUGF(TCP_OUTPUT_DEBUG | LWIP_DBG_STATE | LWIP_DBG_LEVEL_SEVERE, ("tcp_write() called in invalid state\n"));
299 return ERR_CONN;
300 } else if (len == 0) {
301 return ERR_OK;
302 }
303
304 /* fail on too much data */
305 if (len > pcb->snd_buf) {
306 LWIP_DEBUGF(TCP_OUTPUT_DEBUG | 3, ("tcp_write: too much data (len=%"U16_F" > snd_buf=%"U16_F")\n",
307 len, pcb->snd_buf));
308 pcb->flags |= TF_NAGLEMEMERR;
309 return ERR_MEM;
310 }
311
312 LWIP_DEBUGF(TCP_QLEN_DEBUG, ("tcp_write: queuelen: %"U16_F"\n", (u16_t)pcb->snd_queuelen));
313
314 /* If total number of pbufs on the unsent/unacked queues exceeds the
315 * configured maximum, return an error */
316 /* check for configured max queuelen and possible overflow */
317 if ((pcb->snd_queuelen >= TCP_SND_QUEUELEN) || (pcb->snd_queuelen > TCP_SNDQUEUELEN_OVERFLOW)) {
318 LWIP_DEBUGF(TCP_OUTPUT_DEBUG | 3, ("tcp_write: too long queue %"U16_F" (max %"U16_F")\n",
319 pcb->snd_queuelen, TCP_SND_QUEUELEN));
320 TCP_STATS_INC(tcp.memerr);
321 pcb->flags |= TF_NAGLEMEMERR;
322 return ERR_MEM;
323 }
324 if (pcb->snd_queuelen != 0) {
325 LWIP_ASSERT("tcp_write: pbufs on queue => at least one queue non-empty",
326 pcb->unacked != NULL || pcb->unsent != NULL);
327 } else {
328 LWIP_ASSERT("tcp_write: no pbufs on queue => both queues empty",
329 pcb->unacked == NULL && pcb->unsent == NULL);
330 }
331 return ERR_OK;
332 }
333
334 /**
335 * Write data for sending (but does not send it immediately).
336 *
337 * It waits in the expectation of more data being sent soon (as
338 * it can send them more efficiently by combining them together).
339 * To prompt the system to send data now, call tcp_output() after
340 * calling tcp_write().
341 *
342 * @param pcb Protocol control block for the TCP connection to enqueue data for.
343 * @param arg Pointer to the data to be enqueued for sending.
344 * @param len Data length in bytes
345 * @param apiflags combination of following flags :
346 * - TCP_WRITE_FLAG_COPY (0x01) data will be copied into memory belonging to the stack
347 * - TCP_WRITE_FLAG_MORE (0x02) for TCP connection, PSH flag will be set on last segment sent,
348 * @return ERR_OK if enqueued, another err_t on error
349 */
350 err_t
tcp_write(struct tcp_pcb * pcb,const void * arg,u16_t len,u8_t apiflags)351 tcp_write(struct tcp_pcb *pcb, const void *arg, u16_t len, u8_t apiflags)
352 {
353 struct pbuf *concat_p = NULL;
354 struct tcp_seg *last_unsent = NULL, *seg = NULL, *prev_seg = NULL, *queue = NULL;
355 u16_t pos = 0; /* position in 'arg' data */
356 u16_t queuelen;
357 u8_t optlen = 0;
358 u8_t optflags = 0;
359 #if TCP_OVERSIZE
360 u16_t oversize = 0;
361 u16_t oversize_used = 0;
362 #endif /* TCP_OVERSIZE */
363 #if TCP_CHECKSUM_ON_COPY
364 u16_t concat_chksum = 0;
365 u8_t concat_chksum_swapped = 0;
366 u16_t concat_chksummed = 0;
367 #endif /* TCP_CHECKSUM_ON_COPY */
368 err_t err;
369
370 #if LWIP_NETIF_TX_SINGLE_PBUF
371 /* Always copy to try to create single pbufs for TX */
372 apiflags |= TCP_WRITE_FLAG_COPY;
373 #endif /* LWIP_NETIF_TX_SINGLE_PBUF */
374
375 LWIP_DEBUGF(TCP_OUTPUT_DEBUG, ("tcp_write(pcb=%p, data=%p, len=%"U16_F", apiflags=%"U16_F")\n",
376 (void *)pcb, arg, len, (u16_t)apiflags));
377 LWIP_ERROR("tcp_write: arg == NULL (programmer violates API)",
378 arg != NULL, return ERR_ARG;);
379
380 err = tcp_write_checks(pcb, len);
381 if (err != ERR_OK) {
382 return err;
383 }
384 queuelen = pcb->snd_queuelen;
385
386 #if LWIP_TCP_TIMESTAMPS
387 if ((pcb->flags & TF_TIMESTAMP)) {
388 optflags = TF_SEG_OPTS_TS;
389 optlen = LWIP_TCP_OPT_LENGTH(TF_SEG_OPTS_TS);
390 }
391 #endif /* LWIP_TCP_TIMESTAMPS */
392
393
394 /*
395 * TCP segmentation is done in three phases with increasing complexity:
396 *
397 * 1. Copy data directly into an oversized pbuf.
398 * 2. Chain a new pbuf to the end of pcb->unsent.
399 * 3. Create new segments.
400 *
401 * We may run out of memory at any point. In that case we must
402 * return ERR_MEM and not change anything in pcb. Therefore, all
403 * changes are recorded in local variables and committed at the end
404 * of the function. Some pcb fields are maintained in local copies:
405 *
406 * queuelen = pcb->snd_queuelen
407 * oversize = pcb->unsent_oversize
408 *
409 * These variables are set consistently by the phases:
410 *
411 * seg points to the last segment tampered with.
412 *
413 * pos records progress as data is segmented.
414 */
415
416 /* Find the tail of the unsent queue. */
417 if (pcb->unsent != NULL) {
418 u16_t space;
419 u16_t unsent_optlen;
420
421 /* @todo: this could be sped up by keeping last_unsent in the pcb */
422 for (last_unsent = pcb->unsent; last_unsent->next != NULL;
423 last_unsent = last_unsent->next);
424
425 /* Usable space at the end of the last unsent segment */
426 unsent_optlen = LWIP_TCP_OPT_LENGTH(last_unsent->flags);
427 space = pcb->mss - (last_unsent->len + unsent_optlen);
428
429 /*
430 * Phase 1: Copy data directly into an oversized pbuf.
431 *
432 * The number of bytes copied is recorded in the oversize_used
433 * variable. The actual copying is done at the bottom of the
434 * function.
435 */
436 #if TCP_OVERSIZE
437 #if TCP_OVERSIZE_DBGCHECK
438 /* check that pcb->unsent_oversize matches last_unsent->unsent_oversize */
439 LWIP_ASSERT("unsent_oversize mismatch (pcb vs. last_unsent)",
440 pcb->unsent_oversize == last_unsent->oversize_left);
441 #endif /* TCP_OVERSIZE_DBGCHECK */
442 oversize = pcb->unsent_oversize;
443 if (oversize > 0) {
444 LWIP_ASSERT("inconsistent oversize vs. space", oversize_used <= space);
445 seg = last_unsent;
446 oversize_used = oversize < len ? oversize : len;
447 pos += oversize_used;
448 oversize -= oversize_used;
449 space -= oversize_used;
450 }
451 /* now we are either finished or oversize is zero */
452 LWIP_ASSERT("inconsistend oversize vs. len", (oversize == 0) || (pos == len));
453 #endif /* TCP_OVERSIZE */
454
455 /*
456 * Phase 2: Chain a new pbuf to the end of pcb->unsent.
457 *
458 * We don't extend segments containing SYN/FIN flags or options
459 * (len==0). The new pbuf is kept in concat_p and pbuf_cat'ed at
460 * the end.
461 */
462 if ((pos < len) && (space > 0) && (last_unsent->len > 0)) {
463 u16_t seglen = space < len - pos ? space : len - pos;
464 seg = last_unsent;
465
466 /* Create a pbuf with a copy or reference to seglen bytes. We
467 * can use PBUF_RAW here since the data appears in the middle of
468 * a segment. A header will never be prepended. */
469 if (apiflags & TCP_WRITE_FLAG_COPY) {
470 /* Data is copied */
471 if ((concat_p = tcp_pbuf_prealloc(PBUF_RAW, seglen, space, &oversize, pcb, apiflags, 1)) == NULL) {
472 LWIP_DEBUGF(TCP_OUTPUT_DEBUG | 2,
473 ("tcp_write : could not allocate memory for pbuf copy size %"U16_F"\n",
474 seglen));
475 goto memerr;
476 }
477 #if TCP_OVERSIZE_DBGCHECK
478 last_unsent->oversize_left = oversize;
479 #endif /* TCP_OVERSIZE_DBGCHECK */
480 TCP_DATA_COPY2(concat_p->payload, (u8_t*)arg + pos, seglen, &concat_chksum, &concat_chksum_swapped);
481 #if TCP_CHECKSUM_ON_COPY
482 concat_chksummed += seglen;
483 #endif /* TCP_CHECKSUM_ON_COPY */
484 } else {
485 /* Data is not copied */
486 if ((concat_p = pbuf_alloc(PBUF_RAW, seglen, PBUF_ROM)) == NULL) {
487 LWIP_DEBUGF(TCP_OUTPUT_DEBUG | 2,
488 ("tcp_write: could not allocate memory for zero-copy pbuf\n"));
489 goto memerr;
490 }
491 #if TCP_CHECKSUM_ON_COPY
492 /* calculate the checksum of nocopy-data */
493 tcp_seg_add_chksum(~inet_chksum((u8_t*)arg + pos, seglen), seglen,
494 &concat_chksum, &concat_chksum_swapped);
495 concat_chksummed += seglen;
496 #endif /* TCP_CHECKSUM_ON_COPY */
497 /* reference the non-volatile payload data */
498 concat_p->payload = (u8_t*)arg + pos;
499 }
500
501 pos += seglen;
502 queuelen += pbuf_clen(concat_p);
503 }
504 } else {
505 #if TCP_OVERSIZE
506 LWIP_ASSERT("unsent_oversize mismatch (pcb->unsent is NULL)",
507 pcb->unsent_oversize == 0);
508 #endif /* TCP_OVERSIZE */
509 }
510
511 /*
512 * Phase 3: Create new segments.
513 *
514 * The new segments are chained together in the local 'queue'
515 * variable, ready to be appended to pcb->unsent.
516 */
517 while (pos < len) {
518 struct pbuf *p;
519 u16_t left = len - pos;
520 u16_t max_len = pcb->mss - optlen;
521 u16_t seglen = left > max_len ? max_len : left;
522 #if TCP_CHECKSUM_ON_COPY
523 u16_t chksum = 0;
524 u8_t chksum_swapped = 0;
525 #endif /* TCP_CHECKSUM_ON_COPY */
526
527 if (apiflags & TCP_WRITE_FLAG_COPY) {
528 /* If copy is set, memory should be allocated and data copied
529 * into pbuf */
530 if ((p = tcp_pbuf_prealloc(PBUF_TRANSPORT, seglen + optlen, pcb->mss, &oversize, pcb, apiflags, queue == NULL)) == NULL) {
531 LWIP_DEBUGF(TCP_OUTPUT_DEBUG | 2, ("tcp_write : could not allocate memory for pbuf copy size %"U16_F"\n", seglen));
532 goto memerr;
533 }
534 LWIP_ASSERT("tcp_write: check that first pbuf can hold the complete seglen",
535 (p->len >= seglen));
536 TCP_DATA_COPY2((char *)p->payload + optlen, (u8_t*)arg + pos, seglen, &chksum, &chksum_swapped);
537 } else {
538 /* Copy is not set: First allocate a pbuf for holding the data.
539 * Since the referenced data is available at least until it is
540 * sent out on the link (as it has to be ACKed by the remote
541 * party) we can safely use PBUF_ROM instead of PBUF_REF here.
542 */
543 struct pbuf *p2;
544 #if TCP_OVERSIZE
545 LWIP_ASSERT("oversize == 0", oversize == 0);
546 #endif /* TCP_OVERSIZE */
547 if ((p2 = pbuf_alloc(PBUF_TRANSPORT, seglen, PBUF_ROM)) == NULL) {
548 LWIP_DEBUGF(TCP_OUTPUT_DEBUG | 2, ("tcp_write: could not allocate memory for zero-copy pbuf\n"));
549 goto memerr;
550 }
551 #if TCP_CHECKSUM_ON_COPY
552 /* calculate the checksum of nocopy-data */
553 chksum = ~inet_chksum((u8_t*)arg + pos, seglen);
554 #endif /* TCP_CHECKSUM_ON_COPY */
555 /* reference the non-volatile payload data */
556 p2->payload = (u8_t*)arg + pos;
557
558 /* Second, allocate a pbuf for the headers. */
559 if ((p = pbuf_alloc(PBUF_TRANSPORT, optlen, PBUF_RAM)) == NULL) {
560 /* If allocation fails, we have to deallocate the data pbuf as
561 * well. */
562 pbuf_free(p2);
563 LWIP_DEBUGF(TCP_OUTPUT_DEBUG | 2, ("tcp_write: could not allocate memory for header pbuf\n"));
564 goto memerr;
565 }
566 /* Concatenate the headers and data pbufs together. */
567 pbuf_cat(p/*header*/, p2/*data*/);
568 }
569
570 queuelen += pbuf_clen(p);
571
572 /* Now that there are more segments queued, we check again if the
573 * length of the queue exceeds the configured maximum or
574 * overflows. */
575 if ((queuelen > TCP_SND_QUEUELEN) || (queuelen > TCP_SNDQUEUELEN_OVERFLOW)) {
576 LWIP_DEBUGF(TCP_OUTPUT_DEBUG | 2, ("tcp_write: queue too long %"U16_F" (%"U16_F")\n", queuelen, TCP_SND_QUEUELEN));
577 pbuf_free(p);
578 goto memerr;
579 }
580
581 if ((seg = tcp_create_segment(pcb, p, 0, pcb->snd_lbb + pos, optflags)) == NULL) {
582 goto memerr;
583 }
584 #if TCP_OVERSIZE_DBGCHECK
585 seg->oversize_left = oversize;
586 #endif /* TCP_OVERSIZE_DBGCHECK */
587 #if TCP_CHECKSUM_ON_COPY
588 seg->chksum = chksum;
589 seg->chksum_swapped = chksum_swapped;
590 seg->flags |= TF_SEG_DATA_CHECKSUMMED;
591 #endif /* TCP_CHECKSUM_ON_COPY */
592
593 /* first segment of to-be-queued data? */
594 if (queue == NULL) {
595 queue = seg;
596 } else {
597 /* Attach the segment to the end of the queued segments */
598 LWIP_ASSERT("prev_seg != NULL", prev_seg != NULL);
599 prev_seg->next = seg;
600 }
601 /* remember last segment of to-be-queued data for next iteration */
602 prev_seg = seg;
603
604 LWIP_DEBUGF(TCP_OUTPUT_DEBUG | LWIP_DBG_TRACE, ("tcp_write: queueing %"U32_F":%"U32_F"\n",
605 ntohl(seg->tcphdr->seqno),
606 ntohl(seg->tcphdr->seqno) + TCP_TCPLEN(seg)));
607
608 pos += seglen;
609 }
610
611 /*
612 * All three segmentation phases were successful. We can commit the
613 * transaction.
614 */
615
616 /*
617 * Phase 1: If data has been added to the preallocated tail of
618 * last_unsent, we update the length fields of the pbuf chain.
619 */
620 #if TCP_OVERSIZE
621 if (oversize_used > 0) {
622 struct pbuf *p;
623 /* Bump tot_len of whole chain, len of tail */
624 for (p = last_unsent->p; p; p = p->next) {
625 p->tot_len += oversize_used;
626 if (p->next == NULL) {
627 TCP_DATA_COPY((char *)p->payload + p->len, arg, oversize_used, last_unsent);
628 p->len += oversize_used;
629 }
630 }
631 last_unsent->len += oversize_used;
632 #if TCP_OVERSIZE_DBGCHECK
633 last_unsent->oversize_left -= oversize_used;
634 #endif /* TCP_OVERSIZE_DBGCHECK */
635 }
636 pcb->unsent_oversize = oversize;
637 #endif /* TCP_OVERSIZE */
638
639 /*
640 * Phase 2: concat_p can be concatenated onto last_unsent->p
641 */
642 if (concat_p != NULL) {
643 LWIP_ASSERT("tcp_write: cannot concatenate when pcb->unsent is empty",
644 (last_unsent != NULL));
645 pbuf_cat(last_unsent->p, concat_p);
646 last_unsent->len += concat_p->tot_len;
647 #if TCP_CHECKSUM_ON_COPY
648 if (concat_chksummed) {
649 tcp_seg_add_chksum(concat_chksum, concat_chksummed, &last_unsent->chksum,
650 &last_unsent->chksum_swapped);
651 last_unsent->flags |= TF_SEG_DATA_CHECKSUMMED;
652 }
653 #endif /* TCP_CHECKSUM_ON_COPY */
654 }
655
656 /*
657 * Phase 3: Append queue to pcb->unsent. Queue may be NULL, but that
658 * is harmless
659 */
660 if (last_unsent == NULL) {
661 pcb->unsent = queue;
662 } else {
663 last_unsent->next = queue;
664 }
665
666 /*
667 * Finally update the pcb state.
668 */
669 pcb->snd_lbb += len;
670 pcb->snd_buf -= len;
671 pcb->snd_queuelen = queuelen;
672
673 LWIP_DEBUGF(TCP_QLEN_DEBUG, ("tcp_write: %"S16_F" (after enqueued)\n",
674 pcb->snd_queuelen));
675 if (pcb->snd_queuelen != 0) {
676 LWIP_ASSERT("tcp_write: valid queue length",
677 pcb->unacked != NULL || pcb->unsent != NULL);
678 }
679
680 /* Set the PSH flag in the last segment that we enqueued. */
681 if (seg != NULL && seg->tcphdr != NULL && ((apiflags & TCP_WRITE_FLAG_MORE)==0)) {
682 TCPH_SET_FLAG(seg->tcphdr, TCP_PSH);
683 }
684
685 return ERR_OK;
686 memerr:
687 pcb->flags |= TF_NAGLEMEMERR;
688 TCP_STATS_INC(tcp.memerr);
689
690 if (concat_p != NULL) {
691 pbuf_free(concat_p);
692 }
693 if (queue != NULL) {
694 tcp_segs_free(queue);
695 }
696 if (pcb->snd_queuelen != 0) {
697 LWIP_ASSERT("tcp_write: valid queue length", pcb->unacked != NULL ||
698 pcb->unsent != NULL);
699 }
700 LWIP_DEBUGF(TCP_QLEN_DEBUG | LWIP_DBG_STATE, ("tcp_write: %"S16_F" (with mem err)\n", pcb->snd_queuelen));
701 return ERR_MEM;
702 }
703
704 /**
705 * Enqueue TCP options for transmission.
706 *
707 * Called by tcp_connect(), tcp_listen_input(), and tcp_send_ctrl().
708 *
709 * @param pcb Protocol control block for the TCP connection.
710 * @param flags TCP header flags to set in the outgoing segment.
711 * @param optdata pointer to TCP options, or NULL.
712 * @param optlen length of TCP options in bytes.
713 */
714 err_t
tcp_enqueue_flags(struct tcp_pcb * pcb,u8_t flags)715 tcp_enqueue_flags(struct tcp_pcb *pcb, u8_t flags)
716 {
717 struct pbuf *p;
718 struct tcp_seg *seg;
719 u8_t optflags = 0;
720 u8_t optlen = 0;
721
722 LWIP_DEBUGF(TCP_QLEN_DEBUG, ("tcp_enqueue_flags: queuelen: %"U16_F"\n", (u16_t)pcb->snd_queuelen));
723
724 LWIP_ASSERT("tcp_enqueue_flags: need either TCP_SYN or TCP_FIN in flags (programmer violates API)",
725 (flags & (TCP_SYN | TCP_FIN)) != 0);
726
727 /* check for configured max queuelen and possible overflow */
728 if ((pcb->snd_queuelen >= TCP_SND_QUEUELEN) || (pcb->snd_queuelen > TCP_SNDQUEUELEN_OVERFLOW)) {
729 LWIP_DEBUGF(TCP_OUTPUT_DEBUG | 3, ("tcp_enqueue_flags: too long queue %"U16_F" (max %"U16_F")\n",
730 pcb->snd_queuelen, TCP_SND_QUEUELEN));
731 TCP_STATS_INC(tcp.memerr);
732 pcb->flags |= TF_NAGLEMEMERR;
733 return ERR_MEM;
734 }
735
736 if (flags & TCP_SYN) {
737 optflags = TF_SEG_OPTS_MSS;
738 }
739 #if LWIP_TCP_TIMESTAMPS
740 if ((pcb->flags & TF_TIMESTAMP)) {
741 optflags |= TF_SEG_OPTS_TS;
742 }
743 #endif /* LWIP_TCP_TIMESTAMPS */
744 optlen = LWIP_TCP_OPT_LENGTH(optflags);
745
746 /* tcp_enqueue_flags is always called with either SYN or FIN in flags.
747 * We need one available snd_buf byte to do that.
748 * This means we can't send FIN while snd_buf==0. A better fix would be to
749 * not include SYN and FIN sequence numbers in the snd_buf count. */
750 if (pcb->snd_buf == 0) {
751 LWIP_DEBUGF(TCP_OUTPUT_DEBUG | 3, ("tcp_enqueue_flags: no send buffer available\n"));
752 TCP_STATS_INC(tcp.memerr);
753 return ERR_MEM;
754 }
755
756 /* Allocate pbuf with room for TCP header + options */
757 if ((p = pbuf_alloc(PBUF_TRANSPORT, optlen, PBUF_RAM)) == NULL) {
758 pcb->flags |= TF_NAGLEMEMERR;
759 TCP_STATS_INC(tcp.memerr);
760 return ERR_MEM;
761 }
762 LWIP_ASSERT("tcp_enqueue_flags: check that first pbuf can hold optlen",
763 (p->len >= optlen));
764
765 /* Allocate memory for tcp_seg, and fill in fields. */
766 if ((seg = tcp_create_segment(pcb, p, flags, pcb->snd_lbb, optflags)) == NULL) {
767 pcb->flags |= TF_NAGLEMEMERR;
768 TCP_STATS_INC(tcp.memerr);
769 return ERR_MEM;
770 }
771 LWIP_ASSERT("seg->tcphdr not aligned", ((mem_ptr_t)seg->tcphdr % MEM_ALIGNMENT) == 0);
772 LWIP_ASSERT("tcp_enqueue_flags: invalid segment length", seg->len == 0);
773
774 LWIP_DEBUGF(TCP_OUTPUT_DEBUG | LWIP_DBG_TRACE,
775 ("tcp_enqueue_flags: queueing %"U32_F":%"U32_F" (0x%"X16_F")\n",
776 ntohl(seg->tcphdr->seqno),
777 ntohl(seg->tcphdr->seqno) + TCP_TCPLEN(seg),
778 (u16_t)flags));
779
780 /* Now append seg to pcb->unsent queue */
781 if (pcb->unsent == NULL) {
782 pcb->unsent = seg;
783 } else {
784 struct tcp_seg *useg;
785 for (useg = pcb->unsent; useg->next != NULL; useg = useg->next);
786 useg->next = seg;
787 }
788 #if TCP_OVERSIZE
789 /* The new unsent tail has no space */
790 pcb->unsent_oversize = 0;
791 #endif /* TCP_OVERSIZE */
792
793 /* SYN and FIN bump the sequence number */
794 if ((flags & TCP_SYN) || (flags & TCP_FIN)) {
795 pcb->snd_lbb++;
796 /* optlen does not influence snd_buf */
797 pcb->snd_buf--;
798 }
799 if (flags & TCP_FIN) {
800 pcb->flags |= TF_FIN;
801 }
802
803 /* update number of segments on the queues */
804 pcb->snd_queuelen += pbuf_clen(seg->p);
805 LWIP_DEBUGF(TCP_QLEN_DEBUG, ("tcp_enqueue_flags: %"S16_F" (after enqueued)\n", pcb->snd_queuelen));
806 if (pcb->snd_queuelen != 0) {
807 LWIP_ASSERT("tcp_enqueue_flags: invalid queue length",
808 pcb->unacked != NULL || pcb->unsent != NULL);
809 }
810
811 return ERR_OK;
812 }
813
814
815 #if LWIP_TCP_TIMESTAMPS
816 /* Build a timestamp option (12 bytes long) at the specified options pointer)
817 *
818 * @param pcb tcp_pcb
819 * @param opts option pointer where to store the timestamp option
820 */
821 static void
tcp_build_timestamp_option(struct tcp_pcb * pcb,u32_t * opts)822 tcp_build_timestamp_option(struct tcp_pcb *pcb, u32_t *opts)
823 {
824 /* Pad with two NOP options to make everything nicely aligned */
825 opts[0] = PP_HTONL(0x0101080A);
826 opts[1] = htonl(sys_now());
827 opts[2] = htonl(pcb->ts_recent);
828 }
829 #endif
830
831 /** Send an ACK without data.
832 *
833 * @param pcb Protocol control block for the TCP connection to send the ACK
834 */
835 err_t
tcp_send_empty_ack(struct tcp_pcb * pcb)836 tcp_send_empty_ack(struct tcp_pcb *pcb)
837 {
838 struct pbuf *p;
839 struct tcp_hdr *tcphdr;
840 u8_t optlen = 0;
841
842 #if LWIP_TCP_TIMESTAMPS
843 if (pcb->flags & TF_TIMESTAMP) {
844 optlen = LWIP_TCP_OPT_LENGTH(TF_SEG_OPTS_TS);
845 }
846 #endif
847
848 p = tcp_output_alloc_header(pcb, optlen, 0, htonl(pcb->snd_nxt));
849 if (p == NULL) {
850 LWIP_DEBUGF(TCP_OUTPUT_DEBUG, ("tcp_output: (ACK) could not allocate pbuf\n"));
851 return ERR_BUF;
852 }
853 tcphdr = (struct tcp_hdr *)p->payload;
854 LWIP_DEBUGF(TCP_OUTPUT_DEBUG,
855 ("tcp_output: sending ACK for %"U32_F"\n", pcb->rcv_nxt));
856 /* remove ACK flags from the PCB, as we send an empty ACK now */
857 pcb->flags &= ~(TF_ACK_DELAY | TF_ACK_NOW);
858
859 /* NB. MSS option is only sent on SYNs, so ignore it here */
860 #if LWIP_TCP_TIMESTAMPS
861 pcb->ts_lastacksent = pcb->rcv_nxt;
862
863 if (pcb->flags & TF_TIMESTAMP) {
864 tcp_build_timestamp_option(pcb, (u32_t *)(tcphdr + 1));
865 }
866 #endif
867
868 #if CHECKSUM_GEN_TCP
869 tcphdr->chksum = inet_chksum_pseudo(p, &(pcb->local_ip), &(pcb->remote_ip),
870 IP_PROTO_TCP, p->tot_len);
871 #endif
872 #if LWIP_NETIF_HWADDRHINT
873 ip_output_hinted(p, &(pcb->local_ip), &(pcb->remote_ip), pcb->ttl, pcb->tos,
874 IP_PROTO_TCP, &(pcb->addr_hint));
875 #else /* LWIP_NETIF_HWADDRHINT*/
876 ip_output(p, &(pcb->local_ip), &(pcb->remote_ip), pcb->ttl, pcb->tos,
877 IP_PROTO_TCP);
878 #endif /* LWIP_NETIF_HWADDRHINT*/
879 pbuf_free(p);
880
881 return ERR_OK;
882 }
883
884 /**
885 * Find out what we can send and send it
886 *
887 * @param pcb Protocol control block for the TCP connection to send data
888 * @return ERR_OK if data has been sent or nothing to send
889 * another err_t on error
890 */
891 err_t
tcp_output(struct tcp_pcb * pcb)892 tcp_output(struct tcp_pcb *pcb)
893 {
894 struct tcp_seg *seg, *useg;
895 u32_t wnd, snd_nxt;
896 #if TCP_CWND_DEBUG
897 s16_t i = 0;
898 #endif /* TCP_CWND_DEBUG */
899
900 /* First, check if we are invoked by the TCP input processing
901 code. If so, we do not output anything. Instead, we rely on the
902 input processing code to call us when input processing is done
903 with. */
904 if (tcp_input_pcb == pcb) {
905 return ERR_OK;
906 }
907
908 wnd = LWIP_MIN(pcb->snd_wnd, pcb->cwnd);
909
910 seg = pcb->unsent;
911
912 /* If the TF_ACK_NOW flag is set and no data will be sent (either
913 * because the ->unsent queue is empty or because the window does
914 * not allow it), construct an empty ACK segment and send it.
915 *
916 * If data is to be sent, we will just piggyback the ACK (see below).
917 */
918 if (pcb->flags & TF_ACK_NOW &&
919 (seg == NULL ||
920 ntohl(seg->tcphdr->seqno) - pcb->lastack + seg->len > wnd)) {
921 return tcp_send_empty_ack(pcb);
922 }
923
924 /* useg should point to last segment on unacked queue */
925 useg = pcb->unacked;
926 if (useg != NULL) {
927 for (; useg->next != NULL; useg = useg->next);
928 }
929
930 #if TCP_OUTPUT_DEBUG
931 if (seg == NULL) {
932 LWIP_DEBUGF(TCP_OUTPUT_DEBUG, ("tcp_output: nothing to send (%p)\n",
933 (void*)pcb->unsent));
934 }
935 #endif /* TCP_OUTPUT_DEBUG */
936 #if TCP_CWND_DEBUG
937 if (seg == NULL) {
938 LWIP_DEBUGF(TCP_CWND_DEBUG, ("tcp_output: snd_wnd %"U16_F
939 ", cwnd %"U16_F", wnd %"U32_F
940 ", seg == NULL, ack %"U32_F"\n",
941 pcb->snd_wnd, pcb->cwnd, wnd, pcb->lastack));
942 } else {
943 LWIP_DEBUGF(TCP_CWND_DEBUG,
944 ("tcp_output: snd_wnd %"U16_F", cwnd %"U16_F", wnd %"U32_F
945 ", effwnd %"U32_F", seq %"U32_F", ack %"U32_F"\n",
946 pcb->snd_wnd, pcb->cwnd, wnd,
947 ntohl(seg->tcphdr->seqno) - pcb->lastack + seg->len,
948 ntohl(seg->tcphdr->seqno), pcb->lastack));
949 }
950 #endif /* TCP_CWND_DEBUG */
951 /* data available and window allows it to be sent? */
952 while (seg != NULL &&
953 ntohl(seg->tcphdr->seqno) - pcb->lastack + seg->len <= wnd) {
954 LWIP_ASSERT("RST not expected here!",
955 (TCPH_FLAGS(seg->tcphdr) & TCP_RST) == 0);
956 /* Stop sending if the nagle algorithm would prevent it
957 * Don't stop:
958 * - if tcp_write had a memory error before (prevent delayed ACK timeout) or
959 * - if FIN was already enqueued for this PCB (SYN is always alone in a segment -
960 * either seg->next != NULL or pcb->unacked == NULL;
961 * RST is no sent using tcp_write/tcp_output.
962 */
963 if((tcp_do_output_nagle(pcb) == 0) &&
964 ((pcb->flags & (TF_NAGLEMEMERR | TF_FIN)) == 0)){
965 break;
966 }
967 #if TCP_CWND_DEBUG
968 LWIP_DEBUGF(TCP_CWND_DEBUG, ("tcp_output: snd_wnd %"U16_F", cwnd %"U16_F", wnd %"U32_F", effwnd %"U32_F", seq %"U32_F", ack %"U32_F", i %"S16_F"\n",
969 pcb->snd_wnd, pcb->cwnd, wnd,
970 ntohl(seg->tcphdr->seqno) + seg->len -
971 pcb->lastack,
972 ntohl(seg->tcphdr->seqno), pcb->lastack, i));
973 ++i;
974 #endif /* TCP_CWND_DEBUG */
975
976 pcb->unsent = seg->next;
977
978 if (pcb->state != SYN_SENT) {
979 TCPH_SET_FLAG(seg->tcphdr, TCP_ACK);
980 pcb->flags &= ~(TF_ACK_DELAY | TF_ACK_NOW);
981 }
982
983 tcp_output_segment(seg, pcb);
984 snd_nxt = ntohl(seg->tcphdr->seqno) + TCP_TCPLEN(seg);
985 if (TCP_SEQ_LT(pcb->snd_nxt, snd_nxt)) {
986 pcb->snd_nxt = snd_nxt;
987 }
988 /* put segment on unacknowledged list if length > 0 */
989 if (TCP_TCPLEN(seg) > 0) {
990 seg->next = NULL;
991 /* unacked list is empty? */
992 if (pcb->unacked == NULL) {
993 pcb->unacked = seg;
994 useg = seg;
995 /* unacked list is not empty? */
996 } else {
997 /* In the case of fast retransmit, the packet should not go to the tail
998 * of the unacked queue, but rather somewhere before it. We need to check for
999 * this case. -STJ Jul 27, 2004 */
1000 if (TCP_SEQ_LT(ntohl(seg->tcphdr->seqno), ntohl(useg->tcphdr->seqno))) {
1001 /* add segment to before tail of unacked list, keeping the list sorted */
1002 struct tcp_seg **cur_seg = &(pcb->unacked);
1003 while (*cur_seg &&
1004 TCP_SEQ_LT(ntohl((*cur_seg)->tcphdr->seqno), ntohl(seg->tcphdr->seqno))) {
1005 cur_seg = &((*cur_seg)->next );
1006 }
1007 seg->next = (*cur_seg);
1008 (*cur_seg) = seg;
1009 } else {
1010 /* add segment to tail of unacked list */
1011 useg->next = seg;
1012 useg = useg->next;
1013 }
1014 }
1015 /* do not queue empty segments on the unacked list */
1016 } else {
1017 tcp_seg_free(seg);
1018 }
1019 seg = pcb->unsent;
1020 }
1021 #if TCP_OVERSIZE
1022 if (pcb->unsent == NULL) {
1023 /* last unsent has been removed, reset unsent_oversize */
1024 pcb->unsent_oversize = 0;
1025 }
1026 #endif /* TCP_OVERSIZE */
1027
1028 if (seg != NULL && pcb->persist_backoff == 0 &&
1029 ntohl(seg->tcphdr->seqno) - pcb->lastack + seg->len > pcb->snd_wnd) {
1030 /* prepare for persist timer */
1031 pcb->persist_cnt = 0;
1032 pcb->persist_backoff = 1;
1033 }
1034
1035 pcb->flags &= ~TF_NAGLEMEMERR;
1036 return ERR_OK;
1037 }
1038
1039 /**
1040 * Called by tcp_output() to actually send a TCP segment over IP.
1041 *
1042 * @param seg the tcp_seg to send
1043 * @param pcb the tcp_pcb for the TCP connection used to send the segment
1044 */
1045 static void
tcp_output_segment(struct tcp_seg * seg,struct tcp_pcb * pcb)1046 tcp_output_segment(struct tcp_seg *seg, struct tcp_pcb *pcb)
1047 {
1048 u16_t len;
1049 struct netif *netif;
1050 u32_t *opts;
1051
1052 /** @bug Exclude retransmitted segments from this count. */
1053 snmp_inc_tcpoutsegs();
1054
1055 /* The TCP header has already been constructed, but the ackno and
1056 wnd fields remain. */
1057 seg->tcphdr->ackno = htonl(pcb->rcv_nxt);
1058
1059 /* advertise our receive window size in this TCP segment */
1060 seg->tcphdr->wnd = htons(pcb->rcv_ann_wnd);
1061
1062 pcb->rcv_ann_right_edge = pcb->rcv_nxt + pcb->rcv_ann_wnd;
1063
1064 /* Add any requested options. NB MSS option is only set on SYN
1065 packets, so ignore it here */
1066 LWIP_ASSERT("seg->tcphdr not aligned", ((mem_ptr_t)seg->tcphdr % MEM_ALIGNMENT) == 0);
1067 opts = (u32_t *)(void *)(seg->tcphdr + 1);
1068 if (seg->flags & TF_SEG_OPTS_MSS) {
1069 TCP_BUILD_MSS_OPTION(*opts);
1070 opts += 1;
1071 }
1072 #if LWIP_TCP_TIMESTAMPS
1073 pcb->ts_lastacksent = pcb->rcv_nxt;
1074
1075 if (seg->flags & TF_SEG_OPTS_TS) {
1076 tcp_build_timestamp_option(pcb, opts);
1077 opts += 3;
1078 }
1079 #endif
1080
1081 /* Set retransmission timer running if it is not currently enabled
1082 This must be set before checking the route. */
1083 if (pcb->rtime == -1) {
1084 pcb->rtime = 0;
1085 }
1086
1087 /* If we don't have a local IP address, we get one by
1088 calling ip_route(). */
1089 if (ip_addr_isany(&(pcb->local_ip))) {
1090 netif = ip_route(&(pcb->remote_ip));
1091 if (netif == NULL) {
1092 return;
1093 }
1094 ip_addr_copy(pcb->local_ip, netif->ip_addr);
1095 }
1096
1097 if (pcb->rttest == 0) {
1098 pcb->rttest = tcp_ticks;
1099 pcb->rtseq = ntohl(seg->tcphdr->seqno);
1100
1101 LWIP_DEBUGF(TCP_RTO_DEBUG, ("tcp_output_segment: rtseq %"U32_F"\n", pcb->rtseq));
1102 }
1103 LWIP_DEBUGF(TCP_OUTPUT_DEBUG, ("tcp_output_segment: %"U32_F":%"U32_F"\n",
1104 htonl(seg->tcphdr->seqno), htonl(seg->tcphdr->seqno) +
1105 seg->len));
1106
1107 len = (u16_t)((u8_t *)seg->tcphdr - (u8_t *)seg->p->payload);
1108
1109 seg->p->len -= len;
1110 seg->p->tot_len -= len;
1111
1112 seg->p->payload = seg->tcphdr;
1113
1114 seg->tcphdr->chksum = 0;
1115 #if CHECKSUM_GEN_TCP
1116 #if TCP_CHECKSUM_ON_COPY
1117 {
1118 u32_t acc;
1119 #if TCP_CHECKSUM_ON_COPY_SANITY_CHECK
1120 u16_t chksum_slow = inet_chksum_pseudo(seg->p, &(pcb->local_ip),
1121 &(pcb->remote_ip),
1122 IP_PROTO_TCP, seg->p->tot_len);
1123 #endif /* TCP_CHECKSUM_ON_COPY_SANITY_CHECK */
1124 if ((seg->flags & TF_SEG_DATA_CHECKSUMMED) == 0) {
1125 LWIP_ASSERT("data included but not checksummed",
1126 seg->p->tot_len == (TCPH_HDRLEN(seg->tcphdr) * 4));
1127 }
1128
1129 /* rebuild TCP header checksum (TCP header changes for retransmissions!) */
1130 acc = inet_chksum_pseudo_partial(seg->p, &(pcb->local_ip),
1131 &(pcb->remote_ip),
1132 IP_PROTO_TCP, seg->p->tot_len, TCPH_HDRLEN(seg->tcphdr) * 4);
1133 /* add payload checksum */
1134 if (seg->chksum_swapped) {
1135 seg->chksum = SWAP_BYTES_IN_WORD(seg->chksum);
1136 seg->chksum_swapped = 0;
1137 }
1138 acc += (u16_t)~(seg->chksum);
1139 seg->tcphdr->chksum = FOLD_U32T(acc);
1140 #if TCP_CHECKSUM_ON_COPY_SANITY_CHECK
1141 if (chksum_slow != seg->tcphdr->chksum) {
1142 LWIP_DEBUGF(TCP_DEBUG | LWIP_DBG_LEVEL_WARNING,
1143 ("tcp_output_segment: calculated checksum is %"X16_F" instead of %"X16_F"\n",
1144 seg->tcphdr->chksum, chksum_slow));
1145 seg->tcphdr->chksum = chksum_slow;
1146 }
1147 #endif /* TCP_CHECKSUM_ON_COPY_SANITY_CHECK */
1148 }
1149 #else /* TCP_CHECKSUM_ON_COPY */
1150 seg->tcphdr->chksum = inet_chksum_pseudo(seg->p, &(pcb->local_ip),
1151 &(pcb->remote_ip),
1152 IP_PROTO_TCP, seg->p->tot_len);
1153 #endif /* TCP_CHECKSUM_ON_COPY */
1154 #endif /* CHECKSUM_GEN_TCP */
1155 TCP_STATS_INC(tcp.xmit);
1156
1157 #if LWIP_NETIF_HWADDRHINT
1158 ip_output_hinted(seg->p, &(pcb->local_ip), &(pcb->remote_ip), pcb->ttl, pcb->tos,
1159 IP_PROTO_TCP, &(pcb->addr_hint));
1160 #else /* LWIP_NETIF_HWADDRHINT*/
1161 ip_output(seg->p, &(pcb->local_ip), &(pcb->remote_ip), pcb->ttl, pcb->tos,
1162 IP_PROTO_TCP);
1163 #endif /* LWIP_NETIF_HWADDRHINT*/
1164 }
1165
1166 /**
1167 * Send a TCP RESET packet (empty segment with RST flag set) either to
1168 * abort a connection or to show that there is no matching local connection
1169 * for a received segment.
1170 *
1171 * Called by tcp_abort() (to abort a local connection), tcp_input() (if no
1172 * matching local pcb was found), tcp_listen_input() (if incoming segment
1173 * has ACK flag set) and tcp_process() (received segment in the wrong state)
1174 *
1175 * Since a RST segment is in most cases not sent for an active connection,
1176 * tcp_rst() has a number of arguments that are taken from a tcp_pcb for
1177 * most other segment output functions.
1178 *
1179 * @param seqno the sequence number to use for the outgoing segment
1180 * @param ackno the acknowledge number to use for the outgoing segment
1181 * @param local_ip the local IP address to send the segment from
1182 * @param remote_ip the remote IP address to send the segment to
1183 * @param local_port the local TCP port to send the segment from
1184 * @param remote_port the remote TCP port to send the segment to
1185 */
1186 void
tcp_rst(u32_t seqno,u32_t ackno,ip_addr_t * local_ip,ip_addr_t * remote_ip,u16_t local_port,u16_t remote_port)1187 tcp_rst(u32_t seqno, u32_t ackno,
1188 ip_addr_t *local_ip, ip_addr_t *remote_ip,
1189 u16_t local_port, u16_t remote_port)
1190 {
1191 struct pbuf *p;
1192 struct tcp_hdr *tcphdr;
1193 p = pbuf_alloc(PBUF_IP, TCP_HLEN, PBUF_RAM);
1194 if (p == NULL) {
1195 LWIP_DEBUGF(TCP_DEBUG, ("tcp_rst: could not allocate memory for pbuf\n"));
1196 return;
1197 }
1198 LWIP_ASSERT("check that first pbuf can hold struct tcp_hdr",
1199 (p->len >= sizeof(struct tcp_hdr)));
1200
1201 tcphdr = (struct tcp_hdr *)p->payload;
1202 tcphdr->src = htons(local_port);
1203 tcphdr->dest = htons(remote_port);
1204 tcphdr->seqno = htonl(seqno);
1205 tcphdr->ackno = htonl(ackno);
1206 TCPH_HDRLEN_FLAGS_SET(tcphdr, TCP_HLEN/4, TCP_RST | TCP_ACK);
1207 tcphdr->wnd = PP_HTONS(TCP_WND);
1208 tcphdr->chksum = 0;
1209 tcphdr->urgp = 0;
1210
1211 #if CHECKSUM_GEN_TCP
1212 tcphdr->chksum = inet_chksum_pseudo(p, local_ip, remote_ip,
1213 IP_PROTO_TCP, p->tot_len);
1214 #endif
1215 TCP_STATS_INC(tcp.xmit);
1216 snmp_inc_tcpoutrsts();
1217 /* Send output with hardcoded TTL since we have no access to the pcb */
1218 ip_output(p, local_ip, remote_ip, TCP_TTL, 0, IP_PROTO_TCP);
1219 pbuf_free(p);
1220 LWIP_DEBUGF(TCP_RST_DEBUG, ("tcp_rst: seqno %"U32_F" ackno %"U32_F".\n", seqno, ackno));
1221 }
1222
1223 /**
1224 * Requeue all unacked segments for retransmission
1225 *
1226 * Called by tcp_slowtmr() for slow retransmission.
1227 *
1228 * @param pcb the tcp_pcb for which to re-enqueue all unacked segments
1229 */
1230 void
tcp_rexmit_rto(struct tcp_pcb * pcb)1231 tcp_rexmit_rto(struct tcp_pcb *pcb)
1232 {
1233 struct tcp_seg *seg;
1234
1235 if (pcb->unacked == NULL) {
1236 return;
1237 }
1238
1239 /* Move all unacked segments to the head of the unsent queue */
1240 for (seg = pcb->unacked; seg->next != NULL; seg = seg->next);
1241 /* concatenate unsent queue after unacked queue */
1242 seg->next = pcb->unsent;
1243 /* unsent queue is the concatenated queue (of unacked, unsent) */
1244 pcb->unsent = pcb->unacked;
1245 /* unacked queue is now empty */
1246 pcb->unacked = NULL;
1247
1248 /* increment number of retransmissions */
1249 ++pcb->nrtx;
1250
1251 /* Don't take any RTT measurements after retransmitting. */
1252 pcb->rttest = 0;
1253
1254 /* Do the actual retransmission */
1255 tcp_output(pcb);
1256 }
1257
1258 /**
1259 * Requeue the first unacked segment for retransmission
1260 *
1261 * Called by tcp_receive() for fast retramsmit.
1262 *
1263 * @param pcb the tcp_pcb for which to retransmit the first unacked segment
1264 */
1265 void
tcp_rexmit(struct tcp_pcb * pcb)1266 tcp_rexmit(struct tcp_pcb *pcb)
1267 {
1268 struct tcp_seg *seg;
1269 struct tcp_seg **cur_seg;
1270
1271 if (pcb->unacked == NULL) {
1272 return;
1273 }
1274
1275 /* Move the first unacked segment to the unsent queue */
1276 /* Keep the unsent queue sorted. */
1277 seg = pcb->unacked;
1278 pcb->unacked = seg->next;
1279
1280 cur_seg = &(pcb->unsent);
1281 while (*cur_seg &&
1282 TCP_SEQ_LT(ntohl((*cur_seg)->tcphdr->seqno), ntohl(seg->tcphdr->seqno))) {
1283 cur_seg = &((*cur_seg)->next );
1284 }
1285 seg->next = *cur_seg;
1286 *cur_seg = seg;
1287
1288 ++pcb->nrtx;
1289
1290 /* Don't take any rtt measurements after retransmitting. */
1291 pcb->rttest = 0;
1292
1293 /* Do the actual retransmission. */
1294 snmp_inc_tcpretranssegs();
1295 /* No need to call tcp_output: we are always called from tcp_input()
1296 and thus tcp_output directly returns. */
1297 }
1298
1299
1300 /**
1301 * Handle retransmission after three dupacks received
1302 *
1303 * @param pcb the tcp_pcb for which to retransmit the first unacked segment
1304 */
1305 void
tcp_rexmit_fast(struct tcp_pcb * pcb)1306 tcp_rexmit_fast(struct tcp_pcb *pcb)
1307 {
1308 if (pcb->unacked != NULL && !(pcb->flags & TF_INFR)) {
1309 /* This is fast retransmit. Retransmit the first unacked segment. */
1310 LWIP_DEBUGF(TCP_FR_DEBUG,
1311 ("tcp_receive: dupacks %"U16_F" (%"U32_F
1312 "), fast retransmit %"U32_F"\n",
1313 (u16_t)pcb->dupacks, pcb->lastack,
1314 ntohl(pcb->unacked->tcphdr->seqno)));
1315 tcp_rexmit(pcb);
1316
1317 /* Set ssthresh to half of the minimum of the current
1318 * cwnd and the advertised window */
1319 if (pcb->cwnd > pcb->snd_wnd) {
1320 pcb->ssthresh = pcb->snd_wnd / 2;
1321 } else {
1322 pcb->ssthresh = pcb->cwnd / 2;
1323 }
1324
1325 /* The minimum value for ssthresh should be 2 MSS */
1326 if (pcb->ssthresh < 2*pcb->mss) {
1327 LWIP_DEBUGF(TCP_FR_DEBUG,
1328 ("tcp_receive: The minimum value for ssthresh %"U16_F
1329 " should be min 2 mss %"U16_F"...\n",
1330 pcb->ssthresh, 2*pcb->mss));
1331 pcb->ssthresh = 2*pcb->mss;
1332 }
1333
1334 pcb->cwnd = pcb->ssthresh + 3 * pcb->mss;
1335 pcb->flags |= TF_INFR;
1336 }
1337 }
1338
1339
1340 /**
1341 * Send keepalive packets to keep a connection active although
1342 * no data is sent over it.
1343 *
1344 * Called by tcp_slowtmr()
1345 *
1346 * @param pcb the tcp_pcb for which to send a keepalive packet
1347 */
1348 void
tcp_keepalive(struct tcp_pcb * pcb)1349 tcp_keepalive(struct tcp_pcb *pcb)
1350 {
1351 struct pbuf *p;
1352 struct tcp_hdr *tcphdr;
1353
1354 LWIP_DEBUGF(TCP_DEBUG, ("tcp_keepalive: sending KEEPALIVE probe to %"U16_F".%"U16_F".%"U16_F".%"U16_F"\n",
1355 ip4_addr1_16(&pcb->remote_ip), ip4_addr2_16(&pcb->remote_ip),
1356 ip4_addr3_16(&pcb->remote_ip), ip4_addr4_16(&pcb->remote_ip)));
1357
1358 LWIP_DEBUGF(TCP_DEBUG, ("tcp_keepalive: tcp_ticks %"U32_F" pcb->tmr %"U32_F" pcb->keep_cnt_sent %"U16_F"\n",
1359 tcp_ticks, pcb->tmr, pcb->keep_cnt_sent));
1360
1361 p = tcp_output_alloc_header(pcb, 0, 0, htonl(pcb->snd_nxt - 1));
1362 if(p == NULL) {
1363 LWIP_DEBUGF(TCP_DEBUG,
1364 ("tcp_keepalive: could not allocate memory for pbuf\n"));
1365 return;
1366 }
1367 tcphdr = (struct tcp_hdr *)p->payload;
1368
1369 #if CHECKSUM_GEN_TCP
1370 tcphdr->chksum = inet_chksum_pseudo(p, &pcb->local_ip, &pcb->remote_ip,
1371 IP_PROTO_TCP, p->tot_len);
1372 #endif
1373 TCP_STATS_INC(tcp.xmit);
1374
1375 /* Send output to IP */
1376 #if LWIP_NETIF_HWADDRHINT
1377 ip_output_hinted(p, &pcb->local_ip, &pcb->remote_ip, pcb->ttl, 0, IP_PROTO_TCP,
1378 &(pcb->addr_hint));
1379 #else /* LWIP_NETIF_HWADDRHINT*/
1380 ip_output(p, &pcb->local_ip, &pcb->remote_ip, pcb->ttl, 0, IP_PROTO_TCP);
1381 #endif /* LWIP_NETIF_HWADDRHINT*/
1382
1383 pbuf_free(p);
1384
1385 LWIP_DEBUGF(TCP_DEBUG, ("tcp_keepalive: seqno %"U32_F" ackno %"U32_F".\n",
1386 pcb->snd_nxt - 1, pcb->rcv_nxt));
1387 }
1388
1389
1390 /**
1391 * Send persist timer zero-window probes to keep a connection active
1392 * when a window update is lost.
1393 *
1394 * Called by tcp_slowtmr()
1395 *
1396 * @param pcb the tcp_pcb for which to send a zero-window probe packet
1397 */
1398 void
tcp_zero_window_probe(struct tcp_pcb * pcb)1399 tcp_zero_window_probe(struct tcp_pcb *pcb)
1400 {
1401 struct pbuf *p;
1402 struct tcp_hdr *tcphdr;
1403 struct tcp_seg *seg;
1404 u16_t len;
1405 u8_t is_fin;
1406
1407 LWIP_DEBUGF(TCP_DEBUG,
1408 ("tcp_zero_window_probe: sending ZERO WINDOW probe to %"
1409 U16_F".%"U16_F".%"U16_F".%"U16_F"\n",
1410 ip4_addr1_16(&pcb->remote_ip), ip4_addr2_16(&pcb->remote_ip),
1411 ip4_addr3_16(&pcb->remote_ip), ip4_addr4_16(&pcb->remote_ip)));
1412
1413 LWIP_DEBUGF(TCP_DEBUG,
1414 ("tcp_zero_window_probe: tcp_ticks %"U32_F
1415 " pcb->tmr %"U32_F" pcb->keep_cnt_sent %"U16_F"\n",
1416 tcp_ticks, pcb->tmr, pcb->keep_cnt_sent));
1417
1418 seg = pcb->unacked;
1419
1420 if(seg == NULL) {
1421 seg = pcb->unsent;
1422 }
1423 if(seg == NULL) {
1424 return;
1425 }
1426
1427 is_fin = ((TCPH_FLAGS(seg->tcphdr) & TCP_FIN) != 0) && (seg->len == 0);
1428 /* we want to send one seqno: either FIN or data (no options) */
1429 len = is_fin ? 0 : 1;
1430
1431 p = tcp_output_alloc_header(pcb, 0, len, seg->tcphdr->seqno);
1432 if(p == NULL) {
1433 LWIP_DEBUGF(TCP_DEBUG, ("tcp_zero_window_probe: no memory for pbuf\n"));
1434 return;
1435 }
1436 tcphdr = (struct tcp_hdr *)p->payload;
1437
1438 if (is_fin) {
1439 /* FIN segment, no data */
1440 TCPH_FLAGS_SET(tcphdr, TCP_ACK | TCP_FIN);
1441 } else {
1442 /* Data segment, copy in one byte from the head of the unacked queue */
1443 struct tcp_hdr *thdr = (struct tcp_hdr *)seg->p->payload;
1444 char *d = ((char *)p->payload + TCP_HLEN);
1445 pbuf_copy_partial(seg->p, d, 1, TCPH_HDRLEN(thdr) * 4);
1446 }
1447
1448 #if CHECKSUM_GEN_TCP
1449 tcphdr->chksum = inet_chksum_pseudo(p, &pcb->local_ip, &pcb->remote_ip,
1450 IP_PROTO_TCP, p->tot_len);
1451 #endif
1452 TCP_STATS_INC(tcp.xmit);
1453
1454 /* Send output to IP */
1455 #if LWIP_NETIF_HWADDRHINT
1456 ip_output_hinted(p, &pcb->local_ip, &pcb->remote_ip, pcb->ttl, 0, IP_PROTO_TCP,
1457 &(pcb->addr_hint));
1458 #else /* LWIP_NETIF_HWADDRHINT*/
1459 ip_output(p, &pcb->local_ip, &pcb->remote_ip, pcb->ttl, 0, IP_PROTO_TCP);
1460 #endif /* LWIP_NETIF_HWADDRHINT*/
1461
1462 pbuf_free(p);
1463
1464 LWIP_DEBUGF(TCP_DEBUG, ("tcp_zero_window_probe: seqno %"U32_F
1465 " ackno %"U32_F".\n",
1466 pcb->snd_nxt - 1, pcb->rcv_nxt));
1467 }
1468 #endif /* LWIP_TCP */
1469