// // ImapClient.cs // // Author: Jeffrey Stedfast // // Copyright (c) 2013-2020 .NET Foundation and Contributors // // Permission is hereby granted, free of charge, to any person obtaining a copy // of this software and associated documentation files (the "Software"), to deal // in the Software without restriction, including without limitation the rights // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell // copies of the Software, and to permit persons to whom the Software is // furnished to do so, subject to the following conditions: // // The above copyright notice and this permission notice shall be included in // all copies or substantial portions of the Software. // // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN // THE SOFTWARE. // using System; using System.IO; using System.Net; using System.Text; using System.Threading; using System.Net.Sockets; using System.Net.Security; using System.Globalization; using System.Threading.Tasks; using System.Collections.Generic; using System.Security.Cryptography.X509Certificates; using MailKit.Security; using SslStream = MailKit.Net.SslStream; using NetworkStream = MailKit.Net.NetworkStream; namespace MailKit.Net.Imap { ///

/// An IMAP client that can be used to retrieve messages from a server. ///

/// /// The class supports both the "imap" and "imaps" /// protocols. The "imap" protocol makes a clear-text connection to the IMAP /// server and does not use SSL or TLS unless the IMAP server supports the /// STARTTLS extension. /// The "imaps" protocol, however, connects to the IMAP server using an /// SSL-wrapped connection. /// /// ///

