Ggep.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 "Ggep.h"
#include "Ggeps/UnknownGgep.h"
#include "Ggeps/DailyUptime.h"
#include "Ggeps/Ultrapeer.h"
#include "Ggeps/VendorCode.h"
#include "Ggeps/PackedHostCaches.h"
#include "Ggeps/SupportsCachedPongs.h"
#include "Ggeps/UdpHostCache.h"
#include "Ggeps/IpPort.h"
#include "Utils/Encodings/Cobs.h"
#include "Utils/Encodings/Deflate.h"

using namespace Gnutella::Packets::Extensions;

enum Constants
{
    MaximalGgepDataLength = 262143
};

Ggep::Ggep (const GgepId &id, int flags, int dataSize)
{
    d = new Data;

    d->ref.init (1);
    d->isValid = true;
    d->id = id;

    if (flags & LastExtension)  d->flags |= LastExtension;
    if (flags & Encoding)       d->flags |= Encoding;
    if (flags & Compression)    d->flags |= Compression;
    if (flags & Reserved)       d->flags |= Reserved;

    p.dataLength = dataSize;
}

Ggep::~Ggep()
{
    if (!d->ref.deref())
        delete d;
}

Ggep & Ggep::operator= (const Ggep &other)
{
    Data *x = other.d;
    x->ref.ref();
    x = qAtomicSetPtr(&d, x);
    if (!x->ref.deref())
        delete x;

    p = other.p;
    return *this;
}

void Ggep::invalidateData()
{
    if (d->ref != 1) {
        Data *x = new Data;
        x->ref.init (1);

        x->isValid              = d->isValid;
        x->flags                = d->flags;
        x->id                   = d->id;

        x = qAtomicSetPtr (&d, x);
        if (!x->ref.deref())
            delete x;
    };
}

Ggep * Ggep::fromId (const GgepId &id, int flags, int dataSize)
{
    if (id == Ggeps::Ultrapeer::Id)
        return new Ggeps::Ultrapeer (id, flags, dataSize);

    if (id == Ggeps::VendorCode::Id)
        return new Ggeps::VendorCode (id, flags, dataSize);

    if (id == Ggeps::DailyUptime::Id)
        return new Ggeps::DailyUptime (id, flags, dataSize);

    if (id == Ggeps::PackedHostCaches::Id)
        return new Ggeps::PackedHostCaches (id, flags, dataSize);

    if (id == Ggeps::SupportsCachedPongs::Id)
        return new Ggeps::SupportsCachedPongs (id, flags, dataSize);

    if (id == Ggeps::UdpHostCache::Id)
        return new Ggeps::UdpHostCache (id, flags, dataSize);

    if (id == Ggeps::IpPort::Id)
        return new Ggeps::IpPort (id, flags, dataSize);

    return new Ggeps::UnknownGgep (id, flags, dataSize);
}

void Ggep::prepareRead (const QByteArray &rawExtensionData)
{
    invalidateData();
    if (isFlagSet (Compression) || isFlagSet (Encoding))
        d->isValid = true;
    else {
        d->isValid = prepareReadData (rawExtensionData);
    }
}

void Ggep::read (QDataStream &in)
{
    invalidateData(); // \todo prepareRead must have been called before that, but how to assert it?

    uchar temp;
    in >> temp; // Flags
    for (int i = id().size(); i > 0 ; i--)
        in >> temp; // ID

    do {
        in >> temp; // dataSize;
    } while ((temp & 0x40) != 0x40);

    QByteArray decodedData;

    if (isFlagSet (Encoding)) { // Decode data (COBS).
        QByteArray rawData (p.dataLength, 0);
        in.readRawData (rawData.data(), p.dataLength);

        decodedData = Utils::Encodings::Cobs::decode (rawData);
    }
    if (isFlagSet (Compression)) { // Decompress data (inflate).
        QByteArray rawData;
        if (decodedData.length() > 0) {
            rawData = decodedData;
        } else {
            rawData.reserve (p.dataLength);
            in.readRawData (rawData.data(), p.dataLength);
        }
        decodedData = Utils::Encodings::Deflate::unCompress (rawData);
    }

    if (decodedData.size() > 0) {
        QDataStream decodedInStream (decodedData);
        p.dataLength = decodedData.length();
        // Now perform the delayed prepare (see prepareRead() for details).
        d->isValid = prepareReadData (decodedData);
        // Try to read data only if structure is valid.
        if (d->isValid)
            readData (decodedInStream);
    } else {
        // Try to read data only if structure is valid.
        if (d->isValid)
            readData (in);
        else {
            // Even if structure is invalid, make sure the stream pointer is
            // advanced correctly.
            QByteArray rawData (p.dataLength, 0);
            in.readRawData (rawData.data(), p.dataLength);
        }
    }
}

