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

// SPUD event manager

// WINSCW compiler has problems disambiguating TMetaDes8 and Meta::TMetaDes8 so

// I prevent metabuffer.h from being recursively included from other headers

// by defining its include guard.

// 

//

/**

 @file

 @internalComponent

*/

#define METABUFFER_H

#include "spudman.h"

#include "bindman.h"

#include "mux.h"

#include <comms-infras/dbaccess.h>

#include "rpdpfsminterface.h"

using namespace SpudMan; // Access the SpudFsm event names

#include <etelpckt.h>

#include <comms-infras/commsdebugutility.h>

#include <in_sock.h>

#include <networking/qos_if.h>

#include <nifman.h>

#include <comms-infras/es_config.h>

#include <networking/umtsgprs_subconnprovfactory.h>

#include <ss_glob.h>

#include <ss_subconnprov.h>

const TUint KQosPlugInProtocolId = 360; //< Plug-in protocol ID

static const TInt KMaxInetAddrPrintSize = 50; //This should be big enough for an IPv6 printout

#ifdef __FLOG_ACTIVE

_LIT(KSpudUnknownLit, "Unknown event");

_LIT(KSpudSoIfControllerPlugInLit, "KSoIfControllerPlugIn");

_LIT(KSpudLitKRegisterEventHandler, "KRegisterEventHandler");

_LIT(KSpudContextSetEventsLit, "KContextSetEvents");

_LIT(KSpudNifSetDefaultQoSLit, "KNifSetDefaultQoS");

_LIT(KSpudContextCreateLit, "KContextCreate");

_LIT(KSpudContextDeleteLit, "KContextDelete");

_LIT(KSpudContextActivateLit, "KContextActivate");

_LIT(KSpudContextQoSSetLit, "KContextQoSSet");

_LIT(KSpudContextTFTModifyLit, "KContextTFTModify");

_LIT(KSpudGetNegQoSLit, "KGetNegQoS");

_LIT(KSpudContextModifyActiveLit, "KContextModifyActive");

_LIT(KInitialisePdpFsmLit, "KInitialisePdpFsm");

static const TDesC *SpudGuQoSEventToText(TInt aEvent)

	{

	switch(aEvent)

		{

	case KSoIfControllerPlugIn:

		return &KSpudSoIfControllerPlugInLit;

	case KRegisterEventHandler:

		return &KSpudLitKRegisterEventHandler;

	case KContextSetEvents:

		return &KSpudContextSetEventsLit;

	case KNifSetDefaultQoS:

		return &KSpudNifSetDefaultQoSLit;

	case KContextCreate:

		return &KSpudContextCreateLit;

	case KContextDelete:

		return &KSpudContextDeleteLit;

	case KContextActivate:

		return &KSpudContextActivateLit;

	case KContextQoSSet:

		return &KSpudContextQoSSetLit;

	case KContextTFTModify:

		return &KSpudContextTFTModifyLit;

	case KGetNegQoS:

		return &KSpudGetNegQoSLit;

	case KContextModifyActive:

		return &KSpudContextModifyActiveLit;

	case KInitialisePdpFsm:

		return &KInitialisePdpFsmLit;

	default:

    	return &KSpudUnknownLit;

		}

	}

_LIT(KSpudContextDeleteEventLit, "KContextDeleteEvent");

_LIT(KSpudContextActivateEventLit, "KContextActivateEvent");

_LIT(KSpudContextParametersChangeEventLit, "KContextParametersChangeEvent");

_LIT(KSpudContextBlockedEventLit, "KContextBlockedEvent");

_LIT(KSpudContextUnblockedEventLit, "KContextUnblockedEvent");

_LIT(KSpudNetworkStatusEventLit, "KNetworkStatusEvent");

_LIT(KSpudContextQoSSetEventLit, "KContextQoSSetEvent");

_LIT(KSpudContextTFTModifiedEventLit, "KContextTFTModifiedEvent");

_LIT(KSpudPrimaryContextCreatedLit, "KPrimaryContextCreated");

_LIT(KSpudSecondaryContextCreatedLit, "KSecondaryContextCreated");

_LIT(KSpudGetNegQoSEventLit,"KGetNegQoSEvent");

_LIT(KSpudContextModifyActiveEventLit, "KContextModifyActiveEvent");

_LIT(KPdpFsmShuttingDownLit, "KPdpFsmShuttingDown");

