SQLite

         fts3_unicode.lo fts3_unicode2.lo fts3_write.lo \
         func.lo global.lo hash.lo \
         icu.lo insert.lo journal.lo legacy.lo loadext.lo \
         main.lo malloc.lo mem0.lo mem1.lo mem2.lo mem3.lo mem5.lo \
         memjournal.lo \
         mutex.lo mutex_noop.lo mutex_unix.lo mutex_w32.lo \
         notify.lo opcodes.lo os.lo os_unix.lo os_win.lo \
         pager.lo parse.lo pcache.lo pcache1.lo pcache_purgeable.lo pragma.lo prepare.lo printf.lo \
         random.lo resolve.lo rowset.lo rtree.lo select.lo status.lo \
         table.lo tokenize.lo trigger.lo \
         update.lo util.lo vacuum.lo \
         vdbe.lo vdbeapi.lo vdbeaux.lo vdbeblob.lo vdbemem.lo vdbesort.lo \
         vdbetrace.lo wal.lo walker.lo where.lo utf.lo vtab.lo

# Object files for the amalgamation.

  $(TOP)/src/os_win.h \
  $(TOP)/src/pager.c \
  $(TOP)/src/pager.h \
  $(TOP)/src/parse.y \
  $(TOP)/src/pcache.c \
  $(TOP)/src/pcache.h \
  $(TOP)/src/pcache1.c \
  $(TOP)/src/pcache_purgeable.c \
  $(TOP)/src/pragma.c \
  $(TOP)/src/prepare.c \
  $(TOP)/src/printf.c \
  $(TOP)/src/random.c \
  $(TOP)/src/resolve.c \
  $(TOP)/src/rowset.c \
  $(TOP)/src/select.c \
  $(TOP)/src/status.c \
  $(TOP)/src/shell.c \
  $(TOP)/src/sqlite.h.in \
  $(TOP)/src/sqlite3ext.h \
  $(TOP)/src/sqliteInt.h \
  $(TOP)/src/sqliteLimit.h \
  $(TOP)/src/table.c \
  $(TOP)/src/tclsqlite.c \
  $(TOP)/src/test_intarray.h \
  $(TOP)/src/tokenize.c \
  $(TOP)/src/trigger.c \
  $(TOP)/src/utf.c \
  $(TOP)/src/update.c \
  $(TOP)/src/util.c \
  $(TOP)/src/vacuum.c \
  $(TOP)/src/vdbe.c \

  $(TOP)/ext/icu/icu.c
SRC += \
  $(TOP)/ext/rtree/rtree.h \
  $(TOP)/ext/rtree/rtree.c
SRC += \
  $(TOP)/ext/sqlrr/sqlrr.h \
  $(TOP)/ext/sqlrr/sqlrr.c
SRC += \
  $(TOP)/src/test_intarray.c
SRC += \
  $(TOP)/src/sqlite3_private.h


# Generated source code files
#
SRC += \
  keywordhash.h \
  opcodes.c \

  $(TOP)/src/test_config.c \
  $(TOP)/src/test_demovfs.c \
  $(TOP)/src/test_devsym.c \
  $(TOP)/src/test_fs.c \
  $(TOP)/src/test_func.c \
  $(TOP)/src/test_hexio.c \
  $(TOP)/src/test_init.c \

  $(TOP)/src/test_journal.c \
  $(TOP)/src/test_malloc.c \
  $(TOP)/src/test_multiplex.c \
  $(TOP)/src/test_mutex.c \
  $(TOP)/src/test_onefile.c \
  $(TOP)/src/test_osinst.c \
  $(TOP)/src/test_pcache.c \

   $(TOP)/src/pager.h \
   $(TOP)/src/pcache.h \
   parse.h  \
   sqlite3.h  \
   $(TOP)/src/sqlite3ext.h \
   $(TOP)/src/sqliteInt.h  \
   $(TOP)/src/sqliteLimit.h \
   $(TOP)/src/test_intarray.h \
   $(TOP)/src/vdbe.h \
   $(TOP)/src/vdbeInt.h \
   $(TOP)/src/whereInt.h \
   config.h

# Header files used by extensions
#

	$(LTCOMPILE) $(TEMP_STORE) -c $(TOP)/src/pager.c

pcache.lo:	$(TOP)/src/pcache.c $(HDR) $(TOP)/src/pcache.h
	$(LTCOMPILE) $(TEMP_STORE) -c $(TOP)/src/pcache.c

pcache1.lo:	$(TOP)/src/pcache1.c $(HDR) $(TOP)/src/pcache.h
	$(LTCOMPILE) $(TEMP_STORE) -c $(TOP)/src/pcache1.c

pcache_purgeable.lo:	$(TOP)/src/pcache_purgeable.c $(HDR) $(TOP)/src/pcache.h
	$(LTCOMPILE) $(TEMP_STORE) -c $(TOP)/src/pcache_purgeable.c

os.lo:	$(TOP)/src/os.c $(HDR)
	$(LTCOMPILE) $(TEMP_STORE) -c $(TOP)/src/os.c

os_unix.lo:	$(TOP)/src/os_unix.c $(HDR)
	$(LTCOMPILE) $(TEMP_STORE) -c $(TOP)/src/os_unix.c

/* Define to 1 if you have the `localtime_r' function. */
#undef HAVE_LOCALTIME_R

/* Define to 1 if you have the `localtime_s' function. */
#undef HAVE_LOCALTIME_S

/* Define to 1 if you have the <malloc.h> header file. */
/* #undef HAVE_MALLOC_H */

/* Define to 1 if you have the `malloc_usable_size' function. */
/* #undef HAVE_MALLOC_USABLE_SIZE */

/* Define to 1 if you have the <memory.h> header file. */
#undef HAVE_MEMORY_H

/* Define to 1 if you have the <stdint.h> header file. */
#undef HAVE_STDINT_H

/* Define to 1 if you have the <unistd.h> header file. */
#undef HAVE_UNISTD_H

/* Define to 1 if you have the `usleep' function. */
#undef HAVE_USLEEP

/* Define to 1 if you have the utime() library function. */
/* #undef HAVE_UTIME */

/* Define to the sub-directory in which libtool stores uninstalled libraries.
   */
#undef LT_OBJDIR

/* Define to the address where bug reports for this package should be sent. */
#undef PACKAGE_BUGREPORT

**
*************************************************************************
** This file implements a external (disk-based) database using BTrees.
** See the header comment on "btreeInt.h" for additional information.
** Including a description of file format and an overview of operation.
*/
#include "btreeInt.h"
#include <AvailabilityMacros.h>

/*
** The header string that appears at the beginning of every
** SQLite database.
*/
static const char zMagicHeader[] = SQLITE_FILE_HEADER;

#if defined(SQLITE_ENABLE_FLOCKTIMEOUT)&&(SQLITE_ENABLE_FLOCKTIMEOUT>0)
# if (defined(__APPLE__) && (!defined(TARGET_IPHONE_SIMULATOR)||(TARGET_IPHONE_SIMULATOR==0)) && ((TARGET_OS_EMBEDDED>0)||(MAC_OS_X_VERSION_10_9>0)))
#  define SQLITE_USE_FLOCKTIMEOUT 1
# endif
#endif /* SQLITE_ENABLE_FLOCKTIMEOUT */

/*
 ** Operator used with sqlite3_file_control to set the timeout for the next call
 ** to lock the database file via fcntl with F_SETLKWTIMEOUT.  The timeout should
 ** be passed as a pointer to a long representing the timeout in milliseconds
 */
#ifndef SQLITE_FCNTL_SET_NEXTFLOCKTIMEOUT
#define SQLITE_FCNTL_SET_NEXTFLOCKTIMEOUT      104
#define SQLITE_FCNTL_GET_NEXTFLOCKTIMEOUT      105
#endif

/*
** Set this global variable to 1 to enable tracing using the TRACE
** macro.
*/
#if 0
int sqlite3BtreeTrace=1;  /* True to enable tracing */

    /* Call lockBtree() until either pBt->pPage1 is populated or
    ** lockBtree() returns something other than SQLITE_OK. lockBtree()
    ** may return SQLITE_OK but leave pBt->pPage1 set to 0 if after
    ** reading page 1 it discovers that the page-size of the database 
    ** file is not pBt->pageSize. In this case lockBtree() will update
    ** pBt->pageSize to the page-size of the file on disk.
    */
    
#ifdef SQLITE_USE_FLOCKTIMEOUT
    int existingNextTimeout = 0;
    if (wrflag) {
      sqlite3_file_control(p->db, NULL, SQLITE_FCNTL_GET_NEXTFLOCKTIMEOUT, &existingNextTimeout);
    }
    
    while( pBt->pPage1==0 && SQLITE_OK==(rc = lockBtree(pBt)) );

    if (wrflag) {
      sqlite3_file_control(p->db, NULL, SQLITE_FCNTL_SET_NEXTFLOCKTIMEOUT, &existingNextTimeout);
    }
#else
    while( pBt->pPage1==0 && SQLITE_OK==(rc = lockBtree(pBt)) );
#endif
    
    if( rc==SQLITE_OK && wrflag ){
      if( (pBt->btsFlags & BTS_READ_ONLY)!=0 ){
        rc = SQLITE_READONLY;
      }else{
        rc = sqlite3PagerBegin(pBt->pPager,wrflag>1,sqlite3TempInMemory(p->db));
        if( rc==SQLITE_OK ){
          rc = newDatabase(pBt);

  "CASE_SENSITIVE_LIKE",
#endif
#ifdef SQLITE_CHECK_PAGES
  "CHECK_PAGES",
#endif
#ifdef SQLITE_COVERAGE_TEST
  "COVERAGE_TEST",
#endif
#ifdef SQLITE_CURDIR
  "CURDIR",
#endif
#ifdef SQLITE_DEBUG
  "DEBUG",
#endif
#ifdef SQLITE_DEFAULT_LOCKING_MODE
  "DEFAULT_LOCKING_MODE=" CTIMEOPT_VAL(SQLITE_DEFAULT_LOCKING_MODE),
#endif

    }else{
      xInit = (int(*)(sqlite3*,char**,const sqlite3_api_routines*))
              wsdAutoext.aExt[i];
    }
    sqlite3_mutex_leave(mutex);
    zErrmsg = 0;
    if( xInit && (rc = xInit(db, &zErrmsg, &sqlite3Apis))!=0 ){

//      sqlite3Error(db, rc, "automatic extension loading failed: %s", zErrmsg);
//      go = 0;
    }
    sqlite3_free(zErrmsg);
  }
}

*************************************************************************
** Main file for the SQLite library.  The routines in this file
** implement the programmer interface to the library.  Routines in
** other files are for internal use by SQLite and should not be
** accessed by users of the library.
*/
#include "sqliteInt.h"
#include <AvailabilityMacros.h>

#ifdef SQLITE_ENABLE_SQLRR
# include "sqlrr.h"
#endif 
#ifdef SQLITE_ENABLE_FTS3
# include "fts3.h"
#endif
#ifdef SQLITE_ENABLE_RTREE
# include "rtree.h"
#endif
#ifdef SQLITE_ENABLE_ICU
# include "sqliteicu.h"
#endif

#if defined(SQLITE_ENABLE_FLOCKTIMEOUT)&&(SQLITE_ENABLE_FLOCKTIMEOUT>0)
# if (defined(__APPLE__) && (!defined(TARGET_IPHONE_SIMULATOR)||(TARGET_IPHONE_SIMULATOR==0)) && ((TARGET_OS_EMBEDDED>0)||(MAC_OS_X_VERSION_10_9>0)))
# include "sqlite3_private.h"
#  define SQLITE_USE_FLOCKTIMEOUT 1
# endif
#endif /* SQLITE_ENABLE_FLOCKTIMEOUT */

#if defined(__APPLE__)
# include <unistd.h>
# include <dispatch/dispatch.h>
# include <dispatch/private.h>
extern void _sqlite3_purgeEligiblePagerCacheMemory();
# if defined(DISPATCH_API_VERSION)&&(DISPATCH_API_VERSION>=20100226) && \
  defined(SQLITE_ENABLE_PURGEABLE_PCACHE)&&(SQLITE_ENABLE_PURGEABLE_PCACHE>0)
#  include <dlfcn.h> /* amalgamator: keep */ 
static dispatch_source_t _cache_event_source = NULL;
# endif
#endif

/*
 ** Operator used with sqlite3_file_control to set the timeout for the next call
 ** to lock the database file via fcntl with F_SETLKWTIMEOUT.  The timeout should
 ** be passed as a pointer to a long representing the timeout in milliseconds
 */
#ifndef SQLITE_FCNTL_SET_NEXTFLOCKTIMEOUT
#define SQLITE_FCNTL_SET_NEXTFLOCKTIMEOUT      104
#define SQLITE_FCNTL_GET_NEXTFLOCKTIMEOUT      105
#endif

/*
** The version of the library
*/
#ifndef SQLITE_AMALGAMATION
/* IMPLEMENTATION-OF: R-46656-45156 The sqlite3_version[] string constant
** contains the text of SQLITE_VERSION macro. 
*/
const char sqlite3_version[] = SQLITE_VERSION;
#endif

      sqlite3PCacheBufferSetup( sqlite3GlobalConfig.pPage, 
          sqlite3GlobalConfig.szPage, sqlite3GlobalConfig.nPage);
      sqlite3GlobalConfig.isInit = 1;
#ifdef SQLITE_EXTRA_INIT
      bRunExtraInit = 1;
#endif
    }
    
#if defined(__APPLE__) && defined(USETHREADASSERTS)
    if ((0 != access("/var/db/disableAppleInternal", R_OK))) {
//      fprintf(stderr, "SQLite multi-threading assertions ENABLED.\n");
      
      if (sqlite3GlobalConfig.bCoreMutex != 0) {
        sqlite3GlobalConfig.bFullMutex = 1;
      }
    } else {
      sqlite3_mutex_methods *pTo = &sqlite3GlobalConfig.mutex;
      pTo->xMutexHeld = NULL;
      pTo->xMutexNotheld = NULL;
//      fprintf(stderr, "SQLite multi-threading assertions DISABLED.\n");
    }
#endif    
    
  
#if defined(DISPATCH_API_VERSION)&&(DISPATCH_API_VERSION>=20100226) && \
  defined(SQLITE_ENABLE_PURGEABLE_PCACHE)&&(SQLITE_ENABLE_PURGEABLE_PCACHE>0)
    
		dispatch_queue_t mq = dispatch_get_main_queue();
		if (mq) {
      if( NULL != dlopen("/usr/lib/libsqlite3.dylib", RTLD_LAZY) ){ 
        /* never dlclose to avoid dylib unloading */
        dispatch_async(mq, ^{
          dispatch_queue_t queue = dispatch_get_global_queue(0, 0);
          if (queue) {
            _cache_event_source = dispatch_source_create(DISPATCH_SOURCE_TYPE_VM, 0, DISPATCH_VM_PRESSURE, queue);
            if (_cache_event_source != NULL) {
              dispatch_source_set_event_handler(_cache_event_source, ^{ 
                _sqlite3_purgeEligiblePagerCacheMemory();
              });
              dispatch_resume(_cache_event_source);
            }
          }
        });
      }
		}
#endif 
  
    sqlite3GlobalConfig.inProgress = 0;
  }
  sqlite3_mutex_leave(sqlite3GlobalConfig.pInitMutex);

  /* Go back under the static mutex and clean up the recursive
  ** mutex to prevent a resource leak.
  */

** argument.
*/
static int sqliteDefaultBusyCallback(
 void *ptr,               /* Database connection */
 int count                /* Number of times table has been busy */
){
#if SQLITE_OS_WIN || (defined(HAVE_USLEEP) && HAVE_USLEEP)
# ifdef SQLITE_USE_FLOCKTIMEOUT
  static const u16 delays[] =
  { 1, 2, 5, 10, 15, 20, 25, 25,  25,  50,  50, 100, 100, 100, 100, 100, 100, 100, 100,  100, 100, 100,  100,  100,  100,  100,  100,  100,  100,  100,  200,  200,  200,  200,  200,  250,  250,  250,  250, 333 }; // 333, 333, 500, 500, 500, 500, 1000, 1000, 1000, 10000 };
  static const u16 totals[] =
     { 0, 1, 3,  8, 18, 33, 53, 78, 103, 128, 178, 228, 328, 428, 528, 628, 728, 828, 928, 1028, 1128, 1228, 1328, 1428, 1528, 1628, 1728, 1828, 1928, 2128, 2228, 2428, 2628, 2828, 3028, 3228, 3478, 3728, 3978, 4228, 4561, 4894, 5227, 5727, 6227, 6727, 7227, 8227, 9227 };
#else
  static const u8 delays[] =
     { 1, 2, 5, 10, 15, 20, 25, 25,  25,  50,  50, 100 };
  static const u8 totals[] =
     { 0, 1, 3,  8, 18, 33, 53, 78, 103, 128, 178, 228 };
#endif
  
# define NDELAY ArraySize(delays)
  sqlite3 *db = (sqlite3 *)ptr;
  int timeout = db->busyTimeout;
  int delay, prior;

  assert( count>=0 );
  if( count < NDELAY ){
    delay = delays[count];
    prior = totals[count];
  }else{
    delay = delays[NDELAY-1];
    prior = totals[NDELAY-1] + delay*(count-(NDELAY-1));
  }
  if( prior + delay > timeout ){
    delay = timeout - prior;
    if( delay<=0 ){
# ifdef SQLITE_USE_FLOCKTIMEOUT
      delay = 0; /* reset the delay */
      sqlite3_file_control(db, NULL, SQLITE_FCNTL_SET_NEXTFLOCKTIMEOUT, &delay);
# endif
      return 0;
    }
  }
# ifdef SQLITE_USE_FLOCKTIMEOUT
  sqlite3_file_control(db, NULL, SQLITE_FCNTL_SET_NEXTFLOCKTIMEOUT, &delay);
# else
  sqlite3OsSleep(db->pVfs, delay*1000);
# endif
  return 1;
#else
  sqlite3 *db = (sqlite3 *)ptr;
  int timeout = ((sqlite3 *)ptr)->busyTimeout;
  if( (count+1)*1000 > timeout ){
    return 0;
  }

  if( NULL!=autolog_client ){
    asl_close(autolog_client);
    autolog_client = NULL;
  }
}
static void _open_asl_log() {
  if( NULL==autolog_client ){
    autolog_client = asl_open(NULL, NULL, 0);
    atexit(_close_asl_log);
  }
}

void _sqlite_auto_profile_syslog(void *aux, const char *sql, u64 ns);
void _sqlite_auto_trace_syslog(void *aux, const char *sql);
void _sqlite_auto_profile_syslog(void *aux, const char *sql, u64 ns) {
#pragma unused(aux)
	asl_log(autolog_client, NULL, ASL_LEVEL_NOTICE, "Query: %s\n Execution Time: %llu ms\n", sql ? sql : "", ns / 1000000);
}
void _sqlite_auto_trace_syslog(void *aux, const char *sql) {
	asl_log(autolog_client, NULL, ASL_LEVEL_NOTICE, "TraceSQL(%p): %s\n", aux, sql ? sql : "");
}
#endif

/*
** This function is used to parse both URIs and non-URI filenames passed by the
** user to API functions sqlite3_open() or sqlite3_open_v2(), and for database
** URIs specified as part of ATTACH statements.

  const char *zVfs       /* Name of the VFS to use */
){
  sqlite3 *db;                    /* Store allocated handle here */
  int rc;                         /* Return code */
  int isThreadsafe;               /* True for threadsafe connections */
  char *zOpen = 0;                /* Filename argument to pass to BtreeOpen() */
  char *zErrMsg = 0;              /* Error message from sqlite3ParseUri() */
#if SQLITE_ENABLE_DATA_PROTECTION
  int protFlags = flags & SQLITE_OPEN_FILEPROTECTION_MASK;
#endif

  *ppDb = 0;
#ifndef SQLITE_OMIT_AUTOINIT
  rc = sqlite3_initialize();
  if( rc ) return rc;
#endif

               SQLITE_OPEN_TEMP_JOURNAL | 
               SQLITE_OPEN_SUBJOURNAL | 
               SQLITE_OPEN_MASTER_JOURNAL |
               SQLITE_OPEN_NOMUTEX |
               SQLITE_OPEN_FULLMUTEX |
               SQLITE_OPEN_WAL
             );
#if SQLITE_ENABLE_DATA_PROTECTION
  flags |= protFlags;
#endif

  /* Allocate the sqlite data structure */
  db = sqlite3MallocZero( sizeof(sqlite3) );
  if( db==0 ) goto opendb_out;
  if( isThreadsafe ){
    db->mutex = sqlite3MutexAlloc(SQLITE_MUTEX_RECURSIVE);
    if( db->mutex==0 ){

  /* Register all built-in functions, but do not attempt to read the
  ** database schema yet. This is delayed until the first time the database
  ** is accessed.
  */
  sqlite3Error(db, SQLITE_OK, 0);
  sqlite3RegisterBuiltinFunctions(db);













#ifdef SQLITE_ENABLE_FTS1
  if( !db->mallocFailed ){
    extern int sqlite3Fts1Init(sqlite3*);
    rc = sqlite3Fts1Init(db);
  }
#endif

#endif

#ifdef SQLITE_ENABLE_RTREE
  if( !db->mallocFailed && rc==SQLITE_OK){
    rc = sqlite3RtreeInit(db);
  }
#endif

  /* Load automatic extensions - extensions that have been registered
  ** using the sqlite3_automatic_extension() API.
  */
  rc = sqlite3_errcode(db);
  if( rc==SQLITE_OK ){
    sqlite3AutoLoadExtensions(db);
    rc = sqlite3_errcode(db);
    if( rc!=SQLITE_OK ){
      goto opendb_out;
    }
  }

  /* -DSQLITE_DEFAULT_LOCKING_MODE=1 makes EXCLUSIVE the default locking
  ** mode.  -DSQLITE_DEFAULT_LOCKING_MODE=0 make NORMAL the default locking
  ** mode.  Doing nothing at all also makes NORMAL the default.
  */
#ifdef SQLITE_DEFAULT_LOCKING_MODE
  db->dfltLockMode = SQLITE_DEFAULT_LOCKING_MODE;

    return state;
  }
  if( NULL!=db ){ 
    sqlite3_close(db); /* need to close even if open returns an error */
  }
  return SQLITE_LOCKSTATE_ERROR;
}

/*
** Returns the system defined default sqlite3_busy_handler function
**
*/
int (*_sqlite3_system_busy_handler(void))(void*,int) {
  return &sqliteDefaultBusyCallback;
}

#endif /* SQLITE_ENABLE_APPLE_SPI */

*/
void sqlite3_mutex_leave(sqlite3_mutex *p){
  if( p ){
    sqlite3GlobalConfig.mutex.xMutexLeave(p);
  }
}

