Enable ECN/L4S on UNIX

Since this is enabled as a QoS option, it will benefit from the opportunistic disablement code when ECN-intolerant networks are encountered.
Disable QoS tagging if 2 connect packets in a row are dropped
2024-02-03 14:32:25 -06:00 · 2020-06-12 21:16:46 -07:00 · 2020-04-09 17:42:12 -07:00 · 2020-04-03 16:58:18 -07:00 · 2020-03-29 15:44:14 -07:00 · 2020-03-29 15:21:26 -07:00
18 changed files with 672 additions and 702 deletions
@@ -7,6 +7,7 @@ include(CheckFunctionExists)
 include(CheckStructHasMember)
 include(CheckTypeSize)
 check_function_exists("fcntl" HAS_FCNTL)
+check_function_exists("ioctl" HAS_IOCTL)
 check_function_exists("poll" HAS_POLL)
 check_function_exists("getaddrinfo" HAS_GETADDRINFO)
 check_function_exists("getnameinfo" HAS_GETNAMEINFO)
@@ -18,15 +19,13 @@ check_struct_has_member("struct msghdr" "msg_flags" "sys/types.h;sys/socket.h" H
 set(CMAKE_EXTRA_INCLUDE_FILES "sys/types.h" "sys/socket.h")
 check_type_size("socklen_t" HAS_SOCKLEN_T BUILTIN_TYPES_ONLY)
 unset(CMAKE_EXTRA_INCLUDE_FILES)
-if(MSVC)
-	add_definitions(-W3)
-else()
-	add_definitions(-Wno-error)
-endif()
-
+ 
 if(HAS_FCNTL)
    add_definitions(-DHAS_FCNTL=1)
 endif()
+if(HAS_IOCTL)
+    add_definitions(-DHAS_IOCTL=1)
+endif()
 if(HAS_POLL)
    add_definitions(-DHAS_POLL=1)
 endif()
@@ -54,41 +53,17 @@ endif()
 if(HAS_SOCKLEN_T)
    add_definitions(-DHAS_SOCKLEN_T=1)
 endif()
-
+ 
 include_directories(${PROJECT_SOURCE_DIR}/include)
-
-set(INCLUDE_FILES_PREFIX include/enet)
-set(INCLUDE_FILES
-    ${INCLUDE_FILES_PREFIX}/callbacks.h
-    ${INCLUDE_FILES_PREFIX}/enet.h
-    ${INCLUDE_FILES_PREFIX}/list.h
-    ${INCLUDE_FILES_PREFIX}/protocol.h
-    ${INCLUDE_FILES_PREFIX}/time.h
-    ${INCLUDE_FILES_PREFIX}/types.h
-    ${INCLUDE_FILES_PREFIX}/unix.h
-    ${INCLUDE_FILES_PREFIX}/utility.h
-    ${INCLUDE_FILES_PREFIX}/win32.h
-)
-
-set(SOURCE_FILES
-    callbacks.c
-    compress.c
-    host.c
-    list.c
-    packet.c
-    peer.c
-    protocol.c
-    unix.c
-    win32.c)
-
-source_group(include FILES ${INCLUDE_FILES})
-source_group(source FILES ${SOURCE_FILES})
-
+ 
 add_library(enet STATIC
-    ${INCLUDE_FILES}
-    ${SOURCE_FILES}
-)
-
-if (MINGW)
-    target_link_libraries(enet winmm ws2_32)
-endif()
+        callbacks.c
+        compress.c
+        host.c
+        list.c
+        packet.c
+        peer.c
+        protocol.c
+        unix.c
+        win32.c
+    )
@@ -1,21 +1,4 @@
-ENet 1.3.16 (September 8, 2020):
-
-* fix bug in unreliable fragment queuing
-* use single output queue for reliable and unreliable packets for saner ordering
-* revert experimental throttle changes that were less stable than prior algorithm
-
-ENet 1.3.15 (April 20, 2020):
-
-* quicker RTT initialization
-* use fractional precision for RTT calculations
-* fixes for packet throttle with low RTT variance
-* miscellaneous socket bug fixes
-
-ENet 1.3.14 (January 27, 2019):
-
-* bug fix for enet_peer_disconnect_later()
 * use getaddrinfo and getnameinfo where available
-* miscellenous cleanups

 ENet 1.3.13 (April 30, 2015):

@@ -38,7 +38,7 @@ PROJECT_NAME           = "ENet"
 # could be handy for archiving the generated documentation or if some version
 # control system is used.

-PROJECT_NUMBER         = v1.3.16
+PROJECT_NUMBER         = v1.3.13

 # Using the PROJECT_BRIEF tag one can provide an optional one line description
 # for a project that appears at the top of each page and should give viewer a
@@ -1,4 +1,4 @@
-Copyright (c) 2002-2020 Lee Salzman
+Copyright (c) 2002-2016 Lee Salzman

 Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

@@ -16,7 +16,7 @@ enetinclude_HEADERS = \
 lib_LTLIBRARIES = libenet.la
 libenet_la_SOURCES = callbacks.c compress.c host.c list.c packet.c peer.c protocol.c unix.c win32.c
 # see info '(libtool) Updating version info' before making a release
-libenet_la_LDFLAGS = $(AM_LDFLAGS) -version-info 7:4:0
+libenet_la_LDFLAGS = $(AM_LDFLAGS) -version-info 7:1:0
 AM_CPPFLAGS = -I$(top_srcdir)/include

 ACLOCAL_AMFLAGS = -Im4
@@ -1,4 +1,4 @@
-AC_INIT([libenet], [1.3.16])
+AC_INIT([libenet], [1.3.13])
 AC_CONFIG_SRCDIR([include/enet/enet.h])
 AM_INIT_AUTOMAKE([foreign])

@@ -1,7 +1,7 @@
 /**
 @page License License
 
-Copyright (c) 2002-2020 Lee Salzman
+Copyright (c) 2002-2016 Lee Salzman

 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the
@@ -36,7 +36,7 @@ portable, and easily embeddable.
 You can retrieve the source to ENet by downloading it in either .tar.gz form
 or accessing the github distribution directly.

-The most recent stable release (1.3.16) can be downloaded <a class="el" href="download/enet-1.3.16.tar.gz">here</a>.
+The most recent stable release (1.3.13) can be downloaded <a class="el" href="download/enet-1.3.13.tar.gz">here</a>. 
 The last release that is protocol compatible with the 1.2 series or earlier (1.2.5) can be downloaded <a class="el" href="download/enet-1.2.5.tar.gz">here</a>. 

 You can find the most recent ENet source at <a class="el" href="https://github.com/lsalzman/enet">the github repository</a>.
@@ -102,8 +102,8 @@ may be simultaneously open.
    client = enet_host_create (NULL /* create a client host */,
                1 /* only allow 1 outgoing connection */,
                2 /* allow up 2 channels to be used, 0 and 1 */,