static const TDesC *SpudFsmEventToText(TInt aEvent)

	{

	switch(aEvent)

    	{

	case KContextDeleteEvent:

		return &KSpudContextDeleteEventLit;

	case KContextActivateEvent:

		return &KSpudContextActivateEventLit;

	case KContextParametersChangeEvent:

		return &KSpudContextParametersChangeEventLit;

	case KContextBlockedEvent:

		return &KSpudContextBlockedEventLit;

	case KContextUnblockedEvent:

		return &KSpudContextUnblockedEventLit;

	case KNetworkStatusEvent:

		return &KSpudNetworkStatusEventLit;

	case KContextQoSSetEvent:

		return &KSpudContextQoSSetEventLit;

	case KContextTFTModifiedEvent:

		return &KSpudContextTFTModifiedEventLit;

	case KPrimaryContextCreated:

		return &KSpudPrimaryContextCreatedLit;

	case KSecondaryContextCreated:

		return &KSpudSecondaryContextCreatedLit;

	case KGetNegQoSEvent:

    		return &KSpudGetNegQoSEventLit;

    case KContextModifyActiveEvent:

    	return &KSpudContextModifyActiveEventLit;

   	case KPdpFsmShuttingDown:

    	return &KPdpFsmShuttingDownLit;

    default:

    	return &KSpudUnknownLit;

    	}

	}

_LIT(KSpudStateSpudInactiveLit, "ESpudInactive");

_LIT(KSpudStateSpudHaveQosLit, "ESpudHaveQos");

_LIT(KSpudStateSpudCreatingPrimary, "ESpudCreatingPrimary");

_LIT(KSpudStateSpudStartingPrimaryLit, "ESpudStartingPrimary");

_LIT(KSpudStateSpudStartingPrimaryLowerNifLit, "ESpudStartingPrimaryLowerNif");

_LIT(KSpudStateSpudStartingSecondaryLit, "ESpudStartingSecondary");

_LIT(KSpudStateSpudStartingSecondaryLowerNifLit, "ESpudStartingSecondaryLowerNif");

_LIT(KSpudStateSpudGettingNegQoSLit, "ESpudGettingNegQoS");

_LIT(KSpudStateSpudUpLit, "ESpudUp");

_LIT(KSpudStateSpudFlowOffLit, "ESpudFlowOff");

_LIT(KSpudStateSpudSuspendedLit, "ESpudSuspended");

_LIT(KSpudStateSpudFlowOffAndSuspendedLit, "ESpudFlowOffAndSuspended");

_LIT(KSpudStateSpudLinkDownLit, "ESpudLinkDown");

_LIT(KSpudStateSpudContextDeleteLit, "ESpudContextDelete");

_LIT(KSpudStateSpudWaitLinkDownLit, "ESpudWaitLinkDown");

_LIT(KSpudStateSpudWaitBinderDeleteLit, "ESpudWaitBinderDelete");

_LIT(KSpudStateUnknownLit, "Unknown spud state");

static const TDesC *SpudStateToText(TSpudContextStates aState)

	{

	switch(aState)

    	{

	case ESpudInactive:

		return &KSpudStateSpudInactiveLit;

	case ESpudHaveQos:

		return &KSpudStateSpudHaveQosLit;

	case ESpudCreatingPrimary:

		return &KSpudStateSpudCreatingPrimary;

	case ESpudStartingPrimary:

		return &KSpudStateSpudStartingPrimaryLit;

	case ESpudStartingPrimaryLowerNif:

		return &KSpudStateSpudStartingPrimaryLowerNifLit;

	case ESpudStartingSecondary:

		return &KSpudStateSpudStartingSecondaryLit;

	case ESpudStartingSecondaryLowerNif:

		return &KSpudStateSpudStartingSecondaryLowerNifLit;

	case ESpudGettingNegQoS:

		return &KSpudStateSpudGettingNegQoSLit;

	case ESpudUp:

		return &KSpudStateSpudUpLit;

	case ESpudFlowOff:

		return &KSpudStateSpudFlowOffLit;

	case ESpudSuspended:

		return &KSpudStateSpudSuspendedLit;

	case ESpudFlowOffAndSuspended:

		return &KSpudStateSpudFlowOffAndSuspendedLit;

	case ESpudLinkDown:

		return &KSpudStateSpudLinkDownLit;

	case ESpudContextDelete:

		return &KSpudStateSpudContextDeleteLit;

	case ESpudWaitLinkDown:

		return &KSpudStateSpudWaitLinkDownLit;

	case ESpudWaitBinderDelete:

		return &KSpudStateSpudWaitBinderDeleteLit;

	default:

    	return &KSpudStateUnknownLit;

    	}

	}

