ViewVC Help
View File | Revision Log | Show Annotations | Revision Graph | Root Listing
root/cebix/BasiliskII/src/slirp/tcp_output.c
Revision: 1.2
Committed: 2012-03-30T01:10:28Z (12 years, 2 months ago) by asvitkine
Content type: text/plain
Branch: MAIN
CVS Tags: HEAD
Changes since 1.1: +1 -5 lines
Log Message: 
Switch slirp to 3-clause BSD license. This change went in upstream to QEMU's
version of slirp (where this code comes from), with the following checkin:

commit 2f5f89963186d42a7ded253bc6cf5b32abb45cec
Author: aliguori <aliguori@c046a42c-6fe2-441c-8c8c-71466251a162>
Date:   Mon Jan 26 19:37:41 2009 +0000

    Remove the advertising clause from the slirp license

    According to the FSF, the 4-clause BSD license, which slirp is covered under,
    is not compatible with the GPL or LGPL[1].

    [1] http://www.fsf.org/licensing/licenses/index_html#GPLIncompatibleLicenses

    There are three declared copyright holders in slirp that use the 4-clause
    BSD license, the Regents of UC Berkley, Danny Gasparovski, and Kelly Price.
    Below are the appropriate permissions to remove the advertise clause from slirp
    from each party.

    Special thanks go to Richard Fontana from Red Hat for contacting all of the
    necessary authors to resolve this issue!

    Regents of UC Berkley:
    From ftp://ftp.cs.berkeley.edu/pub/4bsd/README.Impt.License.Change

    July 22, 1999

    To All Licensees, Distributors of Any Version of BSD:

    As you know, certain of the Berkeley Software Distribution ("BSD") source
    code files require that further distributions of products containing all or
    portions of the software, acknowledge within their advertising materials
    that such products contain software developed by UC Berkeley and its
    contributors.

    Specifically, the provision reads:

    "     * 3. All advertising materials mentioning features or use of this software
          *    must display the following acknowledgement:
          *    This product includes software developed by the University of
          *    California, Berkeley and its contributors."

    Effective immediately, licensees and distributors are no longer required to
    include the acknowledgement within advertising materials.  Accordingly, the
    foregoing paragraph of those BSD Unix files containing it is hereby deleted
    in its entirety.

    William Hoskins
    Director, Office of Technology Licensing
    University of California, Berkeley

    Danny Gasparovski:

    Subject: RE: Slirp license
    Date: Thu, 8 Jan 2009 10:51:00 +1100
    From: "Gasparovski, Daniel" <Daniel.Gasparovski@ato.gov.au>
    To: "Richard Fontana" <rfontana@redhat.com>

    Hi Richard,

    I have no objection to having Slirp code in QEMU be licensed under the
    3-clause BSD license.

    Thanks for taking the effort to consult me about this.


    Dan ...

    Kelly Price:

    Date: Thu, 8 Jan 2009 19:38:56 -0500
    From: "Kelly Price" <strredwolf@gmail.com>
    To: "Richard Fontana" <rfontana@redhat.com>
    Subject: Re: Slirp license

    Thanks for contacting me, Richard.  I'm glad you were able to find
    Dan, as I've been "keeping the light on" for Slirp.  I have no use for
    it now, and I have little time for it (now holding onto Keenspot's
    Comic Genesis and having a regular US state government position). If
    Dan would like to return to the project, I'd love to give it back to
    him.

    As for copyright, I don't own all of it.  Dan does, so I will defer to
    him.  Any of my patches I will gladly license to the 3-part BSD
    license.  My interest in re-licensing was because we didn't have ready
    info to contact Dan.  If Dan would like to port Slirp back out of
    QEMU, a lot of us 64-bit users would be grateful.

    Feel free to share this email address with Dan.  I will be glad to
    effect a transfer of the project to him and Mr. Bellard of the QEMU
    project.

    Signed-off-by: Anthony Liguori <aliguori@us.ibm.com>


    git-svn-id: svn://svn.savannah.nongnu.org/qemu/trunk@6451 c046a42c-6fe2-441c-8c8c-71466251a162

File Contents

