How does the server know that the client no longer exists?

Question content

I'm trying to understand how TCP works and all I know so far is that if a "random" disconnect occurs, one side There's no way of knowing if the other side still exists. This is why some PING/PONG algorithms or TCP keep-alive are used. I created a simple client-server application where the client connects to the server and sends a simple message after 10 seconds. What confuses me is how the server knows the client no longer exists in the following two cases:

1. I let the program run completely and complete - in which case the server closes the connection (I don't understand how the server knows the client is no longer around, I didn't indicate anywhere on the client that I was closing the connection)
2. I closed the client process before it finished (before it sent a message to the server) - in this case the server printed the following message Error Reading: read tcp 127.0.0.1:8080->127.0. 0.1:60845: wsarecv: The existing connection was forcibly closed by the remote host. (Again, I don't understand how it knows the client no longer exists)

I'm assuming that the operating system (or golang net library) is involved, and that it handles this situation by sending an additional message or similar before the TCP connection is actually closed.

Any help welcome. Below is the full code I used so you can run it locally or in the online Go Playground.

client.go

package main

import (
    "fmt"
    "net"
    "time"
)

func main() {
    // Connect to the server
    conn, err := net.Dial("tcp", "localhost:8080")
    if err != nil {
        fmt.Println("Error connecting:", err)
        return
    }
    defer conn.Close()

    // Send a message to the server
    message := "Hello from client!"
    time.Sleep(10000 * time.Millisecond)
    conn.Write([]byte(message))

    // Read the response from the server
    buffer := make([]byte, 1024)
    n, err := conn.Read(buffer)
    if err != nil {
        fmt.Println("Error reading:", err)
        return
    }

    // Print the server's response
    fmt.Printf("Received response from server: %s\n", buffer[:n])
}

server.go

package main

import (
    "fmt"
    "net"
)

func handleConnection(conn net.Conn) {
    defer conn.Close()

    // Obtain and print the client's IP address when the connection is established
    clientAddr := conn.RemoteAddr()
    fmt.Printf("Client connected from IP address: %s\n", clientAddr)

    for {
        // Read data from the client
        buffer := make([]byte, 1024)
        n, err := conn.Read(buffer)
        if err != nil {
            fmt.Println("Error reading:", err)
            return
        }

        // Print received message
        fmt.Printf("Received message from client (%s): %s\n", clientAddr, buffer[:n])

        // Send a response back to the client
        response := "Hello from server!"
        conn.Write([]byte(response))
    }
}

func main() {
    // Start listening on a port
    listener, err := net.Listen("tcp", "127.0.0.1:8080")
    if err != nil {
        fmt.Println("Error listening:", err)
        return
    }
    defer listener.Close()

    fmt.Println("Server listening on port 8080")

    for {
        // Wait for a connection
        conn, err := listener.Accept()
        if err != nil {
            fmt.Println("Error accepting connection:", err)
            continue
        }

        // Handle the connection in a goroutine
        go handleConnection(conn)
    }
}

Correct answer

I realized I was talking about something I'm not very familiar with, so I tested it myself. Toy example, in three separate terminals on the same machine:

Supervision: sudo tcpdump -tttt -i lo port 8887 (You may need to find out what your localhost device is, maybe lo0, use sudo tcpdump -D. Observe the Flags field: . is ACK, the others should be self-explanatory.)

Server:nc -l 8887

Client:nc localhost 8887

• Client: SYN
• Server: SYN ACK
• Client:ACK

Enter content in the client and press Enter

• Client: PSH ACK
• Server:ACK

Enter content in the server and press Enter

• Server: PSH ACK
• Client:ACK

a) Stop the client, either via ctrl-c or sigkill:

• Client: FIN ACK
• Server: FIN ACK
• Client:ACK

b) Stop the server:

• Server: FIN ACK
• Client:ACK

Then stop the client:

• Client: FIN ACK
• Server: RST

This experiment was completed on WSL/Ubuntu. I haven't compiled your program yet, but you can test your scenario yourself. One thing that surprised me is that even though I sigkilled the client process, the FIN was still sent, suggesting that if the client process terminates with an open port, it is the kernel's responsibility to send the FIN. Additionally, when the server-side process is stopped, the FIN is not sent, causing the client to encounter an RST response.

The kernel implementation of the TCP protocol handles this; apart from what happens in conn.Close(), this is completely irrelevant to Go.

The above is the detailed content of How does the server know that the client no longer exists?. For more information, please follow other related articles on the PHP Chinese website!