// 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);
    process.Close();
    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();
	}
*/