196 strings / 8378 words

Translation Source string Target string
cnp3-ebook/protocols/tcp — French
The Transmission Control Protocol
 
cnp3-ebook/protocols/tcp — French
The Transmission Control Protocol (TCP) was initially defined in :rfc:`793`. Several parts of the protocol have been improved since the publication of the original protocol specification [#ftcpspecs]_. However, the basics of the protocol remain and an implementation that only supports :rfc:`793` should inter-operate with today's implementation.
 
cnp3-ebook/protocols/tcp — French
TCP provides a reliable bytestream, connection-oriented transport service on top of the unreliable connectionless network service provided by :term:`IP`. TCP is used by a large number of applications, including :
 
cnp3-ebook/protocols/tcp — French
Email (:term:`SMTP`, :term:`POP`, :term:`IMAP`)
 
cnp3-ebook/protocols/tcp — French
World wide web ( :term:`HTTP`, ...)
 
cnp3-ebook/protocols/tcp — French
Most file transfer protocols ( :term:`ftp`, peer-to-peer file sharing applications , ...)
 
cnp3-ebook/protocols/tcp — French
remote computer access : :term:`telnet`, :term:`ssh`, :term:`X11`, :term:`VNC`, ...
 
cnp3-ebook/protocols/tcp — French
non-interactive multimedia applications (flash, ...)
 
cnp3-ebook/protocols/tcp — French
On the global Internet, most of the applications used in the wide area rely on TCP. Many studies [#ftcpusage]_ have reported that TCP was responsible for more than 90% of the data exchanged in the global Internet.
 
cnp3-ebook/protocols/tcp — French
To provide this service, TCP relies on a simple segment format that is shown in the figure below. Each TCP segment contains a header described below and, optionally, a payload. The default length of the TCP header is twenty bytes, but some TCP headers contain options.
 
cnp3-ebook/protocols/tcp — French
TCP header format
 
cnp3-ebook/protocols/tcp — French
A TCP header contains the following fields :
 
cnp3-ebook/protocols/tcp — French
the `source and destination ports`. The source and destination ports play an important role in TCP, as they allow the identification of the connection to which a TCP segment belongs. When a client opens a TCP connection, it typically selects an ephemeral TCP port number as its source port and contacts the server by using the server's port number. All the segments that are sent by the client on this connection have the same source and destination ports. The server sends segments that contain as source (resp. destination) port, the destination (resp. source) port of the segments sent by the client (see figure :ref:`fig-tcpports`). A TCP connection is always identified by four pieces of information :
 
cnp3-ebook/protocols/tcp — French
the address of the client
 
cnp3-ebook/protocols/tcp — French
the address of the server
 
cnp3-ebook/protocols/tcp — French
the port chosen by the client
 
cnp3-ebook/protocols/tcp — French
the port chosen by the server
 
cnp3-ebook/protocols/tcp — French
the `sequence number` (32 bits), `acknowledgment number` (32 bits) and `window` (16 bits) fields are used to provide a reliable data transfer, using a window-based protocol. In a TCP bytestream, each byte of the stream consumes one sequence number. Their usage is described in more detail in section :ref:`TCPReliable`
 
cnp3-ebook/protocols/tcp — French
the `Urgent pointer` is used to indicate that some data should be considered as urgent in a TCP bytestream. However, it is rarely used in practice and will not be described here. Additional details about the utilization of this pointer may be found in :rfc:`793`, :rfc:`1122` or [Stevens1994]_
 
cnp3-ebook/protocols/tcp — French
the flags field contains a set of bit flags that indicate how a segment should be interpreted by the TCP entity receiving it :
 
cnp3-ebook/protocols/tcp — French
the `SYN` flag is used during connection establishment
 
cnp3-ebook/protocols/tcp — French
the `FIN` flag is used during connection release
 
cnp3-ebook/protocols/tcp — French
the `RST` is used in case of problems or when an invalid segment has been received
 
cnp3-ebook/protocols/tcp — French
when the `ACK` flag is set, it indicates that the `acknowledgment` field contains a valid number. Otherwise, the content of the `acknowledgment` field must be ignored by the receiver
 
cnp3-ebook/protocols/tcp — French
the `URG` flag is used together with the `Urgent pointer`
 
cnp3-ebook/protocols/tcp — French
the `PSH` flag is used as a notification from the sender to indicate to the receiver that it should pass all the data it has received to the receiving process. However, in practice TCP implementations do not allow TCP users to indicate when the `PSH` flag should be set.
 
cnp3-ebook/protocols/tcp — French
the `checksum` field contains the value of the Internet checksum computed over the entire TCP segment and a pseudo-header as with UDP
 
cnp3-ebook/protocols/tcp — French
the `Reserved` field was initially reserved for future utilization. It is now used by :rfc:`3168`.
 
cnp3-ebook/protocols/tcp — French
the `TCP Header Length` (THL) or `Data Offset` field is a four bits field that indicates the size of the TCP header in 32 bit words. The maximum size of the TCP header is thus 64 bytes.
 
cnp3-ebook/protocols/tcp — French
the `Optional header extension` is used to add optional information to the TCP header. Thanks to this header extension, it is possible to add new fields to the TCP header that were not planned in the original specification. This allowed TCP to evolve since the early eighties. The details of the TCP header extension are explained in sections :ref:`TCPOpen` and :ref:`TCPReliable`.
 
cnp3-ebook/protocols/tcp — French
The rest of this section is organized as follows. We first explain the establishment and the release of a TCP connection, then we discuss the mechanisms that are used by TCP to provide a reliable bytestream service. We end the section with a discussion of network congestion and explain the mechanisms that TCP uses to avoid congestion collapse.
 
cnp3-ebook/protocols/tcp — French
TCP connection establishment
 
cnp3-ebook/protocols/tcp — French
A TCP connection is established by using a three-way handshake. The connection establishment phase uses the `sequence number`, the `acknowledgment number` and the `SYN` flag. When a TCP connection is established, the two communicating hosts negotiate the initial sequence number to be used in both directions of the connection. For this, each TCP entity maintains a 32 bits counter, which is supposed to be incremented by one at least every 4 microseconds and after each connection establishment [#ftcpclock]_. When a client host wants to open a TCP connection with a server host, it creates a TCP segment with :
 
cnp3-ebook/protocols/tcp — French
the `SYN` flag set
 
cnp3-ebook/protocols/tcp — French
the `sequence number` set to the current value of the 32 bits counter of the client host's TCP entity
 
cnp3-ebook/protocols/tcp — French
Upon reception of this segment (which is often called a `SYN segment`), the server host replies with a segment containing :
 
cnp3-ebook/protocols/tcp — French
the `sequence number` set to the current value of the 32 bits counter of the server host's TCP entity
 
cnp3-ebook/protocols/tcp — French
the `ACK` flag set
 
cnp3-ebook/protocols/tcp — French
the `acknowledgment number` set to the `sequence number` of the received `SYN` segment incremented by 1 :math:`\pmod{2^{32}}`. When a TCP entity sends a segment having `x+1` as acknowledgment number, this indicates that it has received all data up to and including sequence number `x` and that it is expecting data having sequence number `x+1`. As the `SYN` flag was set in a segment having sequence number `x`, this implies that setting the `SYN` flag in a segment consumes one sequence number.
 
cnp3-ebook/protocols/tcp — French
This segment is often called a `SYN+ACK` segment. The acknowledgment confirms to the client that the server has correctly received the `SYN` segment. The `sequence number` of the `SYN+ACK` segment is used by the server host to verify that the `client` has received the segment. Upon reception of the `SYN+ACK` segment, the client host replies with a segment containing :
 
cnp3-ebook/protocols/tcp — French
the `acknowledgment number` set to the `sequence number` of the received `SYN+ACK` segment incremented by 1 :math:`\pmod{2^{32}}`
 
cnp3-ebook/protocols/tcp — French
At this point, the TCP connection is open and both the client and the server are allowed to send TCP segments containing data. This is illustrated in the figure below.
 
cnp3-ebook/protocols/tcp — French
Establishment of a TCP connection
 
cnp3-ebook/protocols/tcp — French
In the figure above, the connection is considered to be established by the client once it has received the `SYN+ACK` segment, while the server considers the connection to be established upon reception of the `ACK` segment. The first data segment sent by the client (server) has its `sequence number` set to `x+1` (resp. `y+1`).
 
cnp3-ebook/protocols/tcp — French
Computing TCP's initial sequence number
 
cnp3-ebook/protocols/tcp — French
In the original TCP specification :rfc:`793`, each TCP entity maintained a clock to compute the initial sequence number (:term:`ISN`) placed in the `SYN` and `SYN+ACK` segments. This made the ISN predictable and caused a security issue. The typical security problem was the following. Consider a server that trusts a host based on its IP address and allows the system administrator to log in from this host without giving a password [#frlogin]_. Consider now an attacker who knows this particular configuration and is able to send IP packets having the client's address as source. He can send fake TCP segments to the server, but does not receive the server's answers. If he can predict the `ISN` that is chosen by the server, he can send a fake `SYN` segment and shortly after the fake `ACK` segment confirming the reception of the `SYN+ACK` segment sent by the server. Once the TCP connection is open, he can use it to send any command to the server. To counter this attack, current TCP implementations add randomness to the `ISN`. One of the solutions, proposed in :rfc:`1948` is to compute the `ISN` as ::
 
cnp3-ebook/protocols/tcp — French
where `M` is the current value of the TCP clock and `H` is a cryptographic hash function. `localhost` and `remotehost` (resp. `localport` and `remoteport` ) are the IP addresses (port numbers) of the local and remote host and `secret` is a random number only known by the server. This method allows the server to use different ISNs for different clients at the same time. `Measurements <http://lcamtuf.coredump.cx/newtcp/>`_ performed with the first implementations of this technique showed that it was difficult to implement it correctly, but today's TCP implementation now generate good ISNs.
 
cnp3-ebook/protocols/tcp — French
A server could, of course, refuse to open a TCP connection upon reception of a `SYN` segment. This refusal may be due to various reasons. There may be no server process that is listening on the destination port of the `SYN` segment. The server could always refuse connection establishments from this particular client (e.g. due to security reasons) or the server may not have enough resources to accept a new TCP connection at that time. In this case, the server would reply with a TCP segment having its `RST` flag set and containing the `sequence number` of the received `SYN` segment incremented by one as its `acknowledgment number`. This is illustrated in the figure below. We discuss the other usages of the TCP `RST` flag later (see :ref:`TCPRelease`).
 
cnp3-ebook/protocols/tcp — French
TCP connection establishment rejected by peer
 
cnp3-ebook/protocols/tcp — French
TCP connection establishment can be described as the four state Finite State Machine shown below. In this FSM, `!X` (resp. `?Y`) indicates the transmission of segment `X` (resp. reception of segment `Y`) during the corresponding transition. `Init` is the initial state.
 
cnp3-ebook/protocols/tcp — French
A client host starts in the `Init` state. It then sends a `SYN` segment and enters the `SYN Sent` state where it waits for a `SYN+ACK` segment. Then, it replies with an `ACK` segment and enters the `Established` state where data can be exchanged. On the other hand, a server host starts in the `Init` state. When a server process starts to listen to a destination port, the underlying TCP entity creates a TCP control block and a queue to process incoming `SYN` segments. Upon reception of a `SYN` segment, the server's TCP entity replies with a `SYN+ACK` and enters the `SYN RCVD` state. It remains in this state until it receives an `ACK` segment that acknowledges its `SYN+ACK` segment, with this it then enters the `Established` state.
 
cnp3-ebook/protocols/tcp — French
Apart from these two paths in the TCP connection establishment FSM, there is a third path that corresponds to the case when both the client and the server send a `SYN` segment to open a TCP connection [#ftcpboth]_. In this case, the client and the server send a `SYN` segment and enter the `SYN Sent` state. Upon reception of the `SYN` segment sent by the other host, they reply by sending a `SYN+ACK` segment and enter the `SYN RCVD` state. The `SYN+ACK` that arrives from the other host allows it to transition to the `Established` state. The figure below illustrates such a simultaneous establishment of a TCP connection.
 
cnp3-ebook/protocols/tcp — French
Simultaneous establishment of a TCP connection
 
cnp3-ebook/protocols/tcp — French
Denial of Service attacks
 
cnp3-ebook/protocols/tcp — French
When a TCP entity opens a TCP connection, it creates a Transmission Control Block (:term:`TCB`). The TCB contains the entire state that is maintained by the TCP entity for each TCP connection. During connection establishment, the TCB contains the local IP address, the remote IP address, the local port number, the remote port number, the current local sequence number and the last sequence number received from the remote entity. Until the mid 1990s, TCP implementations had a limit on the number of TCP connections that could be in the `SYN RCVD` state at a given time. Many implementations set this limit to about 100 TCBs. This limit was considered sufficient even for heavily load http servers given the small delay between the reception of a `SYN` segment and the reception of the `ACK` segment that terminates the establishment of the TCP connection. When the limit of 100 TCBs in the `SYN Rcvd` state is reached, the TCP entity discards all received TCP `SYN` segments that do not correspond to an existing TCB.
 
cnp3-ebook/protocols/tcp — French
This limit of 100 TCBs in the `SYN Rcvd` state was chosen to protect the TCP entity from the risk of overloading its memory with too many TCBs in the `SYN Rcvd` state. However, it was also the reason for a new type of Denial of Service (DoS) attack :rfc:`4987`. A DoS attack is defined as an attack where an attacker can render a resource unavailable in the network. For example, an attacker may cause a DoS attack on a 2 Mbps link used by a company by sending more than 2 Mbps of packets through this link. In this case, the DoS attack was more subtle. As a TCP entity discards all received `SYN` segments as soon as it has 100 TCBs in the `SYN Rcvd` state, an attacker simply had to send a few 100 `SYN` segments every second to a server and never reply to the received `SYN+ACK` segments. To avoid being caught, attackers were of course sending these `SYN` segments with a different address than their own IP address [#fspoofing]_. On most TCP implementations, once a TCB entered the `SYN Rcvd` state, it remained in this state for several seconds, waiting for a retransmission of the initial `SYN` segment. This attack was later called a `SYN flood` attack and the servers of the ISP named panix were among the first to `be affected <http://memex.org/meme2-12.html>`_ by this attack.
 
cnp3-ebook/protocols/tcp — French
To avoid the `SYN flood` attacks, recent TCP implementations no longer enter the `SYN Rcvd` state upon reception of a `SYN segment`. Instead, they reply directly with a `SYN+ACK` segment and wait until the reception of a valid `ACK`. This implementation trick is only possible if the TCP implementation is able to verify that the received `ACK` segment acknowledges the `SYN+ACK` segment sent earlier without storing the initial sequence number of this `SYN+ACK` segment in a TCB. The solution to solve this problem, which is known as `SYN cookies <http://cr.yp.to/syncookies.html>`_ is to compute the 32 bits of the `ISN` as follows :
 
cnp3-ebook/protocols/tcp — French
the high order bits contain the low order bits of a counter that is incremented slowly
 
cnp3-ebook/protocols/tcp — French
the low order bits contain a hash value computed over the local and remote IP addresses and ports and a random secret only known to the server
 
cnp3-ebook/protocols/tcp — French
The advantage of the `SYN cookies`_ is that by using them, the server does not need to create a :term:`TCB` upon reception of the `SYN` segment and can still check the returned `ACK` segment by recomputing the `SYN cookie`. The main disadvantage is that they are not fully compatible with the TCP options. This is why they are not enabled by default on a typical system.
 
cnp3-ebook/protocols/tcp — French
Retransmitting the first `SYN` segment
 
cnp3-ebook/protocols/tcp — French
As IP provides an unreliable connectionless service, the `SYN` and `SYN+ACK` segments sent to open a TCP connection could be lost. Current TCP implementations start a retransmission timer when they send the first `SYN` segment. This timer is often set to three seconds for the first retransmission and then doubles after each retransmission :rfc:`2988`. TCP implementations also enforce a maximum number of retransmissions for the initial `SYN` segment.
 
cnp3-ebook/protocols/tcp — French
As explained earlier, TCP segments may contain an optional header extension. In the `SYN` and `SYN+ACK` segments, these options are used to negotiate some parameters and the utilization of extensions to the basic TCP specification.
 
cnp3-ebook/protocols/tcp — French
The first parameter which is negotiated during the establishment of a TCP connection is the Maximum Segment Size (:term:`MSS`). The MSS is the size of the largest segment that a TCP entity is able to process. According to :rfc:`879`, all TCP implementations must be able to receive TCP segments containing 536 bytes of payload. However, most TCP implementations are able to process larger segments. Such TCP implementations use the TCP MSS Option in the `SYN`/`SYN+ACK` segment to indicate the largest segment they are able to process. The MSS value indicates the maximum size of the payload of the TCP segments. The client (resp. server) stores in its :term:`TCB` the MSS value announced by the server (resp. the client).
 
cnp3-ebook/protocols/tcp — French
Another utilization of TCP options during connection establishment is to enable TCP extensions. For example, consider :rfc:`1323` (which is discussed in :ref:`TCPReliable`). :rfc:`1323` defines TCP extensions to support timestamps and larger windows. If the client supports :rfc:`1323`, it adds a :rfc:`1323` option to its `SYN` segment. If the server understands this :rfc:`1323` option and wishes to use it, it replies with a :rfc:`1323` option in the `SYN+ACK` segment and the extension defined in :rfc:`1323` is used throughout the TCP connection. Otherwise, if the server's `SYN+ACK` does not contain the :rfc:`1323` option, the client is not allowed to use this extension and the corresponding TCP header options throughout the TCP connection. TCP's option mechanism is flexible and it allows the extension of TCP while maintaining compatibility with older implementations.
 
cnp3-ebook/protocols/tcp — French
The TCP options are encoded by using a Type Length Value format where :
 
cnp3-ebook/protocols/tcp — French
the first byte indicates the `type` of the option.
 
cnp3-ebook/protocols/tcp — French
the second byte indicates the total length of the option (including the first two bytes) in bytes
 
cnp3-ebook/protocols/tcp — French
the last bytes are specific for each type of option
 
cnp3-ebook/protocols/tcp — French
:rfc:`793` defines the Maximum Segment Size (MSS) TCP option that must be understood by all TCP implementations. This option (type 2) has a length of 4 bytes and contains a 16 bits word that indicates the MSS supported by the sender of the `SYN` segment. The MSS option can only be used in TCP segments having the `SYN` flag set.
 
cnp3-ebook/protocols/tcp — French
:rfc:`793` also defines two special options that must be supported by all TCP implementations. The first option is `End of option`. It is encoded as a single byte having value `0x00` and can be used to ensure that the TCP header extension ends on a 32 bits boundary. The `No-Operation` option, encoded as a single byte having value `0x01`, can be used when the TCP header extension contains several TCP options that should be aligned on 32 bit boundaries. All other options [#ftcpoptions]_ are encoded using the TLV format.
 
cnp3-ebook/protocols/tcp — French
The robustness principle
 
cnp3-ebook/protocols/tcp — French
The handling of the TCP options by TCP implementations is one of the many applications of the `robustness principle` which is usually attributed to `Jon Postel`_ and is often quoted as `"Be liberal in what you accept, and conservative in what you send"` :rfc:`1122`.
 
cnp3-ebook/protocols/tcp — French
Concerning the TCP options, the robustness principle implies that a TCP implementation should be able to accept TCP options that it does not understand, in particular in received `SYN` segments, and that it should be able to parse any received segment without crashing, even if the segment contains an unknown TCP option. Furthermore, a server should not send in the `SYN+ACK` segment or later, options that have not been proposed by the client in the `SYN` segment.
 
cnp3-ebook/protocols/tcp — French
TCP reliable data transfer
 
cnp3-ebook/protocols/tcp — French
The original TCP data transfer mechanisms were defined in :rfc:`793`. Based on the experience of using TCP on the growing global Internet, this part of the TCP specification has been updated and improved several times, always while preserving the backward compatibility with older TCP implementations. In this section, we review the main data transfer mechanisms used by TCP.
 
cnp3-ebook/protocols/tcp — French
TCP is a window-based transport protocol that provides a bi-directional byte stream service. This has several implications on the fields of the TCP header and the mechanisms used by TCP. The three fields of the TCP header are :
 
cnp3-ebook/protocols/tcp — French
`sequence number`. TCP uses a 32 bits sequence number. The `sequence number` placed in the header of a TCP segment containing data is the sequence number of the first byte of the payload of the TCP segment.
 
cnp3-ebook/protocols/tcp — French
`acknowledgment number`. TCP uses cumulative positive acknowledgments. Each TCP segment contains the `sequence number` of the next byte that the sender of the acknowledgment expects to receive from the remote host. In theory, the `acknowledgment number` is only valid if the `ACK` flag of the TCP header is set. In practice, almost all [#fackflag]_ TCP segments have their `ACK` flag set.
 
cnp3-ebook/protocols/tcp — French
`window`. a TCP receiver uses this 16 bits field to indicate the current size of its receive window expressed in bytes.
 
cnp3-ebook/protocols/tcp — French
The Transmission Control Block
 
cnp3-ebook/protocols/tcp — French
For each established TCP connection, a TCP implementation must maintain a Transmission Control Block (:term:`TCB`). A TCB contains all the information required to send and receive segments on this connection :rfc:`793`. This includes [#ftcpurgent]_ :
 
cnp3-ebook/protocols/tcp — French
the local IP address
 
cnp3-ebook/protocols/tcp — French
the remote IP address
 
cnp3-ebook/protocols/tcp — French
the local TCP port number
 
cnp3-ebook/protocols/tcp — French
the remote TCP port number
 
cnp3-ebook/protocols/tcp — French
the current state of the TCP FSM
 
cnp3-ebook/protocols/tcp — French
the `maximum segment size` (MSS)
 
cnp3-ebook/protocols/tcp — French
`snd.nxt` : the sequence number of the next byte in the byte stream (the first byte of a new data segment that you send uses this sequence number)
 
cnp3-ebook/protocols/tcp — French
`snd.una` : the earliest sequence number that has been sent but has not yet been acknowledged
 
cnp3-ebook/protocols/tcp — French
`snd.wnd` : the current size of the sending window (in bytes)
 
cnp3-ebook/protocols/tcp — French
`rcv.nxt` : the sequence number of the next byte that is expected to be received from the remote host
 
cnp3-ebook/protocols/tcp — French
`rcv.wnd` : the current size of the receive window advertised by the remote host
 
cnp3-ebook/protocols/tcp — French
`sending buffer` : a buffer used to store all unacknowledged data
 
cnp3-ebook/protocols/tcp — French
`receiving buffer` : a buffer to store all data received from the remote host that has not yet been delivered to the user. Data may be stored in the `receiving buffer` because either it was not received in sequence or because the user is too slow to process it
 
cnp3-ebook/protocols/tcp — French
The original TCP specification can be summarized as a transport protocol that provides a byte stream service and uses `go-back-n` with a `selective-repeat` reception strategy.
 
cnp3-ebook/protocols/tcp — French
To send new data on an established connection, a TCP entity performs the following operations on the corresponding TCB. It first checks that the `sending buffer` does not contain more data than the receive window advertised by the remote host (`rcv.wnd`). If the window is not full, up to `MSS` bytes of data are placed in the payload of a TCP segment. The `sequence number` of this segment is the sequence number of the first byte of the payload. It is set to the first available sequence number : `snd.nxt` and `snd.nxt` is incremented by the length of the payload of the TCP segment. The `acknowledgment number` of this segment is set to the current value of `rcv.nxt` and the `window` field of the TCP segment is computed based on the current occupancy of the `receiving buffer`. The data is kept in the `sending buffer` in case it needs to be retransmitted later.
 
cnp3-ebook/protocols/tcp — French
When a TCP segment with the `ACK` flag set is received, the following operations are performed. `rcv.wnd` is set to the value of the `window` field of the received segment. The `acknowledgment number` is compared to `snd.una`. The newly acknowledged data is removed from the `sending buffer` and `snd.una` is updated. If the TCP segment contained data, the `sequence number` is compared to `rcv.nxt`. If they are equal, the segment was received in sequence and the data can be delivered to the user and `rcv.nxt` is updated. The contents of the `receiving buffer` is checked to see whether other data already present in this buffer can be delivered in sequence to the user. If so, `rcv.nxt` is updated again. Otherwise, the segment's payload is placed in the `receiving buffer`.
 
cnp3-ebook/protocols/tcp — French
Segment transmission strategies
 
cnp3-ebook/protocols/tcp — French
In a transport protocol such as TCP that offers a bytestream, a practical issue that was left as an implementation choice in :rfc:`793` is to decide when a new TCP segment containing data must be sent. There are two simple and extreme implementation choices. The first implementation choice is to send a TCP segment as soon as the user has requested the transmission of some data. This allows TCP to provide a low delay service. However, if the user is sending data one byte at a time, TCP would place each user byte in a segment containing 20 bytes of TCP header [#fnagleip]_. This is a huge overhead that is not acceptable in wide area networks. A second simple solution would be to only transmit a new TCP segment once the user has produced MSS bytes of data. This solution reduces the overhead, but at the cost of a potentially very high delay.