diff -r 000000000000 -r bde4ae8d615e os/security/authorisation/userpromptservice/server/source/upsserver/upsdbmanager.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/os/security/authorisation/userpromptservice/server/source/upsserver/upsdbmanager.cpp	Fri Jun 15 03:10:57 2012 +0200
@@ -0,0 +1,254 @@
+/*
+* Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of the License "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: 
+* Implements the UPS database handle manager.  See class and function
+* definitions for more information.
+*
+*/
+
+
+/**
+ @file
+*/
+#include <f32file.h>
+#include "upscommon.h"
+#include <ups/upsdbw.h>
+#include "upsdbmanager.h"
+
+namespace UserPromptService
+{
+
+RUpsDbHandleMaster::RUpsDbHandleMaster(RFs &aFs)
+/**
+	Construct the handle master
+
+	This class should be used for synchronous database operations.
+
+	If you need to do asynchronous operations then create/use an instance of the RUpsDbHandleSlave
+	linked to the master.
+
+	If your database operation fails, particularly due to OOM, then you should call Close your handle. You probably
+	do NOT need to explicitly re-open it - it will automatically re-open when the -> operator is used.
+
+	Note that the -> operator may leave.
+*/
+	: iFs(aFs), iDatabase(0), iClientListHead(0)
+	{
+	}
+
+RUpsDbHandleMaster::~RUpsDbHandleMaster()
+/**
+	Destroy the handle master
+*/
+	{
+	ASSERT(iClientListHead == 0); // Should be no clients!!!!
+	Close(); // Deletes iDatabase...
+	iClientListHead = 0;
+	// Do NOT close the iFs (it is a reference to the main server's handle).
+	}
+
+_LIT(KDatabaseFile,"?:\\private\\10283558\\database\\ups.db");
+void RUpsDbHandleMaster::OpenL()
+/**
+	Open the database handle
+
+       It is probably clearer to explictly call this function to open the handle before first use, but the -> operator will
+       auto-open it if called on a closed handle. Note that the -> operator can leave.
+
+	If any database operation fails, particularly due to OOM, then you should Close your handle. Instead of 
+	immediately re-opening it, it is generally safer to let it auto-reopen when the -> operator is next called.
+
+*/
+	{
+	BULLSEYE_OFF
+	if(iDatabase != 0)
+		{
+		// Close/delete the existing database handle.
+		Close();
+		}
+	BULLSEYE_RESTORE
+
+	// Open up a new handle.
+	TFileName databaseFileBuf = KDatabaseFile();
+
+	databaseFileBuf[0] = iFs.GetSystemDriveChar();
+	TParsePtrC databaseFile(databaseFileBuf);
+
+	// Make sure the dir exists
+	(void)iFs.MkDirAll(databaseFile.DriveAndPath());
+	// Create/Open the database
+	iDatabase = CDecisionDbW::NewL(databaseFile.FullName(), iFs);
+	}
+
+void RUpsDbHandleMaster::Close()
+/**
+	Notify all client handles that the master (real) database handle is about to be closed, and then close it.
+*/
+	{
+	// Notify all registered clients that we are about to delete the database handle
+	RUpsDbHandleSlave *p = iClientListHead;
+	while(p)
+		{
+		ASSERT(p->iClient != 0);
+		p->iClient->DbHandleAboutToBeDeleted();
+		p = p->iClientListNext;
+		}
+
+	// Delete database handle
+	delete iDatabase;
+	iDatabase = 0;
+	}
+
+TBool RUpsDbHandleMaster::IsOpen() const
+/**
+	Returns true if the handle is already open.
+*/
+	{
+	return iDatabase != 0;
+	}
+
+CDecisionDbW *RUpsDbHandleMaster::operator->()
+/**
+	Returns the database handle so -> can be used on an RUpsDbHandleMaster instance to call database functions
+
+	If the database is not already open then it calls OpenL.
+
+	This operator CAN leave.
+*/
+	{
+	if(iDatabase == 0)
+		{
+		OpenL();
+		}
+	return iDatabase;
+	}
+
+void RUpsDbHandleMaster::Register(RUpsDbHandleSlave *aClient)
+/**
+	Register new client with us.
+*/
+	{
+	BULLSEYE_OFF
+	if(aClient == 0)
+		{
+		return;
+		}
+	BULLSEYE_RESTORE
+		
+	aClient->iClientListNext = iClientListHead;
+	iClientListHead = aClient;
+	}
+
+void RUpsDbHandleMaster::UnRegister(RUpsDbHandleSlave *aClient)
+/**
+	UnRegister client with us.
+*/
+	{
+	RUpsDbHandleSlave **pp = &iClientListHead;
+BULLSEYE_OFF
+	while(*pp)
+		{
+BULLSEYE_RESTORE
+		if(*pp == aClient)
+			{
+			// Found ptr to client, so remove it.
+			*pp = (*pp)->iClientListNext;
+			aClient->iClientListNext = 0;
+			break;
+			}
+		pp = &(*pp)->iClientListNext;
+		}
+	}
+
+
+
+RUpsDbHandleSlave::RUpsDbHandleSlave(RUpsDbHandleMaster & aMaster, MDbHandleClient * aClient)
+/**
+	Initialise new client and register it with the RUpsDbHandleMaster
+
+	This class is intended for use when asynchronous database operations are being performed. These may then be failed
+	due to another database operation failing, BUT the asycnhronous operation classes (eg. a db view) needs deleting
+	before the actual database handle is deleted/re-created.
+*/
+	: iInUse(EFalse), iMaster(aMaster), iClient(aClient), iClientListNext(0)
+	{
+	ASSERT(aClient != 0);
+	//RDebug::Printf("RUpsDbHandleSlave(%x, %x) - %x\n", &aMaster, aClient, this);
+	}
+
+RUpsDbHandleSlave::~RUpsDbHandleSlave()
+	{
+	//RDebug::Printf("~RUpsDbHandleSlave() master %x client %x - %x\n", &iMaster, iClient, this);
+	Close();
+	}
+
+CDecisionDbW *RUpsDbHandleSlave::operator->()
+/**
+	Returns the database handle so -> can be used on an RUpsDbHandleMaster instance to call database functions
+
+	If the database is not already open, then the master will open it.
+
+	This operator CAN leave.
+*/
+	{
+	if(!iInUse)
+		{
+		iMaster.Register(this);
+		iInUse = ETrue;
+		}
+	return iMaster.operator->();
+	}
+
+void RUpsDbHandleSlave::SetCallback(MDbHandleClient *aClient)
+/**
+	Change what callback should be run if the master handle is closed.
+	Do NOT set it to 0.
+*/
+	{
+	ASSERT(aClient != 0);
+	//RDebug::Printf("RUpsDbHandleSlave::SetCallback client %x - %x\n", aClient, this);
+	iClient = aClient;
+	}
+
+void RUpsDbHandleSlave::Close()
+/**
+	Close this slave handle. This does NOT close the master, it just means we de-register with the
+	master to we are no longer notified if the master is closed.
+	It will automatically re-register if the -> operator is subsequently used.
+*/
+	{
+	if(iInUse)
+		{
+		iMaster.UnRegister(this);
+		iInUse = 0;
+		}
+	}
+
+void RUpsDbHandleSlave::CloseMaster()
+/**
+	Notify all client handles that the master (real) database handle is about to be closed, and then close it.
+
+	Typically used after a database error (particularly OOM) in an attempt to recover. Usually the database is not 
+	explicitly re-opened, instead the re-open is defered until the next use of the -> operator on either tha master
+	or a client handle.
+*/
+	{
+		Close();
+		iMaster.Close();
+	}
+
+
+} // End of UserPromptService namespace
+
+// End of file