/// <summary> /// Returns a new set of plain credentials. /// </summary> /// <param name="pUserId"></param> /// <param name="pPassword"></param> /// <param name="pTLSRequirement">The TLS requirement for the credentials to be used.</param> /// <param name="pTryAuthenticateEvenIfPlainIsntAdvertised">Indicates whether the SASL PLAIN mechanism should be tried even if not advertised.</param> /// <returns></returns> /// <remarks> /// The credentials returned may fall back to IMAP LOGIN if SASL PLAIN isn't available. /// This method will throw if the userid and password can be used in neither <see cref="cLogin"/> nor <see cref="cSASLPlain"/>. /// </remarks> public static cCredentials Plain(string pUserId, string pPassword, eTLSRequirement pTLSRequirement = eTLSRequirement.required, bool pTryAuthenticateEvenIfPlainIsntAdvertised = false) { if (string.IsNullOrEmpty(pUserId)) { throw new ArgumentOutOfRangeException(nameof(pUserId)); } if (string.IsNullOrEmpty(pPassword)) { throw new ArgumentOutOfRangeException(nameof(pPassword)); } cLogin.TryConstruct(pUserId, pPassword, pTLSRequirement, out var lLogin); cSASLPlain.TryConstruct(pUserId, pPassword, pTLSRequirement, out var lPlain); if (lLogin == null && lPlain == null) { throw new ArgumentOutOfRangeException(); // argument_s_outofrange } var lCredentials = new cCredentials(pUserId, lLogin, pTryAuthenticateEvenIfPlainIsntAdvertised); if (lPlain != null) { lCredentials.mSASLs.Add(lPlain); } return(lCredentials); }
/// <summary> /// Returns a new set of anonymous credentials. /// </summary> /// <param name="pTrace">The trace information to be sent to the server.</param> /// <param name="pTLSRequirement">The TLS requirement for the credentials to be used.</param> /// <param name="pTryAuthenticateEvenIfAnonymousIsntAdvertised">Indicates whether the SASL ANONYMOUS mechanism should be tried even if not advertised.</param> /// <returns></returns> /// <remarks> /// The credentials returned may fall back to IMAP LOGIN if SASL ANONYMOUS isn't available. /// This method will throw if <paramref name="pTrace"/> can be used in neither <see cref="cLogin.Password"/> nor <see cref="cSASLAnonymous"/>. /// </remarks> public static cCredentials Anonymous(string pTrace, eTLSRequirement pTLSRequirement = eTLSRequirement.indifferent, bool pTryAuthenticateEvenIfAnonymousIsntAdvertised = false) { if (string.IsNullOrEmpty(pTrace)) { throw new ArgumentOutOfRangeException(nameof(pTrace)); } cLogin.TryConstruct("anonymous", pTrace, pTLSRequirement, out var lLogin); cSASLAnonymous.TryConstruct(pTrace, pTLSRequirement, out var lSASL); if (lLogin == null && lSASL == null) { throw new ArgumentOutOfRangeException(nameof(pTrace)); } var lCredentials = new cCredentials(eAccountType.anonymous, lLogin, pTryAuthenticateEvenIfAnonymousIsntAdvertised); if (lSASL != null) { lCredentials.mSASLs.Add(lSASL); } return(lCredentials); }
private async Task ZConnectAsync(cTrace.cContext pParentContext) { var lContext = mRootContext.NewMethod(nameof(cIMAPClient), nameof(ZConnectAsync)); if (mDisposed) { throw new ObjectDisposedException(nameof(cIMAPClient)); } cServer lServer = Server; cCredentials lCredentials = Credentials; if (lServer == null) { throw new InvalidOperationException("connect requires server to be set"); } if (lCredentials == null) { throw new InvalidOperationException("connect requires credentials to be set"); } bool lSessionReplaced; if (mSession == null) { lSessionReplaced = false; } else { if (!mSession.IsUnconnected) { throw new InvalidOperationException(kInvalidOperationExceptionMessage.NotUnconnected); } mSession.Dispose(); lSessionReplaced = true; mNamespaces = null; mInbox = null; mSynchroniser.InvokePropertyChanged(nameof(Inbox), lContext); } // initialise the SASLs foreach (var lSASL in lCredentials.SASLs) { lSASL.LastAuthentication = null; } mSession = new cSession(mSynchroniser, mIgnoreCapabilities, mMailboxCacheDataItems, mNetworkWriteConfiguration, mIdleConfiguration, mFetchCacheItemsConfiguration, mFetchBodyReadConfiguration, mEncoding, lContext); var lSession = mSession; if (lSessionReplaced) { mSynchroniser.InvokePropertyChanged(nameof(Capabilities), lContext); mSynchroniser.InvokePropertyChanged(nameof(ConnectionState), lContext); mSynchroniser.InvokePropertyChanged(nameof(IsConnected), lContext); mSynchroniser.InvokePropertyChanged(nameof(IsUnconnected), lContext); mSynchroniser.InvokePropertyChanged(nameof(ConnectedAccountId), lContext); mSynchroniser.InvokePropertyChanged(nameof(EnabledExtensions), lContext); mSynchroniser.InvokePropertyChanged(nameof(HomeServerReferral), lContext); mSynchroniser.InvokePropertyChanged(nameof(ServerId), lContext); mSynchroniser.InvokePropertyChanged(nameof(Namespaces), lContext); mSynchroniser.InvokePropertyChanged(nameof(SelectedMailbox), lContext); mSynchroniser.InvokePropertyChanged(nameof(SelectedMailboxDetails), lContext); } using (var lToken = mCancellationManager.GetToken(lContext)) { var lMC = new cMethodControl(mTimeout, lToken.CancellationToken); try { await lSession.ConnectAsync(lMC, lServer, lContext).ConfigureAwait(false); if (lSession.Capabilities == null) { await lSession.CapabilityAsync(lMC, lContext).ConfigureAwait(false); } if (lSession.ConnectionState == eConnectionState.notauthenticated && !lSession.TLSInstalled && lSession.Capabilities.StartTLS) { await lSession.StartTLSAsync(lMC, lContext).ConfigureAwait(false); await lSession.CapabilityAsync(lMC, lContext).ConfigureAwait(false); } object lOriginalCapabilities = lSession.Capabilities; cCapabilities lCurrentCapabilities = lSession.Capabilities; if (lSession.ConnectionState == eConnectionState.notauthenticated) { bool lTLSIssue = false; bool lTriedCredentials = false; Exception lAuthenticateException = null; cAccountId lAccountId = new cAccountId(lServer.Host, lCredentials.Type, lCredentials.UserId); bool lTLSInstalled = lSession.TLSInstalled; if (lCredentials.TryAllSASLs) { foreach (var lSASL in lCredentials.SASLs) { if ((lSASL.TLSRequirement == eTLSRequirement.required && !lTLSInstalled) || (lSASL.TLSRequirement == eTLSRequirement.disallowed && lTLSInstalled)) { lTLSIssue = true; } else { lTriedCredentials = true; lAuthenticateException = await lSession.AuthenticateAsync(lMC, lAccountId, lSASL, lContext).ConfigureAwait(false); if (lSession.ConnectionState != eConnectionState.notauthenticated || lAuthenticateException != null) { break; } } } } else { foreach (var lSASL in lCredentials.SASLs) { if (lCurrentCapabilities.AuthenticationMechanisms.Contains(lSASL.MechanismName)) // no case-invariance required because SASL (rfc 2222) says only uppercase is allowed { if ((lSASL.TLSRequirement == eTLSRequirement.required && !lTLSInstalled) || (lSASL.TLSRequirement == eTLSRequirement.disallowed && lTLSInstalled)) { lTLSIssue = true; } else { lTriedCredentials = true; lAuthenticateException = await lSession.AuthenticateAsync(lMC, lAccountId, lSASL, lContext).ConfigureAwait(false); if (lSession.ConnectionState != eConnectionState.notauthenticated || lAuthenticateException != null) { break; } } } } } if (lSession.ConnectionState == eConnectionState.notauthenticated && lAuthenticateException == null && !lCurrentCapabilities.LoginDisabled && lCredentials.Login != null) { if ((lCredentials.Login.TLSRequirement == eTLSRequirement.required && !lTLSInstalled) || (lCredentials.Login.TLSRequirement == eTLSRequirement.disallowed && lTLSInstalled)) { lTLSIssue = true; } else { lTriedCredentials = true; lAuthenticateException = await lSession.LoginAsync(lMC, lAccountId, lCredentials.Login, lContext).ConfigureAwait(false); } } if (lSession.ConnectionState != eConnectionState.authenticated) { lContext.TraceError("could not authenticate"); // log out await lSession.LogoutAsync(lMC, lContext).ConfigureAwait(false); // throw an exception that indicates why we couldn't connect if (lTriedCredentials) { if (lAuthenticateException != null) { throw lAuthenticateException; } throw new cCredentialsException(lContext); } throw new cAuthenticationMechanismsException(lTLSIssue, lContext); // the server has no mechanisms that we can try } // re-get the capabilities if we didn't get new ones as part of the authentication/ login OR if a security layer was installed (SASL requires this) if (ReferenceEquals(lOriginalCapabilities, lSession.Capabilities) || lSession.SASLSecurityInstalled) { await lSession.CapabilityAsync(lMC, lContext).ConfigureAwait(false); } lCurrentCapabilities = lSession.Capabilities; } if (lCurrentCapabilities.Enable) { fEnableableExtensions lExtensions = fEnableableExtensions.none; if (lCurrentCapabilities.UTF8Accept || lCurrentCapabilities.UTF8Only) { lExtensions = lExtensions | fEnableableExtensions.utf8; } if (lExtensions != fEnableableExtensions.none) { await lSession.EnableAsync(lMC, lExtensions, lContext).ConfigureAwait(false); } } // enabled (lock in the capabilities and enabled extensions) lSession.SetEnabled(lContext); Task lIdTask; if (lCurrentCapabilities.Id) { cId lClientId; if ((lSession.EnabledExtensions & fEnableableExtensions.utf8) == 0) { lClientId = mClientId; } else { lClientId = mClientIdUTF8 ?? mClientId; } lIdTask = lSession.IdAsync(lMC, lClientId, lContext); } else { lIdTask = null; } if (lCurrentCapabilities.Namespace) { await lSession.NamespaceAsync(lMC, lContext).ConfigureAwait(false); var lPersonalNamespaceNames = lSession.NamespaceNames?.Personal; if (lPersonalNamespaceNames != null) { foreach (var lName in lPersonalNamespaceNames) { // special case, where the personal namespace is "INBOX/" (where "/" is the delimiter) if (lName.Delimiter != null && lName.Prefix.Equals(cMailboxName.InboxString + lName.Delimiter, StringComparison.InvariantCultureIgnoreCase)) { mInbox = new cMailbox(this, lSession.GetMailboxHandle(new cMailboxName(cMailboxName.InboxString, lName.Delimiter))); mSynchroniser.InvokePropertyChanged(nameof(Inbox), lContext); break; } cMailboxPathPattern lPattern = new cMailboxPathPattern(lName.Prefix, "%", lName.Delimiter); if (lPattern.Matches(cMailboxName.InboxString)) { mInbox = new cMailbox(this, lSession.GetMailboxHandle(new cMailboxName(cMailboxName.InboxString, lName.Delimiter))); mSynchroniser.InvokePropertyChanged(nameof(Inbox), lContext); break; } } } } if (mInbox == null) { var lDelimiter = await lSession.ListDelimiterAsync(lMC, lContext).ConfigureAwait(false); if (!lCurrentCapabilities.Namespace) { mNamespaces = new cNamespaces(this, new cNamespaceName[] { new cNamespaceName("", lDelimiter) }, null, null); mSynchroniser.InvokePropertyChanged(nameof(Namespaces), lContext); } mInbox = new cMailbox(this, lSession.GetMailboxHandle(new cMailboxName(cMailboxName.InboxString, lDelimiter))); mSynchroniser.InvokePropertyChanged(nameof(Inbox), lContext); } // wait for id to complete if (lIdTask != null) { await lIdTask.ConfigureAwait(false); } // initialised (namespaces set, inbox available, id available (if server supports it); user may now issue commands) lSession.SetInitialised(lContext); } catch when(lSession.ConnectionState != eConnectionState.disconnected) { lSession.Disconnect(lContext); throw; } } }