// 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:

// os_symbian.cpp

// The Symbian OS porting layer - multi-threaded implementation.

// SQLite never accesses the file system and the OS services directly.

// SQLite uses for that sqlite3_vfs and sqlite3_file objects.

// sqlite3_vfs and sqlite3_file functionality is implemented in this file - 

// TVfs and TFileIo classes.

// 

//

/**

 @file

 @see TVfs

 @see TFileIo

*/

#ifdef  SQLITE_OS_SYMBIAN

extern "C" 

	{

	#include "sqliteInt.h"

	#include "os.h"

	#include "os_common.h"

	}

#include <e32math.h>

#include "os_symbian.h"

#include "UTraceSqlite.h"

#ifdef SQLITE_TEST

//Count the number of fullsyncs and normal syncs.  This is used to test

//that syncs and fullsyncs are occuring at the right times.

extern "C" int sqlite3_sync_count = 0;

extern "C" int sqlite3_fullsync_count = 0;

//The following variable, if set to a non-zero value, becomes the result

//returned from sqlite3OsCurrentTime().  This is used for testing.

extern "C" int sqlite3_current_time = 0;

#endif//SQLITE_TEST

_LIT(KCwd, ".\\");

//Used for the random numbers generation

static inline TInt64& Seed()

	{

	static TInt64 seed = 0;

	if(seed == 0)

		{

		TTime now;

		now.UniversalTime();

		seed = now.Int64();

		}

	return seed;

	}

/**

Os2SqliteErr() is called at the end of many of the interface functions of the OS porting layer (wherever it is appropriate - 

TFileIo and TVfs interfaces). The purpose of this function is to identify the "out of memory" and "disk is full" errors

reported by the used Symbian OS APIs (aOsErr parameter) and report them to SQLite as SQLITE_FULL and SQLITE_NOMEM errors.

The KErrEof error (TFileIo::Read() can return KErrEof) is reported to SQLite as SQLITE_IOERR_SHORT_READ. The rest of failures

are reported as the error specified in aDefaultErr parameter.

@param aOsErr      Symbian OS error

@param aDefaultErr The default SQLite error that should be used if the aOsErr parameter is not one of:

                     KErrNone, KErrEof, KErrNoMemory, KErrDiskFull

@return SQLITE_OK,               The OS porting layer function call has completed successfully, 

          SQLITE_IOERR_SHORT_READ, The amount of the data read is less than the requested amount,

          SQLITE_IOERR_NOMEM,      Out of memory,

          SQLITE_FULL,             The disk is full,

          aDefaultErr,             The rest of failures will be reported as aDefaultErr.

*/

static TInt Os2SqliteErr(TInt aOsErr, TInt aDefaultErr)

	{

	switch(aOsErr)

		{

		case KErrNone:

			return SQLITE_OK;	

		case KErrEof:

			return SQLITE_IOERR_SHORT_READ;

		case KErrNoMemory:

			return SQLITE_IOERR_NOMEM;

		case KErrDiskFull:

			return SQLITE_FULL;

		default:

#ifdef _DEBUG		

			RDebug::Print(_L("SQLite3 C API, Os2SqliteErr(), err=%d\n"), aOsErr);

#endif			

			break;

		}

	return aDefaultErr;

	}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

//////////////////////////  TStaticFs  /////////////////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

/**

Connects the file session used by the SQLite OS porting layer.

Single RFs instance per process is used.

@return KErrNone The operation was completed successfully,

                 System-wide error code if the operation has failed.

*/

TInt TStaticFs::Connect()

	{

	TInt err = iFs.Connect();

	if(err == KErrNone)	

		{

		err = iFs.ShareAuto();	

		}

	if(err != KErrNone)

		{

		iFs.Close();	

		}

	return err;

	}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

//////////////////////////  sqlite3_mutex  /////////////////////////////////////////////////////////////////////////////////////            

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

