431 lines
9.9 KiB
C++
431 lines
9.9 KiB
C++
#include "ehs/io/socket/UDP_W32.h"
|
|
#include "ehs/Log.h"
|
|
|
|
#include <WinSock2.h>
|
|
#include <WS2tcpip.h>
|
|
|
|
namespace ehs
|
|
{
|
|
UDP::~UDP()
|
|
{
|
|
if (hdl == EHS_INVALID_SOCKET)
|
|
return;
|
|
|
|
Int_32 code = closesocket(hdl);
|
|
if (code == SOCKET_ERROR)
|
|
EHS_LOG_INT(LogType::ERR, 0, "Failed to close socket with error #" + Str_8::FromNum(GetLastError()) + ".");
|
|
|
|
if (WSACleanup() == SOCKET_ERROR)
|
|
EHS_LOG_INT(LogType::ERR, 1, "Failed to shutdown WSA with error #" + Str_8::FromNum(WSAGetLastError()) + ".");
|
|
}
|
|
|
|
UDP::UDP()
|
|
: hdl(EHS_INVALID_SOCKET)
|
|
{
|
|
}
|
|
|
|
UDP::UDP(const AddrType addrType)
|
|
: BaseUDP(addrType), hdl(EHS_INVALID_SOCKET)
|
|
{
|
|
WSADATA data = {};
|
|
|
|
int code = WSAStartup(MAKEWORD(2, 2), &data);
|
|
if (code)
|
|
{
|
|
EHS_LOG_INT(LogType::ERR, 0, "WSAStartup failed with the error #" + Str_8::FromNum(code) + ".");
|
|
return;
|
|
}
|
|
|
|
if (addrType == AddrType::IPV6)
|
|
hdl = socket(AF_INET6, SOCK_DGRAM, IPPROTO_UDP);
|
|
else if (addrType == AddrType::IPV4)
|
|
hdl = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
|
|
else
|
|
return;
|
|
|
|
if (hdl == EHS_INVALID_SOCKET)
|
|
{
|
|
UInt_32 code = WSAGetLastError();
|
|
|
|
EHS_LOG_INT(LogType::ERR, 1, "Failed to create socket with error #" + Str_8::FromNum(code) + ".");
|
|
|
|
if (WSACleanup() == SOCKET_ERROR)
|
|
EHS_LOG_INT(LogType::ERR, 2, "Failed to shutdown WSA with error #" + Str_8::FromNum(WSAGetLastError()) + ".");
|
|
|
|
return;
|
|
}
|
|
}
|
|
|
|
UDP::UDP(UDP&& udp) noexcept
|
|
: BaseUDP(std::move(udp)), hdl(udp.hdl)
|
|
{
|
|
udp.hdl = EHS_INVALID_SOCKET;
|
|
}
|
|
|
|
UDP::UDP(const UDP& udp)
|
|
: BaseUDP(udp), hdl(EHS_INVALID_SOCKET)
|
|
{
|
|
}
|
|
|
|
UDP& UDP::operator=(UDP&& udp) noexcept
|
|
{
|
|
if (this == &udp)
|
|
return *this;
|
|
|
|
BaseUDP::operator=(std::move(udp));
|
|
|
|
hdl = udp.hdl;
|
|
|
|
udp.hdl = EHS_INVALID_SOCKET;
|
|
|
|
return *this;
|
|
}
|
|
|
|
UDP& UDP::operator=(const UDP& udp)
|
|
{
|
|
if (this == &udp)
|
|
return *this;
|
|
|
|
BaseUDP::operator=(udp);
|
|
|
|
hdl = EHS_INVALID_SOCKET;
|
|
|
|
return *this;
|
|
}
|
|
|
|
void UDP::Release()
|
|
{
|
|
if (!IsValid())
|
|
return;
|
|
|
|
Int_32 code = closesocket(hdl);
|
|
if (code == SOCKET_ERROR)
|
|
EHS_LOG_INT(LogType::ERR, 0, "Failed to close socket with error #" + Str_8::FromNum(GetLastError()) + ".");
|
|
|
|
hdl = EHS_INVALID_SOCKET;
|
|
|
|
if (WSACleanup() == SOCKET_ERROR)
|
|
EHS_LOG_INT(LogType::ERR, 1, "Failed to shutdown WSA with error #" + Str_8::FromNum(WSAGetLastError()) + ".");
|
|
|
|
bound = false;
|
|
}
|
|
|
|
void UDP::Bind(const AddrType type, const Str_8& address, const UInt_16 port)
|
|
{
|
|
if (!IsValid() || bound)
|
|
return;
|
|
|
|
if (type == AddrType::IPV6)
|
|
Bind_v6(address, port);
|
|
else if (type == AddrType::IPV4)
|
|
Bind_v4(address, port);
|
|
|
|
this->address = address;
|
|
this->port = port;
|
|
|
|
bound = true;
|
|
}
|
|
|
|
UInt_64 UDP::Send(const AddrType type, const Str_8& address, const UInt_16 port, const Byte *const data, const UInt_64 size)
|
|
{
|
|
if (type == AddrType::IPV6)
|
|
return Send_v6(address, port, data, size);
|
|
else if (type == AddrType::IPV4)
|
|
return Send_v4(address, port, data, size);
|
|
|
|
return 0;
|
|
}
|
|
|
|
UInt_64 UDP::Receive(AddrType* type, Str_8* const address, UInt_16* const port, Byte* const data, const UInt_64 size)
|
|
{
|
|
if (!IsValid())
|
|
{
|
|
EHS_LOG_INT(LogType::ERR, 0, "Attempted to receive while socket is not initialized.");
|
|
return 0;
|
|
}
|
|
|
|
sockaddr_in6 remote = {};
|
|
UInt_32 addrLen = sizeof(sockaddr_in);
|
|
|
|
SInt_64 received = recvfrom(hdl, (char*)data, (int)size, 0, (sockaddr*)&remote, (int*)&addrLen);
|
|
if (received == SOCKET_ERROR)
|
|
{
|
|
int code = WSAGetLastError();
|
|
if (code != WSAECONNRESET && code != WSAEWOULDBLOCK)
|
|
{
|
|
Release();
|
|
|
|
EHS_LOG_INT(LogType::ERR, 1, "Failed to receive with error #" + Str_8::FromNum(code) + ".");
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
if (addrLen == sizeof(sockaddr_in6))
|
|
{
|
|
char tmpAddr[INET6_ADDRSTRLEN];
|
|
|
|
if (!inet_ntop(remote.sin6_family, &remote.sin6_addr, tmpAddr, INET6_ADDRSTRLEN))
|
|
{
|
|
Int_32 code = WSAGetLastError();
|
|
|
|
EHS_LOG_INT(LogType::ERR, 2, "Failed to convert IPv6 address with error #" + Str_8::FromNum(code) + ".");
|
|
|
|
return received;
|
|
}
|
|
|
|
*type = AddrType::IPV6;
|
|
*address = tmpAddr;
|
|
*port = ntohs(remote.sin6_port);
|
|
}
|
|
else if (addrLen == sizeof(sockaddr_in))
|
|
{
|
|
char tmpAddr[INET_ADDRSTRLEN];
|
|
|
|
if (!inet_ntop(((sockaddr_in*)&remote)->sin_family, &((sockaddr_in*)&remote)->sin_addr, tmpAddr, INET_ADDRSTRLEN))
|
|
{
|
|
Int_32 code = WSAGetLastError();
|
|
|
|
EHS_LOG_INT(LogType::ERR, 2, "Failed to convert IPv4 address with error #" + Str_8::FromNum(code) + ".");
|
|
|
|
return received;
|
|
}
|
|
|
|
*type = AddrType::IPV4;
|
|
*address = tmpAddr;
|
|
*port = ntohs(((sockaddr_in*)&remote)->sin_port);
|
|
}
|
|
|
|
return received;
|
|
}
|
|
|
|
void UDP::SetBlocking(const bool blocking)
|
|
{
|
|
if (!IsValid())
|
|
{
|
|
EHS_LOG_INT(LogType::ERR, 0, "Attempted to toggle blocking while socket is not initialized.");
|
|
return;
|
|
}
|
|
|
|
u_long r = (u_long)!blocking;
|
|
|
|
int result = ioctlsocket(hdl, FIONBIO, &r);
|
|
if (result != NO_ERROR)
|
|
EHS_LOG_INT(LogType::ERR, 1, "Failed to toggle non-blocking mode with error #" + Str_8::FromNum(result) + ".");
|
|
}
|
|
|
|
bool UDP::IsBlocking() const
|
|
{
|
|
u_long r = 0;
|
|
if (ioctlsocket(hdl, FIONREAD, &r) == SOCKET_ERROR)
|
|
EHS_LOG_INT(LogType::ERR, 0, "Failed to retrieve socket info.");
|
|
|
|
return (bool)r;
|
|
}
|
|
|
|
void UDP::SetIPv6Only(const bool value)
|
|
{
|
|
if (type != AddrType::IPV6)
|
|
{
|
|
EHS_LOG_INT(LogType::WARN, 0, "Cannot set IPv6 only mode while socket is not using IPv6.");
|
|
return;
|
|
}
|
|
|
|
if (!IsValid())
|
|
{
|
|
EHS_LOG_INT(LogType::WARN, 1, "Attempted to set IPv6 only mode while socket is not initialized.");
|
|
return;
|
|
}
|
|
|
|
const int result = (int)value;
|
|
if (setsockopt(hdl, IPPROTO_IPV6, IPV6_V6ONLY, &result, sizeof(int)) == -1)
|
|
{
|
|
EHS_LOG_INT(LogType::ERR, 2, "Failed to set IPv6 only mode with error #" + Str_8::FromNum(errno) + ".");
|
|
return;
|
|
}
|
|
|
|
EHS_LOG_SUCCESS();
|
|
}
|
|
|
|
bool UDP::IsIPv6Only() const
|
|
{
|
|
if (type != AddrType::IPV6)
|
|
return false;
|
|
|
|
if (!IsValid())
|
|
{
|
|
EHS_LOG_INT(LogType::WARN, 1, "Attempted to set IPv6 only mode while socket is not initialized.");
|
|
return false;
|
|
}
|
|
|
|
int result;
|
|
socklen_t len = sizeof(int);
|
|
|
|
if (getsockopt(hdl, IPPROTO_IPV6, IPV6_V6ONLY, &result, &len) == -1)
|
|
{
|
|
EHS_LOG_INT(LogType::ERR, 2, "Failed to set IPv6 only mode with error #" + Str_8::FromNum(errno) + ".");
|
|
return false;
|
|
}
|
|
|
|
EHS_LOG_SUCCESS();
|
|
|
|
return result;
|
|
}
|
|
|
|
bool UDP::IsValid() const
|
|
{
|
|
return hdl != EHS_INVALID_SOCKET;
|
|
}
|
|
|
|
void UDP::Bind_v6(const Str_8& address, const UInt_16 port)
|
|
{
|
|
sockaddr_in6 result = {};
|
|
result.sin6_family = AF_INET6;
|
|
result.sin6_port = htons(port);
|
|
|
|
if (address.Size())
|
|
{
|
|
Int_32 code = inet_pton(AF_INET6, address, &result.sin6_addr);
|
|
if (!code)
|
|
{
|
|
EHS_LOG_INT(LogType::ERR, 0, "The given address, \"" + address + "\" is not valid.");
|
|
return;
|
|
}
|
|
else if (code == -1)
|
|
{
|
|
Int_32 dCode = WSAGetLastError();
|
|
|
|
EHS_LOG_INT(LogType::ERR, 1, "Failed to convert address with error #" + Str_8::FromNum(dCode) + ".");
|
|
return;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
result.sin6_addr = in6addr_any;
|
|
}
|
|
|
|
int code = bind(hdl, (sockaddr*)&result, sizeof(sockaddr_in6));
|
|
if (code == SOCKET_ERROR)
|
|
{
|
|
EHS_LOG_INT(LogType::ERR, 2, "Failed to bind socket with error #" + Str_8::FromNum(WSAGetLastError()) + ".");
|
|
return;
|
|
}
|
|
}
|
|
|
|
void UDP::Bind_v4(const Str_8& address, const UInt_16 port)
|
|
{
|
|
sockaddr_in result = {};
|
|
result.sin_family = AF_INET;
|
|
result.sin_port = htons(port);
|
|
|
|
if (address.Size())
|
|
{
|
|
int code = inet_pton(AF_INET, address, &result.sin_addr);
|
|
if (!code)
|
|
{
|
|
EHS_LOG_INT(LogType::ERR, 0, "The given address, \"" + address + "\" is not valid.");
|
|
return;
|
|
}
|
|
else if (code == -1)
|
|
{
|
|
Int_32 dCode = WSAGetLastError();
|
|
|
|
EHS_LOG_INT(LogType::ERR, 1, "Failed to convert address with error #" + Str_8::FromNum(dCode) + ".");
|
|
return;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
result.sin_addr.S_un.S_addr = INADDR_ANY;
|
|
}
|
|
|
|
int code = bind(hdl, (sockaddr*)&result, sizeof(sockaddr_in));
|
|
if (code == SOCKET_ERROR)
|
|
{
|
|
EHS_LOG_INT(LogType::ERR, 2, "Failed to bind socket with error #" + Str_8::FromNum(WSAGetLastError()) + ".");
|
|
return;
|
|
}
|
|
}
|
|
|
|
UInt_64 UDP::Send_v6(const Str_8& addr, const UInt_16 port, const Byte* const data, const UInt_64 size)
|
|
{
|
|
if (!IsValid())
|
|
{
|
|
EHS_LOG_INT(LogType::INFO, 0, "Attempted to send while socket is not initialized.");
|
|
return 0;
|
|
}
|
|
|
|
sockaddr_in6 result = {};
|
|
result.sin6_family = AF_INET6;
|
|
result.sin6_port = htons(port);
|
|
|
|
Int_32 code = inet_pton(AF_INET6, addr, &result.sin6_addr);
|
|
if (!code)
|
|
{
|
|
EHS_LOG_INT(LogType::ERR, 1, "The given address, \"" + address + "\" is not valid.");
|
|
return 0;
|
|
}
|
|
else if (code == -1)
|
|
{
|
|
Int_32 dCode = WSAGetLastError();
|
|
|
|
EHS_LOG_INT(LogType::ERR, 1, "Failed to convert address with error #" + Str_8::FromNum(dCode) + ".");
|
|
return 0;
|
|
}
|
|
|
|
Int_32 sent = sendto(hdl, (char*)&data[0], (int)size, 0, (sockaddr*)&result, sizeof(sockaddr_in6));
|
|
if (sent == SOCKET_ERROR)
|
|
{
|
|
Int_32 dCode = WSAGetLastError();
|
|
|
|
EHS_LOG_INT(LogType::ERR, 3, "Failed to send with error #" + Str_8::FromNum(dCode) + ".");
|
|
|
|
Release();
|
|
|
|
return 0;
|
|
}
|
|
|
|
return sent;
|
|
}
|
|
|
|
UInt_64 UDP::Send_v4(const Str_8& addr, const UInt_16 port, const Byte* const data, const UInt_64 size)
|
|
{
|
|
if (!IsValid())
|
|
{
|
|
EHS_LOG_INT(LogType::INFO, 0, "Attempted to send while socket is not initialized.");
|
|
return 0;
|
|
}
|
|
|
|
sockaddr_in result = {};
|
|
result.sin_family = AF_INET;
|
|
result.sin_port = htons(port);
|
|
|
|
int code = inet_pton(AF_INET, addr, &result.sin_addr);
|
|
if (!code)
|
|
{
|
|
EHS_LOG_INT(LogType::ERR, 1, "The given address, \"" + address + "\" is not valid.");
|
|
return 0;
|
|
}
|
|
else if (code == -1)
|
|
{
|
|
Int_32 dCode = WSAGetLastError();
|
|
|
|
EHS_LOG_INT(LogType::ERR, 1, "Failed to convert address with error #" + Str_8::FromNum(dCode) + ".");
|
|
return 0;
|
|
}
|
|
|
|
int sent = sendto(hdl, (char*)&data[0], (int)size, 0, (sockaddr*)&result, sizeof(sockaddr_in));
|
|
if (sent == SOCKET_ERROR)
|
|
{
|
|
Int_32 dCode = WSAGetLastError();
|
|
|
|
EHS_LOG_INT(LogType::ERR, 3, "Failed to send with error #" + Str_8::FromNum(dCode) + ".");
|
|
|
|
Release();
|
|
|
|
return 0;
|
|
}
|
|
|
|
return sent;
|
|
}
|
|
} |