ITimeZoneService rewrite (#722)

* Clean up ITimeZoneService

Add error codes and simplify parsing

* Add accurate timezone logic

TOOD: LoadTimeZoneRule and location name cmds.

* Integrate the new TimeZone logic

* SCREAMING_UNIX_CASE => PascalCase

* Address comments

* Reduce use of pointer in the LoadTimeZoneRule logic

* Address comments

* Realign tzIfStream logic in LoadTimeZoneRule

* Address gdk's comments

Ryujinx.HLE/FileSystem/Content/ContentManager.cs

@@ -1,5 +1,6 @@
 using LibHac.Fs;
 using LibHac.Fs.NcaUtils;
+using Ryujinx.HLE.HOS.Services.Time.TimeZone;
 using Ryujinx.HLE.Utilities;
 using System;
 using System.Collections.Generic;
@@ -141,6 +142,8 @@ namespace Ryujinx.HLE.FileSystem.Content
                     _locationEntries.Add(storageId, locationList);
                 }
             }
+
+            TimeZoneManager.Instance.Initialize(_device);
         }
 
         public void ClearEntry(long titleId, ContentType contentType, StorageId storageId)

Ryujinx.HLE/HOS/Services/Time/ITimeZoneService.cs

@@ -1,5 +1,8 @@
+using ChocolArm64.Memory;
+using Ryujinx.Common;
 using Ryujinx.Common.Logging;
 using Ryujinx.HLE.HOS.Ipc;
+using Ryujinx.HLE.HOS.Services.Time.TimeZone;
 using System;
 using System.Collections.Generic;
 using System.Text;
@@ -14,34 +17,38 @@ namespace Ryujinx.HLE.HOS.Services.Time
 
         public override IReadOnlyDictionary<int, ServiceProcessRequest> Commands => _commands;
 
-        private static readonly DateTime Epoch = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
-
-        private TimeZoneInfo _timeZone = TimeZoneInfo.Local;
-
         public ITimeZoneService()
         {
             _commands = new Dictionary<int, ServiceProcessRequest>
             {
-                { 0,   GetDeviceLocationName     },
+                { 0,   GetDeviceLocationName               },
-                { 1,   SetDeviceLocationName     },
+                { 1,   SetDeviceLocationName               },
-                { 2,   GetTotalLocationNameCount },
+                { 2,   GetTotalLocationNameCount           },
-                { 3,   LoadLocationNameList      },
+                { 3,   LoadLocationNameList                },
-                { 4,   LoadTimeZoneRule          },
+                { 4,   LoadTimeZoneRule                    },
-                { 100, ToCalendarTime            },
+              //{ 5,   GetTimeZoneRuleVersion              }, // 2.0.0+
-                { 101, ToCalendarTimeWithMyRule  },
+              //{ 6,   GetDeviceLocationNameAndUpdatedTime }, // 5.0.0+
-                { 201, ToPosixTime               },
+                { 100, ToCalendarTime                      },
-                { 202, ToPosixTimeWithMyRule     }
+                { 101, ToCalendarTimeWithMyRule            },
+                { 201, ToPosixTime                         },
+                { 202, ToPosixTimeWithMyRule               }
             };
         }
 
