tkeyvfs.cc File Reference

#include <sqlite3.h>
#include "TFile.h"
#include "TKey.h"
#include <cassert>
#include <cerrno>
#include <cstddef>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <dlfcn.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <sys/time.h>
#include <sys/types.h>
#include <time.h>
#include <unistd.h>

Go to the source code of this file.

Classes
struct	unixFile
struct	unix_syscall
class	RootFileSentry

Macros
#define	SQLITE_OPEN_WAL   0x00080000 /* VFS only */
#define	SQLITE_FCNTL_SIZE_HINT   5
#define	SQLITE_FCNTL_CHUNK_SIZE   6
#define	SQLITE_FCNTL_SYNC_OMITTED   8
#define	SQLITE_FCNTL_DB_UNCHANGED   0xca093fa0
#define	SQLITE_DEFAULT_SECTOR_SIZE   512
#define	UNUSED_PARAMETER(x)   (void)(x)
#define	UNUSED_PARAMETER2(x, y)   UNUSED_PARAMETER(x), UNUSED_PARAMETER(y)
#define	ArraySize(X)   ((int)(sizeof(X) / sizeof(X[0])))
#define	_LARGE_FILE   1
#define	_FILE_OFFSET_BITS   64
#define	_LARGEFILE_SOURCE   1
#define	TKEYVFS_TRACE   0
#define	MEMPAGE   2048
#define	MAX_PATHNAME   512
#define	SQLITE_TEMP_FILE_PREFIX   "etilqs_"
#define	O_LARGEFILE   0
#define	O_NOFOLLOW   0
#define	O_BINARY   0
#define	SQLITE_CANTOPEN_BKPT   sqlite3CantopenError(__LINE__)
#define	osOpen   ((int (*)(const char*, int, ...))aSyscall[0].pCurrent)
#define	osClose   ((int (*)(int))aSyscall[1].pCurrent)
#define	osAccess   ((int (*)(const char*, int))aSyscall[2].pCurrent)
#define	osGetcwd   ((char* (*)(char*, size_t))aSyscall[3].pCurrent)
#define	osStat   ((int (*)(const char*, struct stat*))aSyscall[4].pCurrent)
#define	osFstat   ((int (*)(int, struct stat*))aSyscall[5].pCurrent)
#define	osFtruncate   ((int (*)(int, off_t))aSyscall[6].pCurrent)
#define	osFcntl   ((int (*)(int, int, ...))aSyscall[7].pCurrent)
#define	osRead   ((ssize_t(*)(int, void*, size_t))aSyscall[8].pCurrent)
#define	osPread   ((ssize_t(*)(int, void*, size_t, off_t))aSyscall[9].pCurrent)
#define	osPread64   ((ssize_t(*)(int, void*, size_t, off_t))aSyscall[10].pCurrent)
#define	osWrite   ((ssize_t(*)(int, const void*, size_t))aSyscall[11].pCurrent)
#define	osPwrite   ((ssize_t(*)(int, const void*, size_t, off_t))aSyscall[12].pCurrent)
#define	osPwrite64   ((ssize_t(*)(int, const void*, size_t, off_t))aSyscall[13].pCurrent)
#define	osFchmod   ((int (*)(int, mode_t))aSyscall[14].pCurrent)
#define	osFallocate   ((int (*)(int, off_t, off_t))aSyscall[15].pCurrent)
#define	unixLogError(a, b, c)   unixLogErrorAtLine(a, b, c, __LINE__)
#define	UNIXVFS(VFSNAME, FINDER)

Typedefs
typedef sqlite_int64	i64
typedef struct unixFile	unixFile
typedef const sqlite3_io_methods *(*	finder_type) (const char *, unixFile *)

Functions
static int	sqlite3CantopenError (int lineno)
static int	sqlite3Strlen30 (const char *z)
static const sqlite3_io_methods *	nolockIoFinderImpl (const char *z, unixFile *p)
static int	unixLogErrorAtLine (int errcode, const char *zFunc, const char *zPath, int iLine)
static int	robust_open (const char *z, int f, int m)
static void	robust_close (unixFile *pFile, int h, int lineno)
static int	unixGetTempname (int nBuf, char *zBuf)
static int	fcntlSizeHint (unixFile *pFile, i64 nByte)
static int	seekAndRead (unixFile *id, sqlite3_int64 offset, void *pBuf, int cnt)
static int	seekAndWrite (unixFile *id, i64 offset, const void *pBuf, int cnt)
static int	nolockClose (sqlite3_file *id)
static int	unixRead (sqlite3_file *id, void *pBuf, int amt, sqlite3_int64 offset)
static int	unixWrite (sqlite3_file *id, const void *pBuf, int amt, sqlite3_int64 offset)
static int	unixTruncate (sqlite3_file *id, i64 nByte)
static int	unixSync (sqlite3_file *id, int flags)
static int	unixFileSize (sqlite3_file *id, i64 *pSize)
static int	nolockLock (sqlite3_file *NotUsed, int NotUsed2)
static int	nolockUnlock (sqlite3_file *NotUsed, int NotUsed2)
static int	nolockCheckReservedLock (sqlite3_file *NotUsed, int *pResOut)
static int	unixFileControl (sqlite3_file *id, int op, void *pArg)
static int	unixSectorSize (sqlite3_file *NotUsed)
static int	unixDeviceCharacteristics (sqlite3_file *NotUsed)
static int	unixOpen (sqlite3_vfs *pVfs, const char *zPath, sqlite3_file *pFile, int flags, int *pOutFlags)
static int	unixDelete (sqlite3_vfs *NotUsed, const char *zPath, int dirSync)
static int	unixAccess (sqlite3_vfs *NotUsed, const char *zPath, int flags, int *pResOut)
static int	unixFullPathname (sqlite3_vfs *pVfs, const char *zPath, int nOut, char *zOut)
static void *	unixDlOpen (sqlite3_vfs *NotUsed, const char *zFilename)
static void	unixDlError (sqlite3_vfs *NotUsed, int nBuf, char *zBufOut)
static void	unixDlClose (sqlite3_vfs *NotUsed, void *pHandle)
static int	unixRandomness (sqlite3_vfs *NotUsed, int nBuf, char *zBuf)
static int	unixSleep (sqlite3_vfs *NotUsed, int microseconds)
static int	unixCurrentTime (sqlite3_vfs *NotUsed, double *prNow)
static int	unixGetLastError (sqlite3_vfs *NotUsed, int NotUsed2, char *NotUsed3)
static int	unixCurrentTimeInt64 (sqlite3_vfs *NotUsed, sqlite3_int64 *piNow)
static int	unixSetSystemCall (sqlite3_vfs *pNotUsed, const char *zName, sqlite3_syscall_ptr pNewFunc)
static sqlite3_syscall_ptr	unixGetSystemCall (sqlite3_vfs *pNotUsed, const char *zName)
static const char *	unixNextSystemCall (sqlite3_vfs *p, const char *zName)
static int	closeUnixFile (sqlite3_file *id)
int	tkeyvfs_init (void)
int	tkeyvfs_open_v2 (const char *filename, sqlite3 **ppDb, int flags, TFile *rootFile )

Variables
static TFile *	gRootFile
static void(*)(void)	unixDlSym (sqlite3_vfs *NotUsed, void *p, const char *zSym)
static struct unix_syscall	aSyscall []
static const sqlite3_io_methods	nolockIoMethods
static const sqlite3_io_methods *(*const	nolockIoFinder )(const char *, unixFile *p)

Macro Definition Documentation

#define _FILE_OFFSET_BITS   64

Definition at line 37 of file tkeyvfs.cc.

#define _LARGE_FILE   1

Definition at line 36 of file tkeyvfs.cc.

#define _LARGEFILE_SOURCE   1

Definition at line 38 of file tkeyvfs.cc.

#define ArraySize

(

X

)

((int)(sizeof(X) / sizeof(X[0])))

Definition at line 32 of file tkeyvfs.cc.

#define MAX_PATHNAME   512

Definition at line 88 of file tkeyvfs.cc.

#define MEMPAGE   2048

Definition at line 83 of file tkeyvfs.cc.

#define O_BINARY   0

Definition at line 137 of file tkeyvfs.cc.

