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

// Implements generic base for NIFMAN side of configuration daemon

// 

//

/**

 @file NIFConfigurationControl.cpp

 @internalTechnology

*/

#include "networkconfigextensionbase.h"

#include <comms-infras/nifif.h>

#include <comms-infras/ca_startserver.h>

#include <cdbcols.h>

#include <comms-infras/commsdebugutility.h>

#include <cdblen.h>

#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_NifManNetCfgExtn, "NifManNetCfgExtn");

#endif

_LIT(KIAPId, "IAP\\Id");

_LIT(KIAPNetwork, "IAP\\IAPNetwork");

/**

   ADeletionNotifier

*/

ADeletionNotifier::~ADeletionNotifier()

	{

	iDeletionListener->NotifyDeletionL(this);

	}

/**

   ADeferredDeletion

*/	

void ADeferredDeletion::ListenForObjectDeletionL(ADeletionNotifier */*aDelete*/)

	{

	iDeletionObjectCount++;

	}

EXPORT_C void ADeferredDeletion::DeleteThis()

	{

	iDeleteWhenAllObjectsDeleted = ETrue;

	if (iDeletionObjectCount == 0)

		{

		delete this;

		}

	}

EXPORT_C void ADeferredDeletion::NotifyDeletionL(ADeletionNotifier */*aDelete*/)

	{

	iDeletionObjectCount--;

	if (iDeleteWhenAllObjectsDeleted && iDeletionObjectCount == 0)

		{

		DeleteThis();

		}

	}

NONSHARABLE_CLASS(CAsynchDaemonCancel) : public CActive, public ADeletionNotifier

{

public:

   CAsynchDaemonCancel(ADeferredDeletion* aDeletionListener) :

	   CActive(EPriorityStandard), ADeletionNotifier(aDeletionListener)

	   {

	   }

   void AsyncDelete();

   void CancelControl(RConfigDaemon& aConfigDaemon, TBool aDeleteOnCompletion);

   void CancelControl(RConfigDaemon& aConfigDaemon, TInt aOpMask, TBool aDeleteOnCompletion);

protected:

	virtual void RunL();

	virtual void DoCancel();

protected:

	TBool iDeleteOnCompletion;

	};

NONSHARABLE_CLASS(CNifDaemonProgress) : public CActive, public ADeletionNotifier, public ADeferredDeletion

/**

 * Active object class used by CNetworkConfigExtensionBase to maintain a persistent 

 * ProgressNotification call against the daemon. Delete this object only using the 

 * AsyncDelete method.

 *

 * @internalComponent

 */

	{

public:

	static CNifDaemonProgress* NewL(RConfigDaemon& aConfigDaemon, CNetworkConfigExtensionBase* aProgressDest, ADeferredDeletion* aDeletionListener);

	void ProgressNotification();

   	void AsyncDelete();

	void DeleteThis();

   	void CancelControl();

protected:

	void RunL();

	void DoCancel();

	// This is protectde so that you MUST use AsyncDelete.

	virtual ~CNifDaemonProgress() {};

private:

  	void ConstructL();

   	CNifDaemonProgress(RConfigDaemon& aConfigDaemon, CNetworkConfigExtensionBase* aProgressDest, ADeferredDeletion* aDeletionListener);

	/** Reference to the configuration daemon interface. */

   	RConfigDaemon& iConfigDaemon;

	/** Used to asynchrounously cancel any outstanding request on iConfigDaemon so that esock is never blocked. */

   	CAsynchDaemonCancel* iAsynchDaemonCancel;

	/** The target for progress notifications. */

   	CNetworkConfigExtensionBase* iProgressDest;

	/** Stores the progress notification. */

   	TDaemonProgressBuf iProgressBuf;

	/** If ETrue, the object should delete itself when the outstanding request completes. */

	TBool iDeleteOnCompletion;

	};

void CAsynchDaemonCancel::AsyncDelete()

/**

 * Delete the instance of CAsynchDaemonCancel safely.

 * 

 * @internalComponent

 */

	{

	if (IsActive())

		iDeleteOnCompletion = ETrue;

	else

		delete this;

	}

void CAsynchDaemonCancel::DoCancel()

   {//nothing to do

   }

void CAsynchDaemonCancel::CancelControl(RConfigDaemon& aConfigDaemon, TBool aDeleteOnCompletion)

   {

      if (!IsActive())

         {

         __ASSERT_DEBUG(!IsAdded(), User::Panic(KSpecAssert_NifManNetCfgExtn, 1));	

         CActiveScheduler::Add(this);

         aConfigDaemon.Cancel(iStatus);

         SetActive();

         }

      iDeleteOnCompletion = aDeleteOnCompletion;

   }

