![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to tcp_output.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple Darwin 0.x] / kernel / bsd / netinet|
Return to tcp_output.c CVS log | Up to [Apple Darwin 0.x] / kernel / bsd / netinet |
1.1 root 1: /*
2: * Copyright (c) 1999 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
6: * Portions Copyright (c) 1999 Apple Computer, Inc. All Rights
7: * Reserved. This file contains Original Code and/or Modifications of
8: * Original Code as defined in and that are subject to the Apple Public
9: * Source License Version 1.1 (the "License"). You may not use this file
10: * except in compliance with the License. Please obtain a copy of the
11: * License at http://www.apple.com/publicsource and read it before using
12: * this file.
13: *
14: * The Original Code and all software distributed under the License are
15: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
16: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
17: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
18: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
19: * License for the specific language governing rights and limitations
20: * under the License.
21: *
22: * @APPLE_LICENSE_HEADER_END@
23: */
24:
25: /* Copyright (c) 1995 NeXT Computer, Inc. All Rights Reserved */
26: /*
27: * Copyright (c) 1982, 1986, 1988, 1990, 1993, 1995
28: * The Regents of the University of California. All rights reserved.
29: *
30: * Redistribution and use in source and binary forms, with or without
31: * modification, are permitted provided that the following conditions
32: * are met:
33: * 1. Redistributions of source code must retain the above copyright
34: * notice, this list of conditions and the following disclaimer.
35: * 2. Redistributions in binary form must reproduce the above copyright
36: * notice, this list of conditions and the following disclaimer in the
37: * documentation and/or other materials provided with the distribution.
38: * 3. All advertising materials mentioning features or use of this software
39: * must display the following acknowledgement:
40: * This product includes software developed by the University of
41: * California, Berkeley and its contributors.
42: * 4. Neither the name of the University nor the names of its contributors
43: * may be used to endorse or promote products derived from this software
44: * without specific prior written permission.
45: *
46: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
47: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
48: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
49: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
50: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
51: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
52: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
53: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
54: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
55: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
56: * SUCH DAMAGE.
57: *
58: * @(#)tcp_output.c 8.3 (Berkeley) 12/30/93
59: */
60:
61: #include <sys/param.h>
62: #include <sys/systm.h>
63: #include <sys/malloc.h>
64: #include <sys/mbuf.h>
65: #include <sys/protosw.h>
66: #include <sys/socket.h>
67: #include <sys/socketvar.h>
68: #include <sys/errno.h>
69:
70: #include <net/route.h>
71:
72: #include <netinet/in.h>
73: #include <netinet/in_systm.h>
74: #include <netinet/ip.h>
75: #include <netinet/in_pcb.h>
76: #include <netinet/ip_var.h>
77: #include <netinet/tcp.h>
78: #define TCPOUTFLAGS
79: #include <netinet/tcp_fsm.h>
80: #include <netinet/tcp_seq.h>
81: #include <netinet/tcp_timer.h>
82: #include <netinet/tcp_var.h>
83: #include <netinet/tcpip.h>
84: #include <netinet/tcp_debug.h>
85:
86: #if NEXT
87: #import <kern/kdebug.h>
88:
89: #if KDEBUG
90:
91: #define DBG_LAYER_BEG NETDBG_CODE(DBG_NETTCP, 1)
92: #define DBG_LAYER_END NETDBG_CODE(DBG_NETTCP, 3)
93: #define DBG_FNC_TCP_OUTPUT NETDBG_CODE(DBG_NETTCP, (4 << 8) | 1)
94:
95: #endif
96:
97: #endif
98:
99: #ifdef notyet
100: extern struct mbuf *m_copypack();
101: #endif
102:
103:
104: #define MAX_TCPOPTLEN 32 /* max # bytes that go in options */
105:
106: /*
107: * Tcp output routine: figure out what should be sent and send it.
108: */
109: int
110: tcp_output(tp)
111: register struct tcpcb *tp;
112: {
113: register struct socket *so = tp->t_inpcb->inp_socket;
114: register long len, win;
115: int off, flags, error;
116: register struct mbuf *m;
117: register struct tcpiphdr *ti;
118: u_char opt[MAX_TCPOPTLEN];
119: unsigned optlen, hdrlen;
120: int idle, sendalot;
121:
122:
123:
124: KERNEL_DEBUG(DBG_FNC_TCP_OUTPUT | DBG_FUNC_START, 0,0,0,0,0);
125: KERNEL_DEBUG(DBG_LAYER_BEG,
126: ((tp->t_template->ti_dport << 16) | tp->t_template->ti_sport),
127: (((tp->t_template->ti_src.s_addr & 0xffff) << 16) |
128: (tp->t_template->ti_dst.s_addr & 0xffff)),
129: 0,0,0);
130:
131: /*
132: * Determine length of data that should be transmitted,
133: * and flags that will be used.
134: * If there is some data or critical controls (SYN, RST)
135: * to send, then transmit; otherwise, investigate further.
136: */
137: idle = (tp->snd_max == tp->snd_una);
138: if (idle && tp->t_idle >= tp->t_rxtcur)
139: /*
140: * We have been idle for "a while" and no acks are
141: * expected to clock out any data we send --
142: * slow start to get ack "clock" running again.
143: */
144: tp->snd_cwnd = tp->t_maxseg;
145: again:
146: sendalot = 0;
147: off = tp->snd_nxt - tp->snd_una;
148: win = min(tp->snd_wnd, tp->snd_cwnd);
149:
150: flags = tcp_outflags[tp->t_state];
151: /*
152: * If in persist timeout with window of 0, send 1 byte.
153: * Otherwise, if window is small but nonzero
154: * and timer expired, we will send what we can
155: * and go to transmit state.
156: */
157: if (tp->t_force) {
158: if (win == 0) {
159: /*
160: * If we still have some data to send, then
161: * clear the FIN bit. Usually this would
162: * happen below when it realizes that we
163: * aren't sending all the data. However,
164: * if we have exactly 1 byte of unset data,
165: * then it won't clear the FIN bit below,
166: * and if we are in persist state, we wind
167: * up sending the packet without recording
168: * that we sent the FIN bit.
169: *
170: * We can't just blindly clear the FIN bit,
171: * because if we don't have any more data
172: * to send then the probe will be the FIN
173: * itself.
174: */
175: if (off < so->so_snd.sb_cc)
176: flags &= ~TH_FIN;
177: win = 1;
178: } else {
179: tp->t_timer[TCPT_PERSIST] = 0;
180: tp->t_rxtshift = 0;
181: }
182: }
183:
184: len = min(so->so_snd.sb_cc, win) - off;
185:
186: if (len < 0) {
187: /*
188: * If FIN has been sent but not acked,
189: * but we haven't been called to retransmit,
190: * len will be -1. Otherwise, window shrank
191: * after we sent into it. If window shrank to 0,
192: * cancel pending retransmit and pull snd_nxt
193: * back to (closed) window. We will enter persist
194: * state below. If the window didn't close completely,
195: * just wait for an ACK.
196: */
197: len = 0;
198: if (win == 0) {
199: tp->t_timer[TCPT_REXMT] = 0;
200: tp->snd_nxt = tp->snd_una;
201: }
202: }
203: if (len > tp->t_maxseg) {
204: len = tp->t_maxseg;
205: sendalot = 1;
206: }
207: if (SEQ_LT(tp->snd_nxt + len, tp->snd_una + so->so_snd.sb_cc))
208: flags &= ~TH_FIN;
209:
210: win = sbspace(&so->so_rcv);
211:
212: /*
213: * Sender silly window avoidance. If connection is idle
214: * and can send all data, a maximum segment,
215: * at least a maximum default-size segment do it,
216: * or are forced, do it; otherwise don't bother.
217: * If peer's buffer is tiny, then send
218: * when window is at least half open.
219: * If retransmitting (possibly after persist timer forced us
220: * to send into a small window), then must resend.
221: */
222: if (len) {
223: if (len == tp->t_maxseg)
224: goto send;
225: if (!(so->so_state & SS_MORETOCOME)) {
226: if ((idle || tp->t_flags & TF_NODELAY) &&
227: len + off >= so->so_snd.sb_cc)
228: goto send;
229: }
230: if (tp->t_force)
231: goto send;
232: if (len >= tp->max_sndwnd / 2)
233: goto send;
234: if (SEQ_LT(tp->snd_nxt, tp->snd_max))
235: goto send;
236: }
237:
238: /*
239: * Compare available window to amount of window
240: * known to peer (as advertised window less
241: * next expected input). If the difference is at least two
242: * max size segments, or at least 50% of the maximum possible
243: * window, then want to send a window update to peer.
244: */
245: if (win > 0) {
246: /*
247: * "adv" is the amount we can increase the window,
248: * taking into account that we are limited by
249: * TCP_MAXWIN << tp->rcv_scale.
250: */
251: long adv = min(win, (long)TCP_MAXWIN << tp->rcv_scale) -
252: (tp->rcv_adv - tp->rcv_nxt);
253:
254: if (adv >= (long) (2 * (tp->t_maxseg - MAX_TCPOPTLEN)))
255: goto send;
256: if (2 * adv >= (long) so->so_rcv.sb_hiwat)
257: goto send;
258: }
259:
260: /*
261: * Send if we owe peer an ACK.
262: */
263: if (tp->t_flags & TF_ACKNOW)
264: goto send;
265: if (flags & (TH_SYN|TH_RST))
266: goto send;
267: if (SEQ_GT(tp->snd_up, tp->snd_una))
268: goto send;
269: /*
270: * If our state indicates that FIN should be sent
271: * and we have not yet done so, or we're retransmitting the FIN,
272: * then we need to send.
273: */
274: if (flags & TH_FIN &&
275: ((tp->t_flags & TF_SENTFIN) == 0 || tp->snd_nxt == tp->snd_una))
276: goto send;
277:
278: /*
279: * TCP window updates are not reliable, rather a polling protocol
280: * using ``persist'' packets is used to insure receipt of window
281: * updates. The three ``states'' for the output side are:
282: * idle not doing retransmits or persists
283: * persisting to move a small or zero window
284: * (re)transmitting and thereby not persisting
285: *
286: * tp->t_timer[TCPT_PERSIST]
287: * is set when we are in persist state.
288: * tp->t_force
289: * is set when we are called to send a persist packet.
290: * tp->t_timer[TCPT_REXMT]
291: * is set when we are retransmitting
292: * The output side is idle when both timers are zero.
293: *
294: * If send window is too small, there is data to transmit, and no
295: * retransmit or persist is pending, then go to persist state.
296: * If nothing happens soon, send when timer expires:
297: * if window is nonzero, transmit what we can,
298: * otherwise force out a byte.
299: */
300: if (so->so_snd.sb_cc && tp->t_timer[TCPT_REXMT] == 0 &&
301: tp->t_timer[TCPT_PERSIST] == 0) {
302: tp->t_rxtshift = 0;
303: tcp_setpersist(tp);
304: }
305:
306: /*
307: * No reason to send a segment, just return.
308: */
309: KERNEL_DEBUG(DBG_FNC_TCP_OUTPUT | DBG_FUNC_END, 0,0,0,0,0);
310: return (0);
311:
312: send:
313: /*
314: * Before ESTABLISHED, force sending of initial options
315: * unless TCP set not to do any options.
316: * NOTE: we assume that the IP/TCP header plus TCP options
317: * always fit in a single mbuf, leaving room for a maximum
318: * link header, i.e.
319: * max_linkhdr + sizeof (struct tcpiphdr) + optlen <= MHLEN
320: */
321: optlen = 0;
322: hdrlen = sizeof (struct tcpiphdr);
323: if (flags & TH_SYN) {
324: tp->snd_nxt = tp->iss;
325: if ((tp->t_flags & TF_NOOPT) == 0) {
326: u_short mss;
327:
328: opt[0] = TCPOPT_MAXSEG;
329: opt[1] = 4;
330: mss = htons((u_short) tcp_mss(tp, 0));
331: bcopy((caddr_t)&mss, (caddr_t)(opt + 2), sizeof(mss));
332: optlen = 4;
333:
334: if ((tp->t_flags & TF_REQ_SCALE) &&
335: ((flags & TH_ACK) == 0 ||
336: (tp->t_flags & TF_RCVD_SCALE))) {
337: *((u_long *) (opt + optlen)) = htonl(
338: TCPOPT_NOP << 24 |
339: TCPOPT_WINDOW << 16 |
340: TCPOLEN_WINDOW << 8 |
341: tp->request_r_scale);
342: optlen += 4;
343: }
344: }
345: }
346:
347: /*
348: * Send a timestamp and echo-reply if this is a SYN and our side
349: * wants to use timestamps (TF_REQ_TSTMP is set) or both our side
350: * and our peer have sent timestamps in our SYN's.
351: */
352: if ((tp->t_flags & (TF_REQ_TSTMP|TF_NOOPT)) == TF_REQ_TSTMP &&
353: (flags & TH_RST) == 0 &&
354: ((flags & (TH_SYN|TH_ACK)) == TH_SYN ||
355: (tp->t_flags & TF_RCVD_TSTMP))) {
356: u_long *lp = (u_long *)(opt + optlen);
357:
358: /* Form timestamp option as shown in appendix A of RFC 1323. */
359: *lp++ = htonl(TCPOPT_TSTAMP_HDR);
360: *lp++ = htonl(tcp_now);
361: *lp = htonl(tp->ts_recent);
362: optlen += TCPOLEN_TSTAMP_APPA;
363: }
364:
365: hdrlen += optlen;
366:
367: /*
368: * Adjust data length if insertion of options will
369: * bump the packet length beyond the t_maxseg length.
370: */
371: if (len > tp->t_maxseg - optlen) {
372: len = tp->t_maxseg - optlen;
373: sendalot = 1;
374: flags &= ~TH_FIN;
375: }
376:
377: #if DIAGNOSTIC
378: if (max_linkhdr + hdrlen > MHLEN)
379: panic("tcphdr too big");
380: #endif
381:
382: /*
383: * Grab a header mbuf, attaching a copy of data to
384: * be transmitted, and initialize the header from
385: * the template for sends on this connection.
386: */
387: if (len) {
388: if (tp->t_force && len == 1)
389: tcpstat.tcps_sndprobe++;
390: else if (SEQ_LT(tp->snd_nxt, tp->snd_max)) {
391: tcpstat.tcps_sndrexmitpack++;
392: tcpstat.tcps_sndrexmitbyte += len;
393: } else {
394: tcpstat.tcps_sndpack++;
395: tcpstat.tcps_sndbyte += len;
396: }
397: #ifdef notyet
398: if ((m = m_copypack(so->so_snd.sb_mb, off,
399: (int)len, max_linkhdr + hdrlen)) == 0) {
400: error = ENOBUFS;
401: goto out;
402: }
403: /*
404: * m_copypack left space for our hdr; use it.
405: */
406: m->m_len += hdrlen;
407: m->m_data -= hdrlen;
408: #else
409: MGETHDR(m, M_DONTWAIT, MT_HEADER);
410: if (m == NULL) {
411: error = ENOBUFS;
412: goto out;
413: }
414: m->m_data += max_linkhdr;
415: m->m_len = hdrlen;
416: if (len <= (MHLEN - hdrlen - max_linkhdr)) {
417: register struct mbuf *m1, *m2;
418: register char *p;
419: register int cur_len, len1;
420: register int off1;
421:
422: p = mtod(m, caddr_t) + hdrlen;
423: m1 = so->so_snd.sb_mb;
424: off1 = off;
425: len1 = len;
426:
427: for (;;) {
428: for (cur_len = 0, m2 = m1; m2; m2 = m2->m_next)
429: cur_len += m2->m_len;
430: if (off1 < cur_len) {
431: cur_len = min(cur_len - off1, len1);
432:
433: m_copydata(m1, off1, (int) cur_len, p);
434:
435: if ((len1 -= cur_len) == 0)
436: break;
437: p += cur_len;
438: off1 = 0;
439: } else
440: off1 -= cur_len;
441:
442: kprintf("m_copydata: nextpkt path\n");
443:
444: if ((m1 = m1->m_nextpkt) == NULL)
445: panic("tcp_output: m_copydata");
446: }
447: m->m_len += len;
448:
449: } else {
450: register struct mbuf *m1, *m2, *m3;
451: register int cur_len, len1;
452: register int off1;
453:
454: m1 = so->so_snd.sb_mb;
455: m3 = m;
456: off1 = off;
457: len1 = len;
458:
459: for (;;) {
460: for (cur_len = 0, m2 = m1; m2; m2 = m2->m_next)
461: cur_len += m2->m_len;
462: if (off1 < cur_len) {
463: cur_len = min(cur_len - off1, len1);
464:
465: m3->m_next = m_copy(m1, off1, (int) cur_len);
466: if (m3->m_next == 0) {
467: (void) m_free(m);
468: error = ENOBUFS;
469: goto out;
470: }
471: if ((len1 -= cur_len) == 0)
472: break;
473: for (m3 = m3->m_next; m3->m_next; m3 = m3->m_next);
474:
475: off1 = 0;
476: } else
477: off1 -= cur_len;
478:
479: kprintf("m_copy: nextpkt path\n");
480:
481: if ((m1 = m1->m_nextpkt) == NULL)
482: panic("tcp_output: m_copy");
483: }
484: }
485: #endif
486: /*
487: * If we're sending everything we've got, set PUSH.
488: * (This will keep happy those implementations which only
489: * give data to the user when a buffer fills or
490: * a PUSH comes in.)
491: */
492: if (off + len == so->so_snd.sb_cc)
493: flags |= TH_PUSH;
494: } else {
495: if (tp->t_flags & TF_ACKNOW)
496: tcpstat.tcps_sndacks++;
497: else if (flags & (TH_SYN|TH_FIN|TH_RST))
498: tcpstat.tcps_sndctrl++;
499: else if (SEQ_GT(tp->snd_up, tp->snd_una))
500: tcpstat.tcps_sndurg++;
501: else
502: tcpstat.tcps_sndwinup++;
503:
504: MGETHDR(m, M_DONTWAIT, MT_HEADER);
505: if (m == NULL) {
506: error = ENOBUFS;
507: goto out;
508: }
509: m->m_data += max_linkhdr;
510: m->m_len = hdrlen;
511: }
512: m->m_pkthdr.rcvif = (struct ifnet *)0;
513: ti = mtod(m, struct tcpiphdr *);
514: if (tp->t_template == 0)
515: panic("tcp_output");
516: bcopy((caddr_t)tp->t_template, (caddr_t)ti, sizeof (struct tcpiphdr));
517:
518: /*
519: * Fill in fields, remembering maximum advertised
520: * window for use in delaying messages about window sizes.
521: * If resending a FIN, be sure not to use a new sequence number.
522: */
523: if (flags & TH_FIN && tp->t_flags & TF_SENTFIN &&
524: tp->snd_nxt == tp->snd_max)
525: tp->snd_nxt--;
526: /*
527: * If we are doing retransmissions, then snd_nxt will
528: * not reflect the first unsent octet. For ACK only
529: * packets, we do not want the sequence number of the
530: * retransmitted packet, we want the sequence number
531: * of the next unsent octet. So, if there is no data
532: * (and no SYN or FIN), use snd_max instead of snd_nxt
533: * when filling in ti_seq. But if we are in persist
534: * state, snd_max might reflect one byte beyond the
535: * right edge of the window, so use snd_nxt in that
536: * case, since we know we aren't doing a retransmission.
537: * (retransmit and persist are mutually exclusive...)
538: */
539: if (len || (flags & (TH_SYN|TH_FIN)) || tp->t_timer[TCPT_PERSIST])
540: ti->ti_seq = htonl(tp->snd_nxt);
541: else
542: ti->ti_seq = htonl(tp->snd_max);
543: ti->ti_ack = htonl(tp->rcv_nxt);
544: if (optlen) {
545: bcopy((caddr_t)opt, (caddr_t)(ti + 1), optlen);
546: ti->ti_off = (sizeof (struct tcphdr) + optlen) >> 2;
547: }
548: ti->ti_flags = flags;
549: /*
550: * Calculate receive window. Don't shrink window,
551: * but avoid silly window syndrome.
552: */
553: if (win < (long)(so->so_rcv.sb_hiwat / 4) && win < (long)tp->t_maxseg)
554: win = 0;
555: if (win > (long)TCP_MAXWIN << tp->rcv_scale)
556: win = (long)TCP_MAXWIN << tp->rcv_scale;
557: if (win < (long)(tp->rcv_adv - tp->rcv_nxt))
558: win = (long)(tp->rcv_adv - tp->rcv_nxt);
559: ti->ti_win = htons((u_short) (win>>tp->rcv_scale));
560: if (SEQ_GT(tp->snd_up, tp->snd_nxt)) {
561: ti->ti_urp = htons((u_short)(tp->snd_up - tp->snd_nxt));
562: ti->ti_flags |= TH_URG;
563: } else
564: /*
565: * If no urgent pointer to send, then we pull
566: * the urgent pointer to the left edge of the send window
567: * so that it doesn't drift into the send window on sequence
568: * number wraparound.
569: */
570: tp->snd_up = tp->snd_una; /* drag it along */
571:
572: /*
573: * Put TCP length in extended header, and then
574: * checksum extended header and data.
575: */
576: if (len + optlen)
577: ti->ti_len = htons((u_short)(sizeof (struct tcphdr) +
578: optlen + len));
579: ti->ti_sum = in_cksum(m, (int)(hdrlen + len));
580:
581: /*
582: * In transmit state, time the transmission and arrange for
583: * the retransmit. In persist state, just set snd_max.
584: */
585: if (tp->t_force == 0 || tp->t_timer[TCPT_PERSIST] == 0) {
586: tcp_seq startseq = tp->snd_nxt;
587:
588: /*
589: * Advance snd_nxt over sequence space of this segment.
590: */
591: if (flags & (TH_SYN|TH_FIN)) {
592: if (flags & TH_SYN)
593: tp->snd_nxt++;
594: if (flags & TH_FIN) {
595: tp->snd_nxt++;
596: tp->t_flags |= TF_SENTFIN;
597: }
598: }
599: tp->snd_nxt += len;
600: if (SEQ_GT(tp->snd_nxt, tp->snd_max)) {
601: tp->snd_max = tp->snd_nxt;
602: /*
603: * Time this transmission if not a retransmission and
604: * not currently timing anything.
605: */
606: if (tp->t_rtt == 0) {
607: tp->t_rtt = 1;
608: tp->t_rtseq = startseq;
609: tcpstat.tcps_segstimed++;
610: }
611: }
612:
613: /*
614: * Set retransmit timer if not currently set,
615: * and not doing an ack or a keep-alive probe.
616: * Initial value for retransmit timer is smoothed
617: * round-trip time + 2 * round-trip time variance.
618: * Initialize shift counter which is used for backoff
619: * of retransmit time.
620: */
621: if (tp->t_timer[TCPT_REXMT] == 0 &&
622: tp->snd_nxt != tp->snd_una) {
623: tp->t_timer[TCPT_REXMT] = tp->t_rxtcur;
624: if (tp->t_timer[TCPT_PERSIST]) {
625: tp->t_timer[TCPT_PERSIST] = 0;
626: tp->t_rxtshift = 0;
627: }
628: }
629: } else
630: if (SEQ_GT(tp->snd_nxt + len, tp->snd_max))
631: tp->snd_max = tp->snd_nxt + len;
632:
633: /*
634: * Trace.
635: */
636: if (so->so_options & SO_DEBUG)
637: tcp_trace(TA_OUTPUT, tp->t_state, tp, ti, 0);
638:
639: /*
640: * Fill in IP length and desired time to live and
641: * send to IP level. There should be a better way
642: * to handle ttl and tos; we could keep them in
643: * the template, but need a way to checksum without them.
644: */
645: m->m_pkthdr.len = hdrlen + len;
646: #if TUBA
647: if (tp->t_tuba_pcb)
648: error = tuba_output(m, tp);
649: else
650: #endif
651: {
652: ((struct ip *)ti)->ip_len = m->m_pkthdr.len;
653: ((struct ip *)ti)->ip_ttl = tp->t_inpcb->inp_ip.ip_ttl; /* XXX */
654: ((struct ip *)ti)->ip_tos = tp->t_inpcb->inp_ip.ip_tos; /* XXX */
655:
656: KERNEL_DEBUG(DBG_LAYER_END, ((ti->ti_dport << 16) | ti->ti_sport),
657: (((ti->ti_src.s_addr & 0xffff) << 16) | (ti->ti_dst.s_addr & 0xffff)),
658: ti->ti_seq, ti->ti_ack, ti->ti_win);
659:
660: #if BSD >= 43
661: error = ip_output(m, tp->t_inpcb->inp_options, &tp->t_inpcb->inp_route,
662: so->so_options & SO_DONTROUTE, 0);
663: #else
664: error = ip_output(m, (struct mbuf *)0, &tp->t_inpcb->inp_route,
665: so->so_options & SO_DONTROUTE);
666: #endif
667: }
668: if (error) {
669: out:
670: if (error == ENOBUFS) {
671: tcp_quench(tp->t_inpcb, 0);
672: KERNEL_DEBUG(DBG_FNC_TCP_OUTPUT | DBG_FUNC_END, 0,0,0,0,0);
673: return (0);
674: }
675: if ((error == EHOSTUNREACH || error == ENETDOWN)
676: && TCPS_HAVERCVDSYN(tp->t_state)) {
677: tp->t_softerror = error;
678: KERNEL_DEBUG(DBG_FNC_TCP_OUTPUT | DBG_FUNC_END, 0,0,0,0,0);
679: return (0);
680: }
681: KERNEL_DEBUG(DBG_FNC_TCP_OUTPUT | DBG_FUNC_END, error,0,0,0,0);
682: return (error);
683: }
684: tcpstat.tcps_sndtotal++;
685:
686: /*
687: * Data sent (as far as we can tell).
688: * If this advertises a larger window than any other segment,
689: * then remember the size of the advertised window.
690: * Any pending ACK has now been sent.
691: */
692: if (win > 0 && SEQ_GT(tp->rcv_nxt+win, tp->rcv_adv))
693: tp->rcv_adv = tp->rcv_nxt + win;
694: tp->last_ack_sent = tp->rcv_nxt;
695: tp->t_flags &= ~(TF_ACKNOW|TF_DELACK);
696: if (sendalot)
697: goto again;
698:
699: KERNEL_DEBUG(DBG_FNC_TCP_OUTPUT | DBG_FUNC_END, 0,0,0,0,0);
700: return (0);
701: }
702:
703: void
704: tcp_setpersist(tp)
705: register struct tcpcb *tp;
706: {
707: register t = ((tp->t_srtt >> 2) + tp->t_rttvar) >> 1;
708:
709: if (tp->t_timer[TCPT_REXMT])
710: panic("tcp_output REXMT");
711: /*
712: * Start/restart persistance timer.
713: */
714: TCPT_RANGESET(tp->t_timer[TCPT_PERSIST],
715: t * tcp_backoff[tp->t_rxtshift],
716: TCPTV_PERSMIN, TCPTV_PERSMAX);
717: if (tp->t_rxtshift < TCP_MAXRXTSHIFT)
718: tp->t_rxtshift++;
719: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.