Device.cs

using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.Extensions.Logging;
using OSDP.Net.Connections;
using OSDP.Net.Messages;
using OSDP.Net.Messages.SecureChannel;
using OSDP.Net.Model;
using OSDP.Net.Model.CommandData;
using OSDP.Net.Model.ReplyData;
using CommunicationConfiguration = OSDP.Net.Model.CommandData.CommunicationConfiguration;
using ManufacturerSpecific = OSDP.Net.Model.CommandData.ManufacturerSpecific;
 
namespace OSDP.Net;

public class Device : IDisposable
{
    private readonly ILoggerFactory _loggerFactory;
    private readonly ILogger _logger;
    private readonly ConcurrentQueue<PayloadData> _pendingPollReplies = new();
 
    private volatile int _connectionContextCounter;
    private DeviceConfiguration _deviceConfiguration;
    private IOsdpConnectionListener _connectionListener;
    private CancellationTokenSource _cancellationTokenSource;
    private DateTime _lastValidReceivedCommand = DateTime.MinValue;

    public Device(DeviceConfiguration config, ILoggerFactory loggerFactory = null)
    {
        _deviceConfiguration = config;
        _loggerFactory = loggerFactory;
        _logger = loggerFactory?.CreateLogger<Device>();
    }

    public void Dispose()
    {
        Dispose(true);
        GC.SuppressFinalize(this);
    }

    public bool IsConnected => _connectionListener?.ConnectionCount > 0 && (
        _lastValidReceivedCommand + TimeSpan.FromSeconds(8) >= DateTime.UtcNow);

    public event EventHandler<DeviceComSetUpdatedEventArgs> DeviceComSetUpdated;

    protected virtual void Dispose(bool disposing)
    {
        if (disposing)
        {
            var _ = StopListening();
        }
    }

    public async Task StartListening(IOsdpConnectionListener connectionListener)
    {
        _connectionListener = connectionListener ?? throw new ArgumentNullException(nameof(connectionListener));
        _cancellationTokenSource = new CancellationTokenSource();
        await _connectionListener.Start(ClientListenLoop);
    }
 
    private async Task ClientListenLoop(IOsdpConnection incomingConnection)
    {
        try
        {
            var currentContextCount = _connectionContextCounter;
            var channel = new PdMessageSecureChannel(
                incomingConnection, _deviceConfiguration.SecurityKey, _deviceConfiguration.Identification.ToBytes(), _loggerFactory)
            {
                Address = _deviceConfiguration.Address,
                SecurityMode = !_deviceConfiguration.RequireSecurity
                    ? SecurityMode.Unsecured
                    : (_deviceConfiguration.SecurityKey == null ||
                       _deviceConfiguration.SecurityKey.SequenceEqual(SecurityContext.DefaultKey))
                    ? SecurityMode.InstallMode
                    : SecurityMode.FullSecurity,
                AllowUnsecured = _deviceConfiguration.AllowUnsecured ?? [],
            };
 
            while (incomingConnection.IsOpen && !_cancellationTokenSource.Token.IsCancellationRequested)
            {
                var command = await channel.ReadNextCommand(_cancellationTokenSource.Token);
 
                if (command == null) continue;
 
                var reply = HandleCommand(command);
                await channel.SendReply(reply);
 
                if (currentContextCount != _connectionContextCounter)
                {
                    _logger?.LogInformation("Interrupting existing connection due to 'force disconnect' flag");
                    break;
                }
            }
        }
        catch (OperationCanceledException)
        {
            _logger?.LogInformation("Connection loop cancelled");
        }
        catch (Exception exception)
        {
            _logger?.LogError(exception, $"Unexpected exception in polling loop");
        }
        finally
        {
            await incomingConnection.Close();
        }
    }

    public async Task StopListening()
    {
        _cancellationTokenSource?.Cancel();
        await (_connectionListener?.Stop() ?? Task.CompletedTask);
        _cancellationTokenSource?.Dispose();
        _cancellationTokenSource = null;
        _connectionListener = null;
    }

