/**
*   Copyright (c) 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:
*   Flow implementation for data path for tunnel driver.
* 
*
*/

/**
 @file tundriverflow.cpp
 @internalTechnology
*/

#include <e32std.h>
#include <ecom/ecom.h>
#include <ecom/implementationproxy.h>
#include <elements/nm_messages_base.h>
#include <elements/nm_messages_child.h>

#include "ss_subconnflow.h"
#include <comms-infras/ss_log.h>
#include "tundriverflow.h"
#include "tundriverbinder.h"
#include "tundriverprovision.h"

using namespace Messages;
using namespace MeshMachine;
using namespace ESock;

#ifdef SYMBIAN_TRACE_ENABLE
_LIT8(KNif,"tundriver");
#endif

CTunDriverSubConnectionFlowFactory* CTunDriverSubConnectionFlowFactory::NewL(TAny* aConstructionParameters)
/**
* CTunDriverSubConnectionFlowFactory::NewL constructs a Default SubConnection Flow Factory
* @param aConstructionParameters construction data passed by ECOM
* @returns pointer to a constructed factory object.
*/
    {
    CTunDriverSubConnectionFlowFactory* ptr = new (ELeave) CTunDriverSubConnectionFlowFactory(TUid::Uid(KTunDriverFlowImplementationUid), *(reinterpret_cast<CSubConnectionFlowFactoryContainer*>(aConstructionParameters)));
    return ptr;
    }


CTunDriverSubConnectionFlowFactory::CTunDriverSubConnectionFlowFactory(TUid aFactoryId, CSubConnectionFlowFactoryContainer& aParentContainer)
:   CSubConnectionFlowFactoryBase(aFactoryId, aParentContainer)
/**
* CTunDriverSubConnectionFlowFactory::CTunDriverSubConnectionFlowFactory is a Default SubConnection Flow Factory
* @param aFactoryId ECOM Implementation Id
* @param aParentContainer Object Owner
*/
    {
    }

CSubConnectionFlowBase* CTunDriverSubConnectionFlowFactory::DoCreateFlowL(CProtocolIntfBase* aProtocolIntf, TFactoryQueryBase& aQuery)
/**
* CTunDriverSubConnectionFlowFactory::DoCreateFlowL will create SubConnection Flow.
* @param aFactoryId ECOM Implementation Id
* @param aParentContainer Object Owner
*/
    {
    const TDefaultFlowFactoryQuery& query = static_cast<const TDefaultFlowFactoryQuery&>(aQuery);
    return CTunDriverSubConnectionFlow::NewL(*this, query.iSCprId, aProtocolIntf);
    }

CTunDriverSubConnectionFlow::CTunDriverSubConnectionFlow(CSubConnectionFlowFactoryBase& aFactory, const TNodeId& aSubConnId, CProtocolIntfBase* aProtocolIntf)
:   CSubConnectionFlowBase(aFactory, aSubConnId, aProtocolIntf)
/**
* CTunDriverSubConnectionFlow::CTunDriverSubConnectionFlow is a Default Constructor
* @param aFactoryId ECOM Implementation Id
* @param aParentContainer Object Owner
*/
    {
    __FLOG_OPEN(KCFNodeTag, KNif);
    LOG_NODE_CREATE(KNif, CTunDriverSubConnectionFlow);
    }

CTunDriverSubConnectionFlow::~CTunDriverSubConnectionFlow()
/**
* CTunDriverSubConnectionFlowFactory::~CTunDriverSubConnectionFlow is a Default destructor
* @param aFactoryId ECOM Implementation Id
* @param aParentContainer Object Owner
*/
    {
    delete iBinder4;
    iBinder4 = NULL;
#ifdef IPV6SUPPORT
    delete iBinder6;
    iBinder6 = NULL;
#endif
    LOG_NODE_DESTROY(KNif, CTunDriverSubConnectionFlow);
    __FLOG_CLOSE;
    }