#if defined(USETHREADASSERTS) || defined(SQLITE_DEBUG)
/*
** The sqlite3_mutex_held() and sqlite3_mutex_notheld() routine are
** intended for use inside assert() statements.
*/
int sqlite3_mutex_held(sqlite3_mutex *p){
  return p==0 || (sqlite3GlobalConfig.mutex.xMutexHeld && sqlite3GlobalConfig.mutex.xMutexHeld(p));
}
int sqlite3_mutex_notheld(sqlite3_mutex *p){
  return p==0 || (sqlite3GlobalConfig.mutex.xMutexNotheld && sqlite3GlobalConfig.mutex.xMutexNotheld(p));
}
#endif

#endif /* !defined(SQLITE_MUTEX_OMIT) */

#include <pthread.h>

/*
** The sqlite3_mutex.id, sqlite3_mutex.nRef, and sqlite3_mutex.owner fields
** are necessary under two condidtions:  (1) Debug builds and (2) using
** home-grown mutexes.  Encapsulate these conditions into a single #define.
*/
#if defined(SQLITE_DEBUG) || defined(SQLITE_HOMEGROWN_RECURSIVE_MUTEX) || defined(USETHREADASSERTS)
# define SQLITE_MUTEX_NREF 1
#else
# define SQLITE_MUTEX_NREF 0
#endif

/*
** Each recursive mutex is an instance of the following structure.

** will not always work correctly on HPUX.
**
** On those platforms where pthread_equal() is not atomic, SQLite
** should be compiled without -DSQLITE_DEBUG and with -DNDEBUG to
** make sure no assert() statements are evaluated and hence these
** routines are never called.
*/
#if defined(USETHREADASSERTS) || defined(SQLITE_DEBUG)
static int pthreadMutexHeld(sqlite3_mutex *p){
  return (p->nRef!=0 && pthread_equal(p->owner, pthread_self()));
}
static int pthreadMutexNotheld(sqlite3_mutex *p){
  return p->nRef==0 || pthread_equal(p->owner, pthread_self())==0;
}
#endif

    pthreadMutexInit,
    pthreadMutexEnd,
    pthreadMutexAlloc,
    pthreadMutexFree,
    pthreadMutexEnter,
    pthreadMutexTry,
    pthreadMutexLeave,
#if defined(USETHREADASSERTS) || defined(SQLITE_DEBUG)
    pthreadMutexHeld,
    pthreadMutexNotheld
#else
    0,
    0
#endif
  };

  return &sMutex;
}

#endif /* SQLITE_MUTEX_PTHREADS */

**   *  Definitions of sqlite3_vfs objects for all locking methods
**      plus implementations of sqlite3_os_init() and sqlite3_os_end().
*/
#include "sqliteInt.h"
#if SQLITE_OS_UNIX              /* This file is used on unix only */

#include "btreeInt.h"           /* Use by Apple extensions only */
#include <AvailabilityMacros.h>


/*
** There are various methods for file locking used for concurrency
** control:
**
**   1. POSIX locking (the default),

*/
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <time.h>
#include <sys/time.h>
#include <sys/syslimits.h>
#include <errno.h>
#if !defined(SQLITE_OMIT_WAL) || SQLITE_MAX_MMAP_SIZE>0
#include <sys/mman.h>
#endif


#if SQLITE_ENABLE_LOCKING_STYLE
# include <sys/ioctl.h>
# include <uuid/uuid.h>
# if defined(__APPLE__) && ((__MAC_OS_X_VERSION_MIN_REQUIRED > 1050) || \
                            (__IPHONE_OS_VERSION_MIN_REQUIRED > 2000))
#if (!defined(TARGET_OS_EMBEDDED)||(TARGET_OS_EMBEDDED==0))&&(!defined(TARGET_IPHONE_SIMULATOR)||(TARGET_IPHONE_SIMULATOR==0))
#  define HAVE_GETHOSTUUID 1
#warning "gethostuuid() is enabled."
#else
#warning "gethostuuid() is disabled."
#endif
# endif
# if OS_VXWORKS
#  include <semaphore.h>
#  include <limits.h>
# else
#  include <sys/file.h>
#  include <sys/param.h>
# endif
#endif /* SQLITE_ENABLE_LOCKING_STYLE */

#if defined(__APPLE__) || (SQLITE_ENABLE_LOCKING_STYLE && !OS_VXWORKS)
# include <sys/mount.h>
#endif
#if defined(__APPLE__) && defined(SQLITE_ENABLE_LOCKING_STYLE)
# include <CommonCrypto/CommonDigest.h>
#endif

#ifdef HAVE_UTIME
# include <utime.h>
#endif

#if defined(__APPLE__)
#include <mach/mach.h>
#include <mach/mach_vm.h>
#include <pwd.h>
#endif

/*
** Allowed values of unixFile.fsFlags
*/
#define SQLITE_FSFLAGS_IS_MSDOS     0x1
#define SQLITE_FSFLAGS_IS_MMAP_SAFE 0x2

/*
** If we are to be thread-safe, include the pthreads header and define
** the SQLITE_UNIX_THREADS macro.
*/
#if SQLITE_THREADSAFE
# include <pthread.h>
# define SQLITE_UNIX_THREADS 1
#endif

/*
 ** Operator used with sqlite3_file_control to set the timeout for the next call
 ** to lock the database file via fcntl with F_SETLKWTIMEOUT.  The timeout should
 ** be passed as a pointer to a long representing the timeout in milliseconds
 */
#ifndef SQLITE_FCNTL_SET_NEXTFLOCKTIMEOUT
#define SQLITE_FCNTL_SET_NEXTFLOCKTIMEOUT      104
#define SQLITE_FCNTL_GET_NEXTFLOCKTIMEOUT      105
#endif

#if defined(__APPLE__)
#include <asl.h>
#include <libkern/OSAtomic.h>
static aslclient errorlog_client = NULL;

static void _close_error_asl_log() {
  if( NULL!=errorlog_client ){
    asl_close(errorlog_client);
    errorlog_client = NULL;
  }
}
static void _open_error_asl_log() {
  OSMemoryBarrier();
  if( NULL==errorlog_client ){
    aslclient aclient = asl_open(NULL, NULL, ASL_OPT_STDERR);
    
    if (OSAtomicCompareAndSwapPtrBarrier(NULL, (void*)aclient, (void* volatile*)&errorlog_client)) {
      atexit(_close_error_asl_log);
    } else {
      asl_close(aclient);
    }    
  }
}

#endif

#if defined(USE_GUARDED_FD)&&defined(__APPLE__)
# include <dispatch/dispatch.h>
# include <dlfcn.h>

/* taken from <sys/guarded.h> */
# ifndef _GUARDID_T
typedef __uint64_t guardid_t;
#  define GUARD_CLOSE             (1u << 0)
#  define GUARD_DUP               (1u << 1)
#  define GUARD_SOCKET_IPC        (1u << 2)
#  define GUARD_FILEPORT          (1u << 3)
# endif /* _GUARDID_T */

#ifndef GUARD_WRITE
#define GUARD_WRITE		(1u << 4)
#endif

#ifndef GUARD_MMAP
#define GUARD_MMAP		(1u << 5)
#endif

#ifndef PROTECTION_CLASS_A
#define PROTECTION_CLASS_A 1
#define PROTECTION_CLASS_B 2
#define PROTECTION_CLASS_C 3
#define PROTECTION_CLASS_D 4
#endif

#ifndef PROTECTION_CLASS_SYSTEM_DEFAULT
#define PROTECTION_CLASS_SYSTEM_DEFAULT 0
#endif

static int unixProtectionClassForVFSProtectionFlags(int protFlags) {
  protFlags &= SQLITE_OPEN_FILEPROTECTION_MASK;
  
  switch (protFlags) {
    case SQLITE_OPEN_FILEPROTECTION_COMPLETE:
      return PROTECTION_CLASS_A;
    case SQLITE_OPEN_FILEPROTECTION_COMPLETEUNLESSOPEN:
      return PROTECTION_CLASS_B;
    case SQLITE_OPEN_FILEPROTECTION_COMPLETEUNTILFIRSTUSERAUTHENTICATION:
      return PROTECTION_CLASS_C;
    case SQLITE_OPEN_FILEPROTECTION_NONE:
      return PROTECTION_CLASS_D;
    default:
    return PROTECTION_CLASS_SYSTEM_DEFAULT;
  }
}

static int shmUnixProtectionClassForVFSProtectionFlags(int protFlags) {
  protFlags &= SQLITE_OPEN_FILEPROTECTION_MASK;
  
  switch (protFlags) {
    case SQLITE_OPEN_FILEPROTECTION_COMPLETE:
      return PROTECTION_CLASS_C;
    case SQLITE_OPEN_FILEPROTECTION_COMPLETEUNLESSOPEN:
      return PROTECTION_CLASS_C;
    case SQLITE_OPEN_FILEPROTECTION_COMPLETEUNTILFIRSTUSERAUTHENTICATION:
      return PROTECTION_CLASS_C;
    case SQLITE_OPEN_FILEPROTECTION_NONE:
      return PROTECTION_CLASS_D;
    default:
      return PROTECTION_CLASS_D;
  }
}

static guardid_t guard = 0x8fd4dbfade2deadull;
static dispatch_once_t guard_once_token;

// extern user_ssize_t guarded_pwrite_np(int fd, const guardid_t *guard, user_addr_t buf, user_size_t nbyte, off_t offset);
// extern user_addr_t guarded_mmap_np(caddr_t addr, const guardid_t *guard, size_t len, int prot, int flags, int fd, off_t pos);
// extern user_ssize_t guarded_write_np(int fd, const guardid_t *guard, user_addr_t cbuf, user_size_t nbyte);


static int (*dl_guarded_open_dprotected_np)(const char *path, const guardid_t *guard, u_int guardflags, int flags, int dpclass, int dpflags, ...);

static int (*dl_guarded_open_np)(const char *path, const guardid_t *guard, u_int guardflags, int flags, ...);

static int (*dl_guarded_close_np)(int fd, const guardid_t *guard);

static int (*dl_guarded_pwrite_np)(int fd, const guardid_t *guard, user_addr_t buf, user_size_t nbyte, off_t offset);

static int (*dl_guarded_write_np)(int fd, const guardid_t *guard, user_addr_t cbuf, user_size_t nbyte);

static int (*dl_guarded_mmap_np)(caddr_t addr, const guardid_t *guard, size_t len, int prot, int flags, int fd, off_t pos);

#endif /* USE_GUARDED_FD */

#if defined(SQLITE_ENABLE_FLOCKTIMEOUT)&&(SQLITE_ENABLE_FLOCKTIMEOUT>0)
# if (defined(__APPLE__) && (!defined(TARGET_IPHONE_SIMULATOR)||(TARGET_IPHONE_SIMULATOR==0)) && ((TARGET_OS_EMBEDDED>0)||(MAC_OS_X_VERSION_10_9>0)))
#  define SQLITE_USE_FLOCKTIMEOUT 1
# endif
#endif /* SQLITE_ENABLE_FLOCKTIMEOUT */

/*
** Default permissions when creating a new file
*/
#ifndef SQLITE_DEFAULT_FILE_PERMISSIONS
# define SQLITE_DEFAULT_FILE_PERMISSIONS 0644
#endif

/*
** Default permissions when creating auto proxy dir
*/
#ifndef SQLITE_DEFAULT_PROXYDIR_PERMISSIONS
# define SQLITE_DEFAULT_PROXYDIR_PERMISSIONS 0755
#endif

/*
** Maximum supported path-length.
*/
#define MAX_PATHNAME PATH_MAX

/*
** Only set the lastErrno if the error code is a real error and not 
** a normal expected return code of SQLITE_BUSY or SQLITE_OK
*/
#define IS_LOCK_ERROR(x)  ((x != SQLITE_OK) && (x != SQLITE_BUSY))

#endif
#if SQLITE_ENABLE_DATA_PROTECTION
  int protFlags;                      /* Data protection flags from unixOpen */
#endif
#if SQLITE_ENABLE_LOCKING_STYLE || defined(__APPLE__)
  unsigned fsFlags;                   /* cached details from statfs() */
#endif
#ifdef SQLITE_USE_FLOCKTIMEOUT
  int nextFlockTimeout;
#endif
#if OS_VXWORKS
  struct vxworksFileId *pId;          /* Unique file ID */
#endif
#ifdef SQLITE_DEBUG
  /* The next group of variables are used to track whether or not the
  ** transaction counter in bytes 24-27 of database files are updated
  ** whenever any part of the database changes.  An assertion fault will

#endif

#ifdef SQLITE_TEST
  /* In test mode, increase the size of this structure a bit so that 
  ** it is larger than the struct CrashFile defined in test6.c.
  */
  char aPadding[32];
#endif
#if defined(__APPLE__)
    /* <rdar://problem/17742712> */
    /* This variable is used to sanity check reads and writes against
    ** corrupt offsets or lengths. No reads or writes should ever exceed
    ** the total capacity of the volume.
    */
    i64 nFsBytes;
#endif
};

/* This variable holds the process id (pid) from when the xRandomness()
** method was called.  If xOpen() is called from a different process id,
** indicating that a fork() has occurred, the PRNG will be reset.
*/

** Different Unix systems declare open() in different ways.  Same use
** open(const char*,int,mode_t).  Others use open(const char*,int,...).
** The difference is important when using a pointer to the function.
**
** The safest way to deal with the problem is to always use this wrapper
** which always has the same well-defined interface.
*/
static int posixOpen(const char *zFile, int flags, int mode, int protectionFlags, int allowmmap){
#if defined(USE_GUARDED_FD)&&defined(__APPLE__)
  dispatch_once(&guard_once_token, ^{
    void *kernellib = (void *)dlopen("/usr/lib/libSystem.dylib", RTLD_GLOBAL);
    assert(kernellib);
    if (kernellib) {
#if SQLITE_ENABLE_DATA_PROTECTION
      dl_guarded_open_dprotected_np = dlsym(kernellib, "guarded_open_dprotected_np");
#else
      dl_guarded_open_dprotected_np = NULL;
#endif
      dl_guarded_open_np = dlsym(kernellib, "guarded_open_np");
      
      if (dl_guarded_open_dprotected_np || dl_guarded_open_np) {
        dl_guarded_close_np = dlsym(kernellib, "guarded_close_np");
        dl_guarded_pwrite_np = dlsym(kernellib, "guarded_pwrite_np");
        dl_guarded_write_np = dlsym(kernellib, "guarded_write_np");
        dl_guarded_mmap_np = NULL; // dlsym(kernellib, "guarded_mmap_np");
        
#if ((!defined(TARGET_IPHONE_SIMULATOR)||(TARGET_IPHONE_SIMULATOR==0)) && (!defined(__i386__)))
        char* isbandi = getenv("RC_XBS");
        if (isbandi && (strlen(isbandi) > 0)) {
          dl_guarded_pwrite_np = NULL;
          dl_guarded_write_np = NULL;
          dl_guarded_mmap_np = NULL;
        }
#else
        dl_guarded_open_dprotected_np = NULL;
        dl_guarded_pwrite_np = NULL;
        dl_guarded_write_np = NULL;
        dl_guarded_mmap_np = NULL;
#endif
        
#if defined(SQLITE_DEBUG) && !defined(SQLITE_TEST)
        _open_error_asl_log();
        if (dl_guarded_open_dprotected_np) {
          asl_log(errorlog_client, NULL, ASL_LEVEL_NOTICE, "SQLite: Found guarded_open_dprotected_np\n");
        } else if (dl_guarded_open_np) {
          asl_log(errorlog_client, NULL, ASL_LEVEL_NOTICE, "SQLite: Using guarded_open_np\n");
        }
        if (dl_guarded_pwrite_np) {
          asl_log(errorlog_client, NULL, ASL_LEVEL_NOTICE, "SQLite: Using guarded_pwrite_np\n");
        } else {
          asl_log(errorlog_client, NULL, ASL_LEVEL_WARNING, "SQLite: Failed to find guarded_pwrite_np!\n");
        }
        if (dl_guarded_write_np) {
          asl_log(errorlog_client, NULL, ASL_LEVEL_NOTICE, "SQLite: Using guarded_write_np\n");
          if (!dl_guarded_pwrite_np) {
            dl_guarded_write_np = NULL;
          }
        } else {
          asl_log(errorlog_client, NULL, ASL_LEVEL_WARNING, "SQLite: Failed to find guarded_write_np!\n");
          dl_guarded_pwrite_np = NULL;
        }

        if( dl_guarded_close_np==NULL|| (dl_guarded_open_np == NULL && dl_guarded_open_dprotected_np == NULL) ){
          _open_error_asl_log();
          asl_log(errorlog_client, NULL, ASL_LEVEL_ERR, "SQLite: Failed to find guarded open/close\n");
        }
#else
        if (dl_guarded_pwrite_np == NULL || dl_guarded_write_np == NULL) {
          dl_guarded_pwrite_np = NULL;
          dl_guarded_write_np = NULL;
        }
#endif
      }
    }
  });
  
  if(dl_guarded_open_np || dl_guarded_open_dprotected_np){
    int guardflags = GUARD_CLOSE | GUARD_DUP | GUARD_SOCKET_IPC | GUARD_FILEPORT;
    if (dl_guarded_pwrite_np && dl_guarded_write_np) {
      if (!allowmmap) {
        guardflags |= (GUARD_WRITE );
      }
    }
    if (dl_guarded_mmap_np) {
      guardflags |= ( GUARD_MMAP );
    }
    int dpc = 0;
    if (flags & O_CREAT) {
      dpc = protectionFlags ? protectionFlags : 0;
    }
    if (dl_guarded_open_dprotected_np && dpc) {
      return dl_guarded_open_dprotected_np(zFile, &guard, guardflags, flags, dpc, 0, mode);
    } else {
      return dl_guarded_open_np(zFile, &guard, guardflags, flags, mode);
    }
  }
#endif
  return open(zFile, flags, mode);
}

/*
** On some systems, calls to fchown() will trigger a message in a security
** log if they come from non-root processes.  So avoid calling fchown() if
** we are not running as root.
*/
static int posixFchown(int fd, uid_t uid, gid_t gid){
  return geteuid() ? 0 : fchown(fd,uid,gid);
}

static ssize_t apple_write(int fildes, const void *buf, size_t nbyte, off_t offset) {
#if defined(USE_GUARDED_FD)&&defined(__APPLE__)
  if( dl_guarded_write_np ){
      return dl_guarded_write_np(fildes, &guard, buf, nbyte);
  }
#endif
  return write(fildes, buf, nbyte);
}

static ssize_t apple_Pwrite(int fildes, const void *buf, size_t nbyte, off_t offset) {
#if defined(USE_GUARDED_FD)&&defined(__APPLE__)
  if( dl_guarded_pwrite_np ){
      return dl_guarded_pwrite_np(fildes, &guard, buf, nbyte, offset);
  }
#endif
  return pwrite(fildes, buf, nbyte, offset);;
}

static ssize_t os_rawPwrite(int fildes, const void *buf, size_t nbyte, off_t offset) {
  return pwrite(fildes, buf, nbyte, offset);
}

static int posixOpen2(const char *zFile, int flags, int mode){
  return posixOpen(zFile, flags, mode, 0, 1);
}

static int posixClose(int fd){
#if defined(USE_GUARDED_FD)&&defined(__APPLE__)
  if( dl_guarded_close_np ){
    return dl_guarded_close_np(fd, &guard);
  }
#endif
  return close(fd);
}

/* Forward reference */
static int openDirectory(const char*, int*);
static int unixGetpagesize(void);

/*
** Many system calls are accessed through pointer-to-functions so that
** they may be overridden at runtime to facilitate fault injection during
** testing and sandboxing.  The following array holds the names and pointers
** to all overrideable system calls.
*/
static struct unix_syscall {
  const char *zName;            /* Name of the system call */
  sqlite3_syscall_ptr pCurrent; /* Current value of the system call */
  sqlite3_syscall_ptr pDefault; /* Default value */
} aSyscall[] = {
  { "open",         (sqlite3_syscall_ptr)posixOpen2,  0  },
#define osOpen      ((int(*)(const char*,int,int))aSyscall[0].pCurrent)

  { "close",        (sqlite3_syscall_ptr)posixClose, 0  },
#define osClose     ((int(*)(int))aSyscall[1].pCurrent)

  { "access",       (sqlite3_syscall_ptr)access,     0  },
#define osAccess    ((int(*)(const char*,int))aSyscall[2].pCurrent)

  { "getcwd",       (sqlite3_syscall_ptr)getcwd,     0  },
#define osGetcwd    ((char*(*)(char*,size_t))aSyscall[3].pCurrent)

#if defined(USE_PREAD64)
  { "pread64",      (sqlite3_syscall_ptr)pread64,    0  },
#else
  { "pread64",      (sqlite3_syscall_ptr)0,          0  },
#endif
#define osPread64   ((ssize_t(*)(int,void*,size_t,off_t))aSyscall[10].pCurrent)

  { "write",        (sqlite3_syscall_ptr)apple_write,      0  },
#define osWrite     ((ssize_t(*)(int,const void*,size_t))aSyscall[11].pCurrent)

#if defined(USE_PREAD) || SQLITE_ENABLE_LOCKING_STYLE
  { "pwrite",       (sqlite3_syscall_ptr)apple_Pwrite,     0  },
#else
  { "pwrite",       (sqlite3_syscall_ptr)0,          0  },
#endif
#define osPwrite    ((ssize_t(*)(int,const void*,size_t,off_t))\
                    aSyscall[12].pCurrent)

#if defined(USE_PREAD64)

#if !defined(SQLITE_OMIT_WAL) || SQLITE_MAX_MMAP_SIZE>0
  { "mmap",       (sqlite3_syscall_ptr)mmap,     0 },
#define osMmap ((void*(*)(void*,size_t,int,int,int,off_t))aSyscall[21].pCurrent)

  { "munmap",       (sqlite3_syscall_ptr)munmap,          0 },
#define osMunmap ((void*(*)(void*,size_t))aSyscall[22].pCurrent)

{ "umask",        (sqlite3_syscall_ptr)0,           0 },

#if HAVE_MREMAP
  { "mremap",       (sqlite3_syscall_ptr)mremap,          0 },
#else
  { "mremap",       (sqlite3_syscall_ptr)0,               0 },
#endif
#define osMremap ((void*(*)(void*,size_t,size_t,int,...))aSyscall[23].pCurrent)

** and -shm files.  We want those files to have *exactly* the same
** permissions as their original database, unadulterated by the umask.
** In that way, if a database file is -rw-rw-rw or -rw-rw-r-, and a
** transaction crashes and leaves behind hot journals, then any
** process that is able to write to the database will also be able to
** recover the hot journals.
*/

