/*

 ** 2004 May 22

 **

 ** The author disclaims copyright to this source code.  In place of

 ** a legal notice, here is a blessing:

 **

 **    May you do good and not evil.

 **    May you find forgiveness for yourself and forgive others.

 **    May you share freely, never taking more than you give.

 **

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

 **

 ** This file contains code that is specific to windows.

 */

 #include "sqliteInt.h"

 #if OS_WIN               /* This file is used for windows only */

 /*

 ** A Note About Memory Allocation:

 **

 ** This driver uses malloc()/free() directly rather than going through

 ** the SQLite-wrappers sqlite3_malloc()/sqlite3_free().  Those wrappers

 ** are designed for use on embedded systems where memory is scarce and

 ** malloc failures happen frequently.  Win32 does not typically run on

 ** embedded systems, and when it does the developers normally have bigger

 ** problems to worry about than running out of memory.  So there is not

 ** a compelling need to use the wrappers.

 **

 ** But there is a good reason to not use the wrappers.  If we use the

 ** wrappers then we will get simulated malloc() failures within this

 ** driver.  And that causes all kinds of problems for our tests.  We

 ** could enhance SQLite to deal with simulated malloc failures within

 ** the OS driver, but the code to deal with those failure would not

 ** be exercised on Linux (which does not need to malloc() in the driver)

 ** and so we would have difficulty writing coverage tests for that

 ** code.  Better to leave the code out, we think.

 **

 ** The point of this discussion is as follows:  When creating a new

 ** OS layer for an embedded system, if you use this file as an example,

 ** avoid the use of malloc()/free().  Those routines work ok on windows

 ** desktops but not so well in embedded systems.

 */

 #include <winbase.h>

 #ifdef __CYGWIN__

 # include <sys/cygwin.h>

 #endif

 /*

 ** Macros used to determine whether or not to use threads.

 */

 #if defined(THREADSAFE) && THREADSAFE

 # define SQLITE_W32_THREADS 1

 #endif

 /*

 ** Include code that is common to all os_*.c files

 */

 #include "os_common.h"

 /*

 ** Determine if we are dealing with WindowsCE - which has a much

 ** reduced API.

 */

 #if defined(_WIN32_WCE)

 # define OS_WINCE 1

 # define AreFileApisANSI() 1

 #else

 # define OS_WINCE 0

 #endif

 /*

 ** WinCE lacks native support for file locking so we have to fake it

 ** with some code of our own.

 */

 #if OS_WINCE

 typedef struct winceLock {

   int nReaders;       /* Number of reader locks obtained */

   BOOL bPending;      /* Indicates a pending lock has been obtained */

   BOOL bReserved;     /* Indicates a reserved lock has been obtained */

   BOOL bExclusive;    /* Indicates an exclusive lock has been obtained */

 } winceLock;

 #endif

 /*

 ** The winFile structure is a subclass of sqlite3_file* specific to the win32

 ** portability layer.

 */

 typedef struct winFile winFile;

 struct winFile {

   const sqlite3_io_methods *pMethod;/* Must be first */

   HANDLE h;               /* Handle for accessing the file */

   unsigned char locktype; /* Type of lock currently held on this file */

   short sharedLockByte;   /* Randomly chosen byte used as a shared lock */

 #if OS_WINCE

   WCHAR *zDeleteOnClose;  /* Name of file to delete when closing */

   HANDLE hMutex;          /* Mutex used to control access to shared lock */  

   HANDLE hShared;         /* Shared memory segment used for locking */

   winceLock local;        /* Locks obtained by this instance of winFile */

   winceLock *shared;      /* Global shared lock memory for the file  */

 #endif

 };

 /*

 ** The following variable is (normally) set once and never changes

 ** thereafter.  It records whether the operating system is Win95

 ** or WinNT.

 **

 ** 0:   Operating system unknown.

 ** 1:   Operating system is Win95.

 ** 2:   Operating system is WinNT.

 **

 ** In order to facilitate testing on a WinNT system, the test fixture

 ** can manually set this value to 1 to emulate Win98 behavior.

 */

 #ifdef SQLITE_TEST

 int sqlite3_os_type = 0;

 #else

 static int sqlite3_os_type = 0;

 #endif

 /*

 ** Return true (non-zero) if we are running under WinNT, Win2K, WinXP,

 ** or WinCE.  Return false (zero) for Win95, Win98, or WinME.

 **

 ** Here is an interesting observation:  Win95, Win98, and WinME lack

 ** the LockFileEx() API.  But we can still statically link against that

 ** API as long as we don't call it win running Win95/98/ME.  A call to

 ** this routine is used to determine if the host is Win95/98/ME or

 ** WinNT/2K/XP so that we will know whether or not we can safely call

 ** the LockFileEx() API.

 */

 #if OS_WINCE

 # define isNT()  (1)

 #else

   static int isNT(void){

     if( sqlite3_os_type==0 ){

       OSVERSIONINFO sInfo;

       sInfo.dwOSVersionInfoSize = sizeof(sInfo);

       GetVersionEx(&sInfo);

       sqlite3_os_type = sInfo.dwPlatformId==VER_PLATFORM_WIN32_NT ? 2 : 1;

     }

     return sqlite3_os_type==2;

   }

 #endif /* OS_WINCE */

 /*

 ** Convert a UTF-8 string to microsoft unicode (UTF-16?). 

 **

 ** Space to hold the returned string is obtained from malloc.

 */

 static WCHAR *utf8ToUnicode(const char *zFilename){

   int nChar;

   WCHAR *zWideFilename;

   nChar = MultiByteToWideChar(CP_UTF8, 0, zFilename, -1, NULL, 0);

   zWideFilename = malloc( nChar*sizeof(zWideFilename[0]) );

   if( zWideFilename==0 ){

     return 0;

   }

   nChar = MultiByteToWideChar(CP_UTF8, 0, zFilename, -1, zWideFilename, nChar);

   if( nChar==0 ){

     free(zWideFilename);

     zWideFilename = 0;

   }

   return zWideFilename;

 }

 /*

 ** Convert microsoft unicode to UTF-8.  Space to hold the returned string is

 ** obtained from malloc().

 */

 static char *unicodeToUtf8(const WCHAR *zWideFilename){

   int nByte;

   char *zFilename;

   nByte = WideCharToMultiByte(CP_UTF8, 0, zWideFilename, -1, 0, 0, 0, 0);

   zFilename = malloc( nByte );

   if( zFilename==0 ){

     return 0;

   }

   nByte = WideCharToMultiByte(CP_UTF8, 0, zWideFilename, -1, zFilename, nByte,

                               0, 0);

   if( nByte == 0 ){

     free(zFilename);

     zFilename = 0;

   }

   return zFilename;

 }

 /*

 ** Convert an ansi string to microsoft unicode, based on the

 ** current codepage settings for file apis.

 ** 

 ** Space to hold the returned string is obtained

 ** from malloc.

 */

 static WCHAR *mbcsToUnicode(const char *zFilename){

   int nByte;

   WCHAR *zMbcsFilename;

   int codepage = AreFileApisANSI() ? CP_ACP : CP_OEMCP;

   nByte = MultiByteToWideChar(codepage, 0, zFilename, -1, NULL,0)*sizeof(WCHAR);

   zMbcsFilename = malloc( nByte*sizeof(zMbcsFilename[0]) );

   if( zMbcsFilename==0 ){

     return 0;

   }

   nByte = MultiByteToWideChar(codepage, 0, zFilename, -1, zMbcsFilename, nByte);

   if( nByte==0 ){

     free(zMbcsFilename);

     zMbcsFilename = 0;

   }

   return zMbcsFilename;

 }

 /*

 ** Convert microsoft unicode to multibyte character string, based on the

 ** user's Ansi codepage.

 **

 ** Space to hold the returned string is obtained from

 ** malloc().

 */

 static char *unicodeToMbcs(const WCHAR *zWideFilename){

   int nByte;

   char *zFilename;

   int codepage = AreFileApisANSI() ? CP_ACP : CP_OEMCP;

   nByte = WideCharToMultiByte(codepage, 0, zWideFilename, -1, 0, 0, 0, 0);

   zFilename = malloc( nByte );

   if( zFilename==0 ){

     return 0;

   }

   nByte = WideCharToMultiByte(codepage, 0, zWideFilename, -1, zFilename, nByte,

                               0, 0);

   if( nByte == 0 ){

     free(zFilename);

     zFilename = 0;

   }

   return zFilename;

 }

 /*

 ** Convert multibyte character string to UTF-8.  Space to hold the

 ** returned string is obtained from malloc().

 */

 static char *mbcsToUtf8(const char *zFilename){

   char *zFilenameUtf8;

   WCHAR *zTmpWide;

   zTmpWide = mbcsToUnicode(zFilename);

   if( zTmpWide==0 ){

     return 0;

   }

   zFilenameUtf8 = unicodeToUtf8(zTmpWide);

   free(zTmpWide);

   return zFilenameUtf8;

 }

 /*

 ** Convert UTF-8 to multibyte character string.  Space to hold the 

 ** returned string is obtained from malloc().

 */

 static char *utf8ToMbcs(const char *zFilename){

   char *zFilenameMbcs;

   WCHAR *zTmpWide;

   zTmpWide = utf8ToUnicode(zFilename);

   if( zTmpWide==0 ){

     return 0;

   }

   zFilenameMbcs = unicodeToMbcs(zTmpWide);

   free(zTmpWide);

   return zFilenameMbcs;

 }

 #if OS_WINCE

 /*************************************************************************

 ** This section contains code for WinCE only.

 */

 /*

 ** WindowsCE does not have a localtime() function.  So create a

 ** substitute.

 */

 #include <time.h>

 struct tm *__cdecl localtime(const time_t *t)

 {

   static struct tm y;

   FILETIME uTm, lTm;

   SYSTEMTIME pTm;

   sqlite3_int64 t64;

   t64 = *t;

   t64 = (t64 + 11644473600)*10000000;

   uTm.dwLowDateTime = t64 & 0xFFFFFFFF;

   uTm.dwHighDateTime= t64 >> 32;

   FileTimeToLocalFileTime(&uTm,&lTm);

   FileTimeToSystemTime(&lTm,&pTm);

   y.tm_year = pTm.wYear - 1900;

   y.tm_mon = pTm.wMonth - 1;

   y.tm_wday = pTm.wDayOfWeek;

   y.tm_mday = pTm.wDay;

   y.tm_hour = pTm.wHour;

   y.tm_min = pTm.wMinute;

   y.tm_sec = pTm.wSecond;

   return &y;

 }

 /* This will never be called, but defined to make the code compile */

 #define GetTempPathA(a,b)

 #define LockFile(a,b,c,d,e)       winceLockFile(&a, b, c, d, e)

 #define UnlockFile(a,b,c,d,e)     winceUnlockFile(&a, b, c, d, e)

 #define LockFileEx(a,b,c,d,e,f)   winceLockFileEx(&a, b, c, d, e, f)

 #define HANDLE_TO_WINFILE(a) (winFile*)&((char*)a)[-offsetof(winFile,h)]

 /*

 ** Acquire a lock on the handle h

 */

 static void winceMutexAcquire(HANDLE h){

    DWORD dwErr;

    do {

      dwErr = WaitForSingleObject(h, INFINITE);

    } while (dwErr != WAIT_OBJECT_0 && dwErr != WAIT_ABANDONED);

 }

 /*

 ** Release a lock acquired by winceMutexAcquire()

 */

 #define winceMutexRelease(h) ReleaseMutex(h)

 /*

 ** Create the mutex and shared memory used for locking in the file

 ** descriptor pFile

 */

 static BOOL winceCreateLock(const char *zFilename, winFile *pFile){

   WCHAR *zTok;

   WCHAR *zName = utf8ToUnicode(zFilename);

   BOOL bInit = TRUE;

   /* Initialize the local lockdata */

   ZeroMemory(&pFile->local, sizeof(pFile->local));

   /* Replace the backslashes from the filename and lowercase it

   ** to derive a mutex name. */

   zTok = CharLowerW(zName);

   for (;*zTok;zTok++){

     if (*zTok == '\\') *zTok = '_';

   }

   /* Create/open the named mutex */

   pFile->hMutex = CreateMutexW(NULL, FALSE, zName);

   if (!pFile->hMutex){

     free(zName);

     return FALSE;

   }

   /* Acquire the mutex before continuing */

   winceMutexAcquire(pFile->hMutex);

   /* Since the names of named mutexes, semaphores, file mappings etc are 

   ** case-sensitive, take advantage of that by uppercasing the mutex name

   ** and using that as the shared filemapping name.

   */

   CharUpperW(zName);

   pFile->hShared = CreateFileMappingW(INVALID_HANDLE_VALUE, NULL,

                                        PAGE_READWRITE, 0, sizeof(winceLock),

                                        zName);  

   /* Set a flag that indicates we're the first to create the memory so it 

   ** must be zero-initialized */

   if (GetLastError() == ERROR_ALREADY_EXISTS){

     bInit = FALSE;

   }

   free(zName);

   /* If we succeeded in making the shared memory handle, map it. */

   if (pFile->hShared){

     pFile->shared = (winceLock*)MapViewOfFile(pFile->hShared, 

              FILE_MAP_READ|FILE_MAP_WRITE, 0, 0, sizeof(winceLock));

     /* If mapping failed, close the shared memory handle and erase it */

     if (!pFile->shared){

       CloseHandle(pFile->hShared);

       pFile->hShared = NULL;

     }

   }

   /* If shared memory could not be created, then close the mutex and fail */

   if (pFile->hShared == NULL){

     winceMutexRelease(pFile->hMutex);

     CloseHandle(pFile->hMutex);

     pFile->hMutex = NULL;

     return FALSE;

   }

   /* Initialize the shared memory if we're supposed to */

   if (bInit) {

     ZeroMemory(pFile->shared, sizeof(winceLock));

   }

   winceMutexRelease(pFile->hMutex);

   return TRUE;

 }

 /*

 ** Destroy the part of winFile that deals with wince locks

 */

 static void winceDestroyLock(winFile *pFile){

   if (pFile->hMutex){

     /* Acquire the mutex */

     winceMutexAcquire(pFile->hMutex);

     /* The following blocks should probably assert in debug mode, but they

        are to cleanup in case any locks remained open */

     if (pFile->local.nReaders){

       pFile->shared->nReaders --;

     }

     if (pFile->local.bReserved){

       pFile->shared->bReserved = FALSE;

     }

     if (pFile->local.bPending){

       pFile->shared->bPending = FALSE;

     }

     if (pFile->local.bExclusive){

       pFile->shared->bExclusive = FALSE;

     }

     /* De-reference and close our copy of the shared memory handle */

     UnmapViewOfFile(pFile->shared);

     CloseHandle(pFile->hShared);

     if( pFile->zDeleteOnClose ){

       DeleteFileW(pFile->zDeleteOnClose);

       free(pFile->zDeleteOnClose);

       pFile->zDeleteOnClose = 0;

     }

     /* Done with the mutex */

     winceMutexRelease(pFile->hMutex);    

     CloseHandle(pFile->hMutex);

     pFile->hMutex = NULL;

   }

 }

 /* 

 ** An implementation of the LockFile() API of windows for wince

 */

 static BOOL winceLockFile(

   HANDLE *phFile,

   DWORD dwFileOffsetLow,

   DWORD dwFileOffsetHigh,

   DWORD nNumberOfBytesToLockLow,

   DWORD nNumberOfBytesToLockHigh

 ){

   winFile *pFile = HANDLE_TO_WINFILE(phFile);

   BOOL bReturn = FALSE;

   if (!pFile->hMutex) return TRUE;

   winceMutexAcquire(pFile->hMutex);

   /* Wanting an exclusive lock? */

   if (dwFileOffsetLow == SHARED_FIRST

        && nNumberOfBytesToLockLow == SHARED_SIZE){

     if (pFile->shared->nReaders == 0 && pFile->shared->bExclusive == 0){

        pFile->shared->bExclusive = TRUE;

        pFile->local.bExclusive = TRUE;

        bReturn = TRUE;

     }

   }

   /* Want a read-only lock? */

   else if ((dwFileOffsetLow >= SHARED_FIRST &&

             dwFileOffsetLow < SHARED_FIRST + SHARED_SIZE) &&

             nNumberOfBytesToLockLow == 1){

     if (pFile->shared->bExclusive == 0){

       pFile->local.nReaders ++;

       if (pFile->local.nReaders == 1){

         pFile->shared->nReaders ++;

       }

       bReturn = TRUE;

     }

   }

   /* Want a pending lock? */

   else if (dwFileOffsetLow == PENDING_BYTE && nNumberOfBytesToLockLow == 1){

     /* If no pending lock has been acquired, then acquire it */

     if (pFile->shared->bPending == 0) {

       pFile->shared->bPending = TRUE;

       pFile->local.bPending = TRUE;

       bReturn = TRUE;

     }

   }

   /* Want a reserved lock? */

   else if (dwFileOffsetLow == RESERVED_BYTE && nNumberOfBytesToLockLow == 1){

     if (pFile->shared->bReserved == 0) {

       pFile->shared->bReserved = TRUE;

       pFile->local.bReserved = TRUE;

       bReturn = TRUE;

     }

   }

   winceMutexRelease(pFile->hMutex);

   return bReturn;

 }

 /*

 ** An implementation of the UnlockFile API of windows for wince

 */

 static BOOL winceUnlockFile(

   HANDLE *phFile,

   DWORD dwFileOffsetLow,

   DWORD dwFileOffsetHigh,

   DWORD nNumberOfBytesToUnlockLow,

   DWORD nNumberOfBytesToUnlockHigh

 ){

   winFile *pFile = HANDLE_TO_WINFILE(phFile);

   BOOL bReturn = FALSE;

   if (!pFile->hMutex) return TRUE;

   winceMutexAcquire(pFile->hMutex);

   /* Releasing a reader lock or an exclusive lock */

   if (dwFileOffsetLow >= SHARED_FIRST &&

        dwFileOffsetLow < SHARED_FIRST + SHARED_SIZE){

     /* Did we have an exclusive lock? */

     if (pFile->local.bExclusive){

       pFile->local.bExclusive = FALSE;

       pFile->shared->bExclusive = FALSE;

       bReturn = TRUE;

     }

     /* Did we just have a reader lock? */

     else if (pFile->local.nReaders){

       pFile->local.nReaders --;

       if (pFile->local.nReaders == 0)

       {

         pFile->shared->nReaders --;

       }

       bReturn = TRUE;

     }

   }

   /* Releasing a pending lock */

   else if (dwFileOffsetLow == PENDING_BYTE && nNumberOfBytesToUnlockLow == 1){

     if (pFile->local.bPending){

       pFile->local.bPending = FALSE;

       pFile->shared->bPending = FALSE;

       bReturn = TRUE;

     }

   }

   /* Releasing a reserved lock */

   else if (dwFileOffsetLow == RESERVED_BYTE && nNumberOfBytesToUnlockLow == 1){

     if (pFile->local.bReserved) {

       pFile->local.bReserved = FALSE;

       pFile->shared->bReserved = FALSE;

       bReturn = TRUE;

     }

   }

   winceMutexRelease(pFile->hMutex);

   return bReturn;

 }

 /*

 ** An implementation of the LockFileEx() API of windows for wince

 */

 static BOOL winceLockFileEx(

   HANDLE *phFile,

   DWORD dwFlags,

   DWORD dwReserved,

   DWORD nNumberOfBytesToLockLow,

   DWORD nNumberOfBytesToLockHigh,

   LPOVERLAPPED lpOverlapped

 ){

   /* If the caller wants a shared read lock, forward this call

   ** to winceLockFile */

   if (lpOverlapped->Offset == SHARED_FIRST &&

       dwFlags == 1 &&

       nNumberOfBytesToLockLow == SHARED_SIZE){

     return winceLockFile(phFile, SHARED_FIRST, 0, 1, 0);

   }

   return FALSE;

 }

 /*

 ** End of the special code for wince

 *****************************************************************************/

 #endif /* OS_WINCE */

 /*****************************************************************************

 ** The next group of routines implement the I/O methods specified

 ** by the sqlite3_io_methods object.

 ******************************************************************************/

 /*

 ** Close a file.

 **

 ** It is reported that an attempt to close a handle might sometimes

 ** fail.  This is a very unreasonable result, but windows is notorious

 ** for being unreasonable so I do not doubt that it might happen.  If

 ** the close fails, we pause for 100 milliseconds and try again.  As

 ** many as MX_CLOSE_ATTEMPT attempts to close the handle are made before

 ** giving up and returning an error.

 */

 #define MX_CLOSE_ATTEMPT 3

 static int winClose(sqlite3_file *id){

   int rc, cnt = 0;

   winFile *pFile = (winFile*)id;

   OSTRACE2("CLOSE %d\n", pFile->h);

   do{

     rc = CloseHandle(pFile->h);

   }while( rc==0 && cnt++ < MX_CLOSE_ATTEMPT && (Sleep(100), 1) );

 #if OS_WINCE

   winceDestroyLock(pFile);

 #endif

   OpenCounter(-1);

   return rc ? SQLITE_OK : SQLITE_IOERR;

 }

 /*

 ** Some microsoft compilers lack this definition.

 */

 #ifndef INVALID_SET_FILE_POINTER

 # define INVALID_SET_FILE_POINTER ((DWORD)-1)

 #endif

 /*

 ** Read data from a file into a buffer.  Return SQLITE_OK if all

 ** bytes were read successfully and SQLITE_IOERR if anything goes

 ** wrong.

 */

 static int winRead(

   sqlite3_file *id,          /* File to read from */

   void *pBuf,                /* Write content into this buffer */

   int amt,                   /* Number of bytes to read */

   sqlite3_int64 offset       /* Begin reading at this offset */

 ){

   LONG upperBits = (offset>>32) & 0x7fffffff;

   LONG lowerBits = offset & 0xffffffff;

   DWORD rc;

   DWORD got;

   winFile *pFile = (winFile*)id;

   assert( id!=0 );

   SimulateIOError(return SQLITE_IOERR_READ);

   OSTRACE3("READ %d lock=%d\n", pFile->h, pFile->locktype);

   rc = SetFilePointer(pFile->h, lowerBits, &upperBits, FILE_BEGIN);

   if( rc==INVALID_SET_FILE_POINTER && GetLastError()!=NO_ERROR ){

     return SQLITE_FULL;

   }

   if( !ReadFile(pFile->h, pBuf, amt, &got, 0) ){

     return SQLITE_IOERR_READ;

   }

   if( got==(DWORD)amt ){

     return SQLITE_OK;

   }else{

     memset(&((char*)pBuf)[got], 0, amt-got);

     return SQLITE_IOERR_SHORT_READ;

   }

 }

 /*

 ** Write data from a buffer into a file.  Return SQLITE_OK on success

 ** or some other error code on failure.

 */

 static int winWrite(

   sqlite3_file *id,         /* File to write into */

   const void *pBuf,         /* The bytes to be written */

   int amt,                  /* Number of bytes to write */

   sqlite3_int64 offset      /* Offset into the file to begin writing at */

 ){

   LONG upperBits = (offset>>32) & 0x7fffffff;

   LONG lowerBits = offset & 0xffffffff;

   DWORD rc;

   DWORD wrote;

   winFile *pFile = (winFile*)id;

   assert( id!=0 );

   SimulateIOError(return SQLITE_IOERR_WRITE);

   SimulateDiskfullError(return SQLITE_FULL);

   OSTRACE3("WRITE %d lock=%d\n", pFile->h, pFile->locktype);

   rc = SetFilePointer(pFile->h, lowerBits, &upperBits, FILE_BEGIN);

   if( rc==INVALID_SET_FILE_POINTER && GetLastError()!=NO_ERROR ){

     return SQLITE_FULL;

   }

   assert( amt>0 );

   while(

      amt>0

      && (rc = WriteFile(pFile->h, pBuf, amt, &wrote, 0))!=0

      && wrote>0

   ){

     amt -= wrote;

     pBuf = &((char*)pBuf)[wrote];

   }

   if( !rc || amt>(int)wrote ){

     return SQLITE_FULL;

   }

   return SQLITE_OK;

 }

 /*

 ** Truncate an open file to a specified size

 */

 static int winTruncate(sqlite3_file *id, sqlite3_int64 nByte){

   LONG upperBits = (nByte>>32) & 0x7fffffff;

   LONG lowerBits = nByte & 0xffffffff;

   winFile *pFile = (winFile*)id;

   OSTRACE3("TRUNCATE %d %lld\n", pFile->h, nByte);

   SimulateIOError(return SQLITE_IOERR_TRUNCATE);

   SetFilePointer(pFile->h, lowerBits, &upperBits, FILE_BEGIN);

   SetEndOfFile(pFile->h);

   return SQLITE_OK;

 }

 #ifdef SQLITE_TEST

 /*

 ** Count the number of fullsyncs and normal syncs.  This is used to test

 ** that syncs and fullsyncs are occuring at the right times.

 */

 int sqlite3_sync_count = 0;

 int sqlite3_fullsync_count = 0;

 #endif

 /*

 ** Make sure all writes to a particular file are committed to disk.

 */

 static int winSync(sqlite3_file *id, int flags){

   winFile *pFile = (winFile*)id;

   OSTRACE3("SYNC %d lock=%d\n", pFile->h, pFile->locktype);

 #ifdef SQLITE_TEST

   if( flags & SQLITE_SYNC_FULL ){

     sqlite3_fullsync_count++;

   }

   sqlite3_sync_count++;

 #endif

   if( FlushFileBuffers(pFile->h) ){

     return SQLITE_OK;

   }else{

     return SQLITE_IOERR;

   }

 }

 /*

 ** Determine the current size of a file in bytes

 */

 static int winFileSize(sqlite3_file *id, sqlite3_int64 *pSize){

   winFile *pFile = (winFile*)id;

   DWORD upperBits, lowerBits;

   SimulateIOError(return SQLITE_IOERR_FSTAT);

   lowerBits = GetFileSize(pFile->h, &upperBits);

   *pSize = (((sqlite3_int64)upperBits)<<32) + lowerBits;

   return SQLITE_OK;

 }

 /*

 ** LOCKFILE_FAIL_IMMEDIATELY is undefined on some Windows systems.

 */

 #ifndef LOCKFILE_FAIL_IMMEDIATELY

 # define LOCKFILE_FAIL_IMMEDIATELY 1

 #endif

 /*

 ** Acquire a reader lock.

 ** Different API routines are called depending on whether or not this

 ** is Win95 or WinNT.

 */

 static int getReadLock(winFile *pFile){

   int res;

   if( isNT() ){

     OVERLAPPED ovlp;

     ovlp.Offset = SHARED_FIRST;

     ovlp.OffsetHigh = 0;

     ovlp.hEvent = 0;

     res = LockFileEx(pFile->h, LOCKFILE_FAIL_IMMEDIATELY,

                      0, SHARED_SIZE, 0, &ovlp);

   }else{

     int lk;

     sqlite3Randomness(sizeof(lk), &lk);

     pFile->sharedLockByte = (lk & 0x7fffffff)%(SHARED_SIZE - 1);

     res = LockFile(pFile->h, SHARED_FIRST+pFile->sharedLockByte, 0, 1, 0);

   }

   return res;

 }

 /*

 ** Undo a readlock

 */

 static int unlockReadLock(winFile *pFile){

   int res;

   if( isNT() ){

     res = UnlockFile(pFile->h, SHARED_FIRST, 0, SHARED_SIZE, 0);

   }else{

     res = UnlockFile(pFile->h, SHARED_FIRST + pFile->sharedLockByte, 0, 1, 0);

   }

   return res;

 }

 /*

 ** Lock the file with the lock specified by parameter locktype - one

 ** of the following:

 **

 **     (1) SHARED_LOCK

 **     (2) RESERVED_LOCK

 **     (3) PENDING_LOCK

 **     (4) EXCLUSIVE_LOCK

 **

 ** Sometimes when requesting one lock state, additional lock states

 ** are inserted in between.  The locking might fail on one of the later

 ** transitions leaving the lock state different from what it started but

 ** still short of its goal.  The following chart shows the allowed

 ** transitions and the inserted intermediate states:

 **

 **    UNLOCKED -> SHARED

 **    SHARED -> RESERVED

 **    SHARED -> (PENDING) -> EXCLUSIVE

 **    RESERVED -> (PENDING) -> EXCLUSIVE

 **    PENDING -> EXCLUSIVE

 **

 ** This routine will only increase a lock.  The winUnlock() routine

 ** erases all locks at once and returns us immediately to locking level 0.

 ** It is not possible to lower the locking level one step at a time.  You

 ** must go straight to locking level 0.

 */

 static int winLock(sqlite3_file *id, int locktype){

   int rc = SQLITE_OK;    /* Return code from subroutines */

   int res = 1;           /* Result of a windows lock call */

   int newLocktype;       /* Set pFile->locktype to this value before exiting */

   int gotPendingLock = 0;/* True if we acquired a PENDING lock this time */

   winFile *pFile = (winFile*)id;

   assert( pFile!=0 );

   OSTRACE5("LOCK %d %d was %d(%d)\n",

           pFile->h, locktype, pFile->locktype, pFile->sharedLockByte);

   /* If there is already a lock of this type or more restrictive on the

   ** OsFile, do nothing. Don't use the end_lock: exit path, as

   ** sqlite3OsEnterMutex() hasn't been called yet.

   */

   if( pFile->locktype>=locktype ){

     return SQLITE_OK;

   }

   /* Make sure the locking sequence is correct

   */

   assert( pFile->locktype!=NO_LOCK || locktype==SHARED_LOCK );

   assert( locktype!=PENDING_LOCK );

   assert( locktype!=RESERVED_LOCK || pFile->locktype==SHARED_LOCK );

   /* Lock the PENDING_LOCK byte if we need to acquire a PENDING lock or

   ** a SHARED lock.  If we are acquiring a SHARED lock, the acquisition of

   ** the PENDING_LOCK byte is temporary.

   */

   newLocktype = pFile->locktype;

   if( pFile->locktype==NO_LOCK

    || (locktype==EXCLUSIVE_LOCK && pFile->locktype==RESERVED_LOCK)

   ){

     int cnt = 3;

     while( cnt-->0 && (res = LockFile(pFile->h, PENDING_BYTE, 0, 1, 0))==0 ){

       /* Try 3 times to get the pending lock.  The pending lock might be

       ** held by another reader process who will release it momentarily.

       */

       OSTRACE2("could not get a PENDING lock. cnt=%d\n", cnt);

       Sleep(1);

     }

     gotPendingLock = res;

   }

   /* Acquire a shared lock

   */

   if( locktype==SHARED_LOCK && res ){

     assert( pFile->locktype==NO_LOCK );

     res = getReadLock(pFile);

     if( res ){

       newLocktype = SHARED_LOCK;

     }

   }

   /* Acquire a RESERVED lock

   */

   if( locktype==RESERVED_LOCK && res ){

     assert( pFile->locktype==SHARED_LOCK );

     res = LockFile(pFile->h, RESERVED_BYTE, 0, 1, 0);

     if( res ){

       newLocktype = RESERVED_LOCK;

     }

   }

   /* Acquire a PENDING lock

   */

   if( locktype==EXCLUSIVE_LOCK && res ){

     newLocktype = PENDING_LOCK;

     gotPendingLock = 0;

   }

   /* Acquire an EXCLUSIVE lock

   */

   if( locktype==EXCLUSIVE_LOCK && res ){

     assert( pFile->locktype>=SHARED_LOCK );

     res = unlockReadLock(pFile);

     OSTRACE2("unreadlock = %d\n", res);

     res = LockFile(pFile->h, SHARED_FIRST, 0, SHARED_SIZE, 0);

     if( res ){

       newLocktype = EXCLUSIVE_LOCK;

     }else{

       OSTRACE2("error-code = %d\n", GetLastError());

       getReadLock(pFile);

     }

   }

   /* If we are holding a PENDING lock that ought to be released, then

   ** release it now.

   */

   if( gotPendingLock && locktype==SHARED_LOCK ){

     UnlockFile(pFile->h, PENDING_BYTE, 0, 1, 0);

   }

   /* Update the state of the lock has held in the file descriptor then

   ** return the appropriate result code.

   */

   if( res ){

     rc = SQLITE_OK;

   }else{

     OSTRACE4("LOCK FAILED %d trying for %d but got %d\n", pFile->h,

            locktype, newLocktype);

     rc = SQLITE_BUSY;

   }

   pFile->locktype = newLocktype;

   return rc;

 }

 /*

 ** This routine checks if there is a RESERVED lock held on the specified

 ** file by this or any other process. If such a lock is held, return

 ** non-zero, otherwise zero.

 */

 static int winCheckReservedLock(sqlite3_file *id){

   int rc;

   winFile *pFile = (winFile*)id;

   assert( pFile!=0 );

   if( pFile->locktype>=RESERVED_LOCK ){

     rc = 1;

     OSTRACE3("TEST WR-LOCK %d %d (local)\n", pFile->h, rc);

   }else{

     rc = LockFile(pFile->h, RESERVED_BYTE, 0, 1, 0);

     if( rc ){

       UnlockFile(pFile->h, RESERVED_BYTE, 0, 1, 0);

     }

     rc = !rc;

     OSTRACE3("TEST WR-LOCK %d %d (remote)\n", pFile->h, rc);

   }

   return rc;

 }

 /*

 ** Lower the locking level on file descriptor id to locktype.  locktype

 ** must be either NO_LOCK or SHARED_LOCK.

 **

 ** If the locking level of the file descriptor is already at or below

 ** the requested locking level, this routine is a no-op.

 **

 ** It is not possible for this routine to fail if the second argument

 ** is NO_LOCK.  If the second argument is SHARED_LOCK then this routine

 ** might return SQLITE_IOERR;

 */

 static int winUnlock(sqlite3_file *id, int locktype){

   int type;

   winFile *pFile = (winFile*)id;

   int rc = SQLITE_OK;

   assert( pFile!=0 );

   assert( locktype<=SHARED_LOCK );

   OSTRACE5("UNLOCK %d to %d was %d(%d)\n", pFile->h, locktype,

           pFile->locktype, pFile->sharedLockByte);

   type = pFile->locktype;