Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: orxonox.OLD/trunk/src/lib/network/synchronizeable.cc @ 9486

Last change on this file since 9486 was 9406, checked in by bensch, 18 years ago

orxonox/trunk: merged the proxy back

merged with commandsvn merge -r9346:HEAD https://svn.orxonox.net/orxonox/branches/proxy .

no conflicts

File size: 18.1 KB
Line 
1/*
2   orxonox - the future of 3D-vertical-scrollers
3
4   Copyright (C) 2004 orx
5
6   This program is free software; you can redistribute it and/or modify
7   it under the terms of the GNU General Public License as published by
8   the Free Software Foundation; either version 2, or (at your option)
9   any later version.
10
11
12### File Specific:
13   main-programmer: Christoph Renner (rennerc@ee.ethz.ch)
14   co-programmer: Patrick Boenzli (patrick@orxonox.ethz.ch)
15*/
16
17#define DEBUG_MODULE_NETWORK
18
19#include "shared_network_data.h"
20#include "network_stream.h"
21#include "netdefs.h"
22#include "network_log.h"
23#include "network_game_manager.h"
24
25#include "state.h"
26
27#include <cassert>
28
29#include "synchronizeable.h"
30
31#include "converter.h"
32
33
34
35/**
36 *  default constructor
37 */
38Synchronizeable::Synchronizeable()
39{
40  this->setClassID(CL_SYNCHRONIZEABLE, "Synchronizeable");
41  this->owner = 0;
42//   this->setIsServer(SharedNetworkData::getInstance()->getHostID() == 0);
43  this->uniqueID = NET_UID_UNASSIGNED;
44  this->networkStream = NULL;
45  this->bSynchronize = false;
46
47  if( State::isOnline())
48  {
49    NetworkStream* nd = SharedNetworkData::getInstance()->getDefaultSyncStream();
50    assert(nd != NULL);
51    nd->connectSynchronizeable(*this);
52    this->setUniqueID(SharedNetworkData::getInstance()->getNewUniqueID());
53  }
54
55  /* make sure loadClassId is first synced var because this is read by networkStream */
56  assert( syncVarList.size() == 0 );
57  mLeafClassId = this->registerVarId( new SynchronizeableInt( (int*)&this->getLeafClassID(), (int*)&this->getLeafClassID(), "leafClassId" ) );
58
59  this->registerVar( new SynchronizeableInt( &this->owner, &this->owner, "owner" ) );
60  this->registerVar( new SynchronizeableString( &this->objectName, &this->objectName, "objectName" ) );
61}
62
63
64
65/**
66 *  default destructor deletes all unneded stuff
67 */
68Synchronizeable::~Synchronizeable()
69{
70  if ( this->networkStream )
71  {
72    this->networkStream->disconnectSynchronizeable(*this);
73
74    if ( (SharedNetworkData::getInstance()->isMasterServer() || SharedNetworkData::getInstance()->isProxyServer() )
75           && this->beSynchronized() && this->getUniqueID() > 0 && !this->isA( CL_MESSAGE_MANAGER ) )
76      NetworkGameManager::getInstance()->removeSynchronizeable( this->getUniqueID() );
77  }
78
79  for ( SyncVarList::iterator it = syncVarList.begin(); it != syncVarList.end(); it++ )
80  {
81    delete *it;
82  }
83  syncVarList.clear();
84
85  for ( UserStateHistory::iterator it = recvStates.begin(); it != recvStates.end(); it++ )
86  {
87    for ( StateHistory::iterator it2 = it->begin(); it2 != it->end(); it2++ )
88    {
89      if ( (*it2)->data )
90      {
91        delete [] (*it2)->data;
92        (*it2)->data = NULL;
93      }
94      delete *it2;
95    }
96
97  }
98
99  for ( UserStateHistory::iterator it = sentStates.begin(); it != sentStates.end(); it++ )
100  {
101    for ( StateHistory::iterator it2 = it->begin(); it2 != it->end(); it2++ )
102    {
103      if ( (*it2)->data )
104      {
105        delete [] (*it2)->data;
106        (*it2)->data = NULL;
107      }
108      delete *it2;
109    }
110  }
111}
112
113
114
115/**
116 * creates a diff image from two states
117 * @param userId: the userid of the user where the image will be sent to
118 * @param data: the binary data array to write to
119 * @param maxLength: maximal length of the data written (length of available space in the array)
120 * @param stateId: the state id that this diff will represent
121 * @param priorityTH: the priority threshold: all syncs below this threshold won't be synchronized
122 *
123 * @todo check for permissions
124 */
125int Synchronizeable::getStateDiff( int userId, byte* data, int maxLength, int stateId, int fromStateId, int priorityTH )
126{
127  //make sure this user has his history
128  if ( sentStates.size() <= userId )
129    sentStates.resize( userId+1 );
130
131  //calculate needed memory
132  int neededSize = 0;
133
134  for ( SyncVarList::iterator it = syncVarList.begin(); it != syncVarList.end(); it++ )
135  {
136    //PRINTF(0)("SIZE = %d %s\n", (*it)->getSize(), (*it)->getName().c_str());
137    neededSize += (*it)->getSize();
138  }
139
140  if ( !( neededSize <= maxLength ) )
141  {
142    PRINTF(0)( "%d > %d\n", neededSize, maxLength );
143    assert(false);
144  }
145
146  //remove older states from history than fromStateId
147  StateHistory::iterator it = sentStates[userId].begin();
148
149  while ( it != sentStates[userId].end() && (*it)->stateId < fromStateId )
150    it++;
151
152  if ( it != sentStates[userId].begin() )
153  {
154    for ( StateHistory::iterator it2 = sentStates[userId].begin(); it2 != it; it2++ )
155    {
156      if ( (*it2)->data != NULL )
157      {
158        delete [] (*it2)->data;
159        (*it2)->data = NULL;
160      }
161
162      delete *it2;
163    }
164    sentStates[userId].erase( sentStates[userId].begin(), it );
165  }
166
167  //find state to create diff from
168  StateHistoryEntry * stateFrom = NULL;
169
170  it = sentStates[userId].begin();
171  while ( it != sentStates[userId].end() && (*it)->stateId != fromStateId )
172    it++;
173
174  if ( it == sentStates[userId].end() )
175  {
176    StateHistoryEntry * initialEntry = new StateHistoryEntry();
177
178    initialEntry->stateId = fromStateId;
179    initialEntry->dataLength = 0;
180    initialEntry->data = NULL;
181
182    stateFrom = initialEntry;
183
184    sentStates[userId].push_back( stateFrom );
185  }
186  else
187    stateFrom = (*it);
188
189  StateHistoryEntry * stateTo = new StateHistoryEntry;
190
191  sentStates[userId].push_back( stateTo );
192
193  stateTo->stateId = stateId;
194  stateTo->dataLength = neededSize;
195  stateTo->data = new byte[ neededSize ];
196
197  std::list<int>::iterator sizeIter = stateFrom->sizeList.begin();
198
199  int i = 0;
200  int n;
201
202  bool hasPermission = false;
203  bool sizeChanged = false;
204
205  // now do the actual synchronization: kick all variables to write into a common buffer
206  for ( SyncVarList::iterator it = syncVarList.begin(); it != syncVarList.end(); it++ )
207  {
208    // DATA PERMISSIONS
209    // check if this synchronizeable has the permissions to write the data
210
211    // first check MASTER_SERVER permissions
212    if( SharedNetworkData::getInstance()->isMasterServer() && (*it)->checkPermission( PERMISSION_MASTER_SERVER ))
213      hasPermission = true;
214    // now check PROXY_SERVER permissions
215    else if( SharedNetworkData::getInstance()->isProxyServer() && (*it)->checkPermission( PERMISSION_MASTER_SERVER ))
216      hasPermission = true;
217    // now check OWNER permissions
218    else if( this->owner == SharedNetworkData::getInstance()->getHostID() && (*it)->checkPermission( PERMISSION_OWNER ))
219      hasPermission = true;
220    // now check ALL permissions
221    else if( (*it)->checkPermission( PERMISSION_ALL ))
222      hasPermission = true;
223    // SPECIAL: get write permissions if i am master server and i am able to overwrite the client stuff
224    else if( SharedNetworkData::getInstance()->isMasterServer() && this->owner != userId && (*it)->checkPermission( PERMISSION_OWNER ))
225      hasPermission = true;
226    // SPECIAL: get write permissions if i am proxy server and i am able to overwrite the client stuff
227    else if( SharedNetworkData::getInstance()->isProxyServer()  && this->owner != userId && (*it)->checkPermission( PERMISSION_OWNER ))
228      hasPermission = true;
229    else
230      hasPermission = false;
231
232
233    if ( sizeIter == stateFrom->sizeList.end() || *sizeIter != (*it)->getSize() )
234      sizeChanged = true;
235
236    if ( ( hasPermission && (*it)->getPriority() >= priorityTH ) || sizeChanged )
237    {
238      n = (*it)->writeToBuf( stateTo->data+i, stateTo->dataLength - i );
239      //NETPRINTF(0)("getvar %s %d\n", (*it)->getName().c_str(), n);
240      //PRINTF(0)("getvar %s %d\n", (*it)->getName().c_str(), n);
241      stateTo->sizeList.push_back( n );
242      // this is only for very hardcore debug sessions
243      // (*it)->debug();
244      i += n;
245    }
246    else
247    {
248      for ( int j = 0; j<(*sizeIter); j++ )
249      {
250        assert( i < stateFrom->dataLength );
251        stateTo->data[i] = stateFrom->data[i];
252        i++;
253      }
254      //NETPRINTF(0)("getvar %s %d\n", (*it)->getName().c_str(), *sizeIter);
255      stateTo->sizeList.push_back( (*sizeIter) );
256    }
257
258    if ( sizeIter != stateFrom->sizeList.end() )
259      sizeIter++;
260  }
261
262  if ( i != neededSize )
263  {
264    PRINTF(0)("strange error: (%s) %d != %d\n", this->getClassCName(), i, neededSize);
265    assert(false);
266  }
267
268  //write diff to data
269  for ( i = 0; i<neededSize; i++ )
270  {
271    if ( i < stateFrom->dataLength )
272      data[i] = stateTo->data[i] - stateFrom->data[i];
273    else
274      data[i] = stateTo->data[i];
275  }
276
277  return neededSize;
278}
279
280/**
281 * sets a new state out of a diff created on another host
282 * @param userId hostId of user who send me that diff
283 * @param data pointer to diff
284 * @param length length of diff
285 * @param stateId id of current state
286 * @param fromStateId id of the base state id
287 * @return number bytes read
288 *
289 * @todo check for permissions
290 */
291int Synchronizeable::setStateDiff( int userId, byte* data, int length, int stateId, int fromStateId )
292{
293  //make sure this user has his history
294  if ( recvStates.size() <= userId )
295    recvStates.resize( userId+1 );
296
297  //create new state
298  StateHistoryEntry * stateTo = new StateHistoryEntry();
299  stateTo->stateId = stateId;
300  stateTo->dataLength = length;
301  stateTo->data = new byte[ length ];
302
303
304  //find state to apply diff to
305  StateHistoryEntry * stateFrom = NULL;
306
307  // search the state from wich the diff is made of
308  StateHistory::iterator it = recvStates[userId].begin();
309  while ( it != recvStates[userId].end() && (*it)->stateId != fromStateId )
310    it++;
311
312  // if this is the first state to receive
313  if ( it == recvStates[userId].end() )
314  {
315    StateHistoryEntry * initialEntry = new StateHistoryEntry();
316
317    initialEntry->stateId = fromStateId;
318    initialEntry->dataLength = 0;
319    initialEntry->data = NULL;
320
321    stateFrom = initialEntry;
322
323    recvStates[userId].push_back( stateFrom );
324  }
325  else
326    stateFrom = (*it);
327
328
329  // apply diff
330  for ( int i = 0; i<length; i++ )
331  {
332    if ( i < stateFrom->dataLength )
333      stateTo->data[i] = stateFrom->data[i] + data[i];
334    else
335      stateTo->data[i] = data[i];
336  }
337
338  //add state to state history
339  recvStates[userId].push_back( stateTo );
340
341  int i = 0;
342  int n = 0;
343  std::list<int> changes;
344  bool hasPermission = false;
345
346  // extract the new state for every client
347  for ( SyncVarList::iterator it = syncVarList.begin(); it != syncVarList.end(); it++ )
348  {
349    // DATA PERMISSIONS
350    // check if this synchronizeable has the permissions to write the data
351
352    // first check MASTER_SERVER permissions
353    if(  this->networkStream->isUserMasterServer( userId ) && (*it)->checkPermission( PERMISSION_MASTER_SERVER ))
354      hasPermission = true;
355    // now check PROXY_SERVER permissions
356    else if( this->networkStream->isUserProxyServer( userId )  && (*it)->checkPermission( PERMISSION_MASTER_SERVER ))
357      hasPermission = true;
358    // now check OWNER permissions
359    else if( this->owner == userId && (*it)->checkPermission( PERMISSION_OWNER ))
360      hasPermission = true;
361    // now check ALL permissions
362    else if( (*it)->checkPermission( PERMISSION_ALL ))
363      hasPermission = true;
364    // SPECIAL: get write permissions if im sending to a master server that does not own this sync
365    else if( this->networkStream->isUserMasterServer( userId ) && this->owner != SharedNetworkData::getInstance()->getHostID() && (*it)->checkPermission( PERMISSION_OWNER ))
366      hasPermission = true;
367    // SPECIAL: get write permissions if im sending to a proxy server that does not own this sync
368    else if( this->networkStream->isUserProxyServer( userId )  && this->owner != SharedNetworkData::getInstance()->getHostID() && (*it)->checkPermission( PERMISSION_OWNER ))
369      hasPermission = true;
370    else
371      hasPermission = false;
372
373
374
375    // if it has the permission to write do it
376    if( hasPermission)
377    {
378      n = (*it)->readFromBuf( stateTo->data + i, stateTo->dataLength - i );
379      i += n;
380      //NETPRINTF(0)("%s::setvar %s %d\n", getClassCName(), (*it)->getName().c_str(), n);
381      //PRINTF(0)("%s::setvar %s %d\n", getClassCName(), (*it)->getName().c_str(), n);
382      //(*it)->debug();
383      if ( (*it)->getHasChanged() )
384      {
385        changes.push_back( (*it)->getVarId() );
386      }
387    }
388    else
389    {
390//      PRINTF(0)("DONT SET VAR BECAUSE OF PERMISSION: %s %d %d %d %d %d %d\n", (*it)->getName().c_str(), (*it)->checkPermission( PERMISSION_MASTER_SERVER ), (*it)->checkPermission( PERMISSION_OWNER ), (*it)->checkPermission( PERMISSION_ALL ), networkStream->isUserServer( userId ), this->owner, userId );
391      n = (*it)->getSizeFromBuf( stateTo->data + i, stateTo->dataLength - i );
392      //NETPRINTF(0)("%s::setvar %s %d\n", getClassCName(), (*it)->getName().c_str(), n);
393      //(*it)->debug();
394      i += n;
395    }
396  }
397
398  this->varChangeHandler( changes );
399
400  return i;
401}
402
403 /**
404 * override this function to be notified on change
405 * of your registred variables.
406 * @param id id's which have changed
407 */
408void Synchronizeable::varChangeHandler( std::list<int> & id )
409{
410}
411
412/**
413 * registers a varable to be synchronized over network
414 * @param var see src/lib/network/synchronizeable_var/ for available classes
415 */
416void Synchronizeable::registerVar( SynchronizeableVar * var )
417{
418  //PRINTF(0)("ADDING VAR: %s\n", var->getName().c_str());
419  syncVarList.push_back( var );
420}
421
422/**
423 * registers a varable to be synchronized over network
424 * return value is passed to varChangeHandler on change
425 * @param var see src/lib/network/synchronizeable_var/ for available classes
426 * @return handle passed to varChangeHandler on changes
427 */
428int Synchronizeable::registerVarId( SynchronizeableVar * var )
429{
430  //PRINTF(0)("ADDING VAR: %s\n", var->getName().c_str());
431  syncVarList.push_back( var );
432  var->setWatched( true );
433  var->setVarId( syncVarList.size()-1 );
434  return syncVarList.size()-1;
435}
436
437/**
438 * removed user's states from memory
439 * @param userId user to clean
440 */
441void Synchronizeable::cleanUpUser( int userId )
442{
443  if ( recvStates.size() > userId )
444  {
445    for ( std::list<StateHistoryEntry*>::iterator it = recvStates[userId].begin(); it != recvStates[userId].end(); it++ )
446    {
447      if ( (*it)->data )
448      {
449        delete [] (*it)->data;
450        (*it)->data = NULL;
451      }
452
453      delete *it;
454    }
455    recvStates[userId].clear();
456  }
457
458  if ( sentStates.size() > userId )
459  {
460
461    for ( std::list<StateHistoryEntry*>::iterator it = sentStates[userId].begin(); it != sentStates[userId].end(); it++ )
462    {
463      if ( (*it)->data )
464      {
465        delete [] (*it)->data;
466        (*it)->data = NULL;
467      }
468
469      delete *it;
470    }
471    sentStates[userId].clear();
472  }
473}
474
475/**
476 * this function is called after recieving a state.
477 * @param userId
478 * @param stateId
479 * @param fromStateId
480 */
481void Synchronizeable::handleRecvState( int userId, int stateId, int fromStateId )
482{
483   //make sure this user has his history
484  if ( recvStates.size() <= userId )
485    recvStates.resize( userId+1 );
486
487  //remove old states
488  StateHistory::iterator it = recvStates[userId].begin();
489
490#if 0
491  while ( it != recvStates[userId].end() && (*it)->stateId < fromStateId )
492    it++;
493
494  if ( it != recvStates[userId].begin() )
495  {
496    for ( StateHistory::iterator it2 = recvStates[userId].begin(); it2 != it; it2++ )
497    {
498      if ( (*it2)->data != NULL )
499      {
500        delete [] (*it2)->data;
501        (*it2)->data = NULL;
502      }
503    }
504    recvStates[userId].erase( recvStates[userId].begin(), it );
505  }
506#endif
507
508  for ( it = recvStates[userId].begin(); it != recvStates[userId].end();  )
509  {
510    if ( (*it)->stateId < fromStateId )
511    {
512      StateHistory::iterator delIt = it;
513      it ++;
514
515      if ( (*delIt)->data )
516      {
517        delete [] (*delIt)->data;
518        (*delIt)->data = NULL;
519      }
520      delete *delIt;
521      recvStates[userId].erase( delIt );
522
523      continue;
524    }
525    it++;
526  }
527
528  StateHistory::iterator fromState = recvStates[userId].end();
529  StateHistory::iterator toState = recvStates[userId].end();
530
531  for ( it = recvStates[userId].begin(); it != recvStates[userId].end(); it++ )
532  {
533    if ( (*it)->stateId == stateId )
534      toState = it;
535    if ( (*it)->stateId == fromStateId )
536      fromState = it;
537
538    if ( fromState != recvStates[userId].end() && toState != recvStates[userId].end() )
539      break;
540  }
541
542  // setStateDiff was not called and i know fromStateId
543  if ( fromState != recvStates[userId].end() && toState == recvStates[userId].end() )
544  {
545    StateHistoryEntry * entry = new StateHistoryEntry;
546
547    entry->dataLength = (*fromState)->dataLength;
548    if ( entry->dataLength > 0 )
549    {
550      entry->data = new byte[entry->dataLength];
551
552      assert( (*fromState)->data );
553      memcpy( entry->data, (*fromState)->data, entry->dataLength );
554    }
555    else
556      entry->data = NULL;
557
558    entry->sizeList = (*fromState)->sizeList;
559    entry->stateId = stateId;
560
561    recvStates[userId].push_back(entry);
562  }
563}
564
565/**
566 * this function is called after sending a state
567 * @param userId
568 * @param stateId
569 * @param fromStateId
570 */
571void Synchronizeable::handleSentState( int userId, int stateId, int fromStateId )
572{
573   //make sure this user has his history
574  if ( sentStates.size() <= userId )
575    sentStates.resize( userId+1 );
576
577   //remove old states
578  StateHistory::iterator it = sentStates[userId].begin();
579
580  for ( it = sentStates[userId].begin(); it != sentStates[userId].end();  )
581  {
582    if ( (*it)->stateId < fromStateId )
583    {
584      StateHistory::iterator delIt = it;
585      it ++;
586
587      if ( (*delIt)->data )
588      {
589        delete [] (*delIt)->data;
590        (*delIt)->data = NULL;
591      }
592      delete *delIt;
593      sentStates[userId].erase( delIt );
594
595      continue;
596    }
597    it++;
598  }
599
600
601  StateHistory::iterator fromState = sentStates[userId].end();
602  StateHistory::iterator toState = sentStates[userId].end();
603
604  for ( it = sentStates[userId].begin(); it != sentStates[userId].end(); it++ )
605  {
606    if ( (*it)->stateId == stateId )
607      toState = it;
608    if ( (*it)->stateId == fromStateId )
609      fromState = it;
610
611    if ( fromState != sentStates[userId].end() && toState != sentStates[userId].end() )
612      break;
613  }
614
615
616  // getStateDiff was not called and i know fromStateId
617  if ( fromState != sentStates[userId].end() && toState == sentStates[userId].end() )
618  {
619    StateHistoryEntry * entry = new StateHistoryEntry;
620
621    entry->dataLength = (*fromState)->dataLength;
622    if ( entry->dataLength > 0 )
623    {
624      entry->data = new byte[entry->dataLength];
625
626      assert( (*fromState)->data );
627      memcpy( entry->data, (*fromState)->data, entry->dataLength );
628    }
629    else
630      entry->data = NULL;
631
632    entry->sizeList = (*fromState)->sizeList;
633    entry->stateId = stateId;
634
635    sentStates[userId].push_back(entry);
636  }
637
638}
639
640
641
Note: See TracBrowser for help on using the repository browser.