1 files changed, 225 insertions, 50 deletions

diff --git a/ext/pdo_sqlite/sqlite/src/os.c b/ext/pdo_sqlite/sqlite/src/os.c
index ec482fe0e7..57e2d0fdd0 100644
--- a/ext/pdo_sqlite/sqlite/src/os.c
+++ b/ext/pdo_sqlite/sqlite/src/os.c
@@ -1,4 +1,4 @@
-/*
+ /*
 ** 2005 November 29
 **
 ** The author disclaims copyright to this source code.  In place of
@@ -15,78 +15,253 @@
 */
 #define _SQLITE_OS_C_ 1
 #include "sqliteInt.h"
-#include "os.h"
+#undef _SQLITE_OS_C_
+
+/*
+** The default SQLite sqlite3_vfs implementations do not allocate
+** memory (actually, os_unix.c allocates a small amount of memory
+** from within OsOpen()), but some third-party implementations may.
+** So we test the effects of a malloc() failing and the sqlite3OsXXX()
+** function returning SQLITE_IOERR_NOMEM using the DO_OS_MALLOC_TEST macro.
+**
+** The following functions are instrumented for malloc() failure 
+** testing:
+**
+**     sqlite3OsOpen()
+**     sqlite3OsRead()
+**     sqlite3OsWrite()
+**     sqlite3OsSync()
+**     sqlite3OsLock()
+**
+*/
+#ifdef SQLITE_TEST
+  #define DO_OS_MALLOC_TEST if (1) {            \
+    void *pTstAlloc = sqlite3_malloc(10);       \
+    if (!pTstAlloc) return SQLITE_IOERR_NOMEM;  \
+    sqlite3_free(pTstAlloc);                    \
+  }
+#else
+  #define DO_OS_MALLOC_TEST
+#endif
 
 /*
 ** The following routines are convenience wrappers around methods
-** of the OsFile object.  This is mostly just syntactic sugar.  All
+** of the sqlite3_file object.  This is mostly just syntactic sugar. All
 ** of this would be completely automatic if SQLite were coded using
 ** C++ instead of plain old C.
 */
