/*
* Copyright (c) 2009-2010 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:
* MSRP Implementation
*
*/

// CLASS HEADER
#include "CMSRPConnection.h"
#include "MSRPCommon.h"
// INTERNAL INCLUDES
#include "CMSRPConnector.h"
#include "CMSRPReader.h"
#include "CMSRPParser.h"
#include "CMSRPWriter.h"

// -----------------------------------------------------------------------------
// Constructor
// -----------------------------------------------------------------------------
//
CMSRPConnection::CMSRPConnection( TInetAddr& aRemoteAddr, MMSRPConnectionManager& aConnMngr ): iHostAddress(aRemoteAddr), iConnMngr(aConnMngr)
    {
    MSRPLOG( "CMSRPConnection::CMSRPConnection enter" )
    MSRPLOG( "CMSRPConnection::CMSRPConnection exit" )
    }

// -----------------------------------------------------------------------------
// CMSRPConnection::~CMSRPConnection
// -----------------------------------------------------------------------------
//
CMSRPConnection::~CMSRPConnection()
	{
	MSRPLOG( "CMSRPConnection::~CMSRPConnection enter" )
	iSubsessions.Reset();
	iSubsessions.Close();
	delete iListenTimer;
	delete iConnector;
	delete iWriter;
	delete iParser;
	delete iReader;  
	//delete iBufPool;
	if(iSocket)
	    {
	    iSocket->Close();
	    delete iSocket;
	    }
	
	MSRPLOG( "CMSRPConnection::~CMSRPConnection exit" )
	}

// -----------------------------------------------------------------------------
// CMSRPConnection* CMSRPConnection::NewL
// -----------------------------------------------------------------------------
//
/*static*/ MMSRPConnection* CMSRPConnection::NewL( TInetAddr& aRemoteAddr, MMSRPConnectionManager& aConnMngr )
    {
    MSRPLOG( "CMSRPConnection::NewL enter" )

	// Perform construction.
    CMSRPConnection* self = new ( ELeave ) CMSRPConnection(aRemoteAddr, aConnMngr);
    CleanupStack::PushL( self );
    self->ConstructL( );
    CleanupStack::Pop( self );

    MSRPLOG( "CMSRPConnection::NewL exit" )
    return self;
    }

// -----------------------------------------------------------------------------
// CMSRPConnection::ConstructL
// -----------------------------------------------------------------------------
//
void CMSRPConnection::ConstructL( )
	{
	MSRPLOG( "CMSRPConnection::ConstructL enter" )
	iConnectionState = ENotConnected;
	iListenTimer = CMSRPTimeOutTimer::NewL( *this );
	MSRPLOG( "CMSRPConnection::ConstructL exit" )	
	}

// -----------------------------------------------------------------------------
// CMSRPConnection::CheckIfConnected
// listening state check for validating listener connections 
// -----------------------------------------------------------------------------
//
TBool CMSRPConnection::CheckConnection(TInetAddr& aRemoteAddr, TBool aOnlyListen)
	{
	MSRPLOG( "CMSRPConnection::CheckConnection enter" )
	TUint port_stored = iHostAddress.Port();
	TUint port_connect = aRemoteAddr.Port();
	
	//if (iHostAddress.CmpAddr(aRemoteAddr))//v4, v6 issue	
	if (iHostAddress.Match(aRemoteAddr) && port_stored == port_connect)
	    {
	    if (aOnlyListen && iConnectionState == EListening) //check if listening
	        return ETrue;	    
	    else if (!aOnlyListen /*&& iConnectionState <= EConnected */) //not connected, connecting, listening, connected
	        return ETrue;	   
	    /*else
	        return EFalse;*/ //timed out, disconnecting, disconnected, create a new conn object
	    }
	MSRPLOG( "CMSRPConnection::CheckConnection exit" )	
	return EFalse;
	}

