owen/Ryujinx
1
0
Fork 0
mirror of https://github.com/Ryubing/Ryujinx.git synced 2025-11-27 21:02:31 -05:00
Code Issues Packages Projects Releases Wiki Activity

Move solution and projects to src

Browse Source
This commit is contained in:
TSR Berry
2023-04-08 01:22:00 +02:00
committed by Mary
parent cd124bda58
commit cee7121058
3466 changed files with 55 additions and 55 deletions
Download Patch File Download Diff File Expand all files Collapse all files

184
src/Ryujinx.HLE/HOS/Services/Sockets/Bsd/BsdContext.cs Normal file
View File

@@ -0,0 +1,184 @@
using Ryujinx.HLE.HOS.Services.Sockets.Bsd.Types;
using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Numerics;
namespace Ryujinx.HLE.HOS.Services.Sockets.Bsd
{
class BsdContext
{
private static ConcurrentDictionary<ulong, BsdContext> _registry = new ConcurrentDictionary<ulong, 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 List<IFileDescriptor> RetrieveFileDescriptorsFromMask(ReadOnlySpan<byte> mask)
{
List<IFileDescriptor> fds = new();
for (int i = 0; i < mask.Length; i++)
{
byte current = mask[i];
while (current != 0)
{
int bit = BitOperations.TrailingZeroCount(current);
current &= (byte)~(1 << bit);
int fd = i * 8 + bit;
fds.Add(RetrieveFileDescriptor(fd));
}
}
return fds;
}
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 void BuildMask(List<IFileDescriptor> fds, Span<byte> mask)
{
foreach (IFileDescriptor descriptor in fds)
{
int fd = _fds.IndexOf(descriptor);
mask[fd >> 3] |= (byte)(1 << (fd & 7));
}
}
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(ulong processId)
{
BsdContext context = GetContext(processId);
if (context == null)
{
context = new BsdContext();
_registry.TryAdd(processId, context);
}
return context;
}
public static BsdContext GetContext(ulong processId)
{
if (!_registry.TryGetValue(processId, out BsdContext processContext))
{
return null;
}
return processContext;
}
}
}

1121
src/Ryujinx.HLE/HOS/Services/Sockets/Bsd/IClient.cs Normal file
View File

File diff suppressed because it is too large Load Diff

15
src/Ryujinx.HLE/HOS/Services/Sockets/Bsd/IFileDescriptor.cs Normal file
View File

@@ -0,0 +1,15 @@
using Ryujinx.HLE.HOS.Services.Sockets.Bsd.Types;
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);
}
}

53
src/Ryujinx.HLE/HOS/Services/Sockets/Bsd/ISocket.cs Normal file
View File

@@ -0,0 +1,53 @@
using Ryujinx.HLE.HOS.Services.Sockets.Bsd.Types;
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 RecvMMsg(out int vlen, BsdMMsgHdr message, BsdSocketFlags flags, TimeVal timeout);
LinuxError SendMMsg(out int vlen, BsdMMsgHdr message, BsdSocketFlags flags);
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();
}
}

153
src/Ryujinx.HLE/HOS/Services/Sockets/Bsd/Impl/EventFileDescriptor.cs Normal file
View File

@@ -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;
}
}
}
}

122
src/Ryujinx.HLE/HOS/Services/Sockets/Bsd/Impl/EventFileDescriptorPollManager.cs Normal file
View File

@@ -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;
}
}
}

530
src/Ryujinx.HLE/HOS/Services/Sockets/Bsd/Impl/ManagedSocket.cs Normal file
View File

@@ -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);
}
}
}
}

177
src/Ryujinx.HLE/HOS/Services/Sockets/Bsd/Impl/ManagedSocketPollManager.cs Normal file
View File

@@ -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;
}
}
}

134
src/Ryujinx.HLE/HOS/Services/Sockets/Bsd/Impl/WSAError.cs Normal file
View File

@@ -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)
}
}

225
src/Ryujinx.HLE/HOS/Services/Sockets/Bsd/Impl/WinSockHelper.cs Normal file
View File

@@ -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);
}
}
}

8
src/Ryujinx.HLE/HOS/Services/Sockets/Bsd/ServerInterface.cs Normal file
View File

