/*

* Copyright (c) 2005-2006 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: 

*

*/

#ifdef  OS_SYMBIAN

#ifdef __cplusplus

extern "C" {

#endif

#include "sqliteInt.h"

#include "os.h"

#ifdef __cplusplus

}  /* End of the 'extern "C"' block */

#endif

#include "os_common.h"

#include "os_symbian.h"

#include <f32file.h>

#include <e32math.h>

#include <hal.h>

#include <BAUTILS.H>

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

//Panic category - used by asserts in this file.

_LIT(KPanicCategory, "SqliteSymbian");

//Panic codes - used by asserts in this file.

enum TPanicCodes

    {

    EPanicNullTlsPtr            = 1,

    EPanicInvalidWAmount        = 2,

    EPanicOffset64bit           = 3,

    EPanicInvalidLockType1      = 4,

    EPanicInvalidLockType2      = 5,

    EPanicInvalidLockType3      = 6,

    EPanicInvalidLockType4      = 7,

    EPanicInvalidLockType5      = 8,

    EPanicInvalidLockType6      = 9,

    EPanicInvalidLockType7      =10,

    EPanicInvalidOpType         =11,

    EPanicInvalidFhStr          =12,

    EPanicInvalidFhData         =13

    };

//Define __COUNT_FILE_IO__ if want to get information about the file I/O 

//operations count and the time spent in file I/O operations.

#ifdef __COUNT_FILE_IO__

//File I/O counters.

static TDbFileIOCounters TheDbFileIOCounters;

/**

Resets all file I/O counters.

This function is part of Symbian OS specific SQLITE API.

@internalComponent

*/

void sqlite3SymbianZeroDbFileIOCounters()

    {

    Mem::FillZ(&TheDbFileIOCounters, sizeof(TheDbFileIOCounters));

    }

/**

Copies file I/O counters to the place pointed by aDbFileIOCounters argument.

@param aDbFileIOCounters Output parameter. The place where file I/O counters will be copied.

This function is part of Symbian OS specific SQLITE API.

@internalComponent

*/

void sqlite3SymbianGetDbFileIOCounters(TDbFileIOCounters& aDbFileIOCounters)

    {

    aDbFileIOCounters = TheDbFileIOCounters;

    }

//The following macros are used for managing file I/O counter values.

//They are evaluated to nothing if __COUNT_FILE_IO__ is not defined.

#define INC_COUNTER(cnt)            ++cnt

#define GET_TIME(start)             TUint32 start = User::FastCounter()

#define ADD_TIME_DIFF(start, var)   var += (User::FastCounter() - start);

#else//__COUNT_FILE_IO__  //////////////////////////////////////////

//The following macros are used for managing file I/O counter values.

//They are evaluated to nothing if __COUNT_FILE_IO__ is not defined.

#define INC_COUNTER(cnt)            void(0)

#define GET_TIME(start)             void(0)

#define ADD_TIME_DIFF(start, var)   void(0)

#endif//__COUNT_FILE_IO__

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

//If the following global variable points to a string which is the

//name of a directory, then that directory will be used to store

//temporary files.

//

//"PRAGMA temp_store_directory <dir_path>" command will set it!

//This is a potential platform security hole and the temp dir path

//is not used in os_symbian.cpp file. The temporaty files will be created

//in the process's private data cage.

//

//There is a memory leak in SQLite if "PRAGMA temp_store_directory <dir_path>" is used,

//because sqlite3_temp_directory stays undeleted when the program terminates.

//So, it will be deleted in sqlite3SymbianFsClose() method.

char *sqlite3_temp_directory;

//Current thread's heap. Won't work in a mutithreaded environment.

//Stored as a global variable to reduce Exec::Heap() calls count (made from User::Alloc()).

static RAllocator* TheAllocator = NULL;

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

// Static variables used for thread synchronization

static TInt     TheMutexRefCounter = 0;

//Zeroed thread data instance.

const ThreadData TheZeroThreadData = {0};

//Const buffer used for generating temporary file names.

//No lower case letters in the buffer because the OS won't make difference between lower and upper case in file names.

