TorrentParser.cpp

Go to the documentation of this file.

/*

Copyright (C) 2006-2007 by Peter Dimov.

This file is part of Calitko (http://www.calitko.org).

Calitko is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.

Calitko is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with Calitko; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

*/

#include "Qt.h"
#include "Torrent.h"
#include "TorrentParser.h"
#include "Imports.cpp"


bool TorrentParser::parseAndLoadTorrent (const QByteArray &rawTorrentData,
                                         Torrent &torrent)
{
    Torrent parsedTorrent;

    bool loadedOk = loadAllTorrentData (rawTorrentData, parsedTorrent);
    if (!loadedOk)
        return false;

    torrent = parsedTorrent;
    return true;
}


bool TorrentParser::loadAllTorrentData(const QByteArray &rawData,
                                       Torrent &torrent)
{
    if (rawData.isEmpty())
        return false;

    BDecoder bDecoder (rawData);
    auto_ptr <BItem> item = bDecoder.readNext();
    if (!bDecoder.hasReadAllCorrectly())
        return false;

    const BDictionary *bBasicData = dynamic_cast <const BDictionary *>
        (item.get());
    if (!bBasicData)
        return false;

    bool basicDataLoaded = loadTorrentBasicData (bBasicData, torrent);
    if (!basicDataLoaded)
        return false;

    const BDictionary *bInfo = dynamic_cast <const BDictionary *>
        (bBasicData->item (InfoKeyName));
    if (!bInfo)
        return false;

    bool filesInfoLoaded = loadTorrentFilesInfo (bInfo, torrent);
    if (!filesInfoLoaded)
        return false;

    return true;
}


bool TorrentParser::loadTorrentBasicData (const BDictionary *bBasicData,
                                          Torrent &torrent)
{
    Q_ASSERT (bBasicData);

    bool announceLoaded = getAndLoadAnnounce (bBasicData, torrent);
    if (!announceLoaded)
        return false;

    // These pieces of information are only optional so I'm not testing
    // their return values
    getAndLoadAnnounceList (bBasicData, torrent);
    getAndLoadCreationDate (bBasicData, torrent);
    getAndLoadComment (bBasicData, torrent);
    getAndLoadCreatedBy (bBasicData, torrent);

    return true;
}


bool TorrentParser::loadTorrentFilesInfo (const BDictionary *bInfo,
                                          Torrent &torrent)
{
    Q_ASSERT (bInfo);

    bool pieceLengthLoaded = getAndLoadPieceLength (bInfo, torrent);
    if (!pieceLengthLoaded)
        return false;

    bool piecesLoaded = getAndLoadPieces (bInfo, torrent);
    if (!piecesLoaded)
        return false;

    bool singleFileInfoLoaded = getAndLoadSingleModeFileInfo (bInfo, torrent);
    if (!singleFileInfoLoaded) {
        bool multipleFileInfoLoaded = getAndLoadMultipleModeFileInfo
            (bInfo, torrent);
        if (!multipleFileInfoLoaded)
            return false;
    }

    // Only optional so I'm not testing the return value
    getAndLoadPrivate (bInfo, torrent);

    return true;
}


bool TorrentParser::getAndLoadAnnounce (const BDictionary *bBasicData,
                                        Torrent &torrent)
{
    Q_ASSERT (bBasicData);
    const BString *bAnnounceUrl = dynamic_cast <const BString *>
        (bBasicData->item (AnnounceKeyName));
    if (!bAnnounceUrl)
        return false;

    Uri announceUrl = Uri::fromUnencoded (bAnnounceUrl->value());
    if (!isValidAnnounceUrl (announceUrl))
        return false;

    torrent.d->announce = announceUrl;
    return true;
}


bool TorrentParser::getAndLoadAnnounceList (const BDictionary *bBasicData,
                                            Torrent &torrent)
{
    Q_ASSERT (bBasicData);
    const BList *bAnnounceList = dynamic_cast <const BList *>
        (bBasicData->item (AnnounceListKeyName));
    if (!bAnnounceList)
        return false;

    // Announce list has the following scheme:
    // [
    //   [tracker1, tracker2, ...], // Tier 1
    //   [tracker1, tracker2, ...], // Tier 2
    //   ...
    //   [tracker1, tracker2, ...]  // Tier N
    // ]
    Torrent::AnnounceList loadedAnnounceList;

    // For each tier
    // (cannot use foreach because BList doesn't support it)
    for (int i = 0; i < bAnnounceList->size(); ++i) {
        const BList *bTier = dynamic_cast <const BList *>
            (bAnnounceList->item (i));
        if (!bTier)
            return false;

        QList <Uri> tier;
        bool convertedOk = convertBTierToTier (bTier, tier);
        if (convertedOk && !tier.isEmpty())
            loadedAnnounceList.append (tier);
        else
            return false;
    }

    if (loadedAnnounceList.isEmpty())
        return false;

    torrent.d->announceList = loadedAnnounceList;
    return true;
}


