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

using Ryujinx.HLE.HOS.Ipc;
using System;
using System.Collections.Generic;
using System.Net;
using System.Net.Sockets;
using System.Text;

using static Ryujinx.HLE.HOS.ErrorCode;

namespace Ryujinx.HLE.HOS.Services.Sfdnsres
{
    class IResolver : IpcService
    {
        private Dictionary<int, ServiceProcessRequest> m_Commands;

        public override IReadOnlyDictionary<int, ServiceProcessRequest> Commands => m_Commands;

        public IResolver()
        {
            m_Commands = new Dictionary<int, ServiceProcessRequest>()
            {
                { 0,  SetDnsAddressesPrivate },
                { 1,  GetDnsAddressesPrivate },
                { 2,  GetHostByName          },
                { 3,  GetHostByAddress       },
                { 4,  GetHostStringError     },
                { 5,  GetGaiStringError      },
                { 8,  RequestCancelHandle    },
                { 9,  CancelSocketCall       },
                { 11, ClearDnsAddresses      },
            };
        }

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

        // SetDnsAddressesPrivate(u32, buffer<unknown, 5, 0>)
        public long 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.
            Context.Device.Log.PrintStub(Logging.LogClass.ServiceSfdnsres, $"Stubbed. Unknown0: {Unknown0}");

            return MakeError(ErrorModule.Os, 1023);
        }

        // GetDnsAddressPrivate(u32) -> buffer<unknown, 6, 0>
        public long 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.
            Context.Device.Log.PrintStub(Logging.LogClass.ServiceSfdnsres, $"Stubbed. Unknown0: {Unknown0}");

            return MakeError(ErrorModule.Os, 1023);
        }

        // GetHostByName(u8, u32, u64, pid, buffer<unknown, 5, 0>) -> (u32, u32, u32, buffer<unknown, 6, 0>)
        public long 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 0;
        }

        // GetHostByAddr(u32, u32, u32, u64, pid, buffer<unknown, 5, 0>) -> (u32, u32, u32, buffer<unknown, 6, 0>)
        public long 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 0;
        }

        // GetHostStringError(u32) -> buffer<unknown, 6, 0>
        public long GetHostStringError(ServiceCtx Context)
        {
            long       ResultCode  = MakeError(ErrorModule.Os, 1023);
            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;
        }

        // GetGaiStringError(u32) -> buffer<unknown, 6, 0>
        public long GetGaiStringError(ServiceCtx Context)
        {
            long     ResultCode  = MakeError(ErrorModule.Os, 1023);
            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;
        }

        // RequestCancelHandle(u64, pid) -> u32
        public long RequestCancelHandle(ServiceCtx Context)
        {
            ulong Unknown0 = Context.RequestData.ReadUInt64();

            Context.ResponseData.Write(0);

            Context.Device.Log.PrintStub(Logging.LogClass.ServiceSfdnsres, $"Stubbed. Unknown0: {Unknown0}");

            return 0;
        }

        // CancelSocketCall(u32, u64, pid)
        public long CancelSocketCall(ServiceCtx Context)
        {
            uint  Unknown0 = Context.RequestData.ReadUInt32();
            ulong Unknown1 = Context.RequestData.ReadUInt64();

            Context.Device.Log.PrintStub(Logging.LogClass.ServiceSfdnsres, $"Stubbed. Unknown0: {Unknown0} - " +
                                                                           $"Unknown1: {Unknown1}");

            return 0;
        }

        // ClearDnsAddresses(u32)
        public long ClearDnsAddresses(ServiceCtx Context)
        {
            uint Unknown0 = Context.RequestData.ReadUInt32();

            Context.Device.Log.PrintStub(Logging.LogClass.ServiceSfdnsres, $"Stubbed. Unknown0: {Unknown0}");

            return 0;
        }
    }
}