const char TheChars[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";

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

/////////////////////       TTlsData class - declaration, definition    ///////////////////

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

//TTlsData class manages a per-thread copy of the following data: 

//  - file session instance;

//  - process's private data path, where the temporary file will be stored (on Drive C);

//  - last OS error code, every Symbian OS API call will set it;

//  - stored OS error code, initialized with the last OS error code only if stored OS error code is KErrNone.

//      Each StoredOsErrorCode() call will reset it to KErrNone;

//  - reference counter. Only one TTlsData instance gets created per thread;

//

//The reason of having two data members for storing the OS error codes is that if there is just one variable

//and it gets initialized with the error value reported by a failed OS API call, the next successful OS API

//call will reset it and the TTlsData client will miss the last "real" OS API error.

class TTlsData

    {

public: 

    static TInt Create();

    static void Release();

    static TTlsData& Instance();

    TInt SetOsErrorCode(TInt aError);

    inline TInt StoredOsErrorCode();

    inline void StoreFhData(const RMessage2* aMsg, TBool aReadOnly);

    inline void RetrieveAndResetFhData(const RMessage2*& aMsg, TBool& aReadOnly);

private:

    TTlsData();

    ~TTlsData();

    TInt DoCreate();

public:

    //File session instance.

    RFs         iFs;

    //"<system drive>:\" + process's private data path. Initialized in sqlite3SymbianFsOpen().

    //Used for storing sqlite temporary files.

    TFileName   iSysPrivDir;

    TParse      iParse;

private:    

    //Contains the last OS error code.

    TInt                iStoredOsErrorCode;

    //Counts the number of times when an attempt has been made to create TTlsData instance.

    //TTlsData instance is created just once. This counter is useless in a true client-server

    //environment, but is very usefull when testing the prototype.

    TInt                iRefCounter;

    //Fh data

    const RMessage2*    iMessage;

    TBool               iReadOnly;  

    };

//Returns the address of TlsHandle1() function. Used as a unique handle when calling UserSvr::DllTls()

//and UserSvr::DllSetTls(). 

//So, if the SQL server is a single threaded process, there is a need of only one TLS instance, identified

//uniquely by TlsHandle1() address.

static TInt TlsHandle1()

    {

    return reinterpret_cast <TInt> (&TlsHandle1);

    }

//Checks if the TTlsData instance exists and if not the method creates it and stores it in the TLS.

//The TTlsData instance reference counter is incremented.

TInt TTlsData::Create()

    {

    TTlsData* data = static_cast <TTlsData*> (UserSvr::DllTls(TlsHandle1()));

    if(!data)

        {

        data = new TTlsData;

        if(!data)

            {

            return KErrNoMemory;    

            }

        TInt err = data->DoCreate();

        if(err == KErrNone)

            {

            err = UserSvr::DllSetTls(TlsHandle1(), data);

            }

        if(err != KErrNone)

            {

            delete data;

            return err;

            }

        }

    ++data->iRefCounter;

    //Do not delete "data"! The TLS keeps a pointer to it.

    return KErrNone;

    }

//Destroys the TTlsData instance if it exists and the decremented reference counter reaches 0.

void TTlsData::Release()

    {

    TTlsData* data = static_cast <TTlsData*> (UserSvr::DllTls(TlsHandle1()));

    if(data && !--data->iRefCounter)

        {

        sqliteFree((void*)sqlite3_temp_directory);

        sqlite3_temp_directory = 0;

        sqlite3_thread_cleanup();

        delete data;

        (void)UserSvr::DllSetTls(TlsHandle1(), 0);

        }

    }

//Returns a reference to the TTlsData instance. 

TTlsData& TTlsData::Instance()

    {

    TTlsData* data = static_cast <TTlsData*> (UserSvr::DllTls(TlsHandle1()));

    if (data == NULL) {

        sqlite3SymbianLibInit();

        data = static_cast <TTlsData*> (UserSvr::DllTls(TlsHandle1()));

    }

    __ASSERT_ALWAYS(data != NULL, User::Panic(KPanicCategory, EPanicNullTlsPtr));

    return *data;

    }

//Sets the last OS error code data member. The stored OS error code data member will be set only if it is

//KErrNone. (If it is not KErrNone it means that its value has not been accessed yet)

//An exception from the rule described above is KErrDiskFull error which, if happens, will be set always, because

//this error has a special meaning for the database clients - special actions may have to be taken if the

//disk is full.

//If aError is KErrNoMemory SQLITE will be notified with a sqlite3FailedMalloc() call.

TInt TTlsData::SetOsErrorCode(TInt aError)

    {

    if(aError == KErrNoMemory)

        {

        sqlite3FailedMalloc();          

        }

    if(iStoredOsErrorCode == KErrNone || aError == KErrDiskFull)

        {

        iStoredOsErrorCode = aError;

        }

    return aError;

    }

//Returns the last stored OS error code, which was stored by SetOsErrorCode() call.

//The function also resets the stored OS error code to KErrNone.

inline TInt TTlsData::StoredOsErrorCode()

    {

    TInt err = iStoredOsErrorCode;

    iStoredOsErrorCode = KErrNone;

    return err;

    }

//Stores RMessage2 address, file and file session handles and the read-only flag for use when SQLITE issues a 

//request for open the database file. 

inline void TTlsData::StoreFhData(const RMessage2* aMsg, TBool aReadOnly)

    {

    iMessage = aMsg;

    iReadOnly = aReadOnly;

    }

//Retrieves RMessage2 address, file and file session handles. The stored data will be reset.    

inline void TTlsData::RetrieveAndResetFhData(const RMessage2*& aMsg, TBool& aReadOnly)

    {

    __ASSERT_DEBUG(iMessage != NULL, User::Panic(KPanicCategory, EPanicInvalidFhData));

    aMsg = iMessage; 

    aReadOnly = iReadOnly;

    iMessage = NULL;

    }

//Reference counter is set to 0.

TTlsData::TTlsData() :

    iStoredOsErrorCode(KErrNone),

    iRefCounter(0),

    iMessage(0),

    iReadOnly(EFalse)   

    {

    }

//Closes the file session.

TTlsData::~TTlsData()

    {

    iFs.Close();    

    }

//Creates per-thread file session instance. 

//Creates the private path, where the temporary files will be stored. (on the system drive)

TInt TTlsData::DoCreate()

    {

    TInt err = iFs.Connect();

    if(err != KErrNone)

        {

        return err; 

        }

    //Get the system drive

    TDriveNumber drv;

    err = BaflUtils::GetSystemDrive( drv );

    if(err == KErrNotFound )

        {

        drv = EDriveC;

        err = KErrNone;

        }

    if( err == KErrNone )

        {

        TInt sysDrive = static_cast<TInt>(drv);

        if((err = iFs.CreatePrivatePath(sysDrive)) != KErrNone && err != KErrAlreadyExists)

            {

            return err; 

            }

        TFileName privateDir;

        if((err = iFs.PrivatePath(privateDir)) != KErrNone)

            {

            return err; 

            }

        TDriveUnit drive(sysDrive);

        TDriveName driveName = drive.Name();

        (void)iParse.Set(driveName, &privateDir, 0);//this call can't fail

        iSysPrivDir.Copy(iParse.DriveAndPath());

        return KErrNone;

        }

    return err;    

    }

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

//aFileName argument is expected to point to UTF8 encoded, zero terminated string.

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

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

//aFileNameDestBuf max length must be at least KMaxFileName characters.

//

//aFileNameDestBuf will hold UTF16, non-zero-terminated string

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;

    }

