vleeuwenmenno/Ryujinx
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Refactoring HOS folder structure (#771)

Browse Source 
* Refactoring HOS folder structure

Refactoring HOS folder structure:

- Added some subfolders when needed (Following structure decided in private).
- Added some `Types` folders when needed.
- Little cleanup here and there.
- Add services placeholders for every HOS services (close #766 and #753).

* Remove Types namespaces
This commit is contained in:
Ac_K
2019-09-19 02:45:11 +02:00
committed by jduncanator
parent 4af3101b22
commit a0720b5681
393 changed files with 2540 additions and 1299 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

File diff suppressed because it is too large Load Diff

8
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) { }
}
}

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

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

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

@ -0,0 +1,13 @@
using System.Net.Sockets;
namespace Ryujinx.HLE.HOS.Services.Sockets.Bsd
{
class BsdSocket
{
public int Family;
public int Type;
public int Protocol;
public Socket Handle;
}
}

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

@ -0,0 +1,28 @@
namespace Ryujinx.HLE.HOS.Services.Sockets.Bsd
{
class PollEvent
{
public enum EventTypeMask
{
Input = 1,
UrgentInput = 2,
Output = 4,
Error = 8,
Disconnected = 0x10,
Invalid = 0x20
}
public int SocketFd { get; private set; }
public BsdSocket Socket { get; private set; }
public EventTypeMask InputEvents { get; private set; }
public EventTypeMask OutputEvents { get; private set; }
public PollEvent(int socketFd, BsdSocket socket, EventTypeMask inputEvents, EventTypeMask outputEvents)
{
SocketFd = socketFd;
Socket = socket;
InputEvents = inputEvents;
OutputEvents = outputEvents;
}
}
}

8
Ryujinx.HLE/HOS/Services/Sockets/Ethc/IEthInterface.cs Normal file
View File

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

8
Ryujinx.HLE/HOS/Services/Sockets/Ethc/IEthInterfaceGroup.cs Normal file
View File

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

268
Ryujinx.HLE/HOS/Services/Sockets/Nsd/IManager.cs Normal file
View File

