frameworkpacket.h

/***************************************************************************
 * The contents of this file are subject to the Mozilla Public             *
 * License Version 1.1 (the "License"); you may not use this file          *
 * except in compliance with the License. You may obtain a copy of         *
 * the License at http://www.mozilla.org/MPL/                              *
 *                                                                         *
 * Software distributed under the License is distributed on an "AS         *
 * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or              *
 * implied. See the License for the specific language governing            *
 * rights and limitations under the License.                               *
 *                                                                         *
 * The Original Code is Game Network Framework (GaNeF).                    *
 *                                                                         *
 * The Initial Developers of the Original Code are                         *
 * Lars Langer and Emanuel Greisen                                         *
 * Copyright (C) 2005. Lars Langer & Emanuel Greisen                       *
 * All Rights Reserved.                                                    *
 *                                                                         *
 * Contributor(s):                                                         *
 *   none yet....                                                          *
 *                                                                         *
 ***************************************************************************/
#ifndef FRAMEWORKPACKET_H
#define FRAMEWORKPACKET_H

#include <string>
#include <iostream>
#include <netinet/in.h>

#include "frameworkdata.h"

#include <pinet.h>
USING_PTYPES;

#define INITIAL_BODY_SIZE     256
#define MIN_EXPAND_BODY_SIZE   64
#define MAX_PACKET_SIZE     (65496+sizeof(FrameworkPacket::Header))


template<class PacketType,class SocketType>
class Framework;
template<class PacketType, class SocketType>
class PacketSender;

/**
 * @ingroup Common
 * @brief This struct is used when throwing packet related exceptions.
 */
struct PacketError
{
   std::string msg;
   PacketError(const std::string & msg) : msg(msg){};
};


/**
 * @ingroup Common
 * @brief This class is a UDP-packet, partly read by the framework, This gives us some knowledge of what is inside the packet.
 *
 * Here is the format of the packet:

<table border="1" cellspacing="0">
<tr><th colspan=2>header</th></tr>
<tr><td>[1 unsigned byte]    <td></td>reliable (0: unreliable, 1-255: reliable)</td></tr>
<tr><td>[1 unsigned byte]    <td></td>type (0:system, 1:plugin, 2:new object, 3:detroy object, 4-255: userdefined update of object)</td></tr>
<tr><td>[1 unsigned byte]    <td></td>priority (0: high, 255: low)</td></tr>
<tr><td>[32 bit unsigned int]<td></td>receiver (plugin_id or object_id)</td></tr>
<tr><td>[32 bit unsigned int]<td></td>packet_seq_number: used to determine if a packet should overwrite a new one, and to discard old packets that arrive very late.</td></tr>
<tr><th colspan=2>body</th></tr>
<tr><td>unsigned char[size - sizeof(Header)]</td><td>the actual data</td></tr>
</table>

@author Lars Langer and Emanuel Greisen
*/
class FrameworkPacket
{
friend class PacketSender<class PacketType,class SocketType>;
friend class Framework<class PacketType,class SocketType>;
friend std::ostream & operator <<( std::ostream & o, FrameworkPacket & packet );

public:
   /// This enum is used to keep track of the state of the packet.
   enum PacketState
   {
      /// The packet has just been create (for sending).
      STATE_NEW        = 1000,
      /// The packet has been queued (for sending).
      STATE_QUEUED_OUT = 1001,
      /// The packet has been sent (for sending).
      STATE_SENT       = 1002,
      /// The packet has been aborted (when we should send one of these, it is deleted instead).
      STATE_ABORTED    = 1003,

      /// We just received this packet (Receiving side).
      STATE_RECEIVED   = 2000,
      /// We have queued the packet in the inqueue, ready to be handled in "keepAlive(...)" (Receiving side).
      STATE_QUEUED_IN  = 2001,
      /// The packet has been delivered to the ClientFramework (Receiving side).
      STATE_DELIVERED  = 2002
   };
// Data
protected:
   /// Pointer to the actual packet data.
   char * data;
   /// Allocated size of the actual packet data.
   unsigned int realsize;
   /// The internal position (when reading/writing)
   unsigned int pos;
   /// True if the packet is incomming, false otherwise
   PacketState state;
   /// True if the Packet is ready to transmit (htonl/htons).
   bool packet_ready_to_transmit;

public:
   /// This holds info about who the message is for or who it is from, depending on `incomming`.
   struct PeerStruct
   {
      ipaddress  host;
      int        port;
      bool initialized;
      PeerStruct() : initialized(false),port(0),host(){};
   } peer;

