diff -r 000000000000 -r 72b543305e3a email/imap4mtm/imaptransporthandler/src/csocketconnector.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/email/imap4mtm/imaptransporthandler/src/csocketconnector.cpp Thu Dec 17 08:44:11 2009 +0200 @@ -0,0 +1,367 @@ +// Copyright (c) 2006-2009 Nokia Corporation and/or its subsidiary(-ies). +// All rights reserved. +// This component and the accompanying materials are made available +// under the terms of "Eclipse Public License v1.0" +// which accompanies this distribution, and is available +// at the URL "http://www.eclipse.org/legal/epl-v10.html". +// +// Initial Contributors: +// Nokia Corporation - initial contribution. +// +// Contributors: +// +// Description: +// + +#include "csocketconnector.h" + +#include "csocket.h" +#include "msocketconnectobserver.h" +#include "msocketconnectorstore.h" +#include "msocketcontrollerfactory.h" +#include "mcommsinfoprovider.h" +#include "csocketcontroller.h" +#include "imappaniccodes.h" +#include "imaptransportmanagercommon.h" + +#if defined (_DEBUG) && defined (_LOGGING) +const TInt KHostNameSize = 126; +#endif + +/** +The factory constructor. + +@param aStore The socket connector store. +@param aSocketControllerFactory The socket controller factory. +@param aCommsInfoProvider The comms info provider. +@return A pointer to a fully constructed object. +*/ +CSocketConnector* CSocketConnector::NewL(MSocketConnectorStore& aStore, + MSocketControllerFactory& aSocketControllerFactory, + MCommsInfoProvider& aCommsInfoProvider) + { + return new (ELeave) CSocketConnector(aStore, aSocketControllerFactory, aCommsInfoProvider); + } + +/** +Destructor. +*/ +CSocketConnector::~CSocketConnector() + { + // Cancel any outstanding requests + Cancel(); + + // Cleanup... + delete iHost; + delete iConnectingSocket; + iHostResolver.Close(); + } + +/** +Constructor. + +@param aStore The socket connector store. +@param aSocketControllerFactory The socket controller factory. +@param aCommsInfoProvider The comms info provider. +*/ +CSocketConnector::CSocketConnector(MSocketConnectorStore& aStore, + MSocketControllerFactory& aSocketControllerFactory, + MCommsInfoProvider& aCommsInfoProvider) : CActive(CActive::EPriorityStandard), iStore(aStore), + iSocketControllerFactory(aSocketControllerFactory), + iCommsInfoProvider(aCommsInfoProvider) + { + CActiveScheduler::Add(this); + } + +/** +Start connection to specified remote host. The socket connector starts +connecting to the specified remote host on the specified port. + +@param aRemoteHost The host name/IP address of the remote host +@param aRemotePort The port number of the remote host +@pre The socket connector is in the Idle state. +@post The socket connector is not in the Idle state. +*/ +void CSocketConnector::ConnectL(MSocketConnectObserver& aObserver, const TDesC8& aRemoteHost, TUint16 aRemotePort) + { + __ASSERT_DEBUG( iState == EIdle, TImapServerPanic::ImapPanic(TImapServerPanic::EBadSocketConnectorState) ); + + // Set the observer + iObserver = &aObserver; + + __ASSERT_DEBUG(!iHost, User::Invariant()); + + // Copy the remote host IP address and port + iHost = HBufC::NewL(aRemoteHost.Length()); + iHost->Des().Copy(aRemoteHost); + iPort = aRemotePort; + + // Move to the PendingDNSLookup state and self complete. + iState = EPendingDNSLookup; + CompleteSelf(); + } + +/** +Requests that the socket connector complete itself. This will caused the +RunL() to be called by the scheduler at the next opportunity. + +@pre The socket connector object is not active. +@post The socket connector object is active and the request has been + completed. +*/ +void CSocketConnector::CompleteSelf() + { + TRequestStatus* pStat = &iStatus; + User::RequestComplete(pStat, KErrNone); + SetActive(); + } + +/** +Commit a suicide on the socket connector. +*/ +void CSocketConnector::Suicide() + { + // Inform store that connection is complete and then suicide. + iStore.ConnectionCompleted(*this); + delete this; + } + +/** +Stop the connect. + +@see MSocketConnector +*/ +void CSocketConnector::StopConnect() + { + // Cancel any outstanding requests. + Cancel(); + +#if defined (_DEBUG) && defined (_LOGGING) + TBuf8 host; + host.Copy((*iHost).Left(KHostNameSize)); //just get the KHostNameSize characters + + __FLOG_0(_T8("!! Stopping connection")); + __FLOG_1(_T8("-> connect to host %S stopped"), &host); +#endif + + Suicide(); + } + +/* + * Methods from CActive + */ + +/** +The request servicing function. Behaviour depends on the state of the socket +connector. + +@leave The function will leave if the request status is an error. +*/ +void CSocketConnector::RunL() + { + // Leave if there has been an error + User::LeaveIfError(iStatus.Int()); + + switch( iState ) + { + case EPendingDNSLookup: + { +#if defined (_DEBUG) && defined (_LOGGING) + TBuf8 host; + host.Copy((*iHost).Left(KHostNameSize)); //just get the KHostNameSize characters + + __FLOG_1(_T8("Doing DNS lookup -> searching for host %S"), &host); +#endif + + // Open the host resolver session + User::LeaveIfError(iHostResolver.Open( + iCommsInfoProvider.SocketServer(), + iCommsInfoProvider.ProtocolDescription().iAddrFamily, + KProtocolInetTcp, + iCommsInfoProvider.Connection() + )); + // Start the DNS lookup for the remote host name. + iHostResolver.GetByName(*iHost, iHostDnsEntry, iStatus); + + // Move to the Connecting state and go active + iState = EConnecting; + SetActive(); + } break; + case EConnecting: + { + // DNS lookup successful - form the internet address object + iAddress = TInetAddr(iHostDnsEntry().iAddr); + iAddress.SetPort(iPort); + +#if defined (_DEBUG) && defined (_LOGGING) + TBuf8 host; + host.Copy((*iHost).Left(KHostNameSize)); //just get the KHostNameSize characters + + TBuf ip16bit; + iAddress.Output(ip16bit); + + TBuf8 ip; + ip.Copy(ip16bit); + + __FLOG_2(_T8("DNS lookup complete -> host %S has IP address %S"), &host, &ip); +#endif + + // Create the connecting socket + iConnectingSocket = CSocket::NewL(iCommsInfoProvider, CSocket::EProtocolSocket); + + // Start connecting to the remote client + iConnectingSocket->Connect(iAddress, iStatus); + + // Move to the Connected state and go active + iState = EConnected; + SetActive(); + } break; + case EConnected: + { +#if defined (_DEBUG) && defined (_LOGGING) + TBuf8 host; + host.Copy((*iHost).Left(KHostNameSize)); //just get the KHostNameSize characters + + TInetAddr addr; + iConnectingSocket->RemoteName(addr); + + TBuf ip16bit; + addr.Output(ip16bit); + + TBuf8 ip; + ip.Copy(ip16bit); + + TInetAddr local; + iConnectingSocket->LocalName(local); + + __FLOG_1(_T8("!! Connection with host %S established"), &host); + __FLOG_3(_T8("-> on local port %d with %S, remote port %d"), local.Port(), &ip, addr.Port()); +#endif + + // A connection has been made with the remote client - lose ownership of + // the connecting socket. + CSocket* connectedSocket = iConnectingSocket; + iConnectingSocket = NULL; + + // Create a socket controller object to own the connected socket. + CSocketController* socketController = iSocketControllerFactory.CreateSocketControllerLC(connectedSocket); + + // Inform the socket connect observer that a TCP connection is established - + // pass back the input and output stream objects. + iObserver->ConnectionMadeL(socketController->InputStream(), socketController->OutputStream()); + + // Remove socket controller from cleanup stack - transferring ownership + // to the store. + CleanupStack::Pop(socketController); + + // Add the socket controller in the store - ownership is transferred to + // the store. + iSocketControllerFactory.AddToStoreL(socketController); + + // Socket connector is finished - suicide. + Suicide(); + } break; + case EIdle: + default: + TImapServerPanic::ImapPanic(TImapServerPanic::EBadSocketConnectorState); + break; + } + } + +/** +The asynchronous request cancel. +*/ +void CSocketConnector::DoCancel() + { + // Check state + switch( iState ) + { + case EConnecting: + { + // DNS lookup is pending - cancel + iHostResolver.Cancel(); + } break; + case EConnected: + { + if( iConnectingSocket ) + { + // Connection is pending - cancel and delete the socket + iConnectingSocket->CancelConnect(); + delete iConnectingSocket; + iConnectingSocket = NULL; + } + } break; + case EIdle: + case EPendingDNSLookup: + default: + // Do nothing... + break; + } + } + +/** +The error handler for when RunL() leaves. This function does any necessary +cleanup. The socket connector is then set to suicide. + +@param aError The leave code. +@return A value of KErrNone.if the error has been handled, any other + value if it has not been handled. +@post The socket connector is in the Suicide state. +*/ +TInt CSocketConnector::RunError(TInt aError) + { +#if defined (_DEBUG) && defined (_LOGGING) + TBuf8 host; + host.Copy((*iHost).Left(KHostNameSize)); //just get the KHostNameSize characters + + __FLOG_1(_T8("!! Error : %d"), aError); + __FLOG_1(_T8("-> connect to host %S failed"), &host); +#endif + + TInt errorToPropagate = aError; + TInt error = KErrNone; + + switch( iState ) + { + case EPendingDNSLookup: + case EConnecting: + { + // In EReadyForDNS or EReadyToConnect states, KErrNotReady may be + // returned by the comms call that require a connection. The RConnection + // that is passed in MUST be started or this error will occur. If we own + // the RConnection we should start the RConnection again, else if our + // client own the RConnection, we just propagate the Comms error. + if( iCommsInfoProvider.OwnsConnection() && aError == KErrNotReady ) + { + // We own the RConnection and the error is KErrNotReady + errorToPropagate = iCommsInfoProvider.Connection().Start(); + + if( errorToPropagate == KErrNone ) + { + // RConnection started successfully, try to connect again + CompleteSelf(); + return KErrNone; + } + } + // Opening the connecting socket has failed or the DNS lookup completed + // with an error code - suicide after notifying the observer - do nothing + // except drop through to the Connected state case... + } + case EConnected: + { + // Either the socket controller factory left in AddToStoreL() or in + // CreateSocketControllerLC(), or the observer left in ConnectionMadeL() + // or the connect request completed with an error code. Inform the + // observer of the error. + error = iObserver->HandleConnectError(errorToPropagate); + } break; + case EIdle: + default: + TImapServerPanic::ImapPanic(TImapServerPanic::EBadSocketConnectorState); + break; + } + + Suicide(); + + return error; + }