/**

Initializes sqlite3_mutex data members with their default values.

*/

sqlite3_mutex::sqlite3_mutex() :

	iRefCount(0),

	iOwnerThreadId(KMaxTUint64)

	{

	}

/**

Closes the mutex handle.

*/

sqlite3_mutex::~sqlite3_mutex()

	{

	iMutex.Close();

	}

/**

Gives the calling thread an exclusive access to the SQLite resources (global variables, file handles, buffers, cache, etc.).

The calling thread becomes a mutex owner.

If the mutex is already locked by another thread, the calling thread will block until the other thread releases the mutex.

The method can be called by the mutex owning thread more than once, even if the mutex is already entered.

*/

void sqlite3_mutex::Enter()

	{

	iMutex.Wait();

	RThread currThread;

	iOwnerThreadId = currThread.Id();

	++iRefCount;

	}

/**

Unlocks the mutex. If sqlite3_mutex::Enter() was called more than once by the owning thread, then the number of 

sqlite3_mutex::Leave() calls must eventually match the number of sqlite3_mutex::Enter() calls.

If there are thread(s) blocked on sqlite3_mutex::Enter(), after the mutex gets unlocked one of the waiting threads

will be able to lock the mutex and get an exclusive access to the guarded resources.

@panic SqliteMt 23 Negative mutex lock counter (in debug builds only)

@panic SqliteMt 24 The mutex has been entered (locked) by a different thread than the current one (in debug builds only)

*/

void sqlite3_mutex::Leave()

	{

	__ASSERT_DEBUG(iRefCount > 0, User::Panic(KPanicCategory, EPanicMutexLockCounter));

#ifdef _DEBUG

	RThread currThread;	

	__ASSERT_DEBUG(iOwnerThreadId == currThread.Id(), User::Panic(KPanicCategory, EPanicMutexOwner));

#endif

	--iRefCount;

	iMutex.Signal();

	}

/**

Returns true if the mutex is already locked (entered).

@return True if the mutex is locked, false otherwise

*/

TBool sqlite3_mutex::IsHeld() const

	{

	RThread currThread;

	return iRefCount != 0 && iOwnerThreadId == currThread.Id();

	}

/**

Creates the mutex.

@return KErrNone The operation was completed successfully,

                 System-wide error code if the operation has failed.

*/

TInt sqlite3_mutex::Create()

	{

	return iMutex.CreateLocal();

	}

/**

Creates new CRecursiveMutex object.

@return A pointer to the created CRecursiveMutex object or NULL if the operation has failed.

*/

CRecursiveMutex* CRecursiveMutex::New()

	{

	CRecursiveMutex* self = new CRecursiveMutex;

	if(self)

		{

		if(self->Create() != KErrNone)

			{

			delete self;	

			self = NULL;

			}

		}

	return self;

	}

CRecursiveMutex::~CRecursiveMutex()

	{

	}

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

//////////////////////////  TMutexApi  ////////////////////////////////////////////////////////////////////////////////////////

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

/**

Initializes the mutex system.

No-op function.

@return SQLITE_OK

*/

int TMutexApi::Init()

	{

	SQLUTRACE_PROFILER(0);

	return SQLITE_OK;

	}

/**

Finalizes the mutex system.

No-op function.

@return SQLITE_OK

*/

int TMutexApi::End()

	{

	SQLUTRACE_PROFILER(0);

	return SQLITE_OK;

	}

/**

Creates a new mutex.

If the request is for a static mutex, a pointer to already created static mutex will be returned.

@param aType  The mutex type: static, fast, recursive

@return A pointer to the created mutex or NULL if the operation has failed

*/

sqlite3_mutex* TMutexApi::Alloc(int aType)

	{

	SQLUTRACE_PROFILER(0);

	sqlite3_mutex* mutex = NULL;

	switch(aType)

		{

		case SQLITE_MUTEX_FAST:

		case SQLITE_MUTEX_RECURSIVE:

			mutex = CRecursiveMutex::New();

			break;

		default:

			mutex = ::StaticMutex(aType - 2);

			break;	

		}

	return mutex;

	}