   /// Structure describing the "header" of the packet.
   struct Header
   {
      unsigned char reliable;
      unsigned char type;
      unsigned char priority;
      unsigned int receiver;
      unsigned int packet_seq_number;
   } ;
protected:
   Header * header;

public:
   /// Special constants used when sending system-packets.
   enum SpecialReceivers
   {
      /// May never be sent (only used to write a packet for later appending it to a real packet)
      DUMMY_PACKET        =  666,

      /// Used with handshaking.
      HANDSHAKE_INIT      = 10001,
      /// Used with handshaking.
      DISCONTINUE_CLIENT  = 10002,
      /// Used with handshaking.
      SETUP_DESCRIPTION    = 10003,
      /// Used with handshaking.
      DISCONTINUE_SERVER   = 10004,
      /// Used with handshaking.
      READY_CLIENT            = 10005,

      /// An ACK packet.
      PACKET_ACK          = 20001,

      /// A Heartbeat packet.
      PACKET_HEARTBEAT    = 30001,
   };

protected:
   /// Internal constructor: sets everything
   FrameworkPacket(unsigned int receiver, unsigned char type=1, unsigned char priority=0, unsigned int bodysize=INITIAL_BODY_SIZE, bool reliable=false);

public:
   /// Constructor used when receiving packets.
   FrameworkPacket(char *data, unsigned int size);
   /// Destructor, will delete allocated "data" of the packet.
   ~FrameworkPacket();

public:
   /// Will copy the data from an other packet, this method relies on the fact that they are duplicates, hence you may not call this method unless the header of the two are identical.
   void copyData(FrameworkPacket * packet);

protected:
   /// Will set the position to just after the header (ready for reading/writing)
   inline void resetPosition() { pos = sizeof(Header); };
   /**
    * Will check sanity of read.
    * @throws PacketError
   **/
   void before_read_check(unsigned int s);
   /**
    * Will check sanity of write.
    * @throws PacketError
   **/
   void before_write_check(unsigned int s);

public:
   /// Used when sending the packet, or receiving.
   inline unsigned int getSize() const { return (isIncomming() ? realsize : pos); };
   /// Used to get the size of the data only.
   inline unsigned int getDataSize() const { return (isIncomming() ? realsize : pos)-sizeof(Header); };
   /// Used when sending the packet
   inline char * getData() const { return data; };
   /// Used when receiving or sending packets.
   inline void setPeer(const ipaddress & host, const int port){ peer.host = host; peer.port = port; peer.initialized = true; };
   /// Used to reply other packets.
   void setPeerFromPacket(FrameworkPacket * packet);

public:
   /// This method makes the packet ready for sending (htonl(...) is called on header fields).
   virtual void makeSendReady() = 0;

public:
   /// This sets the sequence number for the packet.
   inline void setSequenceNumber(unsigned int seq_no){ header->packet_seq_number = seq_no; };


public:
   /// @name Header Status Methods
   /// These methods are used to check things about what kind of packet this is, a lot of them are just convienent ways of combining checks on the header.
   /// @{
   /// From header: reliable
   inline bool isReliable() const { return (header->reliable != 0); };
   /// From header: type
   inline unsigned char getType() const { return header->type; };
   /// From header: priority
   inline unsigned char getPriority() const { return header->priority; };
   /// From header: receiver
   inline unsigned int getReceiver() const { return packet_ready_to_transmit ? ntohl(header->receiver) : header->receiver; };
   /// From header: packet_id
   inline unsigned int getSequenceNumber() const { return packet_ready_to_transmit ? ntohl(header->packet_seq_number) : header->packet_seq_number; };
   /// true if the packet is incomming
   inline bool isIncomming() const { return state >= STATE_RECEIVED; };
   /// return true if the packet has left the queue and entered the network.
   inline bool hasBeenSent() const { return state == STATE_SENT; };
   /// Will return true if the last thing that happened to a packet was insertion into a queue.
   inline bool isQueued() const { return state == STATE_QUEUED_IN || state == STATE_QUEUED_OUT; };
   /// Will return true if the packet has been aborted (this happens while in the out-queue).
   inline bool isAborted() const { return state == STATE_ABORTED; };
   /// true if this packet is a plugin-packet
   inline bool isPluginPacket() const { return getType() == 1; };
   inline bool isHeartBeatPacket() const { return getType() == 0 && getReceiver() == PACKET_HEARTBEAT; };
   inline bool isHandshakeInitPacket() const { return getType() == 0 && getReceiver() == HANDSHAKE_INIT; };
   /// Will return true if the packet is an ACK-packet
   inline bool isAckPacket() const { return getType() == 0 && getReceiver() == PACKET_ACK; };
   /// @}


