QueryHits.cpp

Go to the documentation of this file.

/*

Copyright (C) 2005-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 "QueryHits.h"

using namespace Gnutella::Packets;

bool findCString (const QByteArray &rawPayload, int startPos, int* len);

enum QueryHitsDataFlags
{
    GgepFlag            = 0x20,
    UploadSpeedFlag     = 0x10,
    HaveUploadedFlag    = 0x08,
    BusyFlag            = 0x04,
    PushFlag            = 0x01
};

QueryHits::QueryHits (const QByteArray &rawHeader, const QByteArray &rawPayload)
    : Packet (rawHeader, rawPayload)
{
    parse();
}

QueryHits::QueryHits () : Packet (QueryHitsDescriptor)
{
    p.numberOfHits  = 0;
    p.port          = 0;
    p.ipAddress     = QHostAddress ();
    p.speed         = 0;
    p.serventId     = QUuid();
}

QueryHits::~QueryHits()
{
}

/* \todo Refac. Note -- I would like to use size_t instead of int */
/* it seems more natural */
bool findCString (const QByteArray &rawPayload, int startPos, int* len)
{
    int endPos = rawPayload.indexOf ('\0', startPos);
    if (endPos == -1) /* No null terminator found? */
        return false;
    *len = endPos - startPos;
    return true;
}

bool QueryHits::prepareReadPayload (const QByteArray &rawPayload)
{
    int payloadLength = rawPayload.length();
    if (payloadLength < 11) /* \todo What is 11 .. use a suitable const */
        return false;

    int currentPos = 11; // \todo literal constant? use a named one
    int numberOfHits = static_cast <uchar> (rawPayload.at(0));
    for (int i = 0; i < numberOfHits; i++) {
        p.resultSet.append (Result());

        Result& result = p.resultSet [i];

        currentPos += 8;

        int temp = 0;
        if (!findCString (rawPayload, currentPos, &temp))
                return false;
        result.fileNameSize = temp;
        currentPos += result.fileNameSize + 1; /* skip past null */

        int dataLen = 0;
        if (!findCString (rawPayload, currentPos, &dataLen))
            return false;
        QByteArray rawResultData = QByteArray::fromRawData(
            rawPayload.data() + currentPos, dataLen);
        result.resultData.prepareRead (rawResultData);
        currentPos += dataLen + 1; /* skip past null */
    }
    payloadLength -= 16; // The serventId at the very end of the payload.
    if (currentPos > payloadLength)
        return false;

    int queryHitsDataSize = payloadLength - currentPos;
    QByteArray rawQueryHitsData = QByteArray::fromRawData (rawPayload.data() + currentPos, queryHitsDataSize);
    return prepareReadQueryHitsData (rawQueryHitsData);
}

void QueryHits::readPayload (QDataStream &stream)
{
    QByteArray fileName;
    uchar temp;

    stream >> p.numberOfHits;
    stream >> p.port;
    Gnutella::Packets::operator>> (stream, p.ipAddress);
    stream >> p.speed;
    if (p.speed & (1<<15)) p.speed = 0;             // here eventually read the fields

    for (uchar i = 0; i < p.numberOfHits; i++) {
        Result &result = p.resultSet[i];
        stream >> result.fileIndex;
        stream >> result.fileSize;

        fileName.resize (result.fileNameSize);
        stream.readRawData (fileName.data(), result.fileNameSize);
        result.fullFileName = QString::fromLatin1 (fileName);
        fileName = QByteArray();

        stream >> temp; // '\0'
        result.resultData.read (stream);
        stream >> temp; // '\0'
    }
    readQueryHitsData (stream);
    stream >> p.serventId;
}

int QueryHits::prepareWritePayload() const
{
    int payloadLength = 11;

    ResultSet::const_iterator it = p.resultSet.begin();
    for (uchar i = 0; i < p.numberOfHits && it != p.resultSet.end(); i++, it++) {
        const Result &result = *it;

        payloadLength += 8;
        payloadLength += result.fullFileName.length();
        payloadLength ++; // '\0'
        payloadLength += result.resultData.prepareWrite();
        payloadLength ++; // '\0'
    }
    payloadLength += prepareWriteQueryHitsData ();
    payloadLength += 16;

    return payloadLength;
}

