Session.cpp

Go to the documentation of this file.

/*

Copyright (C) 2006-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 "Session.h"
#include "Imports.cpp"

namespace Protocols {
namespace BitTorrent {
namespace Transfers {
namespace Constants {

    const QByteArray ProtocolVersion        = "BitTorrent protocol";
    const QByteArray ProtocolReservedBytes  = QByteArray (8, '\0');
    const uchar ProtocolVersionLength       = (uchar) ProtocolVersion.length();
    const int ReservedBytesCount            = 8;
    const int RawSha1HashLength             = 20;
    const int PeerIdLength                  = 20;
    const int HandshakeLength               = sizeof (ProtocolVersionLength) +
                                              ProtocolVersionLength +
                                              ReservedBytesCount +
                                              RawSha1HashLength + PeerIdLength;

} // namespace Constants
} // namespace Transfers
} // namespace BitTorrent
} // namespace Protocols

Session::Session (Transport &t, SessionStatus &s, const PeerInfo &lpi)
  : transport (t), status (s), localPeerInfo (lpi),
    fileId (QByteArray (Constants::RawSha1HashLength, '\0')),
    state (DisconnectedTransport)
{
}

Session::~Session()
{
}

void Session::establish (const PeerInfo &pi, const FileId &fi)
{
    state = EstablishingSession;
    remotePeerInfo = pi;
    fileId = fi;
    status.establishingSession();
    writeHandshake();
    if (readHandshake()) {
        state = ExchangingPackets;
        status.sessionEstablished();
        // \todo readPacket() ??
    }
}

void Session::waitRequest()
{
    state = AwaitingRequest;
    status.establishingSession();
    if (readHandshake()) {
        state = AwaitingAccept;
        status.sessionRequestedFor (fileId);
    }
}

void Session::accept()
{
    Q_ASSERT (state == AwaitingAccept);
    writeHandshake();
    state = ExchangingPackets;
    status.sessionEstablished();
    // \todo readPacket() ??
}

void Session::connected()
{
    Q_ASSERT (false); // Should never be called. Should have been connected.
}

void Session::readyRead()
{
    Q_ASSERT (state != DisconnectedTransport);
    switch (state)
    {
    case EstablishingSession:
        if (!readHandshake())
            break;
        state = ExchangingPackets;
        status.sessionEstablished();
        // \todo readPacket() ??
        break;
    case AwaitingRequest:
        if (!readHandshake())
            break;
        state = AwaitingAccept;
        status.sessionRequestedFor (fileId);
        break;
    case AwaitingAccept:
        // Ignore data until accept() is called.
        break;
    case ExchangingPackets:
        readPacket();
        break;
    case DisconnectedTransport:
        Q_ASSERT (false);
        break;
    }
}

void Session::readyWrite()
{
}

void Session::disconnected()
{
    state = DisconnectedTransport;
    status.sessionClosed();
}


bool Session::readHandshake()
{
    using namespace Constants;
    QByteArray handshakeBytes = transport.read (HandshakeLength);
    // The complete handshake is not fully buffered by transport.
    if (handshakeBytes.size() == 0)
        return false;
    // Parse the handshake:
    BinaryReader reader (handshakeBytes, BinaryReader::BigEndian);
    // Verify protocol:
    uchar protocolVersionLength = reader.readByte();
    if (protocolVersionLength != ProtocolVersionLength)
        return false;
    QByteArray protocol = reader.readBytes (ProtocolVersionLength);
    if (protocol != ProtocolVersion)
        return false;
    QByteArray reserved = reader.readBytes (ReservedBytesCount);
    fileId = reader.readBytes (RawSha1HashLength);
    remotePeerInfo.id = reader.readBytes (PeerIdLength);
    // Successfully parsed the handshake.
    return true;
}

void Session::writeHandshake()
{
    using namespace Constants;
    // \todo do we really need the BinaryReader? Seems like not. Better wait
    // to see whether we'll need some special case for fileId and peerId though.
    BinaryWriter writer (BinaryWriter::BigEndian);
    writer.reserve (HandshakeLength);

    writer.writeByte (ProtocolVersionLength);
    writer.writeBytes (ProtocolVersion);
    writer.writeBytes (ProtocolReservedBytes);
    writer.writeBytes (fileId);
    writer.writeBytes (localPeerInfo.id);
    Q_ASSERT (writer.hasWrittenAll() && !writer.hasWrittenPastEnd());

    bool hasWritten = transport.write (writer.buffer());
    // The handshake is the first thing we write and the buffer should be empty:
    Q_ASSERT (hasWritten == true);
}

void Session::readPacket()
{
    //const SharedPointer <Packet> packet = packetFactory.readPacket (transport);
    // \todo use a PacketDispatcher:
    //packetDispatcher.dispatch (*packet);
    /*if (typeid (*packet) == typeid (Choke))
        status.sessionChoked();
    if (typeid (*packet) == typeid (Unchoke))
        status.sessionUnchoked();
    if (typeid (*packet) == typeid (Interested))
        status.sessionInterested();
    if (typeid (*packet) == typeid (NotInterested))
        status.sessionNotInterested();*/
}

void Session::writePacket()
{
}

Copyright © 2006 Peter Dimov.
Powered by Doxygen.