PacketProtocol.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 "PacketProtocol.h"
#include "AllowedFast.h"
#include "BadPacket.h"
#include "BitField.h"
#include "Cancel.h"
#include "Choke.h"
#include "Have.h"
#include "HaveAll.h"
#include "HaveNone.h"
#include "Interested.h"
#include "Keepalive.h"
#include "NotInterested.h"
#include "Piece.h"
#include "Port.h"
#include "RejectRequest.h"
#include "Request.h"
#include "SuggestPiece.h"
#include "Unchoke.h"
#include "Imports.cpp"

int PacketProtocol::headerLength() const
{
    return HeaderLength;
}


int PacketProtocol::payloadLength (const QByteArray &header) const
{
    Q_ASSERT (header.length() == HeaderLength);
    // First four bytes are a big-endian integer saying how many bytes follow:
    qint32 length = 0;
    length |= header [3];
    length |= header [2] << 8;
    length |= header [1] << 16;
    length |= header [0] << 24;
    return length;
}


GenericsPacket PacketProtocol::createPacket (const QByteArray &rawHeader,
                                             const QByteArray &rawPayload) const
{
    Q_ASSERT (rawHeader.length() == HeaderLength);
    Packet packet;
    if (rawPayload.length() == 0) // Only Keepalive has no payload.
        packet = Keepalive();
    else
        packet = getPacketFromTypeByte (rawPayload [0]);
    return parsedOrBadPacket (packet, rawHeader, rawPayload);
}

Packet PacketProtocol::getPacketFromTypeByte (uchar byte)
{
    PacketType type = static_cast <PacketType> (byte);
    switch (type)
    {
    case BitFieldPacket:
        return BitField();
    case CancelPacket:
        return Cancel();
    case ChokePacket:
        return Choke();
    case HavePacket:
        return Have();
    case InterestedPacket:
        return Interested();
    case NotInterestedPacket:
        return NotInterested();
    case PiecePacket:
        return Piece();
    case RequestPacket:
        return Request();
    case UnchokePacket:
        return Unchoke();
    case PortPacket:
        return Port();
    case SuggestPiecePacket:
        return SuggestPiece();
    case HaveAllPacket:
        return HaveAll();
    case HaveNonePacket:
        return HaveNone();
    case RejectRequestPacket:
        return RejectRequest();
    case AllowedFastPacket:
        return AllowedFast();
    case KeepalivePacket: // 0xFF is not a valid packet type
        // fallback to BadPacket:
    default:
        return BadPacket (type);
    }
}


Packet PacketProtocol::parsedOrBadPacket (Packet &packet,
                                          const QByteArray &rawHeader,
                                          const QByteArray &rawPayload)
{
    if (packet->parse (rawHeader, rawPayload))
        return packet;
    else
        return BadPacket (packet->packetType(), rawHeader, rawPayload);
}

Copyright © 2006 Peter Dimov.
Powered by Doxygen.