2016-06-01 23:58:21 +02:00
|
|
|
/*****************************************************************************
|
2024-01-01 12:52:28 +01:00
|
|
|
* Copyright (c) 2014-2024 OpenRCT2 developers
|
2016-06-01 23:58:21 +02:00
|
|
|
*
|
2018-06-15 14:07:34 +02:00
|
|
|
* For a complete list of all authors, please refer to contributors.md
|
|
|
|
* Interested in contributing? Visit https://github.com/OpenRCT2/OpenRCT2
|
2016-06-01 23:58:21 +02:00
|
|
|
*
|
2018-06-15 14:07:34 +02:00
|
|
|
* OpenRCT2 is licensed under the GNU General Public License version 3.
|
2016-06-01 23:58:21 +02:00
|
|
|
*****************************************************************************/
|
|
|
|
|
|
|
|
#ifndef DISABLE_NETWORK
|
|
|
|
|
2019-07-24 15:05:26 +02:00
|
|
|
# include <atomic>
|
2018-07-21 16:17:06 +02:00
|
|
|
# include <chrono>
|
|
|
|
# include <cmath>
|
|
|
|
# include <cstring>
|
|
|
|
# include <future>
|
|
|
|
# include <string>
|
|
|
|
# include <thread>
|
2017-03-29 23:17:55 +02:00
|
|
|
|
2018-01-10 16:14:36 +01:00
|
|
|
// clang-format off
|
2017-12-03 23:45:43 +01:00
|
|
|
// MSVC: include <math.h> here otherwise PI gets defined twice
|
|
|
|
#include <cmath>
|
|
|
|
|
2017-03-29 23:17:55 +02:00
|
|
|
#ifdef _WIN32
|
2020-07-26 16:07:24 +02:00
|
|
|
#pragma comment(lib, "Ws2_32.lib")
|
|
|
|
|
2016-06-01 23:58:21 +02:00
|
|
|
// winsock2 must be included before windows.h
|
|
|
|
#include <winsock2.h>
|
|
|
|
#include <ws2tcpip.h>
|
|
|
|
|
|
|
|
#define LAST_SOCKET_ERROR() WSAGetLastError()
|
|
|
|
#undef EWOULDBLOCK
|
|
|
|
#define EWOULDBLOCK WSAEWOULDBLOCK
|
|
|
|
#ifndef SHUT_RD
|
|
|
|
#define SHUT_RD SD_RECEIVE
|
|
|
|
#endif
|
2020-08-17 04:53:37 +02:00
|
|
|
#ifndef SHUT_WR
|
|
|
|
#define SHUT_WR SD_SEND
|
|
|
|
#endif
|
2016-06-01 23:58:21 +02:00
|
|
|
#ifndef SHUT_RDWR
|
|
|
|
#define SHUT_RDWR SD_BOTH
|
|
|
|
#endif
|
|
|
|
#define FLAG_NO_PIPE 0
|
|
|
|
#else
|
|
|
|
#include <arpa/inet.h>
|
2019-05-05 18:54:16 +02:00
|
|
|
#include <cerrno>
|
|
|
|
#include <fcntl.h>
|
|
|
|
#include <net/if.h>
|
2016-06-01 23:58:21 +02:00
|
|
|
#include <netdb.h>
|
2016-12-28 14:18:04 +01:00
|
|
|
#include <netinet/in.h>
|
2019-05-05 18:54:16 +02:00
|
|
|
#include <netinet/tcp.h>
|
|
|
|
#include <sys/ioctl.h>
|
2024-02-24 23:56:02 +01:00
|
|
|
#include <sys/select.h>
|
2016-06-01 23:58:21 +02:00
|
|
|
#include <sys/socket.h>
|
2024-02-24 23:56:02 +01:00
|
|
|
#include <sys/time.h>
|
2023-07-02 11:59:20 +02:00
|
|
|
#include <unistd.h>
|
2017-01-05 23:43:19 +01:00
|
|
|
#include "../common.h"
|
2018-06-20 17:28:51 +02:00
|
|
|
using SOCKET = int32_t;
|
2016-06-01 23:58:21 +02:00
|
|
|
#define SOCKET_ERROR -1
|
|
|
|
#define INVALID_SOCKET -1
|
|
|
|
#define LAST_SOCKET_ERROR() errno
|
|
|
|
#define closesocket close
|
|
|
|
#define ioctlsocket ioctl
|
2017-06-12 19:00:15 +02:00
|
|
|
#if defined(__linux__)
|
2016-06-01 23:58:21 +02:00
|
|
|
#define FLAG_NO_PIPE MSG_NOSIGNAL
|
|
|
|
#else
|
|
|
|
#define FLAG_NO_PIPE 0
|
2017-03-29 23:17:55 +02:00
|
|
|
#endif // defined(__linux__)
|
|
|
|
#endif // _WIN32
|
2018-01-10 16:14:36 +01:00
|
|
|
// clang-format on
|
2016-06-01 23:58:21 +02:00
|
|
|
|
2019-05-05 18:54:16 +02:00
|
|
|
# include "Socket.h"
|
2016-06-01 23:58:21 +02:00
|
|
|
|
2017-03-29 23:17:55 +02:00
|
|
|
constexpr auto CONNECT_TIMEOUT = std::chrono::milliseconds(3000);
|
2016-06-01 23:58:21 +02:00
|
|
|
|
2020-08-17 18:44:53 +02:00
|
|
|
// RAII WSA initialisation needed for Windows
|
2018-07-21 16:17:06 +02:00
|
|
|
# ifdef _WIN32
|
2020-08-17 18:44:53 +02:00
|
|
|
class WSA
|
|
|
|
{
|
|
|
|
private:
|
|
|
|
bool _isInitialised{};
|
|
|
|
|
|
|
|
public:
|
2022-02-09 21:57:25 +01:00
|
|
|
bool IsInitialised() const noexcept
|
2020-08-17 18:44:53 +02:00
|
|
|
{
|
|
|
|
return _isInitialised;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool Initialise()
|
|
|
|
{
|
|
|
|
if (!_isInitialised)
|
|
|
|
{
|
2023-01-17 13:24:51 +01:00
|
|
|
LOG_VERBOSE("WSAStartup()");
|
2020-08-17 18:44:53 +02:00
|
|
|
WSADATA wsa_data;
|
|
|
|
if (WSAStartup(MAKEWORD(2, 2), &wsa_data) != 0)
|
|
|
|
{
|
2023-01-17 13:24:51 +01:00
|
|
|
LOG_ERROR("Unable to initialise winsock.");
|
2020-08-17 18:44:53 +02:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
_isInitialised = true;
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2022-02-09 21:57:25 +01:00
|
|
|
~WSA() noexcept
|
2020-08-17 18:44:53 +02:00
|
|
|
{
|
|
|
|
if (_isInitialised)
|
|
|
|
{
|
2023-01-17 13:24:51 +01:00
|
|
|
LOG_VERBOSE("WSACleanup()");
|
2020-08-17 18:44:53 +02:00
|
|
|
WSACleanup();
|
|
|
|
_isInitialised = false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
static bool InitialiseWSA()
|
|
|
|
{
|
|
|
|
static WSA wsa;
|
|
|
|
return wsa.Initialise();
|
|
|
|
}
|
|
|
|
# else
|
|
|
|
static bool InitialiseWSA()
|
|
|
|
{
|
|
|
|
return true;
|
|
|
|
}
|
2018-07-21 16:17:06 +02:00
|
|
|
# endif
|
2017-02-08 13:53:00 +01:00
|
|
|
|
2018-01-02 20:23:22 +01:00
|
|
|
class SocketException : public std::runtime_error
|
2016-06-01 23:58:21 +02:00
|
|
|
{
|
|
|
|
public:
|
2018-06-22 23:02:47 +02:00
|
|
|
explicit SocketException(const std::string& message)
|
|
|
|
: std::runtime_error(message)
|
|
|
|
{
|
|
|
|
}
|
2016-06-01 23:58:21 +02:00
|
|
|
};
|
|
|
|
|
2019-05-05 18:54:16 +02:00
|
|
|
class NetworkEndpoint final : public INetworkEndpoint
|
|
|
|
{
|
|
|
|
private:
|
|
|
|
sockaddr _address{};
|
|
|
|
socklen_t _addressLen{};
|
|
|
|
|
|
|
|
public:
|
2022-02-09 21:57:25 +01:00
|
|
|
NetworkEndpoint() noexcept = default;
|
2019-05-05 18:54:16 +02:00
|
|
|
|
|
|
|
NetworkEndpoint(const sockaddr* address, socklen_t addressLen)
|
|
|
|
{
|
|
|
|
std::memcpy(&_address, address, addressLen);
|
|
|
|
_addressLen = addressLen;
|
|
|
|
}
|
|
|
|
|
2022-02-09 21:57:25 +01:00
|
|
|
constexpr const sockaddr& GetAddress() const noexcept
|
2019-05-05 18:54:16 +02:00
|
|
|
{
|
|
|
|
return _address;
|
|
|
|
}
|
|
|
|
|
2022-02-09 21:57:25 +01:00
|
|
|
constexpr socklen_t GetAddressLen() const noexcept
|
2019-05-05 18:54:16 +02:00
|
|
|
{
|
|
|
|
return _addressLen;
|
|
|
|
}
|
|
|
|
|
|
|
|
int32_t GetPort() const
|
|
|
|
{
|
|
|
|
if (_address.sa_family == AF_INET)
|
|
|
|
{
|
2020-06-07 23:18:11 +02:00
|
|
|
return reinterpret_cast<const sockaddr_in*>(&_address)->sin_port;
|
2019-05-05 18:54:16 +02:00
|
|
|
}
|
2021-09-15 22:22:15 +02:00
|
|
|
|
|
|
|
return reinterpret_cast<const sockaddr_in6*>(&_address)->sin6_port;
|
2019-05-05 18:54:16 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
std::string GetHostname() const override
|
|
|
|
{
|
2019-05-11 14:59:34 +02:00
|
|
|
char hostname[256]{};
|
2019-05-05 18:54:16 +02:00
|
|
|
int res = getnameinfo(&_address, _addressLen, hostname, sizeof(hostname), nullptr, 0, NI_NUMERICHOST);
|
|
|
|
if (res == 0)
|
|
|
|
{
|
|
|
|
return hostname;
|
|
|
|
}
|
|
|
|
return {};
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
class Socket
|
|
|
|
{
|
|
|
|
protected:
|
|
|
|
static bool ResolveAddress(const std::string& address, uint16_t port, sockaddr_storage* ss, socklen_t* ss_len)
|
|
|
|
{
|
|
|
|
return ResolveAddress(AF_UNSPEC, address, port, ss, ss_len);
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool ResolveAddressIPv4(const std::string& address, uint16_t port, sockaddr_storage* ss, socklen_t* ss_len)
|
|
|
|
{
|
|
|
|
return ResolveAddress(AF_INET, address, port, ss, ss_len);
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool SetNonBlocking(SOCKET socket, bool on)
|
|
|
|
{
|
|
|
|
# ifdef _WIN32
|
|
|
|
u_long nonBlocking = on;
|
|
|
|
return ioctlsocket(socket, FIONBIO, &nonBlocking) == 0;
|
|
|
|
# else
|
|
|
|
int32_t flags = fcntl(socket, F_GETFL, 0);
|
|
|
|
return fcntl(socket, F_SETFL, on ? (flags | O_NONBLOCK) : (flags & ~O_NONBLOCK)) == 0;
|
|
|
|
# endif
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool SetOption(SOCKET socket, int32_t a, int32_t b, bool value)
|
|
|
|
{
|
|
|
|
int32_t ivalue = value ? 1 : 0;
|
2020-04-22 17:09:29 +02:00
|
|
|
return setsockopt(socket, a, b, reinterpret_cast<const char*>(&ivalue), sizeof(ivalue)) == 0;
|
2019-05-05 18:54:16 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
static bool ResolveAddress(
|
|
|
|
int32_t family, const std::string& address, uint16_t port, sockaddr_storage* ss, socklen_t* ss_len)
|
|
|
|
{
|
|
|
|
std::string serviceName = std::to_string(port);
|
|
|
|
|
|
|
|
addrinfo hints = {};
|
|
|
|
hints.ai_family = family;
|
|
|
|
if (address.empty())
|
|
|
|
{
|
|
|
|
hints.ai_flags = AI_PASSIVE;
|
|
|
|
}
|
|
|
|
|
|
|
|
addrinfo* result = nullptr;
|
|
|
|
int errorcode = getaddrinfo(address.empty() ? nullptr : address.c_str(), serviceName.c_str(), &hints, &result);
|
|
|
|
if (errorcode != 0)
|
|
|
|
{
|
2023-01-17 13:24:51 +01:00
|
|
|
LOG_ERROR("Resolving address failed: Code %d.", errorcode);
|
|
|
|
LOG_ERROR("Resolution error message: %s.", gai_strerror(errorcode));
|
2019-05-05 18:54:16 +02:00
|
|
|
return false;
|
|
|
|
}
|
2021-09-15 22:22:15 +02:00
|
|
|
|
2019-05-05 18:54:16 +02:00
|
|
|
if (result == nullptr)
|
|
|
|
{
|
|
|
|
return false;
|
|
|
|
}
|
2021-09-15 22:22:15 +02:00
|
|
|
|
|
|
|
std::memcpy(ss, result->ai_addr, result->ai_addrlen);
|
|
|
|
*ss_len = static_cast<socklen_t>(result->ai_addrlen);
|
|
|
|
freeaddrinfo(result);
|
|
|
|
return true;
|
2019-05-05 18:54:16 +02:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
class TcpSocket final : public ITcpSocket, protected Socket
|
2016-06-01 23:58:21 +02:00
|
|
|
{
|
|
|
|
private:
|
2020-10-02 03:10:51 +02:00
|
|
|
std::atomic<SocketStatus> _status = ATOMIC_VAR_INIT(SocketStatus::Closed);
|
2018-06-22 23:02:47 +02:00
|
|
|
uint16_t _listeningPort = 0;
|
|
|
|
SOCKET _socket = INVALID_SOCKET;
|
2016-06-01 23:58:21 +02:00
|
|
|
|
2020-04-27 20:54:29 +02:00
|
|
|
std::string _ipAddress;
|
2018-06-22 23:02:47 +02:00
|
|
|
std::string _hostName;
|
|
|
|
std::future<void> _connectFuture;
|
|
|
|
std::string _error;
|
2016-06-01 23:58:21 +02:00
|
|
|
|
|
|
|
public:
|
2022-02-09 21:57:25 +01:00
|
|
|
TcpSocket() noexcept = default;
|
2016-06-01 23:58:21 +02:00
|
|
|
|
2022-04-25 15:37:32 +02:00
|
|
|
explicit TcpSocket(SOCKET socket, std::string hostName, std::string ipAddress) noexcept
|
|
|
|
: _status(SocketStatus::Connected)
|
|
|
|
, _socket(socket)
|
|
|
|
, _ipAddress(std::move(ipAddress))
|
|
|
|
, _hostName(std::move(hostName))
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2016-06-01 23:58:21 +02:00
|
|
|
~TcpSocket() override
|
|
|
|
{
|
2017-03-29 23:17:55 +02:00
|
|
|
if (_connectFuture.valid())
|
2016-06-01 23:58:21 +02:00
|
|
|
{
|
2017-03-29 23:17:55 +02:00
|
|
|
_connectFuture.wait();
|
2016-06-01 23:58:21 +02:00
|
|
|
}
|
2017-03-29 23:17:55 +02:00
|
|
|
CloseSocket();
|
2016-06-01 23:58:21 +02:00
|
|
|
}
|
|
|
|
|
2020-10-02 03:10:51 +02:00
|
|
|
SocketStatus GetStatus() const override
|
2016-06-01 23:58:21 +02:00
|
|
|
{
|
|
|
|
return _status;
|
|
|
|
}
|
|
|
|
|
2019-05-12 01:57:56 +02:00
|
|
|
const char* GetError() const override
|
2016-06-01 23:58:21 +02:00
|
|
|
{
|
|
|
|
return _error.empty() ? nullptr : _error.c_str();
|
|
|
|
}
|
|
|
|
|
2020-08-17 14:10:36 +02:00
|
|
|
void SetNoDelay(bool noDelay) override
|
|
|
|
{
|
|
|
|
if (_socket != INVALID_SOCKET)
|
|
|
|
{
|
|
|
|
SetOption(_socket, IPPROTO_TCP, TCP_NODELAY, noDelay);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-06-20 17:28:51 +02:00
|
|
|
void Listen(uint16_t port) override
|
2016-06-01 23:58:21 +02:00
|
|
|
{
|
2019-02-23 15:54:17 +01:00
|
|
|
Listen("", port);
|
2016-06-01 23:58:21 +02:00
|
|
|
}
|
|
|
|
|
2019-02-23 15:54:17 +01:00
|
|
|
void Listen(const std::string& address, uint16_t port) override
|
2016-06-01 23:58:21 +02:00
|
|
|
{
|
2020-10-02 03:10:51 +02:00
|
|
|
if (_status != SocketStatus::Closed)
|
2016-06-01 23:58:21 +02:00
|
|
|
{
|
2018-01-02 20:23:22 +01:00
|
|
|
throw std::runtime_error("Socket not closed.");
|
2016-06-01 23:58:21 +02:00
|
|
|
}
|
|
|
|
|
2018-06-22 23:02:47 +02:00
|
|
|
sockaddr_storage ss{};
|
2019-05-05 18:54:16 +02:00
|
|
|
socklen_t ss_len;
|
2016-06-01 23:58:21 +02:00
|
|
|
if (!ResolveAddress(address, port, &ss, &ss_len))
|
|
|
|
{
|
|
|
|
throw SocketException("Unable to resolve address.");
|
|
|
|
}
|
|
|
|
|
|
|
|
// Create the listening socket
|
|
|
|
_socket = socket(ss.ss_family, SOCK_STREAM, IPPROTO_TCP);
|
|
|
|
if (_socket == INVALID_SOCKET)
|
|
|
|
{
|
|
|
|
throw SocketException("Unable to create socket.");
|
|
|
|
}
|
|
|
|
|
|
|
|
// Turn off IPV6_V6ONLY so we can accept both v4 and v6 connections
|
2021-02-11 22:17:15 +01:00
|
|
|
if (!SetOption(_socket, IPPROTO_IPV6, IPV6_V6ONLY, false))
|
2016-06-01 23:58:21 +02:00
|
|
|
{
|
2023-01-17 13:24:51 +01:00
|
|
|
LOG_VERBOSE("setsockopt(socket, IPV6_V6ONLY) failed: %d", LAST_SOCKET_ERROR());
|
2016-06-01 23:58:21 +02:00
|
|
|
}
|
|
|
|
|
2021-02-11 22:17:15 +01:00
|
|
|
if (!SetOption(_socket, SOL_SOCKET, SO_REUSEADDR, true))
|
2017-07-24 19:24:19 +02:00
|
|
|
{
|
2023-01-17 13:24:51 +01:00
|
|
|
LOG_VERBOSE("setsockopt(socket, SO_REUSEADDR) failed: %d", LAST_SOCKET_ERROR());
|
2017-07-24 19:24:19 +02:00
|
|
|
}
|
|
|
|
|
2016-06-01 23:58:21 +02:00
|
|
|
try
|
|
|
|
{
|
|
|
|
// Bind to address:port and listen
|
2020-04-22 17:09:29 +02:00
|
|
|
if (bind(_socket, reinterpret_cast<sockaddr*>(&ss), ss_len) != 0)
|
2016-06-01 23:58:21 +02:00
|
|
|
{
|
2021-02-11 22:17:15 +01:00
|
|
|
std::string addressOrStar = address.empty() ? "*" : address.c_str();
|
|
|
|
throw SocketException("Unable to bind to address " + addressOrStar + ":" + std::to_string(port));
|
2016-06-01 23:58:21 +02:00
|
|
|
}
|
|
|
|
if (listen(_socket, SOMAXCONN) != 0)
|
|
|
|
{
|
|
|
|
throw SocketException("Unable to listen on socket.");
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!SetNonBlocking(_socket, true))
|
|
|
|
{
|
|
|
|
throw SocketException("Failed to set non-blocking mode.");
|
|
|
|
}
|
|
|
|
}
|
2018-06-22 23:02:47 +02:00
|
|
|
catch (const std::exception&)
|
2016-06-01 23:58:21 +02:00
|
|
|
{
|
|
|
|
CloseSocket();
|
|
|
|
throw;
|
|
|
|
}
|
|
|
|
|
|
|
|
_listeningPort = port;
|
2020-10-02 03:10:51 +02:00
|
|
|
_status = SocketStatus::Listening;
|
2016-06-01 23:58:21 +02:00
|
|
|
}
|
|
|
|
|
2018-12-17 12:58:12 +01:00
|
|
|
std::unique_ptr<ITcpSocket> Accept() override
|
2016-06-01 23:58:21 +02:00
|
|
|
{
|
2020-10-02 03:10:51 +02:00
|
|
|
if (_status != SocketStatus::Listening)
|
2016-06-01 23:58:21 +02:00
|
|
|
{
|
2018-01-02 20:23:22 +01:00
|
|
|
throw std::runtime_error("Socket not listening.");
|
2016-06-01 23:58:21 +02:00
|
|
|
}
|
2018-06-22 23:02:47 +02:00
|
|
|
struct sockaddr_storage client_addr
|
|
|
|
{
|
|
|
|
};
|
2016-10-12 15:44:20 +02:00
|
|
|
socklen_t client_len = sizeof(struct sockaddr_storage);
|
2016-06-01 23:58:21 +02:00
|
|
|
|
2018-12-17 12:58:12 +01:00
|
|
|
std::unique_ptr<ITcpSocket> tcpSocket;
|
2020-04-22 17:09:29 +02:00
|
|
|
SOCKET socket = accept(_socket, reinterpret_cast<struct sockaddr*>(&client_addr), &client_len);
|
2016-06-01 23:58:21 +02:00
|
|
|
if (socket == INVALID_SOCKET)
|
|
|
|
{
|
|
|
|
if (LAST_SOCKET_ERROR() != EWOULDBLOCK)
|
|
|
|
{
|
2023-01-17 13:24:51 +01:00
|
|
|
LOG_ERROR("Failed to accept client.");
|
2016-06-01 23:58:21 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (!SetNonBlocking(socket, true))
|
|
|
|
{
|
|
|
|
closesocket(socket);
|
2023-01-17 13:24:51 +01:00
|
|
|
LOG_ERROR("Failed to set non-blocking mode.");
|
2016-06-01 23:58:21 +02:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2020-04-27 20:54:29 +02:00
|
|
|
auto ipAddress = GetIpAddressFromSocket(reinterpret_cast<sockaddr_in*>(&client_addr));
|
|
|
|
|
2016-10-12 22:56:39 +02:00
|
|
|
char hostName[NI_MAXHOST];
|
2018-06-20 17:28:51 +02:00
|
|
|
int32_t rc = getnameinfo(
|
2020-04-22 17:09:29 +02:00
|
|
|
reinterpret_cast<struct sockaddr*>(&client_addr), client_len, hostName, sizeof(hostName), nullptr, 0,
|
2016-11-13 20:17:49 +01:00
|
|
|
NI_NUMERICHOST | NI_NUMERICSERV);
|
2020-08-17 14:10:36 +02:00
|
|
|
SetNoDelay(true);
|
2020-04-27 20:54:29 +02:00
|
|
|
|
2016-10-12 23:54:13 +02:00
|
|
|
if (rc == 0)
|
|
|
|
{
|
2022-04-25 15:37:32 +02:00
|
|
|
tcpSocket = std::make_unique<TcpSocket>(socket, hostName, ipAddress);
|
2018-08-28 20:46:13 +02:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2022-04-25 15:37:32 +02:00
|
|
|
tcpSocket = std::make_unique<TcpSocket>(socket, "", ipAddress);
|
2016-10-12 22:56:39 +02:00
|
|
|
}
|
2016-06-01 23:58:21 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
return tcpSocket;
|
|
|
|
}
|
|
|
|
|
2019-02-23 15:54:17 +01:00
|
|
|
void Connect(const std::string& address, uint16_t port) override
|
2016-06-01 23:58:21 +02:00
|
|
|
{
|
2020-10-02 03:10:51 +02:00
|
|
|
if (_status != SocketStatus::Closed && _status != SocketStatus::Waiting)
|
2016-06-01 23:58:21 +02:00
|
|
|
{
|
2018-01-02 20:23:22 +01:00
|
|
|
throw std::runtime_error("Socket not closed.");
|
2016-06-01 23:58:21 +02:00
|
|
|
}
|
2016-11-13 20:17:49 +01:00
|
|
|
|
2016-06-01 23:58:21 +02:00
|
|
|
try
|
|
|
|
{
|
|
|
|
// Resolve address
|
2020-10-02 03:10:51 +02:00
|
|
|
_status = SocketStatus::Resolving;
|
2016-06-01 23:58:21 +02:00
|
|
|
|
2018-06-22 23:02:47 +02:00
|
|
|
sockaddr_storage ss{};
|
2019-05-05 18:54:16 +02:00
|
|
|
socklen_t ss_len;
|
2016-06-01 23:58:21 +02:00
|
|
|
if (!ResolveAddress(address, port, &ss, &ss_len))
|
|
|
|
{
|
|
|
|
throw SocketException("Unable to resolve address.");
|
|
|
|
}
|
|
|
|
|
2020-10-02 03:10:51 +02:00
|
|
|
_status = SocketStatus::Connecting;
|
2016-06-01 23:58:21 +02:00
|
|
|
_socket = socket(ss.ss_family, SOCK_STREAM, IPPROTO_TCP);
|
|
|
|
if (_socket == INVALID_SOCKET)
|
|
|
|
{
|
|
|
|
throw SocketException("Unable to create socket.");
|
|
|
|
}
|
|
|
|
|
2020-08-17 14:10:36 +02:00
|
|
|
SetNoDelay(true);
|
2016-06-01 23:58:21 +02:00
|
|
|
if (!SetNonBlocking(_socket, true))
|
|
|
|
{
|
|
|
|
throw SocketException("Failed to set non-blocking mode.");
|
|
|
|
}
|
|
|
|
|
|
|
|
// Connect
|
2020-04-22 17:09:29 +02:00
|
|
|
int32_t connectResult = connect(_socket, reinterpret_cast<sockaddr*>(&ss), ss_len);
|
2018-06-22 23:02:47 +02:00
|
|
|
if (connectResult != SOCKET_ERROR || (LAST_SOCKET_ERROR() != EINPROGRESS && LAST_SOCKET_ERROR() != EWOULDBLOCK))
|
2016-06-01 23:58:21 +02:00
|
|
|
{
|
|
|
|
throw SocketException("Failed to connect.");
|
|
|
|
}
|
|
|
|
|
2017-03-29 23:17:55 +02:00
|
|
|
auto connectStartTime = std::chrono::system_clock::now();
|
2016-06-01 23:58:21 +02:00
|
|
|
|
2018-06-20 17:28:51 +02:00
|
|
|
int32_t error = 0;
|
2016-06-01 23:58:21 +02:00
|
|
|
socklen_t len = sizeof(error);
|
2020-04-22 17:09:29 +02:00
|
|
|
if (getsockopt(_socket, SOL_SOCKET, SO_ERROR, reinterpret_cast<char*>(&error), &len) != 0)
|
2016-06-01 23:58:21 +02:00
|
|
|
{
|
|
|
|
throw SocketException("getsockopt failed with error: " + std::to_string(LAST_SOCKET_ERROR()));
|
|
|
|
}
|
|
|
|
if (error != 0)
|
|
|
|
{
|
|
|
|
throw SocketException("Connection failed: " + std::to_string(error));
|
|
|
|
}
|
|
|
|
|
|
|
|
do
|
|
|
|
{
|
|
|
|
// Sleep for a bit
|
2017-03-29 23:17:55 +02:00
|
|
|
std::this_thread::sleep_for(std::chrono::milliseconds(100));
|
2016-06-01 23:58:21 +02:00
|
|
|
|
|
|
|
fd_set writeFD;
|
|
|
|
FD_ZERO(&writeFD);
|
2018-07-21 16:17:06 +02:00
|
|
|
# pragma warning(push)
|
|
|
|
# pragma warning(disable : 4548) // expression before comma has no effect; expected expression with side-effect
|
2016-06-01 23:58:21 +02:00
|
|
|
FD_SET(_socket, &writeFD);
|
2018-07-21 16:17:06 +02:00
|
|
|
# pragma warning(pop)
|
2018-06-22 23:02:47 +02:00
|
|
|
timeval timeout{};
|
2016-06-01 23:58:21 +02:00
|
|
|
timeout.tv_sec = 0;
|
|
|
|
timeout.tv_usec = 0;
|
2020-04-22 17:09:29 +02:00
|
|
|
if (select(static_cast<int32_t>(_socket + 1), nullptr, &writeFD, nullptr, &timeout) > 0)
|
2016-06-01 23:58:21 +02:00
|
|
|
{
|
|
|
|
error = 0;
|
2017-01-12 18:36:05 +01:00
|
|
|
len = sizeof(error);
|
2020-04-22 17:09:29 +02:00
|
|
|
if (getsockopt(_socket, SOL_SOCKET, SO_ERROR, reinterpret_cast<char*>(&error), &len) != 0)
|
2016-06-01 23:58:21 +02:00
|
|
|
{
|
|
|
|
throw SocketException("getsockopt failed with error: " + std::to_string(LAST_SOCKET_ERROR()));
|
|
|
|
}
|
|
|
|
if (error == 0)
|
|
|
|
{
|
2020-10-02 03:10:51 +02:00
|
|
|
_status = SocketStatus::Connected;
|
2016-06-01 23:58:21 +02:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
2017-03-29 23:17:55 +02:00
|
|
|
} while ((std::chrono::system_clock::now() - connectStartTime) < CONNECT_TIMEOUT);
|
2016-06-01 23:58:21 +02:00
|
|
|
|
|
|
|
// Connection request timed out
|
|
|
|
throw SocketException("Connection timed out.");
|
|
|
|
}
|
2018-06-22 23:02:47 +02:00
|
|
|
catch (const std::exception&)
|
2016-06-01 23:58:21 +02:00
|
|
|
{
|
|
|
|
CloseSocket();
|
|
|
|
throw;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-02-23 15:54:17 +01:00
|
|
|
void ConnectAsync(const std::string& address, uint16_t port) override
|
2016-06-01 23:58:21 +02:00
|
|
|
{
|
2020-10-02 03:10:51 +02:00
|
|
|
if (_status != SocketStatus::Closed)
|
2016-06-01 23:58:21 +02:00
|
|
|
{
|
2018-01-02 20:23:22 +01:00
|
|
|
throw std::runtime_error("Socket not closed.");
|
2016-06-01 23:58:21 +02:00
|
|
|
}
|
|
|
|
|
2020-08-30 20:39:59 +02:00
|
|
|
// When connect is called, the status is set to resolving, but we want to make sure
|
|
|
|
// the status is changed before this async method exits. Otherwise, the consumer
|
|
|
|
// might think the status has closed before it started to connect.
|
2020-10-02 03:10:51 +02:00
|
|
|
_status = SocketStatus::Waiting;
|
2020-08-30 20:39:59 +02:00
|
|
|
|
2017-03-29 23:17:55 +02:00
|
|
|
auto saddress = std::string(address);
|
|
|
|
std::promise<void> barrier;
|
|
|
|
_connectFuture = barrier.get_future();
|
2018-06-22 23:02:47 +02:00
|
|
|
auto thread = std::thread(
|
|
|
|
[this, saddress, port](std::promise<void> barrier2) -> void {
|
|
|
|
try
|
|
|
|
{
|
|
|
|
Connect(saddress.c_str(), port);
|
|
|
|
}
|
|
|
|
catch (const std::exception& ex)
|
|
|
|
{
|
|
|
|
_error = std::string(ex.what());
|
|
|
|
}
|
|
|
|
barrier2.set_value();
|
|
|
|
},
|
|
|
|
std::move(barrier));
|
2017-03-29 23:17:55 +02:00
|
|
|
thread.detach();
|
2016-06-01 23:58:21 +02:00
|
|
|
}
|
|
|
|
|
2020-08-17 04:53:37 +02:00
|
|
|
void Finish() override
|
|
|
|
{
|
2020-10-02 03:10:51 +02:00
|
|
|
if (_status == SocketStatus::Connected)
|
2020-08-17 04:53:37 +02:00
|
|
|
{
|
|
|
|
shutdown(_socket, SHUT_WR);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-06-01 23:58:21 +02:00
|
|
|
void Disconnect() override
|
|
|
|
{
|
2020-10-02 03:10:51 +02:00
|
|
|
if (_status == SocketStatus::Connected)
|
2016-06-01 23:58:21 +02:00
|
|
|
{
|
|
|
|
shutdown(_socket, SHUT_RDWR);
|
|
|
|
}
|
2021-05-09 08:56:20 +02:00
|
|
|
_status = SocketStatus::Closed;
|
2016-06-01 23:58:21 +02:00
|
|
|
}
|
|
|
|
|
2018-06-22 23:02:47 +02:00
|
|
|
size_t SendData(const void* buffer, size_t size) override
|
2016-06-01 23:58:21 +02:00
|
|
|
{
|
2020-10-02 03:10:51 +02:00
|
|
|
if (_status != SocketStatus::Connected)
|
2016-06-01 23:58:21 +02:00
|
|
|
{
|
2018-01-02 20:23:22 +01:00
|
|
|
throw std::runtime_error("Socket not connected.");
|
2016-06-01 23:58:21 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
size_t totalSent = 0;
|
|
|
|
do
|
|
|
|
{
|
2020-04-22 17:09:29 +02:00
|
|
|
const char* bufferStart = static_cast<const char*>(buffer) + totalSent;
|
2016-06-09 13:29:44 +02:00
|
|
|
size_t remainingSize = size - totalSent;
|
2020-04-22 17:09:29 +02:00
|
|
|
int32_t sentBytes = send(_socket, bufferStart, static_cast<int32_t>(remainingSize), FLAG_NO_PIPE);
|
2016-06-01 23:58:21 +02:00
|
|
|
if (sentBytes == SOCKET_ERROR)
|
|
|
|
{
|
2016-06-10 00:04:02 +02:00
|
|
|
return totalSent;
|
2016-06-01 23:58:21 +02:00
|
|
|
}
|
|
|
|
totalSent += sentBytes;
|
|
|
|
} while (totalSent < size);
|
2016-06-10 00:04:02 +02:00
|
|
|
return totalSent;
|
2016-06-01 23:58:21 +02:00
|
|
|
}
|
|
|
|
|
2020-08-31 14:13:15 +02:00
|
|
|
NetworkReadPacket ReceiveData(void* buffer, size_t size, size_t* sizeReceived) override
|
2016-06-01 23:58:21 +02:00
|
|
|
{
|
2020-10-02 03:10:51 +02:00
|
|
|
if (_status != SocketStatus::Connected)
|
2016-06-01 23:58:21 +02:00
|
|
|
{
|
2018-01-02 20:23:22 +01:00
|
|
|
throw std::runtime_error("Socket not connected.");
|
2016-06-01 23:58:21 +02:00
|
|
|
}
|
|
|
|
|
2020-04-22 17:09:29 +02:00
|
|
|
int32_t readBytes = recv(_socket, static_cast<char*>(buffer), static_cast<int32_t>(size), 0);
|
2016-07-24 22:01:14 +02:00
|
|
|
if (readBytes == 0)
|
|
|
|
{
|
|
|
|
*sizeReceived = 0;
|
2020-08-31 14:13:15 +02:00
|
|
|
return NetworkReadPacket::Disconnected;
|
2016-07-24 22:01:14 +02:00
|
|
|
}
|
2021-09-15 22:22:15 +02:00
|
|
|
|
|
|
|
if (readBytes == SOCKET_ERROR)
|
2016-06-01 23:58:21 +02:00
|
|
|
{
|
|
|
|
*sizeReceived = 0;
|
2018-07-21 16:17:06 +02:00
|
|
|
# ifndef _WIN32
|
2018-05-15 21:30:34 +02:00
|
|
|
// Removing the check for EAGAIN and instead relying on the values being the same allows turning on of
|
|
|
|
// -Wlogical-op warning.
|
|
|
|
// This is not true on Windows, see:
|
|
|
|
// * https://msdn.microsoft.com/en-us/library/windows/desktop/ms737828(v=vs.85).aspx
|
|
|
|
// * https://msdn.microsoft.com/en-us/library/windows/desktop/ms741580(v=vs.85).aspx
|
|
|
|
// * https://msdn.microsoft.com/en-us/library/windows/desktop/ms740668(v=vs.85).aspx
|
2018-06-22 23:02:47 +02:00
|
|
|
static_assert(
|
|
|
|
EWOULDBLOCK == EAGAIN,
|
|
|
|
"Portability note: your system has different values for EWOULDBLOCK "
|
|
|
|
"and EAGAIN, please extend the condition below");
|
2018-07-21 16:17:06 +02:00
|
|
|
# endif // _WIN32
|
2018-05-15 21:30:34 +02:00
|
|
|
if (LAST_SOCKET_ERROR() != EWOULDBLOCK)
|
2016-06-01 23:58:21 +02:00
|
|
|
{
|
2020-08-31 14:13:15 +02:00
|
|
|
return NetworkReadPacket::Disconnected;
|
2016-06-01 23:58:21 +02:00
|
|
|
}
|
2021-09-15 22:22:15 +02:00
|
|
|
|
|
|
|
return NetworkReadPacket::NoData;
|
2016-06-01 23:58:21 +02:00
|
|
|
}
|
2021-09-15 22:22:15 +02:00
|
|
|
|
|
|
|
*sizeReceived = readBytes;
|
|
|
|
return NetworkReadPacket::Success;
|
2016-06-01 23:58:21 +02:00
|
|
|
}
|
|
|
|
|
2016-06-02 10:13:25 +02:00
|
|
|
void Close() override
|
2016-06-01 23:58:21 +02:00
|
|
|
{
|
2017-03-29 23:17:55 +02:00
|
|
|
if (_connectFuture.valid())
|
2016-06-01 23:58:21 +02:00
|
|
|
{
|
2017-03-29 23:17:55 +02:00
|
|
|
_connectFuture.wait();
|
2016-06-01 23:58:21 +02:00
|
|
|
}
|
2017-03-29 23:17:55 +02:00
|
|
|
CloseSocket();
|
2016-06-01 23:58:21 +02:00
|
|
|
}
|
|
|
|
|
2018-06-22 23:02:47 +02:00
|
|
|
const char* GetHostName() const override
|
2016-10-12 15:44:20 +02:00
|
|
|
{
|
2016-10-12 22:56:39 +02:00
|
|
|
return _hostName.empty() ? nullptr : _hostName.c_str();
|
2016-10-12 15:44:20 +02:00
|
|
|
}
|
|
|
|
|
2020-04-27 20:54:29 +02:00
|
|
|
std::string GetIpAddress() const override
|
|
|
|
{
|
|
|
|
return _ipAddress;
|
|
|
|
}
|
|
|
|
|
2016-06-01 23:58:21 +02:00
|
|
|
private:
|
|
|
|
void CloseSocket()
|
|
|
|
{
|
|
|
|
if (_socket != INVALID_SOCKET)
|
|
|
|
{
|
|
|
|
closesocket(_socket);
|
|
|
|
_socket = INVALID_SOCKET;
|
|
|
|
}
|
2020-10-02 03:10:51 +02:00
|
|
|
_status = SocketStatus::Closed;
|
2016-06-01 23:58:21 +02:00
|
|
|
}
|
2020-04-27 20:54:29 +02:00
|
|
|
|
2022-02-09 21:57:25 +01:00
|
|
|
std::string GetIpAddressFromSocket(const sockaddr_in* addr) const
|
2020-04-27 20:54:29 +02:00
|
|
|
{
|
|
|
|
std::string result;
|
|
|
|
if (addr->sin_family == AF_INET)
|
|
|
|
{
|
|
|
|
char str[INET_ADDRSTRLEN]{};
|
|
|
|
inet_ntop(AF_INET, &addr->sin_addr, str, sizeof(str));
|
|
|
|
result = str;
|
|
|
|
}
|
|
|
|
else if (addr->sin_family == AF_INET6)
|
|
|
|
{
|
|
|
|
auto addrv6 = reinterpret_cast<const sockaddr_in6*>(&addr);
|
|
|
|
char str[INET6_ADDRSTRLEN]{};
|
|
|
|
inet_ntop(AF_INET6, &addrv6->sin6_addr, str, sizeof(str));
|
|
|
|
result = str;
|
|
|
|
}
|
|
|
|
return result;
|
|
|
|
}
|
2019-05-05 18:54:16 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
class UdpSocket final : public IUdpSocket, protected Socket
|
|
|
|
{
|
|
|
|
private:
|
2020-10-02 03:10:51 +02:00
|
|
|
SocketStatus _status = SocketStatus::Closed;
|
2019-05-05 18:54:16 +02:00
|
|
|
uint16_t _listeningPort = 0;
|
|
|
|
SOCKET _socket = INVALID_SOCKET;
|
|
|
|
NetworkEndpoint _endpoint;
|
2016-06-01 23:58:21 +02:00
|
|
|
|
2019-05-05 18:54:16 +02:00
|
|
|
std::string _hostName;
|
|
|
|
std::string _error;
|
|
|
|
|
|
|
|
public:
|
2022-02-09 21:57:25 +01:00
|
|
|
UdpSocket() noexcept = default;
|
2019-05-05 18:54:16 +02:00
|
|
|
|
|
|
|
~UdpSocket() override
|
2016-06-01 23:58:21 +02:00
|
|
|
{
|
2019-05-05 18:54:16 +02:00
|
|
|
CloseSocket();
|
|
|
|
}
|
2016-06-01 23:58:21 +02:00
|
|
|
|
2020-10-02 03:10:51 +02:00
|
|
|
SocketStatus GetStatus() const override
|
2019-05-05 18:54:16 +02:00
|
|
|
{
|
|
|
|
return _status;
|
|
|
|
}
|
|
|
|
|
2019-05-12 01:57:56 +02:00
|
|
|
const char* GetError() const override
|
2019-05-05 18:54:16 +02:00
|
|
|
{
|
|
|
|
return _error.empty() ? nullptr : _error.c_str();
|
|
|
|
}
|
|
|
|
|
|
|
|
void Listen(uint16_t port) override
|
|
|
|
{
|
|
|
|
Listen("", port);
|
|
|
|
}
|
|
|
|
|
|
|
|
void Listen(const std::string& address, uint16_t port) override
|
|
|
|
{
|
2020-10-02 03:10:51 +02:00
|
|
|
if (_status != SocketStatus::Closed)
|
2016-06-01 23:58:21 +02:00
|
|
|
{
|
2019-05-05 18:54:16 +02:00
|
|
|
throw std::runtime_error("Socket not closed.");
|
2016-06-01 23:58:21 +02:00
|
|
|
}
|
|
|
|
|
2019-05-05 18:54:16 +02:00
|
|
|
sockaddr_storage ss{};
|
|
|
|
socklen_t ss_len;
|
|
|
|
if (!ResolveAddressIPv4(address, port, &ss, &ss_len))
|
2017-09-10 05:48:29 +02:00
|
|
|
{
|
2019-05-05 18:54:16 +02:00
|
|
|
throw SocketException("Unable to resolve address.");
|
2017-09-10 05:48:29 +02:00
|
|
|
}
|
2019-05-05 18:54:16 +02:00
|
|
|
|
|
|
|
// Create the listening socket
|
2019-05-07 18:55:48 +02:00
|
|
|
_socket = CreateSocket();
|
2019-05-05 18:54:16 +02:00
|
|
|
try
|
|
|
|
{
|
|
|
|
// Bind to address:port and listen
|
2020-04-22 17:09:29 +02:00
|
|
|
if (bind(_socket, reinterpret_cast<sockaddr*>(&ss), ss_len) != 0)
|
2019-05-05 18:54:16 +02:00
|
|
|
{
|
|
|
|
throw SocketException("Unable to bind to socket.");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
catch (const std::exception&)
|
|
|
|
{
|
|
|
|
CloseSocket();
|
|
|
|
throw;
|
|
|
|
}
|
|
|
|
|
|
|
|
_listeningPort = port;
|
2020-10-02 03:10:51 +02:00
|
|
|
_status = SocketStatus::Listening;
|
2019-05-05 18:54:16 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
size_t SendData(const std::string& address, uint16_t port, const void* buffer, size_t size) override
|
|
|
|
{
|
|
|
|
sockaddr_storage ss{};
|
|
|
|
socklen_t ss_len;
|
|
|
|
if (!ResolveAddressIPv4(address, port, &ss, &ss_len))
|
|
|
|
{
|
|
|
|
throw SocketException("Unable to resolve address.");
|
|
|
|
}
|
2020-04-22 17:09:29 +02:00
|
|
|
NetworkEndpoint endpoint(reinterpret_cast<const sockaddr*>(&ss), ss_len);
|
2019-05-05 18:54:16 +02:00
|
|
|
return SendData(endpoint, buffer, size);
|
|
|
|
}
|
|
|
|
|
|
|
|
size_t SendData(const INetworkEndpoint& destination, const void* buffer, size_t size) override
|
|
|
|
{
|
|
|
|
if (_socket == INVALID_SOCKET)
|
|
|
|
{
|
2019-05-07 18:55:48 +02:00
|
|
|
_socket = CreateSocket();
|
2019-05-05 18:54:16 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
const auto& dest = dynamic_cast<const NetworkEndpoint*>(&destination);
|
|
|
|
if (dest == nullptr)
|
|
|
|
{
|
|
|
|
throw std::invalid_argument("destination is not compatible.");
|
|
|
|
}
|
|
|
|
auto ss = &dest->GetAddress();
|
|
|
|
auto ss_len = dest->GetAddressLen();
|
|
|
|
|
2020-10-02 03:10:51 +02:00
|
|
|
if (_status != SocketStatus::Listening)
|
2019-05-05 18:54:16 +02:00
|
|
|
{
|
|
|
|
_endpoint = *dest;
|
|
|
|
}
|
|
|
|
|
|
|
|
size_t totalSent = 0;
|
|
|
|
do
|
|
|
|
{
|
2020-04-22 17:09:29 +02:00
|
|
|
const char* bufferStart = static_cast<const char*>(buffer) + totalSent;
|
2019-05-05 18:54:16 +02:00
|
|
|
size_t remainingSize = size - totalSent;
|
2020-04-22 17:09:29 +02:00
|
|
|
int32_t sentBytes = sendto(
|
|
|
|
_socket, bufferStart, static_cast<int32_t>(remainingSize), FLAG_NO_PIPE, static_cast<const sockaddr*>(ss),
|
|
|
|
ss_len);
|
2019-05-05 18:54:16 +02:00
|
|
|
if (sentBytes == SOCKET_ERROR)
|
|
|
|
{
|
|
|
|
return totalSent;
|
|
|
|
}
|
|
|
|
totalSent += sentBytes;
|
|
|
|
} while (totalSent < size);
|
|
|
|
return totalSent;
|
|
|
|
}
|
|
|
|
|
2020-08-31 14:13:15 +02:00
|
|
|
NetworkReadPacket ReceiveData(
|
2019-05-05 18:54:16 +02:00
|
|
|
void* buffer, size_t size, size_t* sizeReceived, std::unique_ptr<INetworkEndpoint>* sender) override
|
|
|
|
{
|
|
|
|
sockaddr_in senderAddr{};
|
|
|
|
socklen_t senderAddrLen = sizeof(sockaddr_in);
|
2020-10-02 03:10:51 +02:00
|
|
|
if (_status != SocketStatus::Listening)
|
2019-05-05 18:54:16 +02:00
|
|
|
{
|
|
|
|
senderAddrLen = _endpoint.GetAddressLen();
|
|
|
|
std::memcpy(&senderAddr, &_endpoint.GetAddress(), senderAddrLen);
|
|
|
|
}
|
2020-04-22 17:09:29 +02:00
|
|
|
auto readBytes = recvfrom(
|
|
|
|
_socket, static_cast<char*>(buffer), static_cast<int32_t>(size), 0, reinterpret_cast<sockaddr*>(&senderAddr),
|
|
|
|
&senderAddrLen);
|
2019-05-05 18:54:16 +02:00
|
|
|
if (readBytes <= 0)
|
|
|
|
{
|
|
|
|
*sizeReceived = 0;
|
2020-08-31 14:13:15 +02:00
|
|
|
return NetworkReadPacket::NoData;
|
2016-06-01 23:58:21 +02:00
|
|
|
}
|
2021-09-15 22:22:15 +02:00
|
|
|
|
|
|
|
*sizeReceived = readBytes;
|
|
|
|
if (sender != nullptr)
|
2016-06-01 23:58:21 +02:00
|
|
|
{
|
2021-09-15 22:22:15 +02:00
|
|
|
*sender = std::make_unique<NetworkEndpoint>(reinterpret_cast<sockaddr*>(&senderAddr), senderAddrLen);
|
2016-06-01 23:58:21 +02:00
|
|
|
}
|
2021-09-15 22:22:15 +02:00
|
|
|
return NetworkReadPacket::Success;
|
2016-06-01 23:58:21 +02:00
|
|
|
}
|
|
|
|
|
2019-05-05 18:54:16 +02:00
|
|
|
void Close() override
|
2016-06-01 23:58:21 +02:00
|
|
|
{
|
2019-05-05 18:54:16 +02:00
|
|
|
CloseSocket();
|
2016-06-01 23:58:21 +02:00
|
|
|
}
|
|
|
|
|
2019-05-05 18:54:16 +02:00
|
|
|
const char* GetHostName() const override
|
2016-06-01 23:58:21 +02:00
|
|
|
{
|
2019-05-05 18:54:16 +02:00
|
|
|
return _hostName.empty() ? nullptr : _hostName.c_str();
|
2016-06-01 23:58:21 +02:00
|
|
|
}
|
|
|
|
|
2019-05-05 18:54:16 +02:00
|
|
|
private:
|
2022-02-09 21:57:25 +01:00
|
|
|
SOCKET CreateSocket() const
|
2019-05-07 18:55:48 +02:00
|
|
|
{
|
|
|
|
auto sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
|
|
|
|
if (sock == INVALID_SOCKET)
|
|
|
|
{
|
|
|
|
throw SocketException("Unable to create socket.");
|
|
|
|
}
|
|
|
|
|
|
|
|
// Enable send and receiving of broadcast messages
|
|
|
|
if (!SetOption(sock, SOL_SOCKET, SO_BROADCAST, true))
|
|
|
|
{
|
2023-01-17 13:24:51 +01:00
|
|
|
LOG_VERBOSE("setsockopt(socket, SO_BROADCAST) failed: %d", LAST_SOCKET_ERROR());
|
2019-05-07 18:55:48 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
// Turn off IPV6_V6ONLY so we can accept both v4 and v6 connections
|
2021-02-21 04:58:34 +01:00
|
|
|
if (!SetOption(sock, IPPROTO_IPV6, IPV6_V6ONLY, false))
|
2019-05-07 18:55:48 +02:00
|
|
|
{
|
2023-01-17 13:24:51 +01:00
|
|
|
LOG_VERBOSE("setsockopt(socket, IPV6_V6ONLY) failed: %d", LAST_SOCKET_ERROR());
|
2019-05-07 18:55:48 +02:00
|
|
|
}
|
|
|
|
|
2021-02-21 04:58:34 +01:00
|
|
|
if (!SetOption(sock, SOL_SOCKET, SO_REUSEADDR, true))
|
2019-05-07 18:55:48 +02:00
|
|
|
{
|
2023-01-17 13:24:51 +01:00
|
|
|
LOG_VERBOSE("setsockopt(socket, SO_REUSEADDR) failed: %d", LAST_SOCKET_ERROR());
|
2019-05-07 18:55:48 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
if (!SetNonBlocking(sock, true))
|
|
|
|
{
|
|
|
|
throw SocketException("Failed to set non-blocking mode.");
|
|
|
|
}
|
|
|
|
|
|
|
|
return sock;
|
|
|
|
}
|
|
|
|
|
2019-05-05 18:54:16 +02:00
|
|
|
void CloseSocket()
|
|
|
|
{
|
|
|
|
if (_socket != INVALID_SOCKET)
|
|
|
|
{
|
|
|
|
closesocket(_socket);
|
|
|
|
_socket = INVALID_SOCKET;
|
|
|
|
}
|
2020-10-02 03:10:51 +02:00
|
|
|
_status = SocketStatus::Closed;
|
2019-05-05 18:54:16 +02:00
|
|
|
}
|
|
|
|
};
|
2016-06-01 23:58:21 +02:00
|
|
|
|
2019-05-05 18:54:16 +02:00
|
|
|
std::unique_ptr<ITcpSocket> CreateTcpSocket()
|
|
|
|
{
|
2020-08-17 04:53:37 +02:00
|
|
|
InitialiseWSA();
|
2019-05-05 18:54:16 +02:00
|
|
|
return std::make_unique<TcpSocket>();
|
|
|
|
}
|
|
|
|
|
|
|
|
std::unique_ptr<IUdpSocket> CreateUdpSocket()
|
|
|
|
{
|
2020-08-17 18:44:53 +02:00
|
|
|
InitialiseWSA();
|
2019-05-05 18:54:16 +02:00
|
|
|
return std::make_unique<UdpSocket>();
|
|
|
|
}
|
|
|
|
|
|
|
|
# ifdef _WIN32
|
2019-05-06 13:51:01 +02:00
|
|
|
static std::vector<INTERFACE_INFO> GetNetworkInterfaces()
|
2019-05-05 18:54:16 +02:00
|
|
|
{
|
2020-08-17 18:44:53 +02:00
|
|
|
InitialiseWSA();
|
|
|
|
|
2019-05-05 18:54:16 +02:00
|
|
|
int sock = socket(AF_INET, SOCK_DGRAM, 0);
|
|
|
|
if (sock == -1)
|
|
|
|
{
|
|
|
|
return {};
|
|
|
|
}
|
|
|
|
|
2021-01-10 19:23:35 +01:00
|
|
|
// Get all the network interfaces, requires a trial and error approach
|
2019-05-07 18:41:34 +02:00
|
|
|
// until we find the capacity required to store all of them.
|
2019-05-05 18:54:16 +02:00
|
|
|
DWORD len = 0;
|
2019-05-07 18:41:34 +02:00
|
|
|
size_t capacity = 16;
|
2019-05-05 18:54:16 +02:00
|
|
|
std::vector<INTERFACE_INFO> interfaces;
|
|
|
|
for (;;)
|
|
|
|
{
|
|
|
|
interfaces.resize(capacity);
|
|
|
|
if (WSAIoctl(
|
2020-07-14 17:50:34 +02:00
|
|
|
sock, SIO_GET_INTERFACE_LIST, nullptr, 0, interfaces.data(),
|
|
|
|
static_cast<DWORD>(capacity * sizeof(INTERFACE_INFO)), &len, nullptr, nullptr)
|
2019-05-05 18:54:16 +02:00
|
|
|
== 0)
|
|
|
|
{
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (WSAGetLastError() != WSAEFAULT)
|
|
|
|
{
|
|
|
|
closesocket(sock);
|
|
|
|
return {};
|
|
|
|
}
|
|
|
|
capacity *= 2;
|
|
|
|
}
|
|
|
|
interfaces.resize(len / sizeof(INTERFACE_INFO));
|
|
|
|
interfaces.shrink_to_fit();
|
|
|
|
return interfaces;
|
|
|
|
}
|
|
|
|
# endif
|
|
|
|
|
|
|
|
std::vector<std::unique_ptr<INetworkEndpoint>> GetBroadcastAddresses()
|
|
|
|
{
|
|
|
|
std::vector<std::unique_ptr<INetworkEndpoint>> baddresses;
|
|
|
|
# ifdef _WIN32
|
|
|
|
auto interfaces = GetNetworkInterfaces();
|
|
|
|
for (const auto& ifo : interfaces)
|
|
|
|
{
|
|
|
|
if (ifo.iiFlags & IFF_LOOPBACK)
|
|
|
|
continue;
|
|
|
|
if (!(ifo.iiFlags & IFF_BROADCAST))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
// iiBroadcast is unusable, because it always seems to be set to 255.255.255.255.
|
|
|
|
sockaddr_storage address{};
|
|
|
|
memcpy(&address, &ifo.iiAddress.Address, sizeof(sockaddr));
|
2020-07-14 17:50:34 +02:00
|
|
|
(reinterpret_cast<sockaddr_in*>(&address))->sin_addr.s_addr = ifo.iiAddress.AddressIn.sin_addr.s_addr
|
2019-05-05 18:54:16 +02:00
|
|
|
| ~ifo.iiNetmask.AddressIn.sin_addr.s_addr;
|
2020-07-14 17:50:34 +02:00
|
|
|
baddresses.push_back(std::make_unique<NetworkEndpoint>(
|
|
|
|
reinterpret_cast<const sockaddr*>(&address), static_cast<socklen_t>(sizeof(sockaddr))));
|
2019-05-05 18:54:16 +02:00
|
|
|
}
|
|
|
|
# else
|
|
|
|
int sock = socket(AF_INET, SOCK_DGRAM, 0);
|
|
|
|
if (sock == -1)
|
|
|
|
{
|
|
|
|
return baddresses;
|
|
|
|
}
|
|
|
|
|
|
|
|
char buf[4 * 1024]{};
|
|
|
|
ifconf ifconfx{};
|
|
|
|
ifconfx.ifc_len = sizeof(buf);
|
|
|
|
ifconfx.ifc_buf = buf;
|
|
|
|
if (ioctl(sock, SIOCGIFCONF, &ifconfx) == -1)
|
|
|
|
{
|
|
|
|
close(sock);
|
|
|
|
return baddresses;
|
|
|
|
}
|
|
|
|
|
|
|
|
const char* buf_end = buf + ifconfx.ifc_len;
|
|
|
|
for (const char* p = buf; p < buf_end;)
|
|
|
|
{
|
2020-04-22 17:09:29 +02:00
|
|
|
auto req = reinterpret_cast<const ifreq*>(p);
|
2019-05-05 18:54:16 +02:00
|
|
|
if (req->ifr_addr.sa_family == AF_INET)
|
|
|
|
{
|
|
|
|
ifreq r;
|
|
|
|
strcpy(r.ifr_name, req->ifr_name);
|
|
|
|
if (ioctl(sock, SIOCGIFFLAGS, &r) != -1 && (r.ifr_flags & IFF_BROADCAST) && ioctl(sock, SIOCGIFBRDADDR, &r) != -1)
|
|
|
|
{
|
|
|
|
baddresses.push_back(std::make_unique<NetworkEndpoint>(&r.ifr_broadaddr, sizeof(sockaddr)));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
p += sizeof(ifreq);
|
|
|
|
# if defined(AF_LINK) && !defined(SUNOS)
|
|
|
|
p += req->ifr_addr.sa_len - sizeof(struct sockaddr);
|
|
|
|
# endif
|
|
|
|
}
|
|
|
|
close(sock);
|
|
|
|
# endif
|
|
|
|
return baddresses;
|
|
|
|
}
|
|
|
|
|
2017-02-08 13:53:00 +01:00
|
|
|
namespace Convert
|
|
|
|
{
|
2018-06-20 17:28:51 +02:00
|
|
|
uint16_t HostToNetwork(uint16_t value)
|
2017-02-08 13:53:00 +01:00
|
|
|
{
|
|
|
|
return htons(value);
|
|
|
|
}
|
|
|
|
|
2018-06-20 17:28:51 +02:00
|
|
|
uint16_t NetworkToHost(uint16_t value)
|
2017-02-08 13:53:00 +01:00
|
|
|
{
|
|
|
|
return ntohs(value);
|
|
|
|
}
|
2018-05-04 22:40:09 +02:00
|
|
|
} // namespace Convert
|
2017-02-08 13:53:00 +01:00
|
|
|
|
2016-06-01 23:58:21 +02:00
|
|
|
#endif
|