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

//

/**

 @file

 @internalComponent

*/

#include <cdbcols.h>

#include "CAgentAdapter.h"

#include "agentscpr.h"

#include "IF_DEF.H"

#include <comms-infras/ss_platsec_apiext.h>

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <comms-infras/nifprvar_internal.h>

#include <comms-infras/nifagt_internal.h>

#endif

#ifdef _DEBUG

// Panic category for "absolutely impossible!" vanilla ASSERT()-type panics from this module

// (if it could happen through user error then you should give it an explicit, documented, category + code)

_LIT(KSpecAssert_NifManAgtPrCCAgn, "NifManAgtPrCCAgn");

#endif

typedef CNifFactory* (*TAgentFactoryNewL)();

#ifdef __CFLOG_ACTIVE

#define KAgentSCprTag KESockSubConnectionTag

_LIT8(KAgentSCprSubTag, "agentscpr");

#endif

/**

Create a CAgentAdapter and Agent (loading the .agt library if necessary)

@param aAgentScpr The CAgentSubConnectionProvider that is to be called upon when

notifications are received from the agent

@param aAgentName The name of the agent to load/create for this CAgentAdaptor

*/

CAgentAdapter* CAgentAdapter::NewL(CAgentSubConnectionProvider& aAgentScpr, const TDesC& aAgentName)

    {

    CAgentAdapter* self = new(ELeave) CAgentAdapter (aAgentScpr);

    CleanupStack::PushL(self);

    self->CreateAgentL(aAgentName);

    CleanupStack::Pop();

    return self;

    }

/**

CAgentAdapter C'tor

@param aAgentScpr The CAgentSubConnectionProvider that is to be called upon when

notifications are received from the agent

*/

CAgentAdapter::CAgentAdapter(CAgentSubConnectionProvider& aAgentScpr)

    : iAgentScpr(aAgentScpr),

    iAgentState(EDisconnected),

    iAgentConnectType(EAgentNone),

    iLastProgress(KFinishedSelection,KErrNone)

    {

    }

/**

CAgentAdapter D'tor

*/

CAgentAdapter::~CAgentAdapter()

    {

    if ( iAgent )

    	{

    	// Delete the Agent

    	delete iAgent;

    	// Clean the Queue of AgentAdapterSessionNotifier still pending.

    	// At this stage the Agent has only removed them from the queue

    	// of pending service change notification.

    	// We need to explicitly call "CancelServiceChangeNotification" due

    	// the completelly different architecture post-399.

    	const TInt count = iAgentAdapterSessionNotifiers.Count();

    	for (TInt i = 0; i < count; ++i)

	    	{

	    	CAgentAdapterSessionNotifier* currentSessNotifier =	iAgentAdapterSessionNotifiers[0];

	    	iAgentAdapterSessionNotifiers.Remove(0);

	    	// The Destruction of an AgentAdapterSessionNotifier force it to

	    	// authomatically notify with KErrCancel node waiting for

	    	// Service Change Notification

	    	delete currentSessNotifier;

	    	}

	    iAgentAdapterSessionNotifiers.Reset();

    	}

    if (iFactory)

        {

        iFactory->Close();		// do this after deleting iAgent

        }

    }

void CAgentAdapter::PromptForReconnect()

    {

    iAgentState = EReconnecting;

    iAgent->Reconnect();

    }

/**

Begins connection of the Agent (called after SCPr receives BindTo and has

Joined the CAgentAdapter)

*/

void CAgentAdapter::ConnectAgent(TAgentConnectType aConnectType)

    {

    if (aConnectType == EAgentReconnect)

        {

        iAgentConnectType = aConnectType;

        iAgentState = EReconnecting;

        iAgent->Connect(aConnectType);

        }

    else

        {

        if (iAgentState != EConnecting || (

            aConnectType == EAgentStartCallBack && iAgentConnectType != EAgentStartCallBack))

            {

            iAgentConnectType = aConnectType;

            iAgentState = EConnecting;

            iAgent->Connect(aConnectType);

            }

        }

    }