@@ -0,0 +1,8 @@
namespace Ryujinx.HLE.HOS.Services.Sockets.Bsd
{
[Service("bsdcfg")]
class ServerInterface : IpcService
{
public ServerInterface(ServiceCtx context) { }
}
}

11
src/Ryujinx.HLE/HOS/Services/Sockets/Bsd/Types/BsdAddressFamily.cs Normal file
View File

@@ -0,0 +1,11 @@
namespace Ryujinx.HLE.HOS.Services.Sockets.Bsd.Types
{
enum BsdAddressFamily : uint
{
Unspecified,
InterNetwork = 2,
InterNetworkV6 = 28,
Unknown = uint.MaxValue
}
}

7
src/Ryujinx.HLE/HOS/Services/Sockets/Bsd/Types/BsdIoctl.cs Normal file
View File

@@ -0,0 +1,7 @@
namespace Ryujinx.HLE.HOS.Services.Sockets.Bsd.Types
{
enum BsdIoctl
{
AtMark = 0x40047307
}
}

56
src/Ryujinx.HLE/HOS/Services/Sockets/Bsd/Types/BsdMMsgHdr.cs Normal file
View File

@@ -0,0 +1,56 @@
using System;
namespace Ryujinx.HLE.HOS.Services.Sockets.Bsd.Types
{
class BsdMMsgHdr
{
public BsdMsgHdr[] Messages { get; }
private BsdMMsgHdr(BsdMsgHdr[] messages)
{
Messages = messages;
}
public static LinuxError Serialize(Span<byte> rawData, BsdMMsgHdr message)
{
rawData[0] = 0x8;
rawData = rawData[1..];
for (int index = 0; index < message.Messages.Length; index++)
{
LinuxError res = BsdMsgHdr.Serialize(ref rawData, message.Messages[index]);
if (res != LinuxError.SUCCESS)
{
return res;
}
}
return LinuxError.SUCCESS;
}
public static LinuxError Deserialize(out BsdMMsgHdr message, ReadOnlySpan<byte> rawData, int vlen)
{
message = null;
BsdMsgHdr[] messages = new BsdMsgHdr[vlen];
// Skip "header" byte (Nintendo also ignore it)
rawData = rawData[1..];
for (int index = 0; index < messages.Length; index++)
{
LinuxError res = BsdMsgHdr.Deserialize(out messages[index], ref rawData);
if (res != LinuxError.SUCCESS)
{
return res;
}
}
message = new BsdMMsgHdr(messages);
return LinuxError.SUCCESS;
}
}
}

212
src/Ryujinx.HLE/HOS/Services/Sockets/Bsd/Types/BsdMsgHdr.cs Normal file
View File