void QueryHits::writePayload (QDataStream &stream) const
{
    stream << p.numberOfHits;
    stream << p.port;
    Gnutella::Packets::operator<< (stream, p.ipAddress);
    stream << p.speed;

    ResultSet::const_iterator it = p.resultSet.begin();
    for (uchar i = 0; i < p.numberOfHits && it != p.resultSet.end(); i++, it++) {
        const Result &result = *it;
        stream << result.fileIndex;
        stream << result.fileSize;
        QByteArray fileName = result.fullFileName.toLatin1();
        stream.writeRawData (fileName.data(), fileName.length());
        stream << uchar (0);
        result.resultData.write (stream);
        stream << uchar (0);
    }
    writeQueryHitsData (stream);
    stream << p.serventId;
}

bool QueryHits::prepareReadQueryHitsData (const QByteArray &rawQueryHitsData)
{
    int rawDataLength = rawQueryHitsData.length();
    // \todo That's just to read raw data until the implementation is tested.
    p.queryHitsData.xmlLength = rawDataLength;
    return true;
    int currentPos = 4;

    if (currentPos + 1 > rawDataLength)
        return false;

    int publicDataLength = rawQueryHitsData.at (currentPos++);
    if (currentPos + publicDataLength > rawDataLength)
        return false;

    p.queryHitsData.openAreaFlags1 = rawQueryHitsData.at (currentPos++);
    p.queryHitsData.openAreaFlags2 = rawQueryHitsData.at (currentPos++);

    if (publicDataLength >= 4) {
        p.queryHitsData.xmlLength = static_cast <uchar> (rawQueryHitsData.at (currentPos++));
        p.queryHitsData.xmlLength |= static_cast <uchar> (rawQueryHitsData.at (currentPos++)) << 8;
        rawDataLength -= p.queryHitsData.xmlLength; // The XML data is at the very end.

        // Jump right after the public area, where the GGEP block is expected to be.
        currentPos += publicDataLength - 4;
    } else
        p.queryHitsData.xmlLength = 0;

    currentPos++; // Private Vendor Flags.

    if ((p.queryHitsData.openAreaFlags1 & GgepFlag)
        && (p.queryHitsData.openAreaFlags2 & GgepFlag)) {

        if (currentPos + 1 > rawDataLength)
            return false;

        QByteArray ggepData = QByteArray::fromRawData (rawQueryHitsData.data() + currentPos, rawDataLength - currentPos);
        if (!p.queryHitsData.ggepBlock.prepareRead (ggepData))
            return false;
    }
    return true;
}

void QueryHits::readQueryHitsData (QDataStream &stream)
{
    // \todo Still needs to be tested.
    p.queryHitsData.xmlData.resize (p.queryHitsData.xmlLength);
    stream.readRawData (p.queryHitsData.xmlData.data(), p.queryHitsData.xmlLength);
    return;
    stream >> p.queryHitsData.vendorCode;
    stream >> p.queryHitsData.openAreaSize;

    stream >> p.queryHitsData.openAreaFlags1;
    stream >> p.queryHitsData.openAreaFlags2;

    if (p.queryHitsData.xmlLength)
        stream >> p.queryHitsData.xmlLength;

    stream >> p.queryHitsData.privateVendorFlag;

    if ((p.queryHitsData.openAreaFlags1 & GgepFlag)
        && (p.queryHitsData.openAreaFlags2 & GgepFlag)) {

        p.queryHitsData.ggepBlock.read (stream);
    }

    if (p.queryHitsData.xmlLength > 0) {
        p.queryHitsData.xmlData.resize (p.queryHitsData.xmlLength - 1);
        stream.readRawData (p.queryHitsData.xmlData.data(), p.queryHitsData.xmlLength - 1);
        uchar tmp;
        stream >> tmp; // This is the engin zero.
    }
}