#define O_LARGEFILE   0

Definition at line 127 of file tkeyvfs.cc.

#define O_NOFOLLOW   0

Definition at line 134 of file tkeyvfs.cc.

#define osAccess   ((int (*)(const char*, int))aSyscall[2].pCurrent)

#define osClose   ((int (*)(int))aSyscall[1].pCurrent)

#define osFallocate   ((int (*)(int, off_t, off_t))aSyscall[15].pCurrent)

#define osFchmod   ((int (*)(int, mode_t))aSyscall[14].pCurrent)

#define osFcntl   ((int (*)(int, int, ...))aSyscall[7].pCurrent)

#define osFstat   ((int (*)(int, struct stat*))aSyscall[5].pCurrent)

#define osFtruncate   ((int (*)(int, off_t))aSyscall[6].pCurrent)

#define osGetcwd   ((char* (*)(char*, size_t))aSyscall[3].pCurrent)

#define osOpen   ((int (*)(const char*, int, ...))aSyscall[0].pCurrent)

#define osPread   ((ssize_t(*)(int, void*, size_t, off_t))aSyscall[9].pCurrent)

#define osPread64   ((ssize_t(*)(int, void*, size_t, off_t))aSyscall[10].pCurrent)

#define osPwrite   ((ssize_t(*)(int, const void*, size_t, off_t))aSyscall[12].pCurrent)

#define osPwrite64   ((ssize_t(*)(int, const void*, size_t, off_t))aSyscall[13].pCurrent)

#define osRead   ((ssize_t(*)(int, void*, size_t))aSyscall[8].pCurrent)

#define osStat   ((int (*)(const char*, struct stat*))aSyscall[4].pCurrent)

#define osWrite   ((ssize_t(*)(int, const void*, size_t))aSyscall[11].pCurrent)

#define SQLITE_CANTOPEN_BKPT   sqlite3CantopenError(__LINE__)

Definition at line 217 of file tkeyvfs.cc.

#define SQLITE_DEFAULT_SECTOR_SIZE   512

Definition at line 27 of file tkeyvfs.cc.

#define SQLITE_FCNTL_CHUNK_SIZE   6

Definition at line 23 of file tkeyvfs.cc.

#define SQLITE_FCNTL_DB_UNCHANGED   0xca093fa0

Definition at line 26 of file tkeyvfs.cc.

#define SQLITE_FCNTL_SIZE_HINT   5

Definition at line 22 of file tkeyvfs.cc.

#define SQLITE_FCNTL_SYNC_OMITTED   8

Definition at line 24 of file tkeyvfs.cc.

#define SQLITE_OPEN_WAL   0x00080000 /* VFS only */

Definition at line 21 of file tkeyvfs.cc.

#define SQLITE_TEMP_FILE_PREFIX   "etilqs_"

Definition at line 90 of file tkeyvfs.cc.

#define TKEYVFS_TRACE   0

Definition at line 69 of file tkeyvfs.cc.

#define unixLogError	(		a,
			b,
			c
	)		unixLogErrorAtLine(a, b, c, __LINE__)

Definition at line 386 of file tkeyvfs.cc.

#define UNIXVFS	(		VFSNAME,
			FINDER
	)

Value:

{                                                                            \
    1,                  /* iVersion */                                         \
      sizeof(unixFile), /* szOsFile */                                         \
      MAX_PATHNAME,     /* mxPathname */                                       \
      0,                /* pNext */                                            \
      VFSNAME,          /* zName */                                            \
      (void*)&FINDER,   /* pAppData */                                         \
      unixOpen,         /* xOpen */                                            \
      unixDelete,       /* xDelete */                                          \
      unixAccess,       /* xAccess */                                          \
      unixFullPathname, /* xFullPathname */                                    \
      unixDlOpen,       /* xDlOpen */                                          \
      unixDlError,      /* xDlError */                                         \
      unixDlSym,        /* xDlSym */                                           \
      unixDlClose,      /* xDlClose */                                         \
      unixRandomness,   /* xRandomness */                                      \
      unixSleep,        /* xSleep */                                           \
      unixCurrentTime,  /* xCurrentTime */                                     \
      unixGetLastError, /* xGetLastError */                                    \
    /* unixCurrentTimeInt64, v2, xCurrentTimeInt64 */                          \
    /* unixSetSystemCall,    v3, xSetSystemCall */                             \
    /* unixGetSystemCall,    v3, xGetSystemCall */                             \
    /* unixNextSystemCall,   v3, xNextSystemCall */                            \
  }

#define UNUSED_PARAMETER

(

x

)

(void)(x)

Definition at line 29 of file tkeyvfs.cc.

#define UNUSED_PARAMETER2	(		x,
			y
	)		UNUSED_PARAMETER(x), UNUSED_PARAMETER(y)

Definition at line 30 of file tkeyvfs.cc.

Typedef Documentation

typedef const sqlite3_io_methods*(* finder_type) (const char *, unixFile *)

Definition at line 368 of file tkeyvfs.cc.

typedef sqlite_int64 i64

Definition at line 34 of file tkeyvfs.cc.

typedef struct unixFile unixFile

Definition at line 120 of file tkeyvfs.cc.

Function Documentation

static int closeUnixFile ( sqlite3_file *  id )

static

Definition at line 473 of file tkeyvfs.cc.

{
  unixFile* pFile = (unixFile*)id;
#if TKEYVFS_TRACE
  fprintf(stderr, "Begin closeUnixFile ...\n");
  if (((unixFile*)id)->zPath) {
    fprintf(stderr, "filename: %s\n", ((unixFile*)id)->zPath);
  }
#ifndef TKEYVFS_NO_ROOT
  fprintf(stderr, "saveToRootFile: %d\n", ((unixFile*)id)->saveToRootFile);
#endif // TKEYVFS_NO_ROOT
#endif /* TKEYVFS_TRACE */
#ifndef TKEYVFS_NO_ROOT
  if (pFile->saveToRootFile) {
  /**/
#if TKEYVFS_TRACE
    fprintf(
      stderr, "fileSize: 0x%016lx\n", (unsigned long long)pFile->fileSize);
#endif /* TKEYVFS_TRACE */
    /* Create a tkey which will contain the contents
    ** of the database in the root file */
    TKey* k = new TKey(pFile->zPath,
                       "sqlite3 database file",
                       TKey::Class(),
                       pFile->fileSize /*nbytes*/,
                       pFile->rootFile /*dir*/);
#if TKEYVFS_TRACE
    /* Ask the key for the size of the database file it contains. */
    Int_t objlen = k->GetObjlen();
    fprintf(stderr, "objlen: %d\n", objlen);
#endif /* TKEYVFS_TRACE */
    /* Add the new key to the root file toplevel directory. */
    /* Note: The tkey is now owned by the root file. */
    Int_t cycle = pFile->rootFile->AppendKey(k);
    /* Get a pointer to the i/o buffer inside the tkey. */
    char* p = k->GetBuffer();
    /* Copy the entire in-memory database file into the tkey i/o buffer. */
    (void*)memcpy((void*)p, (void*)pFile->pBuf, (size_t)pFile->fileSize);
    /* Write the tkey contents to the root file. */
    /* Note: This has not yet written the top-level directory entry for the key.
     */
    Int_t cnt = k->WriteFile(cycle, 0 /*file*/);
    if (cnt == -1) {
      /* bad */
      fprintf(stderr,
              "tkeyvfs: failed to write root tkey containing database "
              "to root file!\n");
    }
    /* Force the root file to flush the top-level directory entry for our tkey
     * to disk. */
    cnt = pFile->rootFile->Write("", TObject::kOverwrite);
    if (cnt < 0) {
      /* bad */
      fprintf(stderr, "tkeyvfs: failed to write root file to disk!\n");
    }
  }
#endif // TKEYVFS_NO_ROOT
  if (pFile->pBuf != nullptr) {
    free(pFile->pBuf);
  }
  if (pFile->zPath != nullptr) {
    free((void*)pFile->zPath);
  }
  memset(pFile, 0, sizeof(unixFile));
#if TKEYVFS_TRACE
  fprintf(stderr, "End   closeUnixFile ...\n");
#endif /* TKEYVFS_TRACE */
  return SQLITE_OK;
}

