|  | Home · All Classes · Main Classes · Grouped Classes · Modules · Functions |

# filemanager.cpp Example File
network/torrent/filemanager.cpp

        /****************************************************************************
        **
        ** Copyright (C) 2004-2005 Trolltech AS. All rights reserved.
        **
        ** This file is part of the documentation of the Qt Toolkit.
        **
        ** This file may be used under the terms of the GNU General Public
        ** License version 2.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 GNU
        ** General Public Licensing requirements will be met:
        ** http://www.trolltech.com/products/qt/opensource.html
        **
        ** If you are unsure which license is appropriate for your use, please
        ** review the following information:
        ** http://www.trolltech.com/products/qt/licensing.html or contact the
        ** sales department at sales@trolltech.com.
        **
        ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
        ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
        **
        ****************************************************************************/

        #include "filemanager.h"
        #include "metainfo.h"

        #include <QByteArray>
        #include <QDir>
        #include <QFile>
        #include <QTimer>
        #include <QTimerEvent>

        extern "C" {
        #include "3rdparty/sha1.h"
        }

        FileManager::FileManager(QObject *parent)
            : QThread(parent)
        {
            quit = false;
            totalLength = 0;
            readId = 0;
            startVerification = false;
            wokeUp = false;
            newFile = false;
            numPieces = 0;
            verifiedPieces.fill(false);
        }

        FileManager::~FileManager()
        {
            quit = true;
            cond.wakeOne();
            wait();

            foreach (QFile *file, files) {
                file->close();
                delete file;
            }
        }

        int FileManager::read(int pieceIndex, int offset, int length)
        {
            ReadRequest request;
            request.pieceIndex = pieceIndex;
            request.offset = offset;
            request.length = length;

            QMutexLocker locker(&mutex);
            request.id = readId++;
            readRequests << request;

            if (!wokeUp) {
                wokeUp = true;
                QMetaObject::invokeMethod(this, "wakeUp", Qt::QueuedConnection);
            }

            return request.id;
        }

        void FileManager::write(int pieceIndex, int offset, const QByteArray &data)
        {
            WriteRequest request;
            request.pieceIndex = pieceIndex;
            request.offset = offset;
            request.data = data;

            QMutexLocker locker(&mutex);
            writeRequests << request;

            if (!wokeUp) {
                wokeUp = true;
                QMetaObject::invokeMethod(this, "wakeUp", Qt::QueuedConnection);
            }
        }

        void FileManager::verifyPiece(int pieceIndex)
        {
            QMutexLocker locker(&mutex);
            pendingVerificationRequests << pieceIndex;
            startVerification = true;

            if (!wokeUp) {
                wokeUp = true;
                QMetaObject::invokeMethod(this, "wakeUp", Qt::QueuedConnection);
            }
        }

        int FileManager::pieceLengthAt(int pieceIndex) const
        {
            QMutexLocker locker(&mutex);
            return (sha1s.size() == pieceIndex + 1)
                ? (totalLength % pieceLength) : pieceLength;
        }

        QBitArray FileManager::completedPieces() const
        {
            QMutexLocker locker(&mutex);
            return verifiedPieces;
        }

        void FileManager::setCompletedPieces(const QBitArray &pieces)
        {
            QMutexLocker locker(&mutex);
            verifiedPieces = pieces;
        }

        QString FileManager::errorString() const
        {
            return errString;
        }

        void FileManager::run()
        {
            if (!generateFiles())
                return;

            do {
                {
                    // Go to sleep if there's nothing to do.
                    QMutexLocker locker(&mutex);
                    if (!quit && readRequests.isEmpty() && writeRequests.isEmpty() && !startVerification)
                        cond.wait(&mutex);
                }

                // Read pending read requests
                mutex.lock();
                QList<ReadRequest> newReadRequests = readRequests;
                readRequests.clear();
                mutex.unlock();
                while (!newReadRequests.isEmpty()) {
                    ReadRequest request = newReadRequests.takeFirst();
                    QByteArray block = readBlock(request.pieceIndex, request.offset, request.length);
                    emit dataRead(request.id, request.pieceIndex, request.offset, block);
                }

                // Write pending write requests
                mutex.lock();
                QList<WriteRequest> newWriteRequests = writeRequests;
                writeRequests.clear();
                while (!quit && !newWriteRequests.isEmpty()) {
                    WriteRequest request = newWriteRequests.takeFirst();
                    writeBlock(request.pieceIndex, request.offset, request.data);
                }

                // Process pending verification requests
                if (startVerification) {
                    newPendingVerificationRequests = pendingVerificationRequests;
                    pendingVerificationRequests.clear();
                    verifyFileContents();
                    startVerification = false;
                }
                mutex.unlock();
                newPendingVerificationRequests.clear();

            } while (!quit);

            // Write pending write requests
            mutex.lock();
            QList<WriteRequest> newWriteRequests = writeRequests;
            writeRequests.clear();
            mutex.unlock();
            while (!newWriteRequests.isEmpty()) {
                WriteRequest request = newWriteRequests.takeFirst();
                writeBlock(request.pieceIndex, request.offset, request.data);
            }
        }

        void FileManager::startDataVerification()
        {
            QMutexLocker locker(&mutex);
            startVerification = true;
            cond.wakeOne();
        }

        bool FileManager::generateFiles()
        {
            numPieces = -1;

            // Set up the thread local data
            if (metaInfo.fileForm() == MetaInfo::SingleFileForm) {
                QMutexLocker locker(&mutex);
                MetaInfoSingleFile singleFile = metaInfo.singleFile();

                QString prefix;
                if (!destinationPath.isEmpty()) {
                    prefix = destinationPath;
                    if (!prefix.endsWith("/"))
                        prefix += "/";
                    QDir dir;
                    if (!dir.mkpath(prefix)) {
                        errString = tr("Failed to create directory %1").arg(prefix);
                        emit error();
                        return false;
                    }
                }
                QFile *file = new QFile(prefix + singleFile.name);
                if (!file->open(QFile::ReadWrite)) {
                    errString = tr("Failed to open/create file %1: %2")
                                .arg(file->fileName()).arg(file->errorString());
                    emit error();
                    return false;
                }

                if (file->size() != singleFile.length) {
                    newFile = true;
                    if (!file->resize(singleFile.length)) {
                        errString = tr("Failed to resize file %1: %2")
                                    .arg(file->fileName()).arg(file->errorString());
                        emit error();
                        return false;
                    }
                }
                fileSizes << file->size();
                files << file;
                file->close();

                pieceLength = singleFile.pieceLength;
                totalLength = singleFile.length;
                sha1s = singleFile.sha1Sums;
            } else {
                QMutexLocker locker(&mutex);
                QDir dir;
                QString prefix;

                if (!destinationPath.isEmpty()) {
                    prefix = destinationPath;
                    if (!prefix.endsWith("/"))
                        prefix += "/";
                }
                if (!metaInfo.name().isEmpty()) {
                    prefix += metaInfo.name();
                    if (!prefix.endsWith("/"))
                        prefix += "/";
                }
                if (!dir.mkpath(prefix)) {
                    errString = tr("Failed to create directory %1").arg(prefix);
                    emit error();
                    return false;
                }

                foreach (const MetaInfoMultiFile &entry, metaInfo.multiFiles()) {
                    QString filePath = QFileInfo(prefix + entry.path).path();
                    if (!QFile::exists(filePath)) {
                        if (!dir.mkpath(filePath)) {
                            errString = tr("Failed to create directory %1").arg(filePath);
                            emit error();
                            return false;
                        }
                    }

                    QFile *file = new QFile(prefix + entry.path);
                    if (!file->open(QFile::ReadWrite)) {
                        errString = tr("Failed to open/create file %1: %2")
                                    .arg(file->fileName()).arg(file->errorString());
                        emit error();
                        return false;
                    }

                    if (file->size() != entry.length) {
                        newFile = true;
                        if (!file->resize(entry.length)) {
                            errString = tr("Failed to resize file %1: %2")
                                        .arg(file->fileName()).arg(file->errorString());
                            emit error();
                            return false;
                        }
                    }
                    fileSizes << file->size();
                    files << file;
                    file->close();

                    totalLength += entry.length;
                }

                sha1s = metaInfo.sha1Sums();
                pieceLength = metaInfo.pieceLength();
            }
            numPieces = sha1s.size();
            return true;
        }

        QByteArray FileManager::readBlock(int pieceIndex, int offset, int length)
        {
            QByteArray block;
            qint64 startReadIndex = (quint64(pieceIndex) * pieceLength) + offset;
            qint64 currentIndex = 0;

            for (int i = 0; !quit && i < files.size() && length > 0; ++i) {
                QFile *file = files[i];
                qint64 currentFileSize = fileSizes.at(i);
                if ((currentIndex + currentFileSize) > startReadIndex) {
                    if (!file->isOpen()) {
                        if (!file->open(QFile::ReadWrite)) {
                            errString = tr("Failed to read from file %1: %2")
                                .arg(file->fileName()).arg(file->errorString());
                            emit error();
                            break;
                        }
                    }

                    file->seek(startReadIndex - currentIndex);
                    QByteArray chunk = file->read(qMin<qint64>(length, currentFileSize - file->pos()));
                    file->close();

                    block += chunk;
                    length -= chunk.size();
                    startReadIndex += chunk.size();
                    if (length < 0) {
                        errString = tr("Failed to read from file %1 (read %3 bytes): %2")
                                    .arg(file->fileName()).arg(file->errorString()).arg(length);
                        emit error();
                        break;
                    }
                }
                currentIndex += currentFileSize;
            }
            return block;
        }

        bool FileManager::writeBlock(int pieceIndex, int offset, const QByteArray &data)
        {
            qint64 startWriteIndex = (qint64(pieceIndex) * pieceLength) + offset;
            qint64 currentIndex = 0;
            int bytesToWrite = data.size();
            int written = 0;

            for (int i = 0; !quit && i < files.size(); ++i) {
                QFile *file = files[i];
                qint64 currentFileSize = fileSizes.at(i);

                if ((currentIndex + currentFileSize) > startWriteIndex) {
                    if (!file->isOpen()) {
                        if (!file->open(QFile::ReadWrite)) {
                            errString = tr("Failed to write to file %1: %2")
                                .arg(file->fileName()).arg(file->errorString());
                            emit error();
                            break;
                        }
                    }

                    file->seek(startWriteIndex - currentIndex);
                    qint64 bytesWritten = file->write(data.constData() + written,
                                                      qMin<qint64>(bytesToWrite, currentFileSize - file->pos()));
                    file->close();

                    if (bytesWritten <= 0) {
                        errString = tr("Failed to write to file %1: %2")
                                    .arg(file->fileName()).arg(file->errorString());
                        emit error();
                        return false;
                    }

                    written += bytesWritten;
                    startWriteIndex += bytesWritten;
                    bytesToWrite -= bytesWritten;
                    if (bytesToWrite == 0)
                        break;
                }
                currentIndex += currentFileSize;
            }
            return true;
        }

        void FileManager::verifyFileContents()
        {
            // Verify all pieces the first time
            if (newPendingVerificationRequests.isEmpty()) {
                if (verifiedPieces.count(true) == 0) {
                    verifiedPieces.resize(sha1s.size());

                    int oldPercent = 0;
                    if (!newFile) {
                        int numPieces = sha1s.size();

                        for (int index = 0; index < numPieces; ++index) {
                            verifySinglePiece(index);

                            int percent = ((index + 1) * 100) / numPieces;
                            if (oldPercent != percent) {
                                emit verificationProgress(percent);
                                oldPercent = percent;
                            }
                        }
                    }
                }
                emit verificationDone();
                return;
            }

            // Verify all pending pieces
            foreach (int index, newPendingVerificationRequests)
                emit pieceVerified(index, verifySinglePiece(index));
        }

        bool FileManager::verifySinglePiece(int pieceIndex)
        {
            QByteArray block = readBlock(pieceIndex, 0, pieceLength);

            SHA1Context sha;
            SHA1Reset(&sha);
            SHA1Input(&sha, (const unsigned char *)block.constData(), block.size());
            SHA1Result(&sha);

            QByteArray sha1Sum(20, ' ');
            unsigned char *digest = (unsigned char *)sha.Message_Digest;
            for (int i = 0; i < 5; ++i) {
        #if Q_BYTE_ORDER == Q_BIG_ENDIAN
                sha1Sum[i * 4 + 3] = digest[i * 4 + 3];
                sha1Sum[i * 4 + 2] = digest[i * 4 + 2];
                sha1Sum[i * 4 + 1] = digest[i * 4 + 1];
                sha1Sum[i * 4 + 0] = digest[i * 4 + 0];
        #else
                sha1Sum[i * 4 + 0] = digest[i * 4 + 3];
                sha1Sum[i * 4 + 1] = digest[i * 4 + 2];
                sha1Sum[i * 4 + 2] = digest[i * 4 + 1];
                sha1Sum[i * 4 + 3] = digest[i * 4 + 0];
        #endif
            }

            if (sha1Sum != sha1s.at(pieceIndex))
                return false;
            verifiedPieces.setBit(pieceIndex);
            return true;
        }

        void FileManager::wakeUp()
        {
            QMutexLocker locker(&mutex);
            wokeUp = false;
            cond.wakeOne();
        }