Comment le serveur sait-il que le client n'existe plus ?

Contenu de la question

J'essaie de comprendre comment fonctionne TCP et tout ce que je sais jusqu'à présent, c'est que si une déconnexion "aléatoire" se produit, un côté n'a aucun moyen de savoir si l'autre côté est toujours en vie. C'est pourquoi certains algorithmes PING/PONG ou TCP keep-alive sont utilisés. J'ai créé une simple application client-serveur dans laquelle le client se connecte au serveur et envoie un simple message après 10 secondes. Ce qui m'embrouille, c'est comment le serveur sait que le client n'existe plus dans les deux cas suivants :

1. Je laisse le programme s'exécuter complètement et se terminer - dans ce cas le serveur ferme la connexion (je ne comprends pas comment le serveur sait que le client n'est plus là, je n'ai indiqué nulle part sur le client que je fermais le connexion)
2. J'ai fermé le processus client avant qu'il ne soit terminé (avant qu'il n'envoie un message au serveur) - dans ce cas, le serveur imprime le message suivant Error Reading: read tcp 127.0.0.1:8080->127.0.0.1:60845 : wsarecv: 现有连接被远程主机强行关闭. (Encore une fois, je ne comprends pas comment il sait que le client n'existe plus)

Je suppose que le système d'exploitation (ou la bibliothèque golang net) est impliqué et qu'il gère cette situation en envoyant un message supplémentaire ou similaire avant que la connexion TCP ne soit réellement fermée.

Toute aide est la bienvenue. Vous trouverez ci-dessous le code complet que j'ai utilisé pour que vous puissiez l'exécuter localement ou dans Go Playground en ligne.

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)
    }
}

Bonne réponse

J'ai réalisé que je parlais de quelque chose que je ne connais pas très bien, alors je l'ai testé moi-même. Exemple de jouet, dans trois terminaux distincts sur une même machine :

Supervision : sudo tcpdump -tttt -i lo port 8887（您可能需要找出您的本地主机设备是什么，也许是 lo0，使用 sudo tcpdump -D。观察 Flags 字段：. C’est ACK, le reste devrait être explicite. )

Serveur :nc -l 8887

Client :nc localhost 8887

• Client : SYN
• Serveur : SYN ACK
• Client : ACK

Tapez le client et appuyez sur Entrée

• Client : PSH ACK
• Serveur : ACK

Tapez le serveur et appuyez sur Entrée

• Serveur : PSH ACK
• Client : ACK

a) Arrêtez le client, soit via ctrl-c ou sigkill :

• Client : FIN ACK
• Serveur : FIN ACK
• Client : ACK

b) Arrêtez le serveur :

• Serveur : FIN ACK
• Client : ACK

Puis arrêtez le client :

• Client : FIN ACK
• Serveur : RST

Cette expérience a été réalisée sur WSL/Ubuntu. Je n'ai pas encore compilé votre programme, mais vous pouvez tester votre scénario vous-même. Une chose qui m'a surpris est que même si j'ai tué le processus client, le FIN a quand même été envoyé, ce qui suggère que si le processus client se termine avec un port ouvert, il est de la responsabilité du noyau d'envoyer le FIN. De plus, lorsque le processus côté serveur est arrêté, le FIN n'est pas envoyé, ce qui amène le client à rencontrer une réponse RST.

L'implémentation du noyau du protocole

TCP s'en charge ; mis à part ce qui se passe dans conn.Close(), cela n'a absolument aucun rapport avec Go.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!