TrackerResponseParser.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 "PeerInfo.h"
#include "TrackerResponseParser.h"
#include "TrackerResponse.h"
#include "Imports.cpp"
#include <limits>


bool TrackerResponseParser::parseAndLoadTrackerResponse (
                                    const QByteArray &rawTrackerResponseData,
                                    TrackerResponse &trackerResponse)
{
    TrackerResponse parsedResponse;

    bool loadedOk = loadAllResponseData (rawTrackerResponseData, parsedResponse);
    if (!loadedOk)
        return false;

    trackerResponse = parsedResponse;
    return true;
}



bool TrackerResponseParser::loadAllResponseData (const QByteArray &rawData,
                                                 TrackerResponse &response)
{
    // Decode raw data into a BDictionary object (pointer)
    BDecoder bDecoder (rawData);
    auto_ptr <BItem> item = bDecoder.readNext();
    if (!bDecoder.hasReadAllCorrectly())
        return false;

    const BDictionary *bData = dynamic_cast <const BDictionary *> (item.get());
    if (!bData || bData->keys().size() == 0)
        return false;

    // Try to get a failure reason - if this field is present, no other data
    // must be present as well. If it's not present, just continue as if it
    // was an optional field.
    bool failureReasonLoadedOk = loadFailureReason (bData, response);
    if (failureReasonLoadedOk)
        return bData->keys().size() == 1;

    // Parse and load mandatory fields
    bool intervalLoaded = loadInterval (bData, response);
    if (!intervalLoaded)
        return false;

    bool peersLoaded = loadPeers (bData, response);
    if (!peersLoaded)
        return false;

    // Parse and load optional fields - I'm not testing the return value
    loadWarningMessage (bData, response);
    loadMinInterval (bData, response);
    loadComplete (bData, response);
    loadIncomplete (bData, response);
    loadTrackerId (bData, response);

    return true;
}


bool TrackerResponseParser::loadFailureReason (const BDictionary *bData,
                                               TrackerResponse &response)
{
    Q_ASSERT (bData != 0);

    const BString *bFailureReason = dynamic_cast <const BString *>
        (bData->item (FailureReasonKeyName));
    if (!bFailureReason)
        return false;

    response.d->failureReason = QString::fromUtf8 (bFailureReason->value());
    return true;
}

bool TrackerResponseParser::loadWarningMessage (const BDictionary *bData,
                                                TrackerResponse &response)
{
    Q_ASSERT (bData != 0);

    const BString *bWarningMessage = dynamic_cast <const BString *>
        (bData->item (WarningMessageKeyName));
    if (!bWarningMessage)
        return false;

    response.d->warningMessage = QString::fromUtf8 (bWarningMessage->value());
    return true;
}

bool TrackerResponseParser::loadInterval (const BDictionary *bData,
                                          TrackerResponse &response)
{
    Q_ASSERT (bData != 0);

    const BInt *bInterval = dynamic_cast <const BInt *>
        (bData->item (IntervalKeyName));
    if (!bInterval || !isValidInterval (bInterval->value()))
        return false;

    // Now the 'interval' value is valid so I can do the cast safely
    response.d->interval = static_cast <uint> (bInterval->value());
    return true;
}

bool TrackerResponseParser::loadMinInterval (const BDictionary *bData,
                                             TrackerResponse &response)
{
    Q_ASSERT (bData != 0);

    const BInt *bMinInterval = dynamic_cast <const BInt *>
        (bData->item (MinIntervalKeyName));
    if (!bMinInterval || !isValidInterval (bMinInterval->value()))
        return false;

    // Now the 'min interval' value is valid so I can do the cast safely
    response.d->minInterval = static_cast <uint> (bMinInterval->value());
    return true;
}

bool TrackerResponseParser::loadTrackerId (const BDictionary *bData,
                                           TrackerResponse &response)
{
    Q_ASSERT (bData != 0);

    const BString *bTrackerId = dynamic_cast <const BString *>
        (bData->item (TrackerIdKeyName));
    if (!bTrackerId)
        return false;

    response.d->trackerId = bTrackerId->value();
    return true;
}