///


	/// 
	/// 
	/// 
	public partial class ImapClient : MailStore, IImapClient
	{
		static readonly char[] ReservedUriCharacters = { ';', '/', '?', ':', '@', '&', '=', '+', '$', ',', '%' };
		const string HexAlphabet = "0123456789ABCDEF";

		readonly ImapEngine engine;
		int timeout = 2 * 60 * 1000;
		string identifier;
		bool disconnecting;
		bool connecting;
		bool disposed;
		bool secure;

		/// 
		/// Initializes a new instance of the  class.
		/// 
		/// 
		/// Before you can retrieve messages with the , you must first
		/// call one of the Connect
		/// methods and then authenticate with the one of the
		/// Authenticate
		/// methods.
		/// 
		/// 
		/// 
		/// 
		public ImapClient () : this (new NullProtocolLogger ())
		{
		}

		/// 
		/// Initializes a new instance of the  class.
		/// 
		/// 
		/// Before you can retrieve messages with the , you must first
		/// call one of the Connect
		/// methods and then authenticate with the one of the
		/// Authenticate
		/// methods.
		/// 
		/// 
		/// 
		/// 
		/// The protocol logger.
		/// 
		///  is null.
		/// 
		public ImapClient (IProtocolLogger protocolLogger) : base (protocolLogger)
		{
			// FIXME: should this take a ParserOptions argument?
			engine = new ImapEngine (CreateImapFolder);
			engine.MetadataChanged += OnEngineMetadataChanged;
			engine.FolderCreated += OnEngineFolderCreated;
			engine.Disconnected += OnEngineDisconnected;
			engine.Alert += OnEngineAlert;
		}

		/// 
		/// Gets an object that can be used to synchronize access to the IMAP server.
		/// 
		/// 
		/// Gets an object that can be used to synchronize access to the IMAP server.
		/// When using the non-Async methods from multiple threads, it is important to lock the
		///  object for thread safety when using the synchronous methods.
		/// 
		/// The lock object.
		public override object SyncRoot {
			get { return engine; }
		}

		/// 
		/// Get the protocol supported by the message service.
		/// 
		/// 
		/// Gets the protocol supported by the message service.
		/// 
		/// The protocol.
		protected override string Protocol {
			get { return "imap"; }
		}

		/// 
		/// Get the capabilities supported by the IMAP server.
		/// 
		/// 
		/// The capabilities will not be known until a successful connection has been made via one of
		/// the Connect methods and may
		/// change as a side-effect of calling one of the
		/// Authenticate
		/// methods.
		/// 
		/// 
		/// 
		/// 
		/// The capabilities.
		/// 
		/// Capabilities cannot be enabled, they may only be disabled.
		/// 
		public ImapCapabilities Capabilities {
			get { return engine.Capabilities; }
			set {
				if ((engine.Capabilities | value) > engine.Capabilities)
					throw new ArgumentException ("Capabilities cannot be enabled, they may only be disabled.", nameof (value));

				engine.Capabilities = value;
			}
		}

		/// 
		/// Gets the maximum size of a message that can be appended to a folder.
		/// 
		/// 
		/// Gets the maximum size of a message, in bytes, that can be appended to a folder.
		/// If the value is not set, then the limit is unspecified.
		/// 
		/// The append limit.
		public uint? AppendLimit {
			get { return engine.AppendLimit; }
		}

		/// 
		/// Gets the internationalization level supported by the IMAP server.
		/// 
		/// 
		/// Gets the internationalization level supported by the IMAP server.
		/// For more information, see
		/// section 4 of rfc5255.
		/// 
		/// The internationalization level.
		public int InternationalizationLevel {
			get { return engine.I18NLevel; }
		}

		/// 
		/// Get the access rights supported by the IMAP server.
		/// 
		/// 
		/// These rights are additional rights supported by the IMAP server beyond the standard rights
		/// defined in section 2.1 of rfc4314
		/// and will not be populated until the client is successfully connected.
		/// 
		/// 
		/// 
		/// 
		/// The rights.
		public AccessRights Rights {
			get { return engine.Rights; }
		}

		void CheckDisposed ()
		{
			if (disposed)
				throw new ObjectDisposedException (nameof (ImapClient));
		}

		void CheckConnected ()
		{
			if (!IsConnected)
				throw new ServiceNotConnectedException ("The ImapClient is not connected.");
		}

		void CheckAuthenticated ()
		{
			if (!IsAuthenticated)
				throw new ServiceNotAuthenticatedException ("The ImapClient is not authenticated.");
		}

		/// 
		/// Instantiate a new .
		/// 
		/// 
		/// Creates a new  instance.
		/// This method's purpose is to allow subclassing .
		/// 
		/// The IMAP folder instance.
		/// The constructior arguments.
		/// 
		///  is null.
		/// 
		protected virtual ImapFolder CreateImapFolder (ImapFolderConstructorArgs args)
		{
			var folder = new ImapFolder (args);

			folder.UpdateAppendLimit (AppendLimit);

			return folder;
		}

		bool ValidateRemoteCertificate (object sender, X509Certificate certificate, X509Chain chain, SslPolicyErrors sslPolicyErrors)
		{
			if (ServerCertificateValidationCallback != null)
				return ServerCertificateValidationCallback (engine.Uri.Host, certificate, chain, sslPolicyErrors);

#if !NETSTANDARD1_3 && !NETSTANDARD1_6
			if (ServicePointManager.ServerCertificateValidationCallback != null)
				return ServicePointManager.ServerCertificateValidationCallback (engine.Uri.Host, certificate, chain, sslPolicyErrors);
#endif

			return DefaultServerCertificateValidationCallback (engine.Uri.Host, certificate, chain, sslPolicyErrors);
		}

		async Task CompressAsync (bool doAsync, CancellationToken cancellationToken)
		{
			CheckDisposed ();
			CheckConnected ();

			if ((engine.Capabilities & ImapCapabilities.Compress) == 0)
				throw new NotSupportedException ("The IMAP server does not support the COMPRESS extension.");

			if (engine.State >= ImapEngineState.Selected)
				throw new InvalidOperationException ("Compression must be enabled before selecting a folder.");

			int capabilitiesVersion = engine.CapabilitiesVersion;
			var ic = engine.QueueCommand (cancellationToken, null, "COMPRESS DEFLATE\r\n");

			await engine.RunAsync (ic, doAsync).ConfigureAwait (false);

			if (ic.Response != ImapCommandResponse.Ok) {
				for (int i = 0; i < ic.RespCodes.Count; i++) {
					if (ic.RespCodes[i].Type == ImapResponseCodeType.CompressionActive)
						return;
				}

				throw ImapCommandException.Create ("COMPRESS", ic);
			}

			engine.Stream.Stream = new CompressedStream (engine.Stream.Stream);
		}

		/// 
		/// Enable compression over the IMAP connection.
		/// 
		/// 
		/// Enables compression over the IMAP connection.
		/// If the IMAP server supports the  extension,
		/// it is possible at any point after connecting to enable compression to reduce network
		/// bandwidth usage. Ideally, this method should be called before authenticating.
		/// 
		/// The cancellation token.
		/// 
		/// The  has been disposed.
		/// 
		/// 
		/// The  is not connected.
		/// 
		/// 
		/// Compression must be enabled before a folder has been selected.
		/// 
		/// 
		/// The IMAP server does not support the  extension.
		/// 
		/// 
		/// The operation was canceled via the cancellation token.
		/// 
		/// 
		/// An I/O error occurred.
		/// 
		/// 
		/// The server replied to the COMPRESS command with a NO or BAD response.
		/// 
		/// 
		/// An IMAP protocol error occurred.
		/// 
		public void Compress (CancellationToken cancellationToken = default (CancellationToken))
		{
			CompressAsync (false, cancellationToken).GetAwaiter ().GetResult ();
		}

		async Task EnableQuickResyncAsync (bool doAsync, CancellationToken cancellationToken)
		{
			CheckDisposed ();
			CheckConnected ();
			CheckAuthenticated ();

			if (engine.State != ImapEngineState.Authenticated)
				throw new InvalidOperationException ("QRESYNC needs to be enabled immediately after authenticating.");

			if ((engine.Capabilities & ImapCapabilities.QuickResync) == 0)
				throw new NotSupportedException ("The IMAP server does not support the QRESYNC extension.");

			if (engine.QResyncEnabled)
				return;

			var ic = engine.QueueCommand (cancellationToken, null, "ENABLE QRESYNC CONDSTORE\r\n");

			await engine.RunAsync (ic, doAsync).ConfigureAwait (false);

			if (ic.Response != ImapCommandResponse.Ok)
				throw ImapCommandException.Create ("ENABLE", ic);
		}

		/// 
		/// Enable the QRESYNC feature.
		/// 
		/// 
		/// Enables the QRESYNC feature.
		/// The QRESYNC extension improves resynchronization performance of folders by
		/// querying the IMAP server for a list of changes when the folder is opened using the
		/// 
		/// method.
		/// If this feature is enabled, the  event is replaced
		/// with the  event.
		/// This method needs to be called immediately after calling one of the
		/// Authenticate methods, before
		/// opening any folders.
		/// 
		/// The cancellation token.
		/// 
		/// The  has been disposed.
		/// 
		/// 
		/// The  is not connected.
		/// 
		/// 
		/// The  is not authenticated.
		/// 
		/// 
		/// Quick resynchronization needs to be enabled before selecting a folder.
		/// 
		/// 
		/// The IMAP server does not support the QRESYNC extension.
		/// 
		/// 
		/// The operation was canceled via the cancellation token.
		/// 
		/// 
		/// An I/O error occurred.
		/// 
		/// 
		/// The server replied to the ENABLE command with a NO or BAD response.
		/// 
		/// 
		/// An IMAP protocol error occurred.
		/// 
		public override void EnableQuickResync (CancellationToken cancellationToken = default (CancellationToken))
		{
			EnableQuickResyncAsync (false, cancellationToken).GetAwaiter ().GetResult ();
		}

		async Task EnableUTF8Async (bool doAsync, CancellationToken cancellationToken)
		{
			CheckDisposed ();
			CheckConnected ();
			CheckAuthenticated ();

			if (engine.State != ImapEngineState.Authenticated)
				throw new InvalidOperationException ("UTF8=ACCEPT needs to be enabled immediately after authenticating.");

			if ((engine.Capabilities & ImapCapabilities.UTF8Accept) == 0)
				throw new NotSupportedException ("The IMAP server does not support the UTF8=ACCEPT extension.");

			if (engine.UTF8Enabled)
				return;

			var ic = engine.QueueCommand (cancellationToken, null, "ENABLE UTF8=ACCEPT\r\n");

			await engine.RunAsync (ic, doAsync).ConfigureAwait (false);

			if (ic.Response != ImapCommandResponse.Ok)
				throw ImapCommandException.Create ("ENABLE", ic);
		}

		/// 
		/// Enable the UTF8=ACCEPT extension.
		/// 
		/// 
		/// Enables the UTF8=ACCEPT extension.
		/// 
		/// The cancellation token.
		/// 
		/// The  has been disposed.
		/// 
		/// 
		/// The  is not connected.
		/// 
		/// 
		/// The  is not authenticated.
		/// 
		/// 
		/// UTF8=ACCEPT needs to be enabled before selecting a folder.
		/// 
		/// 
		/// The IMAP server does not support the UTF8=ACCEPT extension.
		/// 
		/// 
		/// The operation was canceled via the cancellation token.
		/// 
		/// 
		/// An I/O error occurred.
		/// 
		/// 
		/// The server replied to the ENABLE command with a NO or BAD response.
		/// 
		/// 
		/// An IMAP protocol error occurred.
		/// 
		public void EnableUTF8 (CancellationToken cancellationToken = default (CancellationToken))
		{
			EnableUTF8Async (false, cancellationToken).GetAwaiter ().GetResult ();
		}

		async Task IdentifyAsync (ImapImplementation clientImplementation, bool doAsync, CancellationToken cancellationToken)
		{
			CheckDisposed ();
			CheckConnected ();

			if ((engine.Capabilities & ImapCapabilities.Id) == 0)
				throw new NotSupportedException ("The IMAP server does not support the ID extension.");

			var command = new StringBuilder ("ID ");
			var args = new List