//aFileName argument is expected to point to UTF16 encoded, zero terminated string.

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

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

//aFileNameDestBuf max length must be at least KMaxFileName characters.

//

//aFileNameDestBuf will hold UTF8, non-zero-terminated string

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;

    }

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

//////////////////          File name, containing handles, related   //////////////////////

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

const char KFhSeparator = '|';  //The symbol, which when used in the file name means that the string does not contain a real file name but file handles

const TInt KFhSessHandleIdx = 2;//The index of the file session handle in RMessage2 object

const TInt KFhFileHandleIdx = 3;//The index of the file handle in RMessage2 object

const TInt KFhReconPos = 0;     //if the symbol in this position KFhSeparator, then the string contains file handles

const TInt KFhRoPos = 1;        //read-only flag position in the string

const TInt KFhMsgAddrPos = 2;   //RMessage2 address position in the string

const TInt KFhMsgAddrLen = 8;   //RMessage2 address length

//const TInt KFhDrivePos = 1;   //Drive position in the string (after removing the read-only flag and RMessage2 object's address)

//Possible file name string types.

enum TFhStrType

    {

    ENotFhStr,                      //The string does not contain file handles

    EFhStr,                         //The string contain file handles, but is not main db file

    EFhMainDbStr                    //The string contain file handles and is the main db file

    };