int Ggep::prepareWrite() const
{
    // \todo It may happen that two objects sharing the same data try to
    // change the mutable members, which are actually of importance in between
    // the calls of prepareWrite and write().
    p.dataLength = prepareWriteData();

    if (isFlagSet (Compression)) {
        QByteArray rawData (p.dataLength, 0);
        QDataStream unencodedOutStream (rawData);
        writeData (unencodedOutStream);
        p.encodedData = Utils::Encodings::Deflate::compress (rawData);
    }
    if (isFlagSet (Encoding)) {
        QByteArray rawData;
        if (p.encodedData.length() > 0) {
            rawData = p.encodedData;
        } else {
            rawData.resize (p.dataLength);
            QDataStream unencodedOutStream (rawData);
            writeData (unencodedOutStream);
        }
        p.encodedData = Utils::Encodings::Cobs::encode (rawData);
    }
    int encodedDataLength = 0;
    if (p.encodedData.length() > 0) {
        encodedDataLength = p.encodedData.length();
    } else {
        encodedDataLength = p.dataLength;
    }

    // Validate the condition for the size of the extension data
    Q_ASSERT (encodedDataLength >= 0 && encodedDataLength <= MaximalGgepDataLength);

    int totalLength = 1 + d->id.length() + encodedDataLength;

    // We need to calculate the length of the data length field in the header.
    do {
        totalLength++;
        encodedDataLength >>= 6;
    } while (encodedDataLength > 0);

    return totalLength;
}

void Ggep::write (QDataStream &out) const
{
    out << static_cast <uchar> (static_cast <int> (d->flags) | id().size());

    for (int i = 0; i < id().size(); i++)
        out << static_cast <uchar> (d->id[i]);

    int length = p.dataLength;
    if (isFlagSet (Compression) || isFlagSet (Encoding)) {
        length = p.encodedData.length();
    }
    do {
        uchar byte = length & 0x3F;
        length >>= 6;
        byte |= (length > 0) ? 0x80 : 0x40;
        out << byte;
    } while (length > 0);

    if (isFlagSet (Compression) || isFlagSet (Encoding)) {
        out.writeRawData (p.encodedData.data(), p.encodedData.length());
        p.encodedData = QByteArray();   // Free allocated memory.
    } else {
        writeData (out);
    }
}


/*
int Ggep::prepareWrite() const
{
    // If the same extension was copied into more packets, none of which
    // changed, than there is no need to build the raw data many times.
    // We store rawData in the data shared wmong the extensions.
    if (!d->rebuildData)
        return d->rawData.length();

    dataLength = prepareWriteData();
    QByteArray rawData (dataLength, 0);
    {   // Let the stream get quickly out of scope;
        QDataStream unencodedOutStream (rawData);
        writeData (unencodedOutStream);
    }

    if (isFlagSet (Compression))
        rawData = Utils::Encodings::Deflate::compress (rawData);
    if (isFlagSet (Encoding))
        rawData = Utils::Encodings::Cobs::encode (rawData);

    dataLength = rawData.length(); // The length after COBS and "deflate"
    // Validate the condition for the size of the extension data
    Q_ASSERT (dataLength > 0 && dataLength <= MaximalGgepDataLength);

    int totalLength = 1 + id_.length() + dataLength;

    // We need to calculate the length of the data length field in the header.
    for (; dataLength > 0; dataLength >>= 6)
        totalLength++;

    // Now write the extension data in the private member.
    d->rawData.resize (totalLength);
    QDataStream out (d->rawData);

    out << static_cast <uchar> ((int) flags_);

    for (int i = 0; i < id().size(); i++)
        out << static_cast <uchar> (id_[i]);

    do {
        uchar byte = length & 0x3F;
        length >>= 6;
        byte |= (length > 0) ? 0x80 : 0x40;
        out << byte;
    } while (length > 0);

    out.writeRawData (rawData.data(), rawData.length());
    Q_ASSERT (d->rawData.length() == totalLength);

    return d->rawData.length();
}

void Ggep::write (QDataStream &out) const
{
    out.writeRawData (d->rawData.data(), d->rawData.length());
    // Eventually free the rawData buffer.
}
*/

Copyright © 2006 Peter Dimov.
Powered by Doxygen.