Move solution and projects to src

src/Ryujinx.HLE/HOS/Services/Time/TimeZone/TimeZoneContentManager.cs

@@ -0,0 +1,304 @@
+using LibHac;
+using LibHac.Common;
+using LibHac.Fs;
+using LibHac.Fs.Fsa;
+using LibHac.FsSystem;
+using LibHac.Ncm;
+using LibHac.Tools.FsSystem;
+using LibHac.Tools.FsSystem.NcaUtils;
+using Ryujinx.Common.Logging;
+using Ryujinx.Cpu;
+using Ryujinx.HLE.Exceptions;
+using Ryujinx.HLE.FileSystem;
+using Ryujinx.HLE.HOS.Services.Time.Clock;
+using Ryujinx.HLE.Utilities;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Text;
+using TimeZoneRuleBox = Ryujinx.Common.Memory.Box<Ryujinx.HLE.HOS.Services.Time.TimeZone.TimeZoneRule>;
+
+namespace Ryujinx.HLE.HOS.Services.Time.TimeZone
+{
+    public class TimeZoneContentManager
+    {
+        private const long TimeZoneBinaryTitleId = 0x010000000000080E;
+
+        private readonly string TimeZoneSystemTitleMissingErrorMessage = "TimeZoneBinary system title not found! TimeZone conversions will not work, provide the system archive to fix this error. (See https://github.com/Ryujinx/Ryujinx/wiki/Ryujinx-Setup-&-Configuration-Guide#initial-setup-continued---installation-of-firmware for more information)";
+
+        private VirtualFileSystem   _virtualFileSystem;
+        private IntegrityCheckLevel _fsIntegrityCheckLevel;
+        private ContentManager      _contentManager;
+
+        public string[] LocationNameCache { get; private set; }
+
+        internal TimeZoneManager Manager { get; private set; }
+
+        public TimeZoneContentManager()
+        {
+            Manager = new TimeZoneManager();
+        }
+
+        public void InitializeInstance(VirtualFileSystem virtualFileSystem, ContentManager contentManager, IntegrityCheckLevel fsIntegrityCheckLevel)
+        {
+            _virtualFileSystem     = virtualFileSystem;
+            _contentManager        = contentManager;
+            _fsIntegrityCheckLevel = fsIntegrityCheckLevel;
+
+            InitializeLocationNameCache();
+        }
+
+        public string SanityCheckDeviceLocationName(string locationName)
+        {
+            if (IsLocationNameValid(locationName))
+            {
+                return locationName;
+            }
+
+            Logger.Warning?.Print(LogClass.ServiceTime, $"Invalid device TimeZone {locationName}, switching back to UTC");
+
+            return "UTC";
+        }
+
+        internal void Initialize(TimeManager timeManager, Switch device)
+        {
+            InitializeInstance(device.FileSystem, device.System.ContentManager, device.System.FsIntegrityCheckLevel);
+
+            ITickSource tickSource = device.System.TickSource;
+
+            SteadyClockTimePoint timeZoneUpdatedTimePoint = timeManager.StandardSteadyClock.GetCurrentTimePoint(tickSource);
+
+            string deviceLocationName = SanityCheckDeviceLocationName(device.Configuration.TimeZone);
+
+            ResultCode result = GetTimeZoneBinary(deviceLocationName, out Stream timeZoneBinaryStream, out LocalStorage ncaFile);
+
+            if (result == ResultCode.Success)
+            {
+                // TODO: Read TimeZoneVersion from sysarchive.
+                timeManager.SetupTimeZoneManager(deviceLocationName, timeZoneUpdatedTimePoint, (uint)LocationNameCache.Length, new UInt128(), timeZoneBinaryStream);
+
+                ncaFile.Dispose();
+            }
+            else
+            {
+                // In the case the user don't have the timezone system archive, we just mark the manager as initialized.
+                Manager.MarkInitialized();
+            }
+        }
+
+        private void InitializeLocationNameCache()
+        {
+            if (HasTimeZoneBinaryTitle())
+            {
+                using (IStorage ncaFileStream = new LocalStorage(_virtualFileSystem.SwitchPathToSystemPath(GetTimeZoneBinaryTitleContentPath()), FileAccess.Read, FileMode.Open))
+                {
+                    Nca         nca              = new Nca(_virtualFileSystem.KeySet, ncaFileStream);
+                    IFileSystem romfs            = nca.OpenFileSystem(NcaSectionType.Data, _fsIntegrityCheckLevel);
+
+                    using var binaryListFile = new UniqueRef<IFile>();
+
+                    romfs.OpenFile(ref binaryListFile.Ref, "/binaryList.txt".ToU8Span(), OpenMode.Read).ThrowIfFailure();
+
+                    StreamReader reader = new StreamReader(binaryListFile.Get.AsStream());
+
+                    List<string> locationNameList = new List<string>();
+
+                    string locationName;
+                    while ((locationName = reader.ReadLine()) != null)
+                    {
+                        locationNameList.Add(locationName);
+                    }
+
+                    LocationNameCache = locationNameList.ToArray();
+                }
+            }
+            else
+            {
+                LocationNameCache = new string[] { "UTC" };
+
+                Logger.Error?.Print(LogClass.ServiceTime, TimeZoneSystemTitleMissingErrorMessage);
+            }
+        }
+
+        public IEnumerable<(int Offset, string Location, string Abbr)> ParseTzOffsets()
+        {
+            var tzBinaryContentPath = GetTimeZoneBinaryTitleContentPath();
+
+            if (string.IsNullOrEmpty(tzBinaryContentPath))
+            {
+                return new[] { (0, "UTC", "UTC") };
+            }
+
+            List<(int Offset, string Location, string Abbr)> outList = new List<(int Offset, string Location, string Abbr)>();
+            var now = DateTimeOffset.Now.ToUnixTimeSeconds();
+            using (IStorage ncaStorage = new LocalStorage(_virtualFileSystem.SwitchPathToSystemPath(tzBinaryContentPath), FileAccess.Read, FileMode.Open))
+            using (IFileSystem romfs = new Nca(_virtualFileSystem.KeySet, ncaStorage).OpenFileSystem(NcaSectionType.Data, _fsIntegrityCheckLevel))
+            {
+                foreach (string locName in LocationNameCache)
+                {
+                    if (locName.StartsWith("Etc"))
+                    {
+                        continue;
+                    }
+
+                    using var tzif = new UniqueRef<IFile>();
+
+                    if (romfs.OpenFile(ref tzif.Ref, $"/zoneinfo/{locName}".ToU8Span(), OpenMode.Read).IsFailure())
+                    {
+                        Logger.Error?.Print(LogClass.ServiceTime, $"Error opening /zoneinfo/{locName}");
+                        continue;
+                    }
+
+                    TimeZoneRuleBox tzRuleBox = new TimeZoneRuleBox();
+                    ref TimeZoneRule tzRule = ref tzRuleBox.Data;
+
+                    TimeZone.ParseTimeZoneBinary(ref tzRule, tzif.Get.AsStream());
+
+
+                    TimeTypeInfo ttInfo;
+                    if (tzRule.TimeCount > 0) // Find the current transition period
+                    {
+                        int fin = 0;
+                        for (int i = 0; i < tzRule.TimeCount; ++i)
+                        {
+                            if (tzRule.Ats[i] <= now)
+                            {
+                                fin = i;
+                            }
+                        }
+                        ttInfo = tzRule.Ttis[tzRule.Types[fin]];
+                    }
+                    else if (tzRule.TypeCount >= 1) // Otherwise, use the first offset in TTInfo
+                    {
+                        ttInfo = tzRule.Ttis[0];
+                    }
+                    else
+                    {
+                        Logger.Error?.Print(LogClass.ServiceTime, $"Couldn't find UTC offset for zone {locName}");
+                        continue;
+                    }
+
+                    var abbrStart = tzRule.Chars[ttInfo.AbbreviationListIndex..];
+                    int abbrEnd = abbrStart.IndexOf((byte)0);
+
+                    outList.Add((ttInfo.GmtOffset, locName, Encoding.UTF8.GetString(abbrStart[..abbrEnd])));
+                }
+            }
+
+            outList.Sort();
+
+            return outList;
+        }
+
+        private bool IsLocationNameValid(string locationName)
+        {
+            foreach (string cachedLocationName in LocationNameCache)
+            {
+                if (cachedLocationName.Equals(locationName))
+                {
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
+        public ResultCode SetDeviceLocationName(string locationName)
+        {
+            ResultCode result = GetTimeZoneBinary(locationName, out Stream timeZoneBinaryStream, out LocalStorage ncaFile);
+
+            if (result == ResultCode.Success)
+            {
+                result = Manager.SetDeviceLocationNameWithTimeZoneRule(locationName, timeZoneBinaryStream);
+
+                ncaFile.Dispose();
+            }
+
+            return result;
+        }
+
+        public ResultCode LoadLocationNameList(uint index, out string[] outLocationNameArray, uint maxLength)
+        {
+            List<string> locationNameList = new List<string>();
+
+            for (int i = 0; i < LocationNameCache.Length && i < maxLength; i++)
+            {
+                if (i < index)
+                {
+                    continue;
+                }
+
+                string locationName = LocationNameCache[i];
+
+                // If the location name is too long, error out.
+                if (locationName.Length > 0x24)
+                {
+                    outLocationNameArray = Array.Empty<string>();
+
+                    return ResultCode.LocationNameTooLong;
+                }
+
+                locationNameList.Add(locationName);
+            }
+
+            outLocationNameArray = locationNameList.ToArray();
+
+            return ResultCode.Success;
+        }
+
+        public string GetTimeZoneBinaryTitleContentPath()
+        {
+            return _contentManager.GetInstalledContentPath(TimeZoneBinaryTitleId, StorageId.BuiltInSystem, NcaContentType.Data);
+        }
+
+        public bool HasTimeZoneBinaryTitle()
+        {
+            return !string.IsNullOrEmpty(GetTimeZoneBinaryTitleContentPath());
+        }
+
+        internal ResultCode GetTimeZoneBinary(string locationName, out Stream timeZoneBinaryStream, out LocalStorage ncaFile)
+        {
+            timeZoneBinaryStream = null;
+            ncaFile              = null;
+
+            if (!HasTimeZoneBinaryTitle() || !IsLocationNameValid(locationName))
+            {
+                return ResultCode.TimeZoneNotFound;
+            }
+
+            ncaFile = new LocalStorage(_virtualFileSystem.SwitchPathToSystemPath(GetTimeZoneBinaryTitleContentPath()), FileAccess.Read, FileMode.Open);
+
+            Nca         nca   = new Nca(_virtualFileSystem.KeySet, ncaFile);
+            IFileSystem romfs = nca.OpenFileSystem(NcaSectionType.Data, _fsIntegrityCheckLevel);
+
+            using var timeZoneBinaryFile = new UniqueRef<IFile>();
+
+            Result result = romfs.OpenFile(ref timeZoneBinaryFile.Ref, $"/zoneinfo/{locationName}".ToU8Span(), OpenMode.Read);
+
+            timeZoneBinaryStream = timeZoneBinaryFile.Release().AsStream();
+
+            return (ResultCode)result.Value;
+        }
+
+        internal ResultCode LoadTimeZoneRule(ref TimeZoneRule rules, string locationName)
+        {
+            rules = default;
+
+            if (!HasTimeZoneBinaryTitle())
+            {
+                throw new InvalidSystemResourceException(TimeZoneSystemTitleMissingErrorMessage);
+            }
+
+            ResultCode result = GetTimeZoneBinary(locationName, out Stream timeZoneBinaryStream, out LocalStorage ncaFile);
+
+            if (result == ResultCode.Success)
+            {
+                result = Manager.ParseTimeZoneRuleBinary(ref rules, timeZoneBinaryStream);
+
+                ncaFile.Dispose();
+            }
+
+            return result;
+        }
+    }
+}

src/Ryujinx.HLE/HOS/Services/Time/TimeZone/TimeZoneManager.cs

@@ -0,0 +1,261 @@
+using Ryujinx.Common.Memory;
+using Ryujinx.HLE.HOS.Services.Time.Clock;
+using System;
+using System.IO;
+
+namespace Ryujinx.HLE.HOS.Services.Time.TimeZone
+{
+    class TimeZoneManager
+    {
+        private bool                 _isInitialized;
+        private Box<TimeZoneRule>    _myRules;
+        private string               _deviceLocationName;
+        private UInt128              _timeZoneRuleVersion;
+        private uint                 _totalLocationNameCount;
+        private SteadyClockTimePoint _timeZoneUpdateTimePoint;
+        private object               _lock;
+
+        public TimeZoneManager()
+        {
+            _isInitialized       = false;
+            _deviceLocationName  = "UTC";
+            _timeZoneRuleVersion = new UInt128();
+            _lock                = new object();
+            _myRules             = new Box<TimeZoneRule>();
+
+            _timeZoneUpdateTimePoint = SteadyClockTimePoint.GetRandom();
+        }
+
+        public bool IsInitialized()
+        {
+            bool res;
+
+            lock (_lock)
+            {
+                res = _isInitialized;
+            }
+
+            return res;
+        }
+
+        public void MarkInitialized()
+        {
+            lock (_lock)
+            {
+                _isInitialized = true;
+            }
+        }
+
+        public ResultCode GetDeviceLocationName(out string deviceLocationName)
+        {
+            ResultCode result = ResultCode.UninitializedClock;
+
+            deviceLocationName = null;
+
+            lock (_lock)
+            {
+                if (_isInitialized)
+                {
+                    deviceLocationName = _deviceLocationName;
+                    result             = ResultCode.Success;
+                }
+            }
+
+            return result;
+        }
+
+        public ResultCode SetDeviceLocationNameWithTimeZoneRule(string locationName, Stream timeZoneBinaryStream)
+        {
+            ResultCode result = ResultCode.TimeZoneConversionFailed;
+
+            lock (_lock)
+            {
+                Box<TimeZoneRule> rules = new Box<TimeZoneRule>();
+
+                bool timeZoneConversionSuccess = TimeZone.ParseTimeZoneBinary(ref rules.Data, timeZoneBinaryStream);
+
+                if (timeZoneConversionSuccess)
+                {
+                    _deviceLocationName = locationName;
+                    _myRules            = rules;
+                    result              = ResultCode.Success;
+                }
+            }
+
+            return result;
+        }
+
+        public void SetTotalLocationNameCount(uint totalLocationNameCount)
+        {
+            lock (_lock)
+            {
+                _totalLocationNameCount = totalLocationNameCount;
+            }
+        }
+
+        public ResultCode GetTotalLocationNameCount(out uint totalLocationNameCount)
+        {
+            ResultCode result = ResultCode.UninitializedClock;
+
+            totalLocationNameCount = 0;
+
+            lock (_lock)
+            {
+                if (_isInitialized)
+                {
+                    totalLocationNameCount = _totalLocationNameCount;
+                    result                 = ResultCode.Success;
+                }
+            }
+
+            return result;
+        }
+
+        public ResultCode SetUpdatedTime(SteadyClockTimePoint timeZoneUpdatedTimePoint, bool bypassUninitialized = false)
+        {
+            ResultCode result = ResultCode.UninitializedClock;
+
+            lock (_lock)
+            {
+                if (_isInitialized || bypassUninitialized)
+                {
+                    _timeZoneUpdateTimePoint = timeZoneUpdatedTimePoint;
+                    result                   = ResultCode.Success;
+                }
+            }
+
+            return result;
+        }
+
+        public ResultCode GetUpdatedTime(out SteadyClockTimePoint timeZoneUpdatedTimePoint)
+        {
+            ResultCode result;
+
+            lock (_lock)
+            {
+                if (_isInitialized)
+                {
+                    timeZoneUpdatedTimePoint = _timeZoneUpdateTimePoint;
+                    result                   = ResultCode.Success;
+                }
+                else
+                {
+                    timeZoneUpdatedTimePoint = SteadyClockTimePoint.GetRandom();
+                    result                   = ResultCode.UninitializedClock;
+                }
+            }
+
+            return result;
+        }
+
+        public ResultCode ParseTimeZoneRuleBinary(ref TimeZoneRule outRules, Stream timeZoneBinaryStream)
+        {
+            ResultCode result = ResultCode.Success;
+
+            lock (_lock)
+            {
+                bool timeZoneConversionSuccess = TimeZone.ParseTimeZoneBinary(ref outRules, timeZoneBinaryStream);
+
+                if (!timeZoneConversionSuccess)
+                {
+                    result = ResultCode.TimeZoneConversionFailed;
+                }
+            }
+
+            return result;
+        }
+
+        public void SetTimeZoneRuleVersion(UInt128 timeZoneRuleVersion)
+        {
+            lock (_lock)
+            {
+                _timeZoneRuleVersion = timeZoneRuleVersion;
+            }
+        }
+
+        public ResultCode GetTimeZoneRuleVersion(out UInt128 timeZoneRuleVersion)
+        {
+            ResultCode result;
+
+            lock (_lock)
+            {
+                if (_isInitialized)
+                {
+                    timeZoneRuleVersion = _timeZoneRuleVersion;
+                    result              = ResultCode.Success;
+                }
+                else
+                {
+                    timeZoneRuleVersion = new UInt128();
+                    result              = ResultCode.UninitializedClock;
+                }
+            }
+
+            return result;
+        }
+
+        public ResultCode ToCalendarTimeWithMyRules(long time, out CalendarInfo calendar)
+        {
+            ResultCode result;
+
+            lock (_lock)
+            {
+                if (_isInitialized)
+                {
+                    result = ToCalendarTime(in _myRules.Data, time, out calendar);
+                }
+                else
+                {
+                    calendar = new CalendarInfo();
+                    result   = ResultCode.UninitializedClock;
+                }
+            }
+
+            return result;
+        }
+
+        public ResultCode ToCalendarTime(in TimeZoneRule rules, long time, out CalendarInfo calendar)
+        {
+            ResultCode result;
+
+            lock (_lock)
+            {
+                result = TimeZone.ToCalendarTime(in rules, time, out calendar);
+            }
+
+            return result;
+        }
+
+        public ResultCode ToPosixTimeWithMyRules(CalendarTime calendarTime, out long posixTime)
+        {
+            ResultCode result;
+
+            lock (_lock)
+            {
+                if (_isInitialized)
+                {
+                    result = ToPosixTime(in _myRules.Data, calendarTime, out posixTime);
+                }
+                else
+                {
+                    posixTime = 0;
+                    result    = ResultCode.UninitializedClock;
+                }
+            }
+
+            return result;
+        }
+
+        public ResultCode ToPosixTime(in TimeZoneRule rules, CalendarTime calendarTime, out long posixTime)
+        {
+            ResultCode result;
+
+            lock (_lock)
+            {
+                result = TimeZone.ToPosixTime(in rules, calendarTime, out posixTime);
+            }
+
+            return result;
+        }
+    }
+}

src/Ryujinx.HLE/HOS/Services/Time/TimeZone/Types/CalendarAdditionalInfo.cs

@@ -0,0 +1,21 @@
+using Ryujinx.Common.Memory;
+using System.Runtime.InteropServices;
+
+namespace Ryujinx.HLE.HOS.Services.Time.TimeZone
+{
+    [StructLayout(LayoutKind.Sequential, Pack = 0x4, Size = 0x18, CharSet = CharSet.Ansi)]
+    struct CalendarAdditionalInfo
+    {
+        public uint DayOfWeek;
+        public uint DayOfYear;
+
+        public Array8<byte> TimezoneName;
+
+        [MarshalAs(UnmanagedType.I1)]
+        public bool IsDaySavingTime;
+
+        public Array3<byte> Padding;
+
+        public int GmtOffset;
+    }
+}

src/Ryujinx.HLE/HOS/Services/Time/TimeZone/Types/CalendarInfo.cs

@@ -0,0 +1,11 @@
+using System.Runtime.InteropServices;
+
+namespace Ryujinx.HLE.HOS.Services.Time.TimeZone
+{
+    [StructLayout(LayoutKind.Sequential, Pack = 0x4, Size = 0x20, CharSet = CharSet.Ansi)]
+    struct CalendarInfo
+    {
+        public CalendarTime           Time;
+        public CalendarAdditionalInfo AdditionalInfo;
+    }
+}

src/Ryujinx.HLE/HOS/Services/Time/TimeZone/Types/CalendarTime.cs

@@ -0,0 +1,15 @@
+using System.Runtime.InteropServices;
+
+namespace Ryujinx.HLE.HOS.Services.Time.TimeZone
+{
+    [StructLayout(LayoutKind.Sequential, Pack = 0x4, Size = 0x8)]
+    struct CalendarTime
+    {
+        public short Year;
+        public sbyte Month;
+        public sbyte Day;
+        public sbyte Hour;
+        public sbyte Minute;
+        public sbyte Second;
+    }
+}

src/Ryujinx.HLE/HOS/Services/Time/TimeZone/Types/TimeTypeInfo.cs

@@ -0,0 +1,28 @@
+using Ryujinx.Common.Memory;
+using System.Runtime.InteropServices;
+
+namespace Ryujinx.HLE.HOS.Services.Time.TimeZone
+{
+    [StructLayout(LayoutKind.Sequential, Size = Size, Pack = 4)]
+    public struct TimeTypeInfo
+    {
+        public const int Size = 0x10;
+
+        public int GmtOffset;
+
+        [MarshalAs(UnmanagedType.I1)]
+        public bool IsDaySavingTime;
+
+        public Array3<byte> Padding1;
+
+        public int AbbreviationListIndex;
+
+        [MarshalAs(UnmanagedType.I1)]
+        public bool IsStandardTimeDaylight;
+
+        [MarshalAs(UnmanagedType.I1)]
+        public bool IsGMT;
+
+        public ushort Padding2;
+    }
+}

src/Ryujinx.HLE/HOS/Services/Time/TimeZone/Types/TimeZoneRule.cs

@@ -0,0 +1,56 @@
+using Ryujinx.Common.Utilities;
+using System;
+using System.Runtime.InteropServices;
+
+namespace Ryujinx.HLE.HOS.Services.Time.TimeZone
+{
+    [StructLayout(LayoutKind.Sequential, Pack = 4, Size = 0x4000, CharSet = CharSet.Ansi)]
+    public struct TimeZoneRule
+    {
+        public const int TzMaxTypes = 128;
+        public const int TzMaxChars = 50;
+        public const int TzMaxLeaps = 50;
+        public const int TzMaxTimes = 1000;
+        public const int TzNameMax = 255;
+        public const int TzCharsArraySize = 2 * (TzNameMax + 1);
+
+        public int TimeCount;
+        public int TypeCount;
+        public int CharCount;
+
+        [MarshalAs(UnmanagedType.I1)]
+        public bool GoBack;
+
+        [MarshalAs(UnmanagedType.I1)]
+        public bool GoAhead;
+
+        [StructLayout(LayoutKind.Sequential, Size = sizeof(long) * TzMaxTimes)]
+        private struct AtsStorageStruct { }
+
+        private AtsStorageStruct _ats;
+
+        public Span<long> Ats => SpanHelpers.AsSpan<AtsStorageStruct, long>(ref _ats);
+
+        [StructLayout(LayoutKind.Sequential, Size = sizeof(byte) * TzMaxTimes)]
+        private struct TypesStorageStruct { }
+
+        private TypesStorageStruct _types;
+
+        public Span<byte> Types => SpanHelpers.AsByteSpan(ref _types);
+
+        [StructLayout(LayoutKind.Sequential, Size = TimeTypeInfo.Size * TzMaxTypes)]
+        private struct TimeTypeInfoStorageStruct { }
+
+        private TimeTypeInfoStorageStruct _ttis;
+
+        public Span<TimeTypeInfo> Ttis => SpanHelpers.AsSpan<TimeTypeInfoStorageStruct, TimeTypeInfo>(ref _ttis);
+
+        [StructLayout(LayoutKind.Sequential, Size = sizeof(byte) * TzCharsArraySize)]
+        private struct CharsStorageStruct { }
+
+        private CharsStorageStruct _chars;
+        public Span<byte> Chars => SpanHelpers.AsByteSpan(ref _chars);
+
+        public int DefaultType;
+    }
+}

src/Ryujinx.HLE/HOS/Services/Time/TimeZone/Types/TzifHeader.cs

@@ -0,0 +1,19 @@
+using Ryujinx.Common.Memory;
+using System.Runtime.InteropServices;
+
+namespace Ryujinx.HLE.HOS.Services.Time.TimeZone
+{
+    [StructLayout(LayoutKind.Sequential, Pack = 0x4, Size = 0x2C)]
+    struct TzifHeader
+    {
+        public Array4<byte> Magic;
+        public byte Version;
+        private Array15<byte> _reserved;
+        public int TtisGMTCount;
+        public int TtisSTDCount;
+        public int LeapCount;
+        public int TimeCount;
+        public int TypeCount;
+        public int CharCount;
+    }
+}