// Copyright (c) 2007-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:
// Sip SubConnection Provider implementation
// 
//

/**
 @file
 @internalComponent
*/


#include "sipscpr.h"
#include "sipscprstates.h"

using namespace ESock;
using namespace NetStateMachine;
using namespace Messages;
using namespace MeshMachine;
_LIT(KPanicSIPSCPRText,"SCPR doesn't appear to expect an incoming connection");

//-=========================================================
//
// Activities
//
//-=========================================================


namespace SipSCprProvisionActivity
{
DECLARE_DEFINE_NODEACTIVITY(ECFActivityStoreProvision, SipSCprProvision, TCFDataClient::TProvisionConfig)
	NODEACTIVITY_ENTRY(KNoTag, SipSCprStates::TStoreProvision, CoreNetStates::TAwaitingProvision, MeshMachine::TNoTag)
NODEACTIVITY_END()
}

namespace SipSCprNoBearerActivity
{
DECLARE_DEFINE_NODEACTIVITY(ECFActivityNoBearer, SipSCprNoBearer, TCFControlProvider::TNoBearer)
	NODEACTIVITY_ENTRY(KNoTag, MeshMachine::TRaiseError<KErrNotSupported>, CoreNetStates::TAwaitingNoBearer, MeshMachine::TNoTag)
NODEACTIVITY_END()	
}

namespace SipSCprStartConnectionActivity
{
DECLARE_DEFINE_CUSTOM_NODEACTIVITY(ECFActivityStart, SipSCprStartConnection, TCFServiceProvider::TStart,PRActivities::CStartActivity::NewL)	
	FIRST_NODEACTIVITY_ENTRY(CoreNetStates::TAwaitingStart, SipSCprStates::TNoTagOrAlreadyStarted)
	NODEACTIVITY_ENTRY(KNoTag, SipSCprStates::TStartSession, SipSCprStates::TAwaitingSessionEstablished, MeshMachine::TNoTagOrErrorTag)
	LAST_NODEACTIVITY_ENTRY(KNoTag, CoreNetStates::TSendStarted)
	LAST_NODEACTIVITY_ENTRY(CoreNetStates::KAlreadyStarted, CoreNetStates::TSendStarted)	
	LAST_NODEACTIVITY_ENTRY(KErrorTag, MeshMachine::TRaiseActivityError)
NODEACTIVITY_END()
}


namespace SipSCprStopActivity
{
DECLARE_DEFINE_NODEACTIVITY(ECFActivityStop, SipSCprStop, TCFServiceProvider::TStop)
	FIRST_NODEACTIVITY_ENTRY(CoreNetStates::TAwaitingStop, SipSCprStates::TNoTagOrAlreadyStopped)	
	//If SCPR is active, stop it, else jumpt to  EAlreadyStopped
	NODEACTIVITY_ENTRY(KNoTag, SipSCprStates::TStopSession, SipSCprStates::TAwaitingSessionTerminated, MeshMachine::TNoTagOrErrorTag)
	LAST_NODEACTIVITY_ENTRY(KNoTag, /*PRStates::TSendStopped*/PRStates::TSendStoppedAndGoneDown)
	LAST_NODEACTIVITY_ENTRY(CoreNetStates::KAlreadyStopped, /*PRStates::TSendStopped*/PRStates::TSendStoppedAndGoneDown)
	LAST_NODEACTIVITY_ENTRY(KErrorTag, MeshMachine::TRaiseAndClearActivityError)
NODEACTIVITY_END()
}


namespace SipSCprParamsRequestActivity
{
#ifdef SYMBIAN_ADAPTIVE_TCP_RECEIVE_WINDOW
DECLARE_DEFINE_NODEACTIVITY(ECFActivityParamRequest, SipSCprSetParams, TCFScpr::TSetParamsRequest)
	FIRST_NODEACTIVITY_ENTRY(PRStates::TAwaitingParamRequest, MeshMachine::TNoTag)
	LAST_NODEACTIVITY_ENTRY(KNoTag, SipSCprStates::TStoreAndSetParams)	
NODEACTIVITY_END()
#else
DECLARE_DEFINE_NODEACTIVITY(ECFActivityParamRequest, SipSCprSetParams, TCFScpr::TParamsRequest)
	FIRST_NODEACTIVITY_ENTRY(SCprStates::TAwaitingParamRequest, MeshMachine::TNoTag)
	LAST_NODEACTIVITY_ENTRY(KNoTag, SipSCprStates::TStoreAndSetParams)	
NODEACTIVITY_END()
#endif //SYMBIAN_ADAPTIVE_TCP_RECEIVE_WINDOW
}