static int fcntlSizeHint ( unixFile *  pFile, i64  nByte  )

static

Definition at line 590 of file tkeyvfs.cc.

{
/**/
#if TKEYVFS_TRACE
  fprintf(stderr, "Begin fcntlSizeHint ...\n");
#endif /* TKEYVFS_TRACE */
  if (pFile->szChunk) {
    i64 nSize; /* Required file size */
    i64 nAlloc;
    nSize = ((nByte + (pFile->szChunk - 1)) / pFile->szChunk) * pFile->szChunk;
    nAlloc = ((nSize + ((i64)(MEMPAGE - 1))) / ((i64)MEMPAGE)) * ((i64)MEMPAGE);
    if ((nSize > pFile->fileSize) && (nAlloc > pFile->bufAllocated)) {
      if (nAlloc > pFile->bufAllocated) {
        char* pNewBuf = (char*)realloc((void*)pFile->pBuf, (size_t)nAlloc);
        if (pNewBuf == nullptr) {
        /**/
#if TKEYVFS_TRACE
          fprintf(stderr, "End   fcntlSizeHint ...\n");
#endif /* TKEYVFS_TRACE */
          return SQLITE_IOERR_WRITE;
        }
        (void)memset(
          pNewBuf + pFile->fileSize, 0, (size_t)(nAlloc - pFile->fileSize));
        pFile->pBuf = pNewBuf;
        pFile->bufAllocated = nAlloc;
      } else {
        (void)memset(
          pFile->pBuf + pFile->fileSize, 0, (size_t)(nSize - pFile->fileSize));
      }
      pFile->fileSize = nSize;
    }
  }
#if TKEYVFS_TRACE
  fprintf(stderr, "End   fcntlSizeHint ...\n");
#endif /* TKEYVFS_TRACE */
  return SQLITE_OK;
}

static int nolockCheckReservedLock ( sqlite3_file *  NotUsed, int *  pResOut  )

static

Definition at line 998 of file tkeyvfs.cc.

{
/*UNUSED_PARAMETER(NotUsed);*/
#if TKEYVFS_TRACE
  fprintf(stderr, "Begin nolockCheckReservedLock ...\n");
  if (((unixFile*)id)->zPath) {
    fprintf(stderr, "filename: %s\n", ((unixFile*)id)->zPath);
  }
#endif /* TKEYVFS_TRACE */
  *pResOut = 0;
#if TKEYVFS_TRACE
  fprintf(stderr, "End   nolockCheckReservedLock ...\n");
#endif /* TKEYVFS_TRACE */
  return SQLITE_OK;
}

static int nolockClose ( sqlite3_file *  id )

static

Definition at line 718 of file tkeyvfs.cc.

{
/**/
#if TKEYVFS_TRACE
  fprintf(stderr, "Begin nolockClose ...\n");
#endif /* TKEYVFS_TRACE */
  int val = closeUnixFile(id);
#if TKEYVFS_TRACE
  fprintf(stderr, "End   nolockClose ...\n");
#endif /* TKEYVFS_TRACE */
  return val;
}

static const sqlite3_io_methods * nolockIoFinderImpl ( const char *  z, unixFile *  p  )

static

Definition at line 357 of file tkeyvfs.cc.

{
  UNUSED_PARAMETER(z);
  UNUSED_PARAMETER(p);
  return &nolockIoMethods;
}

static int nolockLock ( sqlite3_file *  NotUsed, int  NotUsed2  )

static

Definition at line 964 of file tkeyvfs.cc.

{
  /*UNUSED_PARAMETER2(NotUsed, NotUsed2);*/
  UNUSED_PARAMETER(NotUsed2);
#if TKEYVFS_TRACE
  fprintf(stderr, "Begin nolockLock ...\n");
  if (((unixFile*)id)->zPath) {
    fprintf(stderr, "filename: %s\n", ((unixFile*)id)->zPath);
  }
#endif /* TKEYVFS_TRACE */
#if TKEYVFS_TRACE
  fprintf(stderr, "End   nolockLock ...\n");
#endif /* TKEYVFS_TRACE */
  return SQLITE_OK;
}

static int nolockUnlock ( sqlite3_file *  NotUsed, int  NotUsed2  )

static

Definition at line 981 of file tkeyvfs.cc.

{
  /*UNUSED_PARAMETER2(NotUsed, NotUsed2);*/
  UNUSED_PARAMETER(NotUsed2);
#if TKEYVFS_TRACE
  fprintf(stderr, "Begin nolockUnlock ...\n");
  if (((unixFile*)id)->zPath) {
    fprintf(stderr, "filename: %s\n", ((unixFile*)id)->zPath);
  }
#endif /* TKEYVFS_TRACE */
#if TKEYVFS_TRACE
  fprintf(stderr, "End   nolockUnlock ...\n");
#endif /* TKEYVFS_TRACE */
  return SQLITE_OK;
}

static void robust_close ( unixFile *  pFile, int  h, int  lineno  )

static

Definition at line 443 of file tkeyvfs.cc.

{
/**/
#if TKEYVFS_TRACE
  fprintf(stderr, "Begin robust_close ...\n");
#endif /* TKEYVFS_TRACE */
  if (osClose(h)) {
    if (pFile) {
      unixLogErrorAtLine(SQLITE_IOERR_CLOSE, "close", pFile->zPath, lineno);
    } else {
      unixLogErrorAtLine(SQLITE_IOERR_CLOSE, "close", 0, lineno);
    }
  }
#if TKEYVFS_TRACE
  fprintf(stderr, "End   robust_close ...\n");
#endif /* TKEYVFS_TRACE */
  /**/
}

static int robust_open ( const char *  z, int  f, int  m  )

static

Definition at line 414 of file tkeyvfs.cc.

{
  int rc;
#if TKEYVFS_TRACE
  fprintf(stderr, "Begin robust_open ...\n");
#endif /* TKEYVFS_TRACE */
  do {
    rc = osOpen(z, f, m);
  } while (rc < 0 && errno == EINTR);
#if TKEYVFS_TRACE
  fprintf(stderr, "End   robust_open ...\n");
#endif /* TKEYVFS_TRACE */
  return rc;
}

static int seekAndRead ( unixFile *  id, sqlite3_int64  offset, void *  pBuf, int  cnt  )

static

Definition at line 642 of file tkeyvfs.cc.

{
/**/
#if TKEYVFS_TRACE
  fprintf(stderr, "Begin seekAndRead ...\n");
#endif /* TKEYVFS_TRACE */
  if (offset >= id->fileSize) {
    id->lastErrno = 0;
#if TKEYVFS_TRACE
    fprintf(stderr, "End   seekAndRead ...\n");
#endif /* TKEYVFS_TRACE */
    return 0;
  }
  if ((offset + cnt) > id->fileSize) {
    cnt = (offset + cnt) - id->fileSize;
  }
  (void*)memcpy(pBuf, (const void*)(id->pBuf + offset), (size_t)cnt);
#if TKEYVFS_TRACE
  fprintf(stderr, "End   seekAndRead ...\n");
#endif /* TKEYVFS_TRACE */
  return cnt;
}

static int seekAndWrite ( unixFile *  id, i64  offset, const void *  pBuf, int  cnt  )

static

Definition at line 673 of file tkeyvfs.cc.

{
  unixFile* pFile = (unixFile*)id;
#if TKEYVFS_TRACE
  fprintf(stderr, "Begin seekAndWrite ...\n");
#endif /* TKEYVFS_TRACE */
  if ((offset + (i64)cnt) > id->bufAllocated) {
    i64 nByte;
    i64 newBufSize;
    nByte = offset + ((i64)cnt);
    if (pFile->szChunk) {
      nByte =
        ((nByte + (pFile->szChunk - 1)) / pFile->szChunk) * pFile->szChunk;
    }
    newBufSize =
      ((nByte + (i64)(MEMPAGE - 1)) / ((i64)MEMPAGE)) * ((i64)MEMPAGE);
    char* pNewBuf = (char*)realloc((void*)id->pBuf, (size_t)(newBufSize));
    if (pNewBuf == nullptr) {
      id->lastErrno = errno;
#if TKEYVFS_TRACE
      fprintf(stderr, "End   seekAndWrite ...\n");
#endif /* TKEYVFS_TRACE */
      return 0;
    }
    if ((offset + (i64)cnt) < newBufSize) {
      i64 zeroCnt = newBufSize - (offset + (i64)cnt);
      (void*)memset((void*)(pNewBuf + offset + (i64)cnt), 0, (size_t)zeroCnt);
    }
    id->pBuf = pNewBuf;
    id->bufAllocated = newBufSize;
  }
  (void*)memcpy((void*)(id->pBuf + offset), pBuf, (size_t)cnt);
  if ((offset + (i64)cnt) > id->fileSize) {
    id->fileSize = offset + (i64)cnt;
  }
#if TKEYVFS_TRACE
  fprintf(stderr, "End   seekAndWrite ...\n");
#endif /* TKEYVFS_TRACE */
  return cnt;
}

