Do you know how HTTP uses TCP connection? Today I will tell you

[[281789]]

1. How does HTTP use TCP connections?

Almost all HTTP communications in the world are carried by TCP/IP, a common packet-switched network layered protocol suite used by computers and network devices around the world. A client application can open a TCP/IP connection to a server application that may be running anywhere in the world. Once the connection is established, the messages exchanged between the client and server computers will never be lost, damaged, or out of order.

Although messages will not be lost or damaged, if the computer or network crashes, the communication between the client and the server will still be broken. In this case, the client and server will be notified that the communication has been interrupted.

When a browser receives a URL, it will perform several corresponding steps, as follows

1. The browser resolves the host name;
2. The browser queries the IP address of the host name;
3. The browser obtains the port number;
4. The browser initiates a link to the port number corresponding to the IP address;
5. The browser sends an HTTP GET message to the server;
6. The browser reads the HTTP response message from the server;
7. The browser closes the connection;

1.1 Basic knowledge of TCP connection

TCP is a reliable data pipe

TCP will carry HTTP data in order and without errors, and TCP provides a reliable bit transmission channel for HTTP. The bytes filled in from one end of the TCP connection will be transmitted correctly from the other end in the original order.

TCP streams are segmented and transmitted by IP packets

TCP data is sent in small blocks called IP packets (or IP datagrams).

In this case, as shown in the figure, HTTP is the top layer of the "protocol stack" of "HTTP over TCP over IP". Its secure version, HTTPS, inserts a cryptographic encryption layer (security layer) (called TLS or SSL) between HTTP and TCP, which is in the right half of the figure.

When HTTP wants to send a message, it transmits the contents of the message data in a stream in sequence through an open TCP connection. After receiving the data stream, TCP will chop the data stream into small data blocks called segments, and encapsulate the segments in IP packets and transmit them through the Internet, as shown in the following figure:

Each TCP segment is carried by an IP packet and sent from one IP address to another IP address.

Each IP group includes:

1. An IP packet header (usually 20 bytes);
2. A TCP segment header (usually 20 bytes);
3. A TCP block of data (0 or more bytes).

The IP header contains the source and destination IP addresses, length, and some other flags. The TCP segment header contains the TCP port number, TCP control flags, and some numeric values ​​used for data sequencing and integrity checks.

Keep TCP connections running continuously

A computer can have several TCP connections open at any given time. TCP keeps all of these connections running correctly using port numbers. Port numbers are similar to the telephone extension numbers that employees use.

This is the same as my previous example. The company's switchboard is just like your own landline. The company's switchboard number connects you to the front desk, and the extension number connects you to the correct employee location. The IP address connects you to the correct computer, and the port number connects you to the correct application. TCP connections are identified by 4 values:

Source IP address, source port number, destination IP address, destination port number

These four values ​​together uniquely define a connection. Two different TCP connections cannot have four identical address component values ​​(but some components of different connections can have the same value).

What we need to notice here is that some connections share the same destination port number, some connections use the same source IP address, and some use the same destination IP address, but no two different connections have all four values ​​the same.

TCP Sockets

The operating system provides some tools to manipulate its TCP connections. To explain the problem more specifically, let's look at a TCP programming interface. I won't introduce these sockets one by one. I'll give you a table so that you can understand it.

Socket API Call Description s = socket() Creates a new, unnamed, unassociated socket bind(s,) Assigns a local port number and interface to the socket connect(s,) Creates a connection between the local socket and the remote host and port listen(s,...) Marks a local socket as legal to accept connections s2 = accept(s) Waits for someone to establish a connection to the local port

The socket API allows users to create TCP endpoint data structures, connect these endpoints to remote server TCP endpoints, and read and write data streams. The TCP API hides all the handshake details of the underlying network protocol, as well as the segmentation and reassembly details between TCP data streams and IP packets.

How TCP clients and servers communicate through the TCP socket interface

The figure above illustrates how the socket API can be used to highlight the steps that a client and server should perform to implement an HTTP transaction.

2. TCP connection handshake

