746 lines
26 KiB
C++
746 lines
26 KiB
C++
// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
|
|
// SPDX-License-Identifier: GPL-2.0-or-later
|
|
|
|
#include <memory>
|
|
|
|
#include "core/core.h"
|
|
#include "core/hle/service/ldn/lan_discovery.h"
|
|
#include "core/hle/service/ldn/ldn.h"
|
|
#include "core/hle/service/ldn/ldn_results.h"
|
|
#include "core/hle/service/ldn/ldn_types.h"
|
|
#include "core/hle/service/server_manager.h"
|
|
#include "core/internal_network/network.h"
|
|
#include "core/internal_network/network_interface.h"
|
|
#include "network/network.h"
|
|
|
|
// This is defined by synchapi.h and conflicts with ServiceContext::CreateEvent
|
|
#undef CreateEvent
|
|
|
|
namespace Service::LDN {
|
|
|
|
class IMonitorService final : public ServiceFramework<IMonitorService> {
|
|
public:
|
|
explicit IMonitorService(Core::System& system_) : ServiceFramework{system_, "IMonitorService"} {
|
|
// clang-format off
|
|
static const FunctionInfo functions[] = {
|
|
{0, nullptr, "GetStateForMonitor"},
|
|
{1, nullptr, "GetNetworkInfoForMonitor"},
|
|
{2, nullptr, "GetIpv4AddressForMonitor"},
|
|
{3, nullptr, "GetDisconnectReasonForMonitor"},
|
|
{4, nullptr, "GetSecurityParameterForMonitor"},
|
|
{5, nullptr, "GetNetworkConfigForMonitor"},
|
|
{100, nullptr, "InitializeMonitor"},
|
|
{101, nullptr, "FinalizeMonitor"},
|
|
};
|
|
// clang-format on
|
|
|
|
RegisterHandlers(functions);
|
|
}
|
|
};
|
|
|
|
class LDNM final : public ServiceFramework<LDNM> {
|
|
public:
|
|
explicit LDNM(Core::System& system_) : ServiceFramework{system_, "ldn:m"} {
|
|
// clang-format off
|
|
static const FunctionInfo functions[] = {
|
|
{0, &LDNM::CreateMonitorService, "CreateMonitorService"}
|
|
};
|
|
// clang-format on
|
|
|
|
RegisterHandlers(functions);
|
|
}
|
|
|
|
void CreateMonitorService(HLERequestContext& ctx) {
|
|
LOG_DEBUG(Service_LDN, "called");
|
|
|
|
IPC::ResponseBuilder rb{ctx, 2, 0, 1};
|
|
rb.Push(ResultSuccess);
|
|
rb.PushIpcInterface<IMonitorService>(system);
|
|
}
|
|
};
|
|
|
|
class ISystemLocalCommunicationService final
|
|
: public ServiceFramework<ISystemLocalCommunicationService> {
|
|
public:
|
|
explicit ISystemLocalCommunicationService(Core::System& system_)
|
|
: ServiceFramework{system_, "ISystemLocalCommunicationService"} {
|
|
// clang-format off
|
|
static const FunctionInfo functions[] = {
|
|
{0, nullptr, "GetState"},
|
|
{1, nullptr, "GetNetworkInfo"},
|
|
{2, nullptr, "GetIpv4Address"},
|
|
{3, nullptr, "GetDisconnectReason"},
|
|
{4, nullptr, "GetSecurityParameter"},
|
|
{5, nullptr, "GetNetworkConfig"},
|
|
{100, nullptr, "AttachStateChangeEvent"},
|
|
{101, nullptr, "GetNetworkInfoLatestUpdate"},
|
|
{102, nullptr, "Scan"},
|
|
{103, nullptr, "ScanPrivate"},
|
|
{104, nullptr, "SetWirelessControllerRestriction"},
|
|
{200, nullptr, "OpenAccessPoint"},
|
|
{201, nullptr, "CloseAccessPoint"},
|
|
{202, nullptr, "CreateNetwork"},
|
|
{203, nullptr, "CreateNetworkPrivate"},
|
|
{204, nullptr, "DestroyNetwork"},
|
|
{205, nullptr, "Reject"},
|
|
{206, nullptr, "SetAdvertiseData"},
|
|
{207, nullptr, "SetStationAcceptPolicy"},
|
|
{208, nullptr, "AddAcceptFilterEntry"},
|
|
{209, nullptr, "ClearAcceptFilter"},
|
|
{300, nullptr, "OpenStation"},
|
|
{301, nullptr, "CloseStation"},
|
|
{302, nullptr, "Connect"},
|
|
{303, nullptr, "ConnectPrivate"},
|
|
{304, nullptr, "Disconnect"},
|
|
{400, nullptr, "InitializeSystem"},
|
|
{401, nullptr, "FinalizeSystem"},
|
|
{402, nullptr, "SetOperationMode"},
|
|
{403, nullptr, "InitializeSystem2"},
|
|
};
|
|
// clang-format on
|
|
|
|
RegisterHandlers(functions);
|
|
}
|
|
};
|
|
|
|
class IUserLocalCommunicationService final
|
|
: public ServiceFramework<IUserLocalCommunicationService> {
|
|
public:
|
|
explicit IUserLocalCommunicationService(Core::System& system_)
|
|
: ServiceFramework{system_, "IUserLocalCommunicationService"},
|
|
service_context{system, "IUserLocalCommunicationService"},
|
|
room_network{system_.GetRoomNetwork()}, lan_discovery{room_network} {
|
|
// clang-format off
|
|
static const FunctionInfo functions[] = {
|
|
{0, &IUserLocalCommunicationService::GetState, "GetState"},
|
|
{1, &IUserLocalCommunicationService::GetNetworkInfo, "GetNetworkInfo"},
|
|
{2, &IUserLocalCommunicationService::GetIpv4Address, "GetIpv4Address"},
|
|
{3, &IUserLocalCommunicationService::GetDisconnectReason, "GetDisconnectReason"},
|
|
{4, &IUserLocalCommunicationService::GetSecurityParameter, "GetSecurityParameter"},
|
|
{5, &IUserLocalCommunicationService::GetNetworkConfig, "GetNetworkConfig"},
|
|
{100, &IUserLocalCommunicationService::AttachStateChangeEvent, "AttachStateChangeEvent"},
|
|
{101, &IUserLocalCommunicationService::GetNetworkInfoLatestUpdate, "GetNetworkInfoLatestUpdate"},
|
|
{102, &IUserLocalCommunicationService::Scan, "Scan"},
|
|
{103, &IUserLocalCommunicationService::ScanPrivate, "ScanPrivate"},
|
|
{104, &IUserLocalCommunicationService::SetWirelessControllerRestriction, "SetWirelessControllerRestriction"},
|
|
{200, &IUserLocalCommunicationService::OpenAccessPoint, "OpenAccessPoint"},
|
|
{201, &IUserLocalCommunicationService::CloseAccessPoint, "CloseAccessPoint"},
|
|
{202, &IUserLocalCommunicationService::CreateNetwork, "CreateNetwork"},
|
|
{203, &IUserLocalCommunicationService::CreateNetworkPrivate, "CreateNetworkPrivate"},
|
|
{204, &IUserLocalCommunicationService::DestroyNetwork, "DestroyNetwork"},
|
|
{205, nullptr, "Reject"},
|
|
{206, &IUserLocalCommunicationService::SetAdvertiseData, "SetAdvertiseData"},
|
|
{207, &IUserLocalCommunicationService::SetStationAcceptPolicy, "SetStationAcceptPolicy"},
|
|
{208, &IUserLocalCommunicationService::AddAcceptFilterEntry, "AddAcceptFilterEntry"},
|
|
{209, nullptr, "ClearAcceptFilter"},
|
|
{300, &IUserLocalCommunicationService::OpenStation, "OpenStation"},
|
|
{301, &IUserLocalCommunicationService::CloseStation, "CloseStation"},
|
|
{302, &IUserLocalCommunicationService::Connect, "Connect"},
|
|
{303, nullptr, "ConnectPrivate"},
|
|
{304, &IUserLocalCommunicationService::Disconnect, "Disconnect"},
|
|
{400, &IUserLocalCommunicationService::Initialize, "Initialize"},
|
|
{401, &IUserLocalCommunicationService::Finalize, "Finalize"},
|
|
{402, &IUserLocalCommunicationService::Initialize2, "Initialize2"},
|
|
};
|
|
// clang-format on
|
|
|
|
RegisterHandlers(functions);
|
|
|
|
state_change_event =
|
|
service_context.CreateEvent("IUserLocalCommunicationService:StateChangeEvent");
|
|
}
|
|
|
|
~IUserLocalCommunicationService() {
|
|
if (is_initialized) {
|
|
if (auto room_member = room_network.GetRoomMember().lock()) {
|
|
room_member->Unbind(ldn_packet_received);
|
|
}
|
|
}
|
|
|
|
service_context.CloseEvent(state_change_event);
|
|
}
|
|
|
|
/// Callback to parse and handle a received LDN packet.
|
|
void OnLDNPacketReceived(const Network::LDNPacket& packet) {
|
|
lan_discovery.ReceivePacket(packet);
|
|
}
|
|
|
|
void OnEventFired() {
|
|
state_change_event->Signal();
|
|
}
|
|
|
|
void GetState(HLERequestContext& ctx) {
|
|
State state = State::Error;
|
|
|
|
if (is_initialized) {
|
|
state = lan_discovery.GetState();
|
|
}
|
|
|
|
IPC::ResponseBuilder rb{ctx, 3};
|
|
rb.Push(ResultSuccess);
|
|
rb.PushEnum(state);
|
|
}
|
|
|
|
void GetNetworkInfo(HLERequestContext& ctx) {
|
|
const auto write_buffer_size = ctx.GetWriteBufferSize();
|
|
|
|
if (write_buffer_size != sizeof(NetworkInfo)) {
|
|
LOG_ERROR(Service_LDN, "Invalid buffer size {}", write_buffer_size);
|
|
IPC::ResponseBuilder rb{ctx, 2};
|
|
rb.Push(ResultBadInput);
|
|
return;
|
|
}
|
|
|
|
NetworkInfo network_info{};
|
|
const auto rc = lan_discovery.GetNetworkInfo(network_info);
|
|
if (rc.IsError()) {
|
|
LOG_ERROR(Service_LDN, "NetworkInfo is not valid {}", rc.raw);
|
|
IPC::ResponseBuilder rb{ctx, 2};
|
|
rb.Push(rc);
|
|
return;
|
|
}
|
|
|
|
ctx.WriteBuffer<NetworkInfo>(network_info);
|
|
IPC::ResponseBuilder rb{ctx, 2};
|
|
rb.Push(ResultSuccess);
|
|
}
|
|
|
|
void GetIpv4Address(HLERequestContext& ctx) {
|
|
const auto network_interface = Network::GetSelectedNetworkInterface();
|
|
|
|
if (!network_interface) {
|
|
LOG_ERROR(Service_LDN, "No network interface available");
|
|
IPC::ResponseBuilder rb{ctx, 2};
|
|
rb.Push(ResultNoIpAddress);
|
|
return;
|
|
}
|
|
|
|
Ipv4Address current_address{Network::TranslateIPv4(network_interface->ip_address)};
|
|
Ipv4Address subnet_mask{Network::TranslateIPv4(network_interface->subnet_mask)};
|
|
|
|
// When we're connected to a room, spoof the hosts IP address
|
|
if (auto room_member = room_network.GetRoomMember().lock()) {
|
|
if (room_member->IsConnected()) {
|
|
current_address = room_member->GetFakeIpAddress();
|
|
}
|
|
}
|
|
|
|
std::reverse(std::begin(current_address), std::end(current_address)); // ntohl
|
|
std::reverse(std::begin(subnet_mask), std::end(subnet_mask)); // ntohl
|
|
|
|
IPC::ResponseBuilder rb{ctx, 4};
|
|
rb.Push(ResultSuccess);
|
|
rb.PushRaw(current_address);
|
|
rb.PushRaw(subnet_mask);
|
|
}
|
|
|
|
void GetDisconnectReason(HLERequestContext& ctx) {
|
|
IPC::ResponseBuilder rb{ctx, 3};
|
|
rb.Push(ResultSuccess);
|
|
rb.PushEnum(lan_discovery.GetDisconnectReason());
|
|
}
|
|
|
|
void GetSecurityParameter(HLERequestContext& ctx) {
|
|
SecurityParameter security_parameter{};
|
|
NetworkInfo info{};
|
|
const Result rc = lan_discovery.GetNetworkInfo(info);
|
|
|
|
if (rc.IsError()) {
|
|
LOG_ERROR(Service_LDN, "NetworkInfo is not valid {}", rc.raw);
|
|
IPC::ResponseBuilder rb{ctx, 2};
|
|
rb.Push(rc);
|
|
return;
|
|
}
|
|
|
|
security_parameter.session_id = info.network_id.session_id;
|
|
std::memcpy(security_parameter.data.data(), info.ldn.security_parameter.data(),
|
|
sizeof(SecurityParameter::data));
|
|
|
|
IPC::ResponseBuilder rb{ctx, 10};
|
|
rb.Push(rc);
|
|
rb.PushRaw<SecurityParameter>(security_parameter);
|
|
}
|
|
|
|
void GetNetworkConfig(HLERequestContext& ctx) {
|
|
NetworkConfig config{};
|
|
NetworkInfo info{};
|
|
const Result rc = lan_discovery.GetNetworkInfo(info);
|
|
|
|
if (rc.IsError()) {
|
|
LOG_ERROR(Service_LDN, "NetworkConfig is not valid {}", rc.raw);
|
|
IPC::ResponseBuilder rb{ctx, 2};
|
|
rb.Push(rc);
|
|
return;
|
|
}
|
|
|
|
config.intent_id = info.network_id.intent_id;
|
|
config.channel = info.common.channel;
|
|
config.node_count_max = info.ldn.node_count_max;
|
|
config.local_communication_version = info.ldn.nodes[0].local_communication_version;
|
|
|
|
IPC::ResponseBuilder rb{ctx, 10};
|
|
rb.Push(rc);
|
|
rb.PushRaw<NetworkConfig>(config);
|
|
}
|
|
|
|
void AttachStateChangeEvent(HLERequestContext& ctx) {
|
|
LOG_INFO(Service_LDN, "called");
|
|
|
|
IPC::ResponseBuilder rb{ctx, 2, 1};
|
|
rb.Push(ResultSuccess);
|
|
rb.PushCopyObjects(state_change_event->GetReadableEvent());
|
|
}
|
|
|
|
void GetNetworkInfoLatestUpdate(HLERequestContext& ctx) {
|
|
const std::size_t network_buffer_size = ctx.GetWriteBufferSize(0);
|
|
const std::size_t node_buffer_count = ctx.GetWriteBufferNumElements<NodeLatestUpdate>(1);
|
|
|
|
if (node_buffer_count == 0 || network_buffer_size != sizeof(NetworkInfo)) {
|
|
LOG_ERROR(Service_LDN, "Invalid buffer, size = {}, count = {}", network_buffer_size,
|
|
node_buffer_count);
|
|
IPC::ResponseBuilder rb{ctx, 2};
|
|
rb.Push(ResultBadInput);
|
|
return;
|
|
}
|
|
|
|
NetworkInfo info{};
|
|
std::vector<NodeLatestUpdate> latest_update(node_buffer_count);
|
|
|
|
const auto rc = lan_discovery.GetNetworkInfo(info, latest_update, latest_update.size());
|
|
if (rc.IsError()) {
|
|
LOG_ERROR(Service_LDN, "NetworkInfo is not valid {}", rc.raw);
|
|
IPC::ResponseBuilder rb{ctx, 2};
|
|
rb.Push(rc);
|
|
return;
|
|
}
|
|
|
|
ctx.WriteBuffer(info, 0);
|
|
ctx.WriteBuffer(latest_update, 1);
|
|
|
|
IPC::ResponseBuilder rb{ctx, 2};
|
|
rb.Push(ResultSuccess);
|
|
}
|
|
|
|
void Scan(HLERequestContext& ctx) {
|
|
ScanImpl(ctx);
|
|
}
|
|
|
|
void ScanPrivate(HLERequestContext& ctx) {
|
|
ScanImpl(ctx, true);
|
|
}
|
|
|
|
void ScanImpl(HLERequestContext& ctx, bool is_private = false) {
|
|
IPC::RequestParser rp{ctx};
|
|
const auto channel{rp.PopEnum<WifiChannel>()};
|
|
const auto scan_filter{rp.PopRaw<ScanFilter>()};
|
|
|
|
const std::size_t network_info_size = ctx.GetWriteBufferNumElements<NetworkInfo>();
|
|
|
|
if (network_info_size == 0) {
|
|
LOG_ERROR(Service_LDN, "Invalid buffer size {}", network_info_size);
|
|
IPC::ResponseBuilder rb{ctx, 2};
|
|
rb.Push(ResultBadInput);
|
|
return;
|
|
}
|
|
|
|
u16 count = 0;
|
|
std::vector<NetworkInfo> network_infos(network_info_size);
|
|
Result rc = lan_discovery.Scan(network_infos, count, scan_filter);
|
|
|
|
LOG_INFO(Service_LDN,
|
|
"called, channel={}, filter_scan_flag={}, filter_network_type={}, is_private={}",
|
|
channel, scan_filter.flag, scan_filter.network_type, is_private);
|
|
|
|
ctx.WriteBuffer(network_infos);
|
|
|
|
IPC::ResponseBuilder rb{ctx, 3};
|
|
rb.Push(rc);
|
|
rb.Push<u32>(count);
|
|
}
|
|
|
|
void SetWirelessControllerRestriction(HLERequestContext& ctx) {
|
|
LOG_WARNING(Service_LDN, "(STUBBED) called");
|
|
|
|
IPC::ResponseBuilder rb{ctx, 2};
|
|
rb.Push(ResultSuccess);
|
|
}
|
|
|
|
void OpenAccessPoint(HLERequestContext& ctx) {
|
|
LOG_INFO(Service_LDN, "called");
|
|
|
|
IPC::ResponseBuilder rb{ctx, 2};
|
|
rb.Push(lan_discovery.OpenAccessPoint());
|
|
}
|
|
|
|
void CloseAccessPoint(HLERequestContext& ctx) {
|
|
LOG_INFO(Service_LDN, "called");
|
|
|
|
IPC::ResponseBuilder rb{ctx, 2};
|
|
rb.Push(lan_discovery.CloseAccessPoint());
|
|
}
|
|
|
|
void CreateNetwork(HLERequestContext& ctx) {
|
|
LOG_INFO(Service_LDN, "called");
|
|
|
|
CreateNetworkImpl(ctx);
|
|
}
|
|
|
|
void CreateNetworkPrivate(HLERequestContext& ctx) {
|
|
LOG_INFO(Service_LDN, "called");
|
|
|
|
CreateNetworkImpl(ctx, true);
|
|
}
|
|
|
|
void CreateNetworkImpl(HLERequestContext& ctx, bool is_private = false) {
|
|
IPC::RequestParser rp{ctx};
|
|
|
|
const auto security_config{rp.PopRaw<SecurityConfig>()};
|
|
[[maybe_unused]] const auto security_parameter{is_private ? rp.PopRaw<SecurityParameter>()
|
|
: SecurityParameter{}};
|
|
const auto user_config{rp.PopRaw<UserConfig>()};
|
|
rp.Pop<u32>(); // Padding
|
|
const auto network_Config{rp.PopRaw<NetworkConfig>()};
|
|
|
|
IPC::ResponseBuilder rb{ctx, 2};
|
|
rb.Push(lan_discovery.CreateNetwork(security_config, user_config, network_Config));
|
|
}
|
|
|
|
void DestroyNetwork(HLERequestContext& ctx) {
|
|
LOG_INFO(Service_LDN, "called");
|
|
|
|
IPC::ResponseBuilder rb{ctx, 2};
|
|
rb.Push(lan_discovery.DestroyNetwork());
|
|
}
|
|
|
|
void SetAdvertiseData(HLERequestContext& ctx) {
|
|
const auto read_buffer = ctx.ReadBuffer();
|
|
|
|
IPC::ResponseBuilder rb{ctx, 2};
|
|
rb.Push(lan_discovery.SetAdvertiseData(read_buffer));
|
|
}
|
|
|
|
void SetStationAcceptPolicy(HLERequestContext& ctx) {
|
|
LOG_WARNING(Service_LDN, "(STUBBED) called");
|
|
|
|
IPC::ResponseBuilder rb{ctx, 2};
|
|
rb.Push(ResultSuccess);
|
|
}
|
|
|
|
void AddAcceptFilterEntry(HLERequestContext& ctx) {
|
|
LOG_WARNING(Service_LDN, "(STUBBED) called");
|
|
|
|
IPC::ResponseBuilder rb{ctx, 2};
|
|
rb.Push(ResultSuccess);
|
|
}
|
|
|
|
void OpenStation(HLERequestContext& ctx) {
|
|
LOG_INFO(Service_LDN, "called");
|
|
|
|
IPC::ResponseBuilder rb{ctx, 2};
|
|
rb.Push(lan_discovery.OpenStation());
|
|
}
|
|
|
|
void CloseStation(HLERequestContext& ctx) {
|
|
LOG_INFO(Service_LDN, "called");
|
|
|
|
IPC::ResponseBuilder rb{ctx, 2};
|
|
rb.Push(lan_discovery.CloseStation());
|
|
}
|
|
|
|
void Connect(HLERequestContext& ctx) {
|
|
IPC::RequestParser rp{ctx};
|
|
struct Parameters {
|
|
SecurityConfig security_config;
|
|
UserConfig user_config;
|
|
u32 local_communication_version;
|
|
u32 option;
|
|
};
|
|
static_assert(sizeof(Parameters) == 0x7C, "Parameters has incorrect size.");
|
|
|
|
const auto parameters{rp.PopRaw<Parameters>()};
|
|
|
|
LOG_INFO(Service_LDN,
|
|
"called, passphrase_size={}, security_mode={}, "
|
|
"local_communication_version={}",
|
|
parameters.security_config.passphrase_size,
|
|
parameters.security_config.security_mode, parameters.local_communication_version);
|
|
|
|
const auto read_buffer = ctx.ReadBuffer();
|
|
if (read_buffer.size() != sizeof(NetworkInfo)) {
|
|
LOG_ERROR(Frontend, "NetworkInfo doesn't match read_buffer size!");
|
|
IPC::ResponseBuilder rb{ctx, 2};
|
|
rb.Push(ResultBadInput);
|
|
return;
|
|
}
|
|
|
|
NetworkInfo network_info{};
|
|
std::memcpy(&network_info, read_buffer.data(), read_buffer.size());
|
|
|
|
IPC::ResponseBuilder rb{ctx, 2};
|
|
rb.Push(lan_discovery.Connect(network_info, parameters.user_config,
|
|
static_cast<u16>(parameters.local_communication_version)));
|
|
}
|
|
|
|
void Disconnect(HLERequestContext& ctx) {
|
|
LOG_INFO(Service_LDN, "called");
|
|
|
|
IPC::ResponseBuilder rb{ctx, 2};
|
|
rb.Push(lan_discovery.Disconnect());
|
|
}
|
|
|
|
void Initialize(HLERequestContext& ctx) {
|
|
const auto rc = InitializeImpl(ctx);
|
|
if (rc.IsError()) {
|
|
LOG_ERROR(Service_LDN, "Network isn't initialized, rc={}", rc.raw);
|
|
}
|
|
|
|
IPC::ResponseBuilder rb{ctx, 2};
|
|
rb.Push(rc);
|
|
}
|
|
|
|
void Finalize(HLERequestContext& ctx) {
|
|
if (auto room_member = room_network.GetRoomMember().lock()) {
|
|
room_member->Unbind(ldn_packet_received);
|
|
}
|
|
|
|
is_initialized = false;
|
|
|
|
IPC::ResponseBuilder rb{ctx, 2};
|
|
rb.Push(lan_discovery.Finalize());
|
|
}
|
|
|
|
void Initialize2(HLERequestContext& ctx) {
|
|
const auto rc = InitializeImpl(ctx);
|
|
if (rc.IsError()) {
|
|
LOG_ERROR(Service_LDN, "Network isn't initialized, rc={}", rc.raw);
|
|
}
|
|
|
|
IPC::ResponseBuilder rb{ctx, 2};
|
|
rb.Push(rc);
|
|
}
|
|
|
|
Result InitializeImpl(HLERequestContext& ctx) {
|
|
const auto network_interface = Network::GetSelectedNetworkInterface();
|
|
if (!network_interface) {
|
|
LOG_ERROR(Service_LDN, "No network interface is set");
|
|
return ResultAirplaneModeEnabled;
|
|
}
|
|
|
|
if (auto room_member = room_network.GetRoomMember().lock()) {
|
|
ldn_packet_received = room_member->BindOnLdnPacketReceived(
|
|
[this](const Network::LDNPacket& packet) { OnLDNPacketReceived(packet); });
|
|
} else {
|
|
LOG_ERROR(Service_LDN, "Couldn't bind callback!");
|
|
return ResultAirplaneModeEnabled;
|
|
}
|
|
|
|
lan_discovery.Initialize([&]() { OnEventFired(); });
|
|
is_initialized = true;
|
|
return ResultSuccess;
|
|
}
|
|
|
|
KernelHelpers::ServiceContext service_context;
|
|
Kernel::KEvent* state_change_event;
|
|
Network::RoomNetwork& room_network;
|
|
LANDiscovery lan_discovery;
|
|
|
|
// Callback identifier for the OnLDNPacketReceived event.
|
|
Network::RoomMember::CallbackHandle<Network::LDNPacket> ldn_packet_received;
|
|
|
|
bool is_initialized{};
|
|
};
|
|
|
|
class LDNS final : public ServiceFramework<LDNS> {
|
|
public:
|
|
explicit LDNS(Core::System& system_) : ServiceFramework{system_, "ldn:s"} {
|
|
// clang-format off
|
|
static const FunctionInfo functions[] = {
|
|
{0, &LDNS::CreateSystemLocalCommunicationService, "CreateSystemLocalCommunicationService"},
|
|
};
|
|
// clang-format on
|
|
|
|
RegisterHandlers(functions);
|
|
}
|
|
|
|
void CreateSystemLocalCommunicationService(HLERequestContext& ctx) {
|
|
LOG_DEBUG(Service_LDN, "called");
|
|
|
|
IPC::ResponseBuilder rb{ctx, 2, 0, 1};
|
|
rb.Push(ResultSuccess);
|
|
rb.PushIpcInterface<ISystemLocalCommunicationService>(system);
|
|
}
|
|
};
|
|
|
|
class LDNU final : public ServiceFramework<LDNU> {
|
|
public:
|
|
explicit LDNU(Core::System& system_) : ServiceFramework{system_, "ldn:u"} {
|
|
// clang-format off
|
|
static const FunctionInfo functions[] = {
|
|
{0, &LDNU::CreateUserLocalCommunicationService, "CreateUserLocalCommunicationService"},
|
|
};
|
|
// clang-format on
|
|
|
|
RegisterHandlers(functions);
|
|
}
|
|
|
|
void CreateUserLocalCommunicationService(HLERequestContext& ctx) {
|
|
LOG_DEBUG(Service_LDN, "called");
|
|
|
|
IPC::ResponseBuilder rb{ctx, 2, 0, 1};
|
|
rb.Push(ResultSuccess);
|
|
rb.PushIpcInterface<IUserLocalCommunicationService>(system);
|
|
}
|
|
};
|
|
|
|
class INetworkService final : public ServiceFramework<INetworkService> {
|
|
public:
|
|
explicit INetworkService(Core::System& system_) : ServiceFramework{system_, "INetworkService"} {
|
|
// clang-format off
|
|
static const FunctionInfo functions[] = {
|
|
{0, nullptr, "Initialize"},
|
|
{256, nullptr, "AttachNetworkInterfaceStateChangeEvent"},
|
|
{264, nullptr, "GetNetworkInterfaceLastError"},
|
|
{272, nullptr, "GetRole"},
|
|
{280, nullptr, "GetAdvertiseData"},
|
|
{288, nullptr, "GetGroupInfo"},
|
|
{296, nullptr, "GetGroupInfo2"},
|
|
{304, nullptr, "GetGroupOwner"},
|
|
{312, nullptr, "GetIpConfig"},
|
|
{320, nullptr, "GetLinkLevel"},
|
|
{512, nullptr, "Scan"},
|
|
{768, nullptr, "CreateGroup"},
|
|
{776, nullptr, "DestroyGroup"},
|
|
{784, nullptr, "SetAdvertiseData"},
|
|
{1536, nullptr, "SendToOtherGroup"},
|
|
{1544, nullptr, "RecvFromOtherGroup"},
|
|
{1552, nullptr, "AddAcceptableGroupId"},
|
|
{1560, nullptr, "ClearAcceptableGroupId"},
|
|
};
|
|
// clang-format on
|
|
|
|
RegisterHandlers(functions);
|
|
}
|
|
};
|
|
|
|
class INetworkServiceMonitor final : public ServiceFramework<INetworkServiceMonitor> {
|
|
public:
|
|
explicit INetworkServiceMonitor(Core::System& system_)
|
|
: ServiceFramework{system_, "INetworkServiceMonitor"} {
|
|
// clang-format off
|
|
static const FunctionInfo functions[] = {
|
|
{0, &INetworkServiceMonitor::Initialize, "Initialize"},
|
|
{256, nullptr, "AttachNetworkInterfaceStateChangeEvent"},
|
|
{264, nullptr, "GetNetworkInterfaceLastError"},
|
|
{272, nullptr, "GetRole"},
|
|
{280, nullptr, "GetAdvertiseData"},
|
|
{281, nullptr, "GetAdvertiseData2"},
|
|
{288, nullptr, "GetGroupInfo"},
|
|
{296, nullptr, "GetGroupInfo2"},
|
|
{304, nullptr, "GetGroupOwner"},
|
|
{312, nullptr, "GetIpConfig"},
|
|
{320, nullptr, "GetLinkLevel"},
|
|
{328, nullptr, "AttachJoinEvent"},
|
|
{336, nullptr, "GetMembers"},
|
|
};
|
|
// clang-format on
|
|
|
|
RegisterHandlers(functions);
|
|
}
|
|
|
|
void Initialize(HLERequestContext& ctx) {
|
|
LOG_WARNING(Service_LDN, "(STUBBED) called");
|
|
|
|
IPC::ResponseBuilder rb{ctx, 2};
|
|
rb.Push(ResultDisabled);
|
|
}
|
|
};
|
|
|
|
class LP2PAPP final : public ServiceFramework<LP2PAPP> {
|
|
public:
|
|
explicit LP2PAPP(Core::System& system_) : ServiceFramework{system_, "lp2p:app"} {
|
|
// clang-format off
|
|
static const FunctionInfo functions[] = {
|
|
{0, &LP2PAPP::CreateMonitorService, "CreateNetworkService"},
|
|
{8, &LP2PAPP::CreateMonitorService, "CreateNetworkServiceMonitor"},
|
|
};
|
|
// clang-format on
|
|
|
|
RegisterHandlers(functions);
|
|
}
|
|
|
|
void CreateNetworkervice(HLERequestContext& ctx) {
|
|
IPC::RequestParser rp{ctx};
|
|
const u64 reserved_input = rp.Pop<u64>();
|
|
const u32 input = rp.Pop<u32>();
|
|
|
|
LOG_WARNING(Service_LDN, "(STUBBED) called reserved_input={} input={}", reserved_input,
|
|
input);
|
|
|
|
IPC::ResponseBuilder rb{ctx, 2, 0, 1};
|
|
rb.Push(ResultSuccess);
|
|
rb.PushIpcInterface<INetworkService>(system);
|
|
}
|
|
|
|
void CreateMonitorService(HLERequestContext& ctx) {
|
|
IPC::RequestParser rp{ctx};
|
|
const u64 reserved_input = rp.Pop<u64>();
|
|
|
|
LOG_WARNING(Service_LDN, "(STUBBED) called reserved_input={}", reserved_input);
|
|
|
|
IPC::ResponseBuilder rb{ctx, 2, 0, 1};
|
|
rb.Push(ResultSuccess);
|
|
rb.PushIpcInterface<INetworkServiceMonitor>(system);
|
|
}
|
|
};
|
|
|
|
class LP2PSYS final : public ServiceFramework<LP2PSYS> {
|
|
public:
|
|
explicit LP2PSYS(Core::System& system_) : ServiceFramework{system_, "lp2p:sys"} {
|
|
// clang-format off
|
|
static const FunctionInfo functions[] = {
|
|
{0, &LP2PSYS::CreateMonitorService, "CreateNetworkService"},
|
|
{8, &LP2PSYS::CreateMonitorService, "CreateNetworkServiceMonitor"},
|
|
};
|
|
// clang-format on
|
|
|
|
RegisterHandlers(functions);
|
|
}
|
|
|
|
void CreateNetworkervice(HLERequestContext& ctx) {
|
|
IPC::RequestParser rp{ctx};
|
|
const u64 reserved_input = rp.Pop<u64>();
|
|
const u32 input = rp.Pop<u32>();
|
|
|
|
LOG_WARNING(Service_LDN, "(STUBBED) called reserved_input={} input={}", reserved_input,
|
|
input);
|
|
|
|
IPC::ResponseBuilder rb{ctx, 2, 0, 1};
|
|
rb.Push(ResultSuccess);
|
|
rb.PushIpcInterface<INetworkService>(system);
|
|
}
|
|
|
|
void CreateMonitorService(HLERequestContext& ctx) {
|
|
IPC::RequestParser rp{ctx};
|
|
const u64 reserved_input = rp.Pop<u64>();
|
|
|
|
LOG_WARNING(Service_LDN, "(STUBBED) called reserved_input={}", reserved_input);
|
|
|
|
IPC::ResponseBuilder rb{ctx, 2, 0, 1};
|
|
rb.Push(ResultSuccess);
|
|
rb.PushIpcInterface<INetworkServiceMonitor>(system);
|
|
}
|
|
};
|
|
|
|
void LoopProcess(Core::System& system) {
|
|
auto server_manager = std::make_unique<ServerManager>(system);
|
|
|
|
server_manager->RegisterNamedService("ldn:m", std::make_shared<LDNM>(system));
|
|
server_manager->RegisterNamedService("ldn:s", std::make_shared<LDNS>(system));
|
|
server_manager->RegisterNamedService("ldn:u", std::make_shared<LDNU>(system));
|
|
server_manager->RegisterNamedService("lp2p:app", std::make_shared<LP2PAPP>(system));
|
|
server_manager->RegisterNamedService("lp2p:sys", std::make_shared<LP2PSYS>(system));
|
|
ServerManager::RunServer(std::move(server_manager));
|
|
}
|
|
|
|
} // namespace Service::LDN
|