/**

Destroys a mutex, created previously by a call to TMutexApi::Alloc().

@param aMutex Pointer to the mutex object that has to be destroyed

*/

void TMutexApi::Free(sqlite3_mutex* aMutex)

	{

	SQLUTRACE_PROFILER(0);

	delete aMutex;

	}

/**

Locks the mutex.

See sqlite3_mutex::Enter() for more details.

@param aMutex Pointer to the mutex object

@see sqlite3_mutex::Enter()

*/

void TMutexApi::Enter(sqlite3_mutex* aMutex)

	{

	SQLUTRACE_PROFILER(0);

	aMutex->Enter();

	}

/**

No-op. Always returns SQLITE_BUSY.

@return SQLITE_BUSY

*/

int TMutexApi::Try(sqlite3_mutex*)

	{

	SQLUTRACE_PROFILER(0);

	return SQLITE_BUSY;

	}

/**

Unlocks the mutex.

See sqlite3_mutex::Leave() for more details.

@param aMutex Pointer to the mutex object

@see sqlite3_mutex::Leave()

*/

void TMutexApi::Leave(sqlite3_mutex* aMutex)

	{

	SQLUTRACE_PROFILER(0);

	aMutex->Leave();

	}

/**

Checks whether the mutex is locked or not.

See sqlite3_mutex::IsHeld() for more details.

@param aMutex Pointer to the mutex object

@return True if the mutex is locked, false otherwise

@see sqlite3_mutex::IsHeld()

*/

int TMutexApi::Held(sqlite3_mutex* aMutex)

	{

	SQLUTRACE_PROFILER(0);

	return aMutex->IsHeld();

	}

/**

Checks whether the mutex is locked or not.

See sqlite3_mutex::IsHeld() for more details.

@param aMutex Pointer to the mutex object

@return False if the mutex is locked, true otherwise

@see sqlite3_mutex::IsHeld()

*/

int TMutexApi::Notheld(sqlite3_mutex* aMutex)

	{

	SQLUTRACE_PROFILER(0);

	return !aMutex->IsHeld();

	}

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

///////////////////////////////////       SQLite init/release functions     ///////////////////////////////////////////////////

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

/**

Initializes the OS porting layer global data.

*/

extern "C" SQLITE_EXPORT int sqlite3_os_init(void)

	{

	return sqlite3_vfs_register(VfsApi(), 1);

	}

/**

Destroys the OS porting layer global data.

*/

extern "C" SQLITE_EXPORT int sqlite3_os_end(void)

	{

	return sqlite3_vfs_unregister(VfsApi());

	}

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

//////////////////////////  TheFileIoApi  /////////////////////////////////////////////////////////////////////////////////////

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

/**

Single sqlite3_io_methods instance, which data members (function pointers) are initialized with the addresses of

TFileIo members. 

TheFileIoApi is used by SQLite for performing OS independent file I/O.

@see TFileIo

@see TVfs

@internalComponent

*/

const static sqlite3_io_methods TheFileIoApi = 

	{

	1,						//Version

	&TFileIo::Close,

	&TFileIo::Read,

	&TFileIo::Write,

	&TFileIo::Truncate,

	&TFileIo::Sync,

	&TFileIo::FileSize,

	&TFileIo::Lock,

	&TFileIo::Unlock,

	&TFileIo::CheckReservedLock,

	&TFileIo::FileControl,

	&TFileIo::SectorSize,

	&TFileIo::DeviceCharacteristics

	};

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

//////////////////////////  TheMutexMethods  //////////////////////////////////////////////////////////////////////////////////

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

/**

*/

