/*

** 2007 September 14

**

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

**

*************************************************************************

**

** $Id: test_onefile.c,v 1.9 2008/06/26 10:54:12 danielk1977 Exp $

**

** OVERVIEW:

**

**   This file contains some example code demonstrating how the SQLite 

**   vfs feature can be used to have SQLite operate directly on an 

**   embedded media, without using an intermediate file system.

**

**   Because this is only a demo designed to run on a workstation, the

**   underlying media is simulated using a regular file-system file. The

**   size of the file is fixed when it is first created (default size 10 MB).

**   From SQLite's point of view, this space is used to store a single

**   database file and the journal file. 

**

**   Any statement journal created is stored in volatile memory obtained 

**   from sqlite3_malloc(). Any attempt to create a temporary database file 

**   will fail (SQLITE_IOERR). To prevent SQLite from attempting this,

**   it should be configured to store all temporary database files in 

**   main memory (see pragma "temp_store" or the SQLITE_TEMP_STORE compile 

**   time option).

**

** ASSUMPTIONS:

**

**   After it has been created, the blob file is accessed using the

**   following three functions only:

**

**       mediaRead();            - Read a 512 byte block from the file.

**       mediaWrite();           - Write a 512 byte block to the file.

**       mediaSync();            - Tell the media hardware to sync.

**

**   It is assumed that these can be easily implemented by any "real"

**   media vfs driver adapting this code.

**

** FILE FORMAT:

**

**   The basic principle is that the "database file" is stored at the

**   beginning of the 10 MB blob and grows in a forward direction. The 

**   "journal file" is stored at the end of the 10MB blob and grows

**   in the reverse direction. If, during a transaction, insufficient

**   space is available to expand either the journal or database file,

**   an SQLITE_FULL error is returned. The database file is never allowed

**   to consume more than 90% of the blob space. If SQLite tries to

**   create a file larger than this, SQLITE_FULL is returned.

**

**   No allowance is made for "wear-leveling", as is required by.

**   embedded devices in the absence of equivalent hardware features.

**

**   The first 512 block byte of the file is reserved for storing the

**   size of the "database file". It is updated as part of the sync()

**   operation. On startup, it can only be trusted if no journal file

**   exists. If a journal-file does exist, then it stores the real size

**   of the database region. The second and subsequent blocks store the 

**   actual database content.

**

**   The size of the "journal file" is not stored persistently in the 

**   file. When the system is running, the size of the journal file is

**   stored in volatile memory. When recovering from a crash, this vfs

**   reports a very large size for the journal file. The normal journal

**   header and checksum mechanisms serve to prevent SQLite from 

**   processing any data that lies past the logical end of the journal.

**

**   When SQLite calls OsDelete() to delete the journal file, the final

**   512 bytes of the blob (the area containing the first journal header)

**   are zeroed.

**

** LOCKING:

**

**   File locking is a no-op. Only one connection may be open at any one

**   time using this demo vfs.

*/

#include "sqlite3.h"

#include <assert.h>

#include <string.h>

/*

** Maximum pathname length supported by the fs backend.

*/

#define BLOCKSIZE 512

#define BLOBSIZE 10485760

/*

** Name used to identify this VFS.

*/

#define FS_VFS_NAME "fs"

typedef struct fs_real_file fs_real_file;

struct fs_real_file {

  sqlite3_file *pFile;

  const char *zName;

  int nDatabase;              /* Current size of database region */

  int nJournal;               /* Current size of journal region */

  int nBlob;                  /* Total size of allocated blob */

  int nRef;                   /* Number of pointers to this structure */

  fs_real_file *pNext;

  fs_real_file **ppThis;

};

typedef struct fs_file fs_file;

struct fs_file {

  sqlite3_file base;

  int eType;

  fs_real_file *pReal;

};

typedef struct tmp_file tmp_file;

struct tmp_file {

  sqlite3_file base;

  int nSize;

  int nAlloc;

  char *zAlloc;

};

/* Values for fs_file.eType. */

#define DATABASE_FILE   1

#define JOURNAL_FILE    2

/*

** Method declarations for fs_file.

*/

static int fsClose(sqlite3_file*);

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

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

static int fsTruncate(sqlite3_file*, sqlite3_int64 size);