//Returns:

// - ENotFhStr    - aFileName is a normal file name

// - EFhMainDbStr - aFile name contains the handle of a database file opened on the client side (and some other relevant information)

// - EFhStr       - aFileName is a journal file name for example. The main database file was opened from a handle in this case.

static TFhStrType FhStringProps(const char* aFileName)

    {

    char* first = strchr(aFileName, KFhSeparator);

    if(!first)

        {

        return ENotFhStr;

        }

    char* last = strchr(first + 1, KFhSeparator);

    if(!last)

        {

        return ENotFhStr;

        }

    return *(last + 1) == 0 ? EFhMainDbStr : EFhStr;

    }

//Replaces all invalid characters in aFileName.

static void FhConvertToFileName(TDes& aFileName, TParse& aParse, const TDesC& aPrivateDir)

    {

    TInt firstPos = aFileName.Locate(TChar(KFhSeparator));

    if(firstPos >= 0)

        {

        aFileName.Delete(firstPos, 1);

        TInt lastPos = aFileName.LocateReverse(TChar(KFhSeparator));

        if(lastPos >= 0)

            {

            aFileName.Delete(lastPos, 1);

            (void)aParse.Set(aFileName, &aPrivateDir, 0);//the file name should be verified by the server

            aFileName.Copy(aParse.FullName());

            }

        }

    }

//Extracts read-only flag and RMessage address from aDbFileName and stores them in TLS.

//aDbFileName will be reformatted and won't contain the already extracted data.

//aDbFileName format is:

//      |<R/O flag><RMessage2 pointer><drive><app SID><file_name><file_ext>|

static void FhExtractAndStore(TDes& aDbFileName, TTlsData& aTls)

    {

    TInt fhStartPos = aDbFileName.Locate(TChar(KFhSeparator));

    __ASSERT_DEBUG(fhStartPos == KFhReconPos, User::Panic(KPanicCategory, EPanicInvalidFhStr));

    //If this file name string contains file handles

    if(fhStartPos == KFhReconPos)

        {

        //Extract from aDbFileName string RMessage2 object's address

        TLex lex(aDbFileName.Mid(fhStartPos + KFhMsgAddrPos, KFhMsgAddrLen));

        TUint32 addr;

        TInt err = lex.Val(addr, EHex);

        __ASSERT_DEBUG(err == KErrNone, User::Panic(KPanicCategory, EPanicInvalidFhStr));

        if(err == KErrNone)

            {

            //Cast the address to RMessage2 pointer.

            const RMessage2* msg = reinterpret_cast <const RMessage2*> (addr);

            __ASSERT_DEBUG(msg != NULL, User::Panic(KPanicCategory, EPanicInvalidFhStr));

            if(msg)

                {

                //Store the data from aDbFileName in TLS

                TBool readOnly = aDbFileName[fhStartPos + KFhRoPos] > '0';

                aTls.StoreFhData(msg, readOnly);

                //Remove: read-only flag and RMessage2 object's address

                aDbFileName.Delete(fhStartPos + KFhRoPos, 1 + KFhMsgAddrLen);

                }

            }

        }

    }

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

///////////////////////     Symbian OS specific SQLITE API         ////////////////////////

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

/**

Returns the last OS error which occured durring the operations with the database files.

The per-thread variable, where the last OS error is hold, will be set to KErrNone.

This function is part of Symbian OS specific SQLITE API.

@return The last OS error.

@internalComponent

*/

EXPORT_C TInt sqlite3SymbianLastOsError(void)

    {

    TTlsData& tls = TTlsData::Instance();

    return tls.StoredOsErrorCode();

    }

/**

This function must be called once before any other SQLITE API call. It does Symbian OS specific

initialization. Each sqlite3SymbianLibInit() call must be paired with a sqlite3SymbianLibFinalize() call

when finishing working with SQLITE.

This function is part of Symbian OS specific SQLITE API.

@return Symbian OS specific error code, including KErrNoMemory.

@internalComponent

*/

EXPORT_C TInt sqlite3SymbianLibInit(void)

    {