@ -0,0 +1,268 @@
using Ryujinx.Common.Logging;
using Ryujinx.HLE.Exceptions;
using Ryujinx.HLE.HOS.Services.Settings;
using Ryujinx.HLE.HOS.Services.Sockets.Nsd.Manager;
using System.Text;
namespace Ryujinx.HLE.HOS.Services.Sockets.Nsd
{
[Service("nsd:a")] // Max sessions: 5
[Service("nsd:u")] // Max sessions: 20
class IManager : IpcService
{
private NsdSettings _nsdSettings;
private FqdnResolver _fqdnResolver;
private bool _isInitialized = false;
public IManager(ServiceCtx context)
{
// TODO: Load nsd settings through the savedata 0x80000000000000B0 (nsdsave:/).
NxSettings.Settings.TryGetValue("nsd!test_mode", out object testMode);
_nsdSettings = new NsdSettings
{
Initialized = true,
TestMode = (bool)testMode
};
_fqdnResolver = new FqdnResolver(_nsdSettings);
_isInitialized = true;
}
[Command(10)]
// GetSettingName() -> buffer<unknown<0x100>, 0x16>
public ResultCode GetSettingName(ServiceCtx context)
{
(long outputPosition, long outputSize) = context.Request.GetBufferType0x22();
ResultCode result = _fqdnResolver.GetSettingName(context, out string settingName);
if (result == ResultCode.Success)
{
byte[] settingNameBuffer = Encoding.UTF8.GetBytes(settingName + '\0');
context.Memory.WriteBytes(outputPosition, settingNameBuffer);
}
return result;
}
[Command(11)]
// GetEnvironmentIdentifier() -> buffer<unknown<8>, 0x16>
public ResultCode GetEnvironmentIdentifier(ServiceCtx context)
{
(long outputPosition, long outputSize) = context.Request.GetBufferType0x22();
ResultCode result = _fqdnResolver.GetEnvironmentIdentifier(context, out string identifier);
if (result == ResultCode.Success)
{
byte[] identifierBuffer = Encoding.UTF8.GetBytes(identifier + '\0');
context.Memory.WriteBytes(outputPosition, identifierBuffer);
}
return result;
}
[Command(12)]
// GetDeviceId() -> bytes<0x10, 1>
public ResultCode GetDeviceId(ServiceCtx context)
{
// NOTE: Stubbed in system module.
return ResultCode.Success;
}
[Command(13)]
// DeleteSettings(u32)
public ResultCode DeleteSettings(ServiceCtx context)
{
uint unknown = context.RequestData.ReadUInt32();
if (!_isInitialized)
{
return ResultCode.ServiceNotInitialized;
}
if (unknown > 1)
{
return ResultCode.InvalidArgument;
}
if (unknown == 1)
{
NxSettings.Settings.TryGetValue("nsd!environment_identifier", out object environmentIdentifier);
if ((string)environmentIdentifier == _nsdSettings.Environment)
{
// TODO: Call nn::fs::DeleteSystemFile() to delete the savedata file and return ResultCode.
}
else
{
// TODO: Mount the savedata file and return ResultCode.
}
}
else
{
// TODO: Call nn::fs::DeleteSystemFile() to delete the savedata file and return ResultCode.
}
return ResultCode.Success;
}
[Command(14)]
// ImportSettings(u32, buffer<unknown, 5>) -> buffer<unknown, 6>
public ResultCode ImportSettings(ServiceCtx context)
{
throw new ServiceNotImplementedException(context);
}
[Command(15)]
// Unknown(bytes<1>)
public ResultCode Unknown(ServiceCtx context)
{
throw new ServiceNotImplementedException(context);
}
[Command(20)]
// Resolve(buffer<unknown<0x100>, 0x15>) -> buffer<unknown<0x100>, 0x16>
public ResultCode Resolve(ServiceCtx context)
{
(long outputPosition, long outputSize) = context.Request.GetBufferType0x22();
ResultCode result = _fqdnResolver.ResolveEx(context, out ResultCode errorCode, out string resolvedAddress);
byte[] resolvedAddressBuffer = Encoding.UTF8.GetBytes(resolvedAddress + '\0');
context.Memory.WriteBytes(outputPosition, resolvedAddressBuffer);
return result;
}
[Command(21)]
// ResolveEx(buffer<unknown<0x100>, 0x15>) -> (u32, buffer<unknown<0x100>, 0x16>)
public ResultCode ResolveEx(ServiceCtx context)
{
(long outputPosition, long outputSize) = context.Request.GetBufferType0x22();
ResultCode result = _fqdnResolver.ResolveEx(context, out ResultCode errorCode, out string resolvedAddress);
byte[] resolvedAddressBuffer = Encoding.UTF8.GetBytes(resolvedAddress + '\0');
context.Memory.WriteBytes(outputPosition, resolvedAddressBuffer);
context.ResponseData.Write((int)errorCode);
return result;
}
[Command(30)]
// GetNasServiceSetting(buffer<unknown<0x10>, 0x15>) -> buffer<unknown<0x108>, 0x16>
public ResultCode GetNasServiceSetting(ServiceCtx context)
{
throw new ServiceNotImplementedException(context);
}
[Command(31)]
// GetNasServiceSettingEx(buffer<unknown<0x10>, 0x15>) -> (u32, buffer<unknown<0x108>, 0x16>)
public ResultCode GetNasServiceSettingEx(ServiceCtx context)
{
throw new ServiceNotImplementedException(context);
}
[Command(40)]
// GetNasRequestFqdn() -> buffer<unknown<0x100>, 0x16>
public ResultCode GetNasRequestFqdn(ServiceCtx context)
{
throw new ServiceNotImplementedException(context);
}
[Command(41)]
// GetNasRequestFqdnEx() -> (u32, buffer<unknown<0x100>, 0x16>)
public ResultCode GetNasRequestFqdnEx(ServiceCtx context)
{
throw new ServiceNotImplementedException(context);
}
[Command(42)]
// GetNasApiFqdn() -> buffer<unknown<0x100>, 0x16>
public ResultCode GetNasApiFqdn(ServiceCtx context)
{
throw new ServiceNotImplementedException(context);
}
[Command(43)]
// GetNasApiFqdnEx() -> (u32, buffer<unknown<0x100>, 0x16>)
public ResultCode GetNasApiFqdnEx(ServiceCtx context)
{
throw new ServiceNotImplementedException(context);
}
[Command(50)]
// GetCurrentSetting() -> buffer<unknown<0x12bf0>, 0x16>
public ResultCode GetCurrentSetting(ServiceCtx context)
{
throw new ServiceNotImplementedException(context);
}
[Command(60)]
// ReadSaveDataFromFsForTest() -> buffer<unknown<0x12bf0>, 0x16>
public ResultCode ReadSaveDataFromFsForTest(ServiceCtx context)
{
if (!_isInitialized)
{
return ResultCode.ServiceNotInitialized;
}
// TODO: Call nn::nsd::detail::fs::ReadSaveDataWithOffset() at offset 0 to write the
// whole savedata inside the buffer.
Logger.PrintStub(LogClass.ServiceNsd);
return ResultCode.Success;
}
[Command(61)]
// WriteSaveDataToFsForTest(buffer<unknown<0x12bf0>, 0x15>)
public ResultCode WriteSaveDataToFsForTest(ServiceCtx context)
{
// NOTE: Stubbed in system module.
if (_isInitialized)
{
return ResultCode.NotImplemented;
}
else
{
return ResultCode.ServiceNotInitialized;
}
}
[Command(62)]
// DeleteSaveDataOfFsForTest()
public ResultCode DeleteSaveDataOfFsForTest(ServiceCtx context)
{
// NOTE: Stubbed in system module.
if (_isInitialized)
{
return ResultCode.NotImplemented;
}
else
{
return ResultCode.ServiceNotInitialized;
}
}
[Command(63)]
// IsChangeEnvironmentIdentifierDisabled() -> bytes<1>
public ResultCode IsChangeEnvironmentIdentifierDisabled(ServiceCtx context)
{
throw new ServiceNotImplementedException(context);
}
}
}