#endif

CSpudMan::CSpudMan(CNifIfFactory& aFactory, MNifIfNotify* aNotify)

	: CNifIfLink(aFactory),

	iContextStatusOverride(RPacketContext::EStatusUnknown)

	{

    iNotify = aNotify;

    ASSERT(iNotify);

	__FLOG_OPEN(KSpudFirstTag,KSpudLog);

    __FLOG_0(_L("CSpudMan::CSpudMan"));

	}

CSpudMan::~CSpudMan()

   {

   if (iBindMan)

      {

      // Only log if ConstructL() was called, where logger was initialized

      __FLOG_0(_L("CSpudMan::~CSpudMan"));

      }

   if (AreQoSEventsEnabled())

      {

      // Spud is being destroyed by Nifman. Tell GUQoS to stop bothering SPUD.

      // GUQoS returns the favour by turning off the NIF events within this very call.

      // *********************************************************************************************

      // N.B.: "DEF055691 	GUQoS crashes at shutdown": This defect results in GUQoS crash if the stack

      // closes flows after the NIF proxy was deleted by GUQoS, as a result of KNetworkInterfaceDown event.

      // Because of this defect, we cannot signal KNetworkInterfaceDown from anywhere but here. Once it is fixed,

      // calls from the appropriate places will be enabled, and the line below will not be strictly necessary.

      SendNetworkStatusEvent(KNetworkInterfaceDown, RPacketService::EStatusUnattached);

      // For safety, we should call this from here in any case.

      //**********************************************************************************************

      }

   delete iParkedDefaultQoS;

   delete iBinderSweeperNotifierCb;

   delete iBindMan;

   iPdpFsmInterface.Close();

   iSipServerAddr.Close();

   __FLOG_CLOSE;

   }

/**

Panics the current thread.

@param aReason Panic reason code

*/

void CSpudMan::Panic(TInt aReason) const

	{

    __FLOG_1(_L("CSpudMan::Panic with reason %d"), aReason);

	User::Panic(KSpudName, aReason);

	}

/**

Construct the Link Protocol Object

@param aBindMan Pointer to BindMan object (ownership is transferred)

@leave leaves if could not allocate memory

*/

void CSpudMan::ConstructL(CBindMan* aBindMan)

	{

    __FLOG_1(_L("CSpudMan starting %x"), iNotify);

	iBindMan = aBindMan;

	ASSERT(iBindMan);

	// The lower NIF binder deletion & Nifman notification callback

	iBinderSweeperNotifierCb = new (ELeave) CBinderSweeperNotifierCb(*this);

	}

/**

Implements the Control method of CNifBase - used for retrieval of the P-CSCF (Sip Server) address

*/	

TInt CSpudMan::Control(TUint aLevel,TUint aName,TDes8& aOption, TAny*)

	{

	if (aLevel == KCOLConfiguration && aName == KConnGetSipServerAddr)

		{

		if (aOption.Length() != sizeof (SSipServerAddr))

			{

			__FLOG(_L("CSpudMan::Control - Invalid Descriptior - Descriptor Must contain an SSipServerAddr"));

			Panic();

			}

		SSipServerAddr* sipServerAddr = reinterpret_cast<SSipServerAddr*>(const_cast<TUint8*>(aOption.Ptr()));

		if (sipServerAddr->index < 0 || sipServerAddr->index >= iSipServerAddr.Count())

			{

			__FLOG_1(_L("CSpudMan::Control - Index out of range : value = %d"), sipServerAddr->index);

			return KErrNotFound;

			}

		sipServerAddr->address = iSipServerAddr[sipServerAddr->index];

#ifdef __FLOG_ACTIVE

		TBuf<KMaxInetAddrPrintSize> buf;

		sipServerAddr->address.Output(buf);

		__FLOG_2(_L("CSpudMan::Control Address %S returned for index %d"), &buf, sipServerAddr->index);

#endif

		return KErrNone;				

		}

	return KErrNotSupported;	

	}

/**

Retrieve any GPRS settings required from CommDB

@param aConfigGprs Context configuration parameters to be filled in

*/