    public void EnqueuePollReply(PayloadData reply) => _pendingPollReplies.Enqueue(reply);
 
    internal virtual OutgoingReply HandleCommand(IncomingMessage command)
    {
        if (command.IsDataCorrect && Enum.IsDefined(typeof(CommandType), command.Type))
            _lastValidReceivedCommand = DateTime.UtcNow;
 
        var commandType = (CommandType)command.Type;
        var reply = commandType switch
        {
            CommandType.Poll => HandlePoll(),
            CommandType.IdReport => DispatchIdReport(command.Payload),
            CommandType.DeviceCapabilities => HandleDeviceCapabilities(),
            CommandType.LocalStatus => HandleLocalStatusReport(),
            CommandType.InputStatus => HandleInputStatusReport(),
            CommandType.OutputStatus => HandleOutputStatusReport(),
            CommandType.ReaderStatus => HandleReaderStatusReport(),
            CommandType.OutputControl => HandleOutputControl(OutputControls.ParseData(command.Payload)),
            CommandType.LEDControl => HandleReaderLEDControl(ReaderLedControls.ParseData(command.Payload)),
            CommandType.BuzzerControl => HandleBuzzerControl(ReaderBuzzerControl.ParseData(command.Payload)),
            CommandType.TextOutput => HandleTextOutput(ReaderTextOutput.ParseData(command.Payload)),
            CommandType.CommunicationSet => _HandleCommunicationSet(CommunicationConfiguration.ParseData(command.Payload)),
            CommandType.BioRead => HandleBiometricRead(BiometricReadData.ParseData(command.Payload)),
            CommandType.BioMatch => HandleBiometricMatch(BiometricTemplateData.ParseData(command.Payload)),
            CommandType.KeySet => _HandleKeySettings(EncryptionKeyConfiguration.ParseData(command.Payload)),
            CommandType.MaxReplySize => HandleMaxReplySize(ACUReceiveSize.ParseData(command.Payload)),
            CommandType.FileTransfer => HandleFileTransfer(FileTransferFragment.ParseData(command.Payload)),
            CommandType.ManufacturerSpecific => HandleManufacturerCommand(ManufacturerSpecific.ParseData(command.Payload)),
            CommandType.ExtendedWrite => HandleExtendedWrite(ExtendedWrite.ParseData(command.Payload)),
            CommandType.Abort => HandleAbortRequest(),
            CommandType.PivData => HandlePivData(GetPIVData.ParseData(command.Payload)),
            CommandType.KeepActive => HandleKeepActive(KeepReaderActive.ParseData(command.Payload)),
            _ => HandleUnknownCommand(command)
        };
 
        return new OutgoingReply(command, EnsureValidReply(commandType, reply));
    }

    private static readonly Dictionary<CommandType, ReplyType[]> MandatoryReportReplies = new()
    {
        [CommandType.IdReport] = new[] { ReplyType.PdIdReport, ReplyType.ExtendedPdIdReport },
        [CommandType.DeviceCapabilities] = new[] { ReplyType.PdCapabilitiesReport },
        [CommandType.LocalStatus] = new[] { ReplyType.LocalStatusReport },
        [CommandType.InputStatus] = new[] { ReplyType.InputStatusReport },
        [CommandType.OutputStatus] = new[] { ReplyType.OutputStatusReport },
        [CommandType.ReaderStatus] = new[] { ReplyType.ReaderStatusReport },
        [CommandType.FileTransfer] = new[] { ReplyType.FileTransferStatus }
    };

    internal PayloadData EnsureValidReply(CommandType commandType, PayloadData reply)
    {
        if (!MandatoryReportReplies.TryGetValue(commandType, out var validReplies))
        {
            return reply;
        }
 
        var replyType = (ReplyType)reply.Code;
        if (replyType == ReplyType.Nak || replyType == ReplyType.Busy ||
            Array.IndexOf(validReplies, replyType) >= 0)
        {
            return reply;
        }
 
        _logger?.LogError(
            "Handler for {CommandType} returned an invalid reply ({ReplyType}); substituting NAK. " +
            "A spec-compliant PD must answer with one of [{ValidReplies}], or NAK/BUSY.",
            commandType, replyType, string.Join(", ", validReplies));
 
        return new Nak(ErrorCode.UnknownCommandCode);
    }
 
