diff --git a/Ryujinx.HLE/HOS/Services/Sockets/Bsd/BsdContext.cs b/Ryujinx.HLE/HOS/Services/Sockets/Bsd/BsdContext.cs
new file mode 100644
index 0000000000..071c131766
--- /dev/null
+++ b/Ryujinx.HLE/HOS/Services/Sockets/Bsd/BsdContext.cs
@@ -0,0 +1,150 @@
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+
+namespace Ryujinx.HLE.HOS.Services.Sockets.Bsd
+{
+ class BsdContext
+ {
+ private static ConcurrentDictionary<long, BsdContext> _registry = new ConcurrentDictionary<long, BsdContext>();
+
+ private readonly object _lock = new object();
+
+ private List<IFileDescriptor> _fds;
+
+ private BsdContext()
+ {
+ _fds = new List<IFileDescriptor>();
+ }
+
+ public ISocket RetrieveSocket(int socketFd)
+ {
+ IFileDescriptor file = RetrieveFileDescriptor(socketFd);
+
+ if (file is ISocket socket)
+ {
+ return socket;
+ }
+
+ return null;
+ }
+
+ public IFileDescriptor RetrieveFileDescriptor(int fd)
+ {
+ lock (_lock)
+ {
+ if (fd >= 0 && _fds.Count > fd)
+ {
+ return _fds[fd];
+ }
+ }
+
+ return null;
+ }
+
+ public int RegisterFileDescriptor(IFileDescriptor file)
+ {
+ lock (_lock)
+ {
+ for (int fd = 0; fd < _fds.Count; fd++)
+ {
+ if (_fds[fd] == null)
+ {
+ _fds[fd] = file;
+
+ return fd;
+ }
+ }
+
+ _fds.Add(file);
+
+ return _fds.Count - 1;
+ }
+ }
+
+ public int DuplicateFileDescriptor(int fd)
+ {
+ IFileDescriptor oldFile = RetrieveFileDescriptor(fd);
+
+ if (oldFile != null)
+ {
+ lock (_lock)
+ {
+ oldFile.Refcount++;
+
+ return RegisterFileDescriptor(oldFile);
+ }
+ }
+
+ return -1;
+ }
+
+ public bool CloseFileDescriptor(int fd)
+ {
+ IFileDescriptor file = RetrieveFileDescriptor(fd);
+
+ if (file != null)
+ {
+ file.Refcount--;
+
+ if (file.Refcount <= 0)
+ {
+ file.Dispose();
+ }
+
+ lock (_lock)
+ {
+ _fds[fd] = null;
+ }
+
+ return true;
+ }
+
+ return false;
+ }
+
+ public LinuxError ShutdownAllSockets(BsdSocketShutdownFlags how)
+ {
+ lock (_lock)
+ {
+ foreach (IFileDescriptor file in _fds)
+ {
+ if (file is ISocket socket)
+ {
+ LinuxError errno = socket.Shutdown(how);
+
+ if (errno != LinuxError.SUCCESS)
+ {
+ return errno;
+ }
+ }
+ }
+ }
+
+ return LinuxError.SUCCESS;
+ }
+
+ public static BsdContext GetOrRegister(long processId)
+ {
+ BsdContext context = GetContext(processId);
+
+ if (context == null)
+ {
+ context = new BsdContext();
+
+ _registry.TryAdd(processId, context);
+ }
+
+ return context;
+ }
+
+ public static BsdContext GetContext(long processId)
+ {
+ if (!_registry.TryGetValue(processId, out BsdContext processContext))
+ {
+ return null;
+ }
+
+ return processContext;
+ }
+ }
+}
diff --git a/Ryujinx.HLE/HOS/Services/Sockets/Bsd/IClient.cs b/Ryujinx.HLE/HOS/Services/Sockets/Bsd/IClient.cs
index 76f80f9293..ae245ec889 100644
--- a/Ryujinx.HLE/HOS/Services/Sockets/Bsd/IClient.cs
+++ b/Ryujinx.HLE/HOS/Services/Sockets/Bsd/IClient.cs
@@ -1,11 +1,12 @@
-using Ryujinx.Common.Logging;
+using Ryujinx.Common;
+using Ryujinx.Common.Logging;
+using Ryujinx.Memory;
using System;
-using System.Buffers.Binary;
using System.Collections.Generic;
using System.Net;
using System.Net.Sockets;
+using System.Runtime.CompilerServices;
using System.Text;
-using System.Threading;
namespace Ryujinx.HLE.HOS.Services.Sockets.Bsd
{
@@ -13,221 +14,21 @@ namespace Ryujinx.HLE.HOS.Services.Sockets.Bsd
[Service("bsd:u", false)]
class IClient : IpcService
{
- private static readonly Dictionary<WsaError, LinuxError> _errorMap = new()
+ private static readonly List<IPollManager> _pollManagers = new List<IPollManager>
{
- // WSAEINTR
- {WsaError.WSAEINTR, LinuxError.EINTR},
- // WSAEWOULDBLOCK
- {WsaError.WSAEWOULDBLOCK, LinuxError.EWOULDBLOCK},
- // WSAEINPROGRESS
- {WsaError.WSAEINPROGRESS, LinuxError.EINPROGRESS},
- // WSAEALREADY
- {WsaError.WSAEALREADY, LinuxError.EALREADY},
- // WSAENOTSOCK
- {WsaError.WSAENOTSOCK, LinuxError.ENOTSOCK},
- // WSAEDESTADDRREQ
- {WsaError.WSAEDESTADDRREQ, LinuxError.EDESTADDRREQ},
- // WSAEMSGSIZE
- {WsaError.WSAEMSGSIZE, LinuxError.EMSGSIZE},
- // WSAEPROTOTYPE
- {WsaError.WSAEPROTOTYPE, LinuxError.EPROTOTYPE},
- // WSAENOPROTOOPT
- {WsaError.WSAENOPROTOOPT, LinuxError.ENOPROTOOPT},
- // WSAEPROTONOSUPPORT
- {WsaError.WSAEPROTONOSUPPORT, LinuxError.EPROTONOSUPPORT},
- // WSAESOCKTNOSUPPORT
- {WsaError.WSAESOCKTNOSUPPORT, LinuxError.ESOCKTNOSUPPORT},
- // WSAEOPNOTSUPP
- {WsaError.WSAEOPNOTSUPP, LinuxError.EOPNOTSUPP},
- // WSAEPFNOSUPPORT
- {WsaError.WSAEPFNOSUPPORT, LinuxError.EPFNOSUPPORT},
- // WSAEAFNOSUPPORT
- {WsaError.WSAEAFNOSUPPORT, LinuxError.EAFNOSUPPORT},
- // WSAEADDRINUSE
- {WsaError.WSAEADDRINUSE, LinuxError.EADDRINUSE},
- // WSAEADDRNOTAVAIL
- {WsaError.WSAEADDRNOTAVAIL, LinuxError.EADDRNOTAVAIL},
- // WSAENETDOWN
- {WsaError.WSAENETDOWN, LinuxError.ENETDOWN},
- // WSAENETUNREACH
- {WsaError.WSAENETUNREACH, LinuxError.ENETUNREACH},
- // WSAENETRESET
- {WsaError.WSAENETRESET, LinuxError.ENETRESET},
- // WSAECONNABORTED
- {WsaError.WSAECONNABORTED, LinuxError.ECONNABORTED},
- // WSAECONNRESET
- {WsaError.WSAECONNRESET, LinuxError.ECONNRESET},
- // WSAENOBUFS
- {WsaError.WSAENOBUFS, LinuxError.ENOBUFS},
- // WSAEISCONN
- {WsaError.WSAEISCONN, LinuxError.EISCONN},
- // WSAENOTCONN
- {WsaError.WSAENOTCONN, LinuxError.ENOTCONN},
- // WSAESHUTDOWN
- {WsaError.WSAESHUTDOWN, LinuxError.ESHUTDOWN},
- // WSAETOOMANYREFS
- {WsaError.WSAETOOMANYREFS, LinuxError.ETOOMANYREFS},
- // WSAETIMEDOUT
- {WsaError.WSAETIMEDOUT, LinuxError.ETIMEDOUT},
- // WSAECONNREFUSED
- {WsaError.WSAECONNREFUSED, LinuxError.ECONNREFUSED},
- // WSAELOOP
- {WsaError.WSAELOOP, LinuxError.ELOOP},
- // WSAENAMETOOLONG
- {WsaError.WSAENAMETOOLONG, LinuxError.ENAMETOOLONG},
- // WSAEHOSTDOWN
- {WsaError.WSAEHOSTDOWN, LinuxError.EHOSTDOWN},
- // WSAEHOSTUNREACH
- {WsaError.WSAEHOSTUNREACH, LinuxError.EHOSTUNREACH},
- // WSAENOTEMPTY
- {WsaError.WSAENOTEMPTY, LinuxError.ENOTEMPTY},
- // WSAEUSERS
- {WsaError.WSAEUSERS, LinuxError.EUSERS},
- // WSAEDQUOT
- {WsaError.WSAEDQUOT, LinuxError.EDQUOT},
- // WSAESTALE
- {WsaError.WSAESTALE, LinuxError.ESTALE},
- // WSAEREMOTE
- {WsaError.WSAEREMOTE, LinuxError.EREMOTE},
- // WSAEINVAL
- {WsaError.WSAEINVAL, LinuxError.EINVAL},
- // WSAEFAULT
- {WsaError.WSAEFAULT, LinuxError.EFAULT},
- // NOERROR
- {0, 0}
- };
-
- private static readonly Dictionary<BsdSocketOption, SocketOptionName> _soSocketOptionMap = new()
- {
- { BsdSocketOption.SoDebug, SocketOptionName.Debug },
- { BsdSocketOption.SoReuseAddr, SocketOptionName.ReuseAddress },
- { BsdSocketOption.SoKeepAlive, SocketOptionName.KeepAlive },
- { BsdSocketOption.SoDontRoute, SocketOptionName.DontRoute },
- { BsdSocketOption.SoBroadcast, SocketOptionName.Broadcast },
- { BsdSocketOption.SoUseLoopBack, SocketOptionName.UseLoopback },
- { BsdSocketOption.SoLinger, SocketOptionName.Linger },
- { BsdSocketOption.SoOobInline, SocketOptionName.OutOfBandInline },
- { BsdSocketOption.SoReusePort, SocketOptionName.ReuseAddress },
- { BsdSocketOption.SoSndBuf, SocketOptionName.SendBuffer },
- { BsdSocketOption.SoRcvBuf, SocketOptionName.ReceiveBuffer },
- { BsdSocketOption.SoSndLoWat, SocketOptionName.SendLowWater },
- { BsdSocketOption.SoRcvLoWat, SocketOptionName.ReceiveLowWater },
- { BsdSocketOption.SoSndTimeo, SocketOptionName.SendTimeout },
- { BsdSocketOption.SoRcvTimeo, SocketOptionName.ReceiveTimeout },
- { BsdSocketOption.SoError, SocketOptionName.Error },
- { BsdSocketOption.SoType, SocketOptionName.Type }
- };
-
- private static readonly Dictionary<BsdSocketOption, SocketOptionName> _ipSocketOptionMap = new()
- {
- { BsdSocketOption.IpOptions, SocketOptionName.IPOptions },
- { BsdSocketOption.IpHdrIncl, SocketOptionName.HeaderIncluded },
- { BsdSocketOption.IpTtl, SocketOptionName.IpTimeToLive },
- { BsdSocketOption.IpMulticastIf, SocketOptionName.MulticastInterface },
- { BsdSocketOption.IpMulticastTtl, SocketOptionName.MulticastTimeToLive },
- { BsdSocketOption.IpMulticastLoop, SocketOptionName.MulticastLoopback },
- { BsdSocketOption.IpAddMembership, SocketOptionName.AddMembership },
- { BsdSocketOption.IpDropMembership, SocketOptionName.DropMembership },
- { BsdSocketOption.IpDontFrag, SocketOptionName.DontFragment },
- { BsdSocketOption.IpAddSourceMembership, SocketOptionName.AddSourceMembership },
- { BsdSocketOption.IpDropSourceMembership, SocketOptionName.DropSourceMembership }
- };
-
- private static readonly Dictionary<BsdSocketOption, SocketOptionName> _tcpSocketOptionMap = new()
- {
- { BsdSocketOption.TcpNoDelay, SocketOptionName.NoDelay },
- { BsdSocketOption.TcpKeepIdle, SocketOptionName.TcpKeepAliveTime },
- { BsdSocketOption.TcpKeepIntvl, SocketOptionName.TcpKeepAliveInterval },
- { BsdSocketOption.TcpKeepCnt, SocketOptionName.TcpKeepAliveRetryCount }
+ EventFileDescriptorPollManager.Instance,
+ ManagedSocketPollManager.Instance
};
+ private BsdContext _context;
private bool _isPrivileged;
- private List<BsdSocket> _sockets = new List<BsdSocket>();
-
public IClient(ServiceCtx context, bool isPrivileged) : base(context.Device.System.BsdServer)
{
_isPrivileged = isPrivileged;
}
- private static LinuxError ConvertError(WsaError errorCode)
- {
- if (!_errorMap.TryGetValue(errorCode, out LinuxError errno))
- {
- errno = (LinuxError)errorCode;
- }
-
- return errno;
- }
-
- private static SocketFlags ConvertBsdSocketFlags(BsdSocketFlags bsdSocketFlags)
- {
- SocketFlags socketFlags = SocketFlags.None;
-
- if (bsdSocketFlags.HasFlag(BsdSocketFlags.Oob))
- {
- socketFlags |= SocketFlags.OutOfBand;
- }
-
- if (bsdSocketFlags.HasFlag(BsdSocketFlags.Peek))
- {
- socketFlags |= SocketFlags.Peek;
- }
-
- if (bsdSocketFlags.HasFlag(BsdSocketFlags.DontRoute))
- {
- socketFlags |= SocketFlags.DontRoute;
- }
-
- if (bsdSocketFlags.HasFlag(BsdSocketFlags.Trunc))
- {
- socketFlags |= SocketFlags.Truncated;
- }
-
- if (bsdSocketFlags.HasFlag(BsdSocketFlags.CTrunc))
- {
- socketFlags |= SocketFlags.ControlDataTruncated;
- }
-
- bsdSocketFlags &= ~(BsdSocketFlags.Oob |
- BsdSocketFlags.Peek |
- BsdSocketFlags.DontRoute |
- BsdSocketFlags.Trunc |
- BsdSocketFlags.CTrunc);
-
- if (bsdSocketFlags != BsdSocketFlags.None)
- {
- Logger.Warning?.Print(LogClass.ServiceBsd, $"Unsupported socket flags: {bsdSocketFlags}");
- }
-
- return socketFlags;
- }
-
- private static bool TryConvertSocketOption(BsdSocketOption option, SocketOptionLevel level, out SocketOptionName name)
- {
- var table = level switch
- {
- SocketOptionLevel.Socket => _soSocketOptionMap,
- SocketOptionLevel.IP => _ipSocketOptionMap,
- SocketOptionLevel.Tcp => _tcpSocketOptionMap,
- _ => null
- };
-
- if (table == null)
- {
- name = default;
- return false;
- }
-
- return table.TryGetValue(option, out name);
- }
-
- private ResultCode WriteWinSock2Error(ServiceCtx context, WsaError errorCode)
- {
- return WriteBsdResult(context, -1, ConvertError(errorCode));
- }
-
- private ResultCode WriteBsdResult(ServiceCtx context, int result, LinuxError errorCode = 0)
+ private ResultCode WriteBsdResult(ServiceCtx context, int result, LinuxError errorCode = LinuxError.SUCCESS)
{
if (errorCode != LinuxError.SUCCESS)
{
@@ -240,100 +41,96 @@ namespace Ryujinx.HLE.HOS.Services.Sockets.Bsd
return ResultCode.Success;
}
- private BsdSocket RetrieveSocket(int socketFd)
+ private static AddressFamily ConvertBsdAddressFamily(BsdAddressFamily family)
{
- if (socketFd >= 0 && _sockets.Count > socketFd)
+ switch (family)
{
- return _sockets[socketFd];
+ case BsdAddressFamily.Unspecified:
+ return AddressFamily.Unspecified;
+ case BsdAddressFamily.InterNetwork:
+ return AddressFamily.InterNetwork;
+ case BsdAddressFamily.InterNetworkV6:
+ return AddressFamily.InterNetworkV6;
+ case BsdAddressFamily.Unknown:
+ return AddressFamily.Unknown;
+ default:
+ throw new NotImplementedException(family.ToString());
}
-
- return null;
}
- private LinuxError SetResultErrno(Socket socket, int result)
+ private LinuxError SetResultErrno(IFileDescriptor socket, int result)
{
return result == 0 && !socket.Blocking ? LinuxError.EWOULDBLOCK : LinuxError.SUCCESS;
}
- private AddressFamily ConvertFromBsd(int domain)
- {
- if (domain == 2)
- {
- return AddressFamily.InterNetwork;
- }
-
- // FIXME: AF_ROUTE ignored, is that really needed?
- return AddressFamily.Unknown;
- }
-
private ResultCode SocketInternal(ServiceCtx context, bool exempt)
{
- AddressFamily domain = (AddressFamily)context.RequestData.ReadInt32();
- SocketType type = (SocketType)context.RequestData.ReadInt32();
- ProtocolType protocol = (ProtocolType)context.RequestData.ReadInt32();
+ BsdAddressFamily domain = (BsdAddressFamily)context.RequestData.ReadInt32();
+ BsdSocketType type = (BsdSocketType)context.RequestData.ReadInt32();
+ ProtocolType protocol = (ProtocolType)context.RequestData.ReadInt32();
- if (domain == AddressFamily.Unknown)
+ BsdSocketCreationFlags creationFlags = (BsdSocketCreationFlags)((int)type >> (int)BsdSocketCreationFlags.FlagsShift);
+ type &= BsdSocketType.TypeMask;
+
+ if (domain == BsdAddressFamily.Unknown)
{
return WriteBsdResult(context, -1, LinuxError.EPROTONOSUPPORT);
}
- else if ((type == SocketType.Seqpacket || type == SocketType.Raw) && !_isPrivileged)
+ else if ((type == BsdSocketType.Seqpacket || type == BsdSocketType.Raw) && !_isPrivileged)
{
- if (domain != AddressFamily.InterNetwork || type != SocketType.Raw || protocol != ProtocolType.Icmp)
+ if (domain != BsdAddressFamily.InterNetwork || type != BsdSocketType.Raw || protocol != ProtocolType.Icmp)
{
return WriteBsdResult(context, -1, LinuxError.ENOENT);
}
}
- BsdSocket newBsdSocket = new BsdSocket
- {
- Family = (int)domain,
- Type = (int)type,
- Protocol = (int)protocol,
- Handle = new Socket(domain, type, protocol)
- };
+ AddressFamily netDomain = ConvertBsdAddressFamily(domain);
- _sockets.Add(newBsdSocket);
+ if (protocol == ProtocolType.IP)
+ {
+ if (type == BsdSocketType.Stream)
+ {
+ protocol = ProtocolType.Tcp;
+ }
+ else if (type == BsdSocketType.Dgram)
+ {
+ protocol = ProtocolType.Udp;
+ }
+ }
+
+ ISocket newBsdSocket = new ManagedSocket(netDomain, (SocketType)type, protocol);
+ newBsdSocket.Blocking = !creationFlags.HasFlag(BsdSocketCreationFlags.NonBlocking);
+
+ LinuxError errno = LinuxError.SUCCESS;
+
+ int newSockFd = _context.RegisterFileDescriptor(newBsdSocket);
+
+ if (newSockFd == -1)
+ {
+ errno = LinuxError.EBADF;
+ }
if (exempt)
{
- newBsdSocket.Handle.Disconnect(true);
+ newBsdSocket.Disconnect();
}
- return WriteBsdResult(context, _sockets.Count - 1);
+ return WriteBsdResult(context, newSockFd, errno);
}
- private IPEndPoint ParseSockAddr(ServiceCtx context, ulong bufferPosition, ulong bufferSize)
+ private void WriteSockAddr(ServiceCtx context, ulong bufferPosition, ISocket socket, bool isRemote)
{
- int size = context.Memory.Read<byte>(bufferPosition);
- int family = context.Memory.Read<byte>(bufferPosition + 1);
- int port = BinaryPrimitives.ReverseEndianness(context.Memory.Read<ushort>(bufferPosition + 2));
+ IPEndPoint endPoint = isRemote ? socket.RemoteEndPoint : socket.LocalEndPoint;
- byte[] rawIp = new byte[4];
-
- context.Memory.Read(bufferPosition + 4, rawIp);
-
- return new IPEndPoint(new IPAddress(rawIp), port);
- }
-
- private void WriteSockAddr(ServiceCtx context, ulong bufferPosition, IPEndPoint endPoint)
- {
- context.Memory.Write(bufferPosition, (byte)0);
- context.Memory.Write(bufferPosition + 1, (byte)endPoint.AddressFamily);
- context.Memory.Write(bufferPosition + 2, BinaryPrimitives.ReverseEndianness((ushort)endPoint.Port));
- context.Memory.Write(bufferPosition + 4, endPoint.Address.GetAddressBytes());
- }
-
- private void WriteSockAddr(ServiceCtx context, ulong bufferPosition, BsdSocket socket, bool isRemote)
- {
- IPEndPoint endPoint = (isRemote ? socket.Handle.RemoteEndPoint : socket.Handle.LocalEndPoint) as IPEndPoint;
-
- WriteSockAddr(context, bufferPosition, endPoint);
+ context.Memory.Write(bufferPosition, BsdSockAddr.FromIPEndPoint(endPoint));
}
[CommandHipc(0)]
// Initialize(nn::socket::BsdBufferConfig config, u64 pid, u64 transferMemorySize, KObject<copy, transfer_memory>, pid) -> u32 bsd_errno
public ResultCode RegisterClient(ServiceCtx context)
{
+ _context = BsdContext.GetOrRegister(context.Request.HandleDesc.PId);
+
/*
typedef struct {
u32 version; // Observed 1 on 2.0 LibAppletWeb, 2 on 3.0.
@@ -424,7 +221,6 @@ namespace Ryujinx.HLE.HOS.Services.Sockets.Bsd
(ulong bufferPosition, ulong bufferSize) = context.Request.GetBufferType0x21();
-
if (timeout < -1 || fdsCount < 0 || (ulong)(fdsCount * 8) > bufferSize)
{
return WriteBsdResult(context, -1, LinuxError.EINVAL);
@@ -434,75 +230,94 @@ namespace Ryujinx.HLE.HOS.Services.Sockets.Bsd
for (int i = 0; i < fdsCount; i++)
{
- int socketFd = context.Memory.Read<int>(bufferPosition + (ulong)i * 8);
+ PollEventData pollEventData = context.Memory.Read<PollEventData>(bufferPosition + (ulong)(i * Unsafe.SizeOf<PollEventData>()));
- BsdSocket socket = RetrieveSocket(socketFd);
+ IFileDescriptor fileDescriptor = _context.RetrieveFileDescriptor(pollEventData.SocketFd);
- if (socket == null)
+ if (fileDescriptor == null)
{
- return WriteBsdResult(context, -1, LinuxError.EBADF);}
+ return WriteBsdResult(context, -1, LinuxError.EBADF);
+ }
- PollEvent.EventTypeMask inputEvents = (PollEvent.EventTypeMask)context.Memory.Read<short>(bufferPosition + (ulong)i * 8 + 4);
- PollEvent.EventTypeMask outputEvents = (PollEvent.EventTypeMask)context.Memory.Read<short>(bufferPosition + (ulong)i * 8 + 6);
-
- events[i] = new PollEvent(socketFd, socket, inputEvents, outputEvents);
+ events[i] = new PollEvent(pollEventData, fileDescriptor);
}
- List<Socket> readEvents = new List<Socket>();
- List<Socket> writeEvents = new List<Socket>();
- List<Socket> errorEvents = new List<Socket>();
+ List<PollEvent> discoveredEvents = new List<PollEvent>();
+ List<PollEvent>[] eventsByPollManager = new List<PollEvent>[_pollManagers.Count];
- foreach (PollEvent Event in events)
+ for (int i = 0; i < eventsByPollManager.Length; i++)
{
- bool isValidEvent = false;
+ eventsByPollManager[i] = new List<PollEvent>();
- if ((Event.InputEvents & PollEvent.EventTypeMask.Input) != 0)
+ foreach (PollEvent evnt in events)
{
- readEvents.Add(Event.Socket.Handle);
- errorEvents.Add(Event.Socket.Handle);
-
- isValidEvent = true;
- }
-
- if ((Event.InputEvents & PollEvent.EventTypeMask.UrgentInput) != 0)
- {
- readEvents.Add(Event.Socket.Handle);
- errorEvents.Add(Event.Socket.Handle);
-
- isValidEvent = true;
- }
-
- if ((Event.InputEvents & PollEvent.EventTypeMask.Output) != 0)
- {
- writeEvents.Add(Event.Socket.Handle);
- errorEvents.Add(Event.Socket.Handle);
-
- isValidEvent = true;
- }
-
- if ((Event.InputEvents & PollEvent.EventTypeMask.Error) != 0)
- {
- errorEvents.Add(Event.Socket.Handle);
- isValidEvent = true;
- }
-
- if (!isValidEvent)
- {
- Logger.Warning?.Print(LogClass.ServiceBsd, $"Unsupported Poll input event type: {Event.InputEvents}");
- return WriteBsdResult(context, -1, LinuxError.EINVAL);
+ if (_pollManagers[i].IsCompatible(evnt))
+ {
+ eventsByPollManager[i].Add(evnt);
+ discoveredEvents.Add(evnt);
+ }
}
}
+ foreach (PollEvent evnt in events)
+ {
+ if (!discoveredEvents.Contains(evnt))
+ {
+ Logger.Error?.Print(LogClass.ServiceBsd, $"Poll operation is not supported for {evnt.FileDescriptor.GetType().Name}!");
+
+ return WriteBsdResult(context, -1, LinuxError.EBADF);
+ }
+ }
+
+ int updateCount = 0;
+
+ LinuxError errno = LinuxError.SUCCESS;
+
if (fdsCount != 0)
{
- try
+ bool IsUnexpectedLinuxError(LinuxError error)
{
- System.Net.Sockets.Socket.Select(readEvents, writeEvents, errorEvents, timeout);
+ return errno != LinuxError.SUCCESS && errno != LinuxError.ETIMEDOUT;
}
- catch (SocketException exception)
+
+ // Hybrid approach
+ long budgetLeftMilliseconds;
+
+ if (timeout == -1)
{
- return WriteWinSock2Error(context, (WsaError)exception.ErrorCode);
+ budgetLeftMilliseconds = PerformanceCounter.ElapsedMilliseconds + uint.MaxValue;
}
+ else
+ {
+ budgetLeftMilliseconds = PerformanceCounter.ElapsedMilliseconds + timeout;
+ }
+
+ do
+ {
+ for (int i = 0; i < eventsByPollManager.Length; i++)
+ {
+ if (eventsByPollManager[i].Count == 0)
+ {
+ continue;
+ }
+
+ errno = _pollManagers[i].Poll(eventsByPollManager[i], 0, out updateCount);
+
+ if (IsUnexpectedLinuxError(errno))
+ {
+ break;
+ }
+
+ if (updateCount > 0)
+ {
+ break;
+ }
+ }
+
+ // If we are here, that mean nothing was availaible, sleep for 50ms
+ context.Device.System.KernelContext.Syscall.SleepThread(50 * 1000000);
+ }
+ while (PerformanceCounter.ElapsedMilliseconds < budgetLeftMilliseconds);
}
else if (timeout == -1)
{
@@ -511,47 +326,16 @@ namespace Ryujinx.HLE.HOS.Services.Sockets.Bsd
}
else
{
- // FIXME: We should make the KThread sleep but we can't do much about it yet.
- Thread.Sleep(timeout);
+ context.Device.System.KernelContext.Syscall.SleepThread(timeout);
}
+ // TODO: Spanify
for (int i = 0; i < fdsCount; i++)
{
- PollEvent Event = events[i];
- context.Memory.Write(bufferPosition + (ulong)i * 8, Event.SocketFd);
- context.Memory.Write(bufferPosition + (ulong)i * 8 + 4, (short)Event.InputEvents);
-
- PollEvent.EventTypeMask outputEvents = 0;
-
- Socket socket = Event.Socket.Handle;
-
- if (errorEvents.Contains(socket))
- {
- outputEvents |= PollEvent.EventTypeMask.Error;
-
- if (!socket.Connected || !socket.IsBound)
- {
- outputEvents |= PollEvent.EventTypeMask.Disconnected;
- }
- }
-
- if (readEvents.Contains(socket))
- {
- if ((Event.InputEvents & PollEvent.EventTypeMask.Input) != 0)
- {
- outputEvents |= PollEvent.EventTypeMask.Input;
- }
- }
-
- if (writeEvents.Contains(socket))
- {
- outputEvents |= PollEvent.EventTypeMask.Output;
- }
-
- context.Memory.Write(bufferPosition + (ulong)i * 8 + 6, (short)outputEvents);
+ context.Memory.Write(bufferPosition + (ulong)(i * Unsafe.SizeOf<PollEventData>()), events[i].Data);
}
- return WriteBsdResult(context, readEvents.Count + writeEvents.Count + errorEvents.Count, LinuxError.SUCCESS);
+ return WriteBsdResult(context, updateCount, errno);
}
[CommandHipc(7)]
@@ -574,24 +358,21 @@ namespace Ryujinx.HLE.HOS.Services.Sockets.Bsd
(ulong receivePosition, ulong receiveLength) = context.Request.GetBufferType0x22();
+ WritableRegion receiveRegion = context.Memory.GetWritableRegion(receivePosition, (int)receiveLength);
+
LinuxError errno = LinuxError.EBADF;
- BsdSocket socket = RetrieveSocket(socketFd);
+ ISocket socket = _context.RetrieveSocket(socketFd);
int result = -1;
if (socket != null)
{
- byte[] receivedBuffer = new byte[receiveLength];
+ errno = socket.Receive(out result, receiveRegion.Memory.Span, socketFlags);
- try
+ if (errno == LinuxError.SUCCESS)
{
- result = socket.Handle.Receive(receivedBuffer, ConvertBsdSocketFlags(socketFlags));
- errno = SetResultErrno(socket.Handle, result);
+ SetResultErrno(socket, result);
- context.Memory.Write(receivePosition, receivedBuffer);
- }
- catch (SocketException exception)
- {
- errno = ConvertError((WsaError)exception.ErrorCode);
+ receiveRegion.Dispose();
}
}
@@ -605,29 +386,26 @@ namespace Ryujinx.HLE.HOS.Services.Sockets.Bsd
int socketFd = context.RequestData.ReadInt32();
BsdSocketFlags socketFlags = (BsdSocketFlags)context.RequestData.ReadInt32();
- (ulong receivePosition, ulong receiveLength) = context.Request.GetBufferType0x22();
+ (ulong receivePosition, ulong receiveLength) = context.Request.GetBufferType0x22(0);
(ulong sockAddrOutPosition, ulong sockAddrOutSize) = context.Request.GetBufferType0x22(1);
+ WritableRegion receiveRegion = context.Memory.GetWritableRegion(receivePosition, (int)receiveLength);
+
LinuxError errno = LinuxError.EBADF;
- BsdSocket socket = RetrieveSocket(socketFd);
+ ISocket socket = _context.RetrieveSocket(socketFd);
int result = -1;
if (socket != null)
{
- byte[] receivedBuffer = new byte[receiveLength];
- EndPoint endPoint = new IPEndPoint(IPAddress.Any, 0);
+ errno = socket.ReceiveFrom(out result, receiveRegion.Memory.Span, receiveRegion.Memory.Span.Length, socketFlags, out IPEndPoint endPoint);
- try
+ if (errno == LinuxError.SUCCESS)
{
- result = socket.Handle.ReceiveFrom(receivedBuffer, receivedBuffer.Length, ConvertBsdSocketFlags(socketFlags), ref endPoint);
- errno = SetResultErrno(socket.Handle, result);
+ SetResultErrno(socket, result);
- context.Memory.Write(receivePosition, receivedBuffer);
- WriteSockAddr(context, sockAddrOutPosition, (IPEndPoint)endPoint);
- }
- catch (SocketException exception)
- {
- errno = ConvertError((WsaError)exception.ErrorCode);
+ receiveRegion.Dispose();
+
+ context.Memory.Write(sockAddrOutPosition, BsdSockAddr.FromIPEndPoint(endPoint));
}
}
@@ -643,26 +421,20 @@ namespace Ryujinx.HLE.HOS.Services.Sockets.Bsd
(ulong sendPosition, ulong sendSize) = context.Request.GetBufferType0x21();
+ ReadOnlySpan<byte> sendBuffer = context.Memory.GetSpan(sendPosition, (int)sendSize);
+
LinuxError errno = LinuxError.EBADF;
- BsdSocket socket = RetrieveSocket(socketFd);
+ ISocket socket = _context.RetrieveSocket(socketFd);
int result = -1;
if (socket != null)
{
- byte[] sendBuffer = new byte[sendSize];
+ errno = socket.Send(out result, sendBuffer, socketFlags);
- context.Memory.Read(sendPosition, sendBuffer);
-
- try
+ if (errno == LinuxError.SUCCESS)
{
- result = socket.Handle.Send(sendBuffer, ConvertBsdSocketFlags(socketFlags));
- errno = SetResultErrno(socket.Handle, result);
+ SetResultErrno(socket, result);
}
- catch (SocketException exception)
- {
- errno = ConvertError((WsaError)exception.ErrorCode);
- }
-
}
return WriteBsdResult(context, result, errno);
@@ -675,31 +447,25 @@ namespace Ryujinx.HLE.HOS.Services.Sockets.Bsd
int socketFd = context.RequestData.ReadInt32();
BsdSocketFlags socketFlags = (BsdSocketFlags)context.RequestData.ReadInt32();
- (ulong sendPosition, ulong sendSize) = context.Request.GetBufferType0x21();
+ (ulong sendPosition, ulong sendSize) = context.Request.GetBufferType0x21(0);
(ulong bufferPosition, ulong bufferSize) = context.Request.GetBufferType0x21(1);
+ ReadOnlySpan<byte> sendBuffer = context.Memory.GetSpan(sendPosition, (int)sendSize);
+
LinuxError errno = LinuxError.EBADF;
- BsdSocket socket = RetrieveSocket(socketFd);
+ ISocket socket = _context.RetrieveSocket(socketFd);
int result = -1;
if (socket != null)
{
- byte[] sendBuffer = new byte[sendSize];
+ IPEndPoint endPoint = context.Memory.Read<BsdSockAddr>(bufferPosition).ToIPEndPoint();
- context.Memory.Read(sendPosition, sendBuffer);
+ errno = socket.SendTo(out result, sendBuffer, sendBuffer.Length, socketFlags, endPoint);
- EndPoint endPoint = ParseSockAddr(context, bufferPosition, bufferSize);
-
- try
+ if (errno == LinuxError.SUCCESS)
{
- result = socket.Handle.SendTo(sendBuffer, sendBuffer.Length, ConvertBsdSocketFlags(socketFlags), endPoint);
- errno = SetResultErrno(socket.Handle, result);
+ SetResultErrno(socket, result);
}
- catch (SocketException exception)
- {
- errno = ConvertError((WsaError)exception.ErrorCode);
- }
-
}
return WriteBsdResult(context, result, errno);
@@ -714,22 +480,11 @@ namespace Ryujinx.HLE.HOS.Services.Sockets.Bsd
(ulong bufferPos, ulong bufferSize) = context.Request.GetBufferType0x22();
LinuxError errno = LinuxError.EBADF;
- BsdSocket socket = RetrieveSocket(socketFd);
+ ISocket socket = _context.RetrieveSocket(socketFd);
if (socket != null)
{
- errno = LinuxError.SUCCESS;
-
- Socket newSocket = null;
-
- try
- {
- newSocket = socket.Handle.Accept();
- }
- catch (SocketException exception)
- {
- errno = ConvertError((WsaError)exception.ErrorCode);
- }
+ errno = socket.Accept(out ISocket newSocket);
if (newSocket == null && errno == LinuxError.SUCCESS)
{
@@ -737,19 +492,18 @@ namespace Ryujinx.HLE.HOS.Services.Sockets.Bsd
}
else if (errno == LinuxError.SUCCESS)
{
- BsdSocket newBsdSocket = new BsdSocket
+ int newSockFd = _context.RegisterFileDescriptor(newSocket);
+
+ if (newSockFd == -1)
{
- Family = (int)newSocket.AddressFamily,
- Type = (int)newSocket.SocketType,
- Protocol = (int)newSocket.ProtocolType,
- Handle = newSocket
- };
+ errno = LinuxError.EBADF;
+ }
+ else
+ {
+ WriteSockAddr(context, bufferPos, newSocket, true);
+ }
- _sockets.Add(newBsdSocket);
-
- WriteSockAddr(context, bufferPos, newBsdSocket, true);
-
- WriteBsdResult(context, _sockets.Count - 1, errno);
+ WriteBsdResult(context, newSockFd, errno);
context.ResponseData.Write(0x10);
@@ -766,25 +520,16 @@ namespace Ryujinx.HLE.HOS.Services.Sockets.Bsd
{
int socketFd = context.RequestData.ReadInt32();
- (ulong bufferPos, ulong bufferSize) = context.Request.GetBufferType0x21();
+ (ulong bufferPosition, ulong bufferSize) = context.Request.GetBufferType0x21();
LinuxError errno = LinuxError.EBADF;
- BsdSocket socket = RetrieveSocket(socketFd);
+ ISocket socket = _context.RetrieveSocket(socketFd);
if (socket != null)
{
- errno = LinuxError.SUCCESS;
+ IPEndPoint endPoint = context.Memory.Read<BsdSockAddr>(bufferPosition).ToIPEndPoint();
- try
- {
- IPEndPoint endPoint = ParseSockAddr(context, bufferPos, bufferSize);
-
- socket.Handle.Bind(endPoint);
- }
- catch (SocketException exception)
- {
- errno = ConvertError((WsaError)exception.ErrorCode);
- }
+ errno = socket.Bind(endPoint);
}
return WriteBsdResult(context, 0, errno);
@@ -796,31 +541,16 @@ namespace Ryujinx.HLE.HOS.Services.Sockets.Bsd
{
int socketFd = context.RequestData.ReadInt32();
- (ulong bufferPos, ulong bufferSize) = context.Request.GetBufferType0x21();
+ (ulong bufferPosition, ulong bufferSize) = context.Request.GetBufferType0x21();
LinuxError errno = LinuxError.EBADF;
- BsdSocket socket = RetrieveSocket(socketFd);
+ ISocket socket = _context.RetrieveSocket(socketFd);
if (socket != null)
{
- errno = LinuxError.SUCCESS;
- try
- {
- IPEndPoint endPoint = ParseSockAddr(context, bufferPos, bufferSize);
+ IPEndPoint endPoint = context.Memory.Read<BsdSockAddr>(bufferPosition).ToIPEndPoint();
- socket.Handle.Connect(endPoint);
- }
- catch (SocketException exception)
- {
- if (!socket.Handle.Blocking && exception.ErrorCode == (int)WsaError.WSAEWOULDBLOCK)
- {
- errno = LinuxError.EINPROGRESS;
- }
- else
- {
- errno = ConvertError((WsaError)exception.ErrorCode);
- }
- }
+ errno = socket.Connect(endPoint);
}
return WriteBsdResult(context, 0, errno);
@@ -832,18 +562,18 @@ namespace Ryujinx.HLE.HOS.Services.Sockets.Bsd
{
int socketFd = context.RequestData.ReadInt32();
- (ulong bufferPos, ulong bufferSize) = context.Request.GetBufferType0x22();
+ (ulong bufferPosition, ulong bufferSize) = context.Request.GetBufferType0x22();
- LinuxError errno = LinuxError.EBADF;
- BsdSocket socket = RetrieveSocket(socketFd);
+ LinuxError errno = LinuxError.EBADF;
+ ISocket socket = _context.RetrieveSocket(socketFd);
if (socket != null)
{
errno = LinuxError.SUCCESS;
- WriteSockAddr(context, bufferPos, socket, true);
+ WriteSockAddr(context, bufferPosition, socket, true);
WriteBsdResult(context, 0, errno);
- context.ResponseData.Write(0x10);
+ context.ResponseData.Write(Unsafe.SizeOf<BsdSockAddr>());
}
return WriteBsdResult(context, 0, errno);
@@ -858,7 +588,7 @@ namespace Ryujinx.HLE.HOS.Services.Sockets.Bsd
(ulong bufferPos, ulong bufferSize) = context.Request.GetBufferType0x22();
LinuxError errno = LinuxError.EBADF;
- BsdSocket socket = RetrieveSocket(socketFd);
+ ISocket socket = _context.RetrieveSocket(socketFd);
if (socket != null)
{
@@ -866,7 +596,7 @@ namespace Ryujinx.HLE.HOS.Services.Sockets.Bsd
WriteSockAddr(context, bufferPos, socket, false);
WriteBsdResult(context, 0, errno);
- context.ResponseData.Write(0x10);
+ context.ResponseData.Write(Unsafe.SizeOf<BsdSockAddr>());
}
return WriteBsdResult(context, 0, errno);
@@ -881,13 +611,19 @@ namespace Ryujinx.HLE.HOS.Services.Sockets.Bsd
BsdSocketOption option = (BsdSocketOption)context.RequestData.ReadInt32();
(ulong bufferPosition, ulong bufferSize) = context.Request.GetBufferType0x22();
+ WritableRegion optionValue = context.Memory.GetWritableRegion(bufferPosition, (int)bufferSize);
LinuxError errno = LinuxError.EBADF;
- BsdSocket socket = RetrieveSocket(socketFd);
+ ISocket socket = _context.RetrieveSocket(socketFd);
if (socket != null)
{
- errno = HandleGetSocketOption(context, socket, option, level, bufferPosition, bufferSize);
+ errno = socket.GetSocketOption(option, level, optionValue.Memory.Span);
+
+ if (errno == LinuxError.SUCCESS)
+ {
+ optionValue.Dispose();
+ }
}
return WriteBsdResult(context, 0, errno);
@@ -901,20 +637,11 @@ namespace Ryujinx.HLE.HOS.Services.Sockets.Bsd
int backlog = context.RequestData.ReadInt32();
LinuxError errno = LinuxError.EBADF;
- BsdSocket socket = RetrieveSocket(socketFd);
+ ISocket socket = _context.RetrieveSocket(socketFd);
if (socket != null)
{
- errno = LinuxError.SUCCESS;
-
- try
- {
- socket.Handle.Listen(backlog);
- }
- catch (SocketException exception)
- {
- errno = ConvertError((WsaError)exception.ErrorCode);
- }
+ errno = socket.Listen(backlog);
}
return WriteBsdResult(context, 0, errno);
@@ -929,7 +656,7 @@ namespace Ryujinx.HLE.HOS.Services.Sockets.Bsd
int bufferCount = context.RequestData.ReadInt32();
LinuxError errno = LinuxError.EBADF;
- BsdSocket socket = RetrieveSocket(socketFd);
+ ISocket socket = _context.RetrieveSocket(socketFd);
if (socket != null)
{
@@ -965,7 +692,7 @@ namespace Ryujinx.HLE.HOS.Services.Sockets.Bsd
int result = 0;
LinuxError errno = LinuxError.EBADF;
- BsdSocket socket = RetrieveSocket(socketFd);
+ ISocket socket = _context.RetrieveSocket(socketFd);
if (socket != null)
{
@@ -973,11 +700,11 @@ namespace Ryujinx.HLE.HOS.Services.Sockets.Bsd
if (cmd == 0x3)
{
- result = !socket.Handle.Blocking ? 0x800 : 0;
+ result = !socket.Blocking ? 0x800 : 0;
}
else if (cmd == 0x4 && arg == 0x800)
{
- socket.Handle.Blocking = false;
+ socket.Blocking = false;
result = 0;
}
else
@@ -989,74 +716,6 @@ namespace Ryujinx.HLE.HOS.Services.Sockets.Bsd
return WriteBsdResult(context, result, errno);
}
- private static LinuxError HandleGetSocketOption(
- ServiceCtx context,
- BsdSocket socket,
- BsdSocketOption option,
- SocketOptionLevel level,
- ulong optionValuePosition,
- ulong optionValueSize)
- {
- try
- {
- if (!TryConvertSocketOption(option, level, out SocketOptionName optionName))
- {
- Logger.Warning?.Print(LogClass.ServiceBsd, $"Unsupported GetSockOpt Option: {option} Level: {level}");
-
- return LinuxError.EOPNOTSUPP;
- }
-
- byte[] optionValue = new byte[optionValueSize];
-
- socket.Handle.GetSocketOption(level, optionName, optionValue);
- context.Memory.Write(optionValuePosition, optionValue);
-
- return LinuxError.SUCCESS;
- }
- catch (SocketException exception)
- {
- return ConvertError((WsaError)exception.ErrorCode);
- }
- }
-
- private static LinuxError HandleSetSocketOption(
- ServiceCtx context,
- BsdSocket socket,
- BsdSocketOption option,
- SocketOptionLevel level,
- ulong optionValuePosition,
- ulong optionValueSize)
- {
- try
- {
- if (!TryConvertSocketOption(option, level, out SocketOptionName optionName))
- {
- Logger.Warning?.Print(LogClass.ServiceBsd, $"Unsupported SetSockOpt Option: {option} Level: {level}");
-
- return LinuxError.EOPNOTSUPP;
- }
-
- int value = context.Memory.Read<int>((ulong)optionValuePosition);
-
- if (option == BsdSocketOption.SoLinger)
- {
- int value2 = context.Memory.Read<int>((ulong)optionValuePosition + 4);
-
- socket.Handle.SetSocketOption(level, SocketOptionName.Linger, new LingerOption(value != 0, value2));
- }
- else
- {
- socket.Handle.SetSocketOption(level, optionName, value);
- }
-
- return LinuxError.SUCCESS;
- }
- catch (SocketException exception)
- {
- return ConvertError((WsaError)exception.ErrorCode);
- }
- }
-
[CommandHipc(21)]
// SetSockOpt(u32 socket, u32 level, u32 option_name, buffer<unknown, 0x21, 0> option_value) -> (i32 ret, u32 bsd_errno)
public ResultCode SetSockOpt(ServiceCtx context)
@@ -1067,12 +726,14 @@ namespace Ryujinx.HLE.HOS.Services.Sockets.Bsd
(ulong bufferPos, ulong bufferSize) = context.Request.GetBufferType0x21();
+ ReadOnlySpan<byte> optionValue = context.Memory.GetSpan(bufferPos, (int)bufferSize);
+
LinuxError errno = LinuxError.EBADF;
- BsdSocket socket = RetrieveSocket(socketFd);
+ ISocket socket = _context.RetrieveSocket(socketFd);
if (socket != null)
{
- errno = HandleSetSocketOption(context, socket, option, level, bufferPos, bufferSize);
+ errno = socket.SetSocketOption(option, level, optionValue);
}
return WriteBsdResult(context, 0, errno);
@@ -1086,7 +747,7 @@ namespace Ryujinx.HLE.HOS.Services.Sockets.Bsd
int how = context.RequestData.ReadInt32();
LinuxError errno = LinuxError.EBADF;
- BsdSocket socket = RetrieveSocket(socketFd);
+ ISocket socket = _context.RetrieveSocket(socketFd);
if (socket != null)
{
@@ -1094,16 +755,7 @@ namespace Ryujinx.HLE.HOS.Services.Sockets.Bsd
if (how >= 0 && how <= 2)
{
- errno = LinuxError.SUCCESS;
-
- try
- {
- socket.Handle.Shutdown((SocketShutdown)how);
- }
- catch (SocketException exception)
- {
- errno = ConvertError((WsaError)exception.ErrorCode);
- }
+ errno = socket.Shutdown((BsdSocketShutdownFlags)how);
}
}
@@ -1120,54 +772,33 @@ namespace Ryujinx.HLE.HOS.Services.Sockets.Bsd
if (how >= 0 && how <= 2)
{
- errno = LinuxError.SUCCESS;
-
- foreach (BsdSocket socket in _sockets)
- {
- if (socket != null)
- {
- try
- {
- socket.Handle.Shutdown((SocketShutdown)how);
- }
- catch (SocketException exception)
- {
- errno = ConvertError((WsaError)exception.ErrorCode);
- break;
- }
- }
- }
+ errno = _context.ShutdownAllSockets((BsdSocketShutdownFlags)how);
}
return WriteBsdResult(context, 0, errno);
}
[CommandHipc(24)]
- // Write(u32 socket, buffer<i8, 0x21, 0> message) -> (i32 ret, u32 bsd_errno)
+ // Write(u32 fd, buffer<i8, 0x21, 0> message) -> (i32 ret, u32 bsd_errno)
public ResultCode Write(ServiceCtx context)
{
- int socketFd = context.RequestData.ReadInt32();
+ int fd = context.RequestData.ReadInt32();
(ulong sendPosition, ulong sendSize) = context.Request.GetBufferType0x21();
- LinuxError errno = LinuxError.EBADF;
- BsdSocket socket = RetrieveSocket(socketFd);
- int result = -1;
+ ReadOnlySpan<byte> sendBuffer = context.Memory.GetSpan(sendPosition, (int)sendSize);
- if (socket != null)
+ LinuxError errno = LinuxError.EBADF;
+ IFileDescriptor file = _context.RetrieveFileDescriptor(fd);
+ int result = -1;
+
+ if (file != null)
{
- byte[] sendBuffer = new byte[sendSize];
+ errno = file.Write(out result, sendBuffer);
- context.Memory.Read(sendPosition, sendBuffer);
-
- try
+ if (errno == LinuxError.SUCCESS)
{
- result = socket.Handle.Send(sendBuffer);
- errno = SetResultErrno(socket.Handle, result);
- }
- catch (SocketException exception)
- {
- errno = ConvertError((WsaError)exception.ErrorCode);
+ SetResultErrno(file, result);
}
}
@@ -1175,30 +806,28 @@ namespace Ryujinx.HLE.HOS.Services.Sockets.Bsd
}
[CommandHipc(25)]
- // Read(u32 socket) -> (i32 ret, u32 bsd_errno, buffer<i8, 0x22, 0> message)
+ // Read(u32 fd) -> (i32 ret, u32 bsd_errno, buffer<i8, 0x22, 0> message)
public ResultCode Read(ServiceCtx context)
{
- int socketFd = context.RequestData.ReadInt32();
+ int fd = context.RequestData.ReadInt32();
(ulong receivePosition, ulong receiveLength) = context.Request.GetBufferType0x22();
- LinuxError errno = LinuxError.EBADF;
- BsdSocket socket = RetrieveSocket(socketFd);
- int result = -1;
+ WritableRegion receiveRegion = context.Memory.GetWritableRegion(receivePosition, (int)receiveLength);
- if (socket != null)
+ LinuxError errno = LinuxError.EBADF;
+ IFileDescriptor file = _context.RetrieveFileDescriptor(fd);
+ int result = -1;
+
+ if (file != null)
{
- byte[] receivedBuffer = new byte[receiveLength];
+ errno = file.Read(out result, receiveRegion.Memory.Span);
- try
+ if (errno == LinuxError.SUCCESS)
{
- result = socket.Handle.Receive(receivedBuffer);
- errno = SetResultErrno(socket.Handle, result);
- context.Memory.Write(receivePosition, receivedBuffer);
- }
- catch (SocketException exception)
- {
- errno = ConvertError((WsaError)exception.ErrorCode);
+ SetResultErrno(file, result);
+
+ receiveRegion.Dispose();
}
}
@@ -1206,20 +835,15 @@ namespace Ryujinx.HLE.HOS.Services.Sockets.Bsd
}
[CommandHipc(26)]
- // Close(u32 socket) -> (i32 ret, u32 bsd_errno)
+ // Close(u32 fd) -> (i32 ret, u32 bsd_errno)
public ResultCode Close(ServiceCtx context)
{
- int socketFd = context.RequestData.ReadInt32();
+ int fd = context.RequestData.ReadInt32();
- LinuxError errno = LinuxError.EBADF;
- BsdSocket socket = RetrieveSocket(socketFd);
+ LinuxError errno = LinuxError.EBADF;
- if (socket != null)
+ if (_context.CloseFileDescriptor(fd))
{
- socket.Handle.Close();
-
- _sockets[socketFd] = null;
-
errno = LinuxError.SUCCESS;
}
@@ -1227,29 +851,49 @@ namespace Ryujinx.HLE.HOS.Services.Sockets.Bsd
}
[CommandHipc(27)]
- // DuplicateSocket(u32 socket, u64 reserved) -> (i32 ret, u32 bsd_errno)
+ // DuplicateSocket(u32 fd, u64 reserved) -> (i32 ret, u32 bsd_errno)
public ResultCode DuplicateSocket(ServiceCtx context)
{
- int socketFd = context.RequestData.ReadInt32();
+ int fd = context.RequestData.ReadInt32();
ulong reserved = context.RequestData.ReadUInt64();
- LinuxError errno = LinuxError.ENOENT;
- int newSockFd = -1;
+ LinuxError errno = LinuxError.ENOENT;
+ int newSockFd = -1;
if (_isPrivileged)
{
- errno = LinuxError.EBADF;
+ errno = LinuxError.SUCCESS;
- BsdSocket oldSocket = RetrieveSocket(socketFd);
+ newSockFd = _context.DuplicateFileDescriptor(fd);
- if (oldSocket != null)
+ if (newSockFd == -1)
{
- _sockets.Add(oldSocket);
- newSockFd = _sockets.Count - 1;
+ errno = LinuxError.EBADF;
}
}
return WriteBsdResult(context, newSockFd, errno);
}
+
+ [CommandHipc(31)] // 7.0.0+
+ // EventFd(u64 initval, nn::socket::EventFdFlags flags) -> (i32 ret, u32 bsd_errno)
+ public ResultCode EventFd(ServiceCtx context)
+ {
+ ulong initialValue = context.RequestData.ReadUInt64();
+ EventFdFlags flags = (EventFdFlags)context.RequestData.ReadUInt32();
+
+ EventFileDescriptor newEventFile = new EventFileDescriptor(initialValue, flags);
+
+ LinuxError errno = LinuxError.SUCCESS;
+
+ int newSockFd = _context.RegisterFileDescriptor(newEventFile);
+
+ if (newSockFd == -1)
+ {
+ errno = LinuxError.EBADF;
+ }
+
+ return WriteBsdResult(context, newSockFd, errno);
+ }
}
}
\ No newline at end of file
diff --git a/Ryujinx.HLE/HOS/Services/Sockets/Bsd/IFileDescriptor.cs b/Ryujinx.HLE/HOS/Services/Sockets/Bsd/IFileDescriptor.cs
new file mode 100644
index 0000000000..56f67539b3
--- /dev/null
+++ b/Ryujinx.HLE/HOS/Services/Sockets/Bsd/IFileDescriptor.cs
@@ -0,0 +1,14 @@
+using System;
+
+namespace Ryujinx.HLE.HOS.Services.Sockets.Bsd
+{
+ interface IFileDescriptor : IDisposable
+ {
+ bool Blocking { get; set; }
+ int Refcount { get; set; }
+
+ LinuxError Read(out int readSize, Span<byte> buffer);
+
+ LinuxError Write(out int writeSize, ReadOnlySpan<byte> buffer);
+ }
+}
diff --git a/Ryujinx.HLE/HOS/Services/Sockets/Bsd/ISocket.cs b/Ryujinx.HLE/HOS/Services/Sockets/Bsd/ISocket.cs
new file mode 100644
index 0000000000..ee6bd9e8e5
--- /dev/null
+++ b/Ryujinx.HLE/HOS/Services/Sockets/Bsd/ISocket.cs
@@ -0,0 +1,47 @@
+using System;
+using System.Net;
+using System.Net.Sockets;
+
+namespace Ryujinx.HLE.HOS.Services.Sockets.Bsd
+{
+ interface ISocket : IDisposable, IFileDescriptor
+ {
+ IPEndPoint RemoteEndPoint { get; }
+ IPEndPoint LocalEndPoint { get; }
+
+ AddressFamily AddressFamily { get; }
+
+ SocketType SocketType { get; }
+
+ ProtocolType ProtocolType { get; }
+
+ IntPtr Handle { get; }
+
+ LinuxError Receive(out int receiveSize, Span<byte> buffer, BsdSocketFlags flags);
+
+ LinuxError ReceiveFrom(out int receiveSize, Span<byte> buffer, int size, BsdSocketFlags flags, out IPEndPoint remoteEndPoint);
+
+ LinuxError Send(out int sendSize, ReadOnlySpan<byte> buffer, BsdSocketFlags flags);
+
+ LinuxError SendTo(out int sendSize, ReadOnlySpan<byte> buffer, int size, BsdSocketFlags flags, IPEndPoint remoteEndPoint);
+
+ LinuxError GetSocketOption(BsdSocketOption option, SocketOptionLevel level, Span<byte> optionValue);
+ LinuxError SetSocketOption(BsdSocketOption option, SocketOptionLevel level, ReadOnlySpan<byte> optionValue);
+
+ bool Poll(int microSeconds, SelectMode mode);
+
+ LinuxError Bind(IPEndPoint localEndPoint);
+
+ LinuxError Connect(IPEndPoint remoteEndPoint);
+
+ LinuxError Listen(int backlog);
+
+ LinuxError Accept(out ISocket newSocket);
+
+ void Disconnect();
+
+ LinuxError Shutdown(BsdSocketShutdownFlags how);
+
+ void Close();
+ }
+}
diff --git a/Ryujinx.HLE/HOS/Services/Sockets/Bsd/Impl/EventFileDescriptor.cs b/Ryujinx.HLE/HOS/Services/Sockets/Bsd/Impl/EventFileDescriptor.cs
new file mode 100644
index 0000000000..e92b42ef0a
--- /dev/null
+++ b/Ryujinx.HLE/HOS/Services/Sockets/Bsd/Impl/EventFileDescriptor.cs
@@ -0,0 +1,130 @@
+using System;
+using System.Runtime.InteropServices;
+using System.Threading;
+
+namespace Ryujinx.HLE.HOS.Services.Sockets.Bsd
+{
+ class EventFileDescriptor : IFileDescriptor
+ {
+ private ulong _value;
+ private readonly EventFdFlags _flags;
+ private AutoResetEvent _event;
+
+ private object _lock = new object();
+
+ public bool Blocking { get => !_flags.HasFlag(EventFdFlags.NonBlocking); set => throw new NotSupportedException(); }
+
+ public ManualResetEvent WriteEvent { get; }
+ public ManualResetEvent ReadEvent { get; }
+
+ public EventFileDescriptor(ulong value, EventFdFlags flags)
+ {
+ _value = value;
+ _flags = flags;
+ _event = new AutoResetEvent(false);
+
+ WriteEvent = new ManualResetEvent(true);
+ ReadEvent = new ManualResetEvent(true);
+ }
+
+ public int Refcount { get; set; }
+
+ public void Dispose()
+ {
+ _event.Dispose();
+ WriteEvent.Dispose();
+ ReadEvent.Dispose();
+ }
+
+ public LinuxError Read(out int readSize, Span<byte> buffer)
+ {
+ if (buffer.Length < sizeof(ulong))
+ {
+ readSize = 0;
+
+ return LinuxError.EINVAL;
+ }
+
+ ReadEvent.Reset();
+
+ lock (_lock)
+ {
+ ref ulong count = ref MemoryMarshal.Cast<byte, ulong>(buffer)[0];
+
+ if (_value == 0)
+ {
+ if (Blocking)
+ {
+ while (_value == 0)
+ {
+ _event.WaitOne();
+ }
+ }
+ else
+ {
+ readSize = 0;
+
+ return LinuxError.EAGAIN;
+ }
+ }
+
+ readSize = sizeof(ulong);
+
+ if (_flags.HasFlag(EventFdFlags.Semaphore))
+ {
+ --_value;
+
+ count = 1;
+ }
+ else
+ {
+ count = _value;
+
+ _value = 0;
+ }
+
+ ReadEvent.Set();
+
+ return LinuxError.SUCCESS;
+ }
+ }
+
+ public LinuxError Write(out int writeSize, ReadOnlySpan<byte> buffer)
+ {
+ if (!MemoryMarshal.TryRead(buffer, out ulong count) || count == ulong.MaxValue)
+ {
+ writeSize = 0;
+
+ return LinuxError.EINVAL;
+ }
+
+ WriteEvent.Reset();
+
+ lock (_lock)
+ {
+ if (_value > _value + count)
+ {
+ if (Blocking)
+ {
+ _event.WaitOne();
+ }
+ else
+ {
+ writeSize = 0;
+
+ return LinuxError.EAGAIN;
+ }
+ }
+
+ writeSize = sizeof(ulong);
+
+ _value += count;
+ _event.Set();
+
+ WriteEvent.Set();
+
+ return LinuxError.SUCCESS;
+ }
+ }
+ }
+}
diff --git a/Ryujinx.HLE/HOS/Services/Sockets/Bsd/Impl/EventFileDescriptorPollManager.cs b/Ryujinx.HLE/HOS/Services/Sockets/Bsd/Impl/EventFileDescriptorPollManager.cs
new file mode 100644
index 0000000000..8bd9652bf9
--- /dev/null
+++ b/Ryujinx.HLE/HOS/Services/Sockets/Bsd/Impl/EventFileDescriptorPollManager.cs
@@ -0,0 +1,96 @@
+using Ryujinx.Common.Logging;
+using System.Collections.Generic;
+using System.Threading;
+
+namespace Ryujinx.HLE.HOS.Services.Sockets.Bsd
+{
+ class EventFileDescriptorPollManager : IPollManager
+ {
+ private static EventFileDescriptorPollManager _instance;
+
+ public static EventFileDescriptorPollManager Instance
+ {
+ get
+ {
+ if (_instance == null)
+ {
+ _instance = new EventFileDescriptorPollManager();
+ }
+
+ return _instance;
+ }
+ }
+
+ public bool IsCompatible(PollEvent evnt)
+ {
+ return evnt.FileDescriptor is EventFileDescriptor;
+ }
+
+ public LinuxError Poll(List<PollEvent> events, int timeoutMilliseconds, out int updatedCount)
+ {
+ updatedCount = 0;
+
+ List<ManualResetEvent> waiters = new List<ManualResetEvent>();
+
+ for (int i = 0; i < events.Count; i++)
+ {
+ PollEvent evnt = events[i];
+
+ EventFileDescriptor socket = (EventFileDescriptor)evnt.FileDescriptor;
+
+ bool isValidEvent = false;
+
+ if (evnt.Data.InputEvents.HasFlag(PollEventTypeMask.Input) ||
+ evnt.Data.InputEvents.HasFlag(PollEventTypeMask.UrgentInput))
+ {
+ waiters.Add(socket.ReadEvent);
+
+ isValidEvent = true;
+ }
+ if (evnt.Data.InputEvents.HasFlag(PollEventTypeMask.Output))
+ {
+ waiters.Add(socket.WriteEvent);
+
+ isValidEvent = true;
+ }
+
+ if (!isValidEvent)
+ {
+ Logger.Warning?.Print(LogClass.ServiceBsd, $"Unsupported Poll input event type: {evnt.Data.InputEvents}");
+
+ return LinuxError.EINVAL;
+ }
+ }
+
+ int index = WaitHandle.WaitAny(waiters.ToArray(), timeoutMilliseconds);
+
+ if (index != WaitHandle.WaitTimeout)
+ {
+ for (int i = 0; i < events.Count; i++)
+ {
+ PollEvent evnt = events[i];
+
+ EventFileDescriptor socket = (EventFileDescriptor)evnt.FileDescriptor;
+
+ if ((evnt.Data.InputEvents.HasFlag(PollEventTypeMask.Input) ||
+ evnt.Data.InputEvents.HasFlag(PollEventTypeMask.UrgentInput))
+ && socket.ReadEvent.WaitOne(0))
+ {
+ waiters.Add(socket.ReadEvent);
+ }
+ if ((evnt.Data.InputEvents.HasFlag(PollEventTypeMask.Output))
+ && socket.WriteEvent.WaitOne(0))
+ {
+ waiters.Add(socket.WriteEvent);
+ }
+ }
+ }
+ else
+ {
+ return LinuxError.ETIMEDOUT;
+ }
+
+ return LinuxError.SUCCESS;
+ }
+ }
+}
diff --git a/Ryujinx.HLE/HOS/Services/Sockets/Bsd/Impl/ManagedSocket.cs b/Ryujinx.HLE/HOS/Services/Sockets/Bsd/Impl/ManagedSocket.cs
new file mode 100644
index 0000000000..349dbde0a6
--- /dev/null
+++ b/Ryujinx.HLE/HOS/Services/Sockets/Bsd/Impl/ManagedSocket.cs
@@ -0,0 +1,338 @@
+using Ryujinx.Common.Logging;
+using System;
+using System.Net;
+using System.Net.Sockets;
+using System.Runtime.InteropServices;
+
+namespace Ryujinx.HLE.HOS.Services.Sockets.Bsd
+{
+ class ManagedSocket : ISocket
+ {
+ public int Refcount { get; set; }
+
+ public AddressFamily AddressFamily => Socket.AddressFamily;
+
+ public SocketType SocketType => Socket.SocketType;
+
+ public ProtocolType ProtocolType => Socket.ProtocolType;
+
+ public bool Blocking { get => Socket.Blocking; set => Socket.Blocking = value; }
+
+ public IntPtr Handle => Socket.Handle;
+
+ public IPEndPoint RemoteEndPoint => Socket.RemoteEndPoint as IPEndPoint;
+
+ public IPEndPoint LocalEndPoint => Socket.LocalEndPoint as IPEndPoint;
+
+ public Socket Socket { get; }
+
+ public ManagedSocket(AddressFamily addressFamily, SocketType socketType, ProtocolType protocolType)
+ {
+ Socket = new Socket(addressFamily, socketType, protocolType);
+ Refcount = 1;
+ }
+
+ private ManagedSocket(Socket socket)
+ {
+ Socket = socket;
+ Refcount = 1;
+ }
+
+ private static SocketFlags ConvertBsdSocketFlags(BsdSocketFlags bsdSocketFlags)
+ {
+ SocketFlags socketFlags = SocketFlags.None;
+
+ if (bsdSocketFlags.HasFlag(BsdSocketFlags.Oob))
+ {
+ socketFlags |= SocketFlags.OutOfBand;
+ }
+
+ if (bsdSocketFlags.HasFlag(BsdSocketFlags.Peek))
+ {
+ socketFlags |= SocketFlags.Peek;
+ }
+
+ if (bsdSocketFlags.HasFlag(BsdSocketFlags.DontRoute))
+ {
+ socketFlags |= SocketFlags.DontRoute;
+ }
+
+ if (bsdSocketFlags.HasFlag(BsdSocketFlags.Trunc))
+ {
+ socketFlags |= SocketFlags.Truncated;
+ }
+
+ if (bsdSocketFlags.HasFlag(BsdSocketFlags.CTrunc))
+ {
+ socketFlags |= SocketFlags.ControlDataTruncated;
+ }
+
+ bsdSocketFlags &= ~(BsdSocketFlags.Oob |
+ BsdSocketFlags.Peek |
+ BsdSocketFlags.DontRoute |
+ BsdSocketFlags.DontWait |
+ BsdSocketFlags.Trunc |
+ BsdSocketFlags.CTrunc);
+
+ if (bsdSocketFlags != BsdSocketFlags.None)
+ {
+ Logger.Warning?.Print(LogClass.ServiceBsd, $"Unsupported socket flags: {bsdSocketFlags}");
+ }
+
+ return socketFlags;
+ }
+
+ public LinuxError Accept(out ISocket newSocket)
+ {
+ try
+ {
+ newSocket = new ManagedSocket(Socket.Accept());
+
+ return LinuxError.SUCCESS;
+ }
+ catch (SocketException exception)
+ {
+ newSocket = null;
+
+ return WinSockHelper.ConvertError((WsaError)exception.ErrorCode);
+ }
+ }
+
+ public LinuxError Bind(IPEndPoint localEndPoint)
+ {
+ try
+ {
+ Socket.Bind(localEndPoint);
+
+ return LinuxError.SUCCESS;
+ }
+ catch (SocketException exception)
+ {
+ return WinSockHelper.ConvertError((WsaError)exception.ErrorCode);
+ }
+ }
+
+ public void Close()
+ {
+ Socket.Close();
+ }
+
+ public LinuxError Connect(IPEndPoint remoteEndPoint)
+ {
+ try
+ {
+ Socket.Connect(remoteEndPoint);
+
+ return LinuxError.SUCCESS;
+ }
+ catch (SocketException exception)
+ {
+ if (!Blocking && exception.ErrorCode == (int)WsaError.WSAEWOULDBLOCK)
+ {
+ return LinuxError.EINPROGRESS;
+ }
+ else
+ {
+ return WinSockHelper.ConvertError((WsaError)exception.ErrorCode);
+ }
+ }
+ }
+
+ public void Disconnect()
+ {
+ Socket.Disconnect(true);
+ }
+
+ public void Dispose()
+ {
+ Socket.Close();
+ Socket.Dispose();
+ }
+
+ public LinuxError Listen(int backlog)
+ {
+ try
+ {
+ Socket.Listen(backlog);
+
+ return LinuxError.SUCCESS;
+ }
+ catch (SocketException exception)
+ {
+ return WinSockHelper.ConvertError((WsaError)exception.ErrorCode);
+ }
+ }
+
+ public bool Poll(int microSeconds, SelectMode mode)
+ {
+ return Socket.Poll(microSeconds, mode);
+ }
+
+ public LinuxError Shutdown(BsdSocketShutdownFlags how)
+ {
+ try
+ {
+ Socket.Shutdown((SocketShutdown)how);
+
+ return LinuxError.SUCCESS;
+ }
+ catch (SocketException exception)
+ {
+ return WinSockHelper.ConvertError((WsaError)exception.ErrorCode);
+ }
+ }
+
+ public LinuxError Receive(out int receiveSize, Span<byte> buffer, BsdSocketFlags flags)
+ {
+ try
+ {
+ receiveSize = Socket.Receive(buffer, ConvertBsdSocketFlags(flags));
+
+ return LinuxError.SUCCESS;
+ }
+ catch (SocketException exception)
+ {
+ receiveSize = -1;
+
+ return WinSockHelper.ConvertError((WsaError)exception.ErrorCode);
+ }
+ }
+
+ public LinuxError ReceiveFrom(out int receiveSize, Span<byte> buffer, int size, BsdSocketFlags flags, out IPEndPoint remoteEndPoint)
+ {
+ remoteEndPoint = new IPEndPoint(IPAddress.Any, 0);
+
+ LinuxError result;
+
+ bool shouldBlockAfterOperation = false;
+
+ try
+ {
+ EndPoint temp = new IPEndPoint(IPAddress.Any, 0);
+
+ if (Blocking && flags.HasFlag(BsdSocketFlags.DontWait))
+ {
+ Blocking = false;
+ shouldBlockAfterOperation = true;
+ }
+
+ receiveSize = Socket.ReceiveFrom(buffer[..size], ConvertBsdSocketFlags(flags), ref temp);
+
+ remoteEndPoint = (IPEndPoint)temp;
+ result = LinuxError.SUCCESS;
+ }
+ catch (SocketException exception)
+ {
+ receiveSize = -1;
+
+ result = WinSockHelper.ConvertError((WsaError)exception.ErrorCode);
+ }
+
+ if (shouldBlockAfterOperation)
+ {
+ Blocking = true;
+ }
+
+ return result;
+ }
+
+ public LinuxError Send(out int sendSize, ReadOnlySpan<byte> buffer, BsdSocketFlags flags)
+ {
+ try
+ {
+ sendSize = Socket.Send(buffer, ConvertBsdSocketFlags(flags));
+
+ return LinuxError.SUCCESS;
+ }
+ catch (SocketException exception)
+ {
+ sendSize = -1;
+
+ return WinSockHelper.ConvertError((WsaError)exception.ErrorCode);
+ }
+ }
+
+ public LinuxError SendTo(out int sendSize, ReadOnlySpan<byte> buffer, int size, BsdSocketFlags flags, IPEndPoint remoteEndPoint)
+ {
+ try
+ {
+ sendSize = Socket.SendTo(buffer[..size], ConvertBsdSocketFlags(flags), remoteEndPoint);
+
+ return LinuxError.SUCCESS;
+ }
+ catch (SocketException exception)
+ {
+ sendSize = -1;
+
+ return WinSockHelper.ConvertError((WsaError)exception.ErrorCode);
+ }
+ }
+
+ public LinuxError GetSocketOption(BsdSocketOption option, SocketOptionLevel level, Span<byte> optionValue)
+ {
+ try
+ {
+ if (!WinSockHelper.TryConvertSocketOption(option, level, out SocketOptionName optionName))
+ {
+ Logger.Warning?.Print(LogClass.ServiceBsd, $"Unsupported GetSockOpt Option: {option} Level: {level}");
+
+ return LinuxError.EOPNOTSUPP;
+ }
+
+ byte[] tempOptionValue = new byte[optionValue.Length];
+
+ Socket.GetSocketOption(level, optionName, tempOptionValue);
+
+ tempOptionValue.AsSpan().CopyTo(optionValue);
+
+ return LinuxError.SUCCESS;
+ }
+ catch (SocketException exception)
+ {
+ return WinSockHelper.ConvertError((WsaError)exception.ErrorCode);
+ }
+ }
+
+ public LinuxError SetSocketOption(BsdSocketOption option, SocketOptionLevel level, ReadOnlySpan<byte> optionValue)
+ {
+ try
+ {
+ if (!WinSockHelper.TryConvertSocketOption(option, level, out SocketOptionName optionName))
+ {
+ Logger.Warning?.Print(LogClass.ServiceBsd, $"Unsupported SetSockOpt Option: {option} Level: {level}");
+
+ return LinuxError.EOPNOTSUPP;
+ }
+
+ int value = MemoryMarshal.Read<int>(optionValue);
+
+ if (option == BsdSocketOption.SoLinger)
+ {
+ int value2 = MemoryMarshal.Read<int>(optionValue[4..]);
+
+ Socket.SetSocketOption(level, SocketOptionName.Linger, new LingerOption(value != 0, value2));
+ }
+ else
+ {
+ Socket.SetSocketOption(level, optionName, value);
+ }
+
+ return LinuxError.SUCCESS;
+ }
+ catch (SocketException exception)
+ {
+ return WinSockHelper.ConvertError((WsaError)exception.ErrorCode);
+ }
+ }
+
+ public LinuxError Read(out int readSize, Span<byte> buffer)
+ {
+ return Receive(out readSize, buffer, BsdSocketFlags.None);
+ }
+
+ public LinuxError Write(out int writeSize, ReadOnlySpan<byte> buffer)
+ {
+ return Send(out writeSize, buffer, BsdSocketFlags.None);
+ }
+ }
+}
diff --git a/Ryujinx.HLE/HOS/Services/Sockets/Bsd/Impl/ManagedSocketPollManager.cs b/Ryujinx.HLE/HOS/Services/Sockets/Bsd/Impl/ManagedSocketPollManager.cs
new file mode 100644
index 0000000000..b2414bc12f
--- /dev/null
+++ b/Ryujinx.HLE/HOS/Services/Sockets/Bsd/Impl/ManagedSocketPollManager.cs
@@ -0,0 +1,129 @@
+using Ryujinx.Common.Logging;
+using System.Collections.Generic;
+using System.Net.Sockets;
+
+namespace Ryujinx.HLE.HOS.Services.Sockets.Bsd
+{
+ class ManagedSocketPollManager : IPollManager
+ {
+ private static ManagedSocketPollManager _instance;
+
+ public static ManagedSocketPollManager Instance
+ {
+ get
+ {
+ if (_instance == null)
+ {
+ _instance = new ManagedSocketPollManager();
+ }
+
+ return _instance;
+ }
+ }
+
+ public bool IsCompatible(PollEvent evnt)
+ {
+ return evnt.FileDescriptor is ManagedSocket;
+ }
+
+ public LinuxError Poll(List<PollEvent> events, int timeoutMilliseconds, out int updatedCount)
+ {
+ List<Socket> readEvents = new List<Socket>();
+ List<Socket> writeEvents = new List<Socket>();
+ List<Socket> errorEvents = new List<Socket>();
+
+ updatedCount = 0;
+
+ foreach (PollEvent evnt in events)
+ {
+ ManagedSocket socket = (ManagedSocket)evnt.FileDescriptor;
+
+ bool isValidEvent = false;
+
+ if ((evnt.Data.InputEvents & PollEventTypeMask.Input) != 0)
+ {
+ readEvents.Add(socket.Socket);
+ errorEvents.Add(socket.Socket);
+
+ isValidEvent = true;
+ }
+
+ if ((evnt.Data.InputEvents & PollEventTypeMask.UrgentInput) != 0)
+ {
+ readEvents.Add(socket.Socket);
+ errorEvents.Add(socket.Socket);
+
+ isValidEvent = true;
+ }
+
+ if ((evnt.Data.InputEvents & PollEventTypeMask.Output) != 0)
+ {
+ writeEvents.Add(socket.Socket);
+ errorEvents.Add(socket.Socket);
+
+ isValidEvent = true;
+ }
+
+ if ((evnt.Data.InputEvents & PollEventTypeMask.Error) != 0)
+ {
+ errorEvents.Add(socket.Socket);
+
+ isValidEvent = true;
+ }
+
+ if (!isValidEvent)
+ {
+ Logger.Warning?.Print(LogClass.ServiceBsd, $"Unsupported Poll input event type: {evnt.Data.InputEvents}");
+ return LinuxError.EINVAL;
+ }
+ }
+
+ try
+ {
+ int actualTimeoutMicroseconds = timeoutMilliseconds == -1 ? -1 : timeoutMilliseconds * 1000;
+
+ Socket.Select(readEvents, writeEvents, errorEvents, actualTimeoutMicroseconds);
+ }
+ catch (SocketException exception)
+ {
+ return WinSockHelper.ConvertError((WsaError)exception.ErrorCode);
+ }
+
+ foreach (PollEvent evnt in events)
+ {
+ Socket socket = ((ManagedSocket)evnt.FileDescriptor).Socket;
+
+ PollEventTypeMask outputEvents = 0;
+
+ if (errorEvents.Contains(socket))
+ {
+ outputEvents |= PollEventTypeMask.Error;
+
+ if (!socket.Connected || !socket.IsBound)
+ {
+ outputEvents |= PollEventTypeMask.Disconnected;
+ }
+ }
+
+ if (readEvents.Contains(socket))
+ {
+ if ((evnt.Data.InputEvents & PollEventTypeMask.Input) != 0)
+ {
+ outputEvents |= PollEventTypeMask.Input;
+ }
+ }
+
+ if (writeEvents.Contains(socket))
+ {
+ outputEvents |= PollEventTypeMask.Output;
+ }
+
+ evnt.Data.OutputEvents = outputEvents;
+ }
+
+ updatedCount = readEvents.Count + writeEvents.Count + errorEvents.Count;
+
+ return LinuxError.SUCCESS;
+ }
+ }
+}
diff --git a/Ryujinx.HLE/HOS/Services/Sockets/Bsd/Types/WSAError.cs b/Ryujinx.HLE/HOS/Services/Sockets/Bsd/Impl/WSAError.cs
similarity index 100%
rename from Ryujinx.HLE/HOS/Services/Sockets/Bsd/Types/WSAError.cs
rename to Ryujinx.HLE/HOS/Services/Sockets/Bsd/Impl/WSAError.cs
diff --git a/Ryujinx.HLE/HOS/Services/Sockets/Bsd/Impl/WinSockHelper.cs b/Ryujinx.HLE/HOS/Services/Sockets/Bsd/Impl/WinSockHelper.cs
new file mode 100644
index 0000000000..ad12745e8d
--- /dev/null
+++ b/Ryujinx.HLE/HOS/Services/Sockets/Bsd/Impl/WinSockHelper.cs
@@ -0,0 +1,165 @@
+using System.Collections.Generic;
+using System.Net.Sockets;
+
+namespace Ryujinx.HLE.HOS.Services.Sockets.Bsd
+{
+ static class WinSockHelper
+ {
+ private static readonly Dictionary<WsaError, LinuxError> _errorMap = new()
+ {
+ // WSAEINTR
+ {WsaError.WSAEINTR, LinuxError.EINTR},
+ // WSAEWOULDBLOCK
+ {WsaError.WSAEWOULDBLOCK, LinuxError.EWOULDBLOCK},
+ // WSAEINPROGRESS
+ {WsaError.WSAEINPROGRESS, LinuxError.EINPROGRESS},
+ // WSAEALREADY
+ {WsaError.WSAEALREADY, LinuxError.EALREADY},
+ // WSAENOTSOCK
+ {WsaError.WSAENOTSOCK, LinuxError.ENOTSOCK},
+ // WSAEDESTADDRREQ
+ {WsaError.WSAEDESTADDRREQ, LinuxError.EDESTADDRREQ},
+ // WSAEMSGSIZE
+ {WsaError.WSAEMSGSIZE, LinuxError.EMSGSIZE},
+ // WSAEPROTOTYPE
+ {WsaError.WSAEPROTOTYPE, LinuxError.EPROTOTYPE},
+ // WSAENOPROTOOPT
+ {WsaError.WSAENOPROTOOPT, LinuxError.ENOPROTOOPT},
+ // WSAEPROTONOSUPPORT
+ {WsaError.WSAEPROTONOSUPPORT, LinuxError.EPROTONOSUPPORT},
+ // WSAESOCKTNOSUPPORT
+ {WsaError.WSAESOCKTNOSUPPORT, LinuxError.ESOCKTNOSUPPORT},
+ // WSAEOPNOTSUPP
+ {WsaError.WSAEOPNOTSUPP, LinuxError.EOPNOTSUPP},
+ // WSAEPFNOSUPPORT
+ {WsaError.WSAEPFNOSUPPORT, LinuxError.EPFNOSUPPORT},
+ // WSAEAFNOSUPPORT
+ {WsaError.WSAEAFNOSUPPORT, LinuxError.EAFNOSUPPORT},
+ // WSAEADDRINUSE
+ {WsaError.WSAEADDRINUSE, LinuxError.EADDRINUSE},
+ // WSAEADDRNOTAVAIL
+ {WsaError.WSAEADDRNOTAVAIL, LinuxError.EADDRNOTAVAIL},
+ // WSAENETDOWN
+ {WsaError.WSAENETDOWN, LinuxError.ENETDOWN},
+ // WSAENETUNREACH
+ {WsaError.WSAENETUNREACH, LinuxError.ENETUNREACH},
+ // WSAENETRESET
+ {WsaError.WSAENETRESET, LinuxError.ENETRESET},
+ // WSAECONNABORTED
+ {WsaError.WSAECONNABORTED, LinuxError.ECONNABORTED},
+ // WSAECONNRESET
+ {WsaError.WSAECONNRESET, LinuxError.ECONNRESET},
+ // WSAENOBUFS
+ {WsaError.WSAENOBUFS, LinuxError.ENOBUFS},
+ // WSAEISCONN
+ {WsaError.WSAEISCONN, LinuxError.EISCONN},
+ // WSAENOTCONN
+ {WsaError.WSAENOTCONN, LinuxError.ENOTCONN},
+ // WSAESHUTDOWN
+ {WsaError.WSAESHUTDOWN, LinuxError.ESHUTDOWN},
+ // WSAETOOMANYREFS
+ {WsaError.WSAETOOMANYREFS, LinuxError.ETOOMANYREFS},
+ // WSAETIMEDOUT
+ {WsaError.WSAETIMEDOUT, LinuxError.ETIMEDOUT},
+ // WSAECONNREFUSED
+ {WsaError.WSAECONNREFUSED, LinuxError.ECONNREFUSED},
+ // WSAELOOP
+ {WsaError.WSAELOOP, LinuxError.ELOOP},
+ // WSAENAMETOOLONG
+ {WsaError.WSAENAMETOOLONG, LinuxError.ENAMETOOLONG},
+ // WSAEHOSTDOWN
+ {WsaError.WSAEHOSTDOWN, LinuxError.EHOSTDOWN},
+ // WSAEHOSTUNREACH
+ {WsaError.WSAEHOSTUNREACH, LinuxError.EHOSTUNREACH},
+ // WSAENOTEMPTY
+ {WsaError.WSAENOTEMPTY, LinuxError.ENOTEMPTY},
+ // WSAEUSERS
+ {WsaError.WSAEUSERS, LinuxError.EUSERS},
+ // WSAEDQUOT
+ {WsaError.WSAEDQUOT, LinuxError.EDQUOT},
+ // WSAESTALE
+ {WsaError.WSAESTALE, LinuxError.ESTALE},
+ // WSAEREMOTE
+ {WsaError.WSAEREMOTE, LinuxError.EREMOTE},
+ // WSAEINVAL
+ {WsaError.WSAEINVAL, LinuxError.EINVAL},
+ // WSAEFAULT
+ {WsaError.WSAEFAULT, LinuxError.EFAULT},
+ // NOERROR
+ {0, 0}
+ };
+
+ private static readonly Dictionary<BsdSocketOption, SocketOptionName> _soSocketOptionMap = new()
+ {
+ { BsdSocketOption.SoDebug, SocketOptionName.Debug },
+ { BsdSocketOption.SoReuseAddr, SocketOptionName.ReuseAddress },
+ { BsdSocketOption.SoKeepAlive, SocketOptionName.KeepAlive },
+ { BsdSocketOption.SoDontRoute, SocketOptionName.DontRoute },
+ { BsdSocketOption.SoBroadcast, SocketOptionName.Broadcast },
+ { BsdSocketOption.SoUseLoopBack, SocketOptionName.UseLoopback },
+ { BsdSocketOption.SoLinger, SocketOptionName.Linger },
+ { BsdSocketOption.SoOobInline, SocketOptionName.OutOfBandInline },
+ { BsdSocketOption.SoReusePort, SocketOptionName.ReuseAddress },
+ { BsdSocketOption.SoSndBuf, SocketOptionName.SendBuffer },
+ { BsdSocketOption.SoRcvBuf, SocketOptionName.ReceiveBuffer },
+ { BsdSocketOption.SoSndLoWat, SocketOptionName.SendLowWater },
+ { BsdSocketOption.SoRcvLoWat, SocketOptionName.ReceiveLowWater },
+ { BsdSocketOption.SoSndTimeo, SocketOptionName.SendTimeout },
+ { BsdSocketOption.SoRcvTimeo, SocketOptionName.ReceiveTimeout },
+ { BsdSocketOption.SoError, SocketOptionName.Error },
+ { BsdSocketOption.SoType, SocketOptionName.Type }
+ };
+
+ private static readonly Dictionary<BsdSocketOption, SocketOptionName> _ipSocketOptionMap = new()
+ {
+ { BsdSocketOption.IpOptions, SocketOptionName.IPOptions },
+ { BsdSocketOption.IpHdrIncl, SocketOptionName.HeaderIncluded },
+ { BsdSocketOption.IpTtl, SocketOptionName.IpTimeToLive },
+ { BsdSocketOption.IpMulticastIf, SocketOptionName.MulticastInterface },
+ { BsdSocketOption.IpMulticastTtl, SocketOptionName.MulticastTimeToLive },
+ { BsdSocketOption.IpMulticastLoop, SocketOptionName.MulticastLoopback },
+ { BsdSocketOption.IpAddMembership, SocketOptionName.AddMembership },
+ { BsdSocketOption.IpDropMembership, SocketOptionName.DropMembership },
+ { BsdSocketOption.IpDontFrag, SocketOptionName.DontFragment },
+ { BsdSocketOption.IpAddSourceMembership, SocketOptionName.AddSourceMembership },
+ { BsdSocketOption.IpDropSourceMembership, SocketOptionName.DropSourceMembership }
+ };
+
+ private static readonly Dictionary<BsdSocketOption, SocketOptionName> _tcpSocketOptionMap = new()
+ {
+ { BsdSocketOption.TcpNoDelay, SocketOptionName.NoDelay },
+ { BsdSocketOption.TcpKeepIdle, SocketOptionName.TcpKeepAliveTime },
+ { BsdSocketOption.TcpKeepIntvl, SocketOptionName.TcpKeepAliveInterval },
+ { BsdSocketOption.TcpKeepCnt, SocketOptionName.TcpKeepAliveRetryCount }
+ };
+
+ public static LinuxError ConvertError(WsaError errorCode)
+ {
+ if (!_errorMap.TryGetValue(errorCode, out LinuxError errno))
+ {
+ errno = (LinuxError)errorCode;
+ }
+
+ return errno;
+ }
+
+ public static bool TryConvertSocketOption(BsdSocketOption option, SocketOptionLevel level, out SocketOptionName name)
+ {
+ var table = level switch
+ {
+ SocketOptionLevel.Socket => _soSocketOptionMap,
+ SocketOptionLevel.IP => _ipSocketOptionMap,
+ SocketOptionLevel.Tcp => _tcpSocketOptionMap,
+ _ => null
+ };
+
+ if (table == null)
+ {
+ name = default;
+ return false;
+ }
+
+ return table.TryGetValue(option, out name);
+ }
+ }
+}
diff --git a/Ryujinx.HLE/HOS/Services/Sockets/Bsd/Types/BsdAddressFamily.cs b/Ryujinx.HLE/HOS/Services/Sockets/Bsd/Types/BsdAddressFamily.cs
new file mode 100644
index 0000000000..dcc9f0fd7a
--- /dev/null
+++ b/Ryujinx.HLE/HOS/Services/Sockets/Bsd/Types/BsdAddressFamily.cs
@@ -0,0 +1,11 @@
+namespace Ryujinx.HLE.HOS.Services.Sockets.Bsd
+{
+ enum BsdAddressFamily : uint
+ {
+ Unspecified,
+ InterNetwork = 2,
+ InterNetworkV6 = 28,
+
+ Unknown = uint.MaxValue
+ }
+}
diff --git a/Ryujinx.HLE/HOS/Services/Sockets/Bsd/Types/BsdSockAddr.cs b/Ryujinx.HLE/HOS/Services/Sockets/Bsd/Types/BsdSockAddr.cs
new file mode 100644
index 0000000000..916ca2bbcd
--- /dev/null
+++ b/Ryujinx.HLE/HOS/Services/Sockets/Bsd/Types/BsdSockAddr.cs
@@ -0,0 +1,39 @@
+using Ryujinx.Common.Memory;
+using System;
+using System.Net;
+using System.Runtime.InteropServices;
+
+namespace Ryujinx.HLE.HOS.Services.Sockets.Bsd
+{
+ [StructLayout(LayoutKind.Sequential, Pack = 1, Size = 0x10)]
+ struct BsdSockAddr
+ {
+ public byte Length;
+ public byte Family;
+ public ushort Port;
+ public Array4<byte> Address;
+ private Array8<byte> _reserved;
+
+ public IPEndPoint ToIPEndPoint()
+ {
+ IPAddress address = new IPAddress(Address.ToSpan());
+ int port = (ushort)IPAddress.NetworkToHostOrder((short)Port);
+
+ return new IPEndPoint(address, port);
+ }
+
+ public static BsdSockAddr FromIPEndPoint(IPEndPoint endpoint)
+ {
+ BsdSockAddr result = new BsdSockAddr
+ {
+ Length = 0,
+ Family = (byte)endpoint.AddressFamily,
+ Port = (ushort)IPAddress.HostToNetworkOrder((short)endpoint.Port)
+ };
+
+ endpoint.Address.GetAddressBytes().AsSpan().CopyTo(result.Address.ToSpan());
+
+ return result;
+ }
+ }
+}
diff --git a/Ryujinx.HLE/HOS/Services/Sockets/Bsd/Types/BsdSocket.cs b/Ryujinx.HLE/HOS/Services/Sockets/Bsd/Types/BsdSocket.cs
deleted file mode 100644
index 2d5bf42902..0000000000
--- a/Ryujinx.HLE/HOS/Services/Sockets/Bsd/Types/BsdSocket.cs
+++ /dev/null
@@ -1,13 +0,0 @@
-using System.Net.Sockets;
-
-namespace Ryujinx.HLE.HOS.Services.Sockets.Bsd
-{
- class BsdSocket
- {
- public int Family;
- public int Type;
- public int Protocol;
-
- public Socket Handle;
- }
-}
\ No newline at end of file
diff --git a/Ryujinx.HLE/HOS/Services/Sockets/Bsd/Types/BsdSocketCreationFlags.cs b/Ryujinx.HLE/HOS/Services/Sockets/Bsd/Types/BsdSocketCreationFlags.cs
new file mode 100644
index 0000000000..77718800d2
--- /dev/null
+++ b/Ryujinx.HLE/HOS/Services/Sockets/Bsd/Types/BsdSocketCreationFlags.cs
@@ -0,0 +1,14 @@
+using System;
+
+namespace Ryujinx.HLE.HOS.Services.Sockets.Bsd
+{
+ [Flags]
+ enum BsdSocketCreationFlags
+ {
+ None = 0,
+ CloseOnExecution = 1,
+ NonBlocking = 2,
+
+ FlagsShift = 28
+ }
+}
diff --git a/Ryujinx.HLE/HOS/Services/Sockets/Bsd/Types/BsdSocketShutdownFlags.cs b/Ryujinx.HLE/HOS/Services/Sockets/Bsd/Types/BsdSocketShutdownFlags.cs
new file mode 100644
index 0000000000..2588376bb9
--- /dev/null
+++ b/Ryujinx.HLE/HOS/Services/Sockets/Bsd/Types/BsdSocketShutdownFlags.cs
@@ -0,0 +1,9 @@
+namespace Ryujinx.HLE.HOS.Services.Sockets.Bsd
+{
+ enum BsdSocketShutdownFlags
+ {
+ Receive,
+ Send,
+ ReceiveAndSend
+ }
+}
diff --git a/Ryujinx.HLE/HOS/Services/Sockets/Bsd/Types/BsdSocketType.cs b/Ryujinx.HLE/HOS/Services/Sockets/Bsd/Types/BsdSocketType.cs
new file mode 100644
index 0000000000..9b13e669a6
--- /dev/null
+++ b/Ryujinx.HLE/HOS/Services/Sockets/Bsd/Types/BsdSocketType.cs
@@ -0,0 +1,13 @@
+namespace Ryujinx.HLE.HOS.Services.Sockets.Bsd
+{
+ enum BsdSocketType
+ {
+ Stream = 1,
+ Dgram,
+ Raw,
+ Rdm,
+ Seqpacket,
+
+ TypeMask = 0xFFFFFFF,
+ }
+}
diff --git a/Ryujinx.HLE/HOS/Services/Sockets/Bsd/Types/EventFdFlags.cs b/Ryujinx.HLE/HOS/Services/Sockets/Bsd/Types/EventFdFlags.cs
new file mode 100644
index 0000000000..7d08fb24a3
--- /dev/null
+++ b/Ryujinx.HLE/HOS/Services/Sockets/Bsd/Types/EventFdFlags.cs
@@ -0,0 +1,12 @@
+using System;
+
+namespace Ryujinx.HLE.HOS.Services.Sockets.Bsd
+{
+ [Flags]
+ enum EventFdFlags : uint
+ {
+ None = 0,
+ Semaphore = 1 << 0,
+ NonBlocking = 1 << 2
+ }
+}
diff --git a/Ryujinx.HLE/HOS/Services/Sockets/Bsd/Types/IPollManager.cs b/Ryujinx.HLE/HOS/Services/Sockets/Bsd/Types/IPollManager.cs
new file mode 100644
index 0000000000..8b0959fd06
--- /dev/null
+++ b/Ryujinx.HLE/HOS/Services/Sockets/Bsd/Types/IPollManager.cs
@@ -0,0 +1,11 @@
+using System.Collections.Generic;
+
+namespace Ryujinx.HLE.HOS.Services.Sockets.Bsd
+{
+ interface IPollManager
+ {
+ bool IsCompatible(PollEvent evnt);
+
+ LinuxError Poll(List<PollEvent> events, int timeoutMilliseconds, out int updatedCount);
+ }
+}
diff --git a/Ryujinx.HLE/HOS/Services/Sockets/Bsd/Types/PollEvent.cs b/Ryujinx.HLE/HOS/Services/Sockets/Bsd/Types/PollEvent.cs
index ff47a4c70c..8056e7a875 100644
--- a/Ryujinx.HLE/HOS/Services/Sockets/Bsd/Types/PollEvent.cs
+++ b/Ryujinx.HLE/HOS/Services/Sockets/Bsd/Types/PollEvent.cs
@@ -2,27 +2,13 @@
{
class PollEvent
{
- public enum EventTypeMask
- {
- Input = 1,
- UrgentInput = 2,
- Output = 4,
- Error = 8,
- Disconnected = 0x10,
- Invalid = 0x20
- }
+ public PollEventData Data;
+ public IFileDescriptor FileDescriptor { get; }
- public int SocketFd { get; private set; }
- public BsdSocket Socket { get; private set; }
- public EventTypeMask InputEvents { get; private set; }
- public EventTypeMask OutputEvents { get; private set; }
-
- public PollEvent(int socketFd, BsdSocket socket, EventTypeMask inputEvents, EventTypeMask outputEvents)
+ public PollEvent(PollEventData data, IFileDescriptor fileDescriptor)
{
- SocketFd = socketFd;
- Socket = socket;
- InputEvents = inputEvents;
- OutputEvents = outputEvents;
+ Data = data;
+ FileDescriptor = fileDescriptor;
}
}
}
\ No newline at end of file
diff --git a/Ryujinx.HLE/HOS/Services/Sockets/Bsd/Types/PollEventData.cs b/Ryujinx.HLE/HOS/Services/Sockets/Bsd/Types/PollEventData.cs
new file mode 100644
index 0000000000..ee400e6956
--- /dev/null
+++ b/Ryujinx.HLE/HOS/Services/Sockets/Bsd/Types/PollEventData.cs
@@ -0,0 +1,13 @@
+using System;
+
+namespace Ryujinx.HLE.HOS.Services.Sockets.Bsd
+{
+ struct PollEventData
+ {
+#pragma warning disable CS0649
+ public int SocketFd;
+ public PollEventTypeMask InputEvents;
+#pragma warning restore CS0649
+ public PollEventTypeMask OutputEvents;
+ }
+}
diff --git a/Ryujinx.HLE/HOS/Services/Sockets/Bsd/Types/PollEventTypeMask.cs b/Ryujinx.HLE/HOS/Services/Sockets/Bsd/Types/PollEventTypeMask.cs
new file mode 100644
index 0000000000..899072bf04
--- /dev/null
+++ b/Ryujinx.HLE/HOS/Services/Sockets/Bsd/Types/PollEventTypeMask.cs
@@ -0,0 +1,15 @@
+using System;
+
+namespace Ryujinx.HLE.HOS.Services.Sockets.Bsd
+{
+ [Flags]
+ enum PollEventTypeMask : ushort
+ {
+ Input = 1,
+ UrgentInput = 2,
+ Output = 4,
+ Error = 8,
+ Disconnected = 0x10,
+ Invalid = 0x20
+ }
+}