





Network Working Group                                          R. Braden
Request for Comments: 1379                                           ISI
                                                           November 1992


               Extending TCP for Transactions -- Concepts

Status of This Memo

   This memo provides information for the Internet community.  It does
   not specify an Internet standard.  Distribution of this memo is
   unlimited.

Abstract

   This memo discusses extension of TCP to provide transaction-oriented
   service, without altering its virtual-circuit operation.  This
   extension would fill the large gap between connection-oriented TCP
   and datagram-based UDP, allowing TCP to efficiently perform many
   applications for which UDP is currently used.  A separate memo
   contains a detailed functional specification for this proposed
   extension.

   This work was supported in part by the National Science Foundation
   under Grant Number NCR-8922231.

TABLE OF CONTENTS

   1. INTRODUCTION ..................................................  2
   2. TRANSACTIONS USING STANDARD TCP ...............................  3
   3. BYPASSING THE 3-WAY HANDSHAKE .................................  6
      3.1  Concept of TAO ...........................................  6
      3.2  Cache Initialization ..................................... 10
      3.3  Accepting <SYN,ACK> Segments ............................. 11
   4. SHORTENING TIME-WAIT STATE .................................... 13
   5. CHOOSING A MONOTONIC SEQUENCE ................................. 15
      5.1  Cached Timestamps ........................................ 16
      5.2  Current TCP Sequence Numbers ............................. 18
      5.3  64-bit Sequence Numbers .................................. 20
      5.4  Connection Counts ........................................ 20
      5.5  Conclusions .............................................. 21
   6. CONNECTION STATES ............................................. 24
   7. CONCLUSIONS AND ACKNOWLEDGMENTS ............................... 32
   APPENDIX A: TIME-WAIT STATE AND THE 2-PACKET EXCHANGE ............ 34
   REFERENCES ....................................................... 37
   Security Considerations .......................................... 38
   Author's Address ................................................. 38




Braden                                                          [Page 1]

RFC 1379              Transaction TCP -- Concepts          November 1992


1. INTRODUCTION

   The TCP protocol [STD-007] implements a virtual-circuit transport
   service that provides reliable and ordered data delivery over a
   full-duplex connection.  Under the virtual circuit model, the life of
   a connection is divided into three distinct phases: (1) opening the
   connection to create a full-duplex byte stream; (2) transferring data
   in one or both directions over this stream; and (3) closing the
   connection.  Remote login and file transfer are examples of
   applications that are well suited to virtual-circuit service.

   Distributed applications, which are becoming increasingly numerous
   and sophisticated in the Internet, tend to use a transaction-oriented
   rather than a virtual circuit style of communication.  Currently, a
   transaction-oriented Internet application must choose to suffer the
   overhead of opening and closing TCP connections or else build an
   application-specific transport mechanism on top of the connectionless
   transport protocol UDP.  Greater convenience, uniformity, and
   efficiency would result from widely-available kernel implementations
   of a transport protocol supporting a transaction service model [RFC-
   955].

   The transaction service model has the following features:

   *    The fundamental interaction is a request followed by a response.

   *    An explicit open or close phase would impose excessive overhead.

   *    At-most-once semantics is required; that is, a transaction must
        not be "replayed" by a duplicate request packet.

   *    In favorable circumstances, a reliable request/response
        handshake can be performed with exactly one packet in each
        direction.

   *    The minimum transaction latency for a client is RTT + SPT, where
        RTT is the round-trip time and SPT is the server processing
        time.

   We use the term "transaction transport protocol" for a transport-
   layer protocol that follows this model [RFC-955].

   The Internet architecture allows an arbitrary collection of transport
   protocols to be defined on top of the minimal end-to-end datagram
   service provided by IP [Clark88].  In practice, however, production
   systems implement only TCP and UDP at the transport layer.  It has
   proven difficult to leverage a new transport protocol into place, to
   be widely enough available to be useful for application builders.



Braden                                                          [Page 2]

RFC 1379              Transaction TCP -- Concepts          November 1992


   This memo explores an alternative approach to providing a transaction
   transport protocol: extending TCP to implement the transaction
   service model, while continuing to support the virtual circuit model.
   Each transaction will then be a single instance of a TCP connection.
   The proposed transaction extension is effectively implementable
   within current TCPs and operating systems, and it should also scale
   to the much faster networks, interfaces, and CPUs of the future.

   The present memo explains the theory behind the extension, in
   somewhat exquisite detail.  Despite the length and complexity of this
   memo, the TCP extensions required for transactions are in fact quite
   limited and simple.  Another memo [TTCP-FS] provides a self-contained
   functional specification of the extensions.

   Section 2 of this memo describes the limitations of standard TCP for
   transaction processing, to motivate the extensions.  Sections 3, 4,
   and 5 explore the fundamental extensions that are required for
   transactions.  Section 6 discusses the changes required in the TCP
   connection state diagram.  Finally, Section 7 presents conclusions
   and acknowledgments.  Familiarity with the standard TCP protocol
   [STD-007] is assumed.

2.  TRANSACTIONS USING STANDARD TCP

   Reliable transfer of data depends upon sequence numbers.  Before data
   transfer can begin, both parties must "synchronize" the connection,
   i.e, agree on common sequence numbers.  The synchronization procedure
   must preserve at-most-once semantics, i.e., be free from replay
   hazards due to duplicate packets.  The TCP developers adopted a
   synchronization mechanism known as the 3-way handshake.

   Consider a simple transaction in which client host A sends a single-
   segment request to server host B, and B returns a single-segment
   response.  Many current TCP implementations use at least ten segments
   (i.e., packets) for this sequence: three for the 3-way handshake
   opening the connection, four to send and acknowledge the request and
   response data, and three for TCP's full-duplex data-conserving close
   sequence.  These ten segments represent a high relative overhead for
   two data-bearing segments.  However, a more important consideration
   is the transaction latency seen by the client:  2*RTT + SPT, larger
   than the minimum by one RTT.  As CPU and network speeds increase, the
   relative significance of this extra transaction latency also
   increases.

   Proposed transaction transport protocols have typically used a
   "timer-based" approach to connection synchronization [Birrell84].  In
   this approach, once end-to-end connection state is established in the
   client and server hosts, a subset of this state is maintained for



Braden                                                          [Page 3]

RFC 1379              Transaction TCP -- Concepts          November 1992


   some period of time.  A new request before the expiration of this
   timeout period can then reestablish the full state without an
   explicit handshake.  Watson pointed out that the timer-based approach
   of his Delta-T protocol [Watson81] would encompass both virtual
   circuits and transactions.  However, the TCP group adopted the 3-way
   handshake (because of uncertainty about the robustness of enforcing
   the packet lifetime bounds required by Delta-T, within a general
   Internet environment).  More recently, Liskov, Shrira, and Wroclawski
   [Liskov90] have proposed a different timer-based approach to
   connection synchronization, requiring loosely-synchronized clocks in
   the hosts.

   The technique proposed in this memo, suggested by Clark [Clark89],
   depends upon cacheing of connection state but not upon clocks or
   timers; it is described in Section 3 below.  Garlick, Rom, and Postel
   also proposed a connection synchronization mechanism using cached
   state [Garlick77].  Their scheme required each host to maintain
   connection records containing the highest sequence number on each
   connection.  The technique suggested here retains only per-host
   state, not per-connection state.

   During TCP development, it was suggested that TCP could support
   transactions with data segments containing both SYN and FIN bits.
   (These "Kamikaze" segments were not supported as a service; they were
   used mainly to crash other experimental TCPs!)  To illustrate this
   idea, Figure 1 shows a plausible application of the current TCP rules
   to create a minimal transaction.  (In fact, some minor adjustments in
   the standard TCP spec would be required to make Figure 1 fully legal
   [STD-007]).

   Figure 1, like many of the examples shown in this memo, uses an
   abbreviated form to illustrate segment sequences.  For clarity and
   brevity, it omits explicit sequence and acknowledgment numbers,
   assuming that these will follow the well-known TCP rules.  The
   notation "ACK(x)" implies a cumulative acknowledgment for the control
   bit or data "x" and everything preceding "x" in the sequence space.
   The referent of "x" should be clear from the context.  Also, host A
   will always be the client and host B will be the server in these
   diagrams.

   The first three segments in Figure 1 implement the standard TCP
   three-way handshake.  If segment #1 had been an old duplicate, the
   client side would have sent an RST (Reset) bit in segment #3,
   terminating the sequence.  The request data included on the initial
   SYN segment cannot be delivered to user B until segment #3 completes
   the 3-way handshake.  Loading control bits onto the segments has
   reduced the total number of segments to 5, but the client still
   observes a transaction latency of 2*RTT + SPT.  The 3-way handshake



Braden                                                          [Page 4]

