/*
* Copyright (c) 2006-2007 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:  Socket opener implementation
*
*/


#include <e32property.h>
#include <HttpDownloadMgrCommon.h>
#include <in_sock.h>
#include <uriutils.h>

#include "irpubsubkeys.h"
#include "irdebug.h"
#include "irnetworkcontroller.h"
#include "irsocketopener.h"
#include "irstationconnection.h"
#include "irstreamsourceerrors.h"
#include "irstreamsourceliterals.h"

const TInt KIRSOTimeOutValue = 10000000;

// ---------------------------------------------------------------------------
// CIRSocketOpener::NewL
// ---------------------------------------------------------------------------
//
CIRSocketOpener* CIRSocketOpener::NewL( RSocket& aSocket, CIRStationConnection& aOwner )
	{
	CIRSocketOpener* self = new ( ELeave ) CIRSocketOpener( aSocket, aOwner );
	CleanupStack::PushL( self );
	self->ConstructL();
	CleanupStack::Pop( self );
	return self;
	}
	
// ---------------------------------------------------------------------------
// CIRSocketOpener::CIRSocketOpener
// ---------------------------------------------------------------------------
//
CIRSocketOpener::CIRSocketOpener( RSocket& aSocket, CIRStationConnection& aOwner )
	:CActive( EPriorityStandard ), iPort( KDefaultPort ), iSocket( aSocket), iOwner( aOwner )
	{
	}

// ---------------------------------------------------------------------------
// CIRSocketOpener::ConstructL
// ---------------------------------------------------------------------------
//
void CIRSocketOpener::ConstructL()
	{
	IRLOG_DEBUG( "CIRSocketOpener::ConstructL" );	
	CActiveScheduler::Add( this );
	iState = EIRIdle;
	iSocketTimer = CIRSocketTimeOutTimer::NewL( CActive::EPriorityHigh,*this );

	CIRNetworkController* networkControllerHandle = CIRNetworkController::OpenL();
	CleanupClosePushL( *networkControllerHandle );

    TProtocolName protocolName( KTcpProtocol );
	TProtocolDesc protocolInfo;
	
	networkControllerHandle->GetIRSocketServer().FindProtocol( protocolName, protocolInfo );
	
	iResolver.Close();

	User::LeaveIfError( iResolver.Open( networkControllerHandle->GetIRSocketServer(),
	                                   protocolInfo.iAddrFamily, protocolInfo.iProtocol,
	                                   networkControllerHandle->GetIRConnection() ) );

	IRLOG_DEBUG( "CIRSocketOpener::ConstructL - Opened resolver." );
	User::LeaveIfError( iSocket.Open( networkControllerHandle->GetIRSocketServer(),
				 protocolInfo.iAddrFamily,protocolInfo.iSockType,protocolInfo.iProtocol,
	                                  networkControllerHandle->GetIRConnection() ) );
    IRLOG_DEBUG( "CIRSocketOpener::ConstructL - Opened socket." );
	                                   
    CleanupStack::PopAndDestroy();
	IRLOG_DEBUG( "CIRSocketOpener::ConstructL - Exiting." );	    
	}

// ---------------------------------------------------------------------------
// CIRSocketOpener::CIRSocketOpener
// ---------------------------------------------------------------------------
//
CIRSocketOpener::~CIRSocketOpener()
	{
	Cancel();
//	iResolver.Close()	
    iHost.Close();	
	delete iSocketTimer;	
	}

// ---------------------------------------------------------------------------
// CIRSocketOpener::ResolveAddress()
// ---------------------------------------------------------------------------
//
void CIRSocketOpener::ResolveAddress()
	{
	IRLOG_INFO2( "CIRSocketOpener::ResolveAddress - %S", &iHost );
    Cancel();
	iState = EIRResolving;

	iSocketTimer->Cancel();
	iSocketTimer->After( KIRSOTimeOutValue );
	
	iResolver.GetByName( iHost, iResolvedHostInfo, iStatus );
	SetActive();

	IRLOG_DEBUG( "CIRSocketOpener::ResolveAddress - Exiting." );                
	}

// ---------------------------------------------------------------------------
// CIRSocketOpener::ConnectToAddress()
// ---------------------------------------------------------------------------
//
void CIRSocketOpener::ConnectToAddress()
	{
	IRLOG_INFO( "CIRSocketOpener::ConnectToAddress" );
    Cancel();
	iState = EIRConnecting;

	iSocketTimer->Cancel();
	iSocketTimer->After( KIRSOTimeOutValue );
	
	iSocket.Connect( iSockAddr, iStatus );
	SetActive();

	IRLOG_DEBUG( "CIRSocketOpener::ConnectToAddress - Exiting." );    
    }   