/**

Begins the disconnection of the Agent

*/

void CAgentAdapter::DisconnectAgent(TInt aReason)

    {

    if (iAgentState == EConnecting)

        {

        iAgent->CancelConnect();

        }

    else if (iAgentState == EReconnecting)

        {

        iAgent->CancelReconnect();

        }

    iAgentState = EDisconnecting;

    iAgent->Disconnect(aReason);

    }

/**

Starts the process of obtaining authentication information via the Agent

(called after the SCPr receives an Authentication request from the SCF)

*/

void CAgentAdapter::Authenticate(TDes& aUsername, TDes& aPassword)

    {

    iAgent->Authenticate(aUsername, aPassword);

    }

/**

Stops the process of obtaining authentication information via the Agent

*/

void CAgentAdapter::CancelAuthenticate()

    {

    iAgent->CancelAuthenticate();

    }

// ---------------- Minimal database access methods ----------------

/**

Get the port name for NIFs such as the PPP NIF.

@param aPortName - After a successful call contains the port name from the agent

*/

TInt CAgentAdapter::ReadPortName (TDes8& aPortName)

    {

    _LIT(KModemPortName, "ModemBearer\\PortName");

    return iAgent->ReadDes(KModemPortName, aPortName);

    }

/**

Get the port name for NIFs such as the PPP NIF.

@param aPortName - After a successful call contains the port name from the agent

*/

TInt CAgentAdapter::ReadPortName (TDes16& aPortName)

    {

    _LIT(KModemPortName, "ModemBearer\\PortName");

    return iAgent->ReadDes(KModemPortName, aPortName);

    }

/**

Gets excess data for NIFs such as the PPP NIF.

@param aBuffer - After a successful call contains excess data from the agent

*/

TInt CAgentAdapter::ReadExcessData(TDes8& aBuffer)

    {

    return iAgent->GetExcessData(aBuffer);

    }

/**

Gets the Interface Parameters for NIFs.

@param aIfParams - After a successful call contains interface parameters from the agent

*/

TInt CAgentAdapter::ReadIfParams(TDes8& aIfParams)

    {

    return iAgent->ReadDes(TPtrC(SERVICE_IF_PARAMS), aIfParams);

    }

/**

Gets the Interface Parameters for NIFs.

@param aIfParams - After a successful call contains interface parameters from the agent

*/

TInt CAgentAdapter::ReadIfParams(TDes16& aIfParams)

    {

    return iAgent->ReadDes(TPtrC(SERVICE_IF_PARAMS), aIfParams);

    }

/**

Gets the Interface Networks for NIFs.

@param aNetworks - After a successful call contains the network layer protocols

*/

TInt CAgentAdapter::ReadIfNetworks(TDes8& aIfNetworks)

    {

    return iAgent->ReadDes(TPtrC(SERVICE_IF_NETWORKS), aIfNetworks);

    }

/**

Gets the Interface Networks for NIFs.

@param aNetworks - After a successful call contains the network layer protocols

*/

TInt CAgentAdapter::ReadIfNetworks(TDes16& aIfNetworks)

    {

    return iAgent->ReadDes(TPtrC(SERVICE_IF_NETWORKS), aIfNetworks);

    }

/**

Gets the name of the NIF (Flow)

@param aNifName - After a successful call contains the NIF (Flow) Name

*/

TInt CAgentAdapter::ReadNifName(TDes8& aNifName)

    {

    return iAgent->ReadDes(TPtrC(IF_NAME), aNifName);

    }

/**

Gets the name of the NIF (Flow)

@param aNifName - After a successful call contains the NIF (Flow) Name

*/

TInt CAgentAdapter::ReadNifName(TDes16& aNifName)

    {

    return iAgent->ReadDes(TPtrC(IF_NAME), aNifName);

    }

TInt CAgentAdapter::NotificationToAgent(TFlowToAgentEventType aEvent, TAny* aInfo)

    {

    return iAgent->Notification(static_cast<TNifToAgentEventType>(aEvent), aInfo);

    }

