mirror of
https://github.com/momo5502/emulator.git
synced 2026-01-17 19:13:55 +00:00
1278 lines
42 KiB
C++
1278 lines
42 KiB
C++
#include "../std_include.hpp"
|
|
#include "afd_endpoint.hpp"
|
|
#include "afd_types.hpp"
|
|
|
|
#include "../windows_emulator.hpp"
|
|
#include "../network/socket_factory.hpp"
|
|
|
|
#include <network/address.hpp>
|
|
#include <network/socket.hpp>
|
|
|
|
#include <utils/finally.hpp>
|
|
#include <utils/time.hpp>
|
|
|
|
namespace
|
|
{
|
|
// NOLINTBEGIN(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
|
|
|
|
struct afd_creation_data
|
|
{
|
|
uint64_t unk1;
|
|
char afd_open_packet_xx[0x10];
|
|
uint64_t unk2;
|
|
int address_family;
|
|
int type;
|
|
int protocol;
|
|
// ...
|
|
};
|
|
|
|
struct win_sockaddr
|
|
{
|
|
int16_t sa_family;
|
|
uint8_t sa_data[14];
|
|
};
|
|
|
|
struct win_sockaddr_in
|
|
{
|
|
int16_t sin_family;
|
|
uint16_t sin_port;
|
|
in_addr sin_addr;
|
|
uint8_t sin_zero[8];
|
|
};
|
|
|
|
struct win_sockaddr_in6
|
|
{
|
|
int16_t sin6_family;
|
|
uint16_t sin6_port;
|
|
uint32_t sin6_flowinfo;
|
|
in6_addr sin6_addr;
|
|
uint32_t sin6_scope_id;
|
|
};
|
|
|
|
// NOLINTEND(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
|
|
|
|
static_assert(sizeof(win_sockaddr) == 16);
|
|
static_assert(sizeof(win_sockaddr_in) == 16);
|
|
static_assert(sizeof(win_sockaddr_in6) == 28);
|
|
|
|
static_assert(sizeof(win_sockaddr_in::sin_addr) == 4);
|
|
static_assert(sizeof(win_sockaddr_in6::sin6_addr) == 16);
|
|
static_assert(sizeof(win_sockaddr_in6::sin6_flowinfo) == sizeof(sockaddr_in6::sin6_flowinfo));
|
|
static_assert(sizeof(win_sockaddr_in6::sin6_scope_id) == sizeof(sockaddr_in6::sin6_scope_id));
|
|
|
|
const std::map<int, int> address_family_map{
|
|
{0, AF_UNSPEC}, //
|
|
{2, AF_INET}, //
|
|
{23, AF_INET6}, //
|
|
};
|
|
|
|
const std::map<int, int> socket_type_map{
|
|
{0, 0}, //
|
|
{1, SOCK_STREAM}, //
|
|
{2, SOCK_DGRAM}, //
|
|
{3, SOCK_RAW}, //
|
|
{4, SOCK_RDM}, //
|
|
};
|
|
|
|
const std::map<int, int> socket_protocol_map{
|
|
{0, 0}, //
|
|
{6, IPPROTO_TCP}, //
|
|
{17, IPPROTO_UDP}, //
|
|
{255, IPPROTO_RAW}, //
|
|
};
|
|
|
|
int16_t translate_host_to_win_address_family(const int host_af)
|
|
{
|
|
for (const auto& entry : address_family_map)
|
|
{
|
|
if (entry.second == host_af)
|
|
{
|
|
return static_cast<int16_t>(entry.first);
|
|
}
|
|
}
|
|
|
|
throw std::runtime_error("Unknown host address family: " + std::to_string(host_af));
|
|
}
|
|
|
|
int translate_win_to_host_address_family(const int win_af)
|
|
{
|
|
const auto entry = address_family_map.find(win_af);
|
|
if (entry != address_family_map.end())
|
|
{
|
|
return entry->second;
|
|
}
|
|
|
|
throw std::runtime_error("Unknown address family: " + std::to_string(win_af));
|
|
}
|
|
|
|
int translate_win_to_host_type(const int win_type)
|
|
{
|
|
const auto entry = socket_type_map.find(win_type);
|
|
if (entry != socket_type_map.end())
|
|
{
|
|
return entry->second;
|
|
}
|
|
|
|
throw std::runtime_error("Unknown socket type: " + std::to_string(win_type));
|
|
}
|
|
|
|
int translate_win_to_host_protocol(const int win_protocol)
|
|
{
|
|
const auto entry = socket_protocol_map.find(win_protocol);
|
|
if (entry != socket_protocol_map.end())
|
|
{
|
|
return entry->second;
|
|
}
|
|
|
|
throw std::runtime_error("Unknown socket protocol: " + std::to_string(win_protocol));
|
|
}
|
|
|
|
std::vector<std::byte> convert_to_win_address(const windows_emulator& win_emu, const network::address& a)
|
|
{
|
|
if (a.is_ipv4())
|
|
{
|
|
win_sockaddr_in win_addr{};
|
|
win_addr.sin_family = translate_host_to_win_address_family(a.get_family());
|
|
win_addr.sin_port = htons(win_emu.get_emulator_port(a.get_port()));
|
|
memcpy(&win_addr.sin_addr, &a.get_in_addr().sin_addr, sizeof(win_addr.sin_addr));
|
|
|
|
const auto* ptr = reinterpret_cast<std::byte*>(&win_addr);
|
|
return {ptr, ptr + sizeof(win_addr)};
|
|
}
|
|
|
|
if (a.is_ipv6())
|
|
{
|
|
win_sockaddr_in6 win_addr{};
|
|
win_addr.sin6_family = translate_host_to_win_address_family(a.get_family());
|
|
win_addr.sin6_port = htons(win_emu.get_emulator_port(a.get_port()));
|
|
|
|
const auto& addr = a.get_in6_addr();
|
|
memcpy(&win_addr.sin6_addr, &addr.sin6_addr, sizeof(win_addr.sin6_addr));
|
|
win_addr.sin6_flowinfo = addr.sin6_flowinfo;
|
|
win_addr.sin6_scope_id = addr.sin6_scope_id;
|
|
|
|
const auto* ptr = reinterpret_cast<std::byte*>(&win_addr);
|
|
return {ptr, ptr + sizeof(win_addr)};
|
|
}
|
|
|
|
throw std::runtime_error("Unsupported host address family for conversion: " + std::to_string(a.get_family()));
|
|
}
|
|
|
|
network::address convert_to_host_address(const windows_emulator& win_emu, const std::span<const std::byte> data)
|
|
{
|
|
if (data.size() < sizeof(win_sockaddr))
|
|
{
|
|
throw std::runtime_error("Bad address size");
|
|
}
|
|
|
|
win_sockaddr win_addr{};
|
|
memcpy(&win_addr, data.data(), sizeof(win_addr));
|
|
|
|
const auto family = translate_win_to_host_address_family(win_addr.sa_family);
|
|
|
|
network::address a{};
|
|
|
|
if (family == AF_INET)
|
|
{
|
|
if (data.size() < sizeof(win_sockaddr_in))
|
|
{
|
|
throw std::runtime_error("Bad IPv4 address size");
|
|
}
|
|
|
|
win_sockaddr_in win_addr4{};
|
|
memcpy(&win_addr4, data.data(), sizeof(win_addr4));
|
|
|
|
a.set_ipv4(win_addr4.sin_addr);
|
|
a.set_port(win_emu.get_host_port(ntohs(win_addr4.sin_port)));
|
|
|
|
return a;
|
|
}
|
|
|
|
if (family == AF_INET6)
|
|
{
|
|
if (data.size() < sizeof(win_sockaddr_in6))
|
|
{
|
|
throw std::runtime_error("Bad IPv6 address size");
|
|
}
|
|
|
|
win_sockaddr_in6 win_addr6{};
|
|
memcpy(&win_addr6, data.data(), sizeof(win_addr6));
|
|
|
|
a.set_ipv6(win_addr6.sin6_addr);
|
|
a.set_port(ntohs(win_addr6.sin6_port));
|
|
|
|
auto& addr = a.get_in6_addr();
|
|
addr.sin6_flowinfo = win_addr6.sin6_flowinfo;
|
|
addr.sin6_scope_id = win_addr6.sin6_scope_id;
|
|
|
|
return a;
|
|
}
|
|
|
|
throw std::runtime_error("Unsupported win address family for conversion: " + std::to_string(family));
|
|
}
|
|
|
|
afd_creation_data get_creation_data(windows_emulator& win_emu, const io_device_creation_data& data)
|
|
{
|
|
if (!data.buffer || data.length < sizeof(afd_creation_data))
|
|
{
|
|
throw std::runtime_error("Bad AFD creation data");
|
|
}
|
|
|
|
return win_emu.emu().read_memory<afd_creation_data>(data.buffer);
|
|
}
|
|
|
|
std::pair<AFD_POLL_INFO64, std::vector<AFD_POLL_HANDLE_INFO64>> get_poll_info(windows_emulator& win_emu,
|
|
const io_device_context& c)
|
|
{
|
|
constexpr auto info_size = offsetof(AFD_POLL_INFO64, Handles);
|
|
if (!c.input_buffer || c.input_buffer_length < info_size || c.input_buffer != c.output_buffer)
|
|
{
|
|
throw std::runtime_error("Bad AFD poll data");
|
|
}
|
|
|
|
AFD_POLL_INFO64 poll_info{};
|
|
win_emu.emu().read_memory(c.input_buffer, &poll_info, info_size);
|
|
|
|
std::vector<AFD_POLL_HANDLE_INFO64> handle_info{};
|
|
|
|
const emulator_object<AFD_POLL_HANDLE_INFO64> handle_info_obj{win_emu.emu(), c.input_buffer + info_size};
|
|
|
|
if (c.input_buffer_length < (info_size + sizeof(AFD_POLL_HANDLE_INFO64) * poll_info.NumberOfHandles))
|
|
{
|
|
throw std::runtime_error("Bad AFD poll handle data");
|
|
}
|
|
|
|
for (ULONG i = 0; i < poll_info.NumberOfHandles; ++i)
|
|
{
|
|
handle_info.emplace_back(handle_info_obj.read(i));
|
|
}
|
|
|
|
return {poll_info, std::move(handle_info)};
|
|
}
|
|
|
|
int16_t map_afd_request_events_to_socket(const ULONG poll_events)
|
|
{
|
|
int16_t socket_events{};
|
|
|
|
if (poll_events & (AFD_POLL_DISCONNECT | AFD_POLL_ACCEPT | AFD_POLL_RECEIVE))
|
|
{
|
|
socket_events |= POLLRDNORM;
|
|
}
|
|
|
|
if (poll_events & AFD_POLL_RECEIVE_EXPEDITED)
|
|
{
|
|
socket_events |= POLLRDBAND;
|
|
}
|
|
|
|
if (poll_events & (AFD_POLL_CONNECT | AFD_POLL_CONNECT_FAIL | AFD_POLL_SEND))
|
|
{
|
|
socket_events |= POLLWRNORM;
|
|
}
|
|
|
|
return socket_events;
|
|
}
|
|
|
|
ULONG map_socket_response_events_to_afd(const int16_t socket_events, const ULONG afd_poll_events,
|
|
const bool is_listening, const bool is_connecting)
|
|
{
|
|
ULONG afd_events = 0;
|
|
|
|
if (socket_events & POLLRDNORM)
|
|
{
|
|
if (!is_listening && afd_poll_events & AFD_POLL_RECEIVE)
|
|
{
|
|
afd_events |= AFD_POLL_RECEIVE;
|
|
}
|
|
else if (is_listening && afd_poll_events & AFD_POLL_ACCEPT)
|
|
{
|
|
afd_events |= AFD_POLL_ACCEPT;
|
|
}
|
|
}
|
|
|
|
if (socket_events & POLLRDBAND && afd_poll_events & AFD_POLL_RECEIVE_EXPEDITED)
|
|
{
|
|
afd_events |= AFD_POLL_RECEIVE_EXPEDITED;
|
|
}
|
|
|
|
if (socket_events & POLLWRNORM)
|
|
{
|
|
if (!is_connecting && afd_poll_events & AFD_POLL_SEND)
|
|
{
|
|
afd_events |= AFD_POLL_SEND;
|
|
}
|
|
else if (is_connecting && afd_poll_events & AFD_POLL_CONNECT)
|
|
{
|
|
afd_events |= AFD_POLL_CONNECT;
|
|
}
|
|
}
|
|
|
|
if ((socket_events & (POLLHUP | POLLERR)) == (POLLHUP | POLLERR) &&
|
|
afd_poll_events & (AFD_POLL_CONNECT_FAIL | AFD_POLL_ABORT))
|
|
{
|
|
afd_events |= (AFD_POLL_CONNECT_FAIL | AFD_POLL_ABORT);
|
|
}
|
|
else if (socket_events & POLLHUP && afd_poll_events & AFD_POLL_DISCONNECT)
|
|
{
|
|
afd_events |= AFD_POLL_DISCONNECT;
|
|
}
|
|
|
|
if (socket_events & POLLNVAL && afd_poll_events & AFD_POLL_LOCAL_CLOSE)
|
|
{
|
|
afd_events |= AFD_POLL_LOCAL_CLOSE;
|
|
}
|
|
|
|
return afd_events;
|
|
}
|
|
|
|
struct afd_endpoint : io_device
|
|
{
|
|
struct pending_connection
|
|
{
|
|
network::address remote_address;
|
|
std::unique_ptr<network::i_socket> accepted_socket;
|
|
};
|
|
|
|
std::unique_ptr<network::i_socket> s_{};
|
|
|
|
bool executing_delayed_ioctl_{};
|
|
std::optional<afd_creation_data> creation_data{};
|
|
std::optional<bool> require_poll_{};
|
|
std::optional<io_device_context> delayed_ioctl_{};
|
|
std::optional<std::chrono::steady_clock::time_point> timeout_{};
|
|
std::optional<std::function<void(windows_emulator&, const io_device_context&)>> timeout_callback_{};
|
|
|
|
std::unordered_map<LONG, pending_connection> pending_connections_{};
|
|
LONG next_sequence_{0};
|
|
|
|
std::optional<handle> event_select_event_{};
|
|
ULONG event_select_mask_{0};
|
|
ULONG triggered_events_{0};
|
|
|
|
afd_endpoint()
|
|
{
|
|
network::initialize_wsa();
|
|
}
|
|
|
|
afd_endpoint(afd_endpoint&&) = delete;
|
|
afd_endpoint& operator=(afd_endpoint&&) = delete;
|
|
|
|
~afd_endpoint() override = default;
|
|
|
|
void create(windows_emulator& win_emu, const io_device_creation_data& data) override
|
|
{
|
|
this->creation_data = get_creation_data(win_emu, data);
|
|
this->setup(win_emu.socket_factory());
|
|
}
|
|
|
|
void setup(network::socket_factory& factory)
|
|
{
|
|
if (!this->creation_data)
|
|
{
|
|
return;
|
|
}
|
|
|
|
const auto& data = *this->creation_data;
|
|
|
|
const auto af = translate_win_to_host_address_family(data.address_family);
|
|
const auto type = translate_win_to_host_type(data.type);
|
|
const auto protocol = translate_win_to_host_protocol(data.protocol);
|
|
|
|
this->s_ = factory.create_socket(af, type, protocol);
|
|
if (!this->s_)
|
|
{
|
|
throw std::runtime_error("Failed to create socket!");
|
|
}
|
|
|
|
this->s_->set_blocking(false);
|
|
}
|
|
|
|
void delay_ioctrl(const io_device_context& c, const std::optional<bool> require_poll = {},
|
|
const std::optional<std::chrono::steady_clock::time_point> timeout = {},
|
|
const std::optional<std::function<void(windows_emulator&, const io_device_context&)>>&
|
|
timeout_callback = {})
|
|
{
|
|
if (this->executing_delayed_ioctl_)
|
|
{
|
|
return;
|
|
}
|
|
|
|
this->timeout_callback_ = timeout_callback;
|
|
this->timeout_ = timeout;
|
|
this->require_poll_ = require_poll;
|
|
this->delayed_ioctl_ = c;
|
|
}
|
|
|
|
void clear_pending_state()
|
|
{
|
|
this->timeout_callback_ = {};
|
|
this->timeout_ = {};
|
|
this->require_poll_ = {};
|
|
this->delayed_ioctl_ = {};
|
|
}
|
|
|
|
void work(windows_emulator& win_emu) override
|
|
{
|
|
if (!this->s_ || (!this->delayed_ioctl_ && !this->event_select_mask_))
|
|
{
|
|
return;
|
|
}
|
|
|
|
network::poll_entry pfd{};
|
|
pfd.s = this->s_.get();
|
|
|
|
if (this->delayed_ioctl_ && this->require_poll_.has_value())
|
|
{
|
|
pfd.events |= *this->require_poll_ ? POLLIN : POLLOUT;
|
|
}
|
|
if (this->event_select_mask_)
|
|
{
|
|
pfd.events =
|
|
static_cast<int16_t>(pfd.events | map_afd_request_events_to_socket(this->event_select_mask_));
|
|
}
|
|
pfd.revents = pfd.events;
|
|
|
|
if (pfd.events != 0)
|
|
{
|
|
win_emu.socket_factory().poll_sockets(std::span{&pfd, 1});
|
|
}
|
|
|
|
const auto socket_events = pfd.revents;
|
|
|
|
if (socket_events && this->event_select_mask_)
|
|
{
|
|
const bool is_connecting =
|
|
this->delayed_ioctl_ && _AFD_REQUEST(this->delayed_ioctl_->io_control_code) == AFD_CONNECT;
|
|
ULONG current_events = map_socket_response_events_to_afd(socket_events, this->event_select_mask_,
|
|
pfd.s->is_listening(), is_connecting);
|
|
|
|
if ((current_events & ~this->triggered_events_) != 0)
|
|
{
|
|
this->triggered_events_ |= current_events;
|
|
|
|
if (auto* event = win_emu.process.events.get(*this->event_select_event_))
|
|
{
|
|
event->signaled = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (this->delayed_ioctl_)
|
|
{
|
|
this->executing_delayed_ioctl_ = true;
|
|
const auto _ = utils::finally([&] { this->executing_delayed_ioctl_ = false; });
|
|
|
|
if (this->require_poll_.has_value())
|
|
{
|
|
const auto is_ready =
|
|
socket_events & ((*this->require_poll_ ? POLLIN : POLLOUT) | POLLHUP | POLLERR);
|
|
if (!is_ready)
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
|
|
const auto status = this->execute_ioctl(win_emu, *this->delayed_ioctl_);
|
|
if (status == STATUS_PENDING)
|
|
{
|
|
if (!this->timeout_ || this->timeout_ > win_emu.clock().steady_now())
|
|
{
|
|
return;
|
|
}
|
|
|
|
write_io_status(this->delayed_ioctl_->io_status_block, STATUS_TIMEOUT);
|
|
|
|
if (this->timeout_callback_)
|
|
{
|
|
(*this->timeout_callback_)(win_emu, *this->delayed_ioctl_);
|
|
}
|
|
}
|
|
|
|
auto* e = win_emu.process.events.get(this->delayed_ioctl_->event);
|
|
if (e)
|
|
{
|
|
e->signaled = true;
|
|
}
|
|
|
|
this->clear_pending_state();
|
|
}
|
|
}
|
|
|
|
void deserialize_object(utils::buffer_deserializer& buffer) override
|
|
{
|
|
buffer.read_optional(this->creation_data);
|
|
this->setup(buffer.read<socket_factory_wrapper>());
|
|
|
|
buffer.read_optional(this->require_poll_);
|
|
buffer.read_optional(this->delayed_ioctl_);
|
|
buffer.read_optional(this->timeout_);
|
|
}
|
|
|
|
void serialize_object(utils::buffer_serializer& buffer) const override
|
|
{
|
|
buffer.write_optional(this->creation_data);
|
|
buffer.write_optional(this->require_poll_);
|
|
buffer.write_optional(this->delayed_ioctl_);
|
|
buffer.write_optional(this->timeout_);
|
|
}
|
|
|
|
NTSTATUS io_control(windows_emulator& win_emu, const io_device_context& c) override
|
|
{
|
|
if (_AFD_BASE(c.io_control_code) != FSCTL_AFD_BASE)
|
|
{
|
|
win_emu.log.error("Bad AFD IOCTL: 0x%X\n", static_cast<uint32_t>(c.io_control_code));
|
|
return STATUS_NOT_SUPPORTED;
|
|
}
|
|
|
|
const auto request = _AFD_REQUEST(c.io_control_code);
|
|
|
|
switch (request)
|
|
{
|
|
case AFD_BIND:
|
|
return this->ioctl_bind(win_emu, c);
|
|
case AFD_CONNECT:
|
|
return this->ioctl_connect(win_emu, c);
|
|
case AFD_START_LISTEN:
|
|
return this->ioctl_listen(win_emu, c);
|
|
case AFD_WAIT_FOR_LISTEN:
|
|
return this->ioctl_wait_for_listen(win_emu, c);
|
|
case AFD_ACCEPT:
|
|
return this->ioctl_accept(win_emu, c);
|
|
case AFD_SEND:
|
|
return this->ioctl_send(win_emu, c);
|
|
case AFD_RECEIVE:
|
|
return this->ioctl_receive(win_emu, c);
|
|
case AFD_SEND_DATAGRAM:
|
|
return this->ioctl_send_datagram(win_emu, c);
|
|
case AFD_RECEIVE_DATAGRAM:
|
|
return this->ioctl_receive_datagram(win_emu, c);
|
|
case AFD_POLL:
|
|
return this->ioctl_poll(win_emu, c);
|
|
case AFD_GET_ADDRESS:
|
|
return this->ioctl_get_address(win_emu, c);
|
|
case AFD_EVENT_SELECT:
|
|
return this->ioctl_event_select(win_emu, c);
|
|
case AFD_ENUM_NETWORK_EVENTS:
|
|
return this->ioctl_enum_network_events(win_emu, c);
|
|
case AFD_SET_CONTEXT:
|
|
case AFD_GET_INFORMATION:
|
|
case AFD_SET_INFORMATION:
|
|
case AFD_QUERY_HANDLES:
|
|
case AFD_TRANSPORT_IOCTL:
|
|
return STATUS_SUCCESS;
|
|
default:
|
|
win_emu.log.error("Unsupported AFD IOCTL: 0x%X (%u)\n", static_cast<uint32_t>(c.io_control_code),
|
|
static_cast<uint32_t>(request));
|
|
return STATUS_NOT_SUPPORTED;
|
|
}
|
|
}
|
|
|
|
NTSTATUS ioctl_connect(windows_emulator& win_emu, const io_device_context& c)
|
|
{
|
|
if (!this->s_)
|
|
{
|
|
throw std::runtime_error("Invalid AFD endpoint socket!");
|
|
}
|
|
|
|
auto data = win_emu.emu().read_memory(c.input_buffer, c.input_buffer_length);
|
|
|
|
constexpr auto address_offset = 24;
|
|
|
|
if (data.size() < address_offset)
|
|
{
|
|
return STATUS_BUFFER_TOO_SMALL;
|
|
}
|
|
|
|
const auto addr = convert_to_host_address(win_emu, std::span(data).subspan(address_offset));
|
|
|
|
if (!this->s_->connect(addr))
|
|
{
|
|
const auto error = this->s_->get_last_error();
|
|
if (error == SERR(EWOULDBLOCK))
|
|
{
|
|
this->delay_ioctrl(c, false);
|
|
return STATUS_PENDING;
|
|
}
|
|
|
|
if (this->executing_delayed_ioctl_ && error == SERR(EISCONN))
|
|
{
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
return STATUS_UNSUCCESSFUL;
|
|
}
|
|
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
NTSTATUS ioctl_bind(windows_emulator& win_emu, const io_device_context& c) const
|
|
{
|
|
if (!this->s_)
|
|
{
|
|
throw std::runtime_error("Invalid AFD endpoint socket!");
|
|
}
|
|
|
|
auto data = win_emu.emu().read_memory(c.input_buffer, c.input_buffer_length);
|
|
|
|
constexpr auto address_offset = 4;
|
|
|
|
if (data.size() < address_offset)
|
|
{
|
|
return STATUS_BUFFER_TOO_SMALL;
|
|
}
|
|
|
|
const auto addr = convert_to_host_address(win_emu, std::span(data).subspan(address_offset));
|
|
|
|
if (!this->s_->bind(addr))
|
|
{
|
|
return STATUS_ADDRESS_ALREADY_ASSOCIATED;
|
|
}
|
|
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
NTSTATUS ioctl_listen(windows_emulator& win_emu, const io_device_context& c) const
|
|
{
|
|
if (!this->s_)
|
|
{
|
|
throw std::runtime_error("Invalid AFD endpoint socket!");
|
|
}
|
|
|
|
if (c.input_buffer_length < sizeof(AFD_LISTEN_INFO))
|
|
{
|
|
return STATUS_BUFFER_TOO_SMALL;
|
|
}
|
|
|
|
const auto listen_info = win_emu.emu().read_memory<AFD_LISTEN_INFO>(c.input_buffer);
|
|
|
|
if (!this->s_->listen(static_cast<int>(listen_info.MaximumConnectionQueue)))
|
|
{
|
|
return STATUS_INVALID_PARAMETER;
|
|
}
|
|
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
NTSTATUS ioctl_wait_for_listen(windows_emulator& win_emu, const io_device_context& c)
|
|
{
|
|
if (!this->s_)
|
|
{
|
|
throw std::runtime_error("Invalid AFD endpoint socket!");
|
|
}
|
|
|
|
if (c.output_buffer_length < sizeof(AFD_LISTEN_RESPONSE_INFO))
|
|
{
|
|
return STATUS_BUFFER_TOO_SMALL;
|
|
}
|
|
|
|
network::address remote_address{};
|
|
auto accepted_socket_ptr = this->s_->accept(remote_address);
|
|
|
|
if (!accepted_socket_ptr)
|
|
{
|
|
const auto error = this->s_->get_last_error();
|
|
if (error == SERR(EWOULDBLOCK))
|
|
{
|
|
this->delay_ioctrl(c, true);
|
|
return STATUS_PENDING;
|
|
}
|
|
|
|
return STATUS_UNSUCCESSFUL;
|
|
}
|
|
|
|
if (!remote_address.is_ipv4())
|
|
{
|
|
throw std::runtime_error("Unsupported address family");
|
|
}
|
|
|
|
pending_connection pending{};
|
|
pending.remote_address = remote_address;
|
|
pending.accepted_socket = std::move(accepted_socket_ptr);
|
|
|
|
LONG sequence = next_sequence_++;
|
|
pending_connections_.try_emplace(sequence, std::move(pending));
|
|
|
|
AFD_LISTEN_RESPONSE_INFO response{};
|
|
response.Sequence = sequence;
|
|
|
|
auto transport_buffer = convert_to_win_address(win_emu, remote_address);
|
|
memcpy(&response.RemoteAddress, transport_buffer.data(), sizeof(win_sockaddr));
|
|
|
|
win_emu.emu().write_memory<AFD_LISTEN_RESPONSE_INFO>(c.output_buffer, response);
|
|
|
|
if (c.io_status_block)
|
|
{
|
|
IO_STATUS_BLOCK<EmulatorTraits<Emu64>> block{};
|
|
block.Information = sizeof(AFD_LISTEN_RESPONSE_INFO);
|
|
c.io_status_block.write(block);
|
|
}
|
|
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
NTSTATUS ioctl_accept(windows_emulator& win_emu, const io_device_context& c)
|
|
{
|
|
if (!this->s_)
|
|
{
|
|
throw std::runtime_error("Invalid AFD endpoint socket!");
|
|
}
|
|
|
|
if (c.input_buffer_length < sizeof(AFD_ACCEPT_INFO))
|
|
{
|
|
return STATUS_BUFFER_TOO_SMALL;
|
|
}
|
|
|
|
const auto accept_info = win_emu.emu().read_memory<AFD_ACCEPT_INFO>(c.input_buffer);
|
|
|
|
const auto it = pending_connections_.find(accept_info.Sequence);
|
|
if (it == pending_connections_.end())
|
|
{
|
|
return STATUS_INVALID_PARAMETER;
|
|
}
|
|
|
|
auto& accepted_socket = it->second.accepted_socket;
|
|
|
|
auto* target_device = win_emu.process.devices.get(accept_info.AcceptHandle);
|
|
if (!target_device)
|
|
{
|
|
return STATUS_INVALID_HANDLE;
|
|
}
|
|
|
|
auto* target_endpoint = target_device->get_internal_device<afd_endpoint>();
|
|
if (!target_endpoint)
|
|
{
|
|
return STATUS_INVALID_HANDLE;
|
|
}
|
|
|
|
target_endpoint->s_ = std::move(accepted_socket);
|
|
|
|
pending_connections_.erase(it);
|
|
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
NTSTATUS ioctl_receive(windows_emulator& win_emu, const io_device_context& c)
|
|
{
|
|
if (!this->s_)
|
|
{
|
|
throw std::runtime_error("Invalid AFD endpoint socket!");
|
|
}
|
|
|
|
auto& emu = win_emu.emu();
|
|
|
|
if (c.input_buffer_length < sizeof(AFD_RECV_INFO<EmulatorTraits<Emu64>>))
|
|
{
|
|
return STATUS_BUFFER_TOO_SMALL;
|
|
}
|
|
|
|
const auto receive_info = emu.read_memory<AFD_RECV_INFO<EmulatorTraits<Emu64>>>(c.input_buffer);
|
|
|
|
if (!receive_info.BufferArray || receive_info.BufferCount == 0)
|
|
{
|
|
return STATUS_INVALID_PARAMETER;
|
|
}
|
|
|
|
if (receive_info.BufferCount > 1)
|
|
{
|
|
// TODO: Scatter/Gather
|
|
return STATUS_NOT_SUPPORTED;
|
|
}
|
|
|
|
const auto wsabuf = emu.read_memory<EMU_WSABUF<EmulatorTraits<Emu64>>>(receive_info.BufferArray);
|
|
if (!wsabuf.buf || wsabuf.len == 0)
|
|
{
|
|
return STATUS_INVALID_PARAMETER;
|
|
}
|
|
|
|
std::vector<std::byte> host_buffer;
|
|
host_buffer.resize(wsabuf.len);
|
|
|
|
const auto bytes_received = this->s_->recv(host_buffer);
|
|
|
|
if (bytes_received < 0)
|
|
{
|
|
const auto error = this->s_->get_last_error();
|
|
if (error == SERR(EWOULDBLOCK))
|
|
{
|
|
this->delay_ioctrl(c, true);
|
|
return STATUS_PENDING;
|
|
}
|
|
|
|
if (error == SERR(ECONNRESET))
|
|
{
|
|
return STATUS_CONNECTION_RESET;
|
|
}
|
|
|
|
return STATUS_UNSUCCESSFUL;
|
|
}
|
|
|
|
emu.write_memory(wsabuf.buf, host_buffer.data(), static_cast<size_t>(bytes_received));
|
|
|
|
if (c.io_status_block)
|
|
{
|
|
IO_STATUS_BLOCK<EmulatorTraits<Emu64>> block{};
|
|
block.Information = static_cast<uint32_t>(bytes_received);
|
|
c.io_status_block.write(block);
|
|
}
|
|
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
NTSTATUS ioctl_send(windows_emulator& win_emu, const io_device_context& c)
|
|
{
|
|
if (!this->s_)
|
|
{
|
|
throw std::runtime_error("Invalid AFD endpoint socket!");
|
|
}
|
|
|
|
auto& emu = win_emu.emu();
|
|
|
|
if (c.input_buffer_length < sizeof(AFD_SEND_INFO<EmulatorTraits<Emu64>>))
|
|
{
|
|
return STATUS_BUFFER_TOO_SMALL;
|
|
}
|
|
|
|
const auto send_info = emu.read_memory<AFD_SEND_INFO<EmulatorTraits<Emu64>>>(c.input_buffer);
|
|
|
|
if (!send_info.BufferArray || send_info.BufferCount == 0)
|
|
{
|
|
return STATUS_INVALID_PARAMETER;
|
|
}
|
|
|
|
if (send_info.BufferCount > 1)
|
|
{
|
|
// TODO: Scatter/Gather
|
|
return STATUS_NOT_SUPPORTED;
|
|
}
|
|
|
|
const auto wsabuf = emu.read_memory<EMU_WSABUF<EmulatorTraits<Emu64>>>(send_info.BufferArray);
|
|
if (!wsabuf.buf || wsabuf.len == 0)
|
|
{
|
|
return STATUS_INVALID_PARAMETER;
|
|
}
|
|
|
|
std::vector<std::byte> host_buffer;
|
|
host_buffer.resize(wsabuf.len);
|
|
|
|
emu.read_memory(wsabuf.buf, host_buffer.data(), host_buffer.size());
|
|
|
|
const auto bytes_sent = this->s_->send(host_buffer);
|
|
|
|
if (bytes_sent < 0)
|
|
{
|
|
const auto error = this->s_->get_last_error();
|
|
if (error == SERR(EWOULDBLOCK))
|
|
{
|
|
this->delay_ioctrl(c, false);
|
|
return STATUS_PENDING;
|
|
}
|
|
|
|
if (error == SERR(ECONNRESET))
|
|
{
|
|
return STATUS_CONNECTION_RESET;
|
|
}
|
|
|
|
return STATUS_UNSUCCESSFUL;
|
|
}
|
|
|
|
if (c.io_status_block)
|
|
{
|
|
IO_STATUS_BLOCK<EmulatorTraits<Emu64>> block{};
|
|
block.Information = static_cast<uint32_t>(bytes_sent);
|
|
c.io_status_block.write(block);
|
|
}
|
|
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
static std::vector<const afd_endpoint*> resolve_endpoints(windows_emulator& win_emu,
|
|
const std::span<const AFD_POLL_HANDLE_INFO64> handles)
|
|
{
|
|
auto& proc = win_emu.process;
|
|
|
|
std::vector<const afd_endpoint*> endpoints{};
|
|
endpoints.reserve(handles.size());
|
|
|
|
for (const auto& handle : handles)
|
|
{
|
|
auto* device = proc.devices.get(handle.Handle);
|
|
if (!device)
|
|
{
|
|
throw std::runtime_error("Bad device!");
|
|
}
|
|
|
|
const auto* endpoint = device->get_internal_device<afd_endpoint>();
|
|
if (!endpoint || !endpoint->s_)
|
|
{
|
|
throw std::runtime_error("Invalid AFD endpoint!");
|
|
}
|
|
|
|
endpoints.push_back(endpoint);
|
|
}
|
|
|
|
return endpoints;
|
|
}
|
|
|
|
static NTSTATUS perform_poll(windows_emulator& win_emu, const io_device_context& c,
|
|
const std::span<const afd_endpoint* const> endpoints,
|
|
const std::span<const AFD_POLL_HANDLE_INFO64> handles)
|
|
{
|
|
std::vector<network::poll_entry> poll_data{};
|
|
poll_data.resize(endpoints.size());
|
|
|
|
for (size_t i = 0; i < endpoints.size() && i < handles.size(); ++i)
|
|
{
|
|
auto& pfd = poll_data.at(i);
|
|
const auto& handle = handles[i];
|
|
|
|
pfd.s = endpoints[i]->s_.get();
|
|
pfd.events = map_afd_request_events_to_socket(handle.PollEvents);
|
|
pfd.revents = pfd.events;
|
|
}
|
|
|
|
const auto count = win_emu.socket_factory().poll_sockets(poll_data);
|
|
if (count <= 0)
|
|
{
|
|
return STATUS_PENDING;
|
|
}
|
|
|
|
constexpr auto info_size = offsetof(AFD_POLL_INFO64, Handles);
|
|
const emulator_object<AFD_POLL_HANDLE_INFO64> handle_info_obj{win_emu.emu(), c.input_buffer + info_size};
|
|
|
|
size_t current_index = 0;
|
|
|
|
for (size_t i = 0; i < endpoints.size(); ++i)
|
|
{
|
|
const auto& pfd = poll_data.at(i);
|
|
if (pfd.revents == 0)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
const auto& handle = handles[i];
|
|
const auto& endpoint = endpoints[i];
|
|
|
|
const bool is_connecting =
|
|
endpoint->delayed_ioctl_ && _AFD_REQUEST(endpoint->delayed_ioctl_->io_control_code) == AFD_CONNECT;
|
|
|
|
auto entry = handle_info_obj.read(i);
|
|
entry.PollEvents = map_socket_response_events_to_afd(pfd.revents, handle.PollEvents,
|
|
pfd.s->is_listening(), is_connecting);
|
|
entry.Status = STATUS_SUCCESS;
|
|
|
|
handle_info_obj.write(entry, current_index++);
|
|
}
|
|
|
|
assert(current_index == static_cast<size_t>(count));
|
|
|
|
const emulator_object<AFD_POLL_INFO64> info_obj{win_emu.emu(), c.input_buffer};
|
|
info_obj.access([&](AFD_POLL_INFO64& info) {
|
|
info.NumberOfHandles = static_cast<ULONG>(current_index); //
|
|
});
|
|
|
|
if (c.io_status_block)
|
|
{
|
|
IO_STATUS_BLOCK<EmulatorTraits<Emu64>> block{};
|
|
block.Information = info_size + sizeof(AFD_POLL_HANDLE_INFO64) * current_index;
|
|
c.io_status_block.write(block);
|
|
}
|
|
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
NTSTATUS ioctl_poll(windows_emulator& win_emu, const io_device_context& c)
|
|
{
|
|
const auto [info, handles] = get_poll_info(win_emu, c);
|
|
const auto endpoints = resolve_endpoints(win_emu, handles);
|
|
|
|
const auto status = perform_poll(win_emu, c, endpoints, handles);
|
|
if (status != STATUS_PENDING)
|
|
{
|
|
return status;
|
|
}
|
|
|
|
if (!this->executing_delayed_ioctl_)
|
|
{
|
|
const auto timeout_callback = [](windows_emulator& win_emu, const io_device_context& c) {
|
|
const emulator_object<AFD_POLL_INFO64> info_obj{win_emu.emu(), c.input_buffer};
|
|
info_obj.access([&](AFD_POLL_INFO64& poll_info) {
|
|
poll_info.NumberOfHandles = 0; //
|
|
});
|
|
};
|
|
|
|
if (!info.Timeout.QuadPart)
|
|
{
|
|
if (status == STATUS_PENDING)
|
|
{
|
|
timeout_callback(win_emu, c);
|
|
return STATUS_TIMEOUT;
|
|
}
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
std::optional<std::chrono::steady_clock::time_point> timeout{};
|
|
if (info.Timeout.QuadPart != std::numeric_limits<int64_t>::max())
|
|
{
|
|
timeout = utils::convert_delay_interval_to_time_point(win_emu.clock(), info.Timeout);
|
|
}
|
|
|
|
this->delay_ioctrl(c, {}, timeout, timeout_callback);
|
|
}
|
|
|
|
return STATUS_PENDING;
|
|
}
|
|
|
|
NTSTATUS ioctl_receive_datagram(windows_emulator& win_emu, const io_device_context& c)
|
|
{
|
|
if (!this->s_)
|
|
{
|
|
throw std::runtime_error("Invalid AFD endpoint socket!");
|
|
}
|
|
|
|
auto& emu = win_emu.emu();
|
|
|
|
if (c.input_buffer_length < sizeof(AFD_RECV_DATAGRAM_INFO<EmulatorTraits<Emu64>>))
|
|
{
|
|
return STATUS_BUFFER_TOO_SMALL;
|
|
}
|
|
|
|
const auto receive_info = emu.read_memory<AFD_RECV_DATAGRAM_INFO<EmulatorTraits<Emu64>>>(c.input_buffer);
|
|
const auto buffer = emu.read_memory<EMU_WSABUF<EmulatorTraits<Emu64>>>(receive_info.BufferArray);
|
|
|
|
if (!buffer.len || buffer.len > 0x10000 || !buffer.buf)
|
|
{
|
|
return STATUS_INVALID_PARAMETER;
|
|
}
|
|
|
|
network::address from{};
|
|
std::vector<std::byte> data{};
|
|
data.resize(buffer.len);
|
|
|
|
const auto recevied_data = this->s_->recvfrom(from, data);
|
|
|
|
if (recevied_data < 0)
|
|
{
|
|
const auto error = this->s_->get_last_error();
|
|
if (error == SERR(EWOULDBLOCK))
|
|
{
|
|
this->delay_ioctrl(c, true);
|
|
return STATUS_PENDING;
|
|
}
|
|
|
|
return STATUS_UNSUCCESSFUL;
|
|
}
|
|
|
|
const auto data_size = std::min(data.size(), static_cast<size_t>(recevied_data));
|
|
emu.write_memory(buffer.buf, data.data(), data_size);
|
|
|
|
const auto win_from = convert_to_win_address(win_emu, from);
|
|
|
|
if (receive_info.Address && receive_info.AddressLength)
|
|
{
|
|
const emulator_object<ULONG> address_length{emu, receive_info.AddressLength};
|
|
const auto address_size = std::min(win_from.size(), static_cast<size_t>(address_length.read()));
|
|
|
|
emu.write_memory(receive_info.Address, win_from.data(), address_size);
|
|
address_length.write(static_cast<ULONG>(address_size));
|
|
}
|
|
|
|
if (c.io_status_block)
|
|
{
|
|
IO_STATUS_BLOCK<EmulatorTraits<Emu64>> block{};
|
|
block.Information = static_cast<uint32_t>(recevied_data);
|
|
c.io_status_block.write(block);
|
|
}
|
|
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
NTSTATUS ioctl_send_datagram(windows_emulator& win_emu, const io_device_context& c)
|
|
{
|
|
if (!this->s_)
|
|
{
|
|
throw std::runtime_error("Invalid AFD endpoint socket!");
|
|
}
|
|
|
|
const auto& emu = win_emu.emu();
|
|
|
|
if (c.input_buffer_length < sizeof(AFD_SEND_DATAGRAM_INFO<EmulatorTraits<Emu64>>))
|
|
{
|
|
return STATUS_BUFFER_TOO_SMALL;
|
|
}
|
|
|
|
const auto send_info = emu.read_memory<AFD_SEND_DATAGRAM_INFO<EmulatorTraits<Emu64>>>(c.input_buffer);
|
|
const auto buffer = emu.read_memory<EMU_WSABUF<EmulatorTraits<Emu64>>>(send_info.BufferArray);
|
|
|
|
auto address_buffer = emu.read_memory(send_info.TdiConnInfo.RemoteAddress,
|
|
static_cast<size_t>(send_info.TdiConnInfo.RemoteAddressLength));
|
|
|
|
const auto target = convert_to_host_address(win_emu, address_buffer);
|
|
const auto data = emu.read_memory(buffer.buf, buffer.len);
|
|
|
|
const auto sent_data = this->s_->sendto(target, data);
|
|
if (sent_data < 0)
|
|
{
|
|
const auto error = this->s_->get_last_error();
|
|
if (error == SERR(EWOULDBLOCK))
|
|
{
|
|
this->delay_ioctrl(c, false);
|
|
return STATUS_PENDING;
|
|
}
|
|
|
|
return STATUS_UNSUCCESSFUL;
|
|
}
|
|
|
|
if (c.io_status_block)
|
|
{
|
|
IO_STATUS_BLOCK<EmulatorTraits<Emu64>> block{};
|
|
block.Information = static_cast<uint32_t>(sent_data);
|
|
c.io_status_block.write(block);
|
|
}
|
|
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
NTSTATUS ioctl_get_address(windows_emulator& win_emu, const io_device_context& c) const
|
|
{
|
|
if (!this->s_)
|
|
{
|
|
throw std::runtime_error("Invalid AFD endpoint socket!");
|
|
}
|
|
|
|
const auto local_address = this->s_->get_local_address();
|
|
if (!local_address)
|
|
{
|
|
return STATUS_INVALID_PARAMETER;
|
|
}
|
|
|
|
std::vector<std::byte> win_addr_bytes = convert_to_win_address(win_emu, *local_address);
|
|
|
|
if (c.output_buffer_length < win_addr_bytes.size())
|
|
{
|
|
return STATUS_BUFFER_TOO_SMALL;
|
|
}
|
|
|
|
win_emu.emu().write_memory(c.output_buffer, win_addr_bytes.data(), win_addr_bytes.size());
|
|
|
|
if (c.io_status_block)
|
|
{
|
|
IO_STATUS_BLOCK<EmulatorTraits<Emu64>> block{};
|
|
block.Information = static_cast<ULONG>(win_addr_bytes.size());
|
|
c.io_status_block.write(block);
|
|
}
|
|
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
NTSTATUS ioctl_event_select(windows_emulator& win_emu, const io_device_context& c)
|
|
{
|
|
if (!this->s_)
|
|
{
|
|
throw std::runtime_error("Invalid AFD endpoint socket!");
|
|
}
|
|
|
|
if (c.input_buffer_length < sizeof(AFD_EVENT_SELECT_INFO))
|
|
{
|
|
return STATUS_BUFFER_TOO_SMALL;
|
|
}
|
|
|
|
const auto select_info = win_emu.emu().read_memory<AFD_EVENT_SELECT_INFO>(c.input_buffer);
|
|
|
|
this->event_select_event_ = select_info.Event;
|
|
this->event_select_mask_ = select_info.PollEvents;
|
|
this->triggered_events_ = 0;
|
|
|
|
if (auto* event = win_emu.process.events.get(select_info.Event))
|
|
{
|
|
event->signaled = false;
|
|
}
|
|
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
NTSTATUS ioctl_enum_network_events(windows_emulator& win_emu, const io_device_context& c)
|
|
{
|
|
if (!this->s_)
|
|
{
|
|
throw std::runtime_error("Invalid AFD endpoint socket!");
|
|
}
|
|
|
|
if (c.output_buffer_length < 56)
|
|
{
|
|
return STATUS_BUFFER_TOO_SMALL;
|
|
}
|
|
|
|
if (c.input_buffer)
|
|
{
|
|
if (c.input_buffer_length == 0)
|
|
{
|
|
handle h{};
|
|
h.bits = c.input_buffer;
|
|
|
|
if (auto* event = win_emu.process.events.get(h))
|
|
{
|
|
event->signaled = false;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return STATUS_NOT_SUPPORTED;
|
|
}
|
|
}
|
|
|
|
win_emu.emu().write_memory(c.output_buffer, this->triggered_events_);
|
|
this->triggered_events_ = 0;
|
|
|
|
if (c.io_status_block)
|
|
{
|
|
IO_STATUS_BLOCK<EmulatorTraits<Emu64>> block{};
|
|
block.Information = 56;
|
|
c.io_status_block.write(block);
|
|
}
|
|
|
|
return STATUS_SUCCESS;
|
|
}
|
|
};
|
|
|
|
struct afd_async_connect_hlp : stateless_device
|
|
{
|
|
NTSTATUS io_control(windows_emulator& win_emu, const io_device_context& c) override
|
|
{
|
|
if (c.io_control_code != 0x12007)
|
|
{
|
|
return STATUS_NOT_SUPPORTED;
|
|
}
|
|
|
|
if (c.input_buffer_length < 40)
|
|
{
|
|
return STATUS_BUFFER_TOO_SMALL;
|
|
}
|
|
|
|
const auto target_handle = win_emu.emu().read_memory<handle>(c.input_buffer + 16);
|
|
|
|
auto* target_device = win_emu.process.devices.get(target_handle);
|
|
if (!target_device)
|
|
{
|
|
return STATUS_INVALID_HANDLE;
|
|
}
|
|
|
|
auto* target_endpoint = target_device->get_internal_device<afd_endpoint>();
|
|
if (!target_endpoint)
|
|
{
|
|
return STATUS_INVALID_HANDLE;
|
|
}
|
|
|
|
return target_endpoint->execute_ioctl(win_emu, c);
|
|
}
|
|
};
|
|
}
|
|
|
|
std::unique_ptr<io_device> create_afd_endpoint()
|
|
{
|
|
return std::make_unique<afd_endpoint>();
|
|
}
|
|
|
|
std::unique_ptr<io_device> create_afd_async_connect_hlp()
|
|
{
|
|
return std::make_unique<afd_async_connect_hlp>();
|
|
}
|