2004-04-22 04:10:48 +04:00
|
|
|
/*
|
|
|
|
* Copyright (c) 1982, 1986, 1988, 1990, 1993
|
|
|
|
* The Regents of the University of California. All rights reserved.
|
|
|
|
*
|
|
|
|
* Redistribution and use in source and binary forms, with or without
|
|
|
|
* modification, are permitted provided that the following conditions
|
|
|
|
* are met:
|
|
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
|
|
* notice, this list of conditions and the following disclaimer.
|
|
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
|
|
* documentation and/or other materials provided with the distribution.
|
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
2009-01-26 22:37:41 +03:00
|
|
|
* 3. Neither the name of the University nor the names of its contributors
|
2004-04-22 04:10:48 +04:00
|
|
|
* may be used to endorse or promote products derived from this software
|
|
|
|
* without specific prior written permission.
|
|
|
|
*
|
|
|
|
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
|
|
|
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
|
|
|
|
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
|
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
|
|
|
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
|
|
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
|
|
|
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
|
|
* SUCH DAMAGE.
|
|
|
|
*
|
|
|
|
* @(#)tcp_timer.c 8.1 (Berkeley) 6/10/93
|
|
|
|
* tcp_timer.c,v 1.2 1994/08/02 07:49:10 davidg Exp
|
|
|
|
*/
|
|
|
|
|
2016-06-22 20:11:19 +03:00
|
|
|
#include "slirp.h"
|
2004-04-22 04:10:48 +04:00
|
|
|
|
2007-10-26 23:01:16 +04:00
|
|
|
static struct tcpcb *tcp_timers(register struct tcpcb *tp, int timer);
|
|
|
|
|
2004-04-22 04:10:48 +04:00
|
|
|
/*
|
|
|
|
* Fast timeout routine for processing delayed acks
|
|
|
|
*/
|
|
|
|
void
|
2009-06-24 16:42:31 +04:00
|
|
|
tcp_fasttimo(Slirp *slirp)
|
2004-04-22 04:10:48 +04:00
|
|
|
{
|
|
|
|
register struct socket *so;
|
|
|
|
register struct tcpcb *tp;
|
|
|
|
|
|
|
|
DEBUG_CALL("tcp_fasttimo");
|
2007-09-17 01:08:06 +04:00
|
|
|
|
2009-06-24 16:42:31 +04:00
|
|
|
so = slirp->tcb.so_next;
|
2004-04-22 04:10:48 +04:00
|
|
|
if (so)
|
2009-06-24 16:42:31 +04:00
|
|
|
for (; so != &slirp->tcb; so = so->so_next)
|
2004-04-22 04:10:48 +04:00
|
|
|
if ((tp = (struct tcpcb *)so->so_tcpcb) &&
|
|
|
|
(tp->t_flags & TF_DELACK)) {
|
|
|
|
tp->t_flags &= ~TF_DELACK;
|
|
|
|
tp->t_flags |= TF_ACKNOW;
|
|
|
|
(void) tcp_output(tp);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Tcp protocol timeout routine called every 500 ms.
|
|
|
|
* Updates the timers in all active tcb's and
|
|
|
|
* causes finite state machine actions if timers expire.
|
|
|
|
*/
|
|
|
|
void
|
2009-06-24 16:42:31 +04:00
|
|
|
tcp_slowtimo(Slirp *slirp)
|
2004-04-22 04:10:48 +04:00
|
|
|
{
|
|
|
|
register struct socket *ip, *ipnxt;
|
|
|
|
register struct tcpcb *tp;
|
|
|
|
register int i;
|
|
|
|
|
|
|
|
DEBUG_CALL("tcp_slowtimo");
|
2007-09-17 01:08:06 +04:00
|
|
|
|
2004-04-22 04:10:48 +04:00
|
|
|
/*
|
|
|
|
* Search through tcb's and update active timers.
|
|
|
|
*/
|
2009-06-24 16:42:31 +04:00
|
|
|
ip = slirp->tcb.so_next;
|
2009-08-01 14:13:20 +04:00
|
|
|
if (ip == NULL) {
|
|
|
|
return;
|
|
|
|
}
|
2009-06-24 16:42:31 +04:00
|
|
|
for (; ip != &slirp->tcb; ip = ipnxt) {
|
2004-04-22 04:10:48 +04:00
|
|
|
ipnxt = ip->so_next;
|
|
|
|
tp = sototcpcb(ip);
|
2009-08-01 14:13:20 +04:00
|
|
|
if (tp == NULL) {
|
|
|
|
continue;
|
|
|
|
}
|
2004-04-22 04:10:48 +04:00
|
|
|
for (i = 0; i < TCPT_NTIMERS; i++) {
|
|
|
|
if (tp->t_timer[i] && --tp->t_timer[i] == 0) {
|
|
|
|
tcp_timers(tp,i);
|
|
|
|
if (ipnxt->so_prev != ip)
|
|
|
|
goto tpgone;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
tp->t_idle++;
|
|
|
|
if (tp->t_rtt)
|
|
|
|
tp->t_rtt++;
|
|
|
|
tpgone:
|
|
|
|
;
|
|
|
|
}
|
2009-06-24 16:42:31 +04:00
|
|
|
slirp->tcp_iss += TCP_ISSINCR/PR_SLOWHZ; /* increment iss */
|
|
|
|
slirp->tcp_now++; /* for timestamps */
|
2004-04-22 04:10:48 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Cancel all timers for TCP tp.
|
|
|
|
*/
|
|
|
|
void
|
2009-04-18 11:32:41 +04:00
|
|
|
tcp_canceltimers(struct tcpcb *tp)
|
2004-04-22 04:10:48 +04:00
|
|
|
{
|
|
|
|
register int i;
|
|
|
|
|
|
|
|
for (i = 0; i < TCPT_NTIMERS; i++)
|
|
|
|
tp->t_timer[i] = 0;
|
|
|
|
}
|
|
|
|
|
2007-10-26 23:01:16 +04:00
|
|
|
const int tcp_backoff[TCP_MAXRXTSHIFT + 1] =
|
2004-04-22 04:10:48 +04:00
|
|
|
{ 1, 2, 4, 8, 16, 32, 64, 64, 64, 64, 64, 64, 64 };
|
|
|
|
|
|
|
|
/*
|
|
|
|
* TCP timer processing.
|
|
|
|
*/
|
2007-10-26 23:01:16 +04:00
|
|
|
static struct tcpcb *
|
|
|
|
tcp_timers(register struct tcpcb *tp, int timer)
|
2004-04-22 04:10:48 +04:00
|
|
|
{
|
|
|
|
register int rexmt;
|
2007-09-17 01:08:06 +04:00
|
|
|
|
2004-04-22 04:10:48 +04:00
|
|
|
DEBUG_CALL("tcp_timers");
|
2007-09-17 01:08:06 +04:00
|
|
|
|
2004-04-22 04:10:48 +04:00
|
|
|
switch (timer) {
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 2 MSL timeout in shutdown went off. If we're closed but
|
|
|
|
* still waiting for peer to close and connection has been idle
|
|
|
|
* too long, or if 2MSL time is up from TIME_WAIT, delete connection
|
|
|
|
* control block. Otherwise, check again in a bit.
|
|
|
|
*/
|
|
|
|
case TCPT_2MSL:
|
|
|
|
if (tp->t_state != TCPS_TIME_WAIT &&
|
2007-10-26 23:01:16 +04:00
|
|
|
tp->t_idle <= TCP_MAXIDLE)
|
|
|
|
tp->t_timer[TCPT_2MSL] = TCPTV_KEEPINTVL;
|
2004-04-22 04:10:48 +04:00
|
|
|
else
|
|
|
|
tp = tcp_close(tp);
|
|
|
|
break;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Retransmission timer went off. Message has not
|
|
|
|
* been acked within retransmit interval. Back off
|
|
|
|
* to a longer retransmit interval and retransmit one segment.
|
|
|
|
*/
|
|
|
|
case TCPT_REXMT:
|
2007-09-17 12:09:54 +04:00
|
|
|
|
2004-04-22 04:10:48 +04:00
|
|
|
/*
|
|
|
|
* XXXXX If a packet has timed out, then remove all the queued
|
|
|
|
* packets for that session.
|
|
|
|
*/
|
2007-09-17 12:09:54 +04:00
|
|
|
|
2004-04-22 04:10:48 +04:00
|
|
|
if (++tp->t_rxtshift > TCP_MAXRXTSHIFT) {
|
|
|
|
/*
|
|
|
|
* This is a hack to suit our terminal server here at the uni of canberra
|
|
|
|
* since they have trouble with zeroes... It usually lets them through
|
|
|
|
* unharmed, but under some conditions, it'll eat the zeros. If we
|
|
|
|
* keep retransmitting it, it'll keep eating the zeroes, so we keep
|
|
|
|
* retransmitting, and eventually the connection dies...
|
|
|
|
* (this only happens on incoming data)
|
2007-09-17 01:08:06 +04:00
|
|
|
*
|
2004-04-22 04:10:48 +04:00
|
|
|
* So, if we were gonna drop the connection from too many retransmits,
|
|
|
|
* don't... instead halve the t_maxseg, which might break up the NULLs and
|
|
|
|
* let them through
|
2007-09-17 01:08:06 +04:00
|
|
|
*
|
2004-04-22 04:10:48 +04:00
|
|
|
* *sigh*
|
|
|
|
*/
|
2007-09-17 12:09:54 +04:00
|
|
|
|
2004-04-22 04:10:48 +04:00
|
|
|
tp->t_maxseg >>= 1;
|
|
|
|
if (tp->t_maxseg < 32) {
|
|
|
|
/*
|
|
|
|
* We tried our best, now the connection must die!
|
|
|
|
*/
|
|
|
|
tp->t_rxtshift = TCP_MAXRXTSHIFT;
|
|
|
|
tp = tcp_drop(tp, tp->t_softerror);
|
|
|
|
/* tp->t_softerror : ETIMEDOUT); */ /* XXX */
|
|
|
|
return (tp); /* XXX */
|
|
|
|
}
|
2007-09-17 12:09:54 +04:00
|
|
|
|
2004-04-22 04:10:48 +04:00
|
|
|
/*
|
|
|
|
* Set rxtshift to 6, which is still at the maximum
|
|
|
|
* backoff time
|
|
|
|
*/
|
|
|
|
tp->t_rxtshift = 6;
|
|
|
|
}
|
|
|
|
rexmt = TCP_REXMTVAL(tp) * tcp_backoff[tp->t_rxtshift];
|
|
|
|
TCPT_RANGESET(tp->t_rxtcur, rexmt,
|
|
|
|
(short)tp->t_rttmin, TCPTV_REXMTMAX); /* XXX */
|
|
|
|
tp->t_timer[TCPT_REXMT] = tp->t_rxtcur;
|
|
|
|
/*
|
|
|
|
* If losing, let the lower level know and try for
|
|
|
|
* a better route. Also, if we backed off this far,
|
|
|
|
* our srtt estimate is probably bogus. Clobber it
|
|
|
|
* so we'll take the next rtt measurement as our srtt;
|
|
|
|
* move the current srtt into rttvar to keep the current
|
|
|
|
* retransmit times until then.
|
|
|
|
*/
|
|
|
|
if (tp->t_rxtshift > TCP_MAXRXTSHIFT / 4) {
|
|
|
|
tp->t_rttvar += (tp->t_srtt >> TCP_RTT_SHIFT);
|
|
|
|
tp->t_srtt = 0;
|
|
|
|
}
|
|
|
|
tp->snd_nxt = tp->snd_una;
|
|
|
|
/*
|
|
|
|
* If timing a segment in this window, stop the timer.
|
|
|
|
*/
|
|
|
|
tp->t_rtt = 0;
|
|
|
|
/*
|
|
|
|
* Close the congestion window down to one segment
|
|
|
|
* (we'll open it by one segment for each ack we get).
|
|
|
|
* Since we probably have a window's worth of unacked
|
|
|
|
* data accumulated, this "slow start" keeps us from
|
|
|
|
* dumping all that data as back-to-back packets (which
|
|
|
|
* might overwhelm an intermediate gateway).
|
|
|
|
*
|
|
|
|
* There are two phases to the opening: Initially we
|
|
|
|
* open by one mss on each ack. This makes the window
|
|
|
|
* size increase exponentially with time. If the
|
|
|
|
* window is larger than the path can handle, this
|
|
|
|
* exponential growth results in dropped packet(s)
|
2007-09-17 01:08:06 +04:00
|
|
|
* almost immediately. To get more time between
|
2004-04-22 04:10:48 +04:00
|
|
|
* drops but still "push" the network to take advantage
|
|
|
|
* of improving conditions, we switch from exponential
|
|
|
|
* to linear window opening at some threshold size.
|
|
|
|
* For a threshold, we use half the current window
|
|
|
|
* size, truncated to a multiple of the mss.
|
|
|
|
*
|
|
|
|
* (the minimum cwnd that will give us exponential
|
|
|
|
* growth is 2 mss. We don't allow the threshold
|
|
|
|
* to go below this.)
|
|
|
|
*/
|
|
|
|
{
|
2019-01-17 14:43:53 +03:00
|
|
|
unsigned win = MIN(tp->snd_wnd, tp->snd_cwnd) / 2 / tp->t_maxseg;
|
2004-04-22 04:10:48 +04:00
|
|
|
if (win < 2)
|
|
|
|
win = 2;
|
|
|
|
tp->snd_cwnd = tp->t_maxseg;
|
|
|
|
tp->snd_ssthresh = win * tp->t_maxseg;
|
|
|
|
tp->t_dupacks = 0;
|
|
|
|
}
|
|
|
|
(void) tcp_output(tp);
|
|
|
|
break;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Persistence timer into zero window.
|
|
|
|
* Force a byte to be output, if possible.
|
|
|
|
*/
|
|
|
|
case TCPT_PERSIST:
|
|
|
|
tcp_setpersist(tp);
|
|
|
|
tp->t_force = 1;
|
|
|
|
(void) tcp_output(tp);
|
|
|
|
tp->t_force = 0;
|
|
|
|
break;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Keep-alive timer went off; send something
|
|
|
|
* or drop connection if idle for too long.
|
|
|
|
*/
|
|
|
|
case TCPT_KEEP:
|
|
|
|
if (tp->t_state < TCPS_ESTABLISHED)
|
|
|
|
goto dropit;
|
|
|
|
|
2018-11-14 15:36:28 +03:00
|
|
|
if (slirp_do_keepalive && tp->t_state <= TCPS_CLOSE_WAIT) {
|
2018-12-14 01:37:36 +03:00
|
|
|
if (tp->t_idle >= TCPTV_KEEP_IDLE + TCP_MAXIDLE)
|
2004-04-22 04:10:48 +04:00
|
|
|
goto dropit;
|
|
|
|
/*
|
|
|
|
* Send a packet designed to force a response
|
|
|
|
* if the peer is up and reachable:
|
|
|
|
* either an ACK if the connection is still alive,
|
|
|
|
* or an RST if the peer has closed the connection
|
|
|
|
* due to timeout or reboot.
|
|
|
|
* Using sequence number tp->snd_una-1
|
|
|
|
* causes the transmitted zero-length segment
|
|
|
|
* to lie outside the receive window;
|
|
|
|
* by the protocol spec, this requires the
|
|
|
|
* correspondent TCP to respond.
|
|
|
|
*/
|
|
|
|
tcp_respond(tp, &tp->t_template, (struct mbuf *)NULL,
|
2016-03-15 12:31:21 +03:00
|
|
|
tp->rcv_nxt, tp->snd_una - 1, 0,
|
|
|
|
tp->t_socket->so_ffamily);
|
2007-10-26 23:01:16 +04:00
|
|
|
tp->t_timer[TCPT_KEEP] = TCPTV_KEEPINTVL;
|
2004-04-22 04:10:48 +04:00
|
|
|
} else
|
2007-10-26 23:01:16 +04:00
|
|
|
tp->t_timer[TCPT_KEEP] = TCPTV_KEEP_IDLE;
|
2004-04-22 04:10:48 +04:00
|
|
|
break;
|
|
|
|
|
|
|
|
dropit:
|
2009-06-24 16:42:29 +04:00
|
|
|
tp = tcp_drop(tp, 0);
|
2004-04-22 04:10:48 +04:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return (tp);
|
|
|
|
}
|