// ---------------- MNifAgentNotify Methods ----------------

/**

Agent has started - The SCPR should send BindTo information to the SCF

*/

void CAgentAdapter::ConnectComplete(TInt aStatus)

    {

    if (iAgentState == EConnecting)

        {

        if (aStatus == KErrNone)

            {

            iAgentState = EConnected;

#ifdef __CFLOG_ACTIVE

            TRAPD(err, iAgentScpr.ConnectionUpL());

            if (err != KErrNone)

                {

                __CFLOG_VAR((KAgentSCprTag, KAgentSCprSubTag, _L8("CAgentAdapter::ConnectComplete() - Trapped [err=%d]"), err));

                __ASSERT_DEBUG(EFalse, User::Panic(KSpecAssert_NifManAgtPrCCAgn, 1));

                }

#else

			TRAP_IGNORE(iAgentScpr.ConnectionUpL());

#endif

            }

        else

            {

            iLastProgress.iError = aStatus;

            iAgent->Disconnect(aStatus);

            }

        }

   }

/**

Authentication completed by Agent

*/

void CAgentAdapter::AuthenticateComplete(TInt aStatus)

    {

#ifdef __CFLOG_ACTIVE

	TRAPD(err, iAgentScpr.AuthenticateCompleteL(aStatus));

    if (err != KErrNone)

        {

        __CFLOG_VAR((KAgentSCprTag, KAgentSCprSubTag, _L8("CAgentAdapter::AuthenticateComplete() - Trapped [err=%d]"), err));

        __ASSERT_DEBUG(EFalse, User::Panic(KSpecAssert_NifManAgtPrCCAgn, 2));

        }

#else

	TRAP_IGNORE(iAgentScpr.AuthenticateCompleteL(aStatus));

#endif

    }

/**

Agent has stopped

*/

void CAgentAdapter::DisconnectComplete()

    {

    if (iAgentState == EConnecting)

        {

        if (iLastProgress.iError != KErrNone)

	        {

	        iAgentScpr.Error(iLastProgress);

	        }

        iAgentState = EDisconnected;

        }

    else

        {

#ifdef __CFLOG_ACTIVE

    	TRAPD(err,

    		iAgentScpr.ProgressL(KConnectionUninitialised);

    		iAgentState = EDisconnected;

    		iAgentScpr.ConnectionDownL();

    		);

            if (err != KErrNone)

                {

                __CFLOG_VAR((KAgentSCprTag, KAgentSCprSubTag, _L8("CAgentAdapter::DisconnectComplete() - Trapped [err=%d]"), err));

                __ASSERT_DEBUG(EFalse, User::Panic(KSpecAssert_NifManAgtPrCCAgn, 3));

                }

#else

    	TRAP_IGNORE(

            iAgentScpr.ProgressL(KConnectionUninitialised);

    		iAgentState = EDisconnected;

    		iAgentScpr.ConnectionDownL();

    		);

#endif

        }

   }

/**

Progress notifications from the Agent Connect()

*/

void CAgentAdapter::AgentProgress(TInt aStage, TInt aError)

    {

    iLastProgress.iStage = aStage;

    iLastProgress.iError = aError;

    if (aError == KErrNone)

        {

#ifdef __CFLOG_ACTIVE

		TRAPD(err, iAgentScpr.ProgressL(aStage));

        if (err != KErrNone)

            {

            __CFLOG_VAR((KAgentSCprTag, KAgentSCprSubTag, _L8("CAgentAdapter:\tAgentProgress() - Trapped [err=%d]"), err));

            __ASSERT_DEBUG(EFalse, User::Panic(KSpecAssert_NifManAgtPrCCAgn, 4));

            }

#else

		TRAP_IGNORE(iAgentScpr.ProgressL(aStage));

#endif

        }

    else

        {

        iAgentScpr.Error(iLastProgress);

        }

    }

/**

Notification from the Agent to the Nif (Flow)

*/

