spc-kiosk-pb/Library/FluentFTP/FtpSocketStream.cs

using System;
using System.IO;
using System.Net.Sockets;
using System.Net.Security;
using System.Security.Authentication;
using System.Security.Cryptography.X509Certificates;
using System.Threading;
using System.Collections.Generic;
using System.Diagnostics;
using System.Net;
#if CORE
using System.Threading.Tasks;
#endif

namespace FluentFTP {
	/// <summary>
	/// Event fired if a bad SSL certificate is encountered. This even is used internally; if you
	/// don't have a specific reason for using it you are probably looking for FtpSslValidation.
	/// </summary>
	/// <param name="stream"></param>
	/// <param name="e"></param>
	public delegate void FtpSocketStreamSslValidation(FtpSocketStream stream, FtpSslValidationEventArgs e);

	/// <summary>
	/// Event args for the FtpSslValidationError delegate
	/// </summary>
	public class FtpSslValidationEventArgs : EventArgs {
		X509Certificate m_certificate = null;
		/// <summary>
		/// The certificate to be validated
		/// </summary>
		public X509Certificate Certificate {
			get {
				return m_certificate;
			}
			set {
				m_certificate = value;
			}
		}

		X509Chain m_chain = null;
		/// <summary>
		/// The certificate chain
		/// </summary>
		public X509Chain Chain {
			get {
				return m_chain;
			}
			set {
				m_chain = value;
			}
		}

		SslPolicyErrors m_policyErrors = SslPolicyErrors.None;
		/// <summary>
		/// Validation errors, if any.
		/// </summary>
		public SslPolicyErrors PolicyErrors {
			get {
				return m_policyErrors;
			}
			set {
				m_policyErrors = value;
			}
		}

		bool m_accept = false;
		/// <summary>
		/// Gets or sets a value indicating if this certificate should be accepted. The default
		/// value is false. If the certificate is not accepted, an AuthenticationException will
		/// be thrown.
		/// </summary>
		public bool Accept {
			get {
				return m_accept;
			}
			set {
				m_accept = value;
			}
		}
	}

	/// <summary>
	/// Stream class used for talking. Used by FtpClient, extended by FtpDataStream
	/// </summary>
	public class FtpSocketStream : Stream, IDisposable {
		/// <summary>
		/// Used for tacking read/write activity on the socket
		/// to determine if Poll() should be used to test for
		/// socket conenctivity. The socket in this class will
		/// not know it has been disconnected if the remote host
		/// closes the connection first. Using Poll() avoids 
		/// the exception that would be thrown when trying to
		/// read or write to the disconnected socket.
		/// </summary>
		private DateTime m_lastActivity = DateTime.Now;

		private Socket m_socket = null;
		/// <summary>
		/// The socket used for talking
		/// </summary>
		protected Socket Socket {
			get {
				return m_socket;
			}
			private set {
				m_socket = value;
			}
		}

		int m_socketPollInterval = 15000;
		/// <summary>
		/// Gets or sets the length of time in miliseconds
		/// that must pass since the last socket activity
		/// before calling Poll() on the socket to test for
		/// connectivity. Setting this interval too low will
		/// have a negative impact on perfomance. Setting this
		/// interval to 0 disables Poll()'ing all together.
		/// The default value is 15 seconds.
		/// </summary>
		public int SocketPollInterval {
			get { return m_socketPollInterval; }
			set { m_socketPollInterval = value; }
		}

		/// <summary>
		/// Gets the number of available bytes on the socket, 0 if the
		/// socket has not been initalized. This property is used internally
		/// by FtpClient in an effort to detect disconnections and gracefully
		/// reconnect the control connection.
		/// </summary>
		internal int SocketDataAvailable {
			get {
				if (m_socket != null)
					return m_socket.Available;
				return 0;
			}
		}

		/// <summary>
		/// Gets a value indicating if this socket stream is connected
		/// </summary>
		public bool IsConnected {
			get {
				try {
					if (m_socket == null)
						return false;

					if (!m_socket.Connected) {
						Close();
						return false;
					}

					if (!CanRead || !CanWrite) {
						Close();
						return false;
					}

					if (m_socketPollInterval > 0 && DateTime.Now.Subtract(m_lastActivity).TotalMilliseconds > m_socketPollInterval) {
						FtpTrace.WriteLine("Testing connectivity using Socket.Poll()...");
						if (m_socket.Poll(500000, SelectMode.SelectRead) && m_socket.Available == 0) {
							Close();
							return false;
						}
					}
				} catch (SocketException sockex) {
					Close();
					FtpTrace.WriteLine("FtpSocketStream.IsConnected: Caught and discarded SocketException while testing for connectivity: {0}", sockex.ToString());
					return false;
				} catch (IOException ioex) {
					Close();
					FtpTrace.WriteLine("FtpSocketStream.IsConnected: Caught and discarded IOException while testing for connectivity: {0}", ioex.ToString());
					return false;
				}

				return true;
			}
		}

