2011-04-27 10:05:43 +00:00
|
|
|
/****************************************************************************
|
|
|
|
**
|
2012-01-05 04:03:39 +00:00
|
|
|
** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies).
|
2012-01-20 03:06:31 +00:00
|
|
|
** Contact: http://www.qt-project.org/
|
2011-04-27 10:05:43 +00:00
|
|
|
**
|
|
|
|
** This file is part of the test suite of the Qt Toolkit.
|
|
|
|
**
|
|
|
|
** $QT_BEGIN_LICENSE:LGPL$
|
|
|
|
** GNU Lesser General Public License Usage
|
2011-05-24 09:34:08 +00:00
|
|
|
** This file may be used under the terms of the GNU Lesser General Public
|
|
|
|
** License version 2.1 as published by the Free Software Foundation and
|
|
|
|
** appearing in the file LICENSE.LGPL included in the packaging of this
|
|
|
|
** file. Please review the following information to ensure the GNU Lesser
|
|
|
|
** General Public License version 2.1 requirements will be met:
|
|
|
|
** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
|
2011-04-27 10:05:43 +00:00
|
|
|
**
|
|
|
|
** In addition, as a special exception, Nokia gives you certain additional
|
2011-05-24 09:34:08 +00:00
|
|
|
** rights. These rights are described in the Nokia Qt LGPL Exception
|
2011-04-27 10:05:43 +00:00
|
|
|
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
|
|
|
|
**
|
2011-05-24 09:34:08 +00:00
|
|
|
** GNU General Public License Usage
|
|
|
|
** Alternatively, this file may be used under the terms of the GNU General
|
|
|
|
** Public License version 3.0 as published by the Free Software Foundation
|
|
|
|
** and appearing in the file LICENSE.GPL included in the packaging of this
|
|
|
|
** file. Please review the following information to ensure the GNU General
|
|
|
|
** Public License version 3.0 requirements will be met:
|
|
|
|
** http://www.gnu.org/copyleft/gpl.html.
|
|
|
|
**
|
|
|
|
** Other Usage
|
|
|
|
** Alternatively, this file may be used in accordance with the terms and
|
|
|
|
** conditions contained in a signed written agreement between you and Nokia.
|
2011-04-27 10:05:43 +00:00
|
|
|
**
|
|
|
|
**
|
|
|
|
**
|
|
|
|
**
|
|
|
|
**
|
2012-01-24 06:17:24 +00:00
|
|
|
**
|
2011-04-27 10:05:43 +00:00
|
|
|
** $QT_END_LICENSE$
|
|
|
|
**
|
|
|
|
****************************************************************************/
|
|
|
|
#include "baselineprotocol.h"
|
|
|
|
#include <QLibraryInfo>
|
|
|
|
#include <QImage>
|
|
|
|
#include <QBuffer>
|
|
|
|
#include <QHostInfo>
|
|
|
|
#include <QSysInfo>
|
|
|
|
#include <QProcess>
|
|
|
|
#include <QFileInfo>
|
|
|
|
#include <QDir>
|
|
|
|
#include <QTime>
|
|
|
|
#include <QPointer>
|
|
|
|
|
|
|
|
const QString PI_TestCase(QLS("TestCase"));
|
|
|
|
const QString PI_HostName(QLS("HostName"));
|
|
|
|
const QString PI_HostAddress(QLS("HostAddress"));
|
|
|
|
const QString PI_OSName(QLS("OSName"));
|
|
|
|
const QString PI_OSVersion(QLS("OSVersion"));
|
|
|
|
const QString PI_QtVersion(QLS("QtVersion"));
|
2011-11-11 11:46:24 +00:00
|
|
|
const QString PI_QtBuildMode(QLS("QtBuildMode"));
|
2011-04-27 10:05:43 +00:00
|
|
|
const QString PI_GitCommit(QLS("GitCommit"));
|
|
|
|
const QString PI_QMakeSpec(QLS("QMakeSpec"));
|
|
|
|
const QString PI_PulseGitBranch(QLS("PulseGitBranch"));
|
|
|
|
const QString PI_PulseTestrBranch(QLS("PulseTestrBranch"));
|
|
|
|
|
|
|
|
#ifndef QMAKESPEC
|
|
|
|
#define QMAKESPEC "Unknown"
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#if defined(Q_OS_WIN)
|
|
|
|
#include <QtCore/qt_windows.h>
|
|
|
|
#endif
|
|
|
|
#if defined(Q_OS_UNIX)
|
|
|
|
#include <time.h>
|
|
|
|
#endif
|
|
|
|
void BaselineProtocol::sysSleep(int ms)
|
|
|
|
{
|
|
|
|
#if defined(Q_OS_WIN)
|
|
|
|
Sleep(DWORD(ms));
|
|
|
|
#else
|
|
|
|
struct timespec ts = { ms / 1000, (ms % 1000) * 1000 * 1000 };
|
|
|
|
nanosleep(&ts, NULL);
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
PlatformInfo::PlatformInfo()
|
2011-09-01 12:50:59 +00:00
|
|
|
: QMap<QString, QString>(), adHoc(true)
|
2011-04-27 10:05:43 +00:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
PlatformInfo PlatformInfo::localHostInfo()
|
|
|
|
{
|
|
|
|
PlatformInfo pi;
|
|
|
|
pi.insert(PI_HostName, QHostInfo::localHostName());
|
|
|
|
pi.insert(PI_QtVersion, QLS(qVersion()));
|
|
|
|
pi.insert(PI_QMakeSpec, QString(QLS(QMAKESPEC)).remove(QRegExp(QLS("^.*mkspecs/"))));
|
2011-11-11 11:46:24 +00:00
|
|
|
#if QT_VERSION >= 0x050000
|
|
|
|
pi.insert(PI_QtBuildMode, QLibraryInfo::isDebugBuild() ? QLS("QtDebug") : QLS("QtRelease"));
|
|
|
|
#endif
|
2011-04-27 10:05:43 +00:00
|
|
|
#if defined(Q_OS_LINUX)
|
|
|
|
pi.insert(PI_OSName, QLS("Linux"));
|
|
|
|
QProcess uname;
|
|
|
|
uname.start(QLS("uname"), QStringList() << QLS("-r"));
|
|
|
|
if (uname.waitForFinished(3000))
|
|
|
|
pi.insert(PI_OSVersion, QString::fromLocal8Bit(uname.readAllStandardOutput().constData()).simplified());
|
|
|
|
#elif defined(Q_OS_WINCE)
|
|
|
|
pi.insert(PI_OSName, QLS("WinCE"));
|
|
|
|
pi.insert(PI_OSVersion, QString::number(QSysInfo::windowsVersion()));
|
|
|
|
#elif defined(Q_OS_WIN)
|
|
|
|
pi.insert(PI_OSName, QLS("Windows"));
|
|
|
|
pi.insert(PI_OSVersion, QString::number(QSysInfo::windowsVersion()));
|
|
|
|
#elif defined(Q_OS_MAC)
|
|
|
|
pi.insert(PI_OSName, QLS("MacOS"));
|
2012-02-20 08:43:02 +00:00
|
|
|
pi.insert(PI_OSVersion, QString::number(QSysInfo::macVersion()));
|
2011-04-27 10:05:43 +00:00
|
|
|
#else
|
|
|
|
pi.insert(PI_OSName, QLS("Other"));
|
|
|
|
#endif
|
|
|
|
|
|
|
|
QProcess git;
|
|
|
|
QString cmd;
|
|
|
|
QStringList args;
|
|
|
|
#if defined(Q_OS_WIN)
|
|
|
|
cmd = QLS("cmd.exe");
|
|
|
|
args << QLS("/c") << QLS("git");
|
|
|
|
#else
|
|
|
|
cmd = QLS("git");
|
|
|
|
#endif
|
|
|
|
args << QLS("log") << QLS("--max-count=1") << QLS("--pretty=%H [%an] [%ad] %s");
|
|
|
|
git.start(cmd, args);
|
|
|
|
git.waitForFinished(3000);
|
|
|
|
if (!git.exitCode())
|
|
|
|
pi.insert(PI_GitCommit, QString::fromLocal8Bit(git.readAllStandardOutput().constData()).simplified());
|
|
|
|
else
|
|
|
|
pi.insert(PI_GitCommit, QLS("Unknown"));
|
|
|
|
|
|
|
|
QByteArray gb = qgetenv("PULSE_GIT_BRANCH");
|
2011-09-01 12:50:59 +00:00
|
|
|
if (!gb.isEmpty()) {
|
2011-04-27 10:05:43 +00:00
|
|
|
pi.insert(PI_PulseGitBranch, QString::fromLatin1(gb));
|
2011-09-01 12:50:59 +00:00
|
|
|
pi.setAdHocRun(false);
|
|
|
|
}
|
2011-04-27 10:05:43 +00:00
|
|
|
QByteArray tb = qgetenv("PULSE_TESTR_BRANCH");
|
2011-09-01 12:50:59 +00:00
|
|
|
if (!tb.isEmpty()) {
|
2011-04-27 10:05:43 +00:00
|
|
|
pi.insert(PI_PulseTestrBranch, QString::fromLatin1(tb));
|
2011-09-01 12:50:59 +00:00
|
|
|
pi.setAdHocRun(false);
|
|
|
|
}
|
2011-04-27 10:05:43 +00:00
|
|
|
|
|
|
|
return pi;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
PlatformInfo::PlatformInfo(const PlatformInfo &other)
|
|
|
|
: QMap<QString, QString>(other)
|
|
|
|
{
|
2011-09-01 12:50:59 +00:00
|
|
|
orides = other.orides;
|
|
|
|
adHoc = other.adHoc;
|
2011-04-27 10:05:43 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
PlatformInfo &PlatformInfo::operator=(const PlatformInfo &other)
|
|
|
|
{
|
|
|
|
QMap<QString, QString>::operator=(other);
|
2011-09-01 12:50:59 +00:00
|
|
|
orides = other.orides;
|
|
|
|
adHoc = other.adHoc;
|
2011-04-27 10:05:43 +00:00
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-09-01 12:50:59 +00:00
|
|
|
void PlatformInfo::addOverride(const QString& key, const QString& value)
|
|
|
|
{
|
|
|
|
orides.append(key);
|
|
|
|
orides.append(value);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
QStringList PlatformInfo::overrides() const
|
2011-04-27 10:05:43 +00:00
|
|
|
{
|
2011-09-01 12:50:59 +00:00
|
|
|
return orides;
|
2011-04-27 10:05:43 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-09-01 12:50:59 +00:00
|
|
|
void PlatformInfo::setAdHocRun(bool isAdHoc)
|
2011-04-27 10:05:43 +00:00
|
|
|
{
|
2011-09-01 12:50:59 +00:00
|
|
|
adHoc = isAdHoc;
|
2011-04-27 10:05:43 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-09-01 12:50:59 +00:00
|
|
|
bool PlatformInfo::isAdHocRun() const
|
2011-04-27 10:05:43 +00:00
|
|
|
{
|
2011-09-01 12:50:59 +00:00
|
|
|
return adHoc;
|
2011-04-27 10:05:43 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
QDataStream & operator<< (QDataStream &stream, const PlatformInfo &pi)
|
|
|
|
{
|
|
|
|
stream << static_cast<const QMap<QString, QString>&>(pi);
|
2011-09-01 12:50:59 +00:00
|
|
|
stream << pi.orides << pi.adHoc;
|
2011-04-27 10:05:43 +00:00
|
|
|
return stream;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
QDataStream & operator>> (QDataStream &stream, PlatformInfo &pi)
|
|
|
|
{
|
|
|
|
stream >> static_cast<QMap<QString, QString>&>(pi);
|
2011-09-01 12:50:59 +00:00
|
|
|
stream >> pi.orides >> pi.adHoc;
|
2011-04-27 10:05:43 +00:00
|
|
|
return stream;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
ImageItem &ImageItem::operator=(const ImageItem &other)
|
|
|
|
{
|
|
|
|
testFunction = other.testFunction;
|
|
|
|
itemName = other.itemName;
|
|
|
|
itemChecksum = other.itemChecksum;
|
|
|
|
status = other.status;
|
|
|
|
image = other.image;
|
|
|
|
imageChecksums = other.imageChecksums;
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Defined in lookup3.c:
|
|
|
|
void hashword2 (
|
|
|
|
const quint32 *k, /* the key, an array of quint32 values */
|
|
|
|
size_t length, /* the length of the key, in quint32s */
|
|
|
|
quint32 *pc, /* IN: seed OUT: primary hash value */
|
|
|
|
quint32 *pb); /* IN: more seed OUT: secondary hash value */
|
|
|
|
|
|
|
|
quint64 ImageItem::computeChecksum(const QImage &image)
|
|
|
|
{
|
|
|
|
QImage img(image);
|
|
|
|
const int bpl = img.bytesPerLine();
|
|
|
|
const int padBytes = bpl - (img.width() * img.depth() / 8);
|
|
|
|
if (padBytes) {
|
|
|
|
uchar *p = img.bits() + bpl - padBytes;
|
|
|
|
const int h = img.height();
|
|
|
|
for (int y = 0; y < h; ++y) {
|
2012-04-06 14:34:19 +00:00
|
|
|
memset(p, 0, padBytes);
|
2011-04-27 10:05:43 +00:00
|
|
|
p += bpl;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
quint32 h1 = 0xfeedbacc;
|
|
|
|
quint32 h2 = 0x21604894;
|
|
|
|
hashword2((const quint32 *)img.constBits(), img.byteCount()/4, &h1, &h2);
|
|
|
|
return (quint64(h1) << 32) | h2;
|
|
|
|
}
|
|
|
|
|
|
|
|
#if 0
|
|
|
|
QString ImageItem::engineAsString() const
|
|
|
|
{
|
|
|
|
switch (engine) {
|
|
|
|
case Raster:
|
|
|
|
return QLS("Raster");
|
|
|
|
break;
|
|
|
|
case OpenGL:
|
|
|
|
return QLS("OpenGL");
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
return QLS("Unknown");
|
|
|
|
}
|
|
|
|
|
|
|
|
QString ImageItem::formatAsString() const
|
|
|
|
{
|
|
|
|
static const int numFormats = 16;
|
|
|
|
static const char *formatNames[numFormats] = {
|
|
|
|
"Invalid",
|
|
|
|
"Mono",
|
|
|
|
"MonoLSB",
|
|
|
|
"Indexed8",
|
|
|
|
"RGB32",
|
|
|
|
"ARGB32",
|
|
|
|
"ARGB32-Premult",
|
|
|
|
"RGB16",
|
|
|
|
"ARGB8565-Premult",
|
|
|
|
"RGB666",
|
|
|
|
"ARGB6666-Premult",
|
|
|
|
"RGB555",
|
|
|
|
"ARGB8555-Premult",
|
|
|
|
"RGB888",
|
|
|
|
"RGB444",
|
|
|
|
"ARGB4444-Premult"
|
|
|
|
};
|
|
|
|
if (renderFormat < 0 || renderFormat >= numFormats)
|
|
|
|
return QLS("UnknownFormat");
|
|
|
|
return QLS(formatNames[renderFormat]);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
void ImageItem::writeImageToStream(QDataStream &out) const
|
|
|
|
{
|
|
|
|
if (image.isNull() || image.format() == QImage::Format_Invalid) {
|
|
|
|
out << quint8(0);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
out << quint8('Q') << quint8(image.format());
|
|
|
|
out << quint8(QSysInfo::ByteOrder) << quint8(0); // pad to multiple of 4 bytes
|
|
|
|
out << quint32(image.width()) << quint32(image.height()) << quint32(image.bytesPerLine());
|
|
|
|
out << qCompress((const uchar *)image.constBits(), image.byteCount());
|
|
|
|
//# can be followed by colormap for formats that use it
|
|
|
|
}
|
|
|
|
|
|
|
|
void ImageItem::readImageFromStream(QDataStream &in)
|
|
|
|
{
|
|
|
|
quint8 hdr, fmt, endian, pad;
|
|
|
|
quint32 width, height, bpl;
|
|
|
|
QByteArray data;
|
|
|
|
|
|
|
|
in >> hdr;
|
|
|
|
if (hdr != 'Q') {
|
|
|
|
image = QImage();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
in >> fmt >> endian >> pad;
|
|
|
|
if (!fmt || fmt >= QImage::NImageFormats) {
|
|
|
|
image = QImage();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (endian != QSysInfo::ByteOrder) {
|
|
|
|
qWarning("ImageItem cannot read streamed image with different endianness");
|
|
|
|
image = QImage();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
in >> width >> height >> bpl;
|
|
|
|
in >> data;
|
|
|
|
data = qUncompress(data);
|
|
|
|
QImage res((const uchar *)data.constData(), width, height, bpl, QImage::Format(fmt));
|
|
|
|
image = res.copy(); //# yuck, seems there is currently no way to avoid data copy
|
|
|
|
}
|
|
|
|
|
|
|
|
QDataStream & operator<< (QDataStream &stream, const ImageItem &ii)
|
|
|
|
{
|
|
|
|
stream << ii.testFunction << ii.itemName << ii.itemChecksum << quint8(ii.status) << ii.imageChecksums << ii.misc;
|
|
|
|
ii.writeImageToStream(stream);
|
|
|
|
return stream;
|
|
|
|
}
|
|
|
|
|
|
|
|
QDataStream & operator>> (QDataStream &stream, ImageItem &ii)
|
|
|
|
{
|
|
|
|
quint8 encStatus;
|
|
|
|
stream >> ii.testFunction >> ii.itemName >> ii.itemChecksum >> encStatus >> ii.imageChecksums >> ii.misc;
|
|
|
|
ii.status = ImageItem::ItemStatus(encStatus);
|
|
|
|
ii.readImageFromStream(stream);
|
|
|
|
return stream;
|
|
|
|
}
|
|
|
|
|
|
|
|
BaselineProtocol::BaselineProtocol()
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
BaselineProtocol::~BaselineProtocol()
|
|
|
|
{
|
|
|
|
socket.close();
|
|
|
|
if (socket.state() != QTcpSocket::UnconnectedState)
|
|
|
|
socket.waitForDisconnected(Timeout);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-09-01 12:50:59 +00:00
|
|
|
bool BaselineProtocol::connect(const QString &testCase, bool *dryrun, const PlatformInfo& clientInfo)
|
2011-04-27 10:05:43 +00:00
|
|
|
{
|
|
|
|
errMsg.clear();
|
|
|
|
QByteArray serverName(qgetenv("QT_LANCELOT_SERVER"));
|
|
|
|
if (serverName.isNull())
|
|
|
|
serverName = "lancelot.test.qt.nokia.com";
|
|
|
|
|
|
|
|
socket.connectToHost(serverName, ServerPort);
|
|
|
|
if (!socket.waitForConnected(Timeout)) {
|
|
|
|
sysSleep(Timeout); // Wait a bit and try again, the server might just be restarting
|
|
|
|
if (!socket.waitForConnected(Timeout)) {
|
|
|
|
errMsg += QLS("TCP connectToHost failed. Host:") + serverName + QLS(" port:") + QString::number(ServerPort);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-09-01 12:50:59 +00:00
|
|
|
PlatformInfo pi = clientInfo.isEmpty() ? PlatformInfo::localHostInfo() : clientInfo;
|
2011-04-27 10:05:43 +00:00
|
|
|
pi.insert(PI_TestCase, testCase);
|
|
|
|
QByteArray block;
|
|
|
|
QDataStream ds(&block, QIODevice::ReadWrite);
|
|
|
|
ds << pi;
|
|
|
|
if (!sendBlock(AcceptPlatformInfo, block)) {
|
|
|
|
errMsg += QLS("Failed to send data to server.");
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
Command cmd = UnknownError;
|
|
|
|
if (!receiveBlock(&cmd, &block)) {
|
2011-04-11 13:34:06 +00:00
|
|
|
errMsg.prepend(QLS("Failed to get response from server. "));
|
2011-04-27 10:05:43 +00:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (cmd == Abort) {
|
|
|
|
errMsg += QLS("Server rejected connection. Reason: ") + QString::fromLatin1(block);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (dryrun)
|
|
|
|
*dryrun = (cmd == DoDryRun);
|
|
|
|
|
|
|
|
if (cmd != Ack && cmd != DoDryRun) {
|
|
|
|
errMsg += QLS("Unexpected response from server.");
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
bool BaselineProtocol::acceptConnection(PlatformInfo *pi)
|
|
|
|
{
|
|
|
|
errMsg.clear();
|
|
|
|
|
|
|
|
QByteArray block;
|
|
|
|
Command cmd = AcceptPlatformInfo;
|
|
|
|
if (!receiveBlock(&cmd, &block) || cmd != AcceptPlatformInfo)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (pi) {
|
|
|
|
QDataStream ds(block);
|
|
|
|
ds >> *pi;
|
|
|
|
pi->insert(PI_HostAddress, socket.peerAddress().toString());
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
bool BaselineProtocol::requestBaselineChecksums(const QString &testFunction, ImageItemList *itemList)
|
|
|
|
{
|
|
|
|
errMsg.clear();
|
|
|
|
if (!itemList)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
for(ImageItemList::iterator it = itemList->begin(); it != itemList->end(); it++)
|
|
|
|
it->testFunction = testFunction;
|
|
|
|
|
|
|
|
QByteArray block;
|
2011-05-03 11:32:23 +00:00
|
|
|
QDataStream ds(&block, QIODevice::WriteOnly);
|
2011-04-27 10:05:43 +00:00
|
|
|
ds << *itemList;
|
|
|
|
if (!sendBlock(RequestBaselineChecksums, block))
|
|
|
|
return false;
|
2011-05-03 11:32:23 +00:00
|
|
|
|
2011-04-27 10:05:43 +00:00
|
|
|
Command cmd;
|
2011-05-03 11:32:23 +00:00
|
|
|
QByteArray rcvBlock;
|
|
|
|
if (!receiveBlock(&cmd, &rcvBlock) || cmd != BaselineProtocol::Ack)
|
2011-04-27 10:05:43 +00:00
|
|
|
return false;
|
2011-05-03 11:32:23 +00:00
|
|
|
QDataStream rds(&rcvBlock, QIODevice::ReadOnly);
|
|
|
|
rds >> *itemList;
|
2011-04-27 10:05:43 +00:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
bool BaselineProtocol::submitNewBaseline(const ImageItem &item, QByteArray *serverMsg)
|
|
|
|
{
|
|
|
|
Command cmd;
|
|
|
|
return (sendItem(AcceptNewBaseline, item) && receiveBlock(&cmd, serverMsg) && cmd == Ack);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
bool BaselineProtocol::submitMismatch(const ImageItem &item, QByteArray *serverMsg)
|
|
|
|
{
|
|
|
|
Command cmd;
|
|
|
|
return (sendItem(AcceptMismatch, item) && receiveBlock(&cmd, serverMsg) && cmd == Ack);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
bool BaselineProtocol::sendItem(Command cmd, const ImageItem &item)
|
|
|
|
{
|
|
|
|
errMsg.clear();
|
|
|
|
QBuffer buf;
|
|
|
|
buf.open(QIODevice::WriteOnly);
|
|
|
|
QDataStream ds(&buf);
|
|
|
|
ds << item;
|
|
|
|
if (!sendBlock(cmd, buf.data())) {
|
|
|
|
errMsg.prepend(QLS("Failed to submit image to server. "));
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
bool BaselineProtocol::sendBlock(Command cmd, const QByteArray &block)
|
|
|
|
{
|
|
|
|
QDataStream s(&socket);
|
|
|
|
// TBD: set qds version as a constant
|
|
|
|
s << quint16(ProtocolVersion) << quint16(cmd);
|
|
|
|
s.writeBytes(block.constData(), block.size());
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
bool BaselineProtocol::receiveBlock(Command *cmd, QByteArray *block)
|
|
|
|
{
|
|
|
|
while (socket.bytesAvailable() < int(2*sizeof(quint16) + sizeof(quint32))) {
|
|
|
|
if (!socket.waitForReadyRead(Timeout))
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
QDataStream ds(&socket);
|
|
|
|
quint16 rcvProtocolVersion, rcvCmd;
|
|
|
|
ds >> rcvProtocolVersion >> rcvCmd;
|
|
|
|
if (rcvProtocolVersion != ProtocolVersion) {
|
|
|
|
errMsg = QLS("Baseline protocol version mismatch, received:") + QString::number(rcvProtocolVersion)
|
|
|
|
+ QLS(" expected:") + QString::number(ProtocolVersion);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
if (cmd)
|
|
|
|
*cmd = Command(rcvCmd);
|
|
|
|
|
|
|
|
QByteArray uMsg;
|
|
|
|
quint32 remaining;
|
|
|
|
ds >> remaining;
|
|
|
|
uMsg.resize(remaining);
|
|
|
|
int got = 0;
|
|
|
|
char* uMsgBuf = uMsg.data();
|
|
|
|
do {
|
|
|
|
got = ds.readRawData(uMsgBuf, remaining);
|
|
|
|
remaining -= got;
|
|
|
|
uMsgBuf += got;
|
|
|
|
} while (remaining && got >= 0 && socket.waitForReadyRead(Timeout));
|
|
|
|
|
|
|
|
if (got < 0)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (block)
|
|
|
|
*block = uMsg;
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
QString BaselineProtocol::errorMessage()
|
|
|
|
{
|
|
|
|
QString ret = errMsg;
|
|
|
|
if (socket.error() >= 0)
|
|
|
|
ret += QLS(" Socket state: ") + socket.errorString();
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|