static int fsSync(sqlite3_file*, int flags);

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

static int fsLock(sqlite3_file*, int);

static int fsUnlock(sqlite3_file*, int);

static int fsCheckReservedLock(sqlite3_file*, int *pResOut);

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

static int fsSectorSize(sqlite3_file*);

static int fsDeviceCharacteristics(sqlite3_file*);

/*

** Method declarations for tmp_file.

*/

static int tmpClose(sqlite3_file*);

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

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

static int tmpTruncate(sqlite3_file*, sqlite3_int64 size);

static int tmpSync(sqlite3_file*, int flags);

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

static int tmpLock(sqlite3_file*, int);

static int tmpUnlock(sqlite3_file*, int);

static int tmpCheckReservedLock(sqlite3_file*, int *pResOut);

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

static int tmpSectorSize(sqlite3_file*);

static int tmpDeviceCharacteristics(sqlite3_file*);

/*

** Method declarations for fs_vfs.

*/

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

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

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

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

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

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

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

static void fsDlClose(sqlite3_vfs*, void*);

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

static int fsSleep(sqlite3_vfs*, int microseconds);

static int fsCurrentTime(sqlite3_vfs*, double*);

typedef struct fs_vfs_t fs_vfs_t;

struct fs_vfs_t {

  sqlite3_vfs base;

  fs_real_file *pFileList;

  sqlite3_vfs *pParent;

};

static fs_vfs_t fs_vfs = {

  {

    1,                                          /* iVersion */

    0,                                          /* szOsFile */

    0,                                          /* mxPathname */

    0,                                          /* pNext */

    FS_VFS_NAME,                                /* zName */

    0,                                          /* pAppData */

    fsOpen,                                     /* xOpen */

    fsDelete,                                   /* xDelete */

    fsAccess,                                   /* xAccess */

    fsFullPathname,                             /* xFullPathname */

    fsDlOpen,                                   /* xDlOpen */

    fsDlError,                                  /* xDlError */

    fsDlSym,                                    /* xDlSym */

    fsDlClose,                                  /* xDlClose */

    fsRandomness,                               /* xRandomness */

    fsSleep,                                    /* xSleep */

    fsCurrentTime                               /* xCurrentTime */

  }, 

  0,                                            /* pFileList */

  0                                             /* pParent */

};

static sqlite3_io_methods fs_io_methods = {

  1,                            /* iVersion */

  fsClose,                      /* xClose */

  fsRead,                       /* xRead */

  fsWrite,                      /* xWrite */

  fsTruncate,                   /* xTruncate */

  fsSync,                       /* xSync */

  fsFileSize,                   /* xFileSize */

  fsLock,                       /* xLock */

  fsUnlock,                     /* xUnlock */

  fsCheckReservedLock,          /* xCheckReservedLock */

  fsFileControl,                /* xFileControl */

  fsSectorSize,                 /* xSectorSize */

  fsDeviceCharacteristics       /* xDeviceCharacteristics */

};

static sqlite3_io_methods tmp_io_methods = {

  1,                            /* iVersion */

  tmpClose,                     /* xClose */

  tmpRead,                      /* xRead */

  tmpWrite,                     /* xWrite */

  tmpTruncate,                  /* xTruncate */

  tmpSync,                      /* xSync */

  tmpFileSize,                  /* xFileSize */

  tmpLock,                      /* xLock */

  tmpUnlock,                    /* xUnlock */

  tmpCheckReservedLock,         /* xCheckReservedLock */

  tmpFileControl,               /* xFileControl */

  tmpSectorSize,                /* xSectorSize */

  tmpDeviceCharacteristics      /* xDeviceCharacteristics */

};

/* Useful macros used in several places */

#define MIN(x,y) ((x)<(y)?(x):(y))

#define MAX(x,y) ((x)>(y)?(x):(y))

/*

** Close a tmp-file.

*/

static int tmpClose(sqlite3_file *pFile){

  tmp_file *pTmp = (tmp_file *)pFile;

  sqlite3_free(pTmp->zAlloc);

  return SQLITE_OK;

}

/*

** Read data from a tmp-file.

*/

