Packet.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 "Packet.h"
#include "Bye.h"
#include "Ping.h"
#include "Pong.h"
#include "Push.h"
#include "Query.h"
#include "QueryHits.h"
#include "QueryRouting.h"
#include "QueryRoutingPatch.h"
#include "QueryRoutingReset.h"
#include "UnknownPacket.h"
#include "VendorMessages/VendorMessage.h"

using namespace Gnutella::Packets;


QDataStream & Gnutella::Packets::operator>> (QDataStream &in, PayloadDescriptor &pd)
{
    uchar tmp;
    in >> tmp;
    pd = static_cast<PayloadDescriptor> (tmp);
    return in;
}


QDataStream & Gnutella::Packets::operator<< (QDataStream &out, const PayloadDescriptor &pd)
{
    return out << static_cast<uchar> (pd);
}


QDataStream & Gnutella::Packets::operator>> (QDataStream &in, QHostAddress &ha)
{
    QDataStream::ByteOrder oldByteOrder = in.byteOrder();
    in.setByteOrder (QDataStream::BigEndian);
    quint32 ipAddress;
    in >> ipAddress;
    ha.setAddress (ipAddress);
    in.setByteOrder (oldByteOrder);
    return in;
}


QDataStream & Gnutella::Packets::operator<< (QDataStream &out, const QHostAddress &ha)
{
    QDataStream::ByteOrder oldByteOrder = out.byteOrder();
    out.setByteOrder (QDataStream::BigEndian);
    out << ha.toIPv4Address();
    out.setByteOrder (oldByteOrder);
    return out;
}


QDataStream & Gnutella::Packets::operator>> (QDataStream &in, Extensions::Extension &extension)
{
    extension.read (in);
    return in;
}


QDataStream & Gnutella::Packets::operator<< (QDataStream &out, const Extensions::Extension &extension)
{
    extension.write (out);
    return out;
}

Packet * Packet::fromRawData (const QByteArray &rawHeader, const QByteArray &rawPayload)
{
    int payloadDescriptor = static_cast <uchar> (rawHeader[16]);

// \todo Quick hack!
#ifdef NO_PACKET_VIRTUAL_CTOR
    return 0;
#endif

    switch (static_cast <uchar> (payloadDescriptor))
    {
    case PingDescriptor:
        return new Ping (rawHeader, rawPayload);
    case PongDescriptor:
        return new Pong (rawHeader, rawPayload);
    case QueryDescriptor:
        return new Query (rawHeader, rawPayload);
    case QueryHitsDescriptor:
        return new QueryHits (rawHeader, rawPayload);
    case PushDescriptor:
        return new Push (rawHeader, rawPayload);
    case QueryRoutingDescriptor:
        {
            QueryRouting::Variant variant = QueryRouting::UnknownVariant;
            if (rawPayload.length() > 0)
                variant = static_cast <QueryRouting::Variant> (rawPayload[0]);

            switch (variant){
            case QueryRouting::ResetVariant:
                return new QueryRoutingReset (rawHeader, rawPayload);
            case QueryRouting::PatchVariant:
                return new QueryRoutingPatch (rawHeader, rawPayload);
            case QueryRouting::UnknownVariant:
            default:
                return new UnknownPacket (rawHeader, rawPayload);
            }
        }
    case ByeDescriptor:
        return new Bye (rawHeader, rawPayload);
    case IbmcDescriptor:
    case OpenVendorDescriptor:
    case StandardVendorDescriptor:
        return VendorMessages::VendorMessage::fromRawData (rawHeader, rawPayload);
    default:
        return new UnknownPacket (rawHeader, rawPayload);
    }
}

Packet::Packet(PayloadDescriptor payloadDescriptor)
{
    d = new Data;

    d->ref.init (1);

    d->descriptorId = QUuid::createUuid();
    d->hops = DefaultHops;
    d->ttl = DefaultTtl;
    d->payloadDescriptor = payloadDescriptor;
    d->payloadLength = 0;

    d->rewriteHeader = true;
    d->rewritePayload = true;
    d->isValid = true;
}

