// 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:

// Ethernet MCPR

// 

//

/**

 @file

 @internalComponent

*/

#include <comms-infras/ss_log.h>

#include <comms-infras/agentmcpractivities.h>

#include <comms-infras/coremcpractivities.h>

#include <comms-infras/ss_tiermanagerutils.h>

#include <comms-infras/ss_msgintercept.h>

#include "ethmcpr.h"

#include "EthProvision.h"

#define KEthMCprTag KESockMetaConnectionTag

using namespace Messages;

using namespace MeshMachine;

using namespace ESock;

using namespace NetStateMachine;

using namespace MCprActivities;

using namespace EthMCprStates;

// No Bearer Activity

namespace EthMCPRNoBearerActivity

{

DECLARE_DEFINE_NODEACTIVITY(ECFActivityNoBearer, EthMCPRNoBearer, TCFControlProvider::TNoBearer)

	FIRST_NODEACTIVITY_ENTRY(CoreNetStates::TAwaitingNoBearer, MeshMachine::TNoTag)

	LAST_NODEACTIVITY_ENTRY(KNoTag, CoreNetStates::TSendBearer)

NODEACTIVITY_END()

}

// Activity Map

namespace EthMCprStates

{

DEFINE_EXPORT_ACTIVITY_MAP(stateMap)

	ACTIVITY_MAP_ENTRY(EthMCPRNoBearerActivity, EthMCPRNoBearer)

ACTIVITY_MAP_END_BASE(AgentMCprActivities, agentMCprActivities)

} // namespace EthMCprStates

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

//

//CEthMetaConnectionProvider implementation

//

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

