/*

** 2008 Jan 22

**

** 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 modified the OS layer in order to simulate

** different device types (by overriding the return values of the

** xDeviceCharacteristics() and xSectorSize() methods).

*/

#if SQLITE_TEST /* This file is used for testing only */

#include "sqlite3.h"

#include "sqliteInt.h"

/*

** Maximum pathname length supported by the devsym backend.

*/

#define DEVSYM_MAX_PATHNAME 512

/*

** Name used to identify this VFS.

*/

#define DEVSYM_VFS_NAME "devsym"

typedef struct devsym_file devsym_file;

struct devsym_file {

sqlite3_file base;

sqlite3_file *pReal;

};

/*

** Method declarations for devsym_file.

*/

static int devsymClose(sqlite3_file*);

static int devsymRead(sqlite3_file*, void*, int iAmt, sqlite3_int64 iOfst);

static int devsymWrite(sqlite3_file*,const void*,int iAmt, sqlite3_int64 iOfst);

static int devsymTruncate(sqlite3_file*, sqlite3_int64 size);

static int devsymSync(sqlite3_file*, int flags);

static int devsymFileSize(sqlite3_file*, sqlite3_int64 *pSize);

static int devsymLock(sqlite3_file*, int);

static int devsymUnlock(sqlite3_file*, int);

static int devsymCheckReservedLock(sqlite3_file*, int *);

static int devsymFileControl(sqlite3_file*, int op, void *pArg);

static int devsymSectorSize(sqlite3_file*);

static int devsymDeviceCharacteristics(sqlite3_file*);

static int devsymShmLock(sqlite3_file*,int,int,int);

static int devsymShmMap(sqlite3_file*,int,int,int, void volatile **);

static void devsymShmBarrier(sqlite3_file*);

static int devsymShmUnmap(sqlite3_file*,int);

/*

** Method declarations for devsym_vfs.

*/

static int devsymOpen(sqlite3_vfs*, const char *, sqlite3_file*, int , int *);

static int devsymDelete(sqlite3_vfs*, const char *zName, int syncDir);

static int devsymAccess(sqlite3_vfs*, const char *zName, int flags, int *);

static int devsymFullPathname(sqlite3_vfs*, const char *zName, int, char *zOut);

#ifndef SQLITE_OMIT_LOAD_EXTENSION

static void *devsymDlOpen(sqlite3_vfs*, const char *zFilename);

static void devsymDlError(sqlite3_vfs*, int nByte, char *zErrMsg);

static void (*devsymDlSym(sqlite3_vfs*,void*, const char *zSymbol))(void);

static void devsymDlClose(sqlite3_vfs*, void*);

#endif /* SQLITE_OMIT_LOAD_EXTENSION */

static int devsymRandomness(sqlite3_vfs*, int nByte, char *zOut);

static int devsymSleep(sqlite3_vfs*, int microseconds);

static int devsymCurrentTime(sqlite3_vfs*, double*);

static sqlite3_vfs devsym_vfs = {

2, /* iVersion */

sizeof(devsym_file), /* szOsFile */

DEVSYM_MAX_PATHNAME, /* mxPathname */

0, /* pNext */

DEVSYM_VFS_NAME, /* zName */

0, /* pAppData */

devsymOpen, /* xOpen */

devsymDelete, /* xDelete */

devsymAccess, /* xAccess */

devsymFullPathname, /* xFullPathname */

#ifndef SQLITE_OMIT_LOAD_EXTENSION

devsymDlOpen, /* xDlOpen */

devsymDlError, /* xDlError */

devsymDlSym, /* xDlSym */

devsymDlClose, /* xDlClose */

#else

0, /* xDlOpen */

0, /* xDlError */

0, /* xDlSym */

0, /* xDlClose */

#endif /* SQLITE_OMIT_LOAD_EXTENSION */

devsymRandomness, /* xRandomness */

devsymSleep, /* xSleep */

devsymCurrentTime, /* xCurrentTime */

0, /* xGetLastError */

0 /* xCurrentTimeInt64 */

};

