RowTcpClient.cs

using System.Text;
using System.Threading.Tasks;
#if WINDOWS_UWP
using Windows.Networking.Sockets;
#else
using System.Net.Sockets;
#endif
using Waher.Events;
using Waher.Networking.Sniffers;
 
namespace Waher.Networking
{
    public class RowTcpClient : TextTcpClient
    {
        private readonly StringBuilder buffer = new StringBuilder();
        private readonly int maxLen = 0;
        private char prev = (char)0;
        private bool error = false;
        private int len = 0;
 
        public RowTcpClient(Encoding Encoding, int MaxLength, bool DecoupledEvents, params ISniffer[] Sniffers)
            : base(Encoding, DecoupledEvents, Sniffers)
        {
            this.maxLen = MaxLength;
        }
 
        public RowTcpClient(Encoding Encoding, int MaxLength, bool SniffText, bool DecoupledEvents, params ISniffer[] Sniffers)
            : base(Encoding, SniffText, DecoupledEvents, Sniffers)
        {
            this.maxLen = MaxLength;
        }
 
#if WINDOWS_UWP
        public RowTcpClient(StreamSocket Client, Encoding Encoding, int MaxLength, bool DecoupledEvents, params ISniffer[] Sniffers)
            : base(Client, Encoding, DecoupledEvents, Sniffers)
        {
            this.maxLen = MaxLength;
        }
 
        public RowTcpClient(StreamSocket Client, Encoding Encoding, int MaxLength, bool SniffText, bool DecoupledEvents, params ISniffer[] Sniffers)
            : base(Client, Encoding, SniffText, DecoupledEvents, Sniffers)
        {
            this.maxLen = MaxLength;
        }
#else
        public RowTcpClient(TcpClient Client, Encoding Encoding, int MaxLength, bool DecoupledEvents, params ISniffer[] Sniffers)
            : base(Client, Encoding, DecoupledEvents, Sniffers)
        {
            this.maxLen = MaxLength;
        }
 
        public RowTcpClient(TcpClient Client, Encoding Encoding, int MaxLength, bool SniffText, bool DecoupledEvents, params ISniffer[] Sniffers)
            : base(Client, Encoding, SniffText, DecoupledEvents, Sniffers)
        {
            this.maxLen = MaxLength;
        }
#endif
 
        protected async override Task<bool> TextDataReceived(string Data)
        {
            foreach (char ch in Data)
            {
                if (ch == '\r' || ch == '\n')
                {
                    if (this.len == 0)
                    {
                        if (this.prev == ch && !await base.TextDataReceived(string.Empty))
                            return false;
                    }
                    else
                    {
                        if (this.error)
                        {
                            await this.Error("Row too long: " + this.len.ToString() + " characters");
                            this.error = false;
                        }
                        else if (!await base.TextDataReceived(this.buffer.ToString()))
                            return false;
 
                        this.len = 0;
                        this.buffer.Clear();
                        this.prev = ch;
                    }
                }
                else
                {
                    if (this.len++ > this.maxLen)
                        this.error = true;
                    else
                        this.buffer.Append(ch);
 
                    this.prev = (char)0;
                }
            }
 
            return true;
        }
 
        public override Task<bool> SendAsync(string Packet)
        {
            return this.SendAsync(Packet, null, null);
        }
 
        public override Task<bool> SendAsync(string Text, EventHandlerAsync<DeliveryEventArgs> Callback, object State)
        {
            return base.SendAsync(Text + "\r\n", Callback, State);
        }
 
        protected override Task TextDataSent(string Data)
        {
            return base.TextDataSent(Data.Substring(0, Data.Length - 2));
        }
 
    }
}