@@ -0,0 +1,212 @@
using System;
using System.Runtime.InteropServices;
namespace Ryujinx.HLE.HOS.Services.Sockets.Bsd.Types
{
class BsdMsgHdr
{
public byte[] Name { get; }
public byte[][] Iov { get; }
public byte[] Control { get; }
public BsdSocketFlags Flags { get; }
public uint Length;
private BsdMsgHdr(byte[] name, byte[][] iov, byte[] control, BsdSocketFlags flags, uint length)
{
Name = name;
Iov = iov;
Control = control;
Flags = flags;
Length = length;
}
public static LinuxError Serialize(ref Span<byte> rawData, BsdMsgHdr message)
{
int msgNameLength = message.Name == null ? 0 : message.Name.Length;
int iovCount = message.Iov == null ? 0 : message.Iov.Length;
int controlLength = message.Control == null ? 0 : message.Control.Length;
BsdSocketFlags flags = message.Flags;
if (!MemoryMarshal.TryWrite(rawData, ref msgNameLength))
{
return LinuxError.EFAULT;
}
rawData = rawData[sizeof(uint)..];
if (msgNameLength > 0)
{
if (rawData.Length < msgNameLength)
{
return LinuxError.EFAULT;
}
message.Name.CopyTo(rawData);
rawData = rawData[msgNameLength..];
}
if (!MemoryMarshal.TryWrite(rawData, ref iovCount))
{
return LinuxError.EFAULT;
}
rawData = rawData[sizeof(uint)..];
if (iovCount > 0)
{
for (int index = 0; index < iovCount; index++)
{
ulong iovLength = (ulong)message.Iov[index].Length;
if (!MemoryMarshal.TryWrite(rawData, ref iovLength))
{
return LinuxError.EFAULT;
}
rawData = rawData[sizeof(ulong)..];
if (iovLength > 0)
{
if ((ulong)rawData.Length < iovLength)
{
return LinuxError.EFAULT;
}
message.Iov[index].CopyTo(rawData);
rawData = rawData[(int)iovLength..];
}
}
}
if (!MemoryMarshal.TryWrite(rawData, ref controlLength))
{
return LinuxError.EFAULT;
}
rawData = rawData[sizeof(uint)..];
if (controlLength > 0)
{
if (rawData.Length < controlLength)
{
return LinuxError.EFAULT;
}
message.Control.CopyTo(rawData);
rawData = rawData[controlLength..];
}
if (!MemoryMarshal.TryWrite(rawData, ref flags))
{
return LinuxError.EFAULT;
}
rawData = rawData[sizeof(BsdSocketFlags)..];
if (!MemoryMarshal.TryWrite(rawData, ref message.Length))
{
return LinuxError.EFAULT;
}
rawData = rawData[sizeof(uint)..];
return LinuxError.SUCCESS;
}
public static LinuxError Deserialize(out BsdMsgHdr message, ref ReadOnlySpan<byte> rawData)
{
byte[] name = null;
byte[][] iov = null;
byte[] control = null;
message = null;
if (!MemoryMarshal.TryRead(rawData, out uint msgNameLength))
{
return LinuxError.EFAULT;
}
rawData = rawData[sizeof(uint)..];
if (msgNameLength > 0)
{
if (rawData.Length < msgNameLength)
{
return LinuxError.EFAULT;
}
name = rawData[..(int)msgNameLength].ToArray();
rawData = rawData[(int)msgNameLength..];
}
if (!MemoryMarshal.TryRead(rawData, out uint iovCount))
{
return LinuxError.EFAULT;
}
rawData = rawData[sizeof(uint)..];
if (iovCount > 0)
{
iov = new byte[iovCount][];
for (int index = 0; index < iov.Length; index++)
{
if (!MemoryMarshal.TryRead(rawData, out ulong iovLength))
{
return LinuxError.EFAULT;
}
rawData = rawData[sizeof(ulong)..];
if (iovLength > 0)
{
if ((ulong)rawData.Length < iovLength)
{
return LinuxError.EFAULT;
}
iov[index] = rawData[..(int)iovLength].ToArray();
rawData = rawData[(int)iovLength..];
}
}
}
if (!MemoryMarshal.TryRead(rawData, out uint controlLength))
{
return LinuxError.EFAULT;
}
rawData = rawData[sizeof(uint)..];
if (controlLength > 0)
{
if (rawData.Length < controlLength)
{
return LinuxError.EFAULT;
}
control = rawData[..(int)controlLength].ToArray();
rawData = rawData[(int)controlLength..];
}
if (!MemoryMarshal.TryRead(rawData, out BsdSocketFlags flags))
{
return LinuxError.EFAULT;
}
rawData = rawData[sizeof(BsdSocketFlags)..];
if (!MemoryMarshal.TryRead(rawData, out uint length))
{
return LinuxError.EFAULT;
}
rawData = rawData[sizeof(uint)..];
message = new BsdMsgHdr(name, iov, control, flags, length);
return LinuxError.SUCCESS;
}
}
}

39
src/Ryujinx.HLE/HOS/Services/Sockets/Bsd/Types/BsdSockAddr.cs Normal file
View File

@@ -0,0 +1,39 @@
using Ryujinx.Common.Memory;
using System;
using System.Net;
using System.Runtime.InteropServices;
namespace Ryujinx.HLE.HOS.Services.Sockets.Bsd.Types
{
[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.AsSpan());
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.AsSpan());
return result;
}
}
}

14
src/Ryujinx.HLE/HOS/Services/Sockets/Bsd/Types/BsdSocketCreationFlags.cs Normal file
View File