// -----------------------------------------------------------------------------
// CMSRPConnection::ConnectL
// -----------------------------------------------------------------------------
//
TInt CMSRPConnection::ConnectL(MMSRPConnectionObserver& aSubsession)
	{
	MSRPLOG("CMSRPConnection::ConnectL() enter")
	//subsession to ensure it does not reissue
	//connection does not check for pre-existent observers
	
	iSubsessions.AppendL(&aSubsession);	
	
	switch(iConnectionState)
	    {
	    case ENotConnected:
	        //create connector and issue connect
	        //delete iConnector;
	        iConnector = CMSRPConnector::NewL( iConnMngr, *this );
	        iConnector->Connect(iHostAddress);
	        iConnectionState = EConnecting;
	        
	        break;
	        
	    case EConnecting:        
	        break;
	        
	    case EListening: //as of now, dont try to issue connect,complete when other party connects
	        //TBD
	        //later change state to connecting and issue connect
	        //if connect completes before listen, then change state to connected
	        // if at all listen completes on same conn object, then check if state == connected and drop listen conn
	        // do vice versa if listen completes before connect	        	        
	        break;
	        
	    case EConnected:
            break;
            
	    case EListenTimedOut:
	    case EConnectTimedOut:
	    case EError:
	        //shudn't reach here, if connect issued immediately after/within getConn
	        //User::Leave(MMSRPConnectionObserver::EConnectionStateUnexpected);
	        break;                	        
	    
	    }
	MSRPLOG("CMSRPConnection::ConnectL() exit")
	return iConnectionState;
	}
		

// -----------------------------------------------------------------------------
// CMSRPConnection::ListenL
// -----------------------------------------------------------------------------
//
TInt CMSRPConnection::ListenL(MMSRPConnectionObserver& aSubsession)
    {
    MSRPLOG("CMSRPConnection::ListenL() enter")
        
    iSubsessions.AppendL(&aSubsession);
        
    
    switch(iConnectionState)
        {
        case ENotConnected:
            iConnectionState = EListening;
            iConnMngr.ListenL(this);
            //iListenTimer->After( KListenTimeoutInSeconds * KSecondinMicroseconds );
            
            break;
            
        case EConnecting: //dont issue listen, drop conn if other party connects, change later          
            
            //added check if listening in check connection to prevent accepting conn, 
            //simply allowing will corrupt listen count, TBD: introduce another EListeningandConnecting state                        
            break;
            
        case EListening:                      
            break;
            
        case EConnected:
            break;
                
        case EListenTimedOut:
        case EConnectTimedOut:
        case EError:
            //shudn't reach here, if connect issued immediately after/within getConn
            //User::Leave(MMSRPConnectionObserver::EConnectionStateUnexpected);
            break;                         
        
        }
    MSRPLOG("CMSRPConnection::ListenL() exit")
    return iConnectionState;
    
    }

// -----------------------------------------------------------------------------
// CMSRPConnection::ReleaseConnection
// -----------------------------------------------------------------------------
//
void CMSRPConnection::ReleaseConnection(MMSRPConnectionObserver& aSubsession)
    {
    MSRPLOG("CMSRPConnection::ReleaseConnection() enter")
    
    Remove(&aSubsession);
        
    if(iSubsessions.Count())
        {
        MSRPLOG("CMSRPConnection::ReleaseConnection() exit")
        return;
        }
    
    //if no subsessions (TBD : start timeout timer and disconnect on timeout)
    /*if(iConnectionState == EConnecting)
        {
            //iConnector->CancelConnect();
            delete iConnector;
            iConnector = NULL;
        }
    else if(iConnectionState == EConnected)*/
                
    CloseConnection();
        
    
    //iConnectionState = ENotConnected;
    MSRPLOG("CMSRPConnection::ReleaseConnection() exit")
    return;
    }

