Comment garantir une transmission complète des données dans un proxy TCP ?

Comment résoudre l'incertitude dans la transmission de données du proxy TCP

Lors de la conception d'un proxy TCP qui transmet les requêtes et les réponses entre un client et un serveur, il est crucial de s’assurer que les données sont transmises correctement. Un défi clé se pose lorsqu'il s'agit de déterminer si toutes les informations nécessaires ont été reçues du serveur pour être transmises au client.

Une approche courante consiste à supposer que lorsqu'une opération de lecture à partir de la connexion au serveur renvoie zéro, cela signifie que fin de la transmission des données. Cependant, si le serveur écrit les données sur le socket un octet à la fois, le proxy peut conclure à tort qu'il a reçu toutes les données. En effet, l'opération de lecture peut se produire rapidement, ne lisant que des données partielles avant que le serveur ait fini de transmettre.

Résoudre le problème

Pour résoudre ce problème, un système plus robuste L’approche consiste à utiliser la mise en mémoire tampon et une minuterie. En lisant les données dans un tampon et en vérifiant périodiquement leur longueur, le proxy peut déterminer quand une réponse complète a été reçue. La minuterie garantit que le proxy n'attend pas indéfiniment au cas où le serveur serait bloqué ou déconnecté.

Une considération supplémentaire est la possibilité d'une partition réseau. Si le serveur devient temporairement indisponible, le proxy ne doit pas supposer qu'il a reçu toutes les données. Au lieu de cela, il doit gérer l'exception de délai d'attente de manière appropriée pour maintenir la stabilité de la connexion.

Optimisation du code

Le code fourni dans la question peut être optimisé en utilisant une goroutine distincte pour chaque sens du transfert de données. Cela permet au proxy de gérer les données en parallèle pour les connexions client et serveur.

Exemple d'implémentation

L'extrait de code suivant illustre une implémentation de proxy optimisée à l'aide de goroutines :

package main

import (
    "fmt"
    "net"
)

type Proxy struct {
    ServerConn *net.TCPConn
    ClientConn *net.TCPConn
}

func (p *Proxy) Proxy() {
    fmt.Println("Running proxy...")
    go func() {
        _, err := io.Copy(p.ServerConn, p.ClientConn)
        if err != nil {
            fmt.Println(err)
        }
    }()

    go func() {
        _, err := io.Copy(p.ClientConn, p.ServerConn)
        if err != nil {
            fmt.Println(err)
        }
    }()
}

func main() {
    // Initialize the TCP connections
    serverConn, clientConn, err := net.DialTCP("tcp", nil, &net.TCPAddr{IP: net.ParseIP("127.0.0.1"), Port: 8080})
    if err != nil {
        fmt.Println(err)
        return
    }

    proxy := Proxy{serverConn, clientConn}
    proxy.Proxy()
}

Ce code est plus efficace et gère les erreurs avec plus de grâce que le code original fourni.

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!