CTunDriverSubConnectionFlow* CTunDriverSubConnectionFlow::NewL(CSubConnectionFlowFactoryBase& aFactory, const TNodeId& aSubConnId, CProtocolIntfBase* aProtocolIntf)
/**
* CTunDriverSubConnectionFlowFactory::NewL is a first phase Constructor.
* @param aFactoryId ECOM Implementation Id
* @param aParentContainer Object Owner
*/
    {
    CTunDriverSubConnectionFlow* flow = new (ELeave) CTunDriverSubConnectionFlow(aFactory, aSubConnId, aProtocolIntf);
    return flow;
    }

void CTunDriverSubConnectionFlow::FlowDown(TInt aError, TInt aAction /*= MNifIfNotify::EDisconnect*/)
/**
* CTunDriverSubConnectionFlowFactory::FlowDown will post the message.
* @param aError obtained from the upper CF Layer.
* @param aAction and the action message for aError.
*/
    {
    PostFlowDownMessage(aError, aAction);
    }

void CTunDriverSubConnectionFlow::Progress(TInt aStage, TInt aError)
/**
* CTunDriverSubConnectionFlowFactory::Progress Binder requesting a Progress() message be sent to SCPR
* @param aStage and the action message for aError.
* @param aError obtained from the upper CF Layer.
*/
    {
    PostProgressMessage(aStage, aError);
    }

const TTunDriverIp4Provision* CTunDriverSubConnectionFlow::Ip4Provision() const
/**
* CTunDriverSubConnectionFlowFactory::Ip4Provision
* @param 
* @return iIp4Provision.
*/
    {
    ASSERT(iProvision);
    return &iProvision->iIp4Provision;
    }

#ifdef IPV6SUPPORT
const TTunDriverIp6Provision* CTunDriverSubConnectionFlow::Ip6Provision() const
/**
* CTunDriverSubConnectionFlowFactory::Ip6Provision
* @param 
* @return iIp6Provision.
*/
    {
    ASSERT(iProvision);
    return &iProvision->iIp6Provision;
    }
#endif

//-=========================================================
// Messages::ANode methods
//-=========================================================

#define __FRAMEWORK_PRODUCTION_ERRORHANDLING(c,p) (void)((c)||(p,0))
void CTunDriverSubConnectionFlow::ReceivedL(const TRuntimeCtxId& aSender, const TNodeId& aRecipient, TSignatureBase& aMessage)
/**
* CTunDriverSubConnectionFlowFactory::ReceivedL called on incoming SCPR Messages.
* CTunDriverSubConnectionFlow functions will be called Based on message type
* @param aCFMessage message base
*/
    {
    #ifdef __FLOG_ACTIVE
        TAny* senderAddr = NULL;
        const TNodeId* senderNodeId = address_cast<TNodeId>(&aSender);
        __ASSERT_DEBUG(senderNodeId!=NULL,User::LeaveIfError(KErrCorrupt));
        senderAddr = senderNodeId->Ptr();
        __FLOG_4(_L8("CTunDriverSubConnectionFlow(%x):\tReceivedL() Sender Id: %x, Msg Realm: %X, Msg ID: %d"), this, senderAddr, aMessage.MessageId().Realm(), aMessage.MessageId().MessageId());
    #endif

    CSubConnectionFlowBase::ReceivedL(aSender, aRecipient, aMessage);
    if (aMessage.IsMessage<TEBase::TError>())
        {
        SubConnectionError(static_cast<TEBase::TError&>(aMessage).iValue);
        }
    else if (TEChild::ERealmId == aMessage.MessageId().Realm())
        {
        switch (aMessage.MessageId().MessageId())
            {
        case TEChild::TCancel::EId:
            CancelFlow(KErrCancel);
        case TEChild::TDestroy::EId :
            Destroy();
            break;
        default:
            ASSERT(EFalse);
            }
        }
    else if (TCFDataClient::ERealmId == aMessage.MessageId().Realm())
        {
        switch (aMessage.MessageId().MessageId())
            {
        case TCFDataClient::TStart::EId :
            StartFlowL();
            break;
        case TCFDataClient::TStop::EId :
            StopFlow(static_cast<TCFDataClient::TStop&>(aMessage).iValue);
            break;
        case TCFDataClient::TProvisionConfig::EId:
            ProvisionConfig(static_cast<TCFDataClient::TProvisionConfig&>(aMessage).iConfig);
            break;
        case TCFDataClient::TBindTo::EId:
            {
            TCFDataClient::TBindTo& bindToReq = message_cast<TCFDataClient::TBindTo>(aMessage);
            __FRAMEWORK_PRODUCTION_ERRORHANDLING(bindToReq.iNodeId.IsNull(),User::LeaveIfError(KErrNotSupported));
            RClientInterface::OpenPostMessageClose(Id(), aSender, TCFDataClient::TBindToComplete().CRef());
            }
            break;
        default:
            ASSERT(EFalse);
            }
        }
    else
        {
        User::Leave(KErrNotSupported);
        }
    }

