Add ldn:u implementation, INetworkClient interface and DisabledLdnClient (#5652)1.1.1026

* Impl first attempt to LDN * Make this work. - Endianness swap on all IPs. - Use local network IP for connections, rather than 127.0.0.1. This is to be changed when tunnelling or whatever. - Mac addresses are now randomly assigned on the server. (fixes joining lobbies) - Fixed the "connected" handler for stations to actually find a - Added info retrieval when connected to a station. - Users that disconnect are now removed from rooms they were in. (still need to broadcast tho) - The communication service does a bit better with being closed now. - Some locking around the game instance dictionary. * We may just be "initialized". Ignore this for now. * Lots of WIP * Add Disconnect packet * Improve signalling of internal events. * Fix scan. * Fix some more stupid things. * Enable NoDelay on all sockets. * Add station accept policy, disconnect function. * Limit max number of games. * Split out networking stuff from HLE, so it can be swapped. * Update logging calls. * Missed a spot. * Call SignalDisconnect instead of SetState * Add comment to GetNetworkInfo * Update configuration + UI Now has its own tab, more options. * Refactoring IUserLocalCommunicationService ( Expected new issues :'( ) * some cleanup * More fix * Correctly handle errors when connecting. * Disable *Private call and clean symbols * Structs cleanup * Big cleanup * Fix InvalidHandle (in MK8D and other games) * Add Reject and Private Network support (v1) RyuLdn Version bumped to 1. * Add Initialize Packet Allows users to keep Mac Addresses assigned by the server. * Add SetWirelessControllerRestriction and some cleanup * LDN-2 Initial Rebase Make this work. - Endianness swap on all IPs. - Use local network IP for connections, rather than 127.0.0.1. This is to be changed when tunnelling or whatever. - Fixed the "connected" handler for stations to actually find a - The communication service does a bit better with being closed now. - Some locking around the game instance dictionary. We may just be "initialized". Ignore this for now. Lots of WIP Implement scan filter. Improve signalling of internal events. Fix scan. Fix 0 width data, scan reply end delay removed. Fix some more stupid things. Enable NoDelay on all sockets. Add station accept policy, disconnect function. Limit max number of games. Split out networking stuff from HLE, so it can be swapped. Update logging calls. Missed a spot. SetAdvertiseData when open, don't return games that have accept policy 1 Update configuration + UI Now has its own tab, more options. Don't Keepalive, it causes problems. Refactoring IUserLocalCommunicationService ( Expected new issues :'( ) some cleanup More fix Correctly handle errors when connecting. Disable *Private call and clean symbols Structs cleanup Big cleanup Fix InvalidHandle (in MK8D and other games) Add Reject and Private Network support (v1) Disable TcpNoDelay option on linux. Add SetWirelessControllerRestriction and some cleanup Misc cleanup, implement broadcast flag. * Misc Changes * Fix GetNetworkInfo * Fix some small issues * Implement GetNetworkInfoLatestUpdate * Hotfix when LocalCommunicationId = 0xFFFFFFFFFFFFFFFF * Fix ARMS Scan (and other games using wrong LocalCommunicationId * Fix latest update when host leaves * Revert "Fix ARMS Scan (and other games using wrong LocalCommunicationId" This reverts commit 519c283d3993e2fdfafb8ac6b4e0a98231f6fb75. * Fix the localCommunicationId = -1 * Don't set Connect flag for nodes already in the room before joining. * Make IUserLocalCommunicationService disposable * Don't dispose if there's no client. * LDN-2-2 Rebase Make this work. - Endianness swap on all IPs. - Use local network IP for connections, rather than 127.0.0.1. This is to be changed when tunnelling or whatever. - Fixed the "connected" handler for stations to actually find a - The communication service does a bit better with being closed now. - Some locking around the game instance dictionary. We may just be "initialized". Ignore this for now. Put sockets behind an interface, so that they can be swapped for something proxyable Lots of WIP Implement scan filter. Improve signalling of internal events. Fix scan. Fix 0 width data, scan reply end delay removed. Fix some more stupid things. Enable NoDelay on all sockets. Add station accept policy, disconnect function. Limit max number of games. Split out networking stuff from HLE, so it can be swapped. Update logging calls. Missed a spot. SetAdvertiseData when open, don't return games that have accept policy 1 Update configuration + UI Now has its own tab, more options. Don't Keepalive, it causes problems. Refactoring IUserLocalCommunicationService ( Expected new issues :'( ) some cleanup More fix Correctly handle errors when connecting. Disable *Private call and clean symbols Structs cleanup Big cleanup Fix InvalidHandle (in MK8D and other games) Add Reject and Private Network support (v1) Disable TcpNoDelay option on linux. Add SetWirelessControllerRestriction and some cleanup Misc cleanup, implement broadcast flag. Misc Changes Fix GetNetworkInfo Fix some small issues Disable LAN by default til the config is added. Fix Splatoon 2 - Stub nfp IUser::StartDetection / IUser::StopDetection. - Stub ntc IEnsureNetworkClockAvailabilityService and needed calls. Cleanup previous fixes Stub IAudioInManager/IAudioIn for Splatoon 2 LAN Add LAN settings to multiplayer tab LAN Play > LAN Mode Implement GetNetworkInfoLatestUpdate Hotfix when LocalCommunicationId = 0xFFFFFFFFFFFFFFFF Fix ARMS Scan (and other games using wrong LocalCommunicationId Fix latest update when host leaves Revert "Fix ARMS Scan (and other games using wrong LocalCommunicationId" This reverts commit 519c283d3993e2fdfafb8ac6b4e0a98231f6fb75. Fix the localCommunicationId = -1 Don't set Connect flag for nodes already in the room before joining. Make IUserLocalCommunicationService disposable Fix crash when using LAN mode on linux. Actually use that call Don't dispose if there's no client. Fix the settings window crash Fix configurationFileUpdated * Make LDN compatible with Ryujinx/Ryujinx#3805 * Ava: Add Ldn options to SettingsNetworkTab * Ava: Add update events for multiplayer options * Apply formatting * Remove LdnHelper * ldn: Fix hardcoded /24 subnet mask * Fix naming rule violations * Add missing summary doc tag * Remove NetCoreServer dependency * Address code style issues and typos Co-authored-by: gdkchan <gab.dark.100@gmail.com> * Call CloseStation/CloseAccessPoint to reduce code duplication * Fix typo Co-authored-by: gdkchan <gab.dark.100@gmail.com> * Fix missing trailing commas * Extract AddressList from AddressEntry * Use AcceptPolicy as a type for LdnNetworkInfo.StationAcceptPolicy * Add Flags attribute to ScanFilterFlag * Rename struct members for LdnNetworkInfo * Remove extra line Co-authored-by: Ac_K <Acoustik666@gmail.com> * Extract NetworkErrorMessage from NetworkError * Fix missing trailing commas --------- Co-authored-by: Ac_K <Acoustik666@gmail.com> Co-authored-by: riperiperi <rhy3756547@hotmail.com> Co-authored-by: gdkchan <gab.dark.100@gmail.com>
author: TSRBerry <20988865+TSRBerry@users.noreply.github.com> 2023-09-25 23:50:43 +0200
committer: GitHub <noreply@github.com> 2023-09-25 23:50:43 +0200
commit: 53bd4c9f603c95929ad17fffcce2fe1de04e3ae1 (patch)
tree: d93b6ba6f4032328a487ecebd5c8fc2851e14e7a /src/Ryujinx.HLE/HOS/Services/Ldn/UserServiceCreator/IUserLocalCommunicationService.cs
parent: eca8808649b7d763dd6b528bd26d43b7bd839cd2 (diff)
1 files changed, 1035 insertions, 25 deletions
diff --git a/src/Ryujinx.HLE/HOS/Services/Ldn/UserServiceCreator/IUserLocalCommunicationService.cs b/src/Ryujinx.HLE/HOS/Services/Ldn/UserServiceCreator/IUserLocalCommunicationService.cs
index d390a3e6..6abd2b89 100644
--- a/src/Ryujinx.HLE/HOS/Services/Ldn/UserServiceCreator/IUserLocalCommunicationService.cs
+++ b/src/Ryujinx.HLE/HOS/Services/Ldn/UserServiceCreator/IUserLocalCommunicationService.cs
@@ -1,88 +1,1098 @@
-using Ryujinx.HLE.HOS.Ipc;
+using LibHac.Ns;
+using Ryujinx.Common;
+using Ryujinx.Common.Configuration.Multiplayer;
+using Ryujinx.Common.Logging;
+using Ryujinx.Common.Memory;
+using Ryujinx.Common.Utilities;
+using Ryujinx.Cpu;
+using Ryujinx.HLE.HOS.Ipc;
+using Ryujinx.HLE.HOS.Kernel.Threading;
 using Ryujinx.HLE.HOS.Services.Ldn.Types;
+using Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator.RyuLdn;
 using Ryujinx.Horizon.Common;
+using Ryujinx.Memory;
 using System;
+using System.IO;
 using System.Net;
+using System.Net.NetworkInformation;
+using System.Runtime.InteropServices;
 
 namespace Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator
 {
-    class IUserLocalCommunicationService : IpcService
+    class IUserLocalCommunicationService : IpcService, IDisposable
     {
-        // TODO(Ac_K): Determine what the hardcoded unknown value is.
-        private const int UnknownValue = 90;
+        public INetworkClient NetworkClient { get; private set; }
 
-        private readonly NetworkInterface _networkInterface;
+        private const int NifmRequestID = 90;
+        private const string DefaultIPAddress = "127.0.0.1";
+        private const string DefaultSubnetMask = "255.255.255.0";
+        private const bool IsDevelopment = false;
 
-        private int _stateChangeEventHandle = 0;
+        private readonly KEvent _stateChangeEvent;
+
+        private NetworkState _state;
+        private DisconnectReason _disconnectReason;
+        private ResultCode _nifmResultCode;
+
+        private AccessPoint _accessPoint;
+        private Station _station;
 
         public IUserLocalCommunicationService(ServiceCtx context)
         {
-            _networkInterface = new NetworkInterface(context.Device.System);
+            _stateChangeEvent = new KEvent(context.Device.System.KernelContext);
+            _state = NetworkState.None;
+            _disconnectReason = DisconnectReason.None;
+        }
+
+        private ushort CheckDevelopmentChannel(ushort channel)
+        {
+            return (ushort)(!IsDevelopment ? 0 : channel);
+        }
+
+        private SecurityMode CheckDevelopmentSecurityMode(SecurityMode securityMode)
+        {
+            return !IsDevelopment ? SecurityMode.Retail : securityMode;
+        }
+
+        private bool CheckLocalCommunicationIdPermission(ServiceCtx context, ulong localCommunicationIdChecked)
+        {
+            // TODO: Call nn::arp::GetApplicationControlProperty here when implemented.
+            ApplicationControlProperty controlProperty = context.Device.Processes.ActiveApplication.ApplicationControlProperties;
+
+            foreach (var localCommunicationId in controlProperty.LocalCommunicationId.ItemsRo)
+            {
+                if (localCommunicationId == localCommunicationIdChecked)
+                {
+                    return true;
+                }
+            }
+
+            return false;
         }
 
         [CommandCmif(0)]
         // GetState() -> s32 state
         public ResultCode GetState(ServiceCtx context)
         {
-            if (_networkInterface.NifmState != ResultCode.Success)
+            if (_nifmResultCode != ResultCode.Success)
             {
                 context.ResponseData.Write((int)NetworkState.Error);
 
                 return ResultCode.Success;
             }
 
-            ResultCode result = _networkInterface.GetState(out NetworkState state);
+            // NOTE: Returns ResultCode.InvalidArgument if _state is null, doesn't occur in our case.
+            context.ResponseData.Write((int)_state);
+
+            return ResultCode.Success;
+        }
+
+        public void SetState()
+        {
+            _stateChangeEvent.WritableEvent.Signal();
+        }
+
+        public void SetState(NetworkState state)
+        {
+            _state = state;
+
+            SetState();
+        }
+
+        [CommandCmif(1)]
+        // GetNetworkInfo() -> buffer<network_info<0x480>, 0x1a>
+        public ResultCode GetNetworkInfo(ServiceCtx context)
+        {
+            ulong bufferPosition = context.Request.RecvListBuff[0].Position;
+
+            MemoryHelper.FillWithZeros(context.Memory, bufferPosition, 0x480);
+
+            if (_nifmResultCode != ResultCode.Success)
+            {
+                return _nifmResultCode;
+            }
+
+            ResultCode resultCode = GetNetworkInfoImpl(out NetworkInfo networkInfo);
+            if (resultCode != ResultCode.Success)
+            {
+                return resultCode;
+            }
+
+            ulong infoSize = MemoryHelper.Write(context.Memory, bufferPosition, networkInfo);
 
-            if (result == ResultCode.Success)
+            context.Response.PtrBuff[0] = context.Response.PtrBuff[0].WithSize(infoSize);
+
+            return ResultCode.Success;
+        }
+
+        private ResultCode GetNetworkInfoImpl(out NetworkInfo networkInfo)
+        {
+            if (_state == NetworkState.StationConnected)
+            {
+                networkInfo = _station.NetworkInfo;
+            }
+            else if (_state == NetworkState.AccessPointCreated)
             {
-                context.ResponseData.Write((int)state);
+                networkInfo = _accessPoint.NetworkInfo;
+            }
+            else
+            {
+                networkInfo = new NetworkInfo();
+
+                return ResultCode.InvalidState;
             }
 
-            return result;
+            return ResultCode.Success;
+        }
+
+        private NodeLatestUpdate[] GetNodeLatestUpdateImpl(int count)
+        {
+            if (_state == NetworkState.StationConnected)
+            {
+                return _station.LatestUpdates.ConsumeLatestUpdate(count);
+            }
+            else if (_state == NetworkState.AccessPointCreated)
+            {
+                return _accessPoint.LatestUpdates.ConsumeLatestUpdate(count);
+            }
+            else
+            {
+                return Array.Empty<NodeLatestUpdate>();
+            }
+        }
+
+        [CommandCmif(2)]
+        // GetIpv4Address() -> (u32 ip_address, u32 subnet_mask)
+        public ResultCode GetIpv4Address(ServiceCtx context)
+        {
+            if (_nifmResultCode != ResultCode.Success)
+            {
+                return _nifmResultCode;
+            }
+
+            // NOTE: Return ResultCode.InvalidArgument if ip_address and subnet_mask are null, doesn't occur in our case.
+
+            if (_state == NetworkState.AccessPointCreated || _state == NetworkState.StationConnected)
+            {
+                (_, UnicastIPAddressInformation unicastAddress) = NetworkHelpers.GetLocalInterface(context.Device.Configuration.MultiplayerLanInterfaceId);
+
+                if (unicastAddress == null)
+                {
+                    context.ResponseData.Write(NetworkHelpers.ConvertIpv4Address(DefaultIPAddress));
+                    context.ResponseData.Write(NetworkHelpers.ConvertIpv4Address(DefaultSubnetMask));
+                }
+                else
+                {
+                    Logger.Info?.Print(LogClass.ServiceLdn, $"Console's LDN IP is \"{unicastAddress.Address}\".");
+
+                    context.ResponseData.Write(NetworkHelpers.ConvertIpv4Address(unicastAddress.Address));
+                    context.ResponseData.Write(NetworkHelpers.ConvertIpv4Address(unicastAddress.IPv4Mask));
+                }
+            }
+            else
+            {
+                return ResultCode.InvalidArgument;
+            }
+
+            return ResultCode.Success;
+        }
+
+        [CommandCmif(3)]
+        // GetDisconnectReason() -> u16 disconnect_reason
+        public ResultCode GetDisconnectReason(ServiceCtx context)
+        {
+            // NOTE: Returns ResultCode.InvalidArgument if _disconnectReason is null, doesn't occur in our case.
+
+            context.ResponseData.Write((short)_disconnectReason);
+
+            return ResultCode.Success;
+        }
+
+        public void SetDisconnectReason(DisconnectReason reason)
+        {
+            if (_state != NetworkState.Initialized)
+            {
+                _disconnectReason = reason;
+
+                SetState(NetworkState.Initialized);
+            }
+        }
+
+        [CommandCmif(4)]
+        // GetSecurityParameter() -> bytes<0x20, 1> security_parameter
+        public ResultCode GetSecurityParameter(ServiceCtx context)
+        {
+            if (_nifmResultCode != ResultCode.Success)
+            {
+                return _nifmResultCode;
+            }
+
+            ResultCode resultCode = GetNetworkInfoImpl(out NetworkInfo networkInfo);
+            if (resultCode != ResultCode.Success)
+            {
+                return resultCode;
+            }
+
+            SecurityParameter securityParameter = new()
+            {
+                Data = new Array16<byte>(),
+                SessionId = networkInfo.NetworkId.SessionId,
+            };
+
+            context.ResponseData.WriteStruct(securityParameter);
+
+            return ResultCode.Success;
+        }
+
+        [CommandCmif(5)]
+        // GetNetworkConfig() -> bytes<0x20, 8> network_config
+        public ResultCode GetNetworkConfig(ServiceCtx context)
+        {
+            if (_nifmResultCode != ResultCode.Success)
+            {
+                return _nifmResultCode;
+            }
+
+            ResultCode resultCode = GetNetworkInfoImpl(out NetworkInfo networkInfo);
+            if (resultCode != ResultCode.Success)
+            {
+                return resultCode;
+            }
+
+            NetworkConfig networkConfig = new()
+            {
+                IntentId = networkInfo.NetworkId.IntentId,
+                Channel = networkInfo.Common.Channel,
+                NodeCountMax = networkInfo.Ldn.NodeCountMax,
+                LocalCommunicationVersion = networkInfo.Ldn.Nodes[0].LocalCommunicationVersion,
+                Reserved2 = new Array10<byte>(),
+            };
+
+            context.ResponseData.WriteStruct(networkConfig);
+
+            return ResultCode.Success;
         }
 
         [CommandCmif(100)]
         // AttachStateChangeEvent() -> handle<copy>
         public ResultCode AttachStateChangeEvent(ServiceCtx context)
         {
-            if (_stateChangeEventHandle == 0)
+            if (context.Process.HandleTable.GenerateHandle(_stateChangeEvent.ReadableEvent, out int stateChangeEventHandle) != Result.Success)
+            {
+                throw new InvalidOperationException("Out of handles!");
+            }
+
+            context.Response.HandleDesc = IpcHandleDesc.MakeCopy(stateChangeEventHandle);
+
+            // Returns ResultCode.InvalidArgument if handle is null, doesn't occur in our case since we already throw an Exception.
+
+            return ResultCode.Success;
+        }
+
+        [CommandCmif(101)]
+        // GetNetworkInfoLatestUpdate() -> (buffer<network_info<0x480>, 0x1a>, buffer<node_latest_update, 0xa>)
+        public ResultCode GetNetworkInfoLatestUpdate(ServiceCtx context)
+        {
+            ulong bufferPosition = context.Request.RecvListBuff[0].Position;
+
+            MemoryHelper.FillWithZeros(context.Memory, bufferPosition, 0x480);
+
+            if (_nifmResultCode != ResultCode.Success)
+            {
+                return _nifmResultCode;
+            }
+
+            ResultCode resultCode = GetNetworkInfoImpl(out NetworkInfo networkInfo);
+            if (resultCode != ResultCode.Success)
+            {
+                return resultCode;
+            }
+
+            ulong outputPosition = context.Request.RecvListBuff[0].Position;
+            ulong outputSize = context.Request.RecvListBuff[0].Size;
+
+            ulong latestUpdateSize = (ulong)Marshal.SizeOf<NodeLatestUpdate>();
+            int count = (int)(outputSize / latestUpdateSize);
+
+            NodeLatestUpdate[] latestUpdate = GetNodeLatestUpdateImpl(count);
+
+            MemoryHelper.FillWithZeros(context.Memory, outputPosition, (int)outputSize);
+
+            foreach (NodeLatestUpdate node in latestUpdate)
+            {
+                MemoryHelper.Write(context.Memory, outputPosition, node);
+
+                outputPosition += latestUpdateSize;
+            }
+
+            ulong infoSize = MemoryHelper.Write(context.Memory, bufferPosition, networkInfo);
+
+            context.Response.PtrBuff[0] = context.Response.PtrBuff[0].WithSize(infoSize);
+
+            return ResultCode.Success;
+        }
+
+        [CommandCmif(102)]
+        // Scan(u16 channel, bytes<0x60, 8> scan_filter) -> (u16 count, buffer<network_info, 0x22>)
+        public ResultCode Scan(ServiceCtx context)
+        {
+            return ScanImpl(context);
+        }
+
+        [CommandCmif(103)]
+        // ScanPrivate(u16 channel, bytes<0x60, 8> scan_filter) -> (u16 count, buffer<network_info, 0x22>)
+        public ResultCode ScanPrivate(ServiceCtx context)
+        {
+            return ScanImpl(context, true);
+        }
+
+        private ResultCode ScanImpl(ServiceCtx context, bool isPrivate = false)
+        {
+            ushort channel = (ushort)context.RequestData.ReadUInt64();
+            ScanFilter scanFilter = context.RequestData.ReadStruct<ScanFilter>();
+
+            (ulong bufferPosition, ulong bufferSize) = context.Request.GetBufferType0x22(0);
+
+            if (_nifmResultCode != ResultCode.Success)
+            {
+                return _nifmResultCode;
+            }
+
+            if (!isPrivate)
+            {
+                channel = CheckDevelopmentChannel(channel);
+            }
+
+            ResultCode resultCode = ResultCode.InvalidArgument;
+
+            if (bufferSize != 0)
+            {
+                if (bufferPosition != 0)
+                {
+                    ScanFilterFlag scanFilterFlag = scanFilter.Flag;
+
+                    if (!scanFilterFlag.HasFlag(ScanFilterFlag.NetworkType) || scanFilter.NetworkType <= NetworkType.All)
+                    {
+                        if (scanFilterFlag.HasFlag(ScanFilterFlag.Ssid))
+                        {
+                            if (scanFilter.Ssid.Length <= 31)
+                            {
+                                return resultCode;
+                            }
+                        }
+
+                        if (!scanFilterFlag.HasFlag(ScanFilterFlag.MacAddress))
+                        {
+                            if (scanFilterFlag > ScanFilterFlag.All)
+                            {
+                                return resultCode;
+                            }
+
+                            if (_state - 3 >= NetworkState.AccessPoint)
+                            {
+                                resultCode = ResultCode.InvalidState;
+                            }
+                            else
+                            {
+                                if (scanFilter.NetworkId.IntentId.LocalCommunicationId == -1)
+                                {
+                                    // TODO: Call nn::arp::GetApplicationControlProperty here when implemented.
+                                    ApplicationControlProperty controlProperty = context.Device.Processes.ActiveApplication.ApplicationControlProperties;
+
+                                    scanFilter.NetworkId.IntentId.LocalCommunicationId = (long)controlProperty.LocalCommunicationId[0];
+                                }
+
+                                resultCode = ScanInternal(context.Memory, channel, scanFilter, bufferPosition, bufferSize, out ulong counter);
+
+                                context.ResponseData.Write(counter);
+                            }
+                        }
+                        else
+                        {
+                            throw new NotSupportedException();
+                        }
+                    }
+                }
+            }
+
+            return resultCode;
+        }
+
+        private ResultCode ScanInternal(IVirtualMemoryManager memory, ushort channel, ScanFilter scanFilter, ulong bufferPosition, ulong bufferSize, out ulong counter)
+        {
+            ulong networkInfoSize = (ulong)Marshal.SizeOf(typeof(NetworkInfo));
+            ulong maxGames = bufferSize / networkInfoSize;
+
+            MemoryHelper.FillWithZeros(memory, bufferPosition, (int)bufferSize);
+
+            NetworkInfo[] availableGames = NetworkClient.Scan(channel, scanFilter);
+
+            counter = 0;
+
+            foreach (NetworkInfo networkInfo in availableGames)
+            {
+                MemoryHelper.Write(memory, bufferPosition + (networkInfoSize * counter), networkInfo);
+
+                if (++counter >= maxGames)
+                {
+                    break;
+                }
+            }
+
+            return ResultCode.Success;
+        }
+
+        [CommandCmif(104)] // 5.0.0+
+        // SetWirelessControllerRestriction(u32 wireless_controller_restriction)
+        public ResultCode SetWirelessControllerRestriction(ServiceCtx context)
+        {
+            // NOTE: Return ResultCode.InvalidArgument if an internal IPAddress is null, doesn't occur in our case.
+
+            uint wirelessControllerRestriction = context.RequestData.ReadUInt32();
+
+            if (wirelessControllerRestriction > 1)
+            {
+                return ResultCode.InvalidArgument;
+            }
+
+            if (_state != NetworkState.Initialized)
+            {
+                return ResultCode.InvalidState;
+            }
+
+            // NOTE: WirelessControllerRestriction value is used for the btm service in SetWlanMode call.
+            //       Since we use our own implementation we can do nothing here.
+
+            return ResultCode.Success;
+        }
+
+        [CommandCmif(200)]
+        // OpenAccessPoint()
+        public ResultCode OpenAccessPoint(ServiceCtx context)
+        {
+            if (_nifmResultCode != ResultCode.Success)
+            {
+                return _nifmResultCode;
+            }
+
+            if (_state != NetworkState.Initialized)
+            {
+                return ResultCode.InvalidState;
+            }
+
+            CloseStation();
+
+            SetState(NetworkState.AccessPoint);
+
+            _accessPoint = new AccessPoint(this);
+
+            // NOTE: Calls nifm service and return related result codes.
+            //       Since we use our own implementation we can return ResultCode.Success.
+
+            return ResultCode.Success;
+        }
+
+        [CommandCmif(201)]
+        // CloseAccessPoint()
+        public ResultCode CloseAccessPoint(ServiceCtx context)
+        {
+            if (_nifmResultCode != ResultCode.Success)
+            {
+                return _nifmResultCode;
+            }
+
+            if (_state == NetworkState.AccessPoint || _state == NetworkState.AccessPointCreated)
+            {
+                DestroyNetworkImpl(DisconnectReason.DestroyedByUser);
+            }
+            else
+            {
+                return ResultCode.InvalidState;
+            }
+
+            SetState(NetworkState.Initialized);
+
+            return ResultCode.Success;
+        }
+
+        private void CloseAccessPoint()
+        {
+            _accessPoint?.Dispose();
+            _accessPoint = null;
+        }
+
+        [CommandCmif(202)]
+        // CreateNetwork(bytes<0x44, 2> security_config, bytes<0x30, 1> user_config, bytes<0x20, 8> network_config)
+        public ResultCode CreateNetwork(ServiceCtx context)
+        {
+            return CreateNetworkImpl(context);
+        }
+
+        [CommandCmif(203)]
+        // CreateNetworkPrivate(bytes<0x44, 2> security_config, bytes<0x20, 1> security_parameter, bytes<0x30, 1>, bytes<0x20, 8> network_config, buffer<unknown, 9> address_entry, int count)
+        public ResultCode CreateNetworkPrivate(ServiceCtx context)
+        {
+            return CreateNetworkImpl(context, true);
+        }
+
+        public ResultCode CreateNetworkImpl(ServiceCtx context, bool isPrivate = false)
+        {
+            SecurityConfig securityConfig = context.RequestData.ReadStruct<SecurityConfig>();
+            SecurityParameter securityParameter = isPrivate ? context.RequestData.ReadStruct<SecurityParameter>() : new SecurityParameter();
+
+            UserConfig userConfig = context.RequestData.ReadStruct<UserConfig>();
+
+            context.RequestData.BaseStream.Seek(4, SeekOrigin.Current); // Alignment?
+            NetworkConfig networkConfig = context.RequestData.ReadStruct<NetworkConfig>();
+
+            if (networkConfig.IntentId.LocalCommunicationId == -1)
+            {
+                // TODO: Call nn::arp::GetApplicationControlProperty here when implemented.
+                ApplicationControlProperty controlProperty = context.Device.Processes.ActiveApplication.ApplicationControlProperties;
+
+                networkConfig.IntentId.LocalCommunicationId = (long)controlProperty.LocalCommunicationId[0];
+            }
+
+            bool isLocalCommunicationIdValid = CheckLocalCommunicationIdPermission(context, (ulong)networkConfig.IntentId.LocalCommunicationId);
+            if (!isLocalCommunicationIdValid)
+            {
+                return ResultCode.InvalidObject;
+            }
+
+            if (_nifmResultCode != ResultCode.Success)
+            {
+                return _nifmResultCode;
+            }
+
+            networkConfig.Channel = CheckDevelopmentChannel(networkConfig.Channel);
+            securityConfig.SecurityMode = CheckDevelopmentSecurityMode(securityConfig.SecurityMode);
+
+            if (networkConfig.NodeCountMax <= 8)
+            {
+                if ((((ulong)networkConfig.LocalCommunicationVersion) & 0x80000000) == 0)
+                {
+                    if (securityConfig.SecurityMode <= SecurityMode.Retail)
+                    {
+                        if (securityConfig.Passphrase.Length <= 0x40)
+                        {
+                            if (_state == NetworkState.AccessPoint)
+                            {
+                                if (isPrivate)
+                                {
+                                    ulong bufferPosition = context.Request.PtrBuff[0].Position;
+                                    ulong bufferSize = context.Request.PtrBuff[0].Size;
+
+                                    byte[] addressListBytes = new byte[bufferSize];
+
+                                    context.Memory.Read(bufferPosition, addressListBytes);
+
+                                    AddressList addressList = MemoryMarshal.Cast<byte, AddressList>(addressListBytes)[0];
+
+                                    _accessPoint.CreateNetworkPrivate(securityConfig, securityParameter, userConfig, networkConfig, addressList);
+                                }
+                                else
+                                {
+                                    _accessPoint.CreateNetwork(securityConfig, userConfig, networkConfig);
+                                }
+
+                                return ResultCode.Success;
+                            }
+                            else
+                            {
+                                return ResultCode.InvalidState;
+                            }
+                        }
+                    }
+                }
+            }
+
+            return ResultCode.InvalidArgument;
+        }
+
+        [CommandCmif(204)]
+        // DestroyNetwork()
+        public ResultCode DestroyNetwork(ServiceCtx context)
+        {
+            return DestroyNetworkImpl(DisconnectReason.DestroyedByUser);
+        }
+
+        private ResultCode DestroyNetworkImpl(DisconnectReason disconnectReason)
+        {
+            if (_nifmResultCode != ResultCode.Success)
             {
-                if (context.Process.HandleTable.GenerateHandle(_networkInterface.StateChangeEvent.ReadableEvent, out _stateChangeEventHandle) != Result.Success)
+                return _nifmResultCode;
+            }
+
+            if (disconnectReason - 3 <= DisconnectReason.DisconnectedByUser)
+            {
+                if (_state == NetworkState.AccessPointCreated)
                 {
-                    throw new InvalidOperationException("Out of handles!");
+                    CloseAccessPoint();
+
+                    SetState(NetworkState.AccessPoint);
+
+                    return ResultCode.Success;
                 }
+
+                CloseAccessPoint();
+
+                return ResultCode.InvalidState;
+            }
+
+            return ResultCode.InvalidArgument;
+        }
+
+        [CommandCmif(205)]
+        // Reject(u32 node_id)
+        public ResultCode Reject(ServiceCtx context)
+        {
+            uint nodeId = context.RequestData.ReadUInt32();
+
+            return RejectImpl(DisconnectReason.Rejected, nodeId);
+        }
+
+        private ResultCode RejectImpl(DisconnectReason disconnectReason, uint nodeId)
+        {
+            if (_nifmResultCode != ResultCode.Success)
+            {
+                return _nifmResultCode;
+            }
+
+            if (_state != NetworkState.AccessPointCreated)
+            {
+                return ResultCode.InvalidState; // Must be network host to reject nodes.
+            }
+
+            return NetworkClient.Reject(disconnectReason, nodeId);
+        }
+
+        [CommandCmif(206)]
+        // SetAdvertiseData(buffer<advertise_data, 0x21>)
+        public ResultCode SetAdvertiseData(ServiceCtx context)
+        {
+            (ulong bufferPosition, ulong bufferSize) = context.Request.GetBufferType0x21(0);
+
+            if (_nifmResultCode != ResultCode.Success)
+            {
+                return _nifmResultCode;
+            }
+
+            if (bufferSize == 0 || bufferSize > 0x180)
+            {
+                return ResultCode.InvalidArgument;
+            }
+
+            if (_state == NetworkState.AccessPoint || _state == NetworkState.AccessPointCreated)
+            {
+                byte[] advertiseData = new byte[bufferSize];
+
+                context.Memory.Read(bufferPosition, advertiseData);
+
+                return _accessPoint.SetAdvertiseData(advertiseData);
+            }
+            else
+            {
+                return ResultCode.InvalidState;
+            }
+        }
+
+        [CommandCmif(207)]
+        // SetStationAcceptPolicy(u8 accept_policy)
+        public ResultCode SetStationAcceptPolicy(ServiceCtx context)
+        {
+            AcceptPolicy acceptPolicy = (AcceptPolicy)context.RequestData.ReadByte();
+
+            if (_nifmResultCode != ResultCode.Success)
+            {
+                return _nifmResultCode;
+            }
+
+            if (acceptPolicy > AcceptPolicy.WhiteList)
+            {
+                return ResultCode.InvalidArgument;
+            }
+
+            if (_state == NetworkState.AccessPoint || _state == NetworkState.AccessPointCreated)
+            {
+                return _accessPoint.SetStationAcceptPolicy(acceptPolicy);
+            }
+            else
+            {
+                return ResultCode.InvalidState;
+            }
+        }
+
+        [CommandCmif(208)]
+        // AddAcceptFilterEntry(bytes<6, 1> mac_address)
+        public ResultCode AddAcceptFilterEntry(ServiceCtx context)
+        {
+            if (_nifmResultCode != ResultCode.Success)
+            {
+                return _nifmResultCode;
+            }
+
+            // TODO
+
+            return ResultCode.Success;
+        }
+
+        [CommandCmif(209)]
+        // ClearAcceptFilter()
+        public ResultCode ClearAcceptFilter(ServiceCtx context)
+        {
+            if (_nifmResultCode != ResultCode.Success)
+            {
+                return _nifmResultCode;
+            }
+
+            // TODO
+
+            return ResultCode.Success;
+        }
+
+        [CommandCmif(300)]
+        // OpenStation()
+        public ResultCode OpenStation(ServiceCtx context)
+        {
+            if (_nifmResultCode != ResultCode.Success)
+            {
+                return _nifmResultCode;
+            }
+
+            if (_state != NetworkState.Initialized)
+            {
+                return ResultCode.InvalidState;
+            }
+
+            CloseAccessPoint();
+
+            SetState(NetworkState.Station);
+
+            _station?.Dispose();
+            _station = new Station(this);
+
+            // NOTE: Calls nifm service and returns related result codes.
+            //       Since we use our own implementation we can return ResultCode.Success.
+
+            return ResultCode.Success;
+        }
+
+        [CommandCmif(301)]
+        // CloseStation()
+        public ResultCode CloseStation(ServiceCtx context)
+        {
+            if (_nifmResultCode != ResultCode.Success)
+            {
+                return _nifmResultCode;
             }
 
-            context.Response.HandleDesc = IpcHandleDesc.MakeCopy(_stateChangeEventHandle);
+            if (_state == NetworkState.Station || _state == NetworkState.StationConnected)
+            {
+                DisconnectImpl(DisconnectReason.DisconnectedByUser);
+            }
+            else
+            {
+                return ResultCode.InvalidState;
+            }
 
-            // Return ResultCode.InvalidArgument if handle is null, doesn't occur in our case since we already throw an Exception.
+            SetState(NetworkState.Initialized);
 
             return ResultCode.Success;
         }
 
+        private void CloseStation()
+        {
+            _station?.Dispose();
+            _station = null;
+        }
+
+        [CommandCmif(302)]
+        // Connect(bytes<0x44, 2> security_config, bytes<0x30, 1> user_config, u32 local_communication_version, u32 option_unknown, buffer<network_info<0x480>, 0x19>)
+        public ResultCode Connect(ServiceCtx context)
+        {
+            return ConnectImpl(context);
+        }
+
+        [CommandCmif(303)]
+        // ConnectPrivate(bytes<0x44, 2> security_config, bytes<0x20, 1> security_parameter, bytes<0x30, 1> user_config, u32 local_communication_version, u32 option_unknown, bytes<0x20, 8> network_config)
+        public ResultCode ConnectPrivate(ServiceCtx context)
+        {
+            return ConnectImpl(context, true);
+        }
+
+        private ResultCode ConnectImpl(ServiceCtx context, bool isPrivate = false)
+        {
+            SecurityConfig securityConfig = context.RequestData.ReadStruct<SecurityConfig>();
+            SecurityParameter securityParameter = isPrivate ? context.RequestData.ReadStruct<SecurityParameter>() : new SecurityParameter();
+
+            UserConfig userConfig = context.RequestData.ReadStruct<UserConfig>();
+            uint localCommunicationVersion = context.RequestData.ReadUInt32();
+            uint optionUnknown = context.RequestData.ReadUInt32();
+
+            NetworkConfig networkConfig = new();
+            NetworkInfo networkInfo = new();
+
+            if (isPrivate)
+            {
+                context.RequestData.ReadUInt32(); // Padding.
+
+                networkConfig = context.RequestData.ReadStruct<NetworkConfig>();
+            }
+            else
+            {
+                ulong bufferPosition = context.Request.PtrBuff[0].Position;
+                ulong bufferSize = context.Request.PtrBuff[0].Size;
+
+                byte[] networkInfoBytes = new byte[bufferSize];
+
+                context.Memory.Read(bufferPosition, networkInfoBytes);
+
+                networkInfo = MemoryMarshal.Cast<byte, NetworkInfo>(networkInfoBytes)[0];
+            }
+
+            if (networkInfo.NetworkId.IntentId.LocalCommunicationId == -1)
+            {
+                // TODO: Call nn::arp::GetApplicationControlProperty here when implemented.
+                ApplicationControlProperty controlProperty = context.Device.Processes.ActiveApplication.ApplicationControlProperties;
+
+                networkInfo.NetworkId.IntentId.LocalCommunicationId = (long)controlProperty.LocalCommunicationId[0];
+            }
+
+            bool isLocalCommunicationIdValid = CheckLocalCommunicationIdPermission(context, (ulong)networkInfo.NetworkId.IntentId.LocalCommunicationId);
+            if (!isLocalCommunicationIdValid)
+            {
+                return ResultCode.InvalidObject;
+            }
+
+            if (_nifmResultCode != ResultCode.Success)
+            {
+                return _nifmResultCode;
+            }
+
+            securityConfig.SecurityMode = CheckDevelopmentSecurityMode(securityConfig.SecurityMode);
+
+            ResultCode resultCode = ResultCode.InvalidArgument;
+
+            if (securityConfig.SecurityMode - 1 <= SecurityMode.Debug)
+            {
+                if (optionUnknown <= 1 && (localCommunicationVersion >> 15) == 0 && securityConfig.PassphraseSize <= 64)
+                {
+                    resultCode = ResultCode.VersionTooLow;
+                    if (localCommunicationVersion >= 0)
+                    {
+                        resultCode = ResultCode.VersionTooHigh;
+                        if (localCommunicationVersion <= short.MaxValue)
+                        {
+                            if (_state != NetworkState.Station)
+                            {
+                                resultCode = ResultCode.InvalidState;
+                            }
+                            else
+                            {
+                                if (isPrivate)
+                                {
+                                    resultCode = _station.ConnectPrivate(securityConfig, securityParameter, userConfig, localCommunicationVersion, optionUnknown, networkConfig);
+                                }
+                                else
+                                {
+                                    resultCode = _station.Connect(securityConfig, userConfig, localCommunicationVersion, optionUnknown, networkInfo);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+
+            return resultCode;
+        }
+
+        [CommandCmif(304)]
+        // Disconnect()
+        public ResultCode Disconnect(ServiceCtx context)
+        {
+            return DisconnectImpl(DisconnectReason.DisconnectedByUser);
+        }
+
+        private ResultCode DisconnectImpl(DisconnectReason disconnectReason)
+        {
+            if (_nifmResultCode != ResultCode.Success)
+            {
+                return _nifmResultCode;
+            }
+
+            if (disconnectReason <= DisconnectReason.DisconnectedBySystem)
+            {
+                if (_state == NetworkState.StationConnected)
+                {
+                    SetState(NetworkState.Station);
+
+                    CloseStation();
+
+                    _disconnectReason = disconnectReason;
+
+                    return ResultCode.Success;
+                }
+
+                CloseStation();
+
+                return ResultCode.InvalidState;
+            }
+
+            return ResultCode.InvalidArgument;
+        }
+
         [CommandCmif(400)]
-        // InitializeOld(u64, pid)
+        // InitializeOld(pid)
         public ResultCode InitializeOld(ServiceCtx context)
         {
-            return _networkInterface.Initialize(UnknownValue, 0, null, null);
+            return InitializeImpl(context, context.Process.Pid, NifmRequestID);
         }
 
         [CommandCmif(401)]
         // Finalize()
         public ResultCode Finalize(ServiceCtx context)
         {
-            return _networkInterface.Finalize();
+            if (_nifmResultCode != ResultCode.Success)
+            {
+                return _nifmResultCode;
+            }
+
+            // NOTE: Use true when its called in nn::ldn::detail::ISystemLocalCommunicationService
+            ResultCode resultCode = FinalizeImpl(false);
+            if (resultCode == ResultCode.Success)
+            {
+                SetDisconnectReason(DisconnectReason.None);
+            }
+
+            return resultCode;
+        }
+
+        private ResultCode FinalizeImpl(bool isCausedBySystem)
+        {
+            DisconnectReason disconnectReason;
+
+            switch (_state)
+            {
+                case NetworkState.None:
+                    return ResultCode.Success;
+                case NetworkState.AccessPoint:
+                    {
+                        CloseAccessPoint();
+
+                        break;
+                    }
+                case NetworkState.AccessPointCreated:
+                    {
+                        if (isCausedBySystem)
+                        {
+                            disconnectReason = DisconnectReason.DestroyedBySystem;
+                        }
+                        else
+                        {
+                            disconnectReason = DisconnectReason.DestroyedByUser;
+                        }
+
+                        DestroyNetworkImpl(disconnectReason);
+
+                        break;
+                    }
+                case NetworkState.Station:
+                    {
+                        CloseStation();
+
+                        break;
+                    }
+                case NetworkState.StationConnected:
+                    {
+                        if (isCausedBySystem)
+                        {
+                            disconnectReason = DisconnectReason.DisconnectedBySystem;
+                        }
+                        else
+                        {
+                            disconnectReason = DisconnectReason.DisconnectedByUser;
+                        }
+
+                        DisconnectImpl(disconnectReason);
+
+                        break;
+                    }
+            }
+
+            SetState(NetworkState.None);
+
+            NetworkClient?.DisconnectAndStop();
+            NetworkClient = null;
+
+            return ResultCode.Success;
         }
 
         [CommandCmif(402)] // 7.0.0+
-        // Initialize(u64 ip_addresses, u64, pid)
+        // Initialize(u64 ip_addresses, pid)
         public ResultCode Initialize(ServiceCtx context)
         {
-            // TODO(Ac_K): Determine what addresses are.
-            IPAddress unknownAddress1 = new(context.RequestData.ReadUInt32());
-            IPAddress unknownAddress2 = new(context.RequestData.ReadUInt32());
+            _ = new IPAddress(context.RequestData.ReadUInt32());
+            _ = new IPAddress(context.RequestData.ReadUInt32());
+
+            // NOTE: It seems the guest can get ip_address and subnet_mask from nifm service and pass it through the initialize.
+            //       This calls InitializeImpl() twice: The first time with NIFM_REQUEST_ID, and if it fails, a second time with nifm_request_id = 1.
+
+            return InitializeImpl(context, context.Process.Pid, NifmRequestID);
+        }
+
+        public ResultCode InitializeImpl(ServiceCtx context, ulong pid, int nifmRequestId)
+        {
+            ResultCode resultCode = ResultCode.InvalidArgument;
+
+            if (nifmRequestId <= 255)
+            {
+                if (_state != NetworkState.Initialized)
+                {
+                    // NOTE: Service calls nn::ldn::detail::NetworkInterfaceManager::NetworkInterfaceMonitor::Initialize() with nifmRequestId as argument,
+                    //       then it stores the result code of it in a global variable. Since we use our own implementation, we can just check the connection
+                    //       and return related error codes.
+                    if (System.Net.NetworkInformation.NetworkInterface.GetIsNetworkAvailable())
+                    {
+                        MultiplayerMode mode = context.Device.Configuration.MultiplayerMode;
+                        switch (mode)
+                        {
+                            case MultiplayerMode.Disabled:
+                                NetworkClient = new DisabledLdnClient();
+                                break;
+                        }
+
+                        // TODO: Call nn::arp::GetApplicationLaunchProperty here when implemented.
+                        NetworkClient.SetGameVersion(context.Device.Processes.ActiveApplication.ApplicationControlProperties.DisplayVersion.Items.ToArray());
+
+                        resultCode = ResultCode.Success;
+
+                        _nifmResultCode = resultCode;
+
+                        SetState(NetworkState.Initialized);
+                    }
+                    else
+                    {
+                        // NOTE: Service returns differents ResultCode here related to the nifm ResultCode.
+                        resultCode = ResultCode.DeviceDisabled;
+                        _nifmResultCode = resultCode;
+                    }
+                }
+            }
+
+            return resultCode;
+        }
+
+        public void Dispose()
+        {
+            if (NetworkClient != null)
+            {
+                _station?.Dispose();
+                _accessPoint?.Dispose();
+
+                NetworkClient.DisconnectAndStop();
+            }
 
-            return _networkInterface.Initialize(UnknownValue, version: 1, unknownAddress1, unknownAddress2);
+            NetworkClient = null;
         }
     }
 }
author	TSRBerry <20988865+TSRBerry@users.noreply.github.com>	2023-09-25 23:50:43 +0200
committer	GitHub <noreply@github.com>	2023-09-25 23:50:43 +0200
commit	53bd4c9f603c95929ad17fffcce2fe1de04e3ae1 (patch)
tree	d93b6ba6f4032328a487ecebd5c8fc2851e14e7a /src/Ryujinx.HLE/HOS/Services/Ldn/UserServiceCreator/IUserLocalCommunicationService.cs
parent	eca8808649b7d763dd6b528bd26d43b7bd839cd2 (diff)