Kill T/TCP
authorAggelos Economopoulos <aggelos@coal.nodomain>
Thu, 10 Dec 2009 19:36:55 +0000 (21:36 +0200)
committerAggelos Economopoulos <aggelos@coal.nodomain>
Fri, 11 Dec 2009 02:42:02 +0000 (04:42 +0200)
T/TCP has serious security issues by design and has not
found widespread usage. Keeping it around is also a
maintenance burden.

13 files changed:
share/man/man4/Makefile
share/man/man4/tcp.4
share/man/man4/ttcp.4 [deleted file]
sys/net/route.h
sys/netinet/tcp.h
sys/netinet/tcp_input.c
sys/netinet/tcp_output.c
sys/netinet/tcp_seq.h
sys/netinet/tcp_subr.c
sys/netinet/tcp_syncache.c
sys/netinet/tcp_timer.c
sys/netinet/tcp_usrreq.c
sys/netinet/tcp_var.h

index ef8403e..dfde03f 100644 (file)
@@ -286,7 +286,6 @@ MAN=        aac.4 \
        ti.4 \
        tl.4 \
        trm.4 \
-       ttcp.4 \
        tty.4 \
        tun.4 \
        twa.4 \
index 28fd505..add41fb 100644 (file)
@@ -82,11 +82,6 @@ call to accept incoming connections.  Only active sockets may
 use the
 .Xr connect 2
 call to initiate connections.
-.Tn TCP
-also supports a more datagram-like mode, called Transaction
-.Tn TCP ,
-which is described in
-.Xr ttcp 4 .
 .Pp
 Passive sockets may
 .Dq underspecify
@@ -198,11 +193,6 @@ MIB.
 .Pq tcp.rfc1323
 Implement the window scaling and timestamp options of RFC 1323
 (default true).
-.It Dv TCPCTL_DO_RFC1644
-.Pq tcp.rfc1644
-Implement Transaction
-.Tn TCP ,
-as described in RFC 1644.
 .It Dv TCPCTL_MSSDFLT
 .Pq tcp.mssdflt
 The default value used for the maximum segment size
diff --git a/share/man/man4/ttcp.4 b/share/man/man4/ttcp.4
deleted file mode 100644 (file)
index cf5f5ea..0000000
+++ /dev/null
@@ -1,230 +0,0 @@
-.\" Copyright 1994, 1995 Massachusetts Institute of Technology
-.\"
-.\" Permission to use, copy, modify, and distribute this software and
-.\" its documentation for any purpose and without fee is hereby
-.\" granted, provided that both the above copyright notice and this
-.\" permission notice appear in all copies, that both the above
-.\" copyright notice and this permission notice appear in all
-.\" supporting documentation, and that the name of M.I.T. not be used
-.\" in advertising or publicity pertaining to distribution of the
-.\" software without specific, written prior permission.  M.I.T. makes
-.\" no representations about the suitability of this software for any
-.\" purpose.  It is provided "as is" without express or implied
-.\" warranty.
-.\"
-.\" THIS SOFTWARE IS PROVIDED BY M.I.T. ``AS IS''.  M.I.T. DISCLAIMS
-.\" ALL EXPRESS OR IMPLIED WARRANTIES WITH REGARD TO THIS SOFTWARE,
-.\" INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
-.\" MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT
-.\" SHALL M.I.T. 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.
-.\"
-.\" $FreeBSD: src/share/man/man4/ttcp.4,v 1.8.2.6 2001/12/17 11:30:12 ru Exp $
-.\" $DragonFly: src/share/man/man4/ttcp.4,v 1.3 2007/07/14 21:48:15 swildner Exp $
-.\"
-.Dd January 18, 1995
-.Dt TTCP 4
-.Os
-.Sh NAME
-.Nm ttcp
-.Nd Transmission Control Protocol Extensions for Transactions
-.Sh SYNOPSIS
-.In sys/types.h
-.In sys/socket.h
-.In netinet/in.h
-.In netinet/tcp.h
-.Ft int
-.Fn setsockopt sock IPPROTO_TCP TCP_NOPUSH &One "sizeof One"
-.Ft ssize_t
-.Fn sendto sock msg len MSG_EOF &sin "sizeof sin"
-.Ft ssize_t
-.Fn sendto sock msg len MSG_EOF 0 0
-.Sh DESCRIPTION
-.Tn T/TCP
-refers to a set of extensions to the
-.Tn TCP
-protocol (see
-.Xr tcp 4 )
-which permit hosts to reliably exchange a small amount of data in a
-two-packet exchange, thus eliminating the extra round-trip delays
-inherent in a standard
-.Tn TCP
-connection.  The socket interface includes modifications to support
-.Tn T/TCP ,
-detailed here for the specific case, and in the
-.Xr socket 2
-and
-.Xr send 2
-manual pages for the protocol-independent support.
-.Tn T/TCP
-is defined in RFC 1644.
-.Pp
-The
-.Tn T/TCP
-extensions work by including certain options in all segments of a
-particular connection, which enable the implementation to avoid the
-three-way handshake for all but the first connection between a pair of
-hosts.  These same options also make it possible to more reliably
-recognize old, duplicate packets, which in turn reduces the amount of
-time the
-.Tn TCP
-protocol must maintain state after a connection closes.  The
-.Va net.inet.tcp.rfc1644
-MIB variable can be used to disable
-.Tn T/TCP
-negotiation at run time; however, the protocol has been designed to
-ensure that attempts by non-T/TCP
-systems to communicate with T/TCP-enhanced
-ones automatically degenerate into standard
-.Tn TCP .
-.Sh TRANSACTION MODEL
-The expected model of a
-.Dq transaction
-as used by
-.Tn T/TCP
-is a fairly simple one:
-.Bl -enum
-.It
-A client program generates a request to be sent to the server, which
-is small enough to fit in a single
-.Tn TCP
-segment, and sends a SYN PUSH FIN segment with options and data to the
-server.
-.It
-The server program accepts the request in the same manner as for
-regular
-.Tn TCP
-connections, interprets it, and generates a reply which may be small
-enough to fit in a single segment.  If it is, the reply is sent in a
-single SYN PUSH FIN ACK segment with (different) options and data back
-to the client.  If not, then the connection degenerates into (almost)
-the usual case for
-.Tn TCP .
-The server then closes its socket.
-.It
-The client reads the reply and closes its socket.
-.El
-.Sh CLIENT SUPPORT
-Support on the client side is provided by extending the semantics of
-the
-.Xr sendto 2
-and
-.Xr sendmsg 2
-system calls to understand the notion of
-.Dq implied connect
-and
-.Dq send and shutdown .
-To send the request in a transaction, the
-.Xr sendto 2
-system call is typically used, as in the following example:
-.Bd -literal -offset indent
-char request[REQ_LEN];
-struct sockaddr_in sin;
-int sock, req_len;
-
-sock = socket(PF_INET, SOCK_STREAM, 0);
-
-/* prepare request[] and sin */
-
-err = sendto(sock, request, req_len, MSG_EOF,
-       (struct sockaddr *)&sin, sin.sin_len);
-
-/* do something if error */
-
-req_len = read(sock, request, sizeof request);
-close(sock);
-
-/* do something with the reply */
-
-.Ed
-.Pp
-Note that, after the
-call to
-.Fn sendto ,
-the socket is now in the same state as if the
-.Xr connect 2
-and
-.Xr shutdown 2
-system calls had been used.  That is to say, the only reasonable
-operations to perform on this socket are
-.Xr read 2
-and
-.Xr close 2 .
-(Because the client's
-.Tn TCP
-sender is already shut down, it is not possible to
-.Xr connect 2
-this socket to another destination.)
-.Sh SERVER SUPPORT
-There are two different options available for servers using
-.Tn T/TCP :
-.Bl -enum
-.It
-Set the
-.Dv TCP_NOPUSH
-socket option, and use normal
-.Xr write 2
-calls when formulating the response.
-.It
-Use
-.Xr sendto 2
-with the
-.Dv MSG_EOF
-flag, as in the client, but with the destination unspecified.
-.El
-.Pp
-The first option is generally the appropriate choice when converting
-existing servers to use
-.Tn T/TCP
-extensions; simply add a call to
-.Fn setsockopt sock IPPROTO_TCP TCP_NOPUSH &One "sizeof One"
-(where
-.Va One
-is an integer variable with a non-zero value).  The server socket must
-be closed before any data is sent (unless the socket buffers fill up).
-.Pp
-The second option is preferable for new servers, and is sometimes easy
-enough to retrofit into older servers.  In this case, where the reply
-phase would ordinarily have included a call to
-.Fn write ,
-one substitutes:
-.Pp
-.Dl "sendto(sock, buf, len, MSG_EOF, NULL, 0)"
-.Pp
-In this case, the reply is sent immediately, but as in the client
-case, the socket is no longer useful for anything and should be
-immediately closed.
-.Sh MIB VARIABLES
-The
-.Tn T/TCP
-extensions require the
-.Va net.inet.tcp.rfc1644
-MIB variable to be true in order for the appropriate
-.Tn TCP
-options to be sent.  See
-.Xr tcp 4
-for more information.
-.Sh SEE ALSO
-.Xr send 2 ,
-.Xr setsockopt 2 ,
-.Xr inet 4 ,
-.Xr tcp 4
-.Rs
-.%A R. Braden
-.%T "T/TCP \- TCP Extensions for Transactions"
-.%O RFC 1644
-.Re
-.Sh HISTORY
-Support for
-.Tn T/TCP
-first appeared in
-.Fx 2.1 ,
-based on code written by Bob Braden and Liming Wei at the
-University of Southern California, Information Sciences Institute, and
-ported by Andras Olah at the University of Twente.
index 4acc68d..5ec451f 100644 (file)
@@ -114,7 +114,8 @@ struct rt_metrics { /* grouped for locality of reference */
 
        u_long  rmx_recvpipe;   /* inbound delay-bandwidth product */
        u_long  rmx_hopcount;   /* max hops expected */
-       u_long  rmx_filler[4];  /* will be used for T/TCP later */
+       u_short rmx_mssopt;     /* peer's cached MSS */
+       u_long  rmx_filler[3];  /* for future expansion */
 };
 
 /*
index e320bb7..7c48b70 100644 (file)
@@ -47,7 +47,6 @@
 
 typedef        u_int32_t tcp_seq;
 typedef int32_t          tcp_seq_diff_t;
-typedef u_int32_t tcp_cc;              /* connection count per rfc1644 */
 
 #define tcp6_seq       tcp_seq /* for KAME src sync over BSD*'s */
 #define tcp6hdr                tcphdr  /* for KAME src sync over BSD*'s */