int QueryHits::prepareWriteQueryHitsData() const
{
    int totalLength = 0;

    totalLength += VendorCode::VendorCodeLength; // Vendor code.
    totalLength += 1; // Open area size byte.

    p.queryHitsData.openAreaSize = 2;
    if (p.queryHitsData.xmlData.length()) {
        p.queryHitsData.openAreaSize += 2; // XML data length's 2 bytes.
        p.queryHitsData.xmlLength = p.queryHitsData.xmlData.length();
        p.queryHitsData.xmlLength += 1; // Ending zero.
    } else
        p.queryHitsData.xmlLength = 0;

    totalLength += p.queryHitsData.openAreaSize;
    totalLength += 1; // Private vendor flag;

    int ggepLength = p.queryHitsData.ggepBlock.prepareWrite();
    if (ggepLength > 0) {
        p.queryHitsData.openAreaFlags2 |= GgepFlag;
        // \todo When you add a constructor for local hits do not forget to
        // initialize the flags accordingly.
    }

    totalLength += ggepLength;
    totalLength += p.queryHitsData.xmlLength;

    return totalLength;
}

void QueryHits::writeQueryHitsData (QDataStream &stream) const
{
    stream << p.queryHitsData.vendorCode;

    stream << p.queryHitsData.openAreaSize;
    stream << p.queryHitsData.openAreaFlags1;
    stream << p.queryHitsData.openAreaFlags2;

    if (p.queryHitsData.xmlLength)
        stream << p.queryHitsData.xmlLength;

    stream << p.queryHitsData.privateVendorFlag;
    stream << p.queryHitsData.ggepBlock;

    if (p.queryHitsData.xmlLength) {
        stream.writeRawData (p.queryHitsData.xmlData.data(), p.queryHitsData.xmlData.length());
        stream << uchar (0);
    }
}

QueryHits::QueryHitsData::QueryHitsData()
: vendorCode ("LIME")
{
    openAreaSize        = 2; // Just the two flags
    openAreaFlags1      = 0x3C; // 00111100 => use GGEP, use Avg Upload Speed, use Have uploaded, use Busy, no Push
    openAreaFlags2      = 0x19; // 00011001 => no GGEP, yes Advg Upload Speed, yes have uploaded, no Busy, use Push
    xmlLength           = 0;
    privateVendorFlag   = 0;
}

const QueryHits::Result & QueryHits::result (int &index) const
{
//  qDebug() << index << " " << p.resultSet.size() << numberOfHits();
    if (index < 0 || index >= numberOfHits())
    Q_ASSERT (index >= 0 && index < p.resultSet.size());
    return p.resultSet.at (index);
}

QString QueryHits::Result::fileExtension() const
{
    QString extension = fullFileName;
    int startIndex = extension.length() - 9;
    startIndex = (startIndex > 0) ? startIndex : 0;
    int index = extension.indexOf ('.', startIndex);
    if (index > 0)
        return extension.remove (0, index+1);
    return QString();
}

QString QueryHits::Result::fileName() const
{
    QString name = fullFileName;
    int startIndex = name.length() - 9;
    startIndex = (startIndex > 0) ? startIndex : 0;
    int index = name.indexOf ('.', startIndex);
    return name.remove (index, name.length());
}

quint32 QueryHits::Result::sizeOfFile() const
{
    return fileSize;
}

void QueryHits::setPort (quint16 port)
{
    p.port = port;
    invalidatePayload();
}

void QueryHits::setIpAddress (const QHostAddress &ipAddress)
{
    p.ipAddress = ipAddress;
    invalidatePayload();
}

void QueryHits::setSpeed (quint32 speed)
{
    p.speed = speed;
    invalidatePayload();
}

void QueryHits::setServentId (const QUuid &serventId)
{
    p.serventId = serventId;
    invalidatePayload();
}

//void QueryHits::setQueryHitsData (QByteArray &data)
//{
//  p.queryHitsData.data = data;
//  invalidatePayload();
//}

void QueryHits::appendResult (Result &result)
{
    p.resultSet.append (result);
    p.numberOfHits = p.resultSet.size();
    invalidatePayload();
}

Copyright © 2006 Peter Dimov.
Powered by Doxygen.