static int robust_open2(const char *z, int f, mode_t m, int protectionFlags, int allowmmap){
  int fd = -1;
  mode_t m2 = m ? m : SQLITE_DEFAULT_FILE_PERMISSIONS;

#if defined(O_CLOEXEC)
  f = f|O_CLOEXEC;
#endif

  do{
    if (osOpen == posixOpen2) {
      fd = posixOpen(z,f,m2, protectionFlags, allowmmap);
    } else {
      fd = osOpen(z,f,m2);




    }
    if( fd>=SQLITE_MINIMUM_FILE_DESCRIPTOR ) break;
    osClose(fd);
    sqlite3_log(SQLITE_WARNING, 
                "attempt to open \"%s\" as file descriptor %d", z, fd);
    fd = -1;
    // numist: is this ok with sandboxing?
    if( osOpen("/dev/null", f, m)<0 ) break;
  }while( fd<0 && errno==EINTR );

  if( fd>=0 ) {
  if( m!=0 ){
    struct stat statbuf;
    if( osFstat(fd, &statbuf)==0 
       && statbuf.st_size==0
       && (statbuf.st_mode&0777)!=m 
      ){
        osFchmod(fd, m);
      }
    }
#if defined(FD_CLOEXEC) && (!defined(O_CLOEXEC) || O_CLOEXEC==0)
    osFcntl(fd, F_SETFD, osFcntl(fd, F_GETFD, 0) | FD_CLOEXEC);
#endif
  }
  return fd;
}

static int robust_open(const char *z, int f, mode_t m, int protectionFlags) {
  return robust_open2(z, f, m, protectionFlags, 0);
}

/*
** Helper functions to obtain and relinquish the global mutex. The
** global mutex is used to protect the unixInodeInfo and
** vxworksFileId objects used by this file, all of which may be 
** shared by multiple threads.
**

static void closePendingFds(unixFile *pFile){
  unixInodeInfo *pInode = pFile->pInode;
  UnixUnusedFd *p;
  UnixUnusedFd *pNext;
  for(p=pInode->pUnused; p; p=pNext){
    pNext = p->pNext;
#if OSCLOSE_CHECK_CLOSE_IOERR
    if( osClose(p->fd) ){
      storeLastErrno(pFile, errno);
      rc = SQLITE_IOERR_CLOSE;
      p->pNext = pError;
      pError = p;
    }else{
      sqlite3_free(p);
    }

  ** prior to accessing the inode number.  The one byte written is
  ** an ASCII 'S' character which also happens to be the first byte
  ** in the header of every SQLite database.  In this way, if there
  ** is a race condition such that another thread has already populated
  ** the first page of the database, no damage is done.
  */
  if( statbuf.st_size==0 && (pFile->fsFlags & SQLITE_FSFLAGS_IS_MSDOS)!=0 ){
    do{ rc = (int)osWrite(fd, "S", 1); }while( rc<0 && errno==EINTR );
    if( rc!=1 ){
      storeLastErrno(pFile, errno);
      return SQLITE_IOERR;
    }
    rc = osFstat(fd, &statbuf);
    if( rc!=0 ){
      storeLastErrno(pFile, errno);

    if( pInode->bProcessLock==0 ){
      struct flock lock;
      assert( pInode->nLock==0 );
      lock.l_whence = SEEK_SET;
      lock.l_start = SHARED_FIRST;
      lock.l_len = SHARED_SIZE;
      lock.l_type = F_WRLCK;
#ifdef SQLITE_USE_FLOCKTIMEOUT
      if( pFile->nextFlockTimeout>0 ){
        struct timespec ts;
        struct flocktimeout fltimeout;
        
        ts.tv_sec = pFile->nextFlockTimeout / 1000;
        ts.tv_nsec = (((long)pFile->nextFlockTimeout) % 1000L) * 1000000L;
        fltimeout.fl = lock;
        fltimeout.timeout = ts;
        
        rc = osFcntl(pFile->h, F_SETLKWTIMEOUT, &fltimeout);
        if( !rc ){
          /* reset the timeout on success */
          pFile->nextFlockTimeout = 0;
        }
      }else{
        rc = osFcntl(pFile->h, F_SETLK, &lock);
      }
#else
      rc = osFcntl(pFile->h, F_SETLK, &lock);
#endif
      if( rc<0 ) return rc;
      pInode->bProcessLock = 1;
      pInode->nLock++;
    }else{
      rc = 0;
    }
  }else{
    int i = 0;                      
    do {
#ifdef SQLITE_USE_FLOCKTIMEOUT
      if( (i>0)||(pFile->nextFlockTimeout>0) ){
        struct timespec ts;
        struct flocktimeout fltimeout;
        
        if( i==0 ){
          ts.tv_sec = pFile->nextFlockTimeout / 1000;
          ts.tv_nsec = (((long)pFile->nextFlockTimeout) % 1000L) * 1000000L;
        }else{
          long usTimeout = (i*100);
          assert(i<10000);
          ts.tv_sec = 0;
          ts.tv_nsec = usTimeout * 1000;
        }
        fltimeout.fl = *pLock;
        fltimeout.timeout = ts;
        
        rc = osFcntl(pFile->h, F_SETLKWTIMEOUT, &fltimeout);
        if( !rc ){
          /* reset the timeout on success */
          pFile->nextFlockTimeout = 0;
        }
      }else{
        rc = osFcntl(pFile->h, F_SETLK, pLock);
      }
      i++;
#else
      rc = osFcntl(pFile->h, F_SETLK, pLock);
      if( rc && nRetry ){
         usleep(100 * (++i));
      }
#endif
    }while( !rc && nRetry-- );
  }
  return rc;
}

/*
** Lock the file with the lock specified by parameter eFileLock - one

  /* If some thread using this PID has a lock via a different unixFile*
  ** handle that precludes the requested lock, return BUSY.
  */
  if( (pFile->eFileLock!=pInode->eFileLock && 
          (pInode->eFileLock>=PENDING_LOCK || eFileLock>SHARED_LOCK))
  ){
    rc = SQLITE_BUSY;
#ifdef SQLITE_USE_FLOCKTIMEOUT
    if( pFile->nextFlockTimeout>0 ){
      usleep(((int)pFile->nextFlockTimeout) * 1000L);
    }
#endif
    goto end_lock;
  }

  /* If a SHARED lock is requested, and some thread using this PID already
  ** has a SHARED or RESERVED lock, then increment reference counts and
  ** return SQLITE_OK.
  */

      pInode->nLock++;
      pInode->nShared = 1;
    }
  }else if( eFileLock==EXCLUSIVE_LOCK && pInode->nShared>1 ){
    /* We are trying for an exclusive lock but another thread in this
    ** same process is still holding a shared lock. */
    rc = SQLITE_BUSY;
#ifdef SQLITE_USE_FLOCKTIMEOUT
    if( pFile->nextFlockTimeout>0 ){
      usleep(((int)pFile->nextFlockTimeout) * 1000L);
    }
#endif
  }else{
    /* The request was for a RESERVED or EXCLUSIVE lock.  It is
    ** assumed that there is a SHARED or greater lock on the file
    ** already.
    */
    assert( 0!=pFile->eFileLock );
    lock.l_type = F_WRLCK;

** vxworksReleaseFileId() routine.
*/
static int closeUnixFile(sqlite3_file *id){
  unixFile *pFile = (unixFile*)id;
#if SQLITE_MAX_MMAP_SIZE>0
  unixUnmapfile(pFile);
#endif
#if OSCLOSE_CHECK_CLOSE_IOERR
  if( pFile->h>=0 ){
    int err = osClose(pFile->h);
    if( err ){
      storeLastErrno(pFile, errno);
      return SQLITE_IOERR_CLOSE;
    }else{
      pFile->h=-1;
    }
  }
#else
  if( pFile->h>=0 ){
    robust_close(pFile, pFile->h, __LINE__);
    pFile->h = -1;
  }
#endif
#if OS_VXWORKS
  if( pFile->pId ){
    if( pFile->ctrlFlags & UNIXFILE_DELETE ){
      osUnlink(pFile->pId->zCanonicalName);
    }
    vxworksReleaseFileId(pFile->pId);
    pFile->pId = 0;

  /* grab an exclusive lock */
  rc = osMkdir(zLockFile, 0777);
  if( rc<0 ){
    /* failed to open/create the lock directory */
    int tErrno = errno;
    if( EEXIST == tErrno ){
      rc = SQLITE_BUSY;
#ifdef SQLITE_USE_FLOCKTIMEOUT
      if( pFile->nextFlockTimeout>0 ){
        usleep(((int)pFile->nextFlockTimeout) * 1000L);
      }
#endif
    } else {
      rc = sqliteErrorFromPosixError(tErrno, SQLITE_IOERR_LOCK);
      if( IS_LOCK_ERROR(rc) ){
        storeLastErrno(pFile, tErrno);
      }
    }
    return rc;

    pFile->eFileLock = eFileLock;
  }
  OSTRACE(("LOCK    %d %s %s (flock)\n", pFile->h, azFileLock(eFileLock), 
           rc==SQLITE_OK ? "ok" : "failed"));
#ifdef SQLITE_IGNORE_FLOCK_LOCK_ERRORS
  if( (rc & SQLITE_IOERR) == SQLITE_IOERR ){
    rc = SQLITE_BUSY;
#ifdef SQLITE_USE_FLOCKTIMEOUT
    if( pFile->nextFlockTimeout>0 ){
      usleep(((long)pFile->nextFlockTimeout) * 1000L);
    }
#endif
  }
#endif /* SQLITE_IGNORE_FLOCK_LOCK_ERRORS */
  return rc;
}


/*

    rc = SQLITE_OK;
    goto sem_end_lock;
  }
  
  /* lock semaphore now but bail out when already locked. */
  if( sem_trywait(pSem)==-1 ){
    rc = SQLITE_BUSY;
#ifdef SQLITE_USE_FLOCKTIMEOUT
    if( pFile->nextFlockTimeout>0 ){
      usleep(((long)pFile->nextFlockTimeout) * 1000L);
    }
#endif
    goto sem_end_lock;
  }

  /* got it, set the type and return ok */
  pFile->eFileLock = eFileLock;

 sem_end_lock:

#else
    rc = sqliteErrorFromPosixError(tErrno,
                    setLockFlag ? SQLITE_IOERR_LOCK : SQLITE_IOERR_UNLOCK);
#endif /* SQLITE_IGNORE_AFP_LOCK_ERRORS */
    if( IS_LOCK_ERROR(rc) ){
      storeLastErrno(pFile, tErrno);
    }
#ifdef SQLITE_USE_FLOCKTIMEOUT
    if( (rc==SQLITE_BUSY)&&(pFile->nextFlockTimeout>0) ){
      usleep(((int)pFile->nextFlockTimeout) * 1000L);
    }
#endif
    return rc;
  } else {
    return SQLITE_OK;
  }
}

