Adding upstream version 3.45.1.upstream/3.45.1

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 525 insertions, 0 deletions

diff --git a/src/test_devsym.c b/src/test_devsym.c
new file mode 100644
index 0000000..86b78f1
--- /dev/null
+++ b/src/test_devsym.c
@@ -0,0 +1,525 @@
+/*
+** 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"
+#define WRITECRASH_NAME "writecrash"
+
+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*);
+
+struct DevsymGlobal {
+  sqlite3_vfs *pVfs;
+  int iDeviceChar;
+  int iSectorSize;
+  int nWriteCrash;
+};
+struct DevsymGlobal g = {0, 0, 512, 0};
+
+/*
+** Close an devsym-file.
+*/
+static int devsymClose(sqlite3_file *pFile){
+  devsym_file *p = (devsym_file *)pFile;
+  sqlite3OsClose(p->pReal);
+  return SQLITE_OK;
+}
+
+/*
+** 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-throughs.
+*/
+static int devsymShmLock(sqlite3_file *pFile, int ofst, int n, int flags){
+  devsym_file *p = (devsym_file *)pFile;
+  return p->pReal->pMethods->xShmLock(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 p->pReal->pMethods->xShmMap(p->pReal, iRegion, szRegion, isWrite, pp);
+}
+static void devsymShmBarrier(sqlite3_file *pFile){
+  devsym_file *p = (devsym_file *)pFile;
+  p->pReal->pMethods->xShmBarrier(p->pReal);
+}
+static int devsymShmUnmap(sqlite3_file *pFile, int delFlag){
+  devsym_file *p = (devsym_file *)pFile;
+  return p->pReal->pMethods->xShmUnmap(p->pReal, delFlag);
+}
+
+
+
+/*
+** Open an devsym file handle.
+*/
+static int devsymOpen(
+  sqlite3_vfs *pVfs,
+  const char *zName,
+  sqlite3_file *pFile,
+  int flags,
+  int *pOutFlags
+){
+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 */
+};
+
+  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);
+}
+
+/*
+** Return the sector-size in bytes for an writecrash-file.
+*/
+static int writecrashSectorSize(sqlite3_file *pFile){
+  devsym_file *p = (devsym_file *)pFile;
+  return sqlite3OsSectorSize(p->pReal);
+}
+
+/*
+** Return the device characteristic flags supported by an writecrash-file.
+*/
+static int writecrashDeviceCharacteristics(sqlite3_file *pFile){
+  devsym_file *p = (devsym_file *)pFile;
+  return sqlite3OsDeviceCharacteristics(p->pReal);
+}
+
+/*
+** Write data to an writecrash-file.
+*/
+static int writecrashWrite(
+  sqlite3_file *pFile, 
+  const void *zBuf, 
+  int iAmt, 
+  sqlite_int64 iOfst
+){
+  devsym_file *p = (devsym_file *)pFile;
+  if( g.nWriteCrash>0 ){
+    g.nWriteCrash--;
+    if( g.nWriteCrash==0 ) abort();
+  }
+  return sqlite3OsWrite(p->pReal, zBuf, iAmt, iOfst);
+}
+
+/*
+** Open an writecrash file handle.
+*/
+static int writecrashOpen(
+  sqlite3_vfs *pVfs,
+  const char *zName,
+  sqlite3_file *pFile,
+  int flags,
+  int *pOutFlags
+){
+static sqlite3_io_methods writecrash_io_methods = {
+  2,                                /* iVersion */
+  devsymClose,                      /* xClose */
+  devsymRead,                       /* xRead */
+  writecrashWrite,                  /* xWrite */
+  devsymTruncate,                   /* xTruncate */
+  devsymSync,                       /* xSync */
+  devsymFileSize,                   /* xFileSize */
+  devsymLock,                       /* xLock */
+  devsymUnlock,                     /* xUnlock */
+  devsymCheckReservedLock,          /* xCheckReservedLock */
+  devsymFileControl,                /* xFileControl */
+  writecrashSectorSize,             /* xSectorSize */
+  writecrashDeviceCharacteristics,  /* xDeviceCharacteristics */
+  devsymShmMap,                     /* xShmMap */
+  devsymShmLock,                    /* xShmLock */
+  devsymShmBarrier,                 /* xShmBarrier */
+  devsymShmUnmap                    /* xShmUnmap */
+};
+
+  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 = &writecrash_io_methods;
+  }
+  return rc;
+}
+
+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_vfs writecrash_vfs = {
+  2,                     /* iVersion */
+  sizeof(devsym_file),      /* szOsFile */
+  DEVSYM_MAX_PATHNAME,      /* mxPathname */
+  0,                     /* pNext */
+  WRITECRASH_NAME,          /* zName */
+  0,                     /* pAppData */
+  writecrashOpen,           /* 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 */
+};
+
+
+/*
+** 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;
+    writecrash_vfs.szOsFile += g.pVfs->szOsFile;
+    sqlite3_vfs_register(&devsym_vfs, 0);
+    sqlite3_vfs_register(&writecrash_vfs, 0);
+  }
+  if( iDeviceChar>=0 ){
+    g.iDeviceChar = iDeviceChar;
+  }else{
+    g.iDeviceChar = 0;
+  }
+  if( iSectorSize>=0 ){
+    g.iSectorSize = iSectorSize;
+  }else{
+    g.iSectorSize = 512;
+  }
+}
+
+void devsym_unregister(){
+  sqlite3_vfs_unregister(&devsym_vfs);
+  sqlite3_vfs_unregister(&writecrash_vfs);
+  g.pVfs = 0;
+  g.iDeviceChar = 0;
+  g.iSectorSize = 0;
+}
+
+void devsym_crash_on_write(int nWrite){
+  if( g.pVfs==0 ){
+    g.pVfs = sqlite3_vfs_find(0);
+    devsym_vfs.szOsFile += g.pVfs->szOsFile;
+    writecrash_vfs.szOsFile += g.pVfs->szOsFile;
+    sqlite3_vfs_register(&devsym_vfs, 0);
+    sqlite3_vfs_register(&writecrash_vfs, 0);
+  }
+  g.nWriteCrash = nWrite;
+}
+
+#endif