namespace SipSCprBinderRequestActivity
{
DECLARE_DEFINE_CUSTOM_NODEACTIVITY(ECFActivityBinderRequest, SipSCprBinderRequest, TCFServiceProvider::TCommsBinderRequest, MeshMachine::CNodeParallelActivityBase::NewL)
	NODEACTIVITY_ENTRY(KNoTag, MeshMachine::TRaiseError<KErrNotSupported>, CoreNetStates::TAwaitingBinderRequest, MeshMachine::TNoTag)
NODEACTIVITY_END()
}

namespace SipSCprRejoinDataClient
{
DECLARE_DEFINE_CUSTOM_NODEACTIVITY(ECFActivityRejoin, SipSCprRejoin, TCFRejoiningProvider::TRejoinDataClientRequest, PRActivities::CRejoinDataClientActivity::NewL)
	NODEACTIVITY_ENTRY(KNoTag, MeshMachine::TRaiseError<KErrNotSupported>, CoreNetStates::TAwaitingDataClientRejoin, MeshMachine::TNoTag)
NODEACTIVITY_END()
}

namespace SipSCprActivities
{
DECLARE_DEFINE_ACTIVITY_MAP(activityMap)	
	ACTIVITY_MAP_ENTRY(SipSCprProvisionActivity, SipSCprProvision)
	ACTIVITY_MAP_ENTRY(SipSCprNoBearerActivity, SipSCprNoBearer)
	ACTIVITY_MAP_ENTRY(SipSCprStartConnectionActivity, SipSCprStartConnection)	
	ACTIVITY_MAP_ENTRY(SipSCprStopActivity, SipSCprStop)
	ACTIVITY_MAP_ENTRY(SipSCprParamsRequestActivity, SipSCprSetParams)
	ACTIVITY_MAP_ENTRY(SipSCprBinderRequestActivity, SipSCprBinderRequest)
	ACTIVITY_MAP_ENTRY(SipSCprRejoinDataClient, SipSCprRejoin)	
	ACTIVITY_MAP_ENTRY(SipSCprRejoinDataClient, SipSCprRejoin)	
ACTIVITY_MAP_END_BASE(SCprActivities, coreSCprActivities)
}  

//-=========================================================
//
// CSipSubConnectionProvider methods
//
//-=========================================================	
CSipSubConnectionProvider::~CSipSubConnectionProvider()
    {
    LOG_NODE_DESTROY(KSipSCprTag, CSipSubConnectionProvider);
    if(iSipSm != NULL)
    iSipSm->DeleteWhenReady();
    }

CSipSubConnectionProvider::CSipSubConnectionProvider(ESock::CSubConnectionProviderFactoryBase& aFactory)
	: CCoreSubConnectionProvider(aFactory, SipSCprActivities::activityMap::Self())
    {
    LOG_NODE_CREATE(KSipSCprTag, CSipSubConnectionProvider);
    
    }

CSipSubConnectionProvider* 
CSipSubConnectionProvider::NewL(CSubConnectionProviderFactoryBase& aFactory, TSubConnOpen::TSubConnType aSubConnType)
	{
	CSipSubConnectionProvider* provider = new(ELeave)CSipSubConnectionProvider(aFactory);
	CleanupStack::PushL(provider);
    provider->ConstructL(aSubConnType);
    CleanupStack::Pop();
    return provider;
	}
	
	
void CSipSubConnectionProvider::ConstructL(TSubConnOpen::TSubConnType aSubConnType)
	{
	CCoreSubConnectionProvider::ConstructL();
	iStage = SipSCpr::EFresh;		
	subconType = aSubConnType;
	// Set the flag if the sub con type is WaitForIncoming	
	if (aSubConnType == RSubConnection::EWaitIncoming)
		{
		iAwaitingSubConnection = ETrue;		
		}
		else
		{
		iAwaitingSubConnection = EFalse;
		}		
	iSipSm = NULL;
	}