void CAsynchDaemonCancel::CancelControl(RConfigDaemon& aConfigDaemon, TInt aOpMask, TBool aDeleteOnCompletion)

/**

 * CancelControl - Asynchronously cancels the last server request according to aOpMask.

 *

 * @internalComponent

 */

   {

      if (!IsActive())

         {

         __ASSERT_DEBUG(!IsAdded(), User::Panic(KSpecAssert_NifManNetCfgExtn, 2));

         CActiveScheduler::Add(this);

         aConfigDaemon.Cancel(aOpMask,iStatus);

         SetActive();

         }

      iDeleteOnCompletion = aDeleteOnCompletion;

   }

void CAsynchDaemonCancel::RunL()

  	{

	   if ( iDeleteOnCompletion )

		   {

		   delete this;

		   }

	   else

		   {

		   Deque();

		   }

  	}

CNifDaemonProgress* CNifDaemonProgress::NewL(RConfigDaemon& aConfigDaemon, CNetworkConfigExtensionBase* aProgressDest, ADeferredDeletion* aDeletionListener)

/**

 * Standard NewL for CNifDaemonProgress.

 * 

 * @internalComponent

 *

 * @param aConfigDaemon	Daemon client to be used.

 * @param aProgressDest	Destination for progress notifications.

 * @leave KErrNoMemory if there is insufficient heap.

 */

   {

	   CNifDaemonProgress* pDaemonProgress = new(ELeave)CNifDaemonProgress(aConfigDaemon, aProgressDest, aDeletionListener);

   CleanupStack::PushL(pDaemonProgress);

   pDaemonProgress->ConstructL();

   CleanupStack::Pop(pDaemonProgress);

   return pDaemonProgress;

   }

void CNifDaemonProgress::DeleteThis()

	{

	if (iAsynchDaemonCancel)

		{

		iAsynchDaemonCancel->AsyncDelete();

		iAsynchDaemonCancel = NULL;

		}

	ADeferredDeletion::DeleteThis();

	}

void CNifDaemonProgress::ConstructL()

/**

 * Standard ConstructL for CNifDaemonProgress.

 * 

 * @internalComponent

 *

 * @leave KErrNoMemory if there is insufficient heap.

 */

   {

   iAsynchDaemonCancel = new(ELeave)CAsynchDaemonCancel(this);

   }

CNifDaemonProgress::CNifDaemonProgress(

	RConfigDaemon& aConfigDaemon, 

	CNetworkConfigExtensionBase* aProgressDest,

	ADeferredDeletion* aDeletionListener) :

	CActive(EPriorityStandard),

	ADeletionNotifier(aDeletionListener),

   	iConfigDaemon(aConfigDaemon),

   	iAsynchDaemonCancel(NULL),

   	iProgressDest(aProgressDest),

   	iDeleteOnCompletion(EFalse)

/**

 * Construct the progress active object. Adds the active object to the scheduler and 

 * issues the asynchronous call.

 * 

 * @internalComponent

 *

 * @param aConfigDaemon	Daemon client to be used.

 * @param aProgressDest	Destination for progress notifications.

 */

    {

    CActiveScheduler::Add(this);

    ProgressNotification();       

    }  	

void CNifDaemonProgress::ProgressNotification()

/**

 * Issues the asynchronous progress notification request.

 * 

 * @internalComponent

 */

	{

	iConfigDaemon.ProgressNotification(iProgressBuf, iStatus);

	SetActive();

	}

void CNifDaemonProgress::RunL()

/**

 * Indicates that a progress notification was received. 

 * The progress info will be found in iProgressBuf.

 * 

 * @internalComponent

 */

	{

	if (iDeleteOnCompletion)

		{

		// if iDeleteOnCompletion is true, we are to delete ourselves

	  	__FLOG_STATIC0(KLogSubSysNifman, KLogTagCsDaemon, _L("CNifDaemonProgress::RunL - Deleting ourselves."));	

		DeleteThis();

		}

	else if (iStatus.Int() == KErrNone)

		{

		// We successfully got a progress notification. Pass it

		// on the the target and re-issue the request.

	  	__FLOG_STATIC1(KLogSubSysNifman, KLogTagCsDaemon, _L("CNifDaemonProgress::RunL - Successfully received progress notification %d. Re-issuing request."),iProgressBuf().iStage);	

		iProgressDest->DoOnDaemonProgress(iProgressBuf().iStage, iProgressBuf().iError);

		ProgressNotification();	

		}

	else if (iStatus.Int() == KErrNotReady)

		{

		// The daemon is starting-up. Re-issue the request.

		__FLOG_STATIC0(KLogSubSysNifman, KLogTagCsDaemon, _L("CNifDaemonProgress::RunL - Progress notification. Waiting for server to start."));

		ProgressNotification();	

		}

	else

		{

		// We failed to get a progress notification.

		// The daemon either does not support this request,

		// has exited or has died. Do not issue another request. 

		// We'll get into a tight loop if we do.

	  	__FLOG_STATIC1(KLogSubSysNifman, KLogTagCsDaemon, _L("CNifDaemonProgress::RunL - Failed to get progress notification from daemon. The error was %d"),iStatus.Int());	

	  	}

  	}

