IsoDepReplay.cs

using System;
using System.Collections;
using System.Globalization;
using System.Text;
using System.Threading.Tasks;
using System.Xml;
using NeuroAccess.Nfc.TravelDocuments;
using Waher.Content.Xml;
using Waher.Networking;
 
namespace NeuroAccess.Nfc
{
    public class IsoDepReplay : IIsoDepInterface
    {
        private readonly XmlDocument replayXml;
        private readonly IEnumerator replayEnumerator;
        private readonly DocumentInformation docInfo;
        private readonly string mrz;
        private bool eof = false;
        private bool disposed = false;
 
        public IsoDepReplay(string ReplayFileName)
            : this(XML.LoadFromFile(ReplayFileName))
        {
        }
 
        public IsoDepReplay(XmlDocument ReplayXml)
        {
            if (ReplayXml?.DocumentElement is null)
                throw new ArgumentNullException(nameof(ReplayXml), "Missing XML.");
 
            if (ReplayXml.DocumentElement.Name != "SnifferOutput" ||
                ReplayXml.DocumentElement.NamespaceURI != "http://waher.se/Schema/SnifferOutput.xsd")
            {
                throw new ArgumentException("Not a sniffer output XML file.", nameof(ReplayXml));
            }
 
            this.replayXml = ReplayXml;
            this.replayEnumerator = this.replayXml.DocumentElement.GetEnumerator();
 
            if (!this.replayEnumerator.MoveNext() ||
                this.replayEnumerator.Current is not XmlElement E ||
                E.LocalName != "Info")
            {
                throw new ArgumentException("Not an NFC replay sniffer output XML file.", nameof(ReplayXml));
            }
 
            this.mrz = GetRows(E).Replace("\r\n", "\n").Replace('\r', '\n').Trim();
 
            if (!MrzExtensions.ParseMrz(this.mrz, out DocumentInformation? DocInfo))
                throw new ArgumentException("Invalid Document Information in MRZ in NFC replay sniffer output XML file.", nameof(ReplayXml));
 
            this.docInfo = DocInfo;
        }
 
        public string Mrz => this.mrz;
 
        public DocumentInformation DocumentInfo => this.docInfo;
 
        public INfcTag? Tag => null;
 
        public Task OpenIfClosed()
        {
            this.replayEnumerator.Reset();
            return Task.CompletedTask;
        }
 
        public void CloseIfOpen() { }
 
        public Task<byte[]> GetHighLayerResponse() => Task.FromResult<byte[]>([]);
 
        public Task<byte[]> GetHistoricalBytes() => Task.FromResult<byte[]>([]);
 
        public void SetTimeout(int Timeout) { }
 
        public void Dispose()
        {
            this.Dispose(true);
            GC.SuppressFinalize(this);
        }
 
        protected virtual void Dispose(bool Disposing)
        {
            if (this.disposed)
                return;
 
            if (Disposing)
                this.CloseIfOpen();
 
            this.disposed = true;
        }
 
        public Task<byte[]> ExecuteCommand(byte[] Command, ICommunicationLayer CommunicationLayer)
        {
            CommunicationLayer.TransmitBinary(false, Command);
 
            if (this.eof)
                throw Error("End of replay reached.", CommunicationLayer);
 
            while (this.replayEnumerator.MoveNext())
            {
                if (this.replayEnumerator.Current is XmlElement E &&
                    E.LocalName == "Tx" &&
                    AreSame(Command, GetBin(E)))
                {
                    while (this.replayEnumerator.MoveNext())
                    {
                        if (this.replayEnumerator.Current is XmlElement E2 &&
                            E2.LocalName == "Rx")
                        {
                            return Task.FromResult(GetBin(E2));
                        }
                    }
                }
            }
 
            this.eof = true;
            throw Error("Command not found in replay.", CommunicationLayer);
        }
 
        public string GetInfo(string Prefix, ICommunicationLayer CommunicationLayer)
        {
            if (this.eof)
                throw Error("End of replay reached.", CommunicationLayer);
 
            while (this.replayEnumerator.MoveNext())
            {
                if (this.replayEnumerator.Current is XmlElement E &&
                    E.LocalName == "Info")
                {
                    string Info = GetRows(E, true);
 
                    if (Info.StartsWith(Prefix, StringComparison.InvariantCultureIgnoreCase))
                        return Info[Prefix.Length..].Trim();
                }
            }
 
            throw Error("Information not found: " + Prefix, CommunicationLayer);
        }
 
        public static byte[] GetBin(XmlElement Event)
        {
            return Convert.FromBase64String(GetRows(Event, false));
        }
 
        public static string GetRows(XmlElement Event)
        {
            return GetRows(Event, true);
        }
 
        public static string GetRows(XmlElement Event, bool MultiRow)
        {
            StringBuilder sb = new();
 
            foreach (XmlNode N in Event.ChildNodes)
            {
                if (N is XmlElement E2 && E2.LocalName == "Row")
                {
                    sb.Append(E2.InnerText);
                    if (MultiRow)
                        sb.AppendLine();
                }
            }
 
            return sb.ToString();
        }
 
        private static bool AreSame(byte[] Bin1, byte[] Bin2)
        {
            int i, c = Bin1.Length;
 
            if (Bin2.Length != c)
                return false;
 
            for (i = 0; i < c; i++)
            {
                if (Bin1[i] != Bin2[i])
                    return false;
            }
 
            return true;
        }
 
        private static Exception Error(string Message, ICommunicationLayer CommunicationLayer)
        {
            CommunicationLayer.Error(Message);
            return new Exception(Message);
        }
 
    }
}