3 * Transmission Control Protocol, outgoing traffic
5 * The output functions of TCP.
10 * Copyright (c) 2001-2004 Swedish Institute of Computer Science.
11 * All rights reserved.
13 * Redistribution and use in source and binary forms, with or without modification,
14 * are permitted provided that the following conditions are met:
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.
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
35 * This file is part of the lwIP TCP/IP stack.
37 * Author: Adam Dunkels <adam@sics.se>
43 #if LWIP_TCP /* don't build if not configured for use in lwipopts.h */
45 #include "lwip/tcp_impl.h"
48 #include "lwip/memp.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"
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*/
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
78 /* Forward declarations.*/
79 static void tcp_output_segment(struct tcp_seg *seg, struct tcp_pcb *pcb);
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.)
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
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 */)
95 struct tcp_hdr *tcphdr;
96 struct pbuf *p = pbuf_alloc(PBUF_IP, TCP_HLEN + optlen + datalen, PBUF_RAM);
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);
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;
117 * Called by tcp_close() to send a segment including FIN flag but not data.
119 * @param pcb the tcp_pcb over which to send a segment
120 * @return ERR_OK if sent, another err_t otherwise
123 tcp_send_fin(struct tcp_pcb *pcb)
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);
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);
137 /* no data, no length, flags, copy=1, no optdata */
138 return tcp_enqueue_flags(pcb, TCP_FIN);
142 * Create a TCP segment with prefilled header.
144 * Called by tcp_write and tcp_enqueue_flags.
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.
155 static struct tcp_seg *
156 tcp_create_segment(struct tcp_pcb *pcb, struct pbuf *p, u8_t flags, u32_t seqno, u8_t optflags)
159 u8_t optlen = LWIP_TCP_OPT_LENGTH(optflags);
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"));
166 seg->flags = optflags;
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
175 seg->chksum_swapped = 0;
177 LWIP_ASSERT("invalid optflags passed: TF_SEG_DATA_CHECKSUMMED",
178 (optflags & TF_SEG_DATA_CHECKSUMMED) == 0);
179 #endif /* TCP_CHECKSUM_ON_COPY */
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);
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;
200 * Allocate a PBUF_RAM pbuf, perhaps with extra space at the end.
202 * This function is like pbuf_alloc(layer, length, PBUF_RAM) except
203 * there may be extra bytes available at the end.
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.
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,
221 u16_t alloc = length;
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 */
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:
239 * Did the user set TCP_WRITE_FLAG_MORE?
241 * Will the Nagle algorithm defer transmission of this segment?
243 if ((apiflags & TCP_WRITE_FLAG_MORE) ||
244 (!(pcb->flags & TF_NODELAY) &&
246 pcb->unsent != NULL ||
247 pcb->unacked != NULL))) {
248 alloc = LWIP_MIN(max_length, LWIP_MEM_ALIGN_SIZE(length + TCP_OVERSIZE));
251 #endif /* LWIP_NETIF_TX_SINGLE_PBUF */
252 p = pbuf_alloc(layer, alloc, PBUF_RAM);
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;
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 */
266 #if TCP_CHECKSUM_ON_COPY
267 /** Add a checksum of newly added data to the segment */
269 tcp_seg_add_chksum(u16_t chksum, u16_t len, u16_t *seg_chksum,
270 u8_t *seg_chksum_swapped)
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);
280 *seg_chksum = chksum;
282 #endif /* TCP_CHECKSUM_ON_COPY */
284 /** Checks if tcp_write is allowed or not (checks state, snd_buf and snd_queuelen).
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
291 tcp_write_checks(struct tcp_pcb *pcb, u16_t len)
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"));
300 } else if (len == 0) {
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",
308 pcb->flags |= TF_NAGLEMEMERR;
312 LWIP_DEBUGF(TCP_QLEN_DEBUG, ("tcp_write: queuelen: %"U16_F"\n", (u16_t)pcb->snd_queuelen));
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;
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);
328 LWIP_ASSERT("tcp_write: no pbufs on queue => both queues empty",
329 pcb->unacked == NULL && pcb->unsent == NULL);
335 * Write data for sending (but does not send it immediately).
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().
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
351 tcp_write(struct tcp_pcb *pcb, const void *arg, u16_t len, u8_t apiflags)
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 */
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 */
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 */
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;);
380 err = tcp_write_checks(pcb, len);
384 queuelen = pcb->snd_queuelen;
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);
391 #endif /* LWIP_TCP_TIMESTAMPS */
395 * TCP segmentation is done in three phases with increasing complexity:
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.
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:
406 * queuelen = pcb->snd_queuelen
407 * oversize = pcb->unsent_oversize
409 * These variables are set consistently by the phases:
411 * seg points to the last segment tampered with.
413 * pos records progress as data is segmented.
416 /* Find the tail of the unsent queue. */
417 if (pcb->unsent != NULL) {
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);
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);
430 * Phase 1: Copy data directly into an oversized pbuf.
432 * The number of bytes copied is recorded in the oversize_used
433 * variable. The actual copying is done at the bottom of the
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;
444 LWIP_ASSERT("inconsistent oversize vs. space", oversize_used <= space);
446 oversize_used = oversize < len ? oversize : len;
447 pos += oversize_used;
448 oversize -= oversize_used;
449 space -= oversize_used;
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 */
456 * Phase 2: Chain a new pbuf to the end of pcb->unsent.
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
462 if ((pos < len) && (space > 0) && (last_unsent->len > 0)) {
463 u16_t seglen = space < len - pos ? space : len - pos;
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) {
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",
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 */
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"));
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;
502 queuelen += pbuf_clen(concat_p);
506 LWIP_ASSERT("unsent_oversize mismatch (pcb->unsent is NULL)",
507 pcb->unsent_oversize == 0);
508 #endif /* TCP_OVERSIZE */
512 * Phase 3: Create new segments.
514 * The new segments are chained together in the local 'queue'
515 * variable, ready to be appended to pcb->unsent.
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
524 u8_t chksum_swapped = 0;
525 #endif /* TCP_CHECKSUM_ON_COPY */
527 if (apiflags & TCP_WRITE_FLAG_COPY) {
528 /* If copy is set, memory should be allocated and data copied
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));
534 LWIP_ASSERT("tcp_write: check that first pbuf can hold the complete seglen",
536 TCP_DATA_COPY2((char *)p->payload + optlen, (u8_t*)arg + pos, seglen, &chksum, &chksum_swapped);
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.
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"));
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;
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
563 LWIP_DEBUGF(TCP_OUTPUT_DEBUG | 2, ("tcp_write: could not allocate memory for header pbuf\n"));
566 /* Concatenate the headers and data pbufs together. */
567 pbuf_cat(p/*header*/, p2/*data*/);
570 queuelen += pbuf_clen(p);
572 /* Now that there are more segments queued, we check again if the
573 * length of the queue exceeds the configured maximum or
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));
581 if ((seg = tcp_create_segment(pcb, p, 0, pcb->snd_lbb + pos, optflags)) == NULL) {
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 */
593 /* first segment of to-be-queued data? */
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;
601 /* remember last segment of to-be-queued data for next iteration */
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)));
612 * All three segmentation phases were successful. We can commit the
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.
621 if (oversize_used > 0) {
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;
631 last_unsent->len += oversize_used;
632 #if TCP_OVERSIZE_DBGCHECK
633 last_unsent->oversize_left -= oversize_used;
634 #endif /* TCP_OVERSIZE_DBGCHECK */
636 pcb->unsent_oversize = oversize;
637 #endif /* TCP_OVERSIZE */
640 * Phase 2: concat_p can be concatenated onto last_unsent->p
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 if (concat_chksum_swapped) {
650 concat_chksum = SWAP_BYTES_IN_WORD(concat_chksum);
652 tcp_seg_add_chksum(concat_chksum, concat_chksummed, &last_unsent->chksum,
653 &last_unsent->chksum_swapped);
654 last_unsent->flags |= TF_SEG_DATA_CHECKSUMMED;
656 #endif /* TCP_CHECKSUM_ON_COPY */
660 * Phase 3: Append queue to pcb->unsent. Queue may be NULL, but that
663 if (last_unsent == NULL) {
666 last_unsent->next = queue;
670 * Finally update the pcb state.
674 pcb->snd_queuelen = queuelen;
676 LWIP_DEBUGF(TCP_QLEN_DEBUG, ("tcp_write: %"S16_F" (after enqueued)\n",
678 if (pcb->snd_queuelen != 0) {
679 LWIP_ASSERT("tcp_write: valid queue length",
680 pcb->unacked != NULL || pcb->unsent != NULL);
683 /* Set the PSH flag in the last segment that we enqueued. */
684 if (seg != NULL && seg->tcphdr != NULL && ((apiflags & TCP_WRITE_FLAG_MORE)==0)) {
685 TCPH_SET_FLAG(seg->tcphdr, TCP_PSH);
690 pcb->flags |= TF_NAGLEMEMERR;
691 TCP_STATS_INC(tcp.memerr);
693 if (concat_p != NULL) {
697 tcp_segs_free(queue);
699 if (pcb->snd_queuelen != 0) {
700 LWIP_ASSERT("tcp_write: valid queue length", pcb->unacked != NULL ||
701 pcb->unsent != NULL);
703 LWIP_DEBUGF(TCP_QLEN_DEBUG | LWIP_DBG_STATE, ("tcp_write: %"S16_F" (with mem err)\n", pcb->snd_queuelen));
708 * Enqueue TCP options for transmission.
710 * Called by tcp_connect(), tcp_listen_input(), and tcp_send_ctrl().
712 * @param pcb Protocol control block for the TCP connection.
713 * @param flags TCP header flags to set in the outgoing segment.
714 * @param optdata pointer to TCP options, or NULL.
715 * @param optlen length of TCP options in bytes.
718 tcp_enqueue_flags(struct tcp_pcb *pcb, u8_t flags)
725 LWIP_DEBUGF(TCP_QLEN_DEBUG, ("tcp_enqueue_flags: queuelen: %"U16_F"\n", (u16_t)pcb->snd_queuelen));
727 LWIP_ASSERT("tcp_enqueue_flags: need either TCP_SYN or TCP_FIN in flags (programmer violates API)",
728 (flags & (TCP_SYN | TCP_FIN)) != 0);
730 /* check for configured max queuelen and possible overflow */
731 if ((pcb->snd_queuelen >= TCP_SND_QUEUELEN) || (pcb->snd_queuelen > TCP_SNDQUEUELEN_OVERFLOW)) {
732 LWIP_DEBUGF(TCP_OUTPUT_DEBUG | 3, ("tcp_enqueue_flags: too long queue %"U16_F" (max %"U16_F")\n",
733 pcb->snd_queuelen, TCP_SND_QUEUELEN));
734 TCP_STATS_INC(tcp.memerr);
735 pcb->flags |= TF_NAGLEMEMERR;
739 if (flags & TCP_SYN) {
740 optflags = TF_SEG_OPTS_MSS;
742 #if LWIP_TCP_TIMESTAMPS
743 if ((pcb->flags & TF_TIMESTAMP)) {
744 optflags |= TF_SEG_OPTS_TS;
746 #endif /* LWIP_TCP_TIMESTAMPS */
747 optlen = LWIP_TCP_OPT_LENGTH(optflags);
749 /* tcp_enqueue_flags is always called with either SYN or FIN in flags.
750 * We need one available snd_buf byte to do that.
751 * This means we can't send FIN while snd_buf==0. A better fix would be to
752 * not include SYN and FIN sequence numbers in the snd_buf count. */
753 if (pcb->snd_buf == 0) {
754 LWIP_DEBUGF(TCP_OUTPUT_DEBUG | 3, ("tcp_enqueue_flags: no send buffer available\n"));
755 TCP_STATS_INC(tcp.memerr);
759 /* Allocate pbuf with room for TCP header + options */
760 if ((p = pbuf_alloc(PBUF_TRANSPORT, optlen, PBUF_RAM)) == NULL) {
761 pcb->flags |= TF_NAGLEMEMERR;
762 TCP_STATS_INC(tcp.memerr);
765 LWIP_ASSERT("tcp_enqueue_flags: check that first pbuf can hold optlen",
768 /* Allocate memory for tcp_seg, and fill in fields. */
769 if ((seg = tcp_create_segment(pcb, p, flags, pcb->snd_lbb, optflags)) == NULL) {
770 pcb->flags |= TF_NAGLEMEMERR;
771 TCP_STATS_INC(tcp.memerr);
774 LWIP_ASSERT("seg->tcphdr not aligned", ((mem_ptr_t)seg->tcphdr % MEM_ALIGNMENT) == 0);
775 LWIP_ASSERT("tcp_enqueue_flags: invalid segment length", seg->len == 0);
777 LWIP_DEBUGF(TCP_OUTPUT_DEBUG | LWIP_DBG_TRACE,
778 ("tcp_enqueue_flags: queueing %"U32_F":%"U32_F" (0x%"X16_F")\n",
779 ntohl(seg->tcphdr->seqno),
780 ntohl(seg->tcphdr->seqno) + TCP_TCPLEN(seg),
783 /* Now append seg to pcb->unsent queue */
784 if (pcb->unsent == NULL) {
787 struct tcp_seg *useg;
788 for (useg = pcb->unsent; useg->next != NULL; useg = useg->next);
792 /* The new unsent tail has no space */
793 pcb->unsent_oversize = 0;
794 #endif /* TCP_OVERSIZE */
796 /* SYN and FIN bump the sequence number */
797 if ((flags & TCP_SYN) || (flags & TCP_FIN)) {
799 /* optlen does not influence snd_buf */
802 if (flags & TCP_FIN) {
803 pcb->flags |= TF_FIN;
806 /* update number of segments on the queues */
807 pcb->snd_queuelen += pbuf_clen(seg->p);
808 LWIP_DEBUGF(TCP_QLEN_DEBUG, ("tcp_enqueue_flags: %"S16_F" (after enqueued)\n", pcb->snd_queuelen));
809 if (pcb->snd_queuelen != 0) {
810 LWIP_ASSERT("tcp_enqueue_flags: invalid queue length",
811 pcb->unacked != NULL || pcb->unsent != NULL);
818 #if LWIP_TCP_TIMESTAMPS
819 /* Build a timestamp option (12 bytes long) at the specified options pointer)
822 * @param opts option pointer where to store the timestamp option
825 tcp_build_timestamp_option(struct tcp_pcb *pcb, u32_t *opts)
827 /* Pad with two NOP options to make everything nicely aligned */
828 opts[0] = PP_HTONL(0x0101080A);
829 opts[1] = htonl(sys_now());
830 opts[2] = htonl(pcb->ts_recent);
834 /** Send an ACK without data.
836 * @param pcb Protocol control block for the TCP connection to send the ACK
839 tcp_send_empty_ack(struct tcp_pcb *pcb)
842 struct tcp_hdr *tcphdr;
845 #if LWIP_TCP_TIMESTAMPS
846 if (pcb->flags & TF_TIMESTAMP) {
847 optlen = LWIP_TCP_OPT_LENGTH(TF_SEG_OPTS_TS);
851 p = tcp_output_alloc_header(pcb, optlen, 0, htonl(pcb->snd_nxt));
853 LWIP_DEBUGF(TCP_OUTPUT_DEBUG, ("tcp_output: (ACK) could not allocate pbuf\n"));
856 tcphdr = (struct tcp_hdr *)p->payload;
857 LWIP_DEBUGF(TCP_OUTPUT_DEBUG,
858 ("tcp_output: sending ACK for %"U32_F"\n", pcb->rcv_nxt));
859 /* remove ACK flags from the PCB, as we send an empty ACK now */
860 pcb->flags &= ~(TF_ACK_DELAY | TF_ACK_NOW);
862 /* NB. MSS option is only sent on SYNs, so ignore it here */
863 #if LWIP_TCP_TIMESTAMPS
864 pcb->ts_lastacksent = pcb->rcv_nxt;
866 if (pcb->flags & TF_TIMESTAMP) {
867 tcp_build_timestamp_option(pcb, (u32_t *)(tcphdr + 1));
872 tcphdr->chksum = inet_chksum_pseudo(p, &(pcb->local_ip), &(pcb->remote_ip),
873 IP_PROTO_TCP, p->tot_len);
875 #if LWIP_NETIF_HWADDRHINT
876 ip_output_hinted(p, &(pcb->local_ip), &(pcb->remote_ip), pcb->ttl, pcb->tos,
877 IP_PROTO_TCP, &(pcb->addr_hint));
878 #else /* LWIP_NETIF_HWADDRHINT*/
879 ip_output(p, &(pcb->local_ip), &(pcb->remote_ip), pcb->ttl, pcb->tos,
881 #endif /* LWIP_NETIF_HWADDRHINT*/
888 * Find out what we can send and send it
890 * @param pcb Protocol control block for the TCP connection to send data
891 * @return ERR_OK if data has been sent or nothing to send
892 * another err_t on error
895 tcp_output(struct tcp_pcb *pcb)
897 struct tcp_seg *seg, *useg;
901 #endif /* TCP_CWND_DEBUG */
903 /* First, check if we are invoked by the TCP input processing
904 code. If so, we do not output anything. Instead, we rely on the
905 input processing code to call us when input processing is done
907 if (tcp_input_pcb == pcb) {
911 wnd = LWIP_MIN(pcb->snd_wnd, pcb->cwnd);
915 /* If the TF_ACK_NOW flag is set and no data will be sent (either
916 * because the ->unsent queue is empty or because the window does
917 * not allow it), construct an empty ACK segment and send it.
919 * If data is to be sent, we will just piggyback the ACK (see below).
921 if (pcb->flags & TF_ACK_NOW &&
923 ntohl(seg->tcphdr->seqno) - pcb->lastack + seg->len > wnd)) {
924 return tcp_send_empty_ack(pcb);
927 /* useg should point to last segment on unacked queue */
930 for (; useg->next != NULL; useg = useg->next);
935 LWIP_DEBUGF(TCP_OUTPUT_DEBUG, ("tcp_output: nothing to send (%p)\n",
936 (void*)pcb->unsent));
938 #endif /* TCP_OUTPUT_DEBUG */
941 LWIP_DEBUGF(TCP_CWND_DEBUG, ("tcp_output: snd_wnd %"U16_F
942 ", cwnd %"U16_F", wnd %"U32_F
943 ", seg == NULL, ack %"U32_F"\n",
944 pcb->snd_wnd, pcb->cwnd, wnd, pcb->lastack));
946 LWIP_DEBUGF(TCP_CWND_DEBUG,
947 ("tcp_output: snd_wnd %"U16_F", cwnd %"U16_F", wnd %"U32_F
948 ", effwnd %"U32_F", seq %"U32_F", ack %"U32_F"\n",
949 pcb->snd_wnd, pcb->cwnd, wnd,
950 ntohl(seg->tcphdr->seqno) - pcb->lastack + seg->len,
951 ntohl(seg->tcphdr->seqno), pcb->lastack));
953 #endif /* TCP_CWND_DEBUG */
954 /* data available and window allows it to be sent? */
955 while (seg != NULL &&
956 ntohl(seg->tcphdr->seqno) - pcb->lastack + seg->len <= wnd) {
957 LWIP_ASSERT("RST not expected here!",
958 (TCPH_FLAGS(seg->tcphdr) & TCP_RST) == 0);
959 /* Stop sending if the nagle algorithm would prevent it
961 * - if tcp_write had a memory error before (prevent delayed ACK timeout) or
962 * - if FIN was already enqueued for this PCB (SYN is always alone in a segment -
963 * either seg->next != NULL or pcb->unacked == NULL;
964 * RST is no sent using tcp_write/tcp_output.
966 if((tcp_do_output_nagle(pcb) == 0) &&
967 ((pcb->flags & (TF_NAGLEMEMERR | TF_FIN)) == 0)){
971 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",
972 pcb->snd_wnd, pcb->cwnd, wnd,
973 ntohl(seg->tcphdr->seqno) + seg->len -
975 ntohl(seg->tcphdr->seqno), pcb->lastack, i));
977 #endif /* TCP_CWND_DEBUG */
979 pcb->unsent = seg->next;
981 if (pcb->state != SYN_SENT) {
982 TCPH_SET_FLAG(seg->tcphdr, TCP_ACK);
983 pcb->flags &= ~(TF_ACK_DELAY | TF_ACK_NOW);
986 tcp_output_segment(seg, pcb);
987 snd_nxt = ntohl(seg->tcphdr->seqno) + TCP_TCPLEN(seg);
988 if (TCP_SEQ_LT(pcb->snd_nxt, snd_nxt)) {
989 pcb->snd_nxt = snd_nxt;
991 /* put segment on unacknowledged list if length > 0 */
992 if (TCP_TCPLEN(seg) > 0) {
994 /* unacked list is empty? */
995 if (pcb->unacked == NULL) {
998 /* unacked list is not empty? */
1000 /* In the case of fast retransmit, the packet should not go to the tail
1001 * of the unacked queue, but rather somewhere before it. We need to check for
1002 * this case. -STJ Jul 27, 2004 */
1003 if (TCP_SEQ_LT(ntohl(seg->tcphdr->seqno), ntohl(useg->tcphdr->seqno))) {
1004 /* add segment to before tail of unacked list, keeping the list sorted */
1005 struct tcp_seg **cur_seg = &(pcb->unacked);
1007 TCP_SEQ_LT(ntohl((*cur_seg)->tcphdr->seqno), ntohl(seg->tcphdr->seqno))) {
1008 cur_seg = &((*cur_seg)->next );
1010 seg->next = (*cur_seg);
1013 /* add segment to tail of unacked list */
1018 /* do not queue empty segments on the unacked list */
1025 if (pcb->unsent == NULL) {
1026 /* last unsent has been removed, reset unsent_oversize */
1027 pcb->unsent_oversize = 0;
1029 #endif /* TCP_OVERSIZE */
1031 if (seg != NULL && pcb->persist_backoff == 0 &&
1032 ntohl(seg->tcphdr->seqno) - pcb->lastack + seg->len > pcb->snd_wnd) {
1033 /* prepare for persist timer */
1034 pcb->persist_cnt = 0;
1035 pcb->persist_backoff = 1;
1038 pcb->flags &= ~TF_NAGLEMEMERR;
1043 * Called by tcp_output() to actually send a TCP segment over IP.
1045 * @param seg the tcp_seg to send
1046 * @param pcb the tcp_pcb for the TCP connection used to send the segment
1049 tcp_output_segment(struct tcp_seg *seg, struct tcp_pcb *pcb)
1052 struct netif *netif;
1055 /** @bug Exclude retransmitted segments from this count. */
1056 snmp_inc_tcpoutsegs();
1058 /* The TCP header has already been constructed, but the ackno and
1059 wnd fields remain. */
1060 seg->tcphdr->ackno = htonl(pcb->rcv_nxt);
1062 /* advertise our receive window size in this TCP segment */
1063 seg->tcphdr->wnd = htons(pcb->rcv_ann_wnd);
1065 pcb->rcv_ann_right_edge = pcb->rcv_nxt + pcb->rcv_ann_wnd;
1067 /* Add any requested options. NB MSS option is only set on SYN
1068 packets, so ignore it here */
1069 LWIP_ASSERT("seg->tcphdr not aligned", ((mem_ptr_t)seg->tcphdr % MEM_ALIGNMENT) == 0);
1070 opts = (u32_t *)(void *)(seg->tcphdr + 1);
1071 if (seg->flags & TF_SEG_OPTS_MSS) {
1072 TCP_BUILD_MSS_OPTION(*opts);
1075 #if LWIP_TCP_TIMESTAMPS
1076 pcb->ts_lastacksent = pcb->rcv_nxt;
1078 if (seg->flags & TF_SEG_OPTS_TS) {
1079 tcp_build_timestamp_option(pcb, opts);
1084 /* Set retransmission timer running if it is not currently enabled
1085 This must be set before checking the route. */
1086 if (pcb->rtime == -1) {
1090 /* If we don't have a local IP address, we get one by
1091 calling ip_route(). */
1092 if (ip_addr_isany(&(pcb->local_ip))) {
1093 netif = ip_route(&(pcb->remote_ip));
1094 if (netif == NULL) {
1097 ip_addr_copy(pcb->local_ip, netif->ip_addr);
1100 if (pcb->rttest == 0) {
1101 pcb->rttest = tcp_ticks;
1102 pcb->rtseq = ntohl(seg->tcphdr->seqno);
1104 LWIP_DEBUGF(TCP_RTO_DEBUG, ("tcp_output_segment: rtseq %"U32_F"\n", pcb->rtseq));
1106 LWIP_DEBUGF(TCP_OUTPUT_DEBUG, ("tcp_output_segment: %"U32_F":%"U32_F"\n",
1107 htonl(seg->tcphdr->seqno), htonl(seg->tcphdr->seqno) +
1110 len = (u16_t)((u8_t *)seg->tcphdr - (u8_t *)seg->p->payload);
1113 seg->p->tot_len -= len;
1115 seg->p->payload = seg->tcphdr;
1117 seg->tcphdr->chksum = 0;
1118 #if CHECKSUM_GEN_TCP
1119 #if TCP_CHECKSUM_ON_COPY
1122 #if TCP_CHECKSUM_ON_COPY_SANITY_CHECK
1123 u16_t chksum_slow = inet_chksum_pseudo(seg->p, &(pcb->local_ip),
1125 IP_PROTO_TCP, seg->p->tot_len);
1126 #endif /* TCP_CHECKSUM_ON_COPY_SANITY_CHECK */
1127 if ((seg->flags & TF_SEG_DATA_CHECKSUMMED) == 0) {
1128 LWIP_ASSERT("data included but not checksummed",
1129 seg->p->tot_len == (TCPH_HDRLEN(seg->tcphdr) * 4));
1132 /* rebuild TCP header checksum (TCP header changes for retransmissions!) */
1133 acc = inet_chksum_pseudo_partial(seg->p, &(pcb->local_ip),
1135 IP_PROTO_TCP, seg->p->tot_len, TCPH_HDRLEN(seg->tcphdr) * 4);
1136 /* add payload checksum */
1137 if (seg->chksum_swapped) {
1138 seg->chksum = SWAP_BYTES_IN_WORD(seg->chksum);
1139 seg->chksum_swapped = 0;
1141 acc += (u16_t)~(seg->chksum);
1142 seg->tcphdr->chksum = FOLD_U32T(acc);
1143 #if TCP_CHECKSUM_ON_COPY_SANITY_CHECK
1144 if (chksum_slow != seg->tcphdr->chksum) {
1145 LWIP_DEBUGF(TCP_DEBUG | LWIP_DBG_LEVEL_WARNING,
1146 ("tcp_output_segment: calculated checksum is %"X16_F" instead of %"X16_F"\n",
1147 seg->tcphdr->chksum, chksum_slow));
1148 seg->tcphdr->chksum = chksum_slow;
1150 #endif /* TCP_CHECKSUM_ON_COPY_SANITY_CHECK */
1152 #else /* TCP_CHECKSUM_ON_COPY */
1153 seg->tcphdr->chksum = inet_chksum_pseudo(seg->p, &(pcb->local_ip),
1155 IP_PROTO_TCP, seg->p->tot_len);
1156 #endif /* TCP_CHECKSUM_ON_COPY */
1157 #endif /* CHECKSUM_GEN_TCP */
1158 TCP_STATS_INC(tcp.xmit);
1160 #if LWIP_NETIF_HWADDRHINT
1161 ip_output_hinted(seg->p, &(pcb->local_ip), &(pcb->remote_ip), pcb->ttl, pcb->tos,
1162 IP_PROTO_TCP, &(pcb->addr_hint));
1163 #else /* LWIP_NETIF_HWADDRHINT*/
1164 ip_output(seg->p, &(pcb->local_ip), &(pcb->remote_ip), pcb->ttl, pcb->tos,
1166 #endif /* LWIP_NETIF_HWADDRHINT*/
1170 * Send a TCP RESET packet (empty segment with RST flag set) either to
1171 * abort a connection or to show that there is no matching local connection
1172 * for a received segment.
1174 * Called by tcp_abort() (to abort a local connection), tcp_input() (if no
1175 * matching local pcb was found), tcp_listen_input() (if incoming segment
1176 * has ACK flag set) and tcp_process() (received segment in the wrong state)
1178 * Since a RST segment is in most cases not sent for an active connection,
1179 * tcp_rst() has a number of arguments that are taken from a tcp_pcb for
1180 * most other segment output functions.
1182 * @param seqno the sequence number to use for the outgoing segment
1183 * @param ackno the acknowledge number to use for the outgoing segment
1184 * @param local_ip the local IP address to send the segment from
1185 * @param remote_ip the remote IP address to send the segment to
1186 * @param local_port the local TCP port to send the segment from
1187 * @param remote_port the remote TCP port to send the segment to
1190 tcp_rst(u32_t seqno, u32_t ackno,
1191 ip_addr_t *local_ip, ip_addr_t *remote_ip,
1192 u16_t local_port, u16_t remote_port)
1195 struct tcp_hdr *tcphdr;
1196 p = pbuf_alloc(PBUF_IP, TCP_HLEN, PBUF_RAM);
1198 LWIP_DEBUGF(TCP_DEBUG, ("tcp_rst: could not allocate memory for pbuf\n"));
1201 LWIP_ASSERT("check that first pbuf can hold struct tcp_hdr",
1202 (p->len >= sizeof(struct tcp_hdr)));
1204 tcphdr = (struct tcp_hdr *)p->payload;
1205 tcphdr->src = htons(local_port);
1206 tcphdr->dest = htons(remote_port);
1207 tcphdr->seqno = htonl(seqno);
1208 tcphdr->ackno = htonl(ackno);
1209 TCPH_HDRLEN_FLAGS_SET(tcphdr, TCP_HLEN/4, TCP_RST | TCP_ACK);
1210 tcphdr->wnd = PP_HTONS(TCP_WND);
1214 #if CHECKSUM_GEN_TCP
1215 tcphdr->chksum = inet_chksum_pseudo(p, local_ip, remote_ip,
1216 IP_PROTO_TCP, p->tot_len);
1218 TCP_STATS_INC(tcp.xmit);
1219 snmp_inc_tcpoutrsts();
1220 /* Send output with hardcoded TTL since we have no access to the pcb */
1221 ip_output(p, local_ip, remote_ip, TCP_TTL, 0, IP_PROTO_TCP);
1223 LWIP_DEBUGF(TCP_RST_DEBUG, ("tcp_rst: seqno %"U32_F" ackno %"U32_F".\n", seqno, ackno));
1227 * Requeue all unacked segments for retransmission
1229 * Called by tcp_slowtmr() for slow retransmission.
1231 * @param pcb the tcp_pcb for which to re-enqueue all unacked segments
1234 tcp_rexmit_rto(struct tcp_pcb *pcb)
1236 struct tcp_seg *seg;
1238 if (pcb->unacked == NULL) {
1242 /* Move all unacked segments to the head of the unsent queue */
1243 for (seg = pcb->unacked; seg->next != NULL; seg = seg->next);
1244 /* concatenate unsent queue after unacked queue */
1245 seg->next = pcb->unsent;
1246 /* unsent queue is the concatenated queue (of unacked, unsent) */
1247 pcb->unsent = pcb->unacked;
1248 /* unacked queue is now empty */
1249 pcb->unacked = NULL;
1251 /* increment number of retransmissions */
1254 /* Don't take any RTT measurements after retransmitting. */
1257 /* Do the actual retransmission */
1262 * Requeue the first unacked segment for retransmission
1264 * Called by tcp_receive() for fast retramsmit.
1266 * @param pcb the tcp_pcb for which to retransmit the first unacked segment
1269 tcp_rexmit(struct tcp_pcb *pcb)
1271 struct tcp_seg *seg;
1272 struct tcp_seg **cur_seg;
1274 if (pcb->unacked == NULL) {
1278 /* Move the first unacked segment to the unsent queue */
1279 /* Keep the unsent queue sorted. */
1281 pcb->unacked = seg->next;
1283 cur_seg = &(pcb->unsent);
1285 TCP_SEQ_LT(ntohl((*cur_seg)->tcphdr->seqno), ntohl(seg->tcphdr->seqno))) {
1286 cur_seg = &((*cur_seg)->next );
1288 seg->next = *cur_seg;
1293 /* Don't take any rtt measurements after retransmitting. */
1296 /* Do the actual retransmission. */
1297 snmp_inc_tcpretranssegs();
1298 /* No need to call tcp_output: we are always called from tcp_input()
1299 and thus tcp_output directly returns. */
1304 * Handle retransmission after three dupacks received
1306 * @param pcb the tcp_pcb for which to retransmit the first unacked segment
1309 tcp_rexmit_fast(struct tcp_pcb *pcb)
1311 if (pcb->unacked != NULL && !(pcb->flags & TF_INFR)) {
1312 /* This is fast retransmit. Retransmit the first unacked segment. */
1313 LWIP_DEBUGF(TCP_FR_DEBUG,
1314 ("tcp_receive: dupacks %"U16_F" (%"U32_F
1315 "), fast retransmit %"U32_F"\n",
1316 (u16_t)pcb->dupacks, pcb->lastack,
1317 ntohl(pcb->unacked->tcphdr->seqno)));
1320 /* Set ssthresh to half of the minimum of the current
1321 * cwnd and the advertised window */
1322 if (pcb->cwnd > pcb->snd_wnd) {
1323 pcb->ssthresh = pcb->snd_wnd / 2;
1325 pcb->ssthresh = pcb->cwnd / 2;
1328 /* The minimum value for ssthresh should be 2 MSS */
1329 if (pcb->ssthresh < 2*pcb->mss) {
1330 LWIP_DEBUGF(TCP_FR_DEBUG,
1331 ("tcp_receive: The minimum value for ssthresh %"U16_F
1332 " should be min 2 mss %"U16_F"...\n",
1333 pcb->ssthresh, 2*pcb->mss));
1334 pcb->ssthresh = 2*pcb->mss;
1337 pcb->cwnd = pcb->ssthresh + 3 * pcb->mss;
1338 pcb->flags |= TF_INFR;
1344 * Send keepalive packets to keep a connection active although
1345 * no data is sent over it.
1347 * Called by tcp_slowtmr()
1349 * @param pcb the tcp_pcb for which to send a keepalive packet
1352 tcp_keepalive(struct tcp_pcb *pcb)
1355 struct tcp_hdr *tcphdr;
1357 LWIP_DEBUGF(TCP_DEBUG, ("tcp_keepalive: sending KEEPALIVE probe to %"U16_F".%"U16_F".%"U16_F".%"U16_F"\n",
1358 ip4_addr1_16(&pcb->remote_ip), ip4_addr2_16(&pcb->remote_ip),
1359 ip4_addr3_16(&pcb->remote_ip), ip4_addr4_16(&pcb->remote_ip)));
1361 LWIP_DEBUGF(TCP_DEBUG, ("tcp_keepalive: tcp_ticks %"U32_F" pcb->tmr %"U32_F" pcb->keep_cnt_sent %"U16_F"\n",
1362 tcp_ticks, pcb->tmr, pcb->keep_cnt_sent));
1364 p = tcp_output_alloc_header(pcb, 0, 0, htonl(pcb->snd_nxt - 1));
1366 LWIP_DEBUGF(TCP_DEBUG,
1367 ("tcp_keepalive: could not allocate memory for pbuf\n"));
1370 tcphdr = (struct tcp_hdr *)p->payload;
1372 #if CHECKSUM_GEN_TCP
1373 tcphdr->chksum = inet_chksum_pseudo(p, &pcb->local_ip, &pcb->remote_ip,
1374 IP_PROTO_TCP, p->tot_len);
1376 TCP_STATS_INC(tcp.xmit);
1378 /* Send output to IP */
1379 #if LWIP_NETIF_HWADDRHINT
1380 ip_output_hinted(p, &pcb->local_ip, &pcb->remote_ip, pcb->ttl, 0, IP_PROTO_TCP,
1382 #else /* LWIP_NETIF_HWADDRHINT*/
1383 ip_output(p, &pcb->local_ip, &pcb->remote_ip, pcb->ttl, 0, IP_PROTO_TCP);
1384 #endif /* LWIP_NETIF_HWADDRHINT*/
1388 LWIP_DEBUGF(TCP_DEBUG, ("tcp_keepalive: seqno %"U32_F" ackno %"U32_F".\n",
1389 pcb->snd_nxt - 1, pcb->rcv_nxt));
1394 * Send persist timer zero-window probes to keep a connection active
1395 * when a window update is lost.
1397 * Called by tcp_slowtmr()
1399 * @param pcb the tcp_pcb for which to send a zero-window probe packet
1402 tcp_zero_window_probe(struct tcp_pcb *pcb)
1405 struct tcp_hdr *tcphdr;
1406 struct tcp_seg *seg;
1410 LWIP_DEBUGF(TCP_DEBUG,
1411 ("tcp_zero_window_probe: sending ZERO WINDOW probe to %"
1412 U16_F".%"U16_F".%"U16_F".%"U16_F"\n",
1413 ip4_addr1_16(&pcb->remote_ip), ip4_addr2_16(&pcb->remote_ip),
1414 ip4_addr3_16(&pcb->remote_ip), ip4_addr4_16(&pcb->remote_ip)));
1416 LWIP_DEBUGF(TCP_DEBUG,
1417 ("tcp_zero_window_probe: tcp_ticks %"U32_F
1418 " pcb->tmr %"U32_F" pcb->keep_cnt_sent %"U16_F"\n",
1419 tcp_ticks, pcb->tmr, pcb->keep_cnt_sent));
1430 is_fin = ((TCPH_FLAGS(seg->tcphdr) & TCP_FIN) != 0) && (seg->len == 0);
1431 /* we want to send one seqno: either FIN or data (no options) */
1432 len = is_fin ? 0 : 1;
1434 p = tcp_output_alloc_header(pcb, 0, len, seg->tcphdr->seqno);
1436 LWIP_DEBUGF(TCP_DEBUG, ("tcp_zero_window_probe: no memory for pbuf\n"));
1439 tcphdr = (struct tcp_hdr *)p->payload;
1442 /* FIN segment, no data */
1443 TCPH_FLAGS_SET(tcphdr, TCP_ACK | TCP_FIN);
1445 /* Data segment, copy in one byte from the head of the unacked queue */
1446 struct tcp_hdr *thdr = (struct tcp_hdr *)seg->p->payload;
1447 char *d = ((char *)p->payload + TCP_HLEN);
1448 pbuf_copy_partial(seg->p, d, 1, TCPH_HDRLEN(thdr) * 4);
1451 #if CHECKSUM_GEN_TCP
1452 tcphdr->chksum = inet_chksum_pseudo(p, &pcb->local_ip, &pcb->remote_ip,
1453 IP_PROTO_TCP, p->tot_len);
1455 TCP_STATS_INC(tcp.xmit);
1457 /* Send output to IP */
1458 #if LWIP_NETIF_HWADDRHINT
1459 ip_output_hinted(p, &pcb->local_ip, &pcb->remote_ip, pcb->ttl, 0, IP_PROTO_TCP,
1461 #else /* LWIP_NETIF_HWADDRHINT*/
1462 ip_output(p, &pcb->local_ip, &pcb->remote_ip, pcb->ttl, 0, IP_PROTO_TCP);
1463 #endif /* LWIP_NETIF_HWADDRHINT*/
1467 LWIP_DEBUGF(TCP_DEBUG, ("tcp_zero_window_probe: seqno %"U32_F
1468 " ackno %"U32_F".\n",
1469 pcb->snd_nxt - 1, pcb->rcv_nxt));
1471 #endif /* LWIP_TCP */