		/// <summary>
		/// Gets a value indicating if encryption is being used
		/// </summary>
		public bool IsEncrypted {
			get {
#if NO_SSL
				return false;
#else
				return m_sslStream != null;
#endif
			}
		}

		NetworkStream m_netStream = null;
		/// <summary>
		/// The non-encrypted stream
		/// </summary>
		private NetworkStream NetworkStream {
			get {
				return m_netStream;
			}
			set {
				m_netStream = value;
			}
		}

#if !NO_SSL
		SslStream m_sslStream = null;
		/// <summary>
		/// The encrypted stream
		/// </summary>
		private SslStream SslStream {
			get {
				return m_sslStream;
			}
			set {
				m_sslStream = value;
			}
		}
#endif

		/// <summary>
		/// Underlying stream, could be a NetworkStream or SslStream
		/// </summary>
		protected Stream BaseStream {
			get {
#if NO_SSL
				if (m_netStream != null)
					return m_netStream;
#else
				if (m_sslStream != null)
					return m_sslStream;
				else if (m_netStream != null)
					return m_netStream;
#endif

				return null;
			}
		}

		/// <summary>
		/// Gets a value indicating if this stream can be read
		/// </summary>
		public override bool CanRead {
			get {
				if (m_netStream != null)
					return m_netStream.CanRead;
				return false;
			}
		}

		/// <summary>
		/// Gets a value indicating if this stream if seekable
		/// </summary>
		public override bool CanSeek {
			get {
				return false;
			}
		}

		/// <summary>
		/// Gets a value indicating if this stream can be written to
		/// </summary>
		public override bool CanWrite {
			get {
				if (m_netStream != null)
					return m_netStream.CanWrite;

				return false;
			}
		}

		/// <summary>
		/// Gets the length of the stream
		/// </summary>
		public override long Length {
			get {
				return 0;
			}
		}

		/// <summary>
		/// Gets the current position of the stream. Trying to
		/// set this property throws an InvalidOperationException()
		/// </summary>
		public override long Position {
			get {
				if (BaseStream != null)
					return BaseStream.Position;
				return 0;
			}
			set {
				throw new InvalidOperationException();
			}
		}

		event FtpSocketStreamSslValidation m_sslvalidate = null;
		/// <summary>
		/// Event is fired when a SSL certificate needs to be validated
		/// </summary>
		public event FtpSocketStreamSslValidation ValidateCertificate {
			add {
				m_sslvalidate += value;
			}
			remove {
				m_sslvalidate -= value;
			}
		}

		int m_readTimeout = Timeout.Infinite;
		/// <summary>
		/// Gets or sets the amount of time to wait for a read operation to complete. Default
		/// value is Timeout.Infinite.
		/// </summary>
		public override int ReadTimeout {
			get {
				return m_readTimeout;
			}
			set {
				m_readTimeout = value;
			}
		}

		int m_connectTimeout = 30000;
		/// <summary>
		/// Gets or sets the length of time miliseconds to wait
		/// for a connection succeed before giving up. The default
		/// is 30000 (30 seconds).
		/// </summary>
		public int ConnectTimeout {
			get {
				return m_connectTimeout;
			}
			set {
				m_connectTimeout = value;
			}
		}

		/// <summary>
		/// Gets the local end point of the socket
		/// </summary>
		public IPEndPoint LocalEndPoint {
			get {
				if (m_socket == null)
					return null;
				return (IPEndPoint)m_socket.LocalEndPoint;
			}
		}

		/// <summary>
		/// Gets the remote end point of the socket
		/// </summary>
		public IPEndPoint RemoteEndPoint {
			get {
				if (m_socket == null)
					return null;
				return (IPEndPoint)m_socket.RemoteEndPoint;
			}
		}

		/// <summary>
		/// Fires the SSL certificate validation event
		/// </summary>
		/// <param name="certificate">Certificate being validated</param>
		/// <param name="chain">Certificate chain</param>
		/// <param name="errors">Policy errors if any</param>
		/// <returns>True if it was accepted, false otherwise</returns>
		protected bool OnValidateCertificate(X509Certificate certificate, X509Chain chain, SslPolicyErrors errors) {
			FtpSocketStreamSslValidation evt = m_sslvalidate;

			if (evt != null) {
				FtpSslValidationEventArgs e = new FtpSslValidationEventArgs() {
					Certificate = certificate,
					Chain = chain,
					PolicyErrors = errors,
					Accept = (errors == SslPolicyErrors.None)
				};

				evt(this, e);
				return e.Accept;
			}

			// if the event was not handled then only accept
			// the certificate if there were no validation errors
			return (errors == SslPolicyErrors.None);
		}

