packetreceiver.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 PACKETRECEIVER_H
#define PACKETRECEIVER_H

#include <ptypes.h>

#include "framework.h"


// TODO: What size should we choose ?
#define MAX_UPD_PACKET_SIZE 65536

template<class PacketType>
class Queue;

/**
 * @ingroup Common
 * @brief This class receives UDP packets and places them in the ingoing queue.
 * It also handlings general Framework jobs, like sending Acks back if the packet was set as reliable, etc.
 *
 * @author Lars Langer and Emanuel Greisen
*/
template<class PacketType, class SocketType>
class PacketReceiver : public thread
{
private:
   unsigned long packets_received;
   unsigned long packets_delivered;
   unsigned long bytes_received;
   unsigned long packets_unrel_skipped;
   unsigned long packets_rel_skipped;
   SocketType * socket;
   bool running;
   char buffer[MAX_UPD_PACKET_SIZE];
   Queue<PacketType> * queue;
   Framework<PacketType, SocketType> * framework;

public:
   PacketReceiver(SocketType * socket, Queue<PacketType> * queue, Framework<PacketType, SocketType> * framework);
   ~PacketReceiver();

public:
   void startListening();
   void stopListening();

public:
   virtual void execute();
   virtual void cleanup();
   void handlePacket(PacketType * packet);
   inline unsigned long bytesReceived() const { return bytes_received; };
   inline unsigned long packetsReceived() const { return packets_received; };
   inline unsigned long packetsDelivered() const { return packets_delivered; };
   inline unsigned long packetsUnreliableSkipped() const { return packets_unrel_skipped; };
   inline unsigned long packetsReliableSkipped() const { return packets_rel_skipped; };
};



template<class PacketType, class SocketType>
void PacketReceiver<PacketType, SocketType>::handlePacket( PacketType * packet )
{
   bool deliver_packet = true;

   // If it was sent reliable, we should acknowledge it (Ack-packets are never reliable, hence they cannot keep bouncing).
   bool is_reliable = packet->isReliable();
   if(is_reliable)
   {
      //FIXME: we should not ack anything but server and known clients, if we do they think they are connected, and we can have ppl mis-use our servers bandwidth.
      framework->ackPacket(packet);
   }

   // Special Case: ACKs are ALWAYS ready for delivery
   if(!packet->isAckPacket())
   {
      // Here we figure out if the packet should be delivered or buffered. Or in case of an unreliable packet if the sequence number is high enough.
      deliver_packet = framework->isPacketReadyForDelivery(packet);
   }

   // If it is a system packet (give it to the framework directly)
   if(deliver_packet)
   {
      while(packet != NULL)
      {
         packet = framework->deliverPacket(packet);
         packets_delivered++;
         if(packet)
         {
            //std::cout << "Enqueued packet:" << *packet << std::endl;
         }
      }
   }
   else
   {
      if(is_reliable)
      {
         packets_rel_skipped++;
      }
      else
      {
         packets_unrel_skipped++;
      }
   }
}


template<class PacketType, class SocketType>
void PacketReceiver<PacketType, SocketType>::execute( )
{
   try
   {
      while(running)
      {
         int sender_port = socket->get_port();
         ipaddress sender = socket->get_ip();
         int res_size = socket->receive(buffer, MAX_UPD_PACKET_SIZE);
         if(res_size > 0)
         {
            PacketType * p = new PacketType(buffer, res_size);
            p->setPeer(sender, sender_port);
            bytes_received += res_size;
            packets_received++;
            //std::cout << "Packet recieved " << std::endl;
            handlePacket(p);
         }
         else
         {
            std::cerr << "Error receiving packet from socket: " << std::endl;
         }
      }
   }
   catch(estream * e)
   {
      perr.putf("Error: %s\n", pconst(e->get_message()));
      delete e;
   }
}

template<class PacketType, class SocketType>
void PacketReceiver<PacketType, SocketType>::cleanup( )
{
   std::cout << "Receiver-thread has been terminated" << std::endl;
}


template<class PacketType, class SocketType>
PacketReceiver<PacketType, SocketType>::PacketReceiver(SocketType * socket, Queue<PacketType> * queue, Framework<PacketType, SocketType> * framework) :
      socket(socket),
   queue(queue),
   framework(framework),
   running(false),
   packets_received(0),
   bytes_received(0),
   packets_delivered(0),
   packets_unrel_skipped(0),
   packets_rel_skipped(0),
   thread(false)
{
}

template<class PacketType, class SocketType>
      PacketReceiver<PacketType, SocketType>::~PacketReceiver()
{
   stopListening( );
}

template<class PacketType, class SocketType>
      void PacketReceiver<PacketType, SocketType>::startListening( )
{
   running = true;
   start();
}

template<class PacketType, class SocketType>
      void PacketReceiver<PacketType, SocketType>::stopListening( )
{
   running = false;
}






#endif

---