@@ -111,10 +110,6 @@ struct tcphdr {
 #define        TCPOPT_CC               11              /* CC options: RFC-1644 */
 #define TCPOPT_CCNEW           12
 #define TCPOPT_CCECHO          13
-#define           TCPOLEN_CC                   6
-#define           TCPOLEN_CC_APPA              (TCPOLEN_CC+2)
-#define           TCPOPT_CC_HDR(ccopt)         \
-    (TCPOPT_2NOPs | (ccopt) << 8 | TCPOLEN_CC)
 
 /*
  * Default maximum segment size for TCP.
@@ -148,7 +143,6 @@ struct tcphdr {
 #define        TCP6_MSS        1024
 
 #define        TCP_MAXWIN              65535   /* max value for (unscaled) window */
-#define        TTCP_CLIENT_SND_WND     4096    /* dflt send window for T/TCP client */
 
 #define TCP_MIN_WINSHIFT       5       /* requested minimum (x32) */
 #define TCP_MAX_WINSHIFT       14      /* maximum window shift */
index 8144164..9bcc360 100644 (file)
@@ -135,7 +135,6 @@ struct tcphdr tcp_savetcp;
 
 MALLOC_DEFINE(M_TSEGQ, "tseg_qent", "TCP segment queue entry");
 
-tcp_cc tcp_ccgen;
 static int log_in_vain = 0;
 SYSCTL_INT(_net_inet_tcp, OID_AUTO, log_in_vain, CTLFLAG_RW,
     &log_in_vain, 0, "Log all incoming TCP connections");
@@ -531,8 +530,6 @@ tcp_input(struct mbuf *m, ...)
        u_long tiwin;
        int recvwin;
        struct tcpopt to;               /* options in this segment */
-       struct rmxp_tao *taop;          /* pointer to our TAO cache entry */
-       struct rmxp_tao tao_noncached;  /* in case there's no cached entry */
        struct sockaddr_in *next_hop = NULL;
        int rstreason; /* For badport_bandlim accounting purposes */
        int cpu;
@@ -1031,9 +1028,6 @@ findpcb:
                                 * send SYN,ACK packet.
                                 */
                                return;
-                       /*
-                        * Segment passed TAO tests.
-                        */
                        inp = so->so_pcb;
                        tp = intotcpcb(inp);
                        tp->snd_wnd = tiwin;
@@ -1121,8 +1115,6 @@ after_listen:
                        tp->ts_recent = to.to_tsval;
                        tp->ts_recent_age = ticks;
                }
