How to make sure that readyRead() signals from QTcpSocket can't be missed?

Question

When using `QTcpSocket` to receive data, the signal to use is `readyRead()`, which signals that new data is available. However, when you are in the corresponding slot implementation to read the data, no additional `readyRead()` will be emitted. This may make sense, as you are already in the function, where you are reading all the data that is available. Problem description However assume the following implementation of this slot: ``` void readSocketData() { datacounter += socket->readAll().length(); qDebug() << datacounter; } ``` What if some data arrives after calling `readAll()` but before leaving the slot? What if this was the last data packet sent by the other application (or at least the last one for some time)? No additional signal will be emitted, so you have to make sure to read all the data yourself. One way to minimize the problem (but not avoid it totally) Of course we can modify the slot like this: ``` void readSocketData() { while(socket->bytesAvailable()) datacounter +=…

Accepted Answer

Short answer

The documentation of `QIODevice::readyRead()` states:

`readyRead()` is not emitted recursively; if you reenter the event loop or call `waitForReadyRead()` inside a slot connected to the `readyRead()` signal, the signal will not be reemitted.

Thus, make sure that you

- don't instantiate a `QEventLoop` inside your slot,

- don't call `QApplication::processEvents()` inside your slot,

- don't call `QIODevice::waitForReadyRead()` inside your slot,

- don't use the same `QTcpSocket` instance within different threads.

Now you should always receive all data sent by the other side.

Background

The `readyRead()` signal is emitted by `QAbstractSocketPrivate::emitReadyRead()` as follows:

```
// Only emit readyRead() when not recursing.
if (!emittedReadyRead && channel == currentReadChannel) {
    QScopedValueRollback<bool> r(emittedReadyRead);
    emittedReadyRead = true;
    emit q->readyRead();
}
```

The `emittedReadyRead` variable is rolled back to `false` as soon as the `if` block goes out of scope (done by the `QScopedValueRollback`). So the only chance to miss a `readyRead()` signal is when the control flow reaches the `if` condition again before the processing of the last `readyRead()` signal has finished (in other words, when there would be a recursion).

And a recursion should only be possible in the situations listed above.

How to make sure that readyRead() signals from QTcpSocket can't be missed?

Solution

Problem