diff -r 000000000000 -r af10295192d8 networkcontrol/iptransportlayer/src/netmcpr.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/networkcontrol/iptransportlayer/src/netmcpr.cpp	Tue Jan 26 15:23:49 2010 +0200
@@ -0,0 +1,542 @@
+// 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:
+// This is part of an ECOM plug-in
+// 
+//
+
+#define SYMBIAN_NETWORKING_UPS
+
+#include "netmcpr.h"
+#include "netmcprstates.h"
+#include "netmcpractivities.h"
+#include "policyrequest.h"
+
+
+
+#include <comms-infras/ss_log.h>
+#include <comms-infras/ss_msgintercept.h>
+//#include <comms-infras/ss_roles.h>
+#include <ss_glob.h>
+#include <cs_subconparams.h>
+#include <networking/qos3gpp_subconparams.h>
+
+#ifdef SYMBIAN_ADAPTIVE_TCP_RECEIVE_WINDOW
+#include <tcpdfltrecvwin.h>
+#endif //SYMBIAN_ADAPTIVE_TCP_RECEIVE_WINDOW
+#include <commsdattypeinfov1_1_internal.h>
+
+#if defined __CFLOG_ACTIVE || defined SYMBIAN_TRACE_ENABLE
+#define KNetMCprTag KESockMetaConnectionTag
+_LIT8(KNetMCprSubTag, "netmcpr");
+#endif
+
+using namespace Messages;
+using namespace MeshMachine;
+using namespace ESock;
+using namespace NetStateMachine;
+using namespace MCprActivities;
+using namespace CommsDat;
+
+//
+// CNetworkMetaConnectionProvider
+
+#ifndef SYMBIAN_NETWORKING_UPS
+
+CNetworkMetaConnectionProvider* CNetworkMetaConnectionProvider::NewL(CMetaConnectionProviderFactoryBase& aFactory, const TProviderInfo& aProviderInfo)
+	{
+	__CFLOG_VAR((KNetMCprTag, KNetMCprSubTag, _L8("CNetworkMetaConnectionProvider:\tNewL()")));
+
+	CNetworkMetaConnectionProvider* self = new (ELeave) CNetworkMetaConnectionProvider(aFactory,aProviderInfo,NetMCprActivities::netMCprActivities::Self());
+	CleanupStack::PushL(self);
+	self->ConstructL();
+	CleanupStack::Pop(self);
+	return self;
+	}
+
+#endif
+
+CNetworkMetaConnectionProvider::CNetworkMetaConnectionProvider(CMetaConnectionProviderFactoryBase& aFactory, const TProviderInfo& aProviderInfo, const MeshMachine::TNodeActivityMap& aActivityMap)
+:	CMobilityMetaConnectionProvider(aFactory,aProviderInfo,aActivityMap)
+	{
+	LOG_NODE_CREATE(KNetMCprTag, CNetworkMetaConnectionProvider);
+	}
+
+void CNetworkMetaConnectionProvider::ConstructL()
+	{
+	CCoreMetaConnectionProvider::ConstructL();
+	
+#ifdef SYMBIAN_ADAPTIVE_TCP_RECEIVE_WINDOW
+	RMetaExtensionContainer mec;
+	mec.Open(iAccessPointConfig);
+	CleanupClosePushL(mec);
+	
+	//Append pointer to lookup table which holds the various TCP receive window sizes for different bearer types.
+	CTCPReceiveWindowSize* receiveWindow;
+	receiveWindow = new (ELeave)CDfltTCPReceiveWindowSize();
+	CleanupStack::PushL(receiveWindow);
+	mec.AppendExtensionL(receiveWindow);
+	CleanupStack::Pop(receiveWindow);
+	
+	//Append the pointer of CSAPSetOpt which provides generic SetOpt( ) implementation
+	CSAPSetOpt* protoOption = new (ELeave)CSAPSetOpt();
+	CleanupStack::PushL(protoOption);
+	mec.AppendExtensionL(protoOption);
+	CleanupStack::Pop(protoOption);
+
+	iAccessPointConfig.Close();
+	iAccessPointConfig.Open(mec);
+	CleanupStack::PopAndDestroy(&mec);
+#endif //SYMBIAN_ADAPTIVE_TCP_RECEIVE_WINDOW
+	}
+
+
+CNetworkMetaConnectionProvider::~CNetworkMetaConnectionProvider()
+	{
+	delete iPolicySelectorRecSet;
+	delete iDbSession;
+	LOG_NODE_DESTROY(KNetMCprTag, CNetworkMetaConnectionProvider);
+	}
+
+
+void CNetworkMetaConnectionProvider::ReceivedL(const TRuntimeCtxId& aSender, const TNodeId& aRecipient, TSignatureBase& aMessage)
+    {
+	__CFLOG_VAR((KNetMCprTag, KNetMCprSubTag, _L8("CNetworkMetaConnectionProvider %08x:\tReceivedL() aMessage=%d"),
+	   this, aMessage.MessageId().MessageId()));
+
+	ESOCK_DEBUG_MESSAGE_INTERCEPT(aSender, aMessage, aRecipient);
+
+	TNodeContext<CNetworkMetaConnectionProvider> ctx(*this, aMessage, aSender, aRecipient);
+    CMobilityMetaConnectionProvider::Received(ctx);
+    User::LeaveIfError(ctx.iReturn);
+	}
+
+void CNetworkMetaConnectionProvider::ProcessPolicyParamsL(const TRuntimeCtxId& aSender, TCFIPMessage::TPolicyParams& aPolicyParam)
+	{
+	// this is the best effort call. If db is not there then ignore it
+	TRAPD(err, InitDbL());
+	if(err == KErrNone)
+		{
+		RCFParameterFamilyBundleC paramBundle = CreateParameterBundleL(FindMatchingPolicyL(aPolicyParam));
+
+		// create worker node
+
+#ifndef __GCCXML__
+		RClientInterface::OpenPostMessageClose(Id(),
+			SockManGlobals::Get()->GetPlaneFC(TCFPlayerRole(TCFPlayerRole::ESubConnPlane)),
+			TCFConnPolicyRequest(paramBundle, aPolicyParam.iFlowId, aPolicyParam.iSrcNodeId, address_cast<TNodeId>(aSender)));
+#endif
+		}
+	}
+
+void CNetworkMetaConnectionProvider::InitDbL()
+	{
+	if(iDbSession == NULL)
+		{
+		iDbSession = CMDBSession::NewL(KCDVersion1_2);
+		}
+
+	if(iPolicySelectorRecSet == NULL)
+		{
+	    iPolicySelectorRecSet = new (ELeave) CMDBRecordSet<CCDPolicySelectorRecord>(KCDTIdPolicySelectorRecord);
+		iPolicySelectorRecSet->LoadL(*iDbSession);
+
+		if(iPolicySelectorRecSet->iRecords.Count() == 0)
+			{
+			User::Leave(KErrNotFound);
+			}
+		}
+	else
+		{
+		iPolicySelectorRecSet->RefreshL(*iDbSession);
+
+		if(iPolicySelectorRecSet->iRecords.Count() == 0)
+			{
+			User::Leave(KErrNotFound);
+			}
+		}
+	}
+
+TInt CNetworkMetaConnectionProvider::FindMatchingPolicyL(TCFIPMessage::TPolicyParams& aPolicyParam)
+	{
+	TBool found(EFalse);
+	TUint count(iPolicySelectorRecSet->iRecords.Count());
+
+	CCDPolicySelectorRecord* currentRec(NULL);
+
+	for(TInt i=0;i<count && !found;++i)
+		{
+		currentRec = static_cast<CCDPolicySelectorRecord*>(iPolicySelectorRecSet->iRecords[i]);
+
+		found = (CheckProtocol(aPolicyParam.iAddrUpdate.iProtocolId, currentRec)
+		    && CheckSrcPort(aPolicyParam.iAddrUpdate.iSrcSockAddr.Port(), currentRec)
+		    && CheckDstPort(aPolicyParam.iAddrUpdate.iDestSockAddr.Port(), currentRec)
+		    && CheckIap(aPolicyParam.iAddrUpdate.iIapId, currentRec)
+		    && CheckSrcAddressMatch(aPolicyParam.iAddrUpdate.iSrcSockAddr, currentRec)
+		    && CheckDstAddressMatch(aPolicyParam.iAddrUpdate.iDestSockAddr, currentRec)
+			&& CheckAppUid(aPolicyParam.iAppSid, currentRec));
+		}
+
+	if (!found)
+		{
+		__CFLOG_VAR((KNetMCprTag, KNetMCprSubTag, _L8("CNetworkMetaConnectionProvider::FindMatchingPolicyL not found")));
+		User::Leave(KErrNotFound);
+		}
+	else
+		{
+		__CFLOG_VAR((KNetMCprTag, KNetMCprSubTag, _L8("CNetworkMetaConnectionProvider::FindMatchingPolicyL found")));
+		return currentRec->iPolicyId;
+		}
+
+	// never executed
+	return 0;
+	}
+
+ESock::RCFParameterFamilyBundleC CNetworkMetaConnectionProvider::CreateParameterBundleL(TUint aPolicyId)
+	{
+	CMDBRecordSet<CCDPolicySelector2ParamsRecord>* iRecSet = new(ELeave) CMDBRecordSet<CCDPolicySelector2ParamsRecord>(KCDTIdPolicySelector2ParamsRecord);
+	CleanupStack::PushL(iRecSet);
+
+	// create new record
+	CCDPolicySelector2ParamsRecord* iRec = static_cast<CCDPolicySelector2ParamsRecord*>(CCDRecordBase::RecordFactoryL(KCDTIdPolicySelector2ParamsRecord));
+
+	// Prime record
+	iRec->iPolicySelectorId = aPolicyId;
+	// Append primed record to recordset
+	TInt err = iRecSet->iRecords.Append(iRec);
+	if(err != KErrNone)
+		{
+		delete iRec;
+		User::Leave(err);
+		}
+
+	TBool searchResult = iRecSet->FindL(*iDbSession);
+	if(!searchResult)
+		{
+		// Params not found
+		User::Leave(KErrNotFound);
+		}
+
+	TUint count = iRecSet->iRecords.Count();
+	err = KErrNotFound;
+
+	RCFParameterFamilyBundle tempBundle;
+	RCFParameterFamilyBundleC paramBundle;
+	if(count>0)
+		{
+		paramBundle.CreateL();
+		CleanupClosePushL(paramBundle);
+		tempBundle.CreateL();
+		CleanupClosePushL(tempBundle);
+
+
+		// create family
+		paramBundle.Open(tempBundle);
+		RParameterFamily family = tempBundle.CreateFamilyL(KSubConQoSFamily);
+		CleanupStack::Pop(/*tempBundle*/);
+		
+		//[401TODO]: Replace with fency code with uid's */
+		for (TUint i=0; i<count ; ++i)
+			{
+			// check if at least one param is filled in
+			if(FillInParamsL(static_cast<CCDPolicySelector2ParamsRecord*>(iRecSet->iRecords[i])->iParamsId, family) == KErrNone)
+				{
+				// found at least one param, it is not an error any more
+				err = KErrNone;
+				}
+			}
+		}
+
+	if(err != KErrNone)
+		{
+		CleanupStack::PopAndDestroy(/*paramBundle*/);
+		}
+	else
+		{
+		CleanupStack::Pop(/*paramBundle*/);
+		}
+
+	CleanupStack::PopAndDestroy(iRecSet);
+
+	return paramBundle;
+	}
+
+TInt CNetworkMetaConnectionProvider::FillInParamsL(TUint aParamId, RParameterFamily& aFamily)
+	{
+	TInt err(KErrGeneral);
+
+	switch(aParamId & KCDMaskShowRecordType)
+		{
+		case KCDTIdGenericQosRecord:
+			err = FillInGenericQosParamsL(aParamId, aFamily);
+				break;
+		case KCDTIdUmtsR99QoSAndOnTableRecord:
+			err = FillInUMTSParamsL(aParamId, aFamily);
+				break;
+		default: ;
+		}
+
+	return err;
+	}
+
+TInt CNetworkMetaConnectionProvider::FillInGenericQosParamsL(TUint aParamId, RParameterFamily& aFamily)
+	{
+	CCDGenericQosRecord *rec = static_cast<CCDGenericQosRecord*>(CCDRecordBase::RecordFactoryL(KCDTIdGenericQosRecord));
+	CleanupStack::PushL(rec);
+
+	rec->SetRecordId(aParamId & ~KCDMaskShowRecordType);
+	TRAPD(err, rec->LoadL(*iDbSession);)
+	if(err == KErrNone)
+		{
+	    CSubConQosGenericParamSet* param = CSubConQosGenericParamSet::NewL(aFamily,RParameterFamily::ERequested);
+
+		param->SetHeaderMode(rec->iHeaderMode);
+		param->SetDownlinkBandwidth(rec->iDownlinkBandwidth);
+		param->SetUplinkBandwidth(rec->iUplinkBandwidth);
+		param->SetDownLinkMaximumBurstSize(rec->iDownLinkMaximumBurstSize);
+		param->SetUpLinkMaximumBurstSize(rec->iUpLinkMaximumBurstSize);
+		param->SetDownLinkAveragePacketSize(rec->iDownLinkAveragePacketSize);
+		param->SetUpLinkAveragePacketSize(rec->iUpLinkAveragePacketSize);
+		param->SetDownLinkMaximumPacketSize(rec->iDownLinkMaximumPacketSize);
+		param->SetUpLinkMaximumPacketSize(rec->iUpLinkMaximumPacketSize);
+		param->SetDownLinkDelay(rec->iDownLinkDelay);
+		param->SetUpLinkDelay(rec->iUpLinkDelay);
+		param->SetDownLinkDelayVariation(rec->iDownLinkDelayVariation);
+		param->SetUpLinkDelayVariation(rec->iUpLinkDelayVariation);
+		param->SetDownLinkPriority(rec->iDownLinkPriority);
+		param->SetUpLinkPriority(rec->iUpLinkPriority);
+		}
+
+	CleanupStack::PopAndDestroy(rec);
+	return err;
+	}
+
+TInt CNetworkMetaConnectionProvider::FillInUMTSParamsL(TUint aParamId, RParameterFamily& aFamily)
+	{
+	CCDUmtsR99QoSAndOnTableRecord *rec = static_cast<CCDUmtsR99QoSAndOnTableRecord*>(CCDRecordBase::RecordFactoryL(KCDTIdUmtsR99QoSAndOnTableRecord));
+	CleanupStack::PushL(rec);
+
+	rec->SetRecordId(aParamId & ~KCDMaskShowRecordType);
+	TRAPD(err, rec->LoadL(*iDbSession);)
+	if(err == KErrNone)
+		{
+	    //Fill up the structures
+	    CSubConQosR5ParamSet* param = CSubConQosR5ParamSet::NewL(aFamily,RParameterFamily::ERequested);
+
+	    param->SetTrafficClass(rec->iGPRSReqTrafficClass);
+		param->SetDeliveryOrder(rec->iGPRSReqDeliveryOrder);
+		param->SetErroneousSDUDelivery(rec->iGPRSReqDeliverErroneousSDU);
+		param->SetResidualBitErrorRatio(rec->iGPRSReqBER);
+		param->SetSDUErrorRatio(rec->iGPRSReqSDUErrorRatio);
+		param->SetTrafficHandlingPriority(rec->iGPRSReqTrafficHandlingPriority);
+		param->SetTransferDelay(rec->iGPRSReqTransferDelay);
+		param->SetMaxSduSize(rec->iGPRSReqMaxSDUSize);
+		param->SetMaxBitrateUplink(rec->iGPRSReqMaxUplinkRate);
+		param->SetMaxBitrateDownlink(rec->iGPRSReqMaxDownlinkRate);
+		param->SetGuaBitrateUplink(rec->iGPRSReqGuaranteedUplinkRate);
+		param->SetGuaBitrateDownlink(rec->iGPRSReqGuaranteedDownlinkRate);
+		param->SetSignallingIndicator(rec->iGPRSSignallingIndication);
+		param->SetSourceStatisticsDescriptor(rec->iGPRSSourceStatisticsDescriptor);
+		}
+
+	CleanupStack::PopAndDestroy(rec);
+	return err;
+	}
+
+TBool CNetworkMetaConnectionProvider::CheckSrcAddressMatch(const TSockAddr& aFirst, CCDPolicySelectorRecord* aRecord)
+	{
+	if(aRecord && (!(aRecord->iSrcAddress.IsNull() || aRecord->iSrcMask.IsNull())))
+		{
+		TInetAddr first(aFirst);
+
+		TInetAddr second;
+		second.Input(aRecord->iSrcAddress);
+
+		TInetAddr mask;
+		mask.Input(aRecord->iSrcMask);
+
+		return first.Match(second, mask);
+		}
+
+	return ETrue;
+	}
+
+TBool CNetworkMetaConnectionProvider::CheckDstAddressMatch(const TSockAddr& aFirst, CCDPolicySelectorRecord* aRecord)
+	{
+	if(aRecord && (!(aRecord->iDstAddress.IsNull() || aRecord->iDstMask.IsNull())))
+		{
+		TInetAddr first(aFirst);
+
+		TInetAddr second;
+		second.Input(aRecord->iDstAddress);
+
+		TInetAddr mask;
+		mask.Input(aRecord->iDstMask);
+
+		return first.Match(second, mask);
+		}
+
+	return ETrue;
+	}
+
+TBool CNetworkMetaConnectionProvider::CheckProtocol(TUint aProtocolId, CCDPolicySelectorRecord* aRecord)
+	{
+	// compare protocolId
+	if(aRecord && !aRecord->iProtocolId.IsNull())
+		{
+		return aProtocolId == aRecord->iProtocolId;
+		}
+
+	return ETrue;
+	}
+
+
+TBool CNetworkMetaConnectionProvider::CheckSrcPort(TUint aPort, CCDPolicySelectorRecord* aRecord)
+	{
+	// match src port
+	if(aRecord && (!(aRecord->iSrcPort.IsNull() || aRecord->iSrcPortMax.IsNull())))
+		{
+		return (aPort >= aRecord->iSrcPort)  && (aPort <= aRecord->iSrcPortMax);
+		}
+
+	return ETrue;
+	}
+
+TBool CNetworkMetaConnectionProvider::CheckDstPort(TUint aPort, CCDPolicySelectorRecord* aRecord)
+	{
+	// match src port
+	if(aRecord && (!(aRecord->iDstPort.IsNull() || aRecord->iDstPortMax.IsNull())))
+		{
+		return (aPort >= aRecord->iDstPort)  && (aPort <= aRecord->iDstPortMax);
+		}
+
+	return ETrue;
+	}
+
+TBool CNetworkMetaConnectionProvider::CheckIap(TUint aIapId, CCDPolicySelectorRecord* aRecord)
+	{
+	// check IAP
+	if(aRecord && !aRecord->iIapId.IsNull())
+		{
+		return aIapId == aRecord->iIapId;
+		}
+
+	return ETrue;
+	}
+
+TBool CNetworkMetaConnectionProvider::CheckAppUid(TUid aAppUid, CCDPolicySelectorRecord* aRecord)
+	{
+	// check AppUid
+	if(aRecord && !aRecord->iAppUid.IsNull())
+		{
+		return aAppUid == aRecord->iAppUid;
+		}
+
+	return ETrue;
+	}
+
+#ifdef SYMBIAN_ADAPTIVE_TCP_RECEIVE_WINDOW
+
+CDfltTCPReceiveWindowSize::CDfltTCPReceiveWindowSize()
+                          :CTCPReceiveWindowSize() 	
+                      
+/**
+ *  Populate TCP window lookup table.
+ */
+	{
+	Init();
+	}
+
+void CDfltTCPReceiveWindowSize::Init()
+/**
+ * Initialize TCP receive window lookup table
+ */
+	{  		
+	//TCP receive window size for GPRS
+	iBearerInfoMap.Insert(KGprsBearer,KBearerGprsWinSize);
+
+	//TCP receive window size for EGPRS
+	iBearerInfoMap.Insert(KEGprsBearer,KBearerEdgeWinSize);
+
+	//TCP receive window size for UMTS
+	iBearerInfoMap.Insert(KUmtsBearer,KBearerUmtsWinSize);
+
+	//TCP receive window size for HSDPA
+	iBearerInfoMap.Insert(KHsdpaBearer,KBearerHsdpaWinSize);
+	
+   	//TCP receive window size for ethernet
+   	iBearerInfoMap.Insert(KEthernetBearer,KBearerEthernetWinSize);
+
+   	//TCP receive window size for other bearer
+   	iBearerInfoMap.Insert(KDefaultBearer,KBearerWlanWinSize);
+	}
+
+void CDfltTCPReceiveWindowSize::SetTcpWin(TUint aBearerType)
+/**
+ * Set TCP receive window 
+ */
+	{
+	//Set the TCP Receive Window.
+	iWinSize = *static_cast<TUint*>(iBearerInfoMap.Find(aBearerType));
+	  
+	//Set the Max TCP receive Window.
+	SetMaxWinSize(aBearerType);
+	}
+	
+
+void CDfltTCPReceiveWindowSize::SetMaxWinSize(TUint aBearerType)
+/**
+ * Set Max TCP receive Window.
+ * @Param Bearer type
+ */
+	{
+	switch(aBearerType)
+		{
+		case KGprsBearer:
+		case KEGprsBearer:
+		case KUmtsBearer:
+		case KHsdpaBearer:
+		//
+		// TCP receive window size will be maximum for HSDPA bearers.
+		//
+			iMaxWinSize = KBearerHsdpaWinSize; 
+			break; 
+		case KEthernetBearer:
+			iMaxWinSize = KEthernetMaxWinSize;
+			break;
+   
+		default:
+			iMaxWinSize = KEthernetMaxWinSize;
+			break;
+		}
+	}
+
+
+CDfltTCPReceiveWindowSize::~CDfltTCPReceiveWindowSize()
+/**
+ * Close TCP receive window lookup table
+ */
+	{
+	iBearerInfoMap.Close();
+	}
+	
+/**
+ * Register the variables of TCP receive window class,
+ * since it derives from SMetaData class
+ */
+START_ATTRIBUTE_TABLE(CTCPReceiveWindowSize,CTCPReceiveWindowSize::ERealmId, CTCPReceiveWindowSize::iId)
+  REGISTER_ATTRIBUTE(CTCPReceiveWindowSize, iMaxWinSize, TMetaNumber)
+  REGISTER_ATTRIBUTE(CTCPReceiveWindowSize, iWinSize, TMetaNumber)
+END_ATTRIBUTE_TABLE()
+
+#endif //SYMBIAN_ADAPTIVE_TCP_RECEIVE_WINDOW