bool TorrentParser::getAndLoadCreationDate (const BDictionary *bBasicData,
                                            Torrent &torrent)
{
    Q_ASSERT (bBasicData);
    const BInt *bTimeStamp = dynamic_cast <const BInt *>
        (bBasicData->item (CreationDateKeyName));
    if (!bTimeStamp)
        return false;
    else if (!isValidCreationDate (bTimeStamp->value()))
        return false;

    torrent.d->creationDate.setTime_t (bTimeStamp->value());
    return true;
}


bool TorrentParser::getAndLoadComment (const BDictionary *bBasicData,
                                       Torrent &torrent)
{
    Q_ASSERT (bBasicData);
    const BString *bComment = dynamic_cast <const BString *>
        (bBasicData->item (CommentKeyName));
    if (!bComment)
        return false;

    torrent.d->comment = QString::fromUtf8 (bComment->value());
    return true;
}


bool TorrentParser::getAndLoadCreatedBy (const BDictionary *bBasicData,
                                         Torrent &torrent)
{
    Q_ASSERT (bBasicData);
    const BString *bCreatedBy = dynamic_cast <const BString *>
        (bBasicData->item (CreatedByKeyName));
    if (!bCreatedBy)
        return false;

    torrent.d->createdBy = QString::fromUtf8 (bCreatedBy->value());
    return true;
}


bool TorrentParser::getAndLoadPieceLength (const BDictionary *bInfo,
                                           Torrent &torrent)
{
    Q_ASSERT (bInfo);
    const BInt *bPieceLength = dynamic_cast <const BInt *>
        (bInfo->item (PieceLengthKeyName));
    if (!bPieceLength)
        return false;
    else if (!isValidPieceLength (bPieceLength->value()))
        return false;

    torrent.d->pieceLength = bPieceLength->value();
    return true;
}


bool TorrentParser::getAndLoadPieces (const BDictionary *bInfo,
                                      Torrent &torrent)
{
    Q_ASSERT (bInfo);
    const BString *bPieces = dynamic_cast <const BString *>
        (bInfo->item (PiecesKeyName));
    if (!bPieces)
        return false;

    Torrent::PieceList pieceList;
    bool convertedOk = convertPiecesToPieceList (bPieces->value(), pieceList);
    if (!convertedOk)
        return false;

    torrent.d->pieces = pieceList;
    return true;
}


bool TorrentParser::getAndLoadPrivate (const BDictionary *bInfo,
                                       Torrent &torrent)
{
    Q_ASSERT (bInfo);
    const BInt *bPrivateFlag = dynamic_cast <const BInt *>
        (bInfo->item (PrivateKeyName));
    if (!bPrivateFlag)
        return false;
    else if (!isValidPrivate (bPrivateFlag->value()))
        return false;

    torrent.d->isPrivate = convertPrivateFlagToBool
        (bPrivateFlag->value());
    return true;
}


bool TorrentParser::getAndLoadSingleModeFileInfo (const BDictionary *bInfo,
                                                  Torrent &torrent)
{
    Q_ASSERT (bInfo);
    Torrent::FileInfo fileInfo;
    bool fileLengthLoaded = getAndLoadFileLength (bInfo, fileInfo);
    if (!fileLengthLoaded)
        return false;

    QString fileName;
    bool fileNameLoaded = getAndLoadFileName (bInfo, fileName);
    if (!fileNameLoaded)
        return false;
    else
        fileInfo.filePath = fileName;

    // Only optional so I'm not testing the return value
    getAndLoadFileChecksum (bInfo, fileInfo);

    torrent.d->files.push_back (fileInfo);
    return true;
}


bool TorrentParser::getAndLoadMultipleModeFileInfo (const BDictionary *bInfo,
                                                    Torrent &torrent)
{
    Q_ASSERT (bInfo);
    QString directoryName;
    bool directoryNameLoaded = getAndLoadDirectoryName (bInfo, directoryName);
    if (!directoryNameLoaded)
        return false;

    const BList *bFileInfoList = dynamic_cast <const BList *>
        (bInfo->item (FilesKeyName));
    if (!bFileInfoList)
        return false;

    Torrent::FileInfoList fileInfoList;
    bool fileListLoaded = getAndLoadFileInfoList (bFileInfoList, fileInfoList);
    if (!fileListLoaded)
        return false;

    appendDirectoryName (directoryName, DirectoryDelimiter, fileInfoList);

    torrent.d->files = fileInfoList;
    return true;
}


