host.c 17 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492
  1. /**
  2. @file host.c
  3. @brief ENet host management functions
  4. */
  5. #define ENET_BUILDING_LIB 1
  6. #include <string.h>
  7. #include <time.h>
  8. #include "enet/enet.h"
  9. /** @defgroup host ENet host functions
  10. @{
  11. */
  12. /** Creates a host for communicating to peers.
  13. @param address the address at which other peers may connect to this host. If NULL, then no peers may connect to the host.
  14. @param peerCount the maximum number of peers that should be allocated for the host.
  15. @param channelLimit the maximum number of channels allowed; if 0, then this is equivalent to ENET_PROTOCOL_MAXIMUM_CHANNEL_COUNT
  16. @param incomingBandwidth downstream bandwidth of the host in bytes/second; if 0, ENet will assume unlimited bandwidth.
  17. @param outgoingBandwidth upstream bandwidth of the host in bytes/second; if 0, ENet will assume unlimited bandwidth.
  18. @returns the host on success and NULL on failure
  19. @remarks ENet will strategically drop packets on specific sides of a connection between hosts
  20. to ensure the host's bandwidth is not overwhelmed. The bandwidth parameters also determine
  21. the window size of a connection which limits the amount of reliable packets that may be in transit
  22. at any given time.
  23. */
  24. ENetHost *
  25. enet_host_create (const ENetAddress * address, size_t peerCount, size_t channelLimit, enet_uint32 incomingBandwidth, enet_uint32 outgoingBandwidth)
  26. {
  27. ENetHost * host;
  28. ENetPeer * currentPeer;
  29. if (peerCount > ENET_PROTOCOL_MAXIMUM_PEER_ID)
  30. return NULL;
  31. host = (ENetHost *) enet_malloc (sizeof (ENetHost));
  32. if (host == NULL)
  33. return NULL;
  34. memset (host, 0, sizeof (ENetHost));
  35. host -> peers = (ENetPeer *) enet_malloc (peerCount * sizeof (ENetPeer));
  36. if (host -> peers == NULL)
  37. {
  38. enet_free (host);
  39. return NULL;
  40. }
  41. memset (host -> peers, 0, peerCount * sizeof (ENetPeer));
  42. host -> socket = enet_socket_create (ENET_SOCKET_TYPE_DATAGRAM);
  43. if (host -> socket == ENET_SOCKET_NULL || (address != NULL && enet_socket_bind (host -> socket, address) < 0))
  44. {
  45. if (host -> socket != ENET_SOCKET_NULL)
  46. enet_socket_destroy (host -> socket);
  47. enet_free (host -> peers);
  48. enet_free (host);
  49. return NULL;
  50. }
  51. enet_socket_set_option (host -> socket, ENET_SOCKOPT_NONBLOCK, 1);
  52. enet_socket_set_option (host -> socket, ENET_SOCKOPT_BROADCAST, 1);
  53. enet_socket_set_option (host -> socket, ENET_SOCKOPT_RCVBUF, ENET_HOST_RECEIVE_BUFFER_SIZE);
  54. enet_socket_set_option (host -> socket, ENET_SOCKOPT_SNDBUF, ENET_HOST_SEND_BUFFER_SIZE);
  55. if (address != NULL)
  56. host -> address = * address;
  57. if (! channelLimit || channelLimit > ENET_PROTOCOL_MAXIMUM_CHANNEL_COUNT)
  58. channelLimit = ENET_PROTOCOL_MAXIMUM_CHANNEL_COUNT;
  59. else
  60. if (channelLimit < ENET_PROTOCOL_MINIMUM_CHANNEL_COUNT)
  61. channelLimit = ENET_PROTOCOL_MINIMUM_CHANNEL_COUNT;
  62. host -> randomSeed = (enet_uint32) (size_t) host;
  63. #ifdef WIN32
  64. host -> randomSeed += (enet_uint32) timeGetTime();
  65. #else
  66. host -> randomSeed += (enet_uint32) time(NULL);
  67. #endif
  68. host -> randomSeed = (host -> randomSeed << 16) | (host -> randomSeed >> 16);
  69. host -> channelLimit = channelLimit;
  70. host -> incomingBandwidth = incomingBandwidth;
  71. host -> outgoingBandwidth = outgoingBandwidth;
  72. host -> bandwidthThrottleEpoch = 0;
  73. host -> recalculateBandwidthLimits = 0;
  74. host -> mtu = ENET_HOST_DEFAULT_MTU;
  75. host -> peerCount = peerCount;
  76. host -> commandCount = 0;
  77. host -> bufferCount = 0;
  78. host -> checksum = NULL;
  79. host -> receivedAddress.host = ENET_HOST_ANY;
  80. host -> receivedAddress.port = 0;
  81. host -> receivedData = NULL;
  82. host -> receivedDataLength = 0;
  83. host -> totalSentData = 0;
  84. host -> totalSentPackets = 0;
  85. host -> totalReceivedData = 0;
  86. host -> totalReceivedPackets = 0;
  87. host -> compressor.context = NULL;
  88. host -> compressor.compress = NULL;
  89. host -> compressor.decompress = NULL;
  90. host -> compressor.destroy = NULL;
  91. host -> intercept = NULL;
  92. enet_list_clear (& host -> dispatchQueue);
  93. for (currentPeer = host -> peers;
  94. currentPeer < & host -> peers [host -> peerCount];
  95. ++ currentPeer)
  96. {
  97. currentPeer -> host = host;
  98. currentPeer -> incomingPeerID = currentPeer - host -> peers;
  99. currentPeer -> outgoingSessionID = currentPeer -> incomingSessionID = 0xFF;
  100. currentPeer -> data = NULL;
  101. enet_list_clear (& currentPeer -> acknowledgements);
  102. enet_list_clear (& currentPeer -> sentReliableCommands);
  103. enet_list_clear (& currentPeer -> sentUnreliableCommands);
  104. enet_list_clear (& currentPeer -> outgoingReliableCommands);
  105. enet_list_clear (& currentPeer -> outgoingUnreliableCommands);
  106. enet_list_clear (& currentPeer -> dispatchedCommands);
  107. enet_peer_reset (currentPeer);
  108. }
  109. return host;
  110. }
  111. /** Destroys the host and all resources associated with it.
  112. @param host pointer to the host to destroy
  113. */
  114. void
  115. enet_host_destroy (ENetHost * host)
  116. {
  117. ENetPeer * currentPeer;
  118. if (host == NULL)
  119. return;
  120. enet_socket_destroy (host -> socket);
  121. for (currentPeer = host -> peers;
  122. currentPeer < & host -> peers [host -> peerCount];
  123. ++ currentPeer)
  124. {
  125. enet_peer_reset (currentPeer);
  126. }
  127. if (host -> compressor.context != NULL && host -> compressor.destroy)
  128. (* host -> compressor.destroy) (host -> compressor.context);
  129. enet_free (host -> peers);
  130. enet_free (host);
  131. }
  132. /** Initiates a connection to a foreign host.
  133. @param host host seeking the connection
  134. @param address destination for the connection
  135. @param channelCount number of channels to allocate
  136. @param data user data supplied to the receiving host
  137. @returns a peer representing the foreign host on success, NULL on failure
  138. @remarks The peer returned will have not completed the connection until enet_host_service()
  139. notifies of an ENET_EVENT_TYPE_CONNECT event for the peer.
  140. */
  141. ENetPeer *
  142. enet_host_connect (ENetHost * host, const ENetAddress * address, size_t channelCount, enet_uint32 data)
  143. {
  144. ENetPeer * currentPeer;
  145. ENetChannel * channel;
  146. ENetProtocol command;
  147. if (channelCount < ENET_PROTOCOL_MINIMUM_CHANNEL_COUNT)
  148. channelCount = ENET_PROTOCOL_MINIMUM_CHANNEL_COUNT;
  149. else
  150. if (channelCount > ENET_PROTOCOL_MAXIMUM_CHANNEL_COUNT)
  151. channelCount = ENET_PROTOCOL_MAXIMUM_CHANNEL_COUNT;
  152. for (currentPeer = host -> peers;
  153. currentPeer < & host -> peers [host -> peerCount];
  154. ++ currentPeer)
  155. {
  156. if (currentPeer -> state == ENET_PEER_STATE_DISCONNECTED)
  157. break;
  158. }
  159. if (currentPeer >= & host -> peers [host -> peerCount])
  160. return NULL;
  161. currentPeer -> channels = (ENetChannel *) enet_malloc (channelCount * sizeof (ENetChannel));
  162. if (currentPeer -> channels == NULL)
  163. return NULL;
  164. currentPeer -> channelCount = channelCount;
  165. currentPeer -> state = ENET_PEER_STATE_CONNECTING;
  166. currentPeer -> address = * address;
  167. currentPeer -> connectID = ++ host -> randomSeed;
  168. if (host -> outgoingBandwidth == 0)
  169. currentPeer -> windowSize = ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE;
  170. else
  171. currentPeer -> windowSize = (host -> outgoingBandwidth /
  172. ENET_PEER_WINDOW_SIZE_SCALE) *
  173. ENET_PROTOCOL_MINIMUM_WINDOW_SIZE;
  174. if (currentPeer -> windowSize < ENET_PROTOCOL_MINIMUM_WINDOW_SIZE)
  175. currentPeer -> windowSize = ENET_PROTOCOL_MINIMUM_WINDOW_SIZE;
  176. else
  177. if (currentPeer -> windowSize > ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE)
  178. currentPeer -> windowSize = ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE;
  179. for (channel = currentPeer -> channels;
  180. channel < & currentPeer -> channels [channelCount];
  181. ++ channel)
  182. {
  183. channel -> outgoingReliableSequenceNumber = 0;
  184. channel -> outgoingUnreliableSequenceNumber = 0;
  185. channel -> incomingReliableSequenceNumber = 0;
  186. channel -> incomingUnreliableSequenceNumber = 0;
  187. enet_list_clear (& channel -> incomingReliableCommands);
  188. enet_list_clear (& channel -> incomingUnreliableCommands);
  189. channel -> usedReliableWindows = 0;
  190. memset (channel -> reliableWindows, 0, sizeof (channel -> reliableWindows));
  191. }
  192. command.header.command = ENET_PROTOCOL_COMMAND_CONNECT | ENET_PROTOCOL_COMMAND_FLAG_ACKNOWLEDGE;
  193. command.header.channelID = 0xFF;
  194. command.connect.outgoingPeerID = ENET_HOST_TO_NET_16 (currentPeer -> incomingPeerID);
  195. command.connect.incomingSessionID = currentPeer -> incomingSessionID;
  196. command.connect.outgoingSessionID = currentPeer -> outgoingSessionID;
  197. command.connect.mtu = ENET_HOST_TO_NET_32 (currentPeer -> mtu);
  198. command.connect.windowSize = ENET_HOST_TO_NET_32 (currentPeer -> windowSize);
  199. command.connect.channelCount = ENET_HOST_TO_NET_32 (channelCount);
  200. command.connect.incomingBandwidth = ENET_HOST_TO_NET_32 (host -> incomingBandwidth);
  201. command.connect.outgoingBandwidth = ENET_HOST_TO_NET_32 (host -> outgoingBandwidth);
  202. command.connect.packetThrottleInterval = ENET_HOST_TO_NET_32 (currentPeer -> packetThrottleInterval);
  203. command.connect.packetThrottleAcceleration = ENET_HOST_TO_NET_32 (currentPeer -> packetThrottleAcceleration);
  204. command.connect.packetThrottleDeceleration = ENET_HOST_TO_NET_32 (currentPeer -> packetThrottleDeceleration);
  205. command.connect.connectID = currentPeer -> connectID;
  206. command.connect.data = ENET_HOST_TO_NET_32 (data);
  207. enet_peer_queue_outgoing_command (currentPeer, & command, NULL, 0, 0);
  208. return currentPeer;
  209. }
  210. /** Queues a packet to be sent to all peers associated with the host.
  211. @param host host on which to broadcast the packet
  212. @param channelID channel on which to broadcast
  213. @param packet packet to broadcast
  214. */
  215. void
  216. enet_host_broadcast (ENetHost * host, enet_uint8 channelID, ENetPacket * packet)
  217. {
  218. ENetPeer * currentPeer;
  219. for (currentPeer = host -> peers;
  220. currentPeer < & host -> peers [host -> peerCount];
  221. ++ currentPeer)
  222. {
  223. if (currentPeer -> state != ENET_PEER_STATE_CONNECTED)
  224. continue;
  225. enet_peer_send (currentPeer, channelID, packet);
  226. }
  227. if (packet -> referenceCount == 0)
  228. enet_packet_destroy (packet);
  229. }
  230. /** Sets the packet compressor the host should use to compress and decompress packets.
  231. @param host host to enable or disable compression for
  232. @param compressor callbacks for for the packet compressor; if NULL, then compression is disabled
  233. */
  234. void
  235. enet_host_compress (ENetHost * host, const ENetCompressor * compressor)
  236. {
  237. if (host -> compressor.context != NULL && host -> compressor.destroy)
  238. (* host -> compressor.destroy) (host -> compressor.context);
  239. if (compressor)
  240. host -> compressor = * compressor;
  241. else
  242. host -> compressor.context = NULL;
  243. }
  244. /** Limits the maximum allowed channels of future incoming connections.
  245. @param host host to limit
  246. @param channelLimit the maximum number of channels allowed; if 0, then this is equivalent to ENET_PROTOCOL_MAXIMUM_CHANNEL_COUNT
  247. */
  248. void
  249. enet_host_channel_limit (ENetHost * host, size_t channelLimit)
  250. {
  251. if (! channelLimit || channelLimit > ENET_PROTOCOL_MAXIMUM_CHANNEL_COUNT)
  252. channelLimit = ENET_PROTOCOL_MAXIMUM_CHANNEL_COUNT;
  253. else
  254. if (channelLimit < ENET_PROTOCOL_MINIMUM_CHANNEL_COUNT)
  255. channelLimit = ENET_PROTOCOL_MINIMUM_CHANNEL_COUNT;
  256. host -> channelLimit = channelLimit;
  257. }
  258. /** Adjusts the bandwidth limits of a host.
  259. @param host host to adjust
  260. @param incomingBandwidth new incoming bandwidth
  261. @param outgoingBandwidth new outgoing bandwidth
  262. @remarks the incoming and outgoing bandwidth parameters are identical in function to those
  263. specified in enet_host_create().
  264. */
  265. void
  266. enet_host_bandwidth_limit (ENetHost * host, enet_uint32 incomingBandwidth, enet_uint32 outgoingBandwidth)
  267. {
  268. host -> incomingBandwidth = incomingBandwidth;
  269. host -> outgoingBandwidth = outgoingBandwidth;
  270. host -> recalculateBandwidthLimits = 1;
  271. }
  272. void
  273. enet_host_bandwidth_throttle (ENetHost * host)
  274. {
  275. enet_uint32 timeCurrent = enet_time_get (),
  276. elapsedTime = timeCurrent - host -> bandwidthThrottleEpoch,
  277. peersTotal = 0,
  278. dataTotal = 0,
  279. peersRemaining,
  280. bandwidth,
  281. throttle = 0,
  282. bandwidthLimit = 0;
  283. int needsAdjustment;
  284. ENetPeer * peer;
  285. ENetProtocol command;
  286. if (elapsedTime < ENET_HOST_BANDWIDTH_THROTTLE_INTERVAL)
  287. return;
  288. for (peer = host -> peers;
  289. peer < & host -> peers [host -> peerCount];
  290. ++ peer)
  291. {
  292. if (peer -> state != ENET_PEER_STATE_CONNECTED && peer -> state != ENET_PEER_STATE_DISCONNECT_LATER)
  293. continue;
  294. ++ peersTotal;
  295. dataTotal += peer -> outgoingDataTotal;
  296. }
  297. if (peersTotal == 0)
  298. return;
  299. peersRemaining = peersTotal;
  300. needsAdjustment = 1;
  301. if (host -> outgoingBandwidth == 0)
  302. bandwidth = ~0;
  303. else
  304. bandwidth = (host -> outgoingBandwidth * elapsedTime) / 1000;
  305. while (peersRemaining > 0 && needsAdjustment != 0)
  306. {
  307. needsAdjustment = 0;
  308. if (dataTotal < bandwidth)
  309. throttle = ENET_PEER_PACKET_THROTTLE_SCALE;
  310. else
  311. throttle = (bandwidth * ENET_PEER_PACKET_THROTTLE_SCALE) / dataTotal;
  312. for (peer = host -> peers;
  313. peer < & host -> peers [host -> peerCount];
  314. ++ peer)
  315. {
  316. enet_uint32 peerBandwidth;
  317. if ((peer -> state != ENET_PEER_STATE_CONNECTED && peer -> state != ENET_PEER_STATE_DISCONNECT_LATER) ||
  318. peer -> incomingBandwidth == 0 ||
  319. peer -> outgoingBandwidthThrottleEpoch == timeCurrent)
  320. continue;
  321. peerBandwidth = (peer -> incomingBandwidth * elapsedTime) / 1000;
  322. if ((throttle * peer -> outgoingDataTotal) / ENET_PEER_PACKET_THROTTLE_SCALE <= peerBandwidth)
  323. continue;
  324. peer -> packetThrottleLimit = (peerBandwidth *
  325. ENET_PEER_PACKET_THROTTLE_SCALE) / peer -> outgoingDataTotal;
  326. if (peer -> packetThrottleLimit == 0)
  327. peer -> packetThrottleLimit = 1;
  328. if (peer -> packetThrottle > peer -> packetThrottleLimit)
  329. peer -> packetThrottle = peer -> packetThrottleLimit;
  330. peer -> outgoingBandwidthThrottleEpoch = timeCurrent;
  331. needsAdjustment = 1;
  332. -- peersRemaining;
  333. bandwidth -= peerBandwidth;
  334. dataTotal -= peerBandwidth;
  335. }
  336. }
  337. if (peersRemaining > 0)
  338. for (peer = host -> peers;
  339. peer < & host -> peers [host -> peerCount];
  340. ++ peer)
  341. {
  342. if ((peer -> state != ENET_PEER_STATE_CONNECTED && peer -> state != ENET_PEER_STATE_DISCONNECT_LATER) ||
  343. peer -> outgoingBandwidthThrottleEpoch == timeCurrent)
  344. continue;
  345. peer -> packetThrottleLimit = throttle;
  346. if (peer -> packetThrottle > peer -> packetThrottleLimit)
  347. peer -> packetThrottle = peer -> packetThrottleLimit;
  348. }
  349. if (host -> recalculateBandwidthLimits)
  350. {
  351. host -> recalculateBandwidthLimits = 0;
  352. peersRemaining = peersTotal;
  353. bandwidth = host -> incomingBandwidth;
  354. needsAdjustment = 1;
  355. if (bandwidth == 0)
  356. bandwidthLimit = 0;
  357. else
  358. while (peersRemaining > 0 && needsAdjustment != 0)
  359. {
  360. needsAdjustment = 0;
  361. bandwidthLimit = bandwidth / peersRemaining;
  362. for (peer = host -> peers;
  363. peer < & host -> peers [host -> peerCount];
  364. ++ peer)
  365. {
  366. if ((peer -> state != ENET_PEER_STATE_CONNECTED && peer -> state != ENET_PEER_STATE_DISCONNECT_LATER) ||
  367. peer -> incomingBandwidthThrottleEpoch == timeCurrent)
  368. continue;
  369. if (peer -> outgoingBandwidth > 0 &&
  370. peer -> outgoingBandwidth >= bandwidthLimit)
  371. continue;
  372. peer -> incomingBandwidthThrottleEpoch = timeCurrent;
  373. needsAdjustment = 1;
  374. -- peersRemaining;
  375. bandwidth -= peer -> outgoingBandwidth;
  376. }
  377. }
  378. for (peer = host -> peers;
  379. peer < & host -> peers [host -> peerCount];
  380. ++ peer)
  381. {
  382. if (peer -> state != ENET_PEER_STATE_CONNECTED && peer -> state != ENET_PEER_STATE_DISCONNECT_LATER)
  383. continue;
  384. command.header.command = ENET_PROTOCOL_COMMAND_BANDWIDTH_LIMIT | ENET_PROTOCOL_COMMAND_FLAG_ACKNOWLEDGE;
  385. command.header.channelID = 0xFF;
  386. command.bandwidthLimit.outgoingBandwidth = ENET_HOST_TO_NET_32 (host -> outgoingBandwidth);
  387. if (peer -> incomingBandwidthThrottleEpoch == timeCurrent)
  388. command.bandwidthLimit.incomingBandwidth = ENET_HOST_TO_NET_32 (peer -> outgoingBandwidth);
  389. else
  390. command.bandwidthLimit.incomingBandwidth = ENET_HOST_TO_NET_32 (bandwidthLimit);
  391. enet_peer_queue_outgoing_command (peer, & command, NULL, 0, 0);
  392. }
  393. }
  394. host -> bandwidthThrottleEpoch = timeCurrent;
  395. for (peer = host -> peers;
  396. peer < & host -> peers [host -> peerCount];
  397. ++ peer)
  398. {
  399. peer -> incomingDataTotal = 0;
  400. peer -> outgoingDataTotal = 0;
  401. }
  402. }
  403. /** @} */