iSocketsReader->Start();
        }
    }

// -----------------------------------------------------------------------------
// CSocketsEngine::RunL()
// Called when operation completes.
// -----------------------------------------------------------------------------
//
void CSocketsEngine::RunL()
    {
    // Active object request complete handler.
    // iEngineStatus flags what request was made, so its
    // completion can be handled appropriately
    iTimer->Cancel(); // Cancel TimeOut timer before completion

    switch( iEngineStatus )
        {
        case EConnecting:
            // IP connection request
            if ( iStatus == KErrNone )
                // Connection completed successfully
                {
                ChangeStatus( EConnected );
                Read(); //Start CSocketsReader Active object
                }
            else
                {
                iSocket.Close();

                // Read localized error message from resource file
                HBufC* connectionError =
                    StringLoader::LoadLC( R_SOCK_CONN_FAILED );
                iConsole.ErrorNotify( *connectionError, iStatus.Int() );
                CleanupStack::PopAndDestroy(); // connectionError
                ChangeStatus( ENotConnected );
                }
            break;
        case ELookingUp:
            iResolver.Close();
            if ( iStatus == KErrNone )
                {
                // DNS look up successful
                iNameRecord = iNameEntry();

                // Extract domain name and IP address from name record
                HBufC* domainName =
                    StringLoader::LoadLC( R_SOCK_DOMAIN_NAME );
                Print( *domainName );
                CleanupStack::PopAndDestroy(); // domainName
                Print( iNameRecord.iName );

                TBuf<15> ipAddr;
                TInetAddr::Cast( iNameRecord.iAddr ).Output( ipAddr );

                HBufC* ipAddress = StringLoader::LoadLC( R_SOCK_IP_ADDRESS );
                Print( *ipAddress );
                CleanupStack::PopAndDestroy(); // domainName

                Print( ipAddr );
                Print( KStrNewLine );

                // And connect to the IP address
                ChangeStatus( ENotConnected );
                ConnectL( TInetAddr::Cast( iNameRecord.iAddr ).Address() );
                }
            else
                {
                // DNS lookup failed
                HBufC* dnsError = StringLoader::LoadLC( R_SOCK_DNS_FAILED );
                iConsole.ErrorNotify( *dnsError, iStatus.Int() );
                CleanupStack::PopAndDestroy(); // dnsError
                ChangeStatus( ENotConnected );
                }
            break;
        default:
            User::Panic( KPanicSocketsEngine, ESocketsBadStatus );
            break;

        };
    }

// -----------------------------------------------------------------------------
// CSocketsEngine::TimerExpired()
// The function to be called when a timeout occurs.
// -----------------------------------------------------------------------------
//
void CSocketsEngine::TimerExpired()
    {
    Cancel();

    TBuf<KMaxMessageLength> timeOutError;
    StringLoader::Load(timeOutError, R_SOCK_TIMEOUT );
    iConsole.ErrorNotify( timeOutError, KErrTimedOut );
    }

// -----------------------------------------------------------------------------
// CSocketsEngine::ReportError()
// Report a communication error.
// -----------------------------------------------------------------------------
//
void CSocketsEngine::ReportError( MEngineNotifier::TErrorType aErrorType,
                                  TInt aErrorCode )
    {
    // No recovery or retries are attempted in this example so we just
    // disconnect and inform the user
    Disconnect();
    TBuf<KMaxMessageLength> errorMessage;
    switch ( aErrorType )
        {
        case MEngineNotifier::EDisconnected:
            StringLoader::Load( errorMessage, R_SOCK_DISCONNECTED );
            iConsole.ErrorNotify( errorMessage, aErrorCode );
            break;
        case MEngineNotifier::EGeneralReadError:
            StringLoader::Load( errorMessage, R_SOCK_READ_ERROR );
            iConsole.ErrorNotify( errorMessage, aErrorCode );
            break;
        case MEngineNotifier::ETimeOutOnWrite:
            StringLoader::Load( errorMessage, R_SOCK_WRITE_TIMEOUT );
            iConsole.ErrorNotify( errorMessage, aErrorCode );
            break;
        case MEngineNotifier::EGeneralWriteError:
            StringLoader::Load( errorMessage, R_SOCK_GENERAL_WRITE_ERROR );
            iConsole.ErrorNotify( errorMessage, aErrorCode );
            break;
        default:
            User::Panic( KPanicSocketsEngine, ESocketsBadStatus );
            break;
        }
    }

// -----------------------------------------------------------------------------
// CSocketsEngine::ResponseReceived()
// Data has been received on the socket and read into a buffer.
// -----------------------------------------------------------------------------
//
void CSocketsEngine::ResponseReceived( const TDesC8& aBuffer )
    {
    iConsole.PrintNotify( aBuffer );
    }

// -----------------------------------------------------------------------------
// CSocketsEngine::ChangeStatus()
// Handles a change in this object's status.
// -----------------------------------------------------------------------------
//
void CSocketsEngine::ChangeStatus( TSocketsEngineState aNewStatus )
    {
    TBuf<KMaxMessageLength> statusInfo;
    // Update the status ( and the status display )
    switch ( aNewStatus )
        {
        case ENotConnected:
            StringLoader::Load( statusInfo, R_SOCK_NOT_CONNECTED );
            iConsole.SetStatus( statusInfo );
            break;
        case EConnecting:
            StringLoader::Load( statusInfo, R_SOCK_CONNECTING );
            iConsole.SetStatus( statusInfo );
            break;
        case EConnected:
            StringLoader::Load( statusInfo, R_SOCK_CONNECTED );
            iConsole.SetStatus( statusInfo );
            break;
        case ELookingUp:
            StringLoader::Load( statusInfo, R_SOCK_LOOKING_UP );
            iConsole.SetStatus( statusInfo );
            break;
        default:
            User::Panic( KPanicSocketsEngine, ESocketsBadStatus );
            break;
        }
    iEngineStatus = aNewStatus;
    }

// -----------------------------------------------------------------------------
// CSocketsEngine::Print()
// Displays text on the console.
// -----------------------------------------------------------------------------
//
void CSocketsEngine::Print( const TDesC& aDes )
    {
    iConsole.PrintNotify( aDes, CEikGlobalTextEditor::EItalic );
    }

// -----------------------------------------------------------------------------
// CSocketsEngine::SetServerName()
// Sets name of server to connect to.
// -----------------------------------------------------------------------------
//
void CSocketsEngine::SetServerName( const TDesC& aName )
    {
    iServerName.Copy( aName );
    }

// -----------------------------------------------------------------------------
// CSocketsEngine::ServerName()
// Gets server name.
// -----------------------------------------------------------------------------
//
const TDesC& CSocketsEngine::ServerName() const
    {
    return iServerName;
    }

// -----------------------------------------------------------------------------
// CSocketsEngine::SetPort()
// Sets port number to connect to.
// -----------------------------------------------------------------------------
//
void CSocketsEngine::SetPort( TInt aPort )
    {
    iPort = aPort;
    }

// -----------------------------------------------------------------------------
// CSocketsEngine::Port()
// Gets port number.
// -----------------------------------------------------------------------------
//
TInt CSocketsEngine::Port() const
    {
    return iPort;
    }

// -----------------------------------------------------------------------------
// CSocketsEngine::Connected()
// Checks if socket is fully connected.
// -----------------------------------------------------------------------------
//
TBool CSocketsEngine::Connected() const
    {
    return ( iEngineStatus == EConnected );
    }

// End of File