void CSipSubConnectionProvider::ReceivedL(const TRuntimeCtxId& aSender, const TNodeId& aRecipient, TSignatureBase& aMessage)
    {
	TNodeContext<CSipSubConnectionProvider> ctx(*this, aMessage, aSender, aRecipient);
    CCoreSubConnectionProvider::Received(ctx);
    User::LeaveIfError(ctx.iReturn);
	}
	
void CSipSubConnectionProvider::DoParametersAboutToBeSetL(RCFParameterFamilyBundle_const& aParameterBundle)
	{
	
	if (iStage != SipSCpr::EFresh)
    	{
    	//Can't change parameters after starting.
    	User::Leave(KErrNotSupported);  
    	}
    	
	RParameterFamily calldescrFamily = aParameterBundle.FindFamily(KSubConnCallDescrParamsFamily);
	RParameterFamily authFamily = aParameterBundle.FindFamily(KSubConAuthorisationFamily);
	if(!calldescrFamily.IsNull())
		{
        TSipParams& sipParams = iSipSm->GetSipParams();		
        STypeId idInv = STypeId::CreateSTypeId(KSubConSIPParametersUid,KSubConSIPInviteParamsType);
        STypeId idSbs = STypeId::CreateSTypeId(KSubConSIPParametersUid,KSubConSIPSubscribeParamsType);
		CSubConSIPInviteParamSet* sipInvitationParams = (CSubConSIPInviteParamSet*)calldescrFamily.FindParameterSet(
						idInv, RParameterFamily::ERequested);
		CSubConSIPSubscribeParamSet* sipSubscribeParams = (CSubConSIPSubscribeParamSet*)calldescrFamily.FindParameterSet(
						idSbs, RParameterFamily::ERequested);

        if (sipInvitationParams)
            { 
    	    __CFLOG_VAR((KSipSCprTag, KSipSCprSubTag, _L8("CSipSubConnectionProvider::DoParametersAboutToBeSet() [this=%08x]\t -- CSubConSIPInviteParamSet found "), this));
            
            sipParams.iRequest = TSipHLConsts::ERequestInvite;
            sipParams.iInvParams.iReqUri.Set(sipInvitationParams->GetRequestUri());
            sipParams.iInvParams.iTo.Set(sipInvitationParams->GetTo());
            if (sipInvitationParams->GetFrom().Length() == 0)
                {
                //The application may fail to supply 'from' in which case we
                //should reuse the 'from' field stored by the profile.
           	    __CFLOG_VAR((KSipSCprTag, KSipSCprSubTag, _L8("CSipSubConnectionProvider::DoParametersAboutToBeSet() [this=%08x]\t -- From field not found"), this));
                sipInvitationParams->SetFromL(*iFromField);
        	    }   
            sipParams.iInvParams.iFrom.Set(sipInvitationParams->GetFrom());
            sipParams.iInvParams.iContact.Set(sipInvitationParams->GetContact());
            sipParams.iInvParams.iContentType.Set(sipInvitationParams->GetContentType());
            sipParams.iInvParams.iContentSubType.Set(sipInvitationParams->GetContentSubType());
            sipParams.iInvParams.iContent.Set(sipInvitationParams->GetContent());
            }
        else if (sipSubscribeParams)
            {
    	    __CFLOG_VAR((KSipSCprTag, KSipSCprSubTag, _L8("CSipSubConnectionProvider::DoParametersAboutToBeSet() [this=%08x]\t -- CSubConSIPSubscribeParamSet found"), this));
            
            sipParams.iRequest = TSipHLConsts::ERequestSubscribe;
            sipParams.iSubsParams.iReqUri.Set(sipSubscribeParams->GetRequestUri());
            sipParams.iSubsParams.iTo.Set(sipSubscribeParams->GetTo());
            if (sipSubscribeParams->GetFrom().Length() == 0)
                {
                //The application may fail to supply 'from' in which case we
                //should reuse the 'from' field stored by the profile.
                __CFLOG_VAR((KSipSCprTag, KSipSCprSubTag, _L8("CSipSubConnectionProvider::DoParametersAboutToBeSet() [this=%08x]\t -- From field not found"), this));
        	    sipSubscribeParams->SetFromL(*iFromField);
                }
            sipParams.iSubsParams.iFrom.Set(sipSubscribeParams->GetFrom());
            sipParams.iSubsParams.iContact.Set(sipSubscribeParams->GetContact());
            sipParams.iSubsParams.iEventType.Set(sipSubscribeParams->GetEventType());
            sipParams.iSubsParams.iAcceptType.Set(sipSubscribeParams->GetAcceptType());
            sipParams.iSubsParams.iAcceptSubType.Set(sipSubscribeParams->GetAcceptSubType());
            sipParams.iSubsParams.iExpires = sipSubscribeParams->GetExpires();
            sipParams.iSubsParams.iAutoRefresh = sipSubscribeParams->GetAutoRefresh();
            }
        else
            {
    	    __CFLOG_VAR((KSipSCprTag, KSipSCprSubTag, _L8("CSipSubConnectionProvider::DoParametersAboutToBeSet() [this=%08x]\t -- UnSupported Call Description Params"), this));
    	    //Send error message to mesh. Error activity will handle it and pass it originator
		    User::Leave(KErrNotSupported);		    
		    }
		}
	if (!authFamily.IsNull())
    	{
        STypeId idAuth = STypeId::CreateSTypeId(KSubConSIPParametersUid,KSubConSIPAuthenticateParamsType);
		CSubConSIPAuthenticateParamSet* sipAuthenticateParams = (CSubConSIPAuthenticateParamSet*)authFamily.FindParameterSet(
						idAuth, RParameterFamily::ERequested);
    	
        if (sipAuthenticateParams)
            {
    	    __CFLOG_VAR((KSipSCprTag, KSipSCprSubTag, _L8("CSipSubConnectionProvider::DoParametersAboutToBeSet() [this=%08x]\t -- CSubConSIPAuthenticateParamSet found"), this));

            TSIPCredentials credentials;
            credentials.iUserName.Set(sipAuthenticateParams->GetUserName());
            credentials.iPasswd.Set(sipAuthenticateParams->GetPassword());
            credentials.iRealm.Set(sipAuthenticateParams->GetRealm());
            iTransitionEngine->AddCredentialsL(credentials);
            }
        else
            {            
    	    __CFLOG_VAR((KSipSCprTag, KSipSCprSubTag, _L8("CSipSubConnectionProvider::DoParametersAboutToBeSet() [this=%08x]\t -- UnSupported Authentication Params"), this));
    	    //Send error message to mesh. Error activity will handle it and pass it originator
		    User::Leave(KErrNotSupported);
            }            
    	}
    if(authFamily.IsNull() && calldescrFamily.IsNull())
		{
   	    __CFLOG_VAR((KSipSCprTag, KSipSCprSubTag, _L8("CSipSubConnectionProvider::DoParametersAboutToBeSet() [this=%08x]\t --Auth and Call Description Family NULL"), this));
   	    //Send error message to mesh. Error activity will handle it and pass it originator
        User::Leave(KErrNotFound);        
		}	
	}
		
	void CSipSubConnectionProvider::InitialiseParametersL(TIncomingCallParameters& aCallParams)
		{
		RCFParameterFamilyBundle newBundle;
		iParameterBundle.CreateL();
		newBundle.CreateL();
		newBundle.Open(iParameterBundle);
    	RParameterFamily sipCallDescrFamily = newBundle.CreateFamilyL(KSubConnCallDescrParamsFamily);
		CSubConSIPInviteParamSet* subConSipRequestedParSet = 
	    CSubConSIPInviteParamSet::NewL(sipCallDescrFamily, RParameterFamily::ERequested);

    	subConSipRequestedParSet->SetRequestUriL(aCallParams.iReqUri);
    	subConSipRequestedParSet->SetFromL(aCallParams.iFrom);
    	subConSipRequestedParSet->SetToL(aCallParams.iTo);
		subConSipRequestedParSet->SetContentL(aCallParams.iContent);
		}