static int sqlite3CantopenError ( int  lineno )

static

Definition at line 209 of file tkeyvfs.cc.

{
  fprintf(stderr,
          "tkeyvfs.c: cannot open file at line %d of [%.10s]",
          lineno,
          20 + sqlite3_sourceid());
  return SQLITE_CANTOPEN;
}

static int sqlite3Strlen30 ( const char *  z )

static

Definition at line 228 of file tkeyvfs.cc.

{
  const char* z2 = z;
  if (z == 0) {
    return 0;
  }
  while (*z2) {
    z2++;
  }
  return 0x3fffffff & (int)(z2 - z);
}

int tkeyvfs_init

(

void

)

Definition at line 1768 of file tkeyvfs.cc.

{
/*
** The following macro defines an initializer for an sqlite3_vfs object.
** The name of the VFS is NAME.  The pAppData is a pointer to a pointer
** to the "finder" function.  (pAppData is a pointer to a pointer because
** silly C90 rules prohibit a void* from being cast to a function pointer
** and so we have to go through the intermediate pointer to avoid problems
** when compiling with -pedantic-errors on GCC.)
**
** The FINDER parameter to this macro is the name of the pointer to the
** finder-function.  The finder-function returns a pointer to the
** sqlite_io_methods object that implements the desired locking
** behaviors.  See the division above that contains the IOMETHODS
** macro for addition information on finder-functions.
**
** Most finders simply return a pointer to a fixed sqlite3_io_methods
** object.  But the "autolockIoFinder" available on MacOSX does a little
** more than that; it looks at the filesystem type that hosts the
** database file and tries to choose an locking method appropriate for
** that filesystem time.
*/
#define UNIXVFS(VFSNAME, FINDER)                                               \
  {                                                                            \
    1,                  /* iVersion */                                         \
      sizeof(unixFile), /* szOsFile */                                         \
      MAX_PATHNAME,     /* mxPathname */                                       \
      0,                /* pNext */                                            \
      VFSNAME,          /* zName */                                            \
      (void*)&FINDER,   /* pAppData */                                         \
      unixOpen,         /* xOpen */                                            \
      unixDelete,       /* xDelete */                                          \
      unixAccess,       /* xAccess */                                          \
      unixFullPathname, /* xFullPathname */                                    \
      unixDlOpen,       /* xDlOpen */                                          \
      unixDlError,      /* xDlError */                                         \
      unixDlSym,        /* xDlSym */                                           \
      unixDlClose,      /* xDlClose */                                         \
      unixRandomness,   /* xRandomness */                                      \
      unixSleep,        /* xSleep */                                           \
      unixCurrentTime,  /* xCurrentTime */                                     \
      unixGetLastError, /* xGetLastError */                                    \
    /* unixCurrentTimeInt64, v2, xCurrentTimeInt64 */                          \
    /* unixSetSystemCall,    v3, xSetSystemCall */                             \
    /* unixGetSystemCall,    v3, xGetSystemCall */                             \
    /* unixNextSystemCall,   v3, xNextSystemCall */                            \
  }
  /*
  ** All default VFSes for unix are contained in the following array.
  **
  ** Note that the sqlite3_vfs.pNext field of the VFS object is modified
  ** by the SQLite core when the VFS is registered.  So the following
  ** array cannot be const.
  */
  static sqlite3_vfs aVfs[] = {
    UNIXVFS("tkeyvfs", nolockIoFinder),
  };
  unsigned int i; /* Loop counter */
  /* Double-check that the aSyscall[] array has been constructed
  ** correctly.  See ticket [bb3a86e890c8e96ab] */
  assert(ArraySize(aSyscall) == 16);
  /* Register all VFSes defined in the aVfs[] array */
  for (i = 0; i < (sizeof(aVfs) / sizeof(sqlite3_vfs)); i++) {
    sqlite3_vfs_register(&aVfs[i], 0);
  }
  return SQLITE_OK;
}

int tkeyvfs_open_v2	(	const char *	filename,
		sqlite3 **	ppDb,
		int	flags,
		TFile *	rootFile
	)

Definition at line 1837 of file tkeyvfs.cc.

{
#ifndef TKEYVFS_NO_ROOT
  RootFileSentry rfs(rootFile);
  // Note that the sentry *is* the correct thing to do, here:
  // gRootFile is required in unixOpen(), which is called as part of
  // the chain of functions of which sqlite3_open_v2() is the first
  // call. By the time we return from sqlite3_open_v2() then, we no
  // longer require gRootFile and the sentry can do the job of
  // cleaning up when it goes out of scope.
#endif // TKEYVFS_NO_ROOT
  return sqlite3_open_v2(filename,
                         ppDb,
                         flags,
#ifdef TKEYVFS_NO_ROOT
                         nullptr
#else
                         "tkeyvfs"
#endif
  );
}

static int unixAccess ( sqlite3_vfs *  NotUsed, const char *  zPath, int  flags, int *  pResOut  )

static

Definition at line 1330 of file tkeyvfs.cc.

{
  int amode = 0;
  UNUSED_PARAMETER(NotUsed);
#if TKEYVFS_TRACE
  fprintf(stderr, "Begin unixAccess ...\n");
  if (zPath != nullptr) {
    fprintf(stderr, "filename: %s\n", zPath);
  }
#endif /* TKEYVFS_TRACE */
  switch (flags) {
    case SQLITE_ACCESS_EXISTS:
      /**/
#if TKEYVFS_TRACE
      fprintf(stderr, "op: SQLITE_ACCESS_EXISTS\n");
#endif /* TKEYVFS_TRACE */
      amode = F_OK;
      break;
    case SQLITE_ACCESS_READWRITE:
      /**/
#if TKEYVFS_TRACE
      fprintf(stderr, "op: SQLITE_ACCESS_READWRITE\n");
#endif /* TKEYVFS_TRACE */
      amode = W_OK | R_OK;
      break;
    case SQLITE_ACCESS_READ:
      /**/
#if TKEYVFS_TRACE
      fprintf(stderr, "op: SQLITE_ACCESS_READ\n");
#endif /* TKEYVFS_TRACE */
      amode = R_OK;
      break;
    default:
      assert(!"Invalid flags argument");
  }
  *pResOut = 0;
#if TKEYVFS_TRACE
  fprintf(stderr, "End   unixAccess ...\n");
#endif /* TKEYVFS_TRACE */
  return SQLITE_OK;
}

static int unixCurrentTime ( sqlite3_vfs *  NotUsed, double *  prNow  )

static

Definition at line 1570 of file tkeyvfs.cc.

{
  sqlite3_int64 i;
  UNUSED_PARAMETER(NotUsed);
#if TKEYVFS_TRACE
  fprintf(stderr, "Begin unixCurrentTime ...\n");
#endif /* TKEYVFS_TRACE */
  unixCurrentTimeInt64(0, &i);
  *prNow = i / 86400000.0;
#if TKEYVFS_TRACE
  fprintf(stderr, "End   unixCurrentTime ...\n");
#endif /* TKEYVFS_TRACE */
  return 0;
}

static int unixCurrentTimeInt64 ( sqlite3_vfs *  NotUsed, sqlite3_int64 *  piNow  )

static

Definition at line 1615 of file tkeyvfs.cc.

