sl@0: /*
sl@0: ** 2004 May 22
sl@0: **
sl@0: ** The author disclaims copyright to this source code.  In place of
sl@0: ** a legal notice, here is a blessing:
sl@0: **
sl@0: **    May you do good and not evil.
sl@0: **    May you find forgiveness for yourself and forgive others.
sl@0: **    May you share freely, never taking more than you give.
sl@0: **
sl@0: ******************************************************************************
sl@0: **
sl@0: ** This file contains code that is specific to windows.
sl@0: **
sl@0: ** $Id: os_win.c,v 1.134 2008/09/30 04:20:08 shane Exp $
sl@0: */
sl@0: #include "sqliteInt.h"
sl@0: #if SQLITE_OS_WIN               /* This file is used for windows only */
sl@0: 
sl@0: 
sl@0: /*
sl@0: ** A Note About Memory Allocation:
sl@0: **
sl@0: ** This driver uses malloc()/free() directly rather than going through
sl@0: ** the SQLite-wrappers sqlite3_malloc()/sqlite3_free().  Those wrappers
sl@0: ** are designed for use on embedded systems where memory is scarce and
sl@0: ** malloc failures happen frequently.  Win32 does not typically run on
sl@0: ** embedded systems, and when it does the developers normally have bigger
sl@0: ** problems to worry about than running out of memory.  So there is not
sl@0: ** a compelling need to use the wrappers.
sl@0: **
sl@0: ** But there is a good reason to not use the wrappers.  If we use the
sl@0: ** wrappers then we will get simulated malloc() failures within this
sl@0: ** driver.  And that causes all kinds of problems for our tests.  We
sl@0: ** could enhance SQLite to deal with simulated malloc failures within
sl@0: ** the OS driver, but the code to deal with those failure would not
sl@0: ** be exercised on Linux (which does not need to malloc() in the driver)
sl@0: ** and so we would have difficulty writing coverage tests for that
sl@0: ** code.  Better to leave the code out, we think.
sl@0: **
sl@0: ** The point of this discussion is as follows:  When creating a new
sl@0: ** OS layer for an embedded system, if you use this file as an example,
sl@0: ** avoid the use of malloc()/free().  Those routines work ok on windows
sl@0: ** desktops but not so well in embedded systems.
sl@0: */
sl@0: 
sl@0: #include <winbase.h>
sl@0: 
sl@0: #ifdef __CYGWIN__
sl@0: # include <sys/cygwin.h>
sl@0: #endif
sl@0: 
sl@0: /*
sl@0: ** Macros used to determine whether or not to use threads.
sl@0: */
sl@0: #if defined(THREADSAFE) && THREADSAFE
sl@0: # define SQLITE_W32_THREADS 1
sl@0: #endif
sl@0: 
sl@0: /*
sl@0: ** Include code that is common to all os_*.c files
sl@0: */
sl@0: #include "os_common.h"
sl@0: 
sl@0: /*
sl@0: ** Some microsoft compilers lack this definition.
sl@0: */
sl@0: #ifndef INVALID_FILE_ATTRIBUTES
sl@0: # define INVALID_FILE_ATTRIBUTES ((DWORD)-1) 
sl@0: #endif
sl@0: 
sl@0: /*
sl@0: ** Determine if we are dealing with WindowsCE - which has a much
sl@0: ** reduced API.
sl@0: */
sl@0: #if defined(SQLITE_OS_WINCE)
sl@0: # define AreFileApisANSI() 1
sl@0: #endif
sl@0: 
sl@0: /*
sl@0: ** WinCE lacks native support for file locking so we have to fake it
sl@0: ** with some code of our own.
sl@0: */
sl@0: #if SQLITE_OS_WINCE
sl@0: typedef struct winceLock {
sl@0:   int nReaders;       /* Number of reader locks obtained */
sl@0:   BOOL bPending;      /* Indicates a pending lock has been obtained */
sl@0:   BOOL bReserved;     /* Indicates a reserved lock has been obtained */
sl@0:   BOOL bExclusive;    /* Indicates an exclusive lock has been obtained */
sl@0: } winceLock;
sl@0: #endif
sl@0: 
sl@0: /*
sl@0: ** The winFile structure is a subclass of sqlite3_file* specific to the win32
sl@0: ** portability layer.
sl@0: */
sl@0: typedef struct winFile winFile;
sl@0: struct winFile {
sl@0:   const sqlite3_io_methods *pMethod;/* Must be first */
sl@0:   HANDLE h;               /* Handle for accessing the file */
sl@0:   unsigned char locktype; /* Type of lock currently held on this file */
sl@0:   short sharedLockByte;   /* Randomly chosen byte used as a shared lock */
sl@0: #if SQLITE_OS_WINCE
sl@0:   WCHAR *zDeleteOnClose;  /* Name of file to delete when closing */
sl@0:   HANDLE hMutex;          /* Mutex used to control access to shared lock */  
sl@0:   HANDLE hShared;         /* Shared memory segment used for locking */
sl@0:   winceLock local;        /* Locks obtained by this instance of winFile */
sl@0:   winceLock *shared;      /* Global shared lock memory for the file  */
sl@0: #endif
sl@0: };
sl@0: 
sl@0: 
sl@0: /*
sl@0: ** The following variable is (normally) set once and never changes
sl@0: ** thereafter.  It records whether the operating system is Win95
sl@0: ** or WinNT.
sl@0: **
sl@0: ** 0:   Operating system unknown.
sl@0: ** 1:   Operating system is Win95.
sl@0: ** 2:   Operating system is WinNT.
sl@0: **
sl@0: ** In order to facilitate testing on a WinNT system, the test fixture
sl@0: ** can manually set this value to 1 to emulate Win98 behavior.
sl@0: */
sl@0: #ifdef SQLITE_TEST
sl@0: int sqlite3_os_type = 0;
sl@0: #else
sl@0: static int sqlite3_os_type = 0;
sl@0: #endif
sl@0: 
sl@0: /*
sl@0: ** Return true (non-zero) if we are running under WinNT, Win2K, WinXP,
sl@0: ** or WinCE.  Return false (zero) for Win95, Win98, or WinME.
sl@0: **
sl@0: ** Here is an interesting observation:  Win95, Win98, and WinME lack
sl@0: ** the LockFileEx() API.  But we can still statically link against that
sl@0: ** API as long as we don't call it win running Win95/98/ME.  A call to
sl@0: ** this routine is used to determine if the host is Win95/98/ME or
sl@0: ** WinNT/2K/XP so that we will know whether or not we can safely call
sl@0: ** the LockFileEx() API.
sl@0: */
sl@0: #if SQLITE_OS_WINCE
sl@0: # define isNT()  (1)
sl@0: #else
sl@0:   static int isNT(void){
sl@0:     if( sqlite3_os_type==0 ){
sl@0:       OSVERSIONINFO sInfo;
sl@0:       sInfo.dwOSVersionInfoSize = sizeof(sInfo);
sl@0:       GetVersionEx(&sInfo);
sl@0:       sqlite3_os_type = sInfo.dwPlatformId==VER_PLATFORM_WIN32_NT ? 2 : 1;
sl@0:     }
sl@0:     return sqlite3_os_type==2;
sl@0:   }
sl@0: #endif /* SQLITE_OS_WINCE */
sl@0: 
sl@0: /*
sl@0: ** Convert a UTF-8 string to microsoft unicode (UTF-16?). 
sl@0: **
sl@0: ** Space to hold the returned string is obtained from malloc.
sl@0: */
sl@0: static WCHAR *utf8ToUnicode(const char *zFilename){
sl@0:   int nChar;
sl@0:   WCHAR *zWideFilename;
sl@0: 
sl@0:   nChar = MultiByteToWideChar(CP_UTF8, 0, zFilename, -1, NULL, 0);
sl@0:   zWideFilename = malloc( nChar*sizeof(zWideFilename[0]) );
sl@0:   if( zWideFilename==0 ){
sl@0:     return 0;
sl@0:   }
sl@0:   nChar = MultiByteToWideChar(CP_UTF8, 0, zFilename, -1, zWideFilename, nChar);
sl@0:   if( nChar==0 ){
sl@0:     free(zWideFilename);
sl@0:     zWideFilename = 0;
sl@0:   }
sl@0:   return zWideFilename;
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Convert microsoft unicode to UTF-8.  Space to hold the returned string is
sl@0: ** obtained from malloc().
sl@0: */
sl@0: static char *unicodeToUtf8(const WCHAR *zWideFilename){
sl@0:   int nByte;
sl@0:   char *zFilename;
sl@0: 
sl@0:   nByte = WideCharToMultiByte(CP_UTF8, 0, zWideFilename, -1, 0, 0, 0, 0);
sl@0:   zFilename = malloc( nByte );
sl@0:   if( zFilename==0 ){
sl@0:     return 0;
sl@0:   }
sl@0:   nByte = WideCharToMultiByte(CP_UTF8, 0, zWideFilename, -1, zFilename, nByte,
sl@0:                               0, 0);
sl@0:   if( nByte == 0 ){
sl@0:     free(zFilename);
sl@0:     zFilename = 0;
sl@0:   }
sl@0:   return zFilename;
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Convert an ansi string to microsoft unicode, based on the
sl@0: ** current codepage settings for file apis.
sl@0: ** 
sl@0: ** Space to hold the returned string is obtained
sl@0: ** from malloc.
sl@0: */
sl@0: static WCHAR *mbcsToUnicode(const char *zFilename){
sl@0:   int nByte;
sl@0:   WCHAR *zMbcsFilename;
sl@0:   int codepage = AreFileApisANSI() ? CP_ACP : CP_OEMCP;
sl@0: 
sl@0:   nByte = MultiByteToWideChar(codepage, 0, zFilename, -1, NULL,0)*sizeof(WCHAR);
sl@0:   zMbcsFilename = malloc( nByte*sizeof(zMbcsFilename[0]) );
sl@0:   if( zMbcsFilename==0 ){
sl@0:     return 0;
sl@0:   }
sl@0:   nByte = MultiByteToWideChar(codepage, 0, zFilename, -1, zMbcsFilename, nByte);
sl@0:   if( nByte==0 ){
sl@0:     free(zMbcsFilename);
sl@0:     zMbcsFilename = 0;
sl@0:   }
sl@0:   return zMbcsFilename;
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Convert microsoft unicode to multibyte character string, based on the
sl@0: ** user's Ansi codepage.
sl@0: **
sl@0: ** Space to hold the returned string is obtained from
sl@0: ** malloc().
sl@0: */
sl@0: static char *unicodeToMbcs(const WCHAR *zWideFilename){
sl@0:   int nByte;
sl@0:   char *zFilename;
sl@0:   int codepage = AreFileApisANSI() ? CP_ACP : CP_OEMCP;
sl@0: 
sl@0:   nByte = WideCharToMultiByte(codepage, 0, zWideFilename, -1, 0, 0, 0, 0);
sl@0:   zFilename = malloc( nByte );
sl@0:   if( zFilename==0 ){
sl@0:     return 0;
sl@0:   }
sl@0:   nByte = WideCharToMultiByte(codepage, 0, zWideFilename, -1, zFilename, nByte,
sl@0:                               0, 0);
sl@0:   if( nByte == 0 ){
sl@0:     free(zFilename);
sl@0:     zFilename = 0;
sl@0:   }
sl@0:   return zFilename;
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Convert multibyte character string to UTF-8.  Space to hold the
sl@0: ** returned string is obtained from malloc().
sl@0: */
sl@0: static char *mbcsToUtf8(const char *zFilename){
sl@0:   char *zFilenameUtf8;
sl@0:   WCHAR *zTmpWide;
sl@0: 
sl@0:   zTmpWide = mbcsToUnicode(zFilename);
sl@0:   if( zTmpWide==0 ){
sl@0:     return 0;
sl@0:   }
sl@0:   zFilenameUtf8 = unicodeToUtf8(zTmpWide);
sl@0:   free(zTmpWide);
sl@0:   return zFilenameUtf8;
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Convert UTF-8 to multibyte character string.  Space to hold the 
sl@0: ** returned string is obtained from malloc().
sl@0: */
sl@0: static char *utf8ToMbcs(const char *zFilename){
sl@0:   char *zFilenameMbcs;
sl@0:   WCHAR *zTmpWide;
sl@0: 
sl@0:   zTmpWide = utf8ToUnicode(zFilename);
sl@0:   if( zTmpWide==0 ){
sl@0:     return 0;
sl@0:   }
sl@0:   zFilenameMbcs = unicodeToMbcs(zTmpWide);
sl@0:   free(zTmpWide);
sl@0:   return zFilenameMbcs;
sl@0: }
sl@0: 
sl@0: #if SQLITE_OS_WINCE
sl@0: /*************************************************************************
sl@0: ** This section contains code for WinCE only.
sl@0: */
sl@0: /*
sl@0: ** WindowsCE does not have a localtime() function.  So create a
sl@0: ** substitute.
sl@0: */
sl@0: #include <time.h>
sl@0: struct tm *__cdecl localtime(const time_t *t)
sl@0: {
sl@0:   static struct tm y;
sl@0:   FILETIME uTm, lTm;
sl@0:   SYSTEMTIME pTm;
sl@0:   sqlite3_int64 t64;
sl@0:   t64 = *t;
sl@0:   t64 = (t64 + 11644473600)*10000000;
sl@0:   uTm.dwLowDateTime = t64 & 0xFFFFFFFF;
sl@0:   uTm.dwHighDateTime= t64 >> 32;
sl@0:   FileTimeToLocalFileTime(&uTm,&lTm);
sl@0:   FileTimeToSystemTime(&lTm,&pTm);
sl@0:   y.tm_year = pTm.wYear - 1900;
sl@0:   y.tm_mon = pTm.wMonth - 1;
sl@0:   y.tm_wday = pTm.wDayOfWeek;
sl@0:   y.tm_mday = pTm.wDay;
sl@0:   y.tm_hour = pTm.wHour;
sl@0:   y.tm_min = pTm.wMinute;
sl@0:   y.tm_sec = pTm.wSecond;
sl@0:   return &y;
sl@0: }
sl@0: 
sl@0: /* This will never be called, but defined to make the code compile */
sl@0: #define GetTempPathA(a,b)
sl@0: 
sl@0: #define LockFile(a,b,c,d,e)       winceLockFile(&a, b, c, d, e)
sl@0: #define UnlockFile(a,b,c,d,e)     winceUnlockFile(&a, b, c, d, e)
sl@0: #define LockFileEx(a,b,c,d,e,f)   winceLockFileEx(&a, b, c, d, e, f)
sl@0: 
sl@0: #define HANDLE_TO_WINFILE(a) (winFile*)&((char*)a)[-offsetof(winFile,h)]
sl@0: 
sl@0: /*
sl@0: ** Acquire a lock on the handle h
sl@0: */
sl@0: static void winceMutexAcquire(HANDLE h){
sl@0:    DWORD dwErr;
sl@0:    do {
sl@0:      dwErr = WaitForSingleObject(h, INFINITE);
sl@0:    } while (dwErr != WAIT_OBJECT_0 && dwErr != WAIT_ABANDONED);
sl@0: }
sl@0: /*
sl@0: ** Release a lock acquired by winceMutexAcquire()
sl@0: */
sl@0: #define winceMutexRelease(h) ReleaseMutex(h)
sl@0: 
sl@0: /*
sl@0: ** Create the mutex and shared memory used for locking in the file
sl@0: ** descriptor pFile
sl@0: */
sl@0: static BOOL winceCreateLock(const char *zFilename, winFile *pFile){
sl@0:   WCHAR *zTok;
sl@0:   WCHAR *zName = utf8ToUnicode(zFilename);
sl@0:   BOOL bInit = TRUE;
sl@0: 
sl@0:   /* Initialize the local lockdata */
sl@0:   ZeroMemory(&pFile->local, sizeof(pFile->local));
sl@0: 
sl@0:   /* Replace the backslashes from the filename and lowercase it
sl@0:   ** to derive a mutex name. */
sl@0:   zTok = CharLowerW(zName);
sl@0:   for (;*zTok;zTok++){
sl@0:     if (*zTok == '\\') *zTok = '_';
sl@0:   }
sl@0: 
sl@0:   /* Create/open the named mutex */
sl@0:   pFile->hMutex = CreateMutexW(NULL, FALSE, zName);
sl@0:   if (!pFile->hMutex){
sl@0:     free(zName);
sl@0:     return FALSE;
sl@0:   }
sl@0: 
sl@0:   /* Acquire the mutex before continuing */
sl@0:   winceMutexAcquire(pFile->hMutex);
sl@0:   
sl@0:   /* Since the names of named mutexes, semaphores, file mappings etc are 
sl@0:   ** case-sensitive, take advantage of that by uppercasing the mutex name
sl@0:   ** and using that as the shared filemapping name.
sl@0:   */
sl@0:   CharUpperW(zName);
sl@0:   pFile->hShared = CreateFileMappingW(INVALID_HANDLE_VALUE, NULL,
sl@0:                                        PAGE_READWRITE, 0, sizeof(winceLock),
sl@0:                                        zName);  
sl@0: 
sl@0:   /* Set a flag that indicates we're the first to create the memory so it 
sl@0:   ** must be zero-initialized */
sl@0:   if (GetLastError() == ERROR_ALREADY_EXISTS){
sl@0:     bInit = FALSE;
sl@0:   }
sl@0: 
sl@0:   free(zName);
sl@0: 
sl@0:   /* If we succeeded in making the shared memory handle, map it. */
sl@0:   if (pFile->hShared){
sl@0:     pFile->shared = (winceLock*)MapViewOfFile(pFile->hShared, 
sl@0:              FILE_MAP_READ|FILE_MAP_WRITE, 0, 0, sizeof(winceLock));
sl@0:     /* If mapping failed, close the shared memory handle and erase it */
sl@0:     if (!pFile->shared){
sl@0:       CloseHandle(pFile->hShared);
sl@0:       pFile->hShared = NULL;
sl@0:     }
sl@0:   }
sl@0: 
sl@0:   /* If shared memory could not be created, then close the mutex and fail */
sl@0:   if (pFile->hShared == NULL){
sl@0:     winceMutexRelease(pFile->hMutex);
sl@0:     CloseHandle(pFile->hMutex);
sl@0:     pFile->hMutex = NULL;
sl@0:     return FALSE;
sl@0:   }
sl@0:   
sl@0:   /* Initialize the shared memory if we're supposed to */
sl@0:   if (bInit) {
sl@0:     ZeroMemory(pFile->shared, sizeof(winceLock));
sl@0:   }
sl@0: 
sl@0:   winceMutexRelease(pFile->hMutex);
sl@0:   return TRUE;
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Destroy the part of winFile that deals with wince locks
sl@0: */
sl@0: static void winceDestroyLock(winFile *pFile){
sl@0:   if (pFile->hMutex){
sl@0:     /* Acquire the mutex */
sl@0:     winceMutexAcquire(pFile->hMutex);
sl@0: 
sl@0:     /* The following blocks should probably assert in debug mode, but they
sl@0:        are to cleanup in case any locks remained open */
sl@0:     if (pFile->local.nReaders){
sl@0:       pFile->shared->nReaders --;
sl@0:     }
sl@0:     if (pFile->local.bReserved){
sl@0:       pFile->shared->bReserved = FALSE;
sl@0:     }
sl@0:     if (pFile->local.bPending){
sl@0:       pFile->shared->bPending = FALSE;
sl@0:     }
sl@0:     if (pFile->local.bExclusive){
sl@0:       pFile->shared->bExclusive = FALSE;
sl@0:     }
sl@0: 
sl@0:     /* De-reference and close our copy of the shared memory handle */
sl@0:     UnmapViewOfFile(pFile->shared);
sl@0:     CloseHandle(pFile->hShared);
sl@0: 
sl@0:     /* Done with the mutex */
sl@0:     winceMutexRelease(pFile->hMutex);    
sl@0:     CloseHandle(pFile->hMutex);
sl@0:     pFile->hMutex = NULL;
sl@0:   }
sl@0: }
sl@0: 
sl@0: /* 
sl@0: ** An implementation of the LockFile() API of windows for wince
sl@0: */
sl@0: static BOOL winceLockFile(
sl@0:   HANDLE *phFile,
sl@0:   DWORD dwFileOffsetLow,
sl@0:   DWORD dwFileOffsetHigh,
sl@0:   DWORD nNumberOfBytesToLockLow,
sl@0:   DWORD nNumberOfBytesToLockHigh
sl@0: ){
sl@0:   winFile *pFile = HANDLE_TO_WINFILE(phFile);
sl@0:   BOOL bReturn = FALSE;
sl@0: 
sl@0:   if (!pFile->hMutex) return TRUE;
sl@0:   winceMutexAcquire(pFile->hMutex);
sl@0: 
sl@0:   /* Wanting an exclusive lock? */
sl@0:   if (dwFileOffsetLow == SHARED_FIRST
sl@0:        && nNumberOfBytesToLockLow == SHARED_SIZE){
sl@0:     if (pFile->shared->nReaders == 0 && pFile->shared->bExclusive == 0){
sl@0:        pFile->shared->bExclusive = TRUE;
sl@0:        pFile->local.bExclusive = TRUE;
sl@0:        bReturn = TRUE;
sl@0:     }
sl@0:   }
sl@0: 
sl@0:   /* Want a read-only lock? */
sl@0:   else if ((dwFileOffsetLow >= SHARED_FIRST &&
sl@0:             dwFileOffsetLow < SHARED_FIRST + SHARED_SIZE) &&
sl@0:             nNumberOfBytesToLockLow == 1){
sl@0:     if (pFile->shared->bExclusive == 0){
sl@0:       pFile->local.nReaders ++;
sl@0:       if (pFile->local.nReaders == 1){
sl@0:         pFile->shared->nReaders ++;
sl@0:       }
sl@0:       bReturn = TRUE;
sl@0:     }
sl@0:   }
sl@0: 
sl@0:   /* Want a pending lock? */
sl@0:   else if (dwFileOffsetLow == PENDING_BYTE && nNumberOfBytesToLockLow == 1){
sl@0:     /* If no pending lock has been acquired, then acquire it */
sl@0:     if (pFile->shared->bPending == 0) {
sl@0:       pFile->shared->bPending = TRUE;
sl@0:       pFile->local.bPending = TRUE;
sl@0:       bReturn = TRUE;
sl@0:     }
sl@0:   }
sl@0:   /* Want a reserved lock? */
sl@0:   else if (dwFileOffsetLow == RESERVED_BYTE && nNumberOfBytesToLockLow == 1){
sl@0:     if (pFile->shared->bReserved == 0) {
sl@0:       pFile->shared->bReserved = TRUE;
sl@0:       pFile->local.bReserved = TRUE;
sl@0:       bReturn = TRUE;
sl@0:     }
sl@0:   }
sl@0: 
sl@0:   winceMutexRelease(pFile->hMutex);
sl@0:   return bReturn;
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** An implementation of the UnlockFile API of windows for wince
sl@0: */
sl@0: static BOOL winceUnlockFile(
sl@0:   HANDLE *phFile,
sl@0:   DWORD dwFileOffsetLow,
sl@0:   DWORD dwFileOffsetHigh,
sl@0:   DWORD nNumberOfBytesToUnlockLow,
sl@0:   DWORD nNumberOfBytesToUnlockHigh
sl@0: ){
sl@0:   winFile *pFile = HANDLE_TO_WINFILE(phFile);
sl@0:   BOOL bReturn = FALSE;
sl@0: 
sl@0:   if (!pFile->hMutex) return TRUE;
sl@0:   winceMutexAcquire(pFile->hMutex);
sl@0: 
sl@0:   /* Releasing a reader lock or an exclusive lock */
sl@0:   if (dwFileOffsetLow >= SHARED_FIRST &&
sl@0:        dwFileOffsetLow < SHARED_FIRST + SHARED_SIZE){
sl@0:     /* Did we have an exclusive lock? */
sl@0:     if (pFile->local.bExclusive){
sl@0:       pFile->local.bExclusive = FALSE;
sl@0:       pFile->shared->bExclusive = FALSE;
sl@0:       bReturn = TRUE;
sl@0:     }
sl@0: 
sl@0:     /* Did we just have a reader lock? */
sl@0:     else if (pFile->local.nReaders){
sl@0:       pFile->local.nReaders --;
sl@0:       if (pFile->local.nReaders == 0)
sl@0:       {
sl@0:         pFile->shared->nReaders --;
sl@0:       }
sl@0:       bReturn = TRUE;
sl@0:     }
sl@0:   }
sl@0: 
sl@0:   /* Releasing a pending lock */
sl@0:   else if (dwFileOffsetLow == PENDING_BYTE && nNumberOfBytesToUnlockLow == 1){
sl@0:     if (pFile->local.bPending){
sl@0:       pFile->local.bPending = FALSE;
sl@0:       pFile->shared->bPending = FALSE;
sl@0:       bReturn = TRUE;
sl@0:     }
sl@0:   }
sl@0:   /* Releasing a reserved lock */
sl@0:   else if (dwFileOffsetLow == RESERVED_BYTE && nNumberOfBytesToUnlockLow == 1){
sl@0:     if (pFile->local.bReserved) {
sl@0:       pFile->local.bReserved = FALSE;
sl@0:       pFile->shared->bReserved = FALSE;
sl@0:       bReturn = TRUE;
sl@0:     }
sl@0:   }
sl@0: 
sl@0:   winceMutexRelease(pFile->hMutex);
sl@0:   return bReturn;
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** An implementation of the LockFileEx() API of windows for wince
sl@0: */
sl@0: static BOOL winceLockFileEx(
sl@0:   HANDLE *phFile,
sl@0:   DWORD dwFlags,
sl@0:   DWORD dwReserved,
sl@0:   DWORD nNumberOfBytesToLockLow,
sl@0:   DWORD nNumberOfBytesToLockHigh,
sl@0:   LPOVERLAPPED lpOverlapped
sl@0: ){
sl@0:   /* If the caller wants a shared read lock, forward this call
sl@0:   ** to winceLockFile */
sl@0:   if (lpOverlapped->Offset == SHARED_FIRST &&
sl@0:       dwFlags == 1 &&
sl@0:       nNumberOfBytesToLockLow == SHARED_SIZE){
sl@0:     return winceLockFile(phFile, SHARED_FIRST, 0, 1, 0);
sl@0:   }
sl@0:   return FALSE;
sl@0: }
sl@0: /*
sl@0: ** End of the special code for wince
sl@0: *****************************************************************************/
sl@0: #endif /* SQLITE_OS_WINCE */
sl@0: 
sl@0: /*****************************************************************************
sl@0: ** The next group of routines implement the I/O methods specified
sl@0: ** by the sqlite3_io_methods object.
sl@0: ******************************************************************************/
sl@0: 
sl@0: /*
sl@0: ** Close a file.
sl@0: **
sl@0: ** It is reported that an attempt to close a handle might sometimes
sl@0: ** fail.  This is a very unreasonable result, but windows is notorious
sl@0: ** for being unreasonable so I do not doubt that it might happen.  If
sl@0: ** the close fails, we pause for 100 milliseconds and try again.  As
sl@0: ** many as MX_CLOSE_ATTEMPT attempts to close the handle are made before
sl@0: ** giving up and returning an error.
sl@0: */
sl@0: #define MX_CLOSE_ATTEMPT 3
sl@0: static int winClose(sqlite3_file *id){
sl@0:   int rc, cnt = 0;
sl@0:   winFile *pFile = (winFile*)id;
sl@0:   OSTRACE2("CLOSE %d\n", pFile->h);
sl@0:   do{
sl@0:     rc = CloseHandle(pFile->h);
sl@0:   }while( rc==0 && ++cnt < MX_CLOSE_ATTEMPT && (Sleep(100), 1) );
sl@0: #if SQLITE_OS_WINCE
sl@0: #define WINCE_DELETION_ATTEMPTS 3
sl@0:   winceDestroyLock(pFile);
sl@0:   if( pFile->zDeleteOnClose ){
sl@0:     int cnt = 0;
sl@0:     while(
sl@0:            DeleteFileW(pFile->zDeleteOnClose)==0
sl@0:         && GetFileAttributesW(pFile->zDeleteOnClose)!=0xffffffff 
sl@0:         && cnt++ < WINCE_DELETION_ATTEMPTS
sl@0:     ){
sl@0:        Sleep(100);  /* Wait a little before trying again */
sl@0:     }
sl@0:     free(pFile->zDeleteOnClose);
sl@0:   }
sl@0: #endif
sl@0:   OpenCounter(-1);
sl@0:   return rc ? SQLITE_OK : SQLITE_IOERR;
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Some microsoft compilers lack this definition.
sl@0: */
sl@0: #ifndef INVALID_SET_FILE_POINTER
sl@0: # define INVALID_SET_FILE_POINTER ((DWORD)-1)
sl@0: #endif
sl@0: 
sl@0: /*
sl@0: ** Read data from a file into a buffer.  Return SQLITE_OK if all
sl@0: ** bytes were read successfully and SQLITE_IOERR if anything goes
sl@0: ** wrong.
sl@0: */
sl@0: static int winRead(
sl@0:   sqlite3_file *id,          /* File to read from */
sl@0:   void *pBuf,                /* Write content into this buffer */
sl@0:   int amt,                   /* Number of bytes to read */
sl@0:   sqlite3_int64 offset       /* Begin reading at this offset */
sl@0: ){
sl@0:   LONG upperBits = (offset>>32) & 0x7fffffff;
sl@0:   LONG lowerBits = offset & 0xffffffff;
sl@0:   DWORD rc;
sl@0:   DWORD got;
sl@0:   winFile *pFile = (winFile*)id;
sl@0:   assert( id!=0 );
sl@0:   SimulateIOError(return SQLITE_IOERR_READ);
sl@0:   OSTRACE3("READ %d lock=%d\n", pFile->h, pFile->locktype);
sl@0:   rc = SetFilePointer(pFile->h, lowerBits, &upperBits, FILE_BEGIN);
sl@0:   if( rc==INVALID_SET_FILE_POINTER && GetLastError()!=NO_ERROR ){
sl@0:     return SQLITE_FULL;
sl@0:   }
sl@0:   if( !ReadFile(pFile->h, pBuf, amt, &got, 0) ){
sl@0:     return SQLITE_IOERR_READ;
sl@0:   }
sl@0:   if( got==(DWORD)amt ){
sl@0:     return SQLITE_OK;
sl@0:   }else{
sl@0:     memset(&((char*)pBuf)[got], 0, amt-got);
sl@0:     return SQLITE_IOERR_SHORT_READ;
sl@0:   }
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Write data from a buffer into a file.  Return SQLITE_OK on success
sl@0: ** or some other error code on failure.
sl@0: */
sl@0: static int winWrite(
sl@0:   sqlite3_file *id,         /* File to write into */
sl@0:   const void *pBuf,         /* The bytes to be written */
sl@0:   int amt,                  /* Number of bytes to write */
sl@0:   sqlite3_int64 offset      /* Offset into the file to begin writing at */
sl@0: ){
sl@0:   LONG upperBits = (offset>>32) & 0x7fffffff;
sl@0:   LONG lowerBits = offset & 0xffffffff;
sl@0:   DWORD rc;
sl@0:   DWORD wrote;
sl@0:   winFile *pFile = (winFile*)id;
sl@0:   assert( id!=0 );
sl@0:   SimulateIOError(return SQLITE_IOERR_WRITE);
sl@0:   SimulateDiskfullError(return SQLITE_FULL);
sl@0:   OSTRACE3("WRITE %d lock=%d\n", pFile->h, pFile->locktype);
sl@0:   rc = SetFilePointer(pFile->h, lowerBits, &upperBits, FILE_BEGIN);
sl@0:   if( rc==INVALID_SET_FILE_POINTER && GetLastError()!=NO_ERROR ){
sl@0:     return SQLITE_FULL;
sl@0:   }
sl@0:   assert( amt>0 );
sl@0:   while(
sl@0:      amt>0
sl@0:      && (rc = WriteFile(pFile->h, pBuf, amt, &wrote, 0))!=0
sl@0:      && wrote>0
sl@0:   ){
sl@0:     amt -= wrote;
sl@0:     pBuf = &((char*)pBuf)[wrote];
sl@0:   }
sl@0:   if( !rc || amt>(int)wrote ){
sl@0:     return SQLITE_FULL;
sl@0:   }
sl@0:   return SQLITE_OK;
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Truncate an open file to a specified size
sl@0: */
sl@0: static int winTruncate(sqlite3_file *id, sqlite3_int64 nByte){
sl@0:   LONG upperBits = (nByte>>32) & 0x7fffffff;
sl@0:   LONG lowerBits = nByte & 0xffffffff;
sl@0:   winFile *pFile = (winFile*)id;
sl@0:   OSTRACE3("TRUNCATE %d %lld\n", pFile->h, nByte);
sl@0:   SimulateIOError(return SQLITE_IOERR_TRUNCATE);
sl@0:   SetFilePointer(pFile->h, lowerBits, &upperBits, FILE_BEGIN);
sl@0:   SetEndOfFile(pFile->h);
sl@0:   return SQLITE_OK;
sl@0: }
sl@0: 
sl@0: #ifdef SQLITE_TEST
sl@0: /*
sl@0: ** Count the number of fullsyncs and normal syncs.  This is used to test
sl@0: ** that syncs and fullsyncs are occuring at the right times.
sl@0: */
sl@0: int sqlite3_sync_count = 0;
sl@0: int sqlite3_fullsync_count = 0;
sl@0: #endif
sl@0: 
sl@0: /*
sl@0: ** Make sure all writes to a particular file are committed to disk.
sl@0: */
sl@0: static int winSync(sqlite3_file *id, int flags){
sl@0:   winFile *pFile = (winFile*)id;
sl@0:   OSTRACE3("SYNC %d lock=%d\n", pFile->h, pFile->locktype);
sl@0: #ifdef SQLITE_TEST
sl@0:   if( flags & SQLITE_SYNC_FULL ){
sl@0:     sqlite3_fullsync_count++;
sl@0:   }
sl@0:   sqlite3_sync_count++;
sl@0: #endif
sl@0:   if( FlushFileBuffers(pFile->h) ){
sl@0:     return SQLITE_OK;
sl@0:   }else{
sl@0:     return SQLITE_IOERR;
sl@0:   }
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Determine the current size of a file in bytes
sl@0: */
sl@0: static int winFileSize(sqlite3_file *id, sqlite3_int64 *pSize){
sl@0:   winFile *pFile = (winFile*)id;
sl@0:   DWORD upperBits, lowerBits;
sl@0:   SimulateIOError(return SQLITE_IOERR_FSTAT);
sl@0:   lowerBits = GetFileSize(pFile->h, &upperBits);
sl@0:   *pSize = (((sqlite3_int64)upperBits)<<32) + lowerBits;
sl@0:   return SQLITE_OK;
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** LOCKFILE_FAIL_IMMEDIATELY is undefined on some Windows systems.
sl@0: */
sl@0: #ifndef LOCKFILE_FAIL_IMMEDIATELY
sl@0: # define LOCKFILE_FAIL_IMMEDIATELY 1
sl@0: #endif
sl@0: 
sl@0: /*
sl@0: ** Acquire a reader lock.
sl@0: ** Different API routines are called depending on whether or not this
sl@0: ** is Win95 or WinNT.
sl@0: */
sl@0: static int getReadLock(winFile *pFile){
sl@0:   int res;
sl@0:   if( isNT() ){
sl@0:     OVERLAPPED ovlp;
sl@0:     ovlp.Offset = SHARED_FIRST;
sl@0:     ovlp.OffsetHigh = 0;
sl@0:     ovlp.hEvent = 0;
sl@0:     res = LockFileEx(pFile->h, LOCKFILE_FAIL_IMMEDIATELY,
sl@0:                      0, SHARED_SIZE, 0, &ovlp);
sl@0:   }else{
sl@0:     int lk;
sl@0:     sqlite3_randomness(sizeof(lk), &lk);
sl@0:     pFile->sharedLockByte = (lk & 0x7fffffff)%(SHARED_SIZE - 1);
sl@0:     res = LockFile(pFile->h, SHARED_FIRST+pFile->sharedLockByte, 0, 1, 0);
sl@0:   }
sl@0:   return res;
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Undo a readlock
sl@0: */
sl@0: static int unlockReadLock(winFile *pFile){
sl@0:   int res;
sl@0:   if( isNT() ){
sl@0:     res = UnlockFile(pFile->h, SHARED_FIRST, 0, SHARED_SIZE, 0);
sl@0:   }else{
sl@0:     res = UnlockFile(pFile->h, SHARED_FIRST + pFile->sharedLockByte, 0, 1, 0);
sl@0:   }
sl@0:   return res;
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Lock the file with the lock specified by parameter locktype - one
sl@0: ** of the following:
sl@0: **
sl@0: **     (1) SHARED_LOCK
sl@0: **     (2) RESERVED_LOCK
sl@0: **     (3) PENDING_LOCK
sl@0: **     (4) EXCLUSIVE_LOCK
sl@0: **
sl@0: ** Sometimes when requesting one lock state, additional lock states
sl@0: ** are inserted in between.  The locking might fail on one of the later
sl@0: ** transitions leaving the lock state different from what it started but
sl@0: ** still short of its goal.  The following chart shows the allowed
sl@0: ** transitions and the inserted intermediate states:
sl@0: **
sl@0: **    UNLOCKED -> SHARED
sl@0: **    SHARED -> RESERVED
sl@0: **    SHARED -> (PENDING) -> EXCLUSIVE
sl@0: **    RESERVED -> (PENDING) -> EXCLUSIVE
sl@0: **    PENDING -> EXCLUSIVE
sl@0: **
sl@0: ** This routine will only increase a lock.  The winUnlock() routine
sl@0: ** erases all locks at once and returns us immediately to locking level 0.
sl@0: ** It is not possible to lower the locking level one step at a time.  You
sl@0: ** must go straight to locking level 0.
sl@0: */
sl@0: static int winLock(sqlite3_file *id, int locktype){
sl@0:   int rc = SQLITE_OK;    /* Return code from subroutines */
sl@0:   int res = 1;           /* Result of a windows lock call */
sl@0:   int newLocktype;       /* Set pFile->locktype to this value before exiting */
sl@0:   int gotPendingLock = 0;/* True if we acquired a PENDING lock this time */
sl@0:   winFile *pFile = (winFile*)id;
sl@0: 
sl@0:   assert( pFile!=0 );
sl@0:   OSTRACE5("LOCK %d %d was %d(%d)\n",
sl@0:           pFile->h, locktype, pFile->locktype, pFile->sharedLockByte);
sl@0: 
sl@0:   /* If there is already a lock of this type or more restrictive on the
sl@0:   ** OsFile, do nothing. Don't use the end_lock: exit path, as
sl@0:   ** sqlite3OsEnterMutex() hasn't been called yet.
sl@0:   */
sl@0:   if( pFile->locktype>=locktype ){
sl@0:     return SQLITE_OK;
sl@0:   }
sl@0: 
sl@0:   /* Make sure the locking sequence is correct
sl@0:   */
sl@0:   assert( pFile->locktype!=NO_LOCK || locktype==SHARED_LOCK );
sl@0:   assert( locktype!=PENDING_LOCK );
sl@0:   assert( locktype!=RESERVED_LOCK || pFile->locktype==SHARED_LOCK );
sl@0: 
sl@0:   /* Lock the PENDING_LOCK byte if we need to acquire a PENDING lock or
sl@0:   ** a SHARED lock.  If we are acquiring a SHARED lock, the acquisition of
sl@0:   ** the PENDING_LOCK byte is temporary.
sl@0:   */
sl@0:   newLocktype = pFile->locktype;
sl@0:   if( pFile->locktype==NO_LOCK
sl@0:    || (locktype==EXCLUSIVE_LOCK && pFile->locktype==RESERVED_LOCK)
sl@0:   ){
sl@0:     int cnt = 3;
sl@0:     while( cnt-->0 && (res = LockFile(pFile->h, PENDING_BYTE, 0, 1, 0))==0 ){
sl@0:       /* Try 3 times to get the pending lock.  The pending lock might be
sl@0:       ** held by another reader process who will release it momentarily.
sl@0:       */
sl@0:       OSTRACE2("could not get a PENDING lock. cnt=%d\n", cnt);
sl@0:       Sleep(1);
sl@0:     }
sl@0:     gotPendingLock = res;
sl@0:   }
sl@0: 
sl@0:   /* Acquire a shared lock
sl@0:   */
sl@0:   if( locktype==SHARED_LOCK && res ){
sl@0:     assert( pFile->locktype==NO_LOCK );
sl@0:     res = getReadLock(pFile);
sl@0:     if( res ){
sl@0:       newLocktype = SHARED_LOCK;
sl@0:     }
sl@0:   }
sl@0: 
sl@0:   /* Acquire a RESERVED lock
sl@0:   */
sl@0:   if( locktype==RESERVED_LOCK && res ){
sl@0:     assert( pFile->locktype==SHARED_LOCK );
sl@0:     res = LockFile(pFile->h, RESERVED_BYTE, 0, 1, 0);
sl@0:     if( res ){
sl@0:       newLocktype = RESERVED_LOCK;
sl@0:     }
sl@0:   }
sl@0: 
sl@0:   /* Acquire a PENDING lock
sl@0:   */
sl@0:   if( locktype==EXCLUSIVE_LOCK && res ){
sl@0:     newLocktype = PENDING_LOCK;
sl@0:     gotPendingLock = 0;
sl@0:   }
sl@0: 
sl@0:   /* Acquire an EXCLUSIVE lock
sl@0:   */
sl@0:   if( locktype==EXCLUSIVE_LOCK && res ){
sl@0:     assert( pFile->locktype>=SHARED_LOCK );
sl@0:     res = unlockReadLock(pFile);
sl@0:     OSTRACE2("unreadlock = %d\n", res);
sl@0:     res = LockFile(pFile->h, SHARED_FIRST, 0, SHARED_SIZE, 0);
sl@0:     if( res ){
sl@0:       newLocktype = EXCLUSIVE_LOCK;
sl@0:     }else{
sl@0:       OSTRACE2("error-code = %d\n", GetLastError());
sl@0:       getReadLock(pFile);
sl@0:     }
sl@0:   }
sl@0: 
sl@0:   /* If we are holding a PENDING lock that ought to be released, then
sl@0:   ** release it now.
sl@0:   */
sl@0:   if( gotPendingLock && locktype==SHARED_LOCK ){
sl@0:     UnlockFile(pFile->h, PENDING_BYTE, 0, 1, 0);
sl@0:   }
sl@0: 
sl@0:   /* Update the state of the lock has held in the file descriptor then
sl@0:   ** return the appropriate result code.
sl@0:   */
sl@0:   if( res ){
sl@0:     rc = SQLITE_OK;
sl@0:   }else{
sl@0:     OSTRACE4("LOCK FAILED %d trying for %d but got %d\n", pFile->h,
sl@0:            locktype, newLocktype);
sl@0:     rc = SQLITE_BUSY;
sl@0:   }
sl@0:   pFile->locktype = newLocktype;
sl@0:   return rc;
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** This routine checks if there is a RESERVED lock held on the specified
sl@0: ** file by this or any other process. If such a lock is held, return
sl@0: ** non-zero, otherwise zero.
sl@0: */
sl@0: static int winCheckReservedLock(sqlite3_file *id, int *pResOut){
sl@0:   int rc;
sl@0:   winFile *pFile = (winFile*)id;
sl@0:   assert( pFile!=0 );
sl@0:   if( pFile->locktype>=RESERVED_LOCK ){
sl@0:     rc = 1;
sl@0:     OSTRACE3("TEST WR-LOCK %d %d (local)\n", pFile->h, rc);
sl@0:   }else{
sl@0:     rc = LockFile(pFile->h, RESERVED_BYTE, 0, 1, 0);
sl@0:     if( rc ){
sl@0:       UnlockFile(pFile->h, RESERVED_BYTE, 0, 1, 0);
sl@0:     }
sl@0:     rc = !rc;
sl@0:     OSTRACE3("TEST WR-LOCK %d %d (remote)\n", pFile->h, rc);
sl@0:   }
sl@0:   *pResOut = rc;
sl@0:   return SQLITE_OK;
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Lower the locking level on file descriptor id to locktype.  locktype
sl@0: ** must be either NO_LOCK or SHARED_LOCK.
sl@0: **
sl@0: ** If the locking level of the file descriptor is already at or below
sl@0: ** the requested locking level, this routine is a no-op.
sl@0: **
sl@0: ** It is not possible for this routine to fail if the second argument
sl@0: ** is NO_LOCK.  If the second argument is SHARED_LOCK then this routine
sl@0: ** might return SQLITE_IOERR;
sl@0: */
sl@0: static int winUnlock(sqlite3_file *id, int locktype){
sl@0:   int type;
sl@0:   winFile *pFile = (winFile*)id;
sl@0:   int rc = SQLITE_OK;
sl@0:   assert( pFile!=0 );
sl@0:   assert( locktype<=SHARED_LOCK );
sl@0:   OSTRACE5("UNLOCK %d to %d was %d(%d)\n", pFile->h, locktype,
sl@0:           pFile->locktype, pFile->sharedLockByte);
sl@0:   type = pFile->locktype;
sl@0:   if( type>=EXCLUSIVE_LOCK ){
sl@0:     UnlockFile(pFile->h, SHARED_FIRST, 0, SHARED_SIZE, 0);
sl@0:     if( locktype==SHARED_LOCK && !getReadLock(pFile) ){
sl@0:       /* This should never happen.  We should always be able to
sl@0:       ** reacquire the read lock */
sl@0:       rc = SQLITE_IOERR_UNLOCK;
sl@0:     }
sl@0:   }
sl@0:   if( type>=RESERVED_LOCK ){
sl@0:     UnlockFile(pFile->h, RESERVED_BYTE, 0, 1, 0);
sl@0:   }
sl@0:   if( locktype==NO_LOCK && type>=SHARED_LOCK ){
sl@0:     unlockReadLock(pFile);
sl@0:   }
sl@0:   if( type>=PENDING_LOCK ){
sl@0:     UnlockFile(pFile->h, PENDING_BYTE, 0, 1, 0);
sl@0:   }
sl@0:   pFile->locktype = locktype;
sl@0:   return rc;
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Control and query of the open file handle.
sl@0: */
sl@0: static int winFileControl(sqlite3_file *id, int op, void *pArg){
sl@0:   switch( op ){
sl@0:     case SQLITE_FCNTL_LOCKSTATE: {
sl@0:       *(int*)pArg = ((winFile*)id)->locktype;
sl@0:       return SQLITE_OK;
sl@0:     }
sl@0:   }
sl@0:   return SQLITE_ERROR;
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Return the sector size in bytes of the underlying block device for
sl@0: ** the specified file. This is almost always 512 bytes, but may be
sl@0: ** larger for some devices.
sl@0: **
sl@0: ** SQLite code assumes this function cannot fail. It also assumes that
sl@0: ** if two files are created in the same file-system directory (i.e.
sl@0: ** a database and its journal file) that the sector size will be the
sl@0: ** same for both.
sl@0: */
sl@0: static int winSectorSize(sqlite3_file *id){
sl@0:   return SQLITE_DEFAULT_SECTOR_SIZE;
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Return a vector of device characteristics.
sl@0: */
sl@0: static int winDeviceCharacteristics(sqlite3_file *id){
sl@0:   return 0;
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** This vector defines all the methods that can operate on an
sl@0: ** sqlite3_file for win32.
sl@0: */
sl@0: static const sqlite3_io_methods winIoMethod = {
sl@0:   1,                        /* iVersion */
sl@0:   winClose,
sl@0:   winRead,
sl@0:   winWrite,
sl@0:   winTruncate,
sl@0:   winSync,
sl@0:   winFileSize,
sl@0:   winLock,
sl@0:   winUnlock,
sl@0:   winCheckReservedLock,
sl@0:   winFileControl,
sl@0:   winSectorSize,
sl@0:   winDeviceCharacteristics
sl@0: };
sl@0: 
sl@0: /***************************************************************************
sl@0: ** Here ends the I/O methods that form the sqlite3_io_methods object.
sl@0: **
sl@0: ** The next block of code implements the VFS methods.
sl@0: ****************************************************************************/
sl@0: 
sl@0: /*
sl@0: ** Convert a UTF-8 filename into whatever form the underlying
sl@0: ** operating system wants filenames in.  Space to hold the result
sl@0: ** is obtained from malloc and must be freed by the calling
sl@0: ** function.
sl@0: */
sl@0: static void *convertUtf8Filename(const char *zFilename){
sl@0:   void *zConverted = 0;
sl@0:   if( isNT() ){
sl@0:     zConverted = utf8ToUnicode(zFilename);
sl@0:   }else{
sl@0:     zConverted = utf8ToMbcs(zFilename);
sl@0:   }
sl@0:   /* caller will handle out of memory */
sl@0:   return zConverted;
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Create a temporary file name in zBuf.  zBuf must be big enough to
sl@0: ** hold at pVfs->mxPathname characters.
sl@0: */
sl@0: static int getTempname(int nBuf, char *zBuf){
sl@0:   static char zChars[] =
sl@0:     "abcdefghijklmnopqrstuvwxyz"
sl@0:     "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
sl@0:     "0123456789";
sl@0:   size_t i, j;
sl@0:   char zTempPath[MAX_PATH+1];
sl@0:   if( sqlite3_temp_directory ){
sl@0:     sqlite3_snprintf(MAX_PATH-30, zTempPath, "%s", sqlite3_temp_directory);
sl@0:   }else if( isNT() ){
sl@0:     char *zMulti;
sl@0:     WCHAR zWidePath[MAX_PATH];
sl@0:     GetTempPathW(MAX_PATH-30, zWidePath);
sl@0:     zMulti = unicodeToUtf8(zWidePath);
sl@0:     if( zMulti ){
sl@0:       sqlite3_snprintf(MAX_PATH-30, zTempPath, "%s", zMulti);
sl@0:       free(zMulti);
sl@0:     }else{
sl@0:       return SQLITE_NOMEM;
sl@0:     }
sl@0:   }else{
sl@0:     char *zUtf8;
sl@0:     char zMbcsPath[MAX_PATH];
sl@0:     GetTempPathA(MAX_PATH-30, zMbcsPath);
sl@0:     zUtf8 = mbcsToUtf8(zMbcsPath);
sl@0:     if( zUtf8 ){
sl@0:       sqlite3_snprintf(MAX_PATH-30, zTempPath, "%s", zUtf8);
sl@0:       free(zUtf8);
sl@0:     }else{
sl@0:       return SQLITE_NOMEM;
sl@0:     }
sl@0:   }
sl@0:   for(i=strlen(zTempPath); i>0 && zTempPath[i-1]=='\\'; i--){}
sl@0:   zTempPath[i] = 0;
sl@0:   sqlite3_snprintf(nBuf-30, zBuf,
sl@0:                    "%s\\"SQLITE_TEMP_FILE_PREFIX, zTempPath);
sl@0:   j = strlen(zBuf);
sl@0:   sqlite3_randomness(20, &zBuf[j]);
sl@0:   for(i=0; i<20; i++, j++){
sl@0:     zBuf[j] = (char)zChars[ ((unsigned char)zBuf[j])%(sizeof(zChars)-1) ];
sl@0:   }
sl@0:   zBuf[j] = 0;
sl@0:   OSTRACE2("TEMP FILENAME: %s\n", zBuf);
sl@0:   return SQLITE_OK; 
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** The return value of getLastErrorMsg
sl@0: ** is zero if the error message fits in the buffer, or non-zero
sl@0: ** otherwise (if the message was truncated).
sl@0: */
sl@0: static int getLastErrorMsg(int nBuf, char *zBuf){
sl@0:   DWORD error = GetLastError();
sl@0: 
sl@0: #if SQLITE_OS_WINCE
sl@0:   sqlite3_snprintf(nBuf, zBuf, "OsError 0x%x (%u)", error, error);
sl@0: #else
sl@0:   /* FormatMessage returns 0 on failure.  Otherwise it
sl@0:   ** returns the number of TCHARs written to the output
sl@0:   ** buffer, excluding the terminating null char.
sl@0:   */
sl@0:   if (!FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM,
sl@0:                       NULL,
sl@0:                       error,
sl@0:                       0,
sl@0:                       zBuf,
sl@0:                       nBuf-1,
sl@0:                       0))
sl@0:   {
sl@0:     sqlite3_snprintf(nBuf, zBuf, "OsError 0x%x (%u)", error, error);
sl@0:   }
sl@0: #endif
sl@0: 
sl@0:   return 0;
sl@0: }
sl@0: 
sl@0: 
sl@0: /*
sl@0: ** Open a file.
sl@0: */
sl@0: static int winOpen(
sl@0:   sqlite3_vfs *pVfs,        /* Not used */
sl@0:   const char *zName,        /* Name of the file (UTF-8) */
sl@0:   sqlite3_file *id,         /* Write the SQLite file handle here */
sl@0:   int flags,                /* Open mode flags */
sl@0:   int *pOutFlags            /* Status return flags */
sl@0: ){
sl@0:   HANDLE h;
sl@0:   DWORD dwDesiredAccess;
sl@0:   DWORD dwShareMode;
sl@0:   DWORD dwCreationDisposition;
sl@0:   DWORD dwFlagsAndAttributes = 0;
sl@0: #if SQLITE_OS_WINCE
sl@0:   int isTemp = 0;
sl@0: #endif
sl@0:   winFile *pFile = (winFile*)id;
sl@0:   void *zConverted;                 /* Filename in OS encoding */
sl@0:   const char *zUtf8Name = zName;    /* Filename in UTF-8 encoding */
sl@0:   char zTmpname[MAX_PATH+1];        /* Buffer used to create temp filename */
sl@0: 
sl@0:   /* If the second argument to this function is NULL, generate a 
sl@0:   ** temporary file name to use 
sl@0:   */
sl@0:   if( !zUtf8Name ){
sl@0:     int rc = getTempname(MAX_PATH+1, zTmpname);
sl@0:     if( rc!=SQLITE_OK ){
sl@0:       return rc;
sl@0:     }
sl@0:     zUtf8Name = zTmpname;
sl@0:   }
sl@0: 
sl@0:   /* Convert the filename to the system encoding. */
sl@0:   zConverted = convertUtf8Filename(zUtf8Name);
sl@0:   if( zConverted==0 ){
sl@0:     return SQLITE_NOMEM;
sl@0:   }
sl@0: 
sl@0:   if( flags & SQLITE_OPEN_READWRITE ){
sl@0:     dwDesiredAccess = GENERIC_READ | GENERIC_WRITE;
sl@0:   }else{
sl@0:     dwDesiredAccess = GENERIC_READ;
sl@0:   }
sl@0:   if( flags & SQLITE_OPEN_CREATE ){
sl@0:     dwCreationDisposition = OPEN_ALWAYS;
sl@0:   }else{
sl@0:     dwCreationDisposition = OPEN_EXISTING;
sl@0:   }
sl@0:   if( flags & SQLITE_OPEN_MAIN_DB ){
sl@0:     dwShareMode = FILE_SHARE_READ | FILE_SHARE_WRITE;
sl@0:   }else{
sl@0:     dwShareMode = 0;
sl@0:   }
sl@0:   if( flags & SQLITE_OPEN_DELETEONCLOSE ){
sl@0: #if SQLITE_OS_WINCE
sl@0:     dwFlagsAndAttributes = FILE_ATTRIBUTE_HIDDEN;
sl@0:     isTemp = 1;
sl@0: #else
sl@0:     dwFlagsAndAttributes = FILE_ATTRIBUTE_TEMPORARY
sl@0:                                | FILE_ATTRIBUTE_HIDDEN
sl@0:                                | FILE_FLAG_DELETE_ON_CLOSE;
sl@0: #endif
sl@0:   }else{
sl@0:     dwFlagsAndAttributes = FILE_ATTRIBUTE_NORMAL;
sl@0:   }
sl@0:   /* Reports from the internet are that performance is always
sl@0:   ** better if FILE_FLAG_RANDOM_ACCESS is used.  Ticket #2699. */
sl@0: #if SQLITE_OS_WINCE
sl@0:   dwFlagsAndAttributes |= FILE_FLAG_RANDOM_ACCESS;
sl@0: #endif
sl@0:   if( isNT() ){
sl@0:     h = CreateFileW((WCHAR*)zConverted,
sl@0:        dwDesiredAccess,
sl@0:        dwShareMode,
sl@0:        NULL,
sl@0:        dwCreationDisposition,
sl@0:        dwFlagsAndAttributes,
sl@0:        NULL
sl@0:     );
sl@0:   }else{
sl@0:     h = CreateFileA((char*)zConverted,
sl@0:        dwDesiredAccess,
sl@0:        dwShareMode,
sl@0:        NULL,
sl@0:        dwCreationDisposition,
sl@0:        dwFlagsAndAttributes,
sl@0:        NULL
sl@0:     );
sl@0:   }
sl@0:   if( h==INVALID_HANDLE_VALUE ){
sl@0:     free(zConverted);
sl@0:     if( flags & SQLITE_OPEN_READWRITE ){
sl@0:       return winOpen(0, zName, id, 
sl@0:              ((flags|SQLITE_OPEN_READONLY)&~SQLITE_OPEN_READWRITE), pOutFlags);
sl@0:     }else{
sl@0:       return SQLITE_CANTOPEN;
sl@0:     }
sl@0:   }
sl@0:   if( pOutFlags ){
sl@0:     if( flags & SQLITE_OPEN_READWRITE ){
sl@0:       *pOutFlags = SQLITE_OPEN_READWRITE;
sl@0:     }else{
sl@0:       *pOutFlags = SQLITE_OPEN_READONLY;
sl@0:     }
sl@0:   }
sl@0:   memset(pFile, 0, sizeof(*pFile));
sl@0:   pFile->pMethod = &winIoMethod;
sl@0:   pFile->h = h;
sl@0: #if SQLITE_OS_WINCE
sl@0:   if( (flags & (SQLITE_OPEN_READWRITE|SQLITE_OPEN_MAIN_DB)) ==
sl@0:                (SQLITE_OPEN_READWRITE|SQLITE_OPEN_MAIN_DB)
sl@0:        && !winceCreateLock(zName, pFile)
sl@0:   ){
sl@0:     CloseHandle(h);
sl@0:     free(zConverted);
sl@0:     return SQLITE_CANTOPEN;
sl@0:   }
sl@0:   if( isTemp ){
sl@0:     pFile->zDeleteOnClose = zConverted;
sl@0:   }else
sl@0: #endif
sl@0:   {
sl@0:     free(zConverted);
sl@0:   }
sl@0:   OpenCounter(+1);
sl@0:   return SQLITE_OK;
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Delete the named file.
sl@0: **
sl@0: ** Note that windows does not allow a file to be deleted if some other
sl@0: ** process has it open.  Sometimes a virus scanner or indexing program
sl@0: ** will open a journal file shortly after it is created in order to do
sl@0: ** whatever it does.  While this other process is holding the
sl@0: ** file open, we will be unable to delete it.  To work around this
sl@0: ** problem, we delay 100 milliseconds and try to delete again.  Up
sl@0: ** to MX_DELETION_ATTEMPTs deletion attempts are run before giving
sl@0: ** up and returning an error.
sl@0: */
sl@0: #define MX_DELETION_ATTEMPTS 5
sl@0: static int winDelete(
sl@0:   sqlite3_vfs *pVfs,          /* Not used on win32 */
sl@0:   const char *zFilename,      /* Name of file to delete */
sl@0:   int syncDir                 /* Not used on win32 */
sl@0: ){
sl@0:   int cnt = 0;
sl@0:   DWORD rc;
sl@0:   DWORD error;
sl@0:   void *zConverted = convertUtf8Filename(zFilename);
sl@0:   if( zConverted==0 ){
sl@0:     return SQLITE_NOMEM;
sl@0:   }
sl@0:   SimulateIOError(return SQLITE_IOERR_DELETE);
sl@0:   if( isNT() ){
sl@0:     do{
sl@0:       DeleteFileW(zConverted);
sl@0:     }while(   (   ((rc = GetFileAttributesW(zConverted)) != INVALID_FILE_ATTRIBUTES)
sl@0:                || ((error = GetLastError()) == ERROR_ACCESS_DENIED))
sl@0:            && (++cnt < MX_DELETION_ATTEMPTS)
sl@0:            && (Sleep(100), 1) );
sl@0:   }else{
sl@0:     do{
sl@0:       DeleteFileA(zConverted);
sl@0:     }while(   (   ((rc = GetFileAttributesA(zConverted)) != INVALID_FILE_ATTRIBUTES)
sl@0:                || ((error = GetLastError()) == ERROR_ACCESS_DENIED))
sl@0:            && (++cnt < MX_DELETION_ATTEMPTS)
sl@0:            && (Sleep(100), 1) );
sl@0:   }
sl@0:   free(zConverted);
sl@0:   OSTRACE2("DELETE \"%s\"\n", zFilename);
sl@0:   return (   (rc == INVALID_FILE_ATTRIBUTES) 
sl@0:           && (error == ERROR_FILE_NOT_FOUND)) ? SQLITE_OK : SQLITE_IOERR_DELETE;
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Check the existance and status of a file.
sl@0: */
sl@0: static int winAccess(
sl@0:   sqlite3_vfs *pVfs,         /* Not used on win32 */
sl@0:   const char *zFilename,     /* Name of file to check */
sl@0:   int flags,                 /* Type of test to make on this file */
sl@0:   int *pResOut               /* OUT: Result */
sl@0: ){
sl@0:   DWORD attr;
sl@0:   int rc;
sl@0:   void *zConverted = convertUtf8Filename(zFilename);
sl@0:   if( zConverted==0 ){
sl@0:     return SQLITE_NOMEM;
sl@0:   }
sl@0:   if( isNT() ){
sl@0:     attr = GetFileAttributesW((WCHAR*)zConverted);
sl@0:   }else{
sl@0:     attr = GetFileAttributesA((char*)zConverted);
sl@0:   }
sl@0:   free(zConverted);
sl@0:   switch( flags ){
sl@0:     case SQLITE_ACCESS_READ:
sl@0:     case SQLITE_ACCESS_EXISTS:
sl@0:       rc = attr!=INVALID_FILE_ATTRIBUTES;
sl@0:       break;
sl@0:     case SQLITE_ACCESS_READWRITE:
sl@0:       rc = (attr & FILE_ATTRIBUTE_READONLY)==0;
sl@0:       break;
sl@0:     default:
sl@0:       assert(!"Invalid flags argument");
sl@0:   }
sl@0:   *pResOut = rc;
sl@0:   return SQLITE_OK;
sl@0: }
sl@0: 
sl@0: 
sl@0: /*
sl@0: ** Turn a relative pathname into a full pathname.  Write the full
sl@0: ** pathname into zOut[].  zOut[] will be at least pVfs->mxPathname
sl@0: ** bytes in size.
sl@0: */
sl@0: static int winFullPathname(
sl@0:   sqlite3_vfs *pVfs,            /* Pointer to vfs object */
sl@0:   const char *zRelative,        /* Possibly relative input path */
sl@0:   int nFull,                    /* Size of output buffer in bytes */
sl@0:   char *zFull                   /* Output buffer */
sl@0: ){
sl@0: 
sl@0: #if defined(__CYGWIN__)
sl@0:   cygwin_conv_to_full_win32_path(zRelative, zFull);
sl@0:   return SQLITE_OK;
sl@0: #endif
sl@0: 
sl@0: #if SQLITE_OS_WINCE
sl@0:   /* WinCE has no concept of a relative pathname, or so I am told. */
sl@0:   sqlite3_snprintf(pVfs->mxPathname, zFull, "%s", zRelative);
sl@0:   return SQLITE_OK;
sl@0: #endif
sl@0: 
sl@0: #if !SQLITE_OS_WINCE && !defined(__CYGWIN__)
sl@0:   int nByte;
sl@0:   void *zConverted;
sl@0:   char *zOut;
sl@0:   zConverted = convertUtf8Filename(zRelative);
sl@0:   if( isNT() ){
sl@0:     WCHAR *zTemp;
sl@0:     nByte = GetFullPathNameW((WCHAR*)zConverted, 0, 0, 0) + 3;
sl@0:     zTemp = malloc( nByte*sizeof(zTemp[0]) );
sl@0:     if( zTemp==0 ){
sl@0:       free(zConverted);
sl@0:       return SQLITE_NOMEM;
sl@0:     }
sl@0:     GetFullPathNameW((WCHAR*)zConverted, nByte, zTemp, 0);
sl@0:     free(zConverted);
sl@0:     zOut = unicodeToUtf8(zTemp);
sl@0:     free(zTemp);
sl@0:   }else{
sl@0:     char *zTemp;
sl@0:     nByte = GetFullPathNameA((char*)zConverted, 0, 0, 0) + 3;
sl@0:     zTemp = malloc( nByte*sizeof(zTemp[0]) );
sl@0:     if( zTemp==0 ){
sl@0:       free(zConverted);
sl@0:       return SQLITE_NOMEM;
sl@0:     }
sl@0:     GetFullPathNameA((char*)zConverted, nByte, zTemp, 0);
sl@0:     free(zConverted);
sl@0:     zOut = mbcsToUtf8(zTemp);
sl@0:     free(zTemp);
sl@0:   }
sl@0:   if( zOut ){
sl@0:     sqlite3_snprintf(pVfs->mxPathname, zFull, "%s", zOut);
sl@0:     free(zOut);
sl@0:     return SQLITE_OK;
sl@0:   }else{
sl@0:     return SQLITE_NOMEM;
sl@0:   }
sl@0: #endif
sl@0: }
sl@0: 
sl@0: #ifndef SQLITE_OMIT_LOAD_EXTENSION
sl@0: /*
sl@0: ** Interfaces for opening a shared library, finding entry points
sl@0: ** within the shared library, and closing the shared library.
sl@0: */
sl@0: /*
sl@0: ** Interfaces for opening a shared library, finding entry points
sl@0: ** within the shared library, and closing the shared library.
sl@0: */
sl@0: static void *winDlOpen(sqlite3_vfs *pVfs, const char *zFilename){
sl@0:   HANDLE h;
sl@0:   void *zConverted = convertUtf8Filename(zFilename);
sl@0:   if( zConverted==0 ){
sl@0:     return 0;
sl@0:   }
sl@0:   if( isNT() ){
sl@0:     h = LoadLibraryW((WCHAR*)zConverted);
sl@0:   }else{
sl@0:     h = LoadLibraryA((char*)zConverted);
sl@0:   }
sl@0:   free(zConverted);
sl@0:   return (void*)h;
sl@0: }
sl@0: static void winDlError(sqlite3_vfs *pVfs, int nBuf, char *zBufOut){
sl@0:   getLastErrorMsg(nBuf, zBufOut);
sl@0: }
sl@0: void *winDlSym(sqlite3_vfs *pVfs, void *pHandle, const char *zSymbol){
sl@0: #if SQLITE_OS_WINCE
sl@0:   /* The GetProcAddressA() routine is only available on wince. */
sl@0:   return GetProcAddressA((HANDLE)pHandle, zSymbol);
sl@0: #else
sl@0:   /* All other windows platforms expect GetProcAddress() to take
sl@0:   ** an Ansi string regardless of the _UNICODE setting */
sl@0:   return GetProcAddress((HANDLE)pHandle, zSymbol);
sl@0: #endif
sl@0: }
sl@0: void winDlClose(sqlite3_vfs *pVfs, void *pHandle){
sl@0:   FreeLibrary((HANDLE)pHandle);
sl@0: }
sl@0: #else /* if SQLITE_OMIT_LOAD_EXTENSION is defined: */
sl@0:   #define winDlOpen  0
sl@0:   #define winDlError 0
sl@0:   #define winDlSym   0
sl@0:   #define winDlClose 0
sl@0: #endif
sl@0: 
sl@0: 
sl@0: /*
sl@0: ** Write up to nBuf bytes of randomness into zBuf.
sl@0: */
sl@0: static int winRandomness(sqlite3_vfs *pVfs, int nBuf, char *zBuf){
sl@0:   int n = 0;
sl@0:   if( sizeof(SYSTEMTIME)<=nBuf-n ){
sl@0:     SYSTEMTIME x;
sl@0:     GetSystemTime(&x);
sl@0:     memcpy(&zBuf[n], &x, sizeof(x));
sl@0:     n += sizeof(x);
sl@0:   }
sl@0:   if( sizeof(DWORD)<=nBuf-n ){
sl@0:     DWORD pid = GetCurrentProcessId();
sl@0:     memcpy(&zBuf[n], &pid, sizeof(pid));
sl@0:     n += sizeof(pid);
sl@0:   }
sl@0:   if( sizeof(DWORD)<=nBuf-n ){
sl@0:     DWORD cnt = GetTickCount();
sl@0:     memcpy(&zBuf[n], &cnt, sizeof(cnt));
sl@0:     n += sizeof(cnt);
sl@0:   }
sl@0:   if( sizeof(LARGE_INTEGER)<=nBuf-n ){
sl@0:     LARGE_INTEGER i;
sl@0:     QueryPerformanceCounter(&i);
sl@0:     memcpy(&zBuf[n], &i, sizeof(i));
sl@0:     n += sizeof(i);
sl@0:   }
sl@0:   return n;
sl@0: }
sl@0: 
sl@0: 
sl@0: /*
sl@0: ** Sleep for a little while.  Return the amount of time slept.
sl@0: */
sl@0: static int winSleep(sqlite3_vfs *pVfs, int microsec){
sl@0:   Sleep((microsec+999)/1000);
sl@0:   return ((microsec+999)/1000)*1000;
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** The following variable, if set to a non-zero value, becomes the result
sl@0: ** returned from sqlite3OsCurrentTime().  This is used for testing.
sl@0: */
sl@0: #ifdef SQLITE_TEST
sl@0: int sqlite3_current_time = 0;
sl@0: #endif
sl@0: 
sl@0: /*
sl@0: ** Find the current time (in Universal Coordinated Time).  Write the
sl@0: ** current time and date as a Julian Day number into *prNow and
sl@0: ** return 0.  Return 1 if the time and date cannot be found.
sl@0: */
sl@0: int winCurrentTime(sqlite3_vfs *pVfs, double *prNow){
sl@0:   FILETIME ft;
sl@0:   /* FILETIME structure is a 64-bit value representing the number of 
sl@0:      100-nanosecond intervals since January 1, 1601 (= JD 2305813.5). 
sl@0:   */
sl@0:   double now;
sl@0: #if SQLITE_OS_WINCE
sl@0:   SYSTEMTIME time;
sl@0:   GetSystemTime(&time);
sl@0:   /* if SystemTimeToFileTime() fails, it returns zero. */
sl@0:   if (!SystemTimeToFileTime(&time,&ft)){
sl@0:     return 1;
sl@0:   }
sl@0: #else
sl@0:   GetSystemTimeAsFileTime( &ft );
sl@0: #endif
sl@0:   now = ((double)ft.dwHighDateTime) * 4294967296.0; 
sl@0:   *prNow = (now + ft.dwLowDateTime)/864000000000.0 + 2305813.5;
sl@0: #ifdef SQLITE_TEST
sl@0:   if( sqlite3_current_time ){
sl@0:     *prNow = sqlite3_current_time/86400.0 + 2440587.5;
sl@0:   }
sl@0: #endif
sl@0:   return 0;
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** The idea is that this function works like a combination of
sl@0: ** GetLastError() and FormatMessage() on windows (or errno and
sl@0: ** strerror_r() on unix). After an error is returned by an OS
sl@0: ** function, SQLite calls this function with zBuf pointing to
sl@0: ** a buffer of nBuf bytes. The OS layer should populate the
sl@0: ** buffer with a nul-terminated UTF-8 encoded error message
sl@0: ** describing the last IO error to have occured within the calling
sl@0: ** thread.
sl@0: **
sl@0: ** If the error message is too large for the supplied buffer,
sl@0: ** it should be truncated. The return value of xGetLastError
sl@0: ** is zero if the error message fits in the buffer, or non-zero
sl@0: ** otherwise (if the message was truncated). If non-zero is returned,
sl@0: ** then it is not necessary to include the nul-terminator character
sl@0: ** in the output buffer.
sl@0: **
sl@0: ** Not supplying an error message will have no adverse effect
sl@0: ** on SQLite. It is fine to have an implementation that never
sl@0: ** returns an error message:
sl@0: **
sl@0: **   int xGetLastError(sqlite3_vfs *pVfs, int nBuf, char *zBuf){
sl@0: **     assert(zBuf[0]=='\0');
sl@0: **     return 0;
sl@0: **   }
sl@0: **
sl@0: ** However if an error message is supplied, it will be incorporated
sl@0: ** by sqlite into the error message available to the user using
sl@0: ** sqlite3_errmsg(), possibly making IO errors easier to debug.
sl@0: */
sl@0: static int winGetLastError(sqlite3_vfs *pVfs, int nBuf, char *zBuf){
sl@0:   return getLastErrorMsg(nBuf, zBuf);
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Initialize and deinitialize the operating system interface.
sl@0: */
sl@0: int sqlite3_os_init(void){
sl@0:   static sqlite3_vfs winVfs = {
sl@0:     1,                 /* iVersion */
sl@0:     sizeof(winFile),   /* szOsFile */
sl@0:     MAX_PATH,          /* mxPathname */
sl@0:     0,                 /* pNext */
sl@0:     "win32",           /* zName */
sl@0:     0,                 /* pAppData */
sl@0:  
sl@0:     winOpen,           /* xOpen */
sl@0:     winDelete,         /* xDelete */
sl@0:     winAccess,         /* xAccess */
sl@0:     winFullPathname,   /* xFullPathname */
sl@0:     winDlOpen,         /* xDlOpen */
sl@0:     winDlError,        /* xDlError */
sl@0:     winDlSym,          /* xDlSym */
sl@0:     winDlClose,        /* xDlClose */
sl@0:     winRandomness,     /* xRandomness */
sl@0:     winSleep,          /* xSleep */
sl@0:     winCurrentTime,    /* xCurrentTime */
sl@0:     winGetLastError    /* xGetLastError */
sl@0:   };
sl@0:   sqlite3_vfs_register(&winVfs, 1);
sl@0:   return SQLITE_OK; 
sl@0: }
sl@0: int sqlite3_os_end(void){ 
sl@0:   return SQLITE_OK;
sl@0: }
sl@0: 
sl@0: #endif /* SQLITE_OS_WIN */