+        // GetDeviceLocationName() -> nn::time::LocationName
         public long GetDeviceLocationName(ServiceCtx context)
         {
-            char[] tzName = _timeZone.Id.ToCharArray();
+            char[] tzName = TimeZoneManager.Instance.GetDeviceLocationName().ToCharArray();
-
-            context.ResponseData.Write(tzName);
 
             int padding = 0x24 - tzName.Length;
 
+            if (padding < 0)
+            {
+                return MakeError(ErrorModule.Time, TimeError.LocationNameTooLong);
+            }
+
+            context.ResponseData.Write(tzName);
+
             for (int index = 0; index < padding; index++)
             {
                 context.ResponseData.Write((byte)0);
@@ -50,59 +57,58 @@ namespace Ryujinx.HLE.HOS.Services.Time
             return 0;
         }
 
+        // SetDeviceLocationName(nn::time::LocationName)
         public long SetDeviceLocationName(ServiceCtx context)
         {
-            byte[] locationName = context.RequestData.ReadBytes(0x24);
+            string locationName = Encoding.ASCII.GetString(context.RequestData.ReadBytes(0x24)).TrimEnd('\0');
 
-            string tzId = Encoding.ASCII.GetString(locationName).TrimEnd('\0');
+            return TimeZoneManager.Instance.SetDeviceLocationName(locationName);
-
-            long resultCode = 0;
-
-            try
-            {
-                _timeZone = TimeZoneInfo.FindSystemTimeZoneById(tzId);
-            }
-            catch (TimeZoneNotFoundException)
-            {
-                resultCode = MakeError(ErrorModule.Time, 0x3dd);
-            }
-
-            return resultCode;
         }
 
+        // GetTotalLocationNameCount() -> u32
         public long GetTotalLocationNameCount(ServiceCtx context)
         {
-            context.ResponseData.Write(TimeZoneInfo.GetSystemTimeZones().Count);
+            context.ResponseData.Write(TimeZoneManager.Instance.GetTotalLocationNameCount());
 
             return 0;
         }
 
+        // LoadLocationNameList(u32 index) -> (u32 outCount, buffer<nn::time::LocationName, 6>)
         public long LoadLocationNameList(ServiceCtx context)
         {
-            long bufferPosition = context.Response.SendBuff[0].Position;
+            // TODO: fix logic to use index
-            long bufferSize     = context.Response.SendBuff[0].Size;
+            uint index          = context.RequestData.ReadUInt32();
+            long bufferPosition = context.Request.ReceiveBuff[0].Position;
+            long bufferSize     = context.Request.ReceiveBuff[0].Size;
 
-            int offset = 0;
+            uint errorCode = TimeZoneManager.Instance.LoadLocationNameList(index, out string[] locationNameArray, (uint)bufferSize / 0x24);
 
-            foreach (TimeZoneInfo info in TimeZoneInfo.GetSystemTimeZones())
+            if (errorCode == 0)
             {
-                byte[] tzData = Encoding.ASCII.GetBytes(info.Id);
+                uint offset = 0;
 
-                context.Memory.WriteBytes(bufferPosition + offset, tzData);
+                foreach (string locationName in locationNameArray)
-
-                int padding = 0x24 - tzData.Length;
-
-                for (int index = 0; index < padding; index++)
                 {
-                    context.ResponseData.Write((byte)0);
+                    int padding = 0x24 - locationName.Length;
+
+                    if (padding < 0)
+                    {
+                        return MakeError(ErrorModule.Time, TimeError.LocationNameTooLong);
+                    }
+
+                    context.Memory.WriteBytes(bufferPosition + offset, Encoding.ASCII.GetBytes(locationName));
+                    MemoryHelper.FillWithZeros(context.Memory, bufferPosition + offset + locationName.Length, padding);
+
+                    offset += 0x24;
                 }
 
-                offset += 0x24;
+                context.ResponseData.Write((uint)locationNameArray.Length);
             }
 
-            return 0;
+            return errorCode;
         }
 
+        // LoadTimeZoneRule(nn::time::LocationName locationName) -> buffer<nn::time::TimeZoneRule, 0x16>
         public long LoadTimeZoneRule(ServiceCtx context)
         {
             long bufferPosition = context.Request.ReceiveBuff[0].Position;
@@ -110,58 +116,27 @@ namespace Ryujinx.HLE.HOS.Services.Time
 
             if (bufferSize != 0x4000)
             {
-                Logger.PrintWarning(LogClass.ServiceTime, $"TimeZoneRule buffer size is 0x{bufferSize:x} (expected 0x4000)");
+                // TODO: find error code here
+                Logger.PrintError(LogClass.ServiceTime, $"TimeZoneRule buffer size is 0x{bufferSize:x} (expected 0x4000)");
+
+                throw new InvalidOperationException();
             }
 
-            long resultCode = 0;
 
-            byte[] locationName = context.RequestData.ReadBytes(0x24);
+            string locationName = Encoding.ASCII.GetString(context.RequestData.ReadBytes(0x24)).TrimEnd('\0');
 
-            string tzId = Encoding.ASCII.GetString(locationName).TrimEnd('\0');
+            long resultCode = TimeZoneManager.Instance.LoadTimeZoneRules(out TimeZoneRule rules, locationName);
-
+            
-            // Check if the Time Zone exists, otherwise error out.
+            // Write TimeZoneRule if success
-            try
+            if (resultCode == 0)
             {
-                TimeZoneInfo info = TimeZoneInfo.FindSystemTimeZoneById(tzId);
+                MemoryHelper.Write(context.Memory, bufferPosition, rules);
-
-                byte[] tzData = Encoding.ASCII.GetBytes(info.Id);
-
-                // FIXME: This is not in ANY cases accurate, but the games don't care about the content of the buffer, they only pass it.
-                // TODO: Reverse the TZif2 conversion in PCV to make this match with real hardware.
-                context.Memory.WriteBytes(bufferPosition, tzData);
-            }
-            catch (TimeZoneNotFoundException)
-            {
-                Logger.PrintWarning(LogClass.ServiceTime, $"Timezone not found for string: {tzId} (len: {tzId.Length})");
-
-                resultCode = MakeError(ErrorModule.Time, 0x3dd);
             }
 
             return resultCode;
         }
 
-        private long ToCalendarTimeWithTz(ServiceCtx context, long posixTime, TimeZoneInfo info)
+        // ToCalendarTime(nn::time::PosixTime time, buffer<nn::time::TimeZoneRule, 0x15> rules) -> (nn::time::CalendarTime, nn::time::sf::CalendarAdditionalInfo)
-        {
-            DateTime currentTime = Epoch.AddSeconds(posixTime);
-
-            currentTime = TimeZoneInfo.ConvertTimeFromUtc(currentTime, info);
-
-            context.ResponseData.Write((ushort)currentTime.Year);
-            context.ResponseData.Write((byte)currentTime.Month);
-            context.ResponseData.Write((byte)currentTime.Day);
-            context.ResponseData.Write((byte)currentTime.Hour);
-            context.ResponseData.Write((byte)currentTime.Minute);
-            context.ResponseData.Write((byte)currentTime.Second);
-            context.ResponseData.Write((byte)0); //MilliSecond ?
-            context.ResponseData.Write((int)currentTime.DayOfWeek);
-            context.ResponseData.Write(currentTime.DayOfYear - 1);
-            context.ResponseData.Write(new byte[8]); //TODO: Find out the names used.
-            context.ResponseData.Write((byte)(currentTime.IsDaylightSavingTime() ? 1 : 0));
-            context.ResponseData.Write((int)info.GetUtcOffset(currentTime).TotalSeconds);
-
-            return 0;
-        }
-
         public long ToCalendarTime(ServiceCtx context)
         {
             long posixTime      = context.RequestData.ReadInt64();
@@ -170,111 +145,90 @@ namespace Ryujinx.HLE.HOS.Services.Time
 
             if (bufferSize != 0x4000)
             {
-                Logger.PrintWarning(LogClass.ServiceTime, $"TimeZoneRule buffer size is 0x{bufferSize:x} (expected 0x4000)");
+                // TODO: find error code here
+                Logger.PrintError(LogClass.ServiceTime, $"TimeZoneRule buffer size is 0x{bufferSize:x} (expected 0x4000)");
+
+                throw new InvalidOperationException();
             }
 
-            // TODO: Reverse the TZif2 conversion in PCV to make this match with real hardware.
+            TimeZoneRule rules = MemoryHelper.Read<TimeZoneRule>(context.Memory, bufferPosition);
-            byte[] tzData = context.Memory.ReadBytes(bufferPosition, 0x24);
 
-            string tzId = Encoding.ASCII.GetString(tzData).TrimEnd('\0');
+            long resultCode = TimeZoneManager.ToCalendarTime(rules, posixTime, out CalendarInfo calendar);
 
-            long resultCode = 0;
+            if (resultCode == 0)
-
-            // Check if the Time Zone exists, otherwise error out.
-            try
             {
-                TimeZoneInfo info = TimeZoneInfo.FindSystemTimeZoneById(tzId);
+                context.ResponseData.WriteStruct(calendar);
-
-                resultCode = ToCalendarTimeWithTz(context, posixTime, info);
-            }
-            catch (TimeZoneNotFoundException)
-            {
-                Logger.PrintWarning(LogClass.ServiceTime, $"Timezone not found for string: {tzId} (len: {tzId.Length})");
-
-                resultCode = MakeError(ErrorModule.Time, 0x3dd);
             }
 
             return resultCode;
         }
 
+        // ToCalendarTimeWithMyRule(nn::time::PosixTime) -> (nn::time::CalendarTime, nn::time::sf::CalendarAdditionalInfo)
         public long ToCalendarTimeWithMyRule(ServiceCtx context)
         {
             long posixTime = context.RequestData.ReadInt64();
 
-            return ToCalendarTimeWithTz(context, posixTime, _timeZone);
+            long resultCode = TimeZoneManager.Instance.ToCalendarTimeWithMyRules(posixTime, out CalendarInfo calendar);
-        }
 
-        public long ToPosixTime(ServiceCtx context)
+            if (resultCode == 0)
-        {
-            long bufferPosition = context.Request.SendBuff[0].Position;
-            long bufferSize     = context.Request.SendBuff[0].Size;
-
-            ushort year   = context.RequestData.ReadUInt16();
-            byte   month  = context.RequestData.ReadByte();
-            byte   day    = context.RequestData.ReadByte();
-            byte   hour   = context.RequestData.ReadByte();
-            byte   minute = context.RequestData.ReadByte();
-            byte   second = context.RequestData.ReadByte();
-
-            DateTime calendarTime = new DateTime(year, month, day, hour, minute, second);
-
-            if (bufferSize != 0x4000)
             {
-                Logger.PrintWarning(LogClass.ServiceTime, $"TimeZoneRule buffer size is 0x{bufferSize:x} (expected 0x4000)");
+                context.ResponseData.WriteStruct(calendar);
-            }
-
-            // TODO: Reverse the TZif2 conversion in PCV to make this match with real hardware.
-            byte[] tzData = context.Memory.ReadBytes(bufferPosition, 0x24);
-
-            string tzId = Encoding.ASCII.GetString(tzData).TrimEnd('\0');
-
-            long resultCode = 0;
-
-            // Check if the Time Zone exists, otherwise error out.
-            try
-            {
-                TimeZoneInfo info = TimeZoneInfo.FindSystemTimeZoneById(tzId);
-
-                return ToPosixTimeWithTz(context, calendarTime, info);
-            }
-            catch (TimeZoneNotFoundException)
-            {
-                Logger.PrintWarning(LogClass.ServiceTime, $"Timezone not found for string: {tzId} (len: {tzId.Length})");
-
-                resultCode = MakeError(ErrorModule.Time, 0x3dd);
             }
 
             return resultCode;
         }
 
-        public long ToPosixTimeWithMyRule(ServiceCtx context)
+        // ToPosixTime(nn::time::CalendarTime calendarTime, buffer<nn::time::TimeZoneRule, 0x15> rules) -> (u32 outCount, buffer<nn::time::PosixTime, 0xa>)
+        public long ToPosixTime(ServiceCtx context)
         {
-            ushort year   = context.RequestData.ReadUInt16();
+            long inBufferPosition = context.Request.SendBuff[0].Position;
-            byte   month  = context.RequestData.ReadByte();
+            long inBufferSize     = context.Request.SendBuff[0].Size;
-            byte   day    = context.RequestData.ReadByte();
-            byte   hour   = context.RequestData.ReadByte();
-            byte   minute = context.RequestData.ReadByte();
-            byte   second = context.RequestData.ReadByte();
 
-            DateTime calendarTime = new DateTime(year, month, day, hour, minute, second, DateTimeKind.Local);
+            CalendarTime calendarTime = context.RequestData.ReadStruct<CalendarTime>();
 
-            return ToPosixTimeWithTz(context, calendarTime, _timeZone);
+            if (inBufferSize != 0x4000)
+            {
+                // TODO: find error code here
+                Logger.PrintError(LogClass.ServiceTime, $"TimeZoneRule buffer size is 0x{inBufferSize:x} (expected 0x4000)");
+
+                throw new InvalidOperationException();
+            }
+
+            TimeZoneRule rules = MemoryHelper.Read<TimeZoneRule>(context.Memory, inBufferPosition);
+
+            long resultCode = TimeZoneManager.ToPosixTime(rules, calendarTime, out long posixTime);
+
+            if (resultCode == 0)
+            {
+                long outBufferPosition = context.Request.RecvListBuff[0].Position;
+                long outBufferSize     = context.Request.RecvListBuff[0].Size;
+
+                context.Memory.WriteInt64(outBufferPosition, posixTime);
+                context.ResponseData.Write(1);
+            }
+
+            return resultCode;
         }
 
-        private long ToPosixTimeWithTz(ServiceCtx context, DateTime calendarTime, TimeZoneInfo info)
+        // ToPosixTimeWithMyRule(nn::time::CalendarTime calendarTime) -> (u32 outCount, buffer<nn::time::PosixTime, 0xa>)
+        public long ToPosixTimeWithMyRule(ServiceCtx context)
         {
-            DateTime calenderTimeUtc = TimeZoneInfo.ConvertTimeToUtc(calendarTime, info);
+            CalendarTime calendarTime = context.RequestData.ReadStruct<CalendarTime>();
 
-            long posixTime = ((DateTimeOffset)calenderTimeUtc).ToUnixTimeSeconds();
+            long resultCode = TimeZoneManager.Instance.ToPosixTimeWithMyRules(calendarTime, out long posixTime);
 
-            long position = context.Request.RecvListBuff[0].Position;
+            if (resultCode == 0)
-            long size     = context.Request.RecvListBuff[0].Size;
+            {
+                long outBufferPosition = context.Request.RecvListBuff[0].Position;
+                long outBufferSize     = context.Request.RecvListBuff[0].Size;
 
-            context.Memory.WriteInt64(position, posixTime);
+                context.Memory.WriteInt64(outBufferPosition, posixTime);
 
-            context.ResponseData.Write(1);
+                // There could be only one result on one calendar as leap seconds aren't supported.
+                context.ResponseData.Write(1);
+            }
 
-            return 0;
+            return resultCode;
         }
     }
 }

