CODEWITHSUNDEEP
c++qtsockets
Googie
Googie

Reputation: 6017

How to make blocking tcp socket with Qt?

I work with QTcpSocket. I need any write/read calls to the socket to be synchronous (blocking).

I know there is waitForReadyRead() and waitForBytesWritten(), but those two methods are marked in Qt documentation as they can fail randomly under Windows. I cannot affort this.

The blocking read is the most important (as reading comes always after writting a command to the other peer, so I know that if data reaches the other peer, it will answer).

I have tried 2 approaches.

First:

QByteArray readBytes(qint64 count)
{
    int sleepIterations = 0;
    QByteArray resultBytes;
    while (resultBytes.size() < count && sleepIterations < 100)
    {
        if (socket->bytesAvailable() == 0)
        {
            sleepIterations++;
            QThread::msleep(100);
            QCoreApplication::processEvents(QEventLoop::ExcludeUserInputEvents);
            continue;
        }

        resultBytes += socket->read(qMin(count, socket->bytesAvailable()));
    }
    return resultBytes;
}

This should wait for bytes to be available for reading on the socket, processing the event loop in the mean time, so the socket is doing it's necessary internal stuff.

Unfortunately - for unknown to me reason - the bytesAvailable() sometimes returns correct number of bytes, but sometimes it never returns anything greater than 0.

I know in fact that there was data to be read, because it used to work with the second approach (but it has it's own problems).

Second:

I have a kind of signal "blocker", which blocks current context and processes event loop, until certain signal is emitted. This is the "blocker":

SignalWait.h:

class SignalWait : public QObject
{
        Q_OBJECT

    public:
        SignalWait(QObject *object, const char *signal);

        bool wait(int msTimeout);

    private:
        bool called = false;

    private slots:
        void handleSignal();
};

SignalWait.cpp:

SignalWait::SignalWait(QObject* object, const char* signal) :
    QObject()
{
    connect(object, signal, this, SLOT(handleSignal()));
}

bool SignalWait::wait(int msTimeout)
{
    QTime timer(0, 0, 0, msTimeout);
    timer.start();
    while (!called && timer.elapsed() < msTimeout)
        QCoreApplication::processEvents(QEventLoop::ExcludeUserInputEvents);

    return called;
}

void SignalWait::handleSignal()
{
    called = true;
}

and then I used it like this:

SignalWait signalWait(socket, SIGNAL(readyRead()));
// ...
// socket->write(...);
// ...
if (!signalWait.wait(30000))
{
    // error
    return;
}
bytes = socket->read(size);

This approach seems to be working better, but it also fails from time to time. I don't know why. It's like the readyRead() signal was never emitted and the SignalWait keeps waiting, until it times out.

I'm out of ideas. What is the proper way to deal with it?

Upvotes: 4

Views: 6366

Answers (1)

Nejat
Nejat

Reputation: 32635

I would suggest to use the asynchronous approach but if you really want to go with the synchronous way, then a better way is to use a local event loop:

QTimer timer;
timer.setSingleShot(true);
QEventLoop loop;
loop.connect(socket, SIGNAL(readyRead()), SLOT(quit())); 
connect(&timer, SIGNAL(timeout()), &loop, SLOT(quit()));

while (resultBytes.size() < count)
{
    timer.start(msTimeout);
    loop.exec();

    if(timer.isActive())
        resultBytes += socket->read(qMin(count, socket->bytesAvailable()));
    else
        break;
}

Here it waits until count bytes are read or the the timeout reaches.

Upvotes: 6

Related Questions