131
Ryujinx.HLE/HOS/Services/Sockets/Nsd/Manager/FqdnResolver.cs Normal file
View File

@ -0,0 +1,131 @@
using System.Text;
namespace Ryujinx.HLE.HOS.Services.Sockets.Nsd.Manager
{
class FqdnResolver
{
private const string _dummyAddress = "unknown.dummy.nintendo.net";
private NsdSettings _nsdSettings;
public FqdnResolver(NsdSettings nsdSettings)
{
_nsdSettings = nsdSettings;
}
public ResultCode GetSettingName(ServiceCtx context, out string settingName)
{
if (_nsdSettings.TestMode)
{
settingName = "";
return ResultCode.NotImplemented;
}
else
{
settingName = "";
if (true) // TODO: Determine field (struct + 0x2C)
{
settingName = _nsdSettings.Environment;
return ResultCode.Success;
}
return ResultCode.NullOutputObject;
}
}
public ResultCode GetEnvironmentIdentifier(ServiceCtx context, out string identifier)
{
if (_nsdSettings.TestMode)
{
identifier = "rre";
return ResultCode.NotImplemented;
}
else
{
identifier = _nsdSettings.Environment;
}
return ResultCode.Success;
}
public ResultCode Resolve(ServiceCtx context, string address, out string resolvedAddress)
{
if (address != "api.sect.srv.nintendo.net" || address != "conntest.nintendowifi.net")
{
// TODO: Load Environment from the savedata.
address = address.Replace("%", _nsdSettings.Environment);
resolvedAddress = "";
if (_nsdSettings == null)
{
return ResultCode.SettingsNotInitialized;
}
if (!_nsdSettings.Initialized)
{
return ResultCode.SettingsNotLoaded;
}
switch (address)
{
case "e97b8a9d672e4ce4845ec6947cd66ef6-sb-api.accounts.nintendo.com": // dp1 environment
resolvedAddress = "e97b8a9d672e4ce4845ec6947cd66ef6-sb.baas.nintendo.com";
break;
case "api.accounts.nintendo.com": // dp1 environment
resolvedAddress = "e0d67c509fb203858ebcb2fe3f88c2aa.baas.nintendo.com";
break;
case "e97b8a9d672e4ce4845ec6947cd66ef6-sb.accounts.nintendo.com": // lp1 environment
resolvedAddress = "e97b8a9d672e4ce4845ec6947cd66ef6-sb.baas.nintendo.com";
break;
case "accounts.nintendo.com": // lp1 environment
resolvedAddress = "e0d67c509fb203858ebcb2fe3f88c2aa.baas.nintendo.com";
break;
/*
// TODO: Determine fields of the struct.
case "": // + 0xEB8 || + 0x2BE8
resolvedAddress = ""; // + 0xEB8 + 0x300 || + 0x2BE8 + 0x300
break;
*/
default:
resolvedAddress = address;
break;
}
}
else
{
resolvedAddress = address;
}
return ResultCode.Success;
}
public ResultCode ResolveEx(ServiceCtx context, out ResultCode resultCode, out string resolvedAddress)
{
(long inputPosition, long inputSize) = context.Request.GetBufferType0x21();
byte[] addressBuffer = context.Memory.ReadBytes(inputPosition, inputSize);
string address = Encoding.UTF8.GetString(addressBuffer);
resultCode = Resolve(context, address, out resolvedAddress);
if (resultCode != ResultCode.Success)
{
resolvedAddress = _dummyAddress;
}
if (_nsdSettings.TestMode)
{
return ResultCode.Success;
}
else
{
return resultCode;
}
}
}
}

