Revert "code: updated enet dependency"

This reverts commit 947a6992cc.

code/vendors/enet.h

@@ -35,15 +35,14 @@
 #ifndef ENET_INCLUDE_H
 #define ENET_INCLUDE_H
 
-#include <assert.h>
 #include <stdlib.h>
 #include <stdbool.h>
 #include <stdint.h>
 #include <time.h>
 
 #define ENET_VERSION_MAJOR 2
-#define ENET_VERSION_MINOR 3
+#define ENET_VERSION_MINOR 2
-#define ENET_VERSION_PATCH 4
+#define ENET_VERSION_PATCH 1
 #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)
@@ -84,9 +83,9 @@
     #endif
 
     #ifdef __GNUC__
-    #if (_WIN32_WINNT < 0x0600)
+    #if (_WIN32_WINNT < 0x0501)
     #undef _WIN32_WINNT
-    #define _WIN32_WINNT 0x0600
+    #define _WIN32_WINNT 0x0501
     #endif
     #endif
 
@@ -193,15 +192,6 @@
     #define ENET_SOCKETSET_CHECK(sockset, socket)  FD_ISSET(socket, &(sockset))
 #endif
 
-#ifdef __GNUC__
-#define ENET_DEPRECATED(func) func __attribute__ ((deprecated))
-#elif defined(_MSC_VER)
-#define ENET_DEPRECATED(func) __declspec(deprecated) func
-#else
-#pragma message("WARNING: Please ENET_DEPRECATED for this compiler")
-#define ENET_DEPRECATED(func) func
-#endif
-
 #ifndef ENET_BUFFER_MAXIMUM
 #define ENET_BUFFER_MAXIMUM (1 + 2 * ENET_PROTOCOL_MAXIMUM_PACKET_COMMANDS)
 #endif
@@ -212,12 +202,6 @@
 #define ENET_MIN(x, y) ((x) < (y) ? (x) : (y))
 
 #define ENET_IPV6           1
-static const struct in6_addr enet_v4_anyaddr   = {{{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00 }}};
-static const struct in6_addr enet_v4_noaddr    = {{{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff }}};
-static const struct in6_addr enet_v4_localhost = {{{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x7f, 0x00, 0x00, 0x01 }}};
-static const struct in6_addr enet_v6_anyaddr   = {{{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }}};
-static const struct in6_addr enet_v6_noaddr    = {{{ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff }}};
-static const struct in6_addr enet_v6_localhost = {{{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01 }}};
 #define ENET_HOST_ANY       in6addr_any
 #define ENET_HOST_BROADCAST 0xFFFFFFFFU
 #define ENET_PORT_ANY       0
