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

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

PacketWriter::PacketWriter (Connection *connection)
 :  p()
{
    // Ensure that canWrite() returns true after construction.
    p.packetLength          = 0;
    p.packetBytesWritten    = 0;
    p.connection = connection;

    connect (p.connection,  SIGNAL  (bytesWritten (qint64)),
             this,          SLOT    (bytesWritten (qint64)));
}

PacketWriter::~PacketWriter()
{
    //QObject::disconnect (p.connection,    SIGNAL  (bytesWritten (qint64)),
    //                   this,              SLOT    (bytesWritten (qint64)));
}

void PacketWriter::write (const Packet &packet)
{
    using Gnutella::Packets::Packet;
    using Gnutella::Packets::HeaderLength;
    using Gnutella::Packets::MaximalPayloadLength;
    // Should we copy the data for each connection or use a shared QByteArray?
    // Shared buffer avoids copying the buffer => time + storage (storage may
    // be insignificant due to flow control and routing)
    // Shared buffer may lead to cache misses => time
    // The writer will be UdpConnection friendly if all the data is written
    // at once, i.e. not first header, then payload. Even if we want to use a
    // shared buffer, we can provide a function rawPacket, which returns
    // a QByteArray containing the complete packet. rawHeader() and rawPayload()
    // can then construct a buffer fromRawData().
    // \todo use rawPacket()
    QByteArray header = packet.rawHeader();
    QByteArray payload = packet.rawPayload();

    Q_ASSERT (header.length() == HeaderLength);
    Q_ASSERT (payload.length() <= MaximalPayloadLength);

    memcpy (p.rawPacket, header.data(), header.length());
    memcpy (p.rawPacket + header.length(), payload.data(), payload.length());

    p.packetLength          = header.length() + payload.length();
    p.packetBytesWritten    = 0;

    // \todo Should we delay the actual writing. It may be better to write
    // as much data as possible in the smallest interval possible. Maybe
    // the network implementation will perform better in that case. Do
    // more research on the topic.
    QMetaObject::invokeMethod (this, "bytesWritten", Qt::QueuedConnection,
                QGenericReturnArgument(), Q_ARG (qint64, 0));
}

void PacketWriter::bytesWritten (qint64)
{
    using Gnutella::Packets::HeaderLength;
    using Gnutella::Packets::MaximalPayloadLength;

    if (p.packetLength == p.packetBytesWritten)
        return;

    char *dataStart = p.rawPacket + p.packetBytesWritten;
    qint64 dataLength = p.packetLength - p.packetBytesWritten;
    qint64 written = p.connection->write (dataStart, dataLength);

    if (written >= 0) {
        p.packetBytesWritten += written;
        if (p.packetBytesWritten == p.packetLength)
            emit packetWritten();
    } else {
        emit writeError(); // would be Error::DeviceError
        return;
    }

    return;
}

bool PacketWriter::canWrite() const
{
    return p.packetBytesWritten == p.packetLength;
}

Copyright © 2006 Peter Dimov.
Powered by Doxygen.