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