diff -r 000000000000 -r dfb7c4ff071f datacommsserver/esockserver/inc/ss_api_ext.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/datacommsserver/esockserver/inc/ss_api_ext.h Thu Dec 17 09:22:25 2009 +0200 @@ -0,0 +1,264 @@ +// 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 + @internalTechnology +*/ + +#ifndef SS_API_EXT_H +#define SS_API_EXT_H + +#define SYMBIAN_NETWORKING_UPS + +#include +#include +#include +#include +#include +#include + +/** + Forward declaration to avoid including mm_context.h +*/ +namespace MeshMachine +{ + class TNodeContextBase; +} + +namespace ESock +{ + +/** + @internalTechnology +*/ +class CExtItfMsgPluginInfo : public CBase + { +public: + IMPORT_C static CExtItfMsgPluginInfo* NewInstanceL(const STypeId& aTypeId); + IMPORT_C ~CExtItfMsgPluginInfo(); + + virtual const TImplementationProxy* ImplementationProxy() const = 0; + virtual TInt ImplementationProxyTableSize() const = 0; + +private: + TUid iDestroyUid; + }; + +/** + @internalTechnology +*/ +class CCommsApiExtResponder : public CBase + { +public: + IMPORT_C static void Complete(CCommsApiExtResponder*& aThis, TInt aError); + +protected: + IMPORT_C explicit CCommsApiExtResponder(); + IMPORT_C virtual ~CCommsApiExtResponder(); + +private: + virtual void DoComplete(TInt aError) = 0; + }; + +/** + @internalTechnology +*/ +class CCommsApiExtIpcResponder : public CCommsApiExtResponder + { +public: + IMPORT_C static CCommsApiExtIpcResponder* NewL(const RMessage2& aMessage); + IMPORT_C static CCommsApiExtIpcResponder* NewL(Elements::RResponseMsg& aResponseMsg); + +protected: + explicit CCommsApiExtIpcResponder(const RMessage2& aMessage) + : iResponseMsg(aMessage, aMessage.Int0(), 1, 2) + { + } + explicit CCommsApiExtIpcResponder(Elements::RResponseMsg& aResponseMsg) + : iResponseMsg(aResponseMsg) + { + } + +protected: + IMPORT_C virtual void DoComplete(TInt aError); + +protected: + Elements::RResponseMsg iResponseMsg; + }; + +/** + Specialised responder for Legacy messages. Wraps all RMessage2 functionallity, + so that it cannot be completed without us knowing about it. + + @publishedPartner + @released since tb92 +*/ +class RLegacyResponseMsg : public Elements::RResponseMsg + { +public: + IMPORT_C RLegacyResponseMsg(); + IMPORT_C explicit RLegacyResponseMsg(MeshMachine::TNodeContextBase& aContext); + IMPORT_C explicit RLegacyResponseMsg(MeshMachine::TNodeContextBase& aContext, const RMessage2& aMessage, TInt aInterfaceId, TInt aRequestMsgParam = -1, TInt aResponseMsgParam = -1); + IMPORT_C explicit RLegacyResponseMsg(MeshMachine::TNodeContextBase& aContext, const RMessage2& aMessage, const Den::TApiExtIdentification& aInterfaceId, TInt aRequestMsgParam = -1, TInt aResponseMsgParam = -1); + + IMPORT_C void Complete(TInt aError) const; + IMPORT_C void Panic(const TDesC& aCategory, TInt aReason) const; + + IMPORT_C TBool IsNull() const; + +private: + mutable Messages::TNodeCtxId iNodeAddr; + }; + +/** + @internalTechnology +*/ +class CCommsApiExtLegacyIpcResponder : public CCommsApiExtResponder + { +public: + IMPORT_C static CCommsApiExtLegacyIpcResponder* NewL(MeshMachine::TNodeContextBase& aContext, const RMessage2& aMessage); + IMPORT_C static CCommsApiExtLegacyIpcResponder* NewL(RLegacyResponseMsg& aResponseMsg); + +protected: + explicit CCommsApiExtLegacyIpcResponder(MeshMachine::TNodeContextBase& aContext, const RMessage2& aMessage) + : iResponseMsg(aContext, aMessage, aMessage.Int0(), 1, 2) + { + } + explicit CCommsApiExtLegacyIpcResponder(RLegacyResponseMsg& aResponseMsg) + : iResponseMsg(aResponseMsg) + { + } + +protected: + IMPORT_C virtual void DoComplete(TInt aError); + +protected: + RLegacyResponseMsg iResponseMsg; + }; + + +/** + @internalTechnology +*/ +class CCommsApiExtIpcOpenResponder : public CCommsApiExtIpcResponder + { +public: + IMPORT_C static CCommsApiExtIpcOpenResponder* NewL(TSupportedCommsApiExt aInterfaceId, TSubSessionUniqueId aClientId, const RMessage2& aMessage); + +protected: + explicit CCommsApiExtIpcOpenResponder(TSupportedCommsApiExt aInterfaceId, TSubSessionUniqueId aClientId, const RMessage2& aMessage) + : CCommsApiExtIpcResponder(aMessage), + iInterfaceId(aInterfaceId), + iClientId(aClientId) + { + } + +protected: + IMPORT_C virtual void DoComplete(TInt aError); + +protected: + const TSupportedCommsApiExt iInterfaceId; + const TSubSessionUniqueId iClientId; + }; + + +/** + @internalTechnology +*/ +class MExtensionInterfaceBase + { +public: + virtual void OpenExtensionInterface(TSubSessionUniqueId aClientId, const Messages::TRuntimeCtxId& aControlClient, CCommsApiExtResponder* aResponder) = 0; + virtual void CloseExtensionInterface(TSubSessionUniqueId aClientId) = 0; + virtual void CancelExtensionInterface(TSubSessionUniqueId aClientId) = 0; + }; + +class AExtensionInterfaceThickBase : public MExtensionInterfaceBase + { +public: + // From MExtensionInterfaceBase + IMPORT_C virtual void OpenExtensionInterface(TSubSessionUniqueId aClientId, const Messages::TRuntimeCtxId& aControlClient, CCommsApiExtResponder* aResponder); + IMPORT_C virtual void CloseExtensionInterface(TSubSessionUniqueId aClientId); + IMPORT_C virtual void CancelExtensionInterface(TSubSessionUniqueId aClientId); + + const Meta::STypeId& MsgImplTid() const + { + return iMsgImplTid; + } + +protected: + IMPORT_C AExtensionInterfaceThickBase(const Meta::STypeId& aMsgImplTid); + IMPORT_C virtual ~AExtensionInterfaceThickBase(); + +private: + const Meta::STypeId iMsgImplTid; + }; + + +/** + @internalTechnology + + Minimum functionality for an extension interface. OpenL() + and Close() provided as a means of resource reservation and + release. +*/ +template +class AExtensionInterfaceBase : public AExtensionInterfaceThickBase + { +protected: + AExtensionInterfaceBase() + : AExtensionInterfaceThickBase(Meta::STypeId::CreateSTypeId(MSG_IMPL_UID,MSG_IMPL_TYPEID)) + { + } + //@todo - should AExtensionInterfaceThickBase have a gratuitous pure virtual to try to force use of this template? seems lame... + }; + +/** + @internalTechnology +*/ +class AIPCClientInfo + { +public: + IMPORT_C TInt ClientUidType(TSubSessionUniqueId aSubSessionUniqueId, TUidType& aUidType) const; + IMPORT_C TInt ClientSid(TSubSessionUniqueId aSubSessionUniqueId, TSecureId& aSid) const; + +protected: + IMPORT_C TInt OpenClientProcess(TSubSessionUniqueId aSubSessionUniqueId, RProcess& aProcess) const; +#ifndef SYMBIAN_NETWORKING_UPS +private: +#endif //SYMBIAN_NETWORKING_UPS + TInt GetSubsessionOwnerInfo(TSubSessionUniqueId aSubSessionUniqueId, TProcessId& aProcessId, TUidType& aUidType, TThreadId& aThreadId) const; + }; + +/** + @internalTechnology +*/ +class AIPCClientPlatsecInfo : public AIPCClientInfo + { +public: + IMPORT_C TInt SecureId(TSubSessionUniqueId aSubSessionUniqueId, TSecureId& aResult) const; + IMPORT_C TInt VendorId(TSubSessionUniqueId aSubSessionUniqueId, TVendorId& aResult) const; + IMPORT_C TBool HasCapability(TSubSessionUniqueId aSubSessionUniqueId, const TCapability aCapability) const; + IMPORT_C TInt CheckPolicy(TSubSessionUniqueId aSubSessionUniqueId, const TSecurityPolicy& aPolicy) const; +#ifdef SYMBIAN_NETWORKING_UPS + IMPORT_C TInt GetProcessAndThreadId(TSubSessionUniqueId aSubSessionUniqueId, TProcessId& aProcessId, TThreadId& aThreadId) const; +#endif //SYMBIAN_NETWORKING_UPS + }; + +} //namespace ESock + +#endif // SS_API_EXT_H +