EXPORT_C CEthMetaConnectionProvider* CEthMetaConnectionProvider::NewL(ESock::CMetaConnectionProviderFactoryBase& aFactory, const TProviderInfo& aProviderInfo)

    {

    // coverity[alloc_fn] coverity[alias] coverity[assign]

    CEthMetaConnectionProvider* self = new (ELeave) CEthMetaConnectionProvider(aFactory, aProviderInfo, EthMCprStates::stateMap::Self());

    // coverity[push]

    CleanupStack::PushL(self);

    // coverity[alias] coverity[double_push]

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

EXPORT_C void CEthMetaConnectionProvider::ConstructL()

	{

	CAgentMetaConnectionProvider::ConstructL();

	SetAccessPointConfigFromDbL();

	}

EXPORT_C CEthMetaConnectionProvider::CEthMetaConnectionProvider(CMetaConnectionProviderFactoryBase& aFactory,

    							     const ESock::TProviderInfo& aProviderInfo,

								     const MeshMachine::TNodeActivityMap& aActivityMap)

:	CAgentMetaConnectionProvider(aFactory,aProviderInfo,aActivityMap)

	{

	LOG_NODE_CREATE(KEthMCprTag, CEthMetaConnectionProvider);

	}

EXPORT_C  CEthMetaConnectionProvider::~CEthMetaConnectionProvider()

	{

	LOG_NODE_DESTROY(KEthMCprTag, CEthMetaConnectionProvider);

	}

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

    {

	__CFLOG_VAR((KEthMCprTag, KEthMCprSubTag, _L8("CEthMetaConnectionProvider [this=%08x]::ReceivedL() aCFMessage=%d"),

	   this, aCFMessage.MessageId().MessageId()));

	ESOCK_DEBUG_MESSAGE_INTERCEPT(aSender, aMessage, aRecipient);

	TNodeContext<CEthMetaConnectionProvider> ctx(*this, aMessage, aSender, aRecipient);

    CCoreMetaConnectionProvider::Received(ctx);

    User::LeaveIfError(ctx.iReturn);

	}

void CEthMetaConnectionProvider::SetAccessPointConfigFromDbL()

    {

	__CFLOG_VAR((KEthMCprFactoryTag, KEthMCprFactorySubTag, _L8("CEthMetaConnectionProvider %08x:\tSetAccessPointConfigFromDbL()"), this));

    RMetaExtensionContainer mec;

    mec.Open(AccessPointConfig());

    CleanupClosePushL(mec);

	// Open an IAP specific view on CommsDat

	CCommsDatIapView* iapView = OpenIapViewLC();

	// Presumptions:

	// - none of the extensions can already exist in the AccessPointConfig array.  AppendExtensionL()

	//   is presumed to panic if adding the same extension a second time.

	// - if we have added several extensions to the AccessPointConfig array before getting a failure

	//   and leaving, it is presumed that the MCPr will be destroyed and AccessPointConfig destructor

	//   will clean up the extensions immediately afterwards.

    ProvisionLinkConfigL(iapView, mec);

    ProvisionNetworkConfigL(iapView, mec);

	CleanupStack::PopAndDestroy(); // CloseIapView();

	AccessPointConfig().Close();

	AccessPointConfig().Open(mec);

    CleanupStack::PopAndDestroy(&mec);

	}

void CEthMetaConnectionProvider::ProvisionLinkConfigL(CCommsDatIapView* aIapView, ESock::RMetaExtensionContainer& aMec)

    {

	TLanLinkProvision* linkProvision = new (ELeave) TLanLinkProvision;

	CleanupStack::PushL(linkProvision);

	// Initialise the link config

	// NOTE:

	// All the LANBearer strings are read as 16-bit values and copied into the

	// 8-bit buffers in the provisioning structure to save memory

	HBufC* buf = NULL;

	TInt err(KErrNone);

	// Config Daemon Name

	err = aIapView->GetText(KCDTIdLANConfigDaemonName, buf);

	if (err == KErrNone  && buf != NULL) 

	    {

    	linkProvision->SetConfigDaemonName(*buf);

    	delete buf;

    	buf= NULL;

	    }

	else if (err == KErrNotFound)

	    {

	    linkProvision->SetConfigDaemonName (KNullDesC);

	    }

	else

	    {

	    User::Leave(err);

	    }

	// LDD Filename

	err = aIapView->GetText(KCDTIdLANBearerLddFilename, buf);

	if (err == KErrNone && buf != NULL) 

	    {

    	linkProvision->SetLddFilename(*buf);

    	delete buf;

    	buf= NULL;

	    }

	else if (err == KErrNotFound)

	    {

	    linkProvision->SetLddFilename (KNullDesC);

	    }

	else

	    {

	    User::Leave(err);

	    }

	// LDD Name

	err = aIapView->GetText(KCDTIdLANBearerLddName, buf);

	if (err == KErrNone && buf != NULL) 

	    {

    	linkProvision->SetLddName(*buf);

    	delete buf;

    	buf= NULL;

	    }

	else if (err == KErrNotFound)

	    {

	    linkProvision->SetLddName (KNullDesC);

	    }

	else

	    {

	    User::Leave(err);

	    }

	// PDD Filename

	err = aIapView->GetText(KCDTIdLANBearerPddFilename, buf);

	if (err == KErrNone && buf != NULL) 

	    {

    	linkProvision->SetPddFilename(*buf);

    	delete buf;

    	buf= NULL;

	    }

	else if (err == KErrNotFound)

	    {

	    linkProvision->SetPddFilename (KNullDesC);

	    }

	else

	    {

	    User::Leave(err);

	    }

	// PDD Name

	err = aIapView->GetText(KCDTIdLANBearerPddName, buf);

	if (err == KErrNone && buf != NULL) 

	    {

    	linkProvision->SetPddName(*buf);

    	delete buf;

    	buf= NULL;

	    }

	else if (err == KErrNotFound)

	    {

	    linkProvision->SetPddName (KNullDesC);

	    }

	else

	    {

	    User::Leave(err);

	    }

	// Packet Driver Name - required info, always error

	aIapView->GetTextL(KCDTIdLANBearerPacketDriverName, buf);

	linkProvision->SetPacketDriverName(*buf);

 	delete buf;

	// Append the provisioning object to the CAccessPointConfig array

 	aMec.AppendExtensionL(linkProvision);

	CleanupStack::Pop(linkProvision);

    }

void CEthMetaConnectionProvider::ProvisionNetworkConfigL(CCommsDatIapView* aIapView, ESock::RMetaExtensionContainer& aMec)

    {

	HBufC* buf = NULL;

    aIapView->GetTextL(KCDTIdLANIfNetworks, buf);

    CleanupStack::PushL(buf);

    if (buf->Length() == 0)

        {

        User::Leave(KErrCorrupt);

        }

    TPtrC16 networks;

    networks.Set(*buf);

    TPtrC16 current;

    TUint32 order = 0;

    TInt commaPos = 0;

    while (commaPos != KErrNotFound)

        {

        commaPos = networks.LocateF(',');

        if (commaPos == KErrNotFound)

            {

            // take all of string

            current.Set(networks);

            }

        else

            {

            current.Set(networks.Ptr(), commaPos);

            }

        if (!current.CompareF(_L("ip")))

            {

            ProvisionIp4ConfigL(aIapView, order, aMec);

            }

        else if (!current.CompareF(_L("ip6")))

            {

            ProvisionIp6ConfigL(aIapView, order, aMec);

            }

        else

            {

            User::Leave(KErrCorrupt);

            }

        order++;

        networks.Set(networks.Mid(commaPos+1));

        }

    CleanupStack::PopAndDestroy(buf);

    }

void CEthMetaConnectionProvider::ProvisionIp4ConfigL(CCommsDatIapView* aIapView, TUint32 aOrder, ESock::RMetaExtensionContainer& aMec)

    {

	TLanIp4Provision* ip4Provision = new (ELeave) TLanIp4Provision;

	CleanupStack::PushL(ip4Provision);

	ip4Provision->SetOrder(aOrder);

	// Read IP address configuration parameters

	TBool serverRequired;

	aIapView->GetBoolL(KCDTIdLANIpAddrFromServer, serverRequired);

	TUint32 addr;

	TInt err;

	ip4Provision->SetLocalAddr(KInetAddrNone);

	ip4Provision->SetNetMask(KInetAddrNone);

	ip4Provision->SetDefGateway(KInetAddrNone);

	if (!serverRequired)

		{

		GetIp4AddrL(aIapView, KCDTIdLANIpAddr, addr);

  		ip4Provision->SetLocalAddr(addr);

		err = GetIp4Addr(aIapView, KCDTIdLANIpNetMask, addr);

		if (err == KErrNone)

			{

			ip4Provision->SetNetMask(addr);

			}

		err = GetIp4Addr(aIapView, KCDTIdLANIpGateway, addr);

		if (err == KErrNone)

		    {

		    ip4Provision->SetDefGateway(addr);

		    }

		else if (err == KErrNotFound || err == KErrArgument)

		    {

		    ip4Provision->SetDefGateway(ip4Provision->LocalAddr());

		    }

		else

		    {

		    User::Leave(err);

		    }

		// Because CommDB doesn't define a Broadcast Address field, we must

		// calculate the broadcast address. This is based on the localAddr

		// and the netMask.

		TInetAddr localAddr(ip4Provision->LocalAddr(), 0);

		TInetAddr netMask(ip4Provision->NetMask(), 0);

		TInetAddr broadcast;

		broadcast.SubNetBroadcast(ip4Provision->LocalAddr(), ip4Provision->NetMask());

		ip4Provision->SetBroadcastAddr(broadcast.Address());

   		}

	ip4Provision->SetPrimaryDns(KInetAddrNone);

	ip4Provision->SetSecondaryDns(KInetAddrNone);

	aIapView->GetBoolL(KCDTIdLANIpDNSAddrFromServer, serverRequired);

  	if (!serverRequired)

  		{

  		err = GetIp4Addr(aIapView, KCDTIdLANIpNameServer1, addr);

  		if (err == KErrNone)

  		    {

  		    ip4Provision->SetPrimaryDns(addr);

		    err = GetIp4Addr(aIapView, KCDTIdLANIpNameServer2, addr);

		    if (err == KErrNone)

		        {

		        ip4Provision->SetSecondaryDns(addr);

		        }

  		    }

  		if (err != KErrNone && err != KErrNotFound && err != KErrArgument)

  		    {

  		    User::Leave(err);

  		    }

     	}

	// Append the provisioning object to the CAccessPointConfig array

  	aMec.AppendExtensionL(ip4Provision);

	CleanupStack::Pop(ip4Provision);

    }

void CEthMetaConnectionProvider::ProvisionIp6ConfigL(CCommsDatIapView* aIapView, TUint32 aOrder, ESock::RMetaExtensionContainer& aMec)

    {

	TLanIp6Provision* ip6Provision = new (ELeave) TLanIp6Provision;

	CleanupStack::PushL(ip6Provision);

	ip6Provision->SetOrder(aOrder);

	// Determine whether static DNS configuration is required.

	TBool dynamicDns = ETrue;

	// By default, Ensure that static DNS addresses are set as unspecified,

	// so they are not used in Control(KSoIfConfig).

	ip6Provision->SetPrimaryDns(KInet6AddrNone);

	ip6Provision->SetSecondaryDns(KInet6AddrNone);

	// Ignore any errors from reading this field - default to dynamicDns = ETrue

	(void) aIapView->GetBool(KCDTIdLANIp6DNSAddrFromServer, dynamicDns);

	if (!dynamicDns)

		{

		// Read static DNS addresses

		TInt err;

		TIp6Addr addr6;

  		err = GetIp6Addr(aIapView, KCDTIdLANIp6NameServer1, addr6);

  		if (err == KErrNone)

  		    {

  		    ip6Provision->SetPrimaryDns(addr6);

		    err = GetIp6Addr(aIapView, KCDTIdLANIp6NameServer2, addr6);

		    if (err == KErrNone)

		        {

		        ip6Provision->SetSecondaryDns(addr6);

		        }

  		    }

  		if (err != KErrNone && err != KErrNotFound && err != KErrArgument)

  		    {

  		    User::Leave(err);

  		    }

		}

	// Append the provisioning object to the CAccessPointConfig array

	aMec.AppendExtensionL(ip6Provision);

	CleanupStack::Pop(ip6Provision);

    }