bool TorrentParser::getAndLoadDirectoryName (const BDictionary *bFileInfo,
                                             QString &directoryName)
{
    Q_ASSERT (bFileInfo);
    // Directory name is get exactly the same way as file name
    return getAndLoadFileName (bFileInfo, directoryName);
}


bool TorrentParser::getAndLoadFileName (const BDictionary *bFileInfo,
                                        QString &fileName)
{
    Q_ASSERT (bFileInfo);
    const BString *bFileName = dynamic_cast <const BString *>
        (bFileInfo->item (FileNameKeyName));
    if (!bFileName)
        return false;

    fileName = QString::fromUtf8 (bFileName->value());
    return true;
}


bool TorrentParser::getAndLoadFilePath (const BDictionary *bFileInfo,
                                        QString &filePath)
{
    Q_ASSERT (bFileInfo);
    const BList *bFilePath = dynamic_cast <const BList *>
        (bFileInfo->item (PathKeyName));
    if (!bFilePath)
        return false;

    bool convertedOk = convertBFilePathToFilePath (bFilePath,
        DirectoryDelimiter, filePath);
    return convertedOk && !filePath.isEmpty();
}


bool TorrentParser::getAndLoadFileLength (const BDictionary *bFileInfo,
                                          Torrent::FileInfo &fileInfo)
{
    Q_ASSERT (bFileInfo);
    const BInt *bFileLength = dynamic_cast <const BInt *>
        (bFileInfo->item (FileLengthKeyName));
    if (!bFileLength)
        return false;
    else if (!isValidFileLength (bFileLength->value()))
        return false;

    fileInfo.fileLength = bFileLength->value();
    return true;
}


bool TorrentParser::getAndLoadFileChecksum (const BDictionary *bFileInfo,
                                            Torrent::FileInfo &fileInfo)
{
    Q_ASSERT (bFileInfo);
    const BString *bFileChecksum = dynamic_cast <const BString *>
        (bFileInfo->item (ChecksumKeyName));
    if (!bFileChecksum)
        return false;
    else if (!isValidFileChecksum (bFileChecksum->value()))
        return false;

    fileInfo.fileChecksum = Torrent::FileInfo::Checksum (bFileChecksum->value());
    return true;
}


bool TorrentParser::getAndLoadFileInfoList (const BList *bFileInfoList,
                                            Torrent::FileInfoList &fileInfoList)
{
    Q_ASSERT (bFileInfoList);
    // For each file info
    // (cannot use foreach because BList doesn't support it)
    for (int i = 0; i < bFileInfoList->size(); ++i) {
        const BDictionary *bFileInfo = dynamic_cast <const BDictionary *>
            (bFileInfoList->item (i));
        if (!bFileInfo)
            return false;

        Torrent::FileInfo fileInfo;
        bool fileInfoLoaded = getAndLoadFileInfo (bFileInfo, fileInfo);
        if (!fileInfoLoaded)
            return false;

        fileInfoList.push_back (fileInfo);
    }

    return !fileInfoList.isEmpty();
}


bool TorrentParser::getAndLoadFileInfo (const BDictionary *bFileInfo,
                                        Torrent::FileInfo &fileInfo)
{
    Q_ASSERT (bFileInfo);
    bool fileLengthLoaded = getAndLoadFileLength (bFileInfo, fileInfo);
    if (!fileLengthLoaded)
        return false;

    QString filePath;
    bool filePathLoaded = getAndLoadFilePath (bFileInfo, filePath);
    if (!filePathLoaded)
        return false;
    else
        fileInfo.filePath = filePath;

    // Only optional so I'm not testing the return value
    getAndLoadFileChecksum (bFileInfo, fileInfo);

    return true;
}


bool TorrentParser::isValidAnnounceUrl (const Uri &announceUrl)
{
    return !announceUrl.scheme().isEmpty() && !announceUrl.authority().isEmpty();
}


bool TorrentParser::isValidCreationDate (int creationDate)
{
    return creationDate >= 0;
}


bool TorrentParser::isValidPieceLength (int pieceLength)
{
    return pieceLength > 0;
}


bool TorrentParser::isValidPieces (const QByteArray &pieces)
{
    return !pieces.isEmpty() &&
        ((pieces.size() % Torrent::Piece::size()) == 0);
}