{
  static const sqlite3_int64 unixEpoch = 24405875 * (sqlite3_int64)8640000;
  struct timeval sNow;
#if TKEYVFS_TRACE
  fprintf(stderr, "Begin unixCurrentTimeInt64 ...\n");
#endif /* TKEYVFS_TRACE */
  gettimeofday(&sNow, 0);
  *piNow = unixEpoch + 1000 * (sqlite3_int64)sNow.tv_sec + sNow.tv_usec / 1000;
  UNUSED_PARAMETER(NotUsed);
#if TKEYVFS_TRACE
  fprintf(stderr, "End   unixCurrentTimeInt64 ...\n");
#endif /* TKEYVFS_TRACE */
  return 0;
}

static int unixDelete ( sqlite3_vfs *  NotUsed, const char *  zPath, int  dirSync  )

static

Definition at line 1300 of file tkeyvfs.cc.

{
  int rc = SQLITE_OK;
  UNUSED_PARAMETER(NotUsed);
#if TKEYVFS_TRACE
  fprintf(stderr, "Begin unixDelete ...\n");
  if (zPath != nullptr) {
    fprintf(stderr, "filename: %s\n", zPath);
  }
#endif /* TKEYVFS_TRACE */
#if TKEYVFS_TRACE
  fprintf(stderr, "End   unixDelete ...\n");
#endif /* TKEYVFS_TRACE */
  return rc;
}

static int unixDeviceCharacteristics ( sqlite3_file *  NotUsed )

static

Definition at line 1133 of file tkeyvfs.cc.

{
  UNUSED_PARAMETER(NotUsed);
#if TKEYVFS_TRACE
  fprintf(stderr, "Begin unixDeviceCharacteristics ...\n");
#endif /* TKEYVFS_TRACE */
#if TKEYVFS_TRACE
  fprintf(stderr, "End   unixDeviceCharacteristics ...\n");
#endif /* TKEYVFS_TRACE */
  return 0;
}

static void unixDlClose ( sqlite3_vfs *  NotUsed, void *  pHandle  )

static

Definition at line 1481 of file tkeyvfs.cc.

{
  UNUSED_PARAMETER(NotUsed);
#if TKEYVFS_TRACE
  fprintf(stderr, "Begin unixDlClose ...\n");
#endif /* TKEYVFS_TRACE */
  dlclose(pHandle);
#if TKEYVFS_TRACE
  fprintf(stderr, "End   unixDlClose ...\n");
#endif /* TKEYVFS_TRACE */
  /**/
}

static void unixDlError ( sqlite3_vfs *  NotUsed, int  nBuf, char *  zBufOut  )

static

Definition at line 1435 of file tkeyvfs.cc.

{
  const char* zErr;
  UNUSED_PARAMETER(NotUsed);
#if TKEYVFS_TRACE
  fprintf(stderr, "Begin unixDlError ...\n");
#endif /* TKEYVFS_TRACE */
  zErr = dlerror();
  if (zErr) {
    sqlite3_snprintf(nBuf, zBufOut, "%s", zErr);
  }
#if TKEYVFS_TRACE
  fprintf(stderr, "End   unixDlError ...\n");
#endif /* TKEYVFS_TRACE */
  /**/
}

static void * unixDlOpen ( sqlite3_vfs *  NotUsed, const char *  zFilename  )

static

Definition at line 1414 of file tkeyvfs.cc.

{
  UNUSED_PARAMETER(NotUsed);
#if TKEYVFS_TRACE
  fprintf(stderr, "Begin unixFullPathName ...\n");
#endif /* TKEYVFS_TRACE */
  void* p = dlopen(zFilename, RTLD_NOW | RTLD_GLOBAL);
#if TKEYVFS_TRACE
  fprintf(stderr, "End   unixFullPathName ...\n");
#endif /* TKEYVFS_TRACE */
  return p;
}

static int unixFileControl ( sqlite3_file *  id, int  op, void *  pArg  )

static

Definition at line 1018 of file tkeyvfs.cc.

{
/**/
#if TKEYVFS_TRACE
  fprintf(stderr, "Begin unixFileControl ...\n");
  if (((unixFile*)id)->zPath) {
    fprintf(stderr, "filename: %s\n", ((unixFile*)id)->zPath);
  }
#endif /* TKEYVFS_TRACE */
  switch (op) {
    case SQLITE_FCNTL_LOCKSTATE: {
    /**/
#if TKEYVFS_TRACE
      fprintf(stderr, "op: LOCKSTATE\n");
#endif /* TKEYVFS_TRACE */
      *(int*)pArg = ((unixFile*)id)->eFileLock;
      /*SQLITE_LOCK_NONE*/
#if TKEYVFS_TRACE
      fprintf(stderr, "End   unixFileControl ...\n");
#endif /* TKEYVFS_TRACE */
      return SQLITE_OK;
    }
    case SQLITE_LAST_ERRNO: {
    /**/
#if TKEYVFS_TRACE
      fprintf(stderr, "op: LAST_ERRNO\n");
#endif /* TKEYVFS_TRACE */
      *(int*)pArg = ((unixFile*)id)->lastErrno;
#if TKEYVFS_TRACE
      fprintf(stderr, "End   unixFileControl ...\n");
#endif /* TKEYVFS_TRACE */
      return SQLITE_OK;
    }
    case SQLITE_FCNTL_CHUNK_SIZE: {
    /**/
#if TKEYVFS_TRACE
      fprintf(stderr, "op: CHUNK_SIZE\n");
      fprintf(stderr, "szChunk: %d\n", *(int*)pArg);
#endif /* TKEYVFS_TRACE */
      ((unixFile*)id)->szChunk = *(int*)pArg;
#if TKEYVFS_TRACE
      fprintf(stderr, "End   unixFileControl ...\n");
#endif /* TKEYVFS_TRACE */
      return SQLITE_OK;
    }
    case SQLITE_FCNTL_SIZE_HINT: {
    /**/
#if TKEYVFS_TRACE
      fprintf(stderr, "op: SIZE_HINT\n");
      fprintf(stderr, "hint: 0x%016lx\n", *(i64*)pArg);
#endif /* TKEYVFS_TRACE */
      int val = fcntlSizeHint((unixFile*)id, *(i64*)pArg);
#if TKEYVFS_TRACE
      fprintf(stderr, "End   unixFileControl ...\n");
#endif /* TKEYVFS_TRACE */
      return val;
    }
    /* The pager calls this method to signal that it has done
    ** a rollback and that the database is therefore unchanged and
    ** it hence it is OK for the transaction change counter to be
    ** unchanged.
    */
    case SQLITE_FCNTL_DB_UNCHANGED: {
    /**/
#if TKEYVFS_TRACE
      fprintf(stderr, "op: DB_UNCHANGED\n");
#endif /* TKEYVFS_TRACE */
      ((unixFile*)id)->dbUpdate = 0;
#if TKEYVFS_TRACE
      fprintf(stderr, "End   unixFileControl ...\n");
#endif /* TKEYVFS_TRACE */
      return SQLITE_OK;
    }
    case SQLITE_FCNTL_SYNC_OMITTED: {
    /**/
#if TKEYVFS_TRACE
      fprintf(stderr, "op: SYNC_OMITTED\n");
      fprintf(stderr, "End   unixFileControl ...\n");
#endif                  /* TKEYVFS_TRACE */
      return SQLITE_OK; /* A no-op */
    }
  }
#if TKEYVFS_TRACE
  fprintf(stderr, "End   unixFileControl ...\n");
#endif /* TKEYVFS_TRACE */
  return SQLITE_NOTFOUND;
}

static int unixFileSize ( sqlite3_file *  id, i64 *  pSize  )

static

Definition at line 938 of file tkeyvfs.cc.

{
  unixFile* p = (unixFile*)id;
#if TKEYVFS_TRACE
  fprintf(stderr, "Begin unixFileSize ...\n");
  if (((unixFile*)id)->zPath) {
    fprintf(stderr, "filename: %s\n", ((unixFile*)id)->zPath);
  }
#endif /* TKEYVFS_TRACE */
  *pSize = p->fileSize;
  /* When opening a zero-size database, the findInodeInfo() procedure
  ** writes a single byte into that file in order to work around a bug
  ** in the OS-X msdos filesystem.  In order to avoid problems with upper
  ** layers, we need to report this file size as zero even though it is
  ** really 1.   Ticket #3260.
  */
  if (*pSize == 1) {
    *pSize = 0;
  }
#if TKEYVFS_TRACE
  fprintf(stderr, "End   unixFileSize ...\n");
#endif /* TKEYVFS_TRACE */
  return SQLITE_OK;
}

