--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/backupandrestore/backupengine/src/sbeserver.cpp Tue Feb 02 01:11:40 2010 +0200
@@ -0,0 +1,260 @@
+// 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:
+// Implementation of CSBEServer class.
+//
+//
+
+/**
+ @file
+*/
+
+#include <e32std.h>
+#include <e32base.h>
+#include "sbeclientserver.h"
+#include "sbeserver.h"
+#include "sbesession.h"
+#include <connect/panic.h>
+#include "sbedataownermanager.h"
+#include "sblog.h"
+//#include <stdlib.h>
+
+namespace conn
+ {
+
+
+ /** Secure Backup Engine security request ranges
+
+ This is a breakdown of the SBE requests into ranges
+ for security checking purposes.
+
+ @internalComponent
+ */
+ const TInt mySBERanges[] = {0,23};
+
+ /** Secure Backup Engine range count
+
+ The number of different security ranges for SBEs request numbers
+
+ @internalComponent
+ */
+ const TUint mySBERangeCount = sizeof(mySBERanges)/sizeof(mySBERanges[0]);
+
+ /** Secure Backup Engine security action array
+
+ An array with a one-to-one mapping with the range array
+ specifiying what security action to take for each server request.
+
+ @internalComponent
+ */
+ const TUint8 mySBEElementsIndex[mySBERangeCount] =
+ {
+ 0,
+ CPolicyServer::ENotSupported,
+ };
+
+ /**
+ @internalComponent
+ */
+ const CPolicyServer::TPolicyElement mySBEElements[] =
+ {
+ {_INIT_SECURITY_POLICY_C2(ECapabilityWriteDeviceData,ECapabilityReadDeviceData)
+ , CPolicyServer::EFailClient},
+ };
+
+ /**
+ @internalComponent
+ */
+ const CPolicyServer::TPolicy mySBEPolicy =
+ {
+ 0,
+ mySBERangeCount,
+ mySBERanges,
+ mySBEElementsIndex,
+ mySBEElements,
+ };
+
+ CSBEServer::CSBEServer(CDataOwnerManager* aDOM)
+ : CPolicyServer(EPriorityNormal,mySBEPolicy), iDOM(aDOM)
+ /**
+ Class constructor
+ */
+ {
+ __ASSERT_DEBUG(aDOM, Panic(KErrArgument));
+ }
+
+ CSBEServer::~CSBEServer()
+ /**
+ Class destructor
+ */
+ {
+ iGlobalSharedHeap.Close();
+ delete iGSHInterface;
+ }
+
+ CSBEServer* CSBEServer::NewLC(CDataOwnerManager* aDOM)
+ /**
+ Constructs a new instance of the CSBEServer, calls ConstructL,
+ and returns it to the caller leaving it on the cleanup stack.
+
+ @return The new instance of CSBEServer.
+ */
+ {
+ CSBEServer* pSelf = new (ELeave) CSBEServer(aDOM);
+ CleanupStack::PushL(pSelf);
+ pSelf->ConstructL();
+ return pSelf;
+ }
+
+ void CSBEServer::ConstructL()
+ /**
+ Construct this instance of CSBEServer.
+ */
+ {
+ AllocateGlobalSharedHeapL();
+
+ iGSHInterface = CHeapWrapper::NewL();
+
+ // Initialise the locked flag to be unlock
+ iGSHInterface->ResetHeap(iGlobalSharedHeap);
+ //
+ // Start the server and a timer to stop it if nothing happens.
+ StartL(KSBEServerName);
+ iShutdown.ConstructL();
+ #ifndef _DEBUG
+ iShutdown.Start();
+ #endif
+ }
+
+ void CSBEServer::AllocateGlobalSharedHeapL()
+ /**
+ Attempts to allocate the GSH. If initial attempts fail, it tries to allocate with
+ progressively smaller chunk sizes
+ */
+ {
+ TInt attemptedSize;
+ TInt retryCount;
+ TInt redFactor;
+ iDOM->Config().HeapValues(attemptedSize, retryCount, redFactor);
+
+ TInt result = KErrNone;
+
+ for (; retryCount > 0; retryCount--)
+ {
+ result = iGlobalSharedHeap.CreateGlobal(KNullDesC, attemptedSize, attemptedSize);
+
+ if (result == KErrNone)
+ {
+ // We have succesfully allocated a GSH
+ break;
+ }
+ else
+ {
+ // Reduce the size of the GSH by a scale factor
+ attemptedSize = attemptedSize / redFactor;
+ }
+ }
+
+ User::LeaveIfError(result);
+ }
+
+ void CSBEServer::AddSession()
+ /** Increments the server session count.
+
+ The server will shutdown when its
+ session count drops to zero.
+ */
+ {
+ ++iSessionCount;
+ iShutdown.Cancel();
+ }
+
+ void CSBEServer::DropSession()
+ /** Decrements the server session count.
+
+ The server will shutdown when its
+ session count drops to zero.
+ */
+ {
+ if(--iSessionCount == 0)
+ {
+ iShutdown.Start();
+ }
+ }
+
+
+ CSession2* CSBEServer::NewSessionL(const TVersion& aVersion,
+ const RMessage2& /*aMessage*/) const
+ /** Constructs a new SBE server session.
+
+ Querys the supplied version infomation from the client
+ with that of this server, and leaves if they are incompatable.
+
+ @param aVersion The clients version information
+ @param aMessage Is ignored
+ @return A new instance of CSBESession
+ @leave KErrNotSupported if the version passed in aVersion is not the same as this one
+ */
+ {
+ TVersion thisVersion(KSBEMajorVersionNumber,
+ KSBEMinorVersionNumber,
+ KSBEBuildVersionNumber);
+
+ if (!User::QueryVersionSupported(thisVersion, aVersion))
+ {
+ User::Leave(KErrNotSupported);
+ }
+
+ return new (ELeave) CSBESession();
+ }
+
+ TInt CSBEServer::RunError(TInt aError)
+ /** Called when this active objects RunL leaves.
+
+ May be due to a bad client or the server itself. In either
+ case, complete the last outstanding message with the error
+ code and continue handling client requests.
+
+ @param aError Standard Symbian OS error code
+ @return The error code to be passed back to the active scheduler framework.
+ */
+ {
+ //
+ // A Bad descriptor is a bad client - panic it.
+ if(aError == KErrBadDescriptor)
+ {
+ PanicClient(KErrBadDescriptor);
+ }
+
+ //
+ // Complete the message and continue handling requests.
+ Message().Complete(aError);
+ ReStart();
+ return KErrNone;
+ }
+
+
+ void CSBEServer::PanicClient(TInt aPanic) const
+ /** Panic a client.
+
+ @param aPanic The panic code.
+ */
+ {
+ __DEBUGGER()
+ _LIT(KPanicCategory,"SBE Server");
+ RThread client;
+ Message().Client(client);
+ client.Panic(KPanicCategory, aPanic);
+ }
+
+ } // end namespace