RFC 1379              Transaction TCP -- Concepts          November 1992


   thus precludes high-performance transaction processing.


       TCP A  (Client)                                 TCP B (Server)
       _______________                                 ______________

       CLOSED                                               LISTEN

   (Client sends request)
    1. SYN-SENT             --> <SYN,data1,FIN> -->       SYN-RCVD
                                                       (data1 queued)

    2. ESTABLISHED  <-- <SYN,ACK(SYN)> <--                SYN-RCVD


    3. FIN-WAIT-1            --> <ACK(SYN),FIN> -->     CLOSE-WAIT
                                                    (data1 to server)

                                                 (Server sends reply)
    4. TIME-WAIT    <-- <ACK(FIN),data2,FIN> <--          LAST-ACK
    (data2 to client)

    5. TIME-WAIT                 --> <ACK(FIN)> -->         CLOSED

       (timeout)
       CLOSED

               Figure 1: Transaction Sequence: RFC-793 TCP


   The TCP close sequence also poses a performance problem for
   transactions: one or both end(s) of a closed connection must remain
   in "TIME-WAIT" state until a 4 minute timeout has expired [STD-007].
   The same connection (defined by the host and port numbers at both
   ends) cannot be reopened until this delay has expired.  Because of
   TIME-WAIT state, a client program should choose a new local port
   number (i.e., a different connection) for each successive
   transaction.  However, the TCP port field of 16 bits (less the
   "well-known" port space) provides only 64512 available user ports.
   This limits the total rate of transactions between any pair of hosts
   to a maximum of 64512/240 = 268 per second.  This is much too low a
   rate for low-delay paths, e.g., high-speed LANs.  A high rate of
   short connections (i.e., transactions) could also lead to excessive
   consumption of kernel memory by connection control blocks in TIME-
   WAIT state.

   In summary, to perform efficient transaction processing in TCP, we
   need to suppress the 3-way handshake and to shorten TIME-WAIT state.



Braden                                                          [Page 5]

RFC 1379              Transaction TCP -- Concepts          November 1992


   Protocol mechanisms to accomplish these two goals are discussed in
   Sections 3 and 4, respectively.  Both require the choice of a
   monotonic sequence-like space; Section 5 analyzes the choices and
   makes a selection for this space.  Finally, the TCP connection state
   machine must be extended as described in Section 6.

   Transaction processing in TCP raises some other protocol issues,
   which are discussed in the functional specification memo [TTCP-FS].
   These include:

   (1)  augmenting the user interface for transactions,

   (2)  delaying acknowledgment segments to allow maximum piggy-backing
        of control bits with data,

   (3)  measuring the retransmission timeout time (RTO) on very short
        connections, and

   (4)  providing an initial server window.

   A recently proposed set of enhancements [RFC-1323] defines a TCP
   Timestamps option that carries two 32-bit timestamp values.  The
   Timestamps option is used to accurately measure round-trip time
   (RTT).  The same option is also used in a procedure known as "PAWS"
   (Protect Againsts Wrapped Sequence) to prevent erroneous data
   delivery due to a combination of old duplicate segments and sequence
   number reuse at very high bandwidths.  The particular approach to
   transactions chosen in this memo does not require the RFC-1323
   enhancements; however, they are important and should be implemented
   in every TCP, with or without the transaction extensions described
   here.

3.  BYPASSING THE 3-WAY HANDSHAKE

   To avoid 3-way handshakes for transactions, we introduce a new
   mechanism for validating initial SYN segments, i.e., for enforcing
   at-most-once semantics without a 3-way handshake.  We refer to this
   as the TCP Accelerated Open, or TAO, mechanism.

   3.1 Concept of TAO

      The basis of TAO is this: a TCP uses cached per-host information
      to immediately validate new SYNs [Clark89].  If this validation
      fails, e.g., because there is no current cached state or the
      segment is an old duplicate, the procedure falls back to a normal
      3-way handshake to validate the SYN.  Thus, bypassing a 3-way
      handshake is considered to be an optional optimization.




Braden                                                          [Page 6]

RFC 1379              Transaction TCP -- Concepts          November 1992


      The proposed TAO mechanism uses a finite sequence-like space of
      values that increase monotonically with successive transactions
      (connections) between a given (client, server) host pair.  Call
      this monotonic space M, and let each initial SYN segment carry an
      M value SEG.M.  If M is not the existing sequence (SEG.SEQ) field,
      SEG.M may be carried in a TCP option.

      When host B receives from host A an initial SYN segment containing
      a new value SEG.M, host B compares this against cache.M[A], the
      latest M value that B has cached for host A.  This comparison is
      the "TAO test".  Because the M values are monotonically
      increasing, SEG.M > cache.M[A] implies that the SYN must be new
      and can be accepted immediately.  If not, a normal 3-way handshake
      is performed to validate the initial SYN segment.  Figure 2
      illustrates the TAO mechanism; cached M values are shown enclosed
      in square brackets.  The M values generated by host A satisfy
      x0 < x1, and the M values generated by host B satisfy y0 < y1.

      An appropriate choice for the M value space is discussed in
      Section 5.  M values are drawn from a finite number space, so
      inequalities must be defined in the usual way for sequence numbers
      [STD-007].  The M space must not wrap so quickly that an old
      duplicate SYN will be erroneously accepted.  We assume that some
      maximum segment lifetime (MSL) is enforced by the IP layer.

        ____T_C_P__A_____                                ____T_C_P__B_____

            cache.M[B]                                  cache.M[A]
               V                                            V

            [ y0 ]                                       [ x0 ]

      1.             -->  <SYN,data1,M=x1> -->       ( (x1 > x0) =>
                                                      data1 -> user_B;
                                                      cache.M[A]= x1)

            [ y0 ]                                       [ x1 ]
      2.            <-- <SYN,ACK(data1),data2,M=y1> <--

         (data2 -> user_A,
          cache.M[B]= y1)

            [ y1 ]                                       [ x1 ]
                              ... (etc.) ...


                   Figure 2. TAO: Three-Way Handshake is Bypassed




Braden                                                          [Page 7]

RFC 1379              Transaction TCP -- Concepts          November 1992


      Figure 2 shows the simplest case: each side has cached the latest
      M value of the other, and the SEG.M value in the client's SYN
      segment is greater than the value in the cache at the server host.
      As a result, B can accept the client A's request data1 immediately
      and pass it to the server application.  B's reply data2 is shown
      piggybacked on the <SYN,ACK> segment.  As a result of this 2-way
      exchange, the cached M values are updated at both sites; the
      client side becomes relevant only if the client/server roles
      reverse.  Validation of the <SYN,ACK> segment at host A is
      discussed later.

      Figure 3 shows the TAO test failing but the consequent 3-way
      handshake succeeding.  B updates its cache with the value x2 >= x1
      when the initial SYN is known to be valid.


           _T_C_P__A                                     _T_C_P__B

            cache.M[B]                                  cache.M[A]
               V                                           V

            [ y0 ]                                       [ x0 ]
      1.                 --> <SYN,data1,M=x1> -->   ( (x1 <= x0) =>
                                                    data1 queued;
                                                    3-way handshake)

            [ y0 ]                                       [ x0 ]
      2.                <-- <SYN,ACK(SYN),M=y1> <--
         (cache.M[B]= y1)

            [ y1 ]                                       [ x0 ]
      3.                  --> <ACK(SYN),M=x2> -->  (Handshake OK =>
                                                   data1->user_B,
                                                   cache.M[A]= x2)

            [ y1 ]                                       [ x2 ]
                            ...  (etc.)  ...

          Figure 3. TAO Test Fails but 3-Way Handshake Succeeds.

      There are several possible causes for a TAO test failure on a
      legitimate new SYN segment (not an old duplicate).

      (1)  There may be no cached M value for this particular client
           host.

      (2)  The SYN may be the one of a set of nearly-simultaneous SYNs
           for different connections but from the same host, which



Braden                                                          [Page 8]

RFC 1379              Transaction TCP -- Concepts          November 1992


           arrived out of order.

      (3)  The finite M space may have wrapped around between successive
           transactions from the same client.

      (4)  The M values may advance too slowly for closely-spaced
           transactions.

      None of these TAO failures will cause a lockout, because the
      resulting 3-way handshake will succeed.  Note that the first
      transaction between a given host pair will always require a 3-way
      handshake; subsequent transactions can take advantage of TAO.

      The per-host cache required by TAO is highly desirable for other
      reasons, e.g., to retain the measured round trip time and MTU for
      a given remote host.  Furthermore, a host should already have a
      per-host routing cache [HR-COMM] that should be easily extensible
      for this purpose.

      Figure 4 illustrates a complete TCP transaction sequence using the
      TAO mechanism.  Bypassing the 3-way handshake leads to new
      connection states; Figure 4 shows three of them, "SYN-SENT*",
      "CLOSE-WAIT*", and "LAST-ACK*".  Explanation of these states is
      deferred to Section 6.


          TCP A  (Client)                                 TCP B (Server)
          _______________                                 ______________

          CLOSED                                                  LISTEN

      1.  SYN-SENT*    --> <SYN,data1,FIN,M=x1> -->          CLOSE-WAIT*
                                                         (TAO test OK=>
                                                          data1->user_B)

                   <-- <SYN,ACK(FIN),data2,FIN,M=y1> <--       LAST-ACK*
      2.  TIME-WAIT
       (data2->user_A)


      3.  TIME-WAIT          --> <ACK(FIN),M=x2> -->              CLOSED

          (timeout)
            CLOSED


               Figure 4: Minimal Transaction Sequence Using TAO




Braden                                                          [Page 9]

