Move solution and projects to src

6 files changed, 1341 insertions, 0 deletions

diff --git a/src/Ryujinx.HLE/HOS/Services/Sockets/Bsd/Impl/EventFileDescriptor.cs b/src/Ryujinx.HLE/HOS/Services/Sockets/Bsd/Impl/EventFileDescriptor.cs
new file mode 100644
index 00000000..6514d485
--- /dev/null
+++ b/src/Ryujinx.HLE/HOS/Services/Sockets/Bsd/Impl/EventFileDescriptor.cs
@@ -0,0 +1,153 @@
+using Ryujinx.HLE.HOS.Services.Sockets.Bsd.Types;
+using System;
+using System.Runtime.InteropServices;
+using System.Threading;
+
+namespace Ryujinx.HLE.HOS.Services.Sockets.Bsd.Impl
+{
+    class EventFileDescriptor : IFileDescriptor
+    {
+        private ulong _value;
+        private readonly EventFdFlags _flags;
+
+        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)
+        {
+            // FIXME: We should support blocking operations.
+            // Right now they can't be supported because it would cause the
+            // service to lock up as we only have one thread processing requests.
+            flags |= EventFdFlags.NonBlocking;
+
+            _value = value;
+            _flags = flags;
+
+            WriteEvent = new ManualResetEvent(false);
+            ReadEvent = new ManualResetEvent(false);
+            UpdateEventStates();
+        }
+
+        public int Refcount { get; set; }
+
+        public void Dispose()
+        {
+            WriteEvent.Dispose();
+            ReadEvent.Dispose();
+        }
+
+        private void ResetEventStates()
+        {
+            WriteEvent.Reset();
+            ReadEvent.Reset();
+        }
+
+        private void UpdateEventStates()
+        {
+            if (_value > 0)
+            {
+                ReadEvent.Set();
+            }
+
+            if (_value != uint.MaxValue - 1)
+            {
+                WriteEvent.Set();
+            }
+        }
+
+        public LinuxError Read(out int readSize, Span<byte> buffer)
+        {
+            if (buffer.Length < sizeof(ulong))
+            {
+                readSize = 0;
+
+                return LinuxError.EINVAL;
+            }
+
+            lock (_lock)
+            {
+                ResetEventStates();
+
+                ref ulong count = ref MemoryMarshal.Cast<byte, ulong>(buffer)[0];
+
+                if (_value == 0)
+                {
+                    if (Blocking)
+                    {
+                        while (_value == 0)
+                        {
+                            Monitor.Wait(_lock);
+                        }
+                    }
+                    else
+                    {
+                        readSize = 0;
+
+                        UpdateEventStates();
+                        return LinuxError.EAGAIN;
+                    }
+                }
+
+                readSize = sizeof(ulong);
+
+                if (_flags.HasFlag(EventFdFlags.Semaphore))
+                {
+                    --_value;
+
+                    count = 1;
+                }
+                else
+                {
+                    count = _value;
+
+                    _value = 0;
+                }
+
+                UpdateEventStates();
+                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;
+            }
+
+            lock (_lock)
+            {
+                ResetEventStates();
+
+                if (_value > _value + count)
+                {
+                    if (Blocking)
+                    {
+                        Monitor.Wait(_lock);
+                    }
+                    else
+                    {
+                        writeSize = 0;
+
+                        UpdateEventStates();
+                        return LinuxError.EAGAIN;
+                    }
+                }
+
+                writeSize = sizeof(ulong);
+
+                _value += count;
+                Monitor.Pulse(_lock);
+
+                UpdateEventStates();
+                return LinuxError.SUCCESS;
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/Ryujinx.HLE/HOS/Services/Sockets/Bsd/Impl/EventFileDescriptorPollManager.cs b/src/Ryujinx.HLE/HOS/Services/Sockets/Bsd/Impl/EventFileDescriptorPollManager.cs
new file mode 100644
index 00000000..e0ab68c6
--- /dev/null
+++ b/src/Ryujinx.HLE/HOS/Services/Sockets/Bsd/Impl/EventFileDescriptorPollManager.cs
@@ -0,0 +1,122 @@
+using Ryujinx.Common.Logging;
+using Ryujinx.HLE.HOS.Services.Sockets.Bsd.Types;
+using System.Collections.Generic;
+using System.Threading;
+
+namespace Ryujinx.HLE.HOS.Services.Sockets.Bsd.Impl
+{
+    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++)
+                {
+                    PollEventTypeMask outputEvents = 0;
+
+                    PollEvent evnt = events[i];
+
+                    EventFileDescriptor socket = (EventFileDescriptor)evnt.FileDescriptor;
+
+                    if (socket.ReadEvent.WaitOne(0))
+                    {
+                        if (evnt.Data.InputEvents.HasFlag(PollEventTypeMask.Input))
+                        {
+                            outputEvents |= PollEventTypeMask.Input;
+                        }
+
+                        if (evnt.Data.InputEvents.HasFlag(PollEventTypeMask.UrgentInput))
+                        {
+                            outputEvents |= PollEventTypeMask.UrgentInput;
+                        }
+                    }
+
+                    if ((evnt.Data.InputEvents.HasFlag(PollEventTypeMask.Output))
+                        && socket.WriteEvent.WaitOne(0))
+                    {
+                        outputEvents |= PollEventTypeMask.Output;
+                    }
+
+
+                    if (outputEvents != 0)
+                    {
+                        evnt.Data.OutputEvents = outputEvents;
+
+                        updatedCount++;
+                    }
+                }
+            }
+            else
+            {
+                return LinuxError.ETIMEDOUT;
+            }
+
+            return LinuxError.SUCCESS;
+        }
+
+        public LinuxError Select(List<PollEvent> events, int timeout, out int updatedCount)
+        {
+            // TODO: Implement Select for event file descriptors
+            updatedCount = 0;
+
+            return LinuxError.EOPNOTSUPP;
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/Ryujinx.HLE/HOS/Services/Sockets/Bsd/Impl/ManagedSocket.cs b/src/Ryujinx.HLE/HOS/Services/Sockets/Bsd/Impl/ManagedSocket.cs
new file mode 100644
index 00000000..75efc49a
--- /dev/null
+++ b/src/Ryujinx.HLE/HOS/Services/Sockets/Bsd/Impl/ManagedSocket.cs
@@ -0,0 +1,530 @@
+using Ryujinx.Common.Logging;
+using Ryujinx.HLE.HOS.Services.Sockets.Bsd.Types;
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Net;
+using System.Net.Sockets;
+using System.Runtime.InteropServices;
+
+namespace Ryujinx.HLE.HOS.Services.Sockets.Bsd.Impl
+{
+    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)
+        {
+            LinuxError result;
+
+            bool shouldBlockAfterOperation = false;
+
+            try
+            {
+                if (Blocking && flags.HasFlag(BsdSocketFlags.DontWait))
+                {
+                    Blocking = false;
+                    shouldBlockAfterOperation = true;
+                }
+
+                receiveSize = Socket.Receive(buffer, ConvertBsdSocketFlags(flags));
+
+                result = LinuxError.SUCCESS;
+            }
+            catch (SocketException exception)
+            {
+                receiveSize = -1;
+
+                result = WinSockHelper.ConvertError((WsaError)exception.ErrorCode);
+            }
+
+            if (shouldBlockAfterOperation)
+            {
+                Blocking = true;
+            }
+
+            return result;
+        }
+
+        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;
+                }
+
+                if (!Socket.IsBound)
+                {
+                    receiveSize = -1;
+
+                    return LinuxError.EOPNOTSUPP;
+                }
+
+                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 = optionValue.Length >= 4 ? MemoryMarshal.Read<int>(optionValue) : MemoryMarshal.Read<byte>(optionValue);
+
+                if (level == SocketOptionLevel.Socket && option == BsdSocketOption.SoLinger)
+                {
+                    int value2 = 0;
+
+                    if (optionValue.Length >= 8)
+                    {
+                        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);
+        }
+
+        private bool CanSupportMMsgHdr(BsdMMsgHdr message)
+        {
+            for (int i = 0; i < message.Messages.Length; i++)
+            {
+                if (message.Messages[i].Name != null ||
+                    message.Messages[i].Control != null)
+                {
+                    return false;
+                }
+            }
+
+            return true;
+        }
+
+        private static IList<ArraySegment<byte>> ConvertMessagesToBuffer(BsdMMsgHdr message)
+        {
+            int segmentCount = 0;
+            int index = 0;
+
+            foreach (BsdMsgHdr msgHeader in message.Messages)
+            {
+                segmentCount += msgHeader.Iov.Length;
+            }
+
+            ArraySegment<byte>[] buffers = new ArraySegment<byte>[segmentCount];
+
+            foreach (BsdMsgHdr msgHeader in message.Messages)
+            {
+                foreach (byte[] iov in msgHeader.Iov)
+                {
+                    buffers[index++] = new ArraySegment<byte>(iov);
+                }
+
+                // Clear the length
+                msgHeader.Length = 0;
+            }
+
+            return buffers;
+        }
+
+        private static void UpdateMessages(out int vlen, BsdMMsgHdr message, int transferedSize)
+        {
+            int bytesLeft = transferedSize;
+            int index = 0;
+
+            while (bytesLeft > 0)
+            {
+                // First ensure we haven't finished all buffers
+                if (index >= message.Messages.Length)
+                {
+                    break;
+                }
+
+                BsdMsgHdr msgHeader = message.Messages[index];
+
+                int possiblyTransferedBytes = 0;
+
+                foreach (byte[] iov in msgHeader.Iov)
+                {
+                    possiblyTransferedBytes += iov.Length;
+                }
+
+                int storedBytes;
+
+                if (bytesLeft > possiblyTransferedBytes)
+                {
+                    storedBytes = possiblyTransferedBytes;
+                    index++;
+                }
+                else
+                {
+                    storedBytes = bytesLeft;
+                }
+
+                msgHeader.Length = (uint)storedBytes;
+                bytesLeft -= storedBytes;
+            }
+
+            Debug.Assert(bytesLeft == 0);
+
+            vlen = index + 1;
+        }
+
+        // TODO: Find a way to support passing the timeout somehow without changing the socket ReceiveTimeout.
+        public LinuxError RecvMMsg(out int vlen, BsdMMsgHdr message, BsdSocketFlags flags, TimeVal timeout)
+        {
+            vlen = 0;
+
+            if (message.Messages.Length == 0)
+            {
+                return LinuxError.SUCCESS;
+            }
+
+            if (!CanSupportMMsgHdr(message))
+            {
+                Logger.Warning?.Print(LogClass.ServiceBsd, $"Unsupported BsdMMsgHdr");
+
+                return LinuxError.EOPNOTSUPP;
+            }
+
+            if (message.Messages.Length == 0)
+            {
+                return LinuxError.SUCCESS;
+            }
+
+            try
+            {
+                int receiveSize = Socket.Receive(ConvertMessagesToBuffer(message), ConvertBsdSocketFlags(flags), out SocketError socketError);
+
+                if (receiveSize > 0)
+                {
+                    UpdateMessages(out vlen, message, receiveSize);
+                }
+
+                return WinSockHelper.ConvertError((WsaError)socketError);
+            }
+            catch (SocketException exception)
+            {
+                return WinSockHelper.ConvertError((WsaError)exception.ErrorCode);
+            }
+        }
+
+        public LinuxError SendMMsg(out int vlen, BsdMMsgHdr message, BsdSocketFlags flags)
+        {
+            vlen = 0;
+
+            if (message.Messages.Length == 0)
+            {
+                return LinuxError.SUCCESS;
+            }
+
+            if (!CanSupportMMsgHdr(message))
+            {
+                Logger.Warning?.Print(LogClass.ServiceBsd, $"Unsupported BsdMMsgHdr");
+
+                return LinuxError.EOPNOTSUPP;
+            }
+
+            if (message.Messages.Length == 0)
+            {
+                return LinuxError.SUCCESS;
+            }
+
+            try
+            {
+                int sendSize = Socket.Send(ConvertMessagesToBuffer(message), ConvertBsdSocketFlags(flags), out SocketError socketError);
+
+                if (sendSize > 0)
+                {
+                    UpdateMessages(out vlen, message, sendSize);
+                }
+
+                return WinSockHelper.ConvertError((WsaError)socketError);
+            }
+            catch (SocketException exception)
+            {
+                return WinSockHelper.ConvertError((WsaError)exception.ErrorCode);
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/Ryujinx.HLE/HOS/Services/Sockets/Bsd/Impl/ManagedSocketPollManager.cs b/src/Ryujinx.HLE/HOS/Services/Sockets/Bsd/Impl/ManagedSocketPollManager.cs
new file mode 100644
index 00000000..1b305dfb
--- /dev/null
+++ b/src/Ryujinx.HLE/HOS/Services/Sockets/Bsd/Impl/ManagedSocketPollManager.cs
@@ -0,0 +1,177 @@
+using Ryujinx.Common.Logging;
+using Ryujinx.HLE.HOS.Services.Sockets.Bsd.Types;
+using System.Collections.Generic;
+using System.Net.Sockets;
+
+namespace Ryujinx.HLE.HOS.Services.Sockets.Bsd.Impl
+{
+    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 = evnt.Data.InputEvents == 0;
+
+                errorEvents.Add(socket.Socket);
+
+                if ((evnt.Data.InputEvents & PollEventTypeMask.Input) != 0)
+                {
+                    readEvents.Add(socket.Socket);
+
+                    isValidEvent = true;
+                }
+
+                if ((evnt.Data.InputEvents & PollEventTypeMask.UrgentInput) != 0)
+                {
+                    readEvents.Add(socket.Socket);
+
+                    isValidEvent = true;
+                }
+
+                if ((evnt.Data.InputEvents & PollEventTypeMask.Output) != 0)
+                {
+                    writeEvents.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 = evnt.Data.OutputEvents & ~evnt.Data.InputEvents;
+
+                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;
+        }
+
+        public LinuxError Select(List<PollEvent> events, int timeout, out int updatedCount)
+        {
+            List<Socket> readEvents = new();
+            List<Socket> writeEvents = new();
+            List<Socket> errorEvents = new();
+
+            updatedCount = 0;
+
+            foreach (PollEvent pollEvent in events)
+            {
+                ManagedSocket socket = (ManagedSocket)pollEvent.FileDescriptor;
+
+                if (pollEvent.Data.InputEvents.HasFlag(PollEventTypeMask.Input))
+                {
+                    readEvents.Add(socket.Socket);
+                }
+
+                if (pollEvent.Data.InputEvents.HasFlag(PollEventTypeMask.Output))
+                {
+                    writeEvents.Add(socket.Socket);
+                }
+
+                if (pollEvent.Data.InputEvents.HasFlag(PollEventTypeMask.Error))
+                {
+                    errorEvents.Add(socket.Socket);
+                }
+            }
+
+            Socket.Select(readEvents, writeEvents, errorEvents, timeout);
+
+            updatedCount = readEvents.Count + writeEvents.Count + errorEvents.Count;
+
+            foreach (PollEvent pollEvent in events)
+            {
+                ManagedSocket socket = (ManagedSocket)pollEvent.FileDescriptor;
+
+                if (readEvents.Contains(socket.Socket))
+                {
+                    pollEvent.Data.OutputEvents |= PollEventTypeMask.Input;
+                }
+
+                if (writeEvents.Contains(socket.Socket))
+                {
+                    pollEvent.Data.OutputEvents |= PollEventTypeMask.Output;
+                }
+
+                if (errorEvents.Contains(socket.Socket))
+                {
+                    pollEvent.Data.OutputEvents |= PollEventTypeMask.Error;
+                }
+            }
+
+            return LinuxError.SUCCESS;
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/Ryujinx.HLE/HOS/Services/Sockets/Bsd/Impl/WSAError.cs b/src/Ryujinx.HLE/HOS/Services/Sockets/Bsd/Impl/WSAError.cs
new file mode 100644
index 00000000..0f24a57f
--- /dev/null
+++ b/src/Ryujinx.HLE/HOS/Services/Sockets/Bsd/Impl/WSAError.cs
@@ -0,0 +1,134 @@
+using System.Diagnostics.CodeAnalysis;
+
+namespace Ryujinx.HLE.HOS.Services.Sockets.Bsd.Impl
+{
+    [SuppressMessage("ReSharper", "InconsistentNaming")]
+    enum WsaError
+    {
+        /*
+        * All Windows Sockets error constants are biased by WSABASEERR from
+        * the "normal"
+        */
+        WSABASEERR                 = 10000,
+
+        /*
+        * Windows Sockets definitions of regular Microsoft C error constants
+        */
+        WSAEINTR                   = (WSABASEERR + 4),
+        WSAEBADF                   = (WSABASEERR + 9),
+        WSAEACCES                  = (WSABASEERR + 13),
+        WSAEFAULT                  = (WSABASEERR + 14),
+        WSAEINVAL                  = (WSABASEERR + 22),
+        WSAEMFILE                  = (WSABASEERR + 24),
+
+        /*
+         * Windows Sockets definitions of regular Berkeley error constants
+         */
+        WSAEWOULDBLOCK             = (WSABASEERR + 35),
+        WSAEINPROGRESS             = (WSABASEERR + 36),
+        WSAEALREADY                = (WSABASEERR + 37),
+        WSAENOTSOCK                = (WSABASEERR + 38),
+        WSAEDESTADDRREQ            = (WSABASEERR + 39),
+        WSAEMSGSIZE                = (WSABASEERR + 40),
+        WSAEPROTOTYPE              = (WSABASEERR + 41),
+        WSAENOPROTOOPT             = (WSABASEERR + 42),
+        WSAEPROTONOSUPPORT         = (WSABASEERR + 43),
+        WSAESOCKTNOSUPPORT         = (WSABASEERR + 44),
+        WSAEOPNOTSUPP              = (WSABASEERR + 45),
+        WSAEPFNOSUPPORT            = (WSABASEERR + 46),
+        WSAEAFNOSUPPORT            = (WSABASEERR + 47),
+        WSAEADDRINUSE              = (WSABASEERR + 48),
+        WSAEADDRNOTAVAIL           = (WSABASEERR + 49),
+        WSAENETDOWN                = (WSABASEERR + 50),
+        WSAENETUNREACH             = (WSABASEERR + 51),
+        WSAENETRESET               = (WSABASEERR + 52),
+        WSAECONNABORTED            = (WSABASEERR + 53),
+        WSAECONNRESET              = (WSABASEERR + 54),
+        WSAENOBUFS                 = (WSABASEERR + 55),
+        WSAEISCONN                 = (WSABASEERR + 56),
+        WSAENOTCONN                = (WSABASEERR + 57),
+        WSAESHUTDOWN               = (WSABASEERR + 58),
+        WSAETOOMANYREFS            = (WSABASEERR + 59),
+        WSAETIMEDOUT               = (WSABASEERR + 60),
+        WSAECONNREFUSED            = (WSABASEERR + 61),
+        WSAELOOP                   = (WSABASEERR + 62),
+        WSAENAMETOOLONG            = (WSABASEERR + 63),
+        WSAEHOSTDOWN               = (WSABASEERR + 64),
+        WSAEHOSTUNREACH            = (WSABASEERR + 65),
+        WSAENOTEMPTY               = (WSABASEERR + 66),
+        WSAEPROCLIM                = (WSABASEERR + 67),
+        WSAEUSERS                  = (WSABASEERR + 68),
+        WSAEDQUOT                  = (WSABASEERR + 69),
+        WSAESTALE                  = (WSABASEERR + 70),
+        WSAEREMOTE                 = (WSABASEERR + 71),
+
+        /*
+         * Extended Windows Sockets error constant definitions
+         */
+        WSASYSNOTREADY             = (WSABASEERR + 91),
+        WSAVERNOTSUPPORTED         = (WSABASEERR + 92),
+        WSANOTINITIALISED          = (WSABASEERR + 93),
+        WSAEDISCON                 = (WSABASEERR + 101),
+        WSAENOMORE                 = (WSABASEERR + 102),
+        WSAECANCELLED              = (WSABASEERR + 103),
+        WSAEINVALIDPROCTABLE       = (WSABASEERR + 104),
+        WSAEINVALIDPROVIDER        = (WSABASEERR + 105),
+        WSAEPROVIDERFAILEDINIT     = (WSABASEERR + 106),
+        WSASYSCALLFAILURE          = (WSABASEERR + 107),
+        WSASERVICE_NOT_FOUND       = (WSABASEERR + 108),
+        WSATYPE_NOT_FOUND          = (WSABASEERR + 109),
+        WSA_E_NO_MORE              = (WSABASEERR + 110),
+        WSA_E_CANCELLED            = (WSABASEERR + 111),
+        WSAEREFUSED                = (WSABASEERR + 112),
+
+        /*
+         * Error return codes from gethostbyname() and gethostbyaddr()
+         * (when using the resolver). Note that these errors are
+         * retrieved via WSAGetLastError() and must therefore follow
+         * the rules for avoiding clashes with error numbers from
+         * specific implementations or language run-time systems.
+         * For this reason the codes are based at WSABASEERR+1001.
+         * Note also that [WSA]NO_ADDRESS is defined only for
+         * compatibility purposes.
+         */
+
+        /* Authoritative Answer: Host not found */
+        WSAHOST_NOT_FOUND          = (WSABASEERR + 1001),
+
+        /* Non-Authoritative: Host not found, or SERVERFAIL */
+        WSATRY_AGAIN               = (WSABASEERR + 1002),
+
+        /* Non-recoverable errors, FORMERR, REFUSED, NOTIMP */
+        WSANO_RECOVERY             = (WSABASEERR + 1003),
+
+        /* Valid name, no data record of requested type */
+        WSANO_DATA                 = (WSABASEERR + 1004),
+
+        /*
+         * Define QOS related error return codes
+         *
+         */
+        WSA_QOS_RECEIVERS          = (WSABASEERR + 1005),
+        /* at least one Reserve has arrived */
+        WSA_QOS_SENDERS            = (WSABASEERR + 1006),
+        /* at least one Path has arrived */
+        WSA_QOS_NO_SENDERS         = (WSABASEERR + 1007),
+        /* there are no senders */
+        WSA_QOS_NO_RECEIVERS       = (WSABASEERR + 1008),
+        /* there are no receivers */
+        WSA_QOS_REQUEST_CONFIRMED  = (WSABASEERR + 1009),
+        /* Reserve has been confirmed */
+        WSA_QOS_ADMISSION_FAILURE  = (WSABASEERR + 1010),
+        /* error due to lack of resources */
+        WSA_QOS_POLICY_FAILURE     = (WSABASEERR + 1011),
+        /* rejected for administrative reasons - bad credentials */
+        WSA_QOS_BAD_STYLE          = (WSABASEERR + 1012),
+        /* unknown or conflicting style */
+        WSA_QOS_BAD_OBJECT         = (WSABASEERR + 1013),
+        /* problem with some part of the filterspec or providerspecific
+         * buffer in general */
+        WSA_QOS_TRAFFIC_CTRL_ERROR = (WSABASEERR + 1014),
+        /* problem with some part of the flowspec */
+        WSA_QOS_GENERIC_ERROR      = (WSABASEERR + 1015)
+    }
+}
diff --git a/src/Ryujinx.HLE/HOS/Services/Sockets/Bsd/Impl/WinSockHelper.cs b/src/Ryujinx.HLE/HOS/Services/Sockets/Bsd/Impl/WinSockHelper.cs
new file mode 100644
index 00000000..5668d30b
--- /dev/null
+++ b/src/Ryujinx.HLE/HOS/Services/Sockets/Bsd/Impl/WinSockHelper.cs
@@ -0,0 +1,225 @@
+using Ryujinx.HLE.HOS.Services.Sockets.Bsd.Types;
+using System;
+using System.Collections.Generic;
+using System.Net.Sockets;
+
+namespace Ryujinx.HLE.HOS.Services.Sockets.Bsd.Impl
+{
+    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<int, LinuxError> _errorMapMacOs = new()
+        {
+            { 35, LinuxError.EAGAIN },
+            { 11, LinuxError.EDEADLOCK },
+            { 91, LinuxError.ENOMSG },
+            { 90, LinuxError.EIDRM },
+            { 77, LinuxError.ENOLCK },
+            { 70, LinuxError.ESTALE },
+            { 36, LinuxError.EINPROGRESS },
+            { 37, LinuxError.EALREADY },
+            { 38, LinuxError.ENOTSOCK },
+            { 39, LinuxError.EDESTADDRREQ },
+            { 40, LinuxError.EMSGSIZE },
+            { 41, LinuxError.EPROTOTYPE },
+            { 42, LinuxError.ENOPROTOOPT },
+            { 43, LinuxError.EPROTONOSUPPORT },
+            { 44, LinuxError.ESOCKTNOSUPPORT },
+            { 45, LinuxError.EOPNOTSUPP },
+            { 46, LinuxError.EPFNOSUPPORT },
+            { 47, LinuxError.EAFNOSUPPORT },
+            { 48, LinuxError.EADDRINUSE },
+            { 49, LinuxError.EADDRNOTAVAIL },
+            { 50, LinuxError.ENETDOWN },
+            { 51, LinuxError.ENETUNREACH },
+            { 52, LinuxError.ENETRESET },
+            { 53, LinuxError.ECONNABORTED },
+            { 54, LinuxError.ECONNRESET },
+            { 55, LinuxError.ENOBUFS },
+            { 56, LinuxError.EISCONN },
+            { 57, LinuxError.ENOTCONN },
+            { 58, LinuxError.ESHUTDOWN },
+            { 60, LinuxError.ETIMEDOUT },
+            { 61, LinuxError.ECONNREFUSED },
+            { 64, LinuxError.EHOSTDOWN },
+            { 65, LinuxError.EHOSTUNREACH },
+            { 68, LinuxError.EUSERS },
+            { 62, LinuxError.ELOOP },
+            { 63, LinuxError.ENAMETOOLONG },
+            { 66, LinuxError.ENOTEMPTY },
+            { 69, LinuxError.EDQUOT },
+            { 71, LinuxError.EREMOTE },
+            { 78, LinuxError.ENOSYS },
+            { 59, LinuxError.ETOOMANYREFS },
+            { 92, LinuxError.EILSEQ },
+            { 89, LinuxError.ECANCELED },
+            { 84, LinuxError.EOVERFLOW }
+        };
+
+        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 (OperatingSystem.IsMacOS())
+            {
+                if (_errorMapMacOs.TryGetValue((int)errorCode, out LinuxError errno))
+                {
+                    return errno;
+                }
+            }
+            else
+            {
+                if (_errorMap.TryGetValue(errorCode, out LinuxError errno))
+                {
+                    return errno;
+                }
+            }
+
+            return (LinuxError)errorCode;
+        }
+
+        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);
+        }
+    }
+}
\ No newline at end of file