void CTunDriverSubConnectionFlow::StartFlowL()
/**
* CTunDriverSubConnectionFlowFactory::StartFlowL starts the flow on receiving the message TStart.
* This function is called from CTunDriverSubConnectionFlowFactory::ReceivedL 
*/
    {
    __FLOG(_L8("CTunDriverSubConnectionFlow:\tStartFlowL()"));
    
    if(iMMState == EStarted)
        {
        //Flow can be started multiple times.
        //For example a start may fail on an upper layer in which case the upper layer will not be able
        //to stop our layer and we need to accept start again.
        PostProgressMessage(KLinkLayerOpen, KErrNone);
        PostDataClientStartedMessage();
        return;
        }
    iMMState = EStarted;

    // If the processing of the ProvisionConfig message failed earlier, send the error response
    // here to the StartFlow message as there is no response to ProvisionConfig.
    User::LeaveIfError(iSavedError);

    PostProgressMessage(KLinkLayerOpen, KErrNone);
    PostDataClientStartedMessage();
    iBinder4->StartSending();
#ifdef IPV6SUPPORT
    if(iBinder6)
        {
        iBinder6->StartSending();
        }
#endif
    }

void CTunDriverSubConnectionFlow::CancelFlow(TInt aError)
/**
* CTunDriverSubConnectionFlowFactory::CancelFlow cancels the flow on receiving the message TCancel.
* It will post the message as KErrCancel.
* This function is called from CTunDriverSubConnectionFlowFactory::ReceivedL 
*/
    {
    __FLOG_1(_L8("CTunDriverSubConnectionFlow:\tCancelFlow(%d)"), aError);

    if(iMMState == EStarted)
        {
        PostFlowDownMessage(aError);
        }
    }

void CTunDriverSubConnectionFlow::StopFlow(TInt aError)
/**
* CTunDriverSubConnectionFlowFactory::StopFlow stops the flow on receiving the message TStop.
* It will post the message as KLinkLayerClosed and KErrCancel.
* This function is called from CTunDriverSubConnectionFlowFactory::ReceivedL 
*/
    {
    __FLOG_1(_L8("CTunDriverSubConnectionFlow:\tStopFlow(%d)"), aError);

    PostProgressMessage(KLinkLayerClosed, aError);
    iMMState = EStopped;
    PostFlowDownMessage(aError);
    }

