// Copyright (c) 2005-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:

//

#include <e32hal.h>

#include <e32math.h>

#include <f32file.h>

#include <random.h>

#include "PPPLOG.H"								// must appear before ss_log.h

#include <comms-infras/ss_metaconnprov.h>

#include <comms-infras/ss_log.h>				// for LOG_NODE_CREATE etc.

#include "PPPLCP.H"

#include "PPPAUTH.H"

#include "PPPCCP.H"

#include "PPPLRD.H"

#include "MSCBCPC.H"

#include "PPP_VER.H"

#include "PppProg.h"

#include <commsdattypeinfov1_1.h>

#include <networking/ppplcp.h>

#include "ncpip.h"

#include "ncpip6.h"

#include "PPPConfig.h"

#include "pppmessages.h"

#include <elements/nm_messages_base.h>

#include <elements/nm_messages_child.h>

#include <comms-infras/ss_nodemessages_dataclient.h>

#include <comms-infras/ss_nodemessages_flow.h>

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <nifvar_internal.h>

#endif

using namespace Elements;

using namespace Messages;

using namespace MeshMachine;

using namespace ESock;

static const TInt KMinValueForMSCallBackCode=1000;

//

// PPP LCP

//

#ifdef __VC32__

// warning C4355: 'this' : used in base member initializer list

#pragma warning (disable:4355)

#endif

#if defined ESOCK_LOGGING_ACTIVE || defined SYMBIAN_TRACE_ENABLE

_LIT8(KNif,"Ppp");

#endif

EXPORT_C CPppLcp* CPppLcp::NewL(ESock::CSubConnectionFlowFactoryBase& aFactory, const Messages::TNodeId& aSubConnId, ESock::CProtocolIntfBase* aProtocolIntf)

	{

	CPppLcp* flow = new (ELeave) CPppLcp(aFactory, aSubConnId, aProtocolIntf);

	return flow;

	}

// Registers as unknown initially as lists won't be initialised

EXPORT_C CPppLcp::CPppLcp(ESock::CSubConnectionFlowFactoryBase& aFactory, const Messages::TNodeId& aSubConnId, ESock::CProtocolIntfBase* aProtocolIntf)

  : CSubConnectionFlowBase(aFactory, aSubConnId, aProtocolIntf), MPppFsm(this, EPppPhaseAll, KPppIdLcp), MPppOptionsExtender(),

    iInitialised(EFalse),

    iSavedError(KErrNone),

    iTerminateAction(MNifIfNotify::EDisconnect),

    iLastRequest(Messages::TNodeSignal::TMessageId()),

    iLastRequestErrored(EFalse)

	{

    __FLOG_OPEN(KCFNodeTag, KNif);

	LOG_NODE_CREATE1(KNif, CPppLcp, " [factory=%08x]", &aFactory);

    __DECLARE_FSM_NAME(_S("LCP"));

	iRecvrList.SetOffset(_FOFF(MPppRecvr, iPppRecvrListLink));

    }

#ifdef __VC32__

#pragma warning (default:4355)

#endif

EXPORT_C CPppLcp::~CPppLcp()

	{

	PppNcpMsCbcpFactory::Delete( iPppMsCbcp );

	iPppMsCbcp=NULL;

	delete iRecvTimeRemMessage;

	iRecvTimeRemMessage = NULL;

	delete iRecvIdentification;

	iRecvIdentification = NULL;

	delete iPppLink;

	iPppLink = NULL;

// N.B.: HDLC link relies on iLogger

#if defined (_DEBUG)

	delete iLogger;

#endif

	delete iPppAcp;

	iPppAcp = NULL;

    delete iCallbackInfo;

	iCallbackInfo = NULL;

	delete iCallbackIETFRequestPacket;

	iCallbackIETFRequestPacket = NULL;

	delete iPppCcp;

	iPppCcp = NULL;

	delete iPppLrd;

	iPppLrd = NULL;

	delete iContainerForDlls;

	iContainerForDlls = NULL;

	ASSERT(iBinder4 == NULL);

	ASSERT(iBinder6 == NULL);

	LOG_NODE_DESTROY(KNif, CPppLcp);

    __FLOG_CLOSE;

	}

//-=========================================================

// Messages::ANode methods

//-=========================================================

