TESTERS WANTED: RyuLDN implementation (#65)

These changes allow players to matchmake for local wireless using a LDN
server. The network implementation originates from Berry's public TCP
RyuLDN fork. Logo and unrelated changes have been removed.

Additionally displays LDN game status in the game selection window when
RyuLDN is enabled.

Functionality is only enabled while network mode is set to "RyuLDN" in
the settings.

Directory.Packages.props

@@ -33,6 +33,7 @@
     <PackageVersion Include="OpenTK.Graphics" Version="4.8.2" />
     <PackageVersion Include="OpenTK.Audio.OpenAL" Version="4.8.2" />
     <PackageVersion Include="OpenTK.Windowing.GraphicsLibraryFramework" Version="4.8.2" />
+    <PackageVersion Include="Open.NAT.Core" Version="2.1.0.5" />
     <PackageVersion Include="Ryujinx.Audio.OpenAL.Dependencies" Version="1.21.0.1" />
     <PackageVersion Include="Ryujinx.Graphics.Nvdec.Dependencies" Version="5.0.3-build14" />
     <PackageVersion Include="Ryujinx.Graphics.Vulkan.Dependencies.MoltenVK" Version="1.2.0" />

src/Ryujinx.Common/Configuration/Multiplayer/MultiplayerMode.cs

@@ -3,6 +3,7 @@ namespace Ryujinx.Common.Configuration.Multiplayer
     public enum MultiplayerMode
     {
         Disabled,
+        LdnRyu,
         LdnMitm,
     }
 }

src/Ryujinx.Common/Memory/StructArrayHelpers.cs

@@ -803,18 +803,6 @@ namespace Ryujinx.Common.Memory
         public Span<T> AsSpan() => MemoryMarshal.CreateSpan(ref _e0, Length);
     }
 
-    public struct Array256<T> : IArray<T> where T : unmanaged
-    {
-        T _e0;
-        Array128<T> _other;
-        Array127<T> _other2;
-        public readonly int Length => 256;
-        public ref T this[int index] => ref AsSpan()[index];
-
-        [Pure]
-        public Span<T> AsSpan() => MemoryMarshal.CreateSpan(ref _e0, Length);
-    }
-
     public struct Array140<T> : IArray<T> where T : unmanaged
     {
         T _e0;
@@ -828,6 +816,18 @@ namespace Ryujinx.Common.Memory
         public Span<T> AsSpan() => MemoryMarshal.CreateSpan(ref _e0, Length);
     }
 
+    public struct Array256<T> : IArray<T> where T : unmanaged
+    {
+        T _e0;
+        Array128<T> _other;
+        Array127<T> _other2;
+        public readonly int Length => 256;
+        public ref T this[int index] => ref AsSpan()[index];
+
+        [Pure]
+        public Span<T> AsSpan() => MemoryMarshal.CreateSpan(ref _e0, Length);
+    }
+
     public struct Array384<T> : IArray<T> where T : unmanaged
     {
         T _e0;

src/Ryujinx.Common/Utilities/NetworkHelpers.cs

@@ -1,6 +1,7 @@
 using System.Buffers.Binary;
 using System.Net;
 using System.Net.NetworkInformation;
+using System.Runtime.InteropServices;
 
 namespace Ryujinx.Common.Utilities
 {
@@ -65,6 +66,11 @@ namespace Ryujinx.Common.Utilities
             return (targetProperties, targetAddressInfo);
         }
 
+        public static bool SupportsDynamicDns()
+        {
+            return RuntimeInformation.IsOSPlatform(OSPlatform.Windows);
+        }
+
         public static uint ConvertIpv4Address(IPAddress ipAddress)
         {
             return BinaryPrimitives.ReadUInt32BigEndian(ipAddress.GetAddressBytes());

src/Ryujinx.HLE/HLEConfiguration.cs

@@ -164,6 +164,21 @@ namespace Ryujinx.HLE
         /// </summary>
         public MultiplayerMode MultiplayerMode { internal get; set; }
 
+        /// <summary>
+        /// Disable P2P mode
+        /// </summary>
+        public bool MultiplayerDisableP2p { internal get; set; }
+
+        /// <summary>
+        /// Multiplayer Passphrase
+        /// </summary>
+        public string MultiplayerLdnPassphrase { internal get; set; }
+
+        /// <summary>
+        /// LDN Server
+        /// </summary>
+        public string MultiplayerLdnServer { internal get; set; }
+
         /// <summary>
         /// An action called when HLE force a refresh of output after docked mode changed.
         /// </summary>
@@ -194,7 +209,10 @@ namespace Ryujinx.HLE
                                 float audioVolume,
                                 bool useHypervisor,
                                 string multiplayerLanInterfaceId,
-                                MultiplayerMode multiplayerMode)
+                                MultiplayerMode multiplayerMode,
+                                bool multiplayerDisableP2p,
+                                string multiplayerLdnPassphrase,
+                                string multiplayerLdnServer)
         {
             VirtualFileSystem = virtualFileSystem;
             LibHacHorizonManager = libHacHorizonManager;
@@ -222,6 +240,9 @@ namespace Ryujinx.HLE
             UseHypervisor = useHypervisor;
             MultiplayerLanInterfaceId = multiplayerLanInterfaceId;
             MultiplayerMode = multiplayerMode;
+            MultiplayerDisableP2p = multiplayerDisableP2p;
+            MultiplayerLdnPassphrase = multiplayerLdnPassphrase;
+            MultiplayerLdnServer = multiplayerLdnServer;
         }
     }
 }

src/Ryujinx.HLE/HOS/Services/Ldn/Types/NetworkConfig.cs