// -----------------------------------------------------------------------------
// CMSRPConnection::ConnectionEstablishedL
// -----------------------------------------------------------------------------
//
void CMSRPConnection::ConnectionEstablishedL( TInt aNewState, RSocket* aSocket, TInt aStatus )
    {
    MSRPLOG("CMSRPConnection::ConnectionEstablishedL() enter")
    iListenTimer->Cancel();
    //if not error
    if(aNewState == EConnected)
        {
        iConnectionState = aNewState;
        iSocket = aSocket;
        if(iConnector)
           {
           iConnector->ConnectComplete();
           /*dont delete now,as in case of leave, connector needs 2 b available*/
           //delete iConnector;
           //iConnector = NULL;
           }
        iWriter = CMSRPWriter::NewL(*iSocket , *this);               
        iParser = CMSRPParser::NewL(*this);
        iReader = CMSRPReader::NewL(*iSocket , *this);           
             
        iReader->StartReceivingL(iBufPool.ProvideBufferL());
        }

    /*not deleting connector as yet, notify all could leave in subsession  and also delete conn on conn error*/
    //intimate all subsessions
    NotifyAllL(aNewState, aStatus );
    
    //on error  or connect timeout close connection, i.e. intimate all subsessions and delete connection obj
    if(aStatus != KErrNone)
        {
        //listenaccepted does not comeback with error intimations, hence safe to decrement listen count
        //currently no risk of double decrementing listener count
        //CloseConnection();
        }
    

      
    MSRPLOG("CMSRPConnection::ConnectionEstablishedL() exit")   
    }

TInt CMSRPConnection::getConnectionState()
    {
    return iConnectionState;
    // iConnection state should not be Tint, it should be MMSRPConnection::TMSRPConnectionState.
    }

// -----------------------------------------------------------------------------
// CMSRPConnection::ReadStatus
// -----------------------------------------------------------------------------
//
void CMSRPConnection::ReadStatusL(RMsrpBuf& aBuf, TInt aStatus)
    {
    MSRPLOG("CMSRPConnection::ReadStatusL() enter")
    if(aStatus == KErrNone)
        {
        //post to parser and return immediate
        iParser->ParseL(aBuf);
        
        RMsrpBuf copy(aBuf);
        if(copy.MsrpRightExtract() > KThreshold)
            {
            iReader->StartReceivingL(copy);
            }   
        else
            {
            iReader->StartReceivingL(iBufPool.ProvideBufferL());
            }
        return;
        }
    //read error or connection error
    //intimate all subsessions
    NotifyAllL(EError, aStatus );
    //CloseConnection();
    
    MSRPLOG("CMSRPConnection::ReadStatusL() exit")     
    }

TInt CMSRPConnection::ParseStatusL (CMSRPMessageHandler* aMsg, TInt aStatus)
    {
    MSRPLOG("CMSRPConnection::ParseStatus enter")
    if (aStatus != KErrNone)
        {
        NotifyAllL(EError, aStatus );
        return MMSRPParserObserver::EParseStatusError;
        }
    
    /*if error, count is zero*/
    //while msg not consumed try to handover    
    TBool consumed = FALSE;
    for ( TInt i = 0; (!consumed) && i < iSubsessions.Count(); i++ )
         {
         TRAPD( err, consumed = iSubsessions[ i ]->MessageReceivedL( aMsg ) );
         if ( err )
             {
             // invalid message
             NotifyAllL( EError, err );
             return MMSRPParserObserver::EParseStatusError;
             }
         }
    
    //if unclaimed by any subsession, callback to first subsession
    if(!consumed && iSubsessions.Count())
        {
        iSubsessions[0]->UnclaimedMessageL( aMsg );
        return MMSRPParserObserver::EParseStatusMessageUnclaimed;
        }
          
    MSRPLOG("CMSRPConnection::ParseStatus exit")
    return MMSRPParserObserver::EParseStatusMessageHandled;
    }

// -----------------------------------------------------------------------------
// CMSRPConnection::ReportReceiveprogressL
// -----------------------------------------------------------------------------
//
void CMSRPConnection::ReportReceiveprogressL( CMSRPMessageHandler* aMsg )
    {
    MSRPLOG("-> CMSRPConnection::ReportReceiveprogressL")
    
    for ( TInt i = 0; i < iSubsessions.Count(); i++ )
         {
         TRAPD( err, iSubsessions[ i ]->MessageReceiveProgressL( aMsg ) );
         if ( err )
             {
             // invalid message
             NotifyAllL( EError, err );
             return;
             }
         }
          
    MSRPLOG("<- CMSRPConnection::ReportReceiveprogressL")
    }

