/*

** 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).

**

** $Id: test_devsym.c,v 1.8 2008/09/12 10:22:40 danielk1977 Exp $

*/

#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*);

/*

** 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);

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 = {

  1,                     /* 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 */

};

static sqlite3_io_methods devsym_io_methods = {

  1,                            /* 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 */

};

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;

}

/*

** 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 *pHandle, const char *zSymbol){

  return sqlite3OsDlSym(g.pVfs, pHandle, zSymbol);

}

/*

** 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 sqlite3OsCurrentTime(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;

  }

  if( iSectorSize>=0 ){

    g.iSectorSize = iSectorSize;

  }

}

#endif