static int unixFullPathname ( sqlite3_vfs *  pVfs, const char *  zPath, int  nOut, char *  zOut  )

static

Definition at line 1386 of file tkeyvfs.cc.

{
/**/
#if TKEYVFS_TRACE
  fprintf(stderr, "Begin unixFullPathName ...\n");
  if (zPath != nullptr) {
    fprintf(stderr, "filename: %s\n", zPath);
  }
#endif /* TKEYVFS_TRACE */
  assert(pVfs->mxPathname == MAX_PATHNAME);
  UNUSED_PARAMETER(pVfs);
  zOut[nOut - 1] = '\0';
  sqlite3_snprintf(nOut, zOut, "%s", zPath);
#if TKEYVFS_TRACE
  fprintf(stderr, "End   unixFullPathName ...\n");
#endif /* TKEYVFS_TRACE */
  return SQLITE_OK;
}

static int unixGetLastError ( sqlite3_vfs *  NotUsed, int  NotUsed2, char *  NotUsed3  )

static

Definition at line 1593 of file tkeyvfs.cc.

{
  UNUSED_PARAMETER(NotUsed);
  UNUSED_PARAMETER(NotUsed2);
  UNUSED_PARAMETER(NotUsed3);
#if TKEYVFS_TRACE
  fprintf(stderr, "Begin unixGetLastError ...\n");
  fprintf(stderr, "End   unixGetLastError ...\n");
#endif /* TKEYVFS_TRACE */
  return 0;
}

static sqlite3_syscall_ptr unixGetSystemCall ( sqlite3_vfs *  pNotUsed, const char *  zName  )

static

Definition at line 1690 of file tkeyvfs.cc.

{
  unsigned int i;
  UNUSED_PARAMETER(pNotUsed);
#if TKEYVFS_TRACE
  fprintf(stderr, "Begin unixGetSystemCall ...\n");
#endif /* TKEYVFS_TRACE */
  for (i = 0; i < sizeof(aSyscall) / sizeof(aSyscall[0]); i++) {
    if (strcmp(zName, aSyscall[i].zName) == 0) {
    /**/
#if TKEYVFS_TRACE
      fprintf(stderr, "End   unixGetSystemCall ...\n");
#endif /* TKEYVFS_TRACE */
      return aSyscall[i].pCurrent;
    }
  }
#if TKEYVFS_TRACE
  fprintf(stderr, "End   unixGetSystemCall ...\n");
#endif /* TKEYVFS_TRACE */
  return 0;
}

static int unixGetTempname ( int  nBuf, char *  zBuf  )

static

Definition at line 549 of file tkeyvfs.cc.

{
  static const unsigned char zChars[] = "abcdefghijklmnopqrstuvwxyz"
                                        "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
                                        "0123456789";
  unsigned int i, j;
#if TKEYVFS_TRACE
  fprintf(stderr, "Begin unixGetTempname ...\n");
#endif /* TKEYVFS_TRACE */
  /* Check that the output buffer is large enough for the temporary file
  ** name. If it is not, return SQLITE_ERROR.
  */
  if ((strlen(SQLITE_TEMP_FILE_PREFIX) + 17) >= (size_t)nBuf) {
  /**/
#if TKEYVFS_TRACE
    fprintf(stderr, "End   unixGetTempname ...\n");
#endif /* TKEYVFS_TRACE */
    return SQLITE_ERROR;
  }
  sqlite3_snprintf(nBuf - 17, zBuf, SQLITE_TEMP_FILE_PREFIX);
  j = (int)strlen(zBuf);
  sqlite3_randomness(15, &zBuf[j]);
  for (i = 0; i < 15; i++, j++) {
    zBuf[j] = (char)zChars[((unsigned char)zBuf[j]) % (sizeof(zChars) - 1)];
  }
  zBuf[j] = 0;
#if TKEYVFS_TRACE
  fprintf(stderr, "End   unixGetTempname ...\n");
#endif /* TKEYVFS_TRACE */
  return SQLITE_OK;
}

static int unixLogErrorAtLine ( int  errcode, const char *  zFunc, const char *  zPath, int  iLine  )

static

Definition at line 388 of file tkeyvfs.cc.

{
  char* zErr;         /* Message from strerror() or equivalent */
  int iErrno = errno; /* Saved syscall error number */
  zErr = strerror(iErrno);
  if (zPath == 0) {
    zPath = "";
  }
  fprintf(stderr,
          "tkeyvfs.c:%d: (%d) %s(%s) - %s",
          iLine,
          iErrno,
          zFunc,
          zPath,
          zErr);
  return errcode;
}

static const char * unixNextSystemCall ( sqlite3_vfs *  p, const char *  zName  )

static

Definition at line 1719 of file tkeyvfs.cc.

{
  int i = -1;
  UNUSED_PARAMETER(p);
#if TKEYVFS_TRACE
  fprintf(stderr, "Begin unixNextSystemCall ...\n");
#endif /* TKEYVFS_TRACE */
  if (zName) {
    for (i = 0; i < ArraySize(aSyscall) - 1; i++) {
      if (strcmp(zName, aSyscall[i].zName) == 0) {
        break;
      }
    }
  }
  for (i++; i < ArraySize(aSyscall); i++) {
    if (aSyscall[i].pCurrent != 0) {
    /**/
#if TKEYVFS_TRACE
      fprintf(stderr, "End   unixNextSystemCall ...\n");
#endif /* TKEYVFS_TRACE */
      return aSyscall[i].zName;
    }
  }
#if TKEYVFS_TRACE
  fprintf(stderr, "End   unixNextSystemCall ...\n");
#endif /* TKEYVFS_TRACE */
  return nullptr;
}

static int unixOpen ( sqlite3_vfs *  pVfs, const char *  zPath, sqlite3_file *  pFile, int  flags, int *  pOutFlags  )

static

Definition at line 1171 of file tkeyvfs.cc.