bool TorrentParser::isValidPrivate (int privateFlag)
{
    return (privateFlag == 0) || (privateFlag == 1);
}


bool TorrentParser::isValidFileLength (qint64 fileLength)
{
    return fileLength > 0;
}


bool TorrentParser::isValidFileChecksum (const QByteArray &fileChecksum)
{
    return static_cast <uint> (fileChecksum.size()) ==
        Torrent::FileInfo::Checksum::size();
}


bool TorrentParser::convertBTierToTier (const BList *bTier, QList <Uri> &tier)
{
    Q_ASSERT (bTier);

    // bTier has the following format:
    // [tracker1, tracker2, ..., trackerN]
    QList <Uri> loadedTier;

    // For each announce (tracker) URL
    // (cannot use foreach because BList doesn't support it)
    for (int i = 0; i < bTier->size(); ++i) {
        const BString *bAnnounceUrl = dynamic_cast <const BString *>
            (bTier->item (i));
        if (!bAnnounceUrl)
            return false;

        Uri announceUrl = Uri::fromUnencoded (bAnnounceUrl->value());
        if (!isValidAnnounceUrl (announceUrl))
            return false;

        loadedTier.append (announceUrl);
    }

    tier = loadedTier;
    return true;
}


bool TorrentParser::convertPiecesToPieceList (const QByteArray &pieces,
                                               Torrent::PieceList &pieceList)
{
    if (!isValidPieces (pieces))
        return false;

    // Pieces is an array consisting of the concatenation of all
    // hash values, one per piece, so I'll have to split them
    Torrent::PieceList convertedPieceList;
    for (int pieceIndex = 0; pieceIndex < pieces.size();
        pieceIndex += Torrent::Piece::size()) {
        convertedPieceList.push_back (
            Torrent::Piece (pieces.mid (pieceIndex, Torrent::Piece::size())));
    }

    pieceList = convertedPieceList;
    return true;
}


bool TorrentParser::convertBFilePathToFilePath (const BList *bFilePath,
                                                const QString &delimiter,
                                                QString &filePath)
{
    Q_ASSERT (bFilePath);

    // bFilePath has the following format:
    // [dir1, dir2, ..., dirN, fileName]
    QString loadedFilePath;

    // For each file path part
    // (cannot use foreach because BList doesn't support it)
    for (int i = 0; i < bFilePath->size(); ++i) {
        const BString *bPathPart = dynamic_cast <const BString *>
            (bFilePath->item (i));
        if (!bPathPart)
            return false;

        loadedFilePath += QString::fromUtf8 (bPathPart->value());
        if ((i + 1) < bFilePath->size())
            loadedFilePath += delimiter;
    }

    filePath = loadedFilePath;
    return true;
}


bool TorrentParser::convertPrivateFlagToBool (int privateFlag)
{
    Q_ASSERT (isValidPrivate (privateFlag));

    return privateFlag == 1;
}


void TorrentParser::appendDirectoryName (const QString &directoryName,
                                         const QString &delimiter,
                                         Torrent::FileInfoList &fileInfoList)
{
    // I can't do it via std::transform() + functor because there is currently
    // no way how to modify Torrent::FileInfo.path out of the TorrentParser
    // because only TorrentParser can access it's private data
    typedef QList <Torrent::FileInfo>::iterator FileInfoListIterator;
    for (FileInfoListIterator iter = fileInfoList.begin();
        iter != fileInfoList.end(); ++iter) {
        iter->filePath = directoryName + delimiter + iter->filePath;
    }
}

// Static constants definitions
const char *TorrentParser::InfoKeyName          = "info";
const char *TorrentParser::AnnounceKeyName      = "announce";
const char *TorrentParser::AnnounceListKeyName  = "announce-list";
const char *TorrentParser::CreationDateKeyName  = "creation date";
const char *TorrentParser::CommentKeyName       = "comments";
const char *TorrentParser::CreatedByKeyName     = "created by";
const char *TorrentParser::PieceLengthKeyName   = "piece length";
const char *TorrentParser::PiecesKeyName        = "pieces";
const char *TorrentParser::PrivateKeyName       = "private";
const char *TorrentParser::FileNameKeyName      = "name";
const char *TorrentParser::FileLengthKeyName    = "length";
const char *TorrentParser::ChecksumKeyName      = "md5sum";
const char *TorrentParser::FilesKeyName         = "files";
const char *TorrentParser::PathKeyName          = "path";
const char *TorrentParser::DirectoryDelimiter   = "/";

Copyright © 2006 Peter Dimov.
Powered by Doxygen.