-               if (to.to_flags & (TOF_CC | TOF_CCNEW))
-                       tp->t_flags |= TF_RCVD_CC;
                if (to.to_flags & TOF_MSS)
                        tcp_mss(tp, to.to_mss);
                /*
@@ -1156,13 +1148,6 @@ after_listen:
            !(tp->t_flags & (TF_NEEDSYN | TF_NEEDFIN)) &&
            (!(to.to_flags & TOF_TS) ||
             TSTMP_GEQ(to.to_tsval, tp->ts_recent)) &&
-           /*
-            * Using the CC option is compulsory if once started:
-            *   the segment is OK if no T/TCP was negotiated or
-            *   if the segment has a CC option equal to CCrecv
-            */
-           ((tp->t_flags & (TF_REQ_CC|TF_RCVD_CC)) != (TF_REQ_CC|TF_RCVD_CC) ||
-            ((to.to_flags & TOF_CC) && to.to_cc == tp->cc_recv)) &&
            th->th_seq == tp->rcv_nxt &&
            tp->snd_nxt == tp->snd_max) {
 
@@ -1454,28 +1439,11 @@ after_listen:
         *      continue processing rest of data/controls, beginning with URG
         */
        case TCPS_SYN_SENT:
-               if ((taop = tcp_gettaocache(&inp->inp_inc)) == NULL) {
-                       taop = &tao_noncached;
-                       bzero(taop, sizeof *taop);
-               }
-
                if ((thflags & TH_ACK) &&
                    (SEQ_LEQ(th->th_ack, tp->iss) ||
                     SEQ_GT(th->th_ack, tp->snd_max))) {
-                       /*
-                        * If we have a cached CCsent for the remote host,
-                        * hence we haven't just crashed and restarted,
-                        * do not send a RST.  This may be a retransmission
-                        * from the other side after our earlier ACK was lost.
-                        * Our new SYN, when it arrives, will serve as the
-                        * needed ACK.
-                        */
-                       if (taop->tao_ccsent != 0)
-                               goto drop;
-                       else {
-                               rstreason = BANDLIM_UNLIMITED;
-                               goto dropwithreset;
-                       }
+                       rstreason = BANDLIM_UNLIMITED;
+                       goto dropwithreset;
                }
                if (thflags & TH_RST) {
                        if (thflags & TH_ACK)
@@ -1485,30 +1453,11 @@ after_listen:
                if (!(thflags & TH_SYN))
                        goto drop;
                tp->snd_wnd = th->th_win;       /* initial send window */
-               tp->cc_recv = to.to_cc;         /* foreign CC */
 
                tp->irs = th->th_seq;
                tcp_rcvseqinit(tp);
                if (thflags & TH_ACK) {
-                       /*
-                        * Our SYN was acked.  If segment contains CC.ECHO
-                        * option, check it to make sure this segment really
-                        * matches our SYN.  If not, just drop it as old
-                        * duplicate, but send an RST if we're still playing
-                        * by the old rules.  If no CC.ECHO option, make sure
-                        * we don't get fooled into using T/TCP.
-                        */
-                       if (to.to_flags & TOF_CCECHO) {
-                               if (tp->cc_send != to.to_ccecho) {
-                                       if (taop->tao_ccsent != 0)
-                                               goto drop;
-                                       else {
-                                               rstreason = BANDLIM_UNLIMITED;
-                                               goto dropwithreset;
-                                       }
-                               }
-                       } else
-                               tp->t_flags &= ~TF_RCVD_CC;
+                       /* Our SYN was acked. */
                        tcpstat.tcps_connects++;
                        soisconnected(so);
                        /* Do window scaling on this connection? */
@@ -1517,10 +1466,6 @@ after_listen:
                                tp->snd_scale = tp->requested_s_scale;
                                tp->rcv_scale = tp->request_r_scale;
                        }
-                       /* Segment is acceptable, update cache if undefined. */
-                       if (taop->tao_ccsent == 0)
-                               taop->tao_ccsent = to.to_ccecho;
-
                        tp->rcv_adv += tp->rcv_wnd;
                        tp->snd_una++;          /* SYN is acked */
                        tcp_callout_stop(tp, tp->tt_rexmt);
@@ -1553,43 +1498,14 @@ after_listen:
                } else {
                        /*
                         * Received initial SYN in SYN-SENT[*] state =>
-                        * simultaneous open.  If segment contains CC option
-                        * and there is a cached CC, apply TAO test.
-                        * If it succeeds, connection is * half-synchronized.
-                        * Otherwise, do 3-way handshake:
+                        * simultaneous open.
+                        * Do 3-way handshake:
                         *        SYN-SENT -> SYN-RECEIVED
                         *        SYN-SENT* -> SYN-RECEIVED*
-                        * If there was no CC option, clear cached CC value.
                         */
                        tp->t_flags |= TF_ACKNOW;
                        tcp_callout_stop(tp, tp->tt_rexmt);
-                       if (to.to_flags & TOF_CC) {
-                               if (taop->tao_cc != 0 &&
-                                   CC_GT(to.to_cc, taop->tao_cc)) {
-                                       /*
-                                        * update cache and make transition:
-                                        *        SYN-SENT -> ESTABLISHED*
-                                        *        SYN-SENT* -> FIN-WAIT-1*
-                                        */
-                                       taop->tao_cc = to.to_cc;
-                                       tp->t_starttime = ticks;
-                                       if (tp->t_flags & TF_NEEDFIN) {
-                                               tp->t_state = TCPS_FIN_WAIT_1;
-                                               tp->t_flags &= ~TF_NEEDFIN;
-                                       } else {
-                                               tp->t_state = TCPS_ESTABLISHED;
-                                               tcp_callout_reset(tp,
-                                                   tp->tt_keep, tcp_keepidle,
-                                                   tcp_timer_keep);
-                                       }
-                                       tp->t_flags |= TF_NEEDSYN;
-                               } else
-                                       tp->t_state = TCPS_SYN_RECEIVED;
-                       } else {
-                               /* CC.NEW or no option => invalidate cache */
-                               taop->tao_cc = 0;
-                               tp->t_state = TCPS_SYN_RECEIVED;
-                       }
+                       tp->t_state = TCPS_SYN_RECEIVED;
                }
 
 trimthenstep6:
@@ -1623,35 +1539,11 @@ trimthenstep6:
 
        /*
         * If the state is LAST_ACK or CLOSING or TIME_WAIT:
-        *      if segment contains a SYN and CC [not CC.NEW] option:
-        *              if state == TIME_WAIT and connection duration > MSL,
-        *                  drop packet and send RST;
-        *
-        *              if SEG.CC > CCrecv then is new SYN, and can implicitly
-        *                  ack the FIN (and data) in retransmission queue.
-        *                  Complete close and delete TCPCB.  Then reprocess
-        *                  segment, hoping to find new TCPCB in LISTEN state;
-        *
-        *              else must be old SYN; drop it.
-        *      else do normal processing.
+        *      do normal processing (we no longer bother with T/TCP).
         */
        case TCPS_LAST_ACK:
        case TCPS_CLOSING:
        case TCPS_TIME_WAIT:
-               if ((thflags & TH_SYN) &&
-                   (to.to_flags & TOF_CC) && tp->cc_recv != 0) {
-                       if (tp->t_state == TCPS_TIME_WAIT &&
-                                       (ticks - tp->t_starttime) > tcp_msl) {
-                               rstreason = BANDLIM_UNLIMITED;
-                               goto dropwithreset;
-                       }
-                       if (CC_GT(to.to_cc, tp->cc_recv)) {
-                               tp = tcp_close(tp);
-                               goto findpcb;
-                       }
-                       else
-                               goto drop;
-               }
                break;  /* continue normal processing */
        }
 
@@ -1775,16 +1667,6 @@ trimthenstep6:
        }
 
        /*
-        * T/TCP mechanism
-        *   If T/TCP was negotiated and the segment doesn't have CC,
-        *   or if its CC is wrong then drop the segment.
-        *   RST segments do not have to comply with this.
-        */
-       if ((tp->t_flags & (TF_REQ_CC|TF_RCVD_CC)) == (TF_REQ_CC|TF_RCVD_CC) &&
-           (!(to.to_flags & TOF_CC) || tp->cc_recv != to.to_cc))
-               goto dropafterack;
-
-       /*
         * In the SYN-RECEIVED state, validate that the packet belongs to
         * this connection before trimming the data to fit the receive
         * window.  Check the sequence number versus IRS since we know
@@ -1973,15 +1855,6 @@ trimthenstep6:
                        tp->rcv_scale = tp->request_r_scale;
                }
                /*
-                * Upon successful completion of 3-way handshake,
-                * update cache.CC if it was undefined, pass any queued
-                * data to the user, and advance state appropriately.
-                */
-               if ((taop = tcp_gettaocache(&inp->inp_inc)) != NULL &&
-                   taop->tao_cc == 0)
-                       taop->tao_cc = tp->cc_recv;
-
-               /*
                 * Make transitions:
                 *      SYN-RECEIVED  -> ESTABLISHED
                 *      SYN-RECEIVED* -> FIN-WAIT-1
@@ -2412,16 +2285,8 @@ process_ACK:
                        if (ourfinisacked) {
                                tp->t_state = TCPS_TIME_WAIT;
                                tcp_canceltimers(tp);
-                               /* Shorten TIME_WAIT [RFC-1644, p.28] */
-                               if (tp->cc_recv != 0 &&
-                                   (ticks - tp->t_starttime) < tcp_msl) {
-                                       tcp_callout_reset(tp, tp->tt_2msl,
-                                           tp->t_rxtcur * TCPTV_TWTRUNC,
-                                           tcp_timer_2msl);
-                               } else {
-                                       tcp_callout_reset(tp, tp->tt_2msl,
+                               tcp_callout_reset(tp, tp->tt_2msl,
                                            2 * tcp_msl, tcp_timer_2msl);
-                               }
                                soisdisconnected(so);
                        }
                        break;