RFC 1379              Transaction TCP -- Concepts          November 1992


   3.2 Cache Initialization

      The first connection between hosts A and B will find no cached
      state at one or both ends, so both M caches must be initialized.
      This requires that the first transaction carry a specially marked
      SEG.M value, which we call SEG.M.NEW.  Receiving a SEG.M.NEW value
      in an initial SYN segment, B will cache this value and send its
      own M back to initialize A's cache.  When a host crashes and
      restarts, all its cached M values cache.M[*] must be invalidated
      in order to force a re-synchronization of the caches at both ends.

      This cache synchronization procedure is illustrated in Figure 5,
      where client host A has crashed and restarted with its cache
      entries undefined, as indicated by "??".  Since cache.TS[B] is
      undefined, A sends a SEG.M.NEW value instead of SEG.M in the <SYN>
      segment of its first transaction request to B.  Receiving this
      SEG.M.NEW, the server host B invalidates cache.TS[A] and performs
      a 3-way handshake.  SEG.M in segment #2 updates A's cache, and
      when the handshake completes successfully, B updates its cached M
      value to x2 >= x1.


           _T_C_P__A                                     _T_C_P__B

            cache.M[B]                                  cache.M[A]
               V                                           V
            [ ?? ]                                       [ x0 ]

      1.           --> <SYN,data1,M.NEW=x1> -->   (invalidate cache;
                                                        queue data1;
            [ ?? ]                                  3-way handshake)

                                                         [ ?? ]
      2.              <-- <SYN,ACK(SYN),M=y1> <--
         (cache.M[B]= y1)

            [ y1 ]                                       [ ?? ]

      3.                  --> <ACK(SYN),M=x2> -->  data1->user_B,
                                                   cache.M[A]= x2)

            [ y1 ]                                       [ x2 ]
                            ...  (etc.)  ...

                  Figure 5.  Client Host Crashed


      Suppose that the 3-way handshake failed, presumably because



Braden                                                         [Page 10]

RFC 1379              Transaction TCP -- Concepts          November 1992


      segment #1 was an old duplicate.  Then segment #3 from host A
      would be an RST segment, with the result that both side's caches
      would be left undefined.

      Figure 6 shows the procedure when the server crashes and restarts.
      Upon receiving a <SYN> segment from a host for which it has no
      cached M value, B initiates a 3-way handshake to validate the
      request and sends its own M value to A.  Again the result is to
      update cached M values on both sides.


              _T_C_P__A                                     _T_C_P__B

               cache.M[B]                                  cache.M[A]
                  V                                           V
               [ y0 ]                                       [ ?? ]

         1.               --> <SYN,data1,M=x1> -->      (data1 queued;
                                                       3-way handshake)

               [ y0 ]                                       [ ?? ]
         2.              <-- <SYN,ACK(SYN),M=y1> <--
            (cache.M[B]= y1)

               [ y1 ]                                       [ ?? ]
         3.                --> <ACK(SYN),M=x2> -->   (data1->user_B,
                                                      cache.M[A]= x2)

               [ y1 ]                                       [ x2 ]
                               ...  (etc.)  ...


                        Figure 6. Server Host Crashed


   3.3  Accepting <SYN,ACK> Segments

      Transactions introduce a new hazard of erroneously accepting an
      old duplicate <SYN,ACK> segment.  To be acceptable, a <SYN,ACK>
      segment must arrive in SYN-SENT state, and its ACK field must
      acknowledge something that was sent.  In current TCPs the
      effective send window in SYN-SENT state is exactly one octet, and
      an acceptable <SYN,ACK> must exactly ACK this one octet.  The
      clock-driven selection of Initial Sequence Number (ISN) makes an
      erroneous acceptance exceedingly unlikely.  An old duplicate SYN
      could be accepted erroneously only if successive connection
      attempts occurred more often than once every 4 microseconds, or if
      the segment lifetime exceeded the 4 hour wraparound time for ISN



Braden                                                         [Page 11]