{
  unixFile* p = (unixFile*)pFile;
  int eType = flags & 0xFFFFFF00; /* Type of file to open */
  int rc = SQLITE_OK;
  // int isExclusive  = (flags & SQLITE_OPEN_EXCLUSIVE); // Not used.
  int isDelete = (flags & SQLITE_OPEN_DELETEONCLOSE);
  int isCreate = (flags & SQLITE_OPEN_CREATE);
  int isReadonly = (flags & SQLITE_OPEN_READONLY);
  int isReadWrite = (flags & SQLITE_OPEN_READWRITE);
  char zTmpname[MAX_PATHNAME + 1];
  const char* zName = zPath;
#if TKEYVFS_TRACE
  fprintf(stderr, "Begin unixOpen ...\n");
  if (zPath != nullptr) {
    fprintf(stderr, "filename: %s\n", zPath);
  }
#endif /* TKEYVFS_TRACE */
  memset(p, 0, sizeof(unixFile));
  if (pOutFlags) {
    *pOutFlags = flags;
  }
  if (!zName) {
    rc = unixGetTempname(MAX_PATHNAME + 1, zTmpname);
    if (rc != SQLITE_OK) {
      return rc;
    }
    zName = zTmpname;
  }
  if (zName != nullptr) {
    p->zPath = (char*)malloc(strlen(zName) + 1);
    if (p->zPath != nullptr) {
      (void*)strcpy((char*)p->zPath, zName);
    }
  }
  p->lastErrno = 0;
  p->pMethod = &nolockIoMethods;
#ifndef TKEYVFS_NO_ROOT
  p->rootFile = nullptr;
  if (eType & SQLITE_OPEN_MAIN_DB) {
    p->rootFile = gRootFile;
  }
  p->saveToRootFile =
    (p->rootFile && p->rootFile->IsWritable() &&
     (eType & SQLITE_OPEN_MAIN_DB) && (isCreate || isReadWrite) && !isDelete);
#endif // TKEYVFS_NO_ROOT
  if ((eType & SQLITE_OPEN_MAIN_DB) && !isCreate) {
    /**/
    i64 nBytes = 0;
    i64 nAlloc = 0;
#ifndef TKEYVFS_NO_ROOT
    Bool_t status = kFALSE;
    TKey* k = 0;
    char* pKeyBuf = 0;
    /* Read the highest numbered cycle of the tkey which contains
    ** the database from the root file. */
    k = p->rootFile->GetKey(p->zPath, 9999 /*cycle*/);
    /* Force the tkey to allocate an i/o buffer for its contents. */
    k->SetBuffer();
    /* Read the contents of the tkey from the root file. */
    status = k->ReadFile();
    if (!status) {
    /**/
#if TKEYVFS_TRACE
      fprintf(stderr, "End   unixOpen ...\n");
#endif /* TKEYVFS_TRACE */
      rc = unixLogError(SQLITE_CANTOPEN_BKPT, "open", zName);
      return rc;
    }
    /* Get a pointer to the tkey i/o buffer. */
    pKeyBuf = k->GetBuffer();
    /* Get the size of the contained database file from the tkey. */
    nBytes = k->GetObjlen();
    /* Allocate enough memory pages to contain the database file. */
    nAlloc =
      ((nBytes + ((i64)(MEMPAGE - 1))) / ((i64)MEMPAGE)) * ((i64)MEMPAGE);
    p->pBuf = (char*)malloc((size_t)nAlloc);
#else  // TKEYVFS_NO_ROOT
    /* If not using root, a database file read is a noop. */
    nBytes = 0;
    nAlloc = MEMPAGE;
    p->pBuf = (char*)calloc(1, MEMPAGE);
#endif // TKEYVFS_NO_ROOT
    if (p->pBuf == nullptr) {
    /**/
#if TKEYVFS_TRACE
      fprintf(stderr, "End   unixOpen ...\n");
#endif /* TKEYVFS_TRACE */
      rc = unixLogError(SQLITE_CANTOPEN_BKPT, "open", zName);
      return rc;
    }
#ifndef TKEYVFS_NO_ROOT
    /* Copy the entire database file from the tkey i/o buffer
    ** into our in-memory database. */
    (void*)memcpy(p->pBuf, pKeyBuf, (size_t)nBytes);
#endif // TKEYVFS_NO_ROOT
    p->bufAllocated = nAlloc;
    p->fileSize = nBytes;
    /**/
  } else {
    p->pBuf = (char*)calloc(1, MEMPAGE);
    if (p->pBuf == nullptr) {
    /**/
#if TKEYVFS_TRACE
      fprintf(stderr, "End   unixOpen ...\n");
#endif /* TKEYVFS_TRACE */
      rc = unixLogError(SQLITE_CANTOPEN_BKPT, "open", zName);
      return rc;
    }
    p->bufAllocated = MEMPAGE;
    p->fileSize = 0;
  }
  rc = SQLITE_OK;
#if TKEYVFS_TRACE
  fprintf(stderr, "End   unixOpen ...\n");
#endif /* TKEYVFS_TRACE */
  return rc;
}

static int unixRandomness ( sqlite3_vfs *  NotUsed, int  nBuf, char *  zBuf  )

static

Definition at line 1498 of file tkeyvfs.cc.

{
  UNUSED_PARAMETER(NotUsed);
  assert((size_t)nBuf >= (sizeof(time_t) + sizeof(int)));
#if TKEYVFS_TRACE
  fprintf(stderr, "Begin unixRandomness ...\n");
#endif /* TKEYVFS_TRACE */
  /* We have to initialize zBuf to prevent valgrind from reporting
  ** errors.  The reports issued by valgrind are incorrect - we would
  ** prefer that the randomness be increased by making use of the
  ** uninitialized space in zBuf - but valgrind errors tend to worry
  ** some users.  Rather than argue, it seems easier just to initialize
  ** the whole array and silence valgrind, even if that means less randomness
  ** in the random seed.
  **
  ** When testing, initializing zBuf[] to zero is all we do.  That means
  ** that we always use the same random number sequence.  This makes the
  ** tests repeatable.
  */
  memset(zBuf, 0, nBuf);
  {
    int pid, fd;
    fd = robust_open("/dev/urandom", O_RDONLY, 0);
    if (fd < 0) {
      time_t t;
      time(&t);
      memcpy(zBuf, &t, sizeof(t));
      pid = getpid();
      memcpy(&zBuf[sizeof(t)], &pid, sizeof(pid));
      assert(sizeof(t) + sizeof(pid) <= (size_t)nBuf);
      nBuf = sizeof(t) + sizeof(pid);
    } else {
      do {
        nBuf = osRead(fd, zBuf, nBuf);
      } while (nBuf < 0 && errno == EINTR);
      robust_close(0, fd, __LINE__);
    }
  }
#if TKEYVFS_TRACE
  fprintf(stderr, "End   unixRandomness ...\n");
#endif /* TKEYVFS_TRACE */
  return nBuf;
}

static int unixRead ( sqlite3_file *  id, void *  pBuf, int  amt, sqlite3_int64  offset  )

static

Definition at line 737 of file tkeyvfs.cc.

{
  unixFile* pFile = (unixFile*)id;
  int got;
#if TKEYVFS_TRACE
  fprintf(stderr, "Begin unixRead ...\n");
  if (((unixFile*)id)->zPath) {
    fprintf(stderr, "filename: %s\n", ((unixFile*)id)->zPath);
  }
  fprintf(
    stderr, "offset: 0x%016lx  amt: 0x%08x\n", (unsigned long long)offset, amt);
#endif /* TKEYVFS_TRACE */
  got = seekAndRead(pFile, offset, pBuf, amt);
  if (got == amt) {
  /**/
#if TKEYVFS_TRACE
    fprintf(stderr, "End   unixRead ...\n");
#endif /* TKEYVFS_TRACE */
    return SQLITE_OK;
  } else if (got < 0) {
  /* lastErrno set by seekAndRead */
#if TKEYVFS_TRACE
    fprintf(stderr, "End   unixRead ...\n");
#endif /* TKEYVFS_TRACE */
    return SQLITE_IOERR_READ;
  } else {
    pFile->lastErrno = 0; /* not a system error */
    /* Unread parts of the buffer must be zero-filled */
    memset(&((char*)pBuf)[got], 0, amt - got);
#if TKEYVFS_TRACE
    fprintf(stderr, "End   unixRead ...\n");
#endif /* TKEYVFS_TRACE */
    return SQLITE_IOERR_SHORT_READ;
  }
}

static int unixSectorSize ( sqlite3_file *  NotUsed )

static

Definition at line 1117 of file tkeyvfs.cc.

{
  UNUSED_PARAMETER(NotUsed);
#if TKEYVFS_TRACE
  fprintf(stderr, "Begin unixSectorSize ...\n");
#endif /* TKEYVFS_TRACE */
#if TKEYVFS_TRACE
  fprintf(stderr, "End   unixSectorSize ...\n");
#endif /* TKEYVFS_TRACE */
  return SQLITE_DEFAULT_SECTOR_SIZE;
}

static int unixSetSystemCall ( sqlite3_vfs *  pNotUsed, const char *  zName, sqlite3_syscall_ptr  pNewFunc  )

static

Definition at line 1638 of file tkeyvfs.cc.

{
  unsigned int i;
  int rc = SQLITE_NOTFOUND;
  UNUSED_PARAMETER(pNotUsed);
#if TKEYVFS_TRACE
  fprintf(stderr, "Begin unixSetSystemCall ...\n");
#endif /* TKEYVFS_TRACE */
  if (zName == 0) {
    /* If no zName is given, restore all system calls to their default
    ** settings and return nullptr
    */
    rc = SQLITE_OK;
    for (i = 0; i < sizeof(aSyscall) / sizeof(aSyscall[0]); i++) {
      if (aSyscall[i].pDefault) {
        aSyscall[i].pCurrent = aSyscall[i].pDefault;
      }
    }
  } else {
    /* If zName is specified, operate on only the one system call
    ** specified.
    */
    for (i = 0; i < sizeof(aSyscall) / sizeof(aSyscall[0]); i++) {
      if (strcmp(zName, aSyscall[i].zName) == 0) {
        if (aSyscall[i].pDefault == 0) {
          aSyscall[i].pDefault = aSyscall[i].pCurrent;
        }
        rc = SQLITE_OK;
        if (pNewFunc == 0) {
          pNewFunc = aSyscall[i].pDefault;
        }
        aSyscall[i].pCurrent = pNewFunc;
        break;
      }
    }
  }
#if TKEYVFS_TRACE
  fprintf(stderr, "End   unixSetSystemCall ...\n");
#endif /* TKEYVFS_TRACE */
  return rc;
}

