Bonjour a tous !

Je vais vous expliquer un peu comment gérer le packet stacking qui est un problème assez courant en TCP.
Démonstration du problème :


Front size : Taille annoncé par le header du paquet (attention j'ai codé ca moi même donc il va falloir vous démerder ^^ )
Packet size : Taille retourné par recv.

Comme vous pouvez voir dans la console de mon serveur la taille front annoncé est 11 alors que la taille du packet est de 22 on en conclu donc que 2 packet de même type sont arrivé en 1 seul packet.

Vous vous demanderez "Donc ca arrive uniquement avec des paquets du même type ?" Et non ce n'est pas si simple que ca j'ai juste flooder le même packet avec mon logiciel pour tester le serveur.

Mais le problème est que cette erreur est arrivé après le 8ième packet avec un intervale de 500ms entre chaque packet.
On estime de nos jours qu'il faut 30-40 packet/secondes pour un jeu fluide donc imaginez le nombre de stack que l'on risque d'avoir de plus on peut empiler plus de 2 packet donc on a pas le choix il faut découpé le segment de donné reçu pour retrouvé les packets intacts.

Comment faire ?

    while(packet->size()!=0)
    {
        if(packet->front_size() == packet->size())
        {
            WorldPacket* pa = new WorldPacket;
            char* t = (char*)packet->c_str();
            pa->push_back(t,packet->size());
            _recvQueue.push(pa);
            packet->removeAll();
        }
        else if(packet->front_size() < packet->size())
        {
            _recvQueue.push(packet->pop_front());
        }
    }
    return 0;

Premièrement ce code ne compilera pas chez vous.
packet est le gros packet que l'on recoit par le recv.
pop_front retourne le paquet de taille front_size et les supprime de la queue.
en gros:
front_size = 5, packet = 10.
-----_____
pop_front()
pa = ----- , packet = _____

Ce que je conseil :
- Faire un header contenant la taille du packet, uint16_t suffira
- A la suite de la taille un checksum (optionel)
- A la suite l'opcode.
Vous extrayez les données a coup de memcpy et le tour est joué.

Le packet stacking est le problème le plus courant en TCP car on envoie généralement des petits paquet comme l'heure, un message sur le chat qui sont généralement assez court ("xD", "lol", "go !"...), des évenements NPC et AI, mais il y a aussi les packet coupé qui arrive quand le packet dépasse 1492 octets !
Il faut donc gérer le recollage des données ^^ .

Aussi ce problème ne surviendras pas en UDP mais en UDP les packets arrivent dans n'importe quel ordre et n'arrive pas toujours, donc ne vous cassez pas la tête sur le packet stacking UDP car vous n'aurez aucune chance d'en rencontrer.

Bonne chance a ce qui vont essayé !