examples/Base/IPC/secureserver/secureserver.h

Go to the documentation of this file.

// Copyright (c) 2008-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:
// Defines CSecureServer, CSecureServerSession and CSecureServerSubSession classes.
// It also defines the constants that form the security policy for the server.
//



#ifndef __SECURESERVER_H__
#define __SECURESERVER_H__

#include <e32svr.h>
#include <e32uid.h>
#include <e32math.h>
#include <f32file.h>

const TUint KDefaultHeapSize=0x10000;

enum TSecureServerPanic
        {
        EBadRequest = 1,
        EDescriptorNonNumeric,
        EMainSchedulerError,
        EServerCreateServer,
        EServerStartServer,
        ECreateTrapCleanup,
        EBadSubsessionHandle,
        ESecureServerSecurityPolicy
        };

const TInt KSecureServerRangeCount = 5;

const TInt KSecureServerRanges[KSecureServerRangeCount] =
        {
        0,
        5,
        6,
        11,
        13
        };

const CPolicyServer::TPolicyElement KSecureServerElements[] =
        {
        _INIT_SECURITY_POLICY_S0(0x70fffff0),
        {_INIT_SECURITY_POLICY_C1(ECapabilityReadDeviceData | ECapabilityWriteDeviceData), CPolicyServer::EFailClient}
        };

const TUint8 KSecureServerElementsIndex[KSecureServerRangeCount] =
                {
                CPolicyServer::EAlwaysPass,
                0,
                CPolicyServer::ECustomCheck,
                1,
                CPolicyServer::ENotSupported
                };

const CPolicyServer::TPolicy KSecureServerPolicy =
        {
        CPolicyServer::EAlwaysPass,
        KSecureServerRangeCount,
        KSecureServerRanges,
        KSecureServerElementsIndex,
        KSecureServerElements
        };

class CSecureServer : public CPolicyServer
        {
public:
        CSession2* NewSessionL(const TVersion &aVersion,const RMessage2& aMessage) const;
        static CSecureServer* NewL(CActive::TPriority aActiveObjectPriority);
        static TInt ThreadFunction(TAny* aStarted);
        static void PanicServer(TSecureServerPanic aPanic);
        CPolicyServer::TCustomResult CustomSecurityCheckL(const RMessage2 &aMsg, TInt &aAction, TSecurityInfo &aMissing);
        CObjectCon* NewContainerL();
        void RemoveContainer(CObjectCon *aCon);
        ~CSecureServer();
private :
        CSecureServer(CActive::TPriority aActiveObjectPriority);
        void ConstructL();

private:
        CObjectConIx* iContainerIndex;
        };

class CSecureServerSubSession;

class CSecureServerSession : public CSession2
        {
public:
        static CSecureServerSession* NewL();
        void CreateL();
        void ServiceL(const RMessage2& aMessage);
        void NewCounterL(const RMessage2& aMessage);
        void CloseSession();
        void NumResourcesL(const RMessage2& aMessage);
        CSecureServerSubSession* CounterFromHandle(const RMessage2& aMessage,TInt aHandle);
        void DeleteCounter(TInt aHandle);
        TInt CountResources();
        void PanicClient(const RMessage2& aMessage,TInt aPanic) const;
        CSecureServerSession();
private:
        CObjectCon* iContainer;
        CObjectIx* iCountersObjectIndex;
        TInt iResourceCount;
        };

class CSecureServerSubSession : public CObject
        {
public:
        static CSecureServerSubSession* NewL(CSecureServerSession* aSession);
        CSecureServerSubSession(CSecureServerSession* aSession);
        void ConstructL(CSecureServerSession* aSession);
        void SetFromStringL(const RMessage2& aMessage);
        void Increase();
        void IncreaseBy(const RMessage2& aMessage);
        void Decrease();
        void DecreaseBy(const RMessage2& aMessage);
        void Reset();
        void CounterValueL(const RMessage2& aMessage);
        void SaveCounterValueL();
        void SetCounterValueFromFileL();

protected:
        CSecureServerSession* iSession;

private:
        TInt iCount;
        };

#endif

---