void CTunDriverSubConnectionFlow::ProvisionConfig(const ESock::RMetaExtensionContainerC& aConfigData)
/**
* CTunDriverSubConnectionFlowFactory::Provisionconfig on receipt of the ProvisionConfig message, the pointer contained within it is stored
* in iAccessPointConfig and the information contained within the iAccessPointConfig  array is validated:
* CTunDriverProtoProvision must be present.  It is added by the TunDriverMCPr and populated from CommsDat.
* It is a 'C' class to take advantage of zero initialisation.
* Any errors are saved in iSavedError - there is no response to ProvisionConfig, 
* so an error response is sent later to StartFlow message.
*
* on receipt of TCFDataClient::TStart:
* iSavedError is checked and, if non-zero, an Error message is sent to the SCPr
* TunDriverAgentProvision must be present.  It is added by the TunDriverAgentHandler and populated via calls
* to the Agent.  It is a 'T' class because it requires no zero initialisation.  If missing,
* an Error message is signalled to the SCPr.
* This function is called from CTunDriverSubConnectionFlowFactory::ReceivedL
* @param aData pointer to provisioning structure 
*/
    {
    __FLOG_0(_L8("CTunDriverSubConnectionFlow:\tProvisionConfig message received"));
    iSavedError = KErrNone;
    iAccessPointConfig.Close();
    iAccessPointConfig.Open(aConfigData);

    const CTunDriverProtoProvision* provision = static_cast<const CTunDriverProtoProvision*>(AccessPointConfig().FindExtension(
            STypeId::CreateSTypeId(CTunDriverProtoProvision::EUid, CTunDriverProtoProvision::ETypeId)));
    __FRAMEWORK_PRODUCTION_ERRORHANDLING(provision!=NULL,iSavedError = KErrCorrupt);
    
    iProvision = provision;
    }

void CTunDriverSubConnectionFlow::Destroy()
/**
* CTunDriverSubConnectionFlowFactory::Destroy
* Request from SCPR to destroy
* This function is called from CTunDriverSubConnectionFlowFactory::ReceivedL 
*/
    {
    DeleteThisFlow();
    }

void CTunDriverSubConnectionFlow::SubConnectionGoingDown()
/**
* CTunDriverSubConnectionFlowFactory::SubConnectionGoingDown
* Request from Agemt SCPR
*/
    {
    __FLOG(_L8("CTunDriverSubConnectionFlow:\tSubConnectionGoingDown"));
    }

void CTunDriverSubConnectionFlow::SubConnectionError(TInt /*aError*/)
/**
* CTunDriverSubConnectionFlowFactory::SubConnectionError
* Request from Agemt SCPR
*/
    {
    __FLOG(_L8("CTunDriverSubConnectionFlow:\tSubConnectionError"));
    }

MFlowBinderControl* CTunDriverSubConnectionFlow::DoGetBinderControlL()
/**
* CTunDriverSubConnectionFlowFactory::DoGetBinderControlL Called by upper layer for binding
* Request from Agemt SCPR
* @return MFlowBinderControl instance
*/
    {
    __FLOG(_L8("CTunDriverSubConnectionFlow::DoGetBinderControlL"));
    return this;
    }

//-=========================================================
// MFlowBinderControl methods
//

MLowerControl* CTunDriverSubConnectionFlow::GetControlL(const TDesC8& aProtocol)
/**
* CTunDriverSubConnectionFlow::GetControlL
* Create and return an MLowerControl instance of the specified binder type.
* Called from upper layer during binding procedure.
* @param aProtocol Protocol type of the binder
* @return MLowerControl instance of the protocol type
*/
    {
    MLowerControl* lowerControl = NULL;
    __FLOG(_L8("CTunDriverSubConnectionFlow:\tGetLowerControlL(KProtocol4)"));
    if(aProtocol.Compare(KProtocol4()) == 0)
    		{
    		iBinder4 = CTunDriverBinder4::NewL(*this);
    		lowerControl = iBinder4;
    		}
#ifdef IPV6SUPPORT
    else
    if (aProtocol.CompareF(KProtocol6()) == 0)
        {
        __FLOG(_L8("CTunDriverSubConnectionFlow::GetLowerControlL(KProtocol6)- Should Return KErrNotSupported"));
        iBinder6 = CTunDriverBinder6::NewL(*this);
        lowerControl = iBinder6;        
        }
#endif
    return lowerControl;
    }