-int sqlite3OsClose(OsFile **pId){
-  OsFile *id;
-  if( pId!=0 && (id = *pId)!=0 ){
-    return id->pMethod->xClose(pId);
-  }else{
-    return SQLITE_OK;
+int sqlite3OsClose(sqlite3_file *pId){
+  int rc = SQLITE_OK;
+  if( pId->pMethods ){
+    rc = pId->pMethods->xClose(pId);
+    pId->pMethods = 0;
   }
+  return rc;
 }
-int sqlite3OsOpenDirectory(OsFile *id, const char *zName){
-  return id->pMethod->xOpenDirectory(id, zName);
+int sqlite3OsRead(sqlite3_file *id, void *pBuf, int amt, i64 offset){
+  DO_OS_MALLOC_TEST;
+  return id->pMethods->xRead(id, pBuf, amt, offset);
 }
-int sqlite3OsRead(OsFile *id, void *pBuf, int amt){
-  return id->pMethod->xRead(id, pBuf, amt);
+int sqlite3OsWrite(sqlite3_file *id, const void *pBuf, int amt, i64 offset){
+  DO_OS_MALLOC_TEST;
+  return id->pMethods->xWrite(id, pBuf, amt, offset);
 }
-int sqlite3OsWrite(OsFile *id, const void *pBuf, int amt){
-  return id->pMethod->xWrite(id, pBuf, amt);
+int sqlite3OsTruncate(sqlite3_file *id, i64 size){
+  return id->pMethods->xTruncate(id, size);
 }
-int sqlite3OsSeek(OsFile *id, i64 offset){
-  return id->pMethod->xSeek(id, offset);
+int sqlite3OsSync(sqlite3_file *id, int flags){
+  DO_OS_MALLOC_TEST;
+  return id->pMethods->xSync(id, flags);
 }
-int sqlite3OsTruncate(OsFile *id, i64 size){
-  return id->pMethod->xTruncate(id, size);
+int sqlite3OsFileSize(sqlite3_file *id, i64 *pSize){
+  return id->pMethods->xFileSize(id, pSize);
 }
-int sqlite3OsSync(OsFile *id, int fullsync){
-  return id->pMethod->xSync(id, fullsync);
+int sqlite3OsLock(sqlite3_file *id, int lockType){
+  DO_OS_MALLOC_TEST;
+  return id->pMethods->xLock(id, lockType);
 }
-void sqlite3OsSetFullSync(OsFile *id, int value){
-  id->pMethod->xSetFullSync(id, value);
+int sqlite3OsUnlock(sqlite3_file *id, int lockType){
+  return id->pMethods->xUnlock(id, lockType);
 }
-#if defined(SQLITE_TEST) || defined(SQLITE_DEBUG)
-/* This method is currently only used while interactively debugging the 
-** pager. More specificly, it can only be used when sqlite3DebugPrintf() is
-** included in the build. */
-int sqlite3OsFileHandle(OsFile *id){
-  return id->pMethod->xFileHandle(id);
+int sqlite3OsCheckReservedLock(sqlite3_file *id){
+  return id->pMethods->xCheckReservedLock(id);
 }
-#endif
-int sqlite3OsFileSize(OsFile *id, i64 *pSize){
-  return id->pMethod->xFileSize(id, pSize);
+int sqlite3OsFileControl(sqlite3_file *id, int op, void *pArg){
+  return id->pMethods->xFileControl(id,op,pArg);
+}
+int sqlite3OsSectorSize(sqlite3_file *id){
+  int (*xSectorSize)(sqlite3_file*) = id->pMethods->xSectorSize;
+  return (xSectorSize ? xSectorSize(id) : SQLITE_DEFAULT_SECTOR_SIZE);
+}
+int sqlite3OsDeviceCharacteristics(sqlite3_file *id){
+  return id->pMethods->xDeviceCharacteristics(id);
 }
-int sqlite3OsLock(OsFile *id, int lockType){
-  return id->pMethod->xLock(id, lockType);
+
+/*
+** The next group of routines are convenience wrappers around the
+** VFS methods.
+*/
+int sqlite3OsOpen(
+  sqlite3_vfs *pVfs, 
+  const char *zPath, 
+  sqlite3_file *pFile, 
+  int flags, 
+  int *pFlagsOut
+){
+  DO_OS_MALLOC_TEST;
+  return pVfs->xOpen(pVfs, zPath, pFile, flags, pFlagsOut);
+}
+int sqlite3OsDelete(sqlite3_vfs *pVfs, const char *zPath, int dirSync){
+  return pVfs->xDelete(pVfs, zPath, dirSync);
+}
+int sqlite3OsAccess(sqlite3_vfs *pVfs, const char *zPath, int flags){
+  return pVfs->xAccess(pVfs, zPath, flags);
+}
+int sqlite3OsGetTempname(sqlite3_vfs *pVfs, int nBufOut, char *zBufOut){
+  return pVfs->xGetTempname(pVfs, nBufOut, zBufOut);
+}
+int sqlite3OsFullPathname(
+  sqlite3_vfs *pVfs, 
+  const char *zPath, 
+  int nPathOut, 
+  char *zPathOut
+){
+  return pVfs->xFullPathname(pVfs, zPath, nPathOut, zPathOut);
 }
-int sqlite3OsUnlock(OsFile *id, int lockType){
-  return id->pMethod->xUnlock(id, lockType);
+void *sqlite3OsDlOpen(sqlite3_vfs *pVfs, const char *zPath){
+  return pVfs->xDlOpen(pVfs, zPath);
 }
-int sqlite3OsLockState(OsFile *id){
-  return id->pMethod->xLockState(id);
+void sqlite3OsDlError(sqlite3_vfs *pVfs, int nByte, char *zBufOut){
+  pVfs->xDlError(pVfs, nByte, zBufOut);
 }
-int sqlite3OsCheckReservedLock(OsFile *id){
-  return id->pMethod->xCheckReservedLock(id);
+void *sqlite3OsDlSym(sqlite3_vfs *pVfs, void *pHandle, const char *zSymbol){
+  return pVfs->xDlSym(pVfs, pHandle, zSymbol);
+}
+void sqlite3OsDlClose(sqlite3_vfs *pVfs, void *pHandle){
+  pVfs->xDlClose(pVfs, pHandle);
+}
+int sqlite3OsRandomness(sqlite3_vfs *pVfs, int nByte, char *zBufOut){
+  return pVfs->xRandomness(pVfs, nByte, zBufOut);
+}
+int sqlite3OsSleep(sqlite3_vfs *pVfs, int nMicro){
+  return pVfs->xSleep(pVfs, nMicro);
+}
+int sqlite3OsCurrentTime(sqlite3_vfs *pVfs, double *pTimeOut){
+  return pVfs->xCurrentTime(pVfs, pTimeOut);
+}
+
+int sqlite3OsOpenMalloc(
+  sqlite3_vfs *pVfs, 
+  const char *zFile, 
+  sqlite3_file **ppFile, 
+  int flags,
+  int *pOutFlags
+){
+  int rc = SQLITE_NOMEM;
+  sqlite3_file *pFile;
+  pFile = (sqlite3_file *)sqlite3_malloc(pVfs->szOsFile);
+  if( pFile ){
+    rc = sqlite3OsOpen(pVfs, zFile, pFile, flags, pOutFlags);
+    if( rc!=SQLITE_OK ){
+      sqlite3_free(pFile);
+    }else{
+      *ppFile = pFile;
+    }
+  }
+  return rc;
+}
+int sqlite3OsCloseFree(sqlite3_file *pFile){
+  int rc = SQLITE_OK;
+  if( pFile ){
+    rc = sqlite3OsClose(pFile);
+    sqlite3_free(pFile);
+  }
+  return rc;
 }
 
-#ifdef SQLITE_ENABLE_REDEF_IO
 /*
-** A function to return a pointer to the virtual function table.
-** This routine really does not accomplish very much since the
-** virtual function table is a global variable and anybody who
-** can call this function can just as easily access the variable
-** for themselves.  Nevertheless, we include this routine for
-** backwards compatibility with an earlier redefinable I/O
-** interface design.
+** The list of all registered VFS implementations.  This list is
+** initialized to the single VFS returned by sqlite3OsDefaultVfs()
+** upon the first call to sqlite3_vfs_find().
 */
-struct sqlite3OsVtbl *sqlite3_os_switch(void){
-  return &sqlite3Os;
+static sqlite3_vfs *vfsList = 0;
+
+/*
+** Locate a VFS by name.  If no name is given, simply return the
+** first VFS on the list.
+*/
+sqlite3_vfs *sqlite3_vfs_find(const char *zVfs){
+#ifndef SQLITE_MUTEX_NOOP
+  sqlite3_mutex *mutex = sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_MASTER);
+#endif
+  sqlite3_vfs *pVfs = 0;
+  static int isInit = 0;
+  sqlite3_mutex_enter(mutex);
+  if( !isInit ){
+    vfsList = sqlite3OsDefaultVfs();
+    isInit = 1;
+  }
+  for(pVfs = vfsList; pVfs; pVfs=pVfs->pNext){
+    if( zVfs==0 ) break;
+    if( strcmp(zVfs, pVfs->zName)==0 ) break;
+  }
+  sqlite3_mutex_leave(mutex);
+  return pVfs;
 }
+
+/*
+** Unlink a VFS from the linked list
+*/
+static void vfsUnlink(sqlite3_vfs *pVfs){
+  assert( sqlite3_mutex_held(sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_MASTER)) );
+  if( pVfs==0 ){
+    /* No-op */
+  }else if( vfsList==pVfs ){
+    vfsList = pVfs->pNext;
+  }else if( vfsList ){
+    sqlite3_vfs *p = vfsList;
+    while( p->pNext && p->pNext!=pVfs ){
+      p = p->pNext;
+    }
+    if( p->pNext==pVfs ){
+      p->pNext = pVfs->pNext;
+    }
+  }
+}
+
+/*
+** Register a VFS with the system.  It is harmless to register the same
+** VFS multiple times.  The new VFS becomes the default if makeDflt is
+** true.
+*/
+int sqlite3_vfs_register(sqlite3_vfs *pVfs, int makeDflt){
+#ifndef SQLITE_MUTEX_NOOP
+  sqlite3_mutex *mutex = sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_MASTER);
+#endif
+  sqlite3_vfs_find(0);  /* Make sure we are initialized */
+  sqlite3_mutex_enter(mutex);
+  vfsUnlink(pVfs);
+  if( makeDflt || vfsList==0 ){
+    pVfs->pNext = vfsList;
+    vfsList = pVfs;
+  }else{
+    pVfs->pNext = vfsList->pNext;
+    vfsList->pNext = pVfs;
+  }
+  assert(vfsList);
+  sqlite3_mutex_leave(mutex);
+  return SQLITE_OK;
+}
+
+/*
+** Unregister a VFS so that it is no longer accessible.
+*/
+int sqlite3_vfs_unregister(sqlite3_vfs *pVfs){
+#ifndef SQLITE_MUTEX_NOOP
+  sqlite3_mutex *mutex = sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_MASTER);
 #endif
+  sqlite3_mutex_enter(mutex);
+  vfsUnlink(pVfs);
+  sqlite3_mutex_leave(mutex);
+  return SQLITE_OK;
+}