@@ -2645,18 +2510,8 @@ dodata:                                                  /* XXX */
                case TCPS_FIN_WAIT_2:
                        tp->t_state = TCPS_TIME_WAIT;
                        tcp_canceltimers(tp);
-                       /* Shorten TIME_WAIT [RFC-1644, p.28] */
-                       if (tp->cc_recv != 0 &&
-                           (ticks - tp->t_starttime) < tcp_msl) {
-                               tcp_callout_reset(tp, tp->tt_2msl,
-                                   tp->t_rxtcur * TCPTV_TWTRUNC,
-                                   tcp_timer_2msl);
-                               /* For transaction client, force ACK now. */
-                               tp->t_flags |= TF_ACKNOW;
-                       } else {
-                               tcp_callout_reset(tp, tp->tt_2msl, 2 * tcp_msl,
+                       tcp_callout_reset(tp, tp->tt_2msl, 2 * tcp_msl,
                                    tcp_timer_2msl);
-                       }
                        soisdisconnected(so);
                        break;
 
@@ -2826,31 +2681,6 @@ tcp_dooptions(struct tcpopt *to, u_char *cp, int cnt, boolean_t is_syn)
                        if (to->to_tsecr != 0 && TSTMP_GT(to->to_tsecr, ticks))
                                to->to_tsecr = 0;
                        break;
-               case TCPOPT_CC:
-                       if (optlen != TCPOLEN_CC)
-                               continue;
-                       to->to_flags |= TOF_CC;
-                       bcopy(cp + 2, &to->to_cc, sizeof to->to_cc);
-                       to->to_cc = ntohl(to->to_cc);
-                       break;
-               case TCPOPT_CCNEW:
-                       if (optlen != TCPOLEN_CC)
-                               continue;
-                       if (!is_syn)
-                               continue;
-                       to->to_flags |= TOF_CCNEW;
-                       bcopy(cp + 2, &to->to_cc, sizeof to->to_cc);
-                       to->to_cc = ntohl(to->to_cc);
-                       break;
-               case TCPOPT_CCECHO:
-                       if (optlen != TCPOLEN_CC)
-                               continue;
-                       if (!is_syn)
-                               continue;
-                       to->to_flags |= TOF_CCECHO;
-                       bcopy(cp + 2, &to->to_ccecho, sizeof to->to_ccecho);
-                       to->to_ccecho = ntohl(to->to_ccecho);
-                       break;
                case TCPOPT_SACK_PERMITTED:
                        if (optlen != TCPOLEN_SACK_PERMITTED)
                                continue;
@@ -3012,10 +2842,6 @@ tcp_xmit_timer(struct tcpcb *tp, int rtt)
  *
  * NOTE that this routine is only called when we process an incoming
  * segment, for outgoing segments only tcp_mssopt is called.
- *
- * In case of T/TCP, we call this routine during implicit connection
- * setup as well (offer = -1), to initialize maxseg from the cached
- * MSS of our peer.
  */
 void
 tcp_mss(struct tcpcb *tp, int offer)
@@ -3026,8 +2852,6 @@ tcp_mss(struct tcpcb *tp, int offer)
        u_long bufsize;
        struct inpcb *inp = tp->t_inpcb;
        struct socket *so;
-       struct rmxp_tao *taop;
-       int origoffer = offer;
 #ifdef INET6
        boolean_t isipv6 = ((inp->inp_vflag & INP_IPV6) ? TRUE : FALSE);
        size_t min_protoh = isipv6 ?
@@ -3050,15 +2874,6 @@ tcp_mss(struct tcpcb *tp, int offer)
        ifp = rt->rt_ifp;
        so = inp->inp_socket;
 
-       taop = rmx_taop(rt->rt_rmx);
-
-       /*
-        * Offer == -1 means that we didn't receive SYN yet,
-        * use cached value in that case;
-        */
-       if (offer == -1)
-               offer = taop->tao_mssopt;
-
        /*
         * Offer == 0 means that there was no MSS on the SYN segment,
         * in this case we use either the interface mtu or tcp_mssdflt.
@@ -3093,7 +2908,7 @@ tcp_mss(struct tcpcb *tp, int offer)
        offer = max(offer, tcp_minmss);
        offer = max(offer, 64);
 
-       taop->tao_mssopt = offer;
+       rt->rt_rmx.rmx_mssopt = offer;
 
        /*
         * While we're here, check if there's an initial rtt
@@ -3148,19 +2963,9 @@ tcp_mss(struct tcpcb *tp, int offer)
         */
        tp->t_maxopd = mss;
 
-       /*
-        * In case of T/TCP, origoffer==-1 indicates, that no segments
-        * were received yet.  In this case we just guess, otherwise
-        * we do the same as before T/TCP.
-        */
        if ((tp->t_flags & (TF_REQ_TSTMP | TF_NOOPT)) == TF_REQ_TSTMP &&
-           (origoffer == -1 ||
-            (tp->t_flags & TF_RCVD_TSTMP) == TF_RCVD_TSTMP))
+           ((tp->t_flags & TF_RCVD_TSTMP) == TF_RCVD_TSTMP))
                mss -= TCPOLEN_TSTAMP_APPA;
-       if ((tp->t_flags & (TF_REQ_CC | TF_NOOPT)) == TF_REQ_CC &&
-           (origoffer == -1 ||
-            (tp->t_flags & TF_RCVD_CC) == TF_RCVD_CC))
-               mss -= TCPOLEN_CC_APPA;
 
 #if    (MCLBYTES & (MCLBYTES - 1)) == 0
                if (mss > MCLBYTES)
index 05c5500..97c5ed7 100644 (file)
@@ -165,7 +165,6 @@ tcp_output(struct tcpcb *tp)
 #else
        const boolean_t isipv6 = FALSE;
 #endif