void CNifDaemonProgress::AsyncDelete()

/**

 * Cancels any outstanding progress notification and optionally 

 * the instance of CNifDaemonProgress asynchronously to avoid

 * potential deadlock in Esock.

 *

 * @internalComponent

 */	

	{

   	if (IsActive())

    	{

	  	__FLOG_STATIC0(KLogSubSysNifman, KLogTagCsDaemon, _L("CNifDaemonProgress::AsyncDelete - Waiting for CancelControl to complete"));	

       	iDeleteOnCompletion = ETrue;

       	CancelControl();

       	}

 	else

    	{

		DeleteThis();

       	}

	}

void CNifDaemonProgress::CancelControl()

/**

 * Cancels any outstanding progress asynchronously to avoid

 * potential deadlock in Esock.

 *

 * @internalComponent

 */

	{

	if (IsActive())

		{

		iAsynchDaemonCancel->CancelControl(iConfigDaemon, KConfigDaemonOpMaskProgress, iDeleteOnCompletion);

		if (iDeleteOnCompletion)

			iAsynchDaemonCancel = NULL;

		}

	}

void CNifDaemonProgress::DoCancel()

/**

 * Standard active object DoCancel.

 * 

 * @internalComponent

 */

	{

	// DoCancel() is only used by Cancel(), which is can not be 

	// used as it will block the ESOCK thread.

	__ASSERT_DEBUG(0, User::Panic(KSpecAssert_NifManNetCfgExtn, 3)); 

	}

CNetworkConfigExtensionBase* CNetworkConfigExtensionBase::NewL( TAny* aMNifIfNotify )

   {

   MNifIfNotify* nifIfNotify = reinterpret_cast<MNifIfNotify*>(aMNifIfNotify);

   CNetworkConfigExtensionBase* pDaemon = new(ELeave)CNetworkConfigExtensionBase( *nifIfNotify );

	CleanupStack::PushL(pDaemon);

   pDaemon->ConstructL();

	CleanupStack::Pop(pDaemon);

   return pDaemon;

   }

EXPORT_C void CNetworkConfigExtensionBase::ConstructL()

   {

   __FLOG_STATIC0(KLogSubSysNifman, KLogTagCsDaemon, _L("CNetworkConfigExtensionBase::ConstructL"));

   iAsynchDaemonCancel = new(ELeave)CAsynchDaemonCancel(this);

   }

EXPORT_C void CNetworkConfigExtensionBase::ConfigureNetworkL()

/**

ConfigureNetworkL - starts a daemon and issues configuration request

@internalTechnology

@version 0.02

**/

	{

  	__FLOG_STATIC0(KLogSubSysNifman, KLogTagCsDaemon, _L("CNetworkConfigExtensionBase::ConfigureNetworkL"));	

	//it could access directly CNifAgentRef::ConnectionInfo but i don't want the class be 

	//CNifAgentRef dependent

   	__ASSERT_DEBUG(iMessage.IsNull(), User::Panic(KSpecAssert_NifManNetCfgExtn, 4));

	User::LeaveIfError(iNifIfNotify->ReadInt(KIAPId(), iConnectionInfoBuf().iIapId));

	User::LeaveIfError(iNifIfNotify->ReadInt(KIAPNetwork(), iConnectionInfoBuf().iNetId));

   	//this is the same read as in CNifConfigurationControl::NewL we do the read rather than storing the

   	//server name since the db access should really provide an efficient access to the settings

   	//already selected by NETCON

	TBuf<KCommsDbSvrMaxFieldLength> serverName;		/*100 bytes if unicode*/

	User::LeaveIfError(iNifIfNotify->ReadDes(TPtrC(SERVICE_CONFIG_DAEMON_NAME), serverName));

	// safe to pass stack var here, as its copied down the track...

	// For security reasons, ensure that the server name has the "!" prefix - only protected

	// servers should be involved with Network Configuration.

	_LIT(KExclamationMark, "!");

	if (serverName.Left(1).Compare(KExclamationMark()) != 0)

		serverName.Insert(0,KExclamationMark());

	__ASSERT_DEBUG(!ipStartServer, User::Panic(KSpecAssert_NifManNetCfgExtn, 5));

	DoOnGenericProgress(KConfigDaemonLoading, KErrNone);

	ipStartServer = new(ELeave)CStartServer(iConfigDaemon, iConfigDaemon.Version(), 10);

	ipStartServer->Connect(serverName, iStatus);

	SetActive();

	}

