frameworkpacket.cpp

/***************************************************************************
 * 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....                                                          *
 *                                                                         *
 ***************************************************************************/
#include "frameworkpacket.h"

#include <iostream>

#include "../server/serverdata.h"
#include "../client/clientdata.h"


FrameworkPacket::FrameworkPacket(
               unsigned int receiver,
               unsigned char type,
               unsigned char priority,
               unsigned int bodysize,
               bool reliable)
   : realsize(sizeof(Header)+bodysize),
   state(STATE_NEW),
   packet_ready_to_transmit(false)
{
   data = new char[realsize];

   // set header data
   header = (Header *)data;
   header->reliable = reliable ? 1 : 0;
   header->type = type;
   header->priority = priority;
   header->receiver = receiver;
   header->packet_seq_number = 0;

   // update position
   resetPosition();
}



FrameworkPacket::FrameworkPacket( char * srcdata, unsigned int size )
   : realsize(size),
   state(STATE_RECEIVED),
   packet_ready_to_transmit(false)
{
   // allocate memory
   data = new char[size];

   // copy data
   memcpy(data, srcdata, size);

   // set header
   header = (Header *)data;
   header->receiver  = ntohl(header->receiver);
   header->packet_seq_number = ntohl(header->packet_seq_number);

   // update position
   resetPosition();
}



FrameworkPacket::~FrameworkPacket()
{
   //std::cout << "FrameworkPacket:destructor(" << *this << ")\n";
   if(data)
   {
      char * tmp = data;
      header = 0;
      data = 0;
      delete[] tmp;
   }
}

void FrameworkPacket::before_read_check( unsigned int s )
{
   if(!isIncomming())
      throw new PacketError("Reading from outgoing packet is not allowed");
   if(pos+s > realsize)
      throw new PacketError("Reading beyond packet size is not possible");
}

void FrameworkPacket::before_write_check( unsigned int wanted_s )
{
   unsigned int s = wanted_s;
   if(isIncomming())
      throw new PacketError("Writing to incomming packet is not allowed");
   // Space enough ?
   if(pos+s < realsize)
      return;

   // Make sure we expand enough
   if(s < MIN_EXPAND_BODY_SIZE)
      s = MIN_EXPAND_BODY_SIZE;

   //std::cout << "expand from: " << realsize << " to " << (realsize + s) << std::endl;
   if(realsize + s > MAX_PACKET_SIZE)
      s = MAX_PACKET_SIZE - realsize;
   if(s == 0)
   {
      std::cerr << "realsize:" << realsize << "\ns:" << s << "\nMAX_PACKET_SIZE:" << MAX_PACKET_SIZE << "\nwanted_s:" << wanted_s << std::endl;
      throw new PacketError("Expand to size beyond max packet size: MAX_PACKET_SIZE is not allowed, due to limitations of UDP packets");
   }

   // allocate bigger place
   char * n = new char[realsize + s];
   // copy data
   memcpy(n, data, realsize);

   // delete old data
   delete[] data;

   // Increase size
   realsize += s;

   // Set data to point at new data
   data = n;

   // set header
   header = (Header *)data;
}

std::string FrameworkPacket::readString( )
{
   before_read_check(1); // This is odd, but we don't know how long the string is.

   std::string str((char *)(&data[pos]));
   pos += str.size() + 1;
   return str;
}

void FrameworkPacket::writeString( const std::string & s )
{
   before_write_check(s.size()+1);

   const char *cstr = s.c_str();

   for(int i = 0; i < s.size(); i++)
   {
      *((char*)&data[pos]) = cstr[i];
      pos++;
   }
   *((char*)&data[pos]) = '\0';
   pos++;
}


void FrameworkPacket::appendData( FrameworkPacket * packet )
{
   //void *  memcpy ( void * dest, const void * src, size_t num );
   //OPTIMIZE: we could expand to make room for the data, and then make a memcpy(...) call.
   unsigned int datasize = packet->getSize() - sizeof(Header);
   if(datasize > 0)
   {
      before_write_check(datasize);
      char * tmpsrcdata = &packet->getData()[sizeof(Header)];
      char * tmpdstdata = &getData()[pos];
      memcpy(tmpdstdata, tmpsrcdata, datasize);
      pos += datasize;
   }
}

