nel/src/net/udp_sim_sock.cpp

   1 // NeL - MMORPG Framework <http://dev.ryzom.com/projects/nel/>
   2 // Copyright (C) 2010  Winch Gate Property Limited
   3 //
   4 // This program is free software: you can redistribute it and/or modify
   5 // it under the terms of the GNU Affero General Public License as
   6 // published by the Free Software Foundation, either version 3 of the
   7 // License, or (at your option) any later version.
   8 //
   9 // This program is distributed in the hope that it will be useful,
  10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 // GNU Affero General Public License for more details.
  13 //
  14 // You should have received a copy of the GNU Affero General Public License
  15 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
  16
  17 #include "stdnet.h"
  18
  19 #include "nel/misc/config_file.h"
  20
  21 #include "nel/net/udp_sock.h"
  22 #include "nel/net/udp_sim_sock.h"
  23
  24 using namespace std;
  25 using namespace NLMISC;
  26
  27 namespace NLNET {
  28
  29 //
  30 // Class
  31 //
  32
  33 struct CBufferizedOutPacket
  34 {
  35         CBufferizedOutPacket (CUdpSock *client, const uint8 *packet, uint32 packetSize, uint32 delay, const CInetAddress *addr):
  36                 Client(client), PacketSize(packetSize), Time(CTime::getLocalTime()+delay)
  37         {
  38                 nlassert (packetSize > 0);
  39                 nlassert (packet != NULL);
  40                 nlassert (client != NULL);
  41
  42                 Packet = new uint8[packetSize];
  43                 memcpy (Packet, packet, packetSize);
  44
  45                 if (addr != NULL)
  46                 {
  47                         Addr = new CInetAddress;
  48                         *Addr = *addr;
  49                 }
  50                 else
  51                 {
  52                         Addr = NULL;
  53                 }
  54         }
  55
  56         ~CBufferizedOutPacket ()
  57         {
  58                 nlassert (Packet != NULL);
  59                 delete [] Packet;
  60                 Packet = NULL;
  61                 Client = NULL;
  62                 PacketSize = 0;
  63                 Time = 0;
  64                 if (Addr != NULL)
  65                         delete Addr;
  66         }
  67
  68         CUdpSock                *Client;
  69         uint8                   *Packet;
  70         uint32                   PacketSize;
  71         TTime                    Time;
  72         CInetAddress    *Addr;
  73 };
  74
  75
  76 //
  77 // Variables
  78 //
  79
  80 //queue<CBufferizedOutPacket*> CUdpSimSock::BufferizedOutPackets;
  81 //queue<CBufferizedOutPacket*> CUdpSimSock::BufferizedInPackets;
  82
  83 uint32  CUdpSimSock::_InLag = 0;
  84 uint8   CUdpSimSock::_InPacketLoss = 0;
  85
  86 uint32  CUdpSimSock::_OutLag = 0;
  87 uint8   CUdpSimSock::_OutPacketLoss = 0;
  88 uint8   CUdpSimSock::_OutPacketDuplication = 0;
  89 uint8   CUdpSimSock::_OutPacketDisordering = 0;
  90
  91 //
  92 // Functions
  93 //
  94
  95 void CUdpSimSock::sendUDPNow (const uint8 *buffer, uint32 len, const CInetAddress *addr)
  96 {
  97         if (addr == NULL)
  98                 UdpSock.send (buffer, len);
  99         else
 100                 UdpSock.sendTo (buffer, len, *addr);
 101 }
 102
 103 void CUdpSimSock::sendUDP (const uint8 *buffer, uint32& len, const CInetAddress *addr)
 104 {
 105         nlassert (buffer != NULL);
 106         nlassert (len > 0);
 107
 108         if ((float)rand()/(float)(RAND_MAX)*100.0f >= _OutPacketLoss)
 109         {
 110                 sint32 lag = _OutLag /*+ (rand()%40) - 20*/;// void disordering
 111
 112                 if (lag > 100)
 113                 {
 114                         // send the packet later
 115
 116                         CBufferizedOutPacket *bp = new CBufferizedOutPacket (&UdpSock, buffer, len, lag, addr);
 117
 118                         // duplicate the packet
 119                         if ((float)rand()/(float)(RAND_MAX)*100.0f < _OutPacketDisordering && !_BufferizedOutPackets.empty())
 120                         {
 121                                 CBufferizedOutPacket *bp2 = _BufferizedOutPackets.back();
 122
 123                                 // exange the time
 124                                 TTime t = bp->Time;
 125                                 bp->Time = bp2->Time;
 126                                 bp2->Time = t;
 127
 128                                 // exange packet in the buffer
 129                                 _BufferizedOutPackets.back() = bp;
 130                                 bp = bp2;
 131                         }
 132
 133                         _BufferizedOutPackets.push (bp);
 134
 135                         // duplicate the packet
 136                         if ((float)rand()/(float)(RAND_MAX)*100.0f < _OutPacketDuplication)
 137                         {
 138                                 CBufferizedOutPacket *bp = new CBufferizedOutPacket (&UdpSock, buffer, len, lag, addr);
 139                                 _BufferizedOutPackets.push (bp);
 140                         }
 141                 }
 142                 else
 143                 {
 144                         // send the packet NOW
 145
 146                         sendUDPNow (buffer, len, addr);
 147
 148                         // duplicate the packet
 149                         if ((float)rand()/(float)(RAND_MAX)*100.0f < _OutPacketDuplication)
 150                         {
 151                                 sendUDPNow (buffer, len, addr);
 152                         }
 153                 }
 154         }
 155 }
 156
 157
 158
 159 void CUdpSimSock::updateBufferizedPackets ()
 160 {
 161         TTime ct = CTime::getLocalTime ();
 162         while (!_BufferizedOutPackets.empty())
 163         {
 164                 CBufferizedOutPacket *bp = _BufferizedOutPackets.front ();
 165                 if (bp->Time <= ct)
 166                 {
 167                         // time to send the message
 168                         sendUDPNow (bp->Packet, bp->PacketSize, bp->Addr);
 169                         delete bp;
 170                         _BufferizedOutPackets.pop ();
 171                 }
 172                 else
 173                 {
 174                         break;
 175                 }
 176         }
 177 }
 178
 179 void                            cbSimVar (CConfigFile::CVar &var)
 180 {
 181              if (var.Name == "SimInLag") CUdpSimSock::_InLag = var.asInt ();
 182         else if (var.Name == "SimInPacketLost") CUdpSimSock::_InPacketLoss = uint8(var.asInt ());
 183         else if (var.Name == "SimOutLag") CUdpSimSock::_OutLag = var.asInt ();
 184         else if (var.Name == "SimOutPacketLost") CUdpSimSock::_OutPacketLoss = uint8(var.asInt ());
 185         else if (var.Name == "SimOutPacketDuplication") CUdpSimSock::_OutPacketDuplication = uint8(var.asInt ());
 186         else if (var.Name == "SimOutPacketDisordering") CUdpSimSock::_OutPacketDisordering = uint8(var.asInt ());
 187         else nlstop;
 188 }
 189
 190 void                            CUdpSimSock::setSimValues (NLMISC::CConfigFile &cf)
 191 {
 192         cf.setCallback ("SimInLag", cbSimVar);
 193         cf.setCallback ("SimInPacketLost", cbSimVar);
 194         cf.setCallback ("SimOutLag", cbSimVar);
 195         cf.setCallback ("SimOutPacketLost", cbSimVar);
 196         cf.setCallback ("SimOutPacketDuplication", cbSimVar);
 197         cf.setCallback ("SimOutPacketDisordering", cbSimVar);
 198
 199         CConfigFile::CVar *pv;
 200         pv = cf.getVarPtr("SimInLag");
 201         if( pv )
 202                 cbSimVar( *pv );
 203         pv = cf.getVarPtr("SimInPacketLost");
 204         if( pv )
 205                 cbSimVar( *pv );
 206         pv = cf.getVarPtr("SimOutLag");
 207         if( pv )
 208                 cbSimVar( *pv );
 209         pv = cf.getVarPtr("SimOutPacketLost");
 210         if( pv )
 211                 cbSimVar( *pv );
 212         pv = cf.getVarPtr("SimOutPacketDuplication");
 213         if( pv )
 214                 cbSimVar( *pv );
 215         pv = cf.getVarPtr("SimOutPacketDisordering");
 216         if( pv )
 217                 cbSimVar( *pv );
 218 }
 219
 220 void                            CUdpSimSock::connect( const CInetAddress& addr )
 221 {
 222         UdpSock.connect (addr);
 223 }
 224
 225 void                            CUdpSimSock::close()
 226 {
 227         UdpSock.close ();
 228 }
 229
 230 uint8 buffer [10000];
 231
 232 bool                            CUdpSimSock::dataAvailable ()
 233 {
 234         updateBufferizedPackets ();
 235
 236         if (_InLag > 0)
 237         {
 238                 while (UdpSock.dataAvailable ())
 239                 {
 240                         CInetAddress addr;
 241                         uint len = 10000;
 242                         UdpSock.receivedFrom (buffer, len, addr);
 243
 244                         if ((float)rand()/(float)(RAND_MAX)*100.0f >= _InPacketLoss)
 245                         {
 246                                 CBufferizedOutPacket *bp = new CBufferizedOutPacket (&UdpSock, buffer, len, _InLag, &addr);
 247                                 _BufferizedInPackets.push (bp);
 248                         }
 249                 }
 250
 251                 TTime ct = CTime::getLocalTime ();
 252                 if (!_BufferizedInPackets.empty() && _BufferizedInPackets.front ()->Time <= ct)
 253                         return true;
 254                 else
 255                         return false;
 256         }
 257         else
 258         {
 259                 if ((float)rand()/(float)(RAND_MAX)*100.0f >= _InPacketLoss)
 260                 {
 261                         return UdpSock.dataAvailable ();
 262                 }
 263                 else
 264                 {
 265                         // consume data
 266                         if (UdpSock.dataAvailable ())
 267                         {
 268                                 CInetAddress addr;
 269                                 uint len = 10000;
 270                                 UdpSock.receivedFrom (buffer, len, addr);
 271                         }
 272
 273                         // packet lost
 274                         return false;
 275                 }
 276         }
 277 }
 278
 279 bool                            CUdpSimSock::receive (uint8 *buffer, uint32& len, bool throw_exception)
 280 {
 281         if (_InLag> 0)
 282         {
 283                 if (_BufferizedInPackets.empty())
 284                 {
 285                         if (throw_exception)
 286                                 throw Exception ("no data available");
 287                         return false;
 288                 }
 289
 290                 CBufferizedOutPacket *bp = _BufferizedInPackets.front ();
 291                 uint32 s = min (len, bp->PacketSize);
 292                 memcpy (buffer, bp->Packet, s);
 293                 len = s;
 294
 295                 delete bp;
 296                 _BufferizedInPackets.pop ();
 297                 return true;
 298         }
 299         else
 300         {
 301                 return UdpSock.receive(buffer, len, throw_exception);
 302         }
 303 }
 304
 305 CSock::TSockResult      CUdpSimSock::send (const uint8 *buffer, uint32& len, bool /* throw_exception */)
 306 {
 307         sendUDP (buffer, len);
 308         return CSock::Ok;
 309 }
 310
 311 void CUdpSimSock::sendTo (const uint8 *buffer, uint32& len, const CInetAddress& addr)
 312 {
 313         sendUDP (buffer, len, &addr);
 314 }
 315
 316 bool                            CUdpSimSock::connected()
 317 {
 318         return UdpSock.connected ();
 319 }
 320
 321 } // NLNET