Changeset 1751 for code/trunk/src/network/packet

Timestamp:

Sep 9, 2008, 4:31:34 PM (16 years ago)

Author:

scheusso

Message:

merged network branch back into trunk

Location:

code/trunk/src/network/packet

Files:

• Acknowledgement.cc (modified) (1 diff)
• Gamestate.cc (modified) (19 diffs)
• Gamestate.h (modified) (4 diffs)
• Packet.cc (modified) (4 diffs)
• Packet.h (modified) (1 diff)
• Welcome.cc (modified) (2 diffs)

code/trunk/src/network/packet/Acknowledgement.cc

@@ -45 +45 @@
   data_=new unsigned char[ getSize() ];
   *(ENUM::Type *)(data_ + _PACKETID ) = ENUM::Acknowledgement;
-  *(unsigned int *)&data_[ _ACKID ] = id;
+  *(unsigned int *)(data_ + _ACKID ) = id;
   clientID_=clientID;
 }

code/trunk/src/network/packet/Gamestate.cc

@@ -41 +41 @@
 namespace packet {
 
-
-#define GAMESTATE_START(data) data + sizeof(GamestateHeader)
+#define GAMESTATE_START(data) (data + sizeof(GamestateHeader))
 #define GAMESTATE_HEADER(data) ((GamestateHeader *)data)
 #define HEADER GAMESTATE_HEADER(data_)
@@ -63 +62 @@
 {
   int tempsize=0, currentsize=0;
-  assert(data_==0 /*&& bs_==0*/);
-  int size = calcGamestateSize(mode);
+  assert(data_==0);
+  int size = calcGamestateSize(id, mode);
 
   COUT(4) << "G.ST.Man: producing gamestate with id: " << id << std::endl;
-    //retval->data = (unsigned char*)malloc(size);
   if(size==0)
     return false;
   data_ = new unsigned char[size + sizeof(GamestateHeader)];
-  //bs_ = new Bytestream(data_+sizeof(GamestateHeader), size);
   if(!data_){
     COUT(2) << "GameStateManager: could not allocate memory" << std::endl;
@@ -82 +79 @@
   orxonox::ObjectList<Synchronisable>::iterator it;
   for(it = orxonox::ObjectList<Synchronisable>::begin(); it; ++it){
-    tempsize=it->getSize2(mode);
+    tempsize=it->getSize2(id, mode);
 
     if(currentsize+tempsize > size){
@@ -90 +87 @@
       int addsize=tempsize;
       while(++temp)
-        addsize+=temp->getSize2(mode);
+        addsize+=temp->getSize2(id, mode);
       data_ = (unsigned char *)realloc(data_, sizeof(GamestateHeader) + currentsize + addsize);
       if(!data_)
@@ -97 +94 @@
     }// stop allocate additional memory
 
-    if(!it->getData2(mem, mode))
+    if(!it->getData(mem, id, mode))
       return false; // mem pointer gets automatically increased because of call by reference
     // increase size counter by size of current synchronisable
@@ -121 +118 @@
 bool Gamestate::spreadData(int mode)
 {
-  assert(data_ && !HEADER->compressed && !HEADER->diffed);
+  assert(data_);
+  assert(!HEADER->compressed);
+  assert(!HEADER->diffed);
   unsigned int size, objectID, classID;
   unsigned char *mem=data_+sizeof(GamestateHeader);
@@ -142 +141 @@
         //fabricate the new synchronisable
         if(!Synchronisable::fabricate(mem, mode))
-          /*return false*/;
+          return false;
         it=orxonox::ObjectList<Synchronisable>::end();
       }
@@ -175 +174 @@
 }
 
+bool Gamestate::operator==(packet::Gamestate gs){
+  unsigned char *d1 = data_+sizeof(GamestateHeader);
+  unsigned char *d2 = gs.data_+sizeof(GamestateHeader);
+  assert(!isCompressed());
+  assert(!gs.isCompressed());
+  while(d1<data_+HEADER->normsize)
+  {
+    if(*d1!=*d2)
+      return false;
+    d1++;
+    d2++;
+  }
+  return true;
+}
+
 bool Gamestate::process()
 {
@@ -183 +197 @@
 {
   assert(HEADER);
-  uLongf buffer = (uLongf)((HEADER->normsize + 12)*1.01)+1;
+  assert(!HEADER->compressed);
+  uLongf buffer = (uLongf)(((HEADER->normsize + 12)*1.01)+1);
   if(buffer==0)
     return false;
@@ -189 +204 @@
   unsigned char *ndata = new unsigned char[buffer+sizeof(GamestateHeader)];
   unsigned char *dest = GAMESTATE_START(ndata);
+  //unsigned char *dest = new unsigned char[buffer];
+  unsigned char *source = GAMESTATE_START(data_);
   int retval;
-  retval = compress( dest, &buffer, GAMESTATE_START(data_), (uLong)(HEADER->normsize) );
+  retval = compress( dest, &buffer, source, (uLong)(HEADER->normsize) );
   switch ( retval ) {
     case Z_OK: COUT(5) << "G.St.Man: compress: successfully compressed" << std::endl; break;
-    case Z_MEM_ERROR: COUT(1) << "G.St.Man: compress: not enough memory available in gamestate.compress" << std::endl;
-    return false;
-    case Z_BUF_ERROR: COUT(2) << "G.St.Man: compress: not enough memory available in the buffer in gamestate.compress" << std::endl;
-    return false;
-    case Z_DATA_ERROR: COUT(2) << "G.St.Man: compress: data corrupted in gamestate.compress" << std::endl;
-    return false;
-  }
+    case Z_MEM_ERROR: COUT(1) << "G.St.Man: compress: not enough memory available in gamestate.compress" << std::endl; return false;
+    case Z_BUF_ERROR: COUT(2) << "G.St.Man: compress: not enough memory available in the buffer in gamestate.compress" << std::endl; return false;
+    case Z_DATA_ERROR: COUT(2) << "G.St.Man: compress: data corrupted in gamestate.compress" << std::endl; return false;
+  }
+#ifndef NDEBUG
+  //decompress and compare the start and the decompressed data
+  unsigned char *rdata = new unsigned char[HEADER->normsize+sizeof(GamestateHeader)];
+  unsigned char *d2 = GAMESTATE_START(rdata);
+  uLongf length2 = HEADER->normsize;
+  uncompress(d2, &length2, dest, buffer);
+  for(unsigned int i=0; i<HEADER->normsize; i++){
+    assert(*(source+i)==*(d2+i));
+  }
+  delete[] rdata;
+#endif
 
   //copy and modify header
-  HEADER->compsize = buffer;
-  HEADER->compressed = true;
+#ifndef NDEBUG
+  HEADER->crc32 = calcCRC(data_+sizeof(GamestateHeader), HEADER->normsize);
+#endif
   *GAMESTATE_HEADER(ndata) = *HEADER;
   //delete old data
@@ -209 +235 @@
   //save new data
   data_ = ndata;
+  HEADER->compsize = buffer;
+  HEADER->compressed = true;
   assert(HEADER->compressed);
   COUT(3) << "gamestate compress normsize: " << HEADER->normsize << " compsize: " << HEADER->compsize << std::endl;
@@ -215 +243 @@
 bool Gamestate::decompressData()
 {
+  assert(HEADER);
   assert(HEADER->compressed);
-  //COUT(4) << "GameStateClient: uncompressing gamestate. id: " << a->id << ", baseid: " << a->base_id << ", normsize: " << a->normsize << ", compsize: " << a->compsize << std::endl;
-  int normsize = HEADER->normsize;
-  int compsize = HEADER->compsize;
-  int bufsize;
-  if(normsize < compsize)
-    bufsize = compsize;
-  else
-    bufsize = normsize;
-  if(bufsize==0)
-    return false;
+  COUT(3) << "GameStateClient: uncompressing gamestate. id: " << HEADER->id << ", baseid: " << HEADER->base_id << ", normsize: " << HEADER->normsize << ", compsize: " << HEADER->compsize << std::endl;
+  unsigned int normsize = HEADER->normsize;
+  unsigned int compsize = HEADER->compsize;
+  unsigned int bufsize;
+  assert(compsize<=normsize);
+  bufsize = normsize;
+  assert(bufsize!=0);
   unsigned char *ndata = new unsigned char[bufsize + sizeof(GamestateHeader)];
   unsigned char *dest = ndata + sizeof(GamestateHeader);
+  unsigned char *source = data_ + sizeof(GamestateHeader);
   int retval;
-  uLongf length=normsize;
-  retval = uncompress( dest, &length, data_+sizeof(GamestateHeader), (uLong)compsize );
+  uLongf length=bufsize;
+  retval = uncompress( dest, &length, source, (uLong)compsize );
   switch ( retval ) {
     case Z_OK: COUT(5) << "successfully decompressed" << std::endl; break;
@@ -237 +264 @@
     case Z_DATA_ERROR: COUT(2) << "data corrupted (zlib)" << std::endl; return false;
   }
-
-  HEADER->compressed = false;
+#ifndef NDEBUG
+  assert(HEADER->crc32==calcCRC(ndata+sizeof(GamestateHeader), HEADER->normsize));
+#endif
+  
   //copy over the header
   *GAMESTATE_HEADER(ndata) = *HEADER;
   //delete old (compressed data)
   delete[] data_;
-  //set new pointers and create bytestream
+  //set new pointers
   data_ = ndata;
-  //bs_ = new Bytestream(getGs(), GAMESTATE_HEADER->normsize);
-
+  HEADER->compressed = false;
+  assert(HEADER->normsize==normsize);
+  assert(HEADER->compsize==compsize);
   return true;
 }
@@ -252 +282 @@
 Gamestate *Gamestate::diff(Gamestate *base)
 {
+  assert(HEADER);
+  assert(!HEADER->compressed);
+  assert(!HEADER->diffed);
   //unsigned char *basep = base->getGs()/*, *gs = getGs()*/;
   unsigned char *basep = GAMESTATE_START(base->data_), *gs = GAMESTATE_START(this->data_);
@@ -277 +310 @@
   *GAMESTATE_HEADER(ndata) = *HEADER;
   GAMESTATE_HEADER(ndata)->diffed = true;
-  Gamestate *g = new Gamestate(ndata, 0);
+  GAMESTATE_HEADER(ndata)->base_id = base->getID();
+  Gamestate *g = new Gamestate(ndata, getClientID());
+  g->flags_=flags_;
+  g->packetDirection_ = packetDirection_;
   return g;
 }
@@ -283 +319 @@
 Gamestate *Gamestate::undiff(Gamestate *base)
 {
-  assert(this && base);
+  assert(this && base);assert(HEADER);
+  assert(HEADER->diffed);
   assert(!HEADER->compressed && !GAMESTATE_HEADER(base->data_)->compressed);
   //unsigned char *basep = base->getGs()/*, *gs = getGs()*/;
@@ -310 +347 @@
   *GAMESTATE_HEADER(ndata) = *HEADER;
   GAMESTATE_HEADER(ndata)->diffed = false;
-  Gamestate *g = new Gamestate(ndata, 0);
+  Gamestate *g = new Gamestate(ndata, getClientID());
+  g->flags_=flags_;
+  g->packetDirection_ = packetDirection_;
+  assert(!g->isDiffed());
+  assert(!g->isCompressed());
   return g;
 }
 
 
-unsigned int Gamestate::calcGamestateSize(int mode)
+unsigned int Gamestate::calcGamestateSize(unsigned int id, int mode)
 {
   int size=0;
@@ -322 +363 @@
     // get total size of gamestate
   for(it = orxonox::ObjectList<Synchronisable>::begin(); it; ++it)
-    size+=it->getSize2(mode); // size of the actual data of the synchronisable
+    size+=it->getSize2(id, mode); // size of the actual data of the synchronisable
 //  size+=sizeof(GamestateHeader);
   return size;
@@ -342 +383 @@
   }
 
+  bool Gamestate::isCompressed(){
+    return HEADER->compressed;
+  }
+  
   int Gamestate::getBaseID(){
     return HEADER->base_id;

code/trunk/src/network/packet/Gamestate.h

@@ -29 +29 @@
 #include "Packet.h"
 #include "network/Synchronisable.h"
-//#include "util/Bytestream.h"
+#ifndef NDEBUG
+#include "util/CRC32.h"
+#endif
 #include "core/CoreIncludes.h"
 
@@ -48 +50 @@
   bool complete; // wheter it is a complete gamestate or only partial
   bool compressed;
+#ifndef NDEBUG
+  uint32_t crc32;
+#endif
 };
 
@@ -64 +69 @@
     int getID();
     bool isDiffed();
+    bool isCompressed();
     int getBaseID();
     Gamestate *diff(Gamestate *base);
@@ -74 +80 @@
     virtual bool process();
 
-
+    bool operator ==(packet::Gamestate gs);
   private:
-    unsigned int calcGamestateSize(int mode=0x0);
-    void removeObject(orxonox::ObjectListIterator<Synchronisable> &it);
+    unsigned int calcGamestateSize(unsigned int id, int mode=0x0);
+    void removeObject(orxonox::ObjectList<Synchronisable>::iterator &it);
 
 

code/trunk/src/network/packet/Packet.cc

@@ -92 +92 @@
 
 Packet::~Packet(){
-  if(enetPacket_)
+  if(enetPacket_){
+    assert(enetPacket_->freeCallback==0);
     enet_packet_destroy(enetPacket_);
+  }
   if(data_)
     delete[] data_;
@@ -109 +111 @@
     }
     enetPacket_ = enet_packet_create(getData(), getSize(), getFlags());
-    //enetPacket_->freeCallback = &Packet::deletePacket;
-    enetPacket_->freeCallback = &blub;
+    enetPacket_->freeCallback = &Packet::deletePacket;
+//     enetPacket_->freeCallback = &blub;
     packetMap_[enetPacket_] = this;
   }
-  /*switch( *(ENUM::Type *)(data_ + _PACKETID) )
+#ifndef NDEBUG 
+  switch( *(ENUM::Type *)(data_ + _PACKETID) )
   {
     case ENUM::Acknowledgement:
@@ -120 +123 @@
     case ENUM::Gamestate:
     case ENUM::Welcome:
-      COUT(3) << "welcome" << std::endl;
-      p = new Welcome( data, clientID );
+      break;
     default:
-      assert(0); //TODO: repair this
+      assert(0); //there was some error, if this is the case
       break;
-  }*/
-  network::Host::addPacket( enetPacket_, clientID_);
+  }
+#endif
+  ENetPacket *temp = enetPacket_;
   enetPacket_ = 0; // otherwise we have a double free because enet already handles the deallocation of the packet
+  network::Host::addPacket( temp, clientID_);
   return true;
 }
@@ -168 +172 @@
 void Packet::deletePacket(ENetPacket *packet){
   assert(packetMap_[packet]);
+  assert(packetMap_[packet]->enetPacket_==0);
   delete packetMap_[packet];
 }

code/trunk/src/network/packet/Packet.h

@@ -78 +78 @@
     enet_uint32 flags_;
     int clientID_;
+    ENUM::Direction packetDirection_;
     unsigned char *data_;
   private:
     static std::map<ENetPacket *, Packet *> packetMap_;
     ENetPacket *enetPacket_;
-    ENUM::Direction packetDirection_;
 };
 

code/trunk/src/network/packet/Welcome.cc

@@ -32 +32 @@
 #include "Welcome.h"
 #include "network/Host.h"
+#include "network/Synchronisable.h"
 #include "core/CoreIncludes.h"
 #include <assert.h>
@@ -79 +80 @@
   Host::setShipID(shipID);
   COUT(3) << "Welcome set clientId: " << clientID << " shipID: " << shipID << std::endl;
+  Synchronisable::setClient(true);
   delete this;
   return true;