PacketReader.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 "PacketReader.h"
#include "Protocols/Transports/Connection.h"

using Protocols::Transports::Connection;
using Gnutella::PacketProcessing::PacketReader;
using Gnutella::Packets::Packet;

PacketReader::PacketReader (Connection *connection)
 :  p()
{
    p.payloadLength         = 0;
    p.headerBytesRead       = 0;
    p.payloadBytesRead      = 0;
    p.packet                = 0;
    p.connection            = connection;

    QObject::connect (p.connection, SIGNAL  (readyRead()),
                      this,         SLOT    (readyRead()));
}

PacketReader::~PacketReader()
{
    //QObject::disconnect (p.connection,    SIGNAL  (readyRead()),
    //                   this,              SLOT    (readyRead()));

    if (p.packet != 0)
        delete p.packet;
}

void PacketReader::startReading()
{
    p.payloadLength = 0;
    p.headerBytesRead = 0;
    p.payloadBytesRead = 0;
    p.done = false;
    if (p.packet) {
        delete p.packet;
        p.packet = 0;
    }
    QMetaObject::invokeMethod (this, "readyRead", Qt::QueuedConnection);
}

void PacketReader::readyRead ()
{
    using Gnutella::Packets::HeaderLength;
    using Gnutella::Packets::MaximalPayloadLength;

    if (p.done)
        return;

    if (p.headerBytesRead < HeaderLength) {
        quint64 read = p.connection->read (p.rawHeader + p.headerBytesRead,
                                           HeaderLength - p.headerBytesRead);
        if (read > 0)
            p.headerBytesRead += read;

        if (p.headerBytesRead == HeaderLength) {
            p.payloadLength =    static_cast <uchar> (p.rawHeader [19])
                              + (static_cast <uchar> (p.rawHeader [20]) << 8)
                              + (static_cast <uchar> (p.rawHeader [21]) << 16)
                              + (static_cast <uchar> (p.rawHeader [22]) << 24);
            if (p.payloadLength > MaximalPayloadLength) {
                p.done = true;
                p.packet = 0; // \todo could probably be done nicer...
                emit readError(); // would be Error::ExcessivePacketLength
                return;
            }
        }
    }
    if (p.headerBytesRead == HeaderLength) {
        quint64 read = p.connection->read (p.rawPayload + p.payloadBytesRead,
                                           p.payloadLength - p.payloadBytesRead);
        if (read > 0)
            p.payloadBytesRead += read;

        if (p.payloadBytesRead == p.payloadLength) {
            // Create a copy of the raw data before passing it on.
            QByteArray newRawHeader (p.rawHeader, HeaderLength);
            QByteArray newRawPayload (p.rawPayload, p.payloadLength);

            p.packet = Gnutella::Packets::Packet::fromRawData (newRawHeader,
                                                               newRawPayload);
            p.done = true;
            // \todo What if p.packet is zero??
            emit packetRead();
            return;
        }
    }
}

const Packet * PacketReader::packet() const
{
    Q_ASSERT (p.done == true);

    return p.packet;
}

Copyright © 2006 Peter Dimov.
Powered by Doxygen.