bool TrackerResponseParser::loadComplete (const BDictionary *bData,
                                          TrackerResponse &response)
{
    Q_ASSERT (bData != 0);

    const BInt *bComplete = dynamic_cast <const BInt *>
        (bData->item (CompleteKeyName));
    if (!bComplete || !isValidNumberOfPeers (bComplete->value()))
        return false;

    // Now the 'complete' value is valid so I can do the cast safely
    response.d->complete = static_cast <uint> (bComplete->value());
    return true;
}

bool TrackerResponseParser::loadIncomplete (const BDictionary *bData,
                                            TrackerResponse &response)
{
    Q_ASSERT (bData != 0);

    const BInt *bIncomplete = dynamic_cast <const BInt *>
        (bData->item (IncompleteKeyName));
    if (!bIncomplete || !isValidNumberOfPeers (bIncomplete->value()))
        return false;

    // Now the 'incomplete' value is valid so I can do the cast safely
    response.d->incomplete = static_cast <uint> (bIncomplete->value());
    return true;
}

bool TrackerResponseParser::loadPeers (const BDictionary *bData,
                                       TrackerResponse &response)
{
    Q_ASSERT (bData != 0);

    TrackerResponse::PeerInfoList peerInfoList;
    bool peersLoaded = false;
    const BItem *bPeers = bData->item (PeersKeyName);
    if (dynamic_cast <const BString *> (bPeers) != 0) {
        // Binary model
        peersLoaded = loadPeersBinaryModel (
            static_cast <const BString *> (bPeers), peerInfoList);
    } else if (dynamic_cast <const BList *> (bPeers) != 0) {
        // Dictionary model
        peersLoaded = loadPeersDictionaryModel (
            static_cast <const BList *> (bPeers), peerInfoList);
    } else {
        return false;
    }

    if (!peersLoaded)
        return false;
    response.d->peers = peerInfoList;
    return true;
}

bool TrackerResponseParser::loadPeersBinaryModel (const BString *bPeers,
                                    TrackerResponse::PeerInfoList &peerInfoList)
{
    Q_ASSERT (bPeers != 0);

    QByteArray peers (bPeers->value());
    if ((peers.size() % OnePeerStringSizeBinaryModel) != 0)
        return false;

    for (int peerIndex = 0; peerIndex < peers.size();
         peerIndex += OnePeerStringSizeBinaryModel) {
        peerInfoList.push_back (parseRawPeerInfo (
            peers.mid (peerIndex, OnePeerStringSizeBinaryModel)));
    }

    return true;
}

bool TrackerResponseParser::loadPeersDictionaryModel (const BList *bPeers,
                                    TrackerResponse::PeerInfoList &peerInfoList)
{
    Q_ASSERT (bPeers != 0);

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

        PeerInfo peerInfo;
        bool peerInfoLoadedOk = loadPeerInfo (bPeerInfo, peerInfo);
        if (peerInfoLoadedOk)
            peerInfoList.push_back (peerInfo);
    }

    return true;
}

PeerInfo TrackerResponseParser::parseRawPeerInfo (const QByteArray &rawPeerInfo)
{
    Q_ASSERT (rawPeerInfo.size() == OnePeerStringSizeBinaryModel);

    BinaryReader reader (rawPeerInfo, BinaryReader::BigEndian);
    // Read IP address
    QByteArray ipAddress;
    ipAddress += QByteArray::number (static_cast <uint> (reader.readByte()));
    ipAddress += '.';
    ipAddress += QByteArray::number (static_cast <uint> (reader.readByte()));
    ipAddress += '.';
    ipAddress += QByteArray::number (static_cast <uint> (reader.readByte()));
    ipAddress += '.';
    ipAddress += QByteArray::number (static_cast <uint> (reader.readByte()));
    // Read port
    quint16 port = reader.readUInt16();

    return PeerInfo (ipAddress, port, PeerInfo::PeerId());
}

