diff -r 000000000000 -r dfb7c4ff071f datacommsserver/esockserver/ssock/ss_subconnprov.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/datacommsserver/esockserver/ssock/ss_subconnprov.cpp	Thu Dec 17 09:22:25 2009 +0200
@@ -0,0 +1,232 @@
+    // 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:
+//
+
+/**
+ @file SS_SUBCONNPROV.CPP
+*/
+#include "ss_subconnprov.h"
+
+
+#include <ss_std.h>
+#include <cs_subconevents.h>
+#include <comms-infras/ss_mcprnodemessages.h>
+#include <comms-infras/ss_log.h>
+#include <es_ini.h>
+#include <comms-infras/ss_connprov.h>
+#include <ss_glob.h>
+#include <comms-infras/ss_subconnflow.h>
+
+#include <comms-infras/ss_nodemessages_subconn.h>
+#include <comms-infras/ss_nodemessages_factory.h>
+
+#include <elements/nm_signatures.h>
+#include <comms-infras/ss_nodemessages_legacy.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_ESockSSocksbcnpr, "ESockSSocksbcnpr");
+#endif
+
+using namespace ESock;
+using namespace Messages;
+using namespace MeshMachine;
+using namespace Factories;
+
+
+EXPORT_C CSubConnectionFactoryContainer* CSubConnectionFactoryContainer::NewL()
+/** Create a new instance of a sub-connection factory container
+
+@exception Leaves in out of memory conditions
+@return Pointer to new instance of a sub-connection factory container
+*/
+	{
+	TCFLegacyMessage::RegisterL();
+	return new (ELeave) CSubConnectionFactoryContainer();
+	}
+
+void CSubConnectionFactoryContainer::ReceivedL(const TRuntimeCtxId& aSender, const TNodeId& /* aRecipient */, TSignatureBase& aMessage)
+	{
+	if (aMessage.IsMessage<TCFFactory::TFindOrCreatePeer>())
+		{
+		TCFFactory::TFindOrCreatePeer& msg = message_cast<TCFFactory::TFindOrCreatePeer>(aMessage);
+		CCommsFactoryBase* factory = static_cast<CCommsFactoryBase*>(FindOrCreateFactoryL(msg.iUid));
+	    CSubConnectionProviderBase* provider = static_cast<CSubConnectionProviderBase*>(factory->FindOrCreateObjectL(*(msg.iQuery)));
+	    if (provider)
+	    	{
+     	    CleanupStack::PushL(provider);
+	    	// Second parameters is the Flags to be used for this Node:
+	    	//	check if a "Default DataClient" was requested
+	    	//	and set Flags accordingly     	    
+	    	const TDefaultSCPRFactoryQuery& query = static_cast<const TDefaultSCPRFactoryQuery&>(*(msg.iQuery));
+	    	TCFClientType::TFlags flags = ((TSubConnOpen::TSubConnType)query.iSCPRType == TSubConnOpen::EAttachToDefault) ? 
+	    					      TCFClientType::EDefault : (TCFClientType::TFlags) 0;
+ 		    provider->AddClientL(address_cast<TNodeId>(aSender), TClientType(TCFClientType::ECtrlProvider, flags));
+ 	#ifndef __GCCXML__
+ 		    RClientInterface::OpenPostMessageClose(Id(), aSender, TCFFactory::TPeerFoundOrCreated(provider->Id(), flags).CRef());
+ 	#endif
+     	    CleanupStack::Pop(provider);
+	    	}
+	    else
+            {
+			RClientInterface::OpenPostMessageClose(Id(), aSender, TCFFactory::TPeerFoundOrCreated(TNodeId::NullId(), 0).CRef());
+            }
+		aMessage.ClearMessageId();
+		}
+	else
+		{
+		NM_LOG_START_BLOCK(KESockSubConnectionTag, _L8("CSubConnectionFactoryContainer:ReceivedL"));
+		NM_LOG((KESockSubConnectionTag, _L8("ERROR: KErrNotSupported [this=0x%08x] "), this));
+		NM_LOG_MESSAGE(KESockSubConnectionTag, aMessage);
+		NM_LOG_END_BLOCK(KESockSubConnectionTag, _L8("CSubConnectionFactoryContainer:ReceivedL"));
+
+		__ASSERT_DEBUG(EFalse, User::Panic(KSpecAssert_ESockSSocksbcnpr, 1)); //For debug configurations
+		User::Leave(KErrNotSupported); //For release configurations
+		}
+	}
+
+
+CSubConnectionFactoryContainer::~CSubConnectionFactoryContainer()
+/** Empty Sub-connection factory container destructor */
+	{
+	TCFLegacyMessage::DeRegister();
+	LOG_NODE_DESTROY(KESockSubConnectionTag, CSubConnectionFactoryContainer);
+	}
+
+CSubConnectionFactoryContainer::CSubConnectionFactoryContainer()
+:CCommsFactoryContainer((CCommsFactoryContainer::TContaineeType)CSubConnectionFactoryContainer::EId)
+/** Empty Sub-connection factory container constructor */
+	{
+	LOG_NODE_CREATE(KESockSubConnectionTag, CSubConnectionFactoryContainer);
+	}
+
+CSubConnectionProviderFactoryBase* CSubConnectionFactoryContainer::Factory( TInt aIndex ) const
+	{
+	return static_cast<CSubConnectionProviderFactoryBase*>(CCommsFactoryContainer::Factory(aIndex));
+	}
+
+//==========================================================
+
+EXPORT_C CSubConnectionProviderFactoryBase::~CSubConnectionProviderFactoryBase()
+/** Empty Sub-connection factory base destructor */
+	{
+	}
+
+EXPORT_C CSubConnectionProviderFactoryBase::CSubConnectionProviderFactoryBase(TUid aFactoryId, CSubConnectionFactoryContainer& aParentContainer)
+/** Sub-connection provider factory constructor
+
+@param aFactoryId Unique Integer Identifier of the sub-connection provider factory
+@param aParentContainer Container to add the factory to */
+	: CCommsFactoryBase(aFactoryId, aParentContainer)
+	{
+	}
+
+EXPORT_C ACommsFactoryNodeId* CSubConnectionProviderFactoryBase::DoFindOrCreateObjectL(TFactoryQueryBase& aQuery)
+/** Default implementation of the Find or Create functionality
+
+@param aQuery The match/creation criteria for the sub-connection to be returned
+@return The sub-connection provider found or created
+@exception KErrNoMemory in out of memeory conditions, other system errors based on the specialised factory */
+	{
+	ACommsFactoryNodeId* subConnProvider = static_cast<ACommsFactoryNodeId*>(FindObject(aQuery));
+	if (!subConnProvider)
+		{
+		const TDefaultSCPRFactoryQuery& query = static_cast<const TDefaultSCPRFactoryQuery&>(aQuery);
+		__ASSERT_DEBUG(!query.iControlProvider.IsNull(), User::Panic(KSpecAssert_ESockSSocksbcnpr, 2));
+		subConnProvider = CreateL(aQuery);
+		}
+	return subConnProvider;
+	}
+
+EXPORT_C ACommsFactoryNodeId* CSubConnectionProviderFactoryBase::DoCreateObjectL(TFactoryQueryBase& /*aQuery*/)
+	{
+	__ASSERT_DEBUG(EFalse, User::Panic(KSpecAssert_ESockSSocksbcnpr, 3));
+	User::Leave(KErrNotSupported);
+	return NULL;
+	}
+
+EXPORT_C ACommsFactoryNodeId* CSubConnectionProviderFactoryBase::CreateL(TFactoryQueryBase& aQuery)
+/** Create an instance of a sub-connection provider
+
+@param aConnectionProviderBase The connection provider for the sub-connection
+@param aSubConnType The sub-connection type to create, e.g. attach to default or create a new one
+@return The new sub-connection provider created
+@exception KErrNoMemory in out of memeory conditions, other system errors based on the specialised factory */
+	{
+	CSubConnectionProviderBase* provider = static_cast<CSubConnectionProviderBase*>(DoCreateObjectL(aQuery));
+	CleanupStack::PushL(provider);
+
+	const TDefaultSCPRFactoryQuery& query = static_cast<const TDefaultSCPRFactoryQuery&>(aQuery);	
+
+	TFactoryObjectEntry& entry = AddManagedObjectL(*provider);
+	entry.iFlag |= query.iSCPRType;
+
+	CleanupStack::Pop(provider);
+
+	return provider;
+	}
+
+//=============================================================================
+// Downcalls from control client (Implemented via pure virtual methods below)
+//=============================================================================
+
+EXPORT_C CSubConnectionProviderBase::CSubConnectionProviderBase(CSubConnectionProviderFactoryBase& aFactory,
+                                                                const MeshMachine::TNodeActivityMap& aActivityMap)
+: CMMCommsProviderBase(aFactory,aActivityMap)
+/** Constructor
+
+@param aFactory he factory that created and owns this object
+@param aConnProvider Connection Provider the sub-connection provider is a member of */
+	{
+	LOG(ESockLog::Printf(KESockCtrlFactTag, _L("CSubConnectionProviderBase %08x:\tcreated [%d], factory Uid %x"),
+						 this, sizeof(CSubConnectionProviderBase), Factory().Uid().iUid));
+	}
+
+
+EXPORT_C void CSubConnectionProviderBase::NotifyClientsL(const CSubConNotificationEvent& aEvent)
+    {
+	LOG(ESockLog::Printf(KESockCtrlFactTag, _L("[%08x] CSubConnectionProviderBase::NotifyClientsL ([%d])"),
+					 this, aEvent.Id()));
+    TClientIter<TDefaultClientMatchPolicy> iter = GetClientIter<TDefaultClientMatchPolicy>(TClientType(TCFClientType::ECtrl));
+    if (iter[0] == NULL)
+        {
+        delete &aEvent;
+        return;
+        }
+
+	CRefCountOwnedSubConNotification* eventNode = new (ELeave) CRefCountOwnedSubConNotification(&aEvent);
+    RNodeInterface* ctl = NULL;
+	while ((ctl = iter++) != NULL)
+		{
+		ctl->PostMessage(Id(), TCFSubConnControlClient::TSubConnNotification(eventNode).CRef());
+		eventNode->Open();
+		}
+    }
+
+EXPORT_C CSubConnectionProviderBase::~CSubConnectionProviderBase()
+/** Destructor */
+	{
+#ifndef SYMBIAN_ADAPTIVE_TCP_RECEIVE_WINDOW
+	if(!iParameterBundle.IsNull())
+		{
+		iParameterBundle.Close();
+		}
+#endif // SYMBIAN_ADAPTIVE_TCP_RECEIVE_WINDOW
+	LOG(ESockLog::Printf(KESockCtrlFactTag, _L("~CSubConnectionProviderBase %08x:\tFactory Uid %x"),
+						 this, Factory().Uid().iUid));
+	}
+
+