static sqlite3_io_methods devsym_io_methods = {

2, /* iVersion */

devsymClose, /* xClose */

devsymRead, /* xRead */

devsymWrite, /* xWrite */

devsymTruncate, /* xTruncate */

devsymSync, /* xSync */

devsymFileSize, /* xFileSize */

devsymLock, /* xLock */

devsymUnlock, /* xUnlock */

devsymCheckReservedLock, /* xCheckReservedLock */

devsymFileControl, /* xFileControl */

devsymSectorSize, /* xSectorSize */

devsymDeviceCharacteristics, /* xDeviceCharacteristics */

devsymShmMap, /* xShmMap */

devsymShmLock, /* xShmLock */

devsymShmBarrier, /* xShmBarrier */

devsymShmUnmap /* xShmUnmap */

};

struct DevsymGlobal {

sqlite3_vfs *pVfs;

int iDeviceChar;

int iSectorSize;

};

struct DevsymGlobal g = {0, 0, 512};

/*

** Close an devsym-file.

*/

static int devsymClose(sqlite3_file *pFile){

devsym_file *p = (devsym_file *)pFile;

return sqlite3OsClose(p->pReal);

}

/*

** Read data from an devsym-file.

*/

static int devsymRead(

sqlite3_file *pFile,

void *zBuf,

int iAmt,

sqlite_int64 iOfst

){

devsym_file *p = (devsym_file *)pFile;

return sqlite3OsRead(p->pReal, zBuf, iAmt, iOfst);

}

/*

** Write data to an devsym-file.

*/

static int devsymWrite(

sqlite3_file *pFile,

const void *zBuf,

int iAmt,

sqlite_int64 iOfst

){

devsym_file *p = (devsym_file *)pFile;

return sqlite3OsWrite(p->pReal, zBuf, iAmt, iOfst);

}

/*

** Truncate an devsym-file.

*/

static int devsymTruncate(sqlite3_file *pFile, sqlite_int64 size){

devsym_file *p = (devsym_file *)pFile;

return sqlite3OsTruncate(p->pReal, size);

}

/*

** Sync an devsym-file.

*/

static int devsymSync(sqlite3_file *pFile, int flags){

devsym_file *p = (devsym_file *)pFile;

return sqlite3OsSync(p->pReal, flags);

}

/*

** Return the current file-size of an devsym-file.

*/

static int devsymFileSize(sqlite3_file *pFile, sqlite_int64 *pSize){

devsym_file *p = (devsym_file *)pFile;

return sqlite3OsFileSize(p->pReal, pSize);

}

/*

** Lock an devsym-file.

*/

static int devsymLock(sqlite3_file *pFile, int eLock){

devsym_file *p = (devsym_file *)pFile;

return sqlite3OsLock(p->pReal, eLock);

}

/*

** Unlock an devsym-file.

*/

static int devsymUnlock(sqlite3_file *pFile, int eLock){

devsym_file *p = (devsym_file *)pFile;

return sqlite3OsUnlock(p->pReal, eLock);

}

/*

** Check if another file-handle holds a RESERVED lock on an devsym-file.

*/

static int devsymCheckReservedLock(sqlite3_file *pFile, int *pResOut){

devsym_file *p = (devsym_file *)pFile;

return sqlite3OsCheckReservedLock(p->pReal, pResOut);

}

/*

** File control method. For custom operations on an devsym-file.

*/

static int devsymFileControl(sqlite3_file *pFile, int op, void *pArg){

devsym_file *p = (devsym_file *)pFile;

return sqlite3OsFileControl(p->pReal, op, pArg);

}

/*

** Return the sector-size in bytes for an devsym-file.

*/

static int devsymSectorSize(sqlite3_file *pFile){

return g.iSectorSize;

}

/*

** Return the device characteristic flags supported by an devsym-file.

*/

static int devsymDeviceCharacteristics(sqlite3_file *pFile){

return g.iDeviceChar;

}

/*

** Shared-memory methods are all pass-thrus.

*/

static int devsymShmLock(sqlite3_file *pFile, int ofst, int n, int flags){

devsym_file *p = (devsym_file *)pFile;

return sqlite3OsShmLock(p->pReal, ofst, n, flags);

}

static int devsymShmMap(

sqlite3_file *pFile,

int iRegion,

int szRegion,

int isWrite,

void volatile **pp

){

devsym_file *p = (devsym_file *)pFile;

return sqlite3OsShmMap(p->pReal, iRegion, szRegion, isWrite, pp);

}

static void devsymShmBarrier(sqlite3_file *pFile){

devsym_file *p = (devsym_file *)pFile;

sqlite3OsShmBarrier(p->pReal);

}