bool TrackerResponseParser::loadPeerInfo (const BDictionary *bPeerInfo,
                                          PeerInfo &peerInfo)
{
    Q_ASSERT (bPeerInfo != 0);

    PeerInfo::PeerId peerId;
    bool peerIdLoadedOk = loadPeerInfoPeerId (bPeerInfo, peerId);
    if (!peerIdLoadedOk)
        return false;

    QByteArray hostAddress;
    bool hostAddressLoadedOk = loadPeerInfoHostAddress (bPeerInfo, hostAddress);
    if (!hostAddressLoadedOk)
        return false;

    quint16 port;
    bool portLoadedOk = loadPeerInfoPort (bPeerInfo, port);
    if (!portLoadedOk)
        return false;

    peerInfo = PeerInfo (hostAddress, port, peerId);
    return true;
}

bool TrackerResponseParser::loadPeerInfoPeerId (const BDictionary *bPeerInfo,
                                                PeerInfo::PeerId &peerId)
{
    Q_ASSERT (bPeerInfo != 0);

    const BString *bPeerId = dynamic_cast <const BString *>
        (bPeerInfo->item (PeersPeerIdKeyName));
    if (!bPeerId)
        return false;

    peerId = isValidPeerId (bPeerId->value()) ?
        PeerInfo::PeerId (bPeerId->value()) : PeerInfo::PeerId();
    return true;
}

bool TrackerResponseParser::loadPeerInfoHostAddress (const BDictionary *bPeerInfo,
                                                     QByteArray &hostAddress)
{
    Q_ASSERT (bPeerInfo != 0);

    const BString *bIpAddress = dynamic_cast <const BString *>
        (bPeerInfo->item (PeersIpKeyName));
    if (!bIpAddress)
        return false;

    hostAddress = bIpAddress->value();
    return true;
}

bool TrackerResponseParser::loadPeerInfoPort (const BDictionary *bPeerInfo,
                                              quint16 &port)
{
    Q_ASSERT (bPeerInfo != 0);

    const BInt *bPort = dynamic_cast <const BInt *>
        (bPeerInfo->item (PeersPortKeyName));
    if (!bPort)
        return false;

    port = isValidPort (bPort->value()) ?
        static_cast <quint16> (bPort->value()) : 0;
    return true;
}


bool TrackerResponseParser::isValidInterval (qint64 interval)
{
    return interval >= 0 && interval <= std::numeric_limits<uint>::max();
}


bool TrackerResponseParser::isValidNumberOfPeers (qint64 numOfPeers)
{
    return numOfPeers >= 0 && numOfPeers <= std::numeric_limits<uint>::max();
}


bool TrackerResponseParser::isValidPeerId (const QByteArray &peerId)
{
    return static_cast <uint> (peerId.size()) == PeerInfo::PeerId::size();
}


bool TrackerResponseParser::isValidPort (qint64 port)
{
    return port >= 0 && port <= std::numeric_limits<quint16>::max();
}

// Static constants definitions
const char *TrackerResponseParser::FailureReasonKeyName  = "failure reason";
const char *TrackerResponseParser::WarningMessageKeyName = "warning message";
const char *TrackerResponseParser::IntervalKeyName       = "interval";
const char *TrackerResponseParser::MinIntervalKeyName    = "min interval";
const char *TrackerResponseParser::TrackerIdKeyName      = "tracker id";
const char *TrackerResponseParser::CompleteKeyName       = "complete";
const char *TrackerResponseParser::IncompleteKeyName     = "incomplete";
const char *TrackerResponseParser::PeersKeyName          = "peers";
const char *TrackerResponseParser::PeersPeerIdKeyName    = "peer id";
const char *TrackerResponseParser::PeersIpKeyName        = "ip";
const char *TrackerResponseParser::PeersPortKeyName      = "port";
const int   TrackerResponseParser::OnePeerStringSizeBinaryModel = 6;

Copyright © 2006 Peter Dimov.
Powered by Doxygen.