static sqlite3_mutex_methods TheMutexMethods =

	{

	&TMutexApi::Init,

	&TMutexApi::End,

	&TMutexApi::Alloc,

	&TMutexApi::Free,

	&TMutexApi::Enter,

	&TMutexApi::Try,

	&TMutexApi::Leave,

	&TMutexApi::Held,

	&TMutexApi::Notheld

	};

extern "C" sqlite3_mutex_methods* sqlite3DefaultMutex(void)

	{

	return &TheMutexMethods;

	};

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

//////////////////          UTF16<-->UTF8, conversion functions    ////////////////////////////////////////////////////////////

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

/**

The function converts aFileName to UTF16 encoded file name, and stores the UTF16 encoded file name

to the place pointed by aFileNameDestBuf argument.

If the UTF16 conversion of the file name failed because the file name is too long or NULL, 

the function returns EFalse. 

@param aFileName Expected to point to UTF8 encoded, zero terminated string.

				 Max allowed aFileName length is KMaxFileName (excluding terminating 0 character).

@param aFileNameDestBuf Output parameter. Will hold UTF16, non-zero-terminated string.

						The max length must be at least KMaxFileName characters.

@return True if the conversion has been completed successfully						 

*/

static TBool ConvertToUnicode(const char *aFileName, TDes& aFileNameDestBuf)

	{

	if(aFileName)

		{

		wchar_t* dest = reinterpret_cast <wchar_t*> (const_cast <TUint16*> (aFileNameDestBuf.Ptr()));

		TInt len = mbstowcs(dest, aFileName, KMaxFileName);

		//Check the file name length. If it is longer than KMaxFileName characters, then the file name is not valid.

		if(len > 0 && len <= KMaxFileName)

			{

			aFileNameDestBuf.SetLength(len);

			return ETrue;

			}

		}

	return EFalse;

	}

/**

The function converts aFileName to UTF8 encoded file name, and stores the UTF8 encoded file name

to the place pointed by aFileNameDestBuf argument.

If the UTF8 conversion of the file name failed because the file name is too long or NULL, 

the function returns EFalse. 

@param aFileName Expected to point to UTF16 encoded, zero terminated string.

				 Max allowed aFileName length is KMaxFileName (excluding terminating 0 character).

@param aFileNameDestBuf Output parameter. Will hold UTF8, non-zero-terminated string.

						The max length must be at least KMaxFileName characters.

@return True if the conversion has been completed successfully						 

*/

static TBool ConvertFromUnicode(const TDesC& aFileName, TDes8& aFileNameDestBuf)

	{

	char* dest = reinterpret_cast <char*> (const_cast <TUint8*> (aFileNameDestBuf.Ptr()));

	const wchar_t* src = reinterpret_cast <const wchar_t*> (aFileName.Ptr());

	TInt len = wcstombs(dest, src, KMaxFileName);

	//Check the file name length. If it is longer than KMaxFileName characters, then the file name is not valid.

	if(len > 0 && len <= KMaxFileName)

		{

		aFileNameDestBuf.SetLength(len);

		return ETrue;

		}

	return EFalse;

	}

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

/////////////////////       TDbFile class definition    ///////////////////////////////////////////////////////////////////////

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

const TInt KFileBufSize = 8 * 1024;	

/**

Initializes TDbFile data members with their default values.

*/

inline TDbFile::TDbFile() :

	iFileBuf(KFileBufSize),

	iFullName(NULL),

	iSharedLockByte(0),

	iLockType(SQLITE_LOCK_NONE),

	iReadOnly(EFalse),

	iSectorSize(0),

	iDeviceCharacteristics(-1)

	{

	pMethods = 0;

	}

/**

Casts the passed sqlite3_file pointer to a reference to the derived class - TDbFile&.

All sqlite3_file pointers passed to TFileIo methods are actually pointers to TDbFile instances. 

So the cast is safe.

@param aDbFile A pointer to a sqlite3_file instance

@return A TDbFile reference. 

@see TFileIo