Packet::Packet (const QByteArray &rawHeader, const QByteArray &rawPayload)
{
    d = new Data;

    d->ref.init (1);

    d->rawHeader = rawHeader;
    d->rawPayload = rawPayload;
    d->rewriteHeader = false;
    d->rewritePayload = false;
    d->isValid = false;
}


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


Packet & Packet::operator= (const Packet &other)
{
    qAtomicAssign (d, other.d);
    return *this;
}

void Packet::invalidateHeader()
{
    qAtomicDetach(d);
    d->ref.init(1);
    d->rewriteHeader = true;
}

void Packet::invalidatePayload()
{
    invalidateHeader(); // First copy private data.
    d->rewritePayload = true;
}

void Packet::parse()
{
    Q_ASSERT (d->ref == 1); // parse() is only called on a new object!

    d->isValid = true;
    if (prepareReadHeader (d->rawHeader)) {
        QDataStream headerStream (d->rawHeader);
        headerStream.setByteOrder (QDataStream::LittleEndian);
        readHeader (headerStream);
    } else
        d->isValid = false;

    Q_ASSERT (d->payloadLength == static_cast <uint> (d->rawPayload.length()));

    if (prepareReadPayload (d->rawPayload)) {
        QDataStream payloadStream (d->rawPayload);
        payloadStream.setByteOrder (QDataStream::LittleEndian);
        readPayload (payloadStream);
    } else
        d->isValid = false;
}

bool Packet::prepareReadHeader (const QByteArray &rawHeader) const
{
    return rawHeader.length() == HeaderLength;
}

void Packet::readHeader (QDataStream &stream)
{
    stream >> d->descriptorId;
    stream >> d->payloadDescriptor;
    stream >> d->ttl;
    stream >> d->hops;
    stream >> d->payloadLength;
}

void Packet::writeHeader (QDataStream &stream) const
{
    stream << d->descriptorId;
    stream << d->payloadDescriptor;
    stream << d->ttl;
    stream << d->hops;
    stream << d->payloadLength;
}

QByteArray Packet::rawHeader() const
{
    if (!isValid())
        return QByteArray();

    if (d->rewriteHeader) {
        // Force rebuilding the payload in order to get the new payloadLength.
        if (d->rewritePayload)
            rawPayload();

        // Prepare write.
        d->rawHeader.resize (HeaderLength);

        // Do write.
        QDataStream stream (&d->rawHeader, QIODevice::WriteOnly);
        stream.setByteOrder (QDataStream::LittleEndian);
        writeHeader (stream);

        // See rawPayload() for more details on this:
        Q_ASSERT (d->rawHeader.length() == HeaderLength);
        d->rawHeader.resize (HeaderLength);

        d->rewriteHeader = false;
    }
    return d->rawHeader;
}

QByteArray Packet::rawPayload() const
{
    if (!isValid())
        return QByteArray();

    if (d->rewritePayload) {
        // Prepare write.
        d->payloadLength = prepareWritePayload();
        d->rawPayload.resize (d->payloadLength);

        // Do write.
        QDataStream stream (&d->rawPayload, QIODevice::WriteOnly);
        stream.setByteOrder (QDataStream::LittleEndian);
        writePayload (stream);

        // It may happen that due to a bug more data is written to the stream
        // then the number of bytes declared by prepareWritePayload(). In this
        // case d->rawPayload is resized by the stream in order for the data to
        // fit. Assert and truncate the buffer.
        Q_ASSERT (d->payloadLength ==
                  static_cast <uint> (d->rawPayload.length()));
        d->rawPayload.resize (d->payloadLength);

        d->rewritePayload = false;
    }
    return d->rawPayload;
}

Copyright © 2006 Peter Dimov.
Powered by Doxygen.