RFC 1379              Transaction TCP -- Concepts          November 1992


      selection.

      However, when TCP is used for transactions, data sent with the
      initial SYN increases the range of sequence numbers that have been
      sent.  This increases the danger of accepting an old duplicate
      <SYN,ACK> segment, and the consequences are more serious.  In the
      example in Figure 7, segments 1-3 form a normal transaction
      sequence, and segment 4 begins a new transaction (incarnation) for
      the same connection.  Segment #5 is a duplicate of segment #2 from
      the preceding transaction.  Although the new transaction has a
      larger ISN, the previous ACK value 402 falls into the new range
      [200,700) of sequence numbers that have been sent, so segment #5
      could be erroneously accepted and passed to the client as the
      response to the new request.

           _T_C_P__A                                       _T_C_P__B

         CLOSED                                                   LISTEN

      1.           --> <seq=100,SYN,data=300,FIN,M=x1> --> (TAO test OK)


      2.         <-- <seq=800,ack=402,SYN,data=350,FIN,M=y1> <--


      3. TIME-WAIT                      --> <ACK(FIN)> -->       CLOSED
         (short timeout)
         CLOSED

         (New Request)
      4.           --> <seq=200,SYN,data=500,FIN,M=x2> --> ...

                                            (Duplicate of segment #2)
      5.         <-- <seq=800,ack=402,SYN,data=300,FIN,M=y1> <--...
         (Acceptable!!)


               Figure 7: Old Duplicate <SYN,ACK> Causing Error


      Unfortunately, we cannot simply use TAO on the client side to
      detect and reject old duplicate <SYN,ACK> segments.  A TAO test at
      the client might fail for a valid <SYN,ACK> segment, due to out-
      of-order delivery, and this could result in permanent non-delivery
      of a valid transaction reply.

      Instead, we include a second M value, an echo of the client's M
      value from the initial <SYN> segment, in the <SYN,ACK> segment.  A



Braden                                                         [Page 12]

RFC 1379              Transaction TCP -- Concepts          November 1992


      specially-marked M value, SEG.M.ECHO, is used for this purpose.
      The client knows the value it sent in the initial <SYN> and can
      therefore positively validate the <SYN,ACK> using the echoed
      value.  This is illustrated in Figure 12, which is the same as
      Figure 4 with the addition of the echoed value on the <SYN,ACK>
      segment #2.

      It should be noted that TCP allows a simultaneous open sequence in
      which both sides send and receive an initial <SYN> (see Figure 8
      of [STD-007].  In this case, the TAO test must be performed on
      both sides to preserve the symmetry.  See [TTCP-FS] for an
      example.

4.  SHORTENING TIME-WAIT STATE

   Once a transaction has been initiated for a particular connection
   (pair of ports) between a given host pair, a new transaction for the
   same connection cannot take place for a time that is at least:

       RTT + SPT + TIME-WAIT_delay

   Since the client host can cycle among the 64512 available port
   numbers, an upper bound on the transaction rate between a particular
   host pair is:

   [1]    TRmax = 64512 /(RTT + TIME-WAIT_Delay)

   in transactions per second (Tps), where we assumed SPT is negligible.
   We must reduce TIME-WAIT_Delay to support high-rate TCP transaction
   processing.

   TIME-WAIT state performs two functions: (1) supporting the full-
   duplex reliable close of TCP, and (2) allowing old duplicate segments
   from an earlier connection incarnation to expire before they can
   cause an error (see Appendix to [RFC-1185]).  The first function
   impacts the application model of a TCP connection, which we would not
   want to change.  The second is part of the fundamental machinery of
   TCP reliable delivery; to safely truncate TIME-WAIT state, we must
   provide another means to exclude duplicate packets from earlier
   incarnations of the connection.

   To minimize the delay in TIME-WAIT state while performing both
   functions, we propose to set the TIME-WAIT delay to:

   [2]    TIME-WAIT_Delay = max( K*RTO, U )

   where U and K are constants and RTO is the dynamically-determined
   retransmission timeout, the measured RTT plus an allowance for the



Braden                                                         [Page 13]

RFC 1379              Transaction TCP -- Concepts          November 1992


   RTT variance [Jacobson88].  We choose K large enough so that there is
   high probability of the close completing successfully if at all
   possible; K = 8 seems reasonable.  This takes care of the first
   function of TIME-WAIT state.

   In a real implementation, there may be a minimum RTO value Tr,
   corresponding to the precision of RTO calculation.  For example, in
   the popular BSD implementation of TCP, the minimum RTO is Tr = 0.5
   second.  Assuming K = 8 and U = 0, Eqns [1] and [2] impose an upper
   limit of TRmax = 16K Tps on the transaction rate of these
   implementations.

   It is possible to have many short connections only if RTO is very
   small, in which case the TIME-WAIT delay [2] reduces to U.  To
   accelerate the close sequence, we need to reduce U below the MSL
   enforced by the IP layer, without introducing a hazard from old
   duplicate segments.  For this purpose, we introduce another monotonic
   number sequence; call it X.  X values are required to be monotonic
   between successive connection incarnations; depending upon the choice
   of the X space (see Section 5), X values may also increase during a
   connection.  A value from the X space is to be carried in every
   segment, and a segment is rejected if it is received with an X value
   smaller than the largest X value received.  This mechanism does not
   use a cache; the largest X value is maintained in the TCP connection
   control block (TCB) for each connection.

   The value of U depends upon the choice for the X space, discussed in
   the next section.  If X is time-like, U can be set to twice the time
   granularity (i.e, twice the minimum "tick" time) of X.  The TIME-WAIT
   delay will then ensure that current X values do not overlap the X
   values of earlier incarnations of the same connection.  Another
   consequence of time-like X values is the possibility that an open but
   idle connection might allow the X value to wrap its sign bit,
   resulting in a lockup of the connection.  To prevent this, a 24-day
   idle timer on each open connection could bypass the X check on the
   first segment following the idle period, for example.  In practice,
   many implementations have keep-alive mechanisms that prevent such
   long idle periods [RFC-1323].

   Referring back to Figure 4, our proposed transaction extension
   results in a minimum exchange of 3 packets.  Segment #3, the final
   ACK segment, does not increase transaction latency, but in
   combination with the TIME-WAIT delay of K*RTO it ensures that the
   server side of the connection will be closed before a new transaction
   is issued for this same pair of ports.  It also provides an RTT
   measurement for the server.

   We may ask whether it would be possible to further reduce the TIME-



Braden                                                         [Page 14]

RFC 1379              Transaction TCP -- Concepts          November 1992


   WAIT delay.  We might set K to zero; alternatively, we might allow
   the client TCP to start a new transaction request while the
   connection was still in TIME-WAIT state, with the new initial SYN
   acting as an implied acknowledgment of the previous FIN.  Appendix A
   summarizes the issues raised by these alternatives, which we call
   "truncating" TIME-WAIT state, and suggests some possible solutions.
   Further study would be required, but these solutions appear to bend
   the theory and/or implementations of the TCP protocol farther than we
   wish to bend them.

   We therefore propose using formula [2] with K=8 and retaining the
   final ACK(FIN) transmission.  To raise the transaction rate,
   therefore, we require small values of RTO and U.

5.  CHOOSING A MONOTONIC SEQUENCE

   For simplicity, we want the monotonic sequence X used for shortening
   TIME-WAIT state to be identical to the monotonic sequence M for
   bypassing the 3-way handshake.  Calling the common space M, we will
   send an M value SEG.M in each TCP segment.  Upon receipt of an
   initial SYN segment, SEG.M will be compared with a per-host cached
   value to authenticate the SYN without a 3-way handshake; this is the
   TAO mechanism.  Upon receipt of a non-SYN segment, SEG.M will be
   compared with the current value in the connection control block and
   used to discard old duplicates.

   Note that the situation with TIME-WAIT state differs from that of
   bypassing 3-way handshakes in two ways: (a) TIME-WAIT requires
   duplicate detection on every segment vs. only on SYN segments, and
   (b) TIME-WAIT applies to a single connection vs. being global across
   all connections.  This section discusses possible choices for the
   common monotonic sequence.

   The SEG.M values must satisfy the following requirements.

   *    The values must be monotonic; this requirement is defined more
        precisely below.

   *    Their granularity must be fine-grained enough to support a high
        rate of transaction processing; the M clock must "tick" at least
        once between successive transactions.

   *    Their range (wrap-around time) must be great enough to allow a
        realistic MSL to be enforced by the network.

   The TCP spec calls for an MSL of 120 secs.  Since much of the
   Internet does not carefully enforce this limit, it would be safer to
   have an MSL at least an order of magnitude larger.  We set as an



Braden                                                         [Page 15]

RFC 1379              Transaction TCP -- Concepts          November 1992


   objective an MSL of at least 2000 seconds.  If there were no TIME-
   WAIT delay, the ultimate limit on transaction rate would be set by
   speed-of-light delays in the network and by the latency of host
   operating systems.  As the bottleneck problems with interfacing CPUs
   to gigabit LANs are solved, we can imagine transaction durations as
   short as 1 microsecond.  Therefore, we set an ultimate performance
   goal of TRmax at least 10**6 Tps.

   A particular connection between hosts A and B is identified by the
   local and remote TCP "sockets", i.e., by the quadruplet: {A, B,
   Port.A, Port.B}.  Imagine that each host keeps a count CC of the
   number of TCP connections it has initiated.  We can use this CC
   number to distinguish different incarnations of the same connection.
   Then a particular SEG.M value may be labeled implicitly by 6
   quantities: {A, B, Port.A, Port.B, CC, n}, where n is the byte offset
   of that segment within the connection incarnation.

   To bypass the 3-way handshake, we require thgt SEG.M values on
   successive SYN segments from a host A to a host B be monotone
   increasing.  If CC' > CC, then we require that:

       SEG.M(A,B,Port.A,Port.B,CC',0) >  SEG.M(A,B,Port.A,Port.B,CC,0)

   for any legal values of Port.A and Port.B.

   To delete old duplicates (allowing TIME-WAIT state to be shortened),
   we require that SEG.M values be disjoint across different
   incarnations of the same connection.   If CC' > CC then

       SEG.M(A,B,Port.A,Port.B,CC',n') > SEG.M(A,B,Port.A,Port.B,CC,n),

   for any non-negative integers n and n'.

   We now consider four different choices for the common monotonic
   space: RFC-1323 timestamps, TCP sequence numbers, the connection
   count, and 64-bit TCP sequence numbers.  The results are summarized
   in Table I.

   5.1 Cached Timestamps

      The PAWS mechanism [RFC-1323] uses TCP "timestamps" as
      monotonically increasing integers in order to throw out old
      duplicate segments within the same incarnation.  Jacobson
      suggested the cacheing of these timestamps for bypassing 3-way
      handshakes [Jacobson90], i.e., that TCP timestamps be used for our
      common monotonic space M.  This idea is attractive since it would
      allow the same timestamp options to be used for RTTM, PAWS, and
      transactions.



Braden                                                         [Page 16]

RFC 1379              Transaction TCP -- Concepts          November 1992


      To obtain at-most-once service, the criterion for immediate
      acceptance of a SYN must be that SEG.M is strictly greater than
      the cached M value.  That is, to be useful for bypassing 3-way
      handshakes, the timestamp clock must tick at least once between
      any two successive transactions between the same pair of hosts
      (even if different ports are used).  Hence, the timestamp clock
      rate would determine TRmax, the maximum possible transaction rate.

      Unfortunately, the timestamp clock frequency called for by RFC-
      1323, in the range 1 sec to 1 ms, is much too slow for
      transactions.  The TCP timestamp period was chosen to be
      comparable to the fundamental interval for computing and
      scheduling retransmission timeouts; this is generally in the range
      of 1 sec. to 1 ms., and in many operating systems, much closer to
      1 second.  Although it would be possible to increase the timestamp
      clock frequency by several orders of magnitude, to do so would
      make implementation more difficult, and on some systems
      excessively expensive.

      The wraparound time for TCP timestamps, at least 24 days, causes
      no problem for transactions.

      The PAWS mechanism uses TCP timestamps to protect against old
      duplicate non-SYN segments from the same incarnation [RFC-1323].
      It can also be used to protect against old duplicate data segments
      from earlier incarnations (and therefore allow shortening of
      TIME-WAIT state) if we can ensure that the timestamp clock ticks
      at least once between the end of one incarnation and the beginning
      of the next.  This can be achieved by setting U = 2 seconds, i.e.,
      to twice the maximum timestamp clock period.  This value in
      formula [2] leads to an upper bound TRmax = 32K Tps between a host
      pair.  However, as pointed out above, old duplicate SYN detection
      using timestamps leads to a smaller transaction rate bound, 1 Tps,
      which is unacceptable.  In addition, the timestamp approach is
      imperfect; it allows old ACK segments to enter the new connection
      where they can cause a disconnect.  This happens because old
      duplicate ACKs that arrive during TIME-WAIT state generate new
      ACKs with the current timestamp [RFC-1337].

      We therefore conclude that timestamps are not adequate as the
      monotonic space M; see Table I.  However, they may still be useful
      to effectively extend some other monotonic number space, just as
      they are used in PAWS to extend the TCP sequence number space.
      This is discussed below.







Braden                                                         [Page 17]

RFC 1379              Transaction TCP -- Concepts          November 1992


   5.2 Current TCP Sequence Numbers

      It is useful to understand why the existing 32-bit TCP sequence
      numbers do not form an appropriate monotonic space for
      transactions.

      The sequence number sent in an initial SYN is called the Initial
      Sequence Number or ISN.  According to the TCP specification, an
      ISN is to be selected using:

      [3]      ISN = (R*T) mod 2**32

      where T is the real time in seconds (from an arbitrary origin,
      fixed when the system is started) and R is a constant, currently
      250 KBps.  These ISN values form a monotonic time sequence that
      wraps in 4.55 hours = 16380 seconds and has a granularity of 4
      usecs.  For transaction rates up to roughly 250K Tps, the ISN
      value calculated by formula [3] will be monotonic and could be
      used for bypassing the 3-way handshake.

      However, TCP sequence numbers (alone) could not be used to shorten
      TIME-WAIT state, because there are several ways that overlap of
      the sequence space of successive incarnations can occur (as
      described in Appendix to [RFC-1185]).  One way is a "fast
      connection", with a transfer rate greater than R; another is a
      "long" connection, with a duration of approximately 4.55 hours.
      TIME-WAIT delay is necessary to protect against these cases.  With
      the official delay of 240 seconds, formula [1] implies a upper
      bound (as RTT -> 0) of TRmax = 268 Tps; with our target MSL of
      2000 sec, TRmax = 32 Tps.  These values are unacceptably low.

      To improve this transaction rate, we could use TCP timestamps to
      effectively extend the range of the TCP sequence numbers.
      Timestamps would guard against sequence number wrap-around and
      thereby allow us to increase R in [3] to exceed the maximum
      possible transfer rate.  Then sequence numbers for successive
      incarnations could not overlap.  Timestamps would also provide
      safety with an MSL as large as 24 days.  We could then set U = 0
      in the TIME-WAIT delay calculation [2].  For example, R = 10**9
      Bps leads to TRmax <= 10**9 Tps. See 2(b) in Table I.  These
      values would more than satisfy our objectives.

      We should make clear how this proposal, sequence numbers plus
      timestamps, differs from the timestamps alone discussed (and
      rejected) in the previous section.  The difference lies in what is
      cached and tested for TAO; the proposal here is to cache and test
      BOTH the latest TCP sequence number and the latest TCP timestamp.
      In effect, we are proposing to use timestamps to logically extend



Braden                                                         [Page 18]

RFC 1379              Transaction TCP -- Concepts          November 1992


      the sequence space to 64 bits.  Another alternative, presented in
      the next section, is to directly expand the TCP sequence space to
      64 bits.

      Unfortunately, the proposed solution (TCP sequence numbers plus
      timestamps) based on equation [3] would be difficult or impossible
      to implement on many systems, which base their TCP implementation
      upon a very low granularity software clock, typically O(1 sec).
      To adapt the procedure to a system with a low granularity software
      clock, suppose that we calculate the ISN as:

      [4]      ISN = ( R*Ts*floor(T/Ts) + q*CC) mod 2**32

      where Ts is the time per tick of the software clock, CC is the
      connection count, and q is a constant.  That is, the ISN is
      incremented by the constant R*Ts once every clock tick and by the
      constant q for every new connection.  We need to choose q to
      obtain the required monotonicity.

      For monotonicity of the ISN's themselves, q=1 suffices.  However,
      monotonicity during the entire connection requires q = R*Ts.  This
      value of q can be deduced as follows.  Let S(T, CC, n) be the
      sequence number for byte offset n in a connection with number CC
      at time T:

          S(T, CC, n) = (R*Ts*floor(T/Ts) + q*CC + n) mod 2**32.

      For any T1 > T2, we require that: S(T2, CC+1, 0) - S(T1, CC, n) >
      0 for all n.  Since R is assumed to be an upper bound on the
      transfer rate, we can write down:

          R > n/(T2 - T1),  or  T2/Ts - T1/Ts > n/(R*Ts)

      Using the relationship:  floor(x)-floor(y) > x-y-1 and a little
      algebra leads to the conclusion that using q = R*Ts creates the
      required monotonic number sequence.  Therefore, we consider:

      [5]      ISN = R*Ts*(floor(T/Ts) + CC) mod 2**32

      (which is the algorithm used for ISN selection by BSD TCP).

      For error-free operation, the sequence numbers generated by [5]
      must not wrap the sign bit in less than MSL seconds.  Since CC
      cannot increase faster than TRmax, the safe condition is:

            R* (1 + Ts*TRmax) * MSL < 2**31.

      We are interested in the case: Ts*TRmax >> 1, so this relationship



Braden                                                         [Page 19]

RFC 1379              Transaction TCP -- Concepts          November 1992


      reduces to:

      [6]     R * Ts * TRmax * MSL < 2**31.

      This shows a direct trade-off among the maximum effective
      bandwidth R, the maximum transaction rate TRmax, and the maximum
      segment lifetime MSL.  For reasonable limiting values of R, Ts,
      and MSL, formula [6] leads to a very low value of TRmax.  For
      example, with MSL= 2000 secs, R=10**9 Bps, and Ts = 0.5 sec, TRmax
      < 2*10**-3 Tps.

      To ease the situation, we could supplement sequence numbers with
      timestamps.  This would allow an effective MSL of 2 seconds in
      [6], since longer times would be protected by differing
      timestamps.  Then TRmax < 2**30/(R*Ts).  The actual enforced MSL
      would be increased to 24 days.  Unfortunately, TRmax would still
      be too small, since we want to support transfer rates up to R ~
      10**9 Bps.  Ts = 0.5 sec would imply TRmax ~ 2 Tps.  On many
      systems, it appears infeasible to decrease Ts enough to obtain an
      acceptable TRmax using this approach.

   5.3 64-bit TCP Sequence Numbers

      Another possibility would be to simply increase the TCP sequence
      space to 64 bits as suggested in [RFC-1263].  We would also
      increase the R value for clock-driven ISN selection, beyond the
      fastest transfer rate of which the host is capable.  A reasonable
      upper limit might be R = 10**9 Bps.  As noted above, in a
      practical implementation we would use:

            ISN = R*Ts*( floor(T/Ts) + CC) mod 2**64

      leading to:

            R*(1 +  Ts * TRmax) * MSL < 2**63

      For example, suppose that R = 10**9 Bps, Ts = 0.5, and MSL = 16K
      secs (4.4 hrs); then this result implies that TRmax < 10**6 Tps.
      We see that adding 32 bits to the sequence space has provided
      feasible values for transaction processing.

   5.4 Connection Counts

      The Connection Count CC is well suited to be the monotonic
      sequence M, since it "ticks" exactly once for each new connection
      incarnation and is constant within a single incarnation.  Thus, it
      perfectly separates segments from different incarnations of the
      same connection and would allow U = 0 in the TIME-WAIT state delay



Braden                                                         [Page 20]

RFC 1379              Transaction TCP -- Concepts          November 1992


      formula [2].  (Strictly, U cannot be reduced below 1/R = 4 usec,
      as noted in Section 4.  However, this is of little practical
      consequence until the ultimate limits on TRmax are approached).

      Assume that CC is a 32-bit number.  To prevent wrap-around in the
      sign bit of CC in less than MSL seconds requires that:

           TRmax * MSL < 2**31

      For example, if MSL =  2000 seconds then TRmax < 10**6 Tp.  These
      are acceptable limits for transaction processing.  However, if
      they are not, we could augment CC with TCP timestamps to obtain
      very far-out limits, as discussed below.

      It would be an implementation choice at the client whether CC is
      global for all destinations or private to each destination host
      (and maintained in the per-host cache).  In the latter case, the
      last CC value assigned for each remote host could also be
      maintained in the per-host cache.  Since there is not typically a
      large amount of parallelism in the network connection of a host,
      there should be little difference in the performance of these two
      different approaches, and the single global CC value is certainly
      simpler.

      To augment CC with TCP timestamps, we would bypass a 3-way
      handshake if both SEG.CC > cache.CC[A] and SEG.TSval >=
      cache.TS[A].  The timestamp check would detect a SYN older than 2
      seconds, so that the effective wrap-around requirement would be:

           TRmax * 2 < 2**31

      i.e., TRmax < 10**9 Tps.  The required MSL would be raised to 24
      days.  Using timestamps in this way, we could reduce the size of
      CC.  For example, suppose CC were 16 bits.  Then the wrap-around
      condition TRmax * 2 < 2**15 implies that TRmax is 16K.

      Finally, note that using CC to delete old duplicates from earlier
      incarnations would not obviate the need for the time-stamp-based
      PAWS mechanism to prevent errors within a single incarnation due
      to wrapping the 32-bit TCP sequence space at very high transfer
      rates.

   5.5  Conclusions

      The alternatives for monotonic sequence are summarized in Table I.
      We see that there are two feasible choices for the monotonic
      space: the connection count and 64-bit sequence numbers.  Of these
      two, we believe that the simpler is the connection count.



Braden                                                         [Page 21]

RFC 1379              Transaction TCP -- Concepts          November 1992


      Implementation of 64-bit sequence numbers would require
      negotiation of a new header format and expansion of all variables
      and calculations on the sequence space.  CC can be carried in an
      option and need be examined only once per packet.

      We propose to use a simple 32-bit connection count CC, without
      augmentation with timestamps, for the transaction extension.  This
      choice has the advantages of simplicity and directness.  Its
      drawback is that it adds a third sequence-like space (in addition
      to the TCP sequence number and the TCP timestamp) to each TCP
      header and to the main line of packet processing.  However, the
      additional code is in fact very modest.

   We now have a general outline of the proposed TCP extensions for
   transactions.

   o    A host maintains a 32-bit global connection counter variable CC.

   o    The sender's current CC value is carried in an option in every
        TCP segment.

   o    CC values are cached per host, and the TAO mechanism is used to
        bypass the 3-way handshake when possible.

   o    In non-SYN segments, the CC value is used to reject duplicates
        from earlier incarnations.  This allows TIME-WAIT state delay to
        be reduced to K*RTO (i.e., U=0 in Eq. [2]).
























Braden                                                         [Page 22]

RFC 1379              Transaction TCP -- Concepts          November 1992


                TABLE I: Summary of Monotonic Sequences

      APPROACH              TRmax (Tps)    Required MSL      COMMENTS
   __________________________________________________________________

   1. Timestamp & PAWS        1              24 days         TRmax is
                                                            too small
   __________________________________________________________________

   2. Current TCP Sequence Numbers

     (a) clock-driven
       ISN: eq. [3]           268           240 secs      TRmax & MSL
                                                            too small

     (b) Timestamps& clock-
         driven ISN [3] &     10**9         24 days           Hard to
         R=10**9                                            implement

     (c) Timestamps & c-dr
         ISN: eq. [4]        2**30/(R*Ts)   24 days         TRmax too
                                                               small.
   __________________________________________________________________

   3. 64-bit TCP Sequence Numbers

                          2**63/(MSL*R*Ts)      MSL        Significant
                                                          TCP change
                           e.g., R=10**9 Bps,
                               MSL = 4.4 hrs,
                               Ts = 0.5 sec=>
                               TRmax = 10**6
   __________________________________________________________________

   4. Connection Counts

     (a) no timestamps       2**31/MSL        MSL        3rd sequence
                        e.g., MSL=2000 sec                      space
                             TRmax = 10**6

     (b) with timestamps     2**30           24 days     (ditto)
                 and PAWS
   __________________________________________________________________








Braden                                                         [Page 23]

RFC 1379              Transaction TCP -- Concepts          November 1992


6.  CONNECTION STATES

   TCP has always allowed a connection to be half-closed.  TAO makes a
   significant addition to TCP semantics by allowing a connection to be
   half-synchronized, i.e., to be open for data transfer in one
   direction before the other direction has been opened.  Thus, the
   passive end of a connection (which receives an initial SYN) can
   accept data and even a FIN bit before its own SYN has been
   acknowledged.  This SYN, data, and FIN may arrive on a single segment
   (as in Figure 4), or on multiple segments; packetization makes no
   difference to the logic of the finite-state machine (FSM) defining
   transitions among connection states.

   Half-synchronized connections have several consequences.

   (a)  The passive end must provide an implied initial data window in
        order to accept data.  The minimum size of this implied window
        is a parameter in the specification; we suggest 4K bytes.

   (b)  New connection states and transitions are introduced into the
        TCP FSM at both ends of the connection.  At the active end, new
        states are required to piggy-back the FIN on the initial SYN
        segment.  At the passive end, new states are required for a
        half-synchronized connection.

   This section develops the resulting FSM description of a TCP
   connection as a conventional state/transition diagram.  To develop a
   complete FSM, we take a constructive approach, as follows: (1) write
   down all possible events; (2) write down the precedence rules that
   govern the order in which events may occur; (3) construct the
   resulting FSM; and (4) augment it to support TAO.  In principle, we
   do this separately for the active and passive ends; however, the
   symmetry of TCP results in the two FSMs being almost entirely
   coincident.

   Figure 8 lists all possible state transitions for a TCP connection in
   the absence of TAO, as elementary events and corresponding actions.
   Each transition is labeled with a letter.  Transitions a-g are used
   by the active side, and c-i are used by the passive side.  Without
   TAO, transition "c" (event "rcv ACK(SYN)") synchronizes the
   connection, allowing data to be accepted for the user.

   By definition, the first transition for an active (or passive) side
   must be "a" (or "i", respectively).  During a single instance of a
   connection, the active side will progress through some permutation of
   the complete sequence of transitions {a b c d e f } or the sequence
   {a b c d e f g}.  The set of possible permutations is determined by
   precedence rules governing the order in which transitions can occur.



Braden                                                         [Page 24]

RFC 1379              Transaction TCP -- Concepts          November 1992


          Label              Event / Action
          _____              ________________________
            a                OPEN / snd SYN

            b                rcv SYN [No TAO]/ snd ACK(SYN)

            c                rcv ACK(SYN) /

            d                CLOSE / snd FIN

            e                rcv FIN / snd ACK(FIN)

            f                rcv ACK(FIN) /

            g                timeout=2MSL / delete TCB
        ___________________________________________________
            h                passive OPEN / create TCB

            i                rcv SYN [No TAO]/ snd SYN, ACK(SYN)
        ___________________________________________________

           Figure 8.  Basic TCP Connection Transitions


   Using the notation "<." to mean "must precede", the precedence rules
   are:

   (1)  Logical ordering: must open connection before closing it:

        b <. e

   (2)  Causality -- cannot receive ACK(x) before x has been sent:

        a <. c and i <. c and d <. f

   (3)  Acknowledgments are cumulative

        c <. f

   (4)  First packet in each direction must contain a SYN.

        b <. c and b <. f

   (5)  TIME-WAIT state

        Whenever d precedes e in the sequence, g must be the last
        transition.




Braden                                                         [Page 25]

RFC 1379              Transaction TCP -- Concepts          November 1992


   Applying these rules, we can enumerate all possible permutations of
   the events and summarize them in a state transition diagram.  Figure
   9 shows the result, with boxes representing the states and directed
   arcs representing the transitions.

          ________            ________
         |        |    h     |        |
         | CLOSED |--------->| LISTEN |
         |________|          |________|
              |                   |
              | a                 | i
          ____V____           ____V___                 ________
         |        |    b     |        |      e        |        |
         |        |--------->|        |-------------->|        |
         |________|          |________|               |________|
            /                    /   |                /       |
           /                    /    | c           d /        | c
          /                    /   __V_____          |    ____V___
         /                    /   |        | e       |   |        |
      d  |                d  /    |        |------------>|        |
         |                   |    |________|         |   |________|
         |                   |       |               |         |
         |                   |       |            ___V____     |
         |                   |       |           |        |    |
         |                   |       |           |        |    |
         |                   |       |           |________|    |
         |                   |       |                   |     |
     ____V___          ______V_      |     ________      |     |
    |        |    b   |        | e   |    |        |     |     |
    |        |------->|        |--------->|        |     |     |
    |________|        |________|     |    |________|     |     |
                              |      /          |        |     |
                            c |     / d       c |      c |   d |
                              |    /            |        |     |
                             _V___V__       ____V___     V_____V_
                            |        |  e  |        |   |        |
                            |        |---->|        |   |        |
                            |________|     |________|   |________|
                                 |              |           |
                                 | f            | f         | f
                             ____V___       ____V___     ___V____
                            |        |  e  | TIME-  | g |        |
                            |        |---->|   WAIT |-->| CLOSED |
                            |________|     |________|   |________|


               Figure 9: Basic State Diagram




Braden                                                         [Page 26]

RFC 1379              Transaction TCP -- Concepts          November 1992


   Although Figure 9 gives a correct representation of the possible
   event sequences, it is not quite correct for the actions, which do
   not compose as shown.   In particular, once a control bit X has been
   sent, it must continue to be sent until ACK(X) is received.  This
   requires new transitions with modified actions, shown in the
   following list.  We use the labeling convention that transitions with
   the same event part all have the same letter, with different numbers
   of primes to indicate different actions.

          Label              Event / Action
          _____              _______________________________________
            b' (=i)          rcv SYN [No TAO] / snd SYN,ACK(SYN)
            b''              rcv SYN [No TAO] / snd SYN,FIN,ACK(SYN)
            d'               CLOSE / snd SYN,FIN
            e'               rcv FIN / snd FIN,ACK(FIN)
            e''              rcv FIN / snd SYN,FIN,ACK(FIN)


   Figure 10 shows the state diagram of Figure 9, with the modified
   transitions and with the states used by standard TCP [STD-007]
   identified. Those states that do not occur in standard TCP are
   numbered 1-5.

   Standard TCP has another implied restriction: a FIN bit cannot be
   recognized before the connection has been synchronized, i.e., c <. e.
   This eliminates from standard TCP the states 1, 2, and 5 shown in
   Figure 10.  States 3 and 4 are needed if a FIN is to be piggy-backed
   on a SYN segment (note that the states shown in Figure 1 are actually
   wrong; the states shown as SYN-SENT and ESTABLISHED are really states
   3 and 4).  In the absence of piggybacking the FIN bit, Figure 10
   reduces to the standard TCP state diagram [STD-007].

   The FSM described in Figure 10 is intended to be applied
   cumulatively; that is, parsing a single packet header may lead to
   more than one transition.  For example, the standard TCP state
   diagram includes a direct transition from SYN-SENT to ESTABLISHED:

       rcv SYN,ACK(SYN) / snd ACK(SYN).

   This is transition b followed immediately by c.











Braden                                                         [Page 27]

RFC 1379              Transaction TCP -- Concepts          November 1992


          ________            ________
         |        |     h    |        |
         | CLOSED |--------->| LISTEN |
         |________|          |________|
              |                   |
              | a                 | i
          ____V____           ____V___                 ________
         | SYN-   |     b'   |  SYN-  |     e'        |        |
         |   SENT |--------->|RECEIVED|-------------->|   1    |
         |________|          |________|               |________|
            /                    /   |                  |     |
         d'/                  d'/    | c             d' |   c |
          /                    /   __V_____             |    _V______
         /                    /   |ESTAB-  | e          |   | CLOSE- |
         |                   /    |  LISHED|------------|-->|   WAIT |
         |                   |    |________|            |   |________|
         |                   |       |                  |      |
         |                   |       |             _____V__    |
         |                   |       |            |        |   |
         |                   |       |            |   2    |   |
         |                   |       |            |________|   |
         |                   |       |                   |     |
     ____V___          ______V_      |     ________      |     |
    |        |  b''   |        |e''' |    |        |     |     |
    |    3   |------->|    4   |--------->|    5   |     |     |
    |________|        |________|     |    |________|     |     |
                              |      /          |        |     |
                            c |     / d       c |      c |   d |
                              |    /            |        |     |
                             _V___V__       ____V___     V_____V_
                            | FIN-   | e'' |        |   | LAST-  |
                            |  WAIT-1|---->|CLOSING |   |   ACK  |
                            |________|     |________|   |________|
                                 |              |           |
                                 | f            | f         | f
                             ____V___       ____V___     ___V____
                            | FIN-   |  e  | TIME-  | g |        |
                            |  WAIT-2|---->|   WAIT |-->| CLOSED |
                            |________|     |________|   |________|


        Figure 10: Basic State Diagram -- Correct Actions


   Next we introduce TAO.  If the TAO test succeeds, the connection
   becomes half-synchronized.  This requires a new set of states,
   mirroring the states of Figure 10, beginning with acceptance of a SYN
   (transition "b" or "i"), and ending when ACK(SYN) arrives (transition



Braden                                                         [Page 28]

RFC 1379              Transaction TCP -- Concepts          November 1992


   "c").  Figure 11 shows the result of augmenting Figure 10 with the
   additional states for TAO.  The transitions are defined in the
   following table:

           Key for Figure 11: Complete State Diagram with TAO


                Label            Event / Action
                _____            ________________________

                  a              OPEN / create TCB, snd SYN
                  b'             rcv SYN [no TAO]/ snd SYN,ACK(SYN)
                  b''            rcv SYN [no TAO]/ snd SYN,FIN,ACK(SYN)
                  c              rcv ACK(SYN) /
                  d              CLOSE / snd FIN
                  d'             CLOSE / snd SYN,FIN
                  e              rcv FIN / snd ACK(FIN)
                  e'             rcv FIN / snd SYN,ACK(FIN)
                  e''            rcv FIN / snd FIN,ACK(FIN)
                  e'''           rcv FIN / snd SYN,FIN,ACK(FIN)
                  f              rcv ACK(FIN) /
                  g              timeout=2MSL / delete TCB
                  h              passive OPEN / create TCB
                  i (= b')       rcv SYN [no TAO]/ snd SYN,ACK(SYN)
                  j              rcv SYN [TAO OK] / snd SYN,ACK(SYN)
                  k              rcv SYN [TAO OK] / snd SYN,FIN,ACK(SYN)



   Each new state in Figure 11 bears a very simple relationship to a
   standard TCP state.  We indicate this by naming the new state with
   the standard state name followed by a star.  States SYN-SENT* and
   SYN-RECEIVED* differ from the corresponding unstarred states in
   recording the fact that a FIN has been sent.  The other new states
   with starred names differ from the corresponding unstarred states in
   being half-synchronized (hence, a SYN bit needs to be transmitted).

   The state diagram of Figure 11 is more general than required for
   transaction processing.  In particular, it handles simultaneous
   connection synchronization from both sides, allowing one or both
   sides to bypass the 3-way handshake.  It includes other transitions
   that are unlikely in normal transaction processing, for example, the
   server sending a FIN before it receives a FIN from the client
   (ESTABLISHED* -> FIN-WAIT-1* in Figure 11).







Braden                                                         [Page 29]

RFC 1379              Transaction TCP -- Concepts          November 1992


   ________                  ________
  |        |      h         |        |
  | CLOSED |--------------->| LISTEN |
  |________|                |________|
       |                     /     |
      a|                    / i    | j
       |                   /       |
       |                  /       _V______               ________
       |           j      |      |ESTAB-  |       e'    | CLOSE- |
       |        /---------|----->| LISHED*|------------>|   WAIT*|
       |       /          |      |________|             |________|
       |      /           |       |     |                 |    |
       |     /            |       |d'   | c            d' |    | c
   ____V___ /       ______V_      |    _V______           |   _V______
  | SYN-   |   b'  |  SYN-  | c   |   |ESTAB-  |  e       |  | CLOSE- |
  |   SENT |------>|RECEIVED|-----|-->|  LISHED|----------|->|   WAIT |
  |________|       |________|     |   |________|          |  |________|
       |               |          |     |                 |       |
       |               |          |     |              ___V____   |
       |               |          |     |             | LAST-  |  |
       | d'            | d'       | d'  | d           |  ACK*  |  |
       |               |          |     |             |________|  |
       |               |          |     |                    |    |
       |               |    ______V_    |        ________    |c   |d
       |          k    |   |  FIN-  |   |  e''' |        |   |    |
       |        /------|-->| WAIT-1*|---|------>|CLOSING*|   |    |
       |       /       |   |________|   |       |________|   |    |
       |      /        |          |     |            |       |    |
       |     /         |          | c   |            | c     |    |
   ____V___ /      ____V___       V_____V_       ____V___    V____V__
  | SYN-   |  b'' |  SYN-  |  c  |  FIN-  | e'' |        |  | LAST-  |
  |  SENT* |----->|RECEIVD*|---->| WAIT-1 |---->|CLOSING |  |   ACK  |
  |________|      |________|     |________|     |________|  |________|
                                     |               |           |
                                     | f             | f         | f
                                  ___V____       ____V___     ___V____
                                 |  FIN-  | e   |TIME-   | g |        |
                                 | WAIT-2 |---->|   WAIT |-->| CLOSED |
                                 |________|     |________|   |________|

       Figure 11: Complete State Diagram with TAO



   The relationship between starred and unstarred states is very
   regular.  As a result, the state extensions can be implemented very
   simply using the standard TCP FSM with the addition of two "hidden"
   boolean flags, as described in the functional specification memo



Braden                                                         [Page 30]

RFC 1379              Transaction TCP -- Concepts          November 1992


   [TTCP-FS].

   As an example of the application of Figure 11, consider the minimal
   transaction shown in Figure 12.


       TCP A  (Client)                                 TCP B (Server)
       _______________                                 ______________

       CLOSED                                                  LISTEN

   1.  SYN-SENT*    --> <SYN,data1,FIN,CC=x1> -->     CLOSE-WAIT*
                                                      (TAO test OK=>
                                                       data1->user_B)

                                                             LAST-ACK*
              <-- <SYN,ACK(FIN),data2,FIN,CC=y1,CC.ECHO=x1> <--
   2.  TIME-WAIT
    (TAO test OK,
     data2->user_A)


   3.  TIME-WAIT          --> <ACK(FIN),CC=x2> -->              CLOSED

       (timeout)
         CLOSED


             Figure 12: Minimal Transaction Sequence

   Sending segment #1 leaves the client end in SYN-SENT* state, which
   differs from SYN-SENT state in recording the fact that a FIN has been
   sent.  At the server end, passing the TAO test enters ESTABLISHED*
   state, which passes the data to the user as in ESTABLISHED state and
   also records the fact that the connection is half synchronized.  Then
   the server processes the FIN bit of segment #1, moving to CLOSE-WAIT*
   state.

   Moving to CLOSE-WAIT* state should cause the server to send a segment
   containing SYN and ACK(FIN).  However, transmission of this segment
   is deferred so the server can piggyback the response data and FIN on
   the same segment, unless a timeout occurs first.  When the server
   does send segment #2 containing the response data2 and a FIN, the
   connection advances from CLOSE-WAIT* to LAST-ACK* state; the
   connection is still half-synchronized from B's viewpoint.

   Processing segment #2 at the client again results in multiple
   transitions:



Braden                                                         [Page 31]

RFC 1379              Transaction TCP -- Concepts          November 1992


       SYN-SENT* -> FIN-WAIT-1* -> CLOSING* -> CLOSING -> TIME-WAIT

   These correspond respectively to receiving a SYN, a FIN, an ACK for
   A's SYN, and an ACK for A's FIN.

   Figure 13 shows a slightly more complex example, a transaction
   sequence in which request and response data each require two
   segments.  This figure assumes that both client and server TCP are
   well-behaved, so that e.g., the client sends the single segment #5 to
   acknowledge both data segments #3 and #4.  SEG.CC values are omitted
   for clarity.


        _T_C_P__A                                            _T_C_P__B


    1.  SYN-SENT*      --> <SYN,data1>   -->         ESTABLISHED*
                                                    (TAO OK,
                                                     data1-> user)

    2.  SYN-SENT*      --> <data2,FIN>   -->          CLOSE-WAIT*
                                                    (data2-> user)

    3.  FIN-WAIT-2     <-- <SYN,ACK(FIN),data3> <--   CLOSE-WAIT*
         (data3->user)

    4.  TIME_WAIT      <-- <ACK(FIN),data4,FIN> <--     LAST-ACK*
         (data4->user)

    5.  TIME-WAIT      --> <ACK(FIN)> -->                  CLOSED


         Figure 13. Multi-Packet Request/Response Transaction


7.  CONCLUSIONS AND ACKNOWLEDGMENTS

   TCP was designed to be a highly symmetric protocol.  This symmetry is
   evident in the piggy-backing of acknowledgments on data and in the
   common header format for data segments and acknowledgments.  On the
   other hand, the examples and discussion in this memo are in general
   highly unsymmetrical; the actions of a "client" are clearly
   distinguished from those of a "server".  To explain this apparent
   discrepancy, we note the following.  Even when TCP is used for
   virtual circuit service, the data transfer phase is symmetrical but
   the open and close phases are not.  A minimal transaction, consisting
   of one segment in each direction, compresses the open, data transfer,
   and close phases together, and making the asymmetry of the open and



Braden                                                         [Page 32]

RFC 1379              Transaction TCP -- Concepts          November 1992


   close phases dominant.  As request and response messages increase in
   size, the virtual circuit model becomes increasingly relevant, and
   symmetry again dominates.

   TCP's 3-way handshake precludes any performance gain from including
   data on a SYN segment, while TCP's full-duplex data-conserving close
   sequence ties up communication resources to the detriment of high-
   speed transactions.  Merely loading more control bits onto TCP data
   segments does not provide efficient transaction service.  To use TCP
   as an effective transaction transport protocol requires bypassing the
   3-way handshake and shortening the TIME-WAIT delay.  This memo has
   proposed a backwards-compatible TCP extension to accomplish both
   goals.  It is our hope that by building upon the current version of
   TCP, we can give a boost to community acceptance of the new
   facilities.  Furthermore, the resulting protocol implementations will
   retain the algorithms that have been developed for flow and
   congestion control in TCP [Jacobson88].

   O'Malley and Peterson have recently recommended against backwards-
   compatible extensions to TCP, and suggested instead a mechanism to
   allow easy installation of alternative versions of a protocol [RFC-
   1263].  While this is an interesting long-term approach, in the
   shorter term we suggest that incremental extension of the current TCP
   may be a more effective route.

   Besides the backward-compatible extension proposed here, there are
   two other possible approaches to making efficient transaction
   processing widely available in the Internet: (1) a new version of TCP
   or (2) a new protocol specifically adapted to transactions.  Since
   current TCP "almost" supports transactions, we favor (1) over (2).  A
   new version of TCP that retained the semantics of STD-007 but used 64
   bit sequence numbers with the procedures and states described in
   Sections 3, 4, and 6 of this memo would support transactions as well
   as virtual circuits in a clean, coherent manner.

   A potential application of transaction-mode TCP might be SMTP.  If
   commands and responses are batched, in favorable cases complete SMTP
   delivery operations on short messages could be performed with a
   single minimal transaction; on the other hand, the body of a message
   may be arbitrarily large.  Using a TCP extended as in this memo could
   significantly reduce the load on large mail hosts.

   This work began as an elaboration of the concept of TAO, due to Dave
   Clark.  I am grateful to him and to Van Jacobson, John Wroclawski,
   Dave Borman, and other members of the End-to-End Research group for
   helpful ideas and critiques during the long development of this work.
   I also thank Liming Wei, who tested the initial implementation in Sun
   OS.



Braden                                                         [Page 33]

RFC 1379              Transaction TCP -- Concepts          November 1992


APPENDIX A -- TIME-WAIT STATE AND THE 2-PACKET EXCHANGE

   This appendix considers the implications of reducing TIME-WAIT state
   delay below that given in formula [2].

   An immediate consequence of this would be the requirement for the
   server host to accept an initial SYN for a connection in LAST-ACK
   state.  Without the transaction extensions, the arrival of a new
   <SYN> in LAST-ACK state looks to TCP like a half-open connection, and
   TCP's rules are designed to restore correspondence by destroying the
   state (through sending a RST segment) at one end or the other.  We
   would need to thwart this action in the case of transactions.

   There are two different possible ways to further reduce TIME-WAIT
   delay.

   (1)  Explicit Truncation of TIME-WAIT state

        TIME-WAIT state could be explicitly truncated by accepting a new
        sendto() request for a connection in TIME-WAIT state.

        This would allow the ACK(FIN) segment to be delayed and sent
        only if a timeout occurs before a new request arrives.  This
        allows an ideal 2-segment exchange for closely-spaced
        transactions, which would restore some symmetry to the
        transaction exchange.  However, explicit truncation would
        represent a significant change in many implementations.

        It might be supposed that even greater symmetry would result if
        the new request segment were a <SYN,ACK> that explicitly
        acknowledges the previous reply, rather than a <SYN> that is
        only an implicit acknowledgment.  However, the new request
        segment might arrive at B to find the server side in either
        LAST-ACK or CLOSED state, depending upon whether the ACK(FIN)
        had arrived.  In CLOSED state, a <SYN,ACK> would not be
        acceptable.  Hence, if the client sent an initial <SYN,ACK>
        instead of a <SYN> segment, there would be a race condition at
        the server.

   (2)  No TIME-WAIT delay

        TIME-WAIT delay could be removed entirely.  This would imply
        that the ACK(FIN) would always be sent (which does not of course
        guarantee that it will be received).  As a result, the arrival
        of a new SYN in LAST-ACK state would be rare.

        This choice is much simpler to implement.  Its drawback is that
        the server will get a false failure report if the ACK(FIN) is



Braden                                                         [Page 34]

RFC 1379              Transaction TCP -- Concepts          November 1992


        lost.  This may not matter in practice, but it does represent a
        significant change of TCP semantics.  It should be noted that
        reliable delivery of the reply is not an issue.  The client
        enter TIME-WAIT state only after the entire reply, including the
        FIN bit, has been received successfully.

   The server host B must be certain that a new request received in
   LAST-ACK state is indeed a new SYN and not an old duplicate;
   otherwise, B could falsely acknowledge a previous response that has
   not in fact been delivered to A.  If the TAO comparison succeeds, the
   SYN must be new; however, the server has a dilemma if the TAO test
   fails.

   In Figure A.1, for example, the reply segment from the first
   transaction has been lost; since it has not been acknowledged, it is
   still in B's retransmission queue.  An old duplicate request, segment
   #3, arrives at B and its TAO test fails.  B is in the position of
   having old state it cannot discard (the retransmission queue) and
   needing to build new state to pursue a 3-way handshake to validate
   the new SYN.  If the 3-way handshake failed, it would need to restore
   the earlier LAST-ACK* state.  (Compare with Figure 15 "Old Duplicate
   SYN Initiates a Reset on Two Passive Sockets" in STD-007).  This
   would be complex and difficult to accomplish in many implementations.


       TCP A  (Client)                               TCP B (Server)
       _______________                               ______________

         CLOSED                                          LISTEN


   1.    SYN-SENT*       --> <SYN,data1,FIN> -->    CLOSE-WAIT*
                                                     (TAO test OK;
                                                      data1->server)

   2.        (lost) X<-- <SYN,ACK(FIN),data2,FIN> <-- LAST-ACK*

                   (old duplicate)
   3.                     ... <SYN,data3,FIN> -->     LAST-ACK*
                                                  (TAO test fail;
                                                   3-way handshake?)

                 Figure A.1: The Server's Dilemma


   The only practical action A can taken when the TAO test fails on a
   new SYN received in LAST-ACK state is to ignore the SYN, assuming it
   is really an old duplicate.  We must pursue the possible consequences



Braden                                                         [Page 35]

RFC 1379              Transaction TCP -- Concepts          November 1992


   of this action.

   Section 3.1 listed four possible reasons for failure of the TAO test
   on a legitimate SYN segment: (1) no cached state, (2) out-of-order
   delivery of SYNs, (3) wraparound of CCgen relative to the cached
   value, or (4) the M values advance too slowly.   We are assuming that
   there is a cached CC value at B (otherwise, the SYN cannot be
   acceptable in LAST-ACK state).  Wrapping the CC space is very
   unlikely and probably impossible; it is difficult to imagine
   circumstances which would allow the new SYN to be delivered but not
   the ACK(FIN), especially given the long wraparound time of CCgen.

   This leaves the problem of out-of-order delivery of two nearly-
   concurrent SYNs for different ports.  The second to be delivered may
   have a lower CC option and thus be locked out.  This can be solved by
   using a new CCgen value for every retransmission of an initial SYN.

   Truncation of TIME-WAIT state and acceptance of a SYN in LAST-ACK
   state should take place only if there is a cached CC value for the
   remote host.  Otherwise, a SYN arriving in LAST-ACK state is to be
   processed by normal TCP rules, which will result in a RST segment
   from either A or B.

   This discussion leads to a paradigm for rejecting old duplicate
   segments that is different from TAO.  This alternative scheme is
   based upon the following:

   (a)  Each retransmission of an initial SYN will have a new value of
        CC, as described above.

        This provision takes care of reordered SYNs.

   (b)  A host maintains a distinct CCgen value for each remote host.
        This value could easily be maintained in the same cache used for
        the received CC values, e.g., as cache.CCgen[].

        Once the caches are primed, it should always be true that
        cache.CCgen[B] on host A is equal to cache.CC[A] on host B, and
        the next transaction from A will carry a CC value exactly 1
        greater.  Thus, there is no problem of wraparound of the CC
        value.

   (c)  A new SYN is acceptable if its SEG.CC > cache.CC[client],
        otherwise the SYN is ignored as an old duplicate.

   This alternative paradigm was not adopted because it would be a
   somewhat greater perturbation of TCP rules, because it may not have
   the robustness of TAO, and because all of its consequences may not be



Braden                                                         [Page 36]

RFC 1379              Transaction TCP -- Concepts          November 1992


   understood.


REFERENCES

    [Birrell84]  Birrell, A. and B. Nelson, "Implementing Remote
      Procedure Calls", ACM TOCS, Vo. 2, No. 1, February 1984.

    [Clark88]  Clark, D., "The Design Philosophy of the Internet
      Protocols", ACM SIGCOMM '88, Stanford, CA, August 1988.

    [Clark89]  Clark, D., Private communication, 1989.

    [Garlick77]  Garlick, L., R. Rom, and J. Postel, "Issues in Reliable
      Host-to-Host Protocols", Proc. Second Berkeley Workshop on
      Distributed Data Management and Computer Networks, May 1977.

    [HR-COMM]  Braden, R., Ed., "Requirements for Internet Hosts --
      Communication Layers", STD-003, RFC-1122, October 1989.

    [Jacobson88] Jacobson, V., "Congestion Avoidance and Control",
      SIGCOMM '88, Stanford, CA., August 1988.

    [Jacobson90] Jacobson, V., private communication, 1990.

    [Liskov90]  Liskov, B., Shrira, L., and J. Wroclawski, "Efficient
      At-Most-Once Messages Based on Synchronized Clocks", ACM SIGCOMM
      '90, Philadelphia, PA, September 1990.

    [RFC-955]  Braden, R., "Towards a Transport Service Transaction
      Protocol", RFC-955, September 1985.

    [RFC-1185]  Jacobson, V., Braden, R., and Zhang, L., "TCP Extension
      for High-Speed Paths", RFC-1185, October 1990.

    [RFC-1263]  O'Malley, S. and L. Peterson, "TCP Extensions Considered
      Harmful", RFC-1263, University of Arizona, October 1991.

    [RFC-1323]  Jacobson, V., Braden, R., and Borman, D., "TCP
      Extensions for High Performance, RFC-1323, February 1991.

    [RFC-1337]  Braden, R., "TIME-WAIT Assassination Hazards in TCP",
      RFC-1337, May 1992.

    [STD-007]  Postel, J., "Transmission Control Protocol - DARPA
      Internet Program Protocol Specification", STD-007, RFC-793,
      September 1981.




Braden                                                         [Page 37]

RFC 1379              Transaction TCP -- Concepts          November 1992


    [TTCP-FS]  Braden, R., "Transaction TCP -- Functional
      Specification", Work in Progress, September 1992.

    [Watson81]  Watson, R., "Timer-based Mechanisms in Reliable
      Transport Protocol Connection Management", Computer Networks, Vol.
      5, 1981.

Security Considerations

   Security issues are not discussed in this memo.

Author's Address

   Bob Braden
   University of Southern California
   Information Sciences Institute
   4676 Admiralty Way
   Marina del Rey, CA 90292

   Phone: (310) 822-1511
   EMail: Braden@ISI.EDU






























Braden                                                         [Page 38]