Ryujinx.HLE/HOS/Services/Time/ITimeZoneServiceTypes.cs

@@ -0,0 +1,128 @@
+using System.Runtime.InteropServices;
+
+namespace Ryujinx.HLE.HOS.Services.Time
+{
+    [StructLayout(LayoutKind.Sequential, Size = 0x10, Pack = 4)]
+    struct TimeTypeInfo
+    {
+        public int GmtOffset;
+
+        [MarshalAs(UnmanagedType.I1)]
+        public bool IsDaySavingTime;
+
+        [MarshalAs(UnmanagedType.ByValArray, SizeConst = 3)]
+        char[] Padding1;
+
+        public int AbbreviationListIndex;
+
+        [MarshalAs(UnmanagedType.I1)]
+        public bool IsStandardTimeDaylight;
+
+        [MarshalAs(UnmanagedType.I1)]
+        public bool IsGMT;
+
+        [MarshalAs(UnmanagedType.ByValArray, SizeConst = 2)]
+        char[] Padding2;
+    }
+
+    [StructLayout(LayoutKind.Sequential, Pack = 4, Size = 0x4000, CharSet = CharSet.Ansi)]
+    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;
+
+        [MarshalAs(UnmanagedType.ByValArray, SizeConst = TzMaxTimes)]
+        public long[] Ats;
+
+        [MarshalAs(UnmanagedType.ByValArray, SizeConst = TzMaxTimes)]
+        public byte[] Types;
+
+        [MarshalAs(UnmanagedType.ByValArray, SizeConst = TzMaxTypes)]
+        public TimeTypeInfo[] Ttis;
+
+        [MarshalAs(UnmanagedType.ByValArray, SizeConst = TzCharsArraySize)]
+        public char[] Chars;
+
+        public int DefaultType;
+    }
+
+    [StructLayout(LayoutKind.Sequential, Pack = 0x4, Size = 0x2C)]
+    struct TzifHeader
+    {
+        [MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)]
+        public char[] Magic;
+
+        public char Version;
+
+        [MarshalAs(UnmanagedType.ByValArray, SizeConst = 15)]
+        public byte[] Reserved;
+
+        [MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)]
+        public byte[] TtisGMTCount;
+
+        [MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)]
+        public byte[] TtisSTDCount;
+
+        [MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)]
+        public byte[] LeapCount;
+
+        [MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)]
+        public byte[] TimeCount;
+
+        [MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)]
+        public byte[] TypeCount;
+
+        [MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)]
+        public byte[] CharCount;
+    }
+
+    [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;
+    }
+
+    [StructLayout(LayoutKind.Sequential, Pack = 0x4, Size = 0x18, CharSet = CharSet.Ansi)]
+    struct CalendarAdditionalInfo
+    {
+        public uint DayOfWeek;
+        public uint DayOfYear;
+
+        [MarshalAs(UnmanagedType.ByValArray, SizeConst = 8)]
+        public char[] TimezoneName;
+
+        [MarshalAs(UnmanagedType.I1)]
+        public bool IsDaySavingTime;
+
+        [MarshalAs(UnmanagedType.ByValArray, SizeConst = 3)]
+        char[] Padding;
+
+        public int GmtOffset;
+    }
+
+    [StructLayout(LayoutKind.Sequential, Pack = 0x4, Size = 0x20, CharSet = CharSet.Ansi)]
+    struct CalendarInfo
+    {
+        public CalendarTime           Time;
+        public CalendarAdditionalInfo AdditionalInfo;
+    }
+}