The TCP connection handshake needs to go through the following steps. As shown in the figure:

When requesting a new TCP connection, the client sends a small TCP packet (usually 40 to 60 bytes) to the server. A special SYN flag is set in this packet, indicating that this is a connection request.

If the server accepts the connection, it calculates some connection parameters and sends a TCP packet back to the client. The SYN and ACK flags in this packet are set, indicating that the connection request has been accepted.

Finally, the client sends a confirmation message back to the server, notifying it that the connection has been successfully established.

We never see these packets - they are all managed by the TCP/IP software and are invisible to it. All the HTTP programmer sees is the delay that occurs while the TCP connection is established.

What we need to pay attention to here is the handshake delay of the TCP connection. Usually HTTP transactions do not exchange much data. At this time, the SYN/SYN+ACK handshake (see segment a and segment b in the figure) will produce a measurable delay. The ACK packet of the TCP connection (see segment c in the figure) is usually large enough to carry the entire HTTP request message, and many HTTP server response messages can be put into a single IP packet (for example, the response is a small HTML file containing decorative images, or a 304 Not Modified response to a browser cache request).

TCP slow start

The performance of TCP data transmission also depends on the age of the TCP connection. TCP connections "tune" themselves over time, initially limiting the maximum speed of the connection and increasing the speed over time if data is successfully transmitted. This tuning is called TCP slow start and is used to prevent sudden overload and congestion on the Internet.

TCP slow start limits the number of packets that a TCP endpoint can transmit at any one time. In simple terms, for every packet successfully received, the sender has the right to send two more packets. If an HTTP transaction has a large amount of data to send, it cannot send all the packets at once. One packet must be sent, and then an acknowledgment must be waited for; then two packets can be sent, each of which must be acknowledged, so that four packets can be sent, and so on. This approach is called "opening the congestion window."

Because of this congestion control feature, new connections will be slower than "tuned" connections that have already exchanged a certain amount of data. Since tuned connections are faster, HTTP has facilities for reusing existing connections.

3. HTTP connection processing

We talked about TCP connection before. Let's analyze HTTP again. I also mentioned before that there is Keep-Alive in HTTP 1.0 and after 1.1. If you don't understand about Keep-Alive, please look at the previous article of the public account. Next, I will tell you about HTTP's processing of connections in several parts.

Parallel connections: Initiate concurrent HTTP requests through multiple TCP connections.

Persistent connections: Reuse TCP connections to eliminate connection and closing delays.

Pipelining: Initiate concurrent HTTP requests through a shared TCP connection.

Let's look at the serial:

Each transaction requires a new connection (serial establishment), so the connection delay and slow start delay will be added together.

Parallel connection means that HTTP allows the client to open multiple connections and execute multiple HTTP transactions in parallel, resulting in multiple parallel lines.

In fact, parallel connection does not refer to the transmission speed of the page. It is because multiple objects are progressing at the same time, so its speed is much faster than superimposing them, which makes you feel a lot faster.

Persistent Connections

HTTP 1.1 allows HTTP devices to keep TCP connections open after a transaction is complete, so that existing connections can be reused for future HTTP requests. A TCP connection that remains open after a transaction is complete is called a persistent connection. Non-persistent connections are closed after each transaction. Persistent connections remain open between transactions until the client or server decides to close them.

Pipeline connection (some people also call it pipeline connection)

HTTP/1.1 allows for optional request pipelining over persistent connections. This is another performance improvement over keep-alive connections. Multiple requests can be queued before a response arrives. While the first request is flowing through the network to the server on the other side of the world, the second and third requests can also be sent. In high-latency network conditions, this can reduce the network round-trip time and improve performance.

In fact, pipelining means that there is no need to wait for the server's response before sending several more requests. The browser can significantly shorten the page loading time by submitting a large number of HTTP requests, especially in the case of high transmission delay (lag/latency) (such as satellite connection). The key to this technology is that multiple HTTP request messages can be stuffed into one TCP packet at the same time, so only one packet is submitted to send multiple requests at the same time, thereby reducing redundant packets on the network and reducing line load. `