manuth/Ryujinx
1
0
Fork 0
mirror of https://git.naxdy.org/Mirror/Ryujinx.git synced 2024-11-15 01:25:25 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

ITimeZoneService rewrite (#722)

Browse source 
* 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
This commit is contained in:
Thomas Guillemard 2019-07-04 17:20:40 +02:00 committed by Ac_K
parent 789cdba8b5
commit 708620252e
9 changed files with 2296 additions and 160 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

3
Ryujinx.HLE/FileSystem/Content/ContentManager.cs
View file

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

274
Ryujinx.HLE/HOS/Services/Time/ITimeZoneService.cs
View file

@ -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 },
{ 1, SetDeviceLocationName },
{ 2, GetTotalLocationNameCount },
{ 3, LoadLocationNameList },
{ 4, LoadTimeZoneRule },
{ 100, ToCalendarTime },
{ 101, ToCalendarTimeWithMyRule },
{ 201, ToPosixTime },
{ 202, ToPosixTimeWithMyRule }
{ 0, GetDeviceLocationName },
{ 1, SetDeviceLocationName },
{ 2, GetTotalLocationNameCount },
{ 3, LoadLocationNameList },
{ 4, LoadTimeZoneRule },
//{ 5, GetTimeZoneRuleVersion }, // 2.0.0+
//{ 6, GetDeviceLocationNameAndUpdatedTime }, // 5.0.0+
{ 100, ToCalendarTime },
{ 101, ToCalendarTimeWithMyRule },
{ 201, ToPosixTime },
{ 202, ToPosixTimeWithMyRule }
};
}
// GetDeviceLocationName() -> nn::time::LocationName
public long GetDeviceLocationName(ServiceCtx context)
{
char[] tzName = _timeZone.Id.ToCharArray();
context.ResponseData.Write(tzName);
char[] tzName = TimeZoneManager.Instance.GetDeviceLocationName().ToCharArray();
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');
long resultCode = 0;
try
{
_timeZone = TimeZoneInfo.FindSystemTimeZoneById(tzId);
}
catch (TimeZoneNotFoundException)
{
resultCode = MakeError(ErrorModule.Time, 0x3dd);
}
return resultCode;
return TimeZoneManager.Instance.SetDeviceLocationName(locationName);
}
// 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;
long bufferSize = context.Response.SendBuff[0].Size;
// TODO: fix logic to use index
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);
int padding = 0x24 - tzData.Length;
for (int index = 0; index < padding; index++)
foreach (string locationName in locationNameArray)
{
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');
// Check if the Time Zone exists, otherwise error out.
try
long resultCode = TimeZoneManager.Instance.LoadTimeZoneRules(out TimeZoneRule rules, locationName);
// Write TimeZoneRule if success
if (resultCode == 0)
{
TimeZoneInfo info = TimeZoneInfo.FindSystemTimeZoneById(tzId);
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);
MemoryHelper.Write(context.Memory, bufferPosition, rules);
}
return resultCode;
}
private long ToCalendarTimeWithTz(ServiceCtx context, long posixTime, TimeZoneInfo info)
{
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;
}
// ToCalendarTime(nn::time::PosixTime time, buffer<nn::time::TimeZoneRule, 0x15> rules) -> (nn::time::CalendarTime, nn::time::sf::CalendarAdditionalInfo)
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.
byte[] tzData = context.Memory.ReadBytes(bufferPosition, 0x24);
TimeZoneRule rules = MemoryHelper.Read<TimeZoneRule>(context.Memory, bufferPosition);
string tzId = Encoding.ASCII.GetString(tzData).TrimEnd('\0');
long resultCode = TimeZoneManager.ToCalendarTime(rules, posixTime, out CalendarInfo calendar);
long resultCode = 0;
// Check if the Time Zone exists, otherwise error out.
try
if (resultCode == 0)
{
TimeZoneInfo info = TimeZoneInfo.FindSystemTimeZoneById(tzId);
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);
context.ResponseData.WriteStruct(calendar);
}
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)
{
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)
if (resultCode == 0)
{
Logger.PrintWarning(LogClass.ServiceTime, $"TimeZoneRule buffer size is 0x{bufferSize:x} (expected 0x4000)");
}
// 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);
context.ResponseData.WriteStruct(calendar);
}
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();
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();
long inBufferPosition = context.Request.SendBuff[0].Position;
long inBufferSize = context.Request.SendBuff[0].Size;
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;
long size = context.Request.RecvListBuff[0].Size;
if (resultCode == 0)
{
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;
}
}
}

128
Ryujinx.HLE/HOS/Services/Time/ITimeZoneServiceTypes.cs Normal file
View file

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

12
Ryujinx.HLE/HOS/Services/Time/TimeError.cs Normal file
View file

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

1707
Ryujinx.HLE/HOS/Services/Time/TimeZone/TimeZone.cs Normal file
View file

File diff suppressed because it is too large Load diff

289
Ryujinx.HLE/HOS/Services/Time/TimeZone/TimeZoneManager.cs Normal file
View file

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

1
Ryujinx.HLE/Ryujinx.HLE.csproj
View file

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

16
Ryujinx.HLE/Utilities/StreamUtils.cs Normal file
View file

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

26
Ryujinx.HLE/Utilities/StringUtils.cs
View file

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