//-=========================================================
//
// MSIPStateMachineClient methods
//
//-=========================================================	

void CSipSubConnectionProvider::CallEstablished()
	{
	
	__CFLOG_VAR((KSipSCprTag, KSipSCprSubTag, _L8("CSipSubConnectionProvider::Call Established")));
    
    //We dont need this error here, neither do we need to pass erro in SessionEstablished message
    TInt error = KErrNone;
    ASSERT(iStage == SipSCpr::EStarting);
	RClientInterface::OpenPostMessageClose(Id(),TNodeCtxId(iActivityAwaitingResponse, Id()),TSipSCprMessages::TSipSessionEstablished(error).CRef());	
	iActivityAwaitingResponse = MeshMachine::KActivityNull;  
    }


void CSipSubConnectionProvider::CallTerminated(TInt aError, TInt aSipCode)
	{
	
	//The CallTerminated callback method can be triggered in three cases
	//1. As a result of RsubConnection::Stop(). The UE wants to send a BYE
	//2. As a result of the remote UE sending a BYE
	//3. SCPR start fails (in the cases where sip HL API's doesn't support the given SIP method)
	
	__CFLOG_VAR((KSipSCprTag, KSipSCprSubTag, _L8("CSipSubConnectionProvider::Call Terminated")));	
    
    iStage = SipSCpr::EStopped;
    
    if(iActivityAwaitingResponse == ECFActivityStart)        
    	{
    	__CFLOG_VAR((KSipSCprTag, KSipSCprSubTag, _L8("CSipSubConnectionProvider::Call Terminated : Activity Start")));	
    	RClientInterface::OpenPostMessageClose(Id(),TNodeCtxId(iActivityAwaitingResponse, Id()),TSipSCprMessages::TSipSessionEstablished(aError).CRef());	
    	iActivityAwaitingResponse = MeshMachine::KActivityNull;  
    	}
    	else if (iActivityAwaitingResponse == ECFActivityStop)
    	{
    	__CFLOG_VAR((KSipSCprTag, KSipSCprSubTag, _L8("CSipSubConnectionProvider::Call Terminated : Activity Stop")));	
    	RClientInterface::OpenPostMessageClose(Id(),TNodeCtxId(iActivityAwaitingResponse, Id()),TSipSCprMessages::TSipSessionTerminated(aError).CRef());	
    	iActivityAwaitingResponse = MeshMachine::KActivityNull;  
    	}
    	else
    	{
    	// it if for incoming connection
    	//if (iAwaitingSubConnection)
    	//	{
    	// When the remote party sends BYE send a notification for which the 
    	// app is subscribed to.
    	//Notify the upper layeer about the extended SIP reason for termination
    	CSubConSIPResponseEvent* sipevent = NULL;
    	TRAPD(error, sipevent = CSubConSIPResponseEvent::NewL());    
    	if (error != KErrNone)
        	{
       		__CFLOG_VAR((KSipSCprTag, KSipSCprSubTag, _L8("CSubConSIPResponseEvent::NewL() left with the error: [%d]"), error));
    	  	return;
        	}
    	sipevent->SetResponse(aSipCode);
    	TRAP(error, NotifyClientsL(*sipevent));    		        	    	
    	if (error != KErrNone)
		    {
		    __CFLOG_VAR((KSipSCprTag, KSipSCprSubTag, _L8("NotifyClientsL left with the error: [%d]"), error));
		    return;
        	}
		}
    }