   /// @name Packet State Methods
   /// These will change the state of the packet.
   /// @{
   void setStateQueued();
   void setStateSent();
   void setStateAborted();
   /// @}

///@name Readers
///@throws PacketError is thrown if you try to read beyond the size of the packet.
/// <p>
/// The following methods are used when reading from a packet.
///@{
private:
   template<typename T>
   inline T read()
   {
      before_read_check(sizeof(T));

      T i = *((T*)&data[pos]);

      pos += sizeof(T);
      return i;
   };

public:
   int            readInt32();
   unsigned int   readUInt32();
   short          readInt16();
   unsigned short readUInt16();
   char           readInt8();
   unsigned char  readUInt8();
   float          readFloat32();
   double         readDouble64();
   bool           readBool8();
   void           readData(void * dstbuff, unsigned int bytes);
   std::string    readString();
   ///@}

///@name Writers
///@throws PacketError is thrown if you try to write beyond the hard-coded max-size of the packet.
/// <p>
/// The following methods are used when writing to a packet.
///@{
private:
   template<typename T>
   inline void write(const T &v)
   {
      before_write_check(sizeof(T));

      *((T*)&data[pos]) = v;
      pos += sizeof(T);
   };
public:
   void writeInt32(const int &i);
   void writeInt16(const short &i);
   void writeInt8(const char &i);
   void writeUInt32(const unsigned int &i);
   void writeUInt16(const unsigned short &i);
   void writeUInt8(const unsigned char &i);
   void writeFloat32(const float &f);
   void writeDouble64(const double &d);
   void writeBool8(const bool &b);
   void writeString(const std::string &s);
   void writeData(const void * srcdata, unsigned int bytes);
   /// Will append the data of the given packet to this packets data, using memcpy(...).
   void appendData(FrameworkPacket * packet);
   void writePacket(FrameworkPacket * packet);
///@}
};

//
// Inline wrappers for the template read method
inline int            FrameworkPacket::readInt32()   { return ntohl(read<int>()); };
inline unsigned int   FrameworkPacket::readUInt32()  { return ntohl(read<unsigned int>()); };
inline short          FrameworkPacket::readInt16()   { return ntohs(read<short>()); };
inline unsigned short FrameworkPacket::readUInt16()  { return ntohs(read<unsigned short>()); };
inline char           FrameworkPacket::readInt8()   { return read<char>(); };
inline unsigned char  FrameworkPacket::readUInt8()  { return read<unsigned char>(); };
inline float          FrameworkPacket::readFloat32() { return read<float>(); };
inline double         FrameworkPacket::readDouble64(){ return read<double>(); };
inline bool           FrameworkPacket::readBool8()   { return read<bool>(); };


//
// Inline wrappers for the template write method
inline void FrameworkPacket::writeInt32(const int &i)            { write(htonl(i));};
inline void FrameworkPacket::writeUInt32(const unsigned int &i)  { write(htonl(i));};
inline void FrameworkPacket::writeInt16(const short &i)          { write(htons(i));};
inline void FrameworkPacket::writeUInt16(const unsigned short &i){ write(htons(i));};
inline void FrameworkPacket::writeInt8(const char &i)            { write(i);};
inline void FrameworkPacket::writeUInt8(const unsigned char &i)  { write(i);};
inline void FrameworkPacket::writeFloat32(const float &f)        { write(f);};
inline void FrameworkPacket::writeDouble64(const double &d)      { write(d);};
inline void FrameworkPacket::writeBool8(const bool &b)           { write(b);};


/// Just a method for outputting a packet to standard out.
std::ostream & operator<<(std::ostream & o, FrameworkPacket & packet);



#endif

---