/*

  /* If some thread using this PID has a lock via a different unixFile*
  ** handle that precludes the requested lock, return BUSY.
  */
  if( (pFile->eFileLock!=pInode->eFileLock && 
       (pInode->eFileLock>=PENDING_LOCK || eFileLock>SHARED_LOCK))
     ){
    rc = SQLITE_BUSY;
#ifdef SQLITE_USE_FLOCKTIMEOUT
    if( pFile->nextFlockTimeout>0 ){
      usleep(((int)pFile->nextFlockTimeout) * 1000L);
    }
#endif
    goto afp_end_lock;
  }
  
  /* If a SHARED lock is requested, and some thread using this PID already
  ** has a SHARED or RESERVED lock, then increment reference counts and
  ** return SQLITE_OK.
  */

      pInode->nLock++;
      pInode->nShared = 1;
    }
  }else if( eFileLock==EXCLUSIVE_LOCK && pInode->nShared>1 ){
    /* We are trying for an exclusive lock but another thread in this
     ** same process is still holding a shared lock. */
    rc = SQLITE_BUSY;
#ifdef SQLITE_USE_FLOCKTIMEOUT
    if( pFile->nextFlockTimeout>0 ){
      usleep(((int)pFile->nextFlockTimeout) * 1000L);
    }
#endif
  }else{
    /* The request was for a RESERVED or EXCLUSIVE lock.  It is
    ** assumed that there is a SHARED or greater lock on the file
    ** already.
    */
    int failed = 0;
    assert( 0!=pFile->eFileLock );

    pFile->inNormalWrite = 0;
#endif
    
    if( pFile->eFileLock==EXCLUSIVE_LOCK ){
      rc = afpSetLock(context->dbPath, pFile, SHARED_FIRST, SHARED_SIZE, 0);
      if( rc==SQLITE_OK && (eFileLock==SHARED_LOCK || pInode->nShared>1) ){
        /* only re-establish the shared lock if necessary */
        int sharedLockByte = (int) (SHARED_FIRST+pInode->sharedByte);
        rc = afpSetLock(context->dbPath, pFile, sharedLockByte, 1, 1);
      } else {
        skipShared = 1;
      }
    }
    if( rc==SQLITE_OK && pFile->eFileLock>=PENDING_LOCK ){
      rc = afpSetLock(context->dbPath, pFile, PENDING_BYTE, 1, 0);

*/
static int seekAndRead(unixFile *id, sqlite3_int64 offset, void *pBuf, int cnt){
  int got;
  int prior = 0;
#if (!defined(USE_PREAD) && !defined(USE_PREAD64))
  i64 newOffset;
#endif

#if defined(__APPLE__)
  /* <rdar://problem/17742712> */
  if( id->nFsBytes > 0 && offset + cnt > id->nFsBytes ){
    __builtin_trap();
  }
#endif
  TIMER_START;
  assert( cnt==(cnt&0x1ffff) );
  assert( id->h>2 );
  cnt &= 0x1ffff;
  do{
#if defined(USE_PREAD)
    got = (int)osPread(id->h, pBuf, cnt, offset);
    SimulateIOError( got = -1 );
#elif defined(USE_PREAD64)
    got = osPread64(id->h, pBuf, cnt, offset);
    SimulateIOError( got = -1 );
#else
    newOffset = lseek(id->h, offset, SEEK_SET);
    SimulateIOError( newOffset-- );

  int fd,                         /* File descriptor to write to */
  i64 iOff,                       /* File offset to begin writing at */
  const void *pBuf,               /* Copy data from this buffer to the file */
  int nBuf,                       /* Size of buffer pBuf in bytes */
  int *piErrno                    /* OUT: Error number if error occurs */
){
  int rc = 0;                     /* Value returned by system call */
#if (!defined(USE_PREAD) && !defined(USE_PREAD64))
  i64 newOffset;
#endif

  assert( nBuf==(nBuf&0x1ffff) );
  assert( fd>2 );
  nBuf &= 0x1ffff;
  TIMER_START;

#if defined(USE_PREAD)

** Seek to the offset in id->offset then read cnt bytes into pBuf.
** Return the number of bytes actually read.  Update the offset.
**
** To avoid stomping the errno value on a failed write the lastErrno value
** is set before returning.
*/
static int seekAndWrite(unixFile *id, i64 offset, const void *pBuf, int cnt){
#if defined(__APPLE__)
  /* <rdar://problem/17742712> */
  if( id->nFsBytes > 0 && offset + cnt > id->nFsBytes ){
    __builtin_trap();
  }
#endif
  return seekAndWriteFd(id->h, offset, pBuf, cnt, &id->lastErrno);
}


/*
** Write data from a buffer into a file.  Return SQLITE_OK on success
** or some other error code on failure.

  int fd = -1;
  char zDirname[MAX_PATHNAME+1];

  sqlite3_snprintf(MAX_PATHNAME, zDirname, "%s", zFilename);
  for(ii=(int)strlen(zDirname); ii>1 && zDirname[ii]!='/'; ii--);
  if( ii>0 ){
    zDirname[ii] = '\0';
    fd = robust_open(zDirname, O_RDONLY|O_BINARY, 0, 0);
    if( fd>=0 ){
      OSTRACE(("OPENDIR %-3d %s\n", fd, zDirname));
    }
  }
  *pFd = fd;
  return (fd>=0?SQLITE_OK:unixLogError(SQLITE_CANTOPEN_BKPT, "open", zDirname));
}

    int dirfd;
    OSTRACE(("DIRSYNC %s (have_fullfsync=%d fullsync=%d)\n", pFile->zPath,
            HAVE_FULLFSYNC, isFullsync));
    rc = osOpenDirectory(pFile->zPath, &dirfd);
    if( rc==SQLITE_OK && dirfd>=0 ){
      full_fsync(dirfd, 0, 0);
#if OSCLOSE_CHECK_CLOSE_IOERR
      if( osClose(pFile->dirfd) ){
        storeLastErrno(pFile, errno);
        rc = SQLITE_IOERR_DIR_CLOSE;
      }
#else
      robust_close(pFile, dirfd, __LINE__);
#endif
    }else if( rc==SQLITE_CANTOPEN ){

** nBytes or larger, this routine is a no-op.
*/
static int fcntlSizeHint(unixFile *pFile, i64 nByte){
  if( pFile->szChunk>0 ){
    i64 nSize;                    /* Required file size */
    struct stat buf;              /* Used to hold return values of fstat() */
   
    if( osFstat(pFile->h, &buf) ) {
      storeLastErrno(pFile, errno);
      return SQLITE_IOERR_FSTAT;
    }

    nSize = ((nByte+pFile->szChunk-1) / pFile->szChunk) * pFile->szChunk;
    if( nSize>(i64)buf.st_size ){

#if defined(HAVE_POSIX_FALLOCATE) && HAVE_POSIX_FALLOCATE
      /* The code below is handling the return value of osFallocate() 
      ** correctly. posix_fallocate() is defined to "returns zero on success, 

    return rc;
  }
#endif

  return SQLITE_OK;
}

#if SQLITE_ENABLE_DATA_PROTECTION
static int unixSetFileProtection(int fd, int protFlags, int isShm){
  int protClass;
  int currClass;
  
  if( 0==protFlags ){
    return SQLITE_OK;
  }
  assert(fd>=0);
  assert((protFlags&SQLITE_OPEN_FILEPROTECTION_MASK)==protFlags);
  
  protClass = (!isShm) ? unixProtectionClassForVFSProtectionFlags(protFlags) : shmUnixProtectionClassForVFSProtectionFlags(protFlags);
  
# if defined(__APPLE__)&&(TARGET_OS_EMBEDDED!=0)&&\
(!defined(TARGET_IPHONE_SIMULATOR)||(TARGET_IPHONE_SIMULATOR==0))
  
  currClass = fcntl(fd, F_GETPROTECTIONCLASS);
  if( currClass<1 && protClass==4 ){
    /* F_GETPROTECTIONCLASS will fail if the file system doesn't have content protection enabled, 
     * if the protClass is 4/NONE that's OK */
    return SQLITE_OK;
  }
  if( protClass!=currClass ){
    if (0 != fcntl(fd, F_SETPROTECTIONCLASS, protClass)) {
      if( errno == EPERM ){
        /* <rdar://problem/9385939> Test device locked state when error reporting for content protection issues */        
        return SQLITE_AUTH;
      }
      return SQLITE_IOERR;
    }

    rc = unixMapfile(pFile, nByte);
    return rc;
  }
# else
# warning SQLITE_ENABLE_DATA_PROTECTION is defined but could not be enabled for this deployment target
# endif
  return SQLITE_OK;
}
#endif /* SQLITE_ENABLE_DATA_PROTECTION */

#if (SQLITE_ENABLE_APPLE_SPI>0) && defined(__APPLE__)
#include "sqlite3_private.h"
#include <copyfile.h>
static int getDbPathForUnixFile(unixFile *pFile, char *dbPath);
#endif

#if SQLITE_ENABLE_LOCKING_STYLE
static int isProxyLockingMode(unixFile *);
#endif

#if (SQLITE_ENABLE_APPLE_SPI>0) && defined(__APPLE__)
static int unixTruncateDatabase(unixFile *, int);
static const char *unixTempFileDir(void);

static int unixInvalidateSupportFiles(unixFile *, int);

static int findCreateFileMode(const char *, int, mode_t*, uid_t *,gid_t *);

/* opens a read/write connection to a file zName inheriting the appropriate
** user/perms from the database file if running as root.  Returns the file 

  int *pFd
){
  int fd = -1;
  mode_t openMode;              /* Permissions to create file with */
  uid_t uid;                    /* Userid for the file */
  gid_t gid;                    /* Groupid for the file */
  int rc;
  int isShm = 0;
  
  int zNameLen = zName ? (int)strlen(zName) : 0;
  if (zNameLen > 4) {
    const char* suffix = &(zName[zNameLen-4]);
    if (strncmp("-shm", suffix, 4) == 0) {
      isShm = 1;
    }
  }
  assert(pFd!=NULL);
  rc = findCreateFileMode(zName, dbOpenFlags, &openMode, &uid, &gid);
  if( rc!=SQLITE_OK ){
    return rc;
  }
  int unixProtFlags = (!isShm) ? unixProtectionClassForVFSProtectionFlags(protFlags) : shmUnixProtectionClassForVFSProtectionFlags(protFlags);
  
  fd = robust_open2(zName, openFlags, openMode, unixProtFlags, isShm);
  OSTRACE(("OPENX   %-3d %s 0%o\n", fd, zName, openFlags));
  if( fd<0 ){
#if SQLITE_ENABLE_DATA_PROTECTION
    if( errno==EPERM ){
      /* <rdar://problem/9385939> Test device locked state when error reporting for content protection issues */
      rc = unixLogError(SQLITE_AUTH, "open", zName);
    }else{
      rc = unixLogError(SQLITE_CANTOPEN_BKPT, "open", zName);
    }
#else
    rc = unixLogError(SQLITE_CANTOPEN_BKPT, "open", zName);
#endif
    return rc;
  }
  /* if we're opening the wal or journal and running as root, set
  ** the journal uid/gid */
  if( dbOpenFlags & (SQLITE_OPEN_WAL|SQLITE_OPEN_MAIN_JOURNAL) ){
    uid_t euid = geteuid();
    if( euid==0 && (euid!=uid || getegid()!=gid) ){
      if( fchown(fd, uid, gid) ){
        rc = SQLITE_CANTOPEN_BKPT;
      }
    }
  }
#if SQLITE_ENABLE_DATA_PROTECTION
  if( rc==SQLITE_OK ){
    rc = unixSetFileProtection(fd, protFlags, isShm);
  }
#endif
  if( rc==SQLITE_OK ){
    *pFd = fd;
  } else {
    *pFd = -1;
    osClose(fd);
  }
  return rc;
}

static int readWALSettingFromFile(unixFile *pFile) {
  char magicword[20];
  int result = -1;
  sqlite3_file *id = (sqlite3_file *)pFile;
  if (id != NULL) {
    int sqlitecode = id->pMethods->xRead(id, magicword, sizeof(magicword), 0l);
    
    if (SQLITE_OK == sqlitecode) {
      if (0 == memcmp(magicword, "SQLite format 3", 15)) {
        result = 0;
        if ((magicword[18] == 2) && (magicword[19] == 2)) {
          result = 1;
        }
      }
    }
  }
  return result;
}

static int sqlite_guarded_fcopyfile(int src_fd, int dst_fd) {
  size_t blen;
  char *bp = 0;
  ssize_t nread;
  int ret = 0;
  size_t iBlocksize = 0;
  size_t oBlocksize = 0;
  size_t totalCopied = 0;
  const size_t twomeg = (1024 * 1024 * 2);
  struct statfs sfs;
  bzero(&sfs, sizeof(struct statfs));
  struct stat sbuf;
  bzero(&sbuf, sizeof(struct stat));
  int err = -1;
        
  fstat(src_fd, &sbuf);
  
  if (fstatfs(src_fd, &sfs) == -1) {
    iBlocksize = sbuf.st_blksize;
  } else {
    iBlocksize = sfs.f_iosize;
  }
  
  if (iBlocksize > twomeg) {
    iBlocksize = twomeg;
  }
  
  if ((bp = malloc(iBlocksize)) == NULL)
    return -1;
  
  oBlocksize = iBlocksize;
  
  blen = iBlocksize;
  
  /* If supported, do preallocation for Xsan / HFS volumes */
#ifdef F_PREALLOCATE
  {
    fstore_t fst;
    
    fst.fst_flags = 0;
    fst.fst_posmode = F_PEOFPOSMODE;
    fst.fst_offset = 0;
    fst.fst_length = sbuf.st_size;
    /* Ignore errors; this is merely advisory. */
    (void)fcntl(dst_fd, F_PREALLOCATE, &fst);
  }
#endif
  
  while ((nread = osRead(src_fd, bp, blen)) > 0)
  {
    ssize_t nwritten;
    size_t left = nread;
    void *ptr = bp;
    int loop = 0;
    
    while (left > 0) {
      nwritten = osWrite(dst_fd, ptr, MIN(left, oBlocksize));
      switch (nwritten) {
        case 0:
          if (++loop > 5) {
            ret = -1;
            err = EAGAIN;
            goto exit;
          }
          break;
        case -1:
          ret = -1;
          goto exit;
        default:
          left -= nwritten;
          ptr = ((char*)ptr) + nwritten;
          loop = 0;
          break;
      }
      totalCopied += nwritten;
    }
  }
  if (nread < 0)
  {
    ret = -1;
    goto exit;
  }
  
  if (ftruncate(dst_fd, totalCopied) < 0)
  {
    ret = -1;
    goto exit;
  }
  
exit:
  if (ret == -1)
  {
    if (err != -1) {
      errno = err;
    } else {
      err = errno;
    }
  }
  free(bp);
  return (ret != -1) ? 0 : err;
}


static int unixReplaceDatabase(unixFile *pFile, sqlite3 *srcdb) {
  sqlite3_file *id = (sqlite3_file *)pFile;
  Btree *pSrcBtree = NULL;
  sqlite3_file *src_file = NULL;
  unixFile *pSrcFile = NULL;
  char srcWalPath[MAXPATHLEN+5];
  int srcWalFD = -1;
  int rc = SQLITE_OK;
  Superlock *pLock = NULL;
  int flags = 0;
  sqlite3 *srcdb2 = NULL;
  copyfile_state_t s;
  int corruptSrcFileLock = 0;
  int corruptDstFileLock = 0;
  int isSrcCorrupt = 0;
  int isDstCorrupt = 0;
  int shouldCopySrc = 0;
  int isDstWAL = -1;
  int isSrcWAL = -1;
  int extraFDtoClose = -1;
  char* replacementSrcPath = NULL;
  char* replacementSrcWALPath = NULL;
  char* replacementSrcShmPath = NULL;
  int notGuardedFileDescriptors = 0;
  int dstPreExists = 1;
  struct stat checkBuffer;
  int srcFlags = 0;
  
  if( !sqlite3SafetyCheckOk(srcdb) ){
    return SQLITE_MISUSE;
  }
    
  const char* realSrcPath = sqlite3_db_filename(srcdb, NULL);
  
  const char *tDir = unixTempFileDir();
  int tDirLen = tDir ? (int)strlen(tDir) : 0;
  if (tDirLen < 1) {
    _open_error_asl_log();
    asl_log(errorlog_client, NULL, ASL_LEVEL_CRIT, "SQLite: replace database failed because TMPDIR is not set correctly\n");

    return SQLITE_PERM;
  }

  if (0 == stat(pFile->zPath, &checkBuffer)) {
    if (checkBuffer.st_size == 0l) {
      dstPreExists = 0;
    }
  } else {
    if (errno == ENOENT) {
      dstPreExists = 0;
    }
  }
#if SQLITE_ENABLE_DATA_PROTECTION
  flags |= pFile->protFlags;
#endif
#if SQLITE_ENABLE_LOCKING_STYLE
  if( isProxyLockingMode(pFile) ){
    flags |= SQLITE_OPEN_AUTOPROXY;
  }
#endif
  
  rc = sqlite3demo_superlock(pFile->zPath, 0, flags, 0, 0, (void**)&pLock);
  if( rc ){
    if( rc==SQLITE_CORRUPT || rc==SQLITE_NOTADB ){
      isDstCorrupt = 1;
      rc = sqlite3demo_superlock_corrupt(id, SQLITE_LOCK_EXCLUSIVE,
                                         &corruptDstFileLock);
    }
    if( rc ){
      return rc;
    }
  } else {
    isDstWAL = ((pLock->bWal) ? 1 : 0);
  }
  /* get the src file descriptor adhering to the db struct access rules 
   ** this code is modeled after sqlite3_file_control() in main.c
   */ 
  sqlite3_mutex_enter(srcdb->mutex);
  if( srcdb->nDb>0 ){
    pSrcBtree = srcdb->aDb[0].pBt;
  }
  if( pSrcBtree ){
    Pager *pSrcPager;
    sqlite3BtreeEnter(pSrcBtree);
    pSrcPager = sqlite3BtreePager(pSrcBtree);
    assert( pSrcPager!=0 );
    src_file = sqlite3PagerFile(pSrcPager);
    assert( src_file!=0 );
    if( src_file->pMethods ){

      pSrcFile = (unixFile *)src_file;
#if SQLITE_ENABLE_LOCKING_STYLE || defined(__APPLE__)
      if ((pSrcFile->openFlags & O_RDWR) == O_RDWR) {
        srcFlags = SQLITE_OPEN_READWRITE;
      } else {
        srcFlags = SQLITE_OPEN_READONLY;
      }
#else
      srcFlags = SQLITE_OPEN_READWRITE;
#endif
#if SQLITE_ENABLE_DATA_PROTECTION
      srcFlags |= pSrcFile->protFlags;
#endif
#if SQLITE_ENABLE_LOCKING_STYLE
      if( isProxyLockingMode(pSrcFile) ){
        srcFlags |= SQLITE_OPEN_AUTOPROXY;
      }
#endif
      
      rc = sqlite3_open_v2(pSrcFile->zPath, &srcdb2, srcFlags, 0);
      if( rc==SQLITE_OK ){
        sqlite3_file* tempSrcFile = NULL;
        int anotherError = sqlite3_file_control(srcdb2, NULL, SQLITE_FCNTL_FILE_POINTER, &tempSrcFile);

        if (anotherError == SQLITE_OK && tempSrcFile) {
          isSrcWAL = (1== readWALSettingFromFile((unixFile*)tempSrcFile)) ? 1 : 0;
        } else {
          isSrcWAL = (1== readWALSettingFromFile(pSrcFile)) ? 1 : 0;
        }

        sqlite3_busy_timeout(srcdb2, srcdb->busyTimeout);
        /* start a deferred transaction and read to establish a read lock */
        rc = sqlite3_exec(srcdb2, "BEGIN DEFERRED; PRAGMA schema_version", 0, 0, 0);
        
        if (rc == SQLITE_CANTOPEN) {
          if (isSrcWAL) {
            // try opening writeable and again
            sqlite3_close(srcdb2);
            srcdb2 = NULL;
            rc = sqlite3_open_v2(pSrcFile->zPath, &srcdb2, ((srcFlags & (~SQLITE_OPEN_READONLY))| SQLITE_OPEN_READWRITE), 0);
            if( rc==SQLITE_OK ){
              sqlite3_busy_timeout(srcdb2, srcdb->busyTimeout);
              /* start a deferred transaction and read to establish a read lock */
              rc = sqlite3_exec(srcdb2, "BEGIN DEFERRED; PRAGMA schema_version", 0, 0, 0);
            }
          }
        }
        
        if (isSrcWAL && (rc == SQLITE_CANTOPEN)) {
          // try copying to temp and opening writeable
          if (srcdb2) {
            sqlite3_close(srcdb2);
            srcdb2 = NULL;
          }
          rc = SQLITE_OK;  // well, maybe
          shouldCopySrc = 1;
        }
        if (dstPreExists && (isSrcWAL != isDstWAL) && (!isDstCorrupt)) {
          shouldCopySrc = 1;
        }

        if( rc==SQLITE_CORRUPT || rc==SQLITE_NOTADB ){
          isSrcCorrupt = 1;
          rc = sqlite3demo_superlock_corrupt(src_file, SQLITE_LOCK_SHARED,
                                             &corruptSrcFileLock);
        }
      }
    }
  }
  if( pSrcFile==NULL || pSrcFile->h<0){
    rc = SQLITE_INTERNAL;
  }
  if( rc!=SQLITE_OK ){
    goto end_replace_database;
  }
  
  int srcFD = pSrcFile->h;
  const char* srcPath = pSrcFile->zPath;
  
  if (shouldCopySrc) {
    sqlite3* newSrcDB = NULL;
    int shouldUnlinkWAL = 0;

    /* initialize a new database in TMPDIR and copy the contents over */
    int tLen = sizeof(char) * (tDirLen + 25);
    replacementSrcPath = (char *)calloc(1, tLen);
    
    int tsrcFd = -1;
    
    strlcpy(replacementSrcPath, tDir, tLen);
    /* create a temporary database with the prefix tmpsqlitereplacedb */
    if( replacementSrcPath[(tDirLen-1)] != '/' ){
      strlcat(replacementSrcPath, "/", tLen);
    }
    strlcat(replacementSrcPath, "tmpsqlitereplacedbXXXXXX", tLen);
    tsrcFd = mkstemp(replacementSrcPath);
    if( tsrcFd==-1 ){
      storeLastErrno(pFile, errno);
      rc = SQLITE_IOERR;
    } else{
      extraFDtoClose = tsrcFd;
      
      replacementSrcWALPath = (char*)calloc(1,tLen+5);
      strlcpy(replacementSrcWALPath, replacementSrcPath, tLen+5);
      strlcat(replacementSrcWALPath, "-wal", tLen+5);

      replacementSrcShmPath = (char*)calloc(1,tLen+5);
      strlcpy(replacementSrcShmPath, replacementSrcPath, tLen+5);
      strlcat(replacementSrcShmPath, "-shm", tLen+5);
      
      // copy src wal & db
      s = copyfile_state_alloc();
      lseek(srcFD, 0, SEEK_SET);
      lseek(tsrcFd, 0, SEEK_SET);
      
      if( fcopyfile(srcFD, tsrcFd, s, COPYFILE_DATA)){
        int err=errno;
        switch(err) {
          case ENOMEM:
            rc = SQLITE_NOMEM;
            break;
          default:
            storeLastErrno(pFile, err);
            rc = SQLITE_IOERR;
        }
      }
      copyfile_state_free(s);
      fsync(tsrcFd);
            
      if (rc == SQLITE_OK) {
        int tSrcWALFD = -1;
        strlcpy(srcWalPath, srcPath, MAXPATHLEN+5);
        strlcat(srcWalPath, "-wal", MAXPATHLEN+5);
        tSrcWALFD = robust_open2(srcWalPath, O_RDONLY, 0, 0, 0);
        if (tSrcWALFD >=0) {
          srcWalFD = robust_open2(replacementSrcWALPath, O_RDWR | O_CREAT | O_TRUNC, 0, 0, 0);
          if ((srcWalFD < 0) && (errno != ENOENT)) {
            storeLastErrno(pFile, errno);
            rc = SQLITE_IOERR;
            osClose(tSrcWALFD);
            tSrcWALFD = -1;
          }
        } else {
          if (errno != ENOENT) {
            storeLastErrno(pFile, errno);
            rc = SQLITE_IOERR;
          }
        }
        
        if (rc == SQLITE_OK) {
          if (srcWalFD >= 0) {
            s = copyfile_state_alloc();
            lseek(srcWalFD, 0, SEEK_SET);
            lseek(tSrcWALFD, 0, SEEK_SET);
            if( sqlite_guarded_fcopyfile(tSrcWALFD, srcWalFD) != 0){
              int err=errno;
              switch(err) {
                case ENOMEM:
                  rc = SQLITE_NOMEM;
                  break;
                default:
                  storeLastErrno(pFile, err);
                  rc = SQLITE_IOERR;
              }
            }
            copyfile_state_free(s);
            fsync(srcWalFD);
          }
          if (tSrcWALFD >= 0) {
            osClose(tSrcWALFD);
          }
          
          // open src as db
          rc = sqlite3_open_v2(replacementSrcPath, &newSrcDB, ((srcFlags & (~SQLITE_OPEN_READONLY))| SQLITE_OPEN_READWRITE), 0);
          if (rc != SQLITE_OK) {
          } else {
            sqlite3_busy_timeout(newSrcDB, srcdb->busyTimeout);
          }


        }
      }

      if (rc != SQLITE_OK) {
        if (newSrcDB) {
          sqlite3_close(newSrcDB);
          newSrcDB = NULL;
        }
      }
      
      if (rc == SQLITE_OK) {
        rc = sqlite3_exec(newSrcDB, "BEGIN DEFERRED; PRAGMA schema_version; COMMIT;", 0, 0, 0);
 
        if (isSrcWAL != isDstWAL) {
          if (isDstWAL) {
            rc = sqlite3_exec(newSrcDB, "PRAGMA journal_mode=WAL", 0, 0, 0);
          } else {
            rc = sqlite3_exec(newSrcDB, "PRAGMA journal_mode=DELETE", 0, 0, 0);
            shouldUnlinkWAL = 1;
          }
        }

        if (srcdb2 == NULL) {
          srcdb2 = newSrcDB;
          sqlite3_exec(newSrcDB, "BEGIN DEFERRED; PRAGMA schema_version;", 0, 0, 0);
        } else {
          sqlite3_close(newSrcDB);
          newSrcDB = NULL;
        }
      }
    
    if (shouldUnlinkWAL) {
      if (srcWalFD >= 0) {
        osClose(srcWalFD);
        srcWalFD = -1;
      }
      unlink(replacementSrcWALPath);
      free(replacementSrcWALPath);
      replacementSrcWALPath = NULL;

      unlink(replacementSrcShmPath);
      free(replacementSrcShmPath);
      replacementSrcShmPath = NULL;
    }

      if (rc == SQLITE_OK) {
        notGuardedFileDescriptors = 1;
        srcFD = tsrcFd;
        srcPath = replacementSrcPath;
      }
    }
    
  }
  
  if (!srcdb2) {
    rc = SQLITE_INTERNAL;
  }
  if( rc!=SQLITE_OK ){
    goto end_replace_database;
  }
  /* both databases are locked appropriately, copy the src wal journal if 
   ** one exists and then the actual database file
   */
  strlcpy(srcWalPath, srcPath, MAXPATHLEN+5);
  strlcat(srcWalPath, "-wal", MAXPATHLEN+5);
  if (srcWalFD < 0) {
    srcWalFD = robust_open2(srcWalPath, O_RDONLY, 0, 0, 0);
  }
  if( !(srcWalFD<0) ){
    char dstWalPath[MAXPATHLEN+5];
    int dstWalFD = -1;
    int protFlags = 0;
    strlcpy(dstWalPath, pFile->zPath, MAXPATHLEN+5);
    strlcat(dstWalPath, "-wal", MAXPATHLEN+5);

#if SQLITE_ENABLE_DATA_PROTECTION
    protFlags = pFile->protFlags;
#endif
    rc = unixOpenChildFile(dstWalPath, O_RDWR|O_CREAT, SQLITE_OPEN_WAL,
                           protFlags, &dstWalFD);
    if( rc==SQLITE_OK ){
      s = copyfile_state_alloc();
      lseek(srcWalFD, 0, SEEK_SET);
      lseek(dstWalFD, 0, SEEK_SET);
      if( sqlite_guarded_fcopyfile(srcWalFD, dstWalFD) != 0){
        int err=errno;
        switch(err) {
          case ENOMEM:
            rc = SQLITE_NOMEM;
            break;
          default:
            storeLastErrno(pFile, err);
            rc = SQLITE_IOERR;
        }
      }
      
      copyfile_state_free(s);
      fsync(dstWalFD);
      osClose(dstWalFD);
    }
    osClose(srcWalFD);
  }
  if( rc==SQLITE_OK ){
    /* before we copy, ensure that the file change counter will be modified */
    uint32_t srcChange = 0;
    uint32_t dstChange = 0;
    pread(srcFD, &srcChange, 4, 24);
    pread(pFile->h, &dstChange, 4, 24);
    
    /* copy the actual database */
    s = copyfile_state_alloc();
    lseek(srcFD, 0, SEEK_SET);
    lseek(pFile->h, 0, SEEK_SET);
    if( sqlite_guarded_fcopyfile(srcFD, pFile->h) != 0 ){
      int err=errno;
      switch(err) {
        case ENOMEM:
          rc = SQLITE_NOMEM;
          break;
        default:
          storeLastErrno(pFile, err);
          rc = SQLITE_IOERR;
      }
    }
    copyfile_state_free(s);
    
    if (srcChange == dstChange) {
      /* modify the change counter to force page zero to be reloaded */
      dstChange ++;
      osPwrite(pFile->h, &dstChange, 4, 24);
    }
  }
  if( isSrcCorrupt ){
    sqlite3demo_superunlock_corrupt(src_file, corruptSrcFileLock);
  }else{
    /* done with the source db so end the transaction */
    sqlite3_exec(srcdb2, "COMMIT", 0, 0, 0);
  }
  /* zero out any old journal clutter */
  if( rc==SQLITE_OK ){
    int skipWAL = (srcWalFD<0)?0:1;
    unixInvalidateSupportFiles(pFile, skipWAL);
    pFile->pMethod->xSync((sqlite3_file*)pFile, SQLITE_SYNC_FULL);
  }
  
end_replace_database:
  if (extraFDtoClose >= 0) {
    /* extraFDtoClose is created with mkstemp, can't use guarded close() */
    close(extraFDtoClose);
    extraFDtoClose = -1;
  }
  if (replacementSrcPath) {
    unlink(replacementSrcPath);
    free(replacementSrcPath);
  }
  if (replacementSrcWALPath) {
    unlink(replacementSrcWALPath);
    free(replacementSrcWALPath);
  }
  if (replacementSrcShmPath) {
    unlink(replacementSrcShmPath);
    free(replacementSrcShmPath);
  }
  if (srcdb2) {
    sqlite3_close(srcdb2);
    srcdb2 = NULL;
  }
  if( pSrcBtree ){
    sqlite3BtreeLeave(pSrcBtree);
  }
  sqlite3_mutex_leave(srcdb->mutex);
  if( isDstCorrupt ){
    sqlite3demo_superunlock_corrupt(id, corruptDstFileLock);
  }else{
    sqlite3demo_superunlock(pLock);
  }
  if( rc==SQLITE_OK && (srcWalFD>=0) && !isSrcCorrupt ){
    /* sync up the -shm file */
    sqlite3 *tdb = NULL;
    int trc = sqlite3_open_v2(pFile->zPath, &tdb, SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE|flags, 0);
    if( trc==SQLITE_OK ){
      sqlite3_busy_timeout(tdb, srcdb->busyTimeout);
      sqlite3_exec(tdb, "PRAGMA schema_version", 0, 0, 0);
    }
    if( tdb!=NULL ){
      sqlite3_close(tdb);
    }
  }
  
  if (rc) {
    _open_error_asl_log();
    const char* dstPath = pFile ? pFile->zPath : "<dst db null>";

    if (dstPath == NULL) {
      dstPath = "<dst path null>";
    }
    if (realSrcPath == NULL) {
      realSrcPath = "<src path null>";
    }

    asl_log(errorlog_client, NULL, ASL_LEVEL_ERR, "SQLite: unixReplaceDatabase() failed with error %d for replacing '%s' with '%s' \n", (int)rc, dstPath, realSrcPath);
  }
  return rc;
}
#define SQLITE_FILE_HEADER_LEN 16
/* Check for a conflicting lock.  If one is found, print an this
 ** on standard output using the format string given and return 1.
 ** If there are no conflicting locks, return 0.
 */

    return -1;
  }
  
  if( lk.l_type!=F_UNLCK && (pid==SQLITE_LOCKSTATE_ANYPID || lk.l_pid==pid) ){
#ifdef SQLITE_DEBUG
    fprintf(stderr, "%s lock held by %d\n", zType, (int)lk.l_pid);
#endif
    OSTRACE(("GETLOCKSTATE fd-%d type-%s, loc-0x%x len-%d pid-(%d) state=ON\n",
             h, zType, iOfst, iCnt, pid));
    return 1;
  } 
  OSTRACE(("GETLOCKSTATE fd-%d type-%s, loc-0x%x len-%d pid-(%d) state=OFF\n",
           h, zType, iOfst, iCnt, pid));
  return 0;
}

static int unixLockstatePid(unixFile *, pid_t, int *);

/*
  ** Copy data from shared-memory into a buffer.
  **
  ** Returns an error if the mapping has disappeared, or if the memory cannot
  ** be accessed safely.
*/
static int unixShmRead(sqlite3_file *fd,               /* The underlying database file */
                       void *dst,                      /* The destination memory */
                       volatile void *src,             /* The source (mapped) memory */
                       sqlite3_int64 nByte             /* Size of the destination */
){
#if defined(__APPLE__)
    unixFile *pDbFd;                /* The underlying database file */

  pDbFd = (unixFile*)fd;

  if ( pDbFd->fsFlags & SQLITE_FSFLAGS_IS_MMAP_SAFE ) {
      memcpy(dst, (void *)src, nByte);
    } else {
        mach_vm_size_t aSz;
        mach_vm_read_overwrite(mach_task_self(), src, nByte, dst, &aSz);
        if ( aSz!=nByte ) {
            return SQLITE_IOERR;
          }
      }
#else
    memcpy(dst, (void *)src, nByte);
#endif

  return SQLITE_OK;
}

int sqlite30sShmRead(sqlite3_file *id, void *dst, volatile void *src, sqlite3_int64 size);

int sqlite30sShmRead(sqlite3_file *id, void *dst, volatile void *src, sqlite3_int64 size){
#if (defined(__APPLE__) && ((!defined(TARGET_OS_EMBEDDED)||(TARGET_OS_EMBEDDED==0))))
        return unixShmRead(id, dst, src, size);
#else
    memcpy(dst, (void *)src, size);
    return SQLITE_OK;
#endif
}

#endif /* (SQLITE_ENABLE_APPLE_SPI>0) && defined(__APPLE__) */


/*
** If *pArg is inititially negative then this is a query.  Set *pArg to
** 1 or 0 depending on whether or not bit mask of pFile->ctrlFlags is set.

      }
      pLockstate = (LockstatePID *)pArg;
      rc = unixLockstatePid(pFile, pLockstate->pid, &(pLockstate->state));
      return rc;
    }
      
#endif /* (SQLITE_ENABLE_APPLE_SPI>0) && defined(__APPLE__) */

    case SQLITE_FCNTL_SET_NEXTFLOCKTIMEOUT: {
#ifdef SQLITE_USE_FLOCKTIMEOUT
      pFile->nextFlockTimeout = *(int*)pArg;
#endif
      return SQLITE_OK;
    }
    case SQLITE_FCNTL_GET_NEXTFLOCKTIMEOUT: {
#ifdef SQLITE_USE_FLOCKTIMEOUT
      *(int*)pArg = pFile->nextFlockTimeout;
#endif
      return SQLITE_OK;
    }

  }
  return SQLITE_NOTFOUND;
}