@@ -0,0 +1,14 @@
using System;
namespace Ryujinx.HLE.HOS.Services.Sockets.Bsd.Types
{
[Flags]
enum BsdSocketCreationFlags
{
None = 0,
CloseOnExecution = 1,
NonBlocking = 2,
FlagsShift = 28
}
}

22
src/Ryujinx.HLE/HOS/Services/Sockets/Bsd/Types/BsdSocketFlags.cs Normal file
View File

@@ -0,0 +1,22 @@
namespace Ryujinx.HLE.HOS.Services.Sockets.Bsd.Types
{
enum BsdSocketFlags
{
None = 0,
Oob = 0x1,
Peek = 0x2,
DontRoute = 0x4,
Eor = 0x8,
Trunc = 0x10,
CTrunc = 0x20,
WaitAll = 0x40,
DontWait = 0x80,
Eof = 0x100,
Notification = 0x2000,
Nbio = 0x4000,
Compat = 0x8000,
SoCallbck = 0x10000,
NoSignal = 0x20000,
CMsgCloExec = 0x40000
}
}

119
src/Ryujinx.HLE/HOS/Services/Sockets/Bsd/Types/BsdSocketOption.cs Normal file
View File

@@ -0,0 +1,119 @@
namespace Ryujinx.HLE.HOS.Services.Sockets.Bsd.Types
{
enum BsdSocketOption
{
SoDebug = 0x1,
SoAcceptConn = 0x2,
SoReuseAddr = 0x4,
SoKeepAlive = 0x8,
SoDontRoute = 0x10,
SoBroadcast = 0x20,
SoUseLoopBack = 0x40,
SoLinger = 0x80,
SoOobInline = 0x100,
SoReusePort = 0x200,
SoTimestamp = 0x400,
SoNoSigpipe = 0x800,
SoAcceptFilter = 0x1000,
SoBinTime = 0x2000,
SoNoOffload = 0x4000,
SoNoDdp = 0x8000,
SoReusePortLb = 0x10000,
SoRError = 0x20000,
SoSndBuf = 0x1001,
SoRcvBuf = 0x1002,
SoSndLoWat = 0x1003,
SoRcvLoWat = 0x1004,
SoSndTimeo = 0x1005,
SoRcvTimeo = 0x1006,
SoError = 0x1007,
SoType = 0x1008,
SoLabel = 0x1009,
SoPeerLabel = 0x1010,
SoListenQLimit = 0x1011,
SoListenQLen = 0x1012,
SoListenIncQLen = 0x1013,
SoSetFib = 0x1014,
SoUserCookie = 0x1015,
SoProtocol = 0x1016,
SoTsClock = 0x1017,
SoMaxPacingRate = 0x1018,
SoDomain = 0x1019,
IpOptions = 1,
IpHdrIncl = 2,
IpTos = 3,
IpTtl = 4,
IpRecvOpts = 5,
IpRecvRetOpts = 6,
IpRecvDstAddr = 7,
IpRetOpts = 8,
IpMulticastIf = 9,
IpMulticastTtl = 10,
IpMulticastLoop = 11,
IpAddMembership = 12,
IpDropMembership = 13,
IpMulticastVif = 14,
IpRsvpOn = 15,
IpRsvpOff = 16,
IpRsvpVifOn = 17,
IpRsvpVifOff = 18,
IpPortRange = 19,
IpRecvIf = 20,
IpIpsecPolicy = 21,
IpOnesBcast = 23,
IpBindany = 24,
IpBindMulti = 25,
IpRssListenBucket = 26,
IpOrigDstAddr = 27,
IpFwTableAdd = 40,
IpFwTableDel = 41,
IpFwTableFlush = 42,
IpFwTableGetSize = 43,
IpFwTableList = 44,
IpFw3 = 48,
IpDummyNet3 = 49,
IpFwAdd = 50,
IpFwDel = 51,
IpFwFlush = 52,
IpFwZero = 53,
IpFwGet = 54,
IpFwResetLog = 55,
IpFwNatCfg = 56,
IpFwNatDel = 57,
IpFwNatGetConfig = 58,
IpFwNatGetLog = 59,
IpDummyNetConfigure = 60,
IpDummyNetDel = 61,
IpDummyNetFlush = 62,
IpDummyNetGet = 64,
IpRecvTtl = 65,
IpMinTtl = 66,
IpDontFrag = 67,
IpRecvTos = 68,
IpAddSourceMembership = 70,
IpDropSourceMembership = 71,
IpBlockSource = 72,
IpUnblockSource = 73,
TcpNoDelay = 1,
TcpMaxSeg = 2,
TcpNoPush = 4,
TcpNoOpt = 8,
TcpMd5Sig = 16,
TcpInfo = 32,
TcpCongestion = 64,
TcpKeepInit = 128,
TcpKeepIdle = 256,
TcpKeepIntvl = 512,
TcpKeepCnt = 1024
}
}

