/*
** 2008 February 09
**
** The author disclaims copyright to this source code. In place of
** a legal notice, here is a blessing:
**
** May you do good and not evil.
** May you find forgiveness for yourself and forgive others.
** May you share freely, never taking more than you give.
**
******************************************************************************
**
** This file contains code that is specific to windows.
*/
#include "sqliteInt.h"
#if OS_SYMBIAN /* This file is used for symbian only */
#define MAX_PATH 260
/*
** A Note About Memory Allocation:
**
** This driver uses malloc()/free() directly rather than going through
** the SQLite-wrappers sqlite3_malloc()/sqlite3_free(). Those wrappers
** are designed for use on embedded systems where memory is scarce and
** malloc failures happen frequently. Win32 does not typically run on
** embedded systems, and when it does the developers normally have bigger
** problems to worry about than running out of memory. So there is not
** a compelling need to use the wrappers.
**
** But there is a good reason to not use the wrappers. If we use the
** wrappers then we will get simulated malloc() failures within this
** driver. And that causes all kinds of problems for our tests. We
** could enhance SQLite to deal with simulated malloc failures within
** the OS driver, but the code to deal with those failure would not
** be exercised on Linux (which does not need to malloc() in the driver)
** and so we would have difficulty writing coverage tests for that
** code. Better to leave the code out, we think.
**
** The point of this discussion is as follows: When creating a new
** OS layer for an embedded system, if you use this file as an example,
** avoid the use of malloc()/free(). Those routines work ok on windows
** desktops but not so well in embedded systems.
*/
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <e32std.h>
#include <f32file.h>
#include <charconv.h>
#include <bautils.h>
#include <unistd.h>
/*
** Macros used to determine whether or not to use threads.
*/
#if defined(THREADSAFE) && THREADSAFE
# define SQLITE_W32_THREADS 1
#endif
/*
** Include code that is common to all os_*.c files
*/
#include "os_common.h"
/*
** The symbianFile structure is a subclass of sqlite3_file* specific to the win32
** portability layer.
*/
typedef struct symbianFile symbianFile;
struct symbianFile {
int isOpen;
unsigned char locktype; /* Type of lock currently held on this file */
short sharedLockByte; /* Randomly chosen byte used as a shared lock */
char fileName[512];
RFs session;
RFile file;
};
/*****************************************************************************
** The next group of routines implement the I/O methods specified
** by the sqlite3_io_methods object.
******************************************************************************/
/*
** Close a file.
**
** It is reported that an attempt to close a handle might sometimes
** fail. This is a very unreasonable result, but windows is notorious
** for being unreasonable so I do not doubt that it might happen. If
** the close fails, we pause for 100 milliseconds and try again. As
** many as MX_CLOSE_ATTEMPT attempts to close the handle are made before
** giving up and returning an error.
*/
#define MX_CLOSE_ATTEMPT 3
int winClose(sqlite3_file *id){
int rc, cnt = 0;
symbianFile *pFile = (symbianFile*)id;
pFile->file.Close();
pFile->session.Close();
return SQLITE_OK;
}
/*
** Some microsoft compilers lack this definition.
*/
#ifndef INVALID_SET_FILE_POINTER
# define INVALID_SET_FILE_POINTER ((DWORD)-1)
#endif
/*
** Read data from a file into a buffer. Return SQLITE_OK if all
** bytes were read successfully and SQLITE_IOERR if anything goes
** wrong.
*/
int winRead(
sqlite3_file *id, /* File to read from */
void *pBuf, /* Write content into this buffer */
int amt, /* Number of bytes to read */
sqlite3_int64 offset /* Begin reading at this offset */
){
int rc;
size_t got;
symbianFile *pFile = (symbianFile*)id;
assert( id!=0 );
SimulateIOError(return SQLITE_IOERR_READ);
TInt tOffset = (TInt)offset;
rc = pFile->file.Seek(ESeekStart, tOffset);
if( rc!= KErrNone){
return SQLITE_FULL;
}
HBufC8* buf = HBufC8::NewL(amt) ;
TPtr8 ptr = buf->Des();
if (pFile->file.Read(ptr, amt) != KErrNone)
{
delete buf;
return SQLITE_IOERR_READ;
}
got = buf->Length();
if( got == 0 ){
delete buf;
TInt size = 0;
if (pFile->file.Size(size) != KErrNone)
{
return SQLITE_IOERR_READ;
}
if (size == 0)
{
return SQLITE_IOERR_SHORT_READ;
}
return SQLITE_IOERR_READ;
}
memcpy(pBuf, ptr.Ptr(), got);
delete buf;
if( got == amt ){
return SQLITE_OK;
}else{
memset(&((char*)pBuf)[got], 0, amt-got);
return SQLITE_IOERR_SHORT_READ;
}
}
/*
** Write data from a buffer into a file. Return SQLITE_OK on success
** or some other error code on failure.
*/
int winWrite(
sqlite3_file *id, /* File to write into */
const void *pBuf, /* The bytes to be written */
int amt, /* Number of bytes to write */
sqlite3_int64 offset /* Offset into the file to begin writing at */
){
int rc;
symbianFile *pFile = (symbianFile*)id;
assert( id!=0 );
SimulateIOError(return SQLITE_IOERR_WRITE);
SimulateDiskfullError(return SQLITE_FULL);
TInt tOffset = (TInt)offset;
rc = pFile->file.Seek(ESeekStart, tOffset);
if( rc!= KErrNone){
return SQLITE_FULL;
}
assert( amt>0 );
rc = SQLITE_OK;
TPtrC8 ptr((TUint8 *)pBuf,amt);
if (pFile->file.Write(ptr, amt) != KErrNone) rc = SQLITE_FULL;
return rc;
}
/*
** Truncate an open file to a specified size
*/
int winTruncate(sqlite3_file *id, sqlite3_int64 nByte){
symbianFile *pFile = (symbianFile*)id;
if (pFile->file.SetSize(nByte) != KErrNone)
{
return SQLITE_IOERR;
}
return SQLITE_OK;
}
#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.
*/
int sqlite3_sync_count = 0;
int sqlite3_fullsync_count = 0;
#endif
/*
** Make sure all writes to a particular file are committed to disk.
*/
int winSync(sqlite3_file *id, int flags){
symbianFile *pFile = (symbianFile*)id;
OSTRACE3("SYNC %d lock=%d\n", pFile->h, pFile->locktype);
#ifdef SQLITE_TEST
if( flags & SQLITE_SYNC_FULL ){
sqlite3_fullsync_count++;
}
sqlite3_sync_count++;
#endif
TInt error = pFile->file.Flush();
if (error != KErrNone)
{
return SQLITE_IOERR;
}else{
return SQLITE_OK;
}
}
/*
** Determine the current size of a file in bytes
*/
int winFileSize(sqlite3_file *id, sqlite3_int64 *pSize){
symbianFile *pFile = (symbianFile*)id;
TInt size = 0;
if (pFile->file.Size(size) != KErrNone)
{
return SQLITE_IOERR;
}
*pSize = size;
return SQLITE_OK;
}
/*
** Lock the file with the lock specified by parameter locktype - one
** of the following:
**
** (1) SHARED_LOCK
** (2) RESERVED_LOCK
** (3) PENDING_LOCK
** (4) EXCLUSIVE_LOCK
**
** Sometimes when requesting one lock state, additional lock states
** are inserted in between. The locking might fail on one of the later
** transitions leaving the lock state different from what it started but
** still short of its goal. The following chart shows the allowed
** transitions and the inserted intermediate states:
**
** UNLOCKED -> SHARED
** SHARED -> RESERVED
** SHARED -> (PENDING) -> EXCLUSIVE
** RESERVED -> (PENDING) -> EXCLUSIVE
** PENDING -> EXCLUSIVE
**
** This routine will only increase a lock. The winUnlock() routine
** erases all locks at once and returns us immediately to locking level 0.
** It is not possible to lower the locking level one step at a time. You
** must go straight to locking level 0.
*/
int winLock(sqlite3_file *id, int locktype){
int rc = SQLITE_OK; /* Return code from subroutines */
int res = 1; /* Result of a windows lock call */
int newLocktype; /* Set pFile->locktype to this value before exiting */
int gotPendingLock = 0;/* True if we acquired a PENDING lock this time */
symbianFile *pFile = (symbianFile*)id;
assert( pFile!=0 );
OSTRACE5("LOCK %d %d was %d(%d)\n",
pFile->h, locktype, pFile->locktype, pFile->sharedLockByte);
// one smartphone only one application can control the database
TInt size = 0;
if (pFile->file.Size(size) == KErrNone) return SQLITE_OK;
return SQLITE_BUSY;
}
/*
** This routine checks if there is a RESERVED lock held on the specified
** file by this or any other process. If such a lock is held, return
** non-zero, otherwise zero.
*/
int winCheckReservedLock(sqlite3_file *id){
int rc;
symbianFile *pFile = (symbianFile*)id;
assert( pFile!=0 );
if( pFile->locktype>=RESERVED_LOCK ){
rc = 1;
OSTRACE3("TEST WR-LOCK %d %d (local)\n", pFile->h, rc);
}else{
TInt size = 0;
if (pFile->file.Size(size) == KErrNone) rc = 1;
OSTRACE3("TEST WR-LOCK %d %d (remote)\n", pFile->h, rc);
}
return rc;
}
/*
** Lower the locking level on file descriptor id to locktype. locktype
** must be either NO_LOCK or SHARED_LOCK.
**
** If the locking level of the file descriptor is already at or below
** the requested locking level, this routine is a no-op.
**
** It is not possible for this routine to fail if the second argument
** is NO_LOCK. If the second argument is SHARED_LOCK then this routine
** might return SQLITE_IOERR;
*/
int winUnlock(sqlite3_file *id, int locktype){
int type;
symbianFile *pFile = (symbianFile*)id;
int rc = SQLITE_OK;
assert( pFile!=0 );
return rc;
}
/*
** Control and query of the open file handle.
*/
int winFileControl(sqlite3_file *id, int op, void *pArg){
switch( op ){
case SQLITE_FCNTL_LOCKSTATE: {
*(int*)pArg = ((symbianFile*)id)->locktype;
return SQLITE_OK;
}
}
return SQLITE_ERROR;
}
/*
** Return the sector size in bytes of the underlying block device for
** the specified file. This is almost always 512 bytes, but may be
** larger for some devices.
**
** SQLite code assumes this function cannot fail. It also assumes that
** if two files are created in the same file-system directory (i.e.
** a database and its journal file) that the sector size will be the
** same for both.
*/
int winSectorSize(sqlite3_file *id){
return SQLITE_DEFAULT_SECTOR_SIZE;
}
/*
** Return a vector of device characteristics.
*/
int winDeviceCharacteristics(sqlite3_file *id){
return 0;
}
/***************************************************************************
** Here ends the I/O methods that form the sqlite3_io_methods object.
**
** The next block of code implements the VFS methods.
****************************************************************************/
void ConvertToUnicode(RFs session, TDes16& aUnicode, const char *str)
{
CCnvCharacterSetConverter *converter = CCnvCharacterSetConverter::NewL();
converter->PrepareToConvertToOrFromL(KCharacterSetIdentifierUtf8, session);
TPtrC8 ptr((const unsigned char*)str);
int state = CCnvCharacterSetConverter::KStateDefault;
converter->ConvertToUnicode(aUnicode, ptr, state);
delete converter;
}
/*
** Open a file.
*/
int winOpen(
sqlite3_vfs *pVfs, /* Not used */
const char *zName, /* Name of the file (UTF-8) */
sqlite3_file *id, /* Write the SQLite file handle here */
int flags, /* Open mode flags */
int *pOutFlags /* Status return flags */
){
symbianFile *pFile = (symbianFile*)id;
TBuf16<MAX_PATH> filename;
pFile->isOpen = 0;
memset(pFile, 0, sizeof(*pFile));
strcpy(pFile->fileName, zName);
pFile->session.Connect();
ConvertToUnicode(pFile->session, filename, zName);
int ret = 0;
if( flags & SQLITE_OPEN_CREATE ){
if (BaflUtils::FileExists(pFile->session, filename) == 1)
{
ret = pFile->file.Open(pFile->session, filename, EFileStream | EFileWrite);
}
else
{
ret = pFile->file.Create(pFile->session, filename, EFileStream | EFileWrite);
}
}
else
if( flags & SQLITE_OPEN_READWRITE ){
ret = pFile->file.Open(pFile->session, filename, EFileStream | EFileWrite);
}else{
ret = pFile->file.Open(pFile->session, filename, EFileStream | EFileRead);
}
OpenCounter(+1);
if (ret != KErrNone)
{
return SQLITE_IOERR;
}
pFile->isOpen = 1;
return SQLITE_OK;
}
/*
** Delete the named file.
**
** Note that windows does not allow a file to be deleted if some other
** process has it open. Sometimes a virus scanner or indexing program
** will open a journal file shortly after it is created in order to do
** whatever does. While this other process is holding the
** file open, we will be unable to delete it. To work around this
** problem, we delay 100 milliseconds and try to delete again. Up
** to MX_DELETION_ATTEMPTs deletion attempts are run before giving
** up and returning an error.
*/
#define MX_DELETION_ATTEMPTS 5
int winDelete(
sqlite3_vfs *pVfs, /* Not used on win32 */
const char *zFilename, /* Name of file to delete */
int syncDir /* Not used on win32 */
){
SimulateIOError(return SQLITE_IOERR_DELETE);
TBuf16<MAX_PATH> filename;
RFs session;
session.Connect();
ConvertToUnicode(session, filename, zFilename);
BaflUtils::DeleteFile(session, filename);
OSTRACE2("DELETE \"%s\"\n", zFilename);
session.Close();
return SQLITE_OK;
}
/*
** Check the existance and status of a file.
*/
int winAccess(
sqlite3_vfs *pVfs, /* Not used on win32 */
const char *zFilename, /* Name of file to check */
int flags /* Type of test to make on this file */
){
TBuf16<MAX_PATH> filename;
RFs session;
session.Connect();
ConvertToUnicode(session, filename, zFilename);
int ret = BaflUtils::FileExists(session, filename);
session.Close();
return ret;
}
/*
** Create a temporary file name in zBuf. zBuf must be big enough to
** hold at pVfs->mxPathname characters.
*/
int winGetTempname(sqlite3_vfs *pVfs, int nBuf, char *zBuf){
static char zChars[] =
"abcdefghijklmnopqrstuvwxyz"
"ABCDEFGHIJKLMNOPQRSTUVWXYZ"
"0123456789";
int i, j;
char zTempPath[MAX_PATH+1];
if( sqlite3_temp_directory ){
sqlite3_snprintf(MAX_PATH-30, zTempPath, "%s", sqlite3_temp_directory);
}
else
{
}
for(i=strlen(zTempPath); i>0 && zTempPath[i-1]=='\\'; i--){}
zTempPath[i] = 0;
sqlite3_snprintf(nBuf-30, zBuf,
"%s\\"SQLITE_TEMP_FILE_PREFIX, zTempPath);
j = strlen(zBuf);
sqlite3Randomness(20, &zBuf[j]);
for(i=0; i<20; i++, j++){
zBuf[j] = (char)zChars[ ((unsigned char)zBuf[j])%(sizeof(zChars)-1) ];
}
zBuf[j] = 0;
OSTRACE2("TEMP FILENAME: %s\n", zBuf);
return SQLITE_OK;
}
/*
** Turn a relative pathname into a full pathname. Write the full
** pathname into zOut[]. zOut[] will be at least pVfs->mxPathname
** bytes in size.
*/
int winFullPathname(
sqlite3_vfs *pVfs, /* Pointer to vfs object */
const char *zRelative, /* Possibly relative input path */
int nFull, /* Size of output buffer in bytes */
char *zFull /* Output buffer */
){
/* WinCE has no concept of a relative pathname, or so I am told. */
sqlite3_snprintf(pVfs->mxPathname, zFull, "%s", zRelative);
return SQLITE_OK;
}
#define winDlOpen 0
#define winDlError 0
#define winDlSym 0
#define winDlClose 0
/*
** Write up to nBuf bytes of randomness into zBuf.
*/
int winRandomness(sqlite3_vfs *pVfs, int nBuf, char *zBuf){
int i;
for (i=0; i<nBuf; ++i)
{
zBuf[i] = rand() % 255;
}
return nBuf;
}
/*
** Sleep for a little while. Return the amount of time slept.
*/
int winSleep(sqlite3_vfs *pVfs, int microsec){
return sleep(microsec / 1000);
}
/*
** The following variable, if set to a non-zero value, becomes the result
** returned from sqlite3OsCurrentTime(). This is used for testing.
*/
#ifdef SQLITE_TEST
int sqlite3_current_time = 0;
#endif
/*
** Find the current time (in Universal Coordinated Time). Write the
** current time and date as a Julian Day number into *prNow and
** return 0. Return 1 if the time and date cannot be found.
*/
int winCurrentTime(sqlite3_vfs *pVfs, double *prNow){
double now;
now = time(NULL);
*prNow = now;
return 0;
}
/*
** Return a pointer to the sqlite3DefaultVfs structure. We use
** a function rather than give the structure global scope because
** some compilers (MSVC) do not allow forward declarations of
** initialized structures.
*/
sqlite3_vfs *sqlite3OsDefaultVfs(void){
static sqlite3_vfs winVfs = {
1, /* iVersion */
-1, /* szOsFile */
MAX_PATH, /* mxPathname */
0, /* pNext */
"symbian", /* zName */
0, /* pAppData */
};
winVfs.szOsFile = sizeof(symbianFile);
return &winVfs;
}
#endif /* OS_SYMBIAN */