Ejemplo n.º 1
0
        public static async Task <bool> IsNcsd(IReadOnlyBinaryDataAccessor file)
        {
            try
            {
                if (file.Length < 0x104)
                {
                    return(false);
                }

                return(await file.ReadStringAsync(0x100, 4, Encoding.ASCII) == "NCSD");
            }
            catch (Exception)
            {
                return(false);
            }
        }
Ejemplo n.º 2
0
        public static async Task <NcchExtendedHeader> Load(IReadOnlyBinaryDataAccessor data)
        {
            var header = new NcchExtendedHeader
            {
                ApplicationTitle    = await data.ReadStringAsync(0, 8, Encoding.ASCII),
                Reserved1           = await data.ReadArrayAsync(8, 5),
                Flag                = await data.ReadByteAsync(0xD),
                RemasterVersion     = await data.ReadInt16Async(0xE),
                TextCodeSetInfo     = await CodeSetInfo.Load(data.Slice(0x10, 0xC)),
                StackSize           = await data.ReadInt32Async(0x1C),
                ReadOnlyCodeSetInfo = await CodeSetInfo.Load(data.Slice(0x20, 0xC)),
                Reserved2           = await data.ReadInt32Async(0x2C),
                DataCodeSetInfo     = await CodeSetInfo.Load(data.Slice(0x30, 0xC)),
                BssSize             = await data.ReadInt32Async(0x3C)
            };

            var moduleIds = new long[48];
            await AsyncFor.For(0, 48 - 1, async i =>
            {
                moduleIds[i] = await data.ReadInt64Async(0x40 + i * 8);
            });

            header.DependencyModuleIds = moduleIds;

            header.SystemInformation = await SystemInfo.Load(data.Slice(0x1C0, 0x40));

            header.LocalSystemCapabilities = await Arm11LocalSystemCapabilities.Load(data.Slice(0x200, 0x170));

            header.KernelCapabilities = await Arm11KernelCapabilities.Load(data.Slice(0x370, 0x80));

            header.AccessControl = await Arm9AccessControl.Load(data.Slice(0x3F0, 0x10));

            header.AccessDescSignature = await data.ReadArrayAsync(0x400, 0x100);

            header.NcchHdrPublicKey = await data.ReadArrayAsync(0x500, 0x100);

            header.Aci = await data.ReadArrayAsync(0x600, 0x200);

            return(header);
        }
Ejemplo n.º 3
0
        public async Task Initialize(IReadOnlyBinaryDataAccessor data)
        {
            this.RawData = data;
            if (Header != null && Header.RomFsSize > 0)
            {
                if (Header.ExeFsOffset > 0 && Header.ExeFsSize > 0)
                {
                    ExeFs = await ExeFs.Load(data.Slice((long)Header.ExeFsOffset *MediaUnitSize, (long)Header.ExeFsSize *MediaUnitSize));
                }
                if (Header.RomFsOffset > 0 && Header.RomFsOffset > 0)
                {
                    RomFs = await RomFs.Load(data.Slice((long)Header.RomFsOffset *MediaUnitSize, (long)Header.RomFsSize *MediaUnitSize));
                }
                if (Header.ExHeaderSize > 0)
                {
                    ExHeader = await NcchExtendedHeader.Load(data.Slice(0x200, Header.ExHeaderSize));
                }

                PlainRegion = await data.ReadStringAsync(Header.PlainRegionOffset *MediaUnitSize, Header.PlainRegionSize *MediaUnitSize, Encoding.ASCII);

                Logo = await data.ReadArrayAsync(Header.LogoRegionOffset *MediaUnitSize, Header.LogoRegionSize *MediaUnitSize);
            }
        }