Ryujinx.HLE/HOS/Services/Time/TimeError.cs

@@ -0,0 +1,12 @@
+namespace Ryujinx.HLE.HOS.Services.Time
+{
+    static class TimeError
+    {
+        public const int TimeNotFound             = 200;
+        public const int Overflow                 = 201;
+        public const int LocationNameTooLong      = 801;
+        public const int OutOfRange               = 902;
+        public const int TimeZoneConversionFailed = 903;
+        public const int TimeZoneNotFound         = 989;
+    }
+}

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

@@ -0,0 +1,289 @@
+using LibHac.Fs.NcaUtils;
+using Ryujinx.Common.Logging;
+using Ryujinx.HLE.FileSystem;
+using System;
+using System.Collections.ObjectModel;
+using LibHac.Fs;
+using System.IO;
+using System.Collections.Generic;
+using TimeZoneConverter.Posix;
+using TimeZoneConverter;
+
+using static Ryujinx.HLE.HOS.Services.Time.TimeZoneRule;
+using static Ryujinx.HLE.HOS.ErrorCode;
+
+namespace Ryujinx.HLE.HOS.Services.Time.TimeZone
+{
+    public sealed class TimeZoneManager
+    {
+        private const long TimeZoneBinaryTitleId = 0x010000000000080E;
+
+        private static TimeZoneManager instance;
+
+        private static object instanceLock = new object();
+
+        private Switch       _device;
+        private TimeZoneRule _myRules;
+        private string       _deviceLocationName;
+        private string[]     _locationNameCache;
+
+        public static TimeZoneManager Instance
+        {
+            get
+            {
+                lock (instanceLock)
+                {
+                    if (instance == null)
+                    {
+                        instance = new TimeZoneManager();
+                    }
+
+                    return instance;
+                }
+            }
+        }
+
+        TimeZoneManager()
+        {
+            // Empty rules (UTC)
+            _myRules = new TimeZoneRule
+            {
+                Ats   = new long[TzMaxTimes],
+                Types = new byte[TzMaxTimes],
+                Ttis  = new TimeTypeInfo[TzMaxTypes],
+                Chars = new char[TzCharsArraySize]
+            };
+
+            _deviceLocationName = "UTC";
+        }
+
+        internal void Initialize(Switch device)
+        {
+            _device = device;
+
+            InitializeLocationNameCache();
+        }
+
+        private void InitializeLocationNameCache()
+        {
+            if (HasTimeZoneBinaryTitle())
+            {
+                using (IStorage ncaFileStream = new LocalStorage(_device.FileSystem.SwitchPathToSystemPath(GetTimeZoneBinaryTitleContentPath()), FileAccess.Read, FileMode.Open))
+                {
+                    Nca         nca              = new Nca(_device.System.KeySet, ncaFileStream);
+                    IFileSystem romfs            = nca.OpenFileSystem(NcaSectionType.Data, _device.System.FsIntegrityCheckLevel);
+                    Stream      binaryListStream = romfs.OpenFile("binaryList.txt", OpenMode.Read).AsStream();
+
+                    StreamReader reader = new StreamReader(binaryListStream);
+
+                    List<string> locationNameList = new List<string>();
+
+                    string locationName;
+                    while ((locationName = reader.ReadLine()) != null)
+                    {
+                        locationNameList.Add(locationName);
+                    }
+
+                    _locationNameCache = locationNameList.ToArray();
+                }
+            }
+            else
+            {
+                ReadOnlyCollection<TimeZoneInfo> timeZoneInfos = TimeZoneInfo.GetSystemTimeZones();
+                _locationNameCache = new string[timeZoneInfos.Count];
+
+                int i = 0;
+
+                foreach (TimeZoneInfo timeZoneInfo in timeZoneInfos)
+                {
+                    bool needConversion = TZConvert.TryWindowsToIana(timeZoneInfo.Id, out string convertedName);
+                    if (needConversion)
+                    {
+                        _locationNameCache[i] = convertedName;
+                    }
+                    else
+                    {
+                        _locationNameCache[i] = timeZoneInfo.Id;
+                    }
+                    i++;
+                }
+
+                // As we aren't using the system archive, "UTC" might not exist on the host system.
+                // Load from C# TimeZone APIs UTC id.
+                string utcId             = TimeZoneInfo.Utc.Id;
+                bool   utcNeedConversion = TZConvert.TryWindowsToIana(utcId, out string utcConvertedName);
+                if (utcNeedConversion)
+                {
+                    utcId = utcConvertedName;
+                }
+
+                _deviceLocationName = utcId;
+            }
+        }
+
+        private bool IsLocationNameValid(string locationName)
+        {
+            foreach (string cachedLocationName in _locationNameCache)
+            {
+                if (cachedLocationName.Equals(locationName))
+                {
+                    return true;
+                }
+            }
+            return false;
+        }
+
+        public string GetDeviceLocationName()
+        {
+            return _deviceLocationName;
+        }
+
+        public uint SetDeviceLocationName(string locationName)
+        {
+            uint resultCode = LoadTimeZoneRules(out TimeZoneRule rules, locationName);
+
+            if (resultCode == 0)
+            {
+                _myRules            = rules;
+                _deviceLocationName = locationName;
+            }
+
+            return resultCode;
+        }
+
+        public uint 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 = new string[0];
+
+                    return MakeError(ErrorModule.Time, TimeError.LocationNameTooLong);
+                }
+
+                locationNameList.Add(locationName);
+            }
+
+            outLocationNameArray = locationNameList.ToArray();
+
+            return 0;
+        }
+
+        public uint GetTotalLocationNameCount()
+        {
+            return (uint)_locationNameCache.Length;
+        }
+
+        public string GetTimeZoneBinaryTitleContentPath()
+        {
+            return _device.System.ContentManager.GetInstalledContentPath(TimeZoneBinaryTitleId, StorageId.NandSystem, ContentType.Data);
+        }
+
+        public bool HasTimeZoneBinaryTitle()
+        {
+            return !string.IsNullOrEmpty(GetTimeZoneBinaryTitleContentPath());
+        }
+
+        internal uint LoadTimeZoneRules(out TimeZoneRule outRules, string locationName)
+        {
+            outRules = new TimeZoneRule
+            {
+                Ats   = new long[TzMaxTimes],
+                Types = new byte[TzMaxTimes],
+                Ttis  = new TimeTypeInfo[TzMaxTypes],
+                Chars = new char[TzCharsArraySize]
+            };
+
+            if (!IsLocationNameValid(locationName))
+            {
+                return MakeError(ErrorModule.Time, TimeError.TimeZoneNotFound);
+            }
+
+            if (!HasTimeZoneBinaryTitle())
+            {
+                // If the user doesn't have the system archives, we generate a POSIX rule string and parse it to generate a incomplete TimeZoneRule
+                // TODO: As for now not having system archives is fine, we should enforce the usage of system archives later.
+                Logger.PrintWarning(LogClass.ServiceTime, "TimeZoneBinary system archive not found! Time conversions will not be accurate!");
+                try
+                {
+                    TimeZoneInfo info      = TZConvert.GetTimeZoneInfo(locationName);
+                    string       posixRule = PosixTimeZone.FromTimeZoneInfo(info);
+
+                    if (!TimeZone.ParsePosixName(posixRule, out outRules))
+                    {
+                        return MakeError(ErrorModule.Time, TimeError.TimeZoneConversionFailed);
+                    }
+
+                    return 0;
+                }
+                catch (TimeZoneNotFoundException)
+                {
+                    Logger.PrintWarning(LogClass.ServiceTime, $"Timezone not found for string: {locationName})");
+
+                    return MakeError(ErrorModule.Time, TimeError.TimeZoneNotFound);
+                }
+            }
+            else
+            {
+                using (IStorage ncaFileStream = new LocalStorage(_device.FileSystem.SwitchPathToSystemPath(GetTimeZoneBinaryTitleContentPath()), FileAccess.Read, FileMode.Open))
+                {
+                    Nca         nca        = new Nca(_device.System.KeySet, ncaFileStream);
+                    IFileSystem romfs      = nca.OpenFileSystem(NcaSectionType.Data, _device.System.FsIntegrityCheckLevel);
+                    Stream      tzIfStream = romfs.OpenFile($"zoneinfo/{locationName}", OpenMode.Read).AsStream();
+
+                    if (!TimeZone.LoadTimeZoneRules(out outRules, tzIfStream))
+                    {
+                        return MakeError(ErrorModule.Time, TimeError.TimeZoneConversionFailed);
+                    }
+                }
+
+                return 0;
+            }
+        }
+
+        internal uint ToCalendarTimeWithMyRules(long time, out CalendarInfo calendar)
+        {
+            return ToCalendarTime(_myRules, time, out calendar);
+        }
+
+        internal static uint ToCalendarTime(TimeZoneRule rules, long time, out CalendarInfo calendar)
+        {
+            int error = TimeZone.ToCalendarTime(rules, time, out calendar);
+
+            if (error != 0)
+            {
+                return MakeError(ErrorModule.Time, error);
+            }
+
+            return 0;
+        }
+
+        internal uint ToPosixTimeWithMyRules(CalendarTime calendarTime, out long posixTime)
+        {
+            return ToPosixTime(_myRules, calendarTime, out posixTime);
+        }
+
+        internal static uint ToPosixTime(TimeZoneRule rules, CalendarTime calendarTime, out long posixTime)
+        {
+            int error = TimeZone.ToPosixTime(rules, calendarTime, out posixTime);
+
+            if (error != 0)
+            {
+                return MakeError(ErrorModule.Time, error);
+            }
+
+            return 0;
+        }
+    }
+}