TInt CAgentAdapter::Notification(TAgentToNifEventType aEvent, TAny* aInfo /*=NULL*/)

   {

   // Let the SCPR decide what to do with the notification

   return iAgentScpr.NotificationFromAgent(static_cast<TAgentToFlowEventType>(aEvent), aInfo);

   }

/**

Event notification from the Agent

(Only known use of this is in bluetooth panagt.cpp)

*/

void CAgentAdapter::AgentEvent(TNetworkAdaptorEventType aEventType, TUint aEvent, const TDesC8& aEventData, TAny* aSource /*=NULL*/)

   {

   // Let the SCPR decide what to do with the event

   iAgentScpr.NetworkAdaptorEvent(aEventType, aEvent, aEventData, aSource);

   }

/**

Traditionally reconnection would be initiated from the CNifAgentRef and handled

by NetCon. NetCon would call this method via the ReconnectComplete() in the

CAgentBase. This represents the completion of the prompting of the user for a

decision to be made on whether or not to reconnect, not the actual reconnection

*/

void CAgentAdapter::ReconnectComplete(TInt aStatus)

    {

    iAgentScpr.PromptForReconnectComplete(aStatus);

    }

/**

Agent service started (message from agent)

Traditionally the CNifAgentRef implementation would load the NIF here.

*/

void CAgentAdapter::ServiceStarted()

   {

   iAgentScpr.ServiceStarted();

   }

// ---------------- Empty methods to satisfy interfaces ----------------

/**

Traditionally called by the CNifAgentRef as a result of a DisconnectComplete,

deletion of the the object, or failure to bind. The method would have deleted

the NIF. We do nothing here.

*/

void CAgentAdapter::ServiceClosed()

   {

   // Should never be called

   __CFLOG_VAR((KAgentSCprTag, KAgentSCprSubTag, _L8("CAgentAdapter:\tServiceClosed(): Nothing to do here. Should never be called.")));

   }

/**

The functionality provided by this method has never been used.

*/

void CAgentAdapter::AgentProgress(TSubConnectionUniqueId /*aSubConnectionUniqueId*/, TInt /*aStage*/, TInt /*aError*/)

   {

   // Should never be called

   __ASSERT_DEBUG(0, User::Panic(KSpecAssert_NifManAgtPrCCAgn, 5));

   }

/**

Incoming connections not supported?

*/

TInt CAgentAdapter::IncomingConnectionReceived()

   {

   // Should never be called

   __ASSERT_DEBUG(0, User::Panic(KSpecAssert_NifManAgtPrCCAgn, 6));

   return KErrNotSupported;

   }

// ---------------- Agent Creation / Lookup Methods ----------------

/**

Load a factory and check the Uid etc

function always opens factory CObject if successful

*/

CNifFactory* CAgentAdapter::FindOrCreateAgentFactoryL(const TDesC& aFilename)

	{

    #ifdef _UNICODE

    TUid agentUid(TUid::Uid(KUidUnicodeNifmanAgent));

    #else

    TUid agentUid(TUid::Uid(KUidNifmanAgent));

    #endif

    // Make sure NifMan is installed

    Nif::CheckInstalledL();

    CObjectCon& factoryContainer = *(CNifMan::Global()->iAgentFactories);

	TParse parse;

	User::LeaveIfError(parse.Set(aFilename, 0, 0));

	TName dummy1;

	TInt find=0;

	CNifFactory* factory(NULL);

	if (factoryContainer.FindByName(find, parse.Name(), dummy1) != KErrNone)

        {

        // Load the module

        TAutoClose<RLibrary> lib;

        User::LeaveIfError(lib.iObj.Load(aFilename));

        lib.PushL();

		// The Uid check

		if (lib.iObj.Type()[1] != agentUid)

            {

            User::Leave(KErrBadLibraryEntryPoint);

            }

		TAgentFactoryNewL libEntry = (TAgentFactoryNewL)lib.iObj.Lookup(1);

		if (libEntry==NULL)

            {

            User::Leave(KErrNoMemory);

            }

		factory =(*libEntry)(); // Opens CObject

		if (!factory)

            {