diff -r 000000000000 -r af10295192d8 networkcontrol/ipnetworklayer/src/IPProtoMCpr.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/networkcontrol/ipnetworklayer/src/IPProtoMCpr.cpp Tue Jan 26 15:23:49 2010 +0200 @@ -0,0 +1,221 @@ +// 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: +// IPProto MCPR +// +// + +/** + @file + @internalComponent +*/ + + +#include +//#include +#include +#include +#include +#include // CommsDat +#include //TierManagerUtils +#include +#include +#include "IPProtoMCpr.h" +#include "idletimer.h" + + +#if defined __CFLOG_ACTIVE || defined SYMBIAN_TRACE_ENABLE +#define KIPProtoMCprTag KESockMetaConnectionTag +_LIT8(KIPProtoMCprSubTag, "ipprotomcpr"); +#endif + +#include + +using namespace Messages; +using namespace MeshMachine; +using namespace ESock; +using namespace NetStateMachine; +using namespace CommsDat; +using namespace MCprActivities; + +// +//CIPProtoMetaConnectionProvider +CIPProtoMetaConnectionProvider* CIPProtoMetaConnectionProvider::NewL(CMetaConnectionProviderFactoryBase& aFactory, + const TProviderInfo& aProviderInfo) + { + CIPProtoMetaConnectionProvider* self = new (ELeave) CIPProtoMetaConnectionProvider(aFactory,aProviderInfo,IPProtoMCprActivities::ipProtoActivitiesMCpr::Self()); + CleanupStack::PushL(self); + self->ConstructL(); + CleanupStack::Pop(self); + return self; + } + +CIPProtoMetaConnectionProvider::CIPProtoMetaConnectionProvider(CMetaConnectionProviderFactoryBase& aFactory, + const TProviderInfo& aProviderInfo, + const MeshMachine::TNodeActivityMap& aActivityMap) + : CCoreMetaConnectionProvider(aFactory,aProviderInfo,aActivityMap), iIapLocked(EFalse) + { + LOG_NODE_CREATE(KIPProtoMCprTag, CIPProtoMetaConnectionProvider); + } + +CIPProtoMetaConnectionProvider::~CIPProtoMetaConnectionProvider() + { + LOG_NODE_DESTROY(KIPProtoMCprTag, CIPProtoMetaConnectionProvider); + } + + +void CIPProtoMetaConnectionProvider::ReceivedL(const TRuntimeCtxId& aSender, const TNodeId& aRecipient, TSignatureBase& aMessage) + { + __CFLOG_VAR((KIPProtoMCprTag, KIPProtoMCprSubTag, _L8("CIPProtoMetaConnectionProvider %08x:\tReceived() aCFMessage=%d"), + this, aMessage.MessageId().MessageId())); + + ESOCK_DEBUG_MESSAGE_INTERCEPT(aSender, aMessage, aRecipient); + + TNodeContext ctx(*this, aMessage, aSender, aRecipient); + CCoreMetaConnectionProvider::Received(ctx); + + User::LeaveIfError(ctx.iReturn); + } + +void CIPProtoMetaConnectionProvider::ConstructL() + { + CMetaConnectionProviderBase::ConstructL(); //This initialises the AccessPointInfo + + //For construction of IpProto providers (construction only) we use the instance field of TProviderInfo + //to carry the IAP id. The IAP id is necessary for the initialisation if IpProto specific data. + TInt iap = (TInt)ProviderInfo().Instance(); + SetProviderInfo(TProviderInfo(ProviderInfo().TierId(),iap)); + SetConfigL(); + } + +void CIPProtoMetaConnectionProvider::SetConfigL() +/** +Setup the provisioning information for the IPProto layer. +*/ + { + RMetaExtensionContainer mec; + mec.Open(AccessPointConfig()); + CleanupClosePushL(mec); + + //At this moment our ProviderInfo().APId() points to the IAP this provider represents + TUint configurationIap = ProviderInfo().APId(); + CCommsDatIapView* iapView = CCommsDatIapView::NewLC(configurationIap); + + // Read Idle timer values + TIdleTimerValues* timerValues = new (ELeave) TIdleTimerValues; + CleanupStack::PushL(timerValues); + iapView->GetTimeoutValuesL(timerValues->iShortTimer, timerValues->iMediumTimer, timerValues->iLongTimer); + mec.AppendExtensionL(timerValues); //iAccessPointConfig owns timerValues from now on + CleanupStack::Pop(timerValues); + + // Read NetworkId + TUint32 net = 0; + iapView->GetIntL(KCDTIdIAPNetwork, net); + + // Read Protocol list (from IfNetworks field). This contains a comma seperated list of + // protocol names and determines the binders instantiated in the lower CFProtocol (typically + // "ip" or "ip,ip6"). + + HBufC* protocolList = NULL; + + if (iapView->GetServiceTableType() == KCDTIdVPNServiceRecord) + { + // *** HACK *** + // Normally, the IfNetworks field is read via the Agent ReadDes() methods. This + // allow, for example, the VPNConnAgt to fake up the IfNetworks field to "ip" when, + // in fact, it does not exist in the CommsDat. We should somehow be arranging for the + // provisioning of this field to be from the underlying Agent, but the Agent is + // only accessible from the Agent Adapter in the AgentSCPr layer. Perhaps the + // IPProtoSCPr can do the provisioning of the IfNetworks field, but it would need + // to get the contents of the field from the AgentSCPr below it. + _LIT(KVPNIfNetworks, "ip"); + protocolList = HBufC::NewMaxL(4); + *protocolList = KVPNIfNetworks(); + } + else + { + iapView->GetTableCommonTextFieldL(CCommsDatIapView::EIfNetworks, protocolList); + } + + + HBufC* configdaemonmanager = NULL; + TRAPD(err, iapView->GetTableCommonTextFieldL(ESock::CCommsDatIapView::EConfigDaemonManagerName, + configdaemonmanager)); + if ((err == KErrNone) && (*configdaemonmanager != KNullDesC)) + { + CleanupStack::PushL(configdaemonmanager); + CNetCfgExtProvision* netcfg = CNetCfgExtProvision::NewL(); + CleanupStack::PushL(netcfg); + netcfg->InitialiseConfigL(iapView); + mec.AppendExtensionL(netcfg); + CleanupStack::Pop(netcfg); + CleanupStack::PopAndDestroy(configdaemonmanager); + } + + CleanupStack::PopAndDestroy(iapView); + CleanupStack::PushL(protocolList); + + TItfInfoConfigExt* itfInfoConfig = new (ELeave) TItfInfoConfigExt(TConnectionInfo(configurationIap,net)); + CleanupStack::PushL(itfInfoConfig); + + if (itfInfoConfig->iProtocolList.MaxSize() >= protocolList->Size()) + { + itfInfoConfig->iProtocolList.Copy(*protocolList); + } + else + { + User::Leave(KErrOverflow); + } + + mec.AppendExtensionL(itfInfoConfig); + CleanupStack::Pop(itfInfoConfig); + CleanupStack::PopAndDestroy(protocolList); + + XInterfaceNames* itfNames = XInterfaceNames::NewL(); + CleanupStack::PushL(itfNames); + mec.AppendExtensionL(itfNames); + CleanupStack::Pop(itfNames); + + iAccessPointConfig.Close(); + iAccessPointConfig.Open(mec); + CleanupStack::PopAndDestroy(&mec); + } + +namespace IPProtoMCprSelectConnPrefListActivity +{ +DECLARE_DEFINE_CUSTOM_NODEACTIVITY(ECFActivitySelect, IPProtoMCprSelectConnPrefList, TCFSelector::TSelect, CSelectNextLayerActivity::NewL) + //Reply from TAwaitingSelectNextLayer if no choices, otherwise accept + FIRST_NODEACTIVITY_ENTRY(MCprStates::TAwaitingSelectNextLayerSuper, MeshMachine::TNoTag) + THROUGH_NODEACTIVITY_ENTRY(KNoTag, CSelectNextLayerActivity::TProcessSimpleSelectionPolicySuper, MCprStates::TSelectedProvider) + //Start the selection main loop + NODEACTIVITY_ENTRY(MCprStates::KSelectedProvider, CSelectNextLayerActivity::TFindOrCreateTierManagerSuper, MCprStates::TAwaitingTierManagerCreated, MeshMachine::TNoTag) + NODEACTIVITY_ENTRY(KNoTag, CSelectNextLayerActivity::TJoinTierManager, CoreStates::TAwaitingJoinComplete, MeshMachine::TNoTag) + //Select next provider and enter the selection internal loop if provider received. Break if SelectComplete(NULL). + NODEACTIVITY_ENTRY(KNoTag, CSelectNextLayerActivity::TSelectNextLayerSuper, MCprStates::TAwaitingSelectComplete, CSelectNextLayerActivity::TNoTagOrSelectedProviderIsNull) + NODEACTIVITY_ENTRY(KNoTag, CSelectNextLayerActivity::TAddProviderInfo, MCprStates::TAwaitingSelectComplete, CSelectNextLayerActivity::TNoTagBackwardsOrJoinServiceProvider) + //Break the selection internal loop if SelectComplete(NULL), otherwise stay in this tripple + NODEACTIVITY_ENTRY(MCprStates::KJoinServiceProvider, CSelectNextLayerActivity::TJoinServiceProvider, CoreStates::TAwaitingJoinComplete, MeshMachine::TNoTag) + THROUGH_NODEACTIVITY_ENTRY(KNoTag, CSelectNextLayerActivity::TSendSelectComplete, CSelectNextLayerActivity::TSelectedProviderIsNullOrJoinServiceProviderBackward) + //Break the selection main loop if no more choices, otherwise go back again + THROUGH_NODEACTIVITY_ENTRY(MCprStates::KSelectedProviderIsNull, CSelectNextLayerActivity::TLeaveTierManager, CSelectNextLayerActivity::TNoTagOrSelectedProviderBackwardSuper) + //Finish the activity + LAST_NODEACTIVITY_ENTRY(KNoTag, MCprStates::TSendFinalSelectComplete) +NODEACTIVITY_END() +} + +namespace IPProtoMCprActivities +{ +DEFINE_ACTIVITY_MAP(ipProtoActivitiesMCpr) + ACTIVITY_MAP_ENTRY(IPProtoMCprSelectConnPrefListActivity, IPProtoMCprSelectConnPrefList) +ACTIVITY_MAP_END_BASE(MCprActivities, coreMCprActivities) +}