Initial import from the monolithic Qt.

This is the beginning of revision history for this module. If you
want to look at revision history older than this, please refer to the
Qt Git wiki for how to use Git history grafting. At the time of
writing, this wiki is located here:

http://qt.gitorious.org/qt/pages/GitIntroductionWithQt

If you have already performed the grafting and you don't see any
history beyond this commit, try running "git log" with the "--follow"
argument.

Branched from the monolithic repo, Qt master branch, at commit
896db169ea224deb96c59ce8af800d019de63f12

1 files changed, 552 insertions, 0 deletions

diff --git a/src/qtestlib/wince/cetcpsync/qtcesterconnection.cpp b/src/qtestlib/wince/cetcpsync/qtcesterconnection.cpp
new file mode 100644
index 000000000..5d358e80b
--- /dev/null
+++ b/src/qtestlib/wince/cetcpsync/qtcesterconnection.cpp
@@ -0,0 +1,552 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the tools applications of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, 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.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+#include "qtcesterconnection.h"
+#include <transfer_global.h>
+#include <QtCore/QDir>
+#include <QtCore/QFile>
+#include <QtCore/QFileInfo>
+#include <QtNetwork/QTcpSocket>
+#include <QtNetwork/QHostAddress>
+
+extern void debugOutput(const QString& text, int level);
+
+#pragma warning(disable:4996)
+
+#define END_ERROR(s, a) \
+            if(a) qDebug() << a; \
+            _freeSocket(s); \
+            return false;
+
+QtCesterConnection::QtCesterConnection()
+        : AbstractRemoteConnection()
+{
+}
+
+QtCesterConnection::~QtCesterConnection()
+{
+}
+
+bool QtCesterConnection::connect(QVariantList&)
+{
+    // We connect with each command, so this is always true
+    // The command itself will fail then
+    connected = true;
+    return true;
+}
+
+void QtCesterConnection::disconnect()
+{
+    connected = false;
+}
+
+bool QtCesterConnection::isConnected() const
+{
+    return connected;
+}
+
+bool QtCesterConnection::copyFileToDevice(const QString &localSource, const QString &deviceDest, bool failIfExists)
+{
+    debugOutput( qPrintable(QString::fromLatin1("Copy File: %1 -> %2").arg(localSource).arg(deviceDest)),0);
+    QFile localFile(localSource);
+    QFileInfo info(localSource);
+    if (!localFile.exists() || !localFile.open(QIODevice::ReadOnly)) {
+        qDebug() << "Could not open File!";
+        return false;
+    }
+    
+    QTcpSocket* socket = 0;
+    if (!_initCommand(socket, COMMAND_CREATE_FILE)) {
+        END_ERROR(socket, "Could not initialized command");
+    }
+    
+    CreateFileOptions option;
+    strcpy(option.fileName, qPrintable(deviceDest));
+#ifdef Q_OS_WIN
+    // Copy FileTime for update verification
+    FILETIME creationTime, accessTime, writeTime;
+    HANDLE localHandle = CreateFile(localSource.utf16(), GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, 0);
+    if (localHandle != INVALID_HANDLE_VALUE) {
+        if (GetFileTime(localHandle, &creationTime, &accessTime, &writeTime)) {
+            LocalFileTimeToFileTime(&writeTime, &writeTime);
+            option.fileTime = writeTime;
+        }
+        CloseHandle(localHandle);
+    }
+    DWORD attributes = GetFileAttributes(localSource.utf16());
+    if (attributes != -1 )
+        option.fileAttributes = attributes;
+#endif
+    option.fileSize = info.size();
+    option.overwriteExisting = !failIfExists;
+    
+    if (!_sendData(socket, (char*) &option, sizeof(option))) {
+        END_ERROR(socket, "Could not send options...");
+    }
+
+    if (!_checkResult(socket)) {
+        END_ERROR(socket, "Server did not accept configuration");
+    }
+    
+    int bytesWritten = 0;
+    const int bufferSize = 1024;
+    QByteArray data;
+    while (bytesWritten < option.fileSize) {
+        data = localFile.read(bufferSize);
+        bytesWritten += data.size();
+#ifdef Q_OS_WIN
+        wprintf( L"%s -> %s (%d / %d) %d %%\r", localSource.utf16() , deviceDest.utf16(),
+                 bytesWritten , option.fileSize, (100*bytesWritten)/option.fileSize );
+#endif
+        if (!_sendData(socket, data.constData(), data.size())) {
+            END_ERROR(socket, "Error during file transfer");
+        }
+        if (!_checkResult(socket)) {
+            END_ERROR(socket, "Got some strange result");
+        }
+    }
+#ifdef Q_OS_WIN
+    wprintf( L"\n"); // We should jump to next line...
+#endif
+    if (bytesWritten != option.fileSize) {
+        END_ERROR(socket, "Did not send sufficient data");
+    }
+    _freeSocket(socket);
+    return true;
+}
+
+bool QtCesterConnection::copyDirectoryToDevice(const QString &localSource, const QString &deviceDest, bool recursive)
+{
+    QTcpSocket* socket = NULL;
+    QFileInfo info(localSource);
+    if (!info.exists() || !info.isDir()) {
+        END_ERROR(socket, "Input directory invalid");
+    }
+    
+    createDirectory(deviceDest, true);
+    QDir dir(localSource);
+    QFileInfoList list = dir.entryInfoList(QDir::Files | QDir::Dirs | QDir::NoDotAndDotDot);
+    foreach(QFileInfo item, list) {
+        QString targetName = deviceDest + QLatin1String("\\") + item.fileName();
+        if (item.isDir()) {
+            if (recursive) {
+                if (!copyDirectoryToDevice(item.absoluteFilePath() , targetName, recursive))
+                    return false;
+            }
+        } else {
+            if (!copyFileToDevice(item.absoluteFilePath(), targetName))
+                return false;
+        }
+    }
+    return true;
+}
+
+bool QtCesterConnection::copyFileFromDevice(const QString &deviceSource, const QString &localDest, bool failIfExists)
+{
+    QFile targetFile(localDest);
+    QTcpSocket* socket = 0;
+    if (targetFile.exists() && failIfExists) {
+        END_ERROR(socket, "Local file not supposed to be overwritten");
+    }
+    
+    if (!targetFile.open(QIODevice::WriteOnly | QIODevice::Truncate)) {
+        END_ERROR(socket, "Could not open local file for writing");
+    }
+    
+    if (!_initCommand(socket, COMMAND_READ_FILE)) {
+        END_ERROR(socket, "Could not establish connection");
+    }
+    
+    ReadFileOptions option;
+    strcpy(option.fileName, qPrintable(deviceSource));
+    if (!_sendData(socket, (char*) &option, sizeof(option))) {
+        END_ERROR(socket, "Could not send options");
+    }
+    
+    QByteArray data;
+    if (!_receiveData(socket, data)) {
+        END_ERROR(socket, "Did not receive any data");
+    }
+    
+    ReadFileReply* reply = (ReadFileReply*) data.data();
+    if (!reply->fileValid) {
+        END_ERROR(socket, "Requested file invalid");
+    }
+    
+    int fileSize = reply->fileSize;
+    int currentSize = 0;
+    // ### TODO: make a little bit more error-prone
+    do {
+        _sendData(socket, COMMAND_SUCCESS, strlen(COMMAND_SUCCESS));
+        _receiveData(socket, data);
+        currentSize += data.size();
+        targetFile.write(data);
+    } while(currentSize < fileSize);
+    
+    _freeSocket(socket);
+    targetFile.close();
+    return true;
+}
+ 
+bool QtCesterConnection::copyDirectoryFromDevice(const QString& /*deviceSource*/
+                                                 , const QString& /*localDest*/
+                                                 , bool /*recursive*/)
+{
+    qDebug() << "To be implemented!! Should not be needed for autotest system";
+    exit(-1);
+    return false;
+}
+
+bool QtCesterConnection::copyFile(const QString &srcFile, const QString &destFile, bool failIfExists)
+{
+    QTcpSocket* socket = 0;
+    if (!_initCommand(socket, COMMAND_COPY_FILE)) {
+        END_ERROR(socket, "Could not establish connection for copy");
+    }
+    
+    CopyFileOptions option;
+    strcpy(option.from, qPrintable(srcFile));
+    strcpy(option.to, qPrintable(destFile));
+    option.overwriteExisting = !failIfExists;
+    if (!_sendData(socket, (char*) &option, sizeof(option))) {
+        END_ERROR(socket, "Could not send copy options");
+    }
+    
+    if (!_checkResult(socket)) {
+        END_ERROR(socket, "Copy failed");
+    }
+    
+    _freeSocket(socket);
+    return true;
+}
+
+bool QtCesterConnection::copyDirectory(const QString &srcDirectory, const QString &destDirectory,
+                                      bool recursive)
+{
+    QTcpSocket* socket = 0;
+    if (!_initCommand(socket, COMMAND_COPY_DIRECTORY)) {
+        END_ERROR(socket, "Could not establish connection for dir copy");
+    }
+    
+    CopyDirectoryOptions option;
+    strcpy(option.from, qPrintable(srcDirectory));
+    strcpy(option.to, qPrintable(destDirectory));
+    option.recursive = recursive;
+    if (!_sendData(socket, (char*) &option, sizeof(option))) {
+        END_ERROR(socket, "Could not send dir copy options");
+    }
+    
+    if (!_checkResult(socket)) {
+        END_ERROR(socket, "Dir Copy failed");
+    }
+    
+    _freeSocket(socket);
+    return true;
+}
+
+bool QtCesterConnection::deleteFile(const QString &fileName)
+{
+    QTcpSocket* socket = 0;
+    if (!_initCommand(socket, COMMAND_DELETE_FILE)) {
+        END_ERROR(socket, "Could not establish connection for file deletion");
+    }
+    
+    DeleteFileOptions option;
+    strcpy(option.fileName, qPrintable(fileName));
+    if (!_sendData(socket, (char*) &option, sizeof(option))) {
+        END_ERROR(socket, "Could not send file options");
+    }
+    
+    if (!_checkResult(socket)) {
+        //END_ERROR(socket, "File Deletion failed");
+        // This is actually not an error so ignore it.
+    }
+    
+    _freeSocket(socket);
+    return true;
+}
+
+bool QtCesterConnection::deleteDirectory(const QString &directory, bool recursive, bool failIfContentExists)
+{
+    QTcpSocket* socket = 0;
+    if (!_initCommand(socket, COMMAND_DELETE_DIRECTORY)) {
+        END_ERROR(socket, "Could not establish connection for dir deletion");
+    }
+    
+    DeleteDirectoryOptions option;
+    strcpy(option.dirName, qPrintable(directory));
+    option.recursive = recursive;
+    option.failIfContentExists = failIfContentExists;
+    if (!_sendData(socket, (char*) &option, sizeof(option))) {
+        END_ERROR(socket, "Could not send dir options");
+    }
+    
+    if (!_checkResult(socket)) {
+        // we do not write an error as this will fail a lot on recursive.
+        END_ERROR(socket, 0);
+    }
+    
+    _freeSocket(socket);
+    return true;
+}
+
+bool QtCesterConnection::execute(QString program,
+                                 QString arguments,
+                                 int timeout,
+                                 int *returnValue)
+{
+    QTcpSocket* socket = 0;
+    if (!_initCommand(socket, COMMAND_EXECUTE)) {
+        END_ERROR(socket, "Could not establish connection for dir deletion");
+    }
+
+    ExecuteOptions options;
+    strcpy(options.appName, qPrintable(program));
+    QStringList argList = arguments.split(QLatin1Char(' '));
+    options.argumentsCount = qMin(argList.size(), MAX_ARGUMENTS);
+    options.waitForFinished = true;
+    options.timeout = timeout;
+    if (!_sendData(socket, (char*) &options, sizeof(options))) {
+        END_ERROR(socket, "Could not send dir options");
+    }
+    if (!_checkResult(socket)) {
+        END_ERROR(socket, "Did not receive an answer");
+    }
+
+    for (int i=0; i < options.argumentsCount; ++i) {
+        char someData[MAX_NAME_LENGTH];
+        strcpy(someData, qPrintable(argList[i]));
+        if (!_sendData(socket, someData, MAX_NAME_LENGTH)) {
+            END_ERROR(socket, "Could not send argument");
+        }
+        if (!_checkResult(socket)) {
+            END_ERROR(socket, "Failure in argument send");
+        }
+    }
+
+    // trigger the startup
+    if (!_sendData(socket, COMMAND_SUCCESS, strlen(COMMAND_SUCCESS))) {
+        END_ERROR(socket, "Could not trigger startup");
+    }
+    
+    const int waitTime = 60 * 60 * 1000;
+    if (!socket->waitForReadyRead(waitTime)) {
+        END_ERROR(socket, "Process timed out");
+    }
+    
+    QByteArray result = socket->readAll();
+    if (result != COMMAND_SUCCESS) {
+        if (returnValue)
+            *returnValue = -1; // just some at least
+        END_ERROR(socket, "Application did not start or returned error");
+    }
+    
+    if (returnValue)
+        *returnValue = 0;
+    _freeSocket(socket);
+    return true;
+}
+
+bool QtCesterConnection::createDirectory(const QString &path, bool deleteBefore)
+{
+    if (deleteBefore)
+        deleteDirectory(path, true, true);
+    
+    QTcpSocket* socket = 0;
+    if (!_initCommand(socket, COMMAND_CREATE_DIRECTORY)) {
+        END_ERROR(socket, "Could not establish connection for dir creation");
+    }
+    
+    CreateDirectoryOptions option;
+    strcpy(option.dirName, qPrintable(path));
+    option.recursively = true;
+    if (!_sendData(socket, (char*) &option, sizeof(option))) {
+        END_ERROR(socket, "Could not send dir options");
+    }
+    
+    if (!_checkResult(socket)) {
+        END_ERROR(socket, "Dir creation failed");
+    }
+    
+    _freeSocket(socket);
+    return true;
+}
+
+bool QtCesterConnection::timeStampForLocalFileTime(FILETIME* fTime) const
+{
+    if (!fTime)
+        return false;
+    
+    FILETIME copyTime = *fTime;
+    LocalFileTimeToFileTime(&copyTime, &copyTime);
+    
+    QTcpSocket* socket = 0;
+    if (!_initCommand(socket, COMMAND_TIME_STAMP)) {
+        END_ERROR(socket, "Could not establish time stamp connection");
+    }
+    
+    if (!_sendData(socket, (char*) &copyTime, sizeof(copyTime))) {
+        END_ERROR(socket, "Could not send stamp time");
+    }
+    
+    QByteArray data;
+    if (!_receiveData(socket, data)) {
+        END_ERROR(socket, "Did not receive time stamp or connection interrupted");
+    }
+    
+    copyTime = *((FILETIME*)data.data());
+    if (copyTime.dwLowDateTime == -1 && copyTime.dwHighDateTime == -1) {
+        END_ERROR(socket, "remote Time stamp failed!");
+    }
+    
+    *fTime = copyTime;
+    _freeSocket(socket);
+    return true;
+}
+
+bool QtCesterConnection::fileCreationTime(const QString &fileName, FILETIME* deviceCreationTime) const
+{
+    if (!deviceCreationTime)
+        return false;
+    
+    QTcpSocket* socket = 0;
+    if (!_initCommand(socket, COMMAND_FILE_TIME)) {
+        END_ERROR(socket, "Could not establish connection for file time access");
+    }
+    
+    FileTimeOptions option;
+    strcpy(option.fileName, qPrintable(fileName));
+    if (!_sendData(socket, (char*) &option, sizeof(option))) {
+        END_ERROR(socket, "Could not send file time name");
+    }
+    
+    QByteArray data;
+    if (!_receiveData(socket, data)) {
+        END_ERROR(socket, "File Time request failed");
+    }
+    
+    FILETIME* resultTime = (FILETIME*) data.data();
+    if (resultTime->dwLowDateTime == -1 && resultTime->dwHighDateTime == -1) {
+        END_ERROR(socket, 0);
+        debugOutput("Could not access file time", 0);
+    }
+    
+    *deviceCreationTime = *resultTime;
+    _freeSocket(socket);
+    return true;
+}
+
+bool QtCesterConnection::_createSocket(QTcpSocket*& result) const
+{
+    QTcpSocket* sock = new QTcpSocket();
+    QByteArray ipAddress = qgetenv("DEVICE_IP");
+    if (ipAddress.isEmpty()) {
+        qWarning("Error: You need to have DEVICE_IP set");
+        exit(0);
+    }
+    sock->connectToHost(QHostAddress(QString(ipAddress)), 12145);
+    
+    if (!sock->waitForConnected()) {
+        qDebug() << "connection timeout...";
+        result = NULL;
+        return false;
+    }
+    result = sock;
+    return true;
+}
+
+void QtCesterConnection::_freeSocket(QTcpSocket*& sock) const
+{
+    if (!sock)
+        return;
+    if (sock->state() == QAbstractSocket::ConnectedState) {
+        sock->disconnectFromHost();
+        // seems like no need to wait
+        //sock->waitForDisconnected();
+    }
+    delete sock;
+    sock = NULL;
+#ifdef Q_OS_WIN
+    Sleep(100);
+#endif
+}
+
+bool QtCesterConnection::_initCommand(QTcpSocket*& sock, const char* command) const
+{
+    QTcpSocket* socket = NULL;
+    if (!_createSocket(socket)) {
+        END_ERROR(socket, "Could not connect to server");
+    }
+    
+    if (!_sendData(socket, command, strlen(command)) || 
+        !_checkResult(socket)) {
+        END_ERROR(socket, "Cound not send command");
+    }
+    sock = socket;
+    return true;
+}
+
+bool QtCesterConnection::_sendData(QTcpSocket*& sock, const char* data, int dataSize) const
+{
+    int amount = sock->write(data, dataSize);
+    if (amount != dataSize) {
+        fprintf(stderr, "*******COULD NOT SEND ENOUGH DATA*************\n");
+    }
+    return sock->waitForBytesWritten();
+}
+
+bool QtCesterConnection::_receiveData(QTcpSocket*& sock, QByteArray& data) const
+{
+    if (!sock->waitForReadyRead()) {
+        qDebug() << "did not receive any data";
+        return false;
+    }
+    data = sock->readAll();
+    return true;
+}
+
+bool QtCesterConnection::_checkResult(QTcpSocket*& sock) const
+{
+    QByteArray response;
+    if (!_receiveData(sock, response) || response != COMMAND_SUCCESS)
+        return false;
+    return true;
+}
+