9
src/Ryujinx.HLE/HOS/Services/Sockets/Bsd/Types/BsdSocketShutdownFlags.cs Normal file
View File

@@ -0,0 +1,9 @@
namespace Ryujinx.HLE.HOS.Services.Sockets.Bsd.Types
{
enum BsdSocketShutdownFlags
{
Receive,
Send,
ReceiveAndSend
}
}

13
src/Ryujinx.HLE/HOS/Services/Sockets/Bsd/Types/BsdSocketType.cs Normal file
View File

@@ -0,0 +1,13 @@
namespace Ryujinx.HLE.HOS.Services.Sockets.Bsd.Types
{
enum BsdSocketType
{
Stream = 1,
Dgram,
Raw,
Rdm,
Seqpacket,
TypeMask = 0xFFFFFFF,
}
}

12
src/Ryujinx.HLE/HOS/Services/Sockets/Bsd/Types/EventFdFlags.cs Normal file
View File

@@ -0,0 +1,12 @@
using System;
namespace Ryujinx.HLE.HOS.Services.Sockets.Bsd.Types
{
[Flags]
enum EventFdFlags : uint
{
None = 0,
Semaphore = 1 << 0,
NonBlocking = 1 << 2
}
}

13
src/Ryujinx.HLE/HOS/Services/Sockets/Bsd/Types/IPollManager.cs Normal file
View File

@@ -0,0 +1,13 @@
using System.Collections.Generic;
namespace Ryujinx.HLE.HOS.Services.Sockets.Bsd.Types
{
interface IPollManager
{
bool IsCompatible(PollEvent evnt);
LinuxError Poll(List<PollEvent> events, int timeoutMilliseconds, out int updatedCount);
LinuxError Select(List<PollEvent> events, int timeout, out int updatedCount);
}
}

155
src/Ryujinx.HLE/HOS/Services/Sockets/Bsd/Types/LinuxError.cs Normal file
View File