static int tmpRead(

  sqlite3_file *pFile, 

  void *zBuf, 

  int iAmt, 

  sqlite_int64 iOfst

){

  tmp_file *pTmp = (tmp_file *)pFile;

  if( (iAmt+iOfst)>pTmp->nSize ){

    return SQLITE_IOERR_SHORT_READ;

  }

  memcpy(zBuf, &pTmp->zAlloc[iOfst], iAmt);

  return SQLITE_OK;

}

/*

** Write data to a tmp-file.

*/

static int tmpWrite(

  sqlite3_file *pFile, 

  const void *zBuf, 

  int iAmt, 

  sqlite_int64 iOfst

){

  tmp_file *pTmp = (tmp_file *)pFile;

  if( (iAmt+iOfst)>pTmp->nAlloc ){

    int nNew = 2*(iAmt+iOfst+pTmp->nAlloc);

    char *zNew = sqlite3_realloc(pTmp->zAlloc, nNew);

    if( !zNew ){

      return SQLITE_NOMEM;

    }

    pTmp->zAlloc = zNew;

    pTmp->nAlloc = nNew;

  }

  memcpy(&pTmp->zAlloc[iOfst], zBuf, iAmt);

  pTmp->nSize = MAX(pTmp->nSize, iOfst+iAmt);

  return SQLITE_OK;

}

/*

** Truncate a tmp-file.

*/

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

  tmp_file *pTmp = (tmp_file *)pFile;

  pTmp->nSize = MIN(pTmp->nSize, size);

  return SQLITE_OK;

}

/*

** Sync a tmp-file.

*/

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

  return SQLITE_OK;

}

/*

** Return the current file-size of a tmp-file.

*/

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

  tmp_file *pTmp = (tmp_file *)pFile;

  *pSize = pTmp->nSize;

  return SQLITE_OK;

}

/*

** Lock a tmp-file.

*/

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

  return SQLITE_OK;

}

/*

** Unlock a tmp-file.

*/

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

  return SQLITE_OK;

}

/*

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

*/

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

  *pResOut = 0;

  return SQLITE_OK;

}

/*

** File control method. For custom operations on a tmp-file.

*/

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

  return SQLITE_OK;

}

/*

** Return the sector-size in bytes for a tmp-file.

*/

static int tmpSectorSize(sqlite3_file *pFile){

  return 0;

}

/*

** Return the device characteristic flags supported by a tmp-file.

*/

static int tmpDeviceCharacteristics(sqlite3_file *pFile){

  return 0;

}

/*

** Close an fs-file.

*/

static int fsClose(sqlite3_file *pFile){

  int rc = SQLITE_OK;

  fs_file *p = (fs_file *)pFile;

  fs_real_file *pReal = p->pReal;

  /* Decrement the real_file ref-count. */

  pReal->nRef--;

  assert(pReal->nRef>=0);

  /* When the ref-count reaches 0, destroy the structure */

  if( pReal->nRef==0 ){

    *pReal->ppThis = pReal->pNext;

    if( pReal->pNext ){

      pReal->pNext->ppThis = pReal->ppThis;

    }

    rc = pReal->pFile->pMethods->xClose(pReal->pFile);

    sqlite3_free(pReal);

  }

  return rc;

}

/*

** Read data from an fs-file.

*/

static int fsRead(

  sqlite3_file *pFile, 

  void *zBuf, 

  int iAmt, 

  sqlite_int64 iOfst

){

  int rc = SQLITE_OK;

  fs_file *p = (fs_file *)pFile;

  fs_real_file *pReal = p->pReal;

  sqlite3_file *pF = pReal->pFile;

  if( (p->eType==DATABASE_FILE && (iAmt+iOfst)>pReal->nDatabase)

   || (p->eType==JOURNAL_FILE && (iAmt+iOfst)>pReal->nJournal)

  ){

    rc = SQLITE_IOERR_SHORT_READ;

  }else if( p->eType==DATABASE_FILE ){

    rc = pF->pMethods->xRead(pF, zBuf, iAmt, iOfst+BLOCKSIZE);

  }else{

    /* Journal file. */

    int iRem = iAmt;

    int iBuf = 0;

    int ii = iOfst;

    while( iRem>0 && rc==SQLITE_OK ){

      int iRealOff = pReal->nBlob - BLOCKSIZE*((ii/BLOCKSIZE)+1) + ii%BLOCKSIZE;

      int iRealAmt = MIN(iRem, BLOCKSIZE - (iRealOff%BLOCKSIZE));

      rc = pF->pMethods->xRead(pF, &((char *)zBuf)[iBuf], iRealAmt, iRealOff);

      ii += iRealAmt;

      iBuf += iRealAmt;

      iRem -= iRealAmt;

    }

  }

  return rc;

}