static int devsymShmUnmap(sqlite3_file *pFile, int delFlag){

devsym_file *p = (devsym_file *)pFile;

return sqlite3OsShmUnmap(p->pReal, delFlag);

}

/*

** Open an devsym file handle.

*/

static int devsymOpen(

sqlite3_vfs *pVfs,

const char *zName,

sqlite3_file *pFile,

int flags,

int *pOutFlags

){

int rc;

devsym_file *p = (devsym_file *)pFile;

p->pReal = (sqlite3_file *)&p[1];

rc = sqlite3OsOpen(g.pVfs, zName, p->pReal, flags, pOutFlags);

if( p->pReal->pMethods ){

pFile->pMethods = &devsym_io_methods;

}

return rc;

}

/*

** Delete the file located at zPath. If the dirSync argument is true,

** ensure the file-system modifications are synced to disk before

** returning.

*/

static int devsymDelete(sqlite3_vfs *pVfs, const char *zPath, int dirSync){

return sqlite3OsDelete(g.pVfs, zPath, dirSync);

}

/*

** Test for access permissions. Return true if the requested permission

** is available, or false otherwise.

*/

static int devsymAccess(

sqlite3_vfs *pVfs,

const char *zPath,

int flags,

int *pResOut

){

return sqlite3OsAccess(g.pVfs, zPath, flags, pResOut);

}

/*

** Populate buffer zOut with the full canonical pathname corresponding

** to the pathname in zPath. zOut is guaranteed to point to a buffer

** of at least (DEVSYM_MAX_PATHNAME+1) bytes.

*/

static int devsymFullPathname(

sqlite3_vfs *pVfs,

const char *zPath,

int nOut,

char *zOut

){

return sqlite3OsFullPathname(g.pVfs, zPath, nOut, zOut);

}

#ifndef SQLITE_OMIT_LOAD_EXTENSION

/*

** Open the dynamic library located at zPath and return a handle.

*/

static void *devsymDlOpen(sqlite3_vfs *pVfs, const char *zPath){

return sqlite3OsDlOpen(g.pVfs, zPath);

}

/*

** Populate the buffer zErrMsg (size nByte bytes) with a human readable

** utf-8 string describing the most recent error encountered associated

** with dynamic libraries.

*/

static void devsymDlError(sqlite3_vfs *pVfs, int nByte, char *zErrMsg){

sqlite3OsDlError(g.pVfs, nByte, zErrMsg);

}

/*

** Return a pointer to the symbol zSymbol in the dynamic library pHandle.

*/

static void (*devsymDlSym(sqlite3_vfs *pVfs, void *p, const char *zSym))(void){

return sqlite3OsDlSym(g.pVfs, p, zSym);

}

/*

** Close the dynamic library handle pHandle.

*/

static void devsymDlClose(sqlite3_vfs *pVfs, void *pHandle){

sqlite3OsDlClose(g.pVfs, pHandle);

}

#endif /* SQLITE_OMIT_LOAD_EXTENSION */

/*

** Populate the buffer pointed to by zBufOut with nByte bytes of

** random data.

*/

static int devsymRandomness(sqlite3_vfs *pVfs, int nByte, char *zBufOut){

return sqlite3OsRandomness(g.pVfs, nByte, zBufOut);

}

/*

** Sleep for nMicro microseconds. Return the number of microseconds

** actually slept.

*/

static int devsymSleep(sqlite3_vfs *pVfs, int nMicro){

return sqlite3OsSleep(g.pVfs, nMicro);

}

/*

** Return the current time as a Julian Day number in *pTimeOut.

*/

static int devsymCurrentTime(sqlite3_vfs *pVfs, double *pTimeOut){

return g.pVfs->xCurrentTime(g.pVfs, pTimeOut);

}

/*

** This procedure registers the devsym vfs with SQLite. If the argument is

** true, the devsym vfs becomes the new default vfs. It is the only publicly

** available function in this file.

*/

void devsym_register(int iDeviceChar, int iSectorSize){

if( g.pVfs==0 ){

g.pVfs = sqlite3_vfs_find(0);

devsym_vfs.szOsFile += g.pVfs->szOsFile;

sqlite3_vfs_register(&devsym_vfs, 0);

}

if( iDeviceChar>=0 ){

g.iDeviceChar = iDeviceChar;

}else{

g.iDeviceChar = 0;

}

if( iSectorSize>=0 ){

g.iSectorSize = iSectorSize;

}else{

g.iSectorSize = 512;

}

}

#endif