2 files changed, 54 insertions, 14 deletions

diff --git a/src/plugins/qmltooling/packetprotocol/qpacketprotocol.cpp b/src/plugins/qmltooling/packetprotocol/qpacketprotocol.cpp
index e1d6263e36..c256501301 100644
--- a/src/plugins/qmltooling/packetprotocol/qpacketprotocol.cpp
+++ b/src/plugins/qmltooling/packetprotocol/qpacketprotocol.cpp
@@ -106,6 +106,9 @@ class QPacketProtocolPrivate : public QObjectPrivate
 public:
     QPacketProtocolPrivate(QIODevice *dev);
 
+    bool writeToDevice(const char *bytes, qint64 size);
+    bool readFromDevice(char *buffer, qint64 size);
+
     QList<qint32> sendingPackets;
     QList<QByteArray> packets;
     QByteArray inProgress;
@@ -143,18 +146,18 @@ void QPacketProtocol::send(const QByteArray &data)
         return; // We don't send empty packets
 
     if (data.size() > maxSize) {
-        emit invalidPacket();
+        emit error();
         return;
     }
 
-    qint32 sendSize = data.size() + sizeof(qint32);
+    const qint32 sendSize = data.size() + static_cast<qint32>(sizeof(qint32));
     d->sendingPackets.append(sendSize);
+
     qint32 sendSizeLE = qToLittleEndian(sendSize);
-    qint64 writeBytes = d->dev->write((char *)&sendSizeLE, sizeof(qint32));
-    Q_UNUSED(writeBytes);
-    Q_ASSERT(writeBytes == sizeof(qint32));
-    writeBytes = d->dev->write(data);
-    Q_ASSERT(writeBytes == data.size());
+    if (!d->writeToDevice((const char *)&sendSizeLE, sizeof(qint32))
+            || !d->writeToDevice(data.data(), data.size())) {
+        emit error();
+    }
 }
 
 /*!
@@ -240,28 +243,41 @@ void QPacketProtocol::readyToRead()
         // Need to get trailing data
         if (-1 == d->inProgressSize) {
             // We need a size header of sizeof(qint32)
-            if (sizeof(qint32) > (uint)d->dev->bytesAvailable())
+            if (static_cast<qint64>(sizeof(qint32)) > d->dev->bytesAvailable())
                 return;
 
             // Read size header
             qint32 inProgressSizeLE;
-            const qint64 read = d->dev->read((char *)&inProgressSizeLE, sizeof(qint32));
+            if (!d->readFromDevice((char *)&inProgressSizeLE, sizeof(qint32))) {
+                emit error();
+                return;
+            }
             d->inProgressSize = qFromLittleEndian(inProgressSizeLE);
 
             // Check sizing constraints
-            if (read != sizeof(qint32) || d->inProgressSize < read) {
+            if (d->inProgressSize < qint32(sizeof(qint32))) {
                 disconnect(d->dev, &QIODevice::readyRead, this, &QPacketProtocol::readyToRead);
                 disconnect(d->dev, &QIODevice::aboutToClose, this, &QPacketProtocol::aboutToClose);
                 disconnect(d->dev, &QIODevice::bytesWritten, this, &QPacketProtocol::bytesWritten);
                 d->dev = nullptr;
-                emit invalidPacket();
+                emit error();
                 return;
             }
 
-            d->inProgressSize -= read;
+            d->inProgressSize -= sizeof(qint32);
         } else {
-            d->inProgress.append(d->dev->read(d->inProgressSize - d->inProgress.size()));
 
+            const int bytesToRead = static_cast<int>(
+                        qMin(d->dev->bytesAvailable(),
+                             static_cast<qint64>(d->inProgressSize - d->inProgress.size())));
+
+            QByteArray toRead(bytesToRead, Qt::Uninitialized);
+            if (!d->readFromDevice(toRead.data(), toRead.length())) {
+                emit error();
+                return;
+            }
+
+            d->inProgress.append(toRead);
             if (d->inProgressSize == d->inProgress.size()) {
                 // Packet has arrived!
                 d->packets.append(d->inProgress);
@@ -281,6 +297,30 @@ QPacketProtocolPrivate::QPacketProtocolPrivate(QIODevice *dev) :
 {
 }
 
+bool QPacketProtocolPrivate::writeToDevice(const char *bytes, qint64 size)
+{
+    qint64 totalWritten = 0;
+    while (totalWritten < size) {
+        const qint64 chunkSize = dev->write(bytes + totalWritten, size - totalWritten);
+        if (chunkSize < 0)
+            return false;
+        totalWritten += chunkSize;
+    }
+    return totalWritten == size;
+}
+
+bool QPacketProtocolPrivate::readFromDevice(char *buffer, qint64 size)
+{
+    qint64 totalRead = 0;
+    while (totalRead < size) {
+        const qint64 chunkSize = dev->read(buffer + totalRead, size - totalRead);
+        if (chunkSize < 0)
+            return false;
+        totalRead += chunkSize;
+    }
+    return totalRead == size;
+}
+
 /*!
   \fn void QPacketProtocol::readyRead()
 
diff --git a/src/plugins/qmltooling/packetprotocol/qpacketprotocol_p.h b/src/plugins/qmltooling/packetprotocol/qpacketprotocol_p.h
index 35edb568aa..a478fc9996 100644
--- a/src/plugins/qmltooling/packetprotocol/qpacketprotocol_p.h
+++ b/src/plugins/qmltooling/packetprotocol/qpacketprotocol_p.h
@@ -72,7 +72,7 @@ public:
 
 Q_SIGNALS:
     void readyRead();
-    void invalidPacket();
+    void error();
 
 private:
     void aboutToClose();