void CSpudMan::RetrieveGprsConfig(RPacketContext::TContextConfigGPRS& aConfigGprs) const

	{

	TUint32 pdpType(0);

	Notify()->ReadInt(TPtrC(GPRS_PDP_TYPE), pdpType);

 	__FLOG_1(_L8("ReadInt GPRS_PDP_TYPE [%d]"), pdpType);

	aConfigGprs.iPdpType = STATIC_CAST(RPacketContext::TProtocolType, pdpType);

	Notify()->ReadDes(TPtrC(GPRS_APN), aConfigGprs.iAccessPointName);

  	__FLOG_1(_L8("ReadDes GPRS_APN [%S]"), &aConfigGprs.iAccessPointName);

	TBool fromServer;

	aConfigGprs.iPdpAddress.SetLength(0);

	Notify()->ReadBool(TPtrC(GPRS_IP_ADDR_FROM_SERVER), fromServer);

	if (!fromServer)

	    {

    	Notify()->ReadDes(TPtrC(GPRS_IP_ADDR), aConfigGprs.iPdpAddress);

	    }

    // We can only use IPv4 or IPv6 - we use the first one listed in the IfNetworks field

    TBuf<KCommsDbSvrMaxFieldLength> networks;

	Notify()->ReadDes(TPtrC(LAN_IF_NETWORKS), networks);

	ASSERT(networks.Length() > 0); // If the IfNetworks field is empty there is a serious misconfiguration

	TInt pos = networks.Find(_L(","));

	if (pos == KErrNotFound)

	    {

	    pos = networks.Length();

	    }

	TPtrC protocol(networks.Ptr(), pos);

	_LIT(KIp4, "ip");

	_LIT(KIp6, "ip6");

	if (protocol.CompareF(KIp4) == 0)

	    {

	    // IPv4 settings

    	Notify()->ReadBool(TPtrC(GPRS_IP_DNS_ADDR_FROM_SERVER), fromServer);

    	if (!fromServer)

    	    {

    	    Notify()->ReadDes(TPtrC(GPRS_IP_NAME_SERVER1), aConfigGprs.iProtocolConfigOption.iDnsAddresses.iPrimaryDns);

    	    Notify()->ReadDes(TPtrC(GPRS_IP_NAME_SERVER2), aConfigGprs.iProtocolConfigOption.iDnsAddresses.iSecondaryDns);

    	    }

	    }

	else if (protocol.CompareF(KIp6) == 0)

	    {

	    // IPv6 settings

    	Notify()->ReadBool(TPtrC(GPRS_IP6_DNS_ADDR_FROM_SERVER), fromServer);

    	if (!fromServer)

    	    {

    	    Notify()->ReadDes(TPtrC(GPRS_IP6_NAME_SERVER1), aConfigGprs.iProtocolConfigOption.iDnsAddresses.iPrimaryDns);

    	    Notify()->ReadDes(TPtrC(GPRS_IP6_NAME_SERVER2), aConfigGprs.iProtocolConfigOption.iDnsAddresses.iSecondaryDns);

    	    }

	    }

	else

	    {

	    // Anything else is a serious misconfiguration

	    ASSERT(0);

	    }

	RetrieveGprsCompression(aConfigGprs.iPdpCompression);

	 __FLOG_1(_L8("Read GprsCompression [%d]"), aConfigGprs.iPdpCompression);

	RetrieveGprsAnonymousAccess(aConfigGprs.iAnonymousAccessReqd);

 	__FLOG_1(_L8("Read AnonymousAccess [%d]"), aConfigGprs.iAnonymousAccessReqd);

	TBuf<KCommsDbSvrMaxUserIdPassLength> readBuf;

	Notify()->ReadDes(TPtrC(SERVICE_IF_AUTH_NAME), readBuf);

	aConfigGprs.iProtocolConfigOption.iAuthInfo.iUsername.Copy(readBuf);

	readBuf.Zero();

	Notify()->ReadDes(TPtrC(SERVICE_IF_AUTH_PASS), readBuf);

	aConfigGprs.iProtocolConfigOption.iAuthInfo.iPassword.Copy(readBuf);

 	__FLOG_2(_L8("ReadDes SERVICE_IF_AUTH_NAME [%S] and SERVICE_IF_AUTH_PASS [%S]"), &aConfigGprs.iProtocolConfigOption.iAuthInfo.iUsername, 

			 &aConfigGprs.iProtocolConfigOption.iAuthInfo.iPassword);

	aConfigGprs.iUseEdge = EFalse;

	}

