nel/samples/net/udp/simlag.cpp

   1 // NeL - MMORPG Framework <http://dev.ryzom.com/projects/nel/>
   2 // Copyright (C) 2010  Winch Gate Property Limited
   3 //
   4 // This source file has been modified by the following contributors:
   5 // Copyright (C) 2016  Jan BOON (Kaetemi) <jan.boon@kaetemi.be>
   6 //
   7 // This program is free software: you can redistribute it and/or modify
   8 // it under the terms of the GNU Affero General Public License as
   9 // published by the Free Software Foundation, either version 3 of the
  10 // License, or (at your option) any later version.
  11 //
  12 // This program is distributed in the hope that it will be useful,
  13 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 // GNU Affero General Public License for more details.
  16 //
  17 // You should have received a copy of the GNU Affero General Public License
  18 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
  19
  20 //
  21 // Includes
  22 //
  23
  24 #include <string>
  25 #include <queue>
  26
  27 #include <nel/misc/types_nl.h>
  28 #include <nel/misc/debug.h>
  29
  30 #include <nel/net/udp_sock.h>
  31
  32 //
  33 // Using
  34 //
  35
  36 using namespace std;
  37
  38 using namespace NLMISC;
  39 using namespace NLNET;
  40
  41 //
  42 // Variables
  43 //
  44
  45 static uint32   Lag = 0;
  46 static uint8    PacketLoss = 0;
  47 static uint8    PacketDuplication = 0;
  48 static uint8    PacketDisordering = 0;
  49
  50 //
  51 // Class
  52 //
  53
  54 struct CBufferizedPacket
  55 {
  56         CBufferizedPacket (CUdpSock *client, const uint8 *packet, uint32 packetSize, uint32 delay, const CInetAddress *addr):
  57                 Client(client), PacketSize(packetSize), Time(CTime::getLocalTime()+delay)
  58         {
  59                 nlassert (packetSize > 0);
  60                 nlassert (packet != NULL);
  61                 nlassert (client != NULL);
  62
  63                 Packet = new uint8[packetSize];
  64                 memcpy (Packet, packet, packetSize);
  65
  66                 if (addr != NULL)
  67                 {
  68                         Addr = new CInetAddress;
  69                         *Addr = *addr;
  70                 }
  71                 else
  72                 {
  73                         Addr = NULL;
  74                 }
  75         }
  76
  77         ~CBufferizedPacket ()
  78         {
  79                 nlassert (Packet != NULL);
  80                 delete [] Packet;
  81                 Packet = NULL;
  82                 Client = NULL;
  83                 PacketSize = 0;
  84                 Time = 0;
  85                 if (Addr != NULL)
  86                         delete Addr;
  87         }
  88
  89         CUdpSock        *Client;
  90         uint8           *Packet;
  91         uint32           PacketSize;
  92         TTime            Time;
  93         CInetAddress    *Addr;
  94 };
  95
  96 //
  97 // Variables
  98 //
  99
 100 static queue<CBufferizedPacket*> BufferizedPackets;
 101
 102 //
 103 // Prototypes
 104 //
 105
 106 void sendUDPNow (CUdpSock *client, const uint8 *packet, uint32 packetSize, const CInetAddress *addr);
 107
 108 //
 109 // Functions
 110 //
 111
 112 void updateBufferizedPackets ()
 113 {
 114         TTime ct = CTime::getLocalTime ();
 115         while (!BufferizedPackets.empty())
 116         {
 117                 CBufferizedPacket *bp = BufferizedPackets.front ();
 118                 if (bp->Time <= ct)
 119                 {
 120                         // time to send the message
 121                         sendUDPNow (bp->Client, bp->Packet, bp->PacketSize, bp->Addr);
 122                         delete bp;
 123                         BufferizedPackets.pop ();
 124                 }
 125                 else
 126                 {
 127                         break;
 128                 }
 129         }
 130 }
 131
 132 void setSimlagValues (sint32 lag, sint8 packetLoss, sint8 packetDuplication, sint8 packetDisordering)
 133 {
 134         if (lag != -1) Lag = lag;
 135         if (packetLoss != -1) PacketLoss = packetLoss;
 136         if (packetDuplication != -1) PacketDuplication = packetDuplication;
 137         if (packetDisordering != -1) PacketDisordering = packetDisordering;
 138 }
 139
 140 void sendUDPNow (CUdpSock *client, const uint8 *packet, uint32 packetSize, const CInetAddress *addr)
 141 {
 142         if (addr == NULL)
 143                 client->send (packet, packetSize);
 144         else
 145                 client->sendTo (packet, packetSize, *addr);
 146
 147         uint32 packetNumber = *(uint32 *)packet;
 148 //      nlinfo ("time %" NL_I64 "u sending now packet %5u", CTime::getLocalTime (), packetNumber);
 149 }
 150
 151 void sendUDP (CUdpSock *client, const uint8 *packet, uint32 packetSize, const CInetAddress *addr)
 152 {
 153         nlassert (client != NULL);
 154         nlassert (packet != NULL);
 155         nlassert (packetSize > 0);
 156
 157         if ((float)rand()/(float)(RAND_MAX)*100.0f >= PacketLoss)
 158         {
 159                 sint32 lag = Lag /*+ (rand()%40) - 20*/;// void disordering
 160
 161                 if (lag > 100)
 162                 {
 163                         // send the packet later
 164
 165                         CBufferizedPacket *bp = new CBufferizedPacket (client, packet, packetSize, lag, addr);
 166
 167                         // duplicate the packet
 168                         if ((float)rand()/(float)(RAND_MAX)*100.0f < PacketDisordering && BufferizedPackets.size() > 0)
 169                         {
 170                                 CBufferizedPacket *bp2 = BufferizedPackets.back();
 171
 172                                 // exange the time
 173                                 TTime t = bp->Time;
 174                                 bp->Time = bp2->Time;
 175                                 bp2->Time = t;
 176
 177                                 // exange packet in the buffer
 178                                 BufferizedPackets.back() = bp;
 179                                 bp = bp2;
 180                         }
 181
 182                         BufferizedPackets.push (bp);
 183
 184                         // duplicate the packet
 185                         if ((float)rand()/(float)(RAND_MAX)*100.0f < PacketDuplication)
 186                         {
 187                                 CBufferizedPacket *bp = new CBufferizedPacket (client, packet, packetSize, lag, addr);
 188                                 BufferizedPackets.push (bp);
 189                         }
 190                 }
 191                 else
 192                 {
 193                         // send the packet NOW
 194
 195                         sendUDPNow (client, packet, packetSize, addr);
 196
 197                         // duplicate the packet
 198                         if ((float)rand()/(float)(RAND_MAX)*100.0f < PacketDuplication)
 199                         {
 200                                 sendUDPNow (client, packet, packetSize, addr);
 201                         }
 202                 }
 203         }
 204 }