EXPORT_C void CPppLcp::ReceivedL(const TRuntimeCtxId& aSender, const TNodeId& aRecipient, TSignatureBase& aMessage)

    {

	/**

	   These messages may be received in the middle of another request, such as start.

	   Therefore they must be handled before the CSubConnectionFlowBase::ReceivedL so

	   that they do not override the last request originator for that

	*/	

   	if (TLinkMessage::ERealmId == aMessage.MessageId().Realm())

       	{

       	switch ((iLastRequest = aMessage.MessageId()).MessageId())

           	{

        case TLinkMessage::TAuthenticateResponse::EId:

			{

        	AuthenticateResponseMessage();

        	break;

			}

        case TLinkMessage::TAgentToFlowNotification::EId:

			{

			TLinkMessage::TAgentToFlowNotification& msg = static_cast<TLinkMessage::TAgentToFlowNotification&>(aMessage);

        	AgentToFlowNotification(msg.iValue);

        	break;

			}

        default:

	    	__FLOG_2(_L8("CPppLcp\tReceivedL() unexpected message received [%08x,%d]"), aMessage.MessageId().Realm(), aMessage.MessageId().MessageId());

			PppPanic(EPppPanic_UnexpectedSCPRMessage);

        	}

        return;

        }

	CSubConnectionFlowBase::ReceivedL(aSender, aRecipient, aMessage);

	if (TEBase::ERealmId == aMessage.MessageId().Realm())

    	{

    	switch ((iLastRequest = aMessage.MessageId()).MessageId())

        	{

        case TEBase::TError::EId :

            SubConnectionError(static_cast<TEBase::TError&>(aMessage).iValue);

            break;

        case TEBase::TCancel::EId :

        	if (iMMState != EStarting)

	        	{

	        	User::Leave(KErrNotReady);

	        	}

			DoStopFlow(KErrCancel, MNifIfNotify::EDisconnect);

			break;

        default:

		    __FLOG_2(_L8("CPppLcp\tReceivedL() unexpected message received [%08x,%d]"), aMessage.MessageId().Realm(), aMessage.MessageId().MessageId());

			PppPanic(EPppPanic_UnexpectedSCPRMessage);

			}

		return;

		}

    else if (TEChild::ERealmId == aMessage.MessageId().Realm())

    	{

    	switch ((iLastRequest = aMessage.MessageId()).MessageId())

        	{

        case TEChild::TDestroy::EId :

            Destroy();

            break;

        default:

		    __FLOG_2(_L8("CPppLcp\tReceivedL() unexpected message received [%08x,%d]"), aMessage.MessageId().Realm(), aMessage.MessageId().MessageId());

			PppPanic(EPppPanic_UnexpectedSCPRMessage);

			}

		return;

		}

    else if (TCFDataClient::ERealmId == aMessage.MessageId().Realm())

    	{

    	switch ((iLastRequest = 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);

            if (!bindToReq.iNodeId.IsNull())

             	{

             	User::Leave(KErrNotSupported);

             	}

            RClientInterface::OpenPostMessageClose(Id(), aSender, TCFDataClient::TBindToComplete().CRef());

			}

            break;

        default:

		    __FLOG_2(_L8("CPppLcp\tReceivedL() unexpected message received [%08x,%d]"), aMessage.MessageId().Realm(), aMessage.MessageId().MessageId());

			PppPanic(EPppPanic_UnexpectedSCPRMessage);

			}

		return;

		}

    else if (TCFFlow::ERealmId == aMessage.MessageId().Realm())

    	{

    	switch ((iLastRequest = aMessage.MessageId()).MessageId())

        	{

        case TCFFlow::TBlock::EId :

            if (iBinder4)

            	{

            	iBinder4->BlockFlow(MLowerControl::EDisableAllOtherBindersOnFlow);

            	}

            if (iBinder6)

            	{

            	iBinder6->BlockFlow(MLowerControl::EDisableAllOtherBindersOnFlow);

            	}

            break;

        case TCFFlow::TUnBlock::EId :

            if (iBinder4)

            	{

            	iBinder4->SendFlowOn();

            	}

            if (iBinder6)

            	{

            	iBinder6->SendFlowOn();

            	}

            break;

        default:

		    __FLOG_2(_L8("CPppLcp\tReceivedL() unexpected message received [%08x,%d]"), aMessage.MessageId().Realm(), aMessage.MessageId().MessageId());

			PppPanic(EPppPanic_UnexpectedSCPRMessage);

			}

		return;

		}

    else if (TCFMessage::ERealmId == aMessage.MessageId().Realm())

    	{

		__FLOG_2(_L8("CPppLcp\tReceivedL() unexpected message received [%08x,%d]"), aMessage.MessageId().Realm(), aMessage.MessageId().MessageId());

		PppPanic(EPppPanic_UnexpectedSCPRMessage);

		return;

		}

    else if (TCFMessage::ERealmId == aMessage.MessageId().Realm())

    	{

    	switch ((iLastRequest = aMessage.MessageId()).MessageId())

        	{

        case TCFMessage::TStateChange::EId :

            __FLOG(_L8("WARNING: CPppLcp::\tReceivedL() - I have received a TStateChange and I have ignored it"));

            break;

        default:

		    __FLOG_2(_L8("CPppLcp\tReceivedL() unexpected message received [%08x,%d]"), aMessage.MessageId().Realm(), aMessage.MessageId().MessageId());

			PppPanic(EPppPanic_UnexpectedSCPRMessage);

			}

		return;

		}

    }

