yuzu/enet
1
0
Fork 0
mirror of https://github.com/lsalzman/enet synced 2024-11-21 14:29:05 -07:00
Code Issues Projects Releases Packages Wiki Activity Actions

*** empty log message ***

Browse source
This commit is contained in:
eihrul 2006-10-03 15:39:29 +00:00
parent e310eade3b
commit df636cc8f7
4 changed files with 36 additions and 15 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
configure.in
View file

@ -1,5 +1,5 @@
AC_INIT(libenet, 7-6-2006) AC_INIT(libenet, 10-2-2006)
AM_INIT_AUTOMAKE(libenet.a, 7-6-2006) AM_INIT_AUTOMAKE(libenet.a, 10-2-2006)
AC_PROG_CC AC_PROG_CC
AC_PROG_RANLIB AC_PROG_RANLIB

12
include/enet/enet.h
View file

@ -85,6 +85,9 @@ typedef enum
ENET_PACKET_FLAG_NO_ALLOCATE = (1 << 2) ENET_PACKET_FLAG_NO_ALLOCATE = (1 << 2)
} ENetPacketFlag; } ENetPacketFlag;
struct _ENetPacket;
typedef void (ENET_CALLBACK * ENetPacketFreeCallback) (struct _ENetPacket *);
/** /**
* ENet packet structure. * ENet packet structure.
* *
@ -101,10 +104,11 @@ typedef enum
*/ */
typedef struct _ENetPacket typedef struct _ENetPacket
{ {
size_t referenceCount; /**< internal use only */ size_t referenceCount; /**< internal use only */
enet_uint32 flags; /**< bitwise or of ENetPacketFlag constants */ enet_uint32 flags; /**< bitwise or of ENetPacketFlag constants */
enet_uint8 * data; /**< allocated data for packet */ enet_uint8 * data; /**< allocated data for packet */
size_t dataLength; /**< length of data */ size_t dataLength; /**< length of data */
ENetPacketFreeCallback freeCallback; /**< function to be called when the packet is no longer in use */
} ENetPacket; } ENetPacket;
typedef struct _ENetAcknowledgement typedef struct _ENetAcknowledgement

15
packet.c
View file

@ -21,11 +21,16 @@ enet_packet_create (const void * data, size_t dataLength, enet_uint32 flags)
{ {
ENetPacket * packet = (ENetPacket *) enet_malloc (sizeof (ENetPacket)); ENetPacket * packet = (ENetPacket *) enet_malloc (sizeof (ENetPacket));
if(flags & ENET_PACKET_FLAG_NO_ALLOCATE) if (flags & ENET_PACKET_FLAG_NO_ALLOCATE)
packet -> data = (enet_uint8 *) data; packet -> data = (enet_uint8 *) data;
else else
{ {
packet -> data = (enet_uint8 *) enet_malloc (dataLength); packet -> data = (enet_uint8 *) enet_malloc (dataLength);
if (packet -> data == NULL)
{
enet_free (packet);
return NULL;
};
if (data != NULL) if (data != NULL)
memcpy (packet -> data, data, dataLength); memcpy (packet -> data, data, dataLength);
@ -34,6 +39,7 @@ enet_packet_create (const void * data, size_t dataLength, enet_uint32 flags)
packet -> referenceCount = 0; packet -> referenceCount = 0;
packet -> flags = flags; packet -> flags = flags;
packet -> dataLength = dataLength; packet -> dataLength = dataLength;
packet -> freeCallback = NULL;
return packet; return packet;
} }
@ -44,7 +50,9 @@ enet_packet_create (const void * data, size_t dataLength, enet_uint32 flags)
void void
enet_packet_destroy (ENetPacket * packet) enet_packet_destroy (ENetPacket * packet)
{ {
if((packet -> flags & ENET_PACKET_FLAG_NO_ALLOCATE) == 0) if (packet -> freeCallback != NULL)
(* packet -> freeCallback) (packet);
if (! (packet -> flags & ENET_PACKET_FLAG_NO_ALLOCATE))
enet_free (packet -> data); enet_free (packet -> data);
enet_free (packet); enet_free (packet);
} }
@ -68,6 +76,9 @@ enet_packet_resize (ENetPacket * packet, size_t dataLength)
} }
newData = (enet_uint8 *) enet_malloc (dataLength); newData = (enet_uint8 *) enet_malloc (dataLength);
if (newData == NULL)
return -1;
memcpy (newData, packet -> data, packet -> dataLength); memcpy (newData, packet -> data, packet -> dataLength);
enet_free (packet -> data); enet_free (packet -> data);

