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