diff --git a/NETWORKING.md b/NETWORKING.md
index e36afc1c0..dfa9d780e 100644
--- a/NETWORKING.md
+++ b/NETWORKING.md
@@ -81,7 +81,7 @@ The current server configuration xml looks like this:
-
+
diff --git a/lib/enet/host.c b/lib/enet/host.c
index 3be6c0922..5f9afdae6 100644
--- a/lib/enet/host.c
+++ b/lib/enet/host.c
@@ -87,7 +87,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.host = (ENetIP) { 0 };
host -> receivedAddress.port = 0;
host -> receivedData = NULL;
host -> receivedDataLength = 0;
diff --git a/lib/enet/include/enet/enet.h b/lib/enet/include/enet/enet.h
index 4a704eefc..0f4f4d3b5 100644
--- a/lib/enet/include/enet/enet.h
+++ b/lib/enet/include/enet/enet.h
@@ -76,6 +76,19 @@ typedef enum _ENetSocketShutdown
#define ENET_HOST_BROADCAST 0xFFFFFFFFU
#define ENET_PORT_ANY 0
+typedef struct _ENetIP
+{
+ enet_uint32 p0; // uint32_t here for IPv4, or 4 uint32_t IPv6 address
+ enet_uint32 p1;
+ enet_uint32 p2;
+ enet_uint32 p3;
+ enet_uint32 p4; // sockaddr_in6 sin6_scope_id (required for local link address)
+} ENetIP;
+
+// We don't need to test sin6_scope_id as it only used for connection, and sin6_flowinfo is always zero
+#define enet_ip_equal(a, b) (a.p0 == b.p0 && a.p1 == b.p1 && a.p2 == b.p2 && a.p3 == b.p3)
+#define enet_ip_not_equal(a, b) (a.p0 != b.p0 || a.p1 != b.p1 || a.p2 != b.p2 || a.p3 != b.p3)
+
/**
* Portable internet address structure.
*
@@ -88,7 +101,7 @@ typedef enum _ENetSocketShutdown
*/
typedef struct _ENetAddress
{
- enet_uint32 host;
+ ENetIP host;
enet_uint16 port;
} ENetAddress;
diff --git a/lib/enet/protocol.c b/lib/enet/protocol.c
index eee7f88bc..5c92fc723 100644
--- a/lib/enet/protocol.c
+++ b/lib/enet/protocol.c
@@ -307,7 +307,7 @@ enet_protocol_handle_connect (ENetHost * host, ENetProtocolHeader * header, ENet
}
else
if (currentPeer -> state != ENET_PEER_STATE_CONNECTING &&
- currentPeer -> address.host == host -> receivedAddress.host)
+ enet_ip_equal(currentPeer -> address.host, host -> receivedAddress.host))
{
if (currentPeer -> address.port == host -> receivedAddress.port &&
currentPeer -> connectID == command -> connect.connectID)
@@ -1019,9 +1019,9 @@ 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 ||
+ ((enet_ip_not_equal(host -> receivedAddress.host, peer -> address.host) ||
host -> receivedAddress.port != peer -> address.port) &&
- peer -> address.host != ENET_HOST_BROADCAST) ||
+ peer -> address.host.p0 != ENET_HOST_BROADCAST) ||
(peer -> outgoingPeerID < ENET_PROTOCOL_MAXIMUM_PEER_ID &&
sessionID != peer -> incomingSessionID))
return 0;
diff --git a/lib/enet/unix.c b/lib/enet/unix.c
index a636f0373..c10a3d99d 100644
--- a/lib/enet/unix.c
+++ b/lib/enet/unix.c
@@ -63,6 +63,9 @@ typedef int socklen_t;
static enet_uint32 timeBase = 0;
+// Global variable handled by STK
+extern int isIPv6Socket(void);
+
int
enet_initialize (void)
{
@@ -104,9 +107,9 @@ int
enet_address_set_host_ip (ENetAddress * address, const char * name)
{
#ifdef HAS_INET_PTON
- if (! inet_pton (AF_INET, name, & address -> host))
+ if (! inet_pton (AF_INET, name, & address -> host.p0))
#else
- if (! inet_aton (name, (struct in_addr *) & address -> host))
+ if (! inet_aton (name, (struct in_addr *) & address -> host.p0))
#endif
return -1;
@@ -131,7 +134,7 @@ enet_address_set_host (ENetAddress * address, const char * name)
{
struct sockaddr_in * sin = (struct sockaddr_in *) result -> ai_addr;
- address -> host = sin -> sin_addr.s_addr;
+ address -> host.p0 = sin -> sin_addr.s_addr;
freeaddrinfo (resultList);
@@ -159,7 +162,7 @@ enet_address_set_host (ENetAddress * address, const char * name)
if (hostEntry != NULL && hostEntry -> h_addrtype == AF_INET)
{
- address -> host = * (enet_uint32 *) hostEntry -> h_addr_list [0];
+ address -> host.p0 = * (enet_uint32 *) hostEntry -> h_addr_list [0];
return 0;
}
@@ -172,9 +175,9 @@ 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)
+ if (inet_ntop (AF_INET, & address -> host.p0, name, nameLength) == NULL)
#else
- char * addr = inet_ntoa (* (struct in_addr *) & address -> host);
+ char * addr = inet_ntoa (* (struct in_addr *) & address -> host.p0);
if (addr != NULL)
{
size_t addrLen = strlen(addr);
@@ -199,7 +202,7 @@ enet_address_get_host (const ENetAddress * address, char * name, size_t nameLeng
sin.sin_family = AF_INET;
sin.sin_port = ENET_HOST_TO_NET_16 (address -> port);
- sin.sin_addr.s_addr = address -> host;
+ sin.sin_addr.s_addr = address -> host.p0;
err = getnameinfo ((struct sockaddr *) & sin, sizeof (sin), name, nameLength, NULL, 0, NI_NAMEREQD);
if (! err)
@@ -218,7 +221,7 @@ enet_address_get_host (const ENetAddress * address, char * name, size_t nameLeng
char buffer [2048];
int errnum;
- in.s_addr = address -> host;
+ in.s_addr = address -> host.p0;
#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);
@@ -226,7 +229,7 @@ enet_address_get_host (const ENetAddress * address, char * name, size_t nameLeng
hostEntry = gethostbyaddr_r ((char *) & in, sizeof (struct in_addr), AF_INET, & hostData, buffer, sizeof (buffer), & errnum);
#endif
#else
- in.s_addr = address -> host;
+ in.s_addr = address -> host.p0;
hostEntry = gethostbyaddr ((char *) & in, sizeof (struct in_addr), AF_INET);
#endif
@@ -247,41 +250,83 @@ enet_address_get_host (const ENetAddress * address, char * name, size_t nameLeng
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)
+ if (isIPv6Socket() == 1)
{
- sin.sin_port = ENET_HOST_TO_NET_16 (address -> port);
- sin.sin_addr.s_addr = address -> host;
+ struct sockaddr_in6 sin;
+ memset (& sin, 0, sizeof (sin));
+ sin.sin6_family = AF_INET6;
+
+ if (address != NULL)
+ {
+ sin.sin6_port = ENET_HOST_TO_NET_16 (address -> port);
+ memcpy (sin.sin6_addr.s6_addr, & address -> host.p0, 16);
+ }
+ else
+ {
+ sin.sin6_port = 0;
+ sin.sin6_addr = in6addr_any;
+ }
+
+ return bind (socket,
+ (struct sockaddr *) & sin,
+ sizeof (struct sockaddr_in6));
}
else
{
- sin.sin_port = 0;
- sin.sin_addr.s_addr = INADDR_ANY;
- }
+ struct sockaddr_in sin;
- return bind (socket,
- (struct sockaddr *) & sin,
- sizeof (struct sockaddr_in));
+ 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.p0;
+ }
+ else
+ {
+ sin.sin_port = 0;
+ sin.sin_addr.s_addr = INADDR_ANY;
+ }
+
+ return bind (socket,
+ (struct sockaddr *) & sin,
+ sizeof (struct sockaddr_in));
+ }
}
int
enet_socket_get_address (ENetSocket socket, ENetAddress * address)
{
- struct sockaddr_in sin;
- socklen_t sinLength = sizeof (struct sockaddr_in);
+ if (isIPv6Socket() == 1)
+ {
+ struct sockaddr_in6 sin;
+ memset (& sin, 0, sizeof (sin));
+ socklen_t sinLength = sizeof (struct sockaddr_in6);
- if (getsockname (socket, (struct sockaddr *) & sin, & sinLength) == -1)
- return -1;
+ if (getsockname (socket, (struct sockaddr *) & sin, & sinLength) == -1)
+ return -1;
- address -> host = (enet_uint32) sin.sin_addr.s_addr;
- address -> port = ENET_NET_TO_HOST_16 (sin.sin_port);
+ memcpy (& address -> host.p0, sin.sin6_addr.s6_addr, 16);
+ address -> host.p4 = sin.sin6_scope_id;
+ address -> port = ENET_NET_TO_HOST_16 (sin.sin6_port);
- return 0;
+ return 0;
+ }
+ else
+ {
+ struct sockaddr_in sin;
+ socklen_t sinLength = sizeof (struct sockaddr_in);
+
+ if (getsockname (socket, (struct sockaddr *) & sin, & sinLength) == -1)
+ return -1;
+
+ address -> host.p0 = (enet_uint32) sin.sin_addr.s_addr;
+ address -> port = ENET_NET_TO_HOST_16 (sin.sin_port);
+
+ return 0;
+ }
}
int
@@ -293,7 +338,16 @@ enet_socket_listen (ENetSocket socket, int backlog)
ENetSocket
enet_socket_create (ENetSocketType type)
{
- return socket (PF_INET, type == ENET_SOCKET_TYPE_DATAGRAM ? SOCK_DGRAM : SOCK_STREAM, 0);
+ int pf_family = isIPv6Socket() == 1 ? PF_INET6 : PF_INET;
+ int socket_fd = socket (pf_family, type == ENET_SOCKET_TYPE_DATAGRAM ? SOCK_DGRAM : SOCK_STREAM, 0);
+ if (isIPv6Socket() == 1 && socket_fd != -1)
+ {
+ int no = 0;
+ // Allow IPv6 socket listen to IPv4 connection (as long as the host has IPv4 address)
+ // We always use dual stack in STK
+ setsockopt (socket_fd, IPPROTO_IPV6, IPV6_V6ONLY, (void *) & no, sizeof (no));
+ }
+ return socket_fd;
}
int
@@ -382,7 +436,7 @@ enet_socket_connect (ENetSocket socket, const ENetAddress * address)
sin.sin_family = AF_INET;
sin.sin_port = ENET_HOST_TO_NET_16 (address -> port);
- sin.sin_addr.s_addr = address -> host;
+ sin.sin_addr.s_addr = address -> host.p0;
result = connect (socket, (struct sockaddr *) & sin, sizeof (struct sockaddr_in));
if (result == -1 && errno == EINPROGRESS)
@@ -407,7 +461,7 @@ enet_socket_accept (ENetSocket socket, ENetAddress * address)
if (address != NULL)
{
- address -> host = (enet_uint32) sin.sin_addr.s_addr;
+ address -> host.p0 = (enet_uint32) sin.sin_addr.s_addr;
address -> port = ENET_NET_TO_HOST_16 (sin.sin_port);
}
@@ -434,21 +488,35 @@ enet_socket_send (ENetSocket socket,
size_t bufferCount)
{
struct msghdr msgHdr;
- struct sockaddr_in sin;
+ struct sockaddr_storage sin;
+ memset (& sin, 0, sizeof (sin));
int sentLength;
memset (& msgHdr, 0, sizeof (struct msghdr));
if (address != NULL)
{
- memset (& sin, 0, sizeof (struct sockaddr_in));
+ if (isIPv6Socket() == 1)
+ {
+ struct sockaddr_in6 * v6 = (struct sockaddr_in6 *) & sin;
+ v6 -> sin6_family = AF_INET6;
+ v6 -> sin6_port = ENET_HOST_TO_NET_16 (address -> port);
+ memcpy (v6 -> sin6_addr.s6_addr, & address -> host.p0, 16);
+ v6 -> sin6_scope_id = address -> host.p4;
- 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_in6);
+ }
+ else
+ {
+ struct sockaddr_in * v4 = (struct sockaddr_in *) & sin;
+ v4 -> sin_family = AF_INET;
+ v4 -> sin_port = ENET_HOST_TO_NET_16 (address -> port);
+ v4 -> sin_addr.s_addr = address -> host.p0;
- msgHdr.msg_name = & sin;
- msgHdr.msg_namelen = sizeof (struct sockaddr_in);
+ msgHdr.msg_name = & sin;
+ msgHdr.msg_namelen = sizeof (struct sockaddr_in);
+ }
}
msgHdr.msg_iov = (struct iovec *) buffers;
@@ -474,7 +542,8 @@ enet_socket_receive (ENetSocket socket,
size_t bufferCount)
{
struct msghdr msgHdr;
- struct sockaddr_in sin;
+ struct sockaddr_storage sin;
+ memset (& sin, 0, sizeof (sin));
int recvLength;
memset (& msgHdr, 0, sizeof (struct msghdr));
@@ -482,7 +551,7 @@ enet_socket_receive (ENetSocket socket,
if (address != NULL)
{
msgHdr.msg_name = & sin;
- msgHdr.msg_namelen = sizeof (struct sockaddr_in);
+ msgHdr.msg_namelen = sizeof (sin);
}
msgHdr.msg_iov = (struct iovec *) buffers;
@@ -505,8 +574,27 @@ enet_socket_receive (ENetSocket socket,
if (address != NULL)
{
- address -> host = (enet_uint32) sin.sin_addr.s_addr;
- address -> port = ENET_NET_TO_HOST_16 (sin.sin_port);
+ switch (sin.ss_family)
+ {
+ case AF_INET:
+ // Should not happen if dual stack is working
+ if (isIPv6Socket() == 1)
+ return -1;
+ struct sockaddr_in * v4 = (struct sockaddr_in *) & sin;
+ address -> host.p0 = (enet_uint32) v4 -> sin_addr.s_addr;
+ address -> port = ENET_NET_TO_HOST_16 (v4->sin_port);
+ break;
+ case AF_INET6:
+ if (isIPv6Socket() != 1)
+ return -1;
+ struct sockaddr_in6 * v6 = (struct sockaddr_in6 *) & sin;
+ memcpy (& address -> host.p0, v6 -> sin6_addr.s6_addr, 16);
+ address -> host.p4 = v6 -> sin6_scope_id;
+ address -> port = ENET_NET_TO_HOST_16 (v6 -> sin6_port);
+ break;
+ default:
+ return -1;
+ }
}
return recvLength;
diff --git a/lib/enet/win32.c b/lib/enet/win32.c
index 81175a411..38dce7953 100644
--- a/lib/enet/win32.c
+++ b/lib/enet/win32.c
@@ -6,11 +6,15 @@
#define ENET_BUILDING_LIB 1
#include "enet/enet.h"
+#include
#include
#include
static enet_uint32 timeBase = 0;
+// Global variable handled by STK
+extern int isIPv6Socket(void);
+
int
enet_initialize (void)
{
@@ -81,7 +85,7 @@ enet_address_set_host_ip (ENetAddress * address, const char * name)
name = next + 1;
}
- memcpy (& address -> host, vals, sizeof (enet_uint32));
+ memcpy (& address -> host.p0, vals, sizeof (enet_uint32));
return 0;
}
@@ -95,7 +99,7 @@ enet_address_set_host (ENetAddress * address, const char * name)
hostEntry -> h_addrtype != AF_INET)
return enet_address_set_host_ip (address, name);
- address -> host = * (enet_uint32 *) hostEntry -> h_addr_list [0];
+ address -> host.p0 = * (enet_uint32 *) hostEntry -> h_addr_list [0];
return 0;
}
@@ -103,7 +107,7 @@ enet_address_set_host (ENetAddress * address, const char * name)
int
enet_address_get_host_ip (const ENetAddress * address, char * name, size_t nameLength)
{
- char * addr = inet_ntoa (* (struct in_addr *) & address -> host);
+ char * addr = inet_ntoa (* (struct in_addr *) & address -> host.p0);
if (addr == NULL)
return -1;
else
@@ -122,7 +126,7 @@ enet_address_get_host (const ENetAddress * address, char * name, size_t nameLeng
struct in_addr in;
struct hostent * hostEntry;
- in.s_addr = address -> host;
+ in.s_addr = address -> host.p0;
hostEntry = gethostbyaddr ((char *) & in, sizeof (struct in_addr), AF_INET);
if (hostEntry == NULL)
@@ -141,41 +145,83 @@ enet_address_get_host (const ENetAddress * address, char * name, size_t nameLeng
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)
+ if (isIPv6Socket() == 1)
{
- sin.sin_port = ENET_HOST_TO_NET_16 (address -> port);
- sin.sin_addr.s_addr = address -> host;
+ struct sockaddr_in6 sin;
+ memset (& sin, 0, sizeof (sin));
+ sin.sin6_family = AF_INET6;
+
+ if (address != NULL)
+ {
+ sin.sin6_port = ENET_HOST_TO_NET_16 (address -> port);
+ memcpy (sin.sin6_addr.s6_addr, &address->host.p0, 16);
+ }
+ else
+ {
+ sin.sin6_port = 0;
+ sin.sin6_addr = in6addr_any;
+ }
+
+ return bind (socket,
+ (struct sockaddr *) & sin,
+ sizeof (struct sockaddr_in6)) == SOCKET_ERROR ? -1 : 0;
}
else
{
- sin.sin_port = 0;
- sin.sin_addr.s_addr = INADDR_ANY;
- }
+ struct sockaddr_in sin;
- return bind (socket,
- (struct sockaddr *) & sin,
- sizeof (struct sockaddr_in)) == SOCKET_ERROR ? -1 : 0;
+ 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.p0;
+ }
+ 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;
+ }
}
int
enet_socket_get_address (ENetSocket socket, ENetAddress * address)
{
- struct sockaddr_in sin;
- int sinLength = sizeof (struct sockaddr_in);
+ if (isIPv6Socket() == 1)
+ {
+ struct sockaddr_in6 sin;
+ memset (& sin, 0, sizeof (sin));
+ socklen_t sinLength = sizeof (struct sockaddr_in6);
- if (getsockname (socket, (struct sockaddr *) & sin, & sinLength) == -1)
- return -1;
+ if (getsockname (socket, (struct sockaddr *) & sin, & sinLength) == -1)
+ return -1;
- address -> host = (enet_uint32) sin.sin_addr.s_addr;
- address -> port = ENET_NET_TO_HOST_16 (sin.sin_port);
+ memcpy (& address->host.p0, sin.sin6_addr.s6_addr, 16);
+ address -> host.p4 = sin.sin6_scope_id;
+ address -> port = ENET_NET_TO_HOST_16 (sin.sin6_port);
- return 0;
+ return 0;
+ }
+ else
+ {
+ struct sockaddr_in sin;
+ socklen_t sinLength = sizeof (struct sockaddr_in);
+
+ if (getsockname (socket, (struct sockaddr *) & sin, & sinLength) == -1)
+ return -1;
+
+ address -> host.p0 = (enet_uint32) sin.sin_addr.s_addr;
+ address -> port = ENET_NET_TO_HOST_16 (sin.sin_port);
+
+ return 0;
+ }
}
int
@@ -187,7 +233,16 @@ enet_socket_listen (ENetSocket socket, int backlog)
ENetSocket
enet_socket_create (ENetSocketType type)
{
- return socket (PF_INET, type == ENET_SOCKET_TYPE_DATAGRAM ? SOCK_DGRAM : SOCK_STREAM, 0);
+ int pf_family = isIPv6Socket() == 1 ? PF_INET6 : PF_INET;
+ SOCKET socket_fd = socket (pf_family, type == ENET_SOCKET_TYPE_DATAGRAM ? SOCK_DGRAM : SOCK_STREAM, 0);
+ if (isIPv6Socket() == 1 && socket_fd != INVALID_SOCKET)
+ {
+ int no = 0;
+ // Allow IPv6 socket listen to IPv4 connection (as long as the host has IPv4 address)
+ // We always use dual stack in STK
+ setsockopt (socket_fd, IPPROTO_IPV6, IPV6_V6ONLY, (void *) & no, sizeof (no));
+ }
+ return socket_fd;
}
int
@@ -264,7 +319,7 @@ enet_socket_connect (ENetSocket socket, const ENetAddress * address)
sin.sin_family = AF_INET;
sin.sin_port = ENET_HOST_TO_NET_16 (address -> port);
- sin.sin_addr.s_addr = address -> host;
+ sin.sin_addr.s_addr = address -> host.p0;
result = connect (socket, (struct sockaddr *) & sin, sizeof (struct sockaddr_in));
if (result == SOCKET_ERROR && WSAGetLastError () != WSAEWOULDBLOCK)
@@ -289,7 +344,7 @@ enet_socket_accept (ENetSocket socket, ENetAddress * address)
if (address != NULL)
{
- address -> host = (enet_uint32) sin.sin_addr.s_addr;
+ address -> host.p0 = (enet_uint32) sin.sin_addr.s_addr;
address -> port = ENET_NET_TO_HOST_16 (sin.sin_port);
}
@@ -315,16 +370,33 @@ enet_socket_send (ENetSocket socket,
const ENetBuffer * buffers,
size_t bufferCount)
{
- struct sockaddr_in sin;
+ struct sockaddr_storage sin;
+ memset (& sin, 0, sizeof (sin));
+ size_t sin_size = 0;
+
DWORD sentLength;
if (address != NULL)
{
- memset (& sin, 0, sizeof (struct sockaddr_in));
+ if (isIPv6Socket() == 1)
+ {
+ struct sockaddr_in6 * v6 = (struct sockaddr_in6 *) & sin;
+ v6 -> sin6_family = AF_INET6;
+ v6 -> sin6_port = ENET_HOST_TO_NET_16 (address -> port);
+ memcpy (v6 -> sin6_addr.s6_addr, & address -> host.p0, 16);
+ v6 -> sin6_scope_id = address -> host.p4;
- sin.sin_family = AF_INET;
- sin.sin_port = ENET_HOST_TO_NET_16 (address -> port);
- sin.sin_addr.s_addr = address -> host;
+ sin_size = sizeof (struct sockaddr_in6);
+ }
+ else
+ {
+ struct sockaddr_in * v4 = (struct sockaddr_in *) & sin;
+ v4 -> sin_family = AF_INET;
+ v4 -> sin_port = ENET_HOST_TO_NET_16 (address -> port);
+ v4 -> sin_addr.s_addr = address -> host.p0;
+
+ sin_size = sizeof (struct sockaddr_in);
+ }
}
if (WSASendTo (socket,
@@ -333,7 +405,7 @@ enet_socket_send (ENetSocket socket,
& sentLength,
0,
address != NULL ? (struct sockaddr *) & sin : NULL,
- address != NULL ? sizeof (struct sockaddr_in) : 0,
+ address != NULL ? (int)sin_size : 0,
NULL,
NULL) == SOCKET_ERROR)
{
@@ -352,10 +424,11 @@ enet_socket_receive (ENetSocket socket,
ENetBuffer * buffers,
size_t bufferCount)
{
- INT sinLength = sizeof (struct sockaddr_in);
+ INT sinLength = sizeof (struct sockaddr_storage);
DWORD flags = 0,
recvLength;
- struct sockaddr_in sin;
+ struct sockaddr_storage sin;
+ memset (& sin, 0, sizeof (sin));
if (WSARecvFrom (socket,
(LPWSABUF) buffers,
@@ -382,8 +455,27 @@ enet_socket_receive (ENetSocket socket,
if (address != NULL)
{
- address -> host = (enet_uint32) sin.sin_addr.s_addr;
- address -> port = ENET_NET_TO_HOST_16 (sin.sin_port);
+ switch (sin.ss_family)
+ {
+ case AF_INET:
+ // Should not happen if dual stack is working
+ if (isIPv6Socket() == 1)
+ return -1;
+ struct sockaddr_in * v4 = (struct sockaddr_in *) & sin;
+ address -> host.p0 = (enet_uint32) v4 -> sin_addr.s_addr;
+ address -> port = ENET_NET_TO_HOST_16 (v4->sin_port);
+ break;
+ case AF_INET6:
+ if (isIPv6Socket() != 1)
+ return -1;
+ struct sockaddr_in6 * v6 = (struct sockaddr_in6 *) & sin;
+ memcpy (& address -> host.p0, v6 -> sin6_addr.s6_addr, 16);
+ address -> host.p4 = v6 -> sin6_scope_id;
+ address -> port = ENET_NET_TO_HOST_16 (v6 -> sin6_port);
+ break;
+ default:
+ return -1;
+ }
}
return (int) recvLength;
diff --git a/src/network/network.cpp b/src/network/network.cpp
index 402aa9141..da048b643 100644
--- a/src/network/network.cpp
+++ b/src/network/network.cpp
@@ -69,7 +69,7 @@ Network::Network(int peer_count, int channel_limit,
{
Log::warn("Network", "%d port is in used, use another port",
address->port);
- ENetAddress new_addr;
+ ENetAddress new_addr = {};
new_addr.host = address->host;
// Any port
new_addr.port = 0;
diff --git a/src/network/network_config.cpp b/src/network/network_config.cpp
index beb3ca706..10963ab4d 100644
--- a/src/network/network_config.cpp
+++ b/src/network/network_config.cpp
@@ -210,9 +210,7 @@ void NetworkConfig::detectIPType()
return;
}
#ifdef ENABLE_IPV6
- ENetAddress eaddr;
- eaddr.host = STKHost::HOST_ANY;
- eaddr.port = STKHost::PORT_ANY;
+ ENetAddress eaddr = {};
// We don't need to result of stun, just to check if the socket can be
// used in ipv4 or ipv6
uint8_t stun_tansaction_id[16] = {};
diff --git a/src/network/protocols/connect_to_server.cpp b/src/network/protocols/connect_to_server.cpp
index 9584c96f8..65d3b7c35 100644
--- a/src/network/protocols/connect_to_server.cpp
+++ b/src/network/protocols/connect_to_server.cpp
@@ -69,8 +69,7 @@ ConnectToServer::ConnectToServer(std::shared_ptr server)
: Protocol(PROTOCOL_CONNECTION)
{
m_quick_play_err_msg = _("No quick play server available.");
- m_server_address.host = 0;
- m_server_address.port = 0;
+ m_server_address = {};
if (server)
m_server = server;
} // ConnectToServer(server, host)
@@ -252,8 +251,7 @@ void ConnectToServer::asynchronousUpdate()
// Free the bound socket first
delete STKHost::get()->getNetwork();
setIPv6Socket(1);
- ENetAddress addr;
- addr.host = STKHost::HOST_ANY;
+ ENetAddress addr = {};
addr.port = NetworkConfig::get()->getClientPort();
auto new_network = new Network(/*peer_count*/1,
/*channel_limit*/EVENT_CHANNEL_COUNT,
@@ -409,22 +407,16 @@ int ConnectToServer::interceptCallback(ENetHost* host, ENetEvent* event)
host->receivedData[8] == '-' && host->receivedData[9] == 's' &&
host->receivedData[10] == 't' && host->receivedData[11] == 'k')
{
+#ifdef ENABLE_IPV6
+ if (enet_ip_not_equal(host->receivedAddress.host, m_server_address.host) ||
+#else
if (host->receivedAddress.host != m_server_address.host ||
+#endif
host->receivedAddress.port != m_server_address.port)
{
- std::string new_address =
- enetAddressToString(host->receivedAddress);
- if (isIPv6Socket())
- {
- // It was already mapped to real IPv6 before the intercept
- // callback
- new_address = "[";
- new_address += getIPV6ReadableFromMappedAddress
- (&host->receivedAddress) + "]:" +
- StringUtils::toString(host->receivedAddress.port);
- }
+ SocketAddress new_address(host->receivedAddress);
Log::info("ConnectToServer", "Using new server address %s",
- new_address.c_str());
+ new_address.toString().c_str());
m_retry_count = 15;
m_server_address = host->receivedAddress;
m_done_intecept = true;
@@ -441,9 +433,7 @@ bool ConnectToServer::tryConnect(int timeout, int retry, bool another_port,
{
m_retry_count = retry;
ENetEvent event;
- ENetAddress ea;
- ea.host = STKHost::HOST_ANY;
- ea.port = STKHost::PORT_ANY;
+ ENetAddress ea = {};
Network* nw = another_port ? new Network(/*peer_count*/1,
/*channel_limit*/EVENT_CHANNEL_COUNT,
/*max_in_bandwidth*/0, /*max_out_bandwidth*/0, &ea,
@@ -453,31 +443,21 @@ bool ConnectToServer::tryConnect(int timeout, int retry, bool another_port,
m_done_intecept = false;
nw->getENetHost()->intercept = ConnectToServer::interceptCallback;
+ const SocketAddress* sa;
if (ipv6)
{
- SocketAddress* sa = m_server->getIPV6Address();
+ sa = m_server->getIPV6Address();
if (!sa)
return false;
- struct sockaddr_in6* in6 = (struct sockaddr_in6*)sa->getSockaddr();
- addMappedAddress(&m_server_address, in6);
}
else
- {
- // IPv4 address
- m_server_address = toENetAddress(m_server->getAddress().getIP(),
- m_server->getAddress().getPort());
- }
+ sa = &m_server->getAddress();
+ m_server_address = sa->toENetAddress();
while (--m_retry_count >= 0 && !ProtocolManager::lock()->isExiting())
{
- std::string connecting_address = enetAddressToString(m_server_address);
- if (ipv6)
- {
- connecting_address = "[";
- connecting_address += getIPV6ReadableFromMappedAddress
- (&m_server_address) + "]:" +
- StringUtils::toString(m_server->getIPV6Address()->getPort());
- }
+ std::string connecting_address =
+ SocketAddress(m_server_address).toString();
ENetPeer* p = nw->connectTo(m_server_address);
if (!p)
break;
@@ -555,30 +535,6 @@ void ConnectToServer::registerWithSTKServer()
}
} // registerWithSTKServer
-// ----------------------------------------------------------------------------
-std::string ConnectToServer::enetAddressToString(const ENetAddress& addr)
-{
- uint32_t ip = htonl(addr.host);
- std::string s =
- StringUtils::insertValues("%d.%d.%d.%d",
- ((ip >> 24) & 0xff), ((ip >> 16) & 0xff),
- ((ip >> 8) & 0xff), ((ip >> 0) & 0xff));
- s += StringUtils::insertValues(":%d", addr.port);
- return s;
-} // enetAddressToString
-
-// ----------------------------------------------------------------------------
-ENetAddress ConnectToServer::toENetAddress(uint32_t ip, uint16_t port)
-{
- // because ENet wants little endian
- ENetAddress a;
- a.host = ((ip & 0xff000000) >> 24) +
- ((ip & 0x00ff0000) >> 8) + ((ip & 0x0000ff00) << 8) +
- ((ip & 0x000000ff) << 24);
- a.port = port;
- return a;
-} // toENetAddress
-
// ----------------------------------------------------------------------------
bool ConnectToServer::detectPort()
{
@@ -663,9 +619,7 @@ bool ConnectToServer::detectPort()
}
#endif
- ENetAddress ea;
- ea.host = STKHost::HOST_ANY;
- ea.port = STKHost::PORT_ANY;
+ ENetAddress ea = {};
std::unique_ptr nw(new Network(/*peer_count*/1,
/*channel_limit*/EVENT_CHANNEL_COUNT,
/*max_in_bandwidth*/0, /*max_out_bandwidth*/0, &ea,
diff --git a/src/network/protocols/connect_to_server.hpp b/src/network/protocols/connect_to_server.hpp
index 3deb216c7..4d2c1bca0 100644
--- a/src/network/protocols/connect_to_server.hpp
+++ b/src/network/protocols/connect_to_server.hpp
@@ -68,8 +68,6 @@ public:
virtual void setup() OVERRIDE;
virtual void asynchronousUpdate() OVERRIDE;
virtual void update(int ticks) OVERRIDE;
- static std::string enetAddressToString(const ENetAddress& addr);
- static ENetAddress toENetAddress(uint32_t ip, uint16_t port);
}; // class ConnectToServer
#endif // CONNECT_TO_SERVER_HPP
diff --git a/src/network/server_config.hpp b/src/network/server_config.hpp
index 46f8d4deb..c1f6c6d0f 100644
--- a/src/network/server_config.hpp
+++ b/src/network/server_config.hpp
@@ -189,7 +189,9 @@ namespace ServerConfig
"STK currently uses dual-stack mode which requires server to have both "
"IPv4 and IPv6 and listen to same port. If STK detects your server "
"has no public IPv6 address or port differs between IPv4 and IPv6 "
- "then it will use IPv4 only socket."));
+ "then it will use IPv4 only socket. For system which doesn't support "
+ "dual-stack socket (like OpenBSD) you may fail to be connected by "
+ "IPv4 clients."));
SERVER_CFG_PREFIX BoolServerConfigParam m_owner_less
SERVER_CFG_DEFAULT(BoolServerConfigParam(false, "owner-less",
diff --git a/src/network/servers_manager.cpp b/src/network/servers_manager.cpp
index 96512bf22..274ccdeba 100644
--- a/src/network/servers_manager.cpp
+++ b/src/network/servers_manager.cpp
@@ -159,9 +159,7 @@ std::shared_ptr ServersManager::getLANRefreshRequest() const
// --------------------------------------------------------------------
virtual void operation() OVERRIDE
{
- ENetAddress addr;
- addr.host = STKHost::HOST_ANY;
- addr.port = STKHost::PORT_ANY;
+ ENetAddress addr = {};
setIPv6Socket(UserConfigParams::m_ipv6_lan ? 1 : 0);
NetworkConfig::get()->setIPType(UserConfigParams::m_ipv6_lan ?
NetworkConfig::IP_DUAL_STACK : NetworkConfig::IP_V4);
diff --git a/src/network/socket_address.cpp b/src/network/socket_address.cpp
index ee33d7b3d..4092e45de 100644
--- a/src/network/socket_address.cpp
+++ b/src/network/socket_address.cpp
@@ -63,6 +63,33 @@ SocketAddress::SocketAddress(uint8_t b1, uint8_t b2, uint8_t b3, uint8_t b4,
{
} // SocketAddress(uint8_t,...)
+// ----------------------------------------------------------------------------
+/** ENetAddress constructor. */
+SocketAddress::SocketAddress(const ENetAddress& ea)
+{
+#ifdef ENABLE_IPV6
+ if (isIPv6Socket())
+ {
+ m_family = AF_INET6;
+ m_sockaddr = {};
+ struct sockaddr_in6* in6 = (struct sockaddr_in6*)m_sockaddr.data();
+ in6->sin6_family = AF_INET6;
+ in6->sin6_port = htons(ea.port);
+ // We modify host to use 5 uint32_t (see enet.h)
+ memcpy(in6->sin6_addr.s6_addr, &ea.host.p0, 16);
+ in6->sin6_scope_id = ea.host.p4;
+ }
+ else
+ {
+ setIP(htonl(ea.host.p0));
+ setPort(ea.port);
+ }
+#else
+ setIP(htonl(ea.host));
+ setPort(ea.port);
+#endif
+} // SocketAddress(const ENetAddress&)
+
// ----------------------------------------------------------------------------
/** String initialization (Can be IPv4, IPv6 or domain).
* \param str The address (can have a port with :)
@@ -680,3 +707,31 @@ void SocketAddress::unitTesting()
assert(ipv6_port.getPort() == 1);
} // unitTesting
+
+// ----------------------------------------------------------------------------
+ENetAddress SocketAddress::toENetAddress() const
+{
+ ENetAddress ea = {};
+ uint32_t ip = getIP();
+#ifdef ENABLE_IPV6
+ if (isIPv6Socket())
+ {
+ struct sockaddr_in6* in6 = (struct sockaddr_in6*)m_sockaddr.data();
+ memcpy(&ea.host.p0, in6->sin6_addr.s6_addr, 16);
+ ea.host.p4 = in6->sin6_scope_id;
+ }
+ else
+ {
+ // because ENet wants little endian
+ ea.host.p0 = ((ip & 0xff000000) >> 24) +
+ ((ip & 0x00ff0000) >> 8) + ((ip & 0x0000ff00) << 8) +
+ ((ip & 0x000000ff) << 24);
+ }
+#else
+ ea.host = ((ip & 0xff000000) >> 24) +
+ ((ip & 0x00ff0000) >> 8) + ((ip & 0x0000ff00) << 8) +
+ ((ip & 0x000000ff) << 24);
+#endif
+ ea.port = getPort();
+ return ea;
+} // toENetAddress
diff --git a/src/network/socket_address.hpp b/src/network/socket_address.hpp
index 836731ce8..4b9c5911f 100644
--- a/src/network/socket_address.hpp
+++ b/src/network/socket_address.hpp
@@ -31,6 +31,7 @@
# include
# include
#endif
+#include
#include
#include
@@ -69,6 +70,8 @@ public:
init(str, port_number, family);
}
// ------------------------------------------------------------------------
+ SocketAddress(const ENetAddress& ea);
+ // ------------------------------------------------------------------------
bool operator==(const SocketAddress& other) const;
// ------------------------------------------------------------------------
bool operator!=(const SocketAddress& other) const;
@@ -154,6 +157,8 @@ public:
bool isLoopback() const;
// ------------------------------------------------------------------------
void convertForIPv6Socket(bool ipv6);
+ // ------------------------------------------------------------------------
+ ENetAddress toENetAddress() const;
}; // SocketAddress
#endif // HEADER_SOCKET_ADDRESS_HPP
diff --git a/src/network/stk_host.cpp b/src/network/stk_host.cpp
index 49c78948a..a47e16eae 100644
--- a/src/network/stk_host.cpp
+++ b/src/network/stk_host.cpp
@@ -256,9 +256,7 @@ STKHost::STKHost(bool server)
init();
m_host_id = std::numeric_limits::max();
- ENetAddress addr;
- addr.host = STKHost::HOST_ANY;
-
+ ENetAddress addr = {};
if (server)
{
setIPv6Socket(ServerConfig::m_ipv6_server ? 1 : 0);
@@ -758,8 +756,7 @@ void STKHost::mainLoop()
if ((NetworkConfig::get()->isLAN() && is_server) ||
NetworkConfig::get()->isPublicServer())
{
- ENetAddress eaddr;
- eaddr.host = STKHost::HOST_ANY;
+ ENetAddress eaddr = {};
eaddr.port = stk_config->m_server_discovery_port;
direct_socket = new Network(1, 1, 0, 0, &eaddr);
if (direct_socket->getENetHost() == NULL)
@@ -774,7 +771,6 @@ void STKHost::mainLoop()
uint64_t last_ping_time = StkTime::getMonoTimeMs();
uint64_t last_update_speed_time = StkTime::getMonoTimeMs();
uint64_t last_ping_time_update_for_client = StkTime::getMonoTimeMs();
- uint64_t last_disconnect_time_update = StkTime::getMonoTimeMs();
std::map ctp;
while (m_exit_timeout.load() > StkTime::getMonoTimeMs())
{
@@ -812,15 +808,6 @@ void STKHost::mainLoop()
}
} // if discovery host
- if (isIPv6Socket() &&
- last_disconnect_time_update < StkTime::getMonoTimeMs())
- {
- // Check per 20 second, client needs to be handled too in case
- // the address changed in intercept callback
- // (see ConnectToServer::interceptCallback)
- last_disconnect_time_update = StkTime::getMonoTimeMs() + 20000;
- removeDisconnectedMappedAddress();
- }
if (is_server)
{
std::unique_lock peer_lock(m_peers_mutex);
@@ -969,7 +956,12 @@ void STKHost::mainLoop()
// Enet will reuse a disconnected peer so we check here to avoid
// sending to wrong peer
if (peer->state != ENET_PEER_STATE_CONNECTED ||
+#ifdef ENABLE_IPV6
+ (enet_ip_not_equal(ea_peer_now.host, ea.host) &&
+ ea_peer_now.port != ea.port))
+#else
(ea_peer_now.host != ea.host && ea_peer_now.port != ea.port))
+#endif
{
if (packet != NULL)
enet_packet_destroy(packet);
diff --git a/src/network/stk_host.hpp b/src/network/stk_host.hpp
index 4ab45a9cd..c76c253e9 100644
--- a/src/network/stk_host.hpp
+++ b/src/network/stk_host.hpp
@@ -69,17 +69,6 @@ enum ENetCommandType : unsigned int
class STKHost
{
-public:
- /** \brief Defines three host types for the server.
- * These values tells the host where he will accept connections from.
- */
- enum
- {
- HOST_ANY = 0, //!< Any host.
- HOST_BROADCAST = 0xFFFFFFFF, //!< Defines the broadcast address.
- PORT_ANY = 0 //!< Any port.
- };
-
private:
/** Singleton pointer to the instance. */
static STKHost* m_stk_host;
diff --git a/src/network/stk_ipv6.cpp b/src/network/stk_ipv6.cpp
index 0b4fdcbb7..3037c85e7 100644
--- a/src/network/stk_ipv6.cpp
+++ b/src/network/stk_ipv6.cpp
@@ -334,188 +334,31 @@ extern "C" int insideIPv6CIDR(const char* ipv6_cidr, const char* ipv6_in)
} // andIPv6
#ifndef ENABLE_IPV6
-#include "network/stk_ipv6.hpp"
// ----------------------------------------------------------------------------
-int isIPv6Socket()
+extern "C" int isIPv6Socket()
{
return 0;
} // isIPV6
// ----------------------------------------------------------------------------
-void setIPv6Socket(int val)
+extern "C" void setIPv6Socket(int val)
{
} // setIPV6
-// ----------------------------------------------------------------------------
-std::string getIPV6ReadableFromMappedAddress(const ENetAddress* ea)
-{
- return "";
-} // getIPV6ReadableFromMappedAddress
-
-// ----------------------------------------------------------------------------
-void removeDisconnectedMappedAddress()
-{
-} // removeDisconnectedMappedAddress
-
-// ----------------------------------------------------------------------------
-void addMappedAddress(const ENetAddress* ea, const struct sockaddr_in6* in6)
-{
-} // addMappedAddress
-
#else
-#include "network/stk_ipv6.hpp"
-#include "network/protocols/connect_to_server.hpp"
-#include "utils/string_utils.hpp"
-#include "utils/log.hpp"
-#include "utils/time.hpp"
-#include "utils/types.hpp"
-
-#include
-#include
-
// ============================================================================
-uint32_t g_mapped_ipv6_used;
int g_ipv6;
-struct MappedAddress
-{
- ENetAddress m_addr;
- struct sockaddr_in6 m_in6;
- uint64_t m_last_activity;
- MappedAddress(const ENetAddress& addr, const struct sockaddr_in6& in6)
- {
- m_addr = addr;
- m_in6 = in6;
- m_last_activity = StkTime::getMonoTimeMs();
- }
-};
-std::vector g_mapped_ips;
// ============================================================================
-int isIPv6Socket()
+extern "C" int isIPv6Socket()
{
return g_ipv6;
} // isIPV6
// ----------------------------------------------------------------------------
-void setIPv6Socket(int val)
+extern "C" void setIPv6Socket(int val)
{
g_ipv6 = val;
} // setIPV6
-// ----------------------------------------------------------------------------
-void stkInitialize()
-{
- // Clear previous setting, in case user changed wifi or mobile data
- g_mapped_ipv6_used = 0;
- g_ipv6 = 0;
- g_mapped_ips.clear();
-} // stkInitialize
-
-// ----------------------------------------------------------------------------
-std::string getIPV6ReadableFromMappedAddress(const ENetAddress* ea)
-{
- std::string result;
- auto it = std::find_if(g_mapped_ips.begin(), g_mapped_ips.end(),
- [ea](const MappedAddress& addr)
- {
- return ea->host == addr.m_addr.host &&
- ea->port == addr.m_addr.port;
- });
- if (it != g_mapped_ips.end())
- result = getIPV6ReadableFromIn6(&it->m_in6);
- return result;
-} // getIPV6ReadableFromMappedAddress
-
-// ----------------------------------------------------------------------------
-/** Add a (fake or synthesized by ios / osx) IPv4 address and map it to an IPv6
- * one, used in client to set the game server address or server to initialize
- * host.
- */
-void addMappedAddress(const ENetAddress* ea, const struct sockaddr_in6* in6)
-{
- g_mapped_ips.emplace_back(*ea, *in6);
-} // addMappedAddress
-
-// ----------------------------------------------------------------------------
-/* This is called when enet needs to sent to an mapped IPv4 address, we look up
- * the map here and get the real IPv6 address, so you need to call
- * addMappedAddress above first (for client mostly).
- */
-void getIPV6FromMappedAddress(const ENetAddress* ea, struct sockaddr_in6* in6)
-{
- auto it = std::find_if(g_mapped_ips.begin(), g_mapped_ips.end(),
- [ea](const MappedAddress& addr)
- {
- return ea->host == addr.m_addr.host &&
- ea->port == addr.m_addr.port;
- });
- if (it != g_mapped_ips.end())
- {
- it->m_last_activity = StkTime::getMonoTimeMs();
- memcpy(in6, &it->m_in6, sizeof(struct sockaddr_in6));
- }
- else
- memset(in6, 0, sizeof(struct sockaddr_in6));
-} // getIPV6FromMappedAddress
-
-// ----------------------------------------------------------------------------
-/* This is called when enet recieved a packet from its socket, we create an
- * real IPv4 address out of it or a fake one if it's from IPv6 connection.
- */
-void getMappedFromIPV6(const struct sockaddr_in6* in6, ENetAddress* ea)
-{
- auto it = std::find_if(g_mapped_ips.begin(), g_mapped_ips.end(),
- [in6](const MappedAddress& addr)
- {
- return sameIPV6(in6, &addr.m_in6);
- });
- if (it != g_mapped_ips.end())
- {
- it->m_last_activity = StkTime::getMonoTimeMs();
- *ea = it->m_addr;
- return;
- }
-
- if (isIPv4MappedAddress(in6))
- {
- ea->host = ((in_addr*)(in6->sin6_addr.s6_addr + 12))->s_addr;
- ea->port = ntohs(in6->sin6_port);
- addMappedAddress(ea, in6);
- }
- else
- {
- // Create a fake IPv4 address of 0.x.x.x if it's a real IPv6 connection
- if (g_mapped_ipv6_used >= 16777215)
- g_mapped_ipv6_used = 0;
- *ea = ConnectToServer::toENetAddress(++g_mapped_ipv6_used,
- ntohs(in6->sin6_port));
- Log::debug("IPv6", "Fake IPv4 address %s mapped to %s",
- ConnectToServer::enetAddressToString(*ea).c_str(),
- getIPV6ReadableFromIn6(in6).c_str());
- addMappedAddress(ea, in6);
- }
-} // getMappedFromIPV6
-
-// ----------------------------------------------------------------------------
-/* Called when a peer is expired (no activity for 20 seconds) and we remove its
- * reference to the IPv6.
- */
-void removeDisconnectedMappedAddress()
-{
- for (auto it = g_mapped_ips.begin(); it != g_mapped_ips.end();)
- {
- if (it->m_last_activity + 20000 < StkTime::getMonoTimeMs())
- {
- Log::debug("IPv6", "Removing expired %s, IPv4 address %s.",
- getIPV6ReadableFromIn6(&it->m_in6).c_str(),
- ConnectToServer::enetAddressToString(it->m_addr).c_str());
- it = g_mapped_ips.erase(it);
- Log::debug("IPv6", "Mapped address size now: %d.",
- g_mapped_ips.size());
- }
- else
- it++;
- }
-} // removeDisconnectedMappedAddress
-
#endif
diff --git a/src/network/stk_ipv6.hpp b/src/network/stk_ipv6.hpp
index 67174fa78..43cc4e3d1 100644
--- a/src/network/stk_ipv6.hpp
+++ b/src/network/stk_ipv6.hpp
@@ -23,10 +23,6 @@ extern "C" {
#endif
int isIPv6Socket();
void setIPv6Socket(int val);
-void stkInitialize();
-void getIPV6FromMappedAddress(const ENetAddress* ea, struct sockaddr_in6* in6);
-void getMappedFromIPV6(const struct sockaddr_in6* in6, ENetAddress* ea);
-void addMappedAddress(const ENetAddress* ea, const struct sockaddr_in6* in6);
int getaddrinfo_compat(const char* hostname, const char* servname,
const struct addrinfo* hints, struct addrinfo** res);
int64_t upperIPv6(const char* ipv6);
@@ -34,9 +30,7 @@ int insideIPv6CIDR(const char* ipv6_cidr, const char* ipv6_in);
#ifdef __cplusplus
}
#endif
-std::string getIPV6ReadableFromMappedAddress(const ENetAddress* ea);
std::string getIPV6ReadableFromIn6(const struct sockaddr_in6* in);
bool sameIPV6(const struct sockaddr_in6* in_1,
const struct sockaddr_in6* in_2);
-void removeDisconnectedMappedAddress();
bool isIPv4MappedAddress(const struct sockaddr_in6* in6);
diff --git a/src/network/stk_peer.cpp b/src/network/stk_peer.cpp
index e1bf9f8aa..06c416080 100644
--- a/src/network/stk_peer.cpp
+++ b/src/network/stk_peer.cpp
@@ -39,25 +39,7 @@ STKPeer::STKPeer(ENetPeer *enet_peer, STKHost* host, uint32_t host_id)
: m_address(enet_peer->address), m_host(host)
{
m_addons_scores.fill(-1);
- uint32_t addr = htonl(enet_peer->address.host);
-#ifdef ENABLE_IPV6
- if (isIPv6Socket())
- {
- // This will return the mapped IPv4 address too for IPv6 socket
- // So we can sendto directly with it
- struct sockaddr_in6 in6 = {};
- getIPV6FromMappedAddress(&enet_peer->address, &in6);
- m_socket_address.reset(new SocketAddress());
- m_socket_address->setSockAddrIn(AF_INET6, (sockaddr*)&in6, sizeof(in6));
- if (m_socket_address->isIPv6())
- m_ipv6_address = m_socket_address->toString(false/*show_port*/);
- }
- else
-#endif
- {
- m_socket_address.reset(
- new SocketAddress(addr, enet_peer->address.port));
- }
+ m_socket_address.reset(new SocketAddress(m_address));
m_enet_peer = enet_peer;
m_host_id = host_id;
m_connected_time = StkTime::getMonoTimeMs();
diff --git a/src/network/stk_peer.hpp b/src/network/stk_peer.hpp
index 5ee6e3e59..a46a9a1bb 100644
--- a/src/network/stk_peer.hpp
+++ b/src/network/stk_peer.hpp
@@ -117,8 +117,6 @@ protected:
std::string m_user_version;
- std::string m_ipv6_address;
-
/** List of client capabilities set when connecting it, to determine
* features available in same version. */
std::set m_client_capabilities;
@@ -140,8 +138,6 @@ public:
// ------------------------------------------------------------------------
bool isConnected() const;
// ------------------------------------------------------------------------
- const std::string& getIPV6Address() const { return m_ipv6_address; }
- // ------------------------------------------------------------------------
bool isSamePeer(const STKPeer* peer) const;
bool isSamePeer(const ENetPeer* peer) const;
// ------------------------------------------------------------------------