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.
writeData
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/Unknown.h"
#include "Imports.cpp"


namespace Protocols {
namespace Gnutella {
namespace Packets {
namespace Extensions {

    enum Constants
    {
        MaximalGgepDataLength = 262143
    };

} // namespace Extensions
} // namespace Packets
} // namespace Gnutella
} // namespace Protocols

Ggep::Ggep (int flags_)
 :  flags (0)
{
    if (flags_ & Encoding)      flags |= Encoding;
    if (flags_ & Compression)   flags |= Compression;
    if (flags_ & Reserved)      flags |= Reserved;
}

Ggep::~Ggep()
{
}

Ggep * Ggep::fromId (const GgepId &id, int flags, const QByteArray &rawData)
{
    Ggep* ggep = 0;
    // \todo refactor the Ggeps

    if (ggep != 0 && ggep->parse (rawData))
        return ggep;
    else {
        delete ggep;
        ggep = new Ggeps::Unknown (id, QByteArray(), flags);
        ggep->parse (rawData);
        return ggep;
    }
}

bool Ggep::parse (const QByteArray &rawData)
{
    QByteArray decodedData = rawData; // The raw data could be decoded already.

    if (isFlagSet (Encoding))  // Decode data (COBS).
        decodedData = Utils::Encodings::Cobs::decode (decodedData);
    if (isFlagSet (Compression)) // Decompress data (inflate).
        decodedData = Utils::Encodings::Deflate::unCompress (decodedData);

    BinaryReader reader (decodedData);
    readData (reader);
    return reader.hasReadAll() && !reader.hasReadPastEnd();
}

QByteArray Ggep::rawData() const
{
    BinaryWriter writer;
    writeData (writer); // the Ggeps write the data.
    /*  We must always generate correctly formated messages! The implementaion
        of writeData() might call reserve() and the following will assert if
        less or more than the reserved number of bytes has been written . */
    Q_ASSERT (writer.hasWrittenAll() && !writer.hasWrittenPastEnd());

    QByteArray rawData (writer.buffer());
    if (isFlagSet (Compression)) // Compress data if requested.
        rawData = Utils::Encodings::Deflate::compress (rawData);
    if (isFlagSet (Encoding))  // Encode data if requirested.
        rawData = Utils::Encodings::Cobs::encode (rawData);
    // The raw data must be no longer then the maximal allowed size:
    Q_ASSERT (rawData.length() >= 0
              && rawData.length() <= MaximalGgepDataLength);
    return rawData;
}

bool Ggep::operator==( const Ggep &ggep ) const
{
    bool result = true;
    result = id() == ggep.id() && \
        isFlagSet (Encoding)    ==  ggep.isFlagSet (Encoding) && \
        isFlagSet (Compression) ==  ggep.isFlagSet (Compression) && \
        isFlagSet (Reserved)    ==  ggep.isFlagSet (Reserved) && \
        rawData()   ==  ggep.rawData();
    return result;
}

bool Ggep::operator!=( const Ggep &ggep ) const
{
    return !operator==(ggep);
}

Copyright © 2006 Peter Dimov.
Powered by Doxygen.