MLowerDataSender* CTunDriverSubConnectionFlow::BindL(const TDesC8& aProtocol, MUpperDataReceiver* aReceiver, MUpperControl* aControl)
/**
* CTunDriverSubConnectionFlow::BindL Create and return an MLowerDataSender instance of the specified protocol type.
* This is bound to the specified upper layer objects.
* Called from upper layer to bind to this layer.
* @param aProtocol Protocol type of the binder (same as in GetControlL())
* @param aReceiver upper layer's MUpperDataReceiver instance for this binder to associate with
* @param aControl upper layer's MUpperControl instance for this binder to associate with
* @return MLowerDataSender instance
*/
    {
    __FLOG(_L8("CTunDriverSubConnectionFlow:\tBindL()"));

    MLowerDataSender* lowerDataSender = NULL;

    if(aProtocol.CompareF(KProtocol4()) == 0)
    		{
    		lowerDataSender = iBinder4->Bind(*aReceiver, *aControl);
    		}
#ifdef IPV6SUPPORT
    else
    if (aProtocol.CompareF(KProtocol6()) == 0)
        {
        lowerDataSender = iBinder6->Bind(*aReceiver, *aControl);
        }
#endif
    if(lowerDataSender != NULL)
        {
        iSubConnectionProvider.PostMessage(Id(), TCFControlProvider::TActive().CRef());
        }
    return lowerDataSender;
    }

void CTunDriverSubConnectionFlow::Unbind(MUpperDataReceiver* aReceiver, MUpperControl* aControl)
/**
* CTunDriverSubConnectionFlow::Unbind will Unbind from the upper layer.
* Called from the upper layer during unbinding.
* @param aReceiver
* @param aControl
*/
    {
    __FLOG(_L8("CTunDriverSubConnectionFlow:\tUnbind()"));
    if (iBinder4 && iBinder4->MatchesUpperControl(aControl))
            {
            iBinder4->Unbind(*aReceiver, *aControl);
            delete iBinder4;
            iBinder4 = NULL;
            }
#ifdef IPV6SUPPORT
    if (iBinder6 && iBinder6->MatchesUpperControl(aControl))
            {
            iBinder6->Unbind(*aReceiver, *aControl);
            delete iBinder6;
            iBinder6 = NULL;
            }
#endif
    iSubConnectionProvider.PostMessage(Id(), TCFControlProvider::TIdle().CRef());
    }

ESock::CSubConnectionFlowBase* CTunDriverSubConnectionFlow::Flow()
/**
* CTunDriverSubConnectionFlow::Flow will Return the flow object corresponding to the MFlowBinderControl
* Called from the UpperLayer get the instance of the flow.
*/
    {
    return this;
    }

void CTunDriverSubConnectionFlow::PostProgressMessage(TInt aStage, TInt aError)
/*
* CTunDriverSubConnectionFlow::PostProgressMessage will send the state change message with the param values.
* 
*/
    {
    iSubConnectionProvider.PostMessage(Id(), TCFMessage::TStateChange(Elements::TStateChange(aStage, aError)).CRef());
    }

void CTunDriverSubConnectionFlow::PostDataClientStartedMessage()
/*
* CTunDriverSubConnectionFlow::PostDataClientStartedMessage will send the started message with the param values.
*/
    {
    iLastRequestOriginator.ReplyTo(Id(), TCFDataClient::TStarted().CRef());
    }

void CTunDriverSubConnectionFlow::PostFlowDownMessage(TInt aError, TInt aAction /*= MNifIfNotify::EDisconnect*/)
/*
* CTunDriverSubConnectionFlow::PostFlowDownMessage will send the DataClient Down message with the param values.
*/
    {
    if (iMMState == EStarted)
        {
        iMMState = EStopped;
        iSubConnectionProvider.PostMessage(Id(), TCFControlProvider::TDataClientGoneDown(aError, aAction).CRef());
        }
    else
        {
        iLastRequestOriginator.ReplyTo(Id(), TCFDataClient::TStopped(aError).CRef());
        }
    }

void CTunDriverSubConnectionFlow::MaybePostDataClientIdle()
/*
* CTunDriverSubConnectionFlow::MaybePostDataClientIdle will send the Idle message with the param values.
*/
    {
    // Can only send DataClientIdle when the upper layer has unbound and the flow is stopped
    if( iBinder4 == NULL
#ifdef IPV6SUPPORT
        || iBinder6 == NULL
#endif
      )
        {
        iSubConnectionProvider.PostMessage(Id(), TCFControlProvider::TIdle().CRef());
        }
    }