// -----------------------------------------------------------------------------
// CMSRPConnection::WriteSocketError
// -----------------------------------------------------------------------------
//
void CMSRPConnection::WriteSocketError(TInt aStatus)
    {
    MSRPLOG("CMSRPConnection::WriteSocketError() enter")
    TInt err =0;
    TRAP(err, NotifyAllL(EError, aStatus));
    //CloseConnection();
    MSRPLOG("CMSRPConnection::WriteSocketError() exit")
    }

// -----------------------------------------------------------------------------
// CMSRPConnection::Send
// -----------------------------------------------------------------------------
//
void CMSRPConnection::SendL(MMSRPWriterObserver& aMsg)
    {
    MSRPLOG("CMSRPConnection::SendL() enter")
    if(iConnectionState == EConnected)
        iWriter->RequestSendL(aMsg);
    MSRPLOG("CMSRPConnection::SendL() exit") 
    }
    
// -----------------------------------------------------------------------------
// CMSRPConnection::ContinueSendingL
// -----------------------------------------------------------------------------
//
void CMSRPConnection::ContinueSendingL( MMSRPWriterObserver& aMsg )
    {
    MSRPLOG("-> CMSRPConnection::ContinueSendingL")
    if( iConnectionState == EConnected )
        {
        iWriter->RequestSendL( aMsg );
        }
    MSRPLOG("<- CMSRPConnection::ContinueSendingL") 
    }

// -----------------------------------------------------------------------------
// CMSRPConnection::CancelSendingL
// -----------------------------------------------------------------------------
//
void CMSRPConnection::CancelSendingL( const MMSRPWriterObserver* aMsg )
    {
    MSRPLOG("-> CMSRPConnection::CancelSendingL")
    if( iConnectionState == EConnected )
        {
        iWriter->CancelSendingL( aMsg );
        }
    MSRPLOG("<- CMSRPConnection::CancelSendingL") 
    }

// -----------------------------------------------------------------------------
// CMSRPConnection::TimerExpired
// -----------------------------------------------------------------------------
//
void CMSRPConnection::TimerExpiredL()   
    {
    MSRPLOG("CMSRPConnection::TimerExpired() enter")
    if(iConnectionState == EListening)
        NotifyAllL(EListenTimedOut, KErrTimedOut);
    else 
        NotifyAllL(EConnectTimedOut, KErrTimedOut);
    //iConnMngr.ListenCancel(this);
    MSRPLOG("CMSRPConnection::TimerExpired() exit")
    }


// -----------------------------------------------------------------------------
// CMSRPConnection::Remove
// -----------------------------------------------------------------------------
//
void CMSRPConnection::Remove(MMSRPConnectionObserver* aSubsession)
    {
    MSRPLOG("CMSRPConnection::Remove() enter")
    TInt index = iSubsessions.Find(aSubsession);    
    //iSubsessions[index].DisconnectIssued;
    if(index != KErrNotFound)
        iSubsessions.Remove(index);
    MSRPLOG("CMSRPConnection::Remove() exit")
    }

// -----------------------------------------------------------------------------
// CMSRPConnection::CloseConnection
// -----------------------------------------------------------------------------
//
void CMSRPConnection::CloseConnection()
    {
    MSRPLOG("CMSRPConnection::CloseConnection() enter")
    //for connected no listen cancel needed
    //for listener error listener deleted
    if(/*iConnectionState == EListenConnected ||*/ iConnectionState == EListening || iConnectionState == EListenTimedOut)
        iConnMngr.ListenCancel(this);
    else
        //deleting connection, takes care of issuing cancel connect on connector also (if connecting)
        iConnMngr.Remove(this);
    MSRPLOG("CMSRPConnection::CloseConnection() exit")
    }



// -----------------------------------------------------------------------------
// CMSRPConnection::NotifyAll
// -----------------------------------------------------------------------------
//
void CMSRPConnection::NotifyAllL(TInt aNewState, TInt aStatus ) 
    {
    MSRPLOG("CMSRPConnection::NotifyAll() enter")
    iConnectionState = aNewState;
    for ( TInt i = 0; i < iSubsessions.Count(); i++ )
         {
         //make sure connectionstate does not release in notify
         //else returns a value to reflect the same
         iSubsessions[ i ]->ConnectionStateL( aNewState, aStatus );
         }
    MSRPLOG("CMSRPConnection::NotifyAll() exit")
    }


// End of File