19
Ryujinx.HLE/HOS/Services/Sockets/Nsd/ResultCode.cs Normal file
View File

@ -0,0 +1,19 @@
namespace Ryujinx.HLE.HOS.Services.Sockets.Nsd
{
enum ResultCode
{
ModuleId = 141,
ErrorCodeShift = 9,
Success = 0,
NotImplemented = ( 1 << ErrorCodeShift) | ModuleId,
InvalidObject1 = ( 3 << ErrorCodeShift) | ModuleId,
InvalidObject2 = ( 4 << ErrorCodeShift) | ModuleId,
NullOutputObject = ( 5 << ErrorCodeShift) | ModuleId,
SettingsNotLoaded = ( 6 << ErrorCodeShift) | ModuleId,
InvalidArgument = ( 8 << ErrorCodeShift) | ModuleId,
SettingsNotInitialized = ( 10 << ErrorCodeShift) | ModuleId,
ServiceNotInitialized = (400 << ErrorCodeShift) | ModuleId,
}
}

9
Ryujinx.HLE/HOS/Services/Sockets/Nsd/Types/NsdSettings.cs Normal file
View File

@ -0,0 +1,9 @@
namespace Ryujinx.HLE.HOS.Services.Sockets.Nsd
{
class NsdSettings
{
public bool Initialized;
public bool TestMode;
public string Environment = "lp1"; // or "dd1" if devkit.
}
}

387
Ryujinx.HLE/HOS/Services/Sockets/Sfdnsres/IResolver.cs Normal file
View File