@@ -0,0 +1,155 @@
using System.Diagnostics.CodeAnalysis;
namespace Ryujinx.HLE.HOS.Services.Sockets.Bsd.Types
{
[SuppressMessage("ReSharper", "InconsistentNaming")]
enum LinuxError
{
SUCCESS = 0,
EPERM = 1 /* Operation not permitted */,
ENOENT = 2 /* No such file or directory */,
ESRCH = 3 /* No such process */,
EINTR = 4 /* Interrupted system call */,
EIO = 5 /* I/O error */,
ENXIO = 6 /* No such device or address */,
E2BIG = 7 /* Argument list too long */,
ENOEXEC = 8 /* Exec format error */,
EBADF = 9 /* Bad file number */,
ECHILD = 10 /* No child processes */,
EAGAIN = 11 /* Try again */,
ENOMEM = 12 /* Out of memory */,
EACCES = 13 /* Permission denied */,
EFAULT = 14 /* Bad address */,
ENOTBLK = 15 /* Block device required */,
EBUSY = 16 /* Device or resource busy */,
EEXIST = 17 /* File exists */,
EXDEV = 18 /* Cross-device link */,
ENODEV = 19 /* No such device */,
ENOTDIR = 20 /* Not a directory */,
EISDIR = 21 /* Is a directory */,
EINVAL = 22 /* Invalid argument */,
ENFILE = 23 /* File table overflow */,
EMFILE = 24 /* Too many open files */,
ENOTTY = 25 /* Not a typewriter */,
ETXTBSY = 26 /* Text file busy */,
EFBIG = 27 /* File too large */,
ENOSPC = 28 /* No space left on device */,
ESPIPE = 29 /* Illegal seek */,
EROFS = 30 /* Read-only file system */,
EMLINK = 31 /* Too many links */,
EPIPE = 32 /* Broken pipe */,
EDOM = 33 /* Math argument out of domain of func */,
ERANGE = 34 /* Math result not representable */,
EDEADLK = 35 /* Resource deadlock would occur */,
ENAMETOOLONG = 36 /* File name too long */,
ENOLCK = 37 /* No record locks available */,
/*
* This error code is special: arch syscall entry code will return
* -ENOSYS if users try to call a syscall that doesn't exist. To keep
* failures of syscalls that really do exist distinguishable from
* failures due to attempts to use a nonexistent syscall, syscall
* implementations should refrain from returning -ENOSYS.
*/
ENOSYS = 38 /* Invalid system call number */,
ENOTEMPTY = 39 /* Directory not empty */,
ELOOP = 40 /* Too many symbolic links encountered */,
EWOULDBLOCK = EAGAIN /* Operation would block */,
ENOMSG = 42 /* No message of desired type */,
EIDRM = 43 /* Identifier removed */,
ECHRNG = 44 /* Channel number out of range */,
EL2NSYNC = 45 /* Level 2 not synchronized */,
EL3HLT = 46 /* Level 3 halted */,
EL3RST = 47 /* Level 3 reset */,
ELNRNG = 48 /* Link number out of range */,
EUNATCH = 49 /* Protocol driver not attached */,
ENOCSI = 50 /* No CSI structure available */,
EL2HLT = 51 /* Level 2 halted */,
EBADE = 52 /* Invalid exchange */,
EBADR = 53 /* Invalid request descriptor */,
EXFULL = 54 /* Exchange full */,
ENOANO = 55 /* No anode */,
EBADRQC = 56 /* Invalid request code */,
EBADSLT = 57 /* Invalid slot */,
EDEADLOCK = EDEADLK,
EBFONT = 59 /* Bad font file format */,
ENOSTR = 60 /* Device not a stream */,
ENODATA = 61 /* No data available */,
ETIME = 62 /* Timer expired */,
ENOSR = 63 /* Out of streams resources */,
ENONET = 64 /* Machine is not on the network */,
ENOPKG = 65 /* Package not installed */,
EREMOTE = 66 /* Object is remote */,
ENOLINK = 67 /* Link has been severed */,
EADV = 68 /* Advertise error */,
ESRMNT = 69 /* Srmount error */,
ECOMM = 70 /* Communication error on send */,
EPROTO = 71 /* Protocol error */,
EMULTIHOP = 72 /* Multihop attempted */,
EDOTDOT = 73 /* RFS specific error */,
EBADMSG = 74 /* Not a data message */,
EOVERFLOW = 75 /* Value too large for defined data type */,
ENOTUNIQ = 76 /* Name not unique on network */,
EBADFD = 77 /* File descriptor in bad state */,
EREMCHG = 78 /* Remote address changed */,
ELIBACC = 79 /* Can not access a needed shared library */,
ELIBBAD = 80 /* Accessing a corrupted shared library */,
ELIBSCN = 81 /* .lib section in a.out corrupted */,
ELIBMAX = 82 /* Attempting to link in too many shared libraries */,
ELIBEXEC = 83 /* Cannot exec a shared library directly */,
EILSEQ = 84 /* Illegal byte sequence */,
ERESTART = 85 /* Interrupted system call should be restarted */,
ESTRPIPE = 86 /* Streams pipe error */,
EUSERS = 87 /* Too many users */,
ENOTSOCK = 88 /* Socket operation on non-socket */,
EDESTADDRREQ = 89 /* Destination address required */,
EMSGSIZE = 90 /* Message too long */,
EPROTOTYPE = 91 /* Protocol wrong type for socket */,
ENOPROTOOPT = 92 /* Protocol not available */,
EPROTONOSUPPORT = 93 /* Protocol not supported */,
ESOCKTNOSUPPORT = 94 /* Socket type not supported */,
EOPNOTSUPP = 95 /* Operation not supported on transport endpoint */,
EPFNOSUPPORT = 96 /* Protocol family not supported */,
EAFNOSUPPORT = 97 /* Address family not supported by protocol */,
EADDRINUSE = 98 /* Address already in use */,
EADDRNOTAVAIL = 99 /* Cannot assign requested address */,
ENETDOWN = 100 /* Network is down */,
ENETUNREACH = 101 /* Network is unreachable */,
ENETRESET = 102 /* Network dropped connection because of reset */,
ECONNABORTED = 103 /* Software caused connection abort */,
ECONNRESET = 104 /* Connection reset by peer */,
ENOBUFS = 105 /* No buffer space available */,
EISCONN = 106 /* Transport endpoint is already connected */,
ENOTCONN = 107 /* Transport endpoint is not connected */,
ESHUTDOWN = 108 /* Cannot send after transport endpoint shutdown */,
ETOOMANYREFS = 109 /* Too many references: cannot splice */,
ETIMEDOUT = 110 /* Connection timed out */,
ECONNREFUSED = 111 /* Connection refused */,
EHOSTDOWN = 112 /* Host is down */,
EHOSTUNREACH = 113 /* No route to host */,
EALREADY = 114 /* Operation already in progress */,
EINPROGRESS = 115 /* Operation now in progress */,
ESTALE = 116 /* Stale file handle */,
EUCLEAN = 117 /* Structure needs cleaning */,
ENOTNAM = 118 /* Not a XENIX named type file */,
ENAVAIL = 119 /* No XENIX semaphores available */,
EISNAM = 120 /* Is a named type file */,
EREMOTEIO = 121 /* Remote I/O error */,
EDQUOT = 122 /* Quota exceeded */,
ENOMEDIUM = 123 /* No medium found */,
EMEDIUMTYPE = 124 /* Wrong medium type */,
ECANCELED = 125 /* Operation Canceled */,
ENOKEY = 126 /* Required key not available */,
EKEYEXPIRED = 127 /* Key has expired */,
EKEYREVOKED = 128 /* Key has been revoked */,
EKEYREJECTED = 129 /* Key was rejected by service */,
/* for robust mutexes */
EOWNERDEAD = 130 /* Owner died */,
ENOTRECOVERABLE = 131 /* State not recoverable */,
ERFKILL = 132 /* Operation not possible due to RF-kill */,
EHWPOISON = 133 /* Memory page has hardware error */
}
}

