858 lines
29 KiB
C++
858 lines
29 KiB
C++
|
//
|
||
|
|
// libtgvoip is free and unencumbered public domain software.
|
||
|
|
// For more information, see http://unlicense.org or the UNLICENSE file
|
||
|
|
// you should have received with this source code distribution.
|
||
|
|
//
|
||
|
|
|
||
|
|
#include "NetworkSocketWinsock.h"
|
||
|
|
#include <winsock2.h>
|
||
|
|
#include <ws2tcpip.h>
|
||
|
|
#if WINAPI_FAMILY == WINAPI_FAMILY_PHONE_APP
|
||
|
|
|
||
|
|
#else
|
||
|
|
#include <IPHlpApi.h>
|
||
|
|
#endif
|
||
|
|
#include "../../Buffers.h"
|
||
|
|
#include "../../VoIPController.h"
|
||
|
|
#include "../../logging.h"
|
||
|
|
#include "WindowsSpecific.h"
|
||
|
|
#include <cassert>
|
||
|
|
|
||
|
|
using namespace tgvoip;
|
||
|
|
|
||
|
|
NetworkSocketWinsock::NetworkSocketWinsock(NetworkProtocol protocol)
|
||
|
|
: NetworkSocket(protocol)
|
||
|
|
{
|
||
|
|
needUpdateNat64Prefix = true;
|
||
|
|
nat64Present = false;
|
||
|
|
switchToV6at = 0;
|
||
|
|
isV4Available = false;
|
||
|
|
closing = false;
|
||
|
|
fd = INVALID_SOCKET;
|
||
|
|
|
||
|
|
#ifdef TGVOIP_WINXP_COMPAT
|
||
|
|
DWORD version = GetVersion();
|
||
|
|
isAtLeastVista = LOBYTE(LOWORD(version)) >= 6; // Vista is 6.0, XP is 5.1 and 5.2
|
||
|
|
#else
|
||
|
|
isAtLeastVista = true;
|
||
|
|
#endif
|
||
|
|
|
||
|
|
WSADATA wsaData;
|
||
|
|
WSAStartup(MAKEWORD(2, 2), &wsaData);
|
||
|
|
LOGD("Initialized winsock, version %d.%d", wsaData.wHighVersion, wsaData.wVersion);
|
||
|
|
|
||
|
|
if (protocol == NetworkProtocol::TCP)
|
||
|
|
m_timeout = 10.0;
|
||
|
|
m_lastSuccessfulOperationTime = VoIPController::GetCurrentTime();
|
||
|
|
}
|
||
|
|
|
||
|
|
NetworkSocketWinsock::~NetworkSocketWinsock()
|
||
|
|
{
|
||
|
|
}
|
||
|
|
|
||
|
|
void NetworkSocketWinsock::SetMaxPriority()
|
||
|
|
{
|
||
|
|
}
|
||
|
|
|
||
|
|
void NetworkSocketWinsock::Send(NetworkPacket packet)
|
||
|
|
{
|
||
|
|
if (packet.IsEmpty() || (m_protocol == NetworkProtocol::UDP && packet.address.IsEmpty()))
|
||
|
|
{
|
||
|
|
LOGW("tried to send null packet");
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
int res;
|
||
|
|
if (m_protocol == NetworkProtocol::UDP)
|
||
|
|
{
|
||
|
|
if (isAtLeastVista)
|
||
|
|
{
|
||
|
|
sockaddr_in6 addr;
|
||
|
|
if (!packet.address.isIPv6)
|
||
|
|
{
|
||
|
|
if (needUpdateNat64Prefix && !isV4Available && VoIPController::GetCurrentTime() > switchToV6at && switchToV6at != 0)
|
||
|
|
{
|
||
|
|
LOGV("Updating NAT64 prefix");
|
||
|
|
nat64Present = false;
|
||
|
|
addrinfo* addr0;
|
||
|
|
int res = getaddrinfo("ipv4only.arpa", nullptr, nullptr, &addr0);
|
||
|
|
if (res != 0)
|
||
|
|
{
|
||
|
|
LOGW("Error updating NAT64 prefix: %d / %s", res, gai_strerrorA(res));
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
addrinfo* addrPtr;
|
||
|
|
std::uint8_t* addr170 = nullptr;
|
||
|
|
std::uint8_t* addr171 = nullptr;
|
||
|
|
for (addrPtr = addr0; addrPtr; addrPtr = addrPtr->ai_next)
|
||
|
|
{
|
||
|
|
if (addrPtr->ai_family == AF_INET6)
|
||
|
|
{
|
||
|
|
sockaddr_in6* translatedAddr = (sockaddr_in6*)addrPtr->ai_addr;
|
||
|
|
std::uint32_t v4part = *(reinterpret_cast<std::uint32_t*>(&translatedAddr->sin6_addr.s6_addr[12]));
|
||
|
|
if (v4part == 0xAA0000C0 && !addr170)
|
||
|
|
{
|
||
|
|
addr170 = translatedAddr->sin6_addr.s6_addr;
|
||
|
|
}
|
||
|
|
if (v4part == 0xAB0000C0 && !addr171)
|
||
|
|
{
|
||
|
|
addr171 = translatedAddr->sin6_addr.s6_addr;
|
||
|
|
}
|
||
|
|
char buf[INET6_ADDRSTRLEN];
|
||
|
|
//LOGV("Got translated address: %s", inet_ntop(AF_INET6, &translatedAddr->sin6_addr, buf, sizeof(buf)));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (addr170 && addr171 && memcmp(addr170, addr171, 12) == 0)
|
||
|
|
{
|
||
|
|
nat64Present = true;
|
||
|
|
std::memcpy(m_nat64Prefix, addr170, 12);
|
||
|
|
char buf[INET6_ADDRSTRLEN];
|
||
|
|
//LOGV("Found nat64 prefix from %s", inet_ntop(AF_INET6, addr170, buf, sizeof(buf)));
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
LOGV("Didn't find nat64");
|
||
|
|
}
|
||
|
|
freeaddrinfo(addr0);
|
||
|
|
}
|
||
|
|
needUpdateNat64Prefix = false;
|
||
|
|
}
|
||
|
|
std::memset(&addr, 0, sizeof(sockaddr_in6));
|
||
|
|
addr.sin6_family = AF_INET6;
|
||
|
|
*(reinterpret_cast<std::uint32_t*>(&addr.sin6_addr.s6_addr[12])) = packet.address.addr.ipv4;
|
||
|
|
if (nat64Present)
|
||
|
|
std::memcpy(addr.sin6_addr.s6_addr, m_nat64Prefix, 12);
|
||
|
|
else
|
||
|
|
addr.sin6_addr.s6_addr[11] = addr.sin6_addr.s6_addr[10] = 0xFF;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
std::memcpy(addr.sin6_addr.s6_addr, packet.address.addr.ipv6, 16);
|
||
|
|
}
|
||
|
|
addr.sin6_port = htons(packet.port);
|
||
|
|
res = sendto(fd, reinterpret_cast<const char*>(*packet.data), packet.data.Length(),
|
||
|
|
0, reinterpret_cast<const sockaddr*>(&addr), sizeof(addr));
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
sockaddr_in addr;
|
||
|
|
addr.sin_addr.s_addr = packet.address.addr.ipv4;
|
||
|
|
addr.sin_port = htons(packet.port);
|
||
|
|
addr.sin_family = AF_INET;
|
||
|
|
res = sendto(fd, reinterpret_cast<const char*>(*packet.data), packet.data.Length(),
|
||
|
|
0, reinterpret_cast<const sockaddr*>(&addr), sizeof(addr));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
res = send(fd, (const char*)*packet.data, packet.data.Length(), 0);
|
||
|
|
}
|
||
|
|
if (res == SOCKET_ERROR)
|
||
|
|
{
|
||
|
|
int error = WSAGetLastError();
|
||
|
|
if (error == WSAEWOULDBLOCK)
|
||
|
|
{
|
||
|
|
if (!pendingOutgoingPacket.IsEmpty())
|
||
|
|
{
|
||
|
|
LOGE("Got EAGAIN but there's already a pending packet");
|
||
|
|
m_failed = true;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
LOGV("Socket %d not ready to send", fd);
|
||
|
|
pendingOutgoingPacket = std::move(packet);
|
||
|
|
m_readyToSend = false;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
LOGE("error sending: %d / %s", error, WindowsSpecific::GetErrorMessage(error).c_str());
|
||
|
|
if (error == WSAENETUNREACH && !isV4Available && VoIPController::GetCurrentTime() < switchToV6at)
|
||
|
|
{
|
||
|
|
switchToV6at = VoIPController::GetCurrentTime();
|
||
|
|
LOGI("Network unreachable, trying NAT64");
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else if (res < packet.data.Length() && m_protocol == NetworkProtocol::TCP)
|
||
|
|
{
|
||
|
|
if (!pendingOutgoingPacket.IsEmpty())
|
||
|
|
{
|
||
|
|
LOGE("send returned less than packet length but there's already a pending packet");
|
||
|
|
m_failed = true;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
LOGV("Socket %d not ready to send", fd);
|
||
|
|
pendingOutgoingPacket = std::move(packet);
|
||
|
|
Buffer pdata = std::move(pendingOutgoingPacket.data);
|
||
|
|
pendingOutgoingPacket.data = Buffer::CopyOf(pdata, res, pdata.Length() - res);
|
||
|
|
m_readyToSend = false;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
bool NetworkSocketWinsock::OnReadyToSend()
|
||
|
|
{
|
||
|
|
if (!pendingOutgoingPacket.IsEmpty())
|
||
|
|
{
|
||
|
|
Send(std::move(pendingOutgoingPacket));
|
||
|
|
pendingOutgoingPacket = NetworkPacket::Empty();
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
m_readyToSend = true;
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
NetworkPacket NetworkSocketWinsock::Receive(std::size_t maxLen)
|
||
|
|
{
|
||
|
|
if (maxLen == 0)
|
||
|
|
maxLen = std::numeric_limits<std::uint32_t>::max();
|
||
|
|
switch (m_protocol)
|
||
|
|
{
|
||
|
|
case NetworkProtocol::UDP:
|
||
|
|
{
|
||
|
|
if (isAtLeastVista)
|
||
|
|
{
|
||
|
|
int addrLen = sizeof(sockaddr_in6);
|
||
|
|
sockaddr_in6 srcAddr;
|
||
|
|
int res = recvfrom(fd, reinterpret_cast<char*>(*recvBuf), std::min(recvBuf.Length(), maxLen), 0,
|
||
|
|
reinterpret_cast<sockaddr*>(&srcAddr), reinterpret_cast<socklen_t*>(&addrLen));
|
||
|
|
if (res == SOCKET_ERROR)
|
||
|
|
{
|
||
|
|
int error = WSAGetLastError();
|
||
|
|
LOGE("error receiving %d / %s", error, WindowsSpecific::GetErrorMessage(error).c_str());
|
||
|
|
return NetworkPacket::Empty();
|
||
|
|
}
|
||
|
|
//LOGV("Received %d bytes from %s:%d at %.5lf", len, inet_ntoa(srcAddr.sin_addr), ntohs(srcAddr.sin_port), GetCurrentTime());
|
||
|
|
if (!isV4Available && IN6_IS_ADDR_V4MAPPED(&srcAddr.sin6_addr))
|
||
|
|
{
|
||
|
|
isV4Available = true;
|
||
|
|
LOGI("Detected IPv4 connectivity, will not try IPv6");
|
||
|
|
}
|
||
|
|
NetworkAddress addr = NetworkAddress::Empty();
|
||
|
|
if (IN6_IS_ADDR_V4MAPPED(&srcAddr.sin6_addr) || (nat64Present && memcmp(m_nat64Prefix, srcAddr.sin6_addr.s6_addr, 12) == 0))
|
||
|
|
{
|
||
|
|
in_addr v4addr = *(reinterpret_cast<in_addr*>(&srcAddr.sin6_addr.s6_addr[12]));
|
||
|
|
addr = NetworkAddress::IPv4(v4addr.s_addr);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
addr = NetworkAddress::IPv6(srcAddr.sin6_addr.s6_addr);
|
||
|
|
}
|
||
|
|
return NetworkPacket
|
||
|
|
{
|
||
|
|
Buffer::CopyOf(recvBuf, 0, static_cast<std::size_t>(res)),
|
||
|
|
addr,
|
||
|
|
ntohs(srcAddr.sin6_port),
|
||
|
|
NetworkProtocol::UDP
|
||
|
|
};
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
int addrLen = sizeof(sockaddr_in);
|
||
|
|
sockaddr_in srcAddr;
|
||
|
|
int res = recvfrom(fd, reinterpret_cast<char*>(*recvBuf), std::min(recvBuf.Length(), maxLen), 0,
|
||
|
|
reinterpret_cast<sockaddr*>(&srcAddr), reinterpret_cast<socklen_t*>(&addrLen));
|
||
|
|
if (res == SOCKET_ERROR)
|
||
|
|
{
|
||
|
|
LOGE("error receiving %d", WSAGetLastError());
|
||
|
|
return NetworkPacket::Empty();
|
||
|
|
}
|
||
|
|
return NetworkPacket {
|
||
|
|
Buffer::CopyOf(recvBuf, 0, (std::size_t)res),
|
||
|
|
NetworkAddress::IPv4(srcAddr.sin_addr.s_addr),
|
||
|
|
ntohs(srcAddr.sin_port),
|
||
|
|
NetworkProtocol::UDP};
|
||
|
|
}
|
||
|
|
}
|
||
|
|
case NetworkProtocol::TCP:
|
||
|
|
{
|
||
|
|
int res = recv(fd, reinterpret_cast<char*>(*recvBuf), std::min(recvBuf.Length(), maxLen), 0);
|
||
|
|
if (res == SOCKET_ERROR)
|
||
|
|
{
|
||
|
|
int error = WSAGetLastError();
|
||
|
|
LOGE("Error receiving from TCP socket: %d / %s", error, WindowsSpecific::GetErrorMessage(error).c_str());
|
||
|
|
m_failed = true;
|
||
|
|
return NetworkPacket::Empty();
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
return NetworkPacket
|
||
|
|
{
|
||
|
|
Buffer::CopyOf(recvBuf, 0, static_cast<std::size_t>(res)),
|
||
|
|
tcpConnectedAddress,
|
||
|
|
tcpConnectedPort,
|
||
|
|
NetworkProtocol::TCP
|
||
|
|
};
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
void NetworkSocketWinsock::Open()
|
||
|
|
{
|
||
|
|
if (m_protocol == NetworkProtocol::UDP)
|
||
|
|
{
|
||
|
|
fd = socket(isAtLeastVista ? AF_INET6 : AF_INET, SOCK_DGRAM, IPPROTO_UDP);
|
||
|
|
if (fd == INVALID_SOCKET)
|
||
|
|
{
|
||
|
|
int error = WSAGetLastError();
|
||
|
|
LOGE("error creating socket: %d", error);
|
||
|
|
m_failed = true;
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
int res;
|
||
|
|
if (isAtLeastVista)
|
||
|
|
{
|
||
|
|
DWORD flag = 0;
|
||
|
|
res = setsockopt(fd, IPPROTO_IPV6, IPV6_V6ONLY, (const char*)&flag, sizeof(flag));
|
||
|
|
if (res == SOCKET_ERROR)
|
||
|
|
{
|
||
|
|
LOGE("error enabling dual stack socket: %d", WSAGetLastError());
|
||
|
|
m_failed = true;
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
u_long one = 1;
|
||
|
|
ioctlsocket(fd, FIONBIO, &one);
|
||
|
|
|
||
|
|
SetMaxPriority();
|
||
|
|
|
||
|
|
int tries = 0;
|
||
|
|
sockaddr* addr;
|
||
|
|
sockaddr_in addr4;
|
||
|
|
sockaddr_in6 addr6;
|
||
|
|
int addrLen;
|
||
|
|
if (isAtLeastVista)
|
||
|
|
{
|
||
|
|
//addr.sin6_addr.s_addr=0;
|
||
|
|
std::memset(&addr6, 0, sizeof(sockaddr_in6));
|
||
|
|
//addr.sin6_len=sizeof(sa_family_t);
|
||
|
|
addr6.sin6_family = AF_INET6;
|
||
|
|
addr = reinterpret_cast<sockaddr*>(&addr6);
|
||
|
|
addrLen = sizeof(addr6);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
sockaddr_in addr4;
|
||
|
|
addr4.sin_addr.s_addr = 0;
|
||
|
|
addr4.sin_family = AF_INET;
|
||
|
|
addr = reinterpret_cast<sockaddr*>(&addr4);
|
||
|
|
addrLen = sizeof(addr4);
|
||
|
|
}
|
||
|
|
for (tries = 0; tries < 10; tries++)
|
||
|
|
{
|
||
|
|
std::uint16_t port = htons(GenerateLocalPort());
|
||
|
|
if (isAtLeastVista)
|
||
|
|
(reinterpret_cast<sockaddr_in6*>(addr))->sin6_port = port;
|
||
|
|
else
|
||
|
|
(reinterpret_cast<sockaddr_in*>(addr))->sin_port = port;
|
||
|
|
res = ::bind(fd, addr, addrLen);
|
||
|
|
LOGV("trying bind to port %u", ntohs(port));
|
||
|
|
if (res < 0)
|
||
|
|
{
|
||
|
|
LOGE("error binding to port %u: %d / %s", ntohs(port), errno, strerror(errno));
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (tries == 10)
|
||
|
|
{
|
||
|
|
if (isAtLeastVista)
|
||
|
|
(reinterpret_cast<sockaddr_in6*>(addr))->sin6_port = 0;
|
||
|
|
else
|
||
|
|
(reinterpret_cast<sockaddr_in*>(addr))->sin_port = 0;
|
||
|
|
res = ::bind(fd, addr, addrLen);
|
||
|
|
if (res < 0)
|
||
|
|
{
|
||
|
|
LOGE("error binding to port %u: %d / %s", 0, errno, strerror(errno));
|
||
|
|
//SetState(State::FAILED);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
getsockname(fd, addr, reinterpret_cast<socklen_t*>(&addrLen));
|
||
|
|
std::uint16_t localUdpPort;
|
||
|
|
if (isAtLeastVista)
|
||
|
|
localUdpPort = ntohs((reinterpret_cast<sockaddr_in6*>(addr))->sin6_port);
|
||
|
|
else
|
||
|
|
localUdpPort = ntohs((reinterpret_cast<sockaddr_in*>(addr))->sin_port);
|
||
|
|
LOGD("Bound to local UDP port %u", localUdpPort);
|
||
|
|
|
||
|
|
needUpdateNat64Prefix = true;
|
||
|
|
isV4Available = false;
|
||
|
|
switchToV6at = VoIPController::GetCurrentTime() + m_ipv6Timeout;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
void NetworkSocketWinsock::Close()
|
||
|
|
{
|
||
|
|
closing = true;
|
||
|
|
m_failed = true;
|
||
|
|
if (fd != INVALID_SOCKET)
|
||
|
|
closesocket(fd);
|
||
|
|
}
|
||
|
|
|
||
|
|
void NetworkSocketWinsock::OnActiveInterfaceChanged()
|
||
|
|
{
|
||
|
|
needUpdateNat64Prefix = true;
|
||
|
|
isV4Available = false;
|
||
|
|
switchToV6at = VoIPController::GetCurrentTime() + m_ipv6Timeout;
|
||
|
|
}
|
||
|
|
|
||
|
|
std::string NetworkSocketWinsock::GetLocalInterfaceInfo(NetworkAddress* v4addr, NetworkAddress* v6addr)
|
||
|
|
{
|
||
|
|
#if WINAPI_FAMILY == WINAPI_FAMILY_PHONE_APP
|
||
|
|
Windows::Networking::Connectivity::ConnectionProfile ^ profile = Windows::Networking::Connectivity::NetworkInformation::GetInternetConnectionProfile();
|
||
|
|
if (profile)
|
||
|
|
{
|
||
|
|
Windows::Foundation::Collections::IVectorView<Windows::Networking::HostName ^> ^ hostnames = Windows::Networking::Connectivity::NetworkInformation::GetHostNames();
|
||
|
|
for (unsigned int i = 0; i < hostnames->Size; i++)
|
||
|
|
{
|
||
|
|
Windows::Networking::HostName ^ n = hostnames->GetAt(i);
|
||
|
|
if (n->Type != Windows::Networking::HostNameType::Ipv4 && n->Type != Windows::Networking::HostNameType::Ipv6)
|
||
|
|
continue;
|
||
|
|
if (n->IPInformation->NetworkAdapter->Equals(profile->NetworkAdapter))
|
||
|
|
{
|
||
|
|
if (v4addr && n->Type == Windows::Networking::HostNameType::Ipv4)
|
||
|
|
{
|
||
|
|
char buf[INET_ADDRSTRLEN];
|
||
|
|
WideCharToMultiByte(CP_UTF8, 0, n->RawName->Data(), -1, buf, sizeof(buf), nullptr, nullptr);
|
||
|
|
*v4addr = NetworkAddress::IPv4(buf);
|
||
|
|
}
|
||
|
|
else if (v6addr && n->Type == Windows::Networking::HostNameType::Ipv6)
|
||
|
|
{
|
||
|
|
char buf[INET6_ADDRSTRLEN];
|
||
|
|
WideCharToMultiByte(CP_UTF8, 0, n->RawName->Data(), -1, buf, sizeof(buf), nullptr, nullptr);
|
||
|
|
*v6addr = NetworkAddress::IPv6(buf);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
char buf[128];
|
||
|
|
WideCharToMultiByte(CP_UTF8, 0, profile->NetworkAdapter->NetworkAdapterId.ToString()->Data(), -1, buf, sizeof(buf), nullptr, nullptr);
|
||
|
|
return std::string(buf);
|
||
|
|
}
|
||
|
|
return "";
|
||
|
|
#else
|
||
|
|
IP_ADAPTER_ADDRESSES* addrs = (IP_ADAPTER_ADDRESSES*)std::malloc(15 * 1024);
|
||
|
|
ULONG size = 15 * 1024;
|
||
|
|
ULONG flags = GAA_FLAG_SKIP_ANYCAST | GAA_FLAG_SKIP_MULTICAST | GAA_FLAG_SKIP_DNS_SERVER | GAA_FLAG_SKIP_FRIENDLY_NAME;
|
||
|
|
|
||
|
|
ULONG res = GetAdaptersAddresses(AF_UNSPEC, flags, nullptr, addrs, &size);
|
||
|
|
if (res == ERROR_BUFFER_OVERFLOW)
|
||
|
|
{
|
||
|
|
addrs = (IP_ADAPTER_ADDRESSES*)std::realloc(addrs, size);
|
||
|
|
res = GetAdaptersAddresses(AF_UNSPEC, flags, nullptr, addrs, &size);
|
||
|
|
}
|
||
|
|
|
||
|
|
ULONG bestMetric = 0;
|
||
|
|
std::string bestName("");
|
||
|
|
|
||
|
|
if (res == ERROR_SUCCESS)
|
||
|
|
{
|
||
|
|
IP_ADAPTER_ADDRESSES* current = addrs;
|
||
|
|
while (current)
|
||
|
|
{
|
||
|
|
char* name = current->AdapterName;
|
||
|
|
LOGV("Adapter '%s':", name);
|
||
|
|
IP_ADAPTER_UNICAST_ADDRESS* curAddr = current->FirstUnicastAddress;
|
||
|
|
if (current->OperStatus != IfOperStatusUp)
|
||
|
|
{
|
||
|
|
LOGV("-> (down)");
|
||
|
|
current = current->Next;
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
if (current->IfType == IF_TYPE_SOFTWARE_LOOPBACK)
|
||
|
|
{
|
||
|
|
LOGV("-> (loopback)");
|
||
|
|
current = current->Next;
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
if (isAtLeastVista)
|
||
|
|
LOGV("v4 metric: %u, v6 metric: %u", current->Ipv4Metric, current->Ipv6Metric);
|
||
|
|
while (curAddr)
|
||
|
|
{
|
||
|
|
sockaddr* addr = curAddr->Address.lpSockaddr;
|
||
|
|
if (addr->sa_family == AF_INET && v4addr)
|
||
|
|
{
|
||
|
|
sockaddr_in* ipv4 = (sockaddr_in*)addr;
|
||
|
|
LOGV("-> V4: %s", V4AddressToString(ipv4->sin_addr.s_addr).c_str());
|
||
|
|
std::uint32_t ip = ntohl(ipv4->sin_addr.s_addr);
|
||
|
|
if ((ip & 0xFFFF0000) != 0xA9FE0000)
|
||
|
|
{
|
||
|
|
if (isAtLeastVista)
|
||
|
|
{
|
||
|
|
if (current->Ipv4Metric > bestMetric)
|
||
|
|
{
|
||
|
|
bestMetric = current->Ipv4Metric;
|
||
|
|
bestName = std::string(current->AdapterName);
|
||
|
|
*v4addr = NetworkAddress::IPv4(ipv4->sin_addr.s_addr);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
bestName = std::string(current->AdapterName);
|
||
|
|
*v4addr = NetworkAddress::IPv4(ipv4->sin_addr.s_addr);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else if (addr->sa_family == AF_INET6 && v6addr)
|
||
|
|
{
|
||
|
|
sockaddr_in6* ipv6 = (sockaddr_in6*)addr;
|
||
|
|
LOGV("-> V6: %s", V6AddressToString(ipv6->sin6_addr.s6_addr).c_str());
|
||
|
|
if (!IN6_IS_ADDR_LINKLOCAL(&ipv6->sin6_addr))
|
||
|
|
{
|
||
|
|
*v6addr = NetworkAddress::IPv6(ipv6->sin6_addr.s6_addr);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
curAddr = curAddr->Next;
|
||
|
|
}
|
||
|
|
current = current->Next;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
std::free(addrs);
|
||
|
|
return bestName;
|
||
|
|
#endif
|
||
|
|
}
|
||
|
|
|
||
|
|
std::uint16_t NetworkSocketWinsock::GetLocalPort()
|
||
|
|
{
|
||
|
|
if (!isAtLeastVista)
|
||
|
|
{
|
||
|
|
sockaddr_in addr;
|
||
|
|
std::size_t addrLen = sizeof(sockaddr_in);
|
||
|
|
getsockname(fd, reinterpret_cast<sockaddr*>(&addr), reinterpret_cast<socklen_t*>(&addrLen));
|
||
|
|
return ntohs(addr.sin_port);
|
||
|
|
}
|
||
|
|
sockaddr_in6 addr;
|
||
|
|
std::size_t addrLen = sizeof(sockaddr_in6);
|
||
|
|
getsockname(fd, reinterpret_cast<sockaddr*>(&addr), reinterpret_cast<socklen_t*>(&addrLen));
|
||
|
|
return ntohs(addr.sin6_port);
|
||
|
|
}
|
||
|
|
|
||
|
|
std::string NetworkSocketWinsock::V4AddressToString(std::uint32_t address)
|
||
|
|
{
|
||
|
|
char buf[INET_ADDRSTRLEN];
|
||
|
|
sockaddr_in addr;
|
||
|
|
ZeroMemory(&addr, sizeof(addr));
|
||
|
|
addr.sin_family = AF_INET;
|
||
|
|
addr.sin_addr.s_addr = address;
|
||
|
|
DWORD len = sizeof(buf);
|
||
|
|
#if WINAPI_FAMILY == WINAPI_FAMILY_PHONE_APP
|
||
|
|
wchar_t wbuf[INET_ADDRSTRLEN];
|
||
|
|
ZeroMemory(wbuf, sizeof(wbuf));
|
||
|
|
WSAAddressToStringW(reinterpret_cast<sockaddr*>(&addr), sizeof(addr), nullptr, wbuf, &len);
|
||
|
|
WideCharToMultiByte(CP_UTF8, 0, wbuf, -1, buf, sizeof(buf), nullptr, nullptr);
|
||
|
|
#else
|
||
|
|
WSAAddressToStringA((sockaddr*)&addr, sizeof(addr), nullptr, buf, &len);
|
||
|
|
#endif
|
||
|
|
return std::string(buf);
|
||
|
|
}
|
||
|
|
|
||
|
|
std::string NetworkSocketWinsock::V6AddressToString(const std::uint8_t* address)
|
||
|
|
{
|
||
|
|
char buf[INET6_ADDRSTRLEN];
|
||
|
|
sockaddr_in6 addr;
|
||
|
|
ZeroMemory(&addr, sizeof(addr));
|
||
|
|
addr.sin6_family = AF_INET6;
|
||
|
|
std::memcpy(addr.sin6_addr.s6_addr, address, 16);
|
||
|
|
DWORD len = sizeof(buf);
|
||
|
|
#if WINAPI_FAMILY == WINAPI_FAMILY_PHONE_APP
|
||
|
|
wchar_t wbuf[INET6_ADDRSTRLEN];
|
||
|
|
ZeroMemory(wbuf, sizeof(wbuf));
|
||
|
|
WSAAddressToStringW(reinterpret_cast<sockaddr*>(&addr), sizeof(addr), nullptr, wbuf, &len);
|
||
|
|
WideCharToMultiByte(CP_UTF8, 0, wbuf, -1, buf, sizeof(buf), nullptr, nullptr);
|
||
|
|
#else
|
||
|
|
WSAAddressToStringA((sockaddr*)&addr, sizeof(addr), nullptr, buf, &len);
|
||
|
|
#endif
|
||
|
|
return std::string(buf);
|
||
|
|
}
|
||
|
|
|
||
|
|
std::uint32_t NetworkSocketWinsock::StringToV4Address(std::string address)
|
||
|
|
{
|
||
|
|
sockaddr_in addr;
|
||
|
|
ZeroMemory(&addr, sizeof(addr));
|
||
|
|
addr.sin_family = AF_INET;
|
||
|
|
int size = sizeof(addr);
|
||
|
|
#if WINAPI_FAMILY == WINAPI_FAMILY_PHONE_APP
|
||
|
|
wchar_t buf[INET_ADDRSTRLEN];
|
||
|
|
MultiByteToWideChar(CP_UTF8, 0, address.c_str(), -1, buf, INET_ADDRSTRLEN);
|
||
|
|
WSAStringToAddressW(buf, AF_INET, nullptr, reinterpret_cast<sockaddr*>(&addr), &size);
|
||
|
|
#else
|
||
|
|
WSAStringToAddressA((char*)address.c_str(), AF_INET, nullptr, (sockaddr*)&addr, &size);
|
||
|
|
#endif
|
||
|
|
return addr.sin_addr.s_addr;
|
||
|
|
}
|
||
|
|
|
||
|
|
void NetworkSocketWinsock::StringToV6Address(std::string address, std::uint8_t* out)
|
||
|
|
{
|
||
|
|
sockaddr_in6 addr;
|
||
|
|
ZeroMemory(&addr, sizeof(addr));
|
||
|
|
addr.sin6_family = AF_INET6;
|
||
|
|
int size = sizeof(addr);
|
||
|
|
#if WINAPI_FAMILY == WINAPI_FAMILY_PHONE_APP
|
||
|
|
wchar_t buf[INET6_ADDRSTRLEN];
|
||
|
|
MultiByteToWideChar(CP_UTF8, 0, address.c_str(), -1, buf, INET6_ADDRSTRLEN);
|
||
|
|
WSAStringToAddressW(buf, AF_INET, nullptr, reinterpret_cast<sockaddr*>(&addr), &size);
|
||
|
|
#else
|
||
|
|
WSAStringToAddressA((char*)address.c_str(), AF_INET, nullptr, (sockaddr*)&addr, &size);
|
||
|
|
#endif
|
||
|
|
std::memcpy(out, addr.sin6_addr.s6_addr, 16);
|
||
|
|
}
|
||
|
|
|
||
|
|
void NetworkSocketWinsock::Connect(const NetworkAddress address, std::uint16_t port)
|
||
|
|
{
|
||
|
|
sockaddr_in v4;
|
||
|
|
sockaddr_in6 v6;
|
||
|
|
sockaddr* addr = nullptr;
|
||
|
|
std::size_t addrLen = 0;
|
||
|
|
if (!address.isIPv6)
|
||
|
|
{
|
||
|
|
v4.sin_family = AF_INET;
|
||
|
|
v4.sin_addr.s_addr = address.addr.ipv4;
|
||
|
|
v4.sin_port = htons(port);
|
||
|
|
addr = reinterpret_cast<sockaddr*>(&v4);
|
||
|
|
addrLen = sizeof(v4);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
v6.sin6_family = AF_INET6;
|
||
|
|
std::memcpy(v6.sin6_addr.s6_addr, address.addr.ipv6, 16);
|
||
|
|
v6.sin6_flowinfo = 0;
|
||
|
|
v6.sin6_scope_id = 0;
|
||
|
|
v6.sin6_port = htons(port);
|
||
|
|
addr = reinterpret_cast<sockaddr*>(&v6);
|
||
|
|
addrLen = sizeof(v6);
|
||
|
|
}
|
||
|
|
fd = socket(addr->sa_family, SOCK_STREAM, IPPROTO_TCP);
|
||
|
|
if (fd == INVALID_SOCKET)
|
||
|
|
{
|
||
|
|
LOGE("Error creating TCP socket: %d", WSAGetLastError());
|
||
|
|
m_failed = true;
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
u_long one = 1;
|
||
|
|
ioctlsocket(fd, FIONBIO, &one);
|
||
|
|
int opt = 1;
|
||
|
|
setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, (const char*)&opt, sizeof(opt));
|
||
|
|
DWORD timeout = 5000;
|
||
|
|
setsockopt(fd, SOL_SOCKET, SO_SNDTIMEO, (const char*)&timeout, sizeof(timeout));
|
||
|
|
timeout = 60000;
|
||
|
|
setsockopt(fd, SOL_SOCKET, SO_RCVTIMEO, (const char*)&timeout, sizeof(timeout));
|
||
|
|
int res = connect(fd, reinterpret_cast<const sockaddr*>(addr), addrLen);
|
||
|
|
if (res != 0)
|
||
|
|
{
|
||
|
|
int error = WSAGetLastError();
|
||
|
|
if (error != WSAEINPROGRESS && error != WSAEWOULDBLOCK)
|
||
|
|
{
|
||
|
|
LOGW("error connecting TCP socket to %s:%u: %d / %s", address.ToString().c_str(), port, error, WindowsSpecific::GetErrorMessage(error).c_str());
|
||
|
|
closesocket(fd);
|
||
|
|
m_failed = true;
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
tcpConnectedAddress = address;
|
||
|
|
tcpConnectedPort = port;
|
||
|
|
LOGI("successfully connected to %s:%d", tcpConnectedAddress.ToString().c_str(), tcpConnectedPort);
|
||
|
|
}
|
||
|
|
|
||
|
|
NetworkAddress NetworkSocketWinsock::ResolveDomainName(std::string name)
|
||
|
|
{
|
||
|
|
addrinfo* addr0;
|
||
|
|
NetworkAddress ret = NetworkAddress::Empty();
|
||
|
|
int res = getaddrinfo(name.c_str(), nullptr, nullptr, &addr0);
|
||
|
|
if (res != 0)
|
||
|
|
{
|
||
|
|
LOGW("Error updating NAT64 prefix: %d / %s", res, gai_strerrorA(res));
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
addrinfo* addrPtr;
|
||
|
|
for (addrPtr = addr0; addrPtr; addrPtr = addrPtr->ai_next)
|
||
|
|
{
|
||
|
|
if (addrPtr->ai_family == AF_INET)
|
||
|
|
{
|
||
|
|
sockaddr_in* addr = (sockaddr_in*)addrPtr->ai_addr;
|
||
|
|
ret = NetworkAddress::IPv4(addr->sin_addr.s_addr);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
freeaddrinfo(addr0);
|
||
|
|
}
|
||
|
|
return ret;
|
||
|
|
}
|
||
|
|
|
||
|
|
NetworkAddress NetworkSocketWinsock::GetConnectedAddress()
|
||
|
|
{
|
||
|
|
return tcpConnectedAddress;
|
||
|
|
}
|
||
|
|
|
||
|
|
std::uint16_t NetworkSocketWinsock::GetConnectedPort()
|
||
|
|
{
|
||
|
|
return tcpConnectedPort;
|
||
|
|
}
|
||
|
|
|
||
|
|
void NetworkSocketWinsock::SetTimeouts(int sendTimeout, int recvTimeout)
|
||
|
|
{
|
||
|
|
DWORD timeout = sendTimeout * 1000;
|
||
|
|
setsockopt(fd, SOL_SOCKET, SO_SNDTIMEO, (const char*)&timeout, sizeof(timeout));
|
||
|
|
timeout = recvTimeout * 1000;
|
||
|
|
setsockopt(fd, SOL_SOCKET, SO_RCVTIMEO, (const char*)&timeout, sizeof(timeout));
|
||
|
|
}
|
||
|
|
|
||
|
|
bool NetworkSocketWinsock::Select(std::vector<NetworkSocket*>& readFds, std::vector<NetworkSocket*>& writeFds, std::vector<NetworkSocket*>& errorFds, SocketSelectCanceller* _canceller)
|
||
|
|
{
|
||
|
|
fd_set readSet;
|
||
|
|
fd_set errorSet;
|
||
|
|
fd_set writeSet;
|
||
|
|
SocketSelectCancellerWin32* canceller = dynamic_cast<SocketSelectCancellerWin32*>(_canceller);
|
||
|
|
timeval timeout = {0, 10000};
|
||
|
|
bool anyFailed = false;
|
||
|
|
int res = 0;
|
||
|
|
|
||
|
|
do
|
||
|
|
{
|
||
|
|
FD_ZERO(&readSet);
|
||
|
|
FD_ZERO(&writeSet);
|
||
|
|
FD_ZERO(&errorSet);
|
||
|
|
|
||
|
|
for (std::vector<NetworkSocket*>::iterator itr = readFds.begin(); itr != readFds.end(); ++itr)
|
||
|
|
{
|
||
|
|
int sfd = GetDescriptorFromSocket(*itr);
|
||
|
|
if (sfd == 0)
|
||
|
|
{
|
||
|
|
LOGW("can't select on one of sockets because it's not a NetworkSocketWinsock instance");
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
FD_SET(sfd, &readSet);
|
||
|
|
}
|
||
|
|
|
||
|
|
for (NetworkSocket*& s : writeFds)
|
||
|
|
{
|
||
|
|
int sfd = GetDescriptorFromSocket(s);
|
||
|
|
if (sfd == 0)
|
||
|
|
{
|
||
|
|
LOGW("can't select on one of sockets because it's not a NetworkSocketWinsock instance");
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
FD_SET(sfd, &writeSet);
|
||
|
|
}
|
||
|
|
|
||
|
|
for (std::vector<NetworkSocket*>::iterator itr = errorFds.begin(); itr != errorFds.end(); ++itr)
|
||
|
|
{
|
||
|
|
int sfd = GetDescriptorFromSocket(*itr);
|
||
|
|
if (sfd == 0)
|
||
|
|
{
|
||
|
|
LOGW("can't select on one of sockets because it's not a NetworkSocketWinsock instance");
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
if ((*itr)->m_timeout > 0 && VoIPController::GetCurrentTime() - (*itr)->m_lastSuccessfulOperationTime > (*itr)->m_timeout)
|
||
|
|
{
|
||
|
|
LOGW("Socket %d timed out", sfd);
|
||
|
|
(*itr)->m_failed = true;
|
||
|
|
}
|
||
|
|
anyFailed |= (*itr)->IsFailed();
|
||
|
|
FD_SET(sfd, &errorSet);
|
||
|
|
}
|
||
|
|
if (canceller && canceller->canceled)
|
||
|
|
break;
|
||
|
|
res = select(0, &readSet, &writeSet, &errorSet, &timeout);
|
||
|
|
//LOGV("select result %d", res);
|
||
|
|
if (res == SOCKET_ERROR)
|
||
|
|
LOGE("SELECT ERROR %d", WSAGetLastError());
|
||
|
|
} while (res == 0);
|
||
|
|
|
||
|
|
if (canceller && canceller->canceled && !anyFailed)
|
||
|
|
{
|
||
|
|
canceller->canceled = false;
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
else if (anyFailed)
|
||
|
|
{
|
||
|
|
FD_ZERO(&readSet);
|
||
|
|
FD_ZERO(&errorSet);
|
||
|
|
}
|
||
|
|
|
||
|
|
std::vector<NetworkSocket*>::iterator itr = readFds.begin();
|
||
|
|
while (itr != readFds.end())
|
||
|
|
{
|
||
|
|
int sfd = GetDescriptorFromSocket(*itr);
|
||
|
|
if (FD_ISSET(sfd, &readSet))
|
||
|
|
(*itr)->m_lastSuccessfulOperationTime = VoIPController::GetCurrentTime();
|
||
|
|
if (sfd == 0 || !FD_ISSET(sfd, &readSet) || !(*itr)->OnReadyToReceive())
|
||
|
|
{
|
||
|
|
itr = readFds.erase(itr);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
++itr;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
itr = writeFds.begin();
|
||
|
|
while (itr != writeFds.end())
|
||
|
|
{
|
||
|
|
int sfd = GetDescriptorFromSocket(*itr);
|
||
|
|
if (FD_ISSET(sfd, &writeSet))
|
||
|
|
{
|
||
|
|
(*itr)->m_lastSuccessfulOperationTime = VoIPController::GetCurrentTime();
|
||
|
|
LOGI("Socket %d is ready to send", sfd);
|
||
|
|
}
|
||
|
|
if (sfd == 0 || !FD_ISSET(sfd, &writeSet) || !(*itr)->OnReadyToSend())
|
||
|
|
{
|
||
|
|
itr = writeFds.erase(itr);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
++itr;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
itr = errorFds.begin();
|
||
|
|
while (itr != errorFds.end())
|
||
|
|
{
|
||
|
|
int sfd = GetDescriptorFromSocket(*itr);
|
||
|
|
if ((sfd == 0 || !FD_ISSET(sfd, &errorSet)) && !(*itr)->IsFailed())
|
||
|
|
{
|
||
|
|
itr = errorFds.erase(itr);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
++itr;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
//LOGV("select fds left: read=%d, error=%d", readFds.size(), errorFds.size());
|
||
|
|
|
||
|
|
return readFds.size() > 0 || errorFds.size() > 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
SocketSelectCancellerWin32::SocketSelectCancellerWin32()
|
||
|
|
{
|
||
|
|
canceled = false;
|
||
|
|
}
|
||
|
|
|
||
|
|
SocketSelectCancellerWin32::~SocketSelectCancellerWin32()
|
||
|
|
{
|
||
|
|
}
|
||
|
|
|
||
|
|
void SocketSelectCancellerWin32::CancelSelect()
|
||
|
|
{
|
||
|
|
canceled = true;
|
||
|
|
}
|
||
|
|
|
||
|
|
int NetworkSocketWinsock::GetDescriptorFromSocket(NetworkSocket* socket)
|
||
|
|
{
|
||
|
|
NetworkSocketWinsock* sp = dynamic_cast<NetworkSocketWinsock*>(socket);
|
||
|
|
if (sp != nullptr)
|
||
|
|
return sp->fd;
|
||
|
|
NetworkSocketWrapper* sw = dynamic_cast<NetworkSocketWrapper*>(socket);
|
||
|
|
if (sw != nullptr)
|
||
|
|
return GetDescriptorFromSocket(sw->GetWrapped());
|
||
|
|
return 0;
|
||
|
|
}
|