开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > VxWorks > 查看源码
tcp_output.c
资源名称：vxwork_src.rar　[点击查看]
上传用户：nvosite88
上传日期：2007-01-17
资源大小：4983k
文件大小：23k
源码类别：

VxWorks

开发平台：

C/C++

tcp_output.c：源码内容
  1. /* tcp_output.c - TCP output routines */
  3. /* Copyright 1984 - 2002 Wind River Systems, Inc. */
  4. #include "copyright_wrs.h"
  6. /*
  7.  * Copyright (c) 1982, 1986, 1988, 1990, 1993, 1995
  8.  * The Regents of the University of California.  All rights reserved.
  9.  *
  10.  * Redistribution and use in source and binary forms, with or without
  11.  * modification, are permitted provided that the following conditions
  12.  * are met:
  13.  * 1. Redistributions of source code must retain the above copyright
  14.  *    notice, this list of conditions and the following disclaimer.
  15.  * 2. Redistributions in binary form must reproduce the above copyright
  16.  *    notice, this list of conditions and the following disclaimer in the
  17.  *    documentation and/or other materials provided with the distribution.
  18.  * 3. All advertising materials mentioning features or use of this software
  19.  *    must display the following acknowledgement:
  20.  * This product includes software developed by the University of
  21.  * California, Berkeley and its contributors.
  22.  * 4. Neither the name of the University nor the names of its contributors
  23.  *    may be used to endorse or promote products derived from this software
  24.  *    without specific prior written permission.
  25.  *
  26.  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  27.  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  28.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  29.  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  30.  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  31.  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  32.  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  33.  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  34.  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  35.  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  36.  * SUCH DAMAGE.
  37.  *
  38.  * @(#)tcp_output.c 8.4 (Berkeley) 5/24/95
  39.  */
  41. /*
  42. modification history
  43. --------------------
  44. 01g,05jun02,vvv  reworked previous change to fix performance degradation
  45. 01f,06mar02,vvv  fixed Nagle algorithm to handle large writes correctly
  46.  (SPR #72213)
  47. 01e,12oct01,rae  merge from truestack ver 01g, base 01d
  48. 01d,16mar99,spm  recovered orphaned code from tor2_0_x branch (SPR #25770)
  49. 01c,10dec98,n_s  fixed state machine update for ENOBUFs error. spr 23316
  50. 01b,22nov96,vin  added cluster support replaced m_gethdr(..) with 
  51.  mHdrClGet(..).
  52. 01a,03mar96,vin  created from BSD4.4lite2. Integrated with 02n of tcp_output.c
  53. */
  55. /*
  56. DESCRIPTION
  57. */
  59. #include "vxWorks.h"
  60. #include "net/mbuf.h"
  61. #include "net/protosw.h"
  62. #include "sys/socket.h"
  63. #include "net/socketvar.h"
  64. #include "errno.h"
  66. #include "net/route.h"
  68. #include "netinet/in.h"
  69. #include "netinet/in_pcb.h"
  70. #include "netinet/in_systm.h"
  71. #include "netinet/ip.h"
  72. #include "netinet/ip_var.h"
  73. #include "netinet/tcp.h"
  74. #define TCPOUTFLAGS
  75. #include "netinet/tcp_fsm.h"
  76. #include "netinet/tcp_seq.h"
  77. #include "netinet/tcp_timer.h"
  78. #include "netinet/tcp_var.h"
  79. #include "netinet/tcpip.h"
  80. #include "net/systm.h"
  81. #ifdef BSDDEBUG
  82. #include "netinet/tcp_debug.h"
  83. #endif /* BSDDEBUG */
  85. #ifdef WV_INSTRUMENTATION
  86. #ifdef INCLUDE_WVNET
  87. #include "wvNetLib.h"
  88. #endif
  89. #endif
  91. #ifdef notyet
  92. extern struct mbuf *m_copypack();
  93. #endif
  95. #ifdef VIRTUAL_STACK
  96. #include "netinet/vsLib.h"
  97. #endif
  99. #ifdef WV_INSTRUMENTATION
  100. #ifdef INCLUDE_WVNET
  101.     /* Set common fields of event identifiers for this module. */
  103. LOCAL UCHAR wvNetModuleId = WV_NET_TCPOUT_MODULE; /* Value for tcp_output.c */
  104. LOCAL UCHAR wvNetLocalFilter = WV_NET_NONE;     /* Available event filter */
  106. LOCAL ULONG wvNetEventId;       /* Event identifier: see wvNetLib.h */
  107. #endif    /* INCLUDE_WVNET */
  108. #endif
  110. #define MAX_TCPOPTLEN 32 /* max # bytes that go in options */
  112. /*
  113.  * Tcp output routine: figure out what should be sent and send it.
  114.  */
  115. int
  116. tcp_output(tp)
  117. register struct tcpcb *tp;
  118. {
  119. register struct socket *so = tp->t_inpcb->inp_socket;
  120.         struct rtentry *rt;
  121. register long len, win;
  122. int off, flags, error;
  123. register struct mbuf *m;
  124. register struct tcpiphdr *ti;
  125. u_char opt[MAX_TCPOPTLEN];
  126. unsigned optlen, hdrlen;
  127. int idle, sendalot, sndBufLen;
  129. BOOL     pktSent = FALSE;   /* TRUE if a packet has been sent to IP */
  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;
  146. sndBufLen = so->so_snd.sb_cc;  /* number of bytes in socket buffer */
  147. again:
  148. sendalot = 0;
  149. off = tp->snd_nxt - tp->snd_una;
  150. win = min(tp->snd_wnd, tp->snd_cwnd);
  152. flags = tcp_outflags[tp->t_state];
  153. /*
  154.  * If in persist timeout with window of 0, send 1 byte.
  155.  * Otherwise, if window is small but nonzero
  156.  * and timer expired, we will send what we can
  157.  * and go to transmit state.
  158.  */
  159. if (tp->t_force) {
  160. if (win == 0) {
  161. /*
  162.  * If we still have some data to send, then
  163.  * clear the FIN bit.  Usually this would
  164.  * happen below when it realizes that we
  165.  * aren't sending all the data.  However,
  166.  * if we have exactly 1 byte of unset data,
  167.  * then it won't clear the FIN bit below,
  168.  * and if we are in persist state, we wind
  169.  * up sending the packet without recording
  170.  * that we sent the FIN bit.
  171.  *
  172.  * We can't just blindly clear the FIN bit,
  173.  * because if we don't have any more data
  174.  * to send then the probe will be the FIN
  175.  * itself.
  176.  */
  177. if (off < so->so_snd.sb_cc)
  178. flags &= ~TH_FIN;
  179. win = 1;
  180. } else {
  181. tp->t_timer[TCPT_PERSIST] = 0;
  182. tp->t_rxtshift = 0;
  183. }
  184. }
  186. len = min(so->so_snd.sb_cc, win) - off;
  188. if (len < 0) {
  189. /*
  190.  * If FIN has been sent but not acked,
  191.  * but we haven't been called to retransmit,
  192.  * len will be -1.  Otherwise, window shrank
  193.  * after we sent into it.  If window shrank to 0,
  194.  * cancel pending retransmit and pull snd_nxt
  195.  * back to (closed) window.  We will enter persist
  196.  * state below.  If the window didn't close completely,
  197.  * just wait for an ACK.
  198.  */
  199. len = 0;
  200. if (win == 0) {
  201. tp->t_timer[TCPT_REXMT] = 0;
  202. tp->snd_nxt = tp->snd_una;
  203. }
  204. }
  205. if (len > tp->t_maxseg) {
  206. len = tp->t_maxseg;
  207. sendalot = 1;
  208. }
  209. if (SEQ_LT(tp->snd_nxt + len, tp->snd_una + so->so_snd.sb_cc))
  210. flags &= ~TH_FIN;
  212. win = sbspace(&so->so_rcv);
  214. /*
  215.  * Sender silly window avoidance.  If connection is idle
  216.  * and can send all data, a maximum segment,
  217.  * at least a maximum default-size segment do it,
  218.  * or are forced, do it; otherwise don't bother.
  219.  * If peer's buffer is tiny, then send
  220.  * when window is at least half open.
  221.  * If retransmitting (possibly after persist timer forced us
  222.  * to send into a small window), then must resend.
  223.  */
  224. if (len) {
  225. if (len == tp->t_maxseg)
  226. goto send;
  228. /*
  229.  * Modification to Nagle check - TF_EOB indicates if there
  230.  * is data in the output buffer which is the last part
  231.  * of a large write. Such data should be sent out 
  232.  * immediately even if it results in a small segment.
  233.  * (SPR #72213).
  234.  */
  236. if ((idle || tp->t_flags & TF_NODELAY ||
  237.      (tp->t_flags & TF_EOB)) &&
  238.     len + off >= so->so_snd.sb_cc)
  239.         goto send;
  241. if (tp->t_force)
  242. goto send;
  243. if (len >= tp->max_sndwnd / 2)
  244. goto send;
  245. if (SEQ_LT(tp->snd_nxt, tp->snd_max))
  246. goto send;
  247. }
  249. /*
  250.  * Compare available window to amount of window
  251.  * known to peer (as advertised window less
  252.  * next expected input).  If the difference is at least two
  253.  * max size segments, or at least 50% of the maximum possible
  254.  * window, then want to send a window update to peer.
  255.  */
  256. if (win > 0) {
  257. /* 
  258.  * "adv" is the amount we can increase the window,
  259.  * taking into account that we are limited by
  260.  * TCP_MAXWIN << tp->rcv_scale.
  261.  */
  262. long adv = min(win, (long)TCP_MAXWIN << tp->rcv_scale) -
  263. (tp->rcv_adv - tp->rcv_nxt);
  265. if (adv >= (long) (2 * tp->t_maxseg))
  266. goto send;
  267. if (2 * adv >= (long) so->so_rcv.sb_hiwat)
  268. goto send;
  269. }
  271. /*
  272.  * Send if we owe peer an ACK.
  273.  */
  274. if (tp->t_flags & TF_ACKNOW)
  275. goto send;
  276. if (flags & (TH_SYN|TH_RST))
  277. goto send;
  278. if (SEQ_GT(tp->snd_up, tp->snd_una))
  279. goto send;
  280. /*
  281.  * If our state indicates that FIN should be sent
  282.  * and we have not yet done so, or we're retransmitting the FIN,
  283.  * then we need to send.
  284.  */
  285. if (flags & TH_FIN &&
  286.     ((tp->t_flags & TF_SENTFIN) == 0 || tp->snd_nxt == tp->snd_una))
  287. goto send;
  289. /*
  290.  * TCP window updates are not reliable, rather a polling protocol
  291.  * using ``persist'' packets is used to insure receipt of window
  292.  * updates.  The three ``states'' for the output side are:
  293.  * idle not doing retransmits or persists
  294.  * persisting to move a small or zero window
  295.  * (re)transmitting and thereby not persisting
  296.  *
  297.  * tp->t_timer[TCPT_PERSIST]
  298.  * is set when we are in persist state.
  299.  * tp->t_force
  300.  * is set when we are called to send a persist packet.
  301.  * tp->t_timer[TCPT_REXMT]
  302.  * is set when we are retransmitting
  303.  * The output side is idle when both timers are zero.
  304.  *
  305.  * If send window is too small, there is data to transmit, and no
  306.  * retransmit or persist is pending, then go to persist state.
  307.  * If nothing happens soon, send when timer expires:
  308.  * if window is nonzero, transmit what we can,
  309.  * otherwise force out a byte.
  310.  */
  311. if (so->so_snd.sb_cc && tp->t_timer[TCPT_REXMT] == 0 &&
  312.     tp->t_timer[TCPT_PERSIST] == 0) {
  313. tp->t_rxtshift = 0;
  314. tcp_setpersist(tp);
  315. }
  317. /*
  318.  * No reason to send a segment, just return.
  319.  */
  320. return (0);
  322. send:
  323. /*
  324.  * Before ESTABLISHED, force sending of initial options
  325.  * unless TCP set not to do any options.
  326.  * NOTE: we assume that the IP/TCP header plus TCP options
  327.  * always fit in a single mbuf, leaving room for a maximum
  328.  * link header, i.e.
  329.  * max_linkhdr + sizeof (struct tcpiphdr) + optlen <= MHLEN
  330.  */
  331. optlen = 0;
  332. hdrlen = sizeof (struct tcpiphdr);
  333. if (flags & TH_SYN) {
  334. tp->snd_nxt = tp->iss;
  335. if ((tp->t_flags & TF_NOOPT) == 0) {
  336. u_short mss;
  338. opt[0] = TCPOPT_MAXSEG;
  339. opt[1] = 4;
  340. mss = htons((u_short) tcp_mss(tp, 0));
  341. bcopy((caddr_t)&mss, (caddr_t)(opt + 2), sizeof(mss));
  342. optlen = 4;
  343.  
  344. if ((tp->t_flags & TF_REQ_SCALE) &&
  345.     ((flags & TH_ACK) == 0 ||
  346.     (tp->t_flags & TF_RCVD_SCALE))) {
  347. *((u_long *) (opt + optlen)) = htonl(
  348. TCPOPT_NOP << 24 |
  349. TCPOPT_WINDOW << 16 |
  350. TCPOLEN_WINDOW << 8 |
  351. tp->request_r_scale);
  352. optlen += 4;
  353. }
  354. }
  355.   }
  356.  
  357.   /*
  358.  * Send a timestamp and echo-reply if this is a SYN and our side 
  359.  * wants to use timestamps (TF_REQ_TSTMP is set) or both our side
  360.  * and our peer have sent timestamps in our SYN's.
  361.    */
  362.   if ((tp->t_flags & (TF_REQ_TSTMP|TF_NOOPT)) == TF_REQ_TSTMP &&
  363.        (flags & TH_RST) == 0 &&
  364.       ((flags & (TH_SYN|TH_ACK)) == TH_SYN ||
  365.      (tp->t_flags & TF_RCVD_TSTMP))) {
  366. u_long *lp = (u_long *)(opt + optlen);
  367.  
  368.   /* Form timestamp option as shown in appendix A of RFC 1323. */
  369.   *lp++ = htonl(TCPOPT_TSTAMP_HDR);
  370.   *lp++ = htonl(tcp_now);
  371.   *lp   = htonl(tp->ts_recent);
  372.   optlen += TCPOLEN_TSTAMP_APPA;
  373.   }
  375.   hdrlen += optlen;
  376.  
  377. /*
  378.  * Adjust data length if insertion of options will
  379.  * bump the packet length beyond the t_maxseg length.
  380.  */
  381. if (len > tp->t_maxseg - optlen) {
  382. len = tp->t_maxseg - optlen;
  383. sendalot = 1;
  384. flags &= ~TH_FIN;
  385.  }
  387. #ifdef DIAGNOSTIC
  388.   if (max_linkhdr + hdrlen > CL_SIZE_128)
  389.             {
  390. #ifdef WV_INSTRUMENTATION
  391. #ifdef INCLUDE_WVNET    /* WV_NET_EMERGENCY event */
  392.         WV_NET_PORTOUT_EVENT_1 (NET_CORE_EVENT, WV_NET_EMERGENCY, 28, 1,
  393.                                 tp->t_inpcb->inp_lport, tp->t_inpcb->inp_fport, 
  394.                                 WV_NETEVENT_TCPOUT_HDRPANIC, WV_NET_SEND,
  395.                                 so->so_fd)
  396. #endif  /* INCLUDE_WVNET */
  397. #endif
  399.             panic("tcphdr too big");
  400.             }
  401. #endif
  403. /*
  404.  * Grab a header mbuf, attaching a copy of data to
  405.  * be transmitted, and initialize the header from
  406.  * the template for sends on this connection.
  407.  */
  408. if (len) {
  409. if (tp->t_force && len == 1)
  410. tcpstat.tcps_sndprobe++;
  411. else if (SEQ_LT(tp->snd_nxt, tp->snd_max)) {
  412. tcpstat.tcps_sndrexmitpack++;
  413. tcpstat.tcps_sndrexmitbyte += len;
  414. } else {
  415. tcpstat.tcps_sndpack++;
  416. tcpstat.tcps_sndbyte += len;
  417. }
  418. #ifdef notyet
  419. if ((m = m_copypack(so->so_snd.sb_mb, off,
  420.     (int)len, max_linkhdr + hdrlen)) == 0) {
  421. error = ENOBUFS;
  422. goto out;
  423. }
  424. /*
  425.  * m_copypack left space for our hdr; use it.
  426.  */
  427. m->m_len += hdrlen;
  428. m->m_data -= hdrlen;
  429. #else
  430. /* allocates a small enough cluster for the header */
  431. m = mHdrClGet(M_DONTWAIT, MT_HEADER, (max_linkhdr + hdrlen),
  432.       TRUE);
  433. if (m == NULL) {
  434. error = ENOBUFS;
  435. goto out;
  436. }
  437. m->m_data += max_linkhdr;
  438. m->m_len  = hdrlen;
  439. m->m_next = m_copy(so->so_snd.sb_mb, off, (int) len);
  440. if (m->m_next == 0) {
  441. (void) m_free(m);
  442. error = ENOBUFS;
  443. goto out;
  444. }
  445. #endif
  446. /*
  447.  * If we're sending everything we've got, set PUSH.
  448.  * (This will keep happy those implementations which only
  449.  * give data to the user when a buffer fills or
  450.  * a PUSH comes in.)
  451.  */
  452. if (off + len == so->so_snd.sb_cc)
  453. flags |= TH_PUSH;
  454. } else {
  455. if (tp->t_flags & TF_ACKNOW)
  456. tcpstat.tcps_sndacks++;
  457. else if (flags & (TH_SYN|TH_FIN|TH_RST))
  458. tcpstat.tcps_sndctrl++;
  459. else if (SEQ_GT(tp->snd_up, tp->snd_una))
  460. tcpstat.tcps_sndurg++;
  461. else
  462. tcpstat.tcps_sndwinup++;
  464. /* allocates a small enough cluster for the header */
  465. m = mHdrClGet(M_DONTWAIT, MT_HEADER, (max_linkhdr + hdrlen),
  466.       TRUE);
  468. if (m == NULL) {
  469. error = ENOBUFS;
  470. goto out;
  471. }
  472. m->m_data += max_linkhdr;
  473. m->m_len = hdrlen;
  474. }
  475. m->m_pkthdr.rcvif = (struct ifnet *)0;
  476. ti = mtod(m, struct tcpiphdr *);
  477. if (tp->t_template == 0)
  478.             {
  479. #ifdef WV_INSTRUMENTATION
  480. #ifdef INCLUDE_WVNET    /* WV_NET_EMERGENCY event */
  481.         WV_NET_PORTOUT_EVENT_1 (NET_CORE_EVENT, WV_NET_EMERGENCY, 29, 2,
  482.                                 tp->t_inpcb->inp_lport, tp->t_inpcb->inp_fport,
  483.                                 WV_NETEVENT_TCPOUT_PANIC, WV_NET_SEND,
  484.                                 so->so_fd)
  485. #endif  /* INCLUDE_WVNET */
  486. #endif
  488.             panic("tcp_output");
  489.             }
  491. bcopy((caddr_t)mtod(tp->t_template, struct tcpiphdr *), (caddr_t)ti, 
  492.       sizeof (struct tcpiphdr));
  494. /*
  495.  * Fill in fields, remembering maximum advertised
  496.  * window for use in delaying messages about window sizes.
  497.  * If resending a FIN, be sure not to use a new sequence number.
  498.  */
  499. if (flags & TH_FIN && tp->t_flags & TF_SENTFIN && 
  500.     tp->snd_nxt == tp->snd_max)
  501. tp->snd_nxt--;
  502. /*
  503.  * If we are doing retransmissions, then snd_nxt will
  504.  * not reflect the first unsent octet.  For ACK only
  505.  * packets, we do not want the sequence number of the
  506.  * retransmitted packet, we want the sequence number
  507.  * of the next unsent octet.  So, if there is no data
  508.  * (and no SYN or FIN), use snd_max instead of snd_nxt
  509.  * when filling in ti_seq.  But if we are in persist
  510.  * state, snd_max might reflect one byte beyond the
  511.  * right edge of the window, so use snd_nxt in that
  512.  * case, since we know we aren't doing a retransmission.
  513.  * (retransmit and persist are mutually exclusive...)
  514.  */
  515. if (len || (flags & (TH_SYN|TH_FIN)) || tp->t_timer[TCPT_PERSIST])
  516. ti->ti_seq = htonl(tp->snd_nxt);
  517. else
  518. ti->ti_seq = htonl(tp->snd_max);
  519. ti->ti_ack = htonl(tp->rcv_nxt);
  520. if (optlen) {
  521. bcopy((caddr_t)opt, (caddr_t)(ti + 1), optlen);
  522. ti->ti_off = (sizeof (struct tcphdr) + optlen) >> 2;
  523. }
  524. ti->ti_flags = flags;
  525. /*
  526.  * Calculate receive window.  Don't shrink window,
  527.  * but avoid silly window syndrome.
  528.  */
  529. if (win < (long)(so->so_rcv.sb_hiwat / 4) && win < (long)tp->t_maxseg)
  530. win = 0;
  531. if (win > (long)TCP_MAXWIN << tp->rcv_scale)
  532. win = (long)TCP_MAXWIN << tp->rcv_scale;
  533. if (win < (long)(tp->rcv_adv - tp->rcv_nxt))
  534. win = (long)(tp->rcv_adv - tp->rcv_nxt);
  535. ti->ti_win = htons((u_short) (win>>tp->rcv_scale));
  536. if (SEQ_GT(tp->snd_up, tp->snd_nxt)) {
  537. ti->ti_urp = htons((u_short)(tp->snd_up - tp->snd_nxt));
  538. ti->ti_flags |= TH_URG;
  539. } else
  540. /*
  541.  * If no urgent pointer to send, then we pull
  542.  * the urgent pointer to the left edge of the send window
  543.  * so that it doesn't drift into the send window on sequence
  544.  * number wraparound.
  545.  */
  546. tp->snd_up = tp->snd_una; /* drag it along */
  548. /*
  549.  * Put TCP length in extended header, and then
  550.  * checksum extended header and data.
  551.  */
  552. if (len + optlen)
  553. ti->ti_len = htons((u_short)(sizeof (struct tcphdr) +
  554.     optlen + len));
  555. ti->ti_sum = in_cksum(m, (int)(hdrlen + len));
  557. /*
  558.  * In transmit state, time the transmission and arrange for
  559.  * the retransmit.  In persist state, just set snd_max.
  560.  */
  561. if (tp->t_force == 0 || tp->t_timer[TCPT_PERSIST] == 0) {
  562. tcp_seq startseq = tp->snd_nxt;
  564. /*
  565.  * Advance snd_nxt over sequence space of this segment.
  566.  */
  567. if (flags & (TH_SYN|TH_FIN)) {
  568. if (flags & TH_SYN)
  569. tp->snd_nxt++;
  570. if (flags & TH_FIN) {
  571. tp->snd_nxt++;
  572. tp->t_flags |= TF_SENTFIN;
  573. }
  574. }
  575. tp->snd_nxt += len;
  576. if (SEQ_GT(tp->snd_nxt, tp->snd_max)) {
  577. tp->snd_max = tp->snd_nxt;
  578. /*
  579.  * Time this transmission if not a retransmission and
  580.  * not currently timing anything.
  581.  */
  582. if (tp->t_rtt == 0) {
  583. tp->t_rtt = 1;
  584. tp->t_rtseq = startseq;
  585. tcpstat.tcps_segstimed++;
  586. }
  587. }
  589. /*
  590.  * Set retransmit timer if not currently set,
  591.  * and not doing an ack or a keep-alive probe.
  592.  * Initial value for retransmit timer is smoothed
  593.  * round-trip time + 2 * round-trip time variance.
  594.  * Initialize shift counter which is used for backoff
  595.  * of retransmit time.
  596.  */
  597. if (tp->t_timer[TCPT_REXMT] == 0 &&
  598.     tp->snd_nxt != tp->snd_una) {
  599. tp->t_timer[TCPT_REXMT] = tp->t_rxtcur;
  600. if (tp->t_timer[TCPT_PERSIST]) {
  601. tp->t_timer[TCPT_PERSIST] = 0;
  602. tp->t_rxtshift = 0;
  603. }
  604. }
  605. } else
  606. if (SEQ_GT(tp->snd_nxt + len, tp->snd_max))
  607. tp->snd_max = tp->snd_nxt + len;
  609. /*
  610.  * Trace.
  611.  */
  612. #ifdef BSDDEBUG
  613. if (so->so_options & SO_DEBUG)
  614. (*tcpTraceRtn)(TA_OUTPUT, tp->t_state, tp, ti, 0);
  615. #endif /* BSDDEBUG */
  617. /*
  618.  * Fill in IP length and desired time to live and
  619.  * send to IP level.  There should be a better way
  620.  * to handle ttl and tos; we could keep them in
  621.  * the template, but need a way to checksum without them.
  622.  */
  623. m->m_pkthdr.len = hdrlen + len;
  625. ((struct ip *)ti)->ip_len = m->m_pkthdr.len;
  626. ((struct ip *)ti)->ip_ttl = tp->t_inpcb->inp_ip.ip_ttl; /* XXX */
  627. ((struct ip *)ti)->ip_tos = tp->t_inpcb->inp_ip.ip_tos; /* XXX */
  629.         /*
  630.          * Prevent fragmentation to continue (or trigger) path MTU discovery
  631.          * if the required route and path MTU estimate are available and path
  632.          * MTU discovery is enabled for this socket. (TCP sockets enable MTU
  633.          * discovery by default).
  634.          */
  636.         rt = tp->t_inpcb->inp_route.ro_rt;
  637.         if (rt && (rt->rt_flags & RTF_UP) && !(rt->rt_rmx.rmx_locks & RTV_MTU))
  638.             {
  639.             if (tp->t_inpcb->inp_socket->so_options & SO_USEPATHMTU)
  640.                 ( (struct ip *)ti)->ip_off |= IP_DF;
  641.             }
  643. #if BSD >= 43
  644. error = ip_output(m, tp->t_inpcb->inp_options, &tp->t_inpcb->inp_route,
  645.     so->so_options & SO_DONTROUTE, 0);
  646. #else
  647. error = ip_output(m, (struct mbuf *)0, &tp->t_inpcb->inp_route, 
  648.     so->so_options & SO_DONTROUTE);
  649. #endif
  650. pktSent = TRUE;
  652. #ifdef WV_INSTRUMENTATION
  653. #ifdef INCLUDE_WVNET    /* WV_NET_NOTICE event */
  654.     WV_NET_PORTOUT_EVENT_2 (NET_CORE_EVENT, WV_NET_NOTICE, 19, 3,
  655.                             tp->t_inpcb->inp_lport, tp->t_inpcb->inp_fport,
  656.                             WV_NETEVENT_TCPOUT_FINISH, WV_NET_SEND,
  657.                             so->so_fd, error)
  658. #endif  /* INCLUDE_WVNET */
  659. #endif
  661. if (error) 
  662.     {
  663. out:
  664.     /* 
  665.      * State machine needs to be updated even if packet was not sent 
  666.      * due to errors.
  667.      */
  669.     if (! pktSent)
  670. {
  671. if (! SEQ_GT(tp->snd_up, tp->snd_nxt)) 
  672.     {
  673.     /*
  674.      * If no urgent pointer to send, then we pull
  675.      * the urgent pointer to the left edge of the send window
  676.      * so that it doesn't drift into the send window on 
  677.      * sequence number wraparound.
  678.      */
  680.     tp->snd_up = tp->snd_una; /* drag it along */
  681.     }
  683. /*
  684.  * In transmit state, time the transmission and arrange for
  685.  * the retransmit.  In persist state, just set snd_max.
  686.  */
  687. if (tp->t_force == 0 || tp->t_timer[TCPT_PERSIST] == 0) 
  688.     {
  689.     tcp_seq startseq = tp->snd_nxt;
  690.     
  691.     /*
  692.      * Advance snd_nxt over sequence space of this segment.
  693.      */
  694.     if (flags & (TH_SYN|TH_FIN)) 
  695. {
  696. if (flags & TH_SYN)
  697.     tp->snd_nxt++;
  698. if (flags & TH_FIN) 
  699.     {
  700.     tp->snd_nxt++;
  701.     tp->t_flags |= TF_SENTFIN;
  702.     }
  703. }
  704.     tp->snd_nxt += len;
  705.     if (SEQ_GT(tp->snd_nxt, tp->snd_max)) 
  706. {
  707. tp->snd_max = tp->snd_nxt;
  708. /*
  709.  * Time this transmission if not a retransmission and
  710.  * not currently timing anything.
  711.  */
  712. if (tp->t_rtt == 0) 
  713.     {
  714.     tp->t_rtt = 1;
  715.     tp->t_rtseq = startseq;
  716.     tcpstat.tcps_segstimed++;
  717.     }
  718. }
  719.      
  720.     /*
  721.      * Set retransmit timer if not currently set,
  722.      * and not doing an ack or a keep-alive probe.
  723.      * Initial value for retransmit timer is smoothed
  724.      * round-trip time + 2 * round-trip time variance.
  725.      * Initialize shift counter which is used for backoff
  726.      * of retransmit time.
  727.      */
  728.     if (tp->t_timer[TCPT_REXMT] == 0 &&
  729. tp->snd_nxt != tp->snd_una) 
  730. {
  731. tp->t_timer[TCPT_REXMT] = tp->t_rxtcur;
  732. if (tp->t_timer[TCPT_PERSIST]) 
  733.     {
  734.     tp->t_timer[TCPT_PERSIST] = 0;
  735.     tp->t_rxtshift = 0;
  736.     }
  737. }
  738.     } else
  739. if (SEQ_GT(tp->snd_nxt + len, tp->snd_max))
  740.     tp->snd_max = tp->snd_nxt + len;
  741. }
  743.     if (error == ENOBUFS) 
  744. {
  745. tcp_quench(tp->t_inpcb, 0);
  746. return (0);
  747. }
  749.             if (error == EMSGSIZE)
  750.                 {
  751.                 /*
  752.                  * Update the MSS to reflect the new MTU estimate.
  753.                  * Exit when complete since the tcp_updatemtu() routine
  754.                  * already triggers retransmission.
  755.                  */
  757.                  tcp_updatemtu (tp->t_inpcb, 0);
  758.                  return (0);
  759.                  }
  761.     if ((error == EHOSTUNREACH || error == ENETDOWN)
  762. && TCPS_HAVERCVDSYN(tp->t_state)) 
  763. {
  764. tp->t_softerror = error;
  765. return (0);
  766. }
  767.     return (error);
  768.     }
  769. tcpstat.tcps_sndtotal++;
  771. /*
  772.  * Data sent (as far as we can tell).
  773.  * If this advertises a larger window than any other segment,
  774.  * then remember the size of the advertised window.
  775.  * Any pending ACK has now been sent.
  776.  */
  777. if (win > 0 && SEQ_GT(tp->rcv_nxt+win, tp->rcv_adv))
  778. tp->rcv_adv = tp->rcv_nxt + win;
  779. tp->last_ack_sent = tp->rcv_nxt;
  780. tp->t_flags &= ~(TF_ACKNOW|TF_DELACK);
  781. if (sendalot)
  782. goto again;
  783. return (0);
  784. }
  786. void
  787. tcp_setpersist(tp)
  788. register struct tcpcb *tp;
  789. {
  790. register int t = ((tp->t_srtt >> 2) + tp->t_rttvar) >> 1;
  792. if (tp->t_timer[TCPT_REXMT])
  793. panic("tcp_output REXMT");
  794. /*
  795.  * Start/restart persistance timer.
  796.  */
  797. TCPT_RANGESET(tp->t_timer[TCPT_PERSIST],
  798.     t * tcp_backoff[tp->t_rxtshift],
  799.     TCPTV_PERSMIN, TCPTV_PERSMAX);
  800. if (tp->t_rxtshift < TCP_MAXRXTSHIFT)
  801. tp->t_rxtshift++;
  802. }