# User Rev Content
1 gbeauche 1.1 /*
2     * Copyright (c) 1982, 1986, 1988, 1990, 1993
3     * The Regents of the University of California. 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 asvitkine 1.2 * 3. Neither the name of the University nor the names of its contributors
14 gbeauche 1.1 * may be used to endorse or promote products derived from this software
15     * without specific prior written permission.
16     *
17     * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
18     * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19     * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20     * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
21     * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22     * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23     * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24     * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25     * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26     * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27     * SUCH DAMAGE.
28     *
29     * @(#)tcp_output.c 8.3 (Berkeley) 12/30/93
30     * tcp_output.c,v 1.3 1994/09/15 10:36:55 davidg Exp
31     */
32    
33     /*
34     * Changes and additions relating to SLiRP
35     * Copyright (c) 1995 Danny Gasparovski.
36     *
37     * Please read the file COPYRIGHT for the
38     * terms and conditions of the copyright.
39     */
40    
41     #include <slirp.h>
42    
43     /*
44     * Since this is only used in "stats socket", we give meaning
45     * names instead of the REAL names
46     */
47     char *tcpstates[] = {
48     /* "CLOSED", "LISTEN", "SYN_SENT", "SYN_RCVD", */
49     "REDIRECT", "LISTEN", "SYN_SENT", "SYN_RCVD",
50     "ESTABLISHED", "CLOSE_WAIT", "FIN_WAIT_1", "CLOSING",
51     "LAST_ACK", "FIN_WAIT_2", "TIME_WAIT",
52     };
53    
54     u_char tcp_outflags[TCP_NSTATES] = {
55     TH_RST|TH_ACK, 0, TH_SYN, TH_SYN|TH_ACK,
56     TH_ACK, TH_ACK, TH_FIN|TH_ACK, TH_FIN|TH_ACK,
57     TH_FIN|TH_ACK, TH_ACK, TH_ACK,
58     };
59    
60    
61     #define MAX_TCPOPTLEN 32 /* max # bytes that go in options */
62    
63     /*
64     * Tcp output routine: figure out what should be sent and send it.
65     */
66     int
67     tcp_output(tp)
68     register struct tcpcb *tp;
69     {
70     register struct socket *so = tp->t_socket;
71     register long len, win;
72     int off, flags, error;
73     register struct mbuf *m;
74     register struct tcpiphdr *ti;
75     u_char opt[MAX_TCPOPTLEN];
76     unsigned optlen, hdrlen;
77     int idle, sendalot;
78    
79     DEBUG_CALL("tcp_output");
80     DEBUG_ARG("tp = %lx", (long )tp);
81    
82     /*
83     * Determine length of data that should be transmitted,
84     * and flags that will be used.
85     * If there is some data or critical controls (SYN, RST)
86     * to send, then transmit; otherwise, investigate further.
87     */
88     idle = (tp->snd_max == tp->snd_una);
89     if (idle && tp->t_idle >= tp->t_rxtcur)
90     /*
91     * We have been idle for "a while" and no acks are
92     * expected to clock out any data we send --
93     * slow start to get ack "clock" running again.
94     */
95     tp->snd_cwnd = tp->t_maxseg;
96     again:
97     sendalot = 0;
98     off = tp->snd_nxt - tp->snd_una;
99     win = min(tp->snd_wnd, tp->snd_cwnd);
100    
101     flags = tcp_outflags[tp->t_state];
102    
103     DEBUG_MISC((dfd, " --- tcp_output flags = 0x%x\n",flags));
104    
105     /*
106     * If in persist timeout with window of 0, send 1 byte.
107     * Otherwise, if window is small but nonzero
108     * and timer expired, we will send what we can
109     * and go to transmit state.
110     */
111     if (tp->t_force) {
112     if (win == 0) {
113     /*
114     * If we still have some data to send, then
115     * clear the FIN bit. Usually this would
116     * happen below when it realizes that we
117     * aren't sending all the data. However,
118     * if we have exactly 1 byte of unset data,
119     * then it won't clear the FIN bit below,
120     * and if we are in persist state, we wind
121     * up sending the packet without recording
122     * that we sent the FIN bit.
123     *
124     * We can't just blindly clear the FIN bit,
125     * because if we don't have any more data
126     * to send then the probe will be the FIN
127     * itself.
128     */
129     if (off < so->so_snd.sb_cc)
130     flags &= ~TH_FIN;
131     win = 1;
132     } else {
133     tp->t_timer[TCPT_PERSIST] = 0;
134     tp->t_rxtshift = 0;
135     }
136     }
137    
138     len = min(so->so_snd.sb_cc, win) - off;
139    
140     if (len < 0) {
141     /*
142     * If FIN has been sent but not acked,
143     * but we haven't been called to retransmit,
144     * len will be -1. Otherwise, window shrank
145     * after we sent into it. If window shrank to 0,
146     * cancel pending retransmit and pull snd_nxt
147     * back to (closed) window. We will enter persist
148     * state below. If the window didn't close completely,
149     * just wait for an ACK.
150     */
151     len = 0;
152     if (win == 0) {
153     tp->t_timer[TCPT_REXMT] = 0;
154     tp->snd_nxt = tp->snd_una;
155     }
156     }
157    
158     if (len > tp->t_maxseg) {
159     len = tp->t_maxseg;
160     sendalot = 1;
161     }
162     if (SEQ_LT(tp->snd_nxt + len, tp->snd_una + so->so_snd.sb_cc))
163     flags &= ~TH_FIN;
164    
165     win = sbspace(&so->so_rcv);
166    
167     /*
168     * Sender silly window avoidance. If connection is idle
169     * and can send all data, a maximum segment,
170     * at least a maximum default-size segment do it,
171     * or are forced, do it; otherwise don't bother.
172     * If peer's buffer is tiny, then send
173     * when window is at least half open.
174     * If retransmitting (possibly after persist timer forced us
175     * to send into a small window), then must resend.
176     */
177     if (len) {
178     if (len == tp->t_maxseg)
179     goto send;
180     if ((1 || idle || tp->t_flags & TF_NODELAY) &&
181     len + off >= so->so_snd.sb_cc)
182     goto send;
183     if (tp->t_force)
184     goto send;
185     if (len >= tp->max_sndwnd / 2 && tp->max_sndwnd > 0)
186     goto send;
187     if (SEQ_LT(tp->snd_nxt, tp->snd_max))
188     goto send;
189     }
190    
191     /*
192     * Compare available window to amount of window
193     * known to peer (as advertised window less
194     * next expected input). If the difference is at least two
195     * max size segments, or at least 50% of the maximum possible
196     * window, then want to send a window update to peer.
197     */
198     if (win > 0) {
199     /*
200     * "adv" is the amount we can increase the window,
201     * taking into account that we are limited by
202     * TCP_MAXWIN << tp->rcv_scale.
203     */
204     long adv = min(win, (long)TCP_MAXWIN << tp->rcv_scale) -
205     (tp->rcv_adv - tp->rcv_nxt);
206    
207     if (adv >= (long) (2 * tp->t_maxseg))
208     goto send;
209     if (2 * adv >= (long) so->so_rcv.sb_datalen)
210     goto send;
211     }
212    
213     /*
214     * Send if we owe peer an ACK.
215     */
216     if (tp->t_flags & TF_ACKNOW)
217     goto send;
218     if (flags & (TH_SYN|TH_RST))
219     goto send;
220     if (SEQ_GT(tp->snd_up, tp->snd_una))
221     goto send;
222     /*
223     * If our state indicates that FIN should be sent
224     * and we have not yet done so, or we're retransmitting the FIN,
225     * then we need to send.
226     */
227     if (flags & TH_FIN &&
228     ((tp->t_flags & TF_SENTFIN) == 0 || tp->snd_nxt == tp->snd_una))
229     goto send;
230    
231     /*
232     * TCP window updates are not reliable, rather a polling protocol
233     * using ``persist'' packets is used to insure receipt of window
234     * updates. The three ``states'' for the output side are:
235     * idle not doing retransmits or persists
236     * persisting to move a small or zero window
237     * (re)transmitting and thereby not persisting
238     *
239     * tp->t_timer[TCPT_PERSIST]
240     * is set when we are in persist state.
241     * tp->t_force
242     * is set when we are called to send a persist packet.
243     * tp->t_timer[TCPT_REXMT]
244     * is set when we are retransmitting
245     * The output side is idle when both timers are zero.
246     *
247     * If send window is too small, there is data to transmit, and no
248     * retransmit or persist is pending, then go to persist state.
249     * If nothing happens soon, send when timer expires:
250     * if window is nonzero, transmit what we can,
251     * otherwise force out a byte.
252     */
253     if (so->so_snd.sb_cc && tp->t_timer[TCPT_REXMT] == 0 &&
254     tp->t_timer[TCPT_PERSIST] == 0) {
255     tp->t_rxtshift = 0;
256     tcp_setpersist(tp);
257     }
258    
259     /*
260     * No reason to send a segment, just return.
261     */
262     tcpstat.tcps_didnuttin++;
263    
264     return (0);
265    
266     send:
267     /*
268     * Before ESTABLISHED, force sending of initial options
269     * unless TCP set not to do any options.
270     * NOTE: we assume that the IP/TCP header plus TCP options
271     * always fit in a single mbuf, leaving room for a maximum
272     * link header, i.e.
273     * max_linkhdr + sizeof (struct tcpiphdr) + optlen <= MHLEN
274     */
275     optlen = 0;
276     hdrlen = sizeof (struct tcpiphdr);
277     if (flags & TH_SYN) {
278     tp->snd_nxt = tp->iss;
279     if ((tp->t_flags & TF_NOOPT) == 0) {
280     u_int16_t mss;
281    
282     opt[0] = TCPOPT_MAXSEG;
283     opt[1] = 4;
284     mss = htons((u_int16_t) tcp_mss(tp, 0));
285     memcpy((caddr_t)(opt + 2), (caddr_t)&mss, sizeof(mss));
286     optlen = 4;
287    
288     /* if ((tp->t_flags & TF_REQ_SCALE) &&
289     * ((flags & TH_ACK) == 0 ||
290     * (tp->t_flags & TF_RCVD_SCALE))) {
291     * *((u_int32_t *) (opt + optlen)) = htonl(
292     * TCPOPT_NOP << 24 |
293     * TCPOPT_WINDOW << 16 |
294     * TCPOLEN_WINDOW << 8 |
295     * tp->request_r_scale);
296     * optlen += 4;
297     * }
298     */
299     }
300     }
301    
302     /*
303     * Send a timestamp and echo-reply if this is a SYN and our side
304     * wants to use timestamps (TF_REQ_TSTMP is set) or both our side
305     * and our peer have sent timestamps in our SYN's.
306     */
307     /* if ((tp->t_flags & (TF_REQ_TSTMP|TF_NOOPT)) == TF_REQ_TSTMP &&
308     * (flags & TH_RST) == 0 &&
309     * ((flags & (TH_SYN|TH_ACK)) == TH_SYN ||
310     * (tp->t_flags & TF_RCVD_TSTMP))) {
311     * u_int32_t *lp = (u_int32_t *)(opt + optlen);
312     *
313     * / * Form timestamp option as shown in appendix A of RFC 1323. * /
314     * *lp++ = htonl(TCPOPT_TSTAMP_HDR);
315     * *lp++ = htonl(tcp_now);
316     * *lp = htonl(tp->ts_recent);
317     * optlen += TCPOLEN_TSTAMP_APPA;
318     * }
319     */
320     hdrlen += optlen;
321    
322     /*
323     * Adjust data length if insertion of options will
324     * bump the packet length beyond the t_maxseg length.
325     */
326     if (len > tp->t_maxseg - optlen) {
327     len = tp->t_maxseg - optlen;
328     sendalot = 1;
329     }
330    
331     /*
332     * Grab a header mbuf, attaching a copy of data to
333     * be transmitted, and initialize the header from
334     * the template for sends on this connection.
335     */
336     if (len) {
337     if (tp->t_force && len == 1)
338     tcpstat.tcps_sndprobe++;
339     else if (SEQ_LT(tp->snd_nxt, tp->snd_max)) {
340     tcpstat.tcps_sndrexmitpack++;
341     tcpstat.tcps_sndrexmitbyte += len;
342     } else {
343     tcpstat.tcps_sndpack++;
344     tcpstat.tcps_sndbyte += len;
345     }
346    
347     m = m_get();
348     if (m == NULL) {
349     /* error = ENOBUFS; */
350     error = 1;
351     goto out;
352     }
353     m->m_data += if_maxlinkhdr;
354     m->m_len = hdrlen;
355    
356     /*
357     * This will always succeed, since we make sure our mbufs
358     * are big enough to hold one MSS packet + header + ... etc.
359     */
360     /* if (len <= MHLEN - hdrlen - max_linkhdr) { */
361    
362     sbcopy(&so->so_snd, off, (int) len, mtod(m, caddr_t) + hdrlen);
363     m->m_len += len;
364    
365     /* } else {
366     * m->m_next = m_copy(so->so_snd.sb_mb, off, (int) len);
367     * if (m->m_next == 0)
368     * len = 0;
369     * }
370     */
371     /*
372     * If we're sending everything we've got, set PUSH.
373     * (This will keep happy those implementations which only
374     * give data to the user when a buffer fills or
375     * a PUSH comes in.)
376     */
377     if (off + len == so->so_snd.sb_cc)
378     flags |= TH_PUSH;
379     } else {
380     if (tp->t_flags & TF_ACKNOW)
381     tcpstat.tcps_sndacks++;
382     else if (flags & (TH_SYN|TH_FIN|TH_RST))
383     tcpstat.tcps_sndctrl++;
384     else if (SEQ_GT(tp->snd_up, tp->snd_una))
385     tcpstat.tcps_sndurg++;
386     else
387     tcpstat.tcps_sndwinup++;
388    
389     m = m_get();
390     if (m == NULL) {
391     /* error = ENOBUFS; */
392     error = 1;
393     goto out;
394     }
395     m->m_data += if_maxlinkhdr;
396     m->m_len = hdrlen;
397     }
398    
399     ti = mtod(m, struct tcpiphdr *);
400    
401     memcpy((caddr_t)ti, &tp->t_template, sizeof (struct tcpiphdr));
402    
403     /*
404     * Fill in fields, remembering maximum advertised
405     * window for use in delaying messages about window sizes.
406     * If resending a FIN, be sure not to use a new sequence number.
407     */
408     if (flags & TH_FIN && tp->t_flags & TF_SENTFIN &&
409     tp->snd_nxt == tp->snd_max)
410     tp->snd_nxt--;
411     /*
412     * If we are doing retransmissions, then snd_nxt will
413     * not reflect the first unsent octet. For ACK only
414     * packets, we do not want the sequence number of the
415     * retransmitted packet, we want the sequence number
416     * of the next unsent octet. So, if there is no data
417     * (and no SYN or FIN), use snd_max instead of snd_nxt
418     * when filling in ti_seq. But if we are in persist
419     * state, snd_max might reflect one byte beyond the
420     * right edge of the window, so use snd_nxt in that
421     * case, since we know we aren't doing a retransmission.
422     * (retransmit and persist are mutually exclusive...)
423     */
424     if (len || (flags & (TH_SYN|TH_FIN)) || tp->t_timer[TCPT_PERSIST])
425     ti->ti_seq = htonl(tp->snd_nxt);
426     else
427     ti->ti_seq = htonl(tp->snd_max);
428     ti->ti_ack = htonl(tp->rcv_nxt);
429     if (optlen) {
430     memcpy((caddr_t)(ti + 1), (caddr_t)opt, optlen);
431     ti->ti_off = (sizeof (struct tcphdr) + optlen) >> 2;
432     }
433     ti->ti_flags = flags;
434     /*
435     * Calculate receive window. Don't shrink window,
436     * but avoid silly window syndrome.
437     */
438     if (win < (long)(so->so_rcv.sb_datalen / 4) && win < (long)tp->t_maxseg)
439     win = 0;
440     if (win > (long)TCP_MAXWIN << tp->rcv_scale)
441     win = (long)TCP_MAXWIN << tp->rcv_scale;
442     if (win < (long)(tp->rcv_adv - tp->rcv_nxt))
443     win = (long)(tp->rcv_adv - tp->rcv_nxt);
444     ti->ti_win = htons((u_int16_t) (win>>tp->rcv_scale));
445    
446     if (SEQ_GT(tp->snd_up, tp->snd_una)) {
447     ti->ti_urp = htons((u_int16_t)(tp->snd_up - ntohl(ti->ti_seq)));
448     #ifdef notdef
449     if (SEQ_GT(tp->snd_up, tp->snd_nxt)) {
450     ti->ti_urp = htons((u_int16_t)(tp->snd_up - tp->snd_nxt));
451     #endif
452     ti->ti_flags |= TH_URG;
453     } else
454     /*
455     * If no urgent pointer to send, then we pull
456     * the urgent pointer to the left edge of the send window
457     * so that it doesn't drift into the send window on sequence
458     * number wraparound.
459     */
460     tp->snd_up = tp->snd_una; /* drag it along */
461    
462     /*
463     * Put TCP length in extended header, and then
464     * checksum extended header and data.
465     */
466     if (len + optlen)
467     ti->ti_len = htons((u_int16_t)(sizeof (struct tcphdr) +
468     optlen + len));
469     ti->ti_sum = cksum(m, (int)(hdrlen + len));
470    
471     /*
472     * In transmit state, time the transmission and arrange for
473     * the retransmit. In persist state, just set snd_max.
474     */
475     if (tp->t_force == 0 || tp->t_timer[TCPT_PERSIST] == 0) {
476     tcp_seq startseq = tp->snd_nxt;
477    
478     /*
479     * Advance snd_nxt over sequence space of this segment.
480     */
481     if (flags & (TH_SYN|TH_FIN)) {
482     if (flags & TH_SYN)
483     tp->snd_nxt++;
484     if (flags & TH_FIN) {
485     tp->snd_nxt++;
486     tp->t_flags |= TF_SENTFIN;
487     }
488     }
489     tp->snd_nxt += len;
490     if (SEQ_GT(tp->snd_nxt, tp->snd_max)) {
491     tp->snd_max = tp->snd_nxt;
492     /*
493     * Time this transmission if not a retransmission and
494     * not currently timing anything.
495     */
496     if (tp->t_rtt == 0) {
497     tp->t_rtt = 1;
498     tp->t_rtseq = startseq;
499     tcpstat.tcps_segstimed++;
500     }
501     }
502    
503     /*
504     * Set retransmit timer if not currently set,
505     * and not doing an ack or a keep-alive probe.
506     * Initial value for retransmit timer is smoothed
507     * round-trip time + 2 * round-trip time variance.
508     * Initialize shift counter which is used for backoff
509     * of retransmit time.
510     */
511     if (tp->t_timer[TCPT_REXMT] == 0 &&
512     tp->snd_nxt != tp->snd_una) {
513     tp->t_timer[TCPT_REXMT] = tp->t_rxtcur;
514     if (tp->t_timer[TCPT_PERSIST]) {
515     tp->t_timer[TCPT_PERSIST] = 0;
516     tp->t_rxtshift = 0;
517     }
518     }
519     } else
520     if (SEQ_GT(tp->snd_nxt + len, tp->snd_max))
521     tp->snd_max = tp->snd_nxt + len;
522    
523     /*
524     * Fill in IP length and desired time to live and
525     * send to IP level. There should be a better way
526     * to handle ttl and tos; we could keep them in
527     * the template, but need a way to checksum without them.
528     */
529     m->m_len = hdrlen + len; /* XXX Needed? m_len should be correct */
530    
531     {
532    
533     ((struct ip *)ti)->ip_len = m->m_len;
534    
535     ((struct ip *)ti)->ip_ttl = ip_defttl;
536     ((struct ip *)ti)->ip_tos = so->so_iptos;
537    
538     /* #if BSD >= 43 */
539     /* Don't do IP options... */
540     /* error = ip_output(m, tp->t_inpcb->inp_options, &tp->t_inpcb->inp_route,
541     * so->so_options & SO_DONTROUTE, 0);
542     */
543     error = ip_output(so, m);
544    
545     /* #else
546     * error = ip_output(m, (struct mbuf *)0, &tp->t_inpcb->inp_route,
547     * so->so_options & SO_DONTROUTE);
548     * #endif
549     */
550     }
551     if (error) {
552     out:
553     /* if (error == ENOBUFS) {
554     * tcp_quench(tp->t_inpcb, 0);
555     * return (0);
556     * }
557     */
558     /* if ((error == EHOSTUNREACH || error == ENETDOWN)
559     * && TCPS_HAVERCVDSYN(tp->t_state)) {
560     * tp->t_softerror = error;
561     * return (0);
562     * }
563     */
564     return (error);
565     }
566     tcpstat.tcps_sndtotal++;
567    
568     /*
569     * Data sent (as far as we can tell).
570     * If this advertises a larger window than any other segment,
571     * then remember the size of the advertised window.
572     * Any pending ACK has now been sent.
573     */
574     if (win > 0 && SEQ_GT(tp->rcv_nxt+win, tp->rcv_adv))
575     tp->rcv_adv = tp->rcv_nxt + win;
576     tp->last_ack_sent = tp->rcv_nxt;
577     tp->t_flags &= ~(TF_ACKNOW|TF_DELACK);
578     if (sendalot)
579     goto again;
580    
581     return (0);
582     }
583    
584     void
585     tcp_setpersist(tp)
586     register struct tcpcb *tp;
587     {
588     int t = ((tp->t_srtt >> 2) + tp->t_rttvar) >> 1;
589    
590     /* if (tp->t_timer[TCPT_REXMT])
591     * panic("tcp_output REXMT");
592     */
593     /*
594     * Start/restart persistence timer.
595     */
596     TCPT_RANGESET(tp->t_timer[TCPT_PERSIST],
597     t * tcp_backoff[tp->t_rxtshift],
598     TCPTV_PERSMIN, TCPTV_PERSMAX);
599     if (tp->t_rxtshift < TCP_MAXRXTSHIFT)
600     tp->t_rxtshift++;
601     }