/**
This is a call-back function of SIP stata machine. 
It will be called when an incoming connection(incoming INVITE) is received with the 
incoming connection parameters
*/
void CSipSubConnectionProvider::IncomingCall(TIncomingCallParameters& aCallParams)
	{
	__CFLOG_VAR((KSipSCprTag, KSipSCprSubTag, _L8("CSipSubConnectionProvider::IncomingCall")));
    
    ASSERT(iStage == SipSCpr::EFresh);
    TInt error = KErrNone;
    
    if ((!iAwaitingSubConnection) || !iParameterBundle.IsNull())
        {
        //The logic behind this panic is that IncomingCall() should not
        //arrive, if it doesn't represent an incoming subconnection
        //that is:
        // iAwaitingSubConnection has have to be true
	    User::Panic(KPanicSIPSCPRText, KErrBadHandle);
        }
        
    TRAP(error, InitialiseParametersL(aCallParams));
	if (error != KErrNone)
    	{
    	__CFLOG_VAR((KSipSCprTag, KSipSCprSubTag, _L8("CSipSubConnectionProvider::InitialiseParametersL() left with error [%d]"), error));
		}		
	//at this point the incoming subconnection has been deemed fit
	//scpr should now send a TIncomingConnection message to its CPR so that RConn::WaitForIncoming can return
        
    // post this message to its control provider SIP CPR to send binder response 
    // so that the subcon.open will be returned
    RNodeInterface* cp = ControlProvider();
    cp->PostMessage(Id(),SipCpr::TSipCprMessages::TIncomingConnection(0).CRef());
    
	}
	
