--- /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));
+ }
+
+