/*
** Return the sector size in bytes of the underlying block device for
** the specified file. This is almost always 512 bytes, but may be

** otherwise.
*/
static int unixShmSystemLock(
  unixShmNode *pShmNode, /* Apply locks to this open shared-memory segment */
  int lockType,          /* F_UNLCK, F_RDLCK, or F_WRLCK */
  int ofst,              /* First byte of the locking range */
  int n                  /* Number of bytes to lock */
#ifdef SQLITE_USE_FLOCKTIMEOUT
  , int timeout          /* Lock timeout in milliseconds */
#endif
){
  struct flock f;       /* The posix advisory locking structure */
  int rc = SQLITE_OK;   /* Result code form fcntl() */

  /* Access to the unixShmNode object is serialized by the caller */
  assert( sqlite3_mutex_held(pShmNode->mutex) || pShmNode->nRef==0 );

    /* Initialize the locking parameters */
    memset(&f, 0, sizeof(f));
    f.l_type = lockType;
    f.l_whence = SEEK_SET;
    f.l_start = ofst;
    f.l_len = n;

#ifdef SQLITE_USE_FLOCKTIMEOUT
    if( timeout>0 ){
      struct timespec ts;
      struct flocktimeout fltimeout;

      ts.tv_sec = timeout / 1000;
      ts.tv_nsec = (((long)timeout) % 1000L) * 1000000L;
      fltimeout.fl = f;
      fltimeout.timeout = ts;

      rc = osFcntl(pShmNode->h, F_SETLKWTIMEOUT, &fltimeout);
    }else{
      rc = osFcntl(pShmNode->h, F_SETLK, &f);
    }
#else
    rc = osFcntl(pShmNode->h, F_SETLK, &f);
#endif
    rc = (rc!=(-1)) ? SQLITE_OK : SQLITE_BUSY;
  }

  /* Update the global lock state and do debug tracing */
#ifdef SQLITE_DEBUG
  { u16 mask;
  OSTRACE(("SHM-LOCK "));

    const char *zBasePath = pDbFd->zPath;

    /* Call fstat() to figure out the permissions on the database file. If
    ** a new *-shm file is created, an attempt will be made to create it
    ** with the same permissions.
    */
    if( osFstat(pDbFd->h, &sStat) && pInode->bProcessLock==0 ){
      storeLastErrno(pDbFd, errno);
      rc = SQLITE_IOERR_FSTAT;
      goto shm_open_err;
    }

#if defined(__APPLE__) && SQLITE_ENABLE_LOCKING_STYLE
    /* If pDbFd is configured with proxy locking mode, use the local 
     ** lock file path to determine the -shm file path

    || defined(__APPLE__))
         || (pDbFd->openFlags & O_RDWR) != O_RDWR
#endif
         ){
        openFlags = O_RDONLY;
        pShmNode->isReadonly = 1;
      }
      int protFlags = 0;
#if SQLITE_ENABLE_DATA_PROTECTION
      protFlags = shmUnixProtectionClassForVFSProtectionFlags(pDbFd->protFlags);
#endif
      pShmNode->h = robust_open2(zShmFilename, openFlags, (sStat.st_mode&0777), protFlags, 1);

      if( pShmNode->h<0 ){
#if SQLITE_ENABLE_DATA_PROTECTION
        if( errno==EPERM ) {
          rc = unixLogError(SQLITE_AUTH, "open", zShmFilename);
        }else{
          rc = unixLogError(SQLITE_CANTOPEN_BKPT, "open", zShmFilename);
        }
#else
        rc = unixLogError(SQLITE_CANTOPEN_BKPT, "open", zShmFilename);
#endif      
        goto shm_open_err;
      }
#if SQLITE_ENABLE_DATA_PROTECTION
      if( (pDbFd->ctrlFlags&UNIXFILE_RDONLY) == 0 ){
        int shmProtFlags = (pDbFd->protFlags)&SQLITE_OPEN_FILEPROTECTION_MASK;
        
        rc = unixSetFileProtection(pShmNode->h, shmProtFlags, 1);
        if( rc ){
          if( rc==SQLITE_IOERR ){
            storeLastErrno(pDbFd, errno);
          }
          osClose(pShmNode->h);
          goto shm_open_err;
        }
      }
#endif      

      /* Check to see if another process is holding the dead-man switch.
      ** If not, truncate the file to zero length. 
      */
      rc = SQLITE_OK;
#ifdef SQLITE_USE_FLOCKTIMEOUT
      if( unixShmSystemLock(pShmNode, F_WRLCK, UNIX_SHM_DMS, 1, pDbFd->nextFlockTimeout)==SQLITE_OK ){
        pDbFd->nextFlockTimeout = 0;
#else
      if( unixShmSystemLock(pShmNode, F_WRLCK, UNIX_SHM_DMS, 1)==SQLITE_OK ){
#endif
        if( robust_ftruncate(pShmNode->h, 0) ){
          rc = unixLogError(SQLITE_IOERR_SHMOPEN, "ftruncate", zShmFilename);
        }else{
          /* If running as root set the uid/gid of the shm file to match
          ** the database */
          uid_t euid = geteuid();
          if( (!pShmNode->isReadonly) && euid==0 && (euid!=sStat.st_uid || getegid()!=sStat.st_gid) ){
            if( osFchown(pShmNode->h, sStat.st_uid, sStat.st_gid) ){
              rc = SQLITE_IOERR_SHMOPEN;
            }
          }
        }
      }
      if( rc==SQLITE_OK ){
#ifdef SQLITE_USE_FLOCKTIMEOUT
        rc = unixShmSystemLock(pShmNode, F_RDLCK, UNIX_SHM_DMS, 1, pDbFd->nextFlockTimeout);
        if( rc==SQLITE_OK ){
          pDbFd->nextFlockTimeout = 0;
        }
#else
        rc = unixShmSystemLock(pShmNode, F_RDLCK, UNIX_SHM_DMS, 1);
#endif
      }
      if( rc ) goto shm_open_err;
    }
  }

  /* Make the new connection a child of the unixShmNode */
  p->pShmNode = pShmNode;

