Beispiel #1
0
            public async Task ConnectAsync(cMethodControl pMC, cServer pServer, cTrace.cContext pParentContext)
            {
                var lContext = pParentContext.NewMethod(nameof(cSession), nameof(ConnectAsync), pMC, pServer);

                if (mDisposed)
                {
                    throw new ObjectDisposedException(nameof(cSession));
                }

                if (_ConnectionState != eConnectionState.notconnected)
                {
                    throw new InvalidOperationException(kInvalidOperationExceptionMessage.NotUnconnected);
                }
                ZSetState(eConnectionState.connecting, lContext);

                sGreeting lGreeting;

                try { lGreeting = await mPipeline.ConnectAsync(pMC, pServer, lContext).ConfigureAwait(false); }
                catch (Exception)
                {
                    ZSetState(eConnectionState.disconnected, lContext);
                    throw;
                }

                if (lGreeting.Type == eGreetingType.bye)
                {
                    ZSetState(eConnectionState.disconnected, lContext);
                    if (ZSetHomeServerReferral(lGreeting.ResponseText, lContext))
                    {
                        throw new cHomeServerReferralException(lGreeting.ResponseText, lContext);
                    }
                    throw new cConnectByeException(lGreeting.ResponseText, lContext);
                }

                if (mPipeline.Capabilities != null)
                {
                    ZSetCapabilities(mPipeline.Capabilities, mPipeline.AuthenticationMechanisms, lContext);
                }

                if (lGreeting.Type == eGreetingType.ok)
                {
                    ZSetState(eConnectionState.notauthenticated, lContext);
                    return;
                }

                // preauth

                ZSetHomeServerReferral(lGreeting.ResponseText, lContext);
                ZSetConnectedAccountId(new cAccountId(pServer.Host, eAccountType.unknown), lContext);
            }
Beispiel #2
0
                public async Task <sGreeting> ConnectAsync(cMethodControl pMC, cServer pServer, cTrace.cContext pParentContext)
                {
                    var lContext = pParentContext.NewMethod(nameof(cCommandPipeline), nameof(ConnectAsync), pMC, pServer);

                    if (mDisposed)
                    {
                        throw new ObjectDisposedException(nameof(cCommandPipeline));
                    }

                    if (mState != eState.notconnected)
                    {
                        throw new InvalidOperationException(kInvalidOperationExceptionMessage.NotUnconnected);
                    }
                    mState = eState.connecting;

                    try
                    {
                        await mConnection.ConnectAsync(pMC, pServer, lContext).ConfigureAwait(false);

                        using (var lAwaiter = new cAwaiter(pMC))
                        {
                            while (true)
                            {
                                lContext.TraceVerbose("waiting");
                                await lAwaiter.AwaitAny(mConnection.GetBuildResponseTask(lContext)).ConfigureAwait(false);

                                var lResponse = mConnection.GetResponse(lContext);
                                mSynchroniser.InvokeNetworkReceive(lResponse, lContext);
                                var lCursor = new cBytesCursor(lResponse);

                                if (lCursor.SkipBytes(kGreetingAsteriskSpaceOKSpace))
                                {
                                    var lHook = new cCommandHookInitial();

                                    cResponseText lResponseText = mResponseTextProcessor.Process(eResponseTextContext.greetingok, lCursor, lHook, lContext);
                                    lContext.TraceVerbose("got ok: {0}", lResponseText);

                                    mState          = eState.connected;
                                    mBackgroundTask = ZBackgroundTaskAsync(lContext);

                                    mCapabilities             = lHook.Capabilities;
                                    mAuthenticationMechanisms = lHook.AuthenticationMechanisms;

                                    return(new sGreeting(eGreetingType.ok, null));
                                }

                                if (lCursor.SkipBytes(kGreetingAsteriskSpacePreAuthSpace))
                                {
                                    var lHook = new cCommandHookInitial();

                                    cResponseText lResponseText = mResponseTextProcessor.Process(eResponseTextContext.greetingpreauth, lCursor, lHook, lContext);
                                    lContext.TraceVerbose("got preauth: {0}", lResponseText);

                                    mState          = eState.connected;
                                    mBackgroundTask = ZBackgroundTaskAsync(lContext);

                                    mCapabilities             = lHook.Capabilities;
                                    mAuthenticationMechanisms = lHook.AuthenticationMechanisms;

                                    return(new sGreeting(eGreetingType.preauth, lResponseText));
                                }

                                if (lCursor.SkipBytes(kGreetingAsteriskSpaceBYESpace))
                                {
                                    cResponseText lResponseText = mResponseTextProcessor.Process(eResponseTextContext.greetingbye, lCursor, null, lContext);
                                    lContext.TraceError("got bye: {0}", lResponseText);

                                    mConnection.Disconnect(lContext);

                                    mState = eState.stopped;
                                    return(new sGreeting(eGreetingType.bye, lResponseText));
                                }

                                lContext.TraceError("unrecognised response: {0}", lResponse);
                            }
                        }
                    }
                    catch (Exception)
                    {
                        mConnection.Disconnect(lContext);
                        mState = eState.stopped;
                        throw;
                    }
                }
Beispiel #3
0
        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;
                }
            }
        }
Beispiel #4
0
                    public async Task ConnectAsync(cMethodControl pMC, cServer pServer, cTrace.cContext pParentContext)
                    {
                        var lContext = pParentContext.NewMethod(nameof(cConnection), nameof(ConnectAsync), pMC, pServer);

                        if (mState != eState.notconnected)
                        {
                            throw new InvalidOperationException(kInvalidOperationExceptionMessage.AlreadyConnected);
                        }

                        if (pServer == null)
                        {
                            throw new ArgumentNullException(nameof(pServer));
                        }

                        mState = eState.connecting;
                        mHost  = pServer.Host;

                        try
                        {
                            lContext.TraceVerbose("creating tcpclient");

                            mTCPClient = new TcpClient();

                            mTCPClient.ReceiveTimeout = pMC.Timeout;
                            mTCPClient.SendTimeout    = pMC.Timeout;

                            lContext.TraceVerbose("connecting tcpclient");

                            await mTCPClient.ConnectAsync(pServer.Host, pServer.Port).ConfigureAwait(false);

                            NetworkStream lStream = mTCPClient.GetStream();

                            if (pServer.SSL)
                            {
                                lContext.TraceVerbose("creating sslstream");

                                mSSLStream = new SslStream(lStream);

                                mSSLStream.ReadTimeout  = pMC.Timeout;
                                mSSLStream.WriteTimeout = pMC.Timeout;

                                lContext.TraceVerbose("authenticating as client");

                                await mSSLStream.AuthenticateAsClientAsync(pServer.Host).ConfigureAwait(false);

                                mStream = mSSLStream;
                            }
                            else
                            {
                                mStream = lStream;
                            }

                            mStream.ReadTimeout  = -1;
                            mStream.WriteTimeout = -1;

                            mState = eState.connected;
                        }
                        catch
                        {
                            Disconnect(lContext);
                            throw;
                        }
                    }