    private PayloadData HandlePoll()
    {
        return _pendingPollReplies.TryDequeue(out var reply) ? reply : new Ack();
    }
 
    private PayloadData DispatchIdReport(ReadOnlySpan<byte> payload)
    {
        // Check if the request is for extended ID (data byte = 0x01)
        if (payload.Length > 0 && payload[0] == 0x01)
        {
            return HandleExtendedIdReport();
        }
 
        return HandleIdReport();
    }

    protected virtual PayloadData HandleIdReport()
    {
        return HandleUnknownCommand(CommandType.IdReport);
    }

    protected virtual PayloadData HandleExtendedIdReport()
    {
        return HandleUnknownCommand(CommandType.IdReport);
    }

    protected virtual PayloadData HandleTextOutput(ReaderTextOutput commandPayload)
    {
        return HandleUnknownCommand(CommandType.TextOutput);
    }

    protected virtual PayloadData HandleBuzzerControl(ReaderBuzzerControl commandPayload)
    {
        return HandleUnknownCommand(CommandType.BuzzerControl);
    }

    protected virtual PayloadData HandleOutputControl(OutputControls commandPayload)
    {
        return HandleUnknownCommand(CommandType.OutputControl);
    }

    protected virtual PayloadData HandleDeviceCapabilities()
    {
        return HandleUnknownCommand(CommandType.DeviceCapabilities);
    }

    protected virtual PayloadData HandlePivData(GetPIVData commandPayload)
    {
        return HandleUnknownCommand(CommandType.PivData);
    }

    protected virtual PayloadData HandleManufacturerCommand(ManufacturerSpecific commandPayload)
    {
        return HandleUnknownCommand(CommandType.ManufacturerSpecific);
    }

    protected virtual PayloadData HandleExtendedWrite(ExtendedWrite commandPayload)
    {
        return HandleUnknownCommand(CommandType.ExtendedWrite);
    }

    protected virtual PayloadData HandleKeepActive(KeepReaderActive commandPayload)
    {
        return HandleUnknownCommand(CommandType.KeepActive);
    }

    protected virtual PayloadData HandleAbortRequest()
    {
        return HandleUnknownCommand(CommandType.Abort);
    }

    protected virtual PayloadData HandleFileTransfer(FileTransferFragment commandPayload)
    {
        _logger?.LogInformation("Received a file transfer command: {CommandPayload}", commandPayload.ToString());
        return HandleUnknownCommand(CommandType.FileTransfer);
    }

    protected virtual PayloadData HandleMaxReplySize(ACUReceiveSize commandPayload)
    {
        return HandleUnknownCommand(CommandType.MaxReplySize);
    }
 
    private PayloadData _HandleKeySettings(EncryptionKeyConfiguration commandPayload)
    {
        var response = HandleKeySettings(commandPayload);
 
        if (response.Code == (byte)ReplyType.Ack)
        {
            UpdateDeviceConfig(c => c.SecurityKey = commandPayload.KeyData);
        }
 
        return response;
    }

    protected virtual PayloadData HandleKeySettings(EncryptionKeyConfiguration commandPayload)
    {
        return HandleUnknownCommand(CommandType.KeySet);
    }

    protected virtual PayloadData HandleBiometricMatch(BiometricTemplateData commandPayload)
    {
        return HandleUnknownCommand(CommandType.BioMatch);
    }

    protected virtual PayloadData HandleBiometricRead(BiometricReadData commandPayload)
    {
        return HandleUnknownCommand(CommandType.BioRead);
    }
 
