First run at integrating LWIP into the tree (again)
[akaros.git] / user / lwip / core / tcp_out.c
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.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.h"
53 #include "lwip/inet_chksum.h"
54 #include "lwip/stats.h"
55 #include "lwip/snmp.h"
56
57 #include <string.h>
58
59 /* Forward declarations.*/
60 static void tcp_output_segment(struct tcp_seg *seg, struct tcp_pcb *pcb);
61
62 static struct tcp_hdr *
63 tcp_output_set_header(struct tcp_pcb *pcb, struct pbuf *p, int optlen,
64                       u32_t seqno_be /* already in network byte order */)
65 {
66   struct tcp_hdr *tcphdr = p->payload;
67   tcphdr->src = htons(pcb->local_port);
68   tcphdr->dest = htons(pcb->remote_port);
69   tcphdr->seqno = seqno_be;
70   tcphdr->ackno = htonl(pcb->rcv_nxt);
71   TCPH_FLAGS_SET(tcphdr, TCP_ACK);
72   tcphdr->wnd = htons(pcb->rcv_ann_wnd);
73   tcphdr->urgp = 0;
74   TCPH_HDRLEN_SET(tcphdr, (5 + optlen / 4));
75   tcphdr->chksum = 0;
76
77   /* If we're sending a packet, update the announced right window edge */
78   pcb->rcv_ann_right_edge = pcb->rcv_nxt + pcb->rcv_ann_wnd;
79
80   return tcphdr;
81 }
82
83 /**
84  * Called by tcp_close() to send a segment including flags but not data.
85  *
86  * @param pcb the tcp_pcb over which to send a segment
87  * @param flags the flags to set in the segment header
88  * @return ERR_OK if sent, another err_t otherwise
89  */
90 err_t
91 tcp_send_ctrl(struct tcp_pcb *pcb, u8_t flags)
92 {
93   /* no data, no length, flags, copy=1, no optdata */
94   return tcp_enqueue(pcb, NULL, 0, flags, TCP_WRITE_FLAG_COPY, 0);
95 }
96
97 /**
98  * Write data for sending (but does not send it immediately).
99  *
100  * It waits in the expectation of more data being sent soon (as
101  * it can send them more efficiently by combining them together).
102  * To prompt the system to send data now, call tcp_output() after
103  * calling tcp_write().
104  * 
105  * @param pcb Protocol control block of the TCP connection to enqueue data for.
106  * @param data pointer to the data to send
107  * @param len length (in bytes) of the data to send
108  * @param apiflags combination of following flags :
109  * - TCP_WRITE_FLAG_COPY (0x01) data will be copied into memory belonging to the stack
110  * - TCP_WRITE_FLAG_MORE (0x02) for TCP connection, PSH flag will be set on last segment sent,
111  * @return ERR_OK if enqueued, another err_t on error
112  * 
113  * @see tcp_write()
114  */
115 err_t
116 tcp_write(struct tcp_pcb *pcb, const void *data, u16_t len, u8_t apiflags)
117 {
118   LWIP_DEBUGF(TCP_OUTPUT_DEBUG, ("tcp_write(pcb=%p, data=%p, len=%"U16_F", apiflags=%"U16_F")\n", (void *)pcb,
119     data, len, (u16_t)apiflags));
120   /* connection is in valid state for data transmission? */
121   if (pcb->state == ESTABLISHED ||
122      pcb->state == CLOSE_WAIT ||
123      pcb->state == SYN_SENT ||
124      pcb->state == SYN_RCVD) {
125     if (len > 0) {
126 #if LWIP_TCP_TIMESTAMPS
127       return tcp_enqueue(pcb, (void *)data, len, 0, apiflags, 
128                          pcb->flags & TF_TIMESTAMP ? TF_SEG_OPTS_TS : 0);
129 #else
130       return tcp_enqueue(pcb, (void *)data, len, 0, apiflags, 0);
131 #endif
132     }
133     return ERR_OK;
134   } else {
135     LWIP_DEBUGF(TCP_OUTPUT_DEBUG | LWIP_DBG_STATE | LWIP_DBG_LEVEL_SEVERE, ("tcp_write() called in invalid state\n"));
136     return ERR_CONN;
137   }
138 }
139
140 /**
141  * Enqueue data and/or TCP options for transmission
142  *
143  * Called by tcp_connect(), tcp_listen_input(), tcp_send_ctrl() and tcp_write().
144  *
145  * @param pcb Protocol control block for the TCP connection to enqueue data for.
146  * @param arg Pointer to the data to be enqueued for sending.
147  * @param len Data length in bytes
148  * @param flags tcp header flags to set in the outgoing segment
149  * @param apiflags combination of following flags :
150  * - TCP_WRITE_FLAG_COPY (0x01) data will be copied into memory belonging to the stack
151  * - TCP_WRITE_FLAG_MORE (0x02) for TCP connection, PSH flag will be set on last segment sent,
152  * @param optflags options to include in segment later on (see definition of struct tcp_seg)
153  */
154 err_t
155 tcp_enqueue(struct tcp_pcb *pcb, void *arg, u16_t len,
156             u8_t flags, u8_t apiflags, u8_t optflags)
157 {
158   struct pbuf *p;
159   struct tcp_seg *seg, *useg, *queue;
160   u32_t seqno;
161   u16_t left, seglen;
162   void *ptr;
163   u16_t queuelen;
164   u8_t optlen;
165
166   LWIP_DEBUGF(TCP_OUTPUT_DEBUG, 
167               ("tcp_enqueue(pcb=%p, arg=%p, len=%"U16_F", flags=%"X16_F", apiflags=%"U16_F")\n",
168                (void *)pcb, arg, len, (u16_t)flags, (u16_t)apiflags));
169   LWIP_ERROR("tcp_enqueue: packet needs payload, options, or SYN/FIN (programmer violates API)",
170              ((len != 0) || (optflags != 0) || ((flags & (TCP_SYN | TCP_FIN)) != 0)),
171              return ERR_ARG;);
172   LWIP_ERROR("tcp_enqueue: len != 0 || arg == NULL (programmer violates API)", 
173              ((len != 0) || (arg == NULL)), return ERR_ARG;);
174
175   /* fail on too much data */
176   if (len > pcb->snd_buf) {
177     LWIP_DEBUGF(TCP_OUTPUT_DEBUG | LWIP_DBG_LEVEL_WARNING,
178       ("tcp_enqueue: too much data (len=%"U16_F" > snd_buf=%"U16_F")\n", len, pcb->snd_buf));
179     pcb->flags |= TF_NAGLEMEMERR;
180     return ERR_MEM;
181   }
182   left = len;
183   ptr = arg;
184
185   optlen = LWIP_TCP_OPT_LENGTH(optflags);
186
187   /* seqno will be the sequence number of the first segment enqueued
188    * by the call to this function. */
189   seqno = pcb->snd_lbb;
190
191   LWIP_DEBUGF(TCP_QLEN_DEBUG, ("tcp_enqueue: queuelen: %"U16_F"\n", (u16_t)pcb->snd_queuelen));
192
193   /* If total number of pbufs on the unsent/unacked queues exceeds the
194    * configured maximum, return an error */
195   queuelen = pcb->snd_queuelen;
196   /* check for configured max queuelen and possible overflow */
197   if ((queuelen >= TCP_SND_QUEUELEN) || (queuelen > TCP_SNDQUEUELEN_OVERFLOW)) {
198     LWIP_DEBUGF(TCP_OUTPUT_DEBUG | LWIP_DBG_LEVEL_WARNING,
199       ("tcp_enqueue: too long queue %"U16_F" (max %"U16_F")\n", queuelen, TCP_SND_QUEUELEN));
200     TCP_STATS_INC(tcp.memerr);
201     pcb->flags |= TF_NAGLEMEMERR;
202     return ERR_MEM;
203   }
204   if (queuelen != 0) {
205     LWIP_ASSERT("tcp_enqueue: pbufs on queue => at least one queue non-empty",
206       pcb->unacked != NULL || pcb->unsent != NULL);
207   } else {
208     LWIP_ASSERT("tcp_enqueue: no pbufs on queue => both queues empty",
209       pcb->unacked == NULL && pcb->unsent == NULL);
210   }
211
212   /* First, break up the data into segments and tuck them together in
213    * the local "queue" variable. */
214   useg = queue = seg = NULL;
215   seglen = 0;
216   while (queue == NULL || left > 0) {
217     /* The segment length (including options) should be at most the MSS */
218     seglen = left > (pcb->mss - optlen) ? (pcb->mss - optlen) : left;
219
220     /* Allocate memory for tcp_seg, and fill in fields. */
221     seg = memp_malloc(MEMP_TCP_SEG);
222     if (seg == NULL) {
223       LWIP_DEBUGF(TCP_OUTPUT_DEBUG | LWIP_DBG_LEVEL_SERIOUS, 
224                   ("tcp_enqueue: could not allocate memory for tcp_seg\n"));
225       goto memerr;
226     }
227     seg->next = NULL;
228     seg->p = NULL;
229
230     /* first segment of to-be-queued data? */
231     if (queue == NULL) {
232       queue = seg;
233     }
234     /* subsequent segments of to-be-queued data */
235     else {
236       /* Attach the segment to the end of the queued segments */
237       LWIP_ASSERT("useg != NULL", useg != NULL);
238       useg->next = seg;
239     }
240     /* remember last segment of to-be-queued data for next iteration */
241     useg = seg;
242
243     /* If copy is set, memory should be allocated
244      * and data copied into pbuf, otherwise data comes from
245      * ROM or other static memory, and need not be copied.  */
246     if (apiflags & TCP_WRITE_FLAG_COPY) {
247       if ((seg->p = pbuf_alloc(PBUF_TRANSPORT, seglen + optlen, PBUF_RAM)) == NULL) {
248         LWIP_DEBUGF(TCP_OUTPUT_DEBUG | LWIP_DBG_LEVEL_SERIOUS, 
249                     ("tcp_enqueue : could not allocate memory for pbuf copy size %"U16_F"\n", seglen));
250         goto memerr;
251       }
252       LWIP_ASSERT("check that first pbuf can hold the complete seglen",
253                   (seg->p->len >= seglen + optlen));
254       queuelen += pbuf_clen(seg->p);
255       if (arg != NULL) {
256         MEMCPY((char *)seg->p->payload + optlen, ptr, seglen);
257       }
258       seg->dataptr = seg->p->payload;
259     }
260     /* do not copy data */
261     else {
262       /* First, allocate a pbuf for the headers. */
263       if ((seg->p = pbuf_alloc(PBUF_TRANSPORT, optlen, PBUF_RAM)) == NULL) {
264         LWIP_DEBUGF(TCP_OUTPUT_DEBUG | LWIP_DBG_LEVEL_SERIOUS, 
265                     ("tcp_enqueue: could not allocate memory for header pbuf\n"));
266         goto memerr;
267       }
268       queuelen += pbuf_clen(seg->p);
269
270       /* Second, allocate a pbuf for holding the data.
271        * since the referenced data is available at least until it is sent out on the
272        * link (as it has to be ACKed by the remote party) we can safely use PBUF_ROM
273        * instead of PBUF_REF here.
274        */
275       if (left > 0) {
276         if ((p = pbuf_alloc(PBUF_RAW, seglen, PBUF_ROM)) == NULL) {
277           /* If allocation fails, we have to deallocate the header pbuf as well. */
278           pbuf_free(seg->p);
279           seg->p = NULL;
280           LWIP_DEBUGF(TCP_OUTPUT_DEBUG | LWIP_DBG_LEVEL_SERIOUS, 
281                       ("tcp_enqueue: could not allocate memory for zero-copy pbuf\n"));
282           goto memerr;
283         }
284         ++queuelen;
285         /* reference the non-volatile payload data */
286         p->payload = ptr;
287         seg->dataptr = ptr;
288
289         /* Concatenate the headers and data pbufs together. */
290         pbuf_cat(seg->p/*header*/, p/*data*/);
291         p = NULL;
292       }
293     }
294
295     /* Now that there are more segments queued, we check again if the
296     length of the queue exceeds the configured maximum or overflows. */
297     if ((queuelen > TCP_SND_QUEUELEN) || (queuelen > TCP_SNDQUEUELEN_OVERFLOW)) {
298       LWIP_DEBUGF(TCP_OUTPUT_DEBUG | LWIP_DBG_LEVEL_SERIOUS,
299         ("tcp_enqueue: queue too long %"U16_F" (%"U16_F")\n", queuelen, TCP_SND_QUEUELEN));
300       goto memerr;
301     }
302
303     seg->len = seglen;
304
305     /* build TCP header */
306     if (pbuf_header(seg->p, TCP_HLEN)) {
307       LWIP_DEBUGF(TCP_OUTPUT_DEBUG | LWIP_DBG_LEVEL_SERIOUS, ("tcp_enqueue: no room for TCP header in pbuf.\n"));
308       TCP_STATS_INC(tcp.err);
309       goto memerr;
310     }
311     seg->tcphdr = seg->p->payload;
312     seg->tcphdr->src = htons(pcb->local_port);
313     seg->tcphdr->dest = htons(pcb->remote_port);
314     seg->tcphdr->seqno = htonl(seqno);
315     seg->tcphdr->urgp = 0;
316     TCPH_FLAGS_SET(seg->tcphdr, flags);
317     /* don't fill in tcphdr->ackno and tcphdr->wnd until later */
318
319     seg->flags = optflags;
320
321     /* Set the length of the header */
322     TCPH_HDRLEN_SET(seg->tcphdr, (5 + optlen / 4));
323     LWIP_DEBUGF(TCP_OUTPUT_DEBUG | LWIP_DBG_TRACE, ("tcp_enqueue: queueing %"U32_F":%"U32_F" (0x%"X16_F")\n",
324       ntohl(seg->tcphdr->seqno),
325       ntohl(seg->tcphdr->seqno) + TCP_TCPLEN(seg),
326       (u16_t)flags));
327
328     left -= seglen;
329     seqno += seglen;
330     ptr = (void *)((u8_t *)ptr + seglen);
331   }
332
333   /* Now that the data to be enqueued has been broken up into TCP
334   segments in the queue variable, we add them to the end of the
335   pcb->unsent queue. */
336   if (pcb->unsent == NULL) {
337     useg = NULL;
338   }
339   else {
340     for (useg = pcb->unsent; useg->next != NULL; useg = useg->next);
341   }
342   /* { useg is last segment on the unsent queue, NULL if list is empty } */
343
344   /* If there is room in the last pbuf on the unsent queue,
345   chain the first pbuf on the queue together with that. */
346   if (useg != NULL &&
347     TCP_TCPLEN(useg) != 0 &&
348     !(TCPH_FLAGS(useg->tcphdr) & (TCP_SYN | TCP_FIN)) &&
349     (!(flags & (TCP_SYN | TCP_FIN)) || (flags == TCP_FIN)) &&
350     /* fit within max seg size */
351     (useg->len + queue->len <= pcb->mss) &&
352     /* only concatenate segments with the same options */
353     (useg->flags == queue->flags) &&
354     /* segments are consecutive */
355     (ntohl(useg->tcphdr->seqno) + useg->len == ntohl(queue->tcphdr->seqno)) ) {
356     /* Remove TCP header from first segment of our to-be-queued list */
357     if(pbuf_header(queue->p, -(TCP_HLEN + optlen))) {
358       /* Can we cope with this failing?  Just assert for now */
359       LWIP_ASSERT("pbuf_header failed\n", 0);
360       TCP_STATS_INC(tcp.err);
361       goto memerr;
362     }
363     if (queue->p->len == 0) {
364       /* free the first (header-only) pbuf if it is now empty (contained only headers) */
365       struct pbuf *old_q = queue->p;
366       queue->p = queue->p->next;
367       old_q->next = NULL;
368       queuelen--;
369       pbuf_free(old_q);
370     }
371     if (flags & TCP_FIN) {
372       /* the new segment contains only FIN, no data -> put the FIN into the last segment */
373       LWIP_ASSERT("FIN enqueued together with data", queue->p == NULL && queue->len == 0);
374       TCPH_SET_FLAG(useg->tcphdr, TCP_FIN);
375     } else {
376       LWIP_ASSERT("zero-length pbuf", (queue->p != NULL) && (queue->p->len > 0));
377       pbuf_cat(useg->p, queue->p);
378       useg->len += queue->len;
379       useg->next = queue->next;
380     }
381
382     LWIP_DEBUGF(TCP_OUTPUT_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("tcp_enqueue: chaining segments, new len %"U16_F"\n", useg->len));
383     if (seg == queue) {
384       seg = useg;
385       seglen = useg->len;
386     }
387     memp_free(MEMP_TCP_SEG, queue);
388   }
389   else {
390     /* empty list */
391     if (useg == NULL) {
392       /* initialize list with this segment */
393       pcb->unsent = queue;
394     }
395     /* enqueue segment */
396     else {
397       useg->next = queue;
398     }
399   }
400   if ((flags & TCP_SYN) || (flags & TCP_FIN)) {
401     ++len;
402   }
403   if (flags & TCP_FIN) {
404     pcb->flags |= TF_FIN;
405   }
406   pcb->snd_lbb += len;
407
408   pcb->snd_buf -= len;
409
410   /* update number of segments on the queues */
411   pcb->snd_queuelen = queuelen;
412   LWIP_DEBUGF(TCP_QLEN_DEBUG, ("tcp_enqueue: %"S16_F" (after enqueued)\n", pcb->snd_queuelen));
413   if (pcb->snd_queuelen != 0) {
414     LWIP_ASSERT("tcp_enqueue: valid queue length",
415       pcb->unacked != NULL || pcb->unsent != NULL);
416   }
417
418   /* Set the PSH flag in the last segment that we enqueued, but only
419   if the segment has data (indicated by seglen > 0). */
420   if (seg != NULL && seglen > 0 && seg->tcphdr != NULL && ((apiflags & TCP_WRITE_FLAG_MORE)==0)) {
421     TCPH_SET_FLAG(seg->tcphdr, TCP_PSH);
422   }
423
424   return ERR_OK;
425 memerr:
426   pcb->flags |= TF_NAGLEMEMERR;
427   TCP_STATS_INC(tcp.memerr);
428
429   if (queue != NULL) {
430     tcp_segs_free(queue);
431   }
432   if (pcb->snd_queuelen != 0) {
433     LWIP_ASSERT("tcp_enqueue: valid queue length", pcb->unacked != NULL ||
434       pcb->unsent != NULL);
435   }
436   LWIP_DEBUGF(TCP_QLEN_DEBUG | LWIP_DBG_STATE, ("tcp_enqueue: %"S16_F" (with mem err)\n", pcb->snd_queuelen));
437   return ERR_MEM;
438 }
439
440
441 #if LWIP_TCP_TIMESTAMPS
442 /* Build a timestamp option (12 bytes long) at the specified options pointer)
443  *
444  * @param pcb tcp_pcb
445  * @param opts option pointer where to store the timestamp option
446  */
447 static void
448 tcp_build_timestamp_option(struct tcp_pcb *pcb, u32_t *opts)
449 {
450   /* Pad with two NOP options to make everything nicely aligned */
451   opts[0] = htonl(0x0101080A);
452   opts[1] = htonl(sys_now());
453   opts[2] = htonl(pcb->ts_recent);
454 }
455 #endif
456
457 /** Send an ACK without data.
458  *
459  * @param pcb Protocol control block for the TCP connection to send the ACK
460  */
461 err_t
462 tcp_send_empty_ack(struct tcp_pcb *pcb)
463 {
464   struct pbuf *p;
465   struct tcp_hdr *tcphdr;
466   u8_t optlen = 0;
467
468 #if LWIP_TCP_TIMESTAMPS
469   if (pcb->flags & TF_TIMESTAMP) {
470     optlen = LWIP_TCP_OPT_LENGTH(TF_SEG_OPTS_TS);
471   }
472 #endif
473   p = pbuf_alloc(PBUF_IP, TCP_HLEN + optlen, PBUF_RAM);
474   if (p == NULL) {
475     LWIP_DEBUGF(TCP_OUTPUT_DEBUG, ("tcp_output: (ACK) could not allocate pbuf\n"));
476     return ERR_BUF;
477   }
478   LWIP_DEBUGF(TCP_OUTPUT_DEBUG, 
479               ("tcp_output: sending ACK for %"U32_F"\n", pcb->rcv_nxt));
480   /* remove ACK flags from the PCB, as we send an empty ACK now */
481   pcb->flags &= ~(TF_ACK_DELAY | TF_ACK_NOW);
482
483   tcphdr = tcp_output_set_header(pcb, p, optlen, htonl(pcb->snd_nxt));
484
485   /* NB. MSS option is only sent on SYNs, so ignore it here */
486 #if LWIP_TCP_TIMESTAMPS
487   pcb->ts_lastacksent = pcb->rcv_nxt;
488
489   if (pcb->flags & TF_TIMESTAMP) {
490     tcp_build_timestamp_option(pcb, (u32_t *)(tcphdr + 1));
491   }
492 #endif 
493
494 #if CHECKSUM_GEN_TCP
495   tcphdr->chksum = inet_chksum_pseudo(p, &(pcb->local_ip), &(pcb->remote_ip),
496         IP_PROTO_TCP, p->tot_len);
497 #endif
498 #if LWIP_NETIF_HWADDRHINT
499   ip_output_hinted(p, &(pcb->local_ip), &(pcb->remote_ip), pcb->ttl, pcb->tos,
500       IP_PROTO_TCP, &(pcb->addr_hint));
501 #else /* LWIP_NETIF_HWADDRHINT*/
502   ip_output(p, &(pcb->local_ip), &(pcb->remote_ip), pcb->ttl, pcb->tos,
503       IP_PROTO_TCP);
504 #endif /* LWIP_NETIF_HWADDRHINT*/
505   pbuf_free(p);
506
507   return ERR_OK;
508 }
509
510 /**
511  * Find out what we can send and send it
512  *
513  * @param pcb Protocol control block for the TCP connection to send data
514  * @return ERR_OK if data has been sent or nothing to send
515  *         another err_t on error
516  */
517 err_t
518 tcp_output(struct tcp_pcb *pcb)
519 {
520   struct tcp_seg *seg, *useg;
521   u32_t wnd, snd_nxt;
522 #if TCP_CWND_DEBUG
523   s16_t i = 0;
524 #endif /* TCP_CWND_DEBUG */
525
526   /* First, check if we are invoked by the TCP input processing
527      code. If so, we do not output anything. Instead, we rely on the
528      input processing code to call us when input processing is done
529      with. */
530   if (tcp_input_pcb == pcb) {
531     return ERR_OK;
532   }
533
534   wnd = LWIP_MIN(pcb->snd_wnd, pcb->cwnd);
535
536   seg = pcb->unsent;
537
538   /* If the TF_ACK_NOW flag is set and no data will be sent (either
539    * because the ->unsent queue is empty or because the window does
540    * not allow it), construct an empty ACK segment and send it.
541    *
542    * If data is to be sent, we will just piggyback the ACK (see below).
543    */
544   if (pcb->flags & TF_ACK_NOW &&
545      (seg == NULL ||
546       ntohl(seg->tcphdr->seqno) - pcb->lastack + seg->len > wnd)) {
547      return tcp_send_empty_ack(pcb);
548   }
549
550   /* useg should point to last segment on unacked queue */
551   useg = pcb->unacked;
552   if (useg != NULL) {
553     for (; useg->next != NULL; useg = useg->next);
554   }
555
556 #if TCP_OUTPUT_DEBUG
557   if (seg == NULL) {
558     LWIP_DEBUGF(TCP_OUTPUT_DEBUG, ("tcp_output: nothing to send (%p)\n",
559                                    (void*)pcb->unsent));
560   }
561 #endif /* TCP_OUTPUT_DEBUG */
562 #if TCP_CWND_DEBUG
563   if (seg == NULL) {
564     LWIP_DEBUGF(TCP_CWND_DEBUG, ("tcp_output: snd_wnd %"U16_F
565                                  ", cwnd %"U16_F", wnd %"U32_F
566                                  ", seg == NULL, ack %"U32_F"\n",
567                                  pcb->snd_wnd, pcb->cwnd, wnd, pcb->lastack));
568   } else {
569     LWIP_DEBUGF(TCP_CWND_DEBUG, 
570                 ("tcp_output: snd_wnd %"U16_F", cwnd %"U16_F", wnd %"U32_F
571                  ", effwnd %"U32_F", seq %"U32_F", ack %"U32_F"\n",
572                  pcb->snd_wnd, pcb->cwnd, wnd,
573                  ntohl(seg->tcphdr->seqno) - pcb->lastack + seg->len,
574                  ntohl(seg->tcphdr->seqno), pcb->lastack));
575   }
576 #endif /* TCP_CWND_DEBUG */
577   /* data available and window allows it to be sent? */
578   while (seg != NULL &&
579          ntohl(seg->tcphdr->seqno) - pcb->lastack + seg->len <= wnd) {
580     LWIP_ASSERT("RST not expected here!", 
581                 (TCPH_FLAGS(seg->tcphdr) & TCP_RST) == 0);
582     /* Stop sending if the nagle algorithm would prevent it
583      * Don't stop:
584      * - if tcp_enqueue had a memory error before (prevent delayed ACK timeout) or
585      * - if FIN was already enqueued for this PCB (SYN is always alone in a segment -
586      *   either seg->next != NULL or pcb->unacked == NULL;
587      *   RST is no sent using tcp_enqueue/tcp_output.
588      */
589     if((tcp_do_output_nagle(pcb) == 0) &&
590       ((pcb->flags & (TF_NAGLEMEMERR | TF_FIN)) == 0)){
591       break;
592     }
593 #if TCP_CWND_DEBUG
594     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",
595                             pcb->snd_wnd, pcb->cwnd, wnd,
596                             ntohl(seg->tcphdr->seqno) + seg->len -
597                             pcb->lastack,
598                             ntohl(seg->tcphdr->seqno), pcb->lastack, i));
599     ++i;
600 #endif /* TCP_CWND_DEBUG */
601
602     pcb->unsent = seg->next;
603
604     if (pcb->state != SYN_SENT) {
605       TCPH_SET_FLAG(seg->tcphdr, TCP_ACK);
606       pcb->flags &= ~(TF_ACK_DELAY | TF_ACK_NOW);
607     }
608
609     tcp_output_segment(seg, pcb);
610     snd_nxt = ntohl(seg->tcphdr->seqno) + TCP_TCPLEN(seg);
611     if (TCP_SEQ_LT(pcb->snd_nxt, snd_nxt)) {
612       pcb->snd_nxt = snd_nxt;
613     }
614     /* put segment on unacknowledged list if length > 0 */
615     if (TCP_TCPLEN(seg) > 0) {
616       seg->next = NULL;
617       /* unacked list is empty? */
618       if (pcb->unacked == NULL) {
619         pcb->unacked = seg;
620         useg = seg;
621       /* unacked list is not empty? */
622       } else {
623         /* In the case of fast retransmit, the packet should not go to the tail
624          * of the unacked queue, but rather somewhere before it. We need to check for
625          * this case. -STJ Jul 27, 2004 */
626         if (TCP_SEQ_LT(ntohl(seg->tcphdr->seqno), ntohl(useg->tcphdr->seqno))){
627           /* add segment to before tail of unacked list, keeping the list sorted */
628           struct tcp_seg **cur_seg = &(pcb->unacked);
629           while (*cur_seg &&
630             TCP_SEQ_LT(ntohl((*cur_seg)->tcphdr->seqno), ntohl(seg->tcphdr->seqno))) {
631               cur_seg = &((*cur_seg)->next );
632           }
633           seg->next = (*cur_seg);
634           (*cur_seg) = seg;
635         } else {
636           /* add segment to tail of unacked list */
637           useg->next = seg;
638           useg = useg->next;
639         }
640       }
641     /* do not queue empty segments on the unacked list */
642     } else {
643       tcp_seg_free(seg);
644     }
645     seg = pcb->unsent;
646   }
647
648   if (seg != NULL && pcb->persist_backoff == 0 && 
649       ntohl(seg->tcphdr->seqno) - pcb->lastack + seg->len > pcb->snd_wnd) {
650     /* prepare for persist timer */
651     pcb->persist_cnt = 0;
652     pcb->persist_backoff = 1;
653   }
654
655   pcb->flags &= ~TF_NAGLEMEMERR;
656   return ERR_OK;
657 }
658
659 /**
660  * Called by tcp_output() to actually send a TCP segment over IP.
661  *
662  * @param seg the tcp_seg to send
663  * @param pcb the tcp_pcb for the TCP connection used to send the segment
664  */
665 static void
666 tcp_output_segment(struct tcp_seg *seg, struct tcp_pcb *pcb)
667 {
668   u16_t len;
669   struct netif *netif;
670   u32_t *opts;
671
672   /** @bug Exclude retransmitted segments from this count. */
673   snmp_inc_tcpoutsegs();
674
675   /* The TCP header has already been constructed, but the ackno and
676    wnd fields remain. */
677   seg->tcphdr->ackno = htonl(pcb->rcv_nxt);
678
679   /* advertise our receive window size in this TCP segment */
680   seg->tcphdr->wnd = htons(pcb->rcv_ann_wnd);
681
682   pcb->rcv_ann_right_edge = pcb->rcv_nxt + pcb->rcv_ann_wnd;
683
684   /* Add any requested options.  NB MSS option is only set on SYN
685      packets, so ignore it here */
686   opts = (u32_t *)(seg->tcphdr + 1);
687   if (seg->flags & TF_SEG_OPTS_MSS) {
688     TCP_BUILD_MSS_OPTION(*opts);
689     opts += 1;
690   }
691 #if LWIP_TCP_TIMESTAMPS
692   pcb->ts_lastacksent = pcb->rcv_nxt;
693
694   if (seg->flags & TF_SEG_OPTS_TS) {
695     tcp_build_timestamp_option(pcb, opts);
696     opts += 3;
697   }
698 #endif
699
700   /* If we don't have a local IP address, we get one by
701      calling ip_route(). */
702   if (ip_addr_isany(&(pcb->local_ip))) {
703     netif = ip_route(&(pcb->remote_ip));
704     if (netif == NULL) {
705       return;
706     }
707     ip_addr_set(&(pcb->local_ip), &(netif->ip_addr));
708   }
709
710   /* Set retransmission timer running if it is not currently enabled */
711   if(pcb->rtime == -1)
712     pcb->rtime = 0;
713
714   if (pcb->rttest == 0) {
715     pcb->rttest = tcp_ticks;
716     pcb->rtseq = ntohl(seg->tcphdr->seqno);
717
718     LWIP_DEBUGF(TCP_RTO_DEBUG, ("tcp_output_segment: rtseq %"U32_F"\n", pcb->rtseq));
719   }
720   LWIP_DEBUGF(TCP_OUTPUT_DEBUG, ("tcp_output_segment: %"U32_F":%"U32_F"\n",
721           htonl(seg->tcphdr->seqno), htonl(seg->tcphdr->seqno) +
722           seg->len));
723
724   len = (u16_t)((u8_t *)seg->tcphdr - (u8_t *)seg->p->payload);
725
726   seg->p->len -= len;
727   seg->p->tot_len -= len;
728
729   seg->p->payload = seg->tcphdr;
730
731   seg->tcphdr->chksum = 0;
732 #if CHECKSUM_GEN_TCP
733   seg->tcphdr->chksum = inet_chksum_pseudo(seg->p,
734              &(pcb->local_ip),
735              &(pcb->remote_ip),
736              IP_PROTO_TCP, seg->p->tot_len);
737 #endif
738   TCP_STATS_INC(tcp.xmit);
739
740 #if LWIP_NETIF_HWADDRHINT
741   ip_output_hinted(seg->p, &(pcb->local_ip), &(pcb->remote_ip), pcb->ttl, pcb->tos,
742       IP_PROTO_TCP, &(pcb->addr_hint));
743 #else /* LWIP_NETIF_HWADDRHINT*/
744   ip_output(seg->p, &(pcb->local_ip), &(pcb->remote_ip), pcb->ttl, pcb->tos,
745       IP_PROTO_TCP);
746 #endif /* LWIP_NETIF_HWADDRHINT*/
747 }
748
749 /**
750  * Send a TCP RESET packet (empty segment with RST flag set) either to
751  * abort a connection or to show that there is no matching local connection
752  * for a received segment.
753  *
754  * Called by tcp_abort() (to abort a local connection), tcp_input() (if no
755  * matching local pcb was found), tcp_listen_input() (if incoming segment
756  * has ACK flag set) and tcp_process() (received segment in the wrong state)
757  *
758  * Since a RST segment is in most cases not sent for an active connection,
759  * tcp_rst() has a number of arguments that are taken from a tcp_pcb for
760  * most other segment output functions.
761  *
762  * @param seqno the sequence number to use for the outgoing segment
763  * @param ackno the acknowledge number to use for the outgoing segment
764  * @param local_ip the local IP address to send the segment from
765  * @param remote_ip the remote IP address to send the segment to
766  * @param local_port the local TCP port to send the segment from
767  * @param remote_port the remote TCP port to send the segment to
768  */
769 void
770 tcp_rst(u32_t seqno, u32_t ackno,
771   struct ip_addr *local_ip, struct ip_addr *remote_ip,
772   u16_t local_port, u16_t remote_port)
773 {
774   struct pbuf *p;
775   struct tcp_hdr *tcphdr;
776   p = pbuf_alloc(PBUF_IP, TCP_HLEN, PBUF_RAM);
777   if (p == NULL) {
778       LWIP_DEBUGF(TCP_DEBUG, ("tcp_rst: could not allocate memory for pbuf\n"));
779       return;
780   }
781   LWIP_ASSERT("check that first pbuf can hold struct tcp_hdr",
782               (p->len >= sizeof(struct tcp_hdr)));
783
784   tcphdr = p->payload;
785   tcphdr->src = htons(local_port);
786   tcphdr->dest = htons(remote_port);
787   tcphdr->seqno = htonl(seqno);
788   tcphdr->ackno = htonl(ackno);
789   TCPH_FLAGS_SET(tcphdr, TCP_RST | TCP_ACK);
790   tcphdr->wnd = htons(TCP_WND);
791   tcphdr->urgp = 0;
792   TCPH_HDRLEN_SET(tcphdr, 5);
793
794   tcphdr->chksum = 0;
795 #if CHECKSUM_GEN_TCP
796   tcphdr->chksum = inet_chksum_pseudo(p, local_ip, remote_ip,
797               IP_PROTO_TCP, p->tot_len);
798 #endif
799   TCP_STATS_INC(tcp.xmit);
800   snmp_inc_tcpoutrsts();
801    /* Send output with hardcoded TTL since we have no access to the pcb */
802   ip_output(p, local_ip, remote_ip, TCP_TTL, 0, IP_PROTO_TCP);
803   pbuf_free(p);
804   LWIP_DEBUGF(TCP_RST_DEBUG, ("tcp_rst: seqno %"U32_F" ackno %"U32_F".\n", seqno, ackno));
805 }
806
807 /**
808  * Requeue all unacked segments for retransmission
809  *
810  * Called by tcp_slowtmr() for slow retransmission.
811  *
812  * @param pcb the tcp_pcb for which to re-enqueue all unacked segments
813  */
814 void
815 tcp_rexmit_rto(struct tcp_pcb *pcb)
816 {
817   struct tcp_seg *seg;
818
819   if (pcb->unacked == NULL) {
820     return;
821   }
822
823   /* Move all unacked segments to the head of the unsent queue */
824   for (seg = pcb->unacked; seg->next != NULL; seg = seg->next);
825   /* concatenate unsent queue after unacked queue */
826   seg->next = pcb->unsent;
827   /* unsent queue is the concatenated queue (of unacked, unsent) */
828   pcb->unsent = pcb->unacked;
829   /* unacked queue is now empty */
830   pcb->unacked = NULL;
831
832   /* increment number of retransmissions */
833   ++pcb->nrtx;
834
835   /* Don't take any RTT measurements after retransmitting. */
836   pcb->rttest = 0;
837
838   /* Do the actual retransmission */
839   tcp_output(pcb);
840 }
841
842 /**
843  * Requeue the first unacked segment for retransmission
844  *
845  * Called by tcp_receive() for fast retramsmit.
846  *
847  * @param pcb the tcp_pcb for which to retransmit the first unacked segment
848  */
849 void
850 tcp_rexmit(struct tcp_pcb *pcb)
851 {
852   struct tcp_seg *seg;
853   struct tcp_seg **cur_seg;
854
855   if (pcb->unacked == NULL) {
856     return;
857   }
858
859   /* Move the first unacked segment to the unsent queue */
860   /* Keep the unsent queue sorted. */
861   seg = pcb->unacked;
862   pcb->unacked = seg->next;
863
864   cur_seg = &(pcb->unsent);
865   while (*cur_seg &&
866     TCP_SEQ_LT(ntohl((*cur_seg)->tcphdr->seqno), ntohl(seg->tcphdr->seqno))) {
867       cur_seg = &((*cur_seg)->next );
868   }
869   seg->next = *cur_seg;
870   *cur_seg = seg;
871
872   ++pcb->nrtx;
873
874   /* Don't take any rtt measurements after retransmitting. */
875   pcb->rttest = 0;
876
877   /* Do the actual retransmission. */
878   snmp_inc_tcpretranssegs();
879   /* No need to call tcp_output: we are always called from tcp_input()
880      and thus tcp_output directly returns. */
881 }
882
883
884 /**
885  * Handle retransmission after three dupacks received
886  *
887  * @param pcb the tcp_pcb for which to retransmit the first unacked segment
888  */
889 void 
890 tcp_rexmit_fast(struct tcp_pcb *pcb)
891 {
892   if (pcb->unacked != NULL && !(pcb->flags & TF_INFR)) {
893     /* This is fast retransmit. Retransmit the first unacked segment. */
894     LWIP_DEBUGF(TCP_FR_DEBUG, 
895                 ("tcp_receive: dupacks %"U16_F" (%"U32_F
896                  "), fast retransmit %"U32_F"\n",
897                  (u16_t)pcb->dupacks, pcb->lastack,
898                  ntohl(pcb->unacked->tcphdr->seqno)));
899     tcp_rexmit(pcb);
900
901     /* Set ssthresh to half of the minimum of the current
902      * cwnd and the advertised window */
903     if (pcb->cwnd > pcb->snd_wnd)
904       pcb->ssthresh = pcb->snd_wnd / 2;
905     else
906       pcb->ssthresh = pcb->cwnd / 2;
907     
908     /* The minimum value for ssthresh should be 2 MSS */
909     if (pcb->ssthresh < 2*pcb->mss) {
910       LWIP_DEBUGF(TCP_FR_DEBUG, 
911                   ("tcp_receive: The minimum value for ssthresh %"U16_F
912                    " should be min 2 mss %"U16_F"...\n",
913                    pcb->ssthresh, 2*pcb->mss));
914       pcb->ssthresh = 2*pcb->mss;
915     }
916     
917     pcb->cwnd = pcb->ssthresh + 3 * pcb->mss;
918     pcb->flags |= TF_INFR;
919   } 
920 }
921
922
923 /**
924  * Send keepalive packets to keep a connection active although
925  * no data is sent over it.
926  *
927  * Called by tcp_slowtmr()
928  *
929  * @param pcb the tcp_pcb for which to send a keepalive packet
930  */
931 void
932 tcp_keepalive(struct tcp_pcb *pcb)
933 {
934   struct pbuf *p;
935   struct tcp_hdr *tcphdr;
936
937   LWIP_DEBUGF(TCP_DEBUG, ("tcp_keepalive: sending KEEPALIVE probe to %"U16_F".%"U16_F".%"U16_F".%"U16_F"\n",
938                           ip4_addr1(&pcb->remote_ip), ip4_addr2(&pcb->remote_ip),
939                           ip4_addr3(&pcb->remote_ip), ip4_addr4(&pcb->remote_ip)));
940
941   LWIP_DEBUGF(TCP_DEBUG, ("tcp_keepalive: tcp_ticks %"U32_F"   pcb->tmr %"U32_F" pcb->keep_cnt_sent %"U16_F"\n", 
942                           tcp_ticks, pcb->tmr, pcb->keep_cnt_sent));
943    
944   p = pbuf_alloc(PBUF_IP, TCP_HLEN, PBUF_RAM);
945    
946   if(p == NULL) {
947     LWIP_DEBUGF(TCP_DEBUG, 
948                 ("tcp_keepalive: could not allocate memory for pbuf\n"));
949     return;
950   }
951   LWIP_ASSERT("check that first pbuf can hold struct tcp_hdr",
952               (p->len >= sizeof(struct tcp_hdr)));
953
954   tcphdr = tcp_output_set_header(pcb, p, 0, htonl(pcb->snd_nxt - 1));
955
956 #if CHECKSUM_GEN_TCP
957   tcphdr->chksum = inet_chksum_pseudo(p, &pcb->local_ip, &pcb->remote_ip,
958                                       IP_PROTO_TCP, p->tot_len);
959 #endif
960   TCP_STATS_INC(tcp.xmit);
961
962   /* Send output to IP */
963 #if LWIP_NETIF_HWADDRHINT
964   ip_output_hinted(p, &pcb->local_ip, &pcb->remote_ip, pcb->ttl, 0, IP_PROTO_TCP,
965     &(pcb->addr_hint));
966 #else /* LWIP_NETIF_HWADDRHINT*/
967   ip_output(p, &pcb->local_ip, &pcb->remote_ip, pcb->ttl, 0, IP_PROTO_TCP);
968 #endif /* LWIP_NETIF_HWADDRHINT*/
969
970   pbuf_free(p);
971
972   LWIP_DEBUGF(TCP_DEBUG, ("tcp_keepalive: seqno %"U32_F" ackno %"U32_F".\n",
973                           pcb->snd_nxt - 1, pcb->rcv_nxt));
974 }
975
976
977 /**
978  * Send persist timer zero-window probes to keep a connection active
979  * when a window update is lost.
980  *
981  * Called by tcp_slowtmr()
982  *
983  * @param pcb the tcp_pcb for which to send a zero-window probe packet
984  */
985 void
986 tcp_zero_window_probe(struct tcp_pcb *pcb)
987 {
988   struct pbuf *p;
989   struct tcp_hdr *tcphdr;
990   struct tcp_seg *seg;
991   u16_t len;
992   u8_t is_fin;
993
994   LWIP_DEBUGF(TCP_DEBUG, 
995               ("tcp_zero_window_probe: sending ZERO WINDOW probe to %"
996                U16_F".%"U16_F".%"U16_F".%"U16_F"\n",
997                ip4_addr1(&pcb->remote_ip), ip4_addr2(&pcb->remote_ip),
998                ip4_addr3(&pcb->remote_ip), ip4_addr4(&pcb->remote_ip)));
999
1000   LWIP_DEBUGF(TCP_DEBUG, 
1001               ("tcp_zero_window_probe: tcp_ticks %"U32_F
1002                "   pcb->tmr %"U32_F" pcb->keep_cnt_sent %"U16_F"\n", 
1003                tcp_ticks, pcb->tmr, pcb->keep_cnt_sent));
1004
1005   seg = pcb->unacked;
1006
1007   if(seg == NULL)
1008     seg = pcb->unsent;
1009
1010   if(seg == NULL)
1011     return;
1012
1013   is_fin = ((TCPH_FLAGS(seg->tcphdr) & TCP_FIN) != 0) && (seg->len == 0);
1014   len = is_fin ? TCP_HLEN : TCP_HLEN + 1;
1015
1016   p = pbuf_alloc(PBUF_IP, len, PBUF_RAM);
1017   if(p == NULL) {
1018     LWIP_DEBUGF(TCP_DEBUG, ("tcp_zero_window_probe: no memory for pbuf\n"));
1019     return;
1020   }
1021   LWIP_ASSERT("check that first pbuf can hold struct tcp_hdr",
1022               (p->len >= sizeof(struct tcp_hdr)));
1023
1024   tcphdr = tcp_output_set_header(pcb, p, 0, seg->tcphdr->seqno);
1025
1026   if (is_fin) {
1027     /* FIN segment, no data */
1028     TCPH_FLAGS_SET(tcphdr, TCP_ACK | TCP_FIN);
1029   } else {
1030     /* Data segment, copy in one byte from the head of the unacked queue */
1031     *((char *)p->payload + sizeof(struct tcp_hdr)) = *(char *)seg->dataptr;
1032   }
1033
1034 #if CHECKSUM_GEN_TCP
1035   tcphdr->chksum = inet_chksum_pseudo(p, &pcb->local_ip, &pcb->remote_ip,
1036                                       IP_PROTO_TCP, p->tot_len);
1037 #endif
1038   TCP_STATS_INC(tcp.xmit);
1039
1040   /* Send output to IP */
1041 #if LWIP_NETIF_HWADDRHINT
1042   ip_output_hinted(p, &pcb->local_ip, &pcb->remote_ip, pcb->ttl, 0, IP_PROTO_TCP,
1043     &(pcb->addr_hint));
1044 #else /* LWIP_NETIF_HWADDRHINT*/
1045   ip_output(p, &pcb->local_ip, &pcb->remote_ip, pcb->ttl, 0, IP_PROTO_TCP);
1046 #endif /* LWIP_NETIF_HWADDRHINT*/
1047
1048   pbuf_free(p);
1049
1050   LWIP_DEBUGF(TCP_DEBUG, ("tcp_zero_window_probe: seqno %"U32_F
1051                           " ackno %"U32_F".\n",
1052                           pcb->snd_nxt - 1, pcb->rcv_nxt));
1053 }
1054 #endif /* LWIP_TCP */