static int unixSleep ( sqlite3_vfs *  NotUsed, int  microseconds  )

static

Definition at line 1551 of file tkeyvfs.cc.

{
  UNUSED_PARAMETER(NotUsed);
#if TKEYVFS_TRACE
  fprintf(stderr, "Begin unixSleep ...\n");
#endif /* TKEYVFS_TRACE */
  usleep(microseconds);
#if TKEYVFS_TRACE
  fprintf(stderr, "End   unixSleep ...\n");
#endif /* TKEYVFS_TRACE */
  return microseconds;
}

static int unixSync ( sqlite3_file *  id, int  flags  )

static

Definition at line 919 of file tkeyvfs.cc.

{
  UNUSED_PARAMETER2(id, flags);
#if TKEYVFS_TRACE
  fprintf(stderr, "Begin unixSync ...\n");
  if (((unixFile*)id)->zPath) {
    fprintf(stderr, "filename: %s\n", ((unixFile*)id)->zPath);
  }
#endif /* TKEYVFS_TRACE */
#if TKEYVFS_TRACE
  fprintf(stderr, "End   unixSync ...\n");
#endif /* TKEYVFS_TRACE */
  return SQLITE_OK;
}

static int unixTruncate ( sqlite3_file *  id, i64  nByte  )

static

Definition at line 837 of file tkeyvfs.cc.

{
  unixFile* pFile = (unixFile*)id;
  int rc;
#if TKEYVFS_TRACE
  fprintf(stderr, "Begin unixTruncate ...\n");
  if (((unixFile*)id)->zPath) {
    fprintf(stderr, "filename: %s\n", ((unixFile*)id)->zPath);
  }
  fprintf(stderr, "nByte: 0x%016lx\n", (unsigned long long)nByte);
#endif /* TKEYVFS_TRACE */
  /* If the user has configured a chunk-size for this file, truncate the
  ** file so that it consists of an integer number of chunks (i.e. the
  ** actual file size after the operation may be larger than the requested
  ** size).
  */
  if (pFile->szChunk) {
    nByte = ((nByte + pFile->szChunk - 1) / pFile->szChunk) * pFile->szChunk;
  }
  if (nByte == 0) {
    free(pFile->pBuf);
    pFile->pBuf = (char*)calloc(1, MEMPAGE);
    if (pFile->pBuf == nullptr) {
      pFile->bufAllocated = 0;
      pFile->fileSize = 0;
      pFile->lastErrno = errno;
#if TKEYVFS_TRACE
      fprintf(stderr, "End   unixTruncate ...\n");
#endif /* TKEYVFS_TRACE */
      return unixLogError(SQLITE_IOERR_TRUNCATE, "ftruncate", pFile->zPath);
    }
    pFile->bufAllocated = MEMPAGE;
    pFile->fileSize = 0;
  } else {
    i64 newBufSize =
      ((nByte + (i64)(MEMPAGE - 1)) / ((i64)MEMPAGE)) * ((i64)MEMPAGE);
    i64 zeroCnt = newBufSize - nByte;
    char* pNewBuf = (char*)realloc((void*)pFile->pBuf, (size_t)newBufSize);
    if (pNewBuf == nullptr) {
      pFile->lastErrno = errno;
#if TKEYVFS_TRACE
      fprintf(stderr, "End   unixTruncate ...\n");
#endif /* TKEYVFS_TRACE */
      return unixLogError(SQLITE_IOERR_TRUNCATE, "ftruncate", pFile->zPath);
    }
    (void*)memset((void*)(pNewBuf + nByte), 0, (size_t)zeroCnt);
    pFile->pBuf = pNewBuf;
    pFile->bufAllocated = newBufSize;
    pFile->fileSize = nByte;
  }
  /* If we are doing a normal write to a database file (as opposed to
  ** doing a hot-journal rollback or a write to some file other than a
  ** normal database file) and we truncate the file to zero length,
  ** that effectively updates the change counter.  This might happen
  ** when restoring a database using the backup API from a zero-length
  ** source.
  */
  if (pFile->inNormalWrite && (nByte == 0)) {
    pFile->transCntrChng = 1;
  }
#if TKEYVFS_TRACE
  fprintf(stderr, "End   unixTruncate ...\n");
#endif /* TKEYVFS_TRACE */
  return SQLITE_OK;
}

static int unixWrite ( sqlite3_file *  id, const void *  pBuf, int  amt, sqlite3_int64  offset  )

static

Definition at line 778 of file tkeyvfs.cc.

{
  unixFile* pFile = (unixFile*)id;
  int wrote = 0;
#if TKEYVFS_TRACE
  fprintf(stderr, "Begin unixWrite ...\n");
  if (((unixFile*)id)->zPath) {
    fprintf(stderr, "filename: %s\n", ((unixFile*)id)->zPath);
  }
  fprintf(
    stderr, "offset: 0x%016lx  amt: 0x%08x\n", (unsigned long long)offset, amt);
#endif /* TKEYVFS_TRACE */
  /* If we are doing a normal write to a database file (as opposed to
  ** doing a hot-journal rollback or a write to some file other than a
  ** normal database file) then record the fact that the database
  ** has changed.  If the transaction counter is modified, record that
  ** fact too.
  */
  if (pFile->inNormalWrite) {
    pFile->dbUpdate = 1; /* The database has been modified */
    if ((offset <= 24) && (offset + amt >= 27)) {
      int rc;
      char oldCntr[4];
      rc = seekAndRead(pFile, 24, oldCntr, 4);
      if (rc != 4 || memcmp(oldCntr, &((char*)pBuf)[24 - offset], 4) != 0) {
        pFile->transCntrChng = 1; /* The transaction counter has changed */
      }
    }
  }
  while ((amt > 0) && ((wrote = seekAndWrite(pFile, offset, pBuf, amt)) > 0)) {
    amt -= wrote;
    offset += wrote;
    pBuf = &((char*)pBuf)[wrote];
  }
  if (amt > 0) {
    if (wrote < 0) {
    /* lastErrno set by seekAndWrite */
#if TKEYVFS_TRACE
      fprintf(stderr, "End   unixWrite ...\n");
#endif /* TKEYVFS_TRACE */
      return SQLITE_IOERR_WRITE;
    } else {
      pFile->lastErrno = 0; /* not a system error */
#if TKEYVFS_TRACE
      fprintf(stderr, "End   unixWrite ...\n");
#endif /* TKEYVFS_TRACE */
      return SQLITE_FULL;
    }
  }
#if TKEYVFS_TRACE
  fprintf(stderr, "End   unixWrite ...\n");
#endif /* TKEYVFS_TRACE */
  return SQLITE_OK;
}

Variable Documentation

struct unix_syscall aSyscall[]

static

TFile* gRootFile

static

Definition at line 76 of file tkeyvfs.cc.

const sqlite3_io_methods*(*const nolockIoFinder) (const char *, unixFile *p)

static

Initial value:

=
  nolockIoFinderImpl

Definition at line 364 of file tkeyvfs.cc.

const sqlite3_io_methods nolockIoMethods

static

Initial value:

= {
  1,                         
  nolockClose,               
  unixRead,                  
  unixWrite,                 
  unixTruncate,              
  unixSync,                  
  unixFileSize,              
  nolockLock,                
  nolockUnlock,              
  nolockCheckReservedLock,   
  unixFileControl,           
  unixSectorSize,            
  unixDeviceCharacteristics, 





 
}

Definition at line 334 of file tkeyvfs.cc.

void(*)(void) unixDlSym(sqlite3_vfs *NotUsed, void *p, const char *zSym)

static

Definition at line 194 of file tkeyvfs.cc.