		/// <summary>
		/// Throws an InvalidOperationException
		/// </summary>
		/// <param name="offset">Ignored</param>
		/// <param name="origin">Ignored</param>
		/// <returns></returns>
		public override long Seek(long offset, SeekOrigin origin) {
			throw new InvalidOperationException();
		}

		/// <summary>
		/// Throws an InvalidOperationException
		/// </summary>
		/// <param name="value">Ignored</param>
		public override void SetLength(long value) {
			throw new InvalidOperationException();
		}

		/// <summary>
		/// Flushes the stream
		/// </summary>
		public override void Flush() {
			if (!IsConnected)
				throw new InvalidOperationException("The FtpSocketStream object is not connected.");

			if (BaseStream == null)
				throw new InvalidOperationException("The base stream of the FtpSocketStream object is null.");

			BaseStream.Flush();
		}

		/// <summary>
		/// Bypass the stream and read directly off the socket.
		/// </summary>
		/// <param name="buffer">The buffer to read into</param>
		/// <returns>The number of bytes read</returns>
		internal int RawSocketRead(byte[] buffer) {
			int read = 0;

			if (m_socket != null && m_socket.Connected) {
				read = m_socket.Receive(buffer, buffer.Length, 0);
			}

			return read;
		}

		/// <summary>
		/// Reads data from the stream
		/// </summary>
		/// <param name="buffer">Buffer to read into</param>
		/// <param name="offset">Where in the buffer to start</param>
		/// <param name="count">Number of bytes to be read</param>
		/// <returns></returns>
		public override int Read(byte[] buffer, int offset, int count) {
#if !CORE
			IAsyncResult ar = null;
#endif

			if (BaseStream == null)
				return 0;

			m_lastActivity = DateTime.Now;
#if CORE
			return BaseStream.ReadAsync(buffer, offset, count).Result;
#else
			ar = BaseStream.BeginRead(buffer, offset, count, null, null);
			if (!ar.AsyncWaitHandle.WaitOne(m_readTimeout, true)) {
				Close();
				throw new TimeoutException("Timed out trying to read data from the socket stream!");
			}
			return BaseStream.EndRead(ar);
#endif
		}

		/// <summary>
		/// Reads a line from the socket
		/// </summary>
		/// <returns>A line from the stream, null if there is nothing to read</returns>
		public string ReadLine(System.Text.Encoding encoding) {
			List<byte> data = new List<byte>();
			byte[] buf = new byte[1];
			string line = null;

			while (Read(buf, 0, buf.Length) > 0) {
				data.Add(buf[0]);
				if ((char)buf[0] == '\n') {
					line = encoding.GetString(data.ToArray()).Trim('\r', '\n');
					break;
				}
			}

			return line;
		}

		/// <summary>
		/// Writes data to the stream
		/// </summary>
		/// <param name="buffer">Buffer to write to stream</param>
		/// <param name="offset">Where in the buffer to start</param>
		/// <param name="count">Number of bytes to be read</param>
		public override void Write(byte[] buffer, int offset, int count) {
			if (BaseStream == null)
				return;

			BaseStream.Write(buffer, offset, count);
			m_lastActivity = DateTime.Now;
		}

		/// <summary>
		/// Writes a line to the stream using the specified encoding
		/// </summary>
		/// <param name="encoding">Encoding used for writing the line</param>
		/// <param name="buf">The data to write</param>
		public void WriteLine(System.Text.Encoding encoding, string buf) {
			byte[] data;
			data = encoding.GetBytes(string.Format("{0}\r\n", buf));
			Write(data, 0, data.Length);
		}

		/// <summary>
		/// Disposes the stream
		/// </summary>
		public new void Dispose() {
			FtpTrace.WriteLine("Disposing FtpSocketStream...");
			Close();
		}

