Solution of QT TCP packet sticking

1. Why? TCP There will be sticky subcontracting and half subcontracting ?

TCP There are many reasons for the phenomenon of sticking and subcontracting , It may be caused by the sender , It may also be caused by the receiver .

• The cause of the sender is caused by TCP The agreement itself

  TCP To improve transmission efficiency , The sender often needs to collect enough data before sending a packet of data . If the data sent several times in succession is very small , Usually TCP According to the optimization algorithm, these data will be synthesized into a packet and sent out at a time , The receiver then receives the packet data . The advantages are obvious , It is to reduce the number of small packets in the WAN , So as to reduce the emergence of network congestion . In general ： The sender sent data several times , The receiver reads all the data at one time , Cause multiple sending and one reading ; Usually network traffic optimization , Fill up several small data segments to a certain amount of data , Thus, the transmission times in the network link are reduced .

• The reason caused by the receiver is that the user process of the receiver does not receive data in time , This leads to the phenomenon of sticking .

  Because the receiving party first puts the received data in the system receiving buffer , The user process fetches data from this buffer , If the data of the previous packet has not been taken away by the user process when the next packet arrives , When the next packet is placed in the receiving buffer of the system, it will be received after the previous packet , The user process receives data from the system according to the preset buffer size , In this way, multiple packets of data are fetched at one time .

• Subcontracting or semi subcontracting refers to that our receiver should subcontract when sticky packets occur .

  Subcontracting phenomenon in A long connection Will appear in . In general ： The sender sent a large amount of data , When the receiving end reads the data, the data arrives in batches , Cause one send and multiple reads （ In practice , Client on TCP_NODELAY after , The server is still contaminated , So here is sending multiple times and reading once ）; It is usually related to the cache size of network routes , The size of a data segment exceeds the cache size , Then unpack and send .

2. How to deal with the phenomenon of sticking and subcontracting ?

tcp Sticky package 、 Half package processing ：

• One is to use separator , Use a special separator as the end of a packet , for example :”$$”;

• The second is to adopt a specific location for each package （ For example, the first two bytes of the packet ） Add the length information of the packet , After the other end receives the data, it intercepts the data of a specific length according to the length of the data packet for analysis .

3. Qt Handle sticky and half wrapped demo

For simple display , Use QList< QByteArray > To simulate the socket Receive multiple data , And a complete packet with “$$” end , for example ：1111$$

#include <QApplication>
#include <QDebug>
int main(int argc, char *argv[])
{
    
    //  Simulate sticky packet and half packet data 
    QList<QByteArray> recvMsgs = {
    "1111$$2222$$xxxxx","3333$$444$$yyyy"};
    static QByteArray halfData="0000"; //  Half packet data left over from the last time 

    for (int var = 0; var < recvMsgs.size (); ++var) {
    
        auto recvMsg = recvMsgs.at (var);
        //  Package data 
        int idx = 0;
        while (idx != -1) {
    
            //  from idx Location start search $$ The location of 
            int postion = recvMsg.indexOf ("$$",idx); //  Solve the sticking problem  "1111$$2222$$xxxxx"
            if(postion != -1) {
    
                //  obtain $$ Data before , barring $$
                auto byte = recvMsg.mid(idx, postion - idx);
                if(!halfData.isEmpty ()){
    
                    byte = halfData+byte;
                    halfData.clear ();
                }
                qDebug() << byte;
                postion += 2;
            }
            else{
    
                //  If there is a half bag phenomenon , Then put the last "$$" Save the data after , Temporarily not used 
                if(idx < recvMsg.length ()){
    
                    halfData = recvMsg.mid (idx);
                }
            }
            idx = postion;
        }
        qDebug() << " The remaining half packet of data :" << halfData;
    }
}

Running results ：

"00001111"
"2222"
 The remaining half packet of data : "xxxxx"
"xxxxx3333"
"444"
 The remaining half packet of data : "yyyy"

Reference applications ：

[tcp Sticky package （ One ） - silyvin - Blog Garden (cnblogs.com)]: