enet/protocol.c

   1 /**
   2  @file  protocol.c
   3  @brief ENet protocol functions
   4 */
   5 #include <stdio.h>
   6 #include <string.h>
   7 #define ENET_BUILDING_LIB 1
   8 #include "enet/utility.h"
   9 #include "enet/memory.h"
  10 #include "enet/time.h"
  11 #include "enet/enet.h"
  12
  13 static enet_uint32 timeCurrent;
  14
  15 static int
  16 enet_protocol_dispatch_incoming_commands (ENetHost * host, ENetEvent * event)
  17 {
  18     ENetPeer * currentPeer = host -> lastServicedPeer;
  19     ENetChannel * channel;
  20
  21     do
  22     {
  23        ++ currentPeer;
  24
  25        if (currentPeer >= & host -> peers [host -> peerCount])
  26          currentPeer = host -> peers;
  27
  28        if (currentPeer -> state == ENET_PEER_STATE_ZOMBIE)
  29        {
  30            host -> recalculateBandwidthLimits = 1;
  31
  32            event -> type = ENET_EVENT_TYPE_DISCONNECT;
  33            event -> peer = currentPeer;
  34
  35            enet_peer_reset (currentPeer);
  36
  37            host -> lastServicedPeer = currentPeer;
  38
  39            return 1;
  40        }
  41
  42        if (currentPeer -> state != ENET_PEER_STATE_CONNECTED)
  43          continue;
  44
  45        for (channel = currentPeer -> channels;
  46             channel < & currentPeer -> channels [currentPeer -> channelCount];
  47             ++ channel)
  48        {
  49            if (enet_list_empty (& channel -> incomingReliableCommands) &&
  50                enet_list_empty (& channel -> incomingUnreliableCommands))
  51              continue;
  52
  53            event -> packet = enet_peer_receive (currentPeer, channel - currentPeer -> channels);
  54            if (event -> packet == NULL)
  55              continue;
  56
  57            event -> type = ENET_EVENT_TYPE_RECEIVE;
  58            event -> peer = currentPeer;
  59            event -> channelID = (enet_uint8) (channel - currentPeer -> channels);
  60
  61            host -> lastServicedPeer = currentPeer;
  62
  63            return 1;
  64        }
  65     } while (currentPeer != host -> lastServicedPeer);
  66
  67     return 0;
  68 }
  69
  70 static void
  71 enet_protocol_remove_sent_unreliable_commands (ENetPeer * peer)
  72 {
  73     ENetOutgoingCommand * outgoingCommand;
  74
  75     while (enet_list_empty (& peer -> sentUnreliableCommands) == 0)
  76     {
  77         outgoingCommand = (ENetOutgoingCommand *) enet_list_front (& peer -> sentUnreliableCommands);
  78
  79         enet_list_remove (& outgoingCommand -> outgoingCommandList);
  80
  81         if (outgoingCommand -> packet != NULL)
  82         {
  83            -- outgoingCommand -> packet -> referenceCount;
  84
  85            if (outgoingCommand -> packet -> referenceCount == 0)
  86              enet_packet_destroy (outgoingCommand -> packet);
  87         }
  88
  89         enet_free (outgoingCommand);
  90     }
  91 }
  92
  93 static ENetProtocolCommand
  94 enet_protocol_remove_sent_reliable_command (ENetPeer * peer, enet_uint32 reliableSequenceNumber, enet_uint8 channelID)
  95 {
  96     ENetOutgoingCommand * outgoingCommand;
  97     ENetListIterator currentCommand;
  98     ENetProtocolCommand commandNumber;
  99
 100     for (currentCommand = enet_list_begin (& peer -> sentReliableCommands);
 101          currentCommand != enet_list_end (& peer -> sentReliableCommands);
 102          currentCommand = enet_list_next (currentCommand))
 103     {
 104        outgoingCommand = (ENetOutgoingCommand *) currentCommand;
 105
 106        if (outgoingCommand -> reliableSequenceNumber == reliableSequenceNumber &&
 107            outgoingCommand -> command.header.channelID == channelID)
 108          break;
 109     }
 110
 111     if (currentCommand == enet_list_end (& peer -> sentReliableCommands))
 112       return ENET_PROTOCOL_COMMAND_NONE;
 113
 114     commandNumber = (ENetProtocolCommand) outgoingCommand -> command.header.command;
 115
 116     enet_list_remove (& outgoingCommand -> outgoingCommandList);
 117
 118     if (outgoingCommand -> packet != NULL)
 119     {
 120        peer -> reliableDataInTransit -= outgoingCommand -> fragmentLength;
 121
 122        -- outgoingCommand -> packet -> referenceCount;
 123
 124        if (outgoingCommand -> packet -> referenceCount == 0)
 125          enet_packet_destroy (outgoingCommand -> packet);
 126     }
 127
 128     enet_free (outgoingCommand);
 129
 130     if (enet_list_empty (& peer -> sentReliableCommands))
 131       return commandNumber;
 132
 133     outgoingCommand = (ENetOutgoingCommand *) enet_list_front (& peer -> sentReliableCommands);
 134
 135     peer -> nextTimeout = outgoingCommand -> sentTime + outgoingCommand -> roundTripTimeout;
 136
 137     return commandNumber;
 138 }
 139
 140 static ENetPeer *
 141 enet_protocol_handle_connect (ENetHost * host, const ENetProtocolHeader * header, const ENetProtocol * command)
 142 {
 143     enet_uint16 mtu;
 144     enet_uint32 windowSize;
 145     ENetChannel * channel;
 146     size_t channelCount;
 147     ENetPeer * currentPeer;
 148     ENetProtocol verifyCommand;
 149
 150     if (command -> header.commandLength < sizeof (ENetProtocolConnect))
 151       return NULL;
 152
 153     channelCount = ENET_NET_TO_HOST_32 (command -> connect.channelCount);
 154
 155     if (channelCount < ENET_PROTOCOL_MINIMUM_CHANNEL_COUNT ||
 156         channelCount > ENET_PROTOCOL_MAXIMUM_CHANNEL_COUNT)
 157       return NULL;
 158
 159     for (currentPeer = host -> peers;
 160          currentPeer < & host -> peers [host -> peerCount];
 161          ++ currentPeer)
 162     {
 163         if (currentPeer -> state != ENET_PEER_STATE_DISCONNECTED &&
 164             currentPeer -> address.host == host -> receivedAddress.host &&
 165             currentPeer -> address.port == host -> receivedAddress.port &&
 166             currentPeer -> challenge == header -> challenge)
 167           return NULL;
 168     }
 169
 170     for (currentPeer = host -> peers;
 171          currentPeer < & host -> peers [host -> peerCount];
 172          ++ currentPeer)
 173     {
 174         if (currentPeer -> state == ENET_PEER_STATE_DISCONNECTED)
 175           break;
 176     }
 177
 178     if (currentPeer >= & host -> peers [host -> peerCount])
 179       return NULL;
 180
 181     currentPeer -> state = ENET_PEER_STATE_ACKNOWLEDGING_CONNECT;
 182     currentPeer -> challenge = header -> challenge;
 183     currentPeer -> address = host -> receivedAddress;
 184     currentPeer -> outgoingPeerID = ENET_NET_TO_HOST_16 (command -> connect.outgoingPeerID);
 185     currentPeer -> incomingBandwidth = ENET_NET_TO_HOST_32 (command -> connect.incomingBandwidth);
 186     currentPeer -> outgoingBandwidth = ENET_NET_TO_HOST_32 (command -> connect.outgoingBandwidth);
 187     currentPeer -> packetThrottleInterval = ENET_NET_TO_HOST_32 (command -> connect.packetThrottleInterval);
 188     currentPeer -> packetThrottleAcceleration = ENET_NET_TO_HOST_32 (command -> connect.packetThrottleAcceleration);
 189     currentPeer -> packetThrottleDeceleration = ENET_NET_TO_HOST_32 (command -> connect.packetThrottleDeceleration);
 190     currentPeer -> channels = (ENetChannel *) enet_malloc (channelCount * sizeof (ENetChannel));
 191     currentPeer -> channelCount = channelCount;
 192
 193     for (channel = currentPeer -> channels;
 194          channel < & currentPeer -> channels [channelCount];
 195          ++ channel)
 196     {
 197         channel -> outgoingReliableSequenceNumber = 0;
 198         channel -> outgoingUnreliableSequenceNumber = 0;
 199         channel -> incomingReliableSequenceNumber = 0;
 200         channel -> incomingUnreliableSequenceNumber = 0;
 201
 202         enet_list_clear (& channel -> incomingReliableCommands);
 203         enet_list_clear (& channel -> incomingUnreliableCommands);
 204     }
 205
 206     mtu = ENET_NET_TO_HOST_16 (command -> connect.mtu);
 207
 208     if (mtu < ENET_PROTOCOL_MINIMUM_MTU)
 209       mtu = ENET_PROTOCOL_MINIMUM_MTU;
 210     else
 211     if (mtu > ENET_PROTOCOL_MAXIMUM_MTU)
 212       mtu = ENET_PROTOCOL_MAXIMUM_MTU;
 213
 214     currentPeer -> mtu = mtu;
 215
 216     if (host -> outgoingBandwidth == 0 &&
 217         currentPeer -> incomingBandwidth == 0)
 218       currentPeer -> windowSize = ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE;
 219     else
 220       currentPeer -> windowSize = (ENET_MIN (host -> outgoingBandwidth, currentPeer -> incomingBandwidth) /
 221                                     ENET_PEER_WINDOW_SIZE_SCALE) *
 222                                       ENET_PROTOCOL_MINIMUM_WINDOW_SIZE;
 223
 224     if (currentPeer -> windowSize < ENET_PROTOCOL_MINIMUM_WINDOW_SIZE)
 225       currentPeer -> windowSize = ENET_PROTOCOL_MINIMUM_WINDOW_SIZE;
 226     else
 227     if (currentPeer -> windowSize > ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE)
 228       currentPeer -> windowSize = ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE;
 229
 230     if (host -> incomingBandwidth == 0)
 231       windowSize = ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE;
 232     else
 233       windowSize = (host -> incomingBandwidth / ENET_PEER_WINDOW_SIZE_SCALE) *
 234                      ENET_PROTOCOL_MINIMUM_WINDOW_SIZE;
 235
 236     if (windowSize > ENET_NET_TO_HOST_32 (command -> connect.windowSize))
 237       windowSize = ENET_NET_TO_HOST_32 (command -> connect.windowSize);
 238
 239     if (windowSize < ENET_PROTOCOL_MINIMUM_WINDOW_SIZE)
 240       windowSize = ENET_PROTOCOL_MINIMUM_WINDOW_SIZE;
 241     else
 242     if (windowSize > ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE)
 243       windowSize = ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE;
 244
 245     verifyCommand.header.command = ENET_PROTOCOL_COMMAND_VERIFY_CONNECT;
 246     verifyCommand.header.channelID = 0xFF;
 247     verifyCommand.header.flags = ENET_PROTOCOL_FLAG_ACKNOWLEDGE;
 248     verifyCommand.header.commandLength = sizeof (ENetProtocolVerifyConnect);
 249     verifyCommand.verifyConnect.outgoingPeerID = ENET_HOST_TO_NET_16 (currentPeer -> incomingPeerID);
 250     verifyCommand.verifyConnect.mtu = ENET_HOST_TO_NET_16 (currentPeer -> mtu);
 251     verifyCommand.verifyConnect.windowSize = ENET_HOST_TO_NET_32 (windowSize);
 252     verifyCommand.verifyConnect.channelCount = ENET_HOST_TO_NET_32 (channelCount);
 253     verifyCommand.verifyConnect.incomingBandwidth = ENET_HOST_TO_NET_32 (host -> incomingBandwidth);
 254     verifyCommand.verifyConnect.outgoingBandwidth = ENET_HOST_TO_NET_32 (host -> outgoingBandwidth);
 255     verifyCommand.verifyConnect.packetThrottleInterval = ENET_HOST_TO_NET_32 (currentPeer -> packetThrottleInterval);
 256     verifyCommand.verifyConnect.packetThrottleAcceleration = ENET_HOST_TO_NET_32 (currentPeer -> packetThrottleAcceleration);
 257     verifyCommand.verifyConnect.packetThrottleDeceleration = ENET_HOST_TO_NET_32 (currentPeer -> packetThrottleDeceleration);
 258
 259     enet_peer_queue_outgoing_command (currentPeer, & verifyCommand, NULL, 0, 0);
 260
 261     return currentPeer;
 262 }
 263
 264 static void
 265 enet_protocol_handle_send_reliable (ENetHost * host, ENetPeer * peer, const ENetProtocol * command)
 266 {
 267     ENetPacket * packet;
 268
 269     if (command -> header.commandLength <= sizeof (ENetProtocolSendReliable) ||
 270         command -> header.channelID >= peer -> channelCount ||
 271         peer -> state != ENET_PEER_STATE_CONNECTED)
 272       return;
 273
 274     packet = enet_packet_create ((const enet_uint8 *) command + sizeof (ENetProtocolSendReliable),
 275                                  command -> header.commandLength - sizeof (ENetProtocolSendReliable),
 276                                  ENET_PACKET_FLAG_RELIABLE);
 277
 278     enet_peer_queue_incoming_command (peer, command, packet, 0);
 279 }
 280
 281 static void
 282 enet_protocol_handle_send_unreliable (ENetHost * host, ENetPeer * peer, const ENetProtocol * command)
 283 {
 284     ENetPacket * packet;
 285
 286     if (command -> header.commandLength <= sizeof (ENetProtocolSendUnreliable) ||
 287         command -> header.channelID >= peer -> channelCount ||
 288         peer -> state != ENET_PEER_STATE_CONNECTED)
 289       return;
 290
 291     packet = enet_packet_create ((const enet_uint8 *) command + sizeof (ENetProtocolSendUnreliable),
 292                                  command -> header.commandLength - sizeof (ENetProtocolSendUnreliable),
 293                                  0);
 294
 295     enet_peer_queue_incoming_command (peer, command, packet, 0);
 296 }
 297
 298 static void
 299 enet_protocol_handle_send_fragment (ENetHost * host, ENetPeer * peer, const ENetProtocol * command)
 300 {
 301     enet_uint32 fragmentNumber,
 302            fragmentCount,
 303            fragmentOffset,
 304            fragmentLength,
 305            startSequenceNumber,
 306            totalLength;
 307     ENetChannel * channel;
 308     ENetListIterator currentCommand;
 309     ENetIncomingCommand * startCommand;
 310
 311     if (command -> header.commandLength <= sizeof (ENetProtocolSendFragment) ||
 312         command -> header.channelID >= peer -> channelCount ||
 313         peer -> state != ENET_PEER_STATE_CONNECTED)
 314       return;
 315
 316     startSequenceNumber = ENET_NET_TO_HOST_32 (command -> sendFragment.startSequenceNumber);
 317     fragmentNumber = ENET_NET_TO_HOST_32 (command -> sendFragment.fragmentNumber);
 318     fragmentCount = ENET_NET_TO_HOST_32 (command -> sendFragment.fragmentCount);
 319     fragmentOffset = ENET_NET_TO_HOST_32 (command -> sendFragment.fragmentOffset);
 320     totalLength = ENET_NET_TO_HOST_32 (command -> sendFragment.totalLength);
 321     fragmentLength = command -> header.commandLength - sizeof (ENetProtocolSendFragment);
 322
 323     if (fragmentOffset >= totalLength ||
 324         fragmentOffset + fragmentLength > totalLength ||
 325         fragmentNumber >= fragmentCount)
 326       return;
 327
 328     channel = & peer -> channels [command -> header.channelID];
 329
 330     if (startSequenceNumber <= channel -> incomingReliableSequenceNumber)
 331       return;
 332
 333     for (currentCommand = enet_list_previous (enet_list_end (& channel -> incomingReliableCommands));
 334          currentCommand != enet_list_end (& channel -> incomingReliableCommands);
 335          currentCommand = enet_list_previous (currentCommand))
 336     {
 337        startCommand = (ENetIncomingCommand *) currentCommand;
 338
 339        if (startCommand -> command.header.command == ENET_PROTOCOL_COMMAND_SEND_FRAGMENT &&
 340            startCommand -> command.sendFragment.startSequenceNumber == startSequenceNumber)
 341          break;
 342     }
 343
 344     if (currentCommand == enet_list_end (& channel -> incomingReliableCommands))
 345     {
 346        ENetProtocol hostCommand = * command;
 347
 348        hostCommand.sendFragment.startSequenceNumber = startSequenceNumber;
 349        hostCommand.sendFragment.fragmentNumber = fragmentNumber;
 350        hostCommand.sendFragment.fragmentCount = fragmentCount;
 351        hostCommand.sendFragment.fragmentOffset = fragmentOffset;
 352        hostCommand.sendFragment.totalLength = totalLength;
 353
 354        startCommand = enet_peer_queue_incoming_command (peer,
 355                                                         & hostCommand,
 356                                                         enet_packet_create (NULL, totalLength, ENET_PACKET_FLAG_RELIABLE),
 357                                                         fragmentCount);
 358     }
 359     else
 360     if (totalLength != startCommand -> packet -> dataLength ||
 361         fragmentCount != startCommand -> fragmentCount)
 362       return;
 363
 364     if ((startCommand -> fragments [fragmentNumber / 32] & (1 << fragmentNumber)) == 0)
 365       -- startCommand -> fragmentsRemaining;
 366
 367     startCommand -> fragments [fragmentNumber / 32] |= (1 << fragmentNumber);
 368
 369     if (fragmentOffset + fragmentLength > startCommand -> packet -> dataLength)
 370       fragmentLength = startCommand -> packet -> dataLength - fragmentOffset;
 371
 372     memcpy (startCommand -> packet -> data + fragmentOffset,
 373             (enet_uint8 *) command + sizeof (ENetProtocolSendFragment),
 374             fragmentLength);
 375 }
 376
 377 static void
 378 enet_protocol_handle_ping (ENetHost * host, ENetPeer * peer, const ENetProtocol * command)
 379 {
 380     if (command -> header.commandLength < sizeof (ENetProtocolPing))
 381       return;
 382 }
 383
 384 static void
 385 enet_protocol_handle_bandwidth_limit (ENetHost * host, ENetPeer * peer, const ENetProtocol * command)
 386 {
 387     if (command -> header.commandLength < sizeof (ENetProtocolBandwidthLimit))
 388       return;
 389
 390     peer -> incomingBandwidth = ENET_NET_TO_HOST_32 (command -> bandwidthLimit.incomingBandwidth);
 391     peer -> outgoingBandwidth = ENET_NET_TO_HOST_32 (command -> bandwidthLimit.outgoingBandwidth);
 392
 393     if (peer -> incomingBandwidth == 0 &&
 394         host -> outgoingBandwidth == 0)
 395       peer -> windowSize = ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE;
 396     else
 397       peer -> windowSize = (ENET_MIN (peer -> incomingBandwidth, host -> outgoingBandwidth) /
 398                              ENET_PEER_WINDOW_SIZE_SCALE) * ENET_PROTOCOL_MINIMUM_WINDOW_SIZE;
 399
 400     if (peer -> windowSize < ENET_PROTOCOL_MINIMUM_WINDOW_SIZE)
 401       peer -> windowSize = ENET_PROTOCOL_MINIMUM_WINDOW_SIZE;
 402     else
 403     if (peer -> windowSize > ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE)
 404       peer -> windowSize = ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE;
 405 }
 406
 407 static void
 408 enet_protocol_handle_throttle_configure (ENetHost * host, ENetPeer * peer, const ENetProtocol * command)
 409 {
 410     if (command -> header.commandLength < sizeof (ENetProtocolThrottleConfigure))
 411       return;
 412
 413     peer -> packetThrottleInterval = ENET_NET_TO_HOST_32 (command -> throttleConfigure.packetThrottleInterval);
 414     peer -> packetThrottleAcceleration = ENET_NET_TO_HOST_32 (command -> throttleConfigure.packetThrottleAcceleration);
 415     peer -> packetThrottleDeceleration = ENET_NET_TO_HOST_32 (command -> throttleConfigure.packetThrottleDeceleration);
 416 }
 417
 418 static void
 419 enet_protocol_handle_disconnect (ENetHost * host, ENetPeer * peer, const ENetProtocol * command)
 420 {
 421     if (command -> header.commandLength < sizeof (ENetProtocolDisconnect))
 422       return;
 423
 424     enet_peer_reset_queues (peer);
 425
 426     if (peer -> state != ENET_PEER_STATE_CONNECTED)
 427       enet_peer_reset (peer);
 428     else
 429     if (command -> header.flags & ENET_PROTOCOL_FLAG_ACKNOWLEDGE)
 430       peer -> state = ENET_PEER_STATE_ACKNOWLEDGING_DISCONNECT;
 431     else
 432       peer -> state = ENET_PEER_STATE_ZOMBIE;
 433 }
 434
 435 static int
 436 enet_protocol_handle_acknowledge (ENetHost * host, ENetEvent * event, ENetPeer * peer, const ENetProtocol * command)
 437 {
 438     enet_uint32 roundTripTime,
 439            receivedSentTime,
 440            receivedReliableSequenceNumber;
 441     ENetProtocolCommand commandNumber;
 442
 443     if (command -> header.commandLength < sizeof (ENetProtocolAcknowledge))
 444       return 0;
 445
 446     receivedSentTime = ENET_NET_TO_HOST_32 (command -> acknowledge.receivedSentTime);
 447
 448     if (ENET_TIME_LESS (timeCurrent, receivedSentTime))
 449       return 0;
 450
 451     peer -> lastReceiveTime = timeCurrent;
 452
 453     roundTripTime = ENET_TIME_DIFFERENCE (timeCurrent, receivedSentTime);
 454
 455     enet_peer_throttle (peer, roundTripTime);
 456
 457     peer -> roundTripTimeVariance -= peer -> roundTripTimeVariance / 4;
 458
 459     if (roundTripTime >= peer -> roundTripTime)
 460     {
 461        peer -> roundTripTime += (roundTripTime - peer -> roundTripTime) / 8;
 462        peer -> roundTripTimeVariance += (roundTripTime - peer -> roundTripTime) / 4;
 463     }
 464     else
 465     {
 466        peer -> roundTripTime -= (peer -> roundTripTime - roundTripTime) / 8;
 467        peer -> roundTripTimeVariance += (peer -> roundTripTime - roundTripTime) / 4;
 468     }
 469
 470     if (peer -> roundTripTime < peer -> lowestRoundTripTime)
 471       peer -> lowestRoundTripTime = peer -> roundTripTime;
 472
 473     if (peer -> roundTripTimeVariance > peer -> highestRoundTripTimeVariance)
 474       peer -> highestRoundTripTimeVariance = peer -> roundTripTimeVariance;
 475
 476     if (peer -> packetThrottleEpoch == 0 ||
 477         ENET_TIME_DIFFERENCE(timeCurrent, peer -> packetThrottleEpoch) >= peer -> packetThrottleInterval)
 478     {
 479         peer -> lastRoundTripTime = peer -> lowestRoundTripTime;
 480         peer -> lastRoundTripTimeVariance = peer -> highestRoundTripTimeVariance;
 481         peer -> lowestRoundTripTime = peer -> roundTripTime;
 482         peer -> highestRoundTripTimeVariance = peer -> roundTripTimeVariance;
 483         peer -> packetThrottleEpoch = timeCurrent;
 484     }
 485
 486     receivedReliableSequenceNumber = ENET_NET_TO_HOST_32 (command -> acknowledge.receivedReliableSequenceNumber);
 487
 488     commandNumber = enet_protocol_remove_sent_reliable_command (peer, receivedReliableSequenceNumber, command -> header.channelID);
 489
 490     switch (peer -> state)
 491     {
 492     case ENET_PEER_STATE_ACKNOWLEDGING_CONNECT:
 493        if (commandNumber != ENET_PROTOCOL_COMMAND_VERIFY_CONNECT)
 494          return 0;
 495
 496        host -> recalculateBandwidthLimits = 1;
 497
 498        peer -> state = ENET_PEER_STATE_CONNECTED;
 499
 500        event -> type = ENET_EVENT_TYPE_CONNECT;
 501        event -> peer = peer;
 502
 503        return 1;
 504
 505     case ENET_PEER_STATE_DISCONNECTING:
 506        if (commandNumber != ENET_PROTOCOL_COMMAND_DISCONNECT)
 507          return 0;
 508
 509        host -> recalculateBandwidthLimits = 1;
 510
 511        event -> type = ENET_EVENT_TYPE_DISCONNECT;
 512        event -> peer = peer;
 513
 514        enet_peer_reset (peer);
 515
 516        return 1;
 517
 518     default:
 519        break;
 520     }
 521
 522     return 0;
 523 }
 524
 525 static void
 526 enet_protocol_handle_verify_connect (ENetHost * host, ENetEvent * event, ENetPeer * peer, const ENetProtocol * command)
 527 {
 528     enet_uint16 mtu;
 529     enet_uint32 windowSize;
 530
 531     if (command -> header.commandLength < sizeof (ENetProtocolVerifyConnect) ||
 532         peer -> state != ENET_PEER_STATE_CONNECTING)
 533       return;
 534
 535     if (ENET_NET_TO_HOST_32 (command -> verifyConnect.channelCount) != peer -> channelCount ||
 536         ENET_NET_TO_HOST_32 (command -> verifyConnect.packetThrottleInterval) != peer -> packetThrottleInterval ||
 537         ENET_NET_TO_HOST_32 (command -> verifyConnect.packetThrottleAcceleration) != peer -> packetThrottleAcceleration ||
 538         ENET_NET_TO_HOST_32 (command -> verifyConnect.packetThrottleDeceleration) != peer -> packetThrottleDeceleration)
 539     {
 540         peer -> state = ENET_PEER_STATE_ZOMBIE;
 541
 542         return;
 543     }
 544
 545     peer -> state = ENET_PEER_STATE_CONNECTED;
 546
 547     peer -> outgoingPeerID = ENET_NET_TO_HOST_16 (command -> verifyConnect.outgoingPeerID);
 548
 549     mtu = ENET_NET_TO_HOST_16 (command -> verifyConnect.mtu);
 550
 551     if (mtu < ENET_PROTOCOL_MINIMUM_MTU)
 552       mtu = ENET_PROTOCOL_MINIMUM_MTU;
 553     else
 554     if (mtu > ENET_PROTOCOL_MAXIMUM_MTU)
 555       mtu = ENET_PROTOCOL_MAXIMUM_MTU;
 556
 557     if (mtu < peer -> mtu)
 558       peer -> mtu = mtu;
 559
 560     windowSize = ENET_NET_TO_HOST_32 (command -> verifyConnect.windowSize);
 561
 562     if (windowSize < ENET_PROTOCOL_MINIMUM_WINDOW_SIZE)
 563       windowSize = ENET_PROTOCOL_MINIMUM_WINDOW_SIZE;
 564
 565     if (windowSize > ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE)
 566       windowSize = ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE;
 567
 568     if (windowSize < peer -> windowSize)
 569       peer -> windowSize = windowSize;
 570
 571     peer -> incomingBandwidth = ENET_NET_TO_HOST_32 (command -> verifyConnect.incomingBandwidth);
 572     peer -> outgoingBandwidth = ENET_NET_TO_HOST_32 (command -> verifyConnect.outgoingBandwidth);
 573
 574     host -> recalculateBandwidthLimits = 1;
 575
 576     peer -> state = ENET_PEER_STATE_CONNECTED;
 577
 578     event -> type = ENET_EVENT_TYPE_CONNECT;
 579     event -> peer = peer;
 580 }
 581
 582 static int
 583 enet_protocol_handle_incoming_commands (ENetHost * host, ENetEvent * event)
 584 {
 585     ENetProtocolHeader * header;
 586     ENetProtocol * command;
 587     ENetPeer * peer;
 588     enet_uint8 * currentData;
 589     size_t commandCount;
 590
 591     if (host -> receivedDataLength < sizeof (ENetProtocolHeader))
 592       return 0;
 593
 594     header = (ENetProtocolHeader *) host -> receivedData;
 595
 596     header -> peerID = ENET_NET_TO_HOST_16 (header -> peerID);
 597     header -> sentTime = ENET_NET_TO_HOST_32 (header -> sentTime);
 598
 599     if (header -> peerID == 0xFFFF)
 600       peer = NULL;
 601     else
 602     if (header -> peerID >= host -> peerCount)
 603       return 0;
 604     else
 605     {
 606        peer = & host -> peers [header -> peerID];
 607
 608        if (peer -> state == ENET_PEER_STATE_DISCONNECTED ||
 609            peer -> state == ENET_PEER_STATE_ZOMBIE ||
 610            host -> receivedAddress.host != peer -> address.host ||
 611            header -> challenge != peer -> challenge)
 612          return 0;
 613        else
 614          peer -> address.port = host -> receivedAddress.port;
 615     }
 616
 617     if (peer != NULL)
 618       peer -> incomingDataTotal += host -> receivedDataLength;
 619
 620     commandCount = header -> commandCount;
 621     currentData = host -> receivedData + sizeof (ENetProtocolHeader);
 622
 623     while (commandCount > 0 &&
 624            currentData < & host -> receivedData [host -> receivedDataLength])
 625     {
 626        command = (ENetProtocol *) currentData;
 627
 628        if (currentData + sizeof (ENetProtocolCommandHeader) > & host -> receivedData [host -> receivedDataLength])
 629          return 0;
 630
 631        command -> header.commandLength = ENET_NET_TO_HOST_32 (command -> header.commandLength);
 632
 633        if (currentData + command -> header.commandLength > & host -> receivedData [host -> receivedDataLength])
 634          return 0;
 635
 636        -- commandCount;
 637        currentData += command -> header.commandLength;
 638
 639        if (peer == NULL)
 640        {
 641           if (command -> header.command != ENET_PROTOCOL_COMMAND_CONNECT)
 642             return 0;
 643        }
 644
 645        command -> header.reliableSequenceNumber = ENET_NET_TO_HOST_32 (command -> header.reliableSequenceNumber);
 646
 647        switch (command -> header.command)
 648        {
 649        case ENET_PROTOCOL_COMMAND_ACKNOWLEDGE:
 650           enet_protocol_handle_acknowledge (host, event, peer, command);
 651
 652           break;
 653
 654        case ENET_PROTOCOL_COMMAND_CONNECT:
 655           peer = enet_protocol_handle_connect (host, header, command);
 656
 657           break;
 658
 659        case ENET_PROTOCOL_COMMAND_VERIFY_CONNECT:
 660           enet_protocol_handle_verify_connect (host, event, peer, command);
 661
 662           break;
 663
 664        case ENET_PROTOCOL_COMMAND_DISCONNECT:
 665           enet_protocol_handle_disconnect (host, peer, command);
 666
 667           break;
 668
 669        case ENET_PROTOCOL_COMMAND_PING:
 670           enet_protocol_handle_ping (host, peer, command);
 671
 672           break;
 673
 674        case ENET_PROTOCOL_COMMAND_SEND_RELIABLE:
 675           enet_protocol_handle_send_reliable (host, peer, command);
 676
 677           break;
 678
 679        case ENET_PROTOCOL_COMMAND_SEND_UNRELIABLE:
 680           enet_protocol_handle_send_unreliable (host, peer, command);
 681
 682           break;
 683
 684        case ENET_PROTOCOL_COMMAND_SEND_FRAGMENT:
 685           enet_protocol_handle_send_fragment (host, peer, command);
 686
 687           break;
 688
 689        case ENET_PROTOCOL_COMMAND_BANDWIDTH_LIMIT:
 690           enet_protocol_handle_bandwidth_limit (host, peer, command);
 691
 692           break;
 693
 694        case ENET_PROTOCOL_COMMAND_THROTTLE_CONFIGURE:
 695           enet_protocol_handle_throttle_configure (host, peer, command);
 696
 697           break;
 698
 699        default:
 700           break;
 701        }
 702
 703        if (peer != NULL &&
 704            (command -> header.flags & ENET_PROTOCOL_FLAG_ACKNOWLEDGE) != 0)
 705        {
 706            switch (peer -> state)
 707            {
 708            case ENET_PEER_STATE_DISCONNECTING:
 709               break;
 710
 711            case ENET_PEER_STATE_ACKNOWLEDGING_DISCONNECT:
 712               if (command -> header.command != ENET_PROTOCOL_COMMAND_DISCONNECT)
 713                 break;
 714
 715            default:
 716               enet_peer_queue_acknowledgement (peer, command, header -> sentTime);
 717
 718               break;
 719            }
 720        }
 721     }
 722
 723     if (event -> type != ENET_EVENT_TYPE_NONE)
 724       return 1;
 725
 726     return 0;
 727 }
 728
 729 static int
 730 enet_protocol_receive_incoming_commands (ENetHost * host, ENetEvent * event)
 731 {
 732     for (;;)
 733     {
 734        int receivedLength;
 735        ENetBuffer buffer;
 736
 737        buffer.data = host -> receivedData;
 738        buffer.dataLength = sizeof (host -> receivedData);
 739
 740        receivedLength = enet_socket_receive (host -> socket,
 741                                              & host -> receivedAddress,
 742                                              & buffer,
 743                                              1);
 744
 745        if (receivedLength < 0)
 746          return -1;
 747
 748        if (receivedLength == 0)
 749          return 0;
 750
 751        host -> receivedDataLength = receivedLength;
 752
 753        switch (enet_protocol_handle_incoming_commands (host, event))
 754        {
 755        case 1:
 756           return 1;
 757
 758        case -1:
 759           return -1;
 760
 761        default:
 762           break;
 763        }
 764     }
 765
 766     return -1;
 767 }
 768
 769 static void
 770 enet_protocol_send_acknowledgements (ENetHost * host, ENetPeer * peer)
 771 {
 772     ENetProtocol * command = & host -> commands [host -> commandCount];
 773     ENetBuffer * buffer = & host -> buffers [host -> bufferCount];
 774     ENetAcknowledgement * acknowledgement;
 775     ENetListIterator currentAcknowledgement;
 776
 777     currentAcknowledgement = enet_list_begin (& peer -> acknowledgements);
 778
 779     while (currentAcknowledgement != enet_list_end (& peer -> acknowledgements))
 780     {
 781        if (command >= & host -> commands [sizeof (host -> commands) / sizeof (ENetProtocol)] ||
 782            buffer >= & host -> buffers [sizeof (host -> buffers) / sizeof (ENetBuffer)] ||
 783            peer -> mtu - host -> packetSize < sizeof (ENetProtocolAcknowledge))
 784          break;
 785
 786        acknowledgement = (ENetAcknowledgement *) currentAcknowledgement;
 787
 788        if (peer -> state == ENET_PEER_STATE_ACKNOWLEDGING_DISCONNECT &&
 789            acknowledgement -> command.header.command != ENET_PROTOCOL_COMMAND_DISCONNECT)
 790          continue;
 791
 792        currentAcknowledgement = enet_list_next (currentAcknowledgement);
 793
 794        buffer -> data = command;
 795        buffer -> dataLength = sizeof (ENetProtocolAcknowledge);
 796
 797        host -> packetSize += buffer -> dataLength;
 798
 799        command -> header.command = ENET_PROTOCOL_COMMAND_ACKNOWLEDGE;
 800        command -> header.channelID = acknowledgement -> command.header.channelID;
 801        command -> header.flags = 0;
 802        command -> header.commandLength = ENET_HOST_TO_NET_32 (sizeof (ENetProtocolAcknowledge));
 803        command -> acknowledge.receivedReliableSequenceNumber = ENET_HOST_TO_NET_32 (acknowledgement -> command.header.reliableSequenceNumber);
 804        command -> acknowledge.receivedSentTime = ENET_HOST_TO_NET_32 (acknowledgement -> sentTime);
 805
 806        if (acknowledgement -> command.header.command == ENET_PROTOCOL_COMMAND_DISCONNECT)
 807          peer -> state = ENET_PEER_STATE_ZOMBIE;
 808
 809        enet_list_remove (& acknowledgement -> acknowledgementList);
 810        enet_free (acknowledgement);
 811
 812        ++ command;
 813        ++ buffer;
 814     }
 815
 816     host -> commandCount = command - host -> commands;
 817     host -> bufferCount = buffer - host -> buffers;
 818 }
 819
 820 static void
 821 enet_protocol_send_unreliable_outgoing_commands (ENetHost * host, ENetPeer * peer)
 822 {
 823     ENetProtocol * command = & host -> commands [host -> commandCount];
 824     ENetBuffer * buffer = & host -> buffers [host -> bufferCount];
 825     ENetOutgoingCommand * outgoingCommand;
 826     ENetListIterator currentCommand;
 827
 828     currentCommand = enet_list_begin (& peer -> outgoingUnreliableCommands);
 829
 830     while (currentCommand != enet_list_end (& peer -> outgoingUnreliableCommands))
 831     {
 832        outgoingCommand = (ENetOutgoingCommand *) currentCommand;
 833
 834        if (command >= & host -> commands [sizeof (host -> commands) / sizeof (ENetProtocol)] ||
 835            buffer + 1 >= & host -> buffers [sizeof (host -> buffers) / sizeof (ENetBuffer)] ||
 836            peer -> mtu - host -> packetSize < outgoingCommand -> command.header.commandLength ||
 837            (outgoingCommand -> packet != NULL &&
 838              peer -> mtu - host -> packetSize < outgoingCommand -> command.header.commandLength +
 839                                                          outgoingCommand -> packet -> dataLength))
 840          break;
 841
 842        currentCommand = enet_list_next (currentCommand);
 843
 844        if (outgoingCommand -> packet != NULL)
 845        {
 846           peer -> packetThrottleCounter += ENET_PEER_PACKET_THROTTLE_COUNTER;
 847           peer -> packetThrottleCounter %= ENET_PEER_PACKET_THROTTLE_SCALE;
 848
 849           if (peer -> packetThrottleCounter > peer -> packetThrottle)
 850           {
 851              -- outgoingCommand -> packet -> referenceCount;
 852
 853              if (outgoingCommand -> packet -> referenceCount == 0)
 854                enet_packet_destroy (outgoingCommand -> packet);
 855
 856              enet_list_remove (& outgoingCommand -> outgoingCommandList);
 857              enet_free (outgoingCommand);
 858
 859              continue;
 860           }
 861        }
 862
 863        buffer -> data = command;
 864        buffer -> dataLength = outgoingCommand -> command.header.commandLength;
 865
 866        host -> packetSize += buffer -> dataLength;
 867
 868        * command = outgoingCommand -> command;
 869
 870        enet_list_remove (& outgoingCommand -> outgoingCommandList);
 871
 872        if (outgoingCommand -> packet != NULL)
 873        {
 874           ++ buffer;
 875
 876           buffer -> data = outgoingCommand -> packet -> data;
 877           buffer -> dataLength = outgoingCommand -> packet -> dataLength;
 878
 879           command -> header.commandLength += buffer -> dataLength;
 880
 881           host -> packetSize += buffer -> dataLength;
 882
 883           enet_list_insert (enet_list_end (& peer -> sentUnreliableCommands), outgoingCommand);
 884        }
 885        else
 886          enet_free (outgoingCommand);
 887
 888        command -> header.commandLength = ENET_HOST_TO_NET_32 (command -> header.commandLength);
 889
 890        ++ command;
 891        ++ buffer;
 892     }
 893
 894     host -> commandCount = command - host -> commands;
 895     host -> bufferCount = buffer - host -> buffers;
 896 }
 897
 898 static int
 899 enet_protocol_check_timeouts (ENetHost * host, ENetPeer * peer, ENetEvent * event)
 900 {
 901     ENetOutgoingCommand * outgoingCommand;
 902     ENetListIterator currentCommand;
 903
 904     currentCommand = enet_list_begin (& peer -> sentReliableCommands);
 905
 906     while (currentCommand != enet_list_end (& peer -> sentReliableCommands))
 907     {
 908        outgoingCommand = (ENetOutgoingCommand *) currentCommand;
 909
 910        currentCommand = enet_list_next (currentCommand);
 911
 912        if (ENET_TIME_DIFFERENCE (timeCurrent, outgoingCommand -> sentTime) < outgoingCommand -> roundTripTimeout)
 913          continue;
 914
 915        if (outgoingCommand -> roundTripTimeout >= outgoingCommand -> roundTripTimeoutLimit)
 916        {
 917           event -> type = ENET_EVENT_TYPE_DISCONNECT;
 918           event -> peer = peer;
 919
 920           enet_peer_reset (peer);
 921
 922           return 1;
 923        }
 924
 925        if (outgoingCommand -> packet != NULL)
 926          peer -> reliableDataInTransit -= outgoingCommand -> fragmentLength;
 927
 928        ++ peer -> packetsLost;
 929
 930        outgoingCommand -> roundTripTimeout *= 2;
 931
 932        enet_list_insert (enet_list_begin (& peer -> outgoingReliableCommands),
 933                          enet_list_remove (& outgoingCommand -> outgoingCommandList));
 934
 935        if (currentCommand == enet_list_begin (& peer -> sentReliableCommands) &&
 936            enet_list_empty (& peer -> sentReliableCommands) == 0)
 937        {
 938           outgoingCommand = (ENetOutgoingCommand *) currentCommand;
 939
 940           peer -> nextTimeout = outgoingCommand -> sentTime + outgoingCommand -> roundTripTimeout;
 941        }
 942     }
 943
 944     return 0;
 945 }
 946
 947 static void
 948 enet_protocol_send_reliable_outgoing_commands (ENetHost * host, ENetPeer * peer)
 949 {
 950     ENetProtocol * command = & host -> commands [host -> commandCount];
 951     ENetBuffer * buffer = & host -> buffers [host -> bufferCount];
 952     ENetOutgoingCommand * outgoingCommand;
 953     ENetListIterator currentCommand;
 954
 955     currentCommand = enet_list_begin (& peer -> outgoingReliableCommands);
 956
 957     while (currentCommand != enet_list_end (& peer -> outgoingReliableCommands))
 958     {
 959        outgoingCommand = (ENetOutgoingCommand *) currentCommand;
 960
 961        if (command >= & host -> commands [sizeof (host -> commands) / sizeof (ENetProtocol)] ||
 962            buffer + 1 >= & host -> buffers [sizeof (host -> buffers) / sizeof (ENetBuffer)] ||
 963            peer -> mtu - host -> packetSize < outgoingCommand -> command.header.commandLength)
 964          break;
 965
 966        currentCommand = enet_list_next (currentCommand);
 967
 968        if (outgoingCommand -> packet != NULL)
 969        {
 970           if ((enet_uint16) (peer -> mtu - host -> packetSize) <
 971                 (enet_uint16) (outgoingCommand -> command.header.commandLength +
 972                            outgoingCommand -> fragmentLength) ||
 973               peer -> reliableDataInTransit + outgoingCommand -> fragmentLength > peer -> windowSize)
 974             break;
 975        }
 976
 977        if (outgoingCommand -> roundTripTimeout == 0)
 978        {
 979           outgoingCommand -> roundTripTimeout = peer -> roundTripTime + 4 * peer -> roundTripTimeVariance;
 980           outgoingCommand -> roundTripTimeoutLimit = ENET_PEER_TIMEOUT_LIMIT * outgoingCommand -> roundTripTimeout;
 981        }
 982
 983        if (enet_list_empty (& peer -> sentReliableCommands))
 984          peer -> nextTimeout = timeCurrent + outgoingCommand -> roundTripTimeout;
 985
 986        enet_list_insert (enet_list_end (& peer -> sentReliableCommands),
 987                          enet_list_remove (& outgoingCommand -> outgoingCommandList));
 988
 989        outgoingCommand -> sentTime = timeCurrent;
 990
 991        buffer -> data = command;
 992        buffer -> dataLength = outgoingCommand -> command.header.commandLength;
 993
 994        host -> packetSize += buffer -> dataLength;
 995
 996        * command = outgoingCommand -> command;
 997
 998        if (outgoingCommand -> packet != NULL)
 999        {
1000           ++ buffer;
1001
1002           buffer -> data = outgoingCommand -> packet -> data + outgoingCommand -> fragmentOffset;
1003           buffer -> dataLength = outgoingCommand -> fragmentLength;
1004
1005           command -> header.commandLength += outgoingCommand -> fragmentLength;
1006
1007           host -> packetSize += outgoingCommand -> fragmentLength;
1008
1009           peer -> reliableDataInTransit += outgoingCommand -> fragmentLength;
1010        }
1011
1012        command -> header.commandLength = ENET_HOST_TO_NET_32 (command -> header.commandLength);
1013
1014        ++ peer -> packetsSent;
1015
1016        ++ command;
1017        ++ buffer;
1018     }
1019
1020     host -> commandCount = command - host -> commands;
1021     host -> bufferCount = buffer - host -> buffers;
1022 }
1023
1024 static int
1025 enet_protocol_send_outgoing_commands (ENetHost * host, ENetEvent * event, int checkForTimeouts)
1026 {
1027     size_t packetsSent = 1;
1028     ENetProtocolHeader header;
1029     ENetPeer * currentPeer;
1030     int sentLength;
1031
1032     while (packetsSent > 0)
1033     for (currentPeer = host -> peers,
1034            packetsSent = 0;
1035          currentPeer < & host -> peers [host -> peerCount];
1036          ++ currentPeer)
1037     {
1038         if (currentPeer -> state == ENET_PEER_STATE_DISCONNECTED ||
1039             currentPeer -> state == ENET_PEER_STATE_ZOMBIE)
1040           continue;
1041
1042         host -> commandCount = 0;
1043         host -> bufferCount = 1;
1044         host -> packetSize = sizeof (ENetProtocolHeader);
1045
1046         if (enet_list_empty (& currentPeer -> acknowledgements) == 0)
1047           enet_protocol_send_acknowledgements (host, currentPeer);
1048
1049         if (host -> commandCount < sizeof (host -> commands) / sizeof (ENetProtocol))
1050         {
1051             if (checkForTimeouts != 0 &&
1052                 enet_list_empty (& currentPeer -> sentReliableCommands) == 0 &&
1053                 ENET_TIME_GREATER_EQUAL (timeCurrent, currentPeer -> nextTimeout) &&
1054                 enet_protocol_check_timeouts (host, currentPeer, event) == 1)
1055               return 1;
1056         }
1057         if (enet_list_empty (& currentPeer -> outgoingReliableCommands) == 0)
1058           enet_protocol_send_reliable_outgoing_commands (host, currentPeer);
1059         else
1060         if (enet_list_empty (& currentPeer -> sentReliableCommands) &&
1061             ENET_TIME_DIFFERENCE (timeCurrent, currentPeer -> lastReceiveTime) >= ENET_PEER_PING_INTERVAL &&
1062             currentPeer -> mtu - host -> packetSize >= sizeof (ENetProtocolPing))
1063         {
1064             enet_peer_ping (currentPeer);
1065             enet_protocol_send_reliable_outgoing_commands (host, currentPeer);
1066         }
1067
1068         if (host -> commandCount < sizeof (host -> commands) / sizeof (ENetProtocol) &&
1069             enet_list_empty (& currentPeer -> outgoingUnreliableCommands) == 0)
1070           enet_protocol_send_unreliable_outgoing_commands (host, currentPeer);
1071
1072         if (host -> commandCount == 0)
1073           continue;
1074
1075         if (currentPeer -> packetLossEpoch == 0)
1076           currentPeer -> packetLossEpoch = timeCurrent;
1077         else
1078         if (ENET_TIME_DIFFERENCE (timeCurrent, currentPeer -> packetLossEpoch) >= ENET_PEER_PACKET_LOSS_INTERVAL &&
1079             currentPeer -> packetsSent > 0)
1080         {
1081            enet_uint32 packetLoss = currentPeer -> packetsLost * ENET_PEER_PACKET_LOSS_SCALE / currentPeer -> packetsSent;
1082
1083 #ifdef ENET_DEBUG
1084 #ifdef WIN32
1085            printf ("peer %u: %f%%+-%f%% packet loss, %u+-%u ms round trip time, %f%% throttle, %u/%u outgoing, %u/%u incoming\n", currentPeer -> incomingPeerID, currentPeer -> packetLoss / (float) ENET_PEER_PACKET_LOSS_SCALE, currentPeer -> packetLossVariance / (float) ENET_PEER_PACKET_LOSS_SCALE, currentPeer -> roundTripTime, currentPeer -> roundTripTimeVariance, currentPeer -> packetThrottle / (float) ENET_PEER_PACKET_THROTTLE_SCALE, enet_list_size (& currentPeer -> outgoingReliableCommands), enet_list_size (& currentPeer -> outgoingUnreliableCommands), currentPeer -> channels != NULL ? enet_list_size (& currentPeer -> channels -> incomingReliableCommands) : 0, enet_list_size (& currentPeer -> channels -> incomingUnreliableCommands));
1086 #else
1087            fprintf (stderr, "peer %u: %f%%+-%f%% packet loss, %u+-%u ms round trip time, %f%% throttle, %u/%u outgoing, %u/%u incoming\n", currentPeer -> incomingPeerID, currentPeer -> packetLoss / (float) ENET_PEER_PACKET_LOSS_SCALE, currentPeer -> packetLossVariance / (float) ENET_PEER_PACKET_LOSS_SCALE, currentPeer -> roundTripTime, currentPeer -> roundTripTimeVariance, currentPeer -> packetThrottle / (float) ENET_PEER_PACKET_THROTTLE_SCALE, enet_list_size (& currentPeer -> outgoingReliableCommands), enet_list_size (& currentPeer -> outgoingUnreliableCommands), currentPeer -> channels != NULL ? enet_list_size (& currentPeer -> channels -> incomingReliableCommands) : 0, enet_list_size (& currentPeer -> channels -> incomingUnreliableCommands));
1088 #endif
1089 #endif
1090
1091            currentPeer -> packetLossVariance -= currentPeer -> packetLossVariance / 4;
1092
1093            if (packetLoss >= currentPeer -> packetLoss)
1094            {
1095               currentPeer -> packetLoss += (packetLoss - currentPeer -> packetLoss) / 8;
1096               currentPeer -> packetLossVariance += (packetLoss - currentPeer -> packetLoss) / 4;
1097            }
1098            else
1099            {
1100               currentPeer -> packetLoss -= (currentPeer -> packetLoss - packetLoss) / 8;
1101               currentPeer -> packetLossVariance += (currentPeer -> packetLoss - packetLoss) / 4;
1102            }
1103
1104            currentPeer -> packetLossEpoch = timeCurrent;
1105            currentPeer -> packetsSent = 0;
1106            currentPeer -> packetsLost = 0;
1107         }
1108
1109         header.peerID = ENET_HOST_TO_NET_16 (currentPeer -> outgoingPeerID);
1110         header.flags = 0;
1111         header.commandCount = host -> commandCount;
1112         header.sentTime = ENET_HOST_TO_NET_32 (timeCurrent);
1113         header.challenge = currentPeer -> challenge;
1114
1115         host -> buffers -> data = & header;
1116         host -> buffers -> dataLength = sizeof (ENetProtocolHeader);
1117
1118         currentPeer -> lastSendTime = timeCurrent;
1119
1120         ++ packetsSent;
1121
1122         sentLength = enet_socket_send (host -> socket, & currentPeer -> address, host -> buffers, host -> bufferCount);
1123
1124         enet_protocol_remove_sent_unreliable_commands (currentPeer);
1125
1126         if (sentLength < 0)
1127           return -1;
1128     }
1129
1130     return 0;
1131 }
1132
1133 /** Sends any queued packets on the host specified to its designated peers.
1134
1135     @param host   host to flush
1136     @remarks this function need only be used in circumstances where one wishes to send queued packets earlier than in a call to enet_host_service().
1137     @ingroup host
1138 */
1139 void
1140 enet_host_flush (ENetHost * host)
1141 {
1142     timeCurrent = enet_time_get ();
1143
1144     enet_protocol_send_outgoing_commands (host, NULL, 0);
1145 }
1146
1147 /** Waits for events on the host specified and shuttles packets between
1148     the host and its peers.
1149
1150     @param host    host to service
1151     @param event   an event structure where event details will be placed if one occurs
1152     @param timeout number of milliseconds that ENet should wait for events
1153     @retval > 1 if an event occurred within the specified time limit
1154     @retval 0 if no event occurred
1155     @retval < 1 on failure
1156     @remarks enet_host_service should be called fairly regularly for adequate performance
1157     @ingroup host
1158 */
1159 int
1160 enet_host_service (ENetHost * host, ENetEvent * event, enet_uint32 timeout)
1161 {
1162     enet_uint32 waitCondition;
1163
1164     event -> type = ENET_EVENT_TYPE_NONE;
1165     event -> peer = NULL;
1166     event -> packet = NULL;
1167
1168     switch (enet_protocol_dispatch_incoming_commands (host, event))
1169     {
1170     case 1:
1171        return 1;
1172
1173     case -1:
1174        perror ("Error dispatching incoming packets");
1175
1176        return -1;
1177
1178     default:
1179        break;
1180     }
1181
1182     timeCurrent = enet_time_get ();
1183
1184     timeout += timeCurrent;
1185
1186     do
1187     {
1188        if (ENET_TIME_DIFFERENCE (timeCurrent, host -> bandwidthThrottleEpoch) >= ENET_HOST_BANDWIDTH_THROTTLE_INTERVAL)
1189          enet_host_bandwidth_throttle (host);
1190
1191        switch (enet_protocol_send_outgoing_commands (host, event, 1))
1192        {
1193        case 1:
1194           return 1;
1195
1196        case -1:
1197           perror ("Error sending outgoing packets");
1198
1199           return -1;
1200
1201        default:
1202           break;
1203        }
1204
1205        switch (enet_protocol_receive_incoming_commands (host, event))
1206        {
1207        case 1:
1208           return 1;
1209
1210        case -1:
1211           perror ("Error receiving incoming packets");
1212
1213           return -1;
1214
1215        default:
1216           break;
1217        }
1218
1219        switch (enet_protocol_send_outgoing_commands (host, event, 1))
1220        {
1221        case 1:
1222           return 1;
1223
1224        case -1:
1225           perror ("Error sending outgoing packets");
1226
1227           return -1;
1228
1229        default:
1230           break;
1231        }
1232
1233        switch (enet_protocol_dispatch_incoming_commands (host, event))
1234        {
1235        case 1:
1236           return 1;
1237
1238        case -1:
1239           perror ("Error dispatching incoming packets");
1240
1241           return -1;
1242
1243        default:
1244           break;
1245        }
1246
1247        timeCurrent = enet_time_get ();
1248
1249        if (ENET_TIME_GREATER_EQUAL (timeCurrent, timeout))
1250          return 0;
1251
1252        waitCondition = ENET_SOCKET_WAIT_RECEIVE;
1253
1254        if (enet_socket_wait (host -> socket, & waitCondition, ENET_TIME_DIFFERENCE (timeout, timeCurrent)) != 0)
1255          return -1;
1256
1257        timeCurrent = enet_time_get ();
1258     } while (waitCondition == ENET_SOCKET_WAIT_RECEIVE);
1259
1260     return 0;
1261 }
1262