2. cnp3-ebook
3. protocols/tcp
4. English
5. Zen

170 ../../protocols/tcp.rst:557
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — a non-`SYN` segment was received for a non-existing TCP connection :rfc:`793` 77/10000 · 77
171 ../../protocols/tcp.rst:558
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — by extension, some implementations respond with an `RST` segment to a segment that is received on an existing connection but with an invalid header :rfc:`3360`. This causes the corresponding connection to be closed and has caused security attacks :rfc:`4953` 258/10000 · 258
172 ../../protocols/tcp.rst:559
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — by extension, some implementations send an `RST` segment when they need to close an existing TCP connection (e.g., because there are not enough resources to support this connection or because the remote host is considered to be unreachable). Measurements have shown that this usage of TCP `RST` is widespread [AW05]_ 316/10000 · 316
173 ../../protocols/tcp.rst:561
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — When an `RST` segment is sent by a TCP entity, it should contain the current value of the `sequence number` for the connection (or 0 if it does not belong to any existing connection) and the `acknowledgment number` should be set to the next expected in-sequence `sequence number` on this connection. 299/10000 · 299
174 ../../protocols/tcp.rst:563
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — TCP `RST` wars 14/10000 · 14
175 ../../protocols/tcp.rst:567
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — The designers of TCP implementations should ensure that two TCP entities never enter a TCP `RST` war where host `A` is sending a `RST` segment in response to a previous `RST` segment that was sent by host `B` in response to a TCP `RST` segment sent by host `A` ... To avoid such an infinite exchange of `RST` segments that do not carry data, a TCP entity is *never* allowed to send a `RST` segment in response to another `RST` segment. 435/10000 · 435
176 ../../protocols/tcp.rst:570
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — The normal way of terminating a TCP connection is by using the graceful TCP connection release. This mechanism uses the `FIN` flag of the TCP header and allows each host to release its own direction of data transfer. As for the `SYN` flag, the utilization of the `FIN` flag in the TCP header consumes one sequence number. The figure :ref:`fig-tcprelease` shows the part of the TCP FSM used when a TCP connection is released. 424/10000 · 424
177 ../../protocols/tcp.rst:603
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Starting from the `Established` state, there are two main paths through this FSM. 81/10000 · 81
178 ../../protocols/tcp.rst:605
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — The first path is when the host receives a segment with sequence number `x` and the `FIN` flag set. The utilization of the `FIN` flag indicates that the byte before `sequence number` `x` was the last byte of the byte stream sent by the remote host. Once all of the data has been delivered to the user, the TCP entity sends an `ACK` segment whose `ack` field is set to :math:`(x+1) \pmod{2^{32}}` to acknowledge the `FIN` segment. The `FIN` segment is subject to the same retransmission mechanisms as a normal TCP segment. In particular, its transmission is protected by the retransmission timer. At this point, the TCP connection enters the `CLOSE\_WAIT` state. In this state, the host can still send data to the remote host. Once all its data have been sent, it sends a `FIN` segment and enter the `LAST\_ACK` state. In this state, the TCP entity waits for the acknowledgment of its `FIN` segment. It may still retransmit unacknowledged data segments, e.g., if the retransmission timer expires. Upon reception of the acknowledgment for the `FIN` segment, the TCP connection is completely closed and its :term:`TCB` can be discarded. 1133/10000 · 1133
179 ../../protocols/tcp.rst:607
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — The second path is when the host has transmitted all data. Assume that the last transmitted sequence number is `z`. Then, the host sends a `FIN` segment with sequence number :math:`(z+1) \pmod{2^{32}}` and enters the `FIN_WAIT1` state. In this state, it can retransmit unacknowledged segments but cannot send new data segments. It waits for an acknowledgment of its `FIN` segment (i.e. sequence number :math:`(z+1) \pmod{2^{32}}`), but may receive a `FIN` segment sent by the remote host. In the first case, the TCP connection enters the `FIN\_WAIT2` state. In this state, new data segments from the remote host are still accepted until the reception of the `FIN` segment. The acknowledgment for this `FIN` segment is sent once all data received before the `FIN` segment have been delivered to the user and the connection enters the `TIME\_WAIT` state. In the second case, a `FIN` segment is received and the connection enters the `Closing` state once all data received from the remote host have been delivered to the user. In this state, no new data segments can be sent and the host waits for an acknowledgment of its `FIN` segment before entering the `TIME\_WAIT` state. 1174/10000 · 1174
180 ../../protocols/tcp.rst:609
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — The `TIME\_WAIT` state is different from the other states of the TCP FSM. A TCP entity enters this state after having sent the last `ACK` segment on a TCP connection. This segment indicates to the remote host that all the data that it has sent have been correctly received and that it can safely release the TCP connection and discard the corresponding :term:`TCB`. After having sent the last `ACK` segment, a TCP connection enters the `TIME\_WAIT` and remains in this state for :math:`2*MSL` seconds. During this period, the TCB of the connection is maintained. This ensures that the TCP entity that sent the last `ACK` maintains enough state to be able to retransmit this segment if this `ACK` segment is lost and the remote host retransmits its last `FIN` segment or another one. The delay of :math:`2*MSL` seconds ensures that any duplicate segments on the connection would be handled correctly without causing the transmission of an `RST` segment. Without the `TIME\_WAIT` state and the :math:`2*MSL` seconds delay, the connection release would not be graceful when the last `ACK` segment is lost. 1102/10000 · 1102
181 ../../protocols/tcp.rst:611
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — TIME\_WAIT on busy TCP servers 30/10000 · 30
182 ../../protocols/tcp.rst:613
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — The :math:`2*MSL` seconds delay in the `TIME\_WAIT` state is an important operational problem on servers having thousands of simultaneously opened TCP connections [FTY99]_. Consider for example a busy web server that processes 10.000 TCP connections every second. If each of these connections remains in the `TIME\_WAIT` state for 4 minutes, this implies that the server would have to maintain more than 2 million TCBs at any time. For this reason, some TCP implementations prefer to perform an abrupt connection release by sending a `RST` segment to close the connection [AW05]_ and immediately discard the corresponding :term:`TCB`. However, if the `RST` segment is lost, the remote host continues to maintain a :term:`TCB` for a connection that no longer exists. This optimization reduces the number of TCBs maintained by the host sending the `RST` segment but at the potential cost of increased processing on the remote host when the `RST` segment is lost. 960/10000 · 960
183 ../../protocols/tcp.rst:620
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Footnotes 9/10000 · 9
184 ../../protocols/tcp.rst:621
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — A detailed presentation of all standardization documents concerning TCP may be found in :rfc:`4614` 99/10000 · 99
185 ../../protocols/tcp.rst:623
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Several researchers have analyzed the utilization of TCP and UDP in the global Internet. Most of these studies have been performed by collecting all the packets transmitted over a given link during a period of a few hours or days and then analyzing their headers to infer the transport protocol used, the type of application, ... Recent studies include http://www.caida.org/research/traffic-analysis/tcpudpratio/, https://research.sprintlabs.com/packstat/packetoverview.php or http://www.nanog.org/meetings/nanog43/presentations/Labovitz_internetstats_N43.pdf 559/10000 · 559
186 ../../protocols/tcp.rst:625
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — This 32 bits counter was specified in :rfc:`793`. A 32 bits counter that is incremented every 4 microseconds wraps in about 4.5 hours. This period is much larger than the Maximum Segment Lifetime that is fixed at 2 minutes in the Internet (:rfc:`791`, :rfc:`1122`). 265/10000 · 265
187 ../../protocols/tcp.rst:627
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — On many departmental networks containing Unix workstations, it was common to allow users on one of the hosts to use ``rlogin`` :rfc:`1258` to run commands on any of the workstations of the network without giving any password. In this case, the remote workstation "authenticated" the client host based on its IP address. This was a bad practice from a security viewpoint. 371/10000 · 371
188 ../../protocols/tcp.rst:634
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Of course, such a simultaneous TCP establishment can only occur if the source port chosen by the client is equal to the destination port chosen by the server. This may happen when a host can serve both as a client as a server or in peer-to-peer applications when the communicating hosts do not use ephemeral port numbers. 321/10000 · 321
189 ../../protocols/tcp.rst:636
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Sending a packet with a different source IP address than the address allocated to the host is called sending a :term:`spoofed packet`. 134/10000 · 134