14
src/Ryujinx.HLE/HOS/Services/Sockets/Bsd/Types/PollEvent.cs Normal file
View File

@@ -0,0 +1,14 @@
namespace Ryujinx.HLE.HOS.Services.Sockets.Bsd.Types
{
class PollEvent
{
public PollEventData Data;
public IFileDescriptor FileDescriptor { get; }
public PollEvent(PollEventData data, IFileDescriptor fileDescriptor)
{
Data = data;
FileDescriptor = fileDescriptor;
}
}
}

11
src/Ryujinx.HLE/HOS/Services/Sockets/Bsd/Types/PollEventData.cs Normal file
View File

@@ -0,0 +1,11 @@
namespace Ryujinx.HLE.HOS.Services.Sockets.Bsd.Types
{
struct PollEventData
{
#pragma warning disable CS0649
public int SocketFd;
public PollEventTypeMask InputEvents;
#pragma warning restore CS0649
public PollEventTypeMask OutputEvents;
}
}

15
src/Ryujinx.HLE/HOS/Services/Sockets/Bsd/Types/PollEventTypeMask.cs Normal file
View File

@@ -0,0 +1,15 @@
using System;
namespace Ryujinx.HLE.HOS.Services.Sockets.Bsd.Types
{
[Flags]
enum PollEventTypeMask : ushort
{
Input = 1,
UrgentInput = 2,
Output = 4,
Error = 8,
Disconnected = 0x10,
Invalid = 0x20
}
}

8
src/Ryujinx.HLE/HOS/Services/Sockets/Bsd/Types/TimeVal.cs Normal file
View File

@@ -0,0 +1,8 @@
namespace Ryujinx.HLE.HOS.Services.Sockets.Bsd.Types
{
public struct TimeVal
{
public ulong TvSec;
public ulong TvUsec;
}
}