@@ -3,7 +3,7 @@ using System.Runtime.InteropServices;
 
 namespace Ryujinx.HLE.HOS.Services.Ldn.Types
 {
-    [StructLayout(LayoutKind.Sequential, Size = 0x20)]
+    [StructLayout(LayoutKind.Sequential, Size = 0x20, Pack = 8)]
     struct NetworkConfig
     {
         public IntentId IntentId;

src/Ryujinx.HLE/HOS/Services/Ldn/Types/ScanFilter.cs

@@ -3,7 +3,7 @@ using System.Runtime.InteropServices;
 
 namespace Ryujinx.HLE.HOS.Services.Ldn.Types
 {
-    [StructLayout(LayoutKind.Sequential, Size = 0x60)]
+    [StructLayout(LayoutKind.Sequential, Size = 0x60, Pack = 8)]
     struct ScanFilter
     {
         public NetworkId NetworkId;

src/Ryujinx.HLE/HOS/Services/Ldn/Types/SecurityConfig.cs

@@ -3,7 +3,7 @@ using System.Runtime.InteropServices;
 
 namespace Ryujinx.HLE.HOS.Services.Ldn.Types
 {
-    [StructLayout(LayoutKind.Sequential, Size = 0x44)]
+    [StructLayout(LayoutKind.Sequential, Size = 0x44, Pack = 2)]
     struct SecurityConfig
     {
         public SecurityMode SecurityMode;

src/Ryujinx.HLE/HOS/Services/Ldn/Types/SecurityParameter.cs

@@ -3,7 +3,7 @@ using System.Runtime.InteropServices;
 
 namespace Ryujinx.HLE.HOS.Services.Ldn.Types
 {
-    [StructLayout(LayoutKind.Sequential, Size = 0x20)]
+    [StructLayout(LayoutKind.Sequential, Size = 0x20, Pack = 1)]
     struct SecurityParameter
     {
         public Array16<byte> Data;

src/Ryujinx.HLE/HOS/Services/Ldn/Types/UserConfig.cs

@@ -3,7 +3,7 @@ using System.Runtime.InteropServices;
 
 namespace Ryujinx.HLE.HOS.Services.Ldn.Types
 {
-    [StructLayout(LayoutKind.Sequential, Size = 0x30)]
+    [StructLayout(LayoutKind.Sequential, Size = 0x30, Pack = 1)]
     struct UserConfig
     {
         public Array33<byte> UserName;

src/Ryujinx.HLE/HOS/Services/Ldn/UserServiceCreator/AccessPoint.cs

@@ -15,6 +15,8 @@ namespace Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator
         public Array8<NodeLatestUpdate> LatestUpdates = new();
         public bool Connected { get; private set; }
 
+        public ProxyConfig Config => _parent.NetworkClient.Config;
+
         public AccessPoint(IUserLocalCommunicationService parent)
         {
             _parent = parent;
@@ -23,11 +25,14 @@ namespace Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator
         }
 
         public void Dispose()
+        {
+            if (_parent?.NetworkClient != null)
             {
                 _parent.NetworkClient.DisconnectNetwork();
 
                 _parent.NetworkClient.NetworkChange -= NetworkChanged;
             }
+        }
 
         private void NetworkChanged(object sender, NetworkChangeEventArgs e)
         {

src/Ryujinx.HLE/HOS/Services/Ldn/UserServiceCreator/INetworkClient.cs

@@ -6,6 +6,7 @@ namespace Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator
 {
     interface INetworkClient : IDisposable
     {
+        ProxyConfig Config { get; }
         bool NeedsRealId { get; }
 
         event EventHandler<NetworkChangeEventArgs> NetworkChange;

src/Ryujinx.HLE/HOS/Services/Ldn/UserServiceCreator/IUserLocalCommunicationService.cs

@@ -9,6 +9,8 @@ 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.LdnMitm;
+using Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator.LdnRyu;
+using Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator.Types;
 using Ryujinx.Horizon.Common;
 using Ryujinx.Memory;
 using System;
@@ -21,6 +23,9 @@ namespace Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator
 {
     class IUserLocalCommunicationService : IpcService, IDisposable
     {
+        public static string DefaultLanPlayHost = "ryuldn.vudjun.com";
+        public static short LanPlayPort = 30456;
+
         public INetworkClient NetworkClient { get; private set; }
 
         private const int NifmRequestID = 90;
@@ -174,6 +179,16 @@ namespace Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator
             // 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)
+            {
+                ProxyConfig config = _state switch
+                {
+                    NetworkState.AccessPointCreated => _accessPoint.Config,
+                    NetworkState.StationConnected => _station.Config,
+
+                    _ => default
+                };
+
+                if (config.ProxyIp == 0)
                 {
                     (_, UnicastIPAddressInformation unicastAddress) = NetworkHelpers.GetLocalInterface(context.Device.Configuration.MultiplayerLanInterfaceId);
 
@@ -191,6 +206,14 @@ namespace Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator
                     }
                 }
                 else
+                {
+                    Logger.Info?.Print(LogClass.ServiceLdn, $"LDN obtained proxy IP.");
+
+                    context.ResponseData.Write(config.ProxyIp);
+                    context.ResponseData.Write(config.ProxySubnetMask);
+                }
+            }
+            else
             {
                 return ResultCode.InvalidArgument;
             }
@@ -1066,6 +1089,27 @@ namespace Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator
 
                         switch (mode)
                         {
+                            case MultiplayerMode.LdnRyu:
+                                try
+                                {
+                                    string ldnServer = context.Device.Configuration.MultiplayerLdnServer;
+                                    if (string.IsNullOrEmpty(ldnServer))
+                                    {
+                                        ldnServer = DefaultLanPlayHost;
+                                    }
+                                    if (!IPAddress.TryParse(ldnServer, out IPAddress ipAddress))
+                                    {
+                                        ipAddress = Dns.GetHostEntry(ldnServer).AddressList[0];
+                                    }
+                                    NetworkClient = new LdnMasterProxyClient(ipAddress.ToString(), LanPlayPort, context.Device.Configuration);
+                                }
+                                catch (Exception ex)
+                                {
+                                    Logger.Error?.Print(LogClass.ServiceLdn, "Could not locate LdnRyu server. Defaulting to stubbed wireless.");
+                                    Logger.Error?.Print(LogClass.ServiceLdn, ex.Message);
+                                    NetworkClient = new LdnDisabledClient();
+                                }
+                                break;
                             case MultiplayerMode.LdnMitm:
                                 NetworkClient = new LdnMitmClient(context.Device.Configuration);
                                 break;
@@ -1103,7 +1147,7 @@ namespace Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator
             _accessPoint?.Dispose();
             _accessPoint = null;
 
-            NetworkClient?.Dispose();
+            NetworkClient?.DisconnectAndStop();
             NetworkClient = null;
         }
     }

src/Ryujinx.HLE/HOS/Services/Ldn/UserServiceCreator/LdnDisabledClient.cs

@@ -1,3 +1,4 @@
+using Ryujinx.Common.Logging;
 using Ryujinx.HLE.HOS.Services.Ldn.Types;
 using Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator.Types;
 using System;
@@ -6,12 +7,14 @@ namespace Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator
 {
     class LdnDisabledClient : INetworkClient
     {
+        public ProxyConfig Config { get; }
         public bool NeedsRealId => true;
 
         public event EventHandler<NetworkChangeEventArgs> NetworkChange;
 
         public NetworkError Connect(ConnectRequest request)
         {
+            Logger.Warning?.PrintMsg(LogClass.ServiceLdn, "Attempted to connect to a network, but Multiplayer is disabled!");
             NetworkChange?.Invoke(this, new NetworkChangeEventArgs(new NetworkInfo(), false));
 
             return NetworkError.None;
@@ -19,6 +22,7 @@ namespace Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator
 
         public NetworkError ConnectPrivate(ConnectPrivateRequest request)
         {
+            Logger.Warning?.PrintMsg(LogClass.ServiceLdn, "Attempted to connect to a network, but Multiplayer is disabled!");
             NetworkChange?.Invoke(this, new NetworkChangeEventArgs(new NetworkInfo(), false));
 
             return NetworkError.None;
@@ -26,6 +30,7 @@ namespace Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator
 
         public bool CreateNetwork(CreateAccessPointRequest request, byte[] advertiseData)
         {
+            Logger.Warning?.PrintMsg(LogClass.ServiceLdn, "Attempted to create a network, but Multiplayer is disabled!");
             NetworkChange?.Invoke(this, new NetworkChangeEventArgs(new NetworkInfo(), false));
 
             return true;
@@ -33,6 +38,7 @@ namespace Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator
 
         public bool CreateNetworkPrivate(CreateAccessPointPrivateRequest request, byte[] advertiseData)
         {
+            Logger.Warning?.PrintMsg(LogClass.ServiceLdn, "Attempted to create a network, but Multiplayer is disabled!");
             NetworkChange?.Invoke(this, new NetworkChangeEventArgs(new NetworkInfo(), false));
 
             return true;
@@ -49,6 +55,7 @@ namespace Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator
 
         public NetworkInfo[] Scan(ushort channel, ScanFilter scanFilter)
         {
+            Logger.Warning?.PrintMsg(LogClass.ServiceLdn, "Attempted to scan for networks, but Multiplayer is disabled!");
             return Array.Empty<NetworkInfo>();
         }
 

src/Ryujinx.HLE/HOS/Services/Ldn/UserServiceCreator/LdnMitm/LdnMitmClient.cs

@@ -12,6 +12,7 @@ namespace Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator.LdnMitm
     /// </summary>
     internal class LdnMitmClient : INetworkClient
     {
+        public ProxyConfig Config { get; }
         public bool NeedsRealId => false;
 
         public event EventHandler<NetworkChangeEventArgs> NetworkChange;

src/Ryujinx.HLE/HOS/Services/Ldn/UserServiceCreator/LdnRyu/IProxyClient.cs

@@ -0,0 +1,7 @@
+namespace Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator.LdnRyu
+{
+    interface IProxyClient
+    {
+        bool SendAsync(byte[] buffer);
+    }
+}

src/Ryujinx.HLE/HOS/Services/Ldn/UserServiceCreator/LdnRyu/LdnMasterProxyClient.cs

@@ -0,0 +1,645 @@
+using Ryujinx.Common.Logging;
+using Ryujinx.Common.Utilities;
+using Ryujinx.HLE.HOS.Services.Ldn.Types;
+using Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator.LdnRyu.Proxy;
+using Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator.LdnRyu.Types;
+using Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator.Types;
+using Ryujinx.HLE.HOS.Services.Sockets.Bsd.Proxy;
+using Ryujinx.HLE.Utilities;
+using System;
+using System.Collections.Generic;
+using System.Net;
+using System.Net.NetworkInformation;
+using System.Net.Sockets;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+using TcpClient = NetCoreServer.TcpClient;
+
+namespace Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator.LdnRyu
+{
+    class LdnMasterProxyClient : TcpClient, INetworkClient, IProxyClient
+    {
+        public bool NeedsRealId => true;
+
+        private static InitializeMessage InitializeMemory = new InitializeMessage();
+
+        private const int InactiveTimeout = 6000;
+        private const int FailureTimeout = 4000;
+        private const int ScanTimeout = 1000;
+
+        private bool _useP2pProxy;
+        private NetworkError _lastError;
+
+        private readonly ManualResetEvent _connected = new ManualResetEvent(false);
+        private readonly ManualResetEvent _error = new ManualResetEvent(false);
+        private readonly ManualResetEvent _scan = new ManualResetEvent(false);
+        private readonly ManualResetEvent _reject = new ManualResetEvent(false);
+        private readonly AutoResetEvent _apConnected = new AutoResetEvent(false);
+
+        private readonly RyuLdnProtocol _protocol;
+        private readonly NetworkTimeout _timeout;
+
+        private readonly List<NetworkInfo> _availableGames = new List<NetworkInfo>();
+        private DisconnectReason _disconnectReason;
+
+        private P2pProxyServer _hostedProxy;
+        private P2pProxyClient _connectedProxy;
+
+        private bool _networkConnected;
+
+        private string _passphrase;
+        private byte[] _gameVersion = new byte[0x10];
+
+        private readonly HLEConfiguration _config;
+
+        public event EventHandler<NetworkChangeEventArgs> NetworkChange;
+
+        public ProxyConfig Config { get; private set; }
+
+        public LdnMasterProxyClient(string address, int port, HLEConfiguration config) : base(address, port)
+        {
+            if (ProxyHelpers.SupportsNoDelay())
+            {
+                OptionNoDelay = true;
+            }
+
+            _protocol = new RyuLdnProtocol();
+            _timeout = new NetworkTimeout(InactiveTimeout, TimeoutConnection);
+
+            _protocol.Initialize += HandleInitialize;
+            _protocol.Connected += HandleConnected;
+            _protocol.Reject += HandleReject;
+            _protocol.RejectReply += HandleRejectReply;
+            _protocol.SyncNetwork += HandleSyncNetwork;
+            _protocol.ProxyConfig += HandleProxyConfig;
+            _protocol.Disconnected += HandleDisconnected;
+
+            _protocol.ScanReply += HandleScanReply;
+            _protocol.ScanReplyEnd += HandleScanReplyEnd;
+            _protocol.ExternalProxy += HandleExternalProxy;
+
+            _protocol.Ping += HandlePing;
+            _protocol.NetworkError += HandleNetworkError;
+
+            _config = config;
+            _useP2pProxy = !config.MultiplayerDisableP2p;
+        }
+
+        private void TimeoutConnection()
+        {
+            _connected.Reset();
+
+            DisconnectAsync();
+
+            while (IsConnected)
+            {
+                Thread.Yield();
+            }
+        }
+
+        private bool EnsureConnected()
+        {
+            if (IsConnected)
+            {
+                return true;
+            }
+
+            _error.Reset();
+
+            ConnectAsync();
+
+            int index = WaitHandle.WaitAny(new WaitHandle[] { _connected, _error }, FailureTimeout);
+
+            if (IsConnected)
+            {
+                SendAsync(_protocol.Encode(PacketId.Initialize, InitializeMemory));
+            }
+
+            return index == 0 && IsConnected;
+        }
+
+        private void UpdatePassphraseIfNeeded()
+        {
+            string passphrase = _config.MultiplayerLdnPassphrase ?? "";
+            if (passphrase != _passphrase)
+            {
+                _passphrase = passphrase;
+
+                SendAsync(_protocol.Encode(PacketId.Passphrase, StringUtils.GetFixedLengthBytes(passphrase, 0x80, Encoding.UTF8)));
+            }
+        }
+
+        protected override void OnConnected()
+        {
+            Logger.Info?.PrintMsg(LogClass.ServiceLdn, $"LDN TCP client connected a new session with Id {Id}");
+
+            UpdatePassphraseIfNeeded();
+
+            _connected.Set();
+        }
+
+        protected override void OnDisconnected()
+        {
+            Logger.Info?.PrintMsg(LogClass.ServiceLdn, $"LDN TCP client disconnected a session with Id {Id}");
+
+            _passphrase = null;
+
+            _connected.Reset();
+
+            if (_networkConnected)
+            {
+                DisconnectInternal();
+            }
+        }
+
+        public void DisconnectAndStop()
+        {
+            _timeout.Dispose();
+
+            DisconnectAsync();
+
+            while (IsConnected)
+            {
+                Thread.Yield();
+            }
+
+            Dispose();
+        }
+
+        protected override void OnReceived(byte[] buffer, long offset, long size)
+        {
+            _protocol.Read(buffer, (int)offset, (int)size);
+        }
+
+        protected override void OnError(SocketError error)
+        {
+            Logger.Info?.PrintMsg(LogClass.ServiceLdn, $"LDN TCP client caught an error with code {error}");
+
+            _error.Set();
+        }
+
+
+
+        private void HandleInitialize(LdnHeader header, InitializeMessage initialize)
+        {
+            InitializeMemory = initialize;
+        }
+
+        private void HandleExternalProxy(LdnHeader header, ExternalProxyConfig config)
+        {
+            int length = config.AddressFamily switch
+            {
+                AddressFamily.InterNetwork => 4,
+                AddressFamily.InterNetworkV6 => 16,
+                _ => 0
+            };
+
+            if (length == 0)
+            {
+                return; // Invalid external proxy.
+            }
+
+            IPAddress address = new(config.ProxyIp.AsSpan()[..length].ToArray());
+            P2pProxyClient proxy = new(address.ToString(), config.ProxyPort);
+
+            _connectedProxy = proxy;
+
+            bool success = proxy.PerformAuth(config);
+
+            if (!success)
+            {
+                DisconnectInternal();
+            }
+        }
+
+        private void HandlePing(LdnHeader header, PingMessage ping)
+        {
+            if (ping.Requester == 0) // Server requested.
+            {
+                // Send the ping message back.
+
+                SendAsync(_protocol.Encode(PacketId.Ping, ping));
+            }
+        }
+
+        private void HandleNetworkError(LdnHeader header, NetworkErrorMessage error)
+        {
+            if (error.Error == NetworkError.PortUnreachable)
+            {
+                _useP2pProxy = false;
+            }
+            else
+            {
+                _lastError = error.Error;
+            }
+        }
+
+        private NetworkError ConsumeNetworkError()
+        {
+            NetworkError result = _lastError;
+
+            _lastError = NetworkError.None;
+
+            return result;
+        }
+
+        private void HandleSyncNetwork(LdnHeader header, NetworkInfo info)
+        {
+            NetworkChange?.Invoke(this, new NetworkChangeEventArgs(info, true));
+        }
+
+        private void HandleConnected(LdnHeader header, NetworkInfo info)
+        {
+            _networkConnected = true;
+            _disconnectReason = DisconnectReason.None;
+
+            _apConnected.Set();
+
+            NetworkChange?.Invoke(this, new NetworkChangeEventArgs(info, true));
+        }
+
+        private void HandleDisconnected(LdnHeader header, DisconnectMessage message)
+        {
+            DisconnectInternal();
+        }
+
+        private void HandleReject(LdnHeader header, RejectRequest reject)
+        {
+            // When the client receives a Reject request, we have been rejected and will be disconnected shortly.
+            _disconnectReason = reject.DisconnectReason;
+        }
+
+        private void HandleRejectReply(LdnHeader header)
+        {
+            _reject.Set();
+        }
+
+        private void HandleScanReply(LdnHeader header, NetworkInfo info)
+        {
+            _availableGames.Add(info);
+        }
+
+        private void HandleScanReplyEnd(LdnHeader obj)
+        {
+            _scan.Set();
+        }
+
+        private void DisconnectInternal()
+        {
+            if (_networkConnected)
+            {
+                _networkConnected = false;
+
+                _hostedProxy?.Dispose();
+                _hostedProxy = null;
+
+                _connectedProxy?.Dispose();
+                _connectedProxy = null;
+
+                _apConnected.Reset();
+
+                NetworkChange?.Invoke(this, new NetworkChangeEventArgs(new NetworkInfo(), false, _disconnectReason));
+
+                if (IsConnected)
+                {
+                    _timeout.RefreshTimeout();
+                }
+            }
+        }
+
+        public void DisconnectNetwork()
+        {
+            if (_networkConnected)
+            {
+                SendAsync(_protocol.Encode(PacketId.Disconnect, new DisconnectMessage()));
+
+                DisconnectInternal();
+            }
+        }
+
+        public ResultCode Reject(DisconnectReason disconnectReason, uint nodeId)
+        {
+            if (_networkConnected)
+            {
+                _reject.Reset();
+
+                SendAsync(_protocol.Encode(PacketId.Reject, new RejectRequest(disconnectReason, nodeId)));
+
+                int index = WaitHandle.WaitAny(new WaitHandle[] { _reject, _error }, InactiveTimeout);
+
+                if (index == 0)
+                {
+                    return (ConsumeNetworkError() != NetworkError.None) ? ResultCode.InvalidState : ResultCode.Success;
+                }
+            }
+
+            return ResultCode.InvalidState;
+        }
+
+        public void SetAdvertiseData(byte[] data)
+        {
+            // TODO: validate we're the owner (the server will do this anyways tho)
+            if (_networkConnected)
+            {
+                SendAsync(_protocol.Encode(PacketId.SetAdvertiseData, data));
+            }
+        }
+
+        public void SetGameVersion(byte[] versionString)
+        {
+            _gameVersion = versionString;
+
+            if (_gameVersion.Length < 0x10)
+            {
+                Array.Resize(ref _gameVersion, 0x10);
+            }
+        }
+
+        public void SetStationAcceptPolicy(AcceptPolicy acceptPolicy)
+        {
+            // TODO: validate we're the owner (the server will do this anyways tho)
+            if (_networkConnected)
+            {
+                SendAsync(_protocol.Encode(PacketId.SetAcceptPolicy, new SetAcceptPolicyRequest
+                {
+                    StationAcceptPolicy = acceptPolicy
+                }));
+            }
+        }
+
+        private void DisposeProxy()
+        {
+            _hostedProxy?.Dispose();
+            _hostedProxy = null;
+        }
+
+        private void ConfigureAccessPoint(ref RyuNetworkConfig request)
+        {
+            _gameVersion.AsSpan().CopyTo(request.GameVersion.AsSpan());
+
+            if (_useP2pProxy)
+            {
+                // Before sending the request, attempt to set up a proxy server.
+                // This can be on a range of private ports, which can be exposed on a range of public
+                // ports via UPnP. If any of this fails, we just fall back to using the master server.
+
+                int i = 0;
+                for (; i < P2pProxyServer.PrivatePortRange; i++)
+                {
+                    _hostedProxy = new P2pProxyServer(this, (ushort)(P2pProxyServer.PrivatePortBase + i), _protocol);
+
+                    try
+                    {
+                        _hostedProxy.Start();
+
+                        break;
+                    }
+                    catch (SocketException e)
+                    {
+                        _hostedProxy.Dispose();
+                        _hostedProxy = null;
+
+                        if (e.SocketErrorCode != SocketError.AddressAlreadyInUse)
+                        {
+                            i = P2pProxyServer.PrivatePortRange; // Immediately fail.
+                        }
+                    }
+                }
+
+                bool openSuccess = i < P2pProxyServer.PrivatePortRange;
+
+                if (openSuccess)
+                {
+                    Task<ushort> natPunchResult = _hostedProxy.NatPunch();
+
+                    try
+                    {
+                        if (natPunchResult.Result != 0)
+                        {
+                            // Tell the server that we are hosting the proxy.
+                            request.ExternalProxyPort = natPunchResult.Result;
+                        }
+                    }
+                    catch (Exception) { }
+
+                    if (request.ExternalProxyPort == 0)
+                    {
+                        Logger.Warning?.Print(LogClass.ServiceLdn, "Failed to open a port with UPnP for P2P connection. Proxying through the master server instead. Expect higher latency.");
+                        _hostedProxy.Dispose();
+                    }
+                    else
+                    {
+                        Logger.Info?.Print(LogClass.ServiceLdn, $"Created a wireless P2P network on port {request.ExternalProxyPort}.");
+                        _hostedProxy.Start();
+
+                        (_, UnicastIPAddressInformation unicastAddress) = NetworkHelpers.GetLocalInterface();
+
+                        unicastAddress.Address.GetAddressBytes().AsSpan().CopyTo(request.PrivateIp.AsSpan());
+                        request.InternalProxyPort = _hostedProxy.PrivatePort;
+                        request.AddressFamily = unicastAddress.Address.AddressFamily;
+                    }
+                }
+                else
+                {
+                    Logger.Warning?.Print(LogClass.ServiceLdn, "Cannot create a P2P server. Proxying through the master server instead. Expect higher latency.");
+                }
+            }
+        }
+
+        private bool CreateNetworkCommon()
+        {
+            bool signalled = _apConnected.WaitOne(FailureTimeout);
+
+            if (!_useP2pProxy && _hostedProxy != null)
+            {
+                Logger.Warning?.Print(LogClass.ServiceLdn, "Locally hosted proxy server was not externally reachable. Proxying through the master server instead. Expect higher latency.");
+
+                DisposeProxy();
+            }
+
+            if (signalled && _connectedProxy != null)
+            {
+                _connectedProxy.EnsureProxyReady();
+
+                Config = _connectedProxy.ProxyConfig;
+            }
+            else
+            {
+                DisposeProxy();
+            }
+
+            return signalled;
+        }
+
+        public bool CreateNetwork(CreateAccessPointRequest request, byte[] advertiseData)
+        {
+            _timeout.DisableTimeout();
+
+            ConfigureAccessPoint(ref request.RyuNetworkConfig);
+
+            if (!EnsureConnected())
+            {
+                DisposeProxy();
+
+                return false;
+            }
+
+            UpdatePassphraseIfNeeded();
+
+            SendAsync(_protocol.Encode(PacketId.CreateAccessPoint, request, advertiseData));
+
+            // Send a network change event with dummy data immediately. Necessary to avoid crashes in some games
+            var networkChangeEvent = new NetworkChangeEventArgs(new NetworkInfo()
+            {
+                Common = new CommonNetworkInfo()
+                {
+                    MacAddress = InitializeMemory.MacAddress,
+                    Channel = request.NetworkConfig.Channel,
+                    LinkLevel = 3,
+                    NetworkType = 2,
+                    Ssid = new Ssid()
+                    {
+                        Length = 32
+                    }
+                },
+                Ldn = new LdnNetworkInfo()
+                {
+                    AdvertiseDataSize = (ushort)advertiseData.Length,
+                    AuthenticationId = 0,
+                    NodeCount = 1,
+                    NodeCountMax = request.NetworkConfig.NodeCountMax,
+                    SecurityMode = (ushort)request.SecurityConfig.SecurityMode
+                }
+            }, true);
+            networkChangeEvent.Info.Ldn.Nodes[0] = new NodeInfo()
+            {
+                Ipv4Address = 175243265,
+                IsConnected = 1,
+                LocalCommunicationVersion = request.NetworkConfig.LocalCommunicationVersion,
+                MacAddress = InitializeMemory.MacAddress,
+                NodeId = 0,
+                UserName = request.UserConfig.UserName
+            };
+            "12345678123456781234567812345678"u8.ToArray().CopyTo(networkChangeEvent.Info.Common.Ssid.Name.AsSpan());
+            NetworkChange?.Invoke(this, networkChangeEvent);
+
+            return CreateNetworkCommon();
+        }
+
+        public bool CreateNetworkPrivate(CreateAccessPointPrivateRequest request, byte[] advertiseData)
+        {
+            _timeout.DisableTimeout();
+
+            ConfigureAccessPoint(ref request.RyuNetworkConfig);
+
+            if (!EnsureConnected())
+            {
+                DisposeProxy();
+
+                return false;
+            }
+
+            UpdatePassphraseIfNeeded();
+
+            SendAsync(_protocol.Encode(PacketId.CreateAccessPointPrivate, request, advertiseData));
+
+            return CreateNetworkCommon();
+        }
+
+        public NetworkInfo[] Scan(ushort channel, ScanFilter scanFilter)
+        {
+            if (!_networkConnected)
+            {
+                _timeout.RefreshTimeout();
+            }
+
+            _availableGames.Clear();
+
+            int index = -1;
+
+            if (EnsureConnected())
+            {
+                UpdatePassphraseIfNeeded();
+
+                _scan.Reset();
+
+                SendAsync(_protocol.Encode(PacketId.Scan, scanFilter));
+
+                index = WaitHandle.WaitAny(new WaitHandle[] { _scan, _error }, ScanTimeout);
+            }
+
+            if (index != 0)
+            {
+                // An error occurred or timeout. Write 0 games.
+                return Array.Empty<NetworkInfo>();
+            }
+
+            return _availableGames.ToArray();
+        }
+
+        private NetworkError ConnectCommon()
+        {
+            bool signalled = _apConnected.WaitOne(FailureTimeout);
+
+            NetworkError error = ConsumeNetworkError();
+
+            if (error != NetworkError.None)
+            {
+                return error;
+            }
+
+            if (signalled && _connectedProxy != null)
+            {
+                _connectedProxy.EnsureProxyReady();
+
+                Config = _connectedProxy.ProxyConfig;
+            }
+
+            return signalled ? NetworkError.None : NetworkError.ConnectTimeout;
+        }
+
+        public NetworkError Connect(ConnectRequest request)
+        {
+            _timeout.DisableTimeout();
+
+            if (!EnsureConnected())
+            {
+                return NetworkError.Unknown;
+            }
+
+            SendAsync(_protocol.Encode(PacketId.Connect, request));
+
+            var networkChangeEvent = new NetworkChangeEventArgs(new NetworkInfo()
+            {
+                Common = request.NetworkInfo.Common,
+                Ldn = request.NetworkInfo.Ldn
+            }, true);
+
+            NetworkChange?.Invoke(this, networkChangeEvent);
+
+            return ConnectCommon();
+        }
+
+        public NetworkError ConnectPrivate(ConnectPrivateRequest request)
+        {
+            _timeout.DisableTimeout();
+
+            if (!EnsureConnected())
+            {
+                return NetworkError.Unknown;
+            }
+
+            SendAsync(_protocol.Encode(PacketId.ConnectPrivate, request));
+
+            return ConnectCommon();
+        }
+
+        private void HandleProxyConfig(LdnHeader header, ProxyConfig config)
+        {
+            Config = config;
+
+            SocketHelpers.RegisterProxy(new LdnProxy(config, this, _protocol));
+        }
+    }
+}

src/Ryujinx.HLE/HOS/Services/Ldn/UserServiceCreator/LdnRyu/NetworkTimeout.cs

@@ -0,0 +1,83 @@
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator.LdnRyu
+{
+    class NetworkTimeout : IDisposable
+    {
+        private readonly int _idleTimeout;
+        private readonly Action _timeoutCallback;
+        private CancellationTokenSource _cancel;
+
+        private readonly object _lock = new object();
+
+        public NetworkTimeout(int idleTimeout, Action timeoutCallback)
+        {
+            _idleTimeout = idleTimeout;
+            _timeoutCallback = timeoutCallback;
+        }
+
+        private async Task TimeoutTask()
+        {
+            CancellationTokenSource cts;
+
+            lock (_lock)
+            {
+                cts = _cancel;
+            }
+
+            if (cts == null)
+            {
+                return;
+            }
+
+            try
+            {
+                await Task.Delay(_idleTimeout, cts.Token);
+            }
+            catch (TaskCanceledException)
+            {
+                return; // Timeout cancelled.
+            }
+
+            lock (_lock)
+            {
+                // Run the timeout callback. If the cancel token source has been replaced, we have _just_ been cancelled.
+                if (cts == _cancel)
+                {
+                    _timeoutCallback();
+                }
+            }
+        }
+
+        public bool RefreshTimeout()
+        {
+            lock (_lock)
+            {
+                _cancel?.Cancel();
+
+                _cancel = new CancellationTokenSource();
+
+                Task.Run(TimeoutTask);
+            }
+
+            return true;
+        }
+
+        public void DisableTimeout()
+        {
+            lock (_lock)
+            {
+                _cancel?.Cancel();
+
+                _cancel = new CancellationTokenSource();
+            }
+        }
+
+        public void Dispose()
+        {
+            DisableTimeout();
+        }
+    }
+}

src/Ryujinx.HLE/HOS/Services/Ldn/UserServiceCreator/LdnRyu/Proxy/EphemeralPortPool.cs

@@ -0,0 +1,53 @@
+using System.Collections.Generic;
+
+namespace Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator.LdnRyu.Proxy
+{
+    public class EphemeralPortPool
+    {
+        private const ushort EphemeralBase = 49152;
+
+        private readonly List<ushort> _ephemeralPorts = new List<ushort>();
+
+        private readonly object _lock = new object();
+
+        public ushort Get()
+        {
+            ushort port = EphemeralBase;
+            lock (_lock)
+            {
+                // Starting at the ephemeral port base, return an ephemeral port that is not in use.
+                // Returns 0 if the range is exhausted.
+
+                for (int i = 0; i < _ephemeralPorts.Count; i++)
+                {
+                    ushort existingPort = _ephemeralPorts[i];
+
+                    if (existingPort > port)
+                    {
+                        // The port was free - take it.
+                        _ephemeralPorts.Insert(i, port);
+
+                        return port;
+                    }
+
+                    port++;
+                }
+
+                if (port != 0)
+                {
+                    _ephemeralPorts.Add(port);
+                }
+
+                return port;
+            }
+        }
+
+        public void Return(ushort port)
+        {
+            lock (_lock)
+            {
+                _ephemeralPorts.Remove(port);
+            }
+        }
+    }
+}

src/Ryujinx.HLE/HOS/Services/Ldn/UserServiceCreator/LdnRyu/Proxy/LdnProxy.cs

@@ -0,0 +1,254 @@
+using Ryujinx.Common.Logging;
+using Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator.LdnRyu.Types;
+using Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator.Types;
+using System;
+using System.Collections.Generic;
+using System.Net;
+using System.Net.Sockets;
+
+namespace Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator.LdnRyu.Proxy
+{
+    class LdnProxy : IDisposable
+    {
+        public EndPoint LocalEndpoint { get; }
+        public IPAddress LocalAddress { get; }
+
+        private readonly List<LdnProxySocket> _sockets = new List<LdnProxySocket>();
+        private readonly Dictionary<ProtocolType, EphemeralPortPool> _ephemeralPorts = new Dictionary<ProtocolType, EphemeralPortPool>();
+
+        private readonly IProxyClient _parent;
+        private RyuLdnProtocol _protocol;
+        private readonly uint _subnetMask;
+        private readonly uint _localIp;
+        private readonly uint _broadcast;
+
+        public LdnProxy(ProxyConfig config, IProxyClient client, RyuLdnProtocol protocol)
+        {
+            _parent = client;
+            _protocol = protocol;
+
+            _ephemeralPorts[ProtocolType.Udp] = new EphemeralPortPool();
+            _ephemeralPorts[ProtocolType.Tcp] = new EphemeralPortPool();
+
+            byte[] address = BitConverter.GetBytes(config.ProxyIp);
+            Array.Reverse(address);
+            LocalAddress = new IPAddress(address);
+
+            _subnetMask = config.ProxySubnetMask;
+            _localIp = config.ProxyIp;
+            _broadcast = _localIp | (~_subnetMask);
+
+            RegisterHandlers(protocol);
+        }
+
+        public bool Supported(AddressFamily domain, SocketType type, ProtocolType protocol)
+        {
+            if (protocol == ProtocolType.Tcp)
+            {
+                Logger.Error?.PrintMsg(LogClass.ServiceLdn, "Tcp proxy networking is untested. Please report this game so that it can be tested.");
+            }
+            return domain == AddressFamily.InterNetwork && (protocol == ProtocolType.Tcp || protocol == ProtocolType.Udp);
+        }
+
+        private void RegisterHandlers(RyuLdnProtocol protocol)
+        {
+            protocol.ProxyConnect += HandleConnectionRequest;
+            protocol.ProxyConnectReply += HandleConnectionResponse;
+            protocol.ProxyData += HandleData;
+            protocol.ProxyDisconnect += HandleDisconnect;
+
+            _protocol = protocol;
+        }
+
+        public void UnregisterHandlers(RyuLdnProtocol protocol)
+        {
+            protocol.ProxyConnect -= HandleConnectionRequest;
+            protocol.ProxyConnectReply -= HandleConnectionResponse;
+            protocol.ProxyData -= HandleData;
+            protocol.ProxyDisconnect -= HandleDisconnect;
+        }
+
+        public ushort GetEphemeralPort(ProtocolType type)
+        {
+            return _ephemeralPorts[type].Get();
+        }
+
+        public void ReturnEphemeralPort(ProtocolType type, ushort port)
+        {
+            _ephemeralPorts[type].Return(port);
+        }
+
+        public void RegisterSocket(LdnProxySocket socket)
+        {
+            lock (_sockets)
+            {
+                _sockets.Add(socket);
+            }
+        }
+
+        public void UnregisterSocket(LdnProxySocket socket)
+        {
+            lock (_sockets)
+            {
+                _sockets.Remove(socket);
+            }
+        }
+
+        private void ForRoutedSockets(ProxyInfo info, Action<LdnProxySocket> action)
+        {
+            lock (_sockets)
+            {
+                foreach (LdnProxySocket socket in _sockets)
+                {
+                    // Must match protocol and destination port.
+                    if (socket.ProtocolType != info.Protocol || socket.LocalEndPoint is not IPEndPoint endpoint || endpoint.Port != info.DestPort)
+                    {
+                        continue;
+                    }
+
+                    // We can assume packets routed to us have been sent to our destination.
+                    // They will either be sent to us, or broadcast packets.
+
+                    action(socket);
+                }
+            }
+        }
+
+        public void HandleConnectionRequest(LdnHeader header, ProxyConnectRequest request)
+        {
+            ForRoutedSockets(request.Info, (socket) =>
+            {
+                socket.HandleConnectRequest(request);
+            });
+        }
+
+        public void HandleConnectionResponse(LdnHeader header, ProxyConnectResponse response)
+        {
+            ForRoutedSockets(response.Info, (socket) =>
+            {
+                socket.HandleConnectResponse(response);
+            });
+        }
+
+        public void HandleData(LdnHeader header, ProxyDataHeader proxyHeader, byte[] data)
+        {
+            ProxyDataPacket packet = new ProxyDataPacket() { Header = proxyHeader, Data = data };
+
+            ForRoutedSockets(proxyHeader.Info, (socket) =>
+            {
+                socket.IncomingData(packet);
+            });
+        }
+
+        public void HandleDisconnect(LdnHeader header, ProxyDisconnectMessage disconnect)
+        {
+            ForRoutedSockets(disconnect.Info, (socket) =>
+            {
+                socket.HandleDisconnect(disconnect);
+            });
+        }
+
+        private uint GetIpV4(IPEndPoint endpoint)
+        {
+            if (endpoint.AddressFamily != AddressFamily.InterNetwork)
+            {
+                throw new NotSupportedException();
+            }
+
+            byte[] address = endpoint.Address.GetAddressBytes();
+            Array.Reverse(address);
+
+            return BitConverter.ToUInt32(address);
+        }
+
+        private ProxyInfo MakeInfo(IPEndPoint localEp, IPEndPoint remoteEP, ProtocolType type)
+        {
+            return new ProxyInfo
+            {
+                SourceIpV4 = GetIpV4(localEp),
+                SourcePort = (ushort)localEp.Port,
+
+                DestIpV4 = GetIpV4(remoteEP),
+                DestPort = (ushort)remoteEP.Port,
+
+                Protocol = type
+            };
+        }
+
+        public void RequestConnection(IPEndPoint localEp, IPEndPoint remoteEp, ProtocolType type)
+        {
+            // We must ask the other side to initialize a connection, so they can accept a socket for us.
+
+            ProxyConnectRequest request = new ProxyConnectRequest
+            {
+                Info = MakeInfo(localEp, remoteEp, type)
+            };
+
+            _parent.SendAsync(_protocol.Encode(PacketId.ProxyConnect, request));
+        }
+
+        public void SignalConnected(IPEndPoint localEp, IPEndPoint remoteEp, ProtocolType type)
+        {
+            // We must tell the other side that we have accepted their request for connection.
+
+            ProxyConnectResponse request = new ProxyConnectResponse
+            {
+                Info = MakeInfo(localEp, remoteEp, type)
+            };
+
+            _parent.SendAsync(_protocol.Encode(PacketId.ProxyConnectReply, request));
+        }
+
+        public void EndConnection(IPEndPoint localEp, IPEndPoint remoteEp, ProtocolType type)
+        {
+            // We must tell the other side that our connection is dropped.
+
+            ProxyDisconnectMessage request = new ProxyDisconnectMessage
+            {
+                Info = MakeInfo(localEp, remoteEp, type),
+                DisconnectReason = 0 // TODO
+            };
+
+            _parent.SendAsync(_protocol.Encode(PacketId.ProxyDisconnect, request));
+        }
+
+        public int SendTo(ReadOnlySpan<byte> buffer, SocketFlags flags, IPEndPoint localEp, IPEndPoint remoteEp, ProtocolType type)
+        {
+            // We send exactly as much as the user wants us to, currently instantly.
+            // TODO: handle over "virtual mtu" (we have a max packet size to worry about anyways). fragment if tcp? throw if udp?
+
+            ProxyDataHeader request = new ProxyDataHeader
+            {
+                Info = MakeInfo(localEp, remoteEp, type),
+                DataLength = (uint)buffer.Length
+            };
+
+            _parent.SendAsync(_protocol.Encode(PacketId.ProxyData, request, buffer.ToArray()));
+
+            return buffer.Length;
+        }
+
+        public bool IsBroadcast(uint ip)
+        {
+            return ip == _broadcast;
+        }
+
+        public bool IsMyself(uint ip)
+        {
+            return ip == _localIp;
+        }
+
+        public void Dispose()
+        {
+            UnregisterHandlers(_protocol);
+
+            lock (_sockets)
+            {
+                foreach (LdnProxySocket socket in _sockets)
+                {
+                    socket.ProxyDestroyed();
+                }
+            }
+        }
+    }
+}

src/Ryujinx.HLE/HOS/Services/Ldn/UserServiceCreator/LdnRyu/Proxy/LdnProxySocket.cs

@@ -0,0 +1,797 @@
+using Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator.LdnRyu.Types;
+using Ryujinx.HLE.HOS.Services.Sockets.Bsd.Impl;
+using Ryujinx.HLE.HOS.Services.Sockets.Bsd.Proxy;
+using System;
+using System.Collections.Generic;
+using System.Net;
+using System.Net.Sockets;
+using System.Threading;
+
+namespace Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator.LdnRyu.Proxy
+{
+    /// <summary>
+    /// This socket is forwarded through a TCP stream that goes through the Ldn server.
+    /// The Ldn server will then route the packets we send (or need to receive) within the virtual adhoc network.
+    /// </summary>
+    class LdnProxySocket : ISocketImpl
+    {
+        private readonly LdnProxy _proxy;
+
+        private bool _isListening;
+        private readonly List<LdnProxySocket> _listenSockets = new List<LdnProxySocket>();
+
+        private readonly Queue<ProxyConnectRequest> _connectRequests = new Queue<ProxyConnectRequest>();
+
+        private readonly AutoResetEvent _acceptEvent = new AutoResetEvent(false);
+        private readonly int _acceptTimeout = -1;
+
+        private readonly Queue<int> _errors = new Queue<int>();
+
+        private readonly AutoResetEvent _connectEvent = new AutoResetEvent(false);
+        private ProxyConnectResponse _connectResponse;
+
+        private int _receiveTimeout = -1;
+        private readonly AutoResetEvent _receiveEvent = new AutoResetEvent(false);
+        private readonly Queue<ProxyDataPacket> _receiveQueue = new Queue<ProxyDataPacket>();
+
+        // private int _sendTimeout = -1; // Sends are techically instant right now, so not _really_ used.
+
+        private bool _connecting;
+        private bool _broadcast;
+        private bool _readShutdown;
+        // private bool _writeShutdown;
+        private bool _closed;
+
+        private readonly Dictionary<SocketOptionName, int> _socketOptions = new Dictionary<SocketOptionName, int>()
+        {
+            { SocketOptionName.Broadcast,       0 }, //TODO: honor this value
+            { SocketOptionName.DontLinger,      0 },
+            { SocketOptionName.Debug,           0 },
+            { SocketOptionName.Error,           0 },
+            { SocketOptionName.KeepAlive,       0 },
+            { SocketOptionName.OutOfBandInline, 0 },
+            { SocketOptionName.ReceiveBuffer,   131072 },
+            { SocketOptionName.ReceiveTimeout,  -1 },
+            { SocketOptionName.SendBuffer,      131072 },
+            { SocketOptionName.SendTimeout,     -1 },
+            { SocketOptionName.Type,            0 },
+            { SocketOptionName.ReuseAddress,    0 } //TODO: honor this value
+        };
+
+        public EndPoint RemoteEndPoint { get; private set; }
+
+        public EndPoint LocalEndPoint { get; private set; }
+
+        public bool Connected { get; private set; }
+
+        public bool IsBound { get; private set; }
+
+        public AddressFamily AddressFamily { get; }
+
+        public SocketType SocketType { get; }
+
+        public ProtocolType ProtocolType { get; }
+
+        public bool Blocking { get; set; }
+
+        public int Available
+        {
+            get
+            {
+                int result = 0;
+
+                lock (_receiveQueue)
+                {
+                    foreach (ProxyDataPacket data in _receiveQueue)
+                    {
+                        result += data.Data.Length;
+                    }
+                }
+
+                return result;
+            }
+        }
+
+        public bool Readable
+        {
+            get
+            {
+                if (_isListening)
+                {
+                    lock (_connectRequests)
+                    {
+                        return _connectRequests.Count > 0;
+                    }
+                }
+                else
+                {
+                    if (_readShutdown)
+                    {
+                        return true;
+                    }
+
+                    lock (_receiveQueue)
+                    {
+                        return _receiveQueue.Count > 0;
+                    }
+                }
+
+            }
+        }
+        public bool Writable => Connected || ProtocolType == ProtocolType.Udp;
+        public bool Error => false;
+
+        public LdnProxySocket(AddressFamily addressFamily, SocketType socketType, ProtocolType protocolType, LdnProxy proxy)
+        {
+            AddressFamily = addressFamily;
+            SocketType = socketType;
+            ProtocolType = protocolType;
+
+            _proxy = proxy;
+            _socketOptions[SocketOptionName.Type] = (int)socketType;
+
+            proxy.RegisterSocket(this);
+        }
+
+        private IPEndPoint EnsureLocalEndpoint(bool replace)
+        {
+            if (LocalEndPoint != null)
+            {
+                if (replace)
+                {
+                    _proxy.ReturnEphemeralPort(ProtocolType, (ushort)((IPEndPoint)LocalEndPoint).Port);
+                }
+                else
+                {
+                    return (IPEndPoint)LocalEndPoint;
+                }
+            }
+
+            IPEndPoint localEp = new IPEndPoint(_proxy.LocalAddress, _proxy.GetEphemeralPort(ProtocolType));
+            LocalEndPoint = localEp;
+
+            return localEp;
+        }
+
+        public LdnProxySocket AsAccepted(IPEndPoint remoteEp)
+        {
+            Connected = true;
+            RemoteEndPoint = remoteEp;
+
+            IPEndPoint localEp = EnsureLocalEndpoint(true);
+
+            _proxy.SignalConnected(localEp, remoteEp, ProtocolType);
+
+            return this;
+        }
+
+        private void SignalError(WsaError error)
+        {
+            lock (_errors)
+            {
+                _errors.Enqueue((int)error);
+            }
+        }
+
+        private IPEndPoint GetEndpoint(uint ipv4, ushort port)
+        {
+            byte[] address = BitConverter.GetBytes(ipv4);
+            Array.Reverse(address);
+
+            return new IPEndPoint(new IPAddress(address), port);
+        }
+
+        public void IncomingData(ProxyDataPacket packet)
+        {
+            bool isBroadcast = _proxy.IsBroadcast(packet.Header.Info.DestIpV4);
+
+            if (!_closed && (_broadcast || !isBroadcast))
+            {
+                lock (_receiveQueue)
+                {
+                    _receiveQueue.Enqueue(packet);
+                }
+            }
+        }
+
+        public ISocketImpl Accept()
+        {
+            if (!_isListening)
+            {
+                throw new InvalidOperationException();
+            }
+
+            // Accept a pending request to this socket.
+
+            lock (_connectRequests)
+            {
+                if (!Blocking && _connectRequests.Count == 0)
+                {
+                    throw new SocketException((int)WsaError.WSAEWOULDBLOCK);
+                }
+            }
+
+            while (true)
+            {
+                _acceptEvent.WaitOne(_acceptTimeout);
+
+                lock (_connectRequests)
+                {
+                    while (_connectRequests.Count > 0)
+                    {
+                        ProxyConnectRequest request = _connectRequests.Dequeue();
+
+                        if (_connectRequests.Count > 0)
+                        {
+                            _acceptEvent.Set(); // Still more accepts to do.
+                        }
+
+                        // Is this request made for us?
+                        IPEndPoint endpoint = GetEndpoint(request.Info.DestIpV4, request.Info.DestPort);
+
+                        if (Equals(endpoint, LocalEndPoint))
+                        {
+                            // Yes - let's accept.
+                            IPEndPoint remoteEndpoint = GetEndpoint(request.Info.SourceIpV4, request.Info.SourcePort);
+
+                            LdnProxySocket socket = new LdnProxySocket(AddressFamily, SocketType, ProtocolType, _proxy).AsAccepted(remoteEndpoint);
+
+                            lock (_listenSockets)
+                            {
+                                _listenSockets.Add(socket);
+                            }
+
+                            return socket;
+                        }
+                    }
+                }
+            }
+        }
+
+        public void Bind(EndPoint localEP)
+        {
+            ArgumentNullException.ThrowIfNull(localEP);
+
+            if (LocalEndPoint != null)
+            {
+                _proxy.ReturnEphemeralPort(ProtocolType, (ushort)((IPEndPoint)LocalEndPoint).Port);
+            }
+            var asIPEndpoint = (IPEndPoint)localEP;
+            if (asIPEndpoint.Port == 0)
+            {
+                asIPEndpoint.Port = (ushort)_proxy.GetEphemeralPort(ProtocolType);
+            }
+
+            LocalEndPoint = (IPEndPoint)localEP;
+
+            IsBound = true;
+        }
+
+        public void Close()
+        {
+            _closed = true;
+
+            _proxy.UnregisterSocket(this);
+
+            if (Connected)
+            {
+                Disconnect(false);
+            }
+
+            lock (_listenSockets)
+            {
+                foreach (LdnProxySocket socket in _listenSockets)
+                {
+                    socket.Close();
+                }
+            }
+
+            _isListening = false;
+        }
+
+        public void Connect(EndPoint remoteEP)
+        {
+            if (_isListening || !IsBound)
+            {
+                throw new InvalidOperationException();
+            }
+
+            if (remoteEP is not IPEndPoint)
+            {
+                throw new NotSupportedException();
+            }
+
+            IPEndPoint localEp = EnsureLocalEndpoint(true);
+
+            _connecting = true;
+
+            _proxy.RequestConnection(localEp, (IPEndPoint)remoteEP, ProtocolType);
+
+            if (!Blocking && ProtocolType == ProtocolType.Tcp)
+            {
+                throw new SocketException((int)WsaError.WSAEWOULDBLOCK);
+            }
+
+            _connectEvent.WaitOne(); //timeout?
+
+            if (_connectResponse.Info.SourceIpV4 == 0)
+            {
+                throw new SocketException((int)WsaError.WSAECONNREFUSED);
+            }
+
+            _connectResponse = default;
+        }
+
+        public void HandleConnectResponse(ProxyConnectResponse obj)
+        {
+            if (!_connecting)
+            {
+                return;
+            }
+
+            _connecting = false;
+
+            if (_connectResponse.Info.SourceIpV4 != 0)
+            {
+                IPEndPoint remoteEp = GetEndpoint(obj.Info.SourceIpV4, obj.Info.SourcePort);
+                RemoteEndPoint = remoteEp;
+
+                Connected = true;
+            }
+            else
+            {
+                // Connection failed
+
+                SignalError(WsaError.WSAECONNREFUSED);
+            }
+        }
+
+        public void Disconnect(bool reuseSocket)
+        {
+            if (Connected)
+            {
+                ConnectionEnded();
+
+                // The other side needs to be notified that connection ended.
+                _proxy.EndConnection(LocalEndPoint as IPEndPoint, RemoteEndPoint as IPEndPoint, ProtocolType);
+            }
+        }
+
+        private void ConnectionEnded()
+        {
+            if (Connected)
+            {
+                RemoteEndPoint = null;
+                Connected = false;
+            }
+        }
+
+        public void GetSocketOption(SocketOptionLevel optionLevel, SocketOptionName optionName, byte[] optionValue)
+        {
+            if (optionLevel != SocketOptionLevel.Socket)
+            {
+                throw new NotImplementedException();
+            }
+
+            if (_socketOptions.TryGetValue(optionName, out int result))
+            {
+                byte[] data = BitConverter.GetBytes(result);
+                Array.Copy(data, 0, optionValue, 0, Math.Min(data.Length, optionValue.Length));
+            }
+            else
+            {
+                throw new NotImplementedException();
+            }
+        }
+
+        public void Listen(int backlog)
+        {
+            if (!IsBound)
+            {
+                throw new SocketException();
+            }
+
+            _isListening = true;
+        }
+
+        public void HandleConnectRequest(ProxyConnectRequest obj)
+        {
+            lock (_connectRequests)
+            {
+                _connectRequests.Enqueue(obj);
+            }
+
+            _connectEvent.Set();
+        }
+
+        public void HandleDisconnect(ProxyDisconnectMessage message)
+        {
+            Disconnect(false);
+        }
+
+        public int Receive(Span<byte> buffer)
+        {
+            EndPoint dummy = new IPEndPoint(IPAddress.Any, 0);
+
+            return ReceiveFrom(buffer, SocketFlags.None, ref dummy);
+        }
+
+        public int Receive(Span<byte> buffer, SocketFlags flags)
+        {
+            EndPoint dummy = new IPEndPoint(IPAddress.Any, 0);
+
+            return ReceiveFrom(buffer, flags, ref dummy);
+        }
+
+        public int Receive(Span<byte> buffer, SocketFlags flags, out SocketError socketError)
+        {
+            EndPoint dummy = new IPEndPoint(IPAddress.Any, 0);
+
+            return ReceiveFrom(buffer, flags, out socketError, ref dummy);
+        }
+
+        public int ReceiveFrom(Span<byte> buffer, SocketFlags flags, ref EndPoint remoteEp)
+        {
+            // We just receive all packets meant for us anyways regardless of EP in the actual implementation.
+            // The point is mostly to return the endpoint that we got the data from.
+
+            if (!Connected && ProtocolType == ProtocolType.Tcp)
+            {
+                throw new SocketException((int)WsaError.WSAECONNRESET);
+            }
+
+            lock (_receiveQueue)
+            {
+                if (_receiveQueue.Count > 0)
+                {
+                    return ReceiveFromQueue(buffer, flags, ref remoteEp);
+                }
+                else if (_readShutdown)
+                {
+                    return 0;
+                }
+                else if (!Blocking)
+                {
+                    throw new SocketException((int)WsaError.WSAEWOULDBLOCK);
+                }
+            }
+
+            int timeout = _receiveTimeout;
+
+            _receiveEvent.WaitOne(timeout == 0 ? -1 : timeout);
+
+            if (!Connected && ProtocolType == ProtocolType.Tcp)
+            {
+                throw new SocketException((int)WsaError.WSAECONNRESET);
+            }
+
+            lock (_receiveQueue)
+            {
+                if (_receiveQueue.Count > 0)
+                {
+                    return ReceiveFromQueue(buffer, flags, ref remoteEp);
+                }
+                else if (_readShutdown)
+                {
+                    return 0;
+                }
+                else
+                {
+                    throw new SocketException((int)WsaError.WSAETIMEDOUT);
+                }
+            }
+        }
+
+        public int ReceiveFrom(Span<byte> buffer, SocketFlags flags, out SocketError socketError, ref EndPoint remoteEp)
+        {
+            // We just receive all packets meant for us anyways regardless of EP in the actual implementation.
+            // The point is mostly to return the endpoint that we got the data from.
+
+            if (!Connected && ProtocolType == ProtocolType.Tcp)
+            {
+                socketError = SocketError.ConnectionReset;
+                return -1;
+            }
+
+            lock (_receiveQueue)
+            {
+                if (_receiveQueue.Count > 0)
+                {
+                    return ReceiveFromQueue(buffer, flags, out socketError, ref remoteEp);
+                }
+                else if (_readShutdown)
+                {
+                    socketError = SocketError.Success;
+                    return 0;
+                }
+                else if (!Blocking)
+                {
+                    throw new SocketException((int)WsaError.WSAEWOULDBLOCK);
+                }
+            }
+
+            int timeout = _receiveTimeout;
+
+            _receiveEvent.WaitOne(timeout == 0 ? -1 : timeout);
+
+            if (!Connected && ProtocolType == ProtocolType.Tcp)
+            {
+                throw new SocketException((int)WsaError.WSAECONNRESET);
+            }
+
+            lock (_receiveQueue)
+            {
+                if (_receiveQueue.Count > 0)
+                {
+                    return ReceiveFromQueue(buffer, flags, out socketError, ref remoteEp);
+                }
+                else if (_readShutdown)
+                {
+                    socketError = SocketError.Success;
+                    return 0;
+                }
+                else
+                {
+                    socketError = SocketError.TimedOut;
+                    return -1;
+                }
+            }
+        }
+
+        private int ReceiveFromQueue(Span<byte> buffer, SocketFlags flags, ref EndPoint remoteEp)
+        {
+            int size = buffer.Length;
+
+            // Assumes we have the receive queue lock, and at least one item in the queue.
+            ProxyDataPacket packet = _receiveQueue.Peek();
+
+            remoteEp = GetEndpoint(packet.Header.Info.SourceIpV4, packet.Header.Info.SourcePort);
+
+            bool peek = (flags & SocketFlags.Peek) != 0;
+
+            int read;
+
+            if (packet.Data.Length > size)
+            {
+                read = size;
+
+                // Cannot fit in the output buffer. Copy up to what we've got.
+                packet.Data.AsSpan(0, size).CopyTo(buffer);
+
+                if (ProtocolType == ProtocolType.Udp)
+                {
+                    // Udp overflows, loses the data, then throws an exception.
+
+                    if (!peek)
+                    {
+                        _receiveQueue.Dequeue();
+                    }
+
+                    throw new SocketException((int)WsaError.WSAEMSGSIZE);
+                }
+                else if (ProtocolType == ProtocolType.Tcp)
+                {
+                    // Split the data at the buffer boundary. It will stay on the recieve queue.
+
+                    byte[] newData = new byte[packet.Data.Length - size];
+                    Array.Copy(packet.Data, size, newData, 0, newData.Length);
+
+                    packet.Data = newData;
+                }
+            }
+            else
+            {
+                read = packet.Data.Length;
+
+                packet.Data.AsSpan(0, packet.Data.Length).CopyTo(buffer);
+
+                if (!peek)
+                {
+                    _receiveQueue.Dequeue();
+                }
+            }
+
+            return read;
+        }
+
+        private int ReceiveFromQueue(Span<byte> buffer, SocketFlags flags, out SocketError socketError, ref EndPoint remoteEp)
+        {
+            int size = buffer.Length;
+
+            // Assumes we have the receive queue lock, and at least one item in the queue.
+            ProxyDataPacket packet = _receiveQueue.Peek();
+
+            remoteEp = GetEndpoint(packet.Header.Info.SourceIpV4, packet.Header.Info.SourcePort);
+
+            bool peek = (flags & SocketFlags.Peek) != 0;
+
+            int read;
+
+            if (packet.Data.Length > size)
+            {
+                read = size;
+
+                // Cannot fit in the output buffer. Copy up to what we've got.
+                packet.Data.AsSpan(0, size).CopyTo(buffer);
+
+                if (ProtocolType == ProtocolType.Udp)
+                {
+                    // Udp overflows, loses the data, then throws an exception.
+
+                    if (!peek)
+                    {
+                        _receiveQueue.Dequeue();
+                    }
+
+                    socketError = SocketError.MessageSize;
+                    return -1;
+                }
+                else if (ProtocolType == ProtocolType.Tcp)
+                {
+                    // Split the data at the buffer boundary. It will stay on the recieve queue.
+
+                    byte[] newData = new byte[packet.Data.Length - size];
+                    Array.Copy(packet.Data, size, newData, 0, newData.Length);
+
+                    packet.Data = newData;
+                }
+            }
+            else
+            {
+                read = packet.Data.Length;
+
+                packet.Data.AsSpan(0, packet.Data.Length).CopyTo(buffer);
+
+                if (!peek)
+                {
+                    _receiveQueue.Dequeue();
+                }
+            }
+
+            socketError = SocketError.Success;
+
+            return read;
+        }
+
+        public int Send(ReadOnlySpan<byte> buffer)
+        {
+            // Send to the remote host chosen when we "connect" or "accept".
+            if (!Connected)
+            {
+                throw new SocketException();
+            }
+
+            return SendTo(buffer, SocketFlags.None, RemoteEndPoint);
+        }
+
+        public int Send(ReadOnlySpan<byte> buffer, SocketFlags flags)
+        {
+            // Send to the remote host chosen when we "connect" or "accept".
+            if (!Connected)
+            {
+                throw new SocketException();
+            }
+
+            return SendTo(buffer, flags, RemoteEndPoint);
+        }
+
+        public int Send(ReadOnlySpan<byte> buffer, SocketFlags flags, out SocketError socketError)
+        {
+            // Send to the remote host chosen when we "connect" or "accept".
+            if (!Connected)
+            {
+                throw new SocketException();
+            }
+
+            return SendTo(buffer, flags, out socketError, RemoteEndPoint);
+        }
+
+        public int SendTo(ReadOnlySpan<byte> buffer, SocketFlags flags, EndPoint remoteEP)
+        {
+            if (!Connected && ProtocolType == ProtocolType.Tcp)
+            {
+                throw new SocketException((int)WsaError.WSAECONNRESET);
+            }
+
+            IPEndPoint localEp = EnsureLocalEndpoint(false);
+
+            if (remoteEP is not IPEndPoint)
+            {
+                throw new NotSupportedException();
+            }
+
+            return _proxy.SendTo(buffer, flags, localEp, (IPEndPoint)remoteEP, ProtocolType);
+        }
+
+        public int SendTo(ReadOnlySpan<byte> buffer, SocketFlags flags, out SocketError socketError, EndPoint remoteEP)
+        {
+            if (!Connected && ProtocolType == ProtocolType.Tcp)
+            {
+                socketError = SocketError.ConnectionReset;
+                return -1;
+            }
+
+            IPEndPoint localEp = EnsureLocalEndpoint(false);
+
+            if (remoteEP is not IPEndPoint)
+            {
+                // throw new NotSupportedException();
+                socketError = SocketError.OperationNotSupported;
+                return -1;
+            }
+
+            socketError = SocketError.Success;
+
+            return _proxy.SendTo(buffer, flags, localEp, (IPEndPoint)remoteEP, ProtocolType);
+        }
+
+        public bool Poll(int microSeconds, SelectMode mode)
+        {
+            return mode switch
+            {
+                SelectMode.SelectRead => Readable,
+                SelectMode.SelectWrite => Writable,
+                SelectMode.SelectError => Error,
+                _ => false
+            };
+        }
+
+        public void SetSocketOption(SocketOptionLevel optionLevel, SocketOptionName optionName, int optionValue)
+        {
+            if (optionLevel != SocketOptionLevel.Socket)
+            {
+                throw new NotImplementedException();
+            }
+
+            switch (optionName)
+            {
+                case SocketOptionName.SendTimeout:
+                    //_sendTimeout = optionValue;
+                    break;
+                case SocketOptionName.ReceiveTimeout:
+                    _receiveTimeout = optionValue;
+                    break;
+                case SocketOptionName.Broadcast:
+                    _broadcast = optionValue != 0;
+                    break;
+            }
+
+            lock (_socketOptions)
+            {
+                _socketOptions[optionName] = optionValue;
+            }
+        }
+
+        public void SetSocketOption(SocketOptionLevel optionLevel, SocketOptionName optionName, object optionValue)
+        {
+            // Just linger uses this for now in BSD, which we ignore.
+        }
+
+        public void Shutdown(SocketShutdown how)
+        {
+            switch (how)
+            {
+                case SocketShutdown.Both:
+                    _readShutdown = true;
+                    // _writeShutdown = true;
+                    break;
+                case SocketShutdown.Receive:
+                    _readShutdown = true;
+                    break;
+                case SocketShutdown.Send:
+                    // _writeShutdown = true;
+                    break;
+            }
+        }
+
+        public void ProxyDestroyed()
+        {
+            // Do nothing, for now. Will likely be more useful with TCP.
+        }
+
+        public void Dispose()
+        {
+
+        }
+    }
+}

src/Ryujinx.HLE/HOS/Services/Ldn/UserServiceCreator/LdnRyu/Proxy/P2pProxyClient.cs

@@ -0,0 +1,93 @@
+using Ryujinx.Common.Logging;
+using Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator.LdnRyu.Types;
+using Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator.Types;
+using Ryujinx.HLE.HOS.Services.Sockets.Bsd.Proxy;
+using System.Net.Sockets;
+using System.Threading;
+using TcpClient = NetCoreServer.TcpClient;
+
+namespace Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator.LdnRyu.Proxy
+{
+    class P2pProxyClient : TcpClient, IProxyClient
+    {
+        private const int FailureTimeout = 4000;
+
+        public ProxyConfig ProxyConfig { get; private set; }
+
+        private readonly RyuLdnProtocol _protocol;
+
+        private readonly ManualResetEvent _connected = new ManualResetEvent(false);
+        private readonly ManualResetEvent _ready = new ManualResetEvent(false);
+        private readonly AutoResetEvent _error = new AutoResetEvent(false);
+
+        public P2pProxyClient(string address, int port) : base(address, port)
+        {
+            if (ProxyHelpers.SupportsNoDelay())
+            {
+                OptionNoDelay = true;
+            }
+
+            _protocol = new RyuLdnProtocol();
+
+            _protocol.ProxyConfig += HandleProxyConfig;
+
+            ConnectAsync();
+        }
+
+        protected override void OnConnected()
+        {
+            Logger.Info?.PrintMsg(LogClass.ServiceLdn, $"Proxy TCP client connected a new session with Id {Id}");
+
+            _connected.Set();
+        }
+
+        protected override void OnDisconnected()
+        {
+            Logger.Info?.PrintMsg(LogClass.ServiceLdn, $"Proxy TCP client disconnected a session with Id {Id}");
+
+            SocketHelpers.UnregisterProxy();
+
+            _connected.Reset();
+        }
+
+        protected override void OnReceived(byte[] buffer, long offset, long size)
+        {
+            _protocol.Read(buffer, (int)offset, (int)size);
+        }
+
+        protected override void OnError(SocketError error)
+        {
+            Logger.Info?.PrintMsg(LogClass.ServiceLdn, $"Proxy TCP client caught an error with code {error}");
+
+            _error.Set();
+        }
+
+        private void HandleProxyConfig(LdnHeader header, ProxyConfig config)
+        {
+            ProxyConfig = config;
+
+            SocketHelpers.RegisterProxy(new LdnProxy(config, this, _protocol));
+
+            _ready.Set();
+        }
+
+        public bool EnsureProxyReady()
+        {
+            return _ready.WaitOne(FailureTimeout);
+        }
+
+        public bool PerformAuth(ExternalProxyConfig config)
+        {
+            bool signalled = _connected.WaitOne(FailureTimeout);
+
+            if (!signalled)
+            {
+                return false;
+            }
+
+            SendAsync(_protocol.Encode(PacketId.ExternalProxy, config));
+
+            return true;
+        }
+    }
+}

src/Ryujinx.HLE/HOS/Services/Ldn/UserServiceCreator/LdnRyu/Proxy/P2pProxyServer.cs

@@ -0,0 +1,388 @@
+using NetCoreServer;
+using Open.Nat;
+using Ryujinx.Common.Logging;
+using Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator.LdnRyu.Types;
+using Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator.Types;
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using System.Net;
+using System.Net.Sockets;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator.LdnRyu.Proxy
+{
+    class P2pProxyServer : TcpServer, IDisposable
+    {
+        public const ushort PrivatePortBase = 39990;
+        public const int PrivatePortRange = 10;
+
+        private const ushort PublicPortBase = 39990;
+        private const int PublicPortRange = 10;
+
+        private const ushort PortLeaseLength = 60;
+        private const ushort PortLeaseRenew = 50;
+
+        private const ushort AuthWaitSeconds = 1;
+
+        private readonly ReaderWriterLockSlim _lock = new ReaderWriterLockSlim(LockRecursionPolicy.SupportsRecursion);
+
+        public ushort PrivatePort { get; }
+
+        private ushort _publicPort;
+
+        private bool _disposed;
+        private readonly CancellationTokenSource _disposedCancellation = new CancellationTokenSource();
+
+        private NatDevice _natDevice;
+        private Mapping _portMapping;
+
+        private readonly List<P2pProxySession> _players = new List<P2pProxySession>();
+
+        private readonly List<ExternalProxyToken> _waitingTokens = new List<ExternalProxyToken>();
+        private readonly AutoResetEvent _tokenEvent = new AutoResetEvent(false);
+
+        private uint _broadcastAddress;
+
+        private readonly LdnMasterProxyClient _master;
+        private readonly RyuLdnProtocol _masterProtocol;
+        private readonly RyuLdnProtocol _protocol;
+
+        public P2pProxyServer(LdnMasterProxyClient master, ushort port, RyuLdnProtocol masterProtocol) : base(IPAddress.Any, port)
+        {
+            if (ProxyHelpers.SupportsNoDelay())
+            {
+                OptionNoDelay = true;
+            }
+
+            PrivatePort = port;
+
+            _master = master;
+            _masterProtocol = masterProtocol;
+
+            _masterProtocol.ExternalProxyState += HandleStateChange;
+            _masterProtocol.ExternalProxyToken += HandleToken;
+
+            _protocol = new RyuLdnProtocol();
+        }
+
+        private void HandleToken(LdnHeader header, ExternalProxyToken token)
+        {
+            _lock.EnterWriteLock();
+
+            _waitingTokens.Add(token);
+
+            _lock.ExitWriteLock();
+
+            _tokenEvent.Set();
+        }
+
+        private void HandleStateChange(LdnHeader header, ExternalProxyConnectionState state)
+        {
+            if (!state.Connected)
+            {
+                _lock.EnterWriteLock();
+
+                _waitingTokens.RemoveAll(token => token.VirtualIp == state.IpAddress);
+
+                _players.RemoveAll(player =>
+                {
+                    if (player.VirtualIpAddress == state.IpAddress)
+                    {
+                        player.DisconnectAndStop();
+
+                        return true;
+                    }
+
+                    return false;
+                });
+
+                _lock.ExitWriteLock();
+            }
+        }
+
+        public void Configure(ProxyConfig config)
+        {
+            _broadcastAddress = config.ProxyIp | (~config.ProxySubnetMask);
+        }
+
+        public async Task<ushort> NatPunch()
+        {
+            NatDiscoverer discoverer = new NatDiscoverer();
+            CancellationTokenSource cts = new CancellationTokenSource(1000);
+
+            NatDevice device;
+
+            try
+            {
+                device = await discoverer.DiscoverDeviceAsync(PortMapper.Upnp, cts);
+            }
+            catch (NatDeviceNotFoundException)
+            {
+                return 0;
+            }
+
+            _publicPort = PublicPortBase;
+
+            for (int i = 0; i < PublicPortRange; i++)
+            {
+                try
+                {
+                    _portMapping = new Mapping(Protocol.Tcp, PrivatePort, _publicPort, PortLeaseLength, "Ryujinx Local Multiplayer");
+
+                    await device.CreatePortMapAsync(_portMapping);
+
+                    break;
+                }
+                catch (MappingException)
+                {
+                    _publicPort++;
+                }
+                catch (Exception)
+                {
+                    return 0;
+                }
+
+                if (i == PublicPortRange - 1)
+                {
+                    _publicPort = 0;
+                }
+            }
+
+            if (_publicPort != 0)
+            {
+                _ = Task.Delay(PortLeaseRenew * 1000, _disposedCancellation.Token).ContinueWith((task) => Task.Run(RefreshLease));
+            }
+
+            _natDevice = device;
+
+            return _publicPort;
+        }
+
+        // Proxy handlers
+
+        private void RouteMessage(P2pProxySession sender, ref ProxyInfo info, Action<P2pProxySession> action)
+        {
+            if (info.SourceIpV4 == 0)
+            {
+                // If they sent from a connection bound on 0.0.0.0, make others see it as them.
+                info.SourceIpV4 = sender.VirtualIpAddress;
+            }
+            else if (info.SourceIpV4 != sender.VirtualIpAddress)
+            {
+                // Can't pretend to be somebody else.
+                return;
+            }
+
+            uint destIp = info.DestIpV4;
+
+            if (destIp == 0xc0a800ff)
+            {
+                destIp = _broadcastAddress;
+            }
+
+            bool isBroadcast = destIp == _broadcastAddress;
+
+            _lock.EnterReadLock();
+
+            if (isBroadcast)
+            {
+                _players.ForEach(player =>
+                {
+                    action(player);
+                });
+            }
+            else
+            {
+                P2pProxySession target = _players.FirstOrDefault(player => player.VirtualIpAddress == destIp);
+
+                if (target != null)
+                {
+                    action(target);
+                }
+            }
+
+            _lock.ExitReadLock();
+        }
+
+        public void HandleProxyDisconnect(P2pProxySession sender, LdnHeader header, ProxyDisconnectMessage message)
+        {
+            RouteMessage(sender, ref message.Info, (target) =>
+            {
+                target.SendAsync(sender.Protocol.Encode(PacketId.ProxyDisconnect, message));
+            });
+        }
+
+        public void HandleProxyData(P2pProxySession sender, LdnHeader header, ProxyDataHeader message, byte[] data)
+        {
+            RouteMessage(sender, ref message.Info, (target) =>
+            {
+                target.SendAsync(sender.Protocol.Encode(PacketId.ProxyData, message, data));
+            });
+        }
+
+        public void HandleProxyConnectReply(P2pProxySession sender, LdnHeader header, ProxyConnectResponse message)
+        {
+            RouteMessage(sender, ref message.Info, (target) =>
+            {
+                target.SendAsync(sender.Protocol.Encode(PacketId.ProxyConnectReply, message));
+            });
+        }
+
+        public void HandleProxyConnect(P2pProxySession sender, LdnHeader header, ProxyConnectRequest message)
+        {
+            RouteMessage(sender, ref message.Info, (target) =>
+            {
+                target.SendAsync(sender.Protocol.Encode(PacketId.ProxyConnect, message));
+            });
+        }
+
+        // End proxy handlers
+
+        private async Task RefreshLease()
+        {
+            if (_disposed || _natDevice == null)
+            {
+                return;
+            }
+
+            try
+            {
+                await _natDevice.CreatePortMapAsync(_portMapping);
+            }
+            catch (Exception)
+            {
+
+            }
+
+            _ = Task.Delay(PortLeaseRenew, _disposedCancellation.Token).ContinueWith((task) => Task.Run(RefreshLease));
+        }
+
+        public bool TryRegisterUser(P2pProxySession session, ExternalProxyConfig config)
+        {
+            _lock.EnterWriteLock();
+
+            // Attempt to find matching configuration. If we don't find one, wait for a bit and try again.
+            // Woken by new tokens coming in from the master server.
+
+            IPAddress address = (session.Socket.RemoteEndPoint as IPEndPoint).Address;
+            byte[] addressBytes = ProxyHelpers.AddressTo16Byte(address);
+
+            long time;
+            long endTime = Stopwatch.GetTimestamp() + Stopwatch.Frequency * AuthWaitSeconds;
+
+            do
+            {
+                for (int i = 0; i < _waitingTokens.Count; i++)
+                {
+                    ExternalProxyToken waitToken = _waitingTokens[i];
+
+                    // Allow any client that has a private IP to connect. (indicated by the server as all 0 in the token)
+
+                    bool isPrivate = waitToken.PhysicalIp.AsSpan().SequenceEqual(new byte[16]);
+                    bool ipEqual = isPrivate || waitToken.AddressFamily == address.AddressFamily && waitToken.PhysicalIp.AsSpan().SequenceEqual(addressBytes);
+
+                    if (ipEqual && waitToken.Token.AsSpan().SequenceEqual(config.Token.AsSpan()))
+                    {
+                        // This is a match.
+
+                        _waitingTokens.RemoveAt(i);
+
+                        session.SetIpv4(waitToken.VirtualIp);
+
+                        ProxyConfig pconfig = new ProxyConfig
+                        {
+                            ProxyIp = session.VirtualIpAddress,
+                            ProxySubnetMask = 0xFFFF0000 // TODO: Use from server.
+                        };
+
+                        if (_players.Count == 0)
+                        {
+                            Configure(pconfig);
+                        }
+
+                        _players.Add(session);
+
+                        session.SendAsync(_protocol.Encode(PacketId.ProxyConfig, pconfig));
+
+                        _lock.ExitWriteLock();
+
+                        return true;
+                    }
+                }
+
+                // Couldn't find the token.
+                // It may not have arrived yet, so wait for one to arrive.
+
+                _lock.ExitWriteLock();
+
+                time = Stopwatch.GetTimestamp();
+                int remainingMs = (int)((endTime - time) / (Stopwatch.Frequency / 1000));
+
+                if (remainingMs < 0)
+                {
+                    remainingMs = 0;
+                }
+
+                _tokenEvent.WaitOne(remainingMs);
+
+                _lock.EnterWriteLock();
+
+            } while (time < endTime);
+
+            _lock.ExitWriteLock();
+
+            return false;
+        }
+
+        public void DisconnectProxyClient(P2pProxySession session)
+        {
+            _lock.EnterWriteLock();
+
+            bool removed = _players.Remove(session);
+
+            if (removed)
+            {
+                _master.SendAsync(_masterProtocol.Encode(PacketId.ExternalProxyState, new ExternalProxyConnectionState
+                {
+                    IpAddress = session.VirtualIpAddress,
+                    Connected = false
+                }));
+            }
+
+            _lock.ExitWriteLock();
+        }
+
+        public new void Dispose()
+        {
+            base.Dispose();
+
+            _disposed = true;
+            _disposedCancellation.Cancel();
+
+            try
+            {
+                Task delete = _natDevice?.DeletePortMapAsync(new Mapping(Protocol.Tcp, PrivatePort, _publicPort, 60, "Ryujinx Local Multiplayer"));
+
+                // Just absorb any exceptions.
+                delete?.ContinueWith((task) => { });
+            }
+            catch (Exception)
+            {
+                // Fail silently.
+            }
+        }
+
+        protected override TcpSession CreateSession()
+        {
+            return new P2pProxySession(this);
+        }
+
+        protected override void OnError(SocketError error)
+        {
+            Logger.Info?.PrintMsg(LogClass.ServiceLdn, $"Proxy TCP server caught an error with code {error}");
+        }
+    }
+}

src/Ryujinx.HLE/HOS/Services/Ldn/UserServiceCreator/LdnRyu/Proxy/P2pProxySession.cs

@@ -0,0 +1,90 @@
+using NetCoreServer;
+using Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator.LdnRyu.Types;
+using System;
+
+namespace Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator.LdnRyu.Proxy
+{
+    class P2pProxySession : TcpSession
+    {
+        public uint VirtualIpAddress { get; private set; }
+        public RyuLdnProtocol Protocol { get; }
+
+        private readonly P2pProxyServer _parent;
+
+        private bool _masterClosed;
+
+        public P2pProxySession(P2pProxyServer server) : base(server)
+        {
+            _parent = server;
+
+            Protocol = new RyuLdnProtocol();
+
+            Protocol.ProxyDisconnect += HandleProxyDisconnect;
+            Protocol.ProxyData += HandleProxyData;
+            Protocol.ProxyConnectReply += HandleProxyConnectReply;
+            Protocol.ProxyConnect += HandleProxyConnect;
+
+            Protocol.ExternalProxy += HandleAuthentication;
+        }
+
+        private void HandleAuthentication(LdnHeader header, ExternalProxyConfig token)
+        {
+            if (!_parent.TryRegisterUser(this, token))
+            {
+                Disconnect();
+            }
+        }
+
+        public void SetIpv4(uint ip)
+        {
+            VirtualIpAddress = ip;
+        }
+
+        public void DisconnectAndStop()
+        {
+            _masterClosed = true;
+
+            Disconnect();
+        }
+
+        protected override void OnDisconnected()
+        {
+            if (!_masterClosed)
+            {
+                _parent.DisconnectProxyClient(this);
+            }
+        }
+
+        protected override void OnReceived(byte[] buffer, long offset, long size)
+        {
+            try
+            {
+                Protocol.Read(buffer, (int)offset, (int)size);
+            }
+            catch (Exception)
+            {
+                Disconnect();
+            }
+        }
+
+        private void HandleProxyDisconnect(LdnHeader header, ProxyDisconnectMessage message)
+        {
+            _parent.HandleProxyDisconnect(this, header, message);
+        }
+
+        private void HandleProxyData(LdnHeader header, ProxyDataHeader message, byte[] data)
+        {
+            _parent.HandleProxyData(this, header, message, data);
+        }
+
+        private void HandleProxyConnectReply(LdnHeader header, ProxyConnectResponse data)
+        {
+            _parent.HandleProxyConnectReply(this, header, data);
+        }
+
+        private void HandleProxyConnect(LdnHeader header, ProxyConnectRequest message)
+        {
+            _parent.HandleProxyConnect(this, header, message);
+        }
+    }
+}

src/Ryujinx.HLE/HOS/Services/Ldn/UserServiceCreator/LdnRyu/Proxy/ProxyHelpers.cs

@@ -0,0 +1,24 @@
+using System;
+using System.Net;
+using System.Runtime.InteropServices;
+
+namespace Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator.LdnRyu.Proxy
+{
+    static class ProxyHelpers
+    {
+        public static byte[] AddressTo16Byte(IPAddress address)
+        {
+            byte[] ipBytes = new byte[16];
+            byte[] srcBytes = address.GetAddressBytes();
+
+            Array.Copy(srcBytes, 0, ipBytes, 0, srcBytes.Length);
+
+            return ipBytes;
+        }
+
+        public static bool SupportsNoDelay()
+        {
+            return RuntimeInformation.IsOSPlatform(OSPlatform.Windows);
+        }
+    }
+}

src/Ryujinx.HLE/HOS/Services/Ldn/UserServiceCreator/LdnRyu/RyuLdnProtocol.cs

@@ -0,0 +1,380 @@
+using Ryujinx.Common.Utilities;
+using Ryujinx.HLE.HOS.Services.Ldn.Types;
+using Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator.LdnRyu.Types;
+using Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator.Types;
+using System;
+using System.Runtime.InteropServices;
+
+namespace Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator.LdnRyu
+{
+    class RyuLdnProtocol
+    {
+        private const byte CurrentProtocolVersion = 1;
+        private const int Magic = ('R' << 0) | ('L' << 8) | ('D' << 16) | ('N' << 24);
+        private const int MaxPacketSize = 131072;
+
+        private readonly int _headerSize = Marshal.SizeOf<LdnHeader>();
+
+        private readonly byte[] _buffer = new byte[MaxPacketSize];
+        private int _bufferEnd = 0;
+
+        // Client Packets.
+        public event Action<LdnHeader, InitializeMessage> Initialize;
+        public event Action<LdnHeader, PassphraseMessage> Passphrase;
+        public event Action<LdnHeader, NetworkInfo> Connected;
+        public event Action<LdnHeader, NetworkInfo> SyncNetwork;
+        public event Action<LdnHeader, NetworkInfo> ScanReply;
+        public event Action<LdnHeader> ScanReplyEnd;
+        public event Action<LdnHeader, DisconnectMessage> Disconnected;
+
+        // External Proxy Packets.
+        public event Action<LdnHeader, ExternalProxyConfig> ExternalProxy;
+        public event Action<LdnHeader, ExternalProxyConnectionState> ExternalProxyState;
+        public event Action<LdnHeader, ExternalProxyToken> ExternalProxyToken;
+
+        // Server Packets.
+        public event Action<LdnHeader, CreateAccessPointRequest, byte[]> CreateAccessPoint;
+        public event Action<LdnHeader, CreateAccessPointPrivateRequest, byte[]> CreateAccessPointPrivate;
+        public event Action<LdnHeader, RejectRequest> Reject;
+        public event Action<LdnHeader> RejectReply;
+        public event Action<LdnHeader, SetAcceptPolicyRequest> SetAcceptPolicy;
+        public event Action<LdnHeader, byte[]> SetAdvertiseData;
+        public event Action<LdnHeader, ConnectRequest> Connect;
+        public event Action<LdnHeader, ConnectPrivateRequest> ConnectPrivate;
+        public event Action<LdnHeader, ScanFilter> Scan;
+
+        // Proxy Packets.
+        public event Action<LdnHeader, ProxyConfig> ProxyConfig;
+        public event Action<LdnHeader, ProxyConnectRequest> ProxyConnect;
+        public event Action<LdnHeader, ProxyConnectResponse> ProxyConnectReply;
+        public event Action<LdnHeader, ProxyDataHeader, byte[]> ProxyData;
+        public event Action<LdnHeader, ProxyDisconnectMessage> ProxyDisconnect;
+
+        // Lifecycle Packets.
+        public event Action<LdnHeader, NetworkErrorMessage> NetworkError;
+        public event Action<LdnHeader, PingMessage> Ping;
+
+        public RyuLdnProtocol() { }
+
+        public void Reset()
+        {
+            _bufferEnd = 0;
+        }
+
+        public void Read(byte[] data, int offset, int size)
+        {
+            int index = 0;
+
+            while (index < size)
+            {
+                if (_bufferEnd < _headerSize)
+                {
+                    // Assemble the header first.
+
+                    int copyable = Math.Min(size - index, Math.Min(size, _headerSize - _bufferEnd));
+
+                    Array.Copy(data, index + offset, _buffer, _bufferEnd, copyable);
+
+                    index += copyable;
+                    _bufferEnd += copyable;
+                }
+
+                if (_bufferEnd >= _headerSize)
+                {
+                    // The header is available. Make sure we received all the data (size specified in the header)
+
+                    LdnHeader ldnHeader = MemoryMarshal.Cast<byte, LdnHeader>(_buffer)[0];
+
+                    if (ldnHeader.Magic != Magic)
+                    {
+                        throw new InvalidOperationException("Invalid magic number in received packet.");
+                    }
+
+                    if (ldnHeader.Version != CurrentProtocolVersion)
+                    {
+                        throw new InvalidOperationException($"Protocol version mismatch. Expected ${CurrentProtocolVersion}, was ${ldnHeader.Version}.");
+                    }
+
+                    int finalSize = _headerSize + ldnHeader.DataSize;
+
+                    if (finalSize >= MaxPacketSize)
+                    {
+                        throw new InvalidOperationException($"Max packet size {MaxPacketSize} exceeded.");
+                    }
+
+                    int copyable = Math.Min(size - index, Math.Min(size, finalSize - _bufferEnd));
+
+                    Array.Copy(data, index + offset, _buffer, _bufferEnd, copyable);
+
+                    index += copyable;
+                    _bufferEnd += copyable;
+
+                    if (finalSize == _bufferEnd)
+                    {
+                        // The full packet has been retrieved. Send it to be decoded.
+
+                        byte[] ldnData = new byte[ldnHeader.DataSize];
+
+                        Array.Copy(_buffer, _headerSize, ldnData, 0, ldnData.Length);
+
+                        DecodeAndHandle(ldnHeader, ldnData);
+
+                        Reset();
+                    }
+                }
+            }
+        }
+
+        private (T, byte[]) ParseWithData<T>(byte[] data) where T : struct
+        {
+            T str = default;
+            int size = Marshal.SizeOf(str);
+
+            byte[] remainder = new byte[data.Length - size];
+
+            if (remainder.Length > 0)
+            {
+                Array.Copy(data, size, remainder, 0, remainder.Length);
+            }
+
+            return (MemoryMarshal.Read<T>(data), remainder);
+        }
+
+        private void DecodeAndHandle(LdnHeader header, byte[] data)
+        {
+            switch ((PacketId)header.Type)
+            {
+                // Client Packets.
+                case PacketId.Initialize:
+                    {
+                        Initialize?.Invoke(header, MemoryMarshal.Read<InitializeMessage>(data));
+
+                        break;
+                    }
+                case PacketId.Passphrase:
+                    {
+                        Passphrase?.Invoke(header, MemoryMarshal.Read<PassphraseMessage>(data));
+
+                        break;
+                    }
+                case PacketId.Connected:
+                    {
+                        Connected?.Invoke(header, MemoryMarshal.Read<NetworkInfo>(data));
+
+                        break;
+                    }
+                case PacketId.SyncNetwork:
+                    {
+                        SyncNetwork?.Invoke(header, MemoryMarshal.Read<NetworkInfo>(data));
+
+                        break;
+                    }
+                case PacketId.ScanReply:
+                    {
+                        ScanReply?.Invoke(header, MemoryMarshal.Read<NetworkInfo>(data));
+
+                        break;
+                    }
+
+                case PacketId.ScanReplyEnd:
+                    {
+                        ScanReplyEnd?.Invoke(header);
+
+                        break;
+                    }
+                case PacketId.Disconnect:
+                    {
+                        Disconnected?.Invoke(header, MemoryMarshal.Read<DisconnectMessage>(data));
+
+                        break;
+                    }
+
+                // External Proxy Packets.
+                case PacketId.ExternalProxy:
+                    {
+                        ExternalProxy?.Invoke(header, MemoryMarshal.Read<ExternalProxyConfig>(data));
+
+                        break;
+                    }
+                case PacketId.ExternalProxyState:
+                    {
+                        ExternalProxyState?.Invoke(header, MemoryMarshal.Read<ExternalProxyConnectionState>(data));
+
+                        break;
+                    }
+                case PacketId.ExternalProxyToken:
+                    {
+                        ExternalProxyToken?.Invoke(header, MemoryMarshal.Read<ExternalProxyToken>(data));
+
+                        break;
+                    }
+
+                // Server Packets.
+                case PacketId.CreateAccessPoint:
+                    {
+                        (CreateAccessPointRequest packet, byte[] extraData) = ParseWithData<CreateAccessPointRequest>(data);
+                        CreateAccessPoint?.Invoke(header, packet, extraData);
+                        break;
+                    }
+                case PacketId.CreateAccessPointPrivate:
+                    {
+                        (CreateAccessPointPrivateRequest packet, byte[] extraData) = ParseWithData<CreateAccessPointPrivateRequest>(data);
+                        CreateAccessPointPrivate?.Invoke(header, packet, extraData);
+                        break;
+                    }
+                case PacketId.Reject:
+                    {
+                        Reject?.Invoke(header, MemoryMarshal.Read<RejectRequest>(data));
+
+                        break;
+                    }
+                case PacketId.RejectReply:
+                    {
+                        RejectReply?.Invoke(header);
+
+                        break;
+                    }
+                case PacketId.SetAcceptPolicy:
+                    {
+                        SetAcceptPolicy?.Invoke(header, MemoryMarshal.Read<SetAcceptPolicyRequest>(data));
+
+                        break;
+                    }
+                case PacketId.SetAdvertiseData:
+                    {
+                        SetAdvertiseData?.Invoke(header, data);
+
+                        break;
+                    }
+                case PacketId.Connect:
+                    {
+                        Connect?.Invoke(header, MemoryMarshal.Read<ConnectRequest>(data));
+
+                        break;
+                    }
+                case PacketId.ConnectPrivate:
+                    {
+                        ConnectPrivate?.Invoke(header, MemoryMarshal.Read<ConnectPrivateRequest>(data));
+
+                        break;
+                    }
+                case PacketId.Scan:
+                    {
+                        Scan?.Invoke(header, MemoryMarshal.Read<ScanFilter>(data));
+
+                        break;
+                    }
+
+                // Proxy Packets
+                case PacketId.ProxyConfig:
+                    {
+                        ProxyConfig?.Invoke(header, MemoryMarshal.Read<ProxyConfig>(data));
+
+                        break;
+                    }
+                case PacketId.ProxyConnect:
+                    {
+                        ProxyConnect?.Invoke(header, MemoryMarshal.Read<ProxyConnectRequest>(data));
+
+                        break;
+                    }
+                case PacketId.ProxyConnectReply:
+                    {
+                        ProxyConnectReply?.Invoke(header, MemoryMarshal.Read<ProxyConnectResponse>(data));
+
+                        break;
+                    }
+                case PacketId.ProxyData:
+                    {
+                        (ProxyDataHeader packet, byte[] extraData) = ParseWithData<ProxyDataHeader>(data);
+
+                        ProxyData?.Invoke(header, packet, extraData);
+
+                        break;
+                    }
+                case PacketId.ProxyDisconnect:
+                    {
+                        ProxyDisconnect?.Invoke(header, MemoryMarshal.Read<ProxyDisconnectMessage>(data));
+
+                        break;
+                    }
+
+                // Lifecycle Packets.
+                case PacketId.Ping:
+                    {
+                        Ping?.Invoke(header, MemoryMarshal.Read<PingMessage>(data));
+
+                        break;
+                    }
+                case PacketId.NetworkError:
+                    {
+                        NetworkError?.Invoke(header, MemoryMarshal.Read<NetworkErrorMessage>(data));
+
+                        break;
+                    }
+
+                default:
+                    break;
+            }
+        }
+
+        private static LdnHeader GetHeader(PacketId type, int dataSize)
+        {
+            return new LdnHeader()
+            {
+                Magic = Magic,
+                Version = CurrentProtocolVersion,
+                Type = (byte)type,
+                DataSize = dataSize
+            };
+        }
+
+        public byte[] Encode(PacketId type)
+        {
+            LdnHeader header = GetHeader(type, 0);
+
+            return SpanHelpers.AsSpan<LdnHeader, byte>(ref header).ToArray();
+        }
+
+        public byte[] Encode(PacketId type, byte[] data)
+        {
+            LdnHeader header = GetHeader(type, data.Length);
+
+            byte[] result = SpanHelpers.AsSpan<LdnHeader, byte>(ref header).ToArray();
+
+            Array.Resize(ref result, result.Length + data.Length);
+            Array.Copy(data, 0, result, Marshal.SizeOf<LdnHeader>(), data.Length);
+
+            return result;
+        }
+
+        public byte[] Encode<T>(PacketId type, T packet) where T : unmanaged
+        {
+            byte[] packetData = SpanHelpers.AsSpan<T, byte>(ref packet).ToArray();
+
+            LdnHeader header = GetHeader(type, packetData.Length);
+
+            byte[] result = SpanHelpers.AsSpan<LdnHeader, byte>(ref header).ToArray();
+
+            Array.Resize(ref result, result.Length + packetData.Length);
+            Array.Copy(packetData, 0, result, Marshal.SizeOf<LdnHeader>(), packetData.Length);
+
+            return result;
+        }
+
+        public byte[] Encode<T>(PacketId type, T packet, byte[] data) where T : unmanaged
+        {
+            byte[] packetData = SpanHelpers.AsSpan<T, byte>(ref packet).ToArray();
+
+            LdnHeader header = GetHeader(type, packetData.Length + data.Length);
+
+            byte[] result = SpanHelpers.AsSpan<LdnHeader, byte>(ref header).ToArray();
+
+            Array.Resize(ref result, result.Length + packetData.Length + data.Length);
+            Array.Copy(packetData, 0, result, Marshal.SizeOf<LdnHeader>(), packetData.Length);
+            Array.Copy(data, 0, result, Marshal.SizeOf<LdnHeader>() + packetData.Length, data.Length);
+
+            return result;
+        }
+    }
+}

src/Ryujinx.HLE/HOS/Services/Ldn/UserServiceCreator/LdnRyu/Types/DisconnectMessage.cs

@@ -0,0 +1,10 @@
+using System.Runtime.InteropServices;
+
+namespace Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator.LdnRyu.Types
+{
+    [StructLayout(LayoutKind.Sequential, Size = 0x4)]
+    struct DisconnectMessage
+    {
+        public uint DisconnectIP;
+    }
+}

src/Ryujinx.HLE/HOS/Services/Ldn/UserServiceCreator/LdnRyu/Types/ExternalProxyConfig.cs

@@ -0,0 +1,19 @@
+using Ryujinx.Common.Memory;
+using System.Net.Sockets;
+using System.Runtime.InteropServices;
+
+namespace Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator.LdnRyu.Types
+{
+    /// <summary>
+    /// Sent by the server to point a client towards an external server being used as a proxy.
+    /// The client then forwards this to the external proxy after connecting, to verify the connection worked.
+    /// </summary>
+    [StructLayout(LayoutKind.Sequential, Size = 0x26, Pack = 1)]
+    struct ExternalProxyConfig
+    {
+        public Array16<byte> ProxyIp;
+        public AddressFamily AddressFamily;
+        public ushort ProxyPort;
+        public Array16<byte> Token;
+    }
+}

src/Ryujinx.HLE/HOS/Services/Ldn/UserServiceCreator/LdnRyu/Types/ExternalProxyConnectionState.cs

@@ -0,0 +1,18 @@
+using System.Runtime.InteropServices;
+
+namespace Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator.LdnRyu.Types
+{
+    /// <summary>
+    /// Indicates a change in connection state for the given client.
+    /// Is sent to notify the master server when connection is first established.
+    /// Can be sent by the external proxy to the master server to notify it of a proxy disconnect.
+    /// Can be sent by the master server to notify the external proxy of a user leaving a room.
+    /// Both will result in a force kick.
+    /// </summary>
+    [StructLayout(LayoutKind.Sequential, Size = 0x8, Pack = 4)]
+    struct ExternalProxyConnectionState
+    {
+        public uint IpAddress;
+        public bool Connected;
+    }
+}

src/Ryujinx.HLE/HOS/Services/Ldn/UserServiceCreator/LdnRyu/Types/ExternalProxyToken.cs

@@ -0,0 +1,20 @@
+using Ryujinx.Common.Memory;
+using System.Net.Sockets;
+using System.Runtime.InteropServices;
+
+namespace Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator.LdnRyu.Types
+{
+    /// <summary>
+    /// Sent by the master server to an external proxy to tell them someone is going to connect.
+    /// This drives authentication, and lets the proxy know what virtual IP to give to each joiner,
+    /// as these are managed by the master server.
+    /// </summary>
+    [StructLayout(LayoutKind.Sequential, Size = 0x28)]
+    struct ExternalProxyToken
+    {
+        public uint VirtualIp;
+        public Array16<byte> Token;
+        public Array16<byte> PhysicalIp;
+        public AddressFamily AddressFamily;
+    }
+}

src/Ryujinx.HLE/HOS/Services/Ldn/UserServiceCreator/LdnRyu/Types/InitializeMessage.cs

@@ -0,0 +1,20 @@
+using Ryujinx.Common.Memory;
+using System.Runtime.InteropServices;
+
+namespace Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator.LdnRyu.Types
+{
+    /// <summary>
+    /// This message is first sent by the client to identify themselves.
+    /// If the server has a token+mac combo that matches the submission, then they are returned their new ID and mac address. (the mac is also reassigned to the new id)
+    /// Otherwise, they are returned a random mac address.
+    /// </summary>
+    [StructLayout(LayoutKind.Sequential, Size = 0x16)]
+    struct InitializeMessage
+    {
+        // All 0 if we don't have an ID yet.
+        public Array16<byte> Id;
+
+        // All 0 if we don't have a mac yet.
+        public Array6<byte> MacAddress;
+    }
+}

src/Ryujinx.HLE/HOS/Services/Ldn/UserServiceCreator/LdnRyu/Types/LdnHeader.cs

@@ -0,0 +1,13 @@
+using System.Runtime.InteropServices;
+
+namespace Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator.LdnRyu.Types
+{
+    [StructLayout(LayoutKind.Sequential, Size = 0xA)]
+    struct LdnHeader
+    {
+        public uint Magic;
+        public byte Type;
+        public byte Version;
+        public int DataSize;
+    }
+}

src/Ryujinx.HLE/HOS/Services/Ldn/UserServiceCreator/LdnRyu/Types/PacketId.cs

@@ -0,0 +1,36 @@
+namespace Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator.LdnRyu.Types
+{
+    enum PacketId
+    {
+        Initialize,
+        Passphrase,
+
+        CreateAccessPoint,
+        CreateAccessPointPrivate,
+        ExternalProxy,
+        ExternalProxyToken,
+        ExternalProxyState,
+        SyncNetwork,
+        Reject,
+        RejectReply,
+        Scan,
+        ScanReply,
+        ScanReplyEnd,
+        Connect,
+        ConnectPrivate,
+        Connected,
+        Disconnect,
+
+        ProxyConfig,
+        ProxyConnect,
+        ProxyConnectReply,
+        ProxyData,
+        ProxyDisconnect,
+
+        SetAcceptPolicy,
+        SetAdvertiseData,
+
+        Ping = 254,
+        NetworkError = 255
+    }
+}

src/Ryujinx.HLE/HOS/Services/Ldn/UserServiceCreator/LdnRyu/Types/PassphraseMessage.cs

@@ -0,0 +1,11 @@
+using Ryujinx.Common.Memory;
+using System.Runtime.InteropServices;
+
+namespace Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator.LdnRyu.Types
+{
+    [StructLayout(LayoutKind.Sequential, Size = 0x80)]
+    struct PassphraseMessage
+    {
+        public Array128<byte> Passphrase;
+    }
+}

src/Ryujinx.HLE/HOS/Services/Ldn/UserServiceCreator/LdnRyu/Types/PingMessage.cs

@@ -0,0 +1,11 @@
+using System.Runtime.InteropServices;
+
+namespace Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator.LdnRyu.Types
+{
+    [StructLayout(LayoutKind.Sequential, Size = 0x2)]
+    struct PingMessage
+    {
+        public byte Requester;
+        public byte Id;
+    }
+}

src/Ryujinx.HLE/HOS/Services/Ldn/UserServiceCreator/LdnRyu/Types/ProxyConnectRequest.cs

@@ -0,0 +1,10 @@
+using System.Runtime.InteropServices;
+
+namespace Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator.LdnRyu.Types
+{
+    [StructLayout(LayoutKind.Sequential, Size = 0x10)]
+    struct ProxyConnectRequest
+    {
+        public ProxyInfo Info;
+    }
+}

src/Ryujinx.HLE/HOS/Services/Ldn/UserServiceCreator/LdnRyu/Types/ProxyConnectResponse.cs

@@ -0,0 +1,10 @@
+using System.Runtime.InteropServices;
+
+namespace Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator.LdnRyu.Types
+{
+    [StructLayout(LayoutKind.Sequential, Size = 0x10)]
+    struct ProxyConnectResponse
+    {
+        public ProxyInfo Info;
+    }
+}

src/Ryujinx.HLE/HOS/Services/Ldn/UserServiceCreator/LdnRyu/Types/ProxyDataHeader.cs

@@ -0,0 +1,14 @@
+using System.Runtime.InteropServices;
+
+namespace Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator.LdnRyu.Types
+{
+    /// <summary>
+    /// Represents data sent over a transport layer.
+    /// </summary>
+    [StructLayout(LayoutKind.Sequential, Size = 0x14)]
+    struct ProxyDataHeader
+    {
+        public ProxyInfo Info;
+        public uint DataLength; // Followed by the data with the specified byte length.
+    }
+}

src/Ryujinx.HLE/HOS/Services/Ldn/UserServiceCreator/LdnRyu/Types/ProxyDataPacket.cs

@@ -0,0 +1,8 @@
+namespace Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator.LdnRyu.Types
+{
+    class ProxyDataPacket
+    {
+        public ProxyDataHeader Header;
+        public byte[] Data;
+    }
+}

src/Ryujinx.HLE/HOS/Services/Ldn/UserServiceCreator/LdnRyu/Types/ProxyDisconnectMessage.cs

@@ -0,0 +1,11 @@
+using System.Runtime.InteropServices;
+
+namespace Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator.LdnRyu.Types
+{
+    [StructLayout(LayoutKind.Sequential, Size = 0x14)]
+    struct ProxyDisconnectMessage
+    {
+        public ProxyInfo Info;
+        public int DisconnectReason;
+    }
+}

src/Ryujinx.HLE/HOS/Services/Ldn/UserServiceCreator/LdnRyu/Types/ProxyInfo.cs

@@ -0,0 +1,20 @@
+using System.Net.Sockets;
+using System.Runtime.InteropServices;
+
+namespace Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator.LdnRyu.Types
+{
+    /// <summary>
+    /// Information included in all proxied communication.
+    /// </summary>
+    [StructLayout(LayoutKind.Sequential, Size = 0x10, Pack = 1)]
+    struct ProxyInfo
+    {
+        public uint SourceIpV4;
+        public ushort SourcePort;
+
+        public uint DestIpV4;
+        public ushort DestPort;
+
+        public ProtocolType Protocol;
+    }
+}

src/Ryujinx.HLE/HOS/Services/Ldn/UserServiceCreator/LdnRyu/Types/RejectRequest.cs

@@ -0,0 +1,18 @@
+using Ryujinx.HLE.HOS.Services.Ldn.Types;
+using System.Runtime.InteropServices;
+
+namespace Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator.LdnRyu.Types
+{
+    [StructLayout(LayoutKind.Sequential, Size = 0x8)]
+    struct RejectRequest
+    {
+        public uint NodeId;
+        public DisconnectReason DisconnectReason;
+
+        public RejectRequest(DisconnectReason disconnectReason, uint nodeId)
+        {
+            DisconnectReason = disconnectReason;
+            NodeId = nodeId;
+        }
+    }
+}

src/Ryujinx.HLE/HOS/Services/Ldn/UserServiceCreator/LdnRyu/Types/RyuNetworkConfig.cs

@@ -0,0 +1,23 @@
+using Ryujinx.Common.Memory;
+using System.Net.Sockets;
+using System.Runtime.InteropServices;
+
+namespace Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator.LdnRyu.Types
+{
+    [StructLayout(LayoutKind.Sequential, Size = 0x28, Pack = 1)]
+    struct RyuNetworkConfig
+    {
+        public Array16<byte> GameVersion;
+
+        // PrivateIp is included for external proxies for the case where a client attempts to join from
+        // their own LAN. UPnP forwarding can fail when connecting devices on the same network over the public IP,
+        // so if their public IP is identical, the internal address should be sent instead.
+
+        // The fields below are 0 if not hosting a p2p proxy.
+
+        public Array16<byte> PrivateIp;
+        public AddressFamily AddressFamily;
+        public ushort ExternalProxyPort;
+        public ushort InternalProxyPort;
+    }
+}

src/Ryujinx.HLE/HOS/Services/Ldn/UserServiceCreator/LdnRyu/Types/SetAcceptPolicyRequest.cs

@@ -0,0 +1,11 @@
+using Ryujinx.HLE.HOS.Services.Ldn.Types;
+using System.Runtime.InteropServices;
+
+namespace Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator.LdnRyu.Types
+{
+    [StructLayout(LayoutKind.Sequential, Size = 0x1, Pack = 1)]
+    struct SetAcceptPolicyRequest
+    {
+        public AcceptPolicy StationAcceptPolicy;
+    }
+}

src/Ryujinx.HLE/HOS/Services/Ldn/UserServiceCreator/Station.cs

@@ -14,6 +14,8 @@ namespace Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator
 
         public bool Connected { get; private set; }
 
+        public ProxyConfig Config => _parent.NetworkClient.Config;
+
         public Station(IUserLocalCommunicationService parent)
         {
             _parent = parent;
@@ -47,11 +49,14 @@ namespace Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator
         }
 
         public void Dispose()
+        {
+            if (_parent.NetworkClient != null)
             {
                 _parent.NetworkClient.DisconnectNetwork();
 
                 _parent.NetworkClient.NetworkChange -= NetworkChanged;
             }
+        }
 
         private ResultCode NetworkErrorToResult(NetworkError error)
         {

src/Ryujinx.HLE/HOS/Services/Ldn/UserServiceCreator/Types/CreateAccessPointPrivateRequest.cs

@@ -1,4 +1,5 @@
 using Ryujinx.HLE.HOS.Services.Ldn.Types;
+using Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator.LdnRyu.Types;
 using System.Runtime.InteropServices;
 
 namespace Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator.Types
@@ -14,5 +15,7 @@ namespace Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator.Types
         public UserConfig UserConfig;
         public NetworkConfig NetworkConfig;
         public AddressList AddressList;
+
+        public RyuNetworkConfig RyuNetworkConfig;
     }
 }

src/Ryujinx.HLE/HOS/Services/Ldn/UserServiceCreator/Types/CreateAccessPointRequest.cs

@@ -1,4 +1,5 @@
 using Ryujinx.HLE.HOS.Services.Ldn.Types;
+using Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator.LdnRyu.Types;
 using System.Runtime.InteropServices;
 
 namespace Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator.Types
@@ -6,11 +7,13 @@ namespace Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator.Types
     /// <remarks>
     /// Advertise data is appended separately (remaining data in the buffer).
     /// </remarks>
-    [StructLayout(LayoutKind.Sequential, Size = 0x94, CharSet = CharSet.Ansi)]
+    [StructLayout(LayoutKind.Sequential, Size = 0xBC, Pack = 1)]
     struct CreateAccessPointRequest
     {
         public SecurityConfig SecurityConfig;
         public UserConfig UserConfig;
         public NetworkConfig NetworkConfig;
+
+        public RyuNetworkConfig RyuNetworkConfig;
     }
 }

src/Ryujinx.HLE/HOS/Services/Ldn/UserServiceCreator/Types/ProxyConfig.cs

@@ -0,0 +1,11 @@
+using System.Runtime.InteropServices;
+
+namespace Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator.Types
+{
+    [StructLayout(LayoutKind.Sequential, Size = 0x8)]
+    struct ProxyConfig
+    {
+        public uint ProxyIp;
+        public uint ProxySubnetMask;
+    }
+}

src/Ryujinx.HLE/HOS/Services/Sockets/Bsd/IClient.cs

@@ -95,7 +95,7 @@ namespace Ryujinx.HLE.HOS.Services.Sockets.Bsd
                 }
             }
 
-            ISocket newBsdSocket = new ManagedSocket(netDomain, (SocketType)type, protocol)
+            ISocket newBsdSocket = new ManagedSocket(netDomain, (SocketType)type, protocol, context.Device.Configuration.MultiplayerLanInterfaceId)
             {
                 Blocking = !creationFlags.HasFlag(BsdSocketCreationFlags.NonBlocking),
             };

src/Ryujinx.HLE/HOS/Services/Sockets/Bsd/Impl/ManagedSocket.cs

@@ -1,4 +1,5 @@
 using Ryujinx.Common.Logging;
+using Ryujinx.HLE.HOS.Services.Sockets.Bsd.Proxy;
 using Ryujinx.HLE.HOS.Services.Sockets.Bsd.Types;
 using System;
 using System.Collections.Generic;
@@ -21,21 +22,21 @@ namespace Ryujinx.HLE.HOS.Services.Sockets.Bsd.Impl
 
         public bool Blocking { get => Socket.Blocking; set => Socket.Blocking = value; }
 
-        public nint Handle => Socket.Handle;
+        public nint Handle => IntPtr.Zero;
 
         public IPEndPoint RemoteEndPoint => Socket.RemoteEndPoint as IPEndPoint;
 
         public IPEndPoint LocalEndPoint => Socket.LocalEndPoint as IPEndPoint;
 
-        public Socket Socket { get; }
+        public ISocketImpl Socket { get; }
 
-        public ManagedSocket(AddressFamily addressFamily, SocketType socketType, ProtocolType protocolType)
+        public ManagedSocket(AddressFamily addressFamily, SocketType socketType, ProtocolType protocolType, string lanInterfaceId)
         {
-            Socket = new Socket(addressFamily, socketType, protocolType);
+            Socket = SocketHelpers.CreateSocket(addressFamily, socketType, protocolType, lanInterfaceId);
             Refcount = 1;
         }
 
-        private ManagedSocket(Socket socket)
+        private ManagedSocket(ISocketImpl socket)
         {
             Socket = socket;
             Refcount = 1;
@@ -185,6 +186,8 @@ namespace Ryujinx.HLE.HOS.Services.Sockets.Bsd.Impl
             }
         }
 
+        bool hasEmittedBlockingWarning = false;
+
         public LinuxError Receive(out int receiveSize, Span<byte> buffer, BsdSocketFlags flags)
         {
             LinuxError result;
@@ -199,6 +202,12 @@ namespace Ryujinx.HLE.HOS.Services.Sockets.Bsd.Impl
                     shouldBlockAfterOperation = true;
                 }
 
+                if (Blocking && !hasEmittedBlockingWarning)
+                {
+                    Logger.Warning?.PrintMsg(LogClass.ServiceBsd, "Blocking socket operations are not yet working properly. Expect network errors.");
+                    hasEmittedBlockingWarning = true;
+                }
+
                 receiveSize = Socket.Receive(buffer, ConvertBsdSocketFlags(flags));
 
                 result = LinuxError.SUCCESS;
@@ -236,6 +245,12 @@ namespace Ryujinx.HLE.HOS.Services.Sockets.Bsd.Impl
                     shouldBlockAfterOperation = true;
                 }
 
+                if (Blocking && !hasEmittedBlockingWarning)
+                {
+                    Logger.Warning?.PrintMsg(LogClass.ServiceBsd, "Blocking socket operations are not yet working properly. Expect network errors.");
+                    hasEmittedBlockingWarning = true;
+                }
+
                 if (!Socket.IsBound)
                 {
                     receiveSize = -1;
@@ -313,7 +328,7 @@ namespace Ryujinx.HLE.HOS.Services.Sockets.Bsd.Impl
                     Logger.Warning?.Print(LogClass.ServiceBsd, $"Unsupported GetSockOpt Option: {option} Level: {level}");
                     optionValue.Clear();
 
-                    return LinuxError.SUCCESS;
+                    return LinuxError.EOPNOTSUPP;
                 }
 
                 byte[] tempOptionValue = new byte[optionValue.Length];
@@ -347,7 +362,7 @@ namespace Ryujinx.HLE.HOS.Services.Sockets.Bsd.Impl
                 {
                     Logger.Warning?.Print(LogClass.ServiceBsd, $"Unsupported SetSockOpt Option: {option} Level: {level}");
 
-                    return LinuxError.SUCCESS;
+                    return LinuxError.EOPNOTSUPP;
                 }
 
                 int value = optionValue.Length >= 4 ? MemoryMarshal.Read<int>(optionValue) : MemoryMarshal.Read<byte>(optionValue);
@@ -493,7 +508,7 @@ namespace Ryujinx.HLE.HOS.Services.Sockets.Bsd.Impl
 
             try
             {
-                int receiveSize = Socket.Receive(ConvertMessagesToBuffer(message), ConvertBsdSocketFlags(flags), out SocketError socketError);
+                int receiveSize = (Socket as DefaultSocket).BaseSocket.Receive(ConvertMessagesToBuffer(message), ConvertBsdSocketFlags(flags), out SocketError socketError);
 
                 if (receiveSize > 0)
                 {
@@ -531,7 +546,7 @@ namespace Ryujinx.HLE.HOS.Services.Sockets.Bsd.Impl
 
             try
             {
-                int sendSize = Socket.Send(ConvertMessagesToBuffer(message), ConvertBsdSocketFlags(flags), out SocketError socketError);
+                int sendSize = (Socket as DefaultSocket).BaseSocket.Send(ConvertMessagesToBuffer(message), ConvertBsdSocketFlags(flags), out SocketError socketError);
 
                 if (sendSize > 0)
                 {

src/Ryujinx.HLE/HOS/Services/Sockets/Bsd/Impl/ManagedSocketPollManager.cs

@@ -1,4 +1,5 @@
 using Ryujinx.Common.Logging;
+using Ryujinx.HLE.HOS.Services.Sockets.Bsd.Proxy;
 using Ryujinx.HLE.HOS.Services.Sockets.Bsd.Types;
 using System.Collections.Generic;
 using System.Net.Sockets;
@@ -26,37 +27,37 @@ namespace Ryujinx.HLE.HOS.Services.Sockets.Bsd.Impl
 
         public LinuxError Poll(List<PollEvent> events, int timeoutMilliseconds, out int updatedCount)
         {
-            List<Socket> readEvents = new();
+            List<ISocketImpl> readEvents = new();
-            List<Socket> writeEvents = new();
+            List<ISocketImpl> writeEvents = new();
-            List<Socket> errorEvents = new();
+            List<ISocketImpl> errorEvents = new();
 
             updatedCount = 0;
 
             foreach (PollEvent evnt in events)
             {
-                ManagedSocket socket = (ManagedSocket)evnt.FileDescriptor;
+                if (evnt.FileDescriptor is ManagedSocket ms)
-
+                {
                     bool isValidEvent = evnt.Data.InputEvents == 0;
 
-                errorEvents.Add(socket.Socket);
+                    errorEvents.Add(ms.Socket);
 
                     if ((evnt.Data.InputEvents & PollEventTypeMask.Input) != 0)
                     {
-                    readEvents.Add(socket.Socket);
+                        readEvents.Add(ms.Socket);
 
                         isValidEvent = true;
                     }
 
                     if ((evnt.Data.InputEvents & PollEventTypeMask.UrgentInput) != 0)
                     {
-                    readEvents.Add(socket.Socket);
+                        readEvents.Add(ms.Socket);
 
                         isValidEvent = true;
                     }
 
                     if ((evnt.Data.InputEvents & PollEventTypeMask.Output) != 0)
                     {
-                    writeEvents.Add(socket.Socket);
+                        writeEvents.Add(ms.Socket);
 
                         isValidEvent = true;
                     }
@@ -67,12 +68,13 @@ namespace Ryujinx.HLE.HOS.Services.Sockets.Bsd.Impl
                         return LinuxError.EINVAL;
                     }
                 }
+            }
 
             try
             {
                 int actualTimeoutMicroseconds = timeoutMilliseconds == -1 ? -1 : timeoutMilliseconds * 1000;
 
-                Socket.Select(readEvents, writeEvents, errorEvents, actualTimeoutMicroseconds);
+                SocketHelpers.Select(readEvents, writeEvents, errorEvents, actualTimeoutMicroseconds);
             }
             catch (SocketException exception)
             {
@@ -81,11 +83,13 @@ namespace Ryujinx.HLE.HOS.Services.Sockets.Bsd.Impl
 
             foreach (PollEvent evnt in events)
             {
-                Socket socket = ((ManagedSocket)evnt.FileDescriptor).Socket;
+                if (evnt.FileDescriptor is ManagedSocket ms)
+                {
+                    ISocketImpl socket = ms.Socket;
 
                     PollEventTypeMask outputEvents = evnt.Data.OutputEvents & ~evnt.Data.InputEvents;
 
-                if (errorEvents.Contains(socket))
+                    if (errorEvents.Contains(ms.Socket))
                     {
                         outputEvents |= PollEventTypeMask.Error;
 
@@ -95,7 +99,7 @@ namespace Ryujinx.HLE.HOS.Services.Sockets.Bsd.Impl
                         }
                     }
 
-                if (readEvents.Contains(socket))
+                    if (readEvents.Contains(ms.Socket))
                     {
                         if ((evnt.Data.InputEvents & PollEventTypeMask.Input) != 0)
                         {
@@ -103,13 +107,14 @@ namespace Ryujinx.HLE.HOS.Services.Sockets.Bsd.Impl
                         }
                     }
 
-                if (writeEvents.Contains(socket))
+                    if (writeEvents.Contains(ms.Socket))
                     {
                         outputEvents |= PollEventTypeMask.Output;
                     }
 
                     evnt.Data.OutputEvents = outputEvents;
                 }
+            }
 
             updatedCount = readEvents.Count + writeEvents.Count + errorEvents.Count;
 
@@ -118,55 +123,57 @@ namespace Ryujinx.HLE.HOS.Services.Sockets.Bsd.Impl
 
         public LinuxError Select(List<PollEvent> events, int timeout, out int updatedCount)
         {
-            List<Socket> readEvents = new();
+            List<ISocketImpl> readEvents = new();
-            List<Socket> writeEvents = new();
+            List<ISocketImpl> writeEvents = new();
-            List<Socket> errorEvents = new();
+            List<ISocketImpl> errorEvents = new();
 
             updatedCount = 0;
 
             foreach (PollEvent pollEvent in events)
             {
-                ManagedSocket socket = (ManagedSocket)pollEvent.FileDescriptor;
+                if (pollEvent.FileDescriptor is ManagedSocket ms)
-
+                {
                     if (pollEvent.Data.InputEvents.HasFlag(PollEventTypeMask.Input))
                     {
-                    readEvents.Add(socket.Socket);
+                        readEvents.Add(ms.Socket);
                     }
 
                     if (pollEvent.Data.InputEvents.HasFlag(PollEventTypeMask.Output))
                     {
-                    writeEvents.Add(socket.Socket);
+                        writeEvents.Add(ms.Socket);
                     }
 
                     if (pollEvent.Data.InputEvents.HasFlag(PollEventTypeMask.Error))
                     {
-                    errorEvents.Add(socket.Socket);
+                        errorEvents.Add(ms.Socket);
+                    }
                 }
             }
 
-            Socket.Select(readEvents, writeEvents, errorEvents, timeout);
+            SocketHelpers.Select(readEvents, writeEvents, errorEvents, timeout);
 
             updatedCount = readEvents.Count + writeEvents.Count + errorEvents.Count;
 
             foreach (PollEvent pollEvent in events)
             {
-                ManagedSocket socket = (ManagedSocket)pollEvent.FileDescriptor;
+                if (pollEvent.FileDescriptor is ManagedSocket ms)
-
+                {
-                if (readEvents.Contains(socket.Socket))
+                    if (readEvents.Contains(ms.Socket))
                     {
                         pollEvent.Data.OutputEvents |= PollEventTypeMask.Input;
                     }
 
-                if (writeEvents.Contains(socket.Socket))
+                    if (writeEvents.Contains(ms.Socket))
                     {
                         pollEvent.Data.OutputEvents |= PollEventTypeMask.Output;
                     }
 
-                if (errorEvents.Contains(socket.Socket))
+                    if (errorEvents.Contains(ms.Socket))
                     {
                         pollEvent.Data.OutputEvents |= PollEventTypeMask.Error;
                     }
                 }
+            }
 
             return LinuxError.SUCCESS;
         }

src/Ryujinx.HLE/HOS/Services/Sockets/Bsd/Proxy/DefaultSocket.cs

@@ -0,0 +1,178 @@
+using Ryujinx.Common.Utilities;
+using System;
+using System.Net;
+using System.Net.NetworkInformation;
+using System.Net.Sockets;
+
+namespace Ryujinx.HLE.HOS.Services.Sockets.Bsd.Proxy
+{
+    class DefaultSocket : ISocketImpl
+    {
+        public Socket BaseSocket { get; }
+
+        public EndPoint RemoteEndPoint => BaseSocket.RemoteEndPoint;
+
+        public EndPoint LocalEndPoint => BaseSocket.LocalEndPoint;
+
+        public bool Connected => BaseSocket.Connected;
+
+        public bool IsBound => BaseSocket.IsBound;
+
+        public AddressFamily AddressFamily => BaseSocket.AddressFamily;
+
+        public SocketType SocketType => BaseSocket.SocketType;
+
+        public ProtocolType ProtocolType => BaseSocket.ProtocolType;
+
+        public bool Blocking { get => BaseSocket.Blocking; set => BaseSocket.Blocking = value; }
+
+        public int Available => BaseSocket.Available;
+
+        private readonly string _lanInterfaceId;
+
+        public DefaultSocket(Socket baseSocket, string lanInterfaceId)
+        {
+            _lanInterfaceId = lanInterfaceId;
+
+            BaseSocket = baseSocket;
+        }
+
+        public DefaultSocket(AddressFamily domain, SocketType type, ProtocolType protocol, string lanInterfaceId)
+        {
+            _lanInterfaceId = lanInterfaceId;
+
+            BaseSocket = new Socket(domain, type, protocol);
+        }
+
+        private void EnsureNetworkInterfaceBound()
+        {
+            if (_lanInterfaceId != "0" && !BaseSocket.IsBound)
+            {
+                (_, UnicastIPAddressInformation ipInfo) = NetworkHelpers.GetLocalInterface(_lanInterfaceId);
+
+                BaseSocket.Bind(new IPEndPoint(ipInfo.Address, 0));
+            }
+        }
+
+        public ISocketImpl Accept()
+        {
+            return new DefaultSocket(BaseSocket.Accept(), _lanInterfaceId);
+        }
+
+        public void Bind(EndPoint localEP)
+        {
+            // NOTE: The guest is able to receive on 0.0.0.0 without it being limited to the chosen network interface.
+            // This is because it must get loopback traffic as well. This could allow other network traffic to leak in.
+
+            BaseSocket.Bind(localEP);
+        }
+
+        public void Close()
+        {
+            BaseSocket.Close();
+        }
+
+        public void Connect(EndPoint remoteEP)
+        {
+            EnsureNetworkInterfaceBound();
+
+            BaseSocket.Connect(remoteEP);
+        }
+
+        public void Disconnect(bool reuseSocket)
+        {
+            BaseSocket.Disconnect(reuseSocket);
+        }
+
+        public void GetSocketOption(SocketOptionLevel optionLevel, SocketOptionName optionName, byte[] optionValue)
+        {
+            BaseSocket.GetSocketOption(optionLevel, optionName, optionValue);
+        }
+
+        public void Listen(int backlog)
+        {
+            BaseSocket.Listen(backlog);
+        }
+
+        public int Receive(Span<byte> buffer)
+        {
+            EnsureNetworkInterfaceBound();
+
+            return BaseSocket.Receive(buffer);
+        }
+
+        public int Receive(Span<byte> buffer, SocketFlags flags)
+        {
+            EnsureNetworkInterfaceBound();
+
+            return BaseSocket.Receive(buffer, flags);
+        }
+
+        public int Receive(Span<byte> buffer, SocketFlags flags, out SocketError socketError)
+        {
+            EnsureNetworkInterfaceBound();
+
+            return BaseSocket.Receive(buffer, flags, out socketError);
+        }
+
+        public int ReceiveFrom(Span<byte> buffer, SocketFlags flags, ref EndPoint remoteEP)
+        {
+            EnsureNetworkInterfaceBound();
+
+            return BaseSocket.ReceiveFrom(buffer, flags, ref remoteEP);
+        }
+
+        public int Send(ReadOnlySpan<byte> buffer)
+        {
+            EnsureNetworkInterfaceBound();
+
+            return BaseSocket.Send(buffer);
+        }
+
+        public int Send(ReadOnlySpan<byte> buffer, SocketFlags flags)
+        {
+            EnsureNetworkInterfaceBound();
+
+            return BaseSocket.Send(buffer, flags);
+        }
+
+        public int Send(ReadOnlySpan<byte> buffer, SocketFlags flags, out SocketError socketError)
+        {
+            EnsureNetworkInterfaceBound();
+
+            return BaseSocket.Send(buffer, flags, out socketError);
+        }
+
+        public int SendTo(ReadOnlySpan<byte> buffer, SocketFlags flags, EndPoint remoteEP)
+        {
+            EnsureNetworkInterfaceBound();
+
+            return BaseSocket.SendTo(buffer, flags, remoteEP);
+        }
+
+        public bool Poll(int microSeconds, SelectMode mode)
+        {
+            return BaseSocket.Poll(microSeconds, mode);
+        }
+
+        public void SetSocketOption(SocketOptionLevel optionLevel, SocketOptionName optionName, int optionValue)
+        {
+            BaseSocket.SetSocketOption(optionLevel, optionName, optionValue);
+        }
+
+        public void SetSocketOption(SocketOptionLevel optionLevel, SocketOptionName optionName, object optionValue)
+        {
+            BaseSocket.SetSocketOption(optionLevel, optionName, optionValue);
+        }
+
+        public void Shutdown(SocketShutdown how)
+        {
+            BaseSocket.Shutdown(how);
+        }
+
+        public void Dispose()
+        {
+            BaseSocket.Dispose();
+        }
+    }
+}

src/Ryujinx.HLE/HOS/Services/Sockets/Bsd/Proxy/ISocket.cs

@@ -0,0 +1,47 @@
+using System;
+using System.Net;
+using System.Net.Sockets;
+
+namespace Ryujinx.HLE.HOS.Services.Sockets.Bsd.Proxy
+{
+    interface ISocketImpl : IDisposable
+    {
+        EndPoint RemoteEndPoint { get; }
+        EndPoint LocalEndPoint { get; }
+        bool Connected { get; }
+        bool IsBound { get; }
+
+        AddressFamily AddressFamily { get; }
+        SocketType SocketType { get; }
+        ProtocolType ProtocolType { get; }
+
+        bool Blocking { get; set; }
+        int Available { get; }
+
+        int Receive(Span<byte> buffer);
+        int Receive(Span<byte> buffer, SocketFlags flags);
+        int Receive(Span<byte> buffer, SocketFlags flags, out SocketError socketError);
+        int ReceiveFrom(Span<byte> buffer, SocketFlags flags, ref EndPoint remoteEP);
+
+        int Send(ReadOnlySpan<byte> buffer);
+        int Send(ReadOnlySpan<byte> buffer, SocketFlags flags);
+        int Send(ReadOnlySpan<byte> buffer, SocketFlags flags, out SocketError socketError);
+        int SendTo(ReadOnlySpan<byte> buffer, SocketFlags flags, EndPoint remoteEP);
+
+        bool Poll(int microSeconds, SelectMode mode);
+
+        ISocketImpl Accept();
+
+        void Bind(EndPoint localEP);
+        void Connect(EndPoint remoteEP);
+        void Listen(int backlog);
+
+        void GetSocketOption(SocketOptionLevel optionLevel, SocketOptionName optionName, byte[] optionValue);
+        void SetSocketOption(SocketOptionLevel optionLevel, SocketOptionName optionName, int optionValue);
+        void SetSocketOption(SocketOptionLevel optionLevel, SocketOptionName optionName, object optionValue);
+
+        void Shutdown(SocketShutdown how);
+        void Disconnect(bool reuseSocket);
+        void Close();
+    }
+}

src/Ryujinx.HLE/HOS/Services/Sockets/Bsd/Proxy/SocketHelpers.cs

@@ -0,0 +1,74 @@
+using Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator.LdnRyu.Proxy;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Net.Sockets;
+
+namespace Ryujinx.HLE.HOS.Services.Sockets.Bsd.Proxy
+{
+    static class SocketHelpers
+    {
+        private static LdnProxy _proxy;
+
+        public static void Select(List<ISocketImpl> readEvents, List<ISocketImpl> writeEvents, List<ISocketImpl> errorEvents, int timeout)
+        {
+            var readDefault = readEvents.Select(x => (x as DefaultSocket)?.BaseSocket).Where(x => x != null).ToList();
+            var writeDefault = writeEvents.Select(x => (x as DefaultSocket)?.BaseSocket).Where(x => x != null).ToList();
+            var errorDefault = errorEvents.Select(x => (x as DefaultSocket)?.BaseSocket).Where(x => x != null).ToList();
+
+            if (readDefault.Count != 0 || writeDefault.Count != 0 || errorDefault.Count != 0)
+            {
+                Socket.Select(readDefault, writeDefault, errorDefault, timeout);
+            }
+
+            void FilterSockets(List<ISocketImpl> removeFrom, List<Socket> selectedSockets, Func<LdnProxySocket, bool> ldnCheck)
+            {
+                removeFrom.RemoveAll(socket =>
+                {
+                    switch (socket)
+                    {
+                        case DefaultSocket dsocket:
+                            return !selectedSockets.Contains(dsocket.BaseSocket);
+                        case LdnProxySocket psocket:
+                            return !ldnCheck(psocket);
+                        default:
+                            throw new NotImplementedException();
+                    }
+                });
+            };
+
+            FilterSockets(readEvents, readDefault, (socket) => socket.Readable);
+            FilterSockets(writeEvents, writeDefault, (socket) => socket.Writable);
+            FilterSockets(errorEvents, errorDefault, (socket) => socket.Error);
+        }
+
+        public static void RegisterProxy(LdnProxy proxy)
+        {
+            if (_proxy != null)
+            {
+                UnregisterProxy();
+            }
+
+            _proxy = proxy;
+        }
+
+        public static void UnregisterProxy()
+        {
+            _proxy?.Dispose();
+            _proxy = null;
+        }
+
+        public static ISocketImpl CreateSocket(AddressFamily domain, SocketType type, ProtocolType protocol, string lanInterfaceId)
+        {
+            if (_proxy != null)
+            {
+                if (_proxy.Supported(domain, type, protocol))
+                {
+                    return new LdnProxySocket(domain, type, protocol, _proxy);
+                }
+            }
+
+            return new DefaultSocket(domain, type, protocol, lanInterfaceId);
+        }
+    }
+}

src/Ryujinx.HLE/HOS/Services/Sockets/Sfdnsres/IResolver.cs

@@ -292,7 +292,7 @@ namespace Ryujinx.HLE.HOS.Services.Sockets.Sfdnsres
         {
             string host = MemoryHelper.ReadAsciiString(context.Memory, inputBufferPosition, (int)inputBufferSize);
 
-            if (!context.Device.Configuration.EnableInternetAccess)
+            if (host != "localhost" && !context.Device.Configuration.EnableInternetAccess)
             {
                 Logger.Info?.Print(LogClass.ServiceSfdnsres, $"Guest network access disabled, DNS Blocked: {host}");
 

src/Ryujinx.HLE/HOS/Services/Ssl/SslService/SslManagedSocketConnection.cs

@@ -1,5 +1,6 @@
 using Ryujinx.HLE.HOS.Services.Sockets.Bsd;
 using Ryujinx.HLE.HOS.Services.Sockets.Bsd.Impl;
+using Ryujinx.HLE.HOS.Services.Sockets.Bsd.Proxy;
 using Ryujinx.HLE.HOS.Services.Ssl.Types;
 using System;
 using System.IO;
@@ -116,7 +117,7 @@ namespace Ryujinx.HLE.HOS.Services.Ssl.SslService
         public ResultCode Handshake(string hostName)
         {
             StartSslOperation();
-            _stream = new SslStream(new NetworkStream(((ManagedSocket)Socket).Socket, false), false, null, null);
+            _stream = new SslStream(new NetworkStream(((DefaultSocket)((ManagedSocket)Socket).Socket).BaseSocket, false), false, null, null);
             hostName = RetrieveHostName(hostName);
             _stream.AuthenticateAsClient(hostName, null, TranslateSslVersion(_sslVersion), false);
             EndSslOperation();

src/Ryujinx.HLE/Ryujinx.HLE.csproj

@@ -29,6 +29,7 @@
     <PackageReference Include="SkiaSharp" />
     <PackageReference Include="SkiaSharp.NativeAssets.Linux" />
     <PackageReference Include="NetCoreServer" />
+    <PackageReference Include="Open.NAT.Core" />
   </ItemGroup>
 
   <ItemGroup>

src/Ryujinx.Headless.SDL2/Program.cs

@@ -577,7 +577,10 @@ namespace Ryujinx.Headless.SDL2
                 options.AudioVolume,
                 options.UseHypervisor ?? true,
                 options.MultiplayerLanInterfaceId,
-                Common.Configuration.Multiplayer.MultiplayerMode.Disabled);
+                Common.Configuration.Multiplayer.MultiplayerMode.Disabled,
+                false,
+                "",
+                "");
 
             return new Switch(configuration);
         }

src/Ryujinx.UI.Common/App/ApplicationData.cs

@@ -27,6 +27,8 @@ namespace Ryujinx.UI.App.Common
         public ulong Id { get; set; }
         public string Developer { get; set; } = "Unknown";
         public string Version { get; set; } = "0";
+        public int PlayerCount { get; set; }
+        public int GameCount { get; set; }
         public TimeSpan TimePlayed { get; set; }
         public DateTime? LastPlayed { get; set; }
         public string FileExtension { get; set; }

src/Ryujinx.UI.Common/App/ApplicationLibrary.cs

@@ -12,6 +12,7 @@ using LibHac.Tools.Fs;
 using LibHac.Tools.FsSystem;
 using LibHac.Tools.FsSystem.NcaUtils;
 using Ryujinx.Common.Configuration;
+using Ryujinx.Common.Configuration.Multiplayer;
 using Ryujinx.Common.Logging;
 using Ryujinx.Common.Utilities;
 using Ryujinx.HLE.FileSystem;
@@ -27,10 +28,12 @@ using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
+using System.Net.Http;
 using System.Reflection;
 using System.Text;
 using System.Text.Json;
 using System.Threading;
+using System.Threading.Tasks;
 using ContentType = LibHac.Ncm.ContentType;
 using MissingKeyException = LibHac.Common.Keys.MissingKeyException;
 using Path = System.IO.Path;
@@ -41,8 +44,10 @@ namespace Ryujinx.UI.App.Common
 {
     public class ApplicationLibrary
     {
+        public static string DefaultLanPlayWebHost = "ryuldnweb.vudjun.com";
         public Language DesiredLanguage { get; set; }
         public event EventHandler<ApplicationCountUpdatedEventArgs> ApplicationCountUpdated;
+        public event EventHandler<LdnGameDataReceivedEventArgs> LdnGameDataReceived;
 
         public readonly IObservableCache<ApplicationData, ulong> Applications;
         public readonly IObservableCache<(TitleUpdateModel TitleUpdate, bool IsSelected), TitleUpdateModel> TitleUpdates;
@@ -62,6 +67,7 @@ namespace Ryujinx.UI.App.Common
         private readonly SourceCache<(DownloadableContentModel Dlc, bool IsEnabled), DownloadableContentModel> _downloadableContents = new(it => it.Dlc);
 
         private static readonly ApplicationJsonSerializerContext _serializerContext = new(JsonHelper.GetDefaultSerializerOptions());
+        private static readonly LdnGameDataSerializerContext _ldnDataSerializerContext = new(JsonHelper.GetDefaultSerializerOptions());
 
         public ApplicationLibrary(VirtualFileSystem virtualFileSystem, IntegrityCheckLevel checkLevel)
         {
@@ -719,6 +725,7 @@ namespace Ryujinx.UI.App.Common
                     }
                 }
 
+
                 // Loops through applications list, creating a struct and then firing an event containing the struct for each application
                 foreach (string applicationPath in applicationPaths)
                 {
@@ -775,6 +782,46 @@ namespace Ryujinx.UI.App.Common
             }
         }
 
+        public async Task RefreshLdn()
+        {
+
+            if (ConfigurationState.Instance.Multiplayer.Mode == MultiplayerMode.LdnRyu)
+            {
+                try
+                {
+                    string ldnWebHost = ConfigurationState.Instance.Multiplayer.LdnServer;
+                    if (string.IsNullOrEmpty(ldnWebHost))
+                    {
+                        ldnWebHost = DefaultLanPlayWebHost;
+                    }
+                    IEnumerable<LdnGameData> ldnGameDataArray = Array.Empty<LdnGameData>();
+                    using HttpClient httpClient = new HttpClient();
+                    string ldnGameDataArrayString = await httpClient.GetStringAsync($"https://{ldnWebHost}/api/public_games");
+                    ldnGameDataArray = JsonHelper.Deserialize(ldnGameDataArrayString, _ldnDataSerializerContext.IEnumerableLdnGameData);
+                    var evt = new LdnGameDataReceivedEventArgs
+                    {
+                        LdnData = ldnGameDataArray
+                    };
+                    LdnGameDataReceived?.Invoke(null, evt);
+                }
+                catch (Exception ex)
+                {
+                    Logger.Warning?.Print(LogClass.Application, $"Failed to fetch the public games JSON from the API. Player and game count in the game list will be unavailable.\n{ex.Message}");
+                    LdnGameDataReceived?.Invoke(null, new LdnGameDataReceivedEventArgs()
+                    {
+                        LdnData = Array.Empty<LdnGameData>()
+                    });
+                }
+            }
+            else
+            {
+                LdnGameDataReceived?.Invoke(null, new LdnGameDataReceivedEventArgs()
+                {
+                    LdnData = Array.Empty<LdnGameData>()
+                });
+            }
+        }
+
         // Replace the currently stored DLC state for the game with the provided DLC state.
         public void SaveDownloadableContentsForGame(ApplicationData application, List<(DownloadableContentModel, bool IsEnabled)> dlcs)
         {

src/Ryujinx.UI.Common/App/LdnGameData.cs

@@ -0,0 +1,16 @@
+using System.Collections.Generic;
+
+namespace Ryujinx.UI.App.Common
+{
+    public struct LdnGameData
+    {
+        public string Id { get; set; }
+        public int PlayerCount { get; set; }
+        public int MaxPlayerCount { get; set; }
+        public string GameName { get; set; }
+        public string TitleId { get; set; }
+        public string Mode { get; set; }
+        public string Status { get; set; }
+        public IEnumerable<string> Players { get; set; }
+    }
+}

src/Ryujinx.UI.Common/App/LdnGameDataReceivedEventArgs.cs

@@ -0,0 +1,10 @@
+using System;
+using System.Collections.Generic;
+
+namespace Ryujinx.UI.App.Common
+{
+    public class LdnGameDataReceivedEventArgs : EventArgs
+    {
+        public IEnumerable<LdnGameData> LdnData { get; set; }
+    }
+}

src/Ryujinx.UI.Common/App/LdnGameDataSerializerContext.cs

@@ -0,0 +1,11 @@
+using System.Collections.Generic;
+using System.Text.Json.Serialization;
+
+namespace Ryujinx.UI.App.Common
+{
+    [JsonSerializable(typeof(IEnumerable<LdnGameData>))]
+    internal partial class LdnGameDataSerializerContext : JsonSerializerContext
+    {
+
+    }
+}

src/Ryujinx.UI.Common/Configuration/ConfigurationFileFormat.cs

@@ -392,6 +392,21 @@ namespace Ryujinx.UI.Common.Configuration
         /// </summary>
         public string MultiplayerLanInterfaceId { get; set; }
 
+        /// <summary>
+        /// Disable P2p Toggle
+        /// </summary>
+        public bool MultiplayerDisableP2p { get; set; }
+
+        /// <summary>
+        /// Local network passphrase, for private networks.
+        /// </summary>
+        public string MultiplayerLdnPassphrase { get; set; }
+
+        /// <summary>
+        /// Custom LDN Server
+        /// </summary>
+        public string LdnServer { get; set; }
+
         /// <summary>
         /// Uses Hypervisor over JIT if available
         /// </summary>

src/Ryujinx.UI.Common/Configuration/ConfigurationState.Migration.cs

@@ -1,4 +1,4 @@
-using Ryujinx.Common.Configuration;
+using Ryujinx.Common.Configuration;
 using Ryujinx.Common.Configuration.Hid;
 using Ryujinx.Common.Configuration.Hid.Controller;
 using Ryujinx.Common.Configuration.Hid.Keyboard;
@@ -703,6 +703,9 @@ namespace Ryujinx.UI.Common.Configuration
 
             Multiplayer.LanInterfaceId.Value = configurationFileFormat.MultiplayerLanInterfaceId;
             Multiplayer.Mode.Value = configurationFileFormat.MultiplayerMode;
+            Multiplayer.DisableP2p.Value = configurationFileFormat.MultiplayerDisableP2p;
+            Multiplayer.LdnPassphrase.Value = configurationFileFormat.MultiplayerLdnPassphrase;
+            Multiplayer.LdnServer.Value = configurationFileFormat.LdnServer;
 
             if (configurationFileUpdated)
             {

src/Ryujinx.UI.Common/Configuration/ConfigurationState.Model.cs

@@ -25,6 +25,7 @@ namespace Ryujinx.UI.Common.Configuration
                 public ReactiveObject<bool> AppColumn { get; private set; }
                 public ReactiveObject<bool> DevColumn { get; private set; }
                 public ReactiveObject<bool> VersionColumn { get; private set; }
+                public ReactiveObject<bool> LdnInfoColumn { get; private set; }
                 public ReactiveObject<bool> TimePlayedColumn { get; private set; }
                 public ReactiveObject<bool> LastPlayedColumn { get; private set; }
                 public ReactiveObject<bool> FileExtColumn { get; private set; }
@@ -38,6 +39,7 @@ namespace Ryujinx.UI.Common.Configuration
                     AppColumn = new ReactiveObject<bool>();
                     DevColumn = new ReactiveObject<bool>();
                     VersionColumn = new ReactiveObject<bool>();
+                    LdnInfoColumn = new ReactiveObject<bool>();
                     TimePlayedColumn = new ReactiveObject<bool>();
                     LastPlayedColumn = new ReactiveObject<bool>();
                     FileExtColumn = new ReactiveObject<bool>();
@@ -572,11 +574,32 @@ namespace Ryujinx.UI.Common.Configuration
             /// </summary>
             public ReactiveObject<MultiplayerMode> Mode { get; private set; }
 
+            /// <summary>
+            /// Disable P2P
+            /// </summary>
+            public ReactiveObject<bool> DisableP2p { get; private set; }
+
+            /// <summary>
+            /// LDN PassPhrase
+            /// </summary>
+            public ReactiveObject<string> LdnPassphrase { get; private set; }
+
+            /// <summary>
+            /// LDN Server
+            /// </summary>
+            public ReactiveObject<string> LdnServer { get; private set; }
+
             public MultiplayerSection()
             {
                 LanInterfaceId = new ReactiveObject<string>();
                 Mode = new ReactiveObject<MultiplayerMode>();
                 Mode.LogChangesToValue(nameof(MultiplayerMode));
+                DisableP2p = new ReactiveObject<bool>();
+                DisableP2p.LogChangesToValue(nameof(DisableP2p));
+                LdnPassphrase = new ReactiveObject<string>();
+                LdnPassphrase.LogChangesToValue(nameof(LdnPassphrase));
+                LdnServer = new ReactiveObject<string>();
+                LdnServer.LogChangesToValue(nameof(LdnServer));
             }
         }
 

src/Ryujinx.UI.Common/Configuration/ConfigurationState.cs

@@ -87,6 +87,7 @@ namespace Ryujinx.UI.Common.Configuration
                     AppColumn = UI.GuiColumns.AppColumn,
                     DevColumn = UI.GuiColumns.DevColumn,
                     VersionColumn = UI.GuiColumns.VersionColumn,
+                    LdnInfoColumn = UI.GuiColumns.LdnInfoColumn,
                     TimePlayedColumn = UI.GuiColumns.TimePlayedColumn,
                     LastPlayedColumn = UI.GuiColumns.LastPlayedColumn,
                     FileExtColumn = UI.GuiColumns.FileExtColumn,
@@ -136,6 +137,9 @@ namespace Ryujinx.UI.Common.Configuration
                 PreferredGpu = Graphics.PreferredGpu,
                 MultiplayerLanInterfaceId = Multiplayer.LanInterfaceId,
                 MultiplayerMode = Multiplayer.Mode,
+                MultiplayerDisableP2p = Multiplayer.DisableP2p,
+                MultiplayerLdnPassphrase = Multiplayer.LdnPassphrase,
+                LdnServer = Multiplayer.LdnServer,
             };
 
             return configurationFile;
@@ -195,6 +199,9 @@ namespace Ryujinx.UI.Common.Configuration
             System.UseHypervisor.Value = true;
             Multiplayer.LanInterfaceId.Value = "0";
             Multiplayer.Mode.Value = MultiplayerMode.Disabled;
+            Multiplayer.DisableP2p.Value = false;
+            Multiplayer.LdnPassphrase.Value = "";
+            Multiplayer.LdnServer.Value = "";
             UI.GuiColumns.FavColumn.Value = true;
             UI.GuiColumns.IconColumn.Value = true;
             UI.GuiColumns.AppColumn.Value = true;

src/Ryujinx.UI.Common/Configuration/UI/GuiColumns.cs

@@ -7,6 +7,7 @@ namespace Ryujinx.UI.Common.Configuration.UI
         public bool AppColumn { get; set; }
         public bool DevColumn { get; set; }
         public bool VersionColumn { get; set; }
+        public bool LdnInfoColumn { get; set; }
         public bool TimePlayedColumn { get; set; }
         public bool LastPlayedColumn { get; set; }
         public bool FileExtColumn { get; set; }

src/Ryujinx/AppHost.cs

@@ -207,6 +207,9 @@ namespace Ryujinx.Ava
             ConfigurationState.Instance.System.EnableInternetAccess.Event += UpdateEnableInternetAccessState;
             ConfigurationState.Instance.Multiplayer.LanInterfaceId.Event += UpdateLanInterfaceIdState;
             ConfigurationState.Instance.Multiplayer.Mode.Event += UpdateMultiplayerModeState;
+            ConfigurationState.Instance.Multiplayer.LdnPassphrase.Event += UpdateLdnPassphraseState;
+            ConfigurationState.Instance.Multiplayer.LdnServer.Event += UpdateLdnServerState;
+            ConfigurationState.Instance.Multiplayer.DisableP2p.Event += UpdateDisableP2pState;
 
             _gpuCancellationTokenSource = new CancellationTokenSource();
             _gpuDoneEvent = new ManualResetEvent(false);
@@ -491,6 +494,21 @@ namespace Ryujinx.Ava
             Device.Configuration.MultiplayerMode = e.NewValue;
         }
 
+        private void UpdateLdnPassphraseState(object sender, ReactiveEventArgs<string> e)
+        {
+            Device.Configuration.MultiplayerLdnPassphrase = e.NewValue;
+        }
+
+        private void UpdateLdnServerState(object sender, ReactiveEventArgs<string> e)
+        {
+            Device.Configuration.MultiplayerLdnServer = e.NewValue;
+        }
+
+        private void UpdateDisableP2pState(object sender, ReactiveEventArgs<bool> e)
+        {
+            Device.Configuration.MultiplayerDisableP2p = e.NewValue;
+        }
+
         public void ToggleVSync()
         {
             Device.EnableDeviceVsync = !Device.EnableDeviceVsync;
@@ -863,10 +881,11 @@ namespace Ryujinx.Ava
                 ConfigurationState.Instance.Graphics.AspectRatio,
                 ConfigurationState.Instance.System.AudioVolume,
                 ConfigurationState.Instance.System.UseHypervisor,
-                ConfigurationState.Instance.Multiplayer.LanInterfaceId,
+                ConfigurationState.Instance.Multiplayer.LanInterfaceId.Value,
-                ConfigurationState.Instance.Multiplayer.Mode
+                ConfigurationState.Instance.Multiplayer.Mode,
-                )
+                ConfigurationState.Instance.Multiplayer.DisableP2p,
-            );
+                ConfigurationState.Instance.Multiplayer.LdnPassphrase,
+                ConfigurationState.Instance.Multiplayer.LdnServer));
         }
 
         private static IHardwareDeviceDriver InitializeAudio()

src/Ryujinx/Assets/Locales/en_US.json

@@ -848,5 +848,17 @@
   "MultiplayerMode": "Mode:",
   "MultiplayerModeTooltip": "Change LDN multiplayer mode.\n\nLdnMitm will modify local wireless/local play functionality in games to function as if it were LAN, allowing for local, same-network connections with other Ryujinx instances and hacked Nintendo Switch consoles that have the ldn_mitm module installed.\n\nMultiplayer requires all players to be on the same game version (i.e. Super Smash Bros. Ultimate v13.0.1 can't connect to v13.0.0).\n\nLeave DISABLED if unsure.",
   "MultiplayerModeDisabled": "Disabled",
-  "MultiplayerModeLdnMitm": "ldn_mitm"
+  "MultiplayerModeLdnMitm": "ldn_mitm",
+  "MultiplayerModeLdnRyu": "RyuLDN",
+  "MultiplayerDisableP2P": "Disable P2P Network Hosting (may increase latency)",
+  "MultiplayerDisableP2PTooltip": "Disable P2P network hosting, peers will proxy through the master server instead of connecting to you directly.",
+  "LdnPassphrase": "Network Passphrase:",
+  "LdnPassphraseTooltip": "You will only be able to see hosted games with the same passphrase as you.",
+  "LdnPassphraseInputTooltip": "Enter a passphrase in the format Ryujinx-<8 hex chars>. You will only be able to see hosted games with the same passphrase as you.",
+  "LdnPassphraseInputPublic": "(public)",
+  "GenLdnPass": "Generate Random",
+  "GenLdnPassTooltip": "Generates a new passphrase, which can be shared with other players.",
+  "ClearLdnPass": "Clear",
+  "ClearLdnPassTooltip": "Clears the current passphrase, returning to the public network.",
+  "InvalidLdnPassphrase": "Invalid Passphrase! Must be in the format \"Ryujinx-<8 hex chars>\""
 }

src/Ryujinx/Program.cs

@@ -229,11 +229,9 @@ namespace Ryujinx.Ava
 
             var enabledLogLevels = Logger.GetEnabledLevels().ToArray();
 
-            Logger.Notice.Print(LogClass.Application, $"Logs Enabled: {
+            Logger.Notice.Print(LogClass.Application, $"Logs Enabled: {(enabledLogLevels.Length is 0
-                (enabledLogLevels.Length is 0
                     ? "<None>"
-                    : enabledLogLevels.JoinToString(", "))
+                    : enabledLogLevels.JoinToString(", "))}");
-            }");
 
             Logger.Notice.Print(LogClass.Application,
                 AppDataManager.Mode == AppDataManager.LaunchMode.Custom

src/Ryujinx/UI/Controls/ApplicationListView.axaml

@@ -7,6 +7,7 @@
     xmlns:helpers="clr-namespace:Ryujinx.Ava.UI.Helpers"
     xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
     xmlns:ui="clr-namespace:FluentAvalonia.UI.Controls;assembly=FluentAvalonia"
+    xmlns:converters="clr-namespace:Avalonia.Data.Converters;assembly=Avalonia.Base"
     d:DesignHeight="450"
     d:DesignWidth="800"
     Focusable="True"
@@ -110,6 +111,11 @@
                                         Text="{Binding FileExtension}"
                                         TextAlignment="Start"
                                         TextWrapping="Wrap" />
+                                    <TextBlock
+                                        HorizontalAlignment="Stretch"
+                                        Text="{Binding Converter={helpers:MultiplayerInfoConverter}}"
+                                        TextAlignment="Start"
+                                        TextWrapping="Wrap"/>
                                 </StackPanel>
                                 <StackPanel
                                     Grid.Column="4"

src/Ryujinx/UI/Helpers/MultiplayerInfoConverter.cs

@@ -0,0 +1,44 @@
+using Avalonia.Data.Converters;
+using Avalonia.Markup.Xaml;
+using Ryujinx.Ava.Common.Locale;
+using Ryujinx.UI.App.Common;
+using Ryujinx.UI.Common.Helper;
+using System;
+using System.Globalization;
+
+namespace Ryujinx.Ava.UI.Helpers
+{
+    internal class MultiplayerInfoConverter : MarkupExtension, IValueConverter
+    {
+        private static readonly MultiplayerInfoConverter _instance = new();
+
+        public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
+        {
+            if (value is ApplicationData applicationData)
+            {
+                if (applicationData.PlayerCount != 0 && applicationData.GameCount != 0)
+                {
+                    return $"Hosted Games: {applicationData.GameCount}\nOnline Players: {applicationData.PlayerCount}";
+                }
+                else
+                {
+                    return "";
+                }
+            }
+            else
+            {
+                return "";
+            }
+        }
+
+        public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
+        {
+            throw new NotSupportedException();
+        }
+
+        public override object ProvideValue(IServiceProvider serviceProvider)
+        {
+            return _instance;
+        }
+    }
+}

src/Ryujinx/UI/ViewModels/MainWindowViewModel.cs

@@ -117,6 +117,8 @@ namespace Ryujinx.Ava.UI.ViewModels
         public ApplicationData ListSelectedApplication;
         public ApplicationData GridSelectedApplication;
 
+        public IEnumerable<LdnGameData> LastLdnGameData;
+
         public static readonly Bitmap IconBitmap =
             new(Assembly.GetAssembly(typeof(ConfigurationState))!.GetManifestResourceStream("Ryujinx.UI.Common.Resources.Logo_Ryujinx.png")!);
 

src/Ryujinx/UI/ViewModels/SettingsViewModel.cs

@@ -25,12 +25,13 @@ using System.Collections.ObjectModel;
 using System.Linq;
 using System.Net.NetworkInformation;
 using System.Runtime.InteropServices;
+using System.Text.RegularExpressions;
 using System.Threading.Tasks;
 using TimeZone = Ryujinx.Ava.UI.Models.TimeZone;
 
 namespace Ryujinx.Ava.UI.ViewModels
 {
-    public class SettingsViewModel : BaseModel
+    public partial class SettingsViewModel : BaseModel
     {
         private readonly VirtualFileSystem _virtualFileSystem;
         private readonly ContentManager _contentManager;
@@ -56,6 +57,8 @@ namespace Ryujinx.Ava.UI.ViewModels
         public event Action SaveSettingsEvent;
         private int _networkInterfaceIndex;
         private int _multiplayerModeIndex;
+        private string _ldnPassphrase;
+        private string _LdnServer;
 
         public int ResolutionScale
         {
@@ -180,10 +183,24 @@ namespace Ryujinx.Ava.UI.ViewModels
 
         public bool IsVulkanSelected => GraphicsBackendIndex == 0;
         public bool UseHypervisor { get; set; }
+        public bool DisableP2P { get; set; }
 
         public string TimeZone { get; set; }
         public string ShaderDumpPath { get; set; }
 
+        public string LdnPassphrase
+        {
+            get => _ldnPassphrase;
+            set
+            {
+                _ldnPassphrase = value;
+                IsInvalidLdnPassphraseVisible = !ValidateLdnPassphrase(value);
+
+                OnPropertyChanged();
+                OnPropertyChanged(nameof(IsInvalidLdnPassphraseVisible));
+            }
+        }
+
         public int Language { get; set; }
         public int Region { get; set; }
         public int FsGlobalAccessLogMode { get; set; }
@@ -276,6 +293,21 @@ namespace Ryujinx.Ava.UI.ViewModels
             }
         }
 
+        [GeneratedRegex("Ryujinx-[0-9a-f]{8}")]
+        private static partial Regex LdnPassphraseRegex();
+
+        public bool IsInvalidLdnPassphraseVisible { get; set; }
+
+        public string LdnServer
+        {
+            get => _LdnServer;
+            set
+            {
+                _LdnServer = value;
+                OnPropertyChanged();
+            }
+        }
+
         public SettingsViewModel(VirtualFileSystem virtualFileSystem, ContentManager contentManager) : this()
         {
             _virtualFileSystem = virtualFileSystem;
@@ -393,6 +425,11 @@ namespace Ryujinx.Ava.UI.ViewModels
             Dispatcher.UIThread.Post(() => OnPropertyChanged(nameof(NetworkInterfaceIndex)));
         }
 
+        private bool ValidateLdnPassphrase(string passphrase)
+        {
+            return string.IsNullOrEmpty(passphrase) || (passphrase.Length == 16 && LdnPassphraseRegex().IsMatch(passphrase));
+        }
+
         public void ValidateAndSetTimeZone(string location)
         {
             if (_validTzRegions.Contains(location))
@@ -497,6 +534,9 @@ namespace Ryujinx.Ava.UI.ViewModels
             OpenglDebugLevel = (int)config.Logger.GraphicsDebugLevel.Value;
 
             MultiplayerModeIndex = (int)config.Multiplayer.Mode.Value;
+            DisableP2P = config.Multiplayer.DisableP2p.Value;
+            LdnPassphrase = config.Multiplayer.LdnPassphrase.Value;
+            LdnServer = config.Multiplayer.LdnServer.Value;
         }
 
         public void SaveSettings()
@@ -613,6 +653,9 @@ namespace Ryujinx.Ava.UI.ViewModels
 
             config.Multiplayer.LanInterfaceId.Value = _networkInterfaces[NetworkInterfaceList[NetworkInterfaceIndex]];
             config.Multiplayer.Mode.Value = (MultiplayerMode)MultiplayerModeIndex;
+            config.Multiplayer.DisableP2p.Value = DisableP2P;
+            config.Multiplayer.LdnPassphrase.Value = LdnPassphrase;
+            config.Multiplayer.LdnServer.Value = LdnServer;
 
             config.ToFileFormat().SaveConfig(Program.ConfigurationPath);
 

src/Ryujinx/UI/Views/Settings/SettingsNetworkView.axaml

@@ -1,4 +1,4 @@
-<UserControl
+<UserControl
     x:Class="Ryujinx.Ava.UI.Views.Settings.SettingsNetworkView"
     xmlns="https://github.com/avaloniaui"
     xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
@@ -36,11 +36,57 @@
                         <ComboBoxItem>
                             <TextBlock Text="{ext:Locale MultiplayerModeDisabled}" />
                         </ComboBoxItem>
+                        <ComboBoxItem>
+                            <TextBlock Text="{ext:Locale MultiplayerModeLdnRyu}" />
+                        </ComboBoxItem>
                         <ComboBoxItem>
                             <TextBlock Text="{ext:Locale MultiplayerModeLdnMitm}" />
                         </ComboBoxItem>
                     </ComboBox>
+                    <CheckBox Margin="10,0,0,0" IsChecked="{Binding DisableP2P}">
+                        <TextBlock Text="{ext:Locale MultiplayerDisableP2P}"
+                            ToolTip.Tip="{ext:Locale MultiplayerDisableP2PTooltip}" />
+                    </CheckBox>
                 </StackPanel>
+                <StackPanel Margin="10,0,0,0" Orientation="Horizontal">
+                    <TextBlock VerticalAlignment="Center"
+                        Text="{ext:Locale LdnPassphrase}"
+                        ToolTip.Tip="{ext:Locale LdnPassphraseTooltip}"
+                        Width="200" />
+                    <TextBox Name="LdnPassphrase"
+                        Text="{Binding LdnPassphrase}"
+                        Width="250"
+                        MaxLength="16"
+                        ToolTip.Tip="{ext:Locale LdnPassphraseInputTooltip}"
+                        Watermark="{ext:Locale LdnPassphraseInputPublic}" />
+                    <Button
+                        Name="GenLdnPassButton"
+                        Grid.Column="1"
+                        MinWidth="90"
+                        Margin="10,0,0,0"
+                        ToolTip.Tip="{ext:Locale GenLdnPassTooltip}"
+                        Click="GenLdnPassButton_OnClick">
+                        <TextBlock HorizontalAlignment="Center"
+                                    Text="{ext:Locale GenLdnPass}" />
+                    </Button>
+                    <Button
+                        Name="ClearLdnPassButton"
+                        Grid.Column="1"
+                        MinWidth="90"
+                        Margin="10,0,0,0"
+                        ToolTip.Tip="{ext:Locale ClearLdnPassTooltip}"
+                        Click="ClearLdnPassButton_OnClick">
+                        <TextBlock HorizontalAlignment="Center"
+                                    Text="{ext:Locale ClearLdnPass}" />
+                    </Button>
+                </StackPanel>
+                <TextBlock  Margin="10,0,0,0"
+                    VerticalAlignment="Center"
+                    Name="InvalidLdnPassphraseBlock"
+                    FontStyle="Italic"
+                    IsVisible="{Binding IsInvalidLdnPassphraseVisible}"
+                    Focusable="False"
+                    Text="{ext:Locale InvalidLdnPassphrase}" />
                 <Separator Height="1" />
                 <TextBlock Classes="h1" Text="{ext:Locale SettingsTabNetworkConnection}" />
                 <CheckBox Margin="10,0,0,0" IsChecked="{Binding EnableInternetAccess}">

src/Ryujinx/UI/Views/Settings/SettingsNetworkView.axaml.cs

@@ -1,12 +1,29 @@
 using Avalonia.Controls;
+using Avalonia.Interactivity;
+using Ryujinx.Ava.UI.ViewModels;
+using System;
 
 namespace Ryujinx.Ava.UI.Views.Settings
 {
     public partial class SettingsNetworkView : UserControl
     {
+        public SettingsViewModel ViewModel;
+
         public SettingsNetworkView()
         {
             InitializeComponent();
         }
+
+        private void GenLdnPassButton_OnClick(object sender, RoutedEventArgs e)
+        {
+            byte[] code = new byte[4];
+            new Random().NextBytes(code);
+            ViewModel.LdnPassphrase = $"Ryujinx-{BitConverter.ToUInt32(code):x8}";
+        }
+
+        private void ClearLdnPassButton_OnClick(object sender, RoutedEventArgs e)
+        {
+            ViewModel.LdnPassphrase = "";
+        }
     }
 }

src/Ryujinx/UI/Windows/MainWindow.axaml.cs

@@ -154,6 +154,36 @@ namespace Ryujinx.Ava.UI.Windows
             });
         }
 
+        private void ApplicationLibrary_LdnGameDataReceived(object sender, LdnGameDataReceivedEventArgs e)
+        {
+            Dispatcher.UIThread.Post(() =>
+            {
+                var ldnGameDataArray = e.LdnData;
+                ViewModel.LastLdnGameData = ldnGameDataArray;
+                foreach (var application in ViewModel.Applications)
+                {
+                    UpdateApplicationWithLdnData(application);
+                }
+                ViewModel.RefreshView();
+            });
+        }
+
+        private void UpdateApplicationWithLdnData(ApplicationData application)
+        {
+            if (application.ControlHolder.ByteSpan.Length > 0 && ViewModel.LastLdnGameData != null)
+            {
+                IEnumerable<LdnGameData> ldnGameData = ViewModel.LastLdnGameData.Where(game => application.ControlHolder.Value.LocalCommunicationId.Items.Contains(Convert.ToUInt64(game.TitleId, 16)));
+
+                application.PlayerCount = ldnGameData.Sum(game => game.PlayerCount);
+                application.GameCount = ldnGameData.Count();
+            }
+            else
+            {
+                application.PlayerCount = 0;
+                application.GameCount = 0;
+            }
+        }
+
         public void Application_Opened(object sender, ApplicationOpenedEventArgs args)
         {
             if (args.Application != null)
@@ -450,7 +480,20 @@ namespace Ryujinx.Ava.UI.Windows
                     .Connect()
                     .ObserveOn(SynchronizationContext.Current!)
                     .Bind(ViewModel.Applications)
+                    .OnItemAdded(UpdateApplicationWithLdnData)
                     .Subscribe();
+            ApplicationLibrary.LdnGameDataReceived += ApplicationLibrary_LdnGameDataReceived;
+
+            ConfigurationState.Instance.Multiplayer.Mode.Event += (sender, evt) =>
+            {
+                _ = Task.Run(ViewModel.ApplicationLibrary.RefreshLdn);
+            };
+
+            ConfigurationState.Instance.Multiplayer.LdnServer.Event += (sender, evt) =>
+            {
+                _ = Task.Run(ViewModel.ApplicationLibrary.RefreshLdn);
+            };
+            _ = Task.Run(ViewModel.ApplicationLibrary.RefreshLdn);
 
             ViewModel.RefreshFirmwareStatus();
 
@@ -588,13 +631,26 @@ namespace Ryujinx.Ava.UI.Windows
         {
             switch (fileType)
             {
-                case "NSP": ConfigurationState.Instance.UI.ShownFileTypes.NSP.Toggle(); break;
+                case "NSP":
-                case "PFS0": ConfigurationState.Instance.UI.ShownFileTypes.PFS0.Toggle(); break;
+                    ConfigurationState.Instance.UI.ShownFileTypes.NSP.Toggle();
-                case "XCI": ConfigurationState.Instance.UI.ShownFileTypes.XCI.Toggle(); break;
+                    break;
-                case "NCA": ConfigurationState.Instance.UI.ShownFileTypes.NCA.Toggle(); break;
+                case "PFS0":
-                case "NRO": ConfigurationState.Instance.UI.ShownFileTypes.NRO.Toggle(); break;
+                    ConfigurationState.Instance.UI.ShownFileTypes.PFS0.Toggle();
-                case "NSO": ConfigurationState.Instance.UI.ShownFileTypes.NSO.Toggle(); break;
+                    break;
-                default: throw new ArgumentOutOfRangeException(fileType);
+                case "XCI":
+                    ConfigurationState.Instance.UI.ShownFileTypes.XCI.Toggle();
+                    break;
+                case "NCA":
+                    ConfigurationState.Instance.UI.ShownFileTypes.NCA.Toggle();
+                    break;
+                case "NRO":
+                    ConfigurationState.Instance.UI.ShownFileTypes.NRO.Toggle();
+                    break;
+                case "NSO":
+                    ConfigurationState.Instance.UI.ShownFileTypes.NSO.Toggle();
+                    break;
+                default:
+                    throw new ArgumentOutOfRangeException(fileType);
             }
 
             ConfigurationState.Instance.ToFileFormat().SaveConfig(Program.ConfigurationPath);

src/Ryujinx/UI/Windows/SettingsWindow.axaml.cs

@@ -80,6 +80,7 @@ namespace Ryujinx.Ava.UI.Windows
                         NavPanel.Content = AudioPage;
                         break;
                     case "NetworkPage":
+                        NetworkPage.ViewModel = ViewModel;
                         NavPanel.Content = NetworkPage;
                         break;
                     case "LoggingPage":