Packet.h

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

*/

#ifndef PACKET_H
#define PACKET_H

#include "Extensions/Extension.h"

// Open containing namespaces:
namespace Gnutella {
namespace Packets {

FORWARD_DECLARE (Testing, class ByeConcretePacket)
FORWARD_DECLARE (Testing, class TestPacket)


enum PayloadDescriptor
{
    PingDescriptor              = 0x00, 
    PongDescriptor              = 0x01, 
    QueryDescriptor             = 0x80, 
    QueryHitsDescriptor         = 0x81, 
    PushDescriptor              = 0x40, 
    // Extension Decriptiors:
    ByeDescriptor               = 0x02, 
    IbmcDescriptor              = 0x10, 
    QueryRoutingDescriptor      = 0x30, 
    OpenVendorDescriptor        = 0x31, 
    StandardVendorDescriptor    = 0x32  
};


enum PacketConstants
{
    DefaultHops                 = 0,                            
    DefaultTtl                  = 5,                            
    MaximalTtl                  = 7,                            
    HeaderLength                = 23,                           
    MaximalPayloadLength        = 0x00010000 - HeaderLength,    
    MaximalQueryPayloadLength   = 0x00001000 - HeaderLength,    
    MaximalPacketLength         = HeaderLength + MaximalPayloadLength
};


class Packet
{
public:
                                virtual ~Packet();
    static Packet *             fromRawData (const QByteArray &rawHeader, const QByteArray &rawPayload);

    virtual QString             name() const = 0; 

    inline const QUuid &        descriptorId() const;                           
    inline PayloadDescriptor    payloadDescriptor() const;                      
    inline uchar                ttl() const;                                    
    inline uchar                hops() const;                                   
    inline quint32              payloadLength() const;                          
    inline quint32              packetLength() const;                           

    inline bool                 isValid() const;                                
    inline void                 doHop();                                        

    inline void                 setDescriptorId (const QUuid &descriptorId);    
    inline void                 setTtl (uchar ttl);                             
    inline void                 setHops (uchar hops);                           

    QByteArray                  rawHeader() const;                              
    QByteArray                  rawPayload() const;                             

    virtual Packet*             copy() const = 0;                               

protected:
                        Packet (PayloadDescriptor payloadDescriptor);
                        Packet (const QByteArray &rawHeader, const QByteArray &rawPayload);
    inline              Packet (const Packet &other);
    Packet &            operator= (const Packet &other);

    inline void         setIsValid (bool isValid);                              
    void                invalidateHeader();                                     
    virtual void        invalidatePayload();                                    

    void                parse();                                                
    virtual bool        prepareReadPayload (const QByteArray &rawPayload) = 0;  
    virtual void        readPayload (QDataStream &stream) = 0;                  
    virtual int         prepareWritePayload() const = 0;                        
    virtual void        writePayload (QDataStream &stream) const = 0;           

private:
    bool                prepareReadHeader (const QByteArray &rawHeader) const;  
    void                readHeader (QDataStream &stream);                       
    void                writeHeader (QDataStream &stream) const;                

    struct Data
    {
        QBasicAtomic        ref;                    

        QUuid               descriptorId;           
        PayloadDescriptor   payloadDescriptor;      
        uchar               ttl;                    
        uchar               hops;                   
        mutable quint32     payloadLength;          

        bool                isValid;                
        mutable QByteArray  rawHeader;              
        mutable QByteArray  rawPayload;             
        mutable bool        rewriteHeader;          
        mutable bool        rewritePayload;         
    };

    Data                    *d;                     

    friend class Testing::ByeConcretePacket;
    friend class Testing::TestPacket;
};

QDataStream & operator>> (QDataStream &in, PayloadDescriptor &pd);
QDataStream & operator<< (QDataStream &out, const PayloadDescriptor &pd);
QDataStream & operator>> (QDataStream &in, QHostAddress &ha);
QDataStream & operator<< (QDataStream &out, const QHostAddress &ha);
QDataStream & operator>> (QDataStream &in, Extensions::Extension &extension);
QDataStream & operator<< (QDataStream &out, const Extensions::Extension &extension); // \todo Move to Extension.h


// inline functions

inline Packet::Packet (const Packet &other)
: d (other.d)
{ d->ref.ref(); }

inline const QUuid & Packet::descriptorId() const
{ return d->descriptorId; }

inline PayloadDescriptor Packet::payloadDescriptor() const
{ return d->payloadDescriptor; }

inline uchar Packet::ttl() const
{ return d->ttl; }

inline uchar Packet::hops() const
{ return d->hops; }

inline quint32 Packet::payloadLength() const
{
    // Force payloadLength to be recalculated if required!
    // Necessary for filters!
    rawPayload();
    return d->payloadLength;
}

inline quint32 Packet::packetLength() const
{ return HeaderLength + payloadLength(); }

inline bool Packet::isValid() const
{ return d->isValid; }

inline void Packet::doHop()
{ invalidateHeader(); d->ttl--; d->hops++; }

inline void Packet::setDescriptorId (const QUuid &descriptorId)
{ invalidateHeader(); d->descriptorId = descriptorId; }

inline void Packet::setTtl (uchar ttl)
{ invalidateHeader(); d->ttl = ttl; }

inline void Packet::setHops (uchar hops)
{ invalidateHeader(); d->hops = hops; }

inline void Packet::setIsValid (bool isValid)
{ d->isValid = isValid; }

// Close containing namespaces:
} // namespace Packets
} // namespace Gnutella

#endif // PACKET_H

Copyright © 2006 Peter Dimov.
Powered by Doxygen.