-                0 /* assume any amount of incoming bandwidth */,
-                0 /* assume any amount of outgoing bandwidth */);
+                57600 / 8 /* 56K modem with 56 Kbps downstream bandwidth */,
+                14400 / 8 /* 56K modem with 14 Kbps upstream bandwidth */);

    if (client == NULL)
    {
@@ -12,6 +12,7 @@

 /** Creates a host for communicating to peers.  

+    @param addressFamily the address family of the socket that should be created (ex: PF_INET/PF_INET6)
    @param address   the address at which other peers may connect to this host.  If NULL, then no peers may connect to the host.
    @param peerCount the maximum number of peers that should be allocated for the host.
    @param channelLimit the maximum number of channels allowed; if 0, then this is equivalent to ENET_PROTOCOL_MAXIMUM_CHANNEL_COUNT
@@ -26,7 +27,7 @@
    at any given time.
 */
 ENetHost *
-enet_host_create (const ENetAddress * address, size_t peerCount, size_t channelLimit, enet_uint32 incomingBandwidth, enet_uint32 outgoingBandwidth)
+enet_host_create (int addressFamily, const ENetAddress * address, size_t peerCount, size_t channelLimit, enet_uint32 incomingBandwidth, enet_uint32 outgoingBandwidth)
 {
    ENetHost * host;
    ENetPeer * currentPeer;
@@ -48,7 +49,7 @@ enet_host_create (const ENetAddress * address, size_t peerCount, size_t channelL
    }
    memset (host -> peers, 0, peerCount * sizeof (ENetPeer));

-    host -> socket = enet_socket_create (ENET_SOCKET_TYPE_DATAGRAM);
+    host -> socket = enet_socket_create (addressFamily, ENET_SOCKET_TYPE_DATAGRAM);
    if (host -> socket == ENET_SOCKET_NULL || (address != NULL && enet_socket_bind (host -> socket, address) < 0))
    {
       if (host -> socket != ENET_SOCKET_NULL)
@@ -61,9 +62,9 @@ enet_host_create (const ENetAddress * address, size_t peerCount, size_t channelL
    }

    enet_socket_set_option (host -> socket, ENET_SOCKOPT_NONBLOCK, 1);
-    enet_socket_set_option (host -> socket, ENET_SOCKOPT_BROADCAST, 1);
    enet_socket_set_option (host -> socket, ENET_SOCKOPT_RCVBUF, ENET_HOST_RECEIVE_BUFFER_SIZE);
    enet_socket_set_option (host -> socket, ENET_SOCKOPT_SNDBUF, ENET_HOST_SEND_BUFFER_SIZE);
+    enet_socket_set_option (host -> socket, ENET_SOCKOPT_QOS, 1);

    if (address != NULL && enet_socket_get_address (host -> socket, & host -> address) < 0)   
      host -> address = * address;
@@ -87,8 +88,7 @@ enet_host_create (const ENetAddress * address, size_t peerCount, size_t channelL
    host -> commandCount = 0;
    host -> bufferCount = 0;
    host -> checksum = NULL;
-    host -> receivedAddress.host = ENET_HOST_ANY;
-    host -> receivedAddress.port = 0;
+    memset(& host -> receivedAddress, 0, sizeof (host -> receivedAddress));
    host -> receivedData = NULL;
    host -> receivedDataLength = 0;
     
@@ -124,7 +124,8 @@ enet_host_create (const ENetAddress * address, size_t peerCount, size_t channelL
       enet_list_clear (& currentPeer -> acknowledgements);
       enet_list_clear (& currentPeer -> sentReliableCommands);
       enet_list_clear (& currentPeer -> sentUnreliableCommands);
-       enet_list_clear (& currentPeer -> outgoingCommands);
+       enet_list_clear (& currentPeer -> outgoingReliableCommands);
+       enet_list_clear (& currentPeer -> outgoingUnreliableCommands);
       enet_list_clear (& currentPeer -> dispatchedCommands);

       enet_peer_reset (currentPeer);
@@ -251,30 +252,6 @@ enet_host_connect (ENetHost * host, const ENetAddress * address, size_t channelC
    return currentPeer;
 }

-/** Queues a packet to be sent to all peers associated with the host.
-    @param host host on which to broadcast the packet
-    @param channelID channel on which to broadcast
-    @param packet packet to broadcast
-*/
-void
-enet_host_broadcast (ENetHost * host, enet_uint8 channelID, ENetPacket * packet)
-{
-    ENetPeer * currentPeer;
-
-    for (currentPeer = host -> peers;
-         currentPeer < & host -> peers [host -> peerCount];
-         ++ currentPeer)
-    {
-       if (currentPeer -> state != ENET_PEER_STATE_CONNECTED)
-         continue;
-
-       enet_peer_send (currentPeer, channelID, packet);
-    }
-
-    if (packet -> referenceCount == 0)
-      enet_packet_destroy (packet);
-}
-
 /** Sets the packet compressor the host should use to compress and decompress packets.
    @param host host to enable or disable compression for
    @param compressor callbacks for for the packet compressor; if NULL, then compression is disabled
@@ -25,7 +25,7 @@ extern "C"

 #define ENET_VERSION_MAJOR 1
 #define ENET_VERSION_MINOR 3
-#define ENET_VERSION_PATCH 16
+#define ENET_VERSION_PATCH 13
 #define ENET_VERSION_CREATE(major, minor, patch) (((major)<<16) | ((minor)<<8) | (patch))
 #define ENET_VERSION_GET_MAJOR(version) (((version)>>16)&0xFF)
 #define ENET_VERSION_GET_MINOR(version) (((version)>>8)&0xFF)
@@ -55,14 +55,14 @@ typedef enum _ENetSocketWait
 typedef enum _ENetSocketOption
 {
   ENET_SOCKOPT_NONBLOCK  = 1,
-   ENET_SOCKOPT_BROADCAST = 2,
-   ENET_SOCKOPT_RCVBUF    = 3,
-   ENET_SOCKOPT_SNDBUF    = 4,
-   ENET_SOCKOPT_REUSEADDR = 5,
-   ENET_SOCKOPT_RCVTIMEO  = 6,
-   ENET_SOCKOPT_SNDTIMEO  = 7,
-   ENET_SOCKOPT_ERROR     = 8,
-   ENET_SOCKOPT_NODELAY   = 9
+   ENET_SOCKOPT_RCVBUF,
+   ENET_SOCKOPT_SNDBUF,
+   ENET_SOCKOPT_REUSEADDR,
+   ENET_SOCKOPT_RCVTIMEO,
+   ENET_SOCKOPT_SNDTIMEO,
+   ENET_SOCKOPT_ERROR,
+   ENET_SOCKOPT_NODELAY,
+   ENET_SOCKOPT_QOS,
 } ENetSocketOption;

 typedef enum _ENetSocketShutdown
@@ -72,24 +72,13 @@ typedef enum _ENetSocketShutdown
    ENET_SOCKET_SHUTDOWN_READ_WRITE = 2
 } ENetSocketShutdown;

-#define ENET_HOST_ANY       0
-#define ENET_HOST_BROADCAST 0xFFFFFFFFU
-#define ENET_PORT_ANY       0
-
 /**
 * Portable internet address structure. 
- *
- * The host must be specified in network byte-order, and the port must be in host 
- * byte-order. The constant ENET_HOST_ANY may be used to specify the default 
- * server host. The constant ENET_HOST_BROADCAST may be used to specify the
- * broadcast address (255.255.255.255).  This makes sense for enet_host_connect,
- * but not for enet_host_create.  Once a server responds to a broadcast, the
- * address is updated from ENET_HOST_BROADCAST to the server's actual IP address.
 */
 typedef struct _ENetAddress
 {
-   enet_uint32 host;
-   enet_uint16 port;
+   socklen_t addressLength;
+   struct sockaddr_storage address;
 } ENetAddress;

 /**
@@ -212,7 +201,7 @@ enum
   ENET_HOST_RECEIVE_BUFFER_SIZE          = 256 * 1024,
   ENET_HOST_SEND_BUFFER_SIZE             = 256 * 1024,
   ENET_HOST_BANDWIDTH_THROTTLE_INTERVAL  = 1000,
-   ENET_HOST_DEFAULT_MTU                  = 1400,
+   ENET_HOST_DEFAULT_MTU                  = 900,
   ENET_HOST_DEFAULT_MAXIMUM_PACKET_SIZE  = 32 * 1024 * 1024,
   ENET_HOST_DEFAULT_MAXIMUM_WAITING_DATA = 32 * 1024 * 1024,

@@ -250,11 +239,6 @@ typedef struct _ENetChannel
   ENetList     incomingUnreliableCommands;
 } ENetChannel;

-typedef enum _ENetPeerFlag
-{
-   ENET_PEER_FLAG_NEEDS_DISPATCH = (1 << 0)
-} ENetPeerFlag;
-
 /**
 * An ENet peer which data packets may be sent or received from. 
 *
@@ -313,10 +297,10 @@ typedef struct _ENetPeer
   ENetList      acknowledgements;
   ENetList      sentReliableCommands;
   ENetList      sentUnreliableCommands;
-   ENetList      outgoingCommands;
+   ENetList      outgoingReliableCommands;
+   ENetList      outgoingUnreliableCommands;
   ENetList      dispatchedCommands;
-   enet_uint16   flags;
-   enet_uint16   reserved;
+   int           needsDispatch;
   enet_uint16   incomingUnsequencedGroup;
   enet_uint16   outgoingUnsequencedGroup;
   enet_uint32   unsequencedWindow [ENET_PEER_UNSEQUENCED_WINDOW_SIZE / 32]; 
@@ -353,7 +337,6 @@ typedef int (ENET_CALLBACK * ENetInterceptCallback) (struct _ENetHost * host, st
    @sa enet_host_connect()
    @sa enet_host_service()
    @sa enet_host_flush()
-    @sa enet_host_broadcast()
    @sa enet_host_compress()
    @sa enet_host_compress_with_range_coder()
    @sa enet_host_channel_limit()
@@ -494,7 +477,7 @@ ENET_API void enet_time_set (enet_uint32);
 /** @defgroup socket ENet socket functions
    @{
 */
-ENET_API ENetSocket enet_socket_create (ENetSocketType);
+ENET_API ENetSocket enet_socket_create (int, ENetSocketType);
 ENET_API int        enet_socket_bind (ENetSocket, const ENetAddress *);
 ENET_API int        enet_socket_get_address (ENetSocket, ENetAddress *);
 ENET_API int        enet_socket_listen (ENetSocket, int);
@@ -514,17 +497,6 @@ ENET_API int        enet_socketset_select (ENetSocket, ENetSocketSet *, ENetSock
 /** @defgroup Address ENet address functions
    @{
 */
-
-/** Attempts to parse the printable form of the IP address in the parameter hostName
-    and sets the host field in the address parameter if successful.
-    @param address destination to store the parsed IP address
-    @param hostName IP address to parse
-    @retval 0 on success
-    @retval < 0 on failure
-    @returns the address of the given hostName in address on success
-*/
-ENET_API int enet_address_set_host_ip (ENetAddress * address, const char * hostName);
-
 /** Attempts to resolve the host named by the parameter hostName and sets
    the host field in the address parameter if successful.
    @param address destination to store resolved address
@@ -534,26 +506,9 @@ ENET_API int enet_address_set_host_ip (ENetAddress * address, const char * hostN
    @returns the address of the given hostName in address on success
 */
 ENET_API int enet_address_set_host (ENetAddress * address, const char * hostName);
-
-/** Gives the printable form of the IP address specified in the address parameter.
-    @param address    address printed
-    @param hostName   destination for name, must not be NULL
-    @param nameLength maximum length of hostName.
-    @returns the null-terminated name of the host in hostName on success
-    @retval 0 on success
-    @retval < 0 on failure
-*/
-ENET_API int enet_address_get_host_ip (const ENetAddress * address, char * hostName, size_t nameLength);
-
-/** Attempts to do a reverse lookup of the host field in the address parameter.
-    @param address    address used for reverse lookup
-    @param hostName   destination for name, must not be NULL
-    @param nameLength maximum length of hostName.
-    @returns the null-terminated name of the host in hostName on success
-    @retval 0 on success
-    @retval < 0 on failure
-*/
-ENET_API int enet_address_get_host (const ENetAddress * address, char * hostName, size_t nameLength);
+ENET_API int enet_address_set_address (ENetAddress * address, struct sockaddr * addr, socklen_t addrlen);
+ENET_API int enet_address_set_port (ENetAddress * address, enet_uint16 port);
+ENET_API int enet_address_equal (ENetAddress * address1, ENetAddress * address2);

 /** @} */

@@ -562,13 +517,12 @@ ENET_API void         enet_packet_destroy (ENetPacket *);
 ENET_API int          enet_packet_resize  (ENetPacket *, size_t);
 ENET_API enet_uint32  enet_crc32 (const ENetBuffer *, size_t);
                
-ENET_API ENetHost * enet_host_create (const ENetAddress *, size_t, size_t, enet_uint32, enet_uint32);
+ENET_API ENetHost * enet_host_create (int, const ENetAddress *, size_t, size_t, enet_uint32, enet_uint32);
 ENET_API void       enet_host_destroy (ENetHost *);
 ENET_API ENetPeer * enet_host_connect (ENetHost *, const ENetAddress *, size_t, enet_uint32);
 ENET_API int        enet_host_check_events (ENetHost *, ENetEvent *);
 ENET_API int        enet_host_service (ENetHost *, ENetEvent *, enet_uint32);
 ENET_API void       enet_host_flush (ENetHost *);
-ENET_API void       enet_host_broadcast (ENetHost *, enet_uint8, ENetPacket *);
 ENET_API void       enet_host_compress (ENetHost *, const ENetCompressor *);
 ENET_API int        enet_host_compress_with_range_coder (ENetHost * host);
 ENET_API void       enet_host_channel_limit (ENetHost *, size_t);
@@ -592,8 +546,8 @@ extern void                  enet_peer_setup_outgoing_command (ENetPeer *, ENetO
 extern ENetOutgoingCommand * enet_peer_queue_outgoing_command (ENetPeer *, const ENetProtocol *, ENetPacket *, enet_uint32, enet_uint16);
 extern ENetIncomingCommand * enet_peer_queue_incoming_command (ENetPeer *, const ENetProtocol *, const void *, size_t, enet_uint32, enet_uint32);
 extern ENetAcknowledgement * enet_peer_queue_acknowledgement (ENetPeer *, const ENetProtocol *, enet_uint16);
-extern void                  enet_peer_dispatch_incoming_unreliable_commands (ENetPeer *, ENetChannel *, ENetIncomingCommand *);
-extern void                  enet_peer_dispatch_incoming_reliable_commands (ENetPeer *, ENetChannel *, ENetIncomingCommand *);
+extern void                  enet_peer_dispatch_incoming_unreliable_commands (ENetPeer *, ENetChannel *);
+extern void                  enet_peer_dispatch_incoming_reliable_commands (ENetPeer *, ENetChannel *);
 extern void                  enet_peer_on_connect (ENetPeer *);
 extern void                  enet_peer_on_disconnect (ENetPeer *);

@@ -9,7 +9,6 @@
 #include <sys/time.h>
 #include <sys/types.h>
 #include <sys/socket.h>
-#include <arpa/inet.h>
 #include <netinet/in.h>
 #include <unistd.h>

@@ -7,7 +7,6 @@

 #define ENET_MAX(x, y) ((x) > (y) ? (x) : (y))
 #define ENET_MIN(x, y) ((x) < (y) ? (x) : (y))
-#define ENET_DIFFERENCE(x, y) ((x) < (y) ? (y) - (x) : (x) - (y))

 #endif /* __ENET_UTILITY_H__ */

@@ -16,6 +16,7 @@

 #include <stdlib.h>
 #include <winsock2.h>
+#include <Ws2tcpip.h>

 typedef SOCKET ENetSocket;

@@ -66,7 +66,7 @@ enet_peer_throttle (ENetPeer * peer, enet_uint32 rtt)
        peer -> packetThrottle = peer -> packetThrottleLimit;
    }
    else
-    if (rtt <= peer -> lastRoundTripTime)
+    if (rtt < peer -> lastRoundTripTime)
    {
        peer -> packetThrottle += peer -> packetThrottleAcceleration;

@@ -268,7 +268,7 @@ enet_peer_reset_outgoing_commands (ENetList * queue)
 }

 static void
-enet_peer_remove_incoming_commands (ENetList * queue, ENetListIterator startCommand, ENetListIterator endCommand, ENetIncomingCommand * excludeCommand)
+enet_peer_remove_incoming_commands (ENetList * queue, ENetListIterator startCommand, ENetListIterator endCommand)
 {
    ENetListIterator currentCommand;    
    
@@ -278,9 +278,6 @@ enet_peer_remove_incoming_commands (ENetList * queue, ENetListIterator startComm

       currentCommand = enet_list_next (currentCommand);

-       if (incomingCommand == excludeCommand)
-         continue;
-
       enet_list_remove (& incomingCommand -> incomingCommandList);
 
       if (incomingCommand -> packet != NULL)
@@ -301,7 +298,7 @@ enet_peer_remove_incoming_commands (ENetList * queue, ENetListIterator startComm
 static void
 enet_peer_reset_incoming_commands (ENetList * queue)
 {
-    enet_peer_remove_incoming_commands(queue, enet_list_begin (queue), enet_list_end (queue), NULL);
+    enet_peer_remove_incoming_commands(queue, enet_list_begin (queue), enet_list_end (queue));
 }
 
 void
@@ -309,11 +306,11 @@ enet_peer_reset_queues (ENetPeer * peer)
 {
    ENetChannel * channel;

-    if (peer -> flags & ENET_PEER_FLAG_NEEDS_DISPATCH)
+    if (peer -> needsDispatch)
    {
       enet_list_remove (& peer -> dispatchList);

-       peer -> flags &= ~ ENET_PEER_FLAG_NEEDS_DISPATCH;
+       peer -> needsDispatch = 0;
    }

    while (! enet_list_empty (& peer -> acknowledgements))
@@ -321,7 +318,8 @@ enet_peer_reset_queues (ENetPeer * peer)

    enet_peer_reset_outgoing_commands (& peer -> sentReliableCommands);
    enet_peer_reset_outgoing_commands (& peer -> sentUnreliableCommands);
-    enet_peer_reset_outgoing_commands (& peer -> outgoingCommands);
+    enet_peer_reset_outgoing_commands (& peer -> outgoingReliableCommands);
+    enet_peer_reset_outgoing_commands (& peer -> outgoingUnreliableCommands);
    enet_peer_reset_incoming_commands (& peer -> dispatchedCommands);

    if (peer -> channels != NULL && peer -> channelCount > 0)
@@ -420,7 +418,6 @@ enet_peer_reset (ENetPeer * peer)
    peer -> outgoingUnsequencedGroup = 0;
    peer -> eventData = 0;
    peer -> totalWaitingData = 0;
-    peer -> flags = 0;

    memset (peer -> unsequencedWindow, 0, sizeof (peer -> unsequencedWindow));
    
@@ -573,7 +570,8 @@ void
 enet_peer_disconnect_later (ENetPeer * peer, enet_uint32 data)
 {   
    if ((peer -> state == ENET_PEER_STATE_CONNECTED || peer -> state == ENET_PEER_STATE_DISCONNECT_LATER) && 
-        ! (enet_list_empty (& peer -> outgoingCommands) &&
+        ! (enet_list_empty (& peer -> outgoingReliableCommands) &&
+           enet_list_empty (& peer -> outgoingUnreliableCommands) && 
           enet_list_empty (& peer -> sentReliableCommands)))
    {
        peer -> state = ENET_PEER_STATE_DISCONNECT_LATER;
@@ -675,7 +673,10 @@ enet_peer_setup_outgoing_command (ENetPeer * peer, ENetOutgoingCommand * outgoin
        break;
    }

-    enet_list_insert (enet_list_end (& peer -> outgoingCommands), outgoingCommand);
+    if (outgoingCommand -> command.header.command & ENET_PROTOCOL_COMMAND_FLAG_ACKNOWLEDGE)
+      enet_list_insert (enet_list_end (& peer -> outgoingReliableCommands), outgoingCommand);
+    else
+      enet_list_insert (enet_list_end (& peer -> outgoingUnreliableCommands), outgoingCommand);
 }

 ENetOutgoingCommand *
@@ -698,7 +699,7 @@ enet_peer_queue_outgoing_command (ENetPeer * peer, const ENetProtocol * command,
 }

 void
-enet_peer_dispatch_incoming_unreliable_commands (ENetPeer * peer, ENetChannel * channel, ENetIncomingCommand * queuedCommand)
+enet_peer_dispatch_incoming_unreliable_commands (ENetPeer * peer, ENetChannel * channel)
 {
    ENetListIterator droppedCommand, startCommand, currentCommand;

@@ -723,11 +724,11 @@ enet_peer_dispatch_incoming_unreliable_commands (ENetPeer * peer, ENetChannel *
          {
             enet_list_move (enet_list_end (& peer -> dispatchedCommands), startCommand, enet_list_previous (currentCommand));

-             if (! (peer -> flags & ENET_PEER_FLAG_NEEDS_DISPATCH))
+             if (! peer -> needsDispatch)
             {
                enet_list_insert (enet_list_end (& peer -> host -> dispatchQueue), & peer -> dispatchList);

-                peer -> flags |= ENET_PEER_FLAG_NEEDS_DISPATCH;
+                peer -> needsDispatch = 1;
             }

             droppedCommand = currentCommand;
@@ -751,11 +752,11 @@ enet_peer_dispatch_incoming_unreliable_commands (ENetPeer * peer, ENetChannel *
          {
             enet_list_move (enet_list_end (& peer -> dispatchedCommands), startCommand, enet_list_previous (currentCommand));

-             if (! (peer -> flags & ENET_PEER_FLAG_NEEDS_DISPATCH))
+             if (! peer -> needsDispatch)
             {
                enet_list_insert (enet_list_end (& peer -> host -> dispatchQueue), & peer -> dispatchList);

-                peer -> flags |= ENET_PEER_FLAG_NEEDS_DISPATCH;
+                peer -> needsDispatch = 1;
             }
          }
       }
@@ -767,21 +768,21 @@ enet_peer_dispatch_incoming_unreliable_commands (ENetPeer * peer, ENetChannel *
    {
       enet_list_move (enet_list_end (& peer -> dispatchedCommands), startCommand, enet_list_previous (currentCommand));

-       if (! (peer -> flags & ENET_PEER_FLAG_NEEDS_DISPATCH))
+       if (! peer -> needsDispatch)
       {
           enet_list_insert (enet_list_end (& peer -> host -> dispatchQueue), & peer -> dispatchList);

-           peer -> flags |= ENET_PEER_FLAG_NEEDS_DISPATCH;
+           peer -> needsDispatch = 1;
       }

       droppedCommand = currentCommand;
    }

-    enet_peer_remove_incoming_commands (& channel -> incomingUnreliableCommands, enet_list_begin (& channel -> incomingUnreliableCommands), droppedCommand, queuedCommand);
+    enet_peer_remove_incoming_commands (& channel -> incomingUnreliableCommands, enet_list_begin (& channel -> incomingUnreliableCommands), droppedCommand);
 }

 void
-enet_peer_dispatch_incoming_reliable_commands (ENetPeer * peer, ENetChannel * channel, ENetIncomingCommand * queuedCommand)
+enet_peer_dispatch_incoming_reliable_commands (ENetPeer * peer, ENetChannel * channel)
 {
    ENetListIterator currentCommand;

@@ -808,15 +809,15 @@ enet_peer_dispatch_incoming_reliable_commands (ENetPeer * peer, ENetChannel * ch

    enet_list_move (enet_list_end (& peer -> dispatchedCommands), enet_list_begin (& channel -> incomingReliableCommands), enet_list_previous (currentCommand));

-    if (! (peer -> flags & ENET_PEER_FLAG_NEEDS_DISPATCH))
+    if (! peer -> needsDispatch)
    {
       enet_list_insert (enet_list_end (& peer -> host -> dispatchQueue), & peer -> dispatchList);

-       peer -> flags |= ENET_PEER_FLAG_NEEDS_DISPATCH;
+       peer -> needsDispatch = 1;
    }

    if (! enet_list_empty (& channel -> incomingUnreliableCommands))
-       enet_peer_dispatch_incoming_unreliable_commands (peer, channel, queuedCommand);
+       enet_peer_dispatch_incoming_unreliable_commands (peer, channel);
 }

 ENetIncomingCommand *
@@ -974,11 +975,11 @@ enet_peer_queue_incoming_command (ENetPeer * peer, const ENetProtocol * command,
    {
    case ENET_PROTOCOL_COMMAND_SEND_FRAGMENT:
    case ENET_PROTOCOL_COMMAND_SEND_RELIABLE:
-       enet_peer_dispatch_incoming_reliable_commands (peer, channel, incomingCommand);
+       enet_peer_dispatch_incoming_reliable_commands (peer, channel);
       break;

    default:
-       enet_peer_dispatch_incoming_unreliable_commands (peer, channel, incomingCommand);
+       enet_peer_dispatch_incoming_unreliable_commands (peer, channel);
       break;
    }

@@ -48,11 +48,11 @@ enet_protocol_dispatch_state (ENetHost * host, ENetPeer * peer, ENetPeerState st
 {
    enet_protocol_change_state (host, peer, state);

-    if (! (peer -> flags & ENET_PEER_FLAG_NEEDS_DISPATCH))
+    if (! peer -> needsDispatch)
    {
       enet_list_insert (enet_list_end (& host -> dispatchQueue), & peer -> dispatchList);

-       peer -> flags |= ENET_PEER_FLAG_NEEDS_DISPATCH;
+       peer -> needsDispatch = 1;
    }
 }

@@ -63,7 +63,7 @@ enet_protocol_dispatch_incoming_commands (ENetHost * host, ENetEvent * event)
    {
       ENetPeer * peer = (ENetPeer *) enet_list_remove (enet_list_begin (& host -> dispatchQueue));

-       peer -> flags &= ~ ENET_PEER_FLAG_NEEDS_DISPATCH;
+       peer -> needsDispatch = 0;

       switch (peer -> state)
       {
@@ -101,7 +101,7 @@ enet_protocol_dispatch_incoming_commands (ENetHost * host, ENetEvent * event)

           if (! enet_list_empty (& peer -> dispatchedCommands))
           {
-              peer -> flags |= ENET_PEER_FLAG_NEEDS_DISPATCH;
+              peer -> needsDispatch = 1;
         
              enet_list_insert (enet_list_end (& host -> dispatchQueue), & peer -> dispatchList);
           }
@@ -163,10 +163,7 @@ enet_protocol_remove_sent_unreliable_commands (ENetPeer * peer)
 {
    ENetOutgoingCommand * outgoingCommand;

-    if (enet_list_empty (& peer -> sentUnreliableCommands))
-      return;
-
-    do
+    while (! enet_list_empty (& peer -> sentUnreliableCommands))
    {
        outgoingCommand = (ENetOutgoingCommand *) enet_list_front (& peer -> sentUnreliableCommands);
        
@@ -185,12 +182,7 @@ enet_protocol_remove_sent_unreliable_commands (ENetPeer * peer)
        }

        enet_free (outgoingCommand);
-    } while (! enet_list_empty (& peer -> sentUnreliableCommands));
-
-    if (peer -> state == ENET_PEER_STATE_DISCONNECT_LATER &&
-        enet_list_empty (& peer -> outgoingCommands) &&
-        enet_list_empty (& peer -> sentReliableCommands))
-      enet_peer_disconnect (peer, peer -> eventData);
+    }
 }

 static ENetProtocolCommand
@@ -214,15 +206,12 @@ enet_protocol_remove_sent_reliable_command (ENetPeer * peer, enet_uint16 reliabl

    if (currentCommand == enet_list_end (& peer -> sentReliableCommands))
    {
-       for (currentCommand = enet_list_begin (& peer -> outgoingCommands);
-            currentCommand != enet_list_end (& peer -> outgoingCommands);
+       for (currentCommand = enet_list_begin (& peer -> outgoingReliableCommands);
+            currentCommand != enet_list_end (& peer -> outgoingReliableCommands);
            currentCommand = enet_list_next (currentCommand))
       {
          outgoingCommand = (ENetOutgoingCommand *) currentCommand;

-          if (! (outgoingCommand -> command.header.command & ENET_PROTOCOL_COMMAND_FLAG_ACKNOWLEDGE))
-            continue;
-
          if (outgoingCommand -> sendAttempts < 1) return ENET_PROTOCOL_COMMAND_NONE;

          if (outgoingCommand -> reliableSequenceNumber == reliableSequenceNumber &&
@@ -230,7 +219,7 @@ enet_protocol_remove_sent_reliable_command (ENetPeer * peer, enet_uint16 reliabl
            break;
       }

-       if (currentCommand == enet_list_end (& peer -> outgoingCommands))
+       if (currentCommand == enet_list_end (& peer -> outgoingReliableCommands))
         return ENET_PROTOCOL_COMMAND_NONE;

       wasSent = 0;
@@ -309,10 +298,9 @@ enet_protocol_handle_connect (ENetHost * host, ENetProtocolHeader * header, ENet
        }
        else 
        if (currentPeer -> state != ENET_PEER_STATE_CONNECTING &&
-            currentPeer -> address.host == host -> receivedAddress.host)
+            enet_address_equal (& currentPeer -> address, & host -> receivedAddress))
        {
-            if (currentPeer -> address.port == host -> receivedAddress.port &&
-                currentPeer -> connectID == command -> connect.connectID)
+            if (currentPeer -> connectID == command -> connect.connectID)
              return NULL;

            ++ duplicatePeers;
@@ -625,7 +613,7 @@ enet_protocol_handle_send_fragment (ENetHost * host, ENetPeer * peer, const ENet
               fragmentLength);

        if (startCommand -> fragmentsRemaining <= 0)
-          enet_peer_dispatch_incoming_reliable_commands (peer, channel, NULL);
+          enet_peer_dispatch_incoming_reliable_commands (peer, channel);
    }

    return 0;
@@ -743,7 +731,7 @@ enet_protocol_handle_send_unreliable_fragment (ENetHost * host, ENetPeer * peer,
               fragmentLength);

        if (startCommand -> fragmentsRemaining <= 0)
-          enet_peer_dispatch_incoming_unreliable_commands (peer, channel, NULL);
+          enet_peer_dispatch_incoming_unreliable_commands (peer, channel);
    }

    return 0;
@@ -853,53 +841,42 @@ enet_protocol_handle_acknowledge (ENetHost * host, ENetEvent * event, ENetPeer *
    if (ENET_TIME_LESS (host -> serviceTime, receivedSentTime))
      return 0;

+    peer -> lastReceiveTime = host -> serviceTime;
+    peer -> earliestTimeout = 0;
+
    roundTripTime = ENET_TIME_DIFFERENCE (host -> serviceTime, receivedSentTime);
-    roundTripTime = ENET_MAX (roundTripTime, 1);

-    if (peer -> lastReceiveTime > 0)
+    enet_peer_throttle (peer, roundTripTime);
+
+    peer -> roundTripTimeVariance -= peer -> roundTripTimeVariance / 4;
+
+    if (roundTripTime >= peer -> roundTripTime)
    {
-       enet_peer_throttle (peer, roundTripTime);
-
-       peer -> roundTripTimeVariance -= peer -> roundTripTimeVariance / 4;
-
-       if (roundTripTime >= peer -> roundTripTime)
-       {
-          enet_uint32 diff = roundTripTime - peer -> roundTripTime;
-          peer -> roundTripTimeVariance += diff / 4;
-          peer -> roundTripTime += diff / 8;
-       }
-       else
-       {
-          enet_uint32 diff = peer -> roundTripTime - roundTripTime;
-          peer -> roundTripTimeVariance += diff / 4;
-          peer -> roundTripTime -= diff / 8;
-       }
+       peer -> roundTripTime += (roundTripTime - peer -> roundTripTime) / 8;
+       peer -> roundTripTimeVariance += (roundTripTime - peer -> roundTripTime) / 4;
    }
    else
    {
-       peer -> roundTripTime = roundTripTime;
-       peer -> roundTripTimeVariance = (roundTripTime + 1) / 2;
+       peer -> roundTripTime -= (peer -> roundTripTime - roundTripTime) / 8;
+       peer -> roundTripTimeVariance += (peer -> roundTripTime - roundTripTime) / 4;
    }

    if (peer -> roundTripTime < peer -> lowestRoundTripTime)
      peer -> lowestRoundTripTime = peer -> roundTripTime;

-    if (peer -> roundTripTimeVariance > peer -> highestRoundTripTimeVariance)
+    if (peer -> roundTripTimeVariance > peer -> highestRoundTripTimeVariance) 
      peer -> highestRoundTripTimeVariance = peer -> roundTripTimeVariance;

    if (peer -> packetThrottleEpoch == 0 ||
        ENET_TIME_DIFFERENCE (host -> serviceTime, peer -> packetThrottleEpoch) >= peer -> packetThrottleInterval)
    {
        peer -> lastRoundTripTime = peer -> lowestRoundTripTime;
-        peer -> lastRoundTripTimeVariance = ENET_MAX (peer -> highestRoundTripTimeVariance, 1);
+        peer -> lastRoundTripTimeVariance = peer -> highestRoundTripTimeVariance;
        peer -> lowestRoundTripTime = peer -> roundTripTime;
        peer -> highestRoundTripTimeVariance = peer -> roundTripTimeVariance;
        peer -> packetThrottleEpoch = host -> serviceTime;
    }

-    peer -> lastReceiveTime = ENET_MAX (host -> serviceTime, 1);
-    peer -> earliestTimeout = 0;
-
    receivedReliableSequenceNumber = ENET_NET_TO_HOST_16 (command -> acknowledge.receivedReliableSequenceNumber);

    commandNumber = enet_protocol_remove_sent_reliable_command (peer, receivedReliableSequenceNumber, command -> header.channelID);
@@ -921,7 +898,8 @@ enet_protocol_handle_acknowledge (ENetHost * host, ENetEvent * event, ENetPeer *
       break;

    case ENET_PEER_STATE_DISCONNECT_LATER:
-       if (enet_list_empty (& peer -> outgoingCommands) &&
+       if (enet_list_empty (& peer -> outgoingReliableCommands) &&
+           enet_list_empty (& peer -> outgoingUnreliableCommands) &&   
           enet_list_empty (& peer -> sentReliableCommands))
         enet_peer_disconnect (peer, peer -> eventData);
       break;
@@ -1031,9 +1009,7 @@ enet_protocol_handle_incoming_commands (ENetHost * host, ENetEvent * event)

       if (peer -> state == ENET_PEER_STATE_DISCONNECTED ||
           peer -> state == ENET_PEER_STATE_ZOMBIE ||
-           ((host -> receivedAddress.host != peer -> address.host ||
-             host -> receivedAddress.port != peer -> address.port) &&
-             peer -> address.host != ENET_HOST_BROADCAST) ||
+           /* ! enet_address_equal(& host -> receivedAddress, & peer -> address) || */
           (peer -> outgoingPeerID < ENET_PROTOCOL_MAXIMUM_PEER_ID &&
            sessionID != peer -> incomingSessionID))
         return 0;
@@ -1075,8 +1051,7 @@ enet_protocol_handle_incoming_commands (ENetHost * host, ENetEvent * event)
       
    if (peer != NULL)
    {
-       peer -> address.host = host -> receivedAddress.host;
-       peer -> address.port = host -> receivedAddress.port;
+       memcpy(& peer -> address, & host -> receivedAddress, sizeof (host -> receivedAddress));
       peer -> incomingDataTotal += host -> receivedDataLength;
    }
    
@@ -1274,7 +1249,7 @@ enet_protocol_receive_incoming_commands (ENetHost * host, ENetEvent * event)
       }
    }

-    return 0;
+    return -1;
 }

 static void
@@ -1330,6 +1305,107 @@ enet_protocol_send_acknowledgements (ENetHost * host, ENetPeer * peer)
    host -> bufferCount = buffer - host -> buffers;
 }

+static void
+enet_protocol_send_unreliable_outgoing_commands (ENetHost * host, ENetPeer * peer)
+{
+    ENetProtocol * command = & host -> commands [host -> commandCount];
+    ENetBuffer * buffer = & host -> buffers [host -> bufferCount];
+    ENetOutgoingCommand * outgoingCommand;
+    ENetListIterator currentCommand;
+
+    currentCommand = enet_list_begin (& peer -> outgoingUnreliableCommands);
+    
+    while (currentCommand != enet_list_end (& peer -> outgoingUnreliableCommands))
+    {
+       size_t commandSize;
+
+       outgoingCommand = (ENetOutgoingCommand *) currentCommand;
+       commandSize = commandSizes [outgoingCommand -> command.header.command & ENET_PROTOCOL_COMMAND_MASK];
+
+       if (command >= & host -> commands [sizeof (host -> commands) / sizeof (ENetProtocol)] ||
+           buffer + 1 >= & host -> buffers [sizeof (host -> buffers) / sizeof (ENetBuffer)] ||
+           peer -> mtu - host -> packetSize < commandSize ||
+           (outgoingCommand -> packet != NULL &&
+             peer -> mtu - host -> packetSize < commandSize + outgoingCommand -> fragmentLength))
+       {
+          host -> continueSending = 1;
+
+          break;
+       }
+
+       currentCommand = enet_list_next (currentCommand);
+
+       if (outgoingCommand -> packet != NULL && outgoingCommand -> fragmentOffset == 0)
+       {
+          peer -> packetThrottleCounter += ENET_PEER_PACKET_THROTTLE_COUNTER;
+          peer -> packetThrottleCounter %= ENET_PEER_PACKET_THROTTLE_SCALE;
+          
+          if (peer -> packetThrottleCounter > peer -> packetThrottle)
+          {
+             enet_uint16 reliableSequenceNumber = outgoingCommand -> reliableSequenceNumber,
+                         unreliableSequenceNumber = outgoingCommand -> unreliableSequenceNumber;
+             for (;;)
+             {
+                -- outgoingCommand -> packet -> referenceCount;
+
+                if (outgoingCommand -> packet -> referenceCount == 0)
+                  enet_packet_destroy (outgoingCommand -> packet);
+         
+                enet_list_remove (& outgoingCommand -> outgoingCommandList);
+                enet_free (outgoingCommand);
+
+                if (currentCommand == enet_list_end (& peer -> outgoingUnreliableCommands))
+                  break;
+
+                outgoingCommand = (ENetOutgoingCommand *) currentCommand;
+                if (outgoingCommand -> reliableSequenceNumber != reliableSequenceNumber ||
+                    outgoingCommand -> unreliableSequenceNumber != unreliableSequenceNumber)
+                  break;
+
+                currentCommand = enet_list_next (currentCommand);
+             }
+           
+             continue;
+          }
+       }
+
+       buffer -> data = command;
+       buffer -> dataLength = commandSize;
+      
+       host -> packetSize += buffer -> dataLength;
+
+       * command = outgoingCommand -> command;
+       
+       enet_list_remove (& outgoingCommand -> outgoingCommandList);
+
+       if (outgoingCommand -> packet != NULL)
+       {
+          ++ buffer;
+          
+          buffer -> data = outgoingCommand -> packet -> data + outgoingCommand -> fragmentOffset;
+          buffer -> dataLength = outgoingCommand -> fragmentLength;
+
+          host -> packetSize += buffer -> dataLength;
+
+          enet_list_insert (enet_list_end (& peer -> sentUnreliableCommands), outgoingCommand);
+       }
+       else
+         enet_free (outgoingCommand);
+
+       ++ command;
+       ++ buffer;
+    } 
+
+    host -> commandCount = command - host -> commands;
+    host -> bufferCount = buffer - host -> buffers;
+
+    if (peer -> state == ENET_PEER_STATE_DISCONNECT_LATER && 
+        enet_list_empty (& peer -> outgoingReliableCommands) &&
+        enet_list_empty (& peer -> outgoingUnreliableCommands) && 
+        enet_list_empty (& peer -> sentReliableCommands))
+      enet_peer_disconnect (peer, peer -> eventData);
+}
+
 static int
 enet_protocol_check_timeouts (ENetHost * host, ENetPeer * peer, ENetEvent * event)
 {
@@ -1337,7 +1413,7 @@ enet_protocol_check_timeouts (ENetHost * host, ENetPeer * peer, ENetEvent * even
    ENetListIterator currentCommand, insertPosition;

    currentCommand = enet_list_begin (& peer -> sentReliableCommands);
-    insertPosition = enet_list_begin (& peer -> outgoingCommands);
+    insertPosition = enet_list_begin (& peer -> outgoingReliableCommands);

    while (currentCommand != enet_list_end (& peer -> sentReliableCommands))
    {
@@ -1384,7 +1460,7 @@ enet_protocol_check_timeouts (ENetHost * host, ENetPeer * peer, ENetEvent * even
 }

 static int
-enet_protocol_check_outgoing_commands (ENetHost * host, ENetPeer * peer)
+enet_protocol_send_reliable_outgoing_commands (ENetHost * host, ENetPeer * peer)
 {
    ENetProtocol * command = & host -> commands [host -> commandCount];
    ENetBuffer * buffer = & host -> buffers [host -> bufferCount];
@@ -1395,52 +1471,49 @@ enet_protocol_check_outgoing_commands (ENetHost * host, ENetPeer * peer)
    size_t commandSize;
    int windowExceeded = 0, windowWrap = 0, canPing = 1;

-    currentCommand = enet_list_begin (& peer -> outgoingCommands);
+    currentCommand = enet_list_begin (& peer -> outgoingReliableCommands);
    
-    while (currentCommand != enet_list_end (& peer -> outgoingCommands))
+    while (currentCommand != enet_list_end (& peer -> outgoingReliableCommands))
    {
       outgoingCommand = (ENetOutgoingCommand *) currentCommand;

-       if (outgoingCommand -> command.header.command & ENET_PROTOCOL_COMMAND_FLAG_ACKNOWLEDGE)
+       channel = outgoingCommand -> command.header.channelID < peer -> channelCount ? & peer -> channels [outgoingCommand -> command.header.channelID] : NULL;
+       reliableWindow = outgoingCommand -> reliableSequenceNumber / ENET_PEER_RELIABLE_WINDOW_SIZE;
+       if (channel != NULL)
       {
-          channel = outgoingCommand -> command.header.channelID < peer -> channelCount ? & peer -> channels [outgoingCommand -> command.header.channelID] : NULL;
-          reliableWindow = outgoingCommand -> reliableSequenceNumber / ENET_PEER_RELIABLE_WINDOW_SIZE;
-          if (channel != NULL)
+           if (! windowWrap &&      
+               outgoingCommand -> sendAttempts < 1 && 
+               ! (outgoingCommand -> reliableSequenceNumber % ENET_PEER_RELIABLE_WINDOW_SIZE) &&
+               (channel -> reliableWindows [(reliableWindow + ENET_PEER_RELIABLE_WINDOWS - 1) % ENET_PEER_RELIABLE_WINDOWS] >= ENET_PEER_RELIABLE_WINDOW_SIZE ||
+                 channel -> usedReliableWindows & ((((1 << ENET_PEER_FREE_RELIABLE_WINDOWS) - 1) << reliableWindow) | 
+                   (((1 << ENET_PEER_FREE_RELIABLE_WINDOWS) - 1) >> (ENET_PEER_RELIABLE_WINDOWS - reliableWindow)))))
+             windowWrap = 1;
+          if (windowWrap)
          {
-             if (! windowWrap &&      
-                  outgoingCommand -> sendAttempts < 1 && 
-                  ! (outgoingCommand -> reliableSequenceNumber % ENET_PEER_RELIABLE_WINDOW_SIZE) &&
-                  (channel -> reliableWindows [(reliableWindow + ENET_PEER_RELIABLE_WINDOWS - 1) % ENET_PEER_RELIABLE_WINDOWS] >= ENET_PEER_RELIABLE_WINDOW_SIZE ||
-                    channel -> usedReliableWindows & ((((1 << ENET_PEER_FREE_RELIABLE_WINDOWS) - 1) << reliableWindow) | 
-                      (((1 << ENET_PEER_FREE_RELIABLE_WINDOWS) - 1) >> (ENET_PEER_RELIABLE_WINDOWS - reliableWindow)))))
-                windowWrap = 1;
-             if (windowWrap)
-             {
-                currentCommand = enet_list_next (currentCommand);
+             currentCommand = enet_list_next (currentCommand);
 
-                continue;
-             }
+             continue;
          }
- 
-          if (outgoingCommand -> packet != NULL)
-          {
-             if (! windowExceeded)
-             {
-                enet_uint32 windowSize = (peer -> packetThrottle * peer -> windowSize) / ENET_PEER_PACKET_THROTTLE_SCALE;
-             
-                if (peer -> reliableDataInTransit + outgoingCommand -> fragmentLength > ENET_MAX (windowSize, peer -> mtu))
-                  windowExceeded = 1;
-             }
-             if (windowExceeded)
-             {
-                currentCommand = enet_list_next (currentCommand);
-
-                continue;
-             }
-          }
-
-          canPing = 0;
       }
+ 
+       if (outgoingCommand -> packet != NULL)
+       {
+          if (! windowExceeded)
+          {
+             enet_uint32 windowSize = (peer -> packetThrottle * peer -> windowSize) / ENET_PEER_PACKET_THROTTLE_SCALE;
+             
+             if (peer -> reliableDataInTransit + outgoingCommand -> fragmentLength > ENET_MAX (windowSize, peer -> mtu))
+               windowExceeded = 1;
+          }
+          if (windowExceeded)
+          {
+             currentCommand = enet_list_next (currentCommand);
+
+             continue;
+          }
+       }
+
+       canPing = 0;

       commandSize = commandSizes [outgoingCommand -> command.header.command & ENET_PROTOCOL_COMMAND_MASK];
       if (command >= & host -> commands [sizeof (host -> commands) / sizeof (ENetProtocol)] ||
@@ -1456,80 +1529,33 @@ enet_protocol_check_outgoing_commands (ENetHost * host, ENetPeer * peer)

       currentCommand = enet_list_next (currentCommand);

-       if (outgoingCommand -> command.header.command & ENET_PROTOCOL_COMMAND_FLAG_ACKNOWLEDGE)
+       if (channel != NULL && outgoingCommand -> sendAttempts < 1)
       {
-          if (channel != NULL && outgoingCommand -> sendAttempts < 1)
-          {
-             channel -> usedReliableWindows |= 1 << reliableWindow;
-             ++ channel -> reliableWindows [reliableWindow];
-          }
+          channel -> usedReliableWindows |= 1 << reliableWindow;
+          ++ channel -> reliableWindows [reliableWindow];
+       }

-          ++ outgoingCommand -> sendAttempts;
+       ++ outgoingCommand -> sendAttempts;
 
-          if (outgoingCommand -> roundTripTimeout == 0)
-          {
-             outgoingCommand -> roundTripTimeout = peer -> roundTripTime + 4 * peer -> roundTripTimeVariance;
-             outgoingCommand -> roundTripTimeoutLimit = peer -> timeoutLimit * outgoingCommand -> roundTripTimeout;
-          }
-
-          if (enet_list_empty (& peer -> sentReliableCommands))
-            peer -> nextTimeout = host -> serviceTime + outgoingCommand -> roundTripTimeout;
-
-          enet_list_insert (enet_list_end (& peer -> sentReliableCommands),
-                            enet_list_remove (& outgoingCommand -> outgoingCommandList));
-
-          outgoingCommand -> sentTime = host -> serviceTime;
-
-          host -> headerFlags |= ENET_PROTOCOL_HEADER_FLAG_SENT_TIME;
-
-          peer -> reliableDataInTransit += outgoingCommand -> fragmentLength;
-       }
-       else
+       if (outgoingCommand -> roundTripTimeout == 0)
       {
-          if (outgoingCommand -> packet != NULL && outgoingCommand -> fragmentOffset == 0)
-          {
-             peer -> packetThrottleCounter += ENET_PEER_PACKET_THROTTLE_COUNTER;
-             peer -> packetThrottleCounter %= ENET_PEER_PACKET_THROTTLE_SCALE;
-
-             if (peer -> packetThrottleCounter > peer -> packetThrottle)
-             {
-                enet_uint16 reliableSequenceNumber = outgoingCommand -> reliableSequenceNumber,
-                            unreliableSequenceNumber = outgoingCommand -> unreliableSequenceNumber;
-                for (;;)
-                {
-                   -- outgoingCommand -> packet -> referenceCount;
-
-                   if (outgoingCommand -> packet -> referenceCount == 0)
-                     enet_packet_destroy (outgoingCommand -> packet);
-
-                   enet_list_remove (& outgoingCommand -> outgoingCommandList);
-                   enet_free (outgoingCommand);
-
-                   if (currentCommand == enet_list_end (& peer -> outgoingCommands))
-                     break;
-
-                   outgoingCommand = (ENetOutgoingCommand *) currentCommand;
-                   if (outgoingCommand -> reliableSequenceNumber != reliableSequenceNumber ||
-                       outgoingCommand -> unreliableSequenceNumber != unreliableSequenceNumber)
-                     break;
-
-                   currentCommand = enet_list_next (currentCommand);
-                }
-
-                continue;
-             }
-          }
-
-          enet_list_remove (& outgoingCommand -> outgoingCommandList);
-
-          if (outgoingCommand -> packet != NULL)
-            enet_list_insert (enet_list_end (& peer -> sentUnreliableCommands), outgoingCommand);
+          outgoingCommand -> roundTripTimeout = peer -> roundTripTime + 4 * peer -> roundTripTimeVariance;
+          outgoingCommand -> roundTripTimeoutLimit = peer -> timeoutLimit * outgoingCommand -> roundTripTimeout;
       }

+       if (enet_list_empty (& peer -> sentReliableCommands))
+         peer -> nextTimeout = host -> serviceTime + outgoingCommand -> roundTripTimeout;
+
+       enet_list_insert (enet_list_end (& peer -> sentReliableCommands),
+                         enet_list_remove (& outgoingCommand -> outgoingCommandList));
+
+       outgoingCommand -> sentTime = host -> serviceTime;
+
       buffer -> data = command;
       buffer -> dataLength = commandSize;

       host -> packetSize += buffer -> dataLength;
+       host -> headerFlags |= ENET_PROTOCOL_HEADER_FLAG_SENT_TIME;

       * command = outgoingCommand -> command;

@@ -1541,10 +1567,9 @@ enet_protocol_check_outgoing_commands (ENetHost * host, ENetPeer * peer)
          buffer -> dataLength = outgoingCommand -> fragmentLength;

          host -> packetSize += outgoingCommand -> fragmentLength;
+
+          peer -> reliableDataInTransit += outgoingCommand -> fragmentLength;
       }
-       else
-       if (! (outgoingCommand -> command.header.command & ENET_PROTOCOL_COMMAND_FLAG_ACKNOWLEDGE))
-         enet_free (outgoingCommand);

       ++ peer -> packetsSent;
        
@@ -1555,12 +1580,6 @@ enet_protocol_check_outgoing_commands (ENetHost * host, ENetPeer * peer)
    host -> commandCount = command - host -> commands;
    host -> bufferCount = buffer - host -> buffers;

-    if (peer -> state == ENET_PEER_STATE_DISCONNECT_LATER &&
-        enet_list_empty (& peer -> outgoingCommands) &&
-        enet_list_empty (& peer -> sentReliableCommands) &&
-        enet_list_empty (& peer -> sentUnreliableCommands))
-      enet_peer_disconnect (peer, peer -> eventData);
-
    return canPing;
 }

@@ -1604,15 +1623,18 @@ enet_protocol_send_outgoing_commands (ENetHost * host, ENetEvent * event, int ch
              continue;
        }

-        if ((enet_list_empty (& currentPeer -> outgoingCommands) ||
-              enet_protocol_check_outgoing_commands (host, currentPeer)) &&
+        if ((enet_list_empty (& currentPeer -> outgoingReliableCommands) ||
+              enet_protocol_send_reliable_outgoing_commands (host, currentPeer)) &&
            enet_list_empty (& currentPeer -> sentReliableCommands) &&
            ENET_TIME_DIFFERENCE (host -> serviceTime, currentPeer -> lastReceiveTime) >= currentPeer -> pingInterval &&
            currentPeer -> mtu - host -> packetSize >= sizeof (ENetProtocolPing))
        { 
            enet_peer_ping (currentPeer);
-            enet_protocol_check_outgoing_commands (host, currentPeer);
+            enet_protocol_send_reliable_outgoing_commands (host, currentPeer);
        }
+                      
+        if (! enet_list_empty (& currentPeer -> outgoingUnreliableCommands))
+          enet_protocol_send_unreliable_outgoing_commands (host, currentPeer);

        if (host -> commandCount == 0)
          continue;
@@ -1626,11 +1648,21 @@ enet_protocol_send_outgoing_commands (ENetHost * host, ENetEvent * event, int ch
           enet_uint32 packetLoss = currentPeer -> packetsLost * ENET_PEER_PACKET_LOSS_SCALE / currentPeer -> packetsSent;

 #ifdef ENET_DEBUG
-           printf ("peer %u: %f%%+-%f%% packet loss, %u+-%u ms round trip time, %f%% throttle, %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 -> outgoingCommands), currentPeer -> channels != NULL ? enet_list_size (& currentPeer -> channels -> incomingReliableCommands) : 0, currentPeer -> channels != NULL ? enet_list_size (& currentPeer -> channels -> incomingUnreliableCommands) : 0);
+           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, currentPeer -> channels != NULL ? enet_list_size (& currentPeer -> channels -> incomingUnreliableCommands) : 0);
 #endif
+          
+           currentPeer -> packetLossVariance -= currentPeer -> packetLossVariance / 4;

-           currentPeer -> packetLossVariance = (currentPeer -> packetLossVariance * 3 + ENET_DIFFERENCE (packetLoss, currentPeer -> packetLoss)) / 4;
-           currentPeer -> packetLoss = (currentPeer -> packetLoss * 7 + packetLoss) / 8;
+           if (packetLoss >= currentPeer -> packetLoss)
+           {
+              currentPeer -> packetLoss += (packetLoss - currentPeer -> packetLoss) / 8;
+              currentPeer -> packetLossVariance += (packetLoss - currentPeer -> packetLoss) / 4;
+           }
+           else
+           {
+              currentPeer -> packetLoss -= (currentPeer -> packetLoss - packetLoss) / 8;
+              currentPeer -> packetLossVariance += (currentPeer -> packetLoss - packetLoss) / 4;
+           }

           currentPeer -> packetLossEpoch = host -> serviceTime;
           currentPeer -> packetsSent = 0;
@@ -1686,6 +1718,12 @@ enet_protocol_send_outgoing_commands (ENetHost * host, ENetEvent * event, int ch

        currentPeer -> lastSendTime = host -> serviceTime;

+        if (currentPeer -> state == ENET_PEER_STATE_CONNECTING && currentPeer -> packetsLost == 2) {
+            // Disable QoS tagging if we don't get a response to 2 connection requests in a row.
+            // Some networks drop QoS tagged packets, so let's try without it.
+            enet_socket_set_option (host -> socket, ENET_SOCKOPT_QOS, 0);
+        }
+
        sentLength = enet_socket_send (host -> socket, & currentPeer -> address, host -> buffers, host -> bufferCount);

        enet_protocol_remove_sent_unreliable_commands (currentPeer);
@@ -1780,7 +1818,7 @@ enet_host_service (ENetHost * host, ENetEvent * event, enet_uint32 timeout)
    
    timeout += host -> serviceTime;

-    do
+    for (;;)
    {
       if (ENET_TIME_DIFFERENCE (host -> serviceTime, host -> bandwidthThrottleEpoch) >= ENET_HOST_BANDWIDTH_THROTTLE_INTERVAL)
         enet_host_bandwidth_throttle (host);
@@ -1864,13 +1902,13 @@ enet_host_service (ENetHost * host, ENetEvent * event, enet_uint32 timeout)

          waitCondition = ENET_SOCKET_WAIT_RECEIVE | ENET_SOCKET_WAIT_INTERRUPT;

-          if (enet_socket_wait (host -> socket, & waitCondition, ENET_TIME_DIFFERENCE (timeout, host -> serviceTime)) != 0)
+          if (enet_socket_wait (host -> socket, & waitCondition, ENET_TIME_DIFFERENCE (timeout, host -> serviceTime) / 10) != 0)
            return -1;
       }
       while (waitCondition & ENET_SOCKET_WAIT_INTERRUPT);

       host -> serviceTime = enet_time_get ();
-    } while (waitCondition & ENET_SOCKET_WAIT_RECEIVE);
+    }

    return 0; 
 }
@@ -6,8 +6,9 @@

 #include <sys/types.h>
 #include <sys/socket.h>
-#include <sys/ioctl.h>
+#include <sys/select.h>
 #include <sys/time.h>
+#include <arpa/inet.h>
 #include <netinet/tcp.h>
 #include <netdb.h>
 #include <unistd.h>
@@ -18,7 +19,7 @@
 #define ENET_BUILDING_LIB 1
 #include "enet/enet.h"

-#ifdef __APPLE__
+#if defined(__APPLE__)
 #ifdef HAS_POLL
 #undef HAS_POLL
 #endif
@@ -43,20 +44,60 @@
 #ifndef HAS_GETNAMEINFO
 #define HAS_GETNAMEINFO 1
 #endif
+#elif defined(__vita__)
+#ifdef HAS_POLL
+#undef HAS_POLL
+#endif
+#ifdef HAS_FCNTL
+#undef HAS_FCNTL
+#endif
+#ifdef HAS_IOCTL
+#undef HAS_IOCTL
+#endif
+#ifndef HAS_INET_PTON
+#define HAS_INET_PTON 1
+#endif
+#ifndef HAS_INET_NTOP
+#define HAS_INET_NTOP 1
+#endif
+#ifdef HAS_MSGHDR_FLAGS
+#undef HAS_MSGHDR_FLAGS
+#endif
+#ifndef HAS_SOCKLEN_T
+#define HAS_SOCKLEN_T 1
+#endif
+#ifndef HAS_GETADDRINFO
+#define HAS_GETADDRINFO 1
+#endif
+#ifndef HAS_GETNAMEINFO
+#define HAS_GETNAMEINFO 1
+#endif
+#else
+#ifndef HAS_IOCTL
+#define HAS_IOCTL 1
+#endif
 #endif

 #ifdef HAS_FCNTL
 #include <fcntl.h>
 #endif

+#ifdef HAS_IOCTL
+#include <sys/ioctl.h>
+#endif
+
 #ifdef HAS_POLL
-#include <poll.h>
+#include <sys/poll.h>
 #endif

 #ifndef HAS_SOCKLEN_T
 typedef int socklen_t;
 #endif

+#ifndef SOMAXCONN
+#define SOMAXCONN 128
+#endif
+
 #ifndef MSG_NOSIGNAL
 #define MSG_NOSIGNAL 0
 #endif
@@ -77,7 +118,11 @@ enet_deinitialize (void)
 enet_uint32
 enet_host_random_seed (void)
 {
-    return (enet_uint32) time (NULL);
+    struct timeval timeVal;
+    
+    gettimeofday (& timeVal, NULL);
+    
+    return (timeVal.tv_sec * 1000) ^ (timeVal.tv_usec / 1000);
 }

 enet_uint32
@@ -101,186 +146,112 @@ enet_time_set (enet_uint32 newTimeBase)
 }

 int
-enet_address_set_host_ip (ENetAddress * address, const char * name)
+enet_address_equal (ENetAddress * address1, ENetAddress * address2)
 {
-#ifdef HAS_INET_PTON
-    if (! inet_pton (AF_INET, name, & address -> host))
-#else
-    if (! inet_aton (name, (struct in_addr *) & address -> host))
-#endif
-        return -1;
+    if (address1 -> address.ss_family != address2 -> address.ss_family)
+      return 0;

+    switch (address1 -> address.ss_family)
+    {
+    case AF_INET:
+    {
+        struct sockaddr_in *sin1, *sin2;
+        sin1 = (struct sockaddr_in *) & address1 -> address;
+        sin2 = (struct sockaddr_in *) & address2 -> address;
+        return sin1 -> sin_port == sin2 -> sin_port &&
+            sin1 -> sin_addr.s_addr == sin2 -> sin_addr.s_addr;
+    }
+    case AF_INET6:
+    {
+        struct sockaddr_in6 *sin6a, *sin6b;
+        sin6a = (struct sockaddr_in6 *) & address1 -> address;
+        sin6b = (struct sockaddr_in6 *) & address2 -> address;
+        return sin6a -> sin6_port == sin6b -> sin6_port &&
+            ! memcmp (& sin6a -> sin6_addr, & sin6b -> sin6_addr, sizeof (sin6a -> sin6_addr));
+    }
+    default:
+    {
+        return 0;
+    }
+    }
+}
+
+int
+enet_address_set_port (ENetAddress * address, enet_uint16 port)
+{
+    if (address -> address.ss_family == AF_INET)
+    {
+        struct sockaddr_in *sin = (struct sockaddr_in *) &address -> address;
+        sin -> sin_port = ENET_HOST_TO_NET_16 (port);
+        return 0;
+    }
+    else if (address -> address.ss_family == AF_INET6)
+    {
+        struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *) &address -> address;
+        sin6 -> sin6_port = ENET_HOST_TO_NET_16 (port);
+        return 0;
+    }
+    else
+    {
+        return -1;
+    }
+}
+
+int
+enet_address_set_address (ENetAddress * address, struct sockaddr * addr, socklen_t addrlen)
+{
+    if (addrlen > sizeof(struct sockaddr_storage))
+      return -1;
+
+    memcpy (&address->address, addr, addrlen);
+    address->addressLength = addrlen;
    return 0;
 }

 int
 enet_address_set_host (ENetAddress * address, const char * name)
 {
-#ifdef HAS_GETADDRINFO
    struct addrinfo hints, * resultList = NULL, * result = NULL;

    memset (& hints, 0, sizeof (hints));
-    hints.ai_family = AF_INET;
+    hints.ai_family = AF_UNSPEC;
+    hints.ai_flags = AI_ADDRCONFIG;

-    if (getaddrinfo (name, NULL, NULL, & resultList) != 0)
+    if (getaddrinfo (name, NULL, & hints, & resultList) != 0)
      return -1;

    for (result = resultList; result != NULL; result = result -> ai_next)
    {
-        if (result -> ai_family == AF_INET && result -> ai_addr != NULL && result -> ai_addrlen >= sizeof (struct sockaddr_in))
-        {
-            struct sockaddr_in * sin = (struct sockaddr_in *) result -> ai_addr;
-
-            address -> host = sin -> sin_addr.s_addr;
-
-            freeaddrinfo (resultList);
-
-            return 0;
-        }
+        memcpy (& address -> address, result -> ai_addr, result -> ai_addrlen);
+        address -> addressLength = result -> ai_addrlen;
+        
+        freeaddrinfo (resultList);
+        
+        return 0;
    }

    if (resultList != NULL)
      freeaddrinfo (resultList);
-#else
-    struct hostent * hostEntry = NULL;
-#ifdef HAS_GETHOSTBYNAME_R
-    struct hostent hostData;
-    char buffer [2048];
-    int errnum;

-#if defined(linux) || defined(__linux) || defined(__linux__) || defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__DragonFly__)
-    gethostbyname_r (name, & hostData, buffer, sizeof (buffer), & hostEntry, & errnum);
-#else
-    hostEntry = gethostbyname_r (name, & hostData, buffer, sizeof (buffer), & errnum);
-#endif
-#else
-    hostEntry = gethostbyname (name);
-#endif
-
-    if (hostEntry != NULL && hostEntry -> h_addrtype == AF_INET)
-    {
-        address -> host = * (enet_uint32 *) hostEntry -> h_addr_list [0];
-
-        return 0;
-    }
-#endif
-
-    return enet_address_set_host_ip (address, name);
-}
-
-int
-enet_address_get_host_ip (const ENetAddress * address, char * name, size_t nameLength)
-{
-#ifdef HAS_INET_NTOP
-    if (inet_ntop (AF_INET, & address -> host, name, nameLength) == NULL)
-#else
-    char * addr = inet_ntoa (* (struct in_addr *) & address -> host);
-    if (addr != NULL)
-    {
-        size_t addrLen = strlen(addr);
-        if (addrLen >= nameLength)
-          return -1;
-        memcpy (name, addr, addrLen + 1);
-    } 
-    else
-#endif
-        return -1;
-    return 0;
-}
-
-int
-enet_address_get_host (const ENetAddress * address, char * name, size_t nameLength)
-{
-#ifdef HAS_GETNAMEINFO
-    struct sockaddr_in sin;
-    int err;
-
-    memset (& sin, 0, sizeof (struct sockaddr_in));
-
-    sin.sin_family = AF_INET;
-    sin.sin_port = ENET_HOST_TO_NET_16 (address -> port);
-    sin.sin_addr.s_addr = address -> host;
-
-    err = getnameinfo ((struct sockaddr *) & sin, sizeof (sin), name, nameLength, NULL, 0, NI_NAMEREQD);
-    if (! err)
-    {
-        if (name != NULL && nameLength > 0 && ! memchr (name, '\0', nameLength))
-          return -1;
-        return 0;
-    }
-    if (err != EAI_NONAME)
-      return -1;
-#else
-    struct in_addr in;
-    struct hostent * hostEntry = NULL;
-#ifdef HAS_GETHOSTBYADDR_R
-    struct hostent hostData;
-    char buffer [2048];
-    int errnum;
-
-    in.s_addr = address -> host;
-
-#if defined(linux) || defined(__linux) || defined(__linux__) || defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__DragonFly__)
-    gethostbyaddr_r ((char *) & in, sizeof (struct in_addr), AF_INET, & hostData, buffer, sizeof (buffer), & hostEntry, & errnum);
-#else
-    hostEntry = gethostbyaddr_r ((char *) & in, sizeof (struct in_addr), AF_INET, & hostData, buffer, sizeof (buffer), & errnum);
-#endif
-#else
-    in.s_addr = address -> host;
-
-    hostEntry = gethostbyaddr ((char *) & in, sizeof (struct in_addr), AF_INET);
-#endif
-
-    if (hostEntry != NULL)
-    {
-       size_t hostLen = strlen (hostEntry -> h_name);
-       if (hostLen >= nameLength)
-         return -1;
-       memcpy (name, hostEntry -> h_name, hostLen + 1);
-       return 0;
-    }
-#endif
-
-    return enet_address_get_host_ip (address, name, nameLength);
+    return -1;
 }

 int
 enet_socket_bind (ENetSocket socket, const ENetAddress * address)
 {
-    struct sockaddr_in sin;
-
-    memset (& sin, 0, sizeof (struct sockaddr_in));
-
-    sin.sin_family = AF_INET;
-
-    if (address != NULL)
-    {
-       sin.sin_port = ENET_HOST_TO_NET_16 (address -> port);
-       sin.sin_addr.s_addr = address -> host;
-    }
-    else
-    {
-       sin.sin_port = 0;
-       sin.sin_addr.s_addr = INADDR_ANY;
-    }
-
    return bind (socket,
-                 (struct sockaddr *) & sin,
-                 sizeof (struct sockaddr_in)); 
+        (struct sockaddr *) & address -> address,
+        address -> addressLength);
 }

 int
 enet_socket_get_address (ENetSocket socket, ENetAddress * address)
 {
-    struct sockaddr_in sin;
-    socklen_t sinLength = sizeof (struct sockaddr_in);
+    address -> addressLength = sizeof (address -> address);

-    if (getsockname (socket, (struct sockaddr *) & sin, & sinLength) == -1)
+    if (getsockname (socket, (struct sockaddr *) & address -> address, & address -> addressLength) == -1)
      return -1;

-    address -> host = (enet_uint32) sin.sin_addr.s_addr;
-    address -> port = ENET_NET_TO_HOST_16 (sin.sin_port);
-
    return 0;
 }

@@ -291,9 +262,9 @@ enet_socket_listen (ENetSocket socket, int backlog)
 }

 ENetSocket
-enet_socket_create (ENetSocketType type)
+enet_socket_create (int af, ENetSocketType type)
 {
-    return socket (PF_INET, type == ENET_SOCKET_TYPE_DATAGRAM ? SOCK_DGRAM : SOCK_STREAM, 0);
+    return socket (af, type == ENET_SOCKET_TYPE_DATAGRAM ? SOCK_DGRAM : SOCK_STREAM, 0);
 }

 int
@@ -306,12 +277,12 @@ enet_socket_set_option (ENetSocket socket, ENetSocketOption option, int value)
 #ifdef HAS_FCNTL
            result = fcntl (socket, F_SETFL, (value ? O_NONBLOCK : 0) | (fcntl (socket, F_GETFL) & ~O_NONBLOCK));
 #else
+#ifdef HAS_IOCTL
            result = ioctl (socket, FIONBIO, & value);
+#else
+            result = setsockopt (socket, SOL_SOCKET, SO_NONBLOCK, (char *) & value, sizeof(int));
+#endif
 #endif
-            break;
-
-        case ENET_SOCKOPT_BROADCAST:
-            result = setsockopt (socket, SOL_SOCKET, SO_BROADCAST, (char *) & value, sizeof (int));
            break;

        case ENET_SOCKOPT_REUSEADDR:
@@ -348,6 +319,30 @@ enet_socket_set_option (ENetSocket socket, ENetSocketOption option, int value)
            result = setsockopt (socket, IPPROTO_TCP, TCP_NODELAY, (char *) & value, sizeof (int));
            break;

+        case ENET_SOCKOPT_QOS:
+#ifdef SO_NET_SERVICE_TYPE
+            // iOS/macOS
+            value = value ? NET_SERVICE_TYPE_VO : NET_SERVICE_TYPE_BE;
+            result = setsockopt (socket, SOL_SOCKET, SO_NET_SERVICE_TYPE, (char *) & value, sizeof (int));
+#else
+#ifdef IP_TOS
+            // UNIX - IPv4
+            value = value ? (46 << 2 | 0x01) : 0; // DSCP: Expedited Forwarding + ECT(1) (L4S)
+            result = setsockopt (socket, IPPROTO_IP, IP_TOS, (char *) & value, sizeof (int));
+#endif
+#ifdef IPV6_TCLASS
+            // UNIX - IPv6
+            value = value ? (46 << 2 | 0x01): 0; // DSCP: Expedited Forwarding + ECT(1) (L4S)
+            result = setsockopt (socket, IPPROTO_IPV6, IPV6_TCLASS, (char *) & value, sizeof (int));
+#endif
+#ifdef SO_PRIORITY
+            // Linux
+            value = value ? 6 : 0; // Max priority without NET_CAP_ADMIN
+            result = setsockopt (socket, SOL_SOCKET, SO_PRIORITY, (char *) & value, sizeof (int));
+#endif
+#endif /* SO_NET_SERVICE_TYPE */
+            break;
+
        default:
            break;
    }
@@ -375,16 +370,9 @@ enet_socket_get_option (ENetSocket socket, ENetSocketOption option, int * value)
 int
 enet_socket_connect (ENetSocket socket, const ENetAddress * address)
 {
-    struct sockaddr_in sin;
    int result;

-    memset (& sin, 0, sizeof (struct sockaddr_in));
-
-    sin.sin_family = AF_INET;
-    sin.sin_port = ENET_HOST_TO_NET_16 (address -> port);
-    sin.sin_addr.s_addr = address -> host;
-
-    result = connect (socket, (struct sockaddr *) & sin, sizeof (struct sockaddr_in));
+    result = connect (socket, (struct sockaddr *) & address -> address, address -> addressLength);
    if (result == -1 && errno == EINPROGRESS)
      return 0;

@@ -395,25 +383,20 @@ ENetSocket
 enet_socket_accept (ENetSocket socket, ENetAddress * address)
 {
    int result;
-    struct sockaddr_in sin;
-    socklen_t sinLength = sizeof (struct sockaddr_in);
+
+    if (address != NULL)
+      address -> addressLength = sizeof (address -> address);

    result = accept (socket, 
-                     address != NULL ? (struct sockaddr *) & sin : NULL, 
-                     address != NULL ? & sinLength : NULL);
+                     address != NULL ? (struct sockaddr *) & address -> address : NULL, 
+                     address != NULL ? & address -> addressLength : NULL);
    
    if (result == -1)
      return ENET_SOCKET_NULL;

-    if (address != NULL)
-    {
-        address -> host = (enet_uint32) sin.sin_addr.s_addr;
-        address -> port = ENET_NET_TO_HOST_16 (sin.sin_port);
-    }
-
    return result;
-} 
-    
+}
+
 int
 enet_socket_shutdown (ENetSocket socket, ENetSocketShutdown how)
 {
@@ -433,28 +416,60 @@ enet_socket_send (ENetSocket socket,
                  const ENetBuffer * buffers,
                  size_t bufferCount)
 {
-    struct msghdr msgHdr;
-    struct sockaddr_in sin;
    int sentLength;
+    
+#ifdef NO_MSGAPI
+    void* sendBuffer;
+    size_t sendLength;
+    
+    if (bufferCount > 1)
+    {
+        size_t i;
+        
+        sendLength = 0;
+        for (i = 0; i < bufferCount; i++)
+        {
+            sendLength += buffers[i].dataLength;
+        }
+        
+        sendBuffer = malloc (sendLength);
+        if (sendBuffer == NULL)
+          return -1;
+        
+        sendLength = 0;
+        for (i = 0; i < bufferCount; i++)
+        {
+            memcpy (& ((unsigned char *)sendBuffer)[sendLength], buffers[i].data, buffers[i].dataLength);
+            sendLength += buffers[i].dataLength;
+        }
+    }
+    else
+    {
+        sendBuffer = buffers[0].data;
+        sendLength = buffers[0].dataLength;
+    }
+    
+    sentLength = sendto (socket, sendBuffer, sendLength, MSG_NOSIGNAL,
+        (struct sockaddr *) & address -> address, address -> addressLength);
+        
+    if (bufferCount > 1)
+      free(sendBuffer);
+#else
+    struct msghdr msgHdr;

    memset (& msgHdr, 0, sizeof (struct msghdr));

    if (address != NULL)
    {
-        memset (& sin, 0, sizeof (struct sockaddr_in));
-
-        sin.sin_family = AF_INET;
-        sin.sin_port = ENET_HOST_TO_NET_16 (address -> port);
-        sin.sin_addr.s_addr = address -> host;
-
-        msgHdr.msg_name = & sin;
-        msgHdr.msg_namelen = sizeof (struct sockaddr_in);
+        msgHdr.msg_name = (void*) & address -> address;
+        msgHdr.msg_namelen = address -> addressLength;
    }

    msgHdr.msg_iov = (struct iovec *) buffers;
    msgHdr.msg_iovlen = bufferCount;

    sentLength = sendmsg (socket, & msgHdr, MSG_NOSIGNAL);
+#endif
    
    if (sentLength == -1)
    {
@@ -473,16 +488,33 @@ enet_socket_receive (ENetSocket socket,
                     ENetBuffer * buffers,
                     size_t bufferCount)
 {
-    struct msghdr msgHdr;
-    struct sockaddr_in sin;
    int recvLength;

+#ifdef NO_MSGAPI
+    // This will ONLY work with a single buffer!
+    
+    address -> addressLength = sizeof (address -> address);
+    recvLength = recvfrom (socket, buffers[0].data, buffers[0].dataLength, MSG_NOSIGNAL,
+        (struct sockaddr *) & address -> address, & address -> addressLength);
+    
+    if (recvLength == -1)
+    {
+       if (errno == EWOULDBLOCK)
+         return 0;
+     
+       return -1;
+    }
+    
+    return recvLength;
+#else
+    struct msghdr msgHdr;
+
    memset (& msgHdr, 0, sizeof (struct msghdr));

    if (address != NULL)
    {
-        msgHdr.msg_name = & sin;
-        msgHdr.msg_namelen = sizeof (struct sockaddr_in);
+        msgHdr.msg_name = & address -> address;
+        msgHdr.msg_namelen = sizeof (address -> address);
    }

    msgHdr.msg_iov = (struct iovec *) buffers;
@@ -497,19 +529,17 @@ enet_socket_receive (ENetSocket socket,

       return -1;
    }
+    
+    if (address != NULL)
+      address -> addressLength = msgHdr.msg_namelen;

 #ifdef HAS_MSGHDR_FLAGS
    if (msgHdr.msg_flags & MSG_TRUNC)
      return -1;
 #endif

-    if (address != NULL)
-    {
-        address -> host = (enet_uint32) sin.sin_addr.s_addr;
-        address -> port = ENET_NET_TO_HOST_16 (sin.sin_port);
-    }
-
    return recvLength;
+#endif
 }

 int
@@ -8,20 +8,24 @@
 #include "enet/enet.h"
 #include <windows.h>
 #include <mmsystem.h>
+#include <qos2.h>

 static enet_uint32 timeBase = 0;
+static HANDLE qosHandle = INVALID_HANDLE_VALUE;
+static QOS_FLOWID qosFlowId;
+static BOOL qosAddedFlow;

 int
 enet_initialize (void)
 {
-    WORD versionRequested = MAKEWORD (1, 1);
+    WORD versionRequested = MAKEWORD (2, 0);
    WSADATA wsaData;
   
    if (WSAStartup (versionRequested, & wsaData))
       return -1;

-    if (LOBYTE (wsaData.wVersion) != 1||
-        HIBYTE (wsaData.wVersion) != 1)
+    if (LOBYTE (wsaData.wVersion) != 2||
+        HIBYTE (wsaData.wVersion) != 0)
    {
       WSACleanup ();
       
@@ -36,6 +40,15 @@ enet_initialize (void)
 void
 enet_deinitialize (void)
 {
+    qosAddedFlow = FALSE;
+    qosFlowId = 0;
+
+    if (qosHandle != INVALID_HANDLE_VALUE)
+    {
+        QOSCloseHandle(qosHandle);
+        qosHandle = INVALID_HANDLE_VALUE;
+    }
+
    timeEndPeriod (1);

    WSACleanup ();
@@ -60,121 +73,112 @@ enet_time_set (enet_uint32 newTimeBase)
 }

 int
-enet_address_set_host_ip (ENetAddress * address, const char * name)
+enet_address_set_port (ENetAddress * address, enet_uint16 port)
 {
-    enet_uint8 vals [4] = { 0, 0, 0, 0 };
-    int i;
-
-    for (i = 0; i < 4; ++ i)
+    if (address -> address.ss_family == AF_INET)
    {
-        const char * next = name + 1;
-        if (* name != '0')
-        {
-            long val = strtol (name, (char **) & next, 10);
-            if (val < 0 || val > 255 || next == name || next - name > 3)
-              return -1;
-            vals [i] = (enet_uint8) val;
-        }
-
-        if (* next != (i < 3 ? '.' : '\0'))
-          return -1;
-        name = next + 1;
+        struct sockaddr_in *sin = (struct sockaddr_in *) &address -> address;
+        sin -> sin_port = ENET_HOST_TO_NET_16 (port);
+        return 0;
    }
+    else if (address -> address.ss_family == AF_INET6)
+    {
+        struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *) &address -> address;
+        sin6 -> sin6_port = ENET_HOST_TO_NET_16 (port);
+        return 0;
+    }
+    else
+    {
+        return -1;
+    }
+}

-    memcpy (& address -> host, vals, sizeof (enet_uint32));
+int
+enet_address_set_address (ENetAddress * address, struct sockaddr * addr, socklen_t addrlen)
+{
+    if (addrlen > sizeof(struct sockaddr_storage))
+      return -1;
+
+    memcpy (&address->address, addr, addrlen);
+    address->addressLength = addrlen;
    return 0;
 }

+int
+enet_address_equal (ENetAddress * address1, ENetAddress * address2)
+{
+    if (address1 -> address.ss_family != address2 -> address.ss_family)
+      return 0;
+
+    switch (address1 -> address.ss_family)
+    {
+    case AF_INET:
+    {
+        struct sockaddr_in *sin1, *sin2;
+        sin1 = (struct sockaddr_in *) & address1 -> address;
+        sin2 = (struct sockaddr_in *) & address2 -> address;
+        return sin1 -> sin_port == sin2 -> sin_port &&
+            sin1 -> sin_addr.S_un.S_addr == sin2 -> sin_addr.S_un.S_addr;
+    }
+    case AF_INET6:
+    {
+        struct sockaddr_in6 *sin6a, *sin6b;
+        sin6a = (struct sockaddr_in6 *) & address1 -> address;
+        sin6b = (struct sockaddr_in6 *) & address2 -> address;
+        return sin6a -> sin6_port == sin6b -> sin6_port &&
+            ! memcmp (& sin6a -> sin6_addr, & sin6b -> sin6_addr, sizeof (sin6a -> sin6_addr));
+    }
+    default:
+    {
+        return 0;
+    }
+    }
+}
+
 int
 enet_address_set_host (ENetAddress * address, const char * name)
 {
-    struct hostent * hostEntry;
+    struct addrinfo hints, * resultList = NULL, * result = NULL;

-    hostEntry = gethostbyname (name);
-    if (hostEntry == NULL ||
-        hostEntry -> h_addrtype != AF_INET)
-      return enet_address_set_host_ip (address, name);
+    memset (& hints, 0, sizeof (hints));
+    hints.ai_family = AF_UNSPEC;
+    hints.ai_flags = AI_ADDRCONFIG;

-    address -> host = * (enet_uint32 *) hostEntry -> h_addr_list [0];
+    if (getaddrinfo (name, NULL, & hints, & resultList) != 0)
+      return -1;

-    return 0;
-}
-
-int
-enet_address_get_host_ip (const ENetAddress * address, char * name, size_t nameLength)
-{
-    char * addr = inet_ntoa (* (struct in_addr *) & address -> host);
-    if (addr == NULL)
-        return -1;
-    else
+    for (result = resultList; result != NULL; result = result -> ai_next)
    {
-        size_t addrLen = strlen(addr);
-        if (addrLen >= nameLength)
-          return -1;
-        memcpy (name, addr, addrLen + 1);
-    }
-    return 0;
-}
-
-int
-enet_address_get_host (const ENetAddress * address, char * name, size_t nameLength)
-{
-    struct in_addr in;
-    struct hostent * hostEntry;
- 
-    in.s_addr = address -> host;
-    
-    hostEntry = gethostbyaddr ((char *) & in, sizeof (struct in_addr), AF_INET);
-    if (hostEntry == NULL)
-      return enet_address_get_host_ip (address, name, nameLength);
-    else
-    {
-       size_t hostLen = strlen (hostEntry -> h_name);
-       if (hostLen >= nameLength)
-         return -1;
-       memcpy (name, hostEntry -> h_name, hostLen + 1);
+        memcpy (& address -> address, result -> ai_addr, result -> ai_addrlen);
+        address -> addressLength = result -> ai_addrlen;
+        
+        freeaddrinfo (resultList);
+        
+        return 0;
    }

-    return 0;
+    if (resultList != NULL)
+      freeaddrinfo (resultList);
+
+    return -1;
 }

 int
 enet_socket_bind (ENetSocket socket, const ENetAddress * address)
 {
-    struct sockaddr_in sin;
-
-    memset (& sin, 0, sizeof (struct sockaddr_in));
-
-    sin.sin_family = AF_INET;
-
-    if (address != NULL)
-    {
-       sin.sin_port = ENET_HOST_TO_NET_16 (address -> port);
-       sin.sin_addr.s_addr = address -> host;
-    }
-    else
-    {
-       sin.sin_port = 0;
-       sin.sin_addr.s_addr = INADDR_ANY;
-    }
-
    return bind (socket,
-                 (struct sockaddr *) & sin,
-                 sizeof (struct sockaddr_in)) == SOCKET_ERROR ? -1 : 0;
+        (struct sockaddr *) & address -> address,
+        address -> addressLength);
 }

 int
 enet_socket_get_address (ENetSocket socket, ENetAddress * address)
 {
-    struct sockaddr_in sin;
-    int sinLength = sizeof (struct sockaddr_in);
+    address -> addressLength = sizeof (address -> address);

-    if (getsockname (socket, (struct sockaddr *) & sin, & sinLength) == -1)
+    if (getsockname (socket, (struct sockaddr *) & address -> address, & address -> addressLength) == -1)
      return -1;

-    address -> host = (enet_uint32) sin.sin_addr.s_addr;
-    address -> port = ENET_NET_TO_HOST_16 (sin.sin_port);
-
    return 0;
 }

@@ -185,9 +189,9 @@ enet_socket_listen (ENetSocket socket, int backlog)
 }

 ENetSocket
-enet_socket_create (ENetSocketType type)
+enet_socket_create (int af, ENetSocketType type)
 {
-    return socket (PF_INET, type == ENET_SOCKET_TYPE_DATAGRAM ? SOCK_DGRAM : SOCK_STREAM, 0);
+    return socket (af, type == ENET_SOCKET_TYPE_DATAGRAM ? SOCK_DGRAM : SOCK_STREAM, 0);
 }

 int
@@ -203,10 +207,6 @@ enet_socket_set_option (ENetSocket socket, ENetSocketOption option, int value)
            break;
        }

-        case ENET_SOCKOPT_BROADCAST:
-            result = setsockopt (socket, SOL_SOCKET, SO_BROADCAST, (char *) & value, sizeof (int));
-            break;
-
        case ENET_SOCKOPT_REUSEADDR:
            result = setsockopt (socket, SOL_SOCKET, SO_REUSEADDR, (char *) & value, sizeof (int));
            break;
@@ -231,6 +231,32 @@ enet_socket_set_option (ENetSocket socket, ENetSocketOption option, int value)
            result = setsockopt (socket, IPPROTO_TCP, TCP_NODELAY, (char *) & value, sizeof (int));
            break;

+        case ENET_SOCKOPT_QOS:
+        {
+            if (value)
+            {
+                QOS_VERSION qosVersion;
+
+                qosVersion.MajorVersion = 1;
+                qosVersion.MinorVersion = 0;
+                if (!QOSCreateHandle(&qosVersion, &qosHandle))
+                {
+                    qosHandle = INVALID_HANDLE_VALUE;
+                }
+            }
+            else if (qosHandle != INVALID_HANDLE_VALUE)
+            {
+                QOSCloseHandle(qosHandle);
+                qosHandle = INVALID_HANDLE_VALUE;
+            }
+
+            qosAddedFlow = FALSE;
+            qosFlowId = 0;
+
+            result = 0;
+            break;
+        }
+
        default:
            break;
    }
@@ -257,16 +283,9 @@ enet_socket_get_option (ENetSocket socket, ENetSocketOption option, int * value)
 int
 enet_socket_connect (ENetSocket socket, const ENetAddress * address)
 {
-    struct sockaddr_in sin;
    int result;

-    memset (& sin, 0, sizeof (struct sockaddr_in));
-
-    sin.sin_family = AF_INET;
-    sin.sin_port = ENET_HOST_TO_NET_16 (address -> port);
-    sin.sin_addr.s_addr = address -> host;
-
-    result = connect (socket, (struct sockaddr *) & sin, sizeof (struct sockaddr_in));
+    result = connect (socket, (struct sockaddr *) & address -> address, address -> addressLength);
    if (result == SOCKET_ERROR && WSAGetLastError () != WSAEWOULDBLOCK)
      return -1;

@@ -276,22 +295,17 @@ enet_socket_connect (ENetSocket socket, const ENetAddress * address)
 ENetSocket
 enet_socket_accept (ENetSocket socket, ENetAddress * address)
 {
-    SOCKET result;
-    struct sockaddr_in sin;
-    int sinLength = sizeof (struct sockaddr_in);
-
-    result = accept (socket, 
-                     address != NULL ? (struct sockaddr *) & sin : NULL, 
-                     address != NULL ? & sinLength : NULL);
-
-    if (result == INVALID_SOCKET)
-      return ENET_SOCKET_NULL;
+    int result;

    if (address != NULL)
-    {
-        address -> host = (enet_uint32) sin.sin_addr.s_addr;
-        address -> port = ENET_NET_TO_HOST_16 (sin.sin_port);
-    }
+      address -> addressLength = sizeof (address -> address);
+
+    result = accept (socket, 
+                     address != NULL ? (struct sockaddr *) & address -> address : NULL, 
+                     address != NULL ? & address -> addressLength : NULL);
+    
+    if (result == -1)
+      return ENET_SOCKET_NULL;

    return result;
 }
@@ -315,16 +329,20 @@ enet_socket_send (ENetSocket socket,
                  const ENetBuffer * buffers,
                  size_t bufferCount)
 {
-    struct sockaddr_in sin;
-    DWORD sentLength = 0;
+    DWORD sentLength;

-    if (address != NULL)
+    if (!qosAddedFlow && qosHandle != INVALID_HANDLE_VALUE)
    {
-        memset (& sin, 0, sizeof (struct sockaddr_in));
+        qosFlowId = 0; // Must be initialized to 0
+        QOSAddSocketToFlow(qosHandle,
+                           socket,
+                           (struct sockaddr *)&address->address,
+                           QOSTrafficTypeControl,
+                           QOS_NON_ADAPTIVE_FLOW,
+                           &qosFlowId);

-        sin.sin_family = AF_INET;
-        sin.sin_port = ENET_HOST_TO_NET_16 (address -> port);
-        sin.sin_addr.s_addr = address -> host;
+        // Even if we failed, don't try again
+        qosAddedFlow = TRUE;
    }

    if (WSASendTo (socket, 
@@ -332,8 +350,8 @@ enet_socket_send (ENetSocket socket,
                   (DWORD) bufferCount,
                   & sentLength,
                   0,
-                   address != NULL ? (struct sockaddr *) & sin : NULL,
-                   address != NULL ? sizeof (struct sockaddr_in) : 0,
+                   address != NULL ? (struct sockaddr *) & address -> address : NULL,
+                   address != NULL ? address -> addressLength : 0,
                   NULL,
                   NULL) == SOCKET_ERROR)
    {
@@ -352,18 +370,19 @@ enet_socket_receive (ENetSocket socket,
                     ENetBuffer * buffers,
                     size_t bufferCount)
 {
-    INT sinLength = sizeof (struct sockaddr_in);
    DWORD flags = 0,
-          recvLength = 0;
-    struct sockaddr_in sin;
+          recvLength;
+    
+    if (address != NULL)
+      address -> addressLength = sizeof (address -> address);

    if (WSARecvFrom (socket,
                     (LPWSABUF) buffers,
                     (DWORD) bufferCount,
                     & recvLength,
                     & flags,
-                     address != NULL ? (struct sockaddr *) & sin : NULL,
-                     address != NULL ? & sinLength : NULL,
+                     address != NULL ? (struct sockaddr *) & address -> address : NULL,
+                     address != NULL ? & address -> addressLength : NULL,
                     NULL,
                     NULL) == SOCKET_ERROR)
    {
@@ -380,12 +399,6 @@ enet_socket_receive (ENetSocket socket,
    if (flags & MSG_PARTIAL)
      return -1;

-    if (address != NULL)
-    {
-        address -> host = (enet_uint32) sin.sin_addr.s_addr;
-        address -> port = ENET_NET_TO_HOST_16 (sin.sin_port);
-    }
-
    return (int) recvLength;
 }
Author	SHA1	Message	Date
Cameron Gutman	299ab267c9	Enable ECN/L4S on UNIX Since this is enabled as a QoS option, it will benefit from the opportunistic disablement code when ECN-intolerant networks are encountered.	2024-02-03 14:32:25 -06:00
Cameron Gutman	9bf55a3433	Disable QoS tagging if 2 connect packets in a row are dropped	2020-06-12 21:16:46 -07:00
Cameron Gutman	5c96da29c2	Enable QoS prioritization on Windows	2020-04-09 17:42:12 -07:00
Cameron Gutman	d988023971	Use EF instead of CS7 for DSCP Some security guidelines recommend dropping CS7 tagged packets at the edge, since CS7 is reserved for network control. EF seems to be the standard for telephony applications and is fairly well preserved across the Internet per https://www.sciencedirect.com/science/article/pii/S0166531619300203	2020-04-03 16:58:18 -07:00
Cameron Gutman	637cd52e96	Enable QoS prioritization on Linux	2020-03-29 15:44:14 -07:00
Cameron Gutman	512b3f26f9	Enable QOS prioritization on macOS	2020-03-29 15:21:26 -07:00
Cameron Gutman	5503534362	Fix Linux build	2019-10-12 19:41:41 -07:00
Sunguk Lee	93b080b053	vita: No more need vita specific codesets (#4 ) * vita: No more need to define sockaddr_storage * vita: Remove everything and combine unix codeset * unix: Remove HACK for the specialized code of the vita nonblock IO	2019-10-12 15:10:59 -07:00
Cameron Gutman	cf38f85e08	Be more lenient with the expected peer address for multi-homed hosts	2019-09-14 14:05:05 -07:00
Cameron Gutman	e770a52bca	Merge pull request #3 from d3m3vilurr/fix-vita-error-code vita: No more use self defined net error code	2019-02-17 09:49:11 -08:00
Sunguk Lee	42891f6919	vita: No more use self defined net error code	2018-07-28 21:50:59 +09:00
Antonio Aloisio	eb38c3c737	Fixed build with latest VitaSDK (#2 )	2018-07-25 21:27:12 -07:00
Sunguk Lee	e33ca1dc47	Add vita environment (#1 ) * vita: Initial port * vita: add debug logging and reduce max number of IOV (caused errors) * vita: now using newlib's socket apis * vita: Refactoring for cgutman/enet * Fix review things https://github.com/cgutman/enet/pull/1#pullrequestreview-2436331	2016-10-02 00:56:59 -07:00
Cameron Gutman	7546b505c1	Lower ENet's MTU to 900 because some ISPs will drop the RTSP DESCRIBE response packets with the default MTU	2016-05-21 18:01:31 -05:00
Cameron Gutman	2bc07bb50d	Add enet_address_set_address() function to allow ENetAddress to be populated from sockaddr directly	2016-04-02 14:04:31 -04:00
Cameron Gutman	a602abf244	Switch to gettimeofday() for seeding on UNIX	2016-03-31 11:22:06 -04:00
Cameron Gutman	167f41aa2b	Fix build with NO_MSGAPI undefined	2016-03-27 22:47:50 -04:00
Cameron Gutman	b2ee3b7b48	Add support for building with PNaCl's newlibc	2016-03-11 00:27:48 -08:00
Cameron Gutman	8b24595dbd	Require an address family to be specified when creating a host	2016-03-07 14:26:13 -08:00
Cameron Gutman	b3e34fa1db	Fix some IPv6 compatibility issues	2016-03-06 23:22:59 -08:00
Cameron Gutman	4f7ef11c23	Fix some compilation warnings	2016-03-06 15:33:32 -08:00
Cameron Gutman	a39d3bb49c	Wake up every once in a while to see if any retransmissions or pings need to be sent	2016-03-06 14:56:08 -08:00
Cameron Gutman	ae9002fe19	Protocol agnostic socket address to fix IPv6 and remove broadcast support	2016-03-06 14:47:01 -08:00