20
protocol.c
View file

@ -362,6 +362,8 @@ enet_protocol_handle_send_reliable (ENetHost * host, ENetPeer * peer, const ENet
packet = enet_packet_create ((const enet_uint8 *) command + sizeof (ENetProtocolSendReliable), packet = enet_packet_create ((const enet_uint8 *) command + sizeof (ENetProtocolSendReliable),
dataLength, dataLength,
ENET_PACKET_FLAG_RELIABLE); ENET_PACKET_FLAG_RELIABLE);
if (packet == NULL)
return -1;
enet_peer_queue_incoming_command (peer, command, packet, 0); enet_peer_queue_incoming_command (peer, command, packet, 0);
return 0; return 0;
@ -404,7 +406,9 @@ enet_protocol_handle_send_unsequenced (ENetHost * host, ENetPeer * peer, const E
packet = enet_packet_create ((const enet_uint8 *) command + sizeof (ENetProtocolSendUnsequenced), packet = enet_packet_create ((const enet_uint8 *) command + sizeof (ENetProtocolSendUnsequenced),
dataLength, dataLength,
ENET_PACKET_FLAG_UNSEQUENCED); ENET_PACKET_FLAG_UNSEQUENCED);
if (packet == NULL)
return -1;
enet_peer_queue_incoming_command (peer, command, packet, 0); enet_peer_queue_incoming_command (peer, command, packet, 0);
return 0; return 0;
} }
@ -427,6 +431,8 @@ enet_protocol_handle_send_unreliable (ENetHost * host, ENetPeer * peer, const EN
packet = enet_packet_create ((const enet_uint8 *) command + sizeof (ENetProtocolSendUnreliable), packet = enet_packet_create ((const enet_uint8 *) command + sizeof (ENetProtocolSendUnreliable),
dataLength, dataLength,
0); 0);
if (packet == NULL)
return -1;
enet_peer_queue_incoming_command (peer, command, packet, 0); enet_peer_queue_incoming_command (peer, command, packet, 0);
return 0; return 0;
@ -487,7 +493,10 @@ enet_protocol_handle_send_fragment (ENetHost * host, ENetPeer * peer, const ENet
if (currentCommand == enet_list_end (& channel -> incomingReliableCommands)) if (currentCommand == enet_list_end (& channel -> incomingReliableCommands))
{ {
ENetProtocol hostCommand = * command; ENetProtocol hostCommand = * command;
ENetPacket * packet = enet_packet_create (NULL, totalLength, ENET_PACKET_FLAG_RELIABLE);
if (packet == NULL)
return -1;
hostCommand.header.reliableSequenceNumber = startSequenceNumber; hostCommand.header.reliableSequenceNumber = startSequenceNumber;
hostCommand.sendFragment.startSequenceNumber = startSequenceNumber; hostCommand.sendFragment.startSequenceNumber = startSequenceNumber;
hostCommand.sendFragment.dataLength = fragmentLength; hostCommand.sendFragment.dataLength = fragmentLength;
@ -496,10 +505,7 @@ enet_protocol_handle_send_fragment (ENetHost * host, ENetPeer * peer, const ENet
hostCommand.sendFragment.fragmentOffset = fragmentOffset; hostCommand.sendFragment.fragmentOffset = fragmentOffset;
hostCommand.sendFragment.totalLength = totalLength; hostCommand.sendFragment.totalLength = totalLength;
startCommand = enet_peer_queue_incoming_command (peer, startCommand = enet_peer_queue_incoming_command (peer, & hostCommand, packet, fragmentCount);
& hostCommand,
enet_packet_create (NULL, totalLength, ENET_PACKET_FLAG_RELIABLE),
fragmentCount);
} }
else else
if (totalLength != startCommand -> packet -> dataLength || if (totalLength != startCommand -> packet -> dataLength ||
@ -1278,7 +1284,7 @@ enet_protocol_send_outgoing_commands (ENetHost * host, ENetEvent * event, int ch
#else #else
fprintf (stderr, fprintf (stderr,
#endif #endif
"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)); "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, currentPeer -> channels != NULL ? enet_list_size (& currentPeer -> channels -> incomingUnreliableCommands) : 0);
#endif #endif
currentPeer -> packetLossVariance -= currentPeer -> packetLossVariance / 4; currentPeer -> packetLossVariance -= currentPeer -> packetLossVariance / 4;