A brief discussion of the TCP protocol, finally understand what it does

[[276056]]

1. What is TCP and what does it do?

TCP (Transmission Control Protocol) is a connection-oriented, reliable, byte stream-based transport layer communication protocol.

TCP is a transmission protocol designed to provide reliable end-to-end byte streams over the unreliable Internet.

The Internet is very different from a single network because different parts of the Internet can have very different topologies, bandwidths, delays, packet sizes, and other parameters. TCP is designed to dynamically adapt to these characteristics of the Internet and to be robust to various failures.

A reliable, pipe-like connection is often required between the application layers of different hosts, but the IP layer does not provide such a stream mechanism, but instead provides unreliable packet exchange.

The application layer sends a data stream represented by 8-bit bytes for transmission across the internet to the TCP layer, which then partitions the data stream into segments of appropriate lengths (usually limited by the maximum transmission unit (MTU) of the data link layer of the network being connected). TCP then passes the resulting packet to the IP layer, which delivers the packet to the TCP layer of the receiving entity through the network.

In order to prevent packet loss, TCP assigns a sequence number to each packet. The sequence number also ensures that the packets transmitted to the receiving entity are received in order.

The receiving entity returns a corresponding confirmation (ACK) for the successfully received packet; if the sending entity does not receive the confirmation within a reasonable round-trip delay (RTT), the corresponding data packet is assumed to be lost and will be retransmitted. TCP uses a checksum function to check whether the data is incorrect; the checksum must be calculated when sending and receiving.

Every machine that supports TCP has a TCP transport entity. The TCP entity can be a library procedure, a user process, or part of the kernel. In all these cases, it manages the TCP stream and the interface with the IP layer. The TCP transport entity receives user data streams from local processes and splits them into segments of no more than 64KB (usually no more than 1460 data bytes, excluding IP and TCP headers), each of which is sent as a separate IP datagram. When datagrams containing TCP data arrive at a machine, they are handed over to the TCP transport entity, which reconstructs the original byte stream. For simplicity, we sometimes just use TCP to represent the TCP transport entity (a piece of software) or the TCP protocol (a set of rules). You should be able to clearly infer the actual meaning based on the context. For example, in the sentence 'the user submits data to TCP', it is obvious that this refers to the TCP entity.

The IP layer does not guarantee that datagrams will be delivered correctly to the recipient, nor does it guarantee how fast datagrams are sent. It is TCP that is responsible for sending datagrams fast enough to use the network capacity, but not causing network congestion: and, after TCP times out, retransmitting undelivered datagrams. Even datagrams that are delivered correctly may contain errors, which is also the responsibility of TCP, which must reassemble received datagrams into the correct order. In short, TCP must provide good performance in terms of reliability, which is what most users expect and what IP does not provide.

2. Main features

When the application layer sends an 8-bit byte data stream to the TCP layer for Internet transmission, TCP divides the data stream into messages of appropriate lengths. TCP then passes the data packet to the IP layer, which transmits the packet to the TCP layer of the receiving entity through the network.

TCP is a communication protocol for wide area networks. Its purpose is to provide a communication method with the following characteristics between two communication endpoints when communicating across multiple networks:

(1) Flow-based approach;

(2) Connection-oriented;

(3) Reliable communication method;

(4) When the network conditions are poor, minimize the bandwidth overhead caused by retransmission;

(5) Communication connection maintenance is oriented towards the two endpoints, without considering the intermediate network segments and nodes.

To meet these characteristics of the TCP protocol, the TCP protocol makes the following provisions:

① Data fragmentation: User data is fragmented at the sending end and reassembled at the receiving end. TCP determines the size of the fragment and controls fragmentation and reassembly;

② Arrival confirmation: When the receiving end receives the fragmented data, it sends a confirmation to the sending end according to the fragmented data sequence number;

③ Timeout retransmission: The sender starts the timeout timer when sending the fragment. If no corresponding confirmation is received after the timer times out, the fragment is retransmitted;

④ Sliding window: The receiving buffer space size of each side of the TCP connection is fixed. The receiving end only allows the other end to send data that can be accommodated by the receiving end's buffer. TCP provides flow control based on the sliding window to prevent the faster host from causing the buffer of the slower host to overflow;

⑤ Out-of-order processing: TCP segments transmitted as IP datagrams may arrive out of order. TCP will reorder the received data and hand it over to the application layer in the correct order;

⑥ Duplicate processing: TCP segments transmitted as IP datagrams will be repeated, and the TCP receiver must discard the duplicate data;

⑦ Data checksum: TCP will maintain the checksum of its header and data, which is an end-to-end checksum, the purpose of which is to detect any changes in the data during transmission. If the checksum of the received segment is wrong, TCP will discard the segment and confirm that the receipt of this segment caused the other end to time out and resend.

3. Working method

Establishing a connection

TCP is the transport layer protocol in the Internet, which uses the three-way handshake protocol to establish a connection. When the active party sends a SYN connection request, it waits for the other party to respond with SYN+ACK, and finally performs ACK confirmation on the other party's SYN. ​​This method of establishing a connection can prevent the generation of incorrect connections. The flow control protocol used by TCP is the East China Window Protocol, which can be sized.

The TCP three-way handshake process is as follows:

(1) The client sends a SYN(SEQ=x) message to the server and enters the SYN_SEND state.

(2) The server receives the SYN message, responds with a SYN(SEQ=y)ACK(ACK=x+1) message, and enters the SYN_RECV state.

(3) The client receives the SYN message from the server and responds with an ACK (ACK=y+1) message, entering the Established state.

After the three-way handshake is completed, the TCP client and server have successfully established a connection and can start transmitting data. As shown in the figure:

Connection Termination

It takes three handshakes to establish a connection, and four handshakes to reconnect a connection, which is caused by TCP's half-close. The specific process is shown in the figure below.

(1) An application process first calls close, which is called an "active close". The TCP on that end then sends a FIN segment, indicating that the data distribution is complete.

(2) The peer end that receives this FIN performs a "passive close", and this FIN is confirmed by TCP.

Note: The reception of FIN also serves as an end-of-file to the receiving application, after any other datagrams queued for reception by the application, because the reception of FIN means that there is no additional data to be received by the application on that connection.

(3) After a period of time, the application process that receives this end-of-file character will call close to close its socket, which causes its TCP to also send a FIN.

(4) The original sending TCP that receives the final FIN (i.e., the end that performs the active close) acknowledges the FIN. Since each direction requires a FIN and an ACK, four segments are usually required.