static int unixShmMap(
  sqlite3_file *fd,               /* Handle open on database file */
  int iRegion,                    /* Region to retrieve */
  int szRegion,                   /* Size of regions */
  int bExtend,                    /* True to extend file if necessary */
  void volatile **pp              /* OUT: Mapped memory */
){
  static int oncethingie = 0;
  
  unixFile *pDbFd = (unixFile*)fd;
  unixShm *p;
  unixShmNode *pShmNode;
  int rc = SQLITE_OK;
  int nShmPerMap = unixShmRegionPerMap();
  int nReqRegion;

      rc = SQLITE_IOERR_NOMEM;
      goto shmpage_out;
    }
    pShmNode->apRegion = apNew;
    while( pShmNode->nRegion<nReqRegion ){
      int nMap = szRegion*nShmPerMap;
      int i;
      void *pMem = NULL;
      if( pShmNode->h>=0 ){
        pMem = osMmap(0, nMap,
            pShmNode->isReadonly ? PROT_READ : PROT_READ|PROT_WRITE, 
            MAP_SHARED, pShmNode->h, szRegion*(i64)pShmNode->nRegion
        );
        
        if( pMem==MAP_FAILED ){
          rc = unixLogError(SQLITE_IOERR_SHMMAP, "mmap", pShmNode->zFilename);
          goto shmpage_out;
        }
      }else{
        pMem = sqlite3_malloc(szRegion);
        if( pMem==0 ){

      if( pX==p ) continue;
      assert( (pX->exclMask & (p->exclMask|p->sharedMask))==0 );
      allMask |= pX->sharedMask;
    }

    /* Unlock the system-level locks */
    if( (mask & allMask)==0 ){
#ifdef SQLITE_USE_FLOCKTIMEOUT
      rc = unixShmSystemLock(pShmNode, F_UNLCK, ofst+UNIX_SHM_BASE, n, pDbFd->nextFlockTimeout);
      if( rc==SQLITE_OK ){
        pDbFd->nextFlockTimeout = 0;
      }
#else
      rc = unixShmSystemLock(pShmNode, F_UNLCK, ofst+UNIX_SHM_BASE, n);
#endif
    }else{
      rc = SQLITE_OK;
    }

    /* Undo the local locks */
    if( rc==SQLITE_OK ){
      p->exclMask &= ~mask;
      p->sharedMask &= ~mask;
    } 
  }else if( flags & SQLITE_SHM_SHARED ){
    u16 allShared = 0;  /* Union of locks held by connections other than "p" */

    /* Find out which shared locks are already held by sibling connections.
    ** If any sibling already holds an exclusive lock, go ahead and return
    ** SQLITE_BUSY.
    */
    for(pX=pShmNode->pFirst; pX; pX=pX->pNext){
      if( (pX->exclMask & mask)!=0 ){
        rc = SQLITE_BUSY;
#ifdef SQLITE_USE_FLOCKTIMEOUT
        if( pDbFd->nextFlockTimeout>0 ){
          usleep(((int)pDbFd->nextFlockTimeout) * 1000L);
        }
#endif
        break;
      }
      allShared |= pX->sharedMask;
    }

    /* Get shared locks at the system level, if necessary */
    if( rc==SQLITE_OK ){
      if( (allShared & mask)==0 ){
#ifdef SQLITE_USE_FLOCKTIMEOUT
        rc = unixShmSystemLock(pShmNode, F_RDLCK, ofst+UNIX_SHM_BASE, n, pDbFd->nextFlockTimeout);
        if( rc==SQLITE_OK ){
          pDbFd->nextFlockTimeout = 0;
        }
#else
        rc = unixShmSystemLock(pShmNode, F_RDLCK, ofst+UNIX_SHM_BASE, n);
#endif
      }else{
        rc = SQLITE_OK;
      }
    }

    /* Get the local shared locks */
    if( rc==SQLITE_OK ){
      p->sharedMask |= mask;
    }
  }else{
    /* Make sure no sibling connections hold locks that will block this
    ** lock.  If any do, return SQLITE_BUSY right away.
    */
    for(pX=pShmNode->pFirst; pX; pX=pX->pNext){
      if( (pX->exclMask & mask)!=0 || (pX->sharedMask & mask)!=0 ){
        rc = SQLITE_BUSY;
#ifdef SQLITE_USE_FLOCKTIMEOUT
        if( pDbFd->nextFlockTimeout>0 ){
          usleep(((int)pDbFd->nextFlockTimeout) * 1000L);
        }
#endif
        break;
      }
    }
  
    /* Get the exclusive locks at the system level.  Then if successful
    ** also mark the local connection as being locked.
    */
    if( rc==SQLITE_OK ){
#ifdef SQLITE_USE_FLOCKTIMEOUT
      rc = unixShmSystemLock(pShmNode, F_WRLCK, ofst+UNIX_SHM_BASE, n, pDbFd->nextFlockTimeout);
      if( rc==SQLITE_OK ){
        pDbFd->nextFlockTimeout = 0;
#else
      rc = unixShmSystemLock(pShmNode, F_WRLCK, ofst+UNIX_SHM_BASE, n);
      if( rc==SQLITE_OK ){
#endif
        assert( (p->sharedMask & mask)==0 );
        p->exclMask |= mask;
      }
    }
  }
  sqlite3_mutex_leave(pShmNode->mutex);
  OSTRACE(("SHM-LOCK shmid-%d, pid-%d got %03x,%03x\n",

** All loads and stores begun before the barrier must complete before
** any load or store begun after the barrier.
*/
static void unixShmBarrier(
  sqlite3_file *fd                /* Database file holding the shared memory */
){
  UNUSED_PARAMETER(fd);
#if defined(__APPLE__)
  OSMemoryBarrier();
#else
  unixEnterMutex();
  unixLeaveMutex();
#endif
}

/*
** Close a connection to shared-memory.  Delete the underlying 
** storage if deleteFlag is true.
**
** If there is no shared memory associated with the connection then this

#endif /* #ifndef SQLITE_OMIT_WAL */

#if (SQLITE_ENABLE_APPLE_SPI>0) && defined(__APPLE__)
static const char *unixTempFileDir(void);

static int unixInvalidateSupportFiles(unixFile *pFile, int skipWAL) {
  char jPath[MAXPATHLEN+9];
  int zLen = (int)strlcpy(jPath, pFile->zPath, MAXPATHLEN+9);
  if( zLen<MAXPATHLEN ){
    size_t jLen;
    const char extensions[3][9] = { "-wal", "-journal", "-shm" };
    int j = (skipWAL ? 1 : 0);
    for( ; j<3; j++ ){
      int isShm = 0;
      
      /* Check to see if the shm file is already opened for this pFile */
      if( j==2 ){
        isShm = 1;
        
        unixEnterMutex(); /* Because pFile->pInode is shared across threads */
        unixShmNode *pShmNode = pFile->pInode->pShmNode;
        if( pShmNode && !pShmNode->isReadonly ){
          struct stat sStat;
          sqlite3_mutex_enter(pShmNode->mutex);
          
          if( pShmNode->h>=0 && !osFstat(pShmNode->h, &sStat) ){

          sqlite3_mutex_leave(pShmNode->mutex);
        }
        unixLeaveMutex();
      }
      jLen = strlcpy(&jPath[zLen], extensions[j], 9);
      if( jLen < 9 ){
        int jflags = (j<2) ? O_TRUNC : O_RDWR;
        int jfd = robust_open2(jPath, jflags, 0, 0, isShm);
        if( jfd==(-1) ){
          if( errno!=ENOENT ){
            perror(jPath);
          }
        } else {
          if( j==2 ){
            struct stat sStat;
            if( !osFstat(jfd, &sStat) ){
              unsigned long size = (sStat.st_size<4) ? sStat.st_size : 4;
              if( size>0 ){
                uint32_t zero = 0;
                
                os_rawPwrite(jfd, &zero, (size_t)size, 0);
              }
            }
          }
          fsync(jfd);
          osClose(jfd);
        }
      }
    }
  }
  return SQLITE_OK;
}

    result = errno;
  }
  if (result) {
    rc = SQLITE_IOERR;
    storeLastErrno(pFile, result);
  }
  
  int fd2 = robust_open2(journalPath, O_RDWR, 0, 0, 0);
  int result2 = 0;
  if (fd2 < 0) {
    if (errno != ENOENT) {
      result2 = errno;
    } else {
      result2 = 0;
    }
  } else {
    result2 = ftruncate(fd2, 0ll);
    if (result2) {
      result2 = errno;
    }
  }
  if (result2 && !result) {
    rc = SQLITE_IOERR;
    storeLastErrno(pFile, result2);
  }
  
  int fd3 = robust_open2(walPath, O_RDWR, 0, 0, 0);
  int result3 = 0;
  if (fd3 < 0) {
    if (errno != ENOENT) {
      result3 = errno;
    } else {
      result3 = 0;
    }
  } else {
    result3 = ftruncate(fd3, 0ll);
    if (result3) {
      result3 = errno;
    }
  }
  if (result3 && !(result || result2)) {
    rc = SQLITE_IOERR;
    storeLastErrno(pFile, result2);
  }
  
  if (fd3 >= 0) {
    fsync(fd3);
    osClose(fd3);
  }
  if (fd2 >= 0) {
    fsync(fd2);
    osClose(fd2);
  }
  
  pFile->pMethod->xSync((sqlite3_file*)pFile, SQLITE_SYNC_FULL);
	
  return rc;
}

static int unixTruncateDatabase(unixFile *pFile, int bFlags) {
  sqlite3_file *id = (sqlite3_file *)pFile;
  int rc = SQLITE_OK;
  Superlock *pLock = NULL;
  int flags = 0;
  int corruptFileLock = 0;
  int isCorrupt = 0;
  int isWal = (bFlags & SQLITE_TRUNCATE_JOURNALMODE_WAL);
  int force = (bFlags & SQLITE_TRUNCATE_FORCE);
  int safeFailed = 0;

#if SQLITE_ENABLE_DATA_PROTECTION
  flags |= pFile->protFlags;
#endif
#if SQLITE_ENABLE_LOCKING_STYLE
  if( isProxyLockingMode(pFile) ){
    flags |= SQLITE_OPEN_AUTOPROXY;
  }
#endif

  const char *tDir = NULL;
  int tDirLen = 0;

  if( (bFlags&SQLITE_TRUNCATE_INITIALIZE_HEADER_MASK)!=0 ){
    tDir = unixTempFileDir();
    tDirLen = tDir ? (int)strlen(tDir) : 0;
    if (tDirLen < 1) {
      _open_error_asl_log();
      asl_log(errorlog_client, NULL, ASL_LEVEL_CRIT, "SQLite: truncate database failed because TMPDIR is not set correctly\n");

      return SQLITE_PERM;
    }
  }
  
  rc = sqlite3demo_superlock(pFile->zPath, 0, flags, 0, 0, (void**)&pLock);
  if( rc ){
    if( rc==SQLITE_CORRUPT || rc==SQLITE_NOTADB ){
      isCorrupt = 1;
      rc = sqlite3demo_superlock_corrupt(id, SQLITE_LOCK_EXCLUSIVE,
                                         &corruptFileLock);
    }
    if( rc && !force ){
      return rc;
    }
    if (!isWal) {
      isWal = (1 == readWALSettingFromFile(pFile));
    }
    rc = SQLITE_OK; /* Ignore the locking failure if force is true */
  } else if (!isWal && (pLock != NULL)) {
    isWal = pLock->bWal;
  }
  
  if( (bFlags&SQLITE_TRUNCATE_INITIALIZE_HEADER_MASK)!=0 ){
    /* initialize a new database in TMPDIR and copy the contents over */


    int tLen = sizeof(char) * (tDirLen + 26);
    char *tDbPath = (char *)calloc(1, tLen);
    int tFd = -1;
    
    strlcpy(tDbPath, tDir, tLen);
    /* create a temporary database with the prefix tmpsqlitetruncatedb */
    if( tDbPath[(tDirLen-1)] != '/' ){
      strlcat(tDbPath, "/", tLen);


    }
    strlcat(tDbPath, "tmpsqlitetruncatedbXXXXXX", tLen);
    tFd = mkstemp(tDbPath);
    if( tFd==-1 ){
      storeLastErrno(pFile, errno);
      rc = SQLITE_IOERR;
      safeFailed = 1;
    }else{
      sqlite3 *tDb = NULL;

      }
      if( tDb ){
        int off = 0;
        /* merge the wal into the db */
        sqlite3_file_control(tDb, NULL, SQLITE_FCNTL_PERSIST_WAL, &off);
        sqlite3_close(tDb);
      }

      s = copyfile_state_alloc();
      lseek(tFd, 0, SEEK_SET);
      lseek(pFile->h, 0, SEEK_SET);
      if( sqlite_guarded_fcopyfile(tFd, pFile->h) != 0 ){
        int err=errno;
        switch(err) {
          case ENOMEM:
            trc = SQLITE_NOMEM;
            break;
          default:
            storeLastErrno(pFile, err);
            trc = SQLITE_IOERR;
        }
      }
      copyfile_state_free(s);
      fsync(pFile->h);
      /* tFd is created with mkstemp, can't use guarded close() */
      close(tFd);
      unlink(tDbPath);
      if( trc!=SQLITE_OK ){
        safeFailed = 1;
        rc = trc;
      }
    }
    if (tDbPath) {
      free(tDbPath);
    }
  } else {
    rc = pFile->pMethod->xTruncate(id, 
           ((pFile->fsFlags & SQLITE_FSFLAGS_IS_MSDOS) != 0) ? 1L : 0L);
    if( rc ){
      safeFailed = 1;
    }
  }

    assert(force);
  }
  
  if( force && safeFailed){
    rc = unixUnsafeTruncateDatabase(pFile);
  }
  
  if (rc) {
    _open_error_asl_log();
    const char* dstPath = pFile ? pFile->zPath : "<dst db null>";
    
    if (dstPath == NULL) {
      dstPath = "<dst path null>";
    }

    asl_log(errorlog_client, NULL, ASL_LEVEL_ERR, "SQLite: unixTruncateDatabase() failed with %d for replacing '%s' with flags %x\n", rc, dstPath, flags);
  }

  return rc;
}

/*
 ** Lock locations for shared-memory locks used by WAL mode.
 */
#ifndef SHM_BASE

*/
static int unixLockstatePid(unixFile *pFile, pid_t pid, int *pLockstate){
  int hDb;        /* File descriptor for the open database file */
  int hShm = -1;  /* File descriptor for WAL shared-memory file */
  ssize_t got;    /* Bytes read from header */
  int isWal = 0;             /* True if in WAL mode */
  int nLock = 0;             /* Number of locks held */
  int npLock = 0;            /* Number of potential locks held */
  int noHdr = 0;             /* Zero byte DB has no header */
  unsigned char aHdr[100];   /* Database header */
  
  assert(pLockstate);
  
  /* make sure we are dealing with a database file */
  hDb = pFile->h;
  if( hDb<0 ){
    *pLockstate = SQLITE_LOCKSTATE_ERROR;
    return SQLITE_ERROR;
  }
  
  /* First check for an exclusive lock */
  nLock += unixIsLocked(pid, hDb, F_RDLCK, SHARED_FIRST, SHARED_SIZE,
                        "EXCLUSIVE");
  npLock += unixIsLocked(pid, hDb, F_WRLCK, PENDING_BYTE, SHARED_SIZE+2,
                        "PENDING|RESERVED|SHARED");
  if( nLock==0 && npLock==0 ){
    *pLockstate = SQLITE_LOCKSTATE_OFF;
    return SQLITE_OK;
  }
  
  assert( (strlen(SQLITE_FILE_HEADER)+1)==SQLITE_FILE_HEADER_LEN );
  got = pread(hDb, aHdr, 100, 0);
  if( got<0 ){
    *pLockstate = SQLITE_LOCKSTATE_ERROR;
    return SQLITE_ERROR;
  }
  if( got==0 ){
    noHdr = 1;
  }else if( got!=100
         || memcmp(aHdr, SQLITE_FILE_HEADER, SQLITE_FILE_HEADER_LEN)!=0
  ){
    *pLockstate = SQLITE_LOCKSTATE_NOTADB;
    return SQLITE_NOTADB;
  }
  



  if (!noHdr) {
    isWal = aHdr[18]==2;
  }
  if( nLock==0 && isWal==0 ){
    /* Rollback mode */
    nLock += npLock;

  }
  if( nLock==0 && isWal!=0 ){
    /* lookup the file descriptor for the shared memory file if we have it open
    ** in this process */
    unixEnterMutex(); /* Because pFile->pInode is shared across threads */
    unixShmNode *pShmNode = pFile->pInode->pShmNode;
    if( pShmNode ){

      /* the shared memory file isn't open in this process space, open our
      ** own FD */
      char zShm[MAXPATHLEN];
      
      /* WAL mode */
      strlcpy(zShm, pFile->zPath, MAXPATHLEN);
      strlcat(zShm, "-shm", MAXPATHLEN);
      hShm = robust_open2(zShm, O_RDONLY, 0, 0, 1);
      if( hShm<0 ){
        *pLockstate = SQLITE_LOCKSTATE_OFF;
        unixLeaveMutex();
        return SQLITE_OK;
      }
      if( unixIsLocked(pid, hShm, F_RDLCK, SHM_RECOVER, 1, "WAL-RECOVERY") ||
         unixIsLocked(pid, hShm, F_RDLCK, SHM_WRITE, 1, "WAL-WRITE") ){
        nLock = 1;
      }
      osClose(hShm);
    }
    unixLeaveMutex();
  }
  if( nLock>0 ){
    *pLockstate = SQLITE_LOCKSTATE_ON;
  } else {
    *pLockstate = SQLITE_LOCKSTATE_OFF;

     0,
     0,
     "/var/tmp",
     "/usr/tmp",
     "/tmp",
     0        /* List terminator */
  };
  
  unsigned int i;
  struct stat buf;
  const char *zDir = 0;

  azDirs[0] = sqlite3_temp_directory;
  if( !azDirs[1] ) azDirs[1] = getenv("SQLITE_TMPDIR");
  if( !azDirs[2] ){
#if defined(__APPLE__)
    char *path = malloc(PATH_MAX);
    size_t pathLen = 0;
    path[0] = '\0';
    pathLen = confstr(_CS_DARWIN_USER_TEMP_DIR, path, PATH_MAX);
    if (pathLen > 0) {
      azDirs[2] = path;
    } else {
      free(path);
      path = NULL;
    }
#else
    azDirs[2] = getenv("TMPDIR");
#endif
  }
  for(i=0; i<sizeof(azDirs)/sizeof(azDirs[0]); zDir=azDirs[i++]){
    if( zDir==0 ) continue;
    if( osStat(zDir, &buf) ) continue;
    if( !S_ISDIR(buf.st_mode) ) continue;
    if( osAccess(zDir, R_OK|W_OK|X_OK) ) continue;
    break;
  }
  
  if (!zDir) {
    _open_error_asl_log();
    asl_log(errorlog_client, NULL, ASL_LEVEL_CRIT, "SQLite: No temporary directory is accessible.  This is not a legitimate configuration.  Either the process environment or its sandbox is misconfigured.  Various library routines will error out abruptly.\n");
  }
  return zDir;
}

/*
** Create a temporary file name in zBuf.  zBuf must be allocated
** by the calling process and must be big enough to hold at least
** pVfs->mxPathname bytes.

    }
  }else if( flags & SQLITE_OPEN_DELETEONCLOSE ){
    *pMode = 0600;
  }
  return rc;
}

  
#if defined(__APPLE__)
  
static int _copyUserHomeDirectory(char* userhomedirectory, int bufferSize) {
  uid_t euid;
  gid_t gid;
  
  if (0 != pthread_getugid_np(&euid, &gid)) {
    euid = 0;
  }

  int bufsize;
  if ((bufsize = sysconf(_SC_GETPW_R_SIZE_MAX)) == -1) {
      return 0;
  }
  char buffer[bufsize];
  struct passwd upwd, *result = NULL;
    
  if (getpwuid_r((euid ? euid : getuid()), &upwd, buffer, bufsize, &result) != 0 || !result) {
      return 0;
  }

  const char *homePath = NULL;
    
  if (upwd.pw_dir && (strlen(upwd.pw_dir)) > 0) {
    homePath = upwd.pw_dir;
  }
  if (!homePath) {
    char* t = getenv("HOME");
    if (t && (strlen(t) > 0)) {
      homePath = t;
    }
  }

  if (homePath) {
    strlcpy(userhomedirectory, homePath, bufferSize);
    return 1;
  }
  
  return 0;
}
  
  
static int _canSafelyMapFileDescriptor(struct statfs *fs) {
#if (!defined(TARGET_OS_EMBEDDED)||(TARGET_OS_EMBEDDED==0))
  static int userhomedirinited = 0;
  static fsid_t *userhomedirid = NULL;
  static fsid_t underlyinghomedirid;
  static OSSpinLock underlyinghomelock = OS_SPINLOCK_INIT;
  
  //Network volumes are never safe to mmap
  int isNetworkVolume = (MNT_LOCAL != (fs->f_flags & MNT_LOCAL));
  if (isNetworkVolume) {
    return 0;
  }
  
  //The root volume shouldn't be removeable
  int isRootVolume = (MNT_ROOTFS == (fs->f_flags & MNT_ROOTFS));
  if (isRootVolume) {
    return 1;
  }

  OSMemoryBarrier();
  if (userhomedirinited == 0) {
    OSSpinLockLock(&underlyinghomelock);
    
    char apath[MAXPATHLEN+1];
    bzero(apath, MAXPATHLEN+1);

    if (getuid() != 0) {
      if (0 != _copyUserHomeDirectory(apath, MAXPATHLEN)) {
        if (strlen(apath) > 0) {
          struct statfs userfs;
          
          if (statfs(apath, &userfs) == 0) {
            if (0 != (userfs.f_flags & MNT_LOCAL)) {
              fsid_t tests;
              bzero(&tests, sizeof(fsid_t));

              if (memcmp(&tests, &(userfs.f_fsid), sizeof(fsid_t)) != 0) {
                memcpy(&underlyinghomedirid, &(userfs.f_fsid), sizeof(fsid_t));
                
                // if the user is not root, their home directory is local and the f_fsid field is accessible
                userhomedirid = &underlyinghomedirid;
              }
            }
          }
        }
      }
    }
    
    userhomedirinited = 1;

    OSSpinLockUnlock(&underlyinghomelock);
  }
  
  if (userhomedirid != NULL) {
    if (memcmp(userhomedirid, &(fs->f_fsid), sizeof(fsid_t)) == 0) {
      return 1;
    }
  }
  return 0;
#else
  return 1;
#endif
  }
#endif
  
/*
** Open the file zPath.
** 
** Previously, the SQLite OS layer used three functions in place of this
** one:
**
**     sqlite3OsOpenReadWrite();

  int eType = flags&0xFF0FFF00;  /* Type of file to open */
#else
  int eType = flags&0xFFFFFF00;  /* Type of file to open */
#endif
  int noLock;                    /* True to omit locking primitives */
  int rc = SQLITE_OK;            /* Function Return Code */
  int ctrlFlags = 0;             /* UNIXFILE_* flags */
  int protClass = 0;

  int isExclusive  = (flags & SQLITE_OPEN_EXCLUSIVE);
  int isDelete     = (flags & SQLITE_OPEN_DELETEONCLOSE);
  int isCreate     = (flags & SQLITE_OPEN_CREATE);
  int isReadonly   = (flags & SQLITE_OPEN_READONLY);
  int isReadWrite  = (flags & SQLITE_OPEN_READWRITE);
#if SQLITE_ENABLE_LOCKING_STYLE
  int isAutoProxy  = (flags & SQLITE_OPEN_AUTOPROXY);
#endif
#if defined(__APPLE__) || SQLITE_ENABLE_LOCKING_STYLE
  struct statfs fsInfo;
#endif
  
  int isShm = 0;
  
  /* If creating a master or main-file journal, this function will open
  ** a file-descriptor on the directory too. The first time unixSync()
  ** is called the directory file descriptor will be fsync()ed and close()d.
  */
  int syncDir = (isCreate && (
        eType==SQLITE_OPEN_MASTER_JOURNAL 
     || eType==SQLITE_OPEN_MAIN_JOURNAL 

  if( isReadWrite ) openFlags |= O_RDWR;
  if( isCreate )    openFlags |= O_CREAT;
  if( isExclusive ) openFlags |= (O_EXCL|O_NOFOLLOW);
  openFlags |= (O_LARGEFILE|O_BINARY);

#if SQLITE_ENABLE_DATA_PROTECTION
  p->protFlags = (flags & SQLITE_OPEN_FILEPROTECTION_MASK);
  protClass = (!isShm) ? unixProtectionClassForVFSProtectionFlags((flags & SQLITE_OPEN_FILEPROTECTION_MASK)) : shmUnixProtectionClassForVFSProtectionFlags((flags & SQLITE_OPEN_FILEPROTECTION_MASK));
#endif
    
  if( fd<0 ){
    mode_t openMode;              /* Permissions to create file with */
    uid_t uid;                    /* Userid for the file */
    gid_t gid;                    /* Groupid for the file */
    rc = findCreateFileMode(zName, flags, &openMode, &uid, &gid);
    if( rc!=SQLITE_OK ){
      assert( !p->pUnused );
      assert( eType==SQLITE_OPEN_WAL || eType==SQLITE_OPEN_MAIN_JOURNAL );
      return rc;
    }
    fd = robust_open2(zName, openFlags, openMode, protClass, isShm);
    OSTRACE(("OPENX   %-3d %s 0%o\n", fd, zName, openFlags));
    if( fd<0 && errno!=EISDIR && isReadWrite && !isExclusive ){
      /* Failed to open the file for read/write access. Try read-only. */
      flags &= ~(SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE);
      openFlags &= ~(O_RDWR|O_CREAT);
      flags |= SQLITE_OPEN_READONLY;
      openFlags |= O_RDONLY;
      isReadonly = 1;
      fd = robust_open2(zName, openFlags, openMode, protClass, isShm);
    }
    if( fd<0 ){
#if SQLITE_ENABLE_DATA_PROTECTION
      if( errno==EPERM ){
        /* <rdar://problem/9385939> Test device locked state when error reporting for content protection issues */
        rc = unixLogError(SQLITE_AUTH, "open", zName);
      }else{
        rc = unixLogError(SQLITE_CANTOPEN_BKPT, "open", zName);
      }
#else
      rc = unixLogError(SQLITE_CANTOPEN_BKPT, "open", zName);
#endif
      goto open_finished;
    }

    /* if we're opening the wal or journal and running as root, set the
    ** journal uid/gid */
    if( !isReadonly && (flags & (SQLITE_OPEN_WAL|SQLITE_OPEN_MAIN_JOURNAL)) ){
      uid_t euid = geteuid();
      if( euid==0 && (euid!=uid || getegid()!=gid) ){
        if( osFchown(fd, uid, gid) ){
          rc = SQLITE_CANTOPEN_BKPT;
          goto open_finished;
        }
      }
    }
  }
#if SQLITE_ENABLE_DATA_PROTECTION
  if( !isReadonly ){
    rc = unixSetFileProtection(fd, p->protFlags, isShm);
    if( rc ){
      if( rc!=SQLITE_AUTH ){
        rc =SQLITE_CANTOPEN_BKPT;
      }
      osClose(fd);
      goto open_finished;
    }
  }
#endif
  assert( fd>=0 );
  if( pOutFlags ){
    *pOutFlags = flags;
  }

  if( p->pUnused ){
    p->pUnused->fd = fd;

  }
  if (0 == strncmp("msdos", fsInfo.f_fstypename, 5)) {
    ((unixFile*)pFile)->fsFlags |= SQLITE_FSFLAGS_IS_MSDOS;
  }
  if (0 == strncmp("exfat", fsInfo.f_fstypename, 5)) {
    ((unixFile*)pFile)->fsFlags |= SQLITE_FSFLAGS_IS_MSDOS;
  }
  if (fsInfo.f_flags & MNT_ROOTFS) {
    ((unixFile*)pFile)->fsFlags |= SQLITE_FSFLAGS_IS_MMAP_SAFE;
  } else {
#if defined(__APPLE__)
    if (_canSafelyMapFileDescriptor(&fsInfo)) {
      ((unixFile*)pFile)->fsFlags |= SQLITE_FSFLAGS_IS_MMAP_SAFE;
    }
#endif
  }
#if defined(__APPLE__)
  /* <rdar://problem/17742712> */
  ((unixFile*)pFile)->nFsBytes = (i64)fsInfo.f_blocks * (i64)fsInfo.f_bsize;
#endif
#endif

  /* Set up appropriate ctrlFlags */
  if( isDelete )                ctrlFlags |= UNIXFILE_DELETE;
  if( isReadonly )              ctrlFlags |= UNIXFILE_RDONLY;
  if( noLock )                  ctrlFlags |= UNIXFILE_NOLOCK;
  if( syncDir )                 ctrlFlags |= UNIXFILE_DIRSYNC;

    int useProxy = 0;

    /* SQLITE_FORCE_PROXY_LOCKING==1 means force always use proxy, 0 means 
    ** never use proxy, NULL means use proxy for non-local files only.  */
    if( envforce!=NULL ){
      useProxy = atoi(envforce)>0;
    }else{
      useProxy = !((fsInfo.f_flags&MNT_LOCAL) || (fsInfo.f_flags&MNT_RDONLY));
    }
    if( useProxy ){
      rc = fillInUnixFile(pVfs, fd, pFile, zPath, ctrlFlags);
      if( rc==SQLITE_OK ){
        /* cache the pMethod in case the transform fails */
        const struct sqlite3_io_methods *pMethod = pFile->pMethods;
        rc = proxyTransformUnixFile((unixFile*)pFile, ":auto:");

#else
      if( fsync(fd) )
#endif
      {
        rc = unixLogError(SQLITE_IOERR_DIR_FSYNC, "fsync", zPath);
      }
#if OSCLOSE_CHECK_CLOSE_IOERR
      if( osClose(fd)&&!rc ){
        rc = SQLITE_IOERR_DIR_CLOSE;
      }
#else
      robust_close(0, fd, __LINE__);
#endif
    }else if( rc==SQLITE_CANTOPEN ){
      rc = SQLITE_OK;

#ifndef SQLITE_OMIT_LOAD_EXTENSION
/*
** Interfaces for opening a shared library, finding entry points
** within the shared library, and closing the shared library.
*/
#include <dlfcn.h> /* amalgamator: keep */
static void *unixDlOpen(sqlite3_vfs *NotUsed, const char *zFilename){
  UNUSED_PARAMETER(NotUsed);
  return dlopen(zFilename, RTLD_NOW | RTLD_GLOBAL);
}

/*
** SQLite calls this function immediately after a call to unixDlSym() or

  ** tests repeatable.
  */
  memset(zBuf, 0, nBuf);
  randomnessPid = getpid();  
#if !defined(SQLITE_TEST)
  {
    int fd, got;
    fd = robust_open("/dev/urandom", O_RDONLY, 0, 0);
    if( fd<0 ){
      time_t t;
      time(&t);
      memcpy(zBuf, &t, sizeof(t));
      memcpy(&zBuf[sizeof(t)], &randomnessPid, sizeof(randomnessPid));
      assert( sizeof(t)+sizeof(randomnessPid)<=(size_t)nBuf );
      nBuf = sizeof(t) + sizeof(randomnessPid);
    }else{
      do{ got = (int)osRead(fd, zBuf, nBuf); }while( got<0 && errno==EINTR );
      robust_close(0, fd, __LINE__);
    }
  }
#endif
  return nBuf;
}

};

/* 
** The proxy lock file path for the database at dbPath is written into lPath, 
** which must point to valid, writable memory large enough for a maxLen length
** file path. 
*/
static int proxyGetLockPath(const char *dbPath, char *lockPath, size_t maxLen){
  int len;
  int dbLen;
  int i;
  int tooBig;
  int nameMax;
#ifdef LOCKPROXYDIR
  len = strlcpy(lockPath, LOCKPROXYDIR, maxLen);
#else
# ifdef _CS_DARWIN_USER_TEMP_DIR
  {
    if( !confstr(_CS_DARWIN_USER_TEMP_DIR, lockPath, maxLen) ){
      OSTRACE(("GETLOCKPATH  failed %s errno=%d pid=%d\n",
               lockPath, errno, getpid()));
      return SQLITE_IOERR_LOCK;
    }
    len = (int)strlcat(lockPath, "sqliteplocks", maxLen);
  }
# else
  len = strlcpy(lockPath, "/tmp/", maxLen);
# endif
#endif

  if( lockPath[len-1]!='/' ){
    len = (int)strlcat(lockPath, "/", maxLen);
  }
    
  /* 
  ** transform the db path to a unique cache name.
  ** By default this simply turns '/'s into '_'s,
  ** but if the resulting path would exceed maxLen, hash the
  ** path and create a subpath like:
  **   <SHA-256 hash>-<database filename>:auto:
  */
  dbLen = (int)strlen(dbPath);
  tooBig = ( (dbLen+len+7) > maxLen ) ? 1 : 0;
#if defined(NAME_MAX)
  nameMax = NAME_MAX;
#else
  nameMax = 255;
#endif
  
#if defined(__APPLE__)
  if( tooBig || (nameMax<(dbLen+7)) ){
    CC_SHA256_CTX ctx;
    unsigned char shabytes[CC_SHA256_DIGEST_LENGTH];
    char shahex[CC_SHA256_DIGEST_LENGTH * 2 + 2];
    
    CC_SHA256_Init (&ctx);
    CC_SHA256_Update (&ctx, dbPath, dbLen);
    CC_SHA256_Final (shabytes, &ctx);
    
    /* render the hash into the path as chars [0-9][a-f] */
    for( i=0; i<CC_SHA256_DIGEST_LENGTH; i++ ){
      unsigned char byte = shabytes[i];
      shahex[i*2] = '0' + (byte >> 4);
      if (shahex[i*2] > '9'){
        shahex[i*2] += 'a' - '9' - 1;
      }
      shahex[i*2+1] = '0' + (byte & 0xf);
      if (shahex[i*2+1] > '9'){
        shahex[i*2+1] += 'a' - '9' - 1;
      }
    }
    shahex[CC_SHA256_DIGEST_LENGTH * 2] = '-';
    shahex[CC_SHA256_DIGEST_LENGTH * 2 + 1] = 0;
    
    strlcat(lockPath, shahex, maxLen);
    
    /* tack on the actual database name for discoverability */
    const char *dbName = strrchr (dbPath, '/');
    if (!dbName){
      dbName = dbPath;
    }else{
      ++dbName;
    }
    
    strlcat(lockPath, dbName, maxLen);
  }else{
#endif
    int pos = len;
    for( i=0; i<dbLen; i++){
      char c = dbPath[i];
      /* collapse "./" and "/./" patterns */
      if( (dbLen>(i+2)) && (dbPath[i]=='.') && (dbPath[i+1]=='/') &&
         ((i==0) || dbPath[i-1]=='/') ){
        i ++; /* skips 2 */
        continue;
      }
      
      lockPath[pos] = (c=='/')?'_':c;
      pos++;
    }
    lockPath[pos]='\0';
#if defined(__APPLE__)
  }
#endif
  strlcat(lockPath, ":auto:", maxLen);
  OSTRACE(("GETLOCKPATH  proxy lock path=%s pid=%d\n", lockPath, getpid()));
  return SQLITE_OK;
}

/* 
 ** Creates the lock file and any missing directories in lockPath
 */
static int proxyCreateLockPath(const char *lockPath){

  proxyLockingContext *pCtx;
  unixFile *pLockFile;
  
  assert(pFile!=NULL && pFile->lockingContext!=NULL);
  assert(pFile->pMethod == &proxyIoMethods);
  pCtx = ((proxyLockingContext *)(pFile->lockingContext));
  pLockFile = pCtx->lockProxy;
  
  if (pLockFile) {
    if( pLockFile->pMethod->iVersion>=2 && pLockFile->pMethod->xShmMap!=0 ){
      return pCtx->lockProxyPath;
    }
  }

  return NULL;
}
#endif

/*
** Create a new VFS file descriptor (stored in memory obtained from
** sqlite3_malloc) and open the file named "path" in the file descriptor.
**
** The caller is responsible not only for closing the file descriptor
** but also for freeing the memory associated with the file descriptor.
*/
static int proxyCreateUnixFile(
    const char *path,        /* path for the new unixFile */
    unixFile **ppFile,       /* unixFile created and returned by ref */
    int islockfile           /* if non zero missing dirs will be created */
) {
  int fd = -1;
  unixFile *pNew;
  int rc = SQLITE_OK;
  int openFlags = O_RDWR | O_CREAT;
  int sqliteFlags = SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE;
  sqlite3_vfs dummyVfs;
  int terrno = 0;
  UnixUnusedFd *pUnused = NULL;

  /* 1. first try to open/create the file
  ** 2. if that fails, and this is a lock file (not-conch), try creating
  ** the parent directories and then try again.
  ** 3. if that fails, try to open the file read-only
  ** otherwise return BUSY (if lock file) or CANTOPEN for the conch file
  */
  pUnused = findReusableFd(path, sqliteFlags);
  if( pUnused ){
    fd = pUnused->fd;
  }else{
    pUnused = sqlite3_malloc(sizeof(*pUnused));
    if( !pUnused ){
      return SQLITE_NOMEM;
    }
  }
  if( fd<0 ){
    fd = robust_open2(path, openFlags, 0, 0,0);
    terrno = errno;
    if( fd<0 && errno==ENOENT && islockfile ){
      if( proxyCreateLockPath(path) == SQLITE_OK ){
        fd = robust_open2(path, openFlags, 0, 0, 0);
      }
    }
  }
  if( fd<0 ){
    openFlags = O_RDONLY;
    sqliteFlags = SQLITE_OPEN_READONLY;
    fd = robust_open2(path, openFlags, 0, 0, 0);
    terrno = errno;
  }
  if( fd<0 ){
    sqlite3_free(pUnused);
    if( islockfile ){
      return SQLITE_BUSY;
    }

  }
  memset(pNew, 0, sizeof(unixFile));
  pNew->openFlags = openFlags;
  memset(&dummyVfs, 0, sizeof(dummyVfs));
  dummyVfs.pAppData = (void*)&autolockIoFinder;
  dummyVfs.zName = "dummy";
  pUnused->fd = fd;
  pUnused->flags = sqliteFlags;
  pNew->pUnused = pUnused;
  
  rc = fillInUnixFile(&dummyVfs, fd, (sqlite3_file*)pNew, path, 0);
  if( rc==SQLITE_OK ){
    *ppFile = pNew;
    return SQLITE_OK;
  }

#ifdef SQLITE_TEST
/* simulate multiple hosts by creating unique hostid file paths */
int sqlite3_hostid_num = 0;
#endif

#define PROXY_HOSTIDLEN    16  /* conch file host id length */

#if HAVE_GETHOSTUUID
/* Not always defined in the headers as it ought to be */
extern int gethostuuid(uuid_t id, const struct timespec *wait);
#endif
  
/* get the host ID via gethostuuid(), pHostID must point to PROXY_HOSTIDLEN 
** bytes of writable memory.
*/
static int proxyGetHostID(unsigned char *pHostID, int *pError){
  assert(PROXY_HOSTIDLEN == sizeof(uuid_t));
  memset(pHostID, 0, PROXY_HOSTIDLEN);
#if HAVE_GETHOSTUUID

  /* read the conch content */
  readLen = osPread(conchFile->h, buf, PROXY_MAXCONCHLEN, 0);
  if( readLen<PROXY_PATHINDEX ){
    sqlite3_snprintf(sizeof(errmsg),errmsg,"read error (len %d)",(int)readLen);
    goto end_breaklock;
  }
  /* write it out to the temporary break file */
  fd = robust_open2(tPath, (O_RDWR|O_CREAT|O_EXCL), 0, 0, 0);
  if( fd<0 ){
    sqlite3_snprintf(sizeof(errmsg), errmsg, "create failed (%d)", errno);
    goto end_breaklock;
  }
  if( osPwrite(fd, buf, readLen, 0) != (ssize_t)readLen ){
    sqlite3_snprintf(sizeof(errmsg), errmsg, "write failed (%d)", errno);
    goto end_breaklock;

      if( conchModTime.tv_sec != buf.st_mtimespec.tv_sec || 
         conchModTime.tv_nsec != buf.st_mtimespec.tv_nsec ){
        return SQLITE_BUSY;
      }
      
      if( pCtx->nFails==2 ){  
        char tBuf[PROXY_MAXCONCHLEN];
        int len = (int)osPread(conchFile->h, tBuf, PROXY_MAXCONCHLEN, 0);
        if( len<0 ){
          storeLastErrno(pFile, errno);
          return SQLITE_IOERR_LOCK;
        }
        if( len>PROXY_PATHINDEX && tBuf[0]==(char)PROXY_CONCHVERSION){
          /* don't break the lock if the host id doesn't match, but do log
           * an error to console so users can diagnose stale NFS locks more 

      ** stick.
      */
      futimes(conchFile->h, NULL);
      if( hostIdMatch && !createConch ){
        if( conchFile->pInode && conchFile->pInode->nShared>1 ){
          /* We are trying for an exclusive lock but another thread in this
           ** same process is still holding a shared lock. */
#ifdef SQLITE_USE_FLOCKTIMEOUT
          if( pFile->nextFlockTimeout>0 ){
            usleep(((int)pFile->nextFlockTimeout) * 1000L);
          }
#endif
          rc = SQLITE_BUSY;
        } else {          
          rc = proxyConchLock(pFile, myHostID, EXCLUSIVE_LOCK);
        }
      }else{
        rc = proxyConchLock(pFile, myHostID, EXCLUSIVE_LOCK);
      }
      if( rc==SQLITE_OK ){
        char writeBuffer[PROXY_MAXCONCHLEN];
        int writeSize = 0;
        
        writeBuffer[0] = (char)PROXY_CONCHVERSION;
        memcpy(&writeBuffer[PROXY_HEADERLEN], myHostID, PROXY_HOSTIDLEN);
        if( pCtx->lockProxyPath!=NULL ){
          strlcpy(&writeBuffer[PROXY_PATHINDEX], pCtx->lockProxyPath,
                  MAXPATHLEN);
        }else{
          strlcpy(&writeBuffer[PROXY_PATHINDEX], tempLockPath, MAXPATHLEN);
        }
        writeSize = PROXY_PATHINDEX + (int)strlen(&writeBuffer[PROXY_PATHINDEX]);
        robust_ftruncate(conchFile->h, writeSize);
        rc = unixWrite((sqlite3_file *)conchFile, writeBuffer, writeSize, 0);
        fsync(conchFile->h);
        /* If we created a new conch file (not just updated the contents of a 
         ** valid conch file), try to match the permissions of the database 
         */
        if( rc==SQLITE_OK && createConch ){

      
    end_takeconch:
      OSTRACE(("TRANSPROXY: CLOSE  %d\n", pFile->h));
      if( rc==SQLITE_OK && pFile->openFlags ){
        int fd;
        if( pFile->h>=0 ){
#if defined(STRICT_CLOSE_ERROR) && OSCLOSE_CHECK_CLOSE_IOERR
          if( osClose(pFile->h) ){
            storeLastErrno(pFile, errno);
            return SQLITE_IOERR_CLOSE;
          }
#else
          robust_close(pFile, pFile->h, __LINE__);
#endif
        }
        pFile->h = -1;
        fd = robust_open2(pCtx->dbPath, pFile->openFlags, 0, 0, 0);
        OSTRACE(("TRANSPROXY: OPEN  %d\n", fd));
        if( fd>=0 ){
          pFile->h = fd;
        }else{
          rc=SQLITE_CANTOPEN_BKPT; /* SQLITE_BUSY? proxyTakeConch called
           during locking */
        }

*/
static int switchLockProxyPath(unixFile *pFile, const char *path) {
  proxyLockingContext *pCtx = (proxyLockingContext*)pFile->lockingContext;
  char *oldPath = pCtx->lockProxyPath;
  int rc = SQLITE_OK;

  if( pFile->eFileLock!=NO_LOCK ){
#ifdef SQLITE_USE_FLOCKTIMEOUT
    if( pFile->nextFlockTimeout>0 ){
      usleep(((int)pFile->nextFlockTimeout) * 1000L);
    }
#endif
    return SQLITE_BUSY;
  }  

  /* nothing to do if the path is NULL, :auto: or matches the existing path */
  if( !path || path[0]=='\0' || !strcmp(path, ":auto:") ||
    (oldPath && !strncmp(oldPath, path, MAXPATHLEN)) ){
    return SQLITE_OK;

    strlcpy(dbPath, ((afpLockingContext *)pFile->lockingContext)->dbPath,
            MAXPATHLEN);
  } else
#endif
  if( pFile->pMethod == &dotlockIoMethods ){
    /* dot lock style uses the locking context to store the dot lock
    ** file path */
    long len = strlen((char *)pFile->lockingContext) - strlen(DOTLOCK_SUFFIX);
    memcpy(dbPath, (char *)pFile->lockingContext, len + 1);
  }else{
    /* all other styles use the locking context to store the db file path */
    assert( strlen((char*)pFile->lockingContext)<=MAXPATHLEN );
    strlcpy(dbPath, (char *)pFile->lockingContext, MAXPATHLEN);
  }
  return SQLITE_OK;

static int proxyTransformUnixFile(unixFile *pFile, const char *path) {
  proxyLockingContext *pCtx;
  char dbPath[MAXPATHLEN+1];       /* Name of the database file */
  char *lockPath=NULL;
  int rc = SQLITE_OK;
  
  if( pFile->eFileLock!=NO_LOCK ){
#ifdef SQLITE_USE_FLOCKTIMEOUT
    if( pFile->nextFlockTimeout>0 ){
      usleep(((int)pFile->nextFlockTimeout) * 1000L);
    }
#endif
    return SQLITE_BUSY;
  }
  getDbPathForUnixFile(pFile, dbPath);
  if( !path || path[0]=='\0' || !strcmp(path, ":auto:") ){
    lockPath=NULL;
  }else{
    lockPath=(char *)path;

** file simultaneously, or one process from reading the database while
** another is writing.
*/
#ifndef SQLITE_OMIT_DISKIO
#include "sqliteInt.h"
#include "wal.h"

extern void pthread_yield_np(void);

/******************* NOTES ON THE DESIGN OF THE PAGER ************************
**
** This comment block describes invariants that hold when using a rollback
** journal.  These invariants do not apply for journal_mode=WAL,
** journal_mode=MEMORY, or journal_mode=OFF.
**

  ** sqlite3PagerSetBusyhandler().
  */
  assert( (pPager->eLock>=locktype)
       || (pPager->eLock==NO_LOCK && locktype==SHARED_LOCK)
       || (pPager->eLock==RESERVED_LOCK && locktype==EXCLUSIVE_LOCK)
  );

  int i = 0;
  int c = 0;
  do {
    rc = pagerLockDb(pPager, locktype);
    c = ( rc==SQLITE_BUSY && pPager->xBusyHandler(pPager->pBusyHandlerArg) );
    if (c && (i > 0)) {
      pthread_yield_np();
    }
    i++;
  }while( c );
  
  return rc;
}

/*
** Function assertTruncateConstraint(pPager) checks that one of the 
** following is true for all dirty pages currently in the page-cache:
**

** of the SQLITE_CONFIG_PAGECACHE and sqlite3_release_memory() features.
** If the default page cache implementation is overriden, then neither of
** these two features are available.
*/

#include "sqliteInt.h"

#if !defined(SQLITE_OMIT_PCACHE1_PCACHE)

typedef struct PCache1 PCache1;
typedef struct PgHdr1 PgHdr1;
typedef struct PgFreeslot PgFreeslot;
typedef struct PGroup PGroup;

/* Each page cache (or PCache) belongs to a PGroup.  A PGroup is a set 
** of one or more PCaches that are able to recycle each others unpinned

  }
  *pnCurrent = pcache1.grp.nCurrentPage;
  *pnMax = (int)pcache1.grp.nMaxPage;
  *pnMin = (int)pcache1.grp.nMinPage;
  *pnRecyclable = nRecyclable;
}
#endif

#endif /* SQLITE_OMIT_PCACHE1_PCACHE */

      }
#endif /* SQLITE_OMIT_WSD */
    }
    break;
  }
#endif

#if !defined(SQLITE_ENABLE_LOCKING_STYLE)
#  if defined(__APPLE__)
#    define SQLITE_ENABLE_LOCKING_STYLE 1
#  else
#    define SQLITE_ENABLE_LOCKING_STYLE 0
#  endif
#endif
#if SQLITE_ENABLE_LOCKING_STYLE
  /*
  **   PRAGMA [database.]lock_proxy_file
  **   PRAGMA [database.]lock_proxy_file = ":auto:"|"lock_file_path"
  **
  ** Return or set the value of the lock_proxy_file flag.  Changing
  ** the value sets a specific file to be used for database access locks.

  char *zFirstCmd = 0;
  int i;
  int rc = 0;
  int warnInmemoryDb = 0;

#if USE_SYSTEM_SQLITE+0!=1
  if( strcmp(sqlite3_sourceid(),SQLITE_SOURCE_ID)!=0 ){
    fprintf(stderr, "\nWARNING!  SQLite header and source version mismatch"
            "\n  source: %s\n  header: %s\n\n",
            sqlite3_sourceid(), SQLITE_SOURCE_ID);
    /* exit(1); */
  }
#endif
  Argv0 = argv[0];
  main_init(&data);
  stdin_is_interactive = isatty(0);

  /* Make sure we have a valid signal handler early, before anything

** would generate warning messages when they were used.  But that
** compiler magic ended up generating such a flurry of bug reports
** that we have taken it all out and gone back to using simple
** noop macros.
*/
#define SQLITE_DEPRECATED
#define SQLITE_EXPERIMENTAL
#ifndef __OSX_AVAILABLE_BUT_DEPRECATED
#define __OSX_AVAILABLE_BUT_DEPRECATED(MacOSAvailable, MacOSDeprecated, iPhoneOSAvailable, iPhoneOSDeprecated)
#endif

/*
** Ensure these symbols were not defined by some previous header file.
*/
#ifdef SQLITE_VERSION
# undef SQLITE_VERSION
#endif

#define SQLITE_OPEN_SUBJOURNAL       0x00002000  /* VFS only */
#define SQLITE_OPEN_MASTER_JOURNAL   0x00004000  /* VFS only */
#define SQLITE_OPEN_NOMUTEX          0x00008000  /* Ok for sqlite3_open_v2() */
#define SQLITE_OPEN_FULLMUTEX        0x00010000  /* Ok for sqlite3_open_v2() */
#define SQLITE_OPEN_SHAREDCACHE      0x00020000  /* Ok for sqlite3_open_v2() */
#define SQLITE_OPEN_PRIVATECACHE     0x00040000  /* Ok for sqlite3_open_v2() */
#define SQLITE_OPEN_WAL              0x00080000  /* VFS only */
#define SQLITE_OPEN_FILEPROTECTION_COMPLETE                             0x00100000
#define SQLITE_OPEN_FILEPROTECTION_COMPLETEUNLESSOPEN                   0x00200000
#define SQLITE_OPEN_FILEPROTECTION_COMPLETEUNTILFIRSTUSERAUTHENTICATION 0x00300000
#define SQLITE_OPEN_FILEPROTECTION_NONE                                 0x00400000
#define SQLITE_OPEN_FILEPROTECTION_MASK                                 0x00700000

/* Reserved:                         0x00F00000 */

/*
** CAPI3REF: Device Characteristics
**

** sqlite3_open_v2 with SQLITE_OPEN_SHAREDCACHE instead.
**
** This interface is threadsafe on processors where writing a
** 32-bit integer is atomic.
**
** See Also:  [SQLite Shared-Cache Mode]
*/
int sqlite3_enable_shared_cache(int) __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_7, __IPHONE_2_0, __IPHONE_5_0);

/*
** CAPI3REF: Attempt To Free Heap Memory
**
** ^The sqlite3_release_memory() interface attempts to free N bytes
** of heap memory by deallocating non-essential memory allocations
** held by the database library.   Memory used to cache database

/*
 *  sqlite3_private.h
 */

#ifndef _SQLITE3_PRIVATE_H
#define _SQLITE3_PRIVATE_H

#include <unistd.h>
#include <sqlite3.h>

#define SQLITE_LOCKSTATE_OFF    0
#define SQLITE_LOCKSTATE_ON     1
#define SQLITE_LOCKSTATE_NOTADB 2
#define SQLITE_LOCKSTATE_ERROR  -1

#define SQLITE_LOCKSTATE_ANYPID -1

** Test an open database connection for sqlite locks held by a process ID,
** if a process has an open database connection this will avoid trashing file
** locks by re-using open file descriptors for the database file and support
** files (-shm)
*/
#define SQLITE_FCNTL_LOCKSTATE_PID          103

/*
** Purges eligible purgable memory regions (holding only unpinned pages) from 
** the page cache
*/
extern void _sqlite3_purgeEligiblePagerCacheMemory(void);

/*
** Returns the system defined default sqlite3_busy_handler function
** 
*/
extern int (*_sqlite3_system_busy_handler(void))(void*,int);

/*
** Pass the SQLITE_TRUNCATE_DATABASE operation code to sqlite3_file_control() 
** to truncate a database and its associated journal file to zero length.  The 
** SQLITE_TRUNCATE_* flags represent optional flags to safely initialize an
** empty database in the place of the truncated database, the flags are passed 
** into sqlite3_file_control via the fourth argument using a pointer to an integer
** configured with the ORed flags.  If the fourth argument is NULL, the default 

#include "sqlite3.h"

/*
** Include the configuration header output by 'configure' if we're using the
** autoconf-based build
*/
#ifdef _HAVE_SQLITE_CONFIG_H
# ifdef _MSC_VER
#include "win_config.h" /* hand-mantained windows variant */
# else
#include "config.h"
# endif
#endif

#include "sqliteLimit.h"

/* Disable nuisance warnings on Borland compilers */
#if defined(__BORLANDC__)
#pragma warn -rch /* unreachable code */

** SQLITE_CONFIG_MEMSTATUS are available by default or not. This value can
** be overridden at runtime using the sqlite3_config() API.
*/
#if !defined(SQLITE_DEFAULT_MEMSTATUS)
# define SQLITE_DEFAULT_MEMSTATUS 1
#endif

/*
** The SQLITE_ENABLE_PURGEABLE_PCACHE sets the default pcache to 
** pcache_purgeable, otherwise pcache1 is used.
*/
#if !defined(SQLITE_ENABLE_PURGEABLE_PCACHE)
# define SQLITE_OMIT_PURGEABLE_PCACHE
#else
# define SQLITE_OMIT_PCACHE1_PCACHE
#endif

/*
** Exactly one of the following macros must be defined in order to
** specify which memory allocation subsystem to use.
**
**     SQLITE_SYSTEM_MALLOC          // Use normal system malloc()
**     SQLITE_WIN32_MALLOC           // Use Win32 native heap API
**     SQLITE_ZERO_MALLOC            // Use a stub allocator that always fails

                     Tcl_GetStringFromObj(Tcl_NewIntObj(iArg), 0), " ", 0);
    return TCL_ERROR;
  }
  return TCL_OK;  
}

#ifdef __APPLE__
/* From sqlite3_private.h */
# ifndef SQLITE_TRUNCATE_DATABASE
# define SQLITE_TRUNCATE_DATABASE      101
# define SQLITE_TRUNCATE_JOURNALMODE_WAL           (0x1<<0)
# define SQLITE_TRUNCATE_AUTOVACUUM_MASK           (0x3<<2)
# define SQLITE_TRUNCATE_AUTOVACUUM_OFF            (0x1<<2)
# define SQLITE_TRUNCATE_AUTOVACUUM_FULL           (0x2<<2)
# define SQLITE_TRUNCATE_AUTOVACUUM_INCREMENTAL    (0x3<<2)
# define SQLITE_TRUNCATE_PAGESIZE_MASK             (0x7<<4)
# define SQLITE_TRUNCATE_PAGESIZE_1024             (0x1<<4)
# define SQLITE_TRUNCATE_PAGESIZE_2048             (0x2<<4)
# define SQLITE_TRUNCATE_PAGESIZE_4096             (0x3<<4)
# define SQLITE_TRUNCATE_PAGESIZE_8192             (0x4<<4)
# endif
# ifndef SQLITE_REPLACE_DATABASE
# define SQLITE_REPLACE_DATABASE       102
# endif
# ifndef SQLITE_FCNTL_LOCKSTATE_PID
#  define SQLITE_FCNTL_LOCKSTATE_PID          103
#  define SQLITE_LOCKSTATE_OFF    0
#  define SQLITE_LOCKSTATE_ON     1
#  define SQLITE_LOCKSTATE_NOTADB 2
#  define SQLITE_LOCKSTATE_ERROR  -1
#  define SQLITE_LOCKSTATE_ANYPID -1
extern int _sqlite3_lockstate(const char *path, pid_t pid);
# endif

/*
** tclcmd:   file_control_truncate_test DB
**
** This TCL command runs the sqlite3_file_control interface and
** verifies correct operation of the SQLITE_TRUNCATE_DATABASE verb.
*/

*/
static int file_control_replace_test(
  ClientData clientData, /* Pointer to sqlite3_enable_XXX function */
  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
  int objc,              /* Number of arguments */
  Tcl_Obj *CONST objv[]  /* Command arguments */
){

  sqlite3 *src_db;
  sqlite3 *dst_db;
  int rc;
  
  if( objc!=3 ){
    Tcl_AppendResult(interp, "wrong # args: should be \"",
                     Tcl_GetStringFromObj(objv[0], 0), " DST_DB SRC_DB", 0);

  rc = sqlite3_file_control(dst_db, NULL, SQLITE_REPLACE_DATABASE, src_db);
  if( rc ){ 
    Tcl_SetObjResult(interp, Tcl_NewIntObj(rc)); 
    return TCL_ERROR; 
  }
  return TCL_OK;  
}

/*
** tclcmd:   file_control_lockstate_test DBNAME PID
**
** This TCL command runs the _sqlite3_lockstate interface and
** verifies correct operation of the SQLITE_FCNTL_LOCKSTATE_PID verb.
*/
static int file_control_lockstate_test(
  ClientData clientData, /* Pointer to sqlite3_enable_XXX function */
  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
  int objc,              /* Number of arguments */
  Tcl_Obj *CONST objv[]  /* Command arguments */
){
  char *zDb;
  int pid = -1;
  int state;
  
  if( objc!=3 ){
    Tcl_AppendResult(interp, "wrong # args: should be \"",
                     Tcl_GetStringFromObj(objv[0], 0), " DBNAME PID", 0);
    return TCL_ERROR;
  }
  if( Tcl_GetIntFromObj(interp, objv[2], &pid) ){
    return TCL_ERROR;
  }
  zDb = Tcl_GetString(objv[1]);
  if( zDb[0]=='\0' ) zDb = NULL;
  if( !zDb ){
    return TCL_ERROR;
  }
  state = _sqlite3_lockstate(zDb, pid);
  Tcl_SetObjResult(interp, Tcl_NewIntObj(state));
  return TCL_OK;
}
#endif /* __APPLE__ */

/*
** tclcmd:   file_control_chunksize_test DB DBNAME SIZE
**
** This TCL command runs the sqlite3_file_control interface and
** verifies correct operation of the SQLITE_GET_LOCKPROXYFILE and

     { "vfs_reregister_all",         vfs_reregister_all,  0   },
     { "file_control_test",          file_control_test,   0   },
     { "file_control_lasterrno_test", file_control_lasterrno_test,  0   },
     { "file_control_lockproxy_test", file_control_lockproxy_test,  0   },
#ifdef __APPLE__
     { "file_control_truncate_test", file_control_truncate_test,  0   },
     { "file_control_replace_test", file_control_replace_test,  0   },
     { "file_control_lockstate_test", file_control_lockstate_test,  0   },
#endif 
     { "file_control_chunksize_test", file_control_chunksize_test,  0   },
     { "file_control_sizehint_test",  file_control_sizehint_test,   0   },
#if SQLITE_OS_WIN
     { "file_control_win32_av_retry", file_control_win32_av_retry,  0   },
     { "file_control_win32_set_handle", file_control_win32_set_handle, 0  },
#endif

  Tcl_SetVar2(interp, "sqlite_options", "tclvar", "1", TCL_GLOBAL_ONLY);
#endif

  Tcl_SetVar2(interp, "sqlite_options", "threadsafe", 
      STRINGVALUE(SQLITE_THREADSAFE), TCL_GLOBAL_ONLY);
  assert( sqlite3_threadsafe()==SQLITE_THREADSAFE );

#if defined(USETHREADASSERTS)
  Tcl_SetVar2(interp,"sqlite_options","use_thread_asserts","1",TCL_GLOBAL_ONLY);
#else
  Tcl_SetVar2(interp,"sqlite_options","use_thread_asserts","0",TCL_GLOBAL_ONLY);
#endif
  
#ifdef SQLITE_OMIT_TEMPDB
  Tcl_SetVar2(interp, "sqlite_options", "tempdb", "0", TCL_GLOBAL_ONLY);
#else
  Tcl_SetVar2(interp, "sqlite_options", "tempdb", "1", TCL_GLOBAL_ONLY);
#endif

#ifdef SQLITE_OMIT_TRACE

*/
#ifndef SQLITE_OMIT_VIRTUALTABLE

/*
** Free an sqlite3_intarray object.
*/
static void intarrayFree(sqlite3_intarray *p){
  if( p->xFree && p->a){
    p->xFree(p->a);
    p->a = NULL;
  }
  sqlite3_free(p);
}

/*
** Table destructor for the intarray module.
*/

  sqlite3_intarray *pIntArray,   /* The intarray object to bind to */
  int nElements,                 /* Number of elements in the intarray */
  sqlite3_int64 *aElements,      /* Content of the intarray */
  void (*xFree)(void*)           /* How to dispose of the intarray when done */
){
  if( pIntArray->xFree ){
    pIntArray->xFree(pIntArray->a);
    pIntArray->a = NULL;
  }
  pIntArray->n = nElements;
  pIntArray->a = aElements;
  pIntArray->xFree = xFree;
  return SQLITE_OK;
}

    }
    zBlob[i/2] = 0;
  }
  return zBlob;
}
#endif /* !SQLITE_OMIT_BLOB_LITERAL || SQLITE_HAS_CODEC */

#if defined(__APPLE__) && (defined(USETHREADASSERTS) || defined(SQLITE_DEBUG))
__private_extern__ char* __crashreporter_info__ = NULL;
static const char* _defaultMessage_ = "\n SQLite: Fatal multithreading error in caller.  Illegal multi-threaded access to the same database connection.\n";
#define HALT_CATCH_FIRE() { __crashreporter_info__ = (char*)_defaultMessage_; __builtin_trap(); }
#else
#define HALT_CATCH_FIRE()
#endif

/*
** Log an error that is an API call on a connection pointer that should
** not have been used.  The "type" of connection pointer is given as the
** argument.  The zType is a word like "NULL" or "closed" or "invalid".
*/
static void logBadConnection(const char *zType){
  sqlite3_log(SQLITE_MISUSE, 

  }
  magic = db->magic;
  if( magic!=SQLITE_MAGIC_OPEN ){
    if( sqlite3SafetyCheckSickOrOk(db) ){
      testcase( sqlite3GlobalConfig.xLog!=0 );
      logBadConnection("unopened");
    }
#if defined(USETHREADASSERTS) || defined(SQLITE_DEBUG)
    if (magic==SQLITE_MAGIC_BUSY) {
      HALT_CATCH_FIRE();
    }
#endif
    return 0;
  }else{
    return 1;
  }
}
int sqlite3SafetyCheckSickOrOk(sqlite3 *db){
  u32 magic;

  }
}
#define TWOPOWER32 (((i64)1)<<32)
#define TWOPOWER31 (((i64)1)<<31)
int sqlite3MulInt64(i64 *pA, i64 iB){
  i64 iA = *pA;
  i64 iA1, iA0, iB1, iB0, r;
#undef HALT_CATCH_FIRE

  iA1 = iA/TWOPOWER32;
  iA0 = iA % TWOPOWER32;
  iB1 = iB/TWOPOWER32;
  iB0 = iB % TWOPOWER32;
  if( iA1==0 ){
    if( iB1==0 ){

  int rc = SQLITE_OK;
  int nName;

  sqlite3_mutex_enter(db->mutex);
  nName = sqlite3Strlen30(zName);
  if( sqlite3HashFind(&db->aModule, zName, nName) ){
    rc = SQLITE_MISUSE_BKPT;
    // <rdar://problem/11777852>
    if (strncmp("fts", zName, 3) == 0) {
      xDestroy = NULL;
      rc = SQLITE_OK;
    }
  }else{
    Module *pMod;
    pMod = (Module *)sqlite3DbMallocRaw(db, sizeof(Module) + nName + 1);
    if( pMod ){
      Module *pDel;
      char *zCopy = (char *)(&pMod[1]);
      memcpy(zCopy, zName, nName+1);

  assert( iDb>=0 );

  pTable->tabFlags |= TF_Virtual;
  pTable->nModuleArg = 0;
  addModuleArgument(db, pTable, sqlite3NameFromToken(db, pModuleName));
  addModuleArgument(db, pTable, 0);
  addModuleArgument(db, pTable, sqlite3DbStrDup(db, pTable->zName));
  if (pName2 && pName2->z) {
    pParse->sNameToken.n = (int)(&pModuleName->z[pModuleName->n] - pName2->z);
  } else {
    pParse->sNameToken.n = (int)(&pModuleName->z[pModuleName->n] - pName1->z);
  }

#ifndef SQLITE_OMIT_AUTHORIZATION
  /* Creating a virtual table invokes the authorization callback twice.
  ** The first invocation, to obtain permission to INSERT a row into the
  ** sqlite_master table, has already been made by sqlite3StartTable().
  ** The second call, to obtain permission to create the table, is made now.
  */

  u32 iDbpage = 0;                /* Next database page to write */
  u32 iFrame = 0;                 /* Wal frame containing data for iDbpage */
  u32 mxSafeFrame;                /* Max frame that can be backfilled */
  u32 mxPage;                     /* Max database page to write */
  int i;                          /* Loop counter */
  volatile WalCkptInfo *pInfo;    /* The checkpoint status information */
  int (*xBusy)(void*) = 0;        /* Function to call when waiting for locks */
#if defined(__APPLE__)
  /* <rdar://problem/17742712> */
  i64 szDbFile;                   /* File size of the database, in bytes */
  i64 szWalFile;                  /* File size of the wal, in bytes */
#endif

  szPage = walPagesize(pWal);
  testcase( szPage<=32768 );
  testcase( szPage>=65536 );
  pInfo = walCkptInfo(pWal);
  if( pInfo->nBackfill>=pWal->hdr.mxFrame ) return SQLITE_OK;

#if defined(__APPLE__)
  /* <rdar://problem/17742712> */
  /* Get the size of the db and wal files to sanity check write offsets. */
  rc = sqlite3OsFileSize(pWal->pDbFd, &szDbFile);
  if( rc!=SQLITE_OK ){
      return rc;
  }
  rc = sqlite3OsFileSize(pWal->pWalFd, &szWalFile);
  if( rc!=SQLITE_OK ){
      return rc;
  }
#endif

  /* Allocate the iterator */
  rc = walIteratorInit(pWal, &pIter);
  if( rc!=SQLITE_OK ){
    return rc;
  }
  assert( pIter );

      if( iFrame<=nBackfill || iFrame>mxSafeFrame || iDbpage>mxPage ) continue;
      iOffset = walFrameOffset(iFrame, szPage) + WAL_FRAME_HDRSIZE;
      /* testcase( IS_BIG_INT(iOffset) ); // requires a 4GiB WAL file */
      rc = sqlite3OsRead(pWal->pWalFd, zBuf, szPage, iOffset);
      if( rc!=SQLITE_OK ) break;
      iOffset = (iDbpage-1)*(i64)szPage;
      testcase( IS_BIG_INT(iOffset) );
      
#if defined(__APPLE__)
      /* <rdar://problem/17742712> */
      /* DEBUG(numist): this is way, way more conservative than the checks in
      ** the seekAndRead/seekAndWrite functions. I'm not even 100% sure that
      ** it's not overconservative, but db storage is more efficient than wal
      ** storage, so I'm pretty confident that writes to the db should never
      ** exceed dbsize +_ walsize.
      */
      if( iOffset>(szDbFile+szWalFile) ){
        __builtin_trap();
      }
      /* Update the db file size if the file will grow due to the write. */
      if( iOffset+szPage > szDbFile ){
        szDbFile = iOffset+szPage;
      }
#endif
      
      rc = sqlite3OsWrite(pWal->pDbFd, zBuf, szPage, iOffset);
      if( rc!=SQLITE_OK ) break;
    }

    /* If work was actually accomplished... */
    if( rc==SQLITE_OK ){
      if( mxSafeFrame==walIndexHdr(pWal)->mxFrame ){

    WALTRACE(("WAL%p: closed\n", pWal));
    sqlite3_free((void *)pWal->apWiData);
    sqlite3_free(pWal);
  }
  return rc;
}

#ifndef SQLITE_AMALGAMATION
extern int sqlite30sShmRead(sqlite3_file *id, void *dst, volatile void *src, sqlite3_int64 size);
#endif

/*
** Try to read the wal-index header.  Return 0 on success and 1 if
** there is a problem.
**
** The wal-index is in shared memory.  Another thread or process might
** be writing the header at the same time this procedure is trying to
** read it, which might result in inconsistency.  A dirty read is detected

** If the checksum cannot be verified return non-zero. If the header
** is read successfully and the checksum verified, return zero.
*/
static int walIndexTryHdr(Wal *pWal, int *pChanged){
  u32 aCksum[2];                  /* Checksum on the header content */
  WalIndexHdr h1, h2;             /* Two copies of the header content */
  WalIndexHdr volatile *aHdr;     /* Header in shared memory */
  int rc = SQLITE_OK;

  /* The first page of the wal-index must be mapped at this point. */
  assert( pWal->nWiData>0 && pWal->apWiData[0] );

  /* Read the header. This might happen concurrently with a write to the
  ** same area of shared memory on a different CPU in a SMP,
  ** meaning it is possible that an inconsistent snapshot is read
  ** from the file. If this happens, return non-zero.
  **
  ** There are two copies of the header at the beginning of the wal-index.
  ** When reading, read [0] first then [1].  Writes are in the reverse order.
  ** Memory barriers are used to prevent the compiler or the hardware from
  ** reordering the reads and writes.
  */
  aHdr = walIndexHdr(pWal);
  if( aHdr==NULL ){
    return 1; /* Shouldn't be getting NULL from walIndexHdr, but we are */
  }
  
  rc = sqlite30sShmRead(pWal->pDbFd, &h1, &aHdr[0], sizeof(h1));
  if ( rc!=SQLITE_OK ) {
    return rc;
  }

  walShmBarrier(pWal);

  rc = sqlite30sShmRead(pWal->pDbFd, &h2, &aHdr[1], sizeof(h2));
  if ( rc!=SQLITE_OK ) {
    return rc;
  }

  if( memcmp(&h1, &h2, sizeof(h1))!=0 ){
    return 1;   /* Dirty read */
  }  
  if( h1.isInit==0 ){
    return 1;   /* Malformed header - probably all zeros */
  }

  /* Write all frames into the log file exactly once */
  for(p=pList; p; p=p->pDirty){
    int nDbSize;   /* 0 normally.  Positive == commit flag */
    iFrame++;
    assert( iOffset==walFrameOffset(iFrame, szPage) );
    nDbSize = (isCommit && p->pDirty==0) ? nTruncate : 0;
    rc = walWriteOneFrame(&w, p, nDbSize, iOffset);
    if( rc ) {
#if defined(SQLITE_WRITE_WALFRAME_PREBUFFERED)
      free(w.aFrameBuf);
      w.aFrameBuf = NULL;
#endif
      return rc;
    }
    pLast = p;
    iOffset += szFrame;
  }

  /* If this is the end of a transaction, then we might need to pad
  ** the transaction and/or sync the WAL file.
  **

  */
  if( isCommit && (sync_flags & WAL_SYNC_TRANSACTIONS)!=0 ){
    if( pWal->padToSectorBoundary ){
      int sectorSize = sqlite3SectorSize(pWal->pWalFd);
      w.iSyncPoint = ((iOffset+sectorSize-1)/sectorSize)*sectorSize;
      while( iOffset<w.iSyncPoint ){
        rc = walWriteOneFrame(&w, pLast, nTruncate, iOffset);
        if( rc ) {
#if defined(SQLITE_WRITE_WALFRAME_PREBUFFERED)
          free(w.aFrameBuf);
          w.aFrameBuf = NULL;
#endif
          return rc;
        }
        iOffset += szFrame;
        nExtra++;
      }
    }else{
      rc = sqlite3OsSync(w.pFd, sync_flags & SQLITE_SYNC_MASK);
    }
  }

#if defined(SQLITE_WRITE_WALFRAME_PREBUFFERED)
  free(w.aFrameBuf);
  w.aFrameBuf = NULL;
#endif
  /* If this frame set completes the first transaction in the WAL and
  ** if PRAGMA journal_size_limit is set, then truncate the WAL to the
  ** journal size limit, if possible.
  */
  if( isCommit && pWal->truncateOnCommit && pWal->mxWalSize>=0 ){
    i64 sz = pWal->mxWalSize;

set skipwaltests [expr {
  [permutation]=="journaltest" || [permutation]=="inmemory_journal"
}]
ifcapable !wal { set skipwaltests 1 }
if {![wal_is_ok]} { set skipwaltests 1 }

if {!$skipwaltests} {
  set shmpath test.db-shm
  if {[forced_proxy_locking]} {
    set shmpath [execsql { pragma lock_proxy_file }]-shm
    #puts $shmpath
  }
  db close
  forcedelete test.db
  ifcapable enable_persist_wal {
    forcedelete test.db-journal
    forcedelete test.db-wal
    forcedelete $shmpath
  }
  if {[forced_proxy_locking]} { 
    forcedelete .test.db-conch
  }
  sqlite3 db test.db
  ifcapable enable_persist_wal {
    file_control_persist_wal db 0

  } {1}
  catch { db2 close }


  # test proxy locking readonly file system handling
  #

  if {[path_is_local "."]&&[file exists /usr/bin/hdiutil]} {

    puts "Creating readonly file system for proxy locking tests..."
    if {[file exists /Volumes/readonly]} {
      exec hdiutil detach /Volumes/readonly
    }
    if {[file exists readonly.dmg]} {
      file delete readonly.dmg

      mutex_counters counters
  
      set res [list]
      foreach {key value} [array get counters] {
        if {$key ne "total" && $value > 0} {
          lappend res $key
        }
      }
      ifcapable {use_thread_asserts} {
        if { $mode == "multithread" } {
          # USETHREADASSERTS changes the multithread mutexes to serialized
          set res [lsort $mutexes]
        }
      }
      lsort $res
    } [lsort $mutexes]
  }
  sqlite3_enable_shared_cache $enable_shared_cache

  # Open and use a connection in "nomutex" mode. Test that no recursive

} 

test_suite "coverage-pager" -description {
  Coverage tests for file pager.c.
} -files {
  pager1.test    pager2.test  pagerfault.test  pagerfault2.test
  walfault.test  walbak.test  journal2.test    tkt-9d68c883.test
test_suite "coverage-analyze" -description {
} 


  Coverage tests for file analyze.c.
} -files {
  analyze3.test analyze4.test analyze5.test analyze6.test
  analyze7.test analyze8.test analyze9.test analyzeA.test
  analyze.test analyzeB.test mallocA.test
} 

    execsql "PRAGMA lock_proxy_file='$lpp6'" 
    set lockpath4 [execsql {
      create table if not exists aa(bb);
      PRAGMA lock_proxy_file;
    } db]
    string match "*proxytest/sub/dir/lock" $lockpath4
  } {1}

  # make sure we can deal with long (> NAME_MAX) file paths correctly
  db close
  set db_longroot [exec mktemp -d -t "longdbpath"]
  set db_longpath $db_longroot/123456789/223456789/323456789/423456789/523456789/623456789/723456789/823456789/923456789/a23456789/b23456789/c23456789/d23456789/e23456789/f23456789/g23456789/h23456789/i23456789/j23456789/k23456789/l23456789/m23456789/n23456789/o23456789/p23456789/q23456789
  file mkdir $db_longpath
  do_test pragma-16.10.4.1 {
    sqlite3 db $db_longpath/longtest.db
    execsql "PRAGMA lock_proxy_file=':auto:'"
    set lockpath_long [execsql {
      create table if not exists aa(bb);
      PRAGMA lock_proxy_file;
    } db]
    #puts $db_longpath
    #puts $lockpath_long
    set lockPathLen [string len $lockpath_long]
    set dbPathLen [string len $db_longpath]
    set lockName [string range $lockpath_long [string last / $lockpath_long] $lockPathLen]
    set nameLength [string len $lockName]
    list [expr "$dbPathLen > 256"] [expr "$lockPathLen < 1024"] [expr "$nameLength < 256"] [expr "$lockPathLen > 7"] [expr "$nameLength > 7"]
  } {1 1 1 1 1}
  file delete -force $db_longroot
  file delete -force $lockpath_long

  # ensure that if the path can not be created (perm), setting :auto: deals
  db close
  file delete -force $lpp5d
  do_test pragma-16.10.5 {
    sqlite3 db proxytest.db
    execsql "PRAGMA lock_proxy_file='$lpp5'" 

  set wal2 [read_content ${file2}-wal]
  write_content ${file1}-wal $wal2
  write_content ${file2}-wal $wal1

  unlock1
  unlock2
}

sqlite3 db  test.db
file_control_persist_wal db 0
db close
sqlite3 db2  test.db2
file_control_persist_wal db2 0
db2 close

forcedelete test.db
sqlite3 db  test.db
file_control_persist_wal db 0
do_execsql_test 6.1 {
  ATTACH 'test.db2' AS aux;
  PRAGMA aux.journal_mode = wal;
  CREATE TABLE aux.t2(x, y);
  INSERT INTO aux.t2 VALUES('a', 'b');
  PRAGMA schema_version = 450;
  DETACH aux;

  PRAGMA main.journal_mode = wal;
  CREATE TABLE t1(a, b);
  INSERT INTO t1 VALUES(1, 2);
  INSERT INTO t1 VALUES(3, 4);
  SELECT * FROM t1;
} {wal wal 1 2 3 4}

sqlite3 db2  test.db2
file_control_persist_wal db2 0
db2 close

db_swap test.db2 test.db
do_catchsql_test 6.2 { SELECT * FROM t1 } {1 {no such table: t1}}
do_catchsql_test 6.3 { SELECT * FROM t2 } {0 {a b}}

db_swap test.db2 test.db
do_catchsql_test 6.4 { SELECT * FROM t1 } {0 {1 2 3 4}}

do_multiclient_test tn {
  
  # Close all connections and delete the database.
  #
  code1 { db close  }
  code2 { db2 close }
  code3 { db3 close }
  forcedelete test.db $shmpath
  forcedelete walro
  
  # Do not run tests with the connections in the same process.
  #
  if {$tn==2} continue

  foreach c {code1 code2 code3} {

  } {SQLITE_READONLY_RECOVERY}

  #-----------------------------------------------------------------------
  # Test cases 1.4.* check that checkpoints and log wraps don't prevent
  # read-only connections from reading the database.
  do_test 1.4.1 {
    code1 { db close }
    forcedelete $shmpath
    file exists $shmpath
  } {0}

  # Open one read-only and one read-write connection. Write some data
  # and then run a checkpoint using the read-write connection. Then
  # check the read-only connection can still read.
  do_test 1.4.2 {
    code1 { sqlite3 db file:test.db?readonly_shm=1 }

forcedelete test.db

#-----------------------------------------------------------------------
# Test cases 2.* check that a read-only connection may read the
# database file while a checkpoint operation is ongoing.
#
do_multiclient_test tn {
  # Do not run tests with the connections in the same process.
  #
  if {$tn==2} continue
  
  # Close all connections and delete the database.
  #
  code1 { db close  }
  code2 { db2 close }
  code3 { db3 close }
  forcedelete test.db

   rtree.h
   sqlite3ext.h
   sqlite3.h
   sqliteicu.h
   sqliteInt.h
   sqliteLimit.h
   sqlrr.h
   test_intarray.h
   vdbe.h
   vdbeInt.h
   wal.h
   whereInt.h
   sqlite3_private.h
} {
  set available_hdr($hdr) 1
}
set available_hdr(sqliteInt.h) 0

# 78 stars used for comment formatting.
set s78 \

   os_unix.c
   os_win.c

   bitvec.c
   pcache.c
   pcache1.c
   pcache_purgeable.c
   rowset.c
   pager.c
   wal.c

   btmutex.c
   btree.c
   backup.c

   fts3_unicode.c
   fts3_unicode2.c

   rtree.c
   icu.c
   fts3_icu.c
   sqlrr.c
   test_intarray.c
} {
  copy_file tsrc/$file
}

close $out

#/bin/sh
#
# Run this script in a directory with a working makefile to check for 
# compiler warnings in SQLite.
#
rm -f sqlite3.c
make sqlite3.c

# Apple-specific defines used for platform specific feature support
DEFINES="-DSQLITE_OMIT_LOAD_EXTENSION=1 -DSQLITE_ENABLE_LOCKING_STYLE=1 -DSQLITE_ENABLE_AUTO_PROFILE=1 -DUSE_PREAD=1 -DSQLITE_THREADSAFE=2 -DSQLITE_MAX_LENGTH=2147483645 -DSQLITE_MAX_VARIABLE_NUMBER=500000 -DSQLITE_ENABLE_APPLE_SPI=1 -DHAVE_USLEEP=1 -DSQLITE_OMIT_AUTORESET=1 -DSQLITE_ENABLE_PURGEABLE_PCACHE=1 -DSQLITE_DEFAULT_CKPTFULLFSYNC=1 -DSQLITE_DEFAULT_WAL_SAFETYLEVEL=2 -DSQLITE_USE_URI=1 -DSQLITE_WRITE_WALFRAME_PREBUFFERED=1 -DSQLITE_ENABLE_PERSIST_WAL=1 -DUSE_GUARDED_FD=1 -DSQLITE_ENABLE_FLOCKTIMEOUT=1 -DSQLITE_OMIT_BUILTIN_TEST=1 -DSQLITE_DEFAULT_MEMSTATUS=0 -DSQLITE_DEFAULT_PAGE_SIZE=4096 -DSQLITE_DEFAULT_JOURNAL_SIZE_LIMIT=32768 -DSQLITE_DEFAULT_CACHE_SIZE=500 -DSQLITE_ENABLE_RTREE=1 -DSQLITE_ENABLE_FTS3=1 -DSQLITE_ENABLE_FTS3_PARENTHESIS=1"

echo '********** No optimizations.  Includes FTS4 and RTREE *********'
gcc -c -Wshadow -Wall -Wextra -Weverything -Wno-long-long -std=c89 \
      -ansi $DEFINES -DHAVE_STDINT_H -DSQLITE_ENABLE_FTS4 -DSQLITE_ENABLE_RTREE \
      sqlite3.c
echo '********** No optimizations. ENABLE_STAT4. THREADSAFE=0 *******'
gcc -c -Wshadow -Wall -Wextra -Weverything -Wno-long-long -std=c89 \
      -ansi $DEFINES -DSQLITE_ENABLE_STAT4 -DSQLITE_THREADSAFE=0 \
      sqlite3.c
echo '********** Optimized -O3.  Includes FTS4 and RTREE ************'
gcc -O3 -c -Wshadow -Wall -Wextra -Weverything -Wno-long-long -std=c89 \
      -ansi $DEFINES -DHAVE_STDINT_H -DSQLITE_ENABLE_FTS4 -DSQLITE_ENABLE_RTREE \
      sqlite3.c