BGTU/networks-1.cpp
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Replaced types for each address family with union

Browse Source
This commit is contained in:
Andrew Golovashevich 2025-10-28 12:33:43 +03:00
parent 36f3c7a8ec
commit 8ce26c24c1
3 changed files with 139 additions and 301 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
main.cpp
View File

@ -6,7 +6,9 @@ import ru.landgrafhomyak.BGTU.networks_1.sockets;
int main() { int main() {
LdH::Sockets::init_sockets(); LdH::Sockets::init_sockets();
auto server = LdH::Sockets::listen_tcp(LdH::Sockets::IPv4Address::parse("127.0.0.1"), 8081, 1); std::cout << LdH::Sockets::Address::parse("google.com", "443").to_string() << std::endl;
auto server = LdH::Sockets::listen_tcp(LdH::Sockets::Address::parse("127.0.0.1", "8081"), 1);
auto server_thread = LdH::fork("server", [&] { auto server_thread = LdH::fork("server", [&] {
auto server_stream = server.wait_for_connection(); auto server_stream = server.wait_for_connection();
@ -16,7 +18,7 @@ int main() {
server_stream.sock.close(); server_stream.sock.close();
}); });
auto client_thread = LdH::fork("client", [&] { auto client_thread = LdH::fork("client", [&] {
auto client = LdH::Sockets::connect_tcp(LdH::Sockets::IPv4Address::parse("127.0.0.1"), 8081); auto client = LdH::Sockets::connect_tcp(LdH::Sockets::Address::parse("127.0.0.1", "8081"));
char buffer[10] = "hello\n"; char buffer[10] = "hello\n";
client.write(10, buffer); client.write(10, buffer);
client.close(); client.close();

251
modules/sockets/src/berkeley_sockets.cppm
View File

@ -4,31 +4,13 @@ import std;
import ru.landgrafhomyak.BGTU.networks_1.exceptions; import ru.landgrafhomyak.BGTU.networks_1.exceptions;
import ru.landgrafhomyak.BGTU.networks_1.streams; import ru.landgrafhomyak.BGTU.networks_1.streams;
namespace LdH::Sockets::Berkeley { namespace LdH::Sockets::Berkeley {
export
struct sized_ptr {
std::size_t size;
void *ptr;
};
template<class addr_t, class af_t>
concept _raw_addr = std::default_initializable<addr_t> && std::destructible<addr_t> &&
std::copyable<addr_t> && std::movable<addr_t> &&
requires { { addr_t::any() } -> std::same_as<addr_t>; } &&
requires(char const *raw) { { addr_t::parse(raw) } -> std::same_as<addr_t>; } &&
requires(addr_t self) { { self.raw_ptr() } -> std::same_as<sized_ptr>; } &&
requires { { addr_t::af_value() } -> std::same_as<af_t>; };
export export
template<class ctx_t> template<class ctx_t>
concept BerkeleySocketsContext = requires { typename ctx_t::addr; } && concept BerkeleySocketsContext = requires { typename ctx_t::address_t; } &&
requires { typename ctx_t::af_t; } && std::default_initializable<typename ctx_t::address_t> && std::copyable<typename ctx_t::address_t> && std::destructible<typename ctx_t::address_t> &&
requires { typename ctx_t::af; } && requires(char const *h, char const *s) { { ctx_t::address_t::parse(h, s) } -> std::same_as<typename ctx_t::address_t>; } &&
requires { { ctx_t::af::inet() } -> std::same_as<typename ctx_t::af_t>; } && requires(typename ctx_t::address_t s) { { s.to_string() } -> std::same_as<std::string>; } &&
requires { { ctx_t::af::inet6() } -> std::same_as<typename ctx_t::af_t>; } &&
requires { { ctx_t::af::ipx() } -> std::same_as<typename ctx_t::af_t>; } &&
requires { typename ctx_t::sock_type_t; } && requires { typename ctx_t::sock_type_t; } &&
requires { typename ctx_t::sock_type; } && requires { typename ctx_t::sock_type; } &&
requires { { ctx_t::sock_type::stream() } -> std::same_as<typename ctx_t::sock_type_t>; } && requires { { ctx_t::sock_type::stream() } -> std::same_as<typename ctx_t::sock_type_t>; } &&
@ -38,143 +20,72 @@ namespace LdH::Sockets::Berkeley {
requires { { ctx_t::proto::tcp() } -> std::same_as<typename ctx_t::proto_t>; } && requires { { ctx_t::proto::tcp() } -> std::same_as<typename ctx_t::proto_t>; } &&
requires { { ctx_t::proto::udp() } -> std::same_as<typename ctx_t::proto_t>; } && requires { { ctx_t::proto::udp() } -> std::same_as<typename ctx_t::proto_t>; } &&
requires { { ctx_t::proto::icmp() } -> std::same_as<typename ctx_t::proto_t>; } && requires { { ctx_t::proto::icmp() } -> std::same_as<typename ctx_t::proto_t>; } &&
requires { typename ctx_t::addr::ipv4; requires _raw_addr<typename ctx_t::addr::ipv4, typename ctx_t::af_t>; } &&
requires { typename ctx_t::addr::ipv6; requires _raw_addr<typename ctx_t::addr::ipv6, typename ctx_t::af_t>; } &&
requires { typename ctx_t::socket_t; } && requires { typename ctx_t::socket_t; } &&
std::default_initializable<typename ctx_t::socket_t> && std::movable<typename ctx_t::socket_t> && std::destructible<typename ctx_t::socket_t> && std::default_initializable<typename ctx_t::socket_t> && std::movable<typename ctx_t::socket_t> && std::destructible<typename ctx_t::socket_t> &&
requires(typename ctx_t::af_t a, typename ctx_t::sock_type_t t, typename ctx_t::proto_t p) { { ctx_t::socket_t::create(a, t, p) } -> std::same_as<typename ctx_t::socket_t>; } && requires(typename ctx_t::address_t a, typename ctx_t::sock_type_t t, typename ctx_t::proto_t p) { { ctx_t::socket_t::create(a, t, p) } -> std::same_as<typename ctx_t::socket_t>; } &&
requires(typename ctx_t::socket_t s, std::size_t q) { { s.listen(q) } -> std::same_as<void>; } && requires(typename ctx_t::socket_t s, std::size_t q) { { s.listen(q) } -> std::same_as<void>; } &&
requires(typename ctx_t::socket_t s, typename ctx_t::addr::ipv4 a, std::uint_least16_t p) { { s.connect(a, p) } -> std::same_as<void>; } && requires(typename ctx_t::socket_t s, typename ctx_t::address_t e) { { s.connect(e) } -> std::same_as<void>; } &&
requires(typename ctx_t::socket_t s, typename ctx_t::addr::ipv6 a, std::uint_least16_t p) { { s.connect(a, p) } -> std::same_as<void>; } && requires(typename ctx_t::socket_t s, typename ctx_t::address_t e) { { s.bind(e) } -> std::same_as<void>; } &&
requires(typename ctx_t::socket_t s, typename ctx_t::addr::ipv4 a, std::uint_least16_t p) { { s.bind(a, p) } -> std::same_as<void>; } &&
requires(typename ctx_t::socket_t s, typename ctx_t::addr::ipv6 a, std::uint_least16_t p) { { s.bind(a, p) } -> std::same_as<void>; } &&
requires(typename ctx_t::socket_t s) { { s.close() } -> std::same_as<void>; } && requires(typename ctx_t::socket_t s) { { s.close() } -> std::same_as<void>; } &&
requires(typename ctx_t::socket_t s, std::size_t c, char const *d) { { s.send_stream(c, d) } -> std::same_as<void>; } && requires(typename ctx_t::socket_t s, std::size_t c, char const *d) { { s.send_stream(c, d) } -> std::same_as<void>; } &&
requires(typename ctx_t::socket_t s, std::size_t c, char *d) { { s.recv_stream(c, d) } -> std::same_as<void>; } && requires(typename ctx_t::socket_t s, std::size_t c, char *d) { { s.recv_stream(c, d) } -> std::same_as<void>; } &&
requires(typename ctx_t::socket_t s, typename ctx_t::addr::ipv4 *a) { { s.accept(a) } -> std::same_as<typename ctx_t::socket_t>; } && requires(typename ctx_t::socket_t s, typename ctx_t::address_t *a) { { s.accept(a) } -> std::same_as<typename ctx_t::socket_t>; };
requires(typename ctx_t::socket_t s, typename ctx_t::addr::ipv6 *a) { { s.accept(a) } -> std::same_as<typename ctx_t::socket_t>; };
template<class ctx_t> requires BerkeleySocketsContext<ctx_t>
class _addr_internals;
export export
template<class ctx_t> requires BerkeleySocketsContext<ctx_t>
class Address;
template<class addr_t>
class _addr_internals {
};
template<class raw_t>
class _addr_wrapper {
private:
bool _has_value;
raw_t _value;
_addr_wrapper(bool has_value, raw_t value) : _has_value{has_value}, _value{value} {
}
template<class ctx_t> requires BerkeleySocketsContext<ctx_t>
friend
class Address;
template<class addr_t>
friend
class _addr_internals;
public:
_addr_wrapper() : _has_value{false}, _value{} {
}
_addr_wrapper(_addr_wrapper const &other) noexcept = default;
_addr_wrapper(_addr_wrapper &&other) noexcept : _has_value{other._has_value}, _value{other._value} {
other._has_value = false;
}
_addr_wrapper &operator=(_addr_wrapper const &other) = default;
_addr_wrapper &operator=(_addr_wrapper &&other) noexcept {
this->_has_value = other._has_value;
other._has_value = false;
this->_value = std::move(other._value);
return *this;
}
~_addr_wrapper() noexcept = default;
static _addr_wrapper parse(char const *raw) {
return {true, raw_t::parse(raw)};
}
static _addr_wrapper parse(std::string const &raw) {
return {true, raw_t::parse(raw.c_str())};
}
static _addr_wrapper any() {
return _addr_wrapper{raw_t::any()};
}
};
export
template<class ctx_t> requires BerkeleySocketsContext<ctx_t>
using IPv4Address = _addr_wrapper<typename ctx_t::addr::ipv4>;
export
template<class ctx_t> requires BerkeleySocketsContext<ctx_t>
using IPv6Address = _addr_wrapper<typename ctx_t::addr::ipv6>;
template<class _raw_addr_t>
class _addr_internals<_addr_wrapper<_raw_addr_t> > {
public:
using raw_t = _raw_addr_t;
static _addr_wrapper<_raw_addr_t> empty() {
return _addr_wrapper<_raw_addr_t>{false, _raw_addr_t{}};
}
static _addr_wrapper<_raw_addr_t> wrap(_raw_addr_t value) {
return _addr_wrapper<_raw_addr_t>{true, value};
}
static _raw_addr_t raw_of(_addr_wrapper<_raw_addr_t> const &value) {
return value._value;
}
static bool has_value(_addr_wrapper<_raw_addr_t> const &value) {
return value._has_value;
}
};
template<class ctx_t> requires BerkeleySocketsContext<ctx_t> template<class ctx_t> requires BerkeleySocketsContext<ctx_t>
class Address { class Address {
private: private:
enum _type_t { bool _has_value;
_type_EMPTY, ctx_t::address_t _value;
_type_IPv4,
_type_IPv6,
};
_type_t _type; explicit Address(bool has_value, ctx_t::address_t value) : _has_value{has_value}, _value{value} {
}
union { template<class ctx_t2> requires BerkeleySocketsContext<ctx_t2>
struct { friend class _addr_internals;
} empty;
ctx_t::ipv4 ipv4;
ctx_t::ipv6 ipv6;
} _value;
public: public:
Address() : _type{_type_EMPTY}, _value{.empty{}} { Address() : _has_value{false}, _value{} {
} }
Address(IPv4Address<ctx_t> const &value) : _type{_type_IPv4}, _value{.ipv4 = value._value} { Address(Address const &other) noexcept = default;
Address(Address &&other) noexcept : _has_value{other._has_value}, _value{other._value} {
other._has_value = false;
} }
Address(IPv6Address<ctx_t> const &value) : _type{_type_IPv6}, _value{.ipv6 = value._value} { Address &operator=(Address const &other) = default;
Address &operator=(Address &&other) noexcept {
this->_has_value = other._has_value;
this->_value = std::move(other._value);
other._has_value = false;
return *this;
}
~Address() {
this->_has_value = false;
}
static Address parse(char const *host, char const *service) {
return Address{true, ctx_t::address_t::parse(host, service)};
}
std::string to_string() {
return this->_value.to_string();
} }
}; };
template<class ctx_t> requires BerkeleySocketsContext<ctx_t>
class _addr_internals {
public:
static bool has_value(Address<ctx_t> const &v) { return v._has_value; }
static ctx_t::address_t unwrap(Address<ctx_t> const &v) { return v._value; }
static Address<ctx_t> wrap(ctx_t::address_t const &raw) { return Address<ctx_t>{true, raw}; }
};
enum _socket_state_t { enum _socket_state_t {
_socket_state_UNINITIALIZED, _socket_state_UNINITIALIZED,
@ -210,25 +121,21 @@ namespace LdH::Sockets::Berkeley {
while (true) { while (true) {
switch (current) { switch (current) {
case _socket_state_UNINITIALIZED: case _socket_state_UNINITIALIZED:
if (this->_state.compare_exchange_weak(current, _socket_state_AVAILABLE))
return current;
continue;
case _socket_state_MOVED: case _socket_state_MOVED:
if (this->_state.compare_exchange_weak(current, _socket_state_AVAILABLE))
return current;
continue;
case _socket_state_CLOSED: case _socket_state_CLOSED:
if (this->_state.compare_exchange_weak(current, _socket_state_AVAILABLE)) if (this->_state.compare_exchange_weak(current, _socket_state_AVAILABLE))
return current; goto DONE;
continue; continue;
default: default:
LdH::abort("Variable already initialized"); LdH::abort("Variable already initialized");
} }
} }
DONE:
this->_state.store(other._state.exchange(_socket_state_MOVED)); this->_state.store(other._state.exchange(_socket_state_MOVED));
this->_value = std::move(other._value); this->_value = std::move(other._value);
return *this;; return *this;
} }
private: private:
@ -320,10 +227,10 @@ namespace LdH::Sockets::Berkeley {
}; };
export export
template<class ctx_t, class> requires BerkeleySocketsContext<ctx_t> template<class ctx_t> requires BerkeleySocketsContext<ctx_t>
class StreamSocketsServer; class StreamSocketsServer;
template<class sock_t> template<class>
class _socket_internals { class _socket_internals {
}; };
@ -336,7 +243,7 @@ namespace LdH::Sockets::Berkeley {
} }
template<class ctx_t2, class> requires BerkeleySocketsContext<ctx_t2> template<class ctx_t2> requires BerkeleySocketsContext<ctx_t2>
friend friend
class StreamSocketsServer; class StreamSocketsServer;
@ -348,7 +255,7 @@ namespace LdH::Sockets::Berkeley {
public: public:
StreamSocket() = default; StreamSocket() = default;
explicit StreamSocket(StreamSocket &&other) noexcept = default; StreamSocket(StreamSocket &&other) noexcept = default;
StreamSocket &operator=(StreamSocket &&other) noexcept = default; StreamSocket &operator=(StreamSocket &&other) noexcept = default;
@ -382,17 +289,17 @@ namespace LdH::Sockets::Berkeley {
export export
template<class addr_t, class sock_t> template<class ctx_t, class sock_t>
class SocketWithAddress { class SocketWithAddress {
public: public:
addr_t addr; Address<ctx_t> addr;
sock_t sock; sock_t sock;
SocketWithAddress(addr_t addr, sock_t &&sock) : addr{addr}, sock{std::move(sock)} { SocketWithAddress(Address<ctx_t> addr, sock_t &&sock) : addr{addr}, sock{std::move(sock)} {
} }
}; };
template<class ctx_t, class addr_t> requires BerkeleySocketsContext<ctx_t> template<class ctx_t> requires BerkeleySocketsContext<ctx_t>
class StreamSocketsServer : public _berkeley_socket_commons<ctx_t> { class StreamSocketsServer : public _berkeley_socket_commons<ctx_t> {
private: private:
explicit StreamSocketsServer(ctx_t::socket_t &&value) : _berkeley_socket_commons<ctx_t>{std::move(value)} { explicit StreamSocketsServer(ctx_t::socket_t &&value) : _berkeley_socket_commons<ctx_t>{std::move(value)} {
@ -405,18 +312,18 @@ namespace LdH::Sockets::Berkeley {
public: public:
StreamSocketsServer() = default; StreamSocketsServer() = default;
explicit StreamSocketsServer(StreamSocketsServer &&other) noexcept = default; StreamSocketsServer(StreamSocketsServer &&other) noexcept = default;
StreamSocketsServer &operator=(StreamSocketsServer &&other) noexcept = default; StreamSocketsServer &operator=(StreamSocketsServer &&other) noexcept = default;
[[nodiscard]] [[nodiscard]]
SocketWithAddress<addr_t, StreamSocket<ctx_t> > wait_for_connection() { SocketWithAddress<ctx_t, StreamSocket<ctx_t> > wait_for_connection() {
this->_start_reading("Socket already waiting for connections"); this->_start_reading("Socket already waiting for connections");
typename _addr_internals<addr_t>::raw_t addr{}; typename ctx_t::address_t addr{};
typename ctx_t::socket_t raw = this->_value.accept(&addr); typename ctx_t::socket_t raw = this->_value.accept(&addr);
this->_finish_reading(); this->_finish_reading();
return SocketWithAddress<addr_t, StreamSocket<ctx_t> >{_addr_internals<addr_t>::wrap(addr), StreamSocket<ctx_t>{std::move(raw)}}; return SocketWithAddress<ctx_t, StreamSocket<ctx_t> >{_addr_internals<ctx_t>::wrap(addr), _socket_internals<StreamSocket<ctx_t> >::wrap(std::move(raw))};
} }
void close() { void close() {
@ -427,34 +334,34 @@ namespace LdH::Sockets::Berkeley {
}; };
template<class ctx_t, class addr_t> template<class ctx_t>
class _socket_internals<StreamSocketsServer<ctx_t, addr_t> > { class _socket_internals<StreamSocketsServer<ctx_t> > {
public: public:
static StreamSocketsServer<ctx_t, addr_t> wrap(ctx_t::socket_t &&raw) { static StreamSocketsServer<ctx_t> wrap(ctx_t::socket_t &&raw) {
return StreamSocketsServer<ctx_t, addr_t>{std::move(raw)}; return StreamSocketsServer<ctx_t>{std::move(raw)};
} }
}; };
export export
template<class ctx_t, class addr_t> requires BerkeleySocketsContext<ctx_t> template<class ctx_t> requires BerkeleySocketsContext<ctx_t>
[[nodiscard]] [[nodiscard]]
StreamSocket<ctx_t> connect_tcp(addr_t addr, std::uint_least16_t port) { StreamSocket<ctx_t> connect_tcp(Address<ctx_t> addr) {
if (!_addr_internals<addr_t>::has_value(addr)) if (!_addr_internals<ctx_t>::has_value(addr))
LdH::abort("Address not initialized"); LdH::abort("Address not initialized");
typename ctx_t::socket_t sock = ctx_t::socket_t::create(_addr_internals<addr_t>::raw_t::af_value(), ctx_t::sock_type::stream(), ctx_t::proto::tcp()); typename ctx_t::socket_t sock = ctx_t::socket_t::create(_addr_internals<ctx_t>::unwrap(addr), ctx_t::sock_type::stream(), ctx_t::proto::tcp());
sock.connect(_addr_internals<addr_t>::raw_of(addr), port); sock.connect(_addr_internals<ctx_t>::unwrap(addr));
return _socket_internals<StreamSocket<ctx_t> >::wrap(std::move(sock)); return _socket_internals<StreamSocket<ctx_t> >::wrap(std::move(sock));
} }
export export
template<class ctx_t, class addr_t> requires BerkeleySocketsContext<ctx_t> template<class ctx_t> requires BerkeleySocketsContext<ctx_t>
[[nodiscard]] [[nodiscard]]
StreamSocketsServer<ctx_t, addr_t> listen_tcp(addr_t addr, std::uint_least16_t port, std::size_t queue_size) { StreamSocketsServer<ctx_t> listen_tcp(Address<ctx_t> addr, std::size_t queue_size) {
if (!_addr_internals<addr_t>::has_value(addr)) if (!_addr_internals<ctx_t>::has_value(addr))
LdH::abort("Address not initialized"); LdH::abort("Address not initialized");
typename ctx_t::socket_t sock = ctx_t::socket_t::create(_addr_internals<addr_t>::raw_t::af_value(), ctx_t::sock_type::stream(), ctx_t::proto::tcp()); typename ctx_t::socket_t sock = ctx_t::socket_t::create(_addr_internals<ctx_t>::unwrap(addr), ctx_t::sock_type::stream(), ctx_t::proto::tcp());
sock.bind(_addr_internals<addr_t>::raw_of(addr), port); sock.bind(_addr_internals<ctx_t>::unwrap(addr));
sock.listen(queue_size); sock.listen(queue_size);
return _socket_internals<StreamSocketsServer<ctx_t, addr_t> >::wrap(std::move(sock)); return _socket_internals<StreamSocketsServer<ctx_t> >::wrap(std::move(sock));
} }
} }

183
modules/sockets/src/platform/windows.cpp.inc
View File

@ -19,57 +19,49 @@ namespace LdH::Sockets {
} }
template<class _value_t, INT _family, _value_t (_any_constructor)()>
class _in_addr_wrapper {
public:
_value_t _value;
private:
_in_addr_wrapper(_value_t v) : _value{v} {
}
public:
_in_addr_wrapper() = default;
_in_addr_wrapper(_in_addr_wrapper const &other) = default;
_in_addr_wrapper(_in_addr_wrapper &&other) = default;
_in_addr_wrapper &operator=(_in_addr_wrapper const &other) = default;
_in_addr_wrapper &operator=(_in_addr_wrapper &&other) = default;
static _in_addr_wrapper any() { return _in_addr_wrapper{_any_constructor()}; }
static _in_addr_wrapper parse(char const *raw) {
_value_t val;
switch (inet_pton(_family, raw, &val)) {
case 1:
break;
case 0:
throw LdH::Exception{"Wrong IP address value"};
default:
LdH::throwFromWindowsErrCode(WSAGetLastError());
break;
}
return _in_addr_wrapper{val};
}
Berkeley::sized_ptr raw_ptr() {
return {sizeof(_value_t), &(this->_value)};
}
static INT af_value() { return _family; };
};
struct _WinsockContext { struct _WinsockContext {
struct addr { class address_t {
using ipv4 = _in_addr_wrapper<in_addr, AF_INET, [] { return in4addr_any; }>; public:
using ipv6 = _in_addr_wrapper<in6_addr, AF_INET6, [] { return in6addr_any; }>; sockaddr_storage _value;
private:
address_t(sockaddr_storage value) : _value{value} {
}
public:
address_t() = default;
address_t(address_t const &) = default;
address_t(address_t &&) = default;
address_t &operator=(address_t const &) = default;
address_t &operator=(address_t &&) = default;
static address_t parse(char const *addr, char const *service) {
addrinfo *p;
if (0 != getaddrinfo(addr, service, nullptr, &p)) {
LdH::throwFromWindowsErrCode(WSAGetLastError());
}
sockaddr_storage out;
ZeroMemory(&out, sizeof(sockaddr_storage));
CopyMemory(&out, p->ai_addr, p->ai_addrlen);
freeaddrinfo(p);
return address_t{out};
}
std::string to_string() {
char buffer[1024];
DWORD buf_size = 1024;
if (0 != WSAAddressToStringA(reinterpret_cast<sockaddr *>(&(this->_value)), sizeof(sockaddr_storage), nullptr, buffer, &buf_size)) {
LdH::throwFromWindowsErrCode(WSAGetLastError());
}
return std::string{buffer, buf_size - 1};
}
}; };
using af_t = int;
using sock_type_t = int; using sock_type_t = int;
using proto_t = int; using proto_t = int;
@ -116,8 +108,8 @@ namespace LdH::Sockets {
~socket_t() = default; ~socket_t() = default;
static socket_t create(int af, int type, int proto) { static socket_t create(address_t const &addr, int type, int proto) {
SOCKET sock = ::socket(af, type, proto); SOCKET sock = ::socket(addr._value.ss_family, type, proto);
if (sock == INVALID_SOCKET) { if (sock == INVALID_SOCKET) {
LdH::throwFromWindowsErrCode(WSAGetLastError()); LdH::throwFromWindowsErrCode(WSAGetLastError());
} }
@ -132,74 +124,24 @@ namespace LdH::Sockets {
this->_value = INVALID_SOCKET; this->_value = INVALID_SOCKET;
} }
void connect(addr::ipv4 addr, std::uint_least16_t port) { void connect(address_t addr) {
sockaddr_in combined; if (0 != ::connect(this->_value, reinterpret_cast<sockaddr *>(&(addr._value)), sizeof(sockaddr)))
ZeroMemory(&combined, sizeof(combined));
combined.sin_family = AF_INET;
combined.sin_port = htons(port);
combined.sin_addr = addr._value;
if (0 != ::connect(this->_value, reinterpret_cast<sockaddr *>(&combined), sizeof(combined)))
LdH::throwFromWindowsErrCode(WSAGetLastError()); LdH::throwFromWindowsErrCode(WSAGetLastError());
} }
void connect(addr::ipv6 addr, std::uint_least16_t port) { void bind(address_t addr) {
sockaddr_in6 combined; if (0 != ::bind(this->_value, reinterpret_cast<sockaddr *>(&(addr._value)), sizeof(sockaddr)))
ZeroMemory(&combined, sizeof(combined));
combined.sin6_family = AF_INET6;
combined.sin6_port = htons(port);
combined.sin6_addr = addr._value;
if (0 != ::connect(this->_value, reinterpret_cast<sockaddr *>(&combined), sizeof(combined)))
LdH::throwFromWindowsErrCode(WSAGetLastError()); LdH::throwFromWindowsErrCode(WSAGetLastError());
} }
void bind(addr::ipv4 addr, std::uint_least16_t port) { socket_t accept(address_t *addr) {
sockaddr_in combined; SOCKET sock = ::accept(this->_value, reinterpret_cast<sockaddr *>(&(addr->_value)), nullptr);
ZeroMemory(&combined, sizeof(combined));
combined.sin_family = AF_INET;
combined.sin_port = htons(port);
combined.sin_addr = addr._value;
if (0 != ::bind(this->_value, reinterpret_cast<sockaddr *>(&combined), sizeof(combined)))
LdH::throwFromWindowsErrCode(WSAGetLastError());
}
void bind(addr::ipv6 addr, std::uint_least16_t port) {
sockaddr_in6 combined;
ZeroMemory(&combined, sizeof(combined));
combined.sin6_family = AF_INET6;
combined.sin6_port = htons(port);
combined.sin6_addr = addr._value;
if (0 != ::bind(this->_value, reinterpret_cast<sockaddr *>(&combined), sizeof(combined)))
LdH::throwFromWindowsErrCode(WSAGetLastError());
}
socket_t accept(addr::ipv4 *addr) {
sockaddr_in raw_addr;
raw_addr.sin_family = AF_INET;
int size_i = sizeof(sockaddr_in);
SOCKET sock = ::accept(this->_value, reinterpret_cast<sockaddr *>(&raw_addr), &size_i);
if (sock == INVALID_SOCKET) { if (sock == INVALID_SOCKET) {
LdH::throwFromWindowsErrCode(WSAGetLastError()); LdH::throwFromWindowsErrCode(WSAGetLastError());
} }
addr->_value = raw_addr.sin_addr;
return socket_t{sock}; return socket_t{sock};
} }
socket_t accept(addr::ipv6 *addr) {
sockaddr_in6 raw_addr;
int size_i = sizeof(sockaddr_in6);
SOCKET sock = ::accept(this->_value, reinterpret_cast<sockaddr *>(&raw_addr), &size_i);
if (sock == INVALID_SOCKET) {
LdH::throwFromWindowsErrCode(WSAGetLastError());
}
addr->_value = raw_addr.sin6_addr;
return socket_t{sock};
}
void listen(std::size_t queue_size) { void listen(std::size_t queue_size) {
if (0 != ::listen(this->_value, queue_size)) { if (0 != ::listen(this->_value, queue_size)) {
LdH::throwFromWindowsErrCode(WSAGetLastError()); LdH::throwFromWindowsErrCode(WSAGetLastError());
@ -236,36 +178,23 @@ namespace LdH::Sockets {
static_assert(Berkeley::BerkeleySocketsContext<_WinsockContext>); static_assert(Berkeley::BerkeleySocketsContext<_WinsockContext>);
export using IPv4Address = Berkeley::IPv4Address<_WinsockContext>; export using Address = Berkeley::Address<_WinsockContext>;
export using IPv6Address = Berkeley::IPv6Address<_WinsockContext>;
export export
template<class addr_t, class sock_t> template<class sock_t>
using SocketWithAddress = Berkeley::SocketWithAddress<addr_t, sock_t>; using SocketWithAddress = Berkeley::SocketWithAddress<_WinsockContext, sock_t>;
export using StreamSocket = Berkeley::StreamSocket<_WinsockContext>; export using StreamSocket = Berkeley::StreamSocket<_WinsockContext>;
export export using StreamSocketsServer = Berkeley::StreamSocketsServer<_WinsockContext>;
template<class addr_t>
using StreamSocketsServer = Berkeley::StreamSocketsServer<_WinsockContext, addr_t>;
export export
StreamSocket connect_tcp(IPv4Address addr, std::uint_least16_t port) { StreamSocket connect_tcp(Address addr) {
return Berkeley::connect_tcp<_WinsockContext, IPv4Address>(addr, port); return Berkeley::connect_tcp<_WinsockContext>(addr);
} }
export export
StreamSocket connect_tcp(IPv6Address addr, std::uint_least16_t port) { StreamSocketsServer listen_tcp(Address addr, std::size_t queue_size) {
return Berkeley::connect_tcp<_WinsockContext, IPv6Address>(addr, port); return Berkeley::listen_tcp<_WinsockContext>(addr, queue_size);
}
export
StreamSocketsServer<IPv4Address> listen_tcp(IPv4Address addr, std::uint_least16_t port, std::size_t queue_size) {
return Berkeley::listen_tcp<_WinsockContext, IPv4Address>(addr, port, queue_size);
}
export
StreamSocketsServer<IPv6Address> listen_tcp(IPv6Address addr, std::uint_least16_t port, std::size_t queue_size) {
return Berkeley::listen_tcp<_WinsockContext, IPv6Address>(addr, port, queue_size);
} }
} }