-       struct rmxp_tao *taop;
 
        /*
         * Determine length of data that should be transmitted,
@@ -281,27 +280,23 @@ again:
 
        /*
         * Lop off SYN bit if it has already been sent.  However, if this
-        * is SYN-SENT state and if segment contains data and if we don't
-        * know that foreign host supports TAO, suppress sending segment.
+        * is SYN-SENT state and if segment contains data, suppress sending
+        * segment (sending the segment would be an option if we still
+        * did TAO and the remote host supported it).
         */
        if ((flags & TH_SYN) && SEQ_GT(tp->snd_nxt, tp->snd_una)) {
                flags &= ~TH_SYN;
                off--, len++;
-               if (len > 0 && tp->t_state == TCPS_SYN_SENT &&
-                   ((taop = tcp_gettaocache(&inp->inp_inc)) == NULL ||
-                    taop->tao_ccsent == 0))
+               if (len > 0 && tp->t_state == TCPS_SYN_SENT)
                        return 0;
        }
 
        /*
-        * Be careful not to send data and/or FIN on SYN segments
-        * in cases when no CC option will be sent.
+        * Be careful not to send data and/or FIN on SYN segments.
         * This measure is needed to prevent interoperability problems
         * with not fully conformant TCP implementations.
         */
-       if ((flags & TH_SYN) &&
-           ((tp->t_flags & TF_NOOPT) || !(tp->t_flags & TF_REQ_CC) ||
-            ((flags & TH_ACK) && !(tp->t_flags & TF_RCVD_CC)))) {
+       if (flags & TH_SYN) {
                len = 0;
                flags &= ~TH_FIN;
        }
@@ -595,74 +590,6 @@ send:
                tp->rfbuf_ts = ticks;
 
        /*
-        * Send `CC-family' options if our side wants to use them (TF_REQ_CC),
-        * options are allowed (!TF_NOOPT) and it's not a RST.
-        */
-       if ((tp->t_flags & (TF_REQ_CC | TF_NOOPT)) == TF_REQ_CC &&
-            !(flags & TH_RST)) {
-               switch (flags & (TH_SYN | TH_ACK)) {
-               /*
-                * This is a normal ACK, send CC if we received CC before
-                * from our peer.
-                */
-               case TH_ACK:
-                       if (!(tp->t_flags & TF_RCVD_CC))
-                               break;
-                       /*FALLTHROUGH*/
-
-               /*
-                * We can only get here in T/TCP's SYN_SENT* state, when
-                * we're a sending a non-SYN segment without waiting for
-                * the ACK of our SYN.  A check above assures that we only
-                * do this if our peer understands T/TCP.
-                */
-               case 0:
-                       opt[optlen++] = TCPOPT_NOP;
-                       opt[optlen++] = TCPOPT_NOP;
-                       opt[optlen++] = TCPOPT_CC;
-                       opt[optlen++] = TCPOLEN_CC;
-                       *(u_int32_t *)&opt[optlen] = htonl(tp->cc_send);
-                       optlen += 4;
-                       break;
-
-               /*
-                * This is our initial SYN, check whether we have to use
-                * CC or CC.new.
-                */
-               case TH_SYN:
-                       opt[optlen++] = TCPOPT_NOP;
-                       opt[optlen++] = TCPOPT_NOP;
-                       opt[optlen++] = tp->t_flags & TF_SENDCCNEW ?
-                                               TCPOPT_CCNEW : TCPOPT_CC;
-                       opt[optlen++] = TCPOLEN_CC;
-                       *(u_int32_t *)&opt[optlen] = htonl(tp->cc_send);
-                       optlen += 4;
-                       break;
-
-               /*
-                * This is a SYN,ACK; send CC and CC.echo if we received
-                * CC from our peer.
-                */
-               case (TH_SYN | TH_ACK):
-                       if (tp->t_flags & TF_RCVD_CC) {
-                               opt[optlen++] = TCPOPT_NOP;
-                               opt[optlen++] = TCPOPT_NOP;
-                               opt[optlen++] = TCPOPT_CC;
-                               opt[optlen++] = TCPOLEN_CC;
-                               *(u_int32_t *)&opt[optlen] = htonl(tp->cc_send);
-                               optlen += 4;
-                               opt[optlen++] = TCPOPT_NOP;
-                               opt[optlen++] = TCPOPT_NOP;
-                               opt[optlen++] = TCPOPT_CCECHO;
-                               opt[optlen++] = TCPOLEN_CC;
-                               *(u_int32_t *)&opt[optlen] = htonl(tp->cc_recv);
-                               optlen += 4;
-                       }
-                       break;
-               }
-       }
-
-       /*
         * If this is a SACK connection and we have a block to report,
         * fill in the SACK blocks in the TCP options.
         */
index 249024d..1c66058 100644 (file)
@@ -103,19 +103,6 @@ seq_min(tcp_seq a, tcp_seq b)
 #define TSTMP_GEQ(a,b) ((int)((a)-(b)) >= 0)
 
 /*
- * TCP connection counts are 32 bit integers operated
- * on with modular arithmetic.  These macros can be
- * used to compare such integers.
- */
-#define        CC_LT(a,b)      ((int)((a)-(b)) < 0)
-#define        CC_LEQ(a,b)     ((int)((a)-(b)) <= 0)
-#define        CC_GT(a,b)      ((int)((a)-(b)) > 0)
-#define        CC_GEQ(a,b)     ((int)((a)-(b)) >= 0)
-
-/* Macro to increment a CC: skip 0 which has a special meaning */
-#define CC_INC(c)      (++(c) == 0 ? ++(c) : (c))
-
-/*
  * Macros to initialize tcp sequence numbers for
  * send and receive from initial send and receive
  * sequence numbers.
@@ -130,7 +117,4 @@ seq_min(tcp_seq a, tcp_seq b)
 #define TCP_PAWS_IDLE  (24 * 24 * 60 * 60 * hz)
                                        /* timestamp wrap-around time */
 
-#ifdef _KERNEL
-extern tcp_cc  tcp_ccgen;              /* global connection count */
-#endif /* _KERNEL */
 #endif /* _NETINET_TCP_SEQ_H_ */
index fa69e31..942b0ee 100644 (file)
@@ -200,10 +200,6 @@ int tcp_do_rfc1323 = 1;
 SYSCTL_INT(_net_inet_tcp, TCPCTL_DO_RFC1323, rfc1323, CTLFLAG_RW,
     &tcp_do_rfc1323, 0, "Enable rfc1323 (high performance TCP) extensions");
 
-int tcp_do_rfc1644 = 0;
-SYSCTL_INT(_net_inet_tcp, TCPCTL_DO_RFC1644, rfc1644, CTLFLAG_RW,
-    &tcp_do_rfc1644, 0, "Enable rfc1644 (TTCP) extensions");
-
 static int tcp_tcbhashsize = 0;
 SYSCTL_INT(_net_inet_tcp, OID_AUTO, tcbhashsize, CTLFLAG_RD,
      &tcp_tcbhashsize, 0, "Size of TCP control block hashtable");
@@ -262,7 +258,6 @@ static MALLOC_DEFINE(M_TCPTEMP, "tcptemp", "TCP Templates for Keepalives");
 static struct malloc_pipe tcptemp_mpipe;
 
 static void tcp_willblock(int);
-static void tcp_cleartaocache (void);
 static void tcp_notify (struct inpcb *, int);
 
 struct tcp_stats tcpstats_percpu[MAXCPU];
@@ -345,9 +340,6 @@ tcp_init(void)
        mpipe_init(&tcptemp_mpipe, M_TCPTEMP, sizeof(struct tcptemp),
                    25, -1, 0, NULL);
 
-       tcp_ccgen = 1;
-       tcp_cleartaocache();
-
        tcp_delacktime = TCPTV_DELACK;
        tcp_keepinit = TCPTV_KEEP_INIT;
        tcp_keepidle = TCPTV_KEEP_IDLE;
@@ -746,8 +738,6 @@ tcp_newtcpcb(struct inpcb *inp)
 
        if (tcp_do_rfc1323)
                tp->t_flags = (TF_REQ_SCALE | TF_REQ_TSTMP);
-       if (tcp_do_rfc1644)
-               tp->t_flags |= TF_REQ_CC;
        tp->t_inpcb = inp;      /* XXX */
        tp->t_state = TCPS_CLOSED;
        /*
@@ -1687,8 +1677,6 @@ tcp_mtudisc(struct inpcb *inp, int mtu)
        else
                rt = tcp_rtlookup(&inp->inp_inc);
        if (rt != NULL) {
-               struct rmxp_tao *taop = rmx_taop(rt->rt_rmx);
-
                if (rt->rt_rmx.rmx_mtu != 0 && rt->rt_rmx.rmx_mtu < mtu)
                        mtu = rt->rt_rmx.rmx_mtu;
 
@@ -1714,8 +1702,8 @@ tcp_mtudisc(struct inpcb *inp, int mtu)
                 * will get recorded and the new parameters should get
                 * recomputed.  For Further Study.
                 */
-               if (taop->tao_mssopt != 0 && taop->tao_mssopt < maxopd)
-                       maxopd = taop->tao_mssopt;
+               if (rt->rt_rmx.rmx_mssopt  && rt->rt_rmx.rmx_mssopt < maxopd)
+                       maxopd = rt->rt_rmx.rmx_mssopt;
        } else
                maxopd = mtu -
                    (isipv6 ?
@@ -1731,10 +1719,6 @@ tcp_mtudisc(struct inpcb *inp, int mtu)
                           (TF_REQ_TSTMP | TF_RCVD_TSTMP))
                mss -= TCPOLEN_TSTAMP_APPA;
 