@@ -252,7 +236,6 @@ extern "C" {
     extern void *enet_malloc(size_t);
     extern void enet_free(void *);
     extern ENetPacket* enet_packet_create(const void*,size_t,enet_uint32);
-    extern ENetPacket* enet_packet_copy(ENetPacket*);
     extern void enet_packet_destroy(ENetPacket*);
 
 // =======================================================================//
@@ -902,7 +885,7 @@ extern "C" {
         @retval < 0 on failure
         @returns the address of the given hostName in address on success
     */
-    ENET_API int enet_address_set_host_ip_old(ENetAddress * address, const char * hostName);
+    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.
@@ -912,7 +895,7 @@ extern "C" {
         @retval < 0 on failure
         @returns the address of the given hostName in address on success
     */
-    ENET_API int enet_address_set_host_old(ENetAddress * address, const char * hostName);
+    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
@@ -922,7 +905,7 @@ extern "C" {
         @retval 0 on success
         @retval < 0 on failure
     */
-    ENET_API int enet_address_get_host_ip_old(const ENetAddress * address, char * hostName, size_t nameLength);
+    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
@@ -932,24 +915,7 @@ extern "C" {
         @retval 0 on success
         @retval < 0 on failure
     */
-    ENET_API int enet_address_get_host_old(const ENetAddress * address, char * hostName, size_t nameLength);
+    ENET_API int enet_address_get_host(const ENetAddress * address, char * hostName, size_t nameLength);
-
-    ENET_API int enet_address_set_host_ip_new(ENetAddress * address, const char * hostName);
-    ENET_API int enet_address_set_host_new(ENetAddress * address, const char * hostName);
-    ENET_API int enet_address_get_host_ip_new(const ENetAddress * address, char * hostName, size_t nameLength);
-    ENET_API int enet_address_get_host_new(const ENetAddress * address, char * hostName, size_t nameLength);
-
-#ifdef ENET_FEATURE_ADDRESS_MAPPING
-#define enet_address_set_host_ip enet_address_set_host_ip_new
-#define enet_address_set_host    enet_address_set_host_new
-#define enet_address_get_host_ip enet_address_get_host_ip_new
-#define enet_address_get_host    enet_address_get_host_new
-#else
-#define enet_address_set_host_ip enet_address_set_host_ip_old
-#define enet_address_set_host    enet_address_set_host_old
-#define enet_address_get_host_ip enet_address_get_host_ip_old
-#define enet_address_get_host    enet_address_get_host_old
-#endif
 
     ENET_API enet_uint32 enet_host_get_peers_count(ENetHost *);
     ENET_API enet_uint32 enet_host_get_packets_sent(ENetHost *);
@@ -1231,13 +1197,14 @@ extern "C" {
 
 #endif /* defined(_MSC_VER) */
 
+
 // =======================================================================//
 // !
 // ! Callbacks
 // !
 // =======================================================================//
 
-    ENetCallbacks callbacks = { malloc, free, abort, enet_packet_create, enet_packet_destroy };
+    static ENetCallbacks callbacks = { malloc, free, abort, enet_packet_create, enet_packet_destroy };
 
     int enet_initialize_with_callbacks(ENetVersion version, const ENetCallbacks *inits) {
         if (version < ENET_VERSION_CREATE(1, 3, 0)) {
@@ -1421,10 +1388,6 @@ extern "C" {
         return packet;
     }
 
-    ENetPacket *enet_packet_copy(ENetPacket *packet) {
-        return enet_packet_create(packet->data, packet->dataLength, packet->flags);
-    }
-
     /**
      * Destroys the packet and deallocates its data.
      * @param packet packet to be destroyed
@@ -2218,17 +2181,18 @@ extern "C" {
         if (peer->state != ENET_PEER_STATE_CONNECTED && peer->state != ENET_PEER_STATE_DISCONNECT_LATER) {
             return -1;
         }
+
         if (peer->incomingBandwidth != 0) {
             --host->bandwidthLimitedPeers;
         }
 
         peer->incomingBandwidth = ENET_NET_TO_HOST_32(command->bandwidthLimit.incomingBandwidth);
+        peer->outgoingBandwidth = ENET_NET_TO_HOST_32(command->bandwidthLimit.outgoingBandwidth);
+
         if (peer->incomingBandwidth != 0) {
             ++host->bandwidthLimitedPeers;
         }
 
-        peer->outgoingBandwidth = ENET_NET_TO_HOST_32(command->bandwidthLimit.outgoingBandwidth);
-
         if (peer->incomingBandwidth == 0 && host->outgoingBandwidth == 0) {
             peer->windowSize = ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE;
         } else if (peer->incomingBandwidth == 0 || host->outgoingBandwidth == 0) {
@@ -2641,8 +2605,7 @@ extern "C" {
                     goto commandError;
             }
 
-            assert(peer);
+            if (peer != NULL && (command->header.command & ENET_PROTOCOL_COMMAND_FLAG_ACKNOWLEDGE) != 0) {
-            if ((command->header.command & ENET_PROTOCOL_COMMAND_FLAG_ACKNOWLEDGE) != 0) {
                 enet_uint16 sentTime;
 
                 if (!(flags & ENET_PROTOCOL_HEADER_FLAG_SENT_TIME)) {
@@ -3134,12 +3097,12 @@ extern "C" {
                     currentPeer->packetsLost     = 0;
                 }
 
-                host->buffers[0].data = headerData;
+                host->buffers->data = headerData;
                 if (host->headerFlags & ENET_PROTOCOL_HEADER_FLAG_SENT_TIME) {
                     header->sentTime = ENET_HOST_TO_NET_16(host->serviceTime & 0xFFFF);
-                    host->buffers[0].dataLength = sizeof(ENetProtocolHeader);
+                    host->buffers->dataLength = sizeof(ENetProtocolHeader);
                 } else {
-                    host->buffers[0].dataLength = (size_t) &((ENetProtocolHeader *) 0)->sentTime;
+                    host->buffers->dataLength = (size_t) &((ENetProtocolHeader *) 0)->sentTime;
                 }
 
                 shouldCompress = 0;
@@ -3160,9 +3123,9 @@ extern "C" {
                 }
                 header->peerID = ENET_HOST_TO_NET_16(currentPeer->outgoingPeerID | host->headerFlags);
                 if (host->checksum != NULL) {
-                    enet_uint32 *checksum = (enet_uint32 *) &headerData[host->buffers[0].dataLength];
+                    enet_uint32 *checksum = (enet_uint32 *) &headerData[host->buffers->dataLength];
                     *checksum = currentPeer->outgoingPeerID < ENET_PROTOCOL_MAXIMUM_PEER_ID ? currentPeer->connectID : 0;
-                    host->buffers[0].dataLength += sizeof(enet_uint32);
+                    host->buffers->dataLength += sizeof(enet_uint32);
                     *checksum = host->checksum(host->buffers, host->bufferCount);
                 }
 
@@ -3177,9 +3140,6 @@ extern "C" {
                 enet_protocol_remove_sent_unreliable_commands(currentPeer);
 
                 if (sentLength < 0) {
-                    // The local 'headerData' array (to which 'data' is assigned) goes out
-                    // of scope on return from this function, so ensure we no longer point to it.
-                    host->buffers[0].data = NULL;
                     return -1;
                 }
 
@@ -3188,10 +3148,6 @@ extern "C" {
                 host->totalSentPackets++;
             }
 
-        // The local 'headerData' array (to which 'data' is assigned) goes out
-        // of scope on return from this function, so ensure we no longer point to it.
-        host->buffers[0].data = NULL;
-
         return 0;
     } /* enet_protocol_send_outgoing_commands */
 
@@ -3859,7 +3815,7 @@ extern "C" {
      *  @param pingInterval the interval at which to send pings; defaults to ENET_PEER_PING_INTERVAL if 0
      */
     void enet_peer_ping_interval(ENetPeer *peer, enet_uint32 pingInterval) {
-        peer->pingInterval = pingInterval ? pingInterval : (enet_uint32)ENET_PEER_PING_INTERVAL;
+        peer->pingInterval = pingInterval ? pingInterval : ENET_PEER_PING_INTERVAL;
     }
 
     /** Sets the timeout parameters for a peer.
@@ -3880,9 +3836,9 @@ extern "C" {
      */
 
     void enet_peer_timeout(ENetPeer *peer, enet_uint32 timeoutLimit, enet_uint32 timeoutMinimum, enet_uint32 timeoutMaximum) {
-        peer->timeoutLimit   = timeoutLimit ? timeoutLimit : (enet_uint32)ENET_PEER_TIMEOUT_LIMIT;
+        peer->timeoutLimit   = timeoutLimit ? timeoutLimit : ENET_PEER_TIMEOUT_LIMIT;
-        peer->timeoutMinimum = timeoutMinimum ? timeoutMinimum : (enet_uint32)ENET_PEER_TIMEOUT_MINIMUM;
+        peer->timeoutMinimum = timeoutMinimum ? timeoutMinimum : ENET_PEER_TIMEOUT_MINIMUM;
-        peer->timeoutMaximum = timeoutMaximum ? timeoutMaximum : (enet_uint32)ENET_PEER_TIMEOUT_MAXIMUM;
+        peer->timeoutMaximum = timeoutMaximum ? timeoutMaximum : ENET_PEER_TIMEOUT_MAXIMUM;
     }
 
     /** Force an immediate disconnection from a peer.
@@ -4337,9 +4293,10 @@ extern "C" {
             memset(incomingCommand->fragments, 0, (fragmentCount + 31) / 32 * sizeof(enet_uint32));
         }
 
-        assert(packet != NULL);
+        if (packet != NULL) {
-        ++packet->referenceCount;
+            ++packet->referenceCount;
-        peer->totalWaitingData += packet->dataLength;
+            peer->totalWaitingData += packet->dataLength;
+        }
 
         enet_list_insert(enet_list_next(currentCommand), incomingCommand);
 
@@ -4361,8 +4318,7 @@ extern "C" {
             goto notifyError;
         }
 
-        assert(packet != NULL);
+        if (packet != NULL && packet->referenceCount == 0) {
-        if (packet->referenceCount == 0) {
             callbacks.packet_destroy(packet);
         }
 
@@ -4445,9 +4401,11 @@ extern "C" {
 
         if (!channelLimit || channelLimit > ENET_PROTOCOL_MAXIMUM_CHANNEL_COUNT) {
             channelLimit = ENET_PROTOCOL_MAXIMUM_CHANNEL_COUNT;
+        } else if (channelLimit < ENET_PROTOCOL_MINIMUM_CHANNEL_COUNT) {
+            channelLimit = ENET_PROTOCOL_MINIMUM_CHANNEL_COUNT;
         }
 
-        host->randomSeed                    = (enet_uint32) ((uintptr_t) host % UINT32_MAX);
+        host->randomSeed                    = (enet_uint32) (size_t) host;
         host->randomSeed                    += enet_host_random_seed();
         host->randomSeed                    = (host->randomSeed << 16) | (host->randomSeed >> 16);
         host->channelLimit                  = channelLimit;
@@ -4696,7 +4654,10 @@ extern "C" {
     void enet_host_channel_limit(ENetHost *host, size_t channelLimit) {
         if (!channelLimit || channelLimit > ENET_PROTOCOL_MAXIMUM_CHANNEL_COUNT) {
             channelLimit = ENET_PROTOCOL_MAXIMUM_CHANNEL_COUNT;
+        } else if (channelLimit < ENET_PROTOCOL_MINIMUM_CHANNEL_COUNT) {
+            channelLimit = ENET_PROTOCOL_MINIMUM_CHANNEL_COUNT;
         }
+
         host->channelLimit = channelLimit;
     }
 
@@ -4904,8 +4865,8 @@ extern "C" {
             t.QuadPart |= f.dwLowDateTime;
             return (t);
         }
+
         int clock_gettime(int X, struct timespec *tv) {
-            (void)X;
             LARGE_INTEGER t;
             FILETIME f;
             double microseconds;
@@ -5009,119 +4970,6 @@ extern "C" {
         return (enet_uint32)(result_in_ns / ns_in_ms);
     }
 
-    void enet_inaddr_map4to6(struct in_addr in, struct in6_addr *out)
-    {
-        if (in.s_addr == 0x00000000) { /* 0.0.0.0 */
-            *out = enet_v6_anyaddr;
-        } else if (in.s_addr == 0xFFFFFFFF) { /* 255.255.255.255 */
-            *out = enet_v6_noaddr;
-        } else {
-            *out = enet_v4_anyaddr;
-            out->s6_addr[10] = 0xFF;
-            out->s6_addr[11] = 0xFF;
-            out->s6_addr[12] = ((uint8_t *)&in.s_addr)[0];
-            out->s6_addr[13] = ((uint8_t *)&in.s_addr)[1];
-            out->s6_addr[14] = ((uint8_t *)&in.s_addr)[2];
-            out->s6_addr[15] = ((uint8_t *)&in.s_addr)[3];
-        }
-    }
-    void enet_inaddr_map6to4(const struct in6_addr *in, struct in_addr *out)
-    {
-        memset(out, 0, sizeof(struct in_addr));
-        ((uint8_t *)&out->s_addr)[0] = in->s6_addr[12];
-        ((uint8_t *)&out->s_addr)[1] = in->s6_addr[13];
-        ((uint8_t *)&out->s_addr)[2] = in->s6_addr[14];
-        ((uint8_t *)&out->s_addr)[3] = in->s6_addr[15];
-    }
-
-    int enet_in6addr_lookup_host(const char *name, bool nodns, ENetAddress *out) {
-        struct addrinfo hints, *resultList = NULL, *result = NULL;
-
-        memset(&hints, 0, sizeof(hints));
-        hints.ai_family = AF_UNSPEC;
-
-        if (nodns)
-        {
-            hints.ai_flags = AI_NUMERICHOST; /* prevent actual DNS lookups! */
-        }
-
-        if (getaddrinfo(name, NULL, &hints, &resultList) != 0) {
-            freeaddrinfo(resultList);
-            return -1;
-        }
-
-        for (result = resultList; result != NULL; result = result->ai_next) {
-            if (result->ai_addr != NULL) {
-                if (result->ai_family == AF_INET || (result->ai_family == AF_UNSPEC && result->ai_addrlen == sizeof(struct sockaddr_in))) {
-                    enet_inaddr_map4to6(((struct sockaddr_in*)result->ai_addr)->sin_addr, &out->host);
-                    out->sin6_scope_id = 0;
-                    freeaddrinfo(resultList);
-                    return 0;
-
-                } else if (result->ai_family == AF_INET6 || (result->ai_family == AF_UNSPEC && result->ai_addrlen == sizeof(struct sockaddr_in6))) {
-                    memcpy(&out->host, &((struct sockaddr_in6*)result->ai_addr)->sin6_addr, sizeof(struct in6_addr));
-                    out->sin6_scope_id = (enet_uint16) ((struct sockaddr_in6*)result->ai_addr)->sin6_scope_id;
-                    freeaddrinfo(resultList);
-                    return 0;
-                }
-            }
-        }
-        freeaddrinfo(resultList);
-        return -1;
-    }
-
-    int enet_address_set_host_ip_new(ENetAddress *address, const char *name) {
-        return enet_in6addr_lookup_host(name, true, address);
-    }
-
-    int enet_address_set_host_new(ENetAddress *address, const char *name) {
-        return enet_in6addr_lookup_host(name, false, address);
-    }
-
-    int enet_address_get_host_ip_new(const ENetAddress *address, char *name, size_t nameLength) {
-        if (IN6_IS_ADDR_V4MAPPED(&address->host)) {
-            struct in_addr buf;
-            enet_inaddr_map6to4(&address->host, &buf);
-
-            if (inet_ntop(AF_INET, &buf, name, nameLength) == NULL) {
-                return -1;
-            }
-        }
-        else {
-            if (inet_ntop(AF_INET6, (void*)&address->host, name, nameLength) == NULL) {
-                return -1;
-            }
-        }
-
-        return 0;
-    } /* enet_address_get_host_ip_new */
-
-    int enet_address_get_host_new(const ENetAddress *address, char *name, size_t nameLength) {
-        struct sockaddr_in6 sin;
-        memset(&sin, 0, sizeof(struct sockaddr_in6));
-
-        int err;
-
-
-        sin.sin6_family = AF_INET6;
-        sin.sin6_port = ENET_HOST_TO_NET_16 (address->port);
-        sin.sin6_addr = address->host;
-        sin.sin6_scope_id = address->sin6_scope_id;
-
-        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;
-        }
-
-        return enet_address_get_host_ip_new(address, name, nameLength);
-    } /* enet_address_get_host_new */
-
 // =======================================================================//
 // !
 // ! Platform Specific (Unix)
@@ -5311,7 +5159,7 @@ extern "C" {
             }
         }
     #endif // __MINGW__
-
+    
     int enet_initialize(void) {
         return 0;
     }
@@ -5322,7 +5170,7 @@ extern "C" {
         return (enet_uint64) time(NULL);
     }
 
-    int enet_address_set_host_ip_old(ENetAddress *address, const char *name) {
+    int enet_address_set_host_ip(ENetAddress *address, const char *name) {
         if (!inet_pton(AF_INET6, name, &address->host)) {
             return -1;
         }
@@ -5330,7 +5178,7 @@ extern "C" {
         return 0;
     }
 
-    int enet_address_set_host_old(ENetAddress *address, const char *name) {
+    int enet_address_set_host(ENetAddress *address, const char *name) {
         struct addrinfo hints, *resultList = NULL, *result = NULL;
 
         memset(&hints, 0, sizeof(hints));
@@ -5351,6 +5199,7 @@ extern "C" {
                     ((uint32_t *)&address->host.s6_addr)[3] = sin->sin_addr.s_addr;
 
                     freeaddrinfo(resultList);
+
                     return 0;
                 }
                 else if(result->ai_family == AF_INET6) {
@@ -5360,16 +5209,21 @@ extern "C" {
                     address->sin6_scope_id = sin->sin6_scope_id;
 
                     freeaddrinfo(resultList);
+
                     return 0;
                 }
             }
         }
-        freeaddrinfo(resultList);
+
+
+        if (resultList != NULL) {
+            freeaddrinfo(resultList);
+        }
 
         return enet_address_set_host_ip(address, name);
-    } /* enet_address_set_host_old */
+    } /* enet_address_set_host */
 
-    int enet_address_get_host_ip_old(const ENetAddress *address, char *name, size_t nameLength) {
+    int enet_address_get_host_ip(const ENetAddress *address, char *name, size_t nameLength) {
         if (inet_ntop(AF_INET6, &address->host, name, nameLength) == NULL) {
             return -1;
         }
@@ -5377,14 +5231,17 @@ extern "C" {
         return 0;
     }
 
-    int enet_address_get_host_old(const ENetAddress *address, char *name, size_t nameLength) {
+    int enet_address_get_host(const ENetAddress *address, char *name, size_t nameLength) {
         struct sockaddr_in6 sin;
         int err;
+
         memset(&sin, 0, sizeof(struct sockaddr_in6));
+
         sin.sin6_family = AF_INET6;
         sin.sin6_port = ENET_HOST_TO_NET_16 (address->port);
         sin.sin6_addr = address->host;
         sin.sin6_scope_id = address->sin6_scope_id;
+
         err = getnameinfo((struct sockaddr *) &sin, sizeof(sin), name, nameLength, NULL, 0, NI_NAMEREQD);
         if (!err) {
             if (name != NULL && nameLength > 0 && !memchr(name, '\0', nameLength)) {
@@ -5395,8 +5252,9 @@ extern "C" {
         if (err != EAI_NONAME) {
             return -1;
         }
+
         return enet_address_get_host_ip(address, name, nameLength);
-    } /* enet_address_get_host_old */
+    } /* enet_address_get_host */
 
     int enet_socket_bind(ENetSocket socket, const ENetAddress *address) {
         struct sockaddr_in6 sin;
@@ -5436,7 +5294,7 @@ extern "C" {
     }
 
     ENetSocket enet_socket_create(ENetSocketType type) {
-        return socket(PF_INET6, (int)type == ENET_SOCKET_TYPE_DATAGRAM ? SOCK_DGRAM : SOCK_STREAM, 0);
+        return socket(PF_INET6, type == ENET_SOCKET_TYPE_DATAGRAM ? SOCK_DGRAM : SOCK_STREAM, 0);
     }
 
     int enet_socket_set_option(ENetSocket socket, ENetSocketOption option, int value) {
@@ -5721,7 +5579,7 @@ extern "C" {
         return (enet_uint64) timeGetTime();
     }
 
-    int enet_address_set_host_ip_old(ENetAddress *address, const char *name) {
+    int enet_address_set_host_ip(ENetAddress *address, const char *name) {
         enet_uint8 vals[4] = { 0, 0, 0, 0 };
         int i;
 
@@ -5745,7 +5603,7 @@ extern "C" {
         return 0;
     }
 
-    int enet_address_set_host_old(ENetAddress *address, const char *name) {
+    int enet_address_set_host(ENetAddress *address, const char *name) {
         struct hostent *hostEntry = NULL;
         hostEntry = gethostbyname(name);
 
@@ -5765,7 +5623,7 @@ extern "C" {
         return 0;
     }
 
-    int enet_address_get_host_ip_old(const ENetAddress *address, char *name, size_t nameLength) {
+    int enet_address_get_host_ip(const ENetAddress *address, char *name, size_t nameLength) {
         if (inet_ntop(AF_INET6, (PVOID)&address->host, name, nameLength) == NULL) {
             return -1;
         }
@@ -5773,11 +5631,13 @@ extern "C" {
         return 0;
     }
 
-    int enet_address_get_host_old(const ENetAddress *address, char *name, size_t nameLength) {
+    int enet_address_get_host(const ENetAddress *address, char *name, size_t nameLength) {
         struct in6_addr in;
         struct hostent *hostEntry = NULL;
+
         in = address->host;
         hostEntry = gethostbyaddr((char *)&in, sizeof(struct in6_addr), AF_INET6);
+
         if (hostEntry == NULL) {
             return enet_address_get_host_ip(address, name, nameLength);
         } else {
@@ -5787,6 +5647,7 @@ extern "C" {
             }
             memcpy(name, hostEntry->h_name, hostLen + 1);
         }
+
         return 0;
     }