    private PayloadData _HandleCommunicationSet(CommunicationConfiguration commandPayload)
    {
        var response = HandleCommunicationSet(commandPayload);
 
        if (response.Code == (byte)ReplyType.PdCommunicationsConfigurationReport)
        {
            var config = (Model.ReplyData.CommunicationConfiguration)response;
            var previousAddress = _deviceConfiguration.Address;
            var previousBaudRate = _connectionListener.BaudRate;
 
            if (previousAddress != config.Address)
            {
                UpdateDeviceConfig(c => c.Address = config.Address);
            }
            
            if (previousBaudRate != config.BaudRate || previousAddress != config.Address)
            {
                var updatedEvent = DeviceComSetUpdated;
                if (updatedEvent != null) 
                {
                    // Decouple a current call stack from the event invocation, which could result
                    // in the event subscriber resetting the entire connection so that the current
                    // command has a chance to run to completion, and we don't have any deadlock
                    // situations.
                    Task.Run(() =>
                    {
                        updatedEvent.Invoke(this, new DeviceComSetUpdatedEventArgs()
                        {
                            OldAddress = previousAddress,
                            OldBaudRate = previousBaudRate,
                            NewAddress = config.Address,
                            NewBaudRate = config.BaudRate,
                        });
                    });
                }
            }
        }
 
        return response;
    }

    protected virtual PayloadData HandleCommunicationSet(CommunicationConfiguration commandPayload)
    {
        return HandleUnknownCommand(CommandType.CommunicationSet);
    }

    protected virtual PayloadData HandleReaderLEDControl(ReaderLedControls commandPayload)
    {
        return HandleUnknownCommand(CommandType.LEDControl);
    }

    protected virtual PayloadData HandleReaderStatusReport()
    {
        return HandleUnknownCommand(CommandType.ReaderStatus);
    }

    protected virtual PayloadData HandleOutputStatusReport()
    {
        return HandleUnknownCommand(CommandType.OutputStatus);
    }

    protected virtual PayloadData HandleInputStatusReport()
    {
        return HandleUnknownCommand(CommandType.InputStatus);
    }

    protected virtual PayloadData HandleLocalStatusReport()
    {
        return HandleUnknownCommand(CommandType.LocalStatus);
    }
 
    private PayloadData HandleUnknownCommand(IncomingMessage command)
    {
        _logger?.LogInformation("Unexpected Command: {CommandType}", (CommandType)command.Type);
 
        return new Nak(ErrorCode.UnknownCommandCode);
    }
 
   private PayloadData HandleUnknownCommand(CommandType commandType)
    {
        _logger?.LogInformation("Unexpected Command: {CommandType}", commandType);
 
        return new Nak(ErrorCode.UnknownCommandCode);
    }
 
    private void UpdateDeviceConfig(Action<DeviceConfiguration> updateAction, bool resetConnection = false)
    {
        var configCopy = _deviceConfiguration.Clone();
        updateAction(configCopy);
        _deviceConfiguration = configCopy;
 
        if (resetConnection)
        {
            Interlocked.Add(ref _connectionContextCounter, 1);
        }
    }
    
    public class DeviceComSetUpdatedEventArgs : EventArgs
    {
        public byte OldAddress { get; set; }

        public byte NewAddress { get; set; }

        public int OldBaudRate {  get; set; }

        public int NewBaudRate { get; set; }
    }
}
 

public class DeviceConfiguration : ICloneable
{
    public DeviceConfiguration(ClientIdentification identification)
    {
        Identification = identification;
    }

    public byte Address { get; set; }

    public bool RequireSecurity { get; set; } = true;

    public byte[] SecurityKey { get; set; } = SecurityContext.DefaultKey;

    public CommandType[] AllowUnsecured { get; set; } =
    [
        CommandType.IdReport, CommandType.DeviceCapabilities, CommandType.CommunicationSet
    ];

    public ClientIdentification Identification { get; }

    public DeviceConfiguration Clone() => (DeviceConfiguration)this.MemberwiseClone();

    object ICloneable.Clone() => Clone();
}