-       if ((tp->t_flags & (TF_REQ_CC | TF_RCVD_CC | TF_NOOPT)) ==
-                          (TF_REQ_CC | TF_RCVD_CC))
-               mss -= TCPOLEN_CC_APPA;
-
        /* round down to multiple of MCLBYTES */
 #if    (MCLBYTES & (MCLBYTES - 1)) == 0    /* test if MCLBYTES power of 2 */
        if (mss > MCLBYTES)
@@ -1849,44 +1833,6 @@ ipsec_hdrsiz_tcp(struct tcpcb *tp)
 #endif
 
 /*
- * Return a pointer to the cached information about the remote host.
- * The cached information is stored in the protocol specific part of
- * the route metrics.
- */
-struct rmxp_tao *
-tcp_gettaocache(struct in_conninfo *inc)
-{
-       struct rtentry *rt;
-
-#ifdef INET6
-       if (inc->inc_isipv6)
-               rt = tcp_rtlookup6(inc);
-       else
-#endif
-               rt = tcp_rtlookup(inc);
-
-       /* Make sure this is a host route and is up. */
-       if (rt == NULL ||
-           (rt->rt_flags & (RTF_UP | RTF_HOST)) != (RTF_UP | RTF_HOST))
-               return (NULL);
-
-       return (rmx_taop(rt->rt_rmx));
-}
-
-/*
- * Clear all the TAO cache entries, called from tcp_init.
- *
- * XXX
- * This routine is just an empty one, because we assume that the routing
- * routing tables are initialized at the same time when TCP, so there is
- * nothing in the cache left over.
- */
-static void
-tcp_cleartaocache(void)
-{
-}
-
-/*
  * TCP BANDWIDTH DELAY PRODUCT WINDOW LIMITING
  *
  * This code attempts to calculate the bandwidth-delay product as a
index 6a88784..92fd387 100644 (file)
@@ -797,16 +797,6 @@ syncache_socket(struct syncache *sc, struct socket *lso, struct mbuf *m)
                tp->ts_recent = sc->sc_tsrecent;
                tp->ts_recent_age = ticks;
        }
-       if (sc->sc_flags & SCF_CC) {
-               /*
-                * Initialization of the tcpcb for transaction;
-                *   set SND.WND = SEG.WND,
-                *   initialize CCsend and CCrecv.
-                */
-               tp->t_flags |= TF_REQ_CC | TF_RCVD_CC;
-               tp->cc_send = sc->sc_cc_send;
-               tp->cc_recv = sc->sc_cc_recv;
-       }
        if (sc->sc_flags & SCF_SACK_PERMITTED)
                tp->t_flags |= TF_SACK_PERMITTED;
 
@@ -914,7 +904,6 @@ syncache_add(struct in_conninfo *inc, struct tcpopt *to, struct tcphdr *th,
        struct syncache *sc = NULL;
        struct syncache_head *sch;
        struct mbuf *ipopts = NULL;
-       struct rmxp_tao *taop;
        int win;
 
        syncache_percpu = &tcp_syncache_percpu[mycpu->gd_cpuid];
@@ -1040,69 +1029,11 @@ syncache_add(struct in_conninfo *inc, struct tcpopt *to, struct tcphdr *th,
                        sc->sc_flags |= SCF_WINSCALE;
                }
        }
-       if (tcp_do_rfc1644) {
-               /*
-                * A CC or CC.new option received in a SYN makes
-                * it ok to send CC in subsequent segments.
-                */
-               if (to->to_flags & (TOF_CC | TOF_CCNEW)) {
-                       sc->sc_cc_recv = to->to_cc;
-                       sc->sc_cc_send = CC_INC(tcp_ccgen);
-                       sc->sc_flags |= SCF_CC;
-               }
-       }
        if (tcp_do_sack && (to->to_flags & TOF_SACK_PERMITTED))
                sc->sc_flags |= SCF_SACK_PERMITTED;
        if (tp->t_flags & TF_NOOPT)
                sc->sc_flags = SCF_NOOPT;
 
-       /*
-        * XXX
-        * We have the option here of not doing TAO (even if the segment
-        * qualifies) and instead fall back to a normal 3WHS via the syncache.
-        * This allows us to apply synflood protection to TAO-qualifying SYNs
-        * also. However, there should be a hueristic to determine when to
-        * do this, and is not present at the moment.
-        */
-
-       /*
-        * Perform TAO test on incoming CC (SEG.CC) option, if any.
-        * - compare SEG.CC against cached CC from the same host, if any.
-        * - if SEG.CC > chached value, SYN must be new and is accepted
-        *      immediately: save new CC in the cache, mark the socket
-        *      connected, enter ESTABLISHED state, turn on flag to
-        *      send a SYN in the next segment.
-        *      A virtual advertised window is set in rcv_adv to
-        *      initialize SWS prevention.  Then enter normal segment
-        *      processing: drop SYN, process data and FIN.
-        * - otherwise do a normal 3-way handshake.
-        */
-       taop = tcp_gettaocache(&sc->sc_inc);
-       if (to->to_flags & TOF_CC) {
-               if ((tp->t_flags & TF_NOPUSH) &&
-                   sc->sc_flags & SCF_CC &&
-                   taop != NULL && taop->tao_cc != 0 &&
-                   CC_GT(to->to_cc, taop->tao_cc)) {
-                       sc->sc_rxtslot = 0;
-                       so = syncache_socket(sc, *sop, m);
-                       if (so != NULL) {
-                               taop->tao_cc = to->to_cc;
-                               *sop = so;
-                       }
-                       syncache_free(sc);
-                       return (so != NULL);
-               }
-       } else {
-               /*
-                * No CC option, but maybe CC.NEW: invalidate cached value.
-                */
-               if (taop != NULL)
-                       taop->tao_cc = 0;
-       }
-       /*
-        * TAO test failed or there was no CC option,
-        *    do a standard 3-way handshake.
-        */
        if (syncache_respond(sc, m) == 0) {
                syncache_insert(sc, sch);
                tcpstat.tcps_sndacks++;
@@ -1156,7 +1087,6 @@ syncache_respond(struct syncache *sc, struct mbuf *m)
                optlen = TCPOLEN_MAXSEG +
                    ((sc->sc_flags & SCF_WINSCALE) ? 4 : 0) +
                    ((sc->sc_flags & SCF_TIMESTAMP) ? TCPOLEN_TSTAMP_APPA : 0) +
-                   ((sc->sc_flags & SCF_CC) ? TCPOLEN_CC_APPA * 2 : 0) +
                    ((sc->sc_flags & SCF_SACK_PERMITTED) ?
                        TCPOLEN_SACK_PERMITTED_ALIGNED : 0);
        }
