Commit | Line | Data |
---|---|---|
15637ed4 RG |
1 | /* |
2 | * Copyright (c) 1982, 1986, 1988, 1990 Regents of the University of California. | |
3 | * All rights reserved. | |
4 | * | |
5 | * Redistribution and use in source and binary forms, with or without | |
6 | * modification, are permitted provided that the following conditions | |
7 | * are met: | |
8 | * 1. Redistributions of source code must retain the above copyright | |
9 | * notice, this list of conditions and the following disclaimer. | |
10 | * 2. Redistributions in binary form must reproduce the above copyright | |
11 | * notice, this list of conditions and the following disclaimer in the | |
12 | * documentation and/or other materials provided with the distribution. | |
13 | * 3. All advertising materials mentioning features or use of this software | |
14 | * must display the following acknowledgement: | |
15 | * This product includes software developed by the University of | |
16 | * California, Berkeley and its contributors. | |
17 | * 4. Neither the name of the University nor the names of its contributors | |
18 | * may be used to endorse or promote products derived from this software | |
19 | * without specific prior written permission. | |
20 | * | |
21 | * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND | |
22 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | |
23 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | |
24 | * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE | |
25 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | |
26 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | |
27 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | |
28 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | |
29 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | |
30 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | |
31 | * SUCH DAMAGE. | |
32 | * | |
38e82238 | 33 | * from: @(#)tcp_output.c 7.22 (Berkeley) 8/31/90 |
ff1a3ad7 | 34 | * $Id: tcp_output.c,v 1.3 1993/11/25 01:35:16 wollman Exp $ |
15637ed4 RG |
35 | */ |
36 | ||
37 | #include "param.h" | |
38 | #include "systm.h" | |
39 | #include "malloc.h" | |
40 | #include "mbuf.h" | |
41 | #include "protosw.h" | |
42 | #include "socket.h" | |
43 | #include "socketvar.h" | |
44 | #include "errno.h" | |
45 | ||
46 | #include "../net/route.h" | |
47 | ||
48 | #include "in.h" | |
49 | #include "in_systm.h" | |
50 | #include "ip.h" | |
51 | #include "in_pcb.h" | |
52 | #include "ip_var.h" | |
53 | #include "tcp.h" | |
54 | #define TCPOUTFLAGS | |
55 | #include "tcp_fsm.h" | |
56 | #include "tcp_seq.h" | |
57 | #include "tcp_timer.h" | |
58 | #include "tcp_var.h" | |
59 | #include "tcpip.h" | |
ff1a3ad7 | 60 | #ifdef TCPDEBUG |
15637ed4 | 61 | #include "tcp_debug.h" |
ff1a3ad7 | 62 | #endif |
15637ed4 | 63 | |
15637ed4 RG |
64 | /* |
65 | * Initial options. | |
66 | */ | |
67 | u_char tcp_initopt[4] = { TCPOPT_MAXSEG, 4, 0x0, 0x0, }; | |
68 | ||
69 | /* | |
70 | * Tcp output routine: figure out what should be sent and send it. | |
71 | */ | |
4c45483e | 72 | int |
15637ed4 RG |
73 | tcp_output(tp) |
74 | register struct tcpcb *tp; | |
75 | { | |
76 | register struct socket *so = tp->t_inpcb->inp_socket; | |
77 | register long len, win; | |
78 | int off, flags, error; | |
79 | register struct mbuf *m; | |
80 | register struct tcpiphdr *ti; | |
4c45483e | 81 | u_char *opt = 0; |
15637ed4 RG |
82 | unsigned optlen, hdrlen; |
83 | int idle, sendalot; | |
84 | ||
85 | /* | |
86 | * Determine length of data that should be transmitted, | |
87 | * and flags that will be used. | |
88 | * If there is some data or critical controls (SYN, RST) | |
89 | * to send, then transmit; otherwise, investigate further. | |
90 | */ | |
91 | idle = (tp->snd_max == tp->snd_una); | |
92 | if (idle && tp->t_idle >= tp->t_rxtcur) | |
93 | /* | |
94 | * We have been idle for "a while" and no acks are | |
95 | * expected to clock out any data we send -- | |
96 | * slow start to get ack "clock" running again. | |
97 | */ | |
98 | tp->snd_cwnd = tp->t_maxseg; | |
99 | again: | |
100 | sendalot = 0; | |
101 | off = tp->snd_nxt - tp->snd_una; | |
102 | win = min(tp->snd_wnd, tp->snd_cwnd); | |
103 | ||
104 | /* | |
105 | * If in persist timeout with window of 0, send 1 byte. | |
106 | * Otherwise, if window is small but nonzero | |
107 | * and timer expired, we will send what we can | |
108 | * and go to transmit state. | |
109 | */ | |
110 | if (tp->t_force) { | |
111 | if (win == 0) | |
112 | win = 1; | |
113 | else { | |
114 | tp->t_timer[TCPT_PERSIST] = 0; | |
115 | tp->t_rxtshift = 0; | |
116 | } | |
117 | } | |
118 | ||
119 | flags = tcp_outflags[tp->t_state]; | |
120 | len = min(so->so_snd.sb_cc, win) - off; | |
121 | ||
122 | if (len < 0) { | |
123 | /* | |
124 | * If FIN has been sent but not acked, | |
125 | * but we haven't been called to retransmit, | |
126 | * len will be -1. Otherwise, window shrank | |
127 | * after we sent into it. If window shrank to 0, | |
128 | * cancel pending retransmit and pull snd_nxt | |
129 | * back to (closed) window. We will enter persist | |
130 | * state below. If the window didn't close completely, | |
131 | * just wait for an ACK. | |
132 | */ | |
133 | len = 0; | |
134 | if (win == 0) { | |
135 | tp->t_timer[TCPT_REXMT] = 0; | |
136 | tp->snd_nxt = tp->snd_una; | |
137 | } | |
138 | } | |
139 | if (len > tp->t_maxseg) { | |
140 | len = tp->t_maxseg; | |
141 | sendalot = 1; | |
142 | } | |
143 | if (SEQ_LT(tp->snd_nxt + len, tp->snd_una + so->so_snd.sb_cc)) | |
144 | flags &= ~TH_FIN; | |
145 | ||
146 | win = sbspace(&so->so_rcv); | |
147 | ||
148 | /* | |
149 | * Sender silly window avoidance. If connection is idle | |
150 | * and can send all data, a maximum segment, | |
151 | * at least a maximum default-size segment do it, | |
152 | * or are forced, do it; otherwise don't bother. | |
153 | * If peer's buffer is tiny, then send | |
154 | * when window is at least half open. | |
155 | * If retransmitting (possibly after persist timer forced us | |
156 | * to send into a small window), then must resend. | |
157 | */ | |
158 | if (len) { | |
159 | if (len == tp->t_maxseg) | |
160 | goto send; | |
161 | if ((idle || tp->t_flags & TF_NODELAY) && | |
162 | len + off >= so->so_snd.sb_cc) | |
163 | goto send; | |
164 | if (tp->t_force) | |
165 | goto send; | |
166 | if (len >= tp->max_sndwnd / 2) | |
167 | goto send; | |
168 | if (SEQ_LT(tp->snd_nxt, tp->snd_max)) | |
169 | goto send; | |
170 | } | |
171 | ||
172 | /* | |
173 | * Compare available window to amount of window | |
174 | * known to peer (as advertised window less | |
175 | * next expected input). If the difference is at least two | |
176 | * max size segments, or at least 50% of the maximum possible | |
177 | * window, then want to send a window update to peer. | |
178 | */ | |
179 | if (win > 0) { | |
180 | long adv = win - (tp->rcv_adv - tp->rcv_nxt); | |
181 | ||
182 | if (adv >= (long) (2 * tp->t_maxseg)) | |
183 | goto send; | |
184 | if (2 * adv >= (long) so->so_rcv.sb_hiwat) | |
185 | goto send; | |
186 | } | |
187 | ||
188 | /* | |
189 | * Send if we owe peer an ACK. | |
190 | */ | |
191 | if (tp->t_flags & TF_ACKNOW) | |
192 | goto send; | |
193 | if (flags & (TH_SYN|TH_RST)) | |
194 | goto send; | |
195 | if (SEQ_GT(tp->snd_up, tp->snd_una)) | |
196 | goto send; | |
197 | /* | |
198 | * If our state indicates that FIN should be sent | |
199 | * and we have not yet done so, or we're retransmitting the FIN, | |
200 | * then we need to send. | |
201 | */ | |
202 | if (flags & TH_FIN && | |
203 | ((tp->t_flags & TF_SENTFIN) == 0 || tp->snd_nxt == tp->snd_una)) | |
204 | goto send; | |
205 | ||
206 | /* | |
207 | * TCP window updates are not reliable, rather a polling protocol | |
208 | * using ``persist'' packets is used to insure receipt of window | |
209 | * updates. The three ``states'' for the output side are: | |
210 | * idle not doing retransmits or persists | |
211 | * persisting to move a small or zero window | |
212 | * (re)transmitting and thereby not persisting | |
213 | * | |
214 | * tp->t_timer[TCPT_PERSIST] | |
215 | * is set when we are in persist state. | |
216 | * tp->t_force | |
217 | * is set when we are called to send a persist packet. | |
218 | * tp->t_timer[TCPT_REXMT] | |
219 | * is set when we are retransmitting | |
220 | * The output side is idle when both timers are zero. | |
221 | * | |
222 | * If send window is too small, there is data to transmit, and no | |
223 | * retransmit or persist is pending, then go to persist state. | |
224 | * If nothing happens soon, send when timer expires: | |
225 | * if window is nonzero, transmit what we can, | |
226 | * otherwise force out a byte. | |
227 | */ | |
228 | if (so->so_snd.sb_cc && tp->t_timer[TCPT_REXMT] == 0 && | |
229 | tp->t_timer[TCPT_PERSIST] == 0) { | |
230 | tp->t_rxtshift = 0; | |
231 | tcp_setpersist(tp); | |
232 | } | |
233 | ||
234 | /* | |
235 | * No reason to send a segment, just return. | |
236 | */ | |
237 | return (0); | |
238 | ||
239 | send: | |
240 | /* | |
241 | * Before ESTABLISHED, force sending of initial options | |
242 | * unless TCP set not to do any options. | |
243 | * NOTE: we assume that the IP/TCP header plus TCP options | |
244 | * always fit in a single mbuf, leaving room for a maximum | |
245 | * link header, i.e. | |
246 | * max_linkhdr + sizeof (struct tcpiphdr) + optlen <= MHLEN | |
247 | */ | |
248 | optlen = 0; | |
249 | hdrlen = sizeof (struct tcpiphdr); | |
250 | if (flags & TH_SYN && (tp->t_flags & TF_NOOPT) == 0) { | |
251 | opt = tcp_initopt; | |
252 | optlen = sizeof (tcp_initopt); | |
253 | hdrlen += sizeof (tcp_initopt); | |
254 | *(u_short *)(opt + 2) = htons((u_short) tcp_mss(tp, 0)); | |
255 | #ifdef DIAGNOSTIC | |
256 | if (max_linkhdr + hdrlen > MHLEN) | |
257 | panic("tcphdr too big"); | |
258 | #endif | |
259 | } | |
260 | ||
261 | /* | |
262 | * Grab a header mbuf, attaching a copy of data to | |
263 | * be transmitted, and initialize the header from | |
264 | * the template for sends on this connection. | |
265 | */ | |
266 | if (len) { | |
267 | if (tp->t_force && len == 1) | |
268 | tcpstat.tcps_sndprobe++; | |
269 | else if (SEQ_LT(tp->snd_nxt, tp->snd_max)) { | |
270 | tcpstat.tcps_sndrexmitpack++; | |
271 | tcpstat.tcps_sndrexmitbyte += len; | |
272 | } else { | |
273 | tcpstat.tcps_sndpack++; | |
274 | tcpstat.tcps_sndbyte += len; | |
275 | } | |
276 | #ifdef notyet | |
277 | if ((m = m_copypack(so->so_snd.sb_mb, off, | |
278 | (int)len, max_linkhdr + hdrlen)) == 0) { | |
279 | error = ENOBUFS; | |
280 | goto out; | |
281 | } | |
282 | /* | |
283 | * m_copypack left space for our hdr; use it. | |
284 | */ | |
285 | m->m_len += hdrlen; | |
286 | m->m_data -= hdrlen; | |
287 | #else | |
288 | MGETHDR(m, M_DONTWAIT, MT_HEADER); | |
289 | if (m == NULL) { | |
290 | error = ENOBUFS; | |
291 | goto out; | |
292 | } | |
293 | m->m_data += max_linkhdr; | |
294 | m->m_len = hdrlen; | |
295 | if (len <= MHLEN - hdrlen - max_linkhdr) { | |
296 | m_copydata(so->so_snd.sb_mb, off, (int) len, | |
297 | mtod(m, caddr_t) + hdrlen); | |
298 | m->m_len += len; | |
299 | } else { | |
300 | m->m_next = m_copy(so->so_snd.sb_mb, off, (int) len); | |
301 | if (m->m_next == 0) | |
302 | len = 0; | |
303 | } | |
304 | #endif | |
305 | /* | |
306 | * If we're sending everything we've got, set PUSH. | |
307 | * (This will keep happy those implementations which only | |
308 | * give data to the user when a buffer fills or | |
309 | * a PUSH comes in.) | |
310 | */ | |
311 | if (off + len == so->so_snd.sb_cc) | |
312 | flags |= TH_PUSH; | |
313 | } else { | |
314 | if (tp->t_flags & TF_ACKNOW) | |
315 | tcpstat.tcps_sndacks++; | |
316 | else if (flags & (TH_SYN|TH_FIN|TH_RST)) | |
317 | tcpstat.tcps_sndctrl++; | |
318 | else if (SEQ_GT(tp->snd_up, tp->snd_una)) | |
319 | tcpstat.tcps_sndurg++; | |
320 | else | |
321 | tcpstat.tcps_sndwinup++; | |
322 | ||
323 | MGETHDR(m, M_DONTWAIT, MT_HEADER); | |
324 | if (m == NULL) { | |
325 | error = ENOBUFS; | |
326 | goto out; | |
327 | } | |
328 | m->m_data += max_linkhdr; | |
329 | m->m_len = hdrlen; | |
330 | } | |
331 | m->m_pkthdr.rcvif = (struct ifnet *)0; | |
332 | ti = mtod(m, struct tcpiphdr *); | |
333 | if (tp->t_template == 0) | |
334 | panic("tcp_output"); | |
335 | bcopy((caddr_t)tp->t_template, (caddr_t)ti, sizeof (struct tcpiphdr)); | |
336 | ||
337 | /* | |
338 | * Fill in fields, remembering maximum advertised | |
339 | * window for use in delaying messages about window sizes. | |
340 | * If resending a FIN, be sure not to use a new sequence number. | |
341 | */ | |
342 | if (flags & TH_FIN && tp->t_flags & TF_SENTFIN && | |
343 | tp->snd_nxt == tp->snd_max) | |
344 | tp->snd_nxt--; | |
345 | ti->ti_seq = htonl(tp->snd_nxt); | |
346 | ti->ti_ack = htonl(tp->rcv_nxt); | |
347 | if (optlen) { | |
348 | bcopy((caddr_t)opt, (caddr_t)(ti + 1), optlen); | |
349 | ti->ti_off = (sizeof (struct tcphdr) + optlen) >> 2; | |
350 | } | |
351 | ti->ti_flags = flags; | |
352 | /* | |
353 | * Calculate receive window. Don't shrink window, | |
354 | * but avoid silly window syndrome. | |
355 | */ | |
356 | if (win < (long)(so->so_rcv.sb_hiwat / 4) && win < (long)tp->t_maxseg) | |
357 | win = 0; | |
358 | if (win > TCP_MAXWIN) | |
359 | win = TCP_MAXWIN; | |
360 | if (win < (long)(tp->rcv_adv - tp->rcv_nxt)) | |
361 | win = (long)(tp->rcv_adv - tp->rcv_nxt); | |
362 | ti->ti_win = htons((u_short)win); | |
363 | if (SEQ_GT(tp->snd_up, tp->snd_nxt)) { | |
364 | ti->ti_urp = htons((u_short)(tp->snd_up - tp->snd_nxt)); | |
365 | ti->ti_flags |= TH_URG; | |
366 | } else | |
367 | /* | |
368 | * If no urgent pointer to send, then we pull | |
369 | * the urgent pointer to the left edge of the send window | |
370 | * so that it doesn't drift into the send window on sequence | |
371 | * number wraparound. | |
372 | */ | |
373 | tp->snd_up = tp->snd_una; /* drag it along */ | |
374 | ||
375 | /* | |
376 | * Put TCP length in extended header, and then | |
377 | * checksum extended header and data. | |
378 | */ | |
379 | if (len + optlen) | |
380 | ti->ti_len = htons((u_short)(sizeof (struct tcphdr) + | |
381 | optlen + len)); | |
382 | ti->ti_sum = in_cksum(m, (int)(hdrlen + len)); | |
383 | ||
384 | /* | |
385 | * In transmit state, time the transmission and arrange for | |
386 | * the retransmit. In persist state, just set snd_max. | |
387 | */ | |
388 | if (tp->t_force == 0 || tp->t_timer[TCPT_PERSIST] == 0) { | |
389 | tcp_seq startseq = tp->snd_nxt; | |
390 | ||
391 | /* | |
392 | * Advance snd_nxt over sequence space of this segment. | |
393 | */ | |
394 | if (flags & (TH_SYN|TH_FIN)) { | |
395 | if (flags & TH_SYN) | |
396 | tp->snd_nxt++; | |
397 | if (flags & TH_FIN) { | |
398 | tp->snd_nxt++; | |
399 | tp->t_flags |= TF_SENTFIN; | |
400 | } | |
401 | } | |
402 | tp->snd_nxt += len; | |
403 | if (SEQ_GT(tp->snd_nxt, tp->snd_max)) { | |
404 | tp->snd_max = tp->snd_nxt; | |
405 | /* | |
406 | * Time this transmission if not a retransmission and | |
407 | * not currently timing anything. | |
408 | */ | |
409 | if (tp->t_rtt == 0) { | |
410 | tp->t_rtt = 1; | |
411 | tp->t_rtseq = startseq; | |
412 | tcpstat.tcps_segstimed++; | |
413 | } | |
414 | } | |
415 | ||
416 | /* | |
417 | * Set retransmit timer if not currently set, | |
418 | * and not doing an ack or a keep-alive probe. | |
419 | * Initial value for retransmit timer is smoothed | |
420 | * round-trip time + 2 * round-trip time variance. | |
421 | * Initialize shift counter which is used for backoff | |
422 | * of retransmit time. | |
423 | */ | |
424 | if (tp->t_timer[TCPT_REXMT] == 0 && | |
425 | tp->snd_nxt != tp->snd_una) { | |
426 | tp->t_timer[TCPT_REXMT] = tp->t_rxtcur; | |
427 | if (tp->t_timer[TCPT_PERSIST]) { | |
428 | tp->t_timer[TCPT_PERSIST] = 0; | |
429 | tp->t_rxtshift = 0; | |
430 | } | |
431 | } | |
432 | } else | |
433 | if (SEQ_GT(tp->snd_nxt + len, tp->snd_max)) | |
434 | tp->snd_max = tp->snd_nxt + len; | |
435 | ||
ff1a3ad7 | 436 | #ifdef TCPDEBUG |
15637ed4 RG |
437 | /* |
438 | * Trace. | |
439 | */ | |
440 | if (so->so_options & SO_DEBUG) | |
441 | tcp_trace(TA_OUTPUT, tp->t_state, tp, ti, 0); | |
ff1a3ad7 | 442 | #endif |
15637ed4 RG |
443 | |
444 | /* | |
445 | * Fill in IP length and desired time to live and | |
446 | * send to IP level. There should be a better way | |
447 | * to handle ttl and tos; we could keep them in | |
448 | * the template, but need a way to checksum without them. | |
449 | */ | |
450 | m->m_pkthdr.len = hdrlen + len; | |
451 | ((struct ip *)ti)->ip_len = m->m_pkthdr.len; | |
452 | ((struct ip *)ti)->ip_ttl = tp->t_inpcb->inp_ip.ip_ttl; /* XXX */ | |
453 | ((struct ip *)ti)->ip_tos = tp->t_inpcb->inp_ip.ip_tos; /* XXX */ | |
454 | #if BSD >= 43 | |
455 | error = ip_output(m, tp->t_inpcb->inp_options, &tp->t_inpcb->inp_route, | |
456 | so->so_options & SO_DONTROUTE); | |
457 | #else | |
458 | error = ip_output(m, (struct mbuf *)0, &tp->t_inpcb->inp_route, | |
459 | so->so_options & SO_DONTROUTE); | |
460 | #endif | |
461 | if (error) { | |
462 | out: | |
463 | if (error == ENOBUFS) { | |
4c45483e | 464 | tcp_quench(tp->t_inpcb, 0); |
15637ed4 RG |
465 | return (0); |
466 | } | |
467 | if ((error == EHOSTUNREACH || error == ENETDOWN) | |
468 | && TCPS_HAVERCVDSYN(tp->t_state)) { | |
469 | tp->t_softerror = error; | |
470 | return (0); | |
471 | } | |
472 | return (error); | |
473 | } | |
474 | tcpstat.tcps_sndtotal++; | |
475 | ||
476 | /* | |
477 | * Data sent (as far as we can tell). | |
478 | * If this advertises a larger window than any other segment, | |
479 | * then remember the size of the advertised window. | |
480 | * Any pending ACK has now been sent. | |
481 | */ | |
482 | if (win > 0 && SEQ_GT(tp->rcv_nxt+win, tp->rcv_adv)) | |
483 | tp->rcv_adv = tp->rcv_nxt + win; | |
484 | tp->t_flags &= ~(TF_ACKNOW|TF_DELACK); | |
485 | if (sendalot) | |
486 | goto again; | |
487 | return (0); | |
488 | } | |
489 | ||
4c45483e | 490 | void |
15637ed4 RG |
491 | tcp_setpersist(tp) |
492 | register struct tcpcb *tp; | |
493 | { | |
494 | register t = ((tp->t_srtt >> 2) + tp->t_rttvar) >> 1; | |
495 | ||
496 | if (tp->t_timer[TCPT_REXMT]) | |
497 | panic("tcp_output REXMT"); | |
498 | /* | |
499 | * Start/restart persistance timer. | |
500 | */ | |
501 | TCPT_RANGESET(tp->t_timer[TCPT_PERSIST], | |
502 | t * tcp_backoff[tp->t_rxtshift], | |
503 | TCPTV_PERSMIN, TCPTV_PERSMAX); | |
504 | if (tp->t_rxtshift < TCP_MAXRXTSHIFT) | |
505 | tp->t_rxtshift++; | |
506 | } |