@ -0,0 +1,387 @@
using Ryujinx.Common.Logging;
using System;
using System.Collections.Generic;
using System.Net;
using System.Net.Sockets;
using System.Text;
namespace Ryujinx.HLE.HOS.Services.Sockets.Sfdnsres
{
[Service("sfdnsres")]
class IResolver : IpcService
{
public IResolver(ServiceCtx context) { }
private long SerializeHostEnt(ServiceCtx context, IPHostEntry hostEntry, List<IPAddress> addresses = null)
{
long originalBufferPosition = context.Request.ReceiveBuff[0].Position;
long bufferPosition = originalBufferPosition;
long bufferSize = context.Request.ReceiveBuff[0].Size;
string hostName = hostEntry.HostName + '\0';
// h_name
context.Memory.WriteBytes(bufferPosition, Encoding.ASCII.GetBytes(hostName));
bufferPosition += hostName.Length;
// h_aliases list size
context.Memory.WriteInt32(bufferPosition, IPAddress.HostToNetworkOrder(hostEntry.Aliases.Length));
bufferPosition += 4;
// Actual aliases
foreach (string alias in hostEntry.Aliases)
{
context.Memory.WriteBytes(bufferPosition, Encoding.ASCII.GetBytes(alias + '\0'));
bufferPosition += alias.Length + 1;
}
// h_addrtype but it's a short (also only support IPv4)
context.Memory.WriteInt16(bufferPosition, IPAddress.HostToNetworkOrder((short)2));
bufferPosition += 2;
// h_length but it's a short
context.Memory.WriteInt16(bufferPosition, IPAddress.HostToNetworkOrder((short)4));
bufferPosition += 2;
// Ip address count, we can only support ipv4 (blame Nintendo)
context.Memory.WriteInt32(bufferPosition, addresses != null ? IPAddress.HostToNetworkOrder(addresses.Count) : 0);
bufferPosition += 4;
if (addresses != null)
{
foreach (IPAddress ip in addresses)
{
context.Memory.WriteInt32(bufferPosition, IPAddress.HostToNetworkOrder(BitConverter.ToInt32(ip.GetAddressBytes(), 0)));
bufferPosition += 4;
}
}
return bufferPosition - originalBufferPosition;
}
private string GetGaiStringErrorFromErrorCode(GaiError errorCode)
{
if (errorCode > GaiError.Max)
{
errorCode = GaiError.Max;
}
switch (errorCode)
{
case GaiError.AddressFamily:
return "Address family for hostname not supported";
case GaiError.Again:
return "Temporary failure in name resolution";
case GaiError.BadFlags:
return "Invalid value for ai_flags";
case GaiError.Fail:
return "Non-recoverable failure in name resolution";
case GaiError.Family:
return "ai_family not supported";
case GaiError.Memory:
return "Memory allocation failure";
case GaiError.NoData:
return "No address associated with hostname";
case GaiError.NoName:
return "hostname nor servname provided, or not known";
case GaiError.Service:
return "servname not supported for ai_socktype";
case GaiError.SocketType:
return "ai_socktype not supported";
case GaiError.System:
return "System error returned in errno";
case GaiError.BadHints:
return "Invalid value for hints";
case GaiError.Protocol:
return "Resolved protocol is unknown";
case GaiError.Overflow:
return "Argument buffer overflow";
case GaiError.Max:
return "Unknown error";
default:
return "Success";
}
}
private string GetHostStringErrorFromErrorCode(NetDbError errorCode)
{
if (errorCode <= NetDbError.Internal)
{
return "Resolver internal error";
}
switch (errorCode)
{
case NetDbError.Success:
return "Resolver Error 0 (no error)";
case NetDbError.HostNotFound:
return "Unknown host";
case NetDbError.TryAgain:
return "Host name lookup failure";
case NetDbError.NoRecovery:
return "Unknown server error";
case NetDbError.NoData:
return "No address associated with name";
default:
return "Unknown resolver error";
}
}
private List<IPAddress> GetIpv4Addresses(IPHostEntry hostEntry)
{
List<IPAddress> result = new List<IPAddress>();
foreach (IPAddress ip in hostEntry.AddressList)
{
if (ip.AddressFamily == AddressFamily.InterNetwork)
result.Add(ip);
}
return result;
}
[Command(0)]
// SetDnsAddressesPrivate(u32, buffer<unknown, 5, 0>)
public ResultCode SetDnsAddressesPrivate(ServiceCtx context)
{
uint unknown0 = context.RequestData.ReadUInt32();
long bufferPosition = context.Request.SendBuff[0].Position;
long bufferSize = context.Request.SendBuff[0].Size;
// TODO: This is stubbed in 2.0.0+, reverse 1.0.0 version for the sake completeness.
Logger.PrintStub(LogClass.ServiceSfdnsres, new { unknown0 });
return ResultCode.NotAllocated;
}
[Command(1)]
// GetDnsAddressPrivate(u32) -> buffer<unknown, 6, 0>
public ResultCode GetDnsAddressesPrivate(ServiceCtx context)
{
uint unknown0 = context.RequestData.ReadUInt32();
// TODO: This is stubbed in 2.0.0+, reverse 1.0.0 version for the sake completeness.
Logger.PrintStub(LogClass.ServiceSfdnsres, new { unknown0 });
return ResultCode.NotAllocated;
}
[Command(2)]
// GetHostByName(u8, u32, u64, pid, buffer<unknown, 5, 0>) -> (u32, u32, u32, buffer<unknown, 6, 0>)
public ResultCode GetHostByName(ServiceCtx context)
{
byte[] rawName = context.Memory.ReadBytes(context.Request.SendBuff[0].Position, context.Request.SendBuff[0].Size);
string name = Encoding.ASCII.GetString(rawName).TrimEnd('\0');
// TODO: use params
bool enableNsdResolve = context.RequestData.ReadInt32() == 1;
int timeOut = context.RequestData.ReadInt32();
ulong pidPlaceholder = context.RequestData.ReadUInt64();
IPHostEntry hostEntry = null;
NetDbError netDbErrorCode = NetDbError.Success;
GaiError errno = GaiError.Overflow;
long serializedSize = 0;
if (name.Length <= 255)
{
try
{
hostEntry = Dns.GetHostEntry(name);
}
catch (SocketException exception)
{
netDbErrorCode = NetDbError.Internal;
if (exception.ErrorCode == 11001)
{
netDbErrorCode = NetDbError.HostNotFound;
errno = GaiError.NoData;
}
else if (exception.ErrorCode == 11002)
{
netDbErrorCode = NetDbError.TryAgain;
}
else if (exception.ErrorCode == 11003)
{
netDbErrorCode = NetDbError.NoRecovery;
}
else if (exception.ErrorCode == 11004)
{
netDbErrorCode = NetDbError.NoData;
}
else if (exception.ErrorCode == 10060)
{
errno = GaiError.Again;
}
}
}
else
{
netDbErrorCode = NetDbError.HostNotFound;
}
if (hostEntry != null)
{
errno = GaiError.Success;
List<IPAddress> addresses = GetIpv4Addresses(hostEntry);
if (addresses.Count == 0)
{
errno = GaiError.NoData;
netDbErrorCode = NetDbError.NoAddress;
}
else
{
serializedSize = SerializeHostEnt(context, hostEntry, addresses);
}
}
context.ResponseData.Write((int)netDbErrorCode);
context.ResponseData.Write((int)errno);
context.ResponseData.Write(serializedSize);
return ResultCode.Success;
}
[Command(3)]
// GetHostByAddr(u32, u32, u32, u64, pid, buffer<unknown, 5, 0>) -> (u32, u32, u32, buffer<unknown, 6, 0>)
public ResultCode GetHostByAddress(ServiceCtx context)
{
byte[] rawIp = context.Memory.ReadBytes(context.Request.SendBuff[0].Position, context.Request.SendBuff[0].Size);
// TODO: use params
uint socketLength = context.RequestData.ReadUInt32();
uint type = context.RequestData.ReadUInt32();
int timeOut = context.RequestData.ReadInt32();
ulong pidPlaceholder = context.RequestData.ReadUInt64();
IPHostEntry hostEntry = null;
NetDbError netDbErrorCode = NetDbError.Success;
GaiError errno = GaiError.AddressFamily;
long serializedSize = 0;
if (rawIp.Length == 4)
{
try
{
IPAddress address = new IPAddress(rawIp);
hostEntry = Dns.GetHostEntry(address);
}
catch (SocketException exception)
{
netDbErrorCode = NetDbError.Internal;
if (exception.ErrorCode == 11001)
{
netDbErrorCode = NetDbError.HostNotFound;
errno = GaiError.NoData;
}
else if (exception.ErrorCode == 11002)
{
netDbErrorCode = NetDbError.TryAgain;
}
else if (exception.ErrorCode == 11003)
{
netDbErrorCode = NetDbError.NoRecovery;
}
else if (exception.ErrorCode == 11004)
{
netDbErrorCode = NetDbError.NoData;
}
else if (exception.ErrorCode == 10060)
{
errno = GaiError.Again;
}
}
}
else
{
netDbErrorCode = NetDbError.NoAddress;
}
if (hostEntry != null)
{
errno = GaiError.Success;
serializedSize = SerializeHostEnt(context, hostEntry, GetIpv4Addresses(hostEntry));
}
context.ResponseData.Write((int)netDbErrorCode);
context.ResponseData.Write((int)errno);
context.ResponseData.Write(serializedSize);
return ResultCode.Success;
}
[Command(4)]
// GetHostStringError(u32) -> buffer<unknown, 6, 0>
public ResultCode GetHostStringError(ServiceCtx context)
{
ResultCode resultCode = ResultCode.NotAllocated;
NetDbError errorCode = (NetDbError)context.RequestData.ReadInt32();
string errorString = GetHostStringErrorFromErrorCode(errorCode);
if (errorString.Length + 1 <= context.Request.ReceiveBuff[0].Size)
{
resultCode = 0;
context.Memory.WriteBytes(context.Request.ReceiveBuff[0].Position, Encoding.ASCII.GetBytes(errorString + '\0'));
}
return resultCode;
}
[Command(5)]
// GetGaiStringError(u32) -> buffer<unknown, 6, 0>
public ResultCode GetGaiStringError(ServiceCtx context)
{
ResultCode resultCode = ResultCode.NotAllocated;
GaiError errorCode = (GaiError)context.RequestData.ReadInt32();
string errorString = GetGaiStringErrorFromErrorCode(errorCode);
if (errorString.Length + 1 <= context.Request.ReceiveBuff[0].Size)
{
resultCode = 0;
context.Memory.WriteBytes(context.Request.ReceiveBuff[0].Position, Encoding.ASCII.GetBytes(errorString + '\0'));
}
return resultCode;
}
[Command(8)]
// RequestCancelHandle(u64, pid) -> u32
public ResultCode RequestCancelHandle(ServiceCtx context)
{
ulong unknown0 = context.RequestData.ReadUInt64();
context.ResponseData.Write(0);
Logger.PrintStub(LogClass.ServiceSfdnsres, new { unknown0 });
return ResultCode.Success;
}
[Command(9)]
// CancelSocketCall(u32, u64, pid)
public ResultCode CancelSocketCall(ServiceCtx context)
{
uint unknown0 = context.RequestData.ReadUInt32();
ulong unknown1 = context.RequestData.ReadUInt64();
Logger.PrintStub(LogClass.ServiceSfdnsres, new { unknown0, unknown1 });
return ResultCode.Success;
}
[Command(11)]
// ClearDnsAddresses(u32)
public ResultCode ClearDnsAddresses(ServiceCtx context)
{
uint unknown0 = context.RequestData.ReadUInt32();
Logger.PrintStub(LogClass.ServiceSfdnsres, new { unknown0 });
return ResultCode.Success;
}
}
}

22
Ryujinx.HLE/HOS/Services/Sockets/Sfdnsres/Types/GaiError.cs Normal file
View File

@ -0,0 +1,22 @@
namespace Ryujinx.HLE.HOS.Services.Sockets.Sfdnsres
{
enum GaiError
{
Success,
AddressFamily,
Again,
BadFlags,
Fail,
Family,
Memory,
NoData,
NoName,
Service,
SocketType,
System,
BadHints,
Protocol,
Overflow,
Max
}
}

13
Ryujinx.HLE/HOS/Services/Sockets/Sfdnsres/Types/NetDBError.cs Normal file
View File

@ -0,0 +1,13 @@
namespace Ryujinx.HLE.HOS.Services.Sockets.Sfdnsres
{
enum NetDbError
{
Internal = -1,
Success,
HostNotFound,
TryAgain,
NoRecovery,
NoData,
NoAddress = NoData
}
}