//-=========================================================

// Methods for handling SCPR messages

//-=========================================================

EXPORT_C void CPppLcp::SubConnectionGoingDown()

    {

    }

EXPORT_C void CPppLcp::SubConnectionError(TInt /*aError*/)

    {

    }

EXPORT_C void CPppLcp::StartFlowL()

    {

    ASSERT(iMMState == 0);

	if (iSavedError)

		{

		// Provisioning error has already occurred

	    __FLOG_1(_L8("CPppLcp:\tStartFlowL() error %d"), iSavedError);

		User::Leave(iSavedError);

		}

    __FLOG(_L8("CPppLcp::\tStartFlowL()"));

	User::LeaveIfError(DoStartFlow());

    iMMState = EStarting;

    }

EXPORT_C void CPppLcp::StopFlow(TInt aError)

    {

    __FLOG_1(_L8("CPppLcp::\tStopFlow(%d)"), aError);

    iMMState = EStopping;

    DoStopFlow(aError, MNifIfNotify::EDisconnect);

    }

EXPORT_C void CPppLcp::ProvisionConfig(const ESock::RMetaExtensionContainerC& aConfigData)

    {

    iSavedError = KErrNone;

    TRAPD(err, ProvisionConfigL(aConfigData));

    if (err)

        {

        __FLOG_1(_L8("CPppLcp::\tProvisionConfig(): error %d"), err);

        iSavedError = err;		// report error later on TCFDataClient::TStart message - there no response to TProvisionConfig message

        }

    }

EXPORT_C void CPppLcp::Destroy()

    {

    // No-one should be bound to us from above if we are about to disappear.

    ASSERT(iBinder4 == NULL && iBinder6 == NULL);

	DeleteThisFlow();

    }

EXPORT_C void CPppLcp::AuthenticateResponseMessage()

/**

Process link specific messages.

*/

	{

	// Retrieve credentials from control side memory

	ASSERT(iAgentProvision); //should have been cheked before attempting

	                         //authentication.

	iCredentials = iAgentProvision->Credentials();

	ASSERT(iCredentials);

	TInt authErr = KErrNone;

	CPppAuthentication* p = iAuthenticate;

	iAuthenticate = NULL;

	if((authErr = iCredentials->GetResult())==KErrNone)

		{

		iAuthenticateDone = ETrue;

		}

	if (p)

    	{

    	//may have bailed out due to tear down in progress.

    	p->CallAuthenticateComplete(authErr);

    	}

	if (authErr != KErrNone)

    	{

    	PostErrorMessage(authErr);

    	}

	}

EXPORT_C void CPppLcp::AgentToFlowNotification(TInt aNotificationId)

    {

    TInt err;

    if ((err = NotificationMessage(TAgentToNifEventType(aNotificationId))) != KErrNone)

        {

		if (iMMState == EStarted)

			{

			PostFlowDownMessage(err);

			}

		else

			{

			PostErrorMessage(err);

			}

        }

    }

TInt CPppLcp::NotificationMessage(TAgentToNifEventType aNotificationId)

	{

	switch(aNotificationId)

		{

	case EAgentToNifEventTypeModifyInitialTimer:

		// Notification destined for binders

		if (iBinder4)

			{

			return iBinder4->Notification(aNotificationId);

			}

		if (iBinder6)

			{

			return iBinder6->Notification(aNotificationId);

			}

		break;

	case EAgentToNifEventTypeDisableTimers:

	case EAgentToNifEventTypeEnableTimers:

		return Notification(aNotificationId, NULL);

	case EAgentToNifEventTypeGetDataTransfer:

		break;

	default:

		PppPanic(EPppPanic_UnexpectedSCPRMessage);

		}

	return KErrNotSupported;		// keep compiler happy

	}

//

// Utility functions for sending messages to SCPR

//