		/// <summary>
		/// Disconnects from server
		/// </summary>
#if CORE
		public void Close() {
#else
		public override void Close() {
#endif
			if (m_socket != null) {
				try {
					if (m_socket.Connected) {
						////
						// Calling Shutdown() with mono causes an
						// exception if the remote host closed first
						//m_socket.Shutdown(SocketShutdown.Both);
#if CORE
						m_socket.Dispose();
#else
						m_socket.Close();
#endif
					}

#if !NET2
					m_socket.Dispose();
#endif
				} catch (SocketException ex) {
					FtpTrace.WriteLine("Caught and discarded a SocketException while cleaning up the Socket: {0}", ex.ToString());
				} finally {
					m_socket = null;
				}
			}

			if (m_netStream != null) {
				try {
					m_netStream.Dispose();
				} catch (IOException ex) {
					FtpTrace.WriteLine("Caught and discarded an IOException while cleaning up the NetworkStream: {0}", ex.ToString());
				} finally {
					m_netStream = null;
				}
			}

#if !NO_SSL
			if (m_sslStream != null) {
				try {
					m_sslStream.Dispose();
				} catch (IOException ex) {
					FtpTrace.WriteLine("Caught and discarded an IOException while cleaning up the SslStream: {0}", ex.ToString());
				} finally {
					m_sslStream = null;
				}
			}
#endif

#if CORE
            base.Dispose();
#endif
        }

		/// <summary>
		/// Sets socket options on the underlying socket
		/// </summary>
		/// <param name="level">SocketOptionLevel</param>
		/// <param name="name">SocketOptionName</param>
		/// <param name="value">SocketOptionValue</param>
		public void SetSocketOption(SocketOptionLevel level, SocketOptionName name, bool value) {
			if (m_socket == null)
				throw new InvalidOperationException("The underlying socket is null. Have you established a connection?");
			m_socket.SetSocketOption(level, name, value);
		}

		/// <summary>
		/// Connect to the specified host
		/// </summary>
		/// <param name="host">The host to connect to</param>
		/// <param name="port">The port to connect to</param>
		/// <param name="ipVersions">Internet Protocol versions to support durring the connection phase</param>
		public void Connect(string host, int port, FtpIpVersion ipVersions) {
#if CORE
			IPAddress[] addresses = Dns.GetHostAddressesAsync(host).Result;
#else
			IAsyncResult ar = null;
			IPAddress[] addresses = Dns.GetHostAddresses(host);
#endif

			if (ipVersions == 0)
				throw new ArgumentException("The ipVersions parameter must contain at least 1 flag.");

			for (int i = 0; i < addresses.Length; i++) {
#if DEBUG
				FtpTrace.WriteLine("{0}: {1}", addresses[i].AddressFamily.ToString(), addresses[i].ToString());
#endif
				// we don't need to do this check unless
				// a particular version of IP has been
				// omitted so we won't.
				if (ipVersions != FtpIpVersion.ANY) {
					switch (addresses[i].AddressFamily) {
						case AddressFamily.InterNetwork:
							if ((ipVersions & FtpIpVersion.IPv4) != FtpIpVersion.IPv4) {
#if DEBUG
								FtpTrace.WriteLine("SKIPPED!");
#endif
								continue;
							}
							break;
						case AddressFamily.InterNetworkV6:
							if ((ipVersions & FtpIpVersion.IPv6) != FtpIpVersion.IPv6) {
#if DEBUG
								FtpTrace.WriteLine("SKIPPED!");
#endif
								continue;
							}
							break;
					}
				}

				m_socket = new Socket(addresses[i].AddressFamily, SocketType.Stream, ProtocolType.Tcp);
#if CORE
				m_socket.ConnectAsync(addresses[i], port).Wait();
#else
				ar = m_socket.BeginConnect(addresses[i], port, null, null);
				if (!ar.AsyncWaitHandle.WaitOne(m_connectTimeout, true)) {
					Close();

					// check to see if we're out of addresses
					// and if we are throw a TimeoutException
					if (i + 1 == addresses.Length)
						throw new TimeoutException("Timed out trying to connect!");
				} else {
					m_socket.EndConnect(ar);
					// we got a connection, break out
					// of the loop.
					break;
				}
#endif
			}

			// make sure that we actually connected to
			// one of the addresses returned from GetHostAddresses()
			if (m_socket == null || !m_socket.Connected) {
				Close();
				throw new IOException("Failed to connect to host.");
			}

			m_netStream = new NetworkStream(m_socket);
			m_lastActivity = DateTime.Now;
		}

#if !NO_SSL
		/// <summary>
		/// Activates SSL on this stream using default protocols. Fires the ValidateCertificate event. 
		/// If this event is not handled and there are SslPolicyErrors present, the certificate will 
		/// not be accepted.
		/// </summary>
		/// <param name="targethost">The host to authenticate the certiciate against</param>
		public void ActivateEncryption(string targethost) {
#if CORE
			ActivateEncryption(targethost, null, SslProtocols.Tls11 | SslProtocols.Ssl3);
#else
			ActivateEncryption(targethost, null, SslProtocols.Default);
#endif
		}

		/// <summary>
		/// Activates SSL on this stream using default protocols. Fires the ValidateCertificate event.
		/// If this event is not handled and there are SslPolicyErrors present, the certificate will 
		/// not be accepted.
		/// </summary>
		/// <param name="targethost">The host to authenticate the certiciate against</param>
		/// <param name="clientCerts">A collection of client certificates to use when authenticating the SSL stream</param>
		public void ActivateEncryption(string targethost, X509CertificateCollection clientCerts) {
#if CORE
			ActivateEncryption(targethost, clientCerts, SslProtocols.Tls11 | SslProtocols.Ssl3);
#else
			ActivateEncryption(targethost, clientCerts, SslProtocols.Default);
#endif
		}

		/// <summary>
		/// Activates SSL on this stream using the specified protocols. Fires the ValidateCertificate event.
		/// If this event is not handled and there are SslPolicyErrors present, the certificate will 
		/// not be accepted.
		/// </summary>
		/// <param name="targethost">The host to authenticate the certiciate against</param>
		/// <param name="clientCerts">A collection of client certificates to use when authenticating the SSL stream</param>
		/// <param name="sslProtocols">A bitwise parameter for supported encryption protocols.</param>
		public void ActivateEncryption(string targethost, X509CertificateCollection clientCerts, SslProtocols sslProtocols) {
			if (!IsConnected)
				throw new InvalidOperationException("The FtpSocketStream object is not connected.");

			if (m_netStream == null)
				throw new InvalidOperationException("The base network stream is null.");

			if (m_sslStream != null)
				throw new InvalidOperationException("SSL Encryption has already been enabled on this stream.");

			try {
				DateTime auth_start;
				TimeSpan auth_time_total;

				m_sslStream = new SslStream(NetworkStream, true, new RemoteCertificateValidationCallback(
					delegate(object sender, X509Certificate certificate, X509Chain chain, SslPolicyErrors sslPolicyErrors) {
						return OnValidateCertificate(certificate, chain, sslPolicyErrors);
					}));

				auth_start = DateTime.Now;
#if CORE
				m_sslStream.AuthenticateAsClientAsync(targethost, clientCerts, sslProtocols, true).Wait();
#else
				m_sslStream.AuthenticateAsClient(targethost, clientCerts, sslProtocols, true);
#endif

				auth_time_total = DateTime.Now.Subtract(auth_start);
				FtpTrace.WriteLine("Time to activate encryption: {0}h {1}m {2}s, Total Seconds: {3}.",
					auth_time_total.Hours,
					auth_time_total.Minutes,
					auth_time_total.Seconds,
					auth_time_total.TotalSeconds);
			} catch (AuthenticationException ex) {
				// authentication failed and in addition it left our 
				// ssl stream in an unsuable state so cleanup needs
				// to be done and the exception can be re-thrown for
				// handling down the chain.
				Close();
				throw ex;
			}
		}
#endif

		/// <summary>
		/// Instructs this stream to listen for connections on the specified address and port
		/// </summary>
		/// <param name="address">The address to listen on</param>
		/// <param name="port">The port to listen on</param>
		public void Listen(IPAddress address, int port) {
			if (!IsConnected) {
				if (m_socket == null)
					m_socket = new Socket(address.AddressFamily, SocketType.Stream, ProtocolType.Tcp);

				m_socket.Bind(new IPEndPoint(address, port));
				m_socket.Listen(1);
			}
		}

		/// <summary>
		/// Accepts a connection from a listening socket
		/// </summary>
		public void Accept() {
			if (m_socket != null)
				m_socket = m_socket.Accept();
		}

#if CORE
		public async Task AcceptAsync() {
			if (m_socket != null) {
				m_socket = await m_socket.AcceptAsync();
			}
		}
#else
		/// <summary>
		/// Asynchronously accepts a connection from a listening socket
		/// </summary>
		/// <param name="callback"></param>
		/// <param name="state"></param>
		/// <returns></returns>
		public IAsyncResult BeginAccept(AsyncCallback callback, object state) {
			if (m_socket != null)
				return m_socket.BeginAccept(callback, state);
			return null;
		}

		/// <summary>
		/// Completes a BeginAccept() operation
		/// </summary>
		/// <param name="ar">IAsyncResult returned from BeginAccept</param>
		public void EndAccept(IAsyncResult ar) {
			if (m_socket != null) {
				m_socket = m_socket.EndAccept(ar);
				m_netStream = new NetworkStream(m_socket);
			}
		}
#endif


	}
}