diff -r 000000000000 -r dfb7c4ff071f datacommsserver/esockserver/ssock/ss_api_ext.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/datacommsserver/esockserver/ssock/ss_api_ext.cpp	Thu Dec 17 09:22:25 2009 +0200
@@ -0,0 +1,382 @@
+// Copyright (c) 2005-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
+ @released
+*/
+
+#define SYMBIAN_NETWORKING_UPS
+
+#include "ss_api_ext.h"
+
+#include <comms-infras/ss_log.h>
+#include <comms-infras/ss_roles.h>
+#include <ss_glob.h>
+#include <es_panic.h>
+#include <ss_std.h>
+#include <comms-infras/ss_nodemessages.h>
+#include <comms-infras/ss_nodemessages_internal.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_ESockSSocks_p_xt, "ESockSSocks_p_xt");
+#endif
+
+using namespace Elements;
+using namespace ESock;
+using namespace Messages;
+
+//
+// CExtItfMsgPluginInfo
+//
+
+EXPORT_C CExtItfMsgPluginInfo* CExtItfMsgPluginInfo::NewInstanceL(const STypeId& aTypeId)
+	{
+	TUid destroyUid;
+	CExtItfMsgPluginInfo* obj = reinterpret_cast<CExtItfMsgPluginInfo*>(REComSession::CreateImplementationL(aTypeId.iUid, destroyUid, (TAny*)aTypeId.iType));
+	obj->iDestroyUid = destroyUid;
+	return obj;
+	}
+
+EXPORT_C CExtItfMsgPluginInfo::~CExtItfMsgPluginInfo()
+	{
+	__ASSERT_DEBUG(iDestroyUid.iUid!=0, User::Panic(KSpecAssert_ESockSSocks_p_xt, 1));
+	REComSession::DestroyedImplementation(iDestroyUid);
+	}
+
+//
+// CCommsApiExtResponder
+//
+
+EXPORT_C CCommsApiExtResponder::CCommsApiExtResponder()
+	{
+	}
+
+EXPORT_C CCommsApiExtResponder::~CCommsApiExtResponder()
+	{
+	}
+
+EXPORT_C void CCommsApiExtResponder::Complete(CCommsApiExtResponder*& aThis, TInt aError)
+	{
+	if (aThis==NULL)
+		{
+		return;
+		}
+
+	aThis->DoComplete(aError);
+	delete aThis;
+	aThis = NULL;
+	}
+
+//
+// CCommsApiExtIpcResponder
+//
+
+EXPORT_C void CCommsApiExtIpcResponder::DoComplete(TInt aError)
+	{
+	iResponseMsg.Complete(aError);
+	}
+
+EXPORT_C CCommsApiExtIpcResponder* CCommsApiExtIpcResponder::NewL(const RMessage2& aMessage)
+	{
+	return new (ELeave) CCommsApiExtIpcResponder(aMessage);
+	}
+
+EXPORT_C CCommsApiExtIpcResponder* CCommsApiExtIpcResponder::NewL(Elements::RResponseMsg& aResponseMsg)
+	{
+	return new (ELeave) CCommsApiExtIpcResponder(aResponseMsg);
+	}
+
+//
+// RLegacyRepsonseMsg
+//
+EXPORT_C RLegacyResponseMsg::RLegacyResponseMsg()
+	: iNodeAddr(Messages::TNodeCtxId::NullId())
+	{}
+
+EXPORT_C RLegacyResponseMsg::RLegacyResponseMsg(MeshMachine::TNodeContextBase& aContext)
+	: Elements::RResponseMsg(), iNodeAddr(aContext.ActivityId(), aContext.NodeId())
+	{}
+
+EXPORT_C RLegacyResponseMsg::RLegacyResponseMsg(MeshMachine::TNodeContextBase& aContext, const RMessage2& aMessage, TInt aInterfaceId, TInt aRequestMsgParam, TInt aResponseMsgParam)
+	: Elements::RResponseMsg(aMessage, aInterfaceId, aRequestMsgParam, aResponseMsgParam), iNodeAddr(aContext.ActivityId(), aContext.NodeId())
+	{}
+	
+EXPORT_C RLegacyResponseMsg::RLegacyResponseMsg(MeshMachine::TNodeContextBase& aContext, const RMessage2& aMessage, const Den::TApiExtIdentification& aInterfaceId, TInt aRequestMsgParam, TInt aResponseMsgParam)
+	: Elements::RResponseMsg(aMessage, aInterfaceId, aRequestMsgParam, aResponseMsgParam), iNodeAddr(aContext.ActivityId(), aContext.NodeId())
+	{}
+	
+EXPORT_C void RLegacyResponseMsg::Complete(TInt aError) const
+	{
+	TCFLegacyMessage::TLegacyRMessage2Processed msg(TLegacyRMessage2Response(TLegacyRMessage2Response::ENormal, aError));
+    RNodeInterface::OpenPostMessageClose(iNodeAddr, iNodeAddr, msg);
+	iNodeAddr.SetNull();
+	}
+
+EXPORT_C void RLegacyResponseMsg::Panic(const TDesC& aCategory, TInt aReason) const
+	{
+	TCFLegacyMessage::TLegacyRMessage2Processed msg(TLegacyRMessage2Response(TLegacyRMessage2Response::EPanic, aReason, aCategory));
+    RNodeInterface::OpenPostMessageClose(iNodeAddr, iNodeAddr, msg);
+	iNodeAddr.SetNull();
+	}
+
+EXPORT_C TBool RLegacyResponseMsg::IsNull() const
+	{
+	return iNodeAddr.IsNull();
+	}
+
+//
+// CCommsApiExtLegacyIpcResponder
+//
+EXPORT_C void CCommsApiExtLegacyIpcResponder::DoComplete(TInt aError)
+	{
+	iResponseMsg.Complete(aError);
+	}
+
+EXPORT_C CCommsApiExtLegacyIpcResponder* CCommsApiExtLegacyIpcResponder::NewL(MeshMachine::TNodeContextBase& aContext, const RMessage2& aMessage)
+	{
+	return new (ELeave) CCommsApiExtLegacyIpcResponder(aContext, aMessage);
+	}
+
+EXPORT_C CCommsApiExtLegacyIpcResponder* CCommsApiExtLegacyIpcResponder::NewL(RLegacyResponseMsg& aResponseMsg)
+	{
+	return new (ELeave) CCommsApiExtLegacyIpcResponder(aResponseMsg);
+	}
+
+// CCommsApiExtIpcOpenResponder
+
+EXPORT_C CCommsApiExtIpcOpenResponder* CCommsApiExtIpcOpenResponder::NewL(TSupportedCommsApiExt aInterfaceId, TSubSessionUniqueId aClientId, const RMessage2& aMessage)
+	{
+	return new (ELeave) CCommsApiExtIpcOpenResponder(aInterfaceId, aClientId, aMessage);
+	}
+
+EXPORT_C void CCommsApiExtIpcOpenResponder::DoComplete(TInt aError)
+	{
+	if (aError!=KErrNone)
+		{
+		SockManGlobals::Get()->iCommsApiExtRegister.DeRegisterInterface(iInterfaceId, iClientId);
+		}
+	CCommsApiExtIpcResponder::DoComplete(aError);
+	}
+
+
+//
+// AIPCClientInfo
+//
+
+/**
+   @param aSubSessionUniqueId The id of the subsession to query
+   @param aUidType The uid type
+   @return KErrNone on success and KErrCorrupt when the current aSubSessionUniqueId
+   could not be mapped to an existing client.
+*/
+EXPORT_C TInt AIPCClientInfo::ClientUidType(TSubSessionUniqueId aSubSessionUniqueId, TUidType& aUidType) const
+	{
+	TProcessId processId;
+	TThreadId threadId;
+	TInt err = GetSubsessionOwnerInfo(aSubSessionUniqueId, processId, aUidType, threadId);
+	return err;
+	}
+
+/**
+   Retrieves the secure id of the owner of the subsession
+   @param aSubSessionUniqueId The id of the subsession to query
+   @param aUid The secure id of the owner of the subsession
+   @return KErrNone if the call is successful, otherwise one of the system-wide error codes.
+*/
+EXPORT_C TInt AIPCClientInfo::ClientSid(TSubSessionUniqueId aSubSessionUniqueId, TSecureId& aSid) const
+	{
+	RProcess process;
+	TInt res = OpenClientProcess(aSubSessionUniqueId, process);
+	if (res == KErrNone)
+		{
+        aSid = process.SecureId();
+        process.Close();
+		}
+
+    return res;
+	}
+
+/**
+   Opens the RProcess of the owning client process of the subsession. The caller is responsible
+   for calling the RProcess.Close() method.
+   @param aSubSessionUniqueId The subsession id of to obtain the client process information from
+   @param aProcess Upon returning from a successful call aProcess is an opened RProcess.
+   @return KErrNone if the call is successful, otherwise one of the system-wide error codes.
+*/
+EXPORT_C TInt AIPCClientInfo::OpenClientProcess(TSubSessionUniqueId aSubSessionUniqueId, RProcess& aProcess) const
+    {
+    TProcessId processId;
+	TUidType uidType;
+	TThreadId threadId;
+
+	TInt err = GetSubsessionOwnerInfo(aSubSessionUniqueId, processId, uidType, threadId);
+	if (err == KErrNone)
+	    {
+        err = aProcess.Open(processId);
+	    }
+
+    return err;
+    }
+
+/**
+   Retrieves information about the owner of the subsession
+   @param aSubSessionUniqueId The subsession id of to obtain the client process information from
+   @return KErrNone if the call is successful, otherwise one of the system-wide error codes.
+   @note The thread id. returned is that which opened the RSocketServ, not the RSocket.
+*/
+TInt AIPCClientInfo::GetSubsessionOwnerInfo(TSubSessionUniqueId aSubSessionUniqueId, TProcessId& aProcessId, TUidType& aUidType, TThreadId& aThreadId) const
+    {
+	CWorkerThread* worker = SockManGlobals::Get()->SelfWorker();
+	__ASSERT_DEBUG(worker, Panic(ENonESockWorkerThread));
+	
+	CPlayer* player = worker->Player();
+	__ASSERT_DEBUG(player, Panic(ENonESockWorkerThread));
+	
+	CSockSubSession* ss = player->SubSession(aSubSessionUniqueId);
+	
+	if (ss == NULL)
+		{
+		return KErrCorrupt;
+		}
+
+	ss->GetOwnerInfo(aProcessId, aUidType, aThreadId);
+	return KErrNone;
+   }
+
+EXPORT_C TInt AIPCClientPlatsecInfo::SecureId(TSubSessionUniqueId aSubSessionUniqueId, TSecureId& aResult) const
+    {
+	return ClientSid(aSubSessionUniqueId, aResult);
+    }
+
+
+EXPORT_C TInt AIPCClientPlatsecInfo::VendorId(TSubSessionUniqueId aSubSessionUniqueId, TVendorId& aResult) const
+    {
+	RProcess process;
+	TInt res = OpenClientProcess(aSubSessionUniqueId, process);
+	if (res == KErrNone)
+		{
+        aResult = process.VendorId();
+        process.Close();
+		}
+
+    return res;
+    }
+
+
+EXPORT_C TBool AIPCClientPlatsecInfo::HasCapability(TSubSessionUniqueId aSubSessionUniqueId, const TCapability aCapability) const
+   {
+   RProcess process;
+   TInt res = OpenClientProcess(aSubSessionUniqueId, process);
+   if (res != KErrNone) { return EFalse; }
+
+   TBool platsecResult;
+   platsecResult = process.HasCapability(aCapability);
+   process.Close();
+
+   return platsecResult;
+   }
+
+
+EXPORT_C TInt AIPCClientPlatsecInfo::CheckPolicy(TSubSessionUniqueId aSubSessionUniqueId, const TSecurityPolicy& aPolicy) const
+    {
+	RProcess process;
+	TInt res = OpenClientProcess(aSubSessionUniqueId, process);
+	if (res != KErrNone)
+        {
+        return res;
+        }
+
+    TBool platsecResult;
+    platsecResult = aPolicy.CheckPolicy(process);
+    if (!platsecResult)
+        {
+        return KErrPermissionDenied;
+        }
+    return KErrNone;
+    }
+
+#ifdef SYMBIAN_NETWORKING_UPS
+EXPORT_C TInt AIPCClientPlatsecInfo::GetProcessAndThreadId(TSubSessionUniqueId aSubSessionUniqueId, TProcessId& aProcessId, TThreadId& aThreadId) const
+    {
+    TUidType   uidType;
+    
+	TInt rc = GetSubsessionOwnerInfo(aSubSessionUniqueId, aProcessId, uidType, aThreadId);
+	return rc;
+    }
+#endif //SYMBIAN_NETWORKING_UPS
+
+/**
+
+*/
+EXPORT_C AExtensionInterfaceThickBase::AExtensionInterfaceThickBase(const Meta::STypeId& aMsgImplTid) 
+:	iMsgImplTid(aMsgImplTid)
+	{
+	}
+
+/**
+
+*/
+EXPORT_C AExtensionInterfaceThickBase::~AExtensionInterfaceThickBase()
+	{
+	}
+
+/**
+	Null default implementation
+*/
+EXPORT_C void AExtensionInterfaceThickBase::OpenExtensionInterface(TSubSessionUniqueId /* aClientId */, const TRuntimeCtxId& /*aControlClient*/, CCommsApiExtResponder* aResponder)
+	{
+	CCommsApiExtResponder::Complete(aResponder,KErrNone);
+	}
+
+/**
+	Null default implementation
+*/
+EXPORT_C void AExtensionInterfaceThickBase::CancelExtensionInterface(TSubSessionUniqueId /* aClientId */)
+	{
+	}
+
+/**
+	Null default implementation
+*/
+EXPORT_C void AExtensionInterfaceThickBase::CloseExtensionInterface(TSubSessionUniqueId /* aClientId */)
+	{
+	}
+
+/*
+EXPORT_C void AExtensionInterfaceThickBase::RegisterMessagesL()
+	{
+	__ASSERT_DEBUG(iMsgPluginInfo==NULL, User::Panic(KSpecAssert_ESockSSocks_p_xt, 2)); //Well, we should not be opening the same interface 
+		{
+		iMsgPluginInfo = static_cast<MExtItfMsgPluginInfo*>(REComSession::CreateImplementationL(iMsgImplUid, iDtorIdKey));
+		}
+	const TImplementationProxy* implProxyTable = iMsgPluginInfo->ImplementationProxy();
+	CWorkerThread* worker = SockManGlobals::Get()->SelfWorker();
+	worker->RegisterInterfaceL(iMsgImplUid, iMsgPluginInfo->ImplementationProxyTableSize(), implProxyTable);
+	}
+	
+EXPORT_C void AExtensionInterfaceThickBase::DeregisterMessages()
+	{
+	CWorkerThread* worker = SockManGlobals::Get()->SelfWorker();
+	worker->DeregisterInterface(iMsgImplUid);
+	REComSession::DestroyedImplementation(iDtorIdKey);
+	REComSession::FinalClose();
+	}
+*/
+