void CPppLcp::PostProgressMessage(TInt aStage, TInt aError)

	{

	if (iLastStateChange.iStage != aStage || iLastStateChange.iError != aError)

		{

		//unsolicited send of TStateChange message

		iSubConnectionProvider.PostMessage(Id(), TCFMessage::TStateChange(TStateChange(aStage, aError)).CRef());

		iLastStateChange.iStage = aStage;

		iLastStateChange.iError = aError;

		}

	}

void CPppLcp::PostDataClientStartedMessage()

	{

    #ifdef __FLOG_ACTIVE

		TPtrC8 ptr = GetMMStateName();

	   	__FLOG_1(_L8("CPppLcp:\tPostDataClientStartedMessage() - State: %S."), &ptr);

 	#endif

	if (iMMState == EStarting)

    	{

    	iMMState = EStarted;

    	//respond to earlier start request

    	iLastRequestOriginator.ReplyTo(Id(), TCFDataClient::TStarted().CRef());

    	}

    #ifdef __FLOG_ACTIVE

    	if(iMMState != EStarted)

    		{

	 	   	__FLOG(_L8("ERROR: CPppLcp:\tPostDataClientStartedMessage() - LCP was unable to start"));

    		}

 	#endif

    __ASSERT_DEBUG(iMMState == EStarted, PppPanic(EPppPanic_LCPFailedToStart));

	}

void CPppLcp::PostFlowDownMessage(TInt aError)

	{

    #ifdef __FLOG_ACTIVE

		TPtrC8 ptr = GetMMStateName();

	   	__FLOG_2(_L8("CPppLcp:\tPostFlowDownMessage() - Error: %d, State: %S."), aError, &ptr);

 	#endif

	ASSERT(aError != KErrNone);

	if (iMMState == EStopping)

	    {

	    if (!iLastRequestErrored)

	    	{

			// Unexpected termination so send TError message

			// Flow has gone down for an expected reason

			iLastRequestOriginator.ReplyTo(Id(), TCFDataClient::TStopped(aError).CRef());

			// The SCPR activity will terminate so wait for the next request

			iLastRequestErrored = EFalse;

	    	}

	    else

	    	{

			// TError message has already been sent so ignore

	    	iLastRequestErrored = EFalse;

			}

	    }

    else if (iMMState == EStarted )

        {

        // Something has occured in the bearer causing the link to go down unexpectedly

        // We use the RNodeInterface version of PostMessage because

        // TDataClientGoneDown is always sent as an unsolicited message. We don't want the

        // activity Id to be overidden.

    	iSubConnectionProvider.PostMessage(Id(), TCFControlProvider::TDataClientGoneDown(aError, iTerminateAction).CRef());

	    }

	else if (iMMState == EStarting)

		{

	    if (!iLastRequestErrored)

	    	{

			// Unexpected termination so send TError message

			iLastRequestOriginator.ReplyTo(Id(), TEBase::TError(TCFDataClient::TStart::Id(), aError).CRef());

			// The SCPR activity will terminate so wait for the next request

			iLastRequestErrored = EFalse;

	    	}

	    else

	    	{

	    	// TError message has already been sent so ignore

	    	iLastRequestErrored = EFalse;

	    	}

		}

    iMMState = EStopped;

	}

void CPppLcp::PostErrorMessage(TInt aError)

	{

	ASSERT(aError != KErrNone);

	// Error is always a response to an earlier received request

	if (iLastRequestOriginator.IsOpen()) // Errors only relevant if responding to something

		{

		iLastRequestOriginator.ReplyTo(Id(), TEBase::TError(iLastRequest, aError).CRef());

		}

	}

void CPppLcp::MaybePostDataClientIdle()

    {

    // Can only send DataClientIdle when the upper layer has unbound and the flow is stopped

	if (iBinder4 == NULL && iBinder6 == NULL && !iSentIdle)

		{

		// TDataClientIdle is sent unsolicited to the control side

   		iSubConnectionProvider.PostMessage(Id(), TCFControlProvider::TIdle().CRef());

		iSentIdle = ETrue;

		}

    }

//-=========================================================

// MFlowBinderControl methods

//-=========================================================

EXPORT_C MLowerControl* CPppLcp::GetControlL(const TDesC8& aProtocol)

    {

    User::LeaveIfError(iSavedError);

    MLowerControl* lowerControl = NULL;

	if (aProtocol.CompareF(KProtocol4()) == 0  ||

		aProtocol.CompareF(KDescIcmp) == 0)

		{

        __FLOG(_L8("CPppLcp:\tGetLowerControlL(KProtocol4)"));

		iBinder4 = CPppBinderIp4::NewL(this);

        lowerControl = iBinder4;

		}