The TCP/IP Guide - TCP Connection Termination

In the normal case, each side terminates its end of the connection by sending a special message with the FIN (finish) bit set. This message, sometimes called a FIN, serves as a connection termination request to the other device, while also possibly carrying data like a regular segment. The device receiving the FIN responds with an acknowledgment to the FIN to indicate that it was received. The connection as a whole is not considered terminated until both sides have finished the shut down procedure by sending a FIN and receiving an ACK.

Thus, termination isn't a three-way handshake like establishment: it is a pair of two-way handshakes. The states that the two devices in the connection move through during a normal connection shutdown are different because the device initiating the shutdown must behave differently than the one that receives the termination request. In particular, the TCP on the device receiving the initial termination request must inform its application process and wait for a signal that the process is ready to proceed. The initiating device doesn't need to do this, since the application is what started the ball rolling in the first place.

Table 154 describes in detail how the connection termination process works; the progression of states and messages exchanged can also be seen in Figure 214. The table is adapted from Table 151, describing the TCP finite state machine, but shows what happens for both the server and the client over time during connection shutdown. Either device can initiate connection termination; in this example I am assuming the client does it. Each row shows the state each device begins in, what action it takes in that state and what state to which it transitions. I have also shown the send and receive stages of both of the steps for each of the client and server’s close operations.

**Table 154: TCP Connection Termination Procedure**
Client			Server
Start State	Action	Transitions To State	Start State	Action	Transitions To State
*ESTABLISHED*	Client Close Step #1 Transmit: The application using TCP signals that the connection is no longer needed. The client TCP sends a segment with the FIN bit set to request that the connection be closed.	*FIN-WAIT-1*	*ESTABLISHED*	At this stage the server is still in normal operating mode.	—
*FIN-WAIT-1*	The client, having sent a FIN, is waiting for it to both be acknowledged and for the serve to send its own FIN. In this state the client can still receive data from the server but will no longer accept data from its local application to be sent to the server.	—	*ESTABLISHED*	Client Close Step #1 Receive and Step #2 Transmit: The server receives the client's FIN. It sends an ACK to acknowledge the FIN. The server must wait for the application using it to be told the other end is closing, so the application here can finish what it is doing.	*CLOSE-WAIT*
*FIN-WAIT-1*	Client Close Step #2 Receive: The client receives the ACK for its FIN. It must now wait for the server to close.	*FIN-WAIT-2*	*CLOSE-WAIT*	The server waits for the application process on its end to signal that it is ready to close.	—
*FIN-WAIT-2*	The client is waiting for the server's FIN.	—	*CLOSE-WAIT*	Server Close Step #1 Transmit: The server's TCP receives notice from the local application that it is done. The server sends its FIN to the client.	*LAST-ACK*
*FIN-WAIT-2*	Server Close Step #1 Receive and Step #2 Transmit: The client receives the server's FIN and sends back an ACK.	*TIME-WAIT*	*LAST-ACK*	The server is waiting for an ACK for the FIN it sent.	—
*TIME-WAIT*	The client waits for a period of time equal to double the maximum segment life (MSL) time, to ensure the ACK it sent was received.	—	*LAST-ACK*	Server Close Step #2 Receive: The server receives the ACK to its FIN and closes the connection.	*CLOSED*
*TIME-WAIT*	The timer expires after double the MSL time.	*CLOSED*	*CLOSED*	The connection is closed on the server's end.
*CLOSED*	The connection is closed.		*CLOSED*	The connection is closed.

**Figure 214: TCP Connection Termination Procedure**
This diagram shows the conventional termination procedure for a TCP session, with one device initiating termination and the other responding. In this case the client initiates; it sends a *FIN* which is acknowledged by the server. The server waits for the server process to be ready to close and then sends its *FIN*, which is acknowledged by the client. The client waits for a period of time to ensure that its *ACK* is received, before proceeding to the *CLOSED* state.

TCP Connection Management and Problem Handling, the Connection Reset Function, and TCP "Keepalives"

TCP Message Formatting and Data Transfer

If you find The TCP/IP Guide useful, please consider making a small Paypal donation to help the site, using one of the buttons below. You can also donate a custom amount using the far right button (not less than $1 please, or PayPal gets most/all of your money!) In lieu of a larger donation, you may wish to consider purchasing a download license of The TCP/IP Guide. Thanks for your support!

Home - Table Of Contents - Contact Us

The TCP/IP Guide (http://www.TCPIPGuide.com)
Version 3.0 - Version Date: September 20, 2005

© Copyright 2001-2005 Charles M. Kozierok. All Rights Reserved.
Not responsible for any loss resulting from the use of this site.

Please Whitelist This Site?