{

public static class MemoryHelper

{

{

int size8 = size & ~(8 - 1);

for (int offs = 0; offs < size8; offs += 8)

{

}

for (int offs = size8; offs < (size - size8); offs++)

{

}

}

{

long size = Marshal.SizeOf<T>();

byte[] data = new byte[size];

fixed (byte* ptr = data)

{

}

}

{

long size = Marshal.SizeOf<T>();

Marshal.StructureToPtr<T>(value, (IntPtr)ptr, false);

}

}

{

using (MemoryStream ms = new MemoryStream())

{

for (long offs = 0; offs < maxSize || maxSize == -1; offs++)

{

if (value == 0)

{

private Dictionary<StorageId, LinkedList<LocationEntry>> _locationEntries;

private Dictionary<string, string> _sharedFontFilenameDictionary;

private SortedDictionary<(ulong titleId, NcaContentType type), string> _contentDictionary;

_contentDictionary = new SortedDictionary<(ulong, NcaContentType), string>();

_locationEntries = new Dictionary<StorageId, LinkedList<LocationEntry>>();

{

{ "FontStandard", 0x0100000000000811 },

{ "FontChineseSimplified", 0x0100000000000814 },

{ "FontNintendoExtended", 0x0100000000000810 }

};

{

{ 0x010000000000080E, "TimeZoneBinary" },

{ 0x0100000000000810, "FontNintendoExtension" },

LocationEntry entry = new LocationEntry(switchPath,

0,

nca.Header.ContentType);

AddEntry(entry);

LocationEntry entry = new LocationEntry(switchPath,

0,

nca.Header.ContentType);

AddEntry(entry);

return false;

}

{

lock (_lock)

{

if (_contentDictionary.ContainsValue(ncaId))

{

var content = _contentDictionary.FirstOrDefault(x => x.Value == ncaId);

NcaContentType contentType = content.Key.type;

StorageId storage = GetInstalledStorage(titleId, contentType, storageId);

return false;

}

{

lock (_lock)

{

{

}

}

return new UInt128();

}

{

lock (_lock)

{

}

}

{

lock (_lock)

{

}

}

{

LinkedList<LocationEntry> locationList = null;

}

}

{

return _sharedFontTitleDictionary.TryGetValue(fontName, out titleId);

}

return _sharedFontFilenameDictionary.TryGetValue(fontName, out filename);

}

{

return _systemTitlesNameDictionary.TryGetValue(titleId, out name);

}

{

LinkedList<LocationEntry> locationList = _locationEntries[storageId];

{

public string ContentPath { get; private set; }

public int Flag { get; private set; }

public NcaContentType ContentType { get; private set; }

{

ContentPath = contentPath;

Flag = flag;

FontInfo CreateFont(string name)

{

contentManager.TryGetFontFilename(name, out string fontFilename))

{

string contentPath = contentManager.GetInstalledContentPath(fontTitle, StorageId.NandSystem, NcaContentType.Data);

{

struct IpcBuffDesc

{

public IpcBuffDesc(BinaryReader reader)

{

Position = word1;

Position |= (word2 << 4) & 0x0f00000000;

Size = word0;

Size |= (word2 << 8) & 0xf00000000;

}

}

} \ No newline at end of file

}

// ReSharper disable once InconsistentNaming

{

if (PtrBuff.Count > index &&

PtrBuff[index].Position != 0 &&

}

// ReSharper disable once InconsistentNaming

{

if (RecvListBuff.Count > index &&

RecvListBuff[index].Position != 0 &&

{

struct IpcPtrBuffDesc

{

{

Position = position;

Index = index;

public IpcPtrBuffDesc(BinaryReader reader)

{

Position |= (word0 << 20) & 0x0f00000000;

Position |= (word0 << 30) & 0x7000000000;

Size = (ushort)(word0 >> 16);

}

{

return new IpcPtrBuffDesc(Position, Index, size);

}

word0 = (uint)((Position & 0x0f00000000) >> 20);

word0 |= (uint)((Position & 0x7000000000) >> 30);

word0 |= (uint)Size << 16;

{

struct IpcRecvListBuffDesc

{

{

Position = position;

Size = size;

public IpcRecvListBuffDesc(BinaryReader reader)

{

Position = value & 0xffffffffffff;

if (currentProcess.CpuMemory.IsMapped(address) &&

currentProcess.CpuMemory.IsMapped(address + (ulong)size - 1))

{

return true;

}

UserExceptionContextAddress = userExceptionContextAddress;

Name = creationInfo.Name;

{

pageInfo = new KTlsPageInfo(tlsPageVa);

}

return result;

{

KProcess process = KernelStatic.GetCurrentProcess();

Logger.Warning?.Print(LogClass.KernelSvc, str);

}

TlsDramAddress = owner.MemoryManager.GetDramAddressFromVa(_tlsAddress);

}

bool is64Bits;

public ResultCode LoadIdTokenCache(ServiceCtx context)

{

// NOTE: This opens the file at "su/cache/USERID_IN_UUID_STRING.dat" (where USERID_IN_UUID_STRING is formatted as "%08x-%04x-%04x-%02x%02x-%08x%04x")

// in the "account:/" savedata and writes some data in the buffer.

public ResultCode Get(ServiceCtx context)

{

MemoryHelper.FillWithZeros(context.Memory, bufferPosition, 0x80);

// TODO: Determine the struct.

// 0x07 bytes - Unknown

// 0x10 bytes - Some ID related to the Mii? All zeros when a character icon is used.

// 0x60 bytes - Usually zeros?

public ResultCode LoadImage(ServiceCtx context)

{

{

return ResultCode.InvalidBufferSize;

}

context.ResponseData.Write(_profile.Image.Length);

public ResultCode Store(ServiceCtx context)

{

byte[] userData = new byte[userDataSize];

// TODO: Read the nn::account::profile::ProfileBase and store everything in the savedata.

public ResultCode StoreWithImage(ServiceCtx context)

{

byte[] userData = new byte[userDataSize];

byte[] profileImageData = new byte[profileImageSize];

// TODO: Read the nn::account::profile::ProfileBase and store everything in the savedata.

return ResultCode.InvalidBuffer;

}

MemoryHelper.FillWithZeros(context.Memory, outputPosition, (int)outputSize);

break;

}

offset += 0x10;

}

return ResultCode.InvalidBuffer;

}

if (inputSize != 0x24000)

{

byte[] thumbnailBuffer = new byte[inputSize];

// NOTE: Account service call nn::fs::WriteSaveDataThumbnailFile().

// TODO: Store thumbnailBuffer somewhere, in save data 0x8000000000000010 ?

// ListOpenContextStoredUsers() -> array<nn::account::Uid, 0xa>

public ResultCode ListOpenContextStoredUsers(ServiceCtx context)

{

MemoryHelper.FillWithZeros(context.Memory, outputPosition, (int)outputSize);

return ResultCode.ObjectInvalid;

}

{

return ResultCode.OutOfBounds;

}

if (size > 0)

{

if (size > maxSize)

{

byte[] data = new byte[size];

Buffer.BlockCopy(data, 0, _storage.Data, (int)writePosition, (int)size);

}

// Read(u64) -> buffer<bytes, 0x22>

public ResultCode Read(ServiceCtx context)

{

{

return ResultCode.OutOfBounds;

}

byte[] data = new byte[size];

Buffer.BlockCopy(_storage.Data, (int)readPosition, data, 0, (int)size);

return ResultCode.Success;

}

// SetApplicationCopyrightImage(buffer<bytes, 0x45> frame_buffer, s32 x, s32 y, s32 width, s32 height, s32 window_origin_mode)

public ResultCode SetApplicationCopyrightImage(ServiceCtx context)

{

ResultCode resultCode = ResultCode.InvalidParameters;

return resultCode;

}

{

/*

if (_copyrightBuffer == null)

// AppendAudioInBuffer(u64 tag, buffer<nn::audio::AudioInBuffer, 5>)

public ResultCode AppendAudioInBuffer(ServiceCtx context)

{

ulong bufferTag = context.RequestData.ReadUInt64();

// GetReleasedAudioInBuffers() -> (u32 count, buffer<u64, 6> tags)

public ResultCode GetReleasedAudioInBuffers(ServiceCtx context)

{

using (WritableRegion outputRegion = context.Memory.GetWritableRegion((ulong)position, (int)size))

{

// AppendUacInBuffer(u64 tag, handle<copy, unknown>, buffer<nn::audio::AudioInBuffer, 5>)

public ResultCode AppendUacInBuffer(ServiceCtx context)

{

ulong bufferTag = context.RequestData.ReadUInt64();

uint handle = (uint)context.Request.HandleDesc.ToCopy[0];

// AppendAudioInBufferAuto(u64 tag, buffer<nn::audio::AudioInBuffer, 0x21>)

public ResultCode AppendAudioInBufferAuto(ServiceCtx context)

{

ulong bufferTag = context.RequestData.ReadUInt64();

// GetReleasedAudioInBuffersAuto() -> (u32 count, buffer<u64, 0x22> tags)

public ResultCode GetReleasedAudioInBuffersAuto(ServiceCtx context)

{

{

ResultCode result = _impl.GetReleasedBuffers(MemoryMarshal.Cast<byte, ulong>(outputRegion.Memory.Span), out uint releasedCount);

// AppendUacInBufferAuto(u64 tag, handle<copy, event>, buffer<nn::audio::AudioInBuffer, 0x21>)

public ResultCode AppendUacInBufferAuto(ServiceCtx context)

{

ulong bufferTag = context.RequestData.ReadUInt64();

uint handle = (uint)context.Request.HandleDesc.ToCopy[0];

{

string[] deviceNames = _impl.ListAudioIns(false);

int count = 0;

{

byte[] buffer = Encoding.ASCII.GetBytes(name);

{

Logger.Error?.Print(LogClass.ServiceAudio, $"Output buffer size {size} too small!");

break;

}

position += AudioInNameSize;

count++;

AudioInputConfiguration inputConfiguration = context.RequestData.ReadStruct<AudioInputConfiguration>();

ulong appletResourceUserId = context.RequestData.ReadUInt64();

uint processHandle = (uint)context.Request.HandleDesc.ToCopy[0];

ResultCode resultCode = _impl.OpenAudioIn(context, out string outputDeviceName, out AudioOutputConfiguration outputConfiguration, out IAudioIn obj, inputDeviceName, ref inputConfiguration, appletResourceUserId, processHandle);

byte[] outputDeviceNameRaw = Encoding.ASCII.GetBytes(outputDeviceName);

MakeObject(context, new AudioInServer(obj));

}

{

string[] deviceNames = _impl.ListAudioIns(false);

int count = 0;

{

byte[] buffer = Encoding.ASCII.GetBytes(name);

{

Logger.Error?.Print(LogClass.ServiceAudio, $"Output buffer size {size} too small!");

break;

}

position += AudioInNameSize;

count++;

AudioInputConfiguration inputConfiguration = context.RequestData.ReadStruct<AudioInputConfiguration>();

ulong appletResourceUserId = context.RequestData.ReadUInt64();

uint processHandle = (uint)context.Request.HandleDesc.ToCopy[0];

ResultCode resultCode = _impl.OpenAudioIn(context, out string outputDeviceName, out AudioOutputConfiguration outputConfiguration, out IAudioIn obj, inputDeviceName, ref inputConfiguration, appletResourceUserId, processHandle);

byte[] outputDeviceNameRaw = Encoding.ASCII.GetBytes(outputDeviceName);

MakeObject(context, new AudioInServer(obj));

}

{

string[] deviceNames = _impl.ListAudioIns(true);

int count = 0;

{

byte[] buffer = Encoding.ASCII.GetBytes(name);

{

Logger.Error?.Print(LogClass.ServiceAudio, $"Output buffer size {size} too small!");

break;

}

position += AudioInNameSize;

count++;

AudioInputConfiguration inputConfiguration = context.RequestData.ReadStruct<AudioInputConfiguration>();

ulong appletResourceUserId = context.RequestData.ReadUInt64();

uint processHandle = (uint)context.Request.HandleDesc.ToCopy[0];

ResultCode resultCode = _impl.OpenAudioIn(context, out string outputDeviceName, out AudioOutputConfiguration outputConfiguration, out IAudioIn obj, inputDeviceName, ref inputConfiguration, appletResourceUserId, processHandle);

byte[] outputDeviceNameRaw = Encoding.ASCII.GetBytes(outputDeviceName);

MakeObject(context, new AudioInServer(obj));

}

// AppendAudioOutBuffer(u64 bufferTag, buffer<nn::audio::AudioOutBuffer, 5> buffer)

public ResultCode AppendAudioOutBuffer(ServiceCtx context)

{

ulong bufferTag = context.RequestData.ReadUInt64();

// GetReleasedAudioOutBuffers() -> (u32 count, buffer<u64, 6> tags)

public ResultCode GetReleasedAudioOutBuffers(ServiceCtx context)

{

{

ResultCode result = _impl.GetReleasedBuffers(MemoryMarshal.Cast<byte, ulong>(outputRegion.Memory.Span), out uint releasedCount);

// AppendAudioOutBufferAuto(u64 tag, buffer<nn::audio::AudioOutBuffer, 0x21>)

public ResultCode AppendAudioOutBufferAuto(ServiceCtx context)

{

ulong bufferTag = context.RequestData.ReadUInt64();

// GetReleasedAudioOutBuffersAuto() -> (u32 count, buffer<u64, 0x22> tags)

public ResultCode GetReleasedAudioOutBuffersAuto(ServiceCtx context)

{

{

ResultCode result = _impl.GetReleasedBuffers(MemoryMarshal.Cast<byte, ulong>(outputRegion.Memory.Span), out uint releasedCount);

{

string[] deviceNames = _impl.ListAudioOuts();

int count = 0;

{

byte[] buffer = Encoding.ASCII.GetBytes(name);

{

Logger.Error?.Print(LogClass.ServiceAudio, $"Output buffer size {size} too small!");

break;

}

position += AudioOutNameSize;

count++;

AudioInputConfiguration inputConfiguration = context.RequestData.ReadStruct<AudioInputConfiguration>();

ulong appletResourceUserId = context.RequestData.ReadUInt64();

uint processHandle = (uint)context.Request.HandleDesc.ToCopy[0];

ResultCode resultCode = _impl.OpenAudioOut(context, out string outputDeviceName, out AudioOutputConfiguration outputConfiguration, out IAudioOut obj, inputDeviceName, ref inputConfiguration, appletResourceUserId, processHandle);

byte[] outputDeviceNameRaw = Encoding.ASCII.GetBytes(outputDeviceName);

MakeObject(context, new AudioOutServer(obj));

}

{

string[] deviceNames = _impl.ListAudioOuts();

int count = 0;

{

byte[] buffer = Encoding.ASCII.GetBytes(name);

{

Logger.Error?.Print(LogClass.ServiceAudio, $"Output buffer size {size} too small!");

break;

}

position += AudioOutNameSize;

count++;

AudioInputConfiguration inputConfiguration = context.RequestData.ReadStruct<AudioInputConfiguration>();

ulong appletResourceUserId = context.RequestData.ReadUInt64();

uint processHandle = (uint)context.Request.HandleDesc.ToCopy[0];

ResultCode resultCode = _impl.OpenAudioOut(context, out string outputDeviceName, out AudioOutputConfiguration outputConfiguration, out IAudioOut obj, inputDeviceName, ref inputConfiguration, appletResourceUserId, processHandle);

byte[] outputDeviceNameRaw = Encoding.ASCII.GetBytes(outputDeviceName);

MakeObject(context, new AudioOutServer(obj));

}

{

string[] deviceNames = _impl.ListAudioDeviceName();

int count = 0;

{

byte[] buffer = Encoding.ASCII.GetBytes(name);

{

Logger.Error?.Print(LogClass.ServiceAudio, $"Output buffer size {size} too small!");

break;

}

position += AudioDeviceNameSize;

count++;

{

float volume = context.RequestData.ReadSingle();

return _impl.SetAudioDeviceOutputVolume(deviceName, volume);

}

// GetAudioDeviceOutputVolume(buffer<bytes, 5> name) -> f32 volume

public ResultCode GetAudioDeviceOutputVolume(ServiceCtx context)

{

ResultCode result = _impl.GetAudioDeviceOutputVolume(deviceName, out float volume);

{

string name = _impl.GetActiveAudioDeviceName();

byte[] deviceNameBuffer = Encoding.ASCII.GetBytes(name + "\0");

{

}

else

{

{

string[] deviceNames = _impl.ListAudioDeviceName();

int count = 0;

{

byte[] buffer = Encoding.ASCII.GetBytes(name);

{

Logger.Error?.Print(LogClass.ServiceAudio, $"Output buffer size {size} too small!");

break;

}

position += AudioDeviceNameSize;

count++;

{

float volume = context.RequestData.ReadSingle();

return _impl.SetAudioDeviceOutputVolume(deviceName, volume);

}

// GetAudioDeviceOutputVolumeAuto(buffer<bytes, 0x21> name) -> f32

public ResultCode GetAudioDeviceOutputVolumeAuto(ServiceCtx context)

{

ResultCode result = _impl.GetAudioDeviceOutputVolume(deviceName, out float volume);

{

string name = _impl.GetActiveAudioDeviceName();

byte[] deviceNameBuffer = Encoding.UTF8.GetBytes(name + '\0');

{

}

else

{

// GetAudioSystemMasterVolumeSetting(buffer<bytes, 5> name) -> f32

public ResultCode GetAudioSystemMasterVolumeSetting(ServiceCtx context)

{

ResultCode result = _impl.GetAudioSystemMasterVolumeSetting(deviceName, out float systemMasterVolume);

// -> (buffer<nn::audio::detail::AudioRendererUpdateDataHeader, 6> output, buffer<nn::audio::detail::AudioRendererUpdateDataHeader, 6> performanceOutput)

public ResultCode RequestUpdate(ServiceCtx context)

{

Memory<byte> output = new byte[outputSize];

Memory<byte> performanceOutput = new byte[performanceOutputSize];

if (result == ResultCode.Success)

{

}

else

{

// -> (buffer<nn::audio::detail::AudioRendererUpdateDataHeader, 0x22> output, buffer<nn::audio::detail::AudioRendererUpdateDataHeader, 0x22> performanceOutput)

public ResultCode RequestUpdateAuto(ServiceCtx context)

{

Memory<byte> output = new byte[outputSize];

Memory<byte> performanceOutput = new byte[performanceOutputSize];

if (result == ResultCode.Success)

{

}

return result;

{

ResultCode result;

byte[] buffer = new byte[inSize];

using (BinaryReader inputStream = new BinaryReader(new MemoryStream(buffer)))

{

if (result == ResultCode.Success)

{

byte[] pcmDataBytes = new byte[outPcmData.Length * sizeof(short)];

Buffer.BlockCopy(outPcmData, 0, pcmDataBytes, 0, pcmDataBytes.Length);

context.ResponseData.Write(outConsumed);

context.ResponseData.Write(outSamples);

{

ResultCode result;

byte[] buffer = new byte[inSize];

using (BinaryReader inputStream = new BinaryReader(new MemoryStream(buffer)))

{

if (result == ResultCode.Success)

{

byte[] pcmDataBytes = new byte[outPcmData.Length * sizeof(short)];

Buffer.BlockCopy(outPcmData, 0, pcmDataBytes, 0, pcmDataBytes.Length);

context.ResponseData.Write(outConsumed);

context.ResponseData.Write(outSamples);

_reset = context.RequestData.ReadBoolean();

byte[] buffer = new byte[inSize];

using (BinaryReader inputStream = new BinaryReader(new MemoryStream(buffer)))

{

if (result == ResultCode.Success)

{

byte[] pcmDataBytes = new byte[outPcmData.Length * sizeof(short)];

Buffer.BlockCopy(outPcmData, 0, pcmDataBytes, 0, pcmDataBytes.Length);

context.ResponseData.Write(outConsumed);

context.ResponseData.Write(outSamples);

_reset = context.RequestData.ReadBoolean();

byte[] buffer = new byte[inSize];

using (BinaryReader inputStream = new BinaryReader(new MemoryStream(buffer)))

{

if (result == ResultCode.Success)

{

byte[] pcmDataBytes = new byte[outPcmData.Length * sizeof(short)];

Buffer.BlockCopy(outPcmData, 0, pcmDataBytes, 0, pcmDataBytes.Length);

context.ResponseData.Write(outConsumed);

context.ResponseData.Write(outSamples);

// Read() -> (u32, buffer<nn::bcat::DeliveryCacheDirectoryEntry, 6>)

public ResultCode Read(ServiceCtx context)

{

byte[] data = new byte[size];

Result result = _base.Read(out int entriesRead, MemoryMarshal.Cast<byte, DeliveryCacheDirectoryEntry>(data));

context.ResponseData.Write(entriesRead);

// Read(u64) -> (u64, buffer<bytes, 6>)

public ResultCode Read(ServiceCtx context)

{

long offset = context.RequestData.ReadInt64();

Result result = _base.Read(out long bytesRead, offset, data);

context.ResponseData.Write(bytesRead);

Result = 0

};

context.Response.PtrBuff[0] = context.Response.PtrBuff[0].WithSize(dcpSize);

Logger.Stub?.PrintStub(LogClass.ServiceBcat);

return ResultCode.Success;

}

{

return MemoryHelper.Write(context.Memory, ipcDesc.Position, deliveryCacheProgress);

}

// EnumerateDeliveryCacheDirectory() -> (u32, buffer<nn::bcat::DirectoryName, 6>)

public ResultCode EnumerateDeliveryCacheDirectory(ServiceCtx context)

{

byte[] data = new byte[size];

Result result = _base.EnumerateDeliveryCacheDirectory(out int count, MemoryMarshal.Cast<byte, DirectoryName>(data));

context.ResponseData.Write(count);

ulong appletResourceUserId = context.RequestData.ReadUInt64();

ulong pidPlaceholder = context.RequestData.ReadUInt64();

ResultCode resultCode = context.Device.System.CaptureManager.SaveScreenShot(screenshotData, appletResourceUserId, context.Device.Application.TitleId, out ApplicationAlbumEntry applicationAlbumEntry);

ulong appletResourceUserId = context.RequestData.ReadUInt64();

ulong pidPlaceholder = context.RequestData.ReadUInt64();

// TODO: Parse the application data: At 0x00 it's UserData (Size of 0x400), at 0x404 it's a uint UserDataSize (Always empty for now).

ResultCode resultCode = context.Device.System.CaptureManager.SaveScreenShot(screenshotData, appletResourceUserId, context.Device.Application.TitleId, out ApplicationAlbumEntry applicationAlbumEntry);

uint unknown = context.RequestData.ReadUInt32();

ulong appletResourceUserId = context.RequestData.ReadUInt64();

// TODO: Parse the UserIdList.

ResultCode resultCode = context.Device.System.CaptureManager.SaveScreenShot(screenshotData, appletResourceUserId, context.Device.Application.TitleId, out ApplicationAlbumEntry applicationAlbumEntry);

// Pid placeholder

context.RequestData.ReadInt64();

byte[] bufferContent = new byte[size];

if (uuid.IsNull)

{

bool unknownBool = context.RequestData.ReadBoolean();

UserId userId = context.RequestData.ReadStruct<UserId>();

if (userId.IsNull)

{

*/

return ResultCode.Success;

}

context.RequestData.ReadInt64();

long pid = context.Process.Pid;

if (userId.IsNull || inAppScreenName1Size > 0x48 || inAppScreenName2Size > 0x48)

{

public static Result ReadFsPath(out FsPath path, ServiceCtx context, int index = 0)

{

byte[] pathBytes = new byte[size];

return FsPath.FromSpan(out path, pathBytes);

}

// Read() -> (u64 count, buffer<nn::fssrv::sf::IDirectoryEntry, 6, 0> entries)

public ResultCode Read(ServiceCtx context)

{

byte[] entriesBytes = new byte[bufferLen];

Span<DirectoryEntry> entries = MemoryMarshal.Cast<byte, DirectoryEntry>(entriesBytes);

Result result = _baseDirectory.Read(out long entriesRead, entries);

context.ResponseData.Write(entriesRead);

return (ResultCode)result.Value;

// Read(u32 readOption, u64 offset, u64 size) -> (u64 out_size, buffer<u8, 0x46, 0> out_buf)

public ResultCode Read(ServiceCtx context)

{

ReadOption readOption = new ReadOption(context.RequestData.ReadInt32());

context.RequestData.BaseStream.Position += 4;

Result result = _baseFile.Read(out long bytesRead, offset, data, readOption);

context.ResponseData.Write(bytesRead);

// Write(u32 writeOption, u64 offset, u64 size, buffer<u8, 0x45, 0>)

public ResultCode Write(ServiceCtx context)

{

WriteOption writeOption = new WriteOption(context.RequestData.ReadInt32());

context.RequestData.BaseStream.Position += 4;

byte[] data = new byte[size];

return (ResultCode)_baseFile.Write(offset, data, writeOption).Value;

}

// Read(u64 offset, u64 length) -> buffer<u8, 0x46, 0> buffer

public ResultCode Read(ServiceCtx context)

{

if (context.Request.ReceiveBuff.Count > 0)

{

byte[] data = new byte[size];

return (ResultCode)result.Value;

}

public ResultCode OpenFileSystemWithId(ServiceCtx context)

{

FileSystemType fileSystemType = (FileSystemType)context.RequestData.ReadInt32();

string switchPath = ReadUtf8String(context);

string fullPath = context.Device.FileSystem.SwitchPathToSystemPath(switchPath);

SaveDataSpaceId spaceId = (SaveDataSpaceId)context.RequestData.ReadInt64();

SaveDataFilter filter = context.RequestData.ReadStruct<SaveDataFilter>();

byte[] infoBuffer = new byte[bufferLen];

Result result = _baseFileSystemProxy.FindSaveDataWithFilter(out long count, infoBuffer, spaceId, ref filter);

context.ResponseData.Write(count);

return (ResultCode)result.Value;

{

StorageId storageId = (StorageId)context.RequestData.ReadByte();

byte[] padding = context.RequestData.ReadBytes(7);

// We do a mitm here to find if the request is for an AOC.

// This is because AOC can be distributed over multiple containers in the emulator.

// ReadSaveDataInfo() -> (u64, buffer<unknown, 6>)

public ResultCode ReadSaveDataInfo(ServiceCtx context)

{

byte[] infoBuffer = new byte[bufferLen];

Result result = _baseReader.Target.Read(out long readCount, infoBuffer);

context.ResponseData.Write(readCount);

return (ResultCode)result.Value;

using Ryujinx.HLE.HOS.Kernel.Threading;

using Ryujinx.HLE.HOS.Services.Hid.HidServer;

using System;

namespace Ryujinx.HLE.HOS.Services.Hid

{

public ResultCode SetSupportedNpadIdType(ServiceCtx context)

{

long appletResourceUserId = context.RequestData.ReadInt64();

context.Device.Hid.Npads.ClearSupportedPlayers();

{

{

}

}

return ResultCode.Success;

}

byte[] vibrationDeviceHandleBuffer = new byte[context.Request.PtrBuff[0].Size];

byte[] vibrationValueBuffer = new byte[context.Request.PtrBuff[1].Size];

// TODO: Read all handles and values from buffer.

namespace Ryujinx.HLE.HOS.Services.Hid

{

{

Player1 = 0,

Player2 = 1,

private string LogImpl(ServiceCtx context)

{

byte[] logBuffer = new byte[bufSize];

using MemoryStream ms = new MemoryStream(logBuffer);

ResultCode result = Export(data);

return result;

}

{

rawData = new byte[ipcBuff.Size];

}

return new Span<byte>(rawData);

{

Span<byte> rawData = MemoryMarshal.Cast<T, byte>(span);

}

protected abstract bool IsUpdated(SourceFlag flag);

}

[CommandHipc(0)]

public ResultCode ResolveProgramPath(ServiceCtx context)

{

if (ResolvePath(context, titleId, NcaContentType.Program))

{

}

[CommandHipc(1)]

public ResultCode RedirectProgramPath(ServiceCtx context)

{

RedirectPath(context, titleId, 0, NcaContentType.Program);

}

[CommandHipc(2)]

public ResultCode ResolveApplicationControlPath(ServiceCtx context)

{

if (ResolvePath(context, titleId, NcaContentType.Control))

{

}

[CommandHipc(3)]

public ResultCode ResolveApplicationHtmlDocumentPath(ServiceCtx context)

{

if (ResolvePath(context, titleId, NcaContentType.Manual))

{

}

[CommandHipc(4)]

public ResultCode ResolveDataPath(ServiceCtx context)

{

if (ResolvePath(context, titleId, NcaContentType.Data) || ResolvePath(context, titleId, NcaContentType.PublicData))

{

}

[CommandHipc(5)]

public ResultCode RedirectApplicationControlPath(ServiceCtx context)

{

RedirectPath(context, titleId, 1, NcaContentType.Control);

}

[CommandHipc(6)]

public ResultCode RedirectApplicationHtmlDocumentPath(ServiceCtx context)

{

RedirectPath(context, titleId, 1, NcaContentType.Manual);

}

[CommandHipc(7)]

public ResultCode ResolveApplicationLegalInformationPath(ServiceCtx context)

{

if (ResolvePath(context, titleId, NcaContentType.Manual))

{

}

[CommandHipc(8)]

public ResultCode RedirectApplicationLegalInformationPath(ServiceCtx context)

{

RedirectPath(context, titleId, 1, NcaContentType.Manual);

}

[CommandHipc(10)]

public ResultCode SetProgramNcaPath2(ServiceCtx context)

{

RedirectPath(context, titleId, 1, NcaContentType.Program);

}

[CommandHipc(12)]

public ResultCode DeleteProgramNcaPath(ServiceCtx context)

{

DeleteContentPath(context, titleId, NcaContentType.Program);

}

[CommandHipc(13)]

public ResultCode DeleteControlNcaPath(ServiceCtx context)

{

DeleteContentPath(context, titleId, NcaContentType.Control);

}

[CommandHipc(14)]

public ResultCode DeleteDocHtmlNcaPath(ServiceCtx context)

{

DeleteContentPath(context, titleId, NcaContentType.Manual);

}

[CommandHipc(15)]

public ResultCode DeleteInfoHtmlNcaPath(ServiceCtx context)

{

DeleteContentPath(context, titleId, NcaContentType.Manual);

return ResultCode.Success;

}

{

string contentPath = ReadUtf8String(context);

LocationEntry newLocation = new LocationEntry(contentPath, flag, titleId, contentType);

context.Device.System.ContentManager.RedirectLocation(newLocation, _storageId);

}

{

ContentManager contentManager = context.Device.System.ContentManager;

string contentPath = contentManager.GetInstalledContentPath(titleId, _storageId, NcaContentType.Program);

if (!string.IsNullOrWhiteSpace(contentPath))

{

byte[] contentPathBuffer = Encoding.UTF8.GetBytes(contentPath);

}

else

{

return true;

}

{

ContentManager contentManager = context.Device.System.ContentManager;

string contentPath = contentManager.GetInstalledContentPath(titleId, _storageId, NcaContentType.Manual);

_appletResourceUserId = context.RequestData.ReadUInt64();

_mcuVersionData = context.RequestData.ReadUInt64();

_mcuData = new byte[inputSize];

// TODO: The mcuData buffer seems to contains entries with a size of 0x40 bytes each. Usage of the data needs to be determined.

return ResultCode.WrongArgument;

}

if (context.Device.System.NfpDevices.Count == 0)

{

{

for (int i = 0; i < context.Device.System.NfpDevices.Count; i++)

{

}

context.ResponseData.Write(context.Device.System.NfpDevices.Count);

return ResultCode.DeviceNotFound;

}

MemoryHelper.FillWithZeros(context.Memory, outputPosition, (int)outputSize);

{

byte[] applicationArea = VirtualAmiibo.GetApplicationArea(context.Device.System.NfpDevices[i].AmiiboId);

size = (uint)applicationArea.Length;

return ResultCode.DeviceNotFound;

}

byte[] applicationArea = new byte[inputSize];

for (int i = 0; i < context.Device.System.NfpDevices.Count; i++)

{

uint applicationAreaId = context.RequestData.ReadUInt32();

byte[] applicationArea = new byte[inputSize];

bool isCreated = false;

return ResultCode.WrongArgument;

}

MemoryHelper.FillWithZeros(context.Memory, outputPosition, Marshal.SizeOf(typeof(TagInfo)));

Uuid.CopyTo(tagInfo.Uuid.ToSpan());

resultCode = ResultCode.Success;

}

return ResultCode.WrongArgument;

}

MemoryHelper.FillWithZeros(context.Memory, outputPosition, Marshal.SizeOf(typeof(RegisterInfo)));

{

RegisterInfo registerInfo = VirtualAmiibo.GetRegisterInfo(context.Device.System.NfpDevices[i].AmiiboId);

resultCode = ResultCode.Success;

}

return ResultCode.WrongArgument;

}

MemoryHelper.FillWithZeros(context.Memory, outputPosition, Marshal.SizeOf(typeof(CommonInfo)));

{

CommonInfo commonInfo = VirtualAmiibo.GetCommonInfo(context.Device.System.NfpDevices[i].AmiiboId);

resultCode = ResultCode.Success;

}

return ResultCode.WrongArgument;

}

MemoryHelper.FillWithZeros(context.Memory, outputPosition, Marshal.SizeOf(typeof(ModelInfo)));

modelInfo.ModelNumber = ushort.Parse(context.Device.System.NfpDevices[i].AmiiboId.Substring(8, 4), NumberStyles.HexNumber);

modelInfo.Type = byte.Parse(context.Device.System.NfpDevices[i].AmiiboId.Substring(6, 2), NumberStyles.HexNumber);

resultCode = ResultCode.Success;

}

// Then it checks if ngc.t!functionality_override_enabled is enabled and if sys:set GetT is == 2.

// If both conditions are true, it does this following code. Since we currently stub it, it's fine to don't check settings service values.

bool isMatch = false;

string text = "";

{

byte[] buffer = new byte[bufferSize];

text = Encoding.ASCII.GetString(buffer);

// Then it checks if ngc.t!functionality_override_enabled is enabled and if sys:set GetT is == 2.

// If both conditions are true, it does this following code. Since we currently stub it, it's fine to don't check settings service values.

string text = "";

string textFiltered = "";

{

textFiltered = new string('*', text.Length);

}

else

{

byte[] buffer = new byte[bufferSize];

// NOTE: Ngct use the archive 0100000000001034 which contains a words table. This is pushed on Chinese Switchs using Bcat service.

// This call check if the string contains words which are in the table then returns the same string with each matched words replaced by '*'.

textFiltered = text = Encoding.ASCII.GetString(buffer);

}

}

// GetClientId() -> buffer<nn::nifm::ClientId, 0x1a, 4>

public ResultCode GetClientId(ServiceCtx context)

{

return ResultCode.Success;

}

// GetCurrentNetworkProfile() -> buffer<nn::nifm::detail::sf::NetworkProfileData, 0x1a, 0x17c>

public ResultCode GetCurrentNetworkProfile(ServiceCtx context)

{

(IPInterfaceProperties interfaceProperties, UnicastIPAddressInformation unicastAddress) = GetLocalInterface();

Logger.Info?.Print(LogClass.ServiceNifm, $"Console's local IP is \"{unicastAddress.Address}\".");

NetworkProfileData networkProfile = new NetworkProfileData

{

Encoding.ASCII.GetBytes("RyujinxNetwork").CopyTo(networkProfile.Name.ToSpan());

return ResultCode.Success;

}

// IsAnyInternetRequestAccepted(buffer<nn::nifm::ClientId, 0x19, 4>) -> bool

public ResultCode IsAnyInternetRequestAccepted(ServiceCtx context)

{

context.ResponseData.Write(GeneralServiceManager.Get(clientId).IsAnyInternetRequestAccepted);

byte source = (byte)context.RequestData.ReadInt64();

ulong titleId = context.RequestData.ReadUInt64();

byte[] nacpData = context.Device.Application.ControlData.ByteSpan.ToArray();

return ResultCode.Success;

}

// SetDefaultDeliveryTarget(pid, buffer<bytes, 5> unknown)

public ResultCode SetDefaultDeliveryTarget(ServiceCtx context)

{

byte[] buffer = new byte[inBufferSize];

// NOTE: Service use the pid to call arp:r GetApplicationLaunchProperty and store it in internal field.

// Then it seems to use the buffer content and compare it with a stored linked instrusive list.

byte source = (byte)context.RequestData.ReadInt64();

ulong titleId = context.RequestData.ReadUInt64();

byte[] nacpData = context.Device.Application.ControlData.ByteSpan.ToArray();

return ResultCode.Success;

}

private NvResult GetIoctlArgument(ServiceCtx context, NvIoctl ioctlCommand, out Span<byte> arguments)

{

NvIoctl.Direction ioctlDirection = ioctlCommand.DirectionValue;

uint ioctlSize = ioctlCommand.Size;

byte[] temp = new byte[inputDataSize];

Buffer.BlockCopy(temp, 0, outputData, 0, temp.Length);

{

byte[] temp = new byte[inputDataSize];

arguments = new Span<byte>(temp);

}

if (errorCode == NvResult.Success)

{

fd = Open(context, path);

if ((ioctlCommand.DirectionValue & NvIoctl.Direction.Write) != 0)

{

}

}

}

int fd = context.RequestData.ReadInt32();

NvIoctl ioctlCommand = context.RequestData.ReadStruct<NvIoctl>();

errorCode = GetIoctlArgument(context, ioctlCommand, out Span<byte> arguments);

byte[] temp = new byte[inlineInBufferSize];

Span<byte> inlineInBuffer = new Span<byte>(temp);

if ((ioctlCommand.DirectionValue & NvIoctl.Direction.Write) != 0)

{

}

}

}

int fd = context.RequestData.ReadInt32();

NvIoctl ioctlCommand = context.RequestData.ReadStruct<NvIoctl>();

errorCode = GetIoctlArgument(context, ioctlCommand, out Span<byte> arguments);

byte[] temp = new byte[inlineOutBufferSize];

Span<byte> inlineOutBuffer = new Span<byte>(temp);

if ((ioctlCommand.DirectionValue & NvIoctl.Direction.Write) != 0)

{

}

}

}

return ResultCode.InvalidState;

}

if (inputSize == 0)

{

byte[] inputBuffer = new byte[inputSize];

Logger.Info?.Print(LogClass.ServicePrepo, ReadReportBuffer(inputBuffer, gameRoom, userId));

_owner = null;

}

{

nrrInfo = null;

{

byte[] temp = new byte[0x20];

hashes.Add(temp);

}

return ResultCode.Success;

}

process.CpuMemory.Write(roStart, relocatableObject.Ro);

process.CpuMemory.Write(dataStart, relocatableObject.Data);

KernelResult result;

return process.MemoryManager.SetProcessMemoryPermission(dataStart, bssEnd - dataStart, KMemoryPermission.ReadAndWrite);

}

{

foreach (NrrInfo info in _nrrInfos)

{

// pid placeholder, zero

context.RequestData.ReadUInt64();

if (result == ResultCode.Success)

{

// pid placeholder, zero

context.RequestData.ReadUInt64();

if (result == ResultCode.Success)

{

{

public NrrHeader Header { get; private set; }

public List<byte[]> Hashes { get; private set; }

{

NrrAddress = nrrAddress;

Header = header;

internal static ResultCode GetPlayStatistics(ServiceCtx context, bool byUserId = false)

{

UserId userId = byUserId ? context.RequestData.ReadStruct<UserId>() : new UserId();

List<ulong> titleIds = new List<ulong>();

{

}

if (queryCapability == PlayLogQueryCapability.WhiteList)

for (int i = 0; i < filteredApplicationPlayStatistics.Count(); i++)

{

}

context.ResponseData.Write(filteredApplicationPlayStatistics.Count());

for (SharedFontType type = 0; type < SharedFontType.Count; type++)

{

if (!AddFontToOrderOfPriorityList(context, type, offset))

{

return ResultCode.Success;

}

{

{

return false;

}

return true;

}

{

for (int i = 0; i < request.RecvListBuff.Count; i++)

{

}

}

break;

}

if (version == 1 && context.Device.System.State.DesiredKeyboardLayout == (long)KeyboardLayout.Default)

{

}

return ResultCode.Success;

}

{

int count = (int)(size / 8);

for (int index = 0; index < count; index++)

{

position += 8;

}

// GetFirmwareVersion2() -> buffer<nn::settings::system::FirmwareVersion, 0x1a, 0x100>

public ResultCode GetFirmwareVersion2(ServiceCtx context)

{

context.Response.PtrBuff[0] = context.Response.PtrBuff[0].WithSize(0x100L);

if (firmwareData != null)

{

return ResultCode.Success;

}

writer.Write(Encoding.ASCII.GetBytes(build));

}

return ResultCode.Success;

// GetSettingsItemValueSize(buffer<nn::settings::SettingsName, 0x19>, buffer<nn::settings::SettingsItemKey, 0x19>) -> u64

public ResultCode GetSettingsItemValueSize(ServiceCtx context)

{

byte[] classBuffer = new byte[classSize];

byte[] nameBuffer = new byte[nameSize];

string askedSetting = Encoding.ASCII.GetString(classBuffer).Trim('\0') + "!" + Encoding.ASCII.GetString(nameBuffer).Trim('\0');

// GetSettingsItemValue(buffer<nn::settings::SettingsName, 0x19, 0x48>, buffer<nn::settings::SettingsItemKey, 0x19, 0x48>) -> (u64, buffer<unknown, 6, 0>)

public ResultCode GetSettingsItemValue(ServiceCtx context)

{

byte[] classBuffer = new byte[classSize];

byte[] nameBuffer = new byte[nameSize];

string askedSetting = Encoding.ASCII.GetString(classBuffer).Trim('\0') + "!" + Encoding.ASCII.GetString(nameBuffer).Trim('\0');

if (nxSetting is string stringValue)

{

{

Logger.Error?.Print(LogClass.ServiceSet, $"{askedSetting} String value size is too big!");

}

throw new NotImplementedException(nxSetting.GetType().Name);

}

Logger.Debug?.Print(LogClass.ServiceSet, $"{askedSetting} set value: {nxSetting} as {nxSetting.GetType()}");

}

public byte[] GetFirmwareData(Switch device)

{

if (string.IsNullOrWhiteSpace(contentPath))

{

return WriteBsdResult(context, _sockets.Count - 1);

}

{

byte[] rawIp = new byte[4];

return new IPEndPoint(new IPAddress(rawIp), port);

}

{

}

{

IPEndPoint endPoint = (isRemote ? socket.Handle.RemoteEndPoint : socket.Handle.LocalEndPoint) as IPEndPoint;

// Open(u32 flags, array<unknown, 0x21> path) -> (i32 ret, u32 bsd_errno)

public ResultCode Open(ServiceCtx context)

{

int flags = context.RequestData.ReadInt32();

byte[] rawPath = new byte[bufferSize];

string path = Encoding.ASCII.GetString(rawPath);

int fdsCount = context.RequestData.ReadInt32();

int timeout = context.RequestData.ReadInt32();

{

return WriteBsdResult(context, -1, LinuxError.EINVAL);

}

for (int i = 0; i < fdsCount; i++)

{

BsdSocket socket = RetrieveSocket(socketFd);

{

return WriteBsdResult(context, -1, LinuxError.EBADF);}

events[i] = new PollEvent(socketFd, socket, inputEvents, outputEvents);

}

for (int i = 0; i < fdsCount; i++)

{

PollEvent Event = events[i];

PollEvent.EventTypeMask outputEvents = 0;

outputEvents |= PollEvent.EventTypeMask.Output;

}

}

return WriteBsdResult(context, readEvents.Count + writeEvents.Count + errorEvents.Count, LinuxError.SUCCESS);

int socketFd = context.RequestData.ReadInt32();

SocketFlags socketFlags = (SocketFlags)context.RequestData.ReadInt32();

LinuxError errno = LinuxError.EBADF;

BsdSocket socket = RetrieveSocket(socketFd);

result = socket.Handle.Receive(receivedBuffer, socketFlags);

errno = SetResultErrno(socket.Handle, result);

}

catch (SocketException exception)

{

int socketFd = context.RequestData.ReadInt32();

SocketFlags socketFlags = (SocketFlags)context.RequestData.ReadInt32();

LinuxError errno = LinuxError.EBADF;

BsdSocket socket = RetrieveSocket(socketFd);

result = socket.Handle.ReceiveFrom(receivedBuffer, receivedBuffer.Length, socketFlags, ref endPoint);

errno = SetResultErrno(socket.Handle, result);

WriteSockAddr(context, sockAddrOutPosition, (IPEndPoint)endPoint);

}

catch (SocketException exception)

int socketFd = context.RequestData.ReadInt32();

SocketFlags socketFlags = (SocketFlags)context.RequestData.ReadInt32();

LinuxError errno = LinuxError.EBADF;

BsdSocket socket = RetrieveSocket(socketFd);

byte[] sendBuffer = new byte[sendSize];

try

{

int socketFd = context.RequestData.ReadInt32();

SocketFlags socketFlags = (SocketFlags)context.RequestData.ReadInt32();

LinuxError errno = LinuxError.EBADF;

BsdSocket socket = RetrieveSocket(socketFd);

byte[] sendBuffer = new byte[sendSize];

EndPoint endPoint = ParseSockAddr(context, bufferPosition, bufferSize);

{

int socketFd = context.RequestData.ReadInt32();

LinuxError errno = LinuxError.EBADF;

BsdSocket socket = RetrieveSocket(socketFd);

{

int socketFd = context.RequestData.ReadInt32();

LinuxError errno = LinuxError.EBADF;

BsdSocket socket = RetrieveSocket(socketFd);

{

int socketFd = context.RequestData.ReadInt32();

LinuxError errno = LinuxError.EBADF;

BsdSocket socket = RetrieveSocket(socketFd);

{

int socketFd = context.RequestData.ReadInt32();

LinuxError errno = LinuxError.EBADF;

BsdSocket socket = RetrieveSocket(socketFd);

{

int socketFd = context.RequestData.ReadInt32();

LinuxError errno = LinuxError.EBADF;

BsdSocket socket = RetrieveSocket(socketFd);

int level = context.RequestData.ReadInt32();

int optionName = context.RequestData.ReadInt32();

LinuxError errno = LinuxError.EBADF;

BsdSocket socket = RetrieveSocket(socketFd);

case BsdIoctl.AtMark:

errno = LinuxError.SUCCESS;

// FIXME: OOB not implemented.

break;

default:

return WriteBsdResult(context, result, errno);

}

{

try

{

case SocketOptionName.Type:

case SocketOptionName.Linger:

socket.Handle.GetSocketOption(SocketOptionLevel.Socket, optionName, optionValue);

return LinuxError.SUCCESS;

case (SocketOptionName)0x200:

socket.Handle.GetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, optionValue);

return LinuxError.SUCCESS;

}

}

{

try

{

int level = context.RequestData.ReadInt32();

int optionName = context.RequestData.ReadInt32();

LinuxError errno = LinuxError.EBADF;

BsdSocket socket = RetrieveSocket(socketFd);

{

int socketFd = context.RequestData.ReadInt32();

LinuxError errno = LinuxError.EBADF;

BsdSocket socket = RetrieveSocket(socketFd);

{

byte[] sendBuffer = new byte[sendSize];

try

{

{

int socketFd = context.RequestData.ReadInt32();

LinuxError errno = LinuxError.EBADF;

BsdSocket socket = RetrieveSocket(socketFd);

{

result = socket.Handle.Receive(receivedBuffer);

errno = SetResultErrno(socket.Handle, result);

}

catch (SocketException exception)

{

// GetSettingName() -> buffer<unknown<0x100>, 0x16>

public ResultCode GetSettingName(ServiceCtx context)

{

ResultCode result = _fqdnResolver.GetSettingName(context, out string settingName);

{

byte[] settingNameBuffer = Encoding.UTF8.GetBytes(settingName + '\0');

}

return result;

// GetEnvironmentIdentifier() -> buffer<unknown<8>, 0x16>

public ResultCode GetEnvironmentIdentifier(ServiceCtx context)

{

ResultCode result = _fqdnResolver.GetEnvironmentIdentifier(context, out string identifier);

{

byte[] identifierBuffer = Encoding.UTF8.GetBytes(identifier + '\0');

}

return result;

// Resolve(buffer<unknown<0x100>, 0x15>) -> buffer<unknown<0x100>, 0x16>

public ResultCode Resolve(ServiceCtx context)

{

ResultCode result = _fqdnResolver.ResolveEx(context, out _, out string resolvedAddress);

{

return ResultCode.InvalidArgument;

}

MemoryHelper.FillWithZeros(context.Memory, outputPosition, (int)outputSize);

return result;

}

// ResolveEx(buffer<unknown<0x100>, 0x15>) -> (u32, buffer<unknown<0x100>, 0x16>)

public ResultCode ResolveEx(ServiceCtx context)

{

ResultCode result = _fqdnResolver.ResolveEx(context, out ResultCode errorCode, out string resolvedAddress);

{

return ResultCode.InvalidArgument;

}

MemoryHelper.FillWithZeros(context.Memory, outputPosition, (int)outputSize);

context.ResponseData.Write((int)errorCode);

public ResultCode ResolveEx(ServiceCtx context, out ResultCode resultCode, out string resolvedAddress)

{

byte[] addressBuffer = new byte[inputSize];

string address = Encoding.UTF8.GetString(addressBuffer).TrimEnd('\0');

public ResultCode SetDnsAddressesPrivateRequest(ServiceCtx context)

{

uint cancelHandleRequest = context.RequestData.ReadUInt32();

// TODO: This is stubbed in 2.0.0+, reverse 1.0.0 version for the sake of completeness.

Logger.Stub?.PrintStub(LogClass.ServiceSfdnsres, new { cancelHandleRequest });

public ResultCode GetDnsAddressPrivateRequest(ServiceCtx context)

{

uint cancelHandleRequest = context.RequestData.ReadUInt32();

// TODO: This is stubbed in 2.0.0+, reverse 1.0.0 version for the sake of completeness.

Logger.Stub?.PrintStub(LogClass.ServiceSfdnsres, new { cancelHandleRequest });

// GetHostByNameRequest(u8, u32, u64, pid, buffer<unknown, 5, 0>) -> (u32, u32, u32, buffer<unknown, 6, 0>)

public ResultCode GetHostByNameRequest(ServiceCtx context)

{

return GetHostByNameRequestImpl(context, inputBufferPosition, inputBufferSize, outputBufferPosition, outputBufferSize, 0, 0);

}

// GetHostByAddrRequest(u32, u32, u32, u64, pid, buffer<unknown, 5, 0>) -> (u32, u32, u32, buffer<unknown, 6, 0>)

public ResultCode GetHostByAddrRequest(ServiceCtx context)

{

return GetHostByAddrRequestImpl(context, inputBufferPosition, inputBufferSize, outputBufferPosition, outputBufferSize, 0, 0);

}

_ => (errorCode <= NetDbError.Internal) ? "Resolver internal error" : "Unknown resolver error"

};

{

resultCode = ResultCode.Success;

}

_ => "Success"

};

{

resultCode = ResultCode.Success;

}

// GetAddrInfoRequest(bool enable_nsd_resolve, u32, u64 pid_placeholder, pid, buffer<i8, 5, 0> host, buffer<i8, 5, 0> service, buffer<packed_addrinfo, 5, 0> hints) -> (i32 ret, u32 bsd_errno, u32 packed_addrinfo_size, buffer<packed_addrinfo, 6, 0> response)

public ResultCode GetAddrInfoRequest(ServiceCtx context)

{

return GetAddrInfoRequestImpl(context, responseBufferPosition, responseBufferSize, 0, 0);

}

// GetHostByNameRequestWithOptions(u8, u32, u64, pid, buffer<unknown, 21, 0>, buffer<unknown, 21, 0>) -> (u32, u32, u32, buffer<unknown, 22, 0>)

public ResultCode GetHostByNameRequestWithOptions(ServiceCtx context)

{

return GetHostByNameRequestImpl(context, inputBufferPosition, inputBufferSize, outputBufferPosition, outputBufferSize, optionsBufferPosition, optionsBufferSize);

}

// GetHostByAddrRequestWithOptions(u32, u32, u32, u64, pid, buffer<unknown, 21, 0>, buffer<unknown, 21, 0>) -> (u32, u32, u32, buffer<unknown, 22, 0>)

public ResultCode GetHostByAddrRequestWithOptions(ServiceCtx context)

{

return GetHostByAddrRequestImpl(context, inputBufferPosition, inputBufferSize, outputBufferPosition, outputBufferSize, optionsBufferPosition, optionsBufferSize);

}

// GetAddrInfoRequestWithOptions(bool enable_nsd_resolve, u32, u64 pid_placeholder, pid, buffer<i8, 5, 0> host, buffer<i8, 5, 0> service, buffer<packed_addrinfo, 5, 0> hints, buffer<unknown, 21, 0>) -> (i32 ret, u32 bsd_errno, u32 unknown, u32 packed_addrinfo_size, buffer<packed_addrinfo, 22, 0> response)

public ResultCode GetAddrInfoRequestWithOptions(ServiceCtx context)

{

return GetAddrInfoRequestImpl(context, responseBufferPosition, responseBufferSize, optionsBufferPosition, optionsBufferSize);

}

{

byte[] rawName = new byte[inputBufferSize];

string name = Encoding.ASCII.GetString(rawName).TrimEnd('\0');

NetDbError netDbErrorCode = NetDbError.Success;

GaiError errno = GaiError.Overflow;

if (name.Length <= byte.MaxValue)

{

return ResultCode.Success;

}

{

byte[] rawIp = new byte[inputBufferSize];

// TODO: Use params.

uint socketLength = context.RequestData.ReadUInt32();

NetDbError netDbErrorCode = NetDbError.Success;

GaiError errno = GaiError.AddressFamily;

if (rawIp.Length == 4)

{

return ResultCode.Success;

}

{

string hostName = hostEntry.HostName + '\0';

// h_name

// h_aliases list size

// Actual aliases

foreach (string alias in hostEntry.Aliases)

{

}

// h_addrtype but it's a short (also only support IPv4)

// h_length but it's a short

// Ip address count, we can only support ipv4 (blame Nintendo)

if (addresses != null)

{

foreach (IPAddress ip in addresses)

{

}

}

return bufferPosition - originalBufferPosition;

}

{

bool enableNsdResolve = (context.RequestData.ReadInt32() & 1) != 0;

uint cancelHandle = context.RequestData.ReadUInt32();

// NOTE: We ignore hints for now.

DeserializeAddrInfos(context.Memory, (ulong)context.Request.SendBuff[2].Position, (ulong)context.Request.SendBuff[2].Size);

}

}

{

ulong originalBufferPosition = (ulong)responseBufferPosition;

ulong bufferPosition = originalBufferPosition;

// Termination zero value.

context.Memory.Write(bufferPosition, 0);

return bufferPosition - originalBufferPosition;

}

_rng.GetBytes(randomBytes);

return ResultCode.Success;

}

// SetHostName(buffer<bytes, 5>)

public ResultCode SetHostName(ServiceCtx context)

{

byte[] hostNameData = new byte[hostNameDataSize];

string hostName = Encoding.ASCII.GetString(hostNameData).Trim('\0');

// Write(buffer<bytes, 5>) -> u32

public ResultCode Write(ServiceCtx context)

{

byte[] data = new byte[inputDataSize];

// NOTE: Tell the guest everything is transferred.

uint transferredSize = (uint)inputDataSize;

{

CertificateFormat certificateFormat = (CertificateFormat)context.RequestData.ReadUInt32();

context.ResponseData.Write(_serverCertificateId++);

// ImportClientPki(buffer<bytes, 5> certificate, buffer<bytes, 5> ascii_password) -> u64 certificateId

public ResultCode ImportClientPki(ServiceCtx context)

{

byte[] asciiPasswordData = new byte[asciiPasswordDataSize];

string asciiPassword = Encoding.ASCII.GetString(asciiPasswordData).Trim('\0');

uint code = context.RequestData.ReadUInt32();

uint flags = context.RequestData.ReadUInt32();

ReadOnlySpan<byte> inputParcel = context.Memory.GetSpan(dataPos, (int)dataSize);

if (result == ResultCode.Success)

{

}

return result;

uint code = context.RequestData.ReadUInt32();

uint flags = context.RequestData.ReadUInt32();

Span<byte> outputParcel = new Span<byte>(new byte[replySize]);

if (result == ResultCode.Success)

{

}

return result;

{

byte type = context.RequestData.ReadByte();

ResultCode result = _timeManager.StandardUserSystemClock.GetClockContext(context.Thread, out SystemClockContext userContext);

{

byte type = context.RequestData.ReadByte();

context.RequestData.BaseStream.Position += 7;

private ClockSnapshot ReadClockSnapshotFromBuffer(ServiceCtx context, IpcPtrBuffDesc ipcDesc)

{

byte[] temp = new byte[ipcDesc.Size];

using (BinaryReader bufferReader = new BinaryReader(new MemoryStream(temp)))

{

uint totalLocationNameCount = context.RequestData.ReadUInt32();

UInt128 timeZoneRuleVersion = context.RequestData.ReadStruct<UInt128>();

byte[] temp = new byte[bufferSize];

using (MemoryStream timeZoneBinaryStream = new MemoryStream(temp))

{

// LoadLocationNameList(u32 index) -> (u32 outCount, buffer<nn::time::LocationName, 6>)

public ResultCode LoadLocationNameList(ServiceCtx context)

{

ResultCode errorCode = _timeZoneContentManager.LoadLocationNameList(index, out string[] locationNameArray, (uint)bufferSize / 0x24);

return ResultCode.LocationNameTooLong;

}

offset += 0x24;

}

// LoadTimeZoneRule(nn::time::LocationName locationName) -> buffer<nn::time::TimeZoneRule, 0x16>

public ResultCode LoadTimeZoneRule(ServiceCtx context)

{

if (bufferSize != 0x4000)

{

return ResultCode.PermissionDenied;

}

string locationName = Encoding.ASCII.GetString(context.RequestData.ReadBytes(0x24)).TrimEnd('\0');

byte[] temp = new byte[bufferSize];

using (MemoryStream timeZoneBinaryStream = new MemoryStream(temp))

{

// ParseTimeZoneBinary(buffer<nn::time::TimeZoneBinary, 0x21> timeZoneBinary) -> buffer<nn::time::TimeZoneRule, 0x16>

public ResultCode ParseTimeZoneBinary(ServiceCtx context)

{

if (timeZoneRuleBufferSize != 0x4000)

{

byte[] temp = new byte[bufferSize];

using (MemoryStream timeZoneBinaryStream = new MemoryStream(temp))

{

// ToCalendarTime(nn::time::PosixTime time, buffer<nn::time::TimeZoneRule, 0x15> rules) -> (nn::time::CalendarTime, nn::time::sf::CalendarAdditionalInfo)

public ResultCode ToCalendarTime(ServiceCtx context)

{

if (bufferSize != 0x4000)

{

ResultCode resultCode = _timeZoneManager.ToCalendarTimeWithMyRules(posixTime, out CalendarInfo calendar);

{

context.ResponseData.WriteStruct(calendar);

}

// ToPosixTime(nn::time::CalendarTime calendarTime, buffer<nn::time::TimeZoneRule, 0x15> rules) -> (u32 outCount, buffer<nn::time::PosixTime, 0xa>)

public ResultCode ToPosixTime(ServiceCtx context)

{

CalendarTime calendarTime = context.RequestData.ReadStruct<CalendarTime>();

ResultCode resultCode = _timeZoneManager.ToPosixTime(rules, calendarTime, out long posixTime);

{

context.ResponseData.Write(1);

}

ResultCode resultCode = _timeZoneManager.ToPosixTimeWithMyRules(calendarTime, out long posixTime);

{

// There could be only one result on one calendar as leap seconds aren't supported.

context.ResponseData.Write(1);

// ListDisplays() -> (u64, buffer<nn::vi::DisplayInfo, 6>)

public ResultCode ListDisplays(ServiceCtx context)

{

MemoryHelper.FillWithZeros(context.Memory, recBuffPtr, 0x60);

// Add only the default display to buffer

context.ResponseData.Write(1L);

// TODO: support multi display.

byte[] displayName = context.RequestData.ReadBytes(0x40);

IBinder producer = context.Device.System.SurfaceFlinger.OpenLayer(context.Request.HandleDesc.PId, layerId);

ReadOnlySpan<byte> parcelData = parcel.Finish();

context.ResponseData.Write((long)parcelData.Length);

long layerFlags = context.RequestData.ReadInt64();

long displayId = context.RequestData.ReadInt64();

// TODO: support multi display.

Display disp = _displays.GetData<Display>((int)displayId);

ReadOnlySpan<byte> parcelData = parcel.Finish();

context.ResponseData.Write(layerId);

context.ResponseData.Write((long)parcelData.Length);

// The size of the layer buffer should be an aligned multiple of width * height

// because it was created using GetIndirectLayerImageRequiredMemoryInfo as a guide.

// Fill the layer with zeros.

Logger.Stub?.PrintStub(LogClass.ServiceVi);

public static string ReadUtf8String(ServiceCtx context, int index = 0)

{

using (MemoryStream ms = new MemoryStream())

{

while (size-- > 0)

{

if (value == 0)

{

public static string ReadUtf8StringSend(ServiceCtx context, int index = 0)

{

using (MemoryStream ms = new MemoryStream())

{

using Ryujinx.Cpu;

using Ryujinx.Memory;

using System.Runtime.InteropServices;

namespace Ryujinx.HLE.Utilities

{

private IVirtualMemoryManager _memory;

{

_memory = memory;

Position = position;

}

{

T value = MemoryHelper.Read<T>(_memory, Position);

return value;

}

{

}

}

}

{

private IVirtualMemoryManager _memory;

{

_memory = memory;

Position = position;

{

MemoryHelper.Write(_memory, Position, value);

}

{

Position += count;

}