@@ -1259,19 +1189,6 @@ syncache_respond(struct syncache *sc, struct mbuf *m)
                optp += TCPOLEN_TSTAMP_APPA;
        }
 
-       /*
-        * Send CC and CC.echo if we received CC from our peer.
-        */
-       if (sc->sc_flags & SCF_CC) {
-               u_int32_t *lp = (u_int32_t *)(optp);
-
-               *lp++ = htonl(TCPOPT_CC_HDR(TCPOPT_CC));
-               *lp++ = htonl(sc->sc_cc_send);
-               *lp++ = htonl(TCPOPT_CC_HDR(TCPOPT_CCECHO));
-               *lp   = htonl(sc->sc_cc_recv);
-               optp += TCPOLEN_CC_APPA * 2;
-       }
-
        if (sc->sc_flags & SCF_SACK_PERMITTED) {
                *((u_int32_t *)optp) = htonl(TCPOPT_SACK_PERMITTED_ALIGNED);
                optp += TCPOLEN_SACK_PERMITTED_ALIGNED;
index ff0d99d..ddd7b73 100644 (file)
@@ -552,14 +552,14 @@ tcp_timer_rexmt_handler(struct tcpcb *tp)
        TCPT_RANGESET(tp->t_rxtcur, rexmt,
                      tp->t_rttmin, TCPTV_REXMTMAX);
        /*
-        * Disable rfc1323 and rfc1644 if we havn't got any response to
+        * Disable rfc1323 if we havn't got any response to
         * our third SYN to work-around some broken terminal servers
         * (most of which have hopefully been retired) that have bad VJ
         * header compression code which trashes TCP segments containing
         * unknown-to-them TCP options.
         */
        if ((tp->t_state == TCPS_SYN_SENT) && (tp->t_rxtshift == 3))
-               tp->t_flags &= ~(TF_REQ_SCALE|TF_REQ_TSTMP|TF_REQ_CC);
+               tp->t_flags &= ~(TF_REQ_SCALE|TF_REQ_TSTMP);
        /*
         * If losing, let the lower level know and try for
         * a better route.  Also, if we backed off this far,
index 916c2c4..efa9360 100644 (file)
@@ -867,9 +867,6 @@ tcp_connect_oncpu(struct tcpcb *tp, int flags, struct mbuf *m,
        struct inpcb *inp = tp->t_inpcb, *oinp;
        struct socket *so = inp->inp_socket;
        struct route *ro = &inp->inp_route;
-       struct tcpcb *otp;
-       struct rmxp_tao *taop;
-       struct rmxp_tao tao_noncached;
 
        oinp = in_pcblookup_hash(&tcbinfo[mycpu->gd_cpuid],
            sin->sin_addr, sin->sin_port,
@@ -877,15 +874,8 @@ tcp_connect_oncpu(struct tcpcb *tp, int flags, struct mbuf *m,
                inp->inp_laddr : if_sin->sin_addr,
            inp->inp_lport, 0, NULL);
        if (oinp != NULL) {
-               if (oinp != inp && (otp = intotcpcb(oinp)) != NULL &&
-                   otp->t_state == TCPS_TIME_WAIT &&
-                   (ticks - otp->t_starttime) < tcp_msl &&
-                   (otp->t_flags & TF_RCVD_CC)) {
-                       tcp_close(otp);
-               } else {
-                       m_freem(m);
-                       return (EADDRINUSE);
-               }
+               m_freem(m);
+               return (EADDRINUSE);
        }
        if (inp->inp_laddr.s_addr == INADDR_ANY)
                inp->inp_laddr = if_sin->sin_addr;
@@ -948,24 +938,6 @@ tcp_connect_oncpu(struct tcpcb *tp, int flags, struct mbuf *m,
        }
 
        /*
-        * Generate a CC value for this connection and
-        * check whether CC or CCnew should be used.
-        */
-       if ((taop = tcp_gettaocache(&tp->t_inpcb->inp_inc)) == NULL) {
-               taop = &tao_noncached;
-               bzero(taop, sizeof *taop);
-       }
-
-       tp->cc_send = CC_INC(tcp_ccgen);
-       if (taop->tao_ccsent != 0 &&
-           CC_GEQ(tp->cc_send, taop->tao_ccsent)) {
-               taop->tao_ccsent = tp->cc_send;
-       } else {
-               taop->tao_ccsent = 0;
-               tp->t_flags |= TF_SENDCCNEW;
-       }
-
-       /*
         * Close the send side of the connection after
         * the data is sent if flagged.
         */
@@ -1024,10 +996,7 @@ tcp6_connect_handler(netmsg_t netmsg)
  * Common subroutine to open a TCP connection to remote host specified
  * by struct sockaddr_in in mbuf *nam.  Call in_pcbbind to assign a local
  * port number if needed.  Call in_pcbladdr to do the routing and to choose
- * a local host address (interface).  If there is an existing incarnation
- * of the same connection in TIME-WAIT state and if the remote host was
- * sending CC options and if the connection duration was < MSL, then
- * truncate the previous TIME-WAIT state and proceed.
+ * a local host address (interface).
  * Initialize connection parameters and enter SYN-SENT state.
  */
 static int
@@ -1176,9 +1145,6 @@ tcp6_connect_oncpu(struct tcpcb *tp, int flags, struct mbuf *m,
        struct inpcb *inp = tp->t_inpcb;
        struct socket *so = inp->inp_socket;
        struct inpcb *oinp;
-       struct tcpcb *otp;
-       struct rmxp_tao *taop;
-       struct rmxp_tao tao_noncached;
 
        /*
         * Cannot simply call in_pcbconnect, because there might be an
@@ -1191,15 +1157,8 @@ tcp6_connect_oncpu(struct tcpcb *tp, int flags, struct mbuf *m,
                                      addr6 : &inp->in6p_laddr,
                                  inp->inp_lport,  0, NULL);
        if (oinp) {
-               if (oinp != inp && (otp = intotcpcb(oinp)) != NULL &&
-                   otp->t_state == TCPS_TIME_WAIT &&
-                   (ticks - otp->t_starttime) < tcp_msl &&
-                   (otp->t_flags & TF_RCVD_CC)) {
-                       otp = tcp_close(otp);
-               } else {
-                       m_freem(m);
-                       return (EADDRINUSE);
-               }
+               m_freem(m);
+               return (EADDRINUSE);
        }
        if (IN6_IS_ADDR_UNSPECIFIED(&inp->in6p_laddr))
                inp->in6p_laddr = *addr6;
@@ -1241,24 +1200,6 @@ tcp6_connect_oncpu(struct tcpcb *tp, int flags, struct mbuf *m,
        }
 
        /*
-        * Generate a CC value for this connection and
-        * check whether CC or CCnew should be used.
-        */
-       if ((taop = tcp_gettaocache(&tp->t_inpcb->inp_inc)) == NULL) {
-               taop = &tao_noncached;
-               bzero(taop, sizeof *taop);
-       }
-
-       tp->cc_send = CC_INC(tcp_ccgen);
-       if (taop->tao_ccsent != 0 &&
-           CC_GEQ(tp->cc_send, taop->tao_ccsent)) {
-               taop->tao_ccsent = tp->cc_send;
-       } else {
-               taop->tao_ccsent = 0;
-               tp->t_flags |= TF_SENDCCNEW;
-       }
-
-       /*
         * Close the send side of the connection after
         * the data is sent if flagged.
         */
index 0d5e97d..356c901 100644 (file)
@@ -82,7 +82,6 @@
  * Kernel variables for tcp.
  */
 extern int tcp_do_rfc1323;
-extern int tcp_do_rfc1644;
 extern int tcp_do_rfc3390;
 extern int tcp_do_sack;
 extern int tcp_do_smartsack;
@@ -160,9 +159,7 @@ struct tcpcb {
 #define        TF_NEEDSYN      0x00000400      /* send SYN (implicit state) */
 #define        TF_NEEDFIN      0x00000800      /* send FIN (implicit state) */
 #define        TF_NOPUSH       0x00001000      /* don't push */
-#define        TF_REQ_CC       0x00002000      /* have/will request CC */
-#define        TF_RCVD_CC      0x00004000      /* a CC was received in SYN */
-#define        TF_SENDCCNEW    0x00008000      /* send CCnew instead of CC in SYN */
+/* 0x00001000 - 0x00008000 were used for T/TCP */
 #define        TF_MORETOCOME   0x00010000      /* More data to be appended to sock */
 #define        TF_LQ_OVERFLOW  0x00020000      /* listen queue overflow */
 #define        TF_LASTIDLE     0x00040000      /* connection was previously idle */
@@ -239,10 +236,6 @@ struct tcpcb {
        u_long  ts_recent_age;          /* when last updated */
        tcp_seq last_ack_sent;
 
-/* RFC 1644 variables */
-       tcp_cc  cc_send;                /* send connection count */
-       tcp_cc  cc_recv;                /* receive connection count */
-
 /* experimental */
        u_long  snd_cwnd_prev;          /* cwnd prior to retransmit */
        u_long  snd_wacked_prev;        /* prior bytes acked in send window */
@@ -404,17 +397,12 @@ static const int tcprexmtthresh = 3;
 struct tcpopt {
        u_long          to_flags;       /* which options are present */
 #define        TOF_TS                  0x0001          /* timestamp */
-#define        TOF_CC                  0x0002          /* CC and CCnew are exclusive */
-#define        TOF_CCNEW               0x0004
-#define        TOF_CCECHO              0x0008
 #define        TOF_MSS                 0x0010
 #define        TOF_SCALE               0x0020
 #define        TOF_SACK_PERMITTED      0x0040
 #define        TOF_SACK                0x0080
        u_int32_t       to_tsval;
        u_int32_t       to_tsecr;
-       tcp_cc          to_cc;          /* holds CC or CCnew */
-       tcp_cc          to_ccecho;
        u_int16_t       to_mss;
        u_int8_t        to_requested_s_scale;
        u_int8_t        to_nsackblocks;
@@ -429,8 +417,6 @@ struct syncache {
 #define sc_route       sc_inc.inc_route
 #define sc_route6      sc_inc.inc6_route
        u_int32_t       sc_tsrecent;
-       tcp_cc          sc_cc_send;             /* holds CC or CCnew */
-       tcp_cc          sc_cc_recv;
        tcp_seq         sc_irs;                 /* seq from peer */
        tcp_seq         sc_iss;                 /* our ISS */
        u_long          sc_rxttime;             /* retransmit time */
@@ -443,7 +429,6 @@ struct syncache {
 #define SCF_NOOPT              0x01            /* no TCP options */
 #define SCF_WINSCALE           0x02            /* negotiated window scaling */
 #define SCF_TIMESTAMP          0x04            /* negotiated timestamps */
-#define SCF_CC                 0x08            /* negotiated CC */
 #define SCF_UNREACH            0x10            /* icmp unreachable received */
 #define        SCF_SACK_PERMITTED      0x20            /* saw SACK permitted option */
        TAILQ_ENTRY(syncache) sc_hash;
@@ -455,25 +440,6 @@ struct syncache_head {
        u_int           sch_length;
 };
 
-/*
- * The TAO cache entry which is stored in the protocol family specific
- * portion of the route metrics.
- */
-struct rmxp_tao {
-       tcp_cc  tao_cc;                 /* latest CC in valid SYN */
-       tcp_cc  tao_ccsent;             /* latest CC sent to peer */
-       u_short tao_mssopt;             /* peer's cached MSS */
-
-#ifdef notyet
-       u_short tao_flags;              /* cache status flags */
-#define        TAOF_DONT       0x0001          /* peer doesn't understand rfc1644 */
-#define        TAOF_OK         0x0002          /* peer does understand rfc1644 */
-#define        TAOF_UNDEF      0               /* we don't know yet */
-#endif
-};
-
-#define rmx_taop(rt)   ((struct rmxp_tao *)(rt).rmx_filler)
-
 #define        intotcpcb(ip)   ((struct tcpcb *)(ip)->inp_ppcb)
 #define        sototcpcb(so)   (intotcpcb(sotoinpcb(so)))
 
@@ -531,7 +497,7 @@ struct      xtcpcb {
  * Names for TCP sysctl objects
  */
 #define        TCPCTL_DO_RFC1323       1       /* use RFC-1323 extensions */
-#define        TCPCTL_DO_RFC1644       2       /* use RFC-1644 extensions */
+/* 2 was TCPCTL_DO_RFC1644 */
 #define        TCPCTL_MSSDFLT          3       /* MSS default */
 #define TCPCTL_STATS           4       /* statistics (read-only) */
 #define        TCPCTL_RTTDFLT          5       /* default RTT estimate */
@@ -548,7 +514,7 @@ struct      xtcpcb {
 #define TCPCTL_NAMES { \
        { 0, 0 }, \
        { "rfc1323", CTLTYPE_INT }, \
-       { "rfc1644", CTLTYPE_INT }, \
+         { "reserved", CTLTYPE_INT},   /* was rfc1644 */       \
        { "mssdflt", CTLTYPE_INT }, \
        { "stats", CTLTYPE_STRUCT }, \
        { "rttdflt", CTLTYPE_INT }, \
@@ -597,8 +563,6 @@ struct tcpcb *
         tcp_drop (struct tcpcb *, int);
 void    tcp_drain (void);
 void    tcp_fasttimo (void);
-struct rmxp_tao *
-        tcp_gettaocache (struct in_conninfo *);
 void    tcp_init (void);
 void    tcp_thread_init (void);
 void    tcp_input (struct mbuf *, ...);