FileTransferReceiver.cs

using System;
using OSDP.Net.Model.CommandData;
using OSDP.Net.Model.ReplyData;
 
namespace OSDP.Net;

public class FileTransferReceiver
{
    public const int DefaultMaximumFileSize = 16 * 1024 * 1024;
 
    private readonly int _maximumFileSize;
 
    private byte[] _buffer;
    private int _highWaterMark;

    public FileTransferReceiver(int maximumFileSize = DefaultMaximumFileSize)
    {
        if (maximumFileSize <= 0)
        {
            throw new ArgumentOutOfRangeException(nameof(maximumFileSize), maximumFileSize,
                "The maximum file size must be greater than zero.");
        }
 
        _maximumFileSize = maximumFileSize;
    }

    public bool IsTransferInProgress => _buffer != null;

    public bool IsComplete => _buffer != null && _highWaterMark >= _buffer.Length;

    public byte FileType { get; private set; }

    public int TotalSize => _buffer?.Length ?? 0;

    public int ReceivedSize => _highWaterMark;

    public FileTransferStatus.ControlFlags Action { get; set; } = FileTransferStatus.ControlFlags.None;

    public ushort RequestedDelay { get; set; }

    public ushort UpdateMessageMaximum { get; set; }

    public FileTransferStatus AcceptFragment(FileTransferFragment fragment)
    {
        if (fragment == null) throw new ArgumentNullException(nameof(fragment));
 
        var data = fragment.Fragment;
        var fragmentData = data.DataFragment ?? [];
 
        // A fragment that is internally inconsistent is malformed, regardless of transfer state.
        if (data.TotalSize < 0 || data.Offset < 0 || data.TotalSize > _maximumFileSize ||
            data.Offset > data.TotalSize || data.FragmentSize > data.TotalSize - data.Offset ||
            data.FragmentSize > fragmentData.Length)
        {
            Reset();
            return Status(FileTransferStatus.StatusDetail.FileDataUnacceptable);
        }
 
        // Offset zero starts a transfer, which also makes an ACU retry from the beginning recover
        // cleanly rather than colliding with the abandoned buffer.
        if (data.Offset == 0)
        {
            _buffer = new byte[data.TotalSize];
            _highWaterMark = 0;
            FileType = fragment.Type;
        }
        else if (_buffer == null)
        {
            // The ACU resumed mid-file with no transfer established, so there is nothing to append to.
            return Status(FileTransferStatus.StatusDetail.FileDataUnacceptable);
        }
 
        // Changing the declared size or type mid-transfer would silently corrupt the assembled file.
        if (data.TotalSize != _buffer.Length || fragment.Type != FileType)
        {
            Reset();
            return Status(FileTransferStatus.StatusDetail.FileDataUnacceptable);
        }
 
        // A fragment starting past the contiguous region would leave a hole the PD cannot fill, since
        // osdp_FTSTAT has no way to request a specific offset.
        if (data.Offset > _highWaterMark)
        {
            Reset();
            return Status(FileTransferStatus.StatusDetail.FileDataUnacceptable);
        }
 
        if (data.FragmentSize > 0)
        {
            Array.Copy(fragmentData, 0, _buffer, data.Offset, data.FragmentSize);
            _highWaterMark = Math.Max(_highWaterMark, data.Offset + data.FragmentSize);
        }
 
        return Status(IsComplete
            ? FileTransferStatus.StatusDetail.FileContentsProcessed
            : FileTransferStatus.StatusDetail.OkToProceed);
    }

    public byte[] GetFile()
    {
        if (!IsComplete)
        {
            throw new InvalidOperationException(
                "The file transfer has not completed, so the assembled contents are not available.");
        }
 
        return (byte[])_buffer.Clone();
    }

    public void Reset()
    {
        _buffer = null;
        _highWaterMark = 0;
        FileType = 0;
    }
 
    private FileTransferStatus Status(FileTransferStatus.StatusDetail detail) =>
        new(detail, Action, RequestedDelay, UpdateMessageMaximum);
}