void FrameworkPacket::writeData( const void * srcdata, unsigned int bytes )
{
   before_write_check(bytes);
   char * tmpdstdata = &getData()[pos];
   memcpy(tmpdstdata, srcdata, bytes);
   pos += bytes;
}

void FrameworkPacket::readData( void * dstbuff, unsigned int bytes )
{
   before_read_check(bytes);
   char * tmpsrcdata = &getData()[pos];
   memcpy(dstbuff, tmpsrcdata, bytes);
   pos += bytes;
}



void FrameworkPacket::writePacket( FrameworkPacket * packet )
{
   // First make sure the packet is ready
   packet->makeSendReady();

   // Then copy all the data to this packet
   before_write_check(packet->getSize());
   char * tmpdstdata = &getData()[pos];
   memcpy(tmpdstdata, packet->getData(), packet->getSize());
   pos += packet->getSize();
}


void FrameworkPacket::setPeerFromPacket( FrameworkPacket * packet )
{
   if(!packet->isIncomming())
      throw new PacketError("Cannot reply an outgoing packet");
   peer = packet->peer;
   peer.initialized = true;
}


void FrameworkPacket::copyData( FrameworkPacket * packet )
{
   // Check that size, and everything is identical
   if(packet->data != data)
      throw new PacketError("You may only use this copy-method if the packets are duplicates");

   // Allocate and copy data
   data = new char[realsize];
   memcpy(data, packet->data, pos);
   header = (Header *)data;
}

void FrameworkPacket::setStateQueued( )
{
   switch(state)
   {
   // Sending side:
   case STATE_NEW: //        = 1000,
   case STATE_SENT:
      state = STATE_QUEUED_OUT;
      break;

   // Receiving side:
   case STATE_RECEIVED: //   = 2000,
      state = STATE_QUEUED_IN;
      break;
   default:
      std::cout << "You may only enqueue packets with states: STATE_NEW, STATE_RECEIVED and STATE_SENT(this: " <<state<<std::endl;
      throw new PacketError("You may only enqueue packets with states: STATE_NEW, STATE_RECEIVED and STATE_SENT");
      break;
   }
}

void FrameworkPacket::setStateSent( )
{
   switch(state)
   {
   case STATE_NEW: //        = 1000,
   case STATE_QUEUED_OUT:
      state = STATE_SENT;
      break;
   default:
      throw new PacketError("You may only send packets with states: STATE_NEW and STATE_QUEUED_OUT");
      break;
   }
}

void FrameworkPacket::setStateAborted( )
{
   if(state == STATE_QUEUED_OUT)
   {
      state == STATE_ABORTED;
   }
   else
   {
      throw new PacketError("You may only abort packets with state: STATE_QUEUED_OUT");
   }
}

std::ostream & operator <<( std::ostream & o, FrameworkPacket & packet )
{
   o << "[Packet]";
   o << "typ:" << (unsigned short)packet.getType()<<",";
   o << "rec:" << packet.getReceiver() << ",";
   o << "pri:" << (unsigned short)packet.getPriority() << ",";
   if(packet.isReliable())
   {
      o << "rel-seq:" << packet.getSequenceNumber() << ",";
   }
   else
   {
      o << "unrel-seq:" << packet.getSequenceNumber() << ",";
   }
   o << "size:" << packet.getSize() << ",";
   o << (packet.isIncomming() ? "From:" : "To:");
   o << static_cast<int>(packet.peer.host[0]) << ".";
   o << static_cast<int>(packet.peer.host[1]) << ".";
   o << static_cast<int>(packet.peer.host[2]) << ".";
   o << static_cast<int>(packet.peer.host[3]);
o << ":" << packet.peer.port << "[/Packet]";
   return o;
}

---