EXPORT_C void CNetworkConfigExtensionBase::LinkLayerDown()	

/**

 * Generates an EConfigDaemonLinkLayerDown request. Used to inform the

 * daemon that link-layer renegotiation has started.

 * 

 * @internalComponent

 */

	{

	if (iSuccessfullyCreatedDaemon)

		iConfigDaemon.LinkLayerDown();

	}

EXPORT_C void CNetworkConfigExtensionBase::LinkLayerUp()	

/**

 * Generates an EConfigDaemonLinkLayerUp request. Used to inform the

 * daemon that link-layer renegotiation has completed.

 * 

 * @internalComponent

 */

	{

	if (iSuccessfullyCreatedDaemon)

		iConfigDaemon.LinkLayerUp();

	}

EXPORT_C void CNetworkConfigExtensionBase::Deregister(

	TInt aCause)	

/**

 * Generates a deregistration request.

 * 

 * @internalComponent

 *

 * @param aCause Specifies what caused the deregistration request (idle timer or Stop call)

 */

	{

	if (IsActive())

		{

		// if a deregistration request isn't queued up, queue one up

		if (!iDeregisterOnCompletionOfRequest)

			{

			iDeregisterOnCompletionOfRequest = ETrue;

			iDeregistrationCauseCode = aCause;

			}

		}

	else if (!iSuccessfullyCreatedDaemon)

		{

		// note that there is no longer a queued deregistration

		// request

		iDeregisterOnCompletionOfRequest = EFalse;

		// fake the behaviour of the daemon and report 

		// KErrNotFound to be compatible with the previous

		// behaviour expected by the DHCP tests - KErrNotFound

		// as in the daemon "was not found"

		DoOnGenericProgress(KConfigDaemonStartingDeregistration, KErrNone);

		DoOnGenericProgress(KConfigDaemonFinishedDeregistrationStop, KErrNotFound);		

		}

	else

		{

		// note that there is no longer a queued deregistration

		// request

		iDeregisterOnCompletionOfRequest = EFalse;

		// progress notification before the operation

		DoOnGenericProgress(KConfigDaemonStartingDeregistration, KErrNone);

		// ask the daemon to deregister

		iConfigDaemon.Deregister(aCause, &iDesDeregActionStatus, iStatus);

		SetActive();

		}    	

	}

EXPORT_C void CNetworkConfigExtensionBase::SendIoctlMessageL(const ESock::RLegacyResponseMsg& aMessage)

/**

* SendIoctlMessageL forwards Ioctl request to the daemon and activates the AO to wait for response

* 

@internalTechnology

@version 0.02

@param aMessage[in] a message to be processed (it's the caller's resposibility to forward just Ioctl

*                   messages)

**/

	{

   	__FLOG_STATIC0(KLogSubSysNifman, KLogTagCsDaemon, _L("CNetworkConfigExtensionBase::SendIoctlMessageL"));	

	if (static_cast<TUint>(aMessage.Int0()) != KCOLConfiguration)

		{

		User::Leave(KErrNotSupported);

		}

   	else

		{

		if (!IsActive())

			{

			TDes8* ptr = NULL;

			// may not always have a buffer to read...

			if (aMessage.Ptr2())

				{

            	delete iIoBuf;

            	iIoBuf = NULL;

            	TInt maxLength = aMessage.GetDesMaxLengthL(2);

				iIoBuf=HBufC8::NewMaxL(maxLength);

				iIoPtr.Set(iIoBuf->Des());

				aMessage.ReadL(2, iIoPtr);

				TInt length = aMessage.GetDesLength(2);

				if (length<1) //length could be -ve due to error return from GetDesLength

					{

					iIoPtr.SetLength(maxLength);

					}

				else

					{

					iIoPtr.SetLength(length);

					}

				ptr = &iIoPtr;

				}

			//store msg after ReadDescriptorL which could leave

			iMessage = aMessage;

			iConfigDaemon.Ioctl(aMessage.Int0(), aMessage.Int1(), iStatus, ptr);

			SetActive();      

			}

		else

			{

			User::Leave(KErrInUse);

			}

		}

	}

EXPORT_C void CNetworkConfigExtensionBase::AsyncDelete()