Ryujinx.HLE/Ryujinx.HLE.csproj

@@ -47,6 +47,7 @@
   <ItemGroup>
     <PackageReference Include="Concentus" Version="1.1.7" />
     <PackageReference Include="LibHac" Version="0.4.1" />
+    <PackageReference Include="TimeZoneConverter.Posix" Version="2.1.0" />
   </ItemGroup>
 
 </Project>

Ryujinx.HLE/Utilities/StreamUtils.cs

@@ -0,0 +1,16 @@
+using System.IO;
+
+namespace Ryujinx.HLE.Utilities
+{
+    static class StreamUtils
+    {
+        public static byte[] StreamToBytes(Stream input)
+        {
+            using (MemoryStream ms = new MemoryStream())
+            {
+                input.CopyTo(ms);
+                return ms.ToArray();
+            }
+        }
+    }
+}

Ryujinx.HLE/Utilities/StringUtils.cs

@@ -95,5 +95,31 @@ namespace Ryujinx.HLE.Utilities
                 return Encoding.UTF8.GetString(ms.ToArray());
             }
         }
+
+        public static unsafe int CompareCStr(char* s1, char* s2)
+        {
+            int s1Index = 0;
+            int s2Index = 0;
+
+            while (s1[s1Index] != 0 && s2[s2Index] != 0 && s1[s1Index] == s2[s2Index])
+            {
+                s1Index += 1;
+                s2Index += 1;
+            }
+
+            return s2[s2Index] - s1[s1Index];
+        }
+
+        public static unsafe int LengthCstr(char* s)
+        {
+            int i = 0;
+
+            while (s[i] != '\0')
+            {
+                i++;
+            }
+
+            return i;
+        }
     }
 }