/**
This is a call-back function of the SIP state machine.
It will be called when the high-level API ignores the received challenge
(Response code 401). 
*/
void CSipSubConnectionProvider::CredentialsRequired(const TDesC8 &/* aRealm*/)
	{
	
	__CFLOG_VAR((KSipSCprTag, KSipSCprSubTag, _L8("CSipSubConnectionProvider::CredentialsRequired")));
	    
    ASSERT(iStage == SipSCpr::EStarting);
    TInt error = KErrNone;
    
    CSubConSIPAuthenticationRequiredEvent* event = NULL;
	TRAP(error, event = CSubConSIPAuthenticationRequiredEvent::NewL());
	if (error != KErrNone)
    	{
    	__CFLOG_VAR((KSipSCprTag, KSipSCprSubTag, _L8(" CSubConSIPAuthenticationRequiredEvent::NewL()left with error [%d]"), error));	    	    
	    return;
    	}
    delete event; // remove this if the following code is uncommented
    // uncomment the following code if app is subscribed for the event
    #if 0
    TRAP(error, event->SetRealmL(aRealm));
	if (error != KErrNone)
    	{
    	__CFLOG_VAR((KSipSCprTag, KSipSCprSubTag, _L8("CSubConSIPAuthenticationRequiredEvent::SetRealmL()  left with error [%d]"), error));    	      	
	    return;
    	}
     TRAP(error, NotifyClientsL(*event)); 
	if (error != KErrNone)
	{
	__CFLOG_VAR((KSipSCprTag, KSipSCprSubTag, _L8("NotifyClientsL left with the error: [%d]"), error));
	return;
	}
     #endif   
	}

/**
This is callback function. This will be called when the SIP high-level
API receives notification for the Subscribe request
*/
void CSipSubConnectionProvider::ReceiveNotification(TDesC8 & aNotification)
	{
	
	__CFLOG_VAR((KSipSCprTag, KSipSCprSubTag, _L8("CSipSubConnectionProvider::ReceiveNotification")));
	CSubConSIPNotificationEvent* event = CSubConSIPNotificationEvent::NewL();
	TRAPD(error, event->SetNotificationL(aNotification));
	if (error != KErrNone)
	{
	__CFLOG_VAR((KSipSCprTag, KSipSCprSubTag, _L8("event->SetNotificationL left with the error: [%d]"), error));
	return;
	}
	
	TInt32 gId = event->GroupId();
		
	TRAP(error, NotifyClientsL(*event));      
	if (error != KErrNone)
	{
	__CFLOG_VAR((KSipSCprTag, KSipSCprSubTag, _L8("NotifyClientsL left with the error: [%d]"), error));
	return;
	}
	}
	
/**
Creates SIP high-level state machine
*/
void CSipSubConnectionProvider::CreateStateMachineL()
	{	
 	iSipSm = CSipStateMachine::NewL(iTransitionEngine,NodeAddr(), iAwaitingSubConnection); 	
 	}

// this pointer is used in the creation of the SIP statemachine	
MSIPStateMachineClient* CSipSubConnectionProvider::NodeAddr()
{
	return this; 
}