// ---------------------------------------------------------------------------
// CIRSocketOpener::ExtractUriComponents
// ---------------------------------------------------------------------------
//
TBool CIRSocketOpener::ExtractUriComponentsL(const TDesC& aUrl)
	{
	IRLOG_DEBUG( "CIRSocketOpener::ExtractUriComponentsL" );    

    TBool retMe = EFalse;

	if( !UriUtils::HasInvalidChars( aUrl ) )
		{
    	// Initialize the Uri Parser
    	CUri8* uri = UriUtils::CreateUriL( aUrl );
    	CleanupStack::PushL( uri );
    	
    	const TUriC8& accessorUri = uri->Uri(); 

        iHost.Close();
    
        const TDesC8& host = accessorUri.Extract( EUriHost ); 
        if ( host.Length() > 0 )
            {
            if ( iHost.Create( host.Length() ) == KErrNone )
                {
                iHost.Copy( host );
            
	            TLex8 uriLex( accessorUri.Extract( EUriPort ) );
	            if ( uriLex.Val( iPort ) != KErrNone )
	                {
    	            iPort = KDefaultPort;
	                }
                retMe = ETrue;	            
                }
            }
        CleanupStack::PopAndDestroy( uri );
		}
	IRLOG_DEBUG2( "CIRSocketOpener::ExtractUriComponentsL - Returning %d.", retMe );        
	return retMe;
	}


// ---------------------------------------------------------------------------
// CIRSocketOpener::RunL
// ---------------------------------------------------------------------------
//
void CIRSocketOpener::RunL()
	{
	IRLOG_INFO3( "CIRSocketOpener::RunL - iStatus = %d, iState = %d", iStatus.Int(), iState );

	if( iStatus == KErrNone )
		{
		switch( iState )
			{
			case EIRResolving:
				iSocketTimer->Cancel();
				iSockAddr = ( iResolvedHostInfo() ).iAddr;
				iSockAddr.SetPort( iPort );
				ConnectToAddress();
				break;
			case EIRConnecting:
    			iSocketTimer->Cancel();
				iState = EIRReady;
				iOwner.ConnectionReady();
				break;
			default:
                __ASSERT_DEBUG( EFalse, User::Invariant() );
    			break;
			}
		}
	else 
		{
		switch( iState )
			{
			case EIRResolving:
				IRLOG_ERROR( "CIRConnectionHandler::RunL - EIRResolving" );
				iSocketTimer->Cancel();
				iOwner.ConnectionError( KIRStreamSourceLookupError );
				break;
			case EIRConnecting: 
				IRLOG_ERROR( "CIRConnectionHandler::RunL - EConnecting"); 
				iSocketTimer->Cancel();
				iOwner.ConnectionError( KIRStreamSourceConnectionError );
				break;
			default:
				IRLOG_FATAL2( "CIRConnectionHandler::RunL - Error in unexpected state (%d)", iStatus.Int() );
                __ASSERT_DEBUG( EFalse, User::Invariant() );				
				break;
			}
		}
	IRLOG_DEBUG( "CIRSocketOpener::RunL - Exiting." );
	}

// ---------------------------------------------------------------------------
// CIRSocketOpener::Connect
// ---------------------------------------------------------------------------
//
void CIRSocketOpener::ConnectL( const TDesC& aUrl )
	{
    IRLOG_INFO2( "CIRSocketOpener::ConnectL - %S", &aUrl );
	if( ExtractUriComponentsL( aUrl ) )
		{
		ResolveAddress();		  	
		}
	else
		{
		IRLOG_ERROR( "CIRConnectionHandler::ConnectL - Invalid URL" );
		iOwner.ConnectionError( KIRStreamSourceInvalidUrl );		  		
		}  
	IRLOG_DEBUG( "CIRSocketOpener::ConnectL - Exiting." );		
	}

// ---------------------------------------------------------------------------
// CIRSocketOpener::TimerExpired
// ---------------------------------------------------------------------------
//
void CIRSocketOpener::TimerExpired()
	{
	switch( iState )
		{
		case EIRResolving: 
			Cancel();
			IRLOG_ERROR( "CIRSocketOpener::TimerExpired - Timed out while looking up server." );
			iOwner.ConnectionError( KIRStreamSourceTimeOut );
			break;
		
		case EIRConnecting: 
		    Cancel();
			IRLOG_ERROR( "CIRSocketOpener::TimerExpired - Connecting to server timed out." );   	 		    
			iOwner.ConnectionError( KIRStreamSourceTimeOut );
			break;
		default:
            __ASSERT_DEBUG( EFalse, User::Invariant() );				
			break;
		} 
	}


// ---------------------------------------------------------------------------
// CIRSocketOpener::DoCancel
// ---------------------------------------------------------------------------
//
void CIRSocketOpener::DoCancel()
	{
	IRLOG_DEBUG( "CIRSocketOpener::DoCancel." );	
	iResolver.Cancel();
	iSocket.CancelAll();
	
	iSocketTimer->Cancel();
	IRLOG_DEBUG( "CIRSocketOpener::DoCancel - Exiting." );		
	}