/*

** Write data to an fs-file.

*/

static int fsWrite(

  sqlite3_file *pFile, 

  const void *zBuf, 

  int iAmt, 

  sqlite_int64 iOfst

){

  int rc = SQLITE_OK;

  fs_file *p = (fs_file *)pFile;

  fs_real_file *pReal = p->pReal;

  sqlite3_file *pF = pReal->pFile;

  if( p->eType==DATABASE_FILE ){

    if( (iAmt+iOfst+BLOCKSIZE)>(pReal->nBlob-pReal->nJournal) ){

      rc = SQLITE_FULL;

    }else{

      rc = pF->pMethods->xWrite(pF, zBuf, iAmt, iOfst+BLOCKSIZE);

      if( rc==SQLITE_OK ){

        pReal->nDatabase = MAX(pReal->nDatabase, iAmt+iOfst);

      }

    }

  }else{

    /* Journal file. */

    int iRem = iAmt;

    int iBuf = 0;

    int ii = iOfst;

    while( iRem>0 && rc==SQLITE_OK ){

      int iRealOff = pReal->nBlob - BLOCKSIZE*((ii/BLOCKSIZE)+1) + ii%BLOCKSIZE;

      int iRealAmt = MIN(iRem, BLOCKSIZE - (iRealOff%BLOCKSIZE));

      if( iRealOff<(pReal->nDatabase+BLOCKSIZE) ){

        rc = SQLITE_FULL;

      }else{

        rc = pF->pMethods->xWrite(pF, &((char *)zBuf)[iBuf], iRealAmt,iRealOff);

        ii += iRealAmt;

        iBuf += iRealAmt;

        iRem -= iRealAmt;

      }

    }

    if( rc==SQLITE_OK ){

      pReal->nJournal = MAX(pReal->nJournal, iAmt+iOfst);

    }

  }

  return rc;

}

/*

** Truncate an fs-file.

*/

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

  fs_file *p = (fs_file *)pFile;

  fs_real_file *pReal = p->pReal;

  if( p->eType==DATABASE_FILE ){

    pReal->nDatabase = MIN(pReal->nDatabase, size);

  }else{

    pReal->nJournal = MIN(pReal->nJournal, size);

  }

  return SQLITE_OK;

}

/*

** Sync an fs-file.

*/

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

  fs_file *p = (fs_file *)pFile;

  fs_real_file *pReal = p->pReal;

  sqlite3_file *pRealFile = pReal->pFile;

  int rc = SQLITE_OK;

  if( p->eType==DATABASE_FILE ){

    unsigned char zSize[4];

    zSize[0] = (pReal->nDatabase&0xFF000000)>>24;

    zSize[1] = (pReal->nDatabase&0x00FF0000)>>16;

    zSize[2] = (pReal->nDatabase&0x0000FF00)>>8;

    zSize[3] = (pReal->nDatabase&0x000000FF);

    rc = pRealFile->pMethods->xWrite(pRealFile, zSize, 4, 0);

  }

  if( rc==SQLITE_OK ){

    rc = pRealFile->pMethods->xSync(pRealFile, flags&(~SQLITE_SYNC_DATAONLY));

  }

  return rc;

}

/*

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

*/

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

  fs_file *p = (fs_file *)pFile;

  fs_real_file *pReal = p->pReal;

  if( p->eType==DATABASE_FILE ){

    *pSize = pReal->nDatabase;

  }else{

    *pSize = pReal->nJournal;

  }

  return SQLITE_OK;

}

/*

** Lock an fs-file.

*/

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

  return SQLITE_OK;

}

/*

** Unlock an fs-file.

*/

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

  return SQLITE_OK;

}

/*

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

*/

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

  *pResOut = 0;

  return SQLITE_OK;

}