void CSpudMan::RetrieveGprsCompression(TUint& aCompression) const

	{

	aCompression = 0;

	TBool isCompression = EFalse;

	Notify()->ReadBool(TPtrC(GPRS_DATA_COMPRESSION), isCompression);

	if (isCompression)

		{

		aCompression |= RPacketContext::KPdpDataCompression;

		}

	isCompression = EFalse;

	Notify()->ReadBool(TPtrC(GPRS_HEADER_COMPRESSION), isCompression);

	if (isCompression)

		{

		aCompression |= RPacketContext::KPdpHeaderCompression;

		}

	}

void CSpudMan::RetrieveGprsAnonymousAccess(RPacketContext::TAnonymousAccess& aAnonymous) const

	{	

	TBool isAnonymous = EFalse;

	Notify()->ReadBool(TPtrC(GPRS_ANONYMOUS_ACCESS),isAnonymous);

	if (isAnonymous)

		aAnonymous = RPacketContext::ERequired;

	else

		aAnonymous = RPacketContext::ENotRequired;

	}

/**

Indicates whether QoS has been enabled or not.

@return ETrue if QoS has been enabled for this NIF.

*/

TBool CSpudMan::AreQoSEventsEnabled() const

	{

	return iQosEventHandler != NULL;

	}

/**

Returns pointer to BindMan.

@return Pointer to BindMan object

*/

CBindMan* CSpudMan::BindMan() const

	{

	return iBindMan;

	}

/**

Returns pointer to the MNifIfNotify object in NIFMAN.

@return Pointer to MNifIfNotify object

*/

MNifIfNotify* CSpudMan::Notify() const

	{

	ASSERT(iNotify);

	return iNotify;

	}

/**

Set default QoS parameters from the values in CommDb.

@param aQos QoS parameters filled in on exit

*/

void CSpudMan::ReadDefaultQoS(RPacketQoS::TQoSR99_R4Requested& aQos) const

	{

	TBuf<2*KCommsDbSvrMaxColumnNameLength+1> columnName;

	_LIT(KFormatText,"%s\\%s");

	columnName.Format(KFormatText,QOS_UMTS_R99_AND_ON_TABLE,GPRS_QOS_REQ_TRAFFIC_CLASS);

	Notify()->ReadInt (columnName, reinterpret_cast<TUint32&>(aQos.iReqTrafficClass));

	columnName.Format(KFormatText,QOS_UMTS_R99_AND_ON_TABLE,GPRS_QOS_MIN_TRAFFIC_CLASS);

	Notify()->ReadInt (columnName, reinterpret_cast<TUint32&>(aQos.iMinTrafficClass));

	columnName.Format(KFormatText,QOS_UMTS_R99_AND_ON_TABLE,GPRS_QOS_REQ_DELIVERY_ORDER);

	Notify()->ReadInt (columnName, reinterpret_cast<TUint32&>(aQos.iReqDeliveryOrderReqd));

	columnName.Format(KFormatText,QOS_UMTS_R99_AND_ON_TABLE,GPRS_QOS_MIN_DELIVERY_ORDER);

	Notify()->ReadInt (columnName, reinterpret_cast<TUint32&>(aQos.iMinDeliveryOrderReqd));

	columnName.Format(KFormatText,QOS_UMTS_R99_AND_ON_TABLE,GPRS_QOS_REQ_DELIVER_ERRONEOUS_SDU);

	Notify()->ReadInt (columnName, reinterpret_cast<TUint32&>(aQos.iReqDeliverErroneousSDU));

	columnName.Format(KFormatText,QOS_UMTS_R99_AND_ON_TABLE,GPRS_QOS_MIN_DELIVER_ERRONEOUS_SDU);

	Notify()->ReadInt (columnName, reinterpret_cast<TUint32&>(aQos.iMinDeliverErroneousSDU));

	columnName.Format(KFormatText,QOS_UMTS_R99_AND_ON_TABLE,GPRS_QOS_REQ_MAX_SDUSIZE);

	Notify()->ReadInt (columnName, reinterpret_cast<TUint32&>(aQos.iReqMaxSDUSize));

	columnName.Format(KFormatText,QOS_UMTS_R99_AND_ON_TABLE,GPRS_QOS_MIN_ACCEPTABLE_MAX_SDU_SIZE);

	Notify()->ReadInt (columnName, reinterpret_cast<TUint32&>(aQos.iMinAcceptableMaxSDUSize));

	columnName.Format(KFormatText,QOS_UMTS_R99_AND_ON_TABLE,GPRS_QOS_REQ_MAX_UPLINK_RATE);

	Notify()->ReadInt (columnName, reinterpret_cast<TUint32&>(aQos.iReqMaxRate.iUplinkRate));