NdsElfProgramImporter.cs

using System.Buffers;
 
namespace NdsForge;

public static class NdsElfProgramImporter
{
    public static NdsElfImportResult Import(
        ReadOnlyMemory<byte> data,
        NdsProcessor processor,
        NdsElfImportOptions? options = null)
    {
        NdsElfImportOptions effectiveOptions = Snapshot(options);
        ValidateProcessor(processor);
        if (data.Length > effectiveOptions.MaxInputBytes)
        {
            throw new InvalidDataException("The ELF input exceeds the configured allocation limit.");
        }
 
        NdsElfFile elf = NdsElfParser.Parse(data, effectiveOptions);
        return NdsElfAssembler.Assemble(data, elf, processor, effectiveOptions);
    }

    public static async ValueTask<NdsElfImportResult> ImportAsync(
        string path,
        NdsProcessor processor,
        NdsElfImportOptions? options = null,
        CancellationToken cancellationToken = default)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(path);
        NdsElfImportOptions effectiveOptions = Snapshot(options);
        ValidateProcessor(processor);
        var stream = new FileStream(
            path,
            FileMode.Open,
            FileAccess.Read,
            FileShare.Read,
            64 * 1024,
            FileOptions.Asynchronous | FileOptions.SequentialScan);
        await using (stream.ConfigureAwait(false))
        {
            return await ImportAsync(stream, processor, leaveOpen: true, effectiveOptions, cancellationToken).ConfigureAwait(false);
        }
    }

    public static async ValueTask<NdsElfImportResult> ImportAsync(
        Stream stream,
        NdsProcessor processor,
        bool leaveOpen = false,
        NdsElfImportOptions? options = null,
        CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(stream);
        NdsElfImportOptions effectiveOptions = Snapshot(options);
        ValidateProcessor(processor);
        try
        {
            if (!stream.CanRead)
            {
                throw new ArgumentException("The ELF source stream must be readable.", nameof(stream));
            }
 
            byte[] data = await ReadBoundedAsync(stream, effectiveOptions.MaxInputBytes, cancellationToken).ConfigureAwait(false);
            return Import(data, processor, effectiveOptions);
        }
        finally
        {
            if (!leaveOpen)
            {
                await stream.DisposeAsync().ConfigureAwait(false);
            }
        }
    }

    private static async ValueTask<byte[]> ReadBoundedAsync(
        Stream source,
        long limit,
        CancellationToken cancellationToken)
    {
        if (source.CanSeek && source.Length - source.Position > limit)
        {
            throw new InvalidDataException("The ELF input exceeds the configured allocation limit.");
        }
 
        byte[] buffer = ArrayPool<byte>.Shared.Rent(64 * 1024);
        try
        {
            using var output = new MemoryStream();
            while (true)
            {
                int count = await source.ReadAsync(buffer, cancellationToken).ConfigureAwait(false);
                if (count == 0)
                {
                    return output.ToArray();
                }
 
                if (output.Length > limit - count)
                {
                    throw new InvalidDataException("The ELF input exceeds the configured allocation limit.");
                }
 
                await output.WriteAsync(buffer.AsMemory(0, count), cancellationToken).ConfigureAwait(false);
            }
        }
        finally
        {
            ArrayPool<byte>.Shared.Return(buffer, clearArray: true);
        }
    }

    private static NdsElfImportOptions Snapshot(NdsElfImportOptions? options)
    {
        options ??= NdsElfImportOptions.Default;
        var snapshot = new NdsElfImportOptions
        {
            MaxInputBytes = options.MaxInputBytes,
            MaxProgramBytes = options.MaxProgramBytes,
            MaxProgramHeaders = options.MaxProgramHeaders,
            MaxOverlays = options.MaxOverlays,
            ImportOverlays = options.ImportOverlays,
        };
        snapshot.Validate();
        return snapshot;
    }

    private static void ValidateProcessor(NdsProcessor processor)
    {
        if (!Enum.IsDefined(processor))
        {
            throw new ArgumentOutOfRangeException(nameof(processor), processor, "Unknown NDS processor identity.");
        }
    }
}