/*

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

*/

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

  return SQLITE_OK;

}

/*

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

*/

static int fsSectorSize(sqlite3_file *pFile){

  return BLOCKSIZE;

}

/*

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

*/

static int fsDeviceCharacteristics(sqlite3_file *pFile){

  return 0;

}

/*

** Open an fs file handle.

*/

static int fsOpen(

  sqlite3_vfs *pVfs,

  const char *zName,

  sqlite3_file *pFile,

  int flags,

  int *pOutFlags

){

  fs_vfs_t *pFsVfs = (fs_vfs_t *)pVfs;

  fs_file *p = (fs_file *)pFile;

  fs_real_file *pReal = 0;

  int eType;

  int nName;

  int rc = SQLITE_OK;

  if( 0==(flags&(SQLITE_OPEN_MAIN_DB|SQLITE_OPEN_MAIN_JOURNAL)) ){

    tmp_file *p = (tmp_file *)pFile;

    memset(p, 0, sizeof(*p));

    p->base.pMethods = &tmp_io_methods;

    return SQLITE_OK;

  }

  eType = ((flags&(SQLITE_OPEN_MAIN_DB))?DATABASE_FILE:JOURNAL_FILE);

  p->base.pMethods = &fs_io_methods;

  p->eType = eType;

  assert(strlen("-journal")==8);

  nName = strlen(zName)-((eType==JOURNAL_FILE)?8:0);

  pReal=pFsVfs->pFileList; 

  for(; pReal && strncmp(pReal->zName, zName, nName); pReal=pReal->pNext);

  if( !pReal ){

    sqlite3_int64 size;

    sqlite3_file *pRealFile;

    sqlite3_vfs *pParent = pFsVfs->pParent;

    assert(eType==DATABASE_FILE);

    pReal = (fs_real_file *)sqlite3_malloc(sizeof(*pReal)+pParent->szOsFile);

    if( !pReal ){

      rc = SQLITE_NOMEM;

      goto open_out;

    }

    memset(pReal, 0, sizeof(*pReal)+pParent->szOsFile);

    pReal->zName = zName;

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

    rc = pParent->xOpen(pParent, zName, pReal->pFile, flags, pOutFlags);

    if( rc!=SQLITE_OK ){

      goto open_out;

    }

    pRealFile = pReal->pFile;

    rc = pRealFile->pMethods->xFileSize(pRealFile, &size);

    if( rc!=SQLITE_OK ){

      goto open_out;

    }

    if( size==0 ){

      rc = pRealFile->pMethods->xWrite(pRealFile, "\0", 1, BLOBSIZE-1);

      pReal->nBlob = BLOBSIZE;

    }else{

      unsigned char zS[4];

      pReal->nBlob = size;

      rc = pRealFile->pMethods->xRead(pRealFile, zS, 4, 0);

      pReal->nDatabase = (zS[0]<<24)+(zS[1]<<16)+(zS[2]<<8)+zS[3];

      if( rc==SQLITE_OK ){

        rc = pRealFile->pMethods->xRead(pRealFile, zS, 4, pReal->nBlob-4);

        if( zS[0] || zS[1] || zS[2] || zS[3] ){

          pReal->nJournal = pReal->nBlob;

        }

      }

    }

    if( rc==SQLITE_OK ){

      pReal->pNext = pFsVfs->pFileList;

      if( pReal->pNext ){

        pReal->pNext->ppThis = &pReal->pNext;

      }

      pReal->ppThis = &pFsVfs->pFileList;

      pFsVfs->pFileList = pReal;

    }

  }

open_out:

  if( pReal ){

    if( rc==SQLITE_OK ){

      p->pReal = pReal;

      pReal->nRef++;

    }else{

      if( pReal->pFile->pMethods ){

        pReal->pFile->pMethods->xClose(pReal->pFile);

      }

      sqlite3_free(pReal);

    }

  }

  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 fsDelete(sqlite3_vfs *pVfs, const char *zPath, int dirSync){

  int rc = SQLITE_OK;

  fs_vfs_t *pFsVfs = (fs_vfs_t *)pVfs;

  fs_real_file *pReal;

  sqlite3_file *pF;

  int nName = strlen(zPath) - 8;

  assert(strlen("-journal")==8);

  assert(strcmp("-journal", &zPath[nName])==0);

  pReal = pFsVfs->pFileList; 

  for(; pReal && strncmp(pReal->zName, zPath, nName); pReal=pReal->pNext);

  if( pReal ){

    pF = pReal->pFile;

    rc = pF->pMethods->xWrite(pF, "\0\0\0\0", 4, pReal->nBlob-BLOCKSIZE);

    if( rc==SQLITE_OK ){

      pReal->nJournal = 0;

    }

  }

  return rc;

}

/*

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

** is available, or false otherwise.

*/

static int fsAccess(

  sqlite3_vfs *pVfs, 

  const char *zPath, 

  int flags, 

  int *pResOut

){

  fs_vfs_t *pFsVfs = (fs_vfs_t *)pVfs;

  fs_real_file *pReal;

  int isJournal = 0;

  int nName = strlen(zPath);

  if( flags!=SQLITE_ACCESS_EXISTS ){

    sqlite3_vfs *pParent = ((fs_vfs_t *)pVfs)->pParent;

    return pParent->xAccess(pParent, zPath, flags, pResOut);

  }

  assert(strlen("-journal")==8);

  if( nName>8 && strcmp("-journal", &zPath[nName-8])==0 ){

    nName -= 8;

    isJournal = 1;

  }

  pReal = pFsVfs->pFileList; 

  for(; pReal && strncmp(pReal->zName, zPath, nName); pReal=pReal->pNext);

  *pResOut = (pReal && (!isJournal || pReal->nJournal>0));

  return SQLITE_OK;

}

/*

** 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 (FS_MAX_PATHNAME+1) bytes.

*/

static int fsFullPathname(

  sqlite3_vfs *pVfs,            /* Pointer to vfs object */

  const char *zPath,            /* Possibly relative input path */

  int nOut,                     /* Size of output buffer in bytes */

  char *zOut                    /* Output buffer */

){

  sqlite3_vfs *pParent = ((fs_vfs_t *)pVfs)->pParent;

  return pParent->xFullPathname(pParent, zPath, nOut, zOut);

}

/*

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

*/

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

  sqlite3_vfs *pParent = ((fs_vfs_t *)pVfs)->pParent;

  return pParent->xDlOpen(pParent, 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 fsDlError(sqlite3_vfs *pVfs, int nByte, char *zErrMsg){

  sqlite3_vfs *pParent = ((fs_vfs_t *)pVfs)->pParent;

  pParent->xDlError(pParent, nByte, zErrMsg);

}

/*

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

*/

static void *fsDlSym(sqlite3_vfs *pVfs, void *pHandle, const char *zSymbol){

  sqlite3_vfs *pParent = ((fs_vfs_t *)pVfs)->pParent;

  return pParent->xDlSym(pParent, pHandle, zSymbol);

}

/*

** Close the dynamic library handle pHandle.

*/

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

  sqlite3_vfs *pParent = ((fs_vfs_t *)pVfs)->pParent;

  pParent->xDlClose(pParent, pHandle);

}

/*

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

** random data.

*/

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

  sqlite3_vfs *pParent = ((fs_vfs_t *)pVfs)->pParent;

  return pParent->xRandomness(pParent, nByte, zBufOut);

}

/*

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

** actually slept.

*/

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

  sqlite3_vfs *pParent = ((fs_vfs_t *)pVfs)->pParent;

  return pParent->xSleep(pParent, nMicro);

}

/*

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

*/

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

  sqlite3_vfs *pParent = ((fs_vfs_t *)pVfs)->pParent;

  return pParent->xCurrentTime(pParent, pTimeOut);

}

/*

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

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

** available function in this file.

*/

int fs_register(){

  if( fs_vfs.pParent ) return SQLITE_OK;

  fs_vfs.pParent = sqlite3_vfs_find(0);

  fs_vfs.base.mxPathname = fs_vfs.pParent->mxPathname;

  fs_vfs.base.szOsFile = MAX(sizeof(tmp_file), sizeof(fs_file));

  return sqlite3_vfs_register(&fs_vfs.base, 0);

}

#ifdef SQLITE_TEST

  int SqlitetestOnefile_Init() {return fs_register();}

#endif