Je souhaite créer un gadget proxy http en utilisant go :
func main() {
listener, err := net.Listen("tcp", ":8080")
if err != nil {
log.Panic(err)
}
for {
client, err := listener.Accept()
if err != nil {
log.Panic(err)
}
go handleClientRequest(client)
}
}
func handleClientRequest(client net.Conn) {
if client == nil {
return
}
defer client.Close()
var buf [1024]byte
n, err := client.Read(buf[:])
if err != nil {
log.Println(err)
return
}
fmt.Println("recv msg:", string(buf[0:n]))
}1024 octets ne suffisent peut-être pas, il doit y avoir une marque de fin, non ?
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
Le protocole TCP libère la connexion en envoyant le paquet FIN, le paquet FIN est donc la marque de fin, ce qui signifie qu'il est reçu jusqu'à ce que la connexion soit déconnectée.
Mais
Alors comment juger la fin après avoir activé Keep-Alive ?
En fait, l'en-tête HTTP a une longueur de contenu, qui correspond à la longueur du corps du paquet HTTP
Bien sûr, il existe également un cas où il n'y a pas de longueur de contenu, c'est-à-dire qu'un codage en bloc est utilisé. Les données sont divisées en une série de blocs et envoyées, et chaque bloc a une description de taille. Même si le serveur ne connaît pas la taille de l'entité entière lors de la génération de l'en-tête (généralement parce que l'entité est générée dynamiquement), le codage en fragments peut toujours être utilisé pour transmettre un certain nombre de fragments de taille connue.
De plus, l'en-tête et le corps du message HTTP sont séparés par CRLF (retour chariot et saut de ligne),
rnrn