1 /*

     2 ** 2004 May 22

     3 **

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

     5 ** a legal notice, here is a blessing:

     6 **

     7 **    May you do good and not evil.

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

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

    10 **

    11 ******************************************************************************

    12 **

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

    14 **

    15 ** $Id: os_win.c,v 1.132 2008/07/31 01:34:34 shane Exp $

    16 */

    17 #include "sqliteInt.h"

    18 #if SQLITE_OS_WIN               /* This file is used for windows only */

    19 

    20 

    21 /*

    22 ** A Note About Memory Allocation:

    23 **

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

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

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

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

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

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

    30 ** a compelling need to use the wrappers.

    31 **

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

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

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

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

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

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

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

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

    40 **

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

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

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

    44 ** desktops but not so well in embedded systems.

    45 */

    46 

    47 #include <winbase.h>

    48 

    49 #ifdef __CYGWIN__

    50 # include <sys/cygwin.h>

    51 #endif

    52 

    53 /*

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

    55 */

    56 #if defined(THREADSAFE) && THREADSAFE

    57 # define SQLITE_W32_THREADS 1

    58 #endif

    59 

    60 /*

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

    62 */

    63 #include "os_common.h"

    64 

    65 /*

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

    67 ** reduced API.

    68 */

    69 #if defined(SQLITE_OS_WINCE)

    70 # define AreFileApisANSI() 1

    71 #endif

    72 

    73 /*

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

    75 ** with some code of our own.

    76 */

    77 #if SQLITE_OS_WINCE

    78 typedef struct winceLock {

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

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

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

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

    83 } winceLock;

    84 #endif

    85 

    86 /*

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

    88 ** portability layer.

    89 */

    90 typedef struct winFile winFile;

    91 struct winFile {

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

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

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

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

    96 #if SQLITE_OS_WINCE

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

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

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

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

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

   102 #endif

   103 };

   104 

   105 

   106 /*

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

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

   109 ** or WinNT.

   110 **

   111 ** 0:   Operating system unknown.

   112 ** 1:   Operating system is Win95.

   113 ** 2:   Operating system is WinNT.

   114 **

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

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

   117 */

   118 #ifdef SQLITE_TEST

   119 int sqlite3_os_type = 0;

   120 #else

   121 static int sqlite3_os_type = 0;

   122 #endif

   123 

   124 /*

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

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

   127 **

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

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

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

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

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

   133 ** the LockFileEx() API.

   134 */

   135 #if SQLITE_OS_WINCE

   136 # define isNT()  (1)

   137 #else

   138   static int isNT(void){

   139     if( sqlite3_os_type==0 ){

   140       OSVERSIONINFO sInfo;

   141       sInfo.dwOSVersionInfoSize = sizeof(sInfo);

   142       GetVersionEx(&sInfo);

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

   144     }

   145     return sqlite3_os_type==2;

   146   }

   147 #endif /* SQLITE_OS_WINCE */

   148 

   149 /*

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

   151 **

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

   153 */

   154 static WCHAR *utf8ToUnicode(const char *zFilename){

   155   int nChar;

   156   WCHAR *zWideFilename;

   157 

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

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

   160   if( zWideFilename==0 ){

   161     return 0;

   162   }

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

   164   if( nChar==0 ){

   165     free(zWideFilename);

   166     zWideFilename = 0;

   167   }

   168   return zWideFilename;

   169 }

   170 

   171 /*

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

   173 ** obtained from malloc().

   174 */

   175 static char *unicodeToUtf8(const WCHAR *zWideFilename){

   176   int nByte;

   177   char *zFilename;

   178 

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

   180   zFilename = malloc( nByte );

   181   if( zFilename==0 ){

   182     return 0;

   183   }

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

   185                               0, 0);

   186   if( nByte == 0 ){

   187     free(zFilename);

   188     zFilename = 0;

   189   }

   190   return zFilename;

   191 }

   192 

   193 /*

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

   195 ** current codepage settings for file apis.

   196 ** 

   197 ** Space to hold the returned string is obtained

   198 ** from malloc.

   199 */

   200 static WCHAR *mbcsToUnicode(const char *zFilename){

   201   int nByte;

   202   WCHAR *zMbcsFilename;

   203   int codepage = AreFileApisANSI() ? CP_ACP : CP_OEMCP;

   204 

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

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

   207   if( zMbcsFilename==0 ){

   208     return 0;

   209   }

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

   211   if( nByte==0 ){

   212     free(zMbcsFilename);

   213     zMbcsFilename = 0;

   214   }

   215   return zMbcsFilename;

   216 }

   217 

   218 /*

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

   220 ** user's Ansi codepage.

   221 **

   222 ** Space to hold the returned string is obtained from

   223 ** malloc().

   224 */

   225 static char *unicodeToMbcs(const WCHAR *zWideFilename){

   226   int nByte;

   227   char *zFilename;

   228   int codepage = AreFileApisANSI() ? CP_ACP : CP_OEMCP;

   229 

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

   231   zFilename = malloc( nByte );

   232   if( zFilename==0 ){

   233     return 0;

   234   }

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

   236                               0, 0);

   237   if( nByte == 0 ){

   238     free(zFilename);

   239     zFilename = 0;

   240   }

   241   return zFilename;

   242 }

   243 

   244 /*

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

   246 ** returned string is obtained from malloc().

   247 */

   248 static char *mbcsToUtf8(const char *zFilename){

   249   char *zFilenameUtf8;

   250   WCHAR *zTmpWide;

   251 

   252   zTmpWide = mbcsToUnicode(zFilename);

   253   if( zTmpWide==0 ){

   254     return 0;

   255   }

   256   zFilenameUtf8 = unicodeToUtf8(zTmpWide);

   257   free(zTmpWide);

   258   return zFilenameUtf8;

   259 }

   260 

   261 /*

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

   263 ** returned string is obtained from malloc().

   264 */

   265 static char *utf8ToMbcs(const char *zFilename){

   266   char *zFilenameMbcs;

   267   WCHAR *zTmpWide;

   268 

   269   zTmpWide = utf8ToUnicode(zFilename);

   270   if( zTmpWide==0 ){

   271     return 0;

   272   }

   273   zFilenameMbcs = unicodeToMbcs(zTmpWide);

   274   free(zTmpWide);

   275   return zFilenameMbcs;

   276 }

   277 

   278 #if SQLITE_OS_WINCE

   279 /*************************************************************************

   280 ** This section contains code for WinCE only.

   281 */

   282 /*

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

   284 ** substitute.

   285 */

   286 #include <time.h>

   287 struct tm *__cdecl localtime(const time_t *t)

   288 {

   289   static struct tm y;

   290   FILETIME uTm, lTm;

   291   SYSTEMTIME pTm;

   292   sqlite3_int64 t64;

   293   t64 = *t;

   294   t64 = (t64 + 11644473600)*10000000;

   295   uTm.dwLowDateTime = t64 & 0xFFFFFFFF;

   296   uTm.dwHighDateTime= t64 >> 32;

   297   FileTimeToLocalFileTime(&uTm,&lTm);

   298   FileTimeToSystemTime(&lTm,&pTm);

   299   y.tm_year = pTm.wYear - 1900;

   300   y.tm_mon = pTm.wMonth - 1;

   301   y.tm_wday = pTm.wDayOfWeek;

   302   y.tm_mday = pTm.wDay;

   303   y.tm_hour = pTm.wHour;

   304   y.tm_min = pTm.wMinute;

   305   y.tm_sec = pTm.wSecond;

   306   return &y;

   307 }

   308 

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

   310 #define GetTempPathA(a,b)

   311 

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

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

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

   315 

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

   317 

   318 /*

   319 ** Acquire a lock on the handle h

   320 */

   321 static void winceMutexAcquire(HANDLE h){

   322    DWORD dwErr;

   323    do {

   324      dwErr = WaitForSingleObject(h, INFINITE);

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

   326 }

   327 /*

   328 ** Release a lock acquired by winceMutexAcquire()

   329 */

   330 #define winceMutexRelease(h) ReleaseMutex(h)

   331 

   332 /*

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

   334 ** descriptor pFile

   335 */

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

   337   WCHAR *zTok;

   338   WCHAR *zName = utf8ToUnicode(zFilename);

   339   BOOL bInit = TRUE;

   340 

   341   /* Initialize the local lockdata */

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

   343 

   344   /* Replace the backslashes from the filename and lowercase it

   345   ** to derive a mutex name. */

   346   zTok = CharLowerW(zName);

   347   for (;*zTok;zTok++){

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

   349   }

   350 

   351   /* Create/open the named mutex */

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

   353   if (!pFile->hMutex){

   354     free(zName);

   355     return FALSE;

   356   }

   357 

   358   /* Acquire the mutex before continuing */

   359   winceMutexAcquire(pFile->hMutex);

   360   

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

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

   363   ** and using that as the shared filemapping name.

   364   */

   365   CharUpperW(zName);

   366   pFile->hShared = CreateFileMappingW(INVALID_HANDLE_VALUE, NULL,

   367                                        PAGE_READWRITE, 0, sizeof(winceLock),

   368                                        zName);  

   369 

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

   371   ** must be zero-initialized */

   372   if (GetLastError() == ERROR_ALREADY_EXISTS){

   373     bInit = FALSE;

   374   }

   375 

   376   free(zName);

   377 

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

   379   if (pFile->hShared){

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

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

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

   383     if (!pFile->shared){

   384       CloseHandle(pFile->hShared);

   385       pFile->hShared = NULL;

   386     }

   387   }

   388 

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

   390   if (pFile->hShared == NULL){

   391     winceMutexRelease(pFile->hMutex);

   392     CloseHandle(pFile->hMutex);

   393     pFile->hMutex = NULL;

   394     return FALSE;

   395   }

   396   

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

   398   if (bInit) {

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

   400   }

   401 

   402   winceMutexRelease(pFile->hMutex);

   403   return TRUE;

   404 }

   405 

   406 /*

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

   408 */

   409 static void winceDestroyLock(winFile *pFile){

   410   if (pFile->hMutex){

   411     /* Acquire the mutex */

   412     winceMutexAcquire(pFile->hMutex);

   413 

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

   415        are to cleanup in case any locks remained open */

   416     if (pFile->local.nReaders){

   417       pFile->shared->nReaders --;

   418     }

   419     if (pFile->local.bReserved){

   420       pFile->shared->bReserved = FALSE;

   421     }

   422     if (pFile->local.bPending){

   423       pFile->shared->bPending = FALSE;

   424     }

   425     if (pFile->local.bExclusive){

   426       pFile->shared->bExclusive = FALSE;

   427     }

   428 

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

   430     UnmapViewOfFile(pFile->shared);

   431     CloseHandle(pFile->hShared);

   432 

   433     /* Done with the mutex */

   434     winceMutexRelease(pFile->hMutex);    

   435     CloseHandle(pFile->hMutex);

   436     pFile->hMutex = NULL;

   437   }

   438 }

   439 

   440 /* 

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

   442 */

   443 static BOOL winceLockFile(

   444   HANDLE *phFile,

   445   DWORD dwFileOffsetLow,

   446   DWORD dwFileOffsetHigh,

   447   DWORD nNumberOfBytesToLockLow,

   448   DWORD nNumberOfBytesToLockHigh

   449 ){

   450   winFile *pFile = HANDLE_TO_WINFILE(phFile);

   451   BOOL bReturn = FALSE;

   452 

   453   if (!pFile->hMutex) return TRUE;

   454   winceMutexAcquire(pFile->hMutex);

   455 

   456   /* Wanting an exclusive lock? */

   457   if (dwFileOffsetLow == SHARED_FIRST

   458        && nNumberOfBytesToLockLow == SHARED_SIZE){

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

   460        pFile->shared->bExclusive = TRUE;

   461        pFile->local.bExclusive = TRUE;

   462        bReturn = TRUE;

   463     }

   464   }

   465 

   466   /* Want a read-only lock? */

   467   else if ((dwFileOffsetLow >= SHARED_FIRST &&

   468             dwFileOffsetLow < SHARED_FIRST + SHARED_SIZE) &&

   469             nNumberOfBytesToLockLow == 1){

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

   471       pFile->local.nReaders ++;

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

   473         pFile->shared->nReaders ++;

   474       }

   475       bReturn = TRUE;

   476     }

   477   }

   478 

   479   /* Want a pending lock? */

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

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

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

   483       pFile->shared->bPending = TRUE;

   484       pFile->local.bPending = TRUE;

   485       bReturn = TRUE;

   486     }

   487   }

   488   /* Want a reserved lock? */

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

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

   491       pFile->shared->bReserved = TRUE;

   492       pFile->local.bReserved = TRUE;

   493       bReturn = TRUE;

   494     }

   495   }

   496 

   497   winceMutexRelease(pFile->hMutex);

   498   return bReturn;

   499 }

   500 

   501 /*

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

   503 */

   504 static BOOL winceUnlockFile(

   505   HANDLE *phFile,

   506   DWORD dwFileOffsetLow,

   507   DWORD dwFileOffsetHigh,

   508   DWORD nNumberOfBytesToUnlockLow,

   509   DWORD nNumberOfBytesToUnlockHigh

   510 ){

   511   winFile *pFile = HANDLE_TO_WINFILE(phFile);

   512   BOOL bReturn = FALSE;

   513 

   514   if (!pFile->hMutex) return TRUE;

   515   winceMutexAcquire(pFile->hMutex);

   516 

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

   518   if (dwFileOffsetLow >= SHARED_FIRST &&

   519        dwFileOffsetLow < SHARED_FIRST + SHARED_SIZE){

   520     /* Did we have an exclusive lock? */

   521     if (pFile->local.bExclusive){

   522       pFile->local.bExclusive = FALSE;

   523       pFile->shared->bExclusive = FALSE;

   524       bReturn = TRUE;

   525     }

   526 

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

   528     else if (pFile->local.nReaders){

   529       pFile->local.nReaders --;

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

   531       {

   532         pFile->shared->nReaders --;

   533       }

   534       bReturn = TRUE;

   535     }

   536   }

   537 

   538   /* Releasing a pending lock */

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

   540     if (pFile->local.bPending){

   541       pFile->local.bPending = FALSE;

   542       pFile->shared->bPending = FALSE;

   543       bReturn = TRUE;

   544     }

   545   }

   546   /* Releasing a reserved lock */

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

   548     if (pFile->local.bReserved) {

   549       pFile->local.bReserved = FALSE;

   550       pFile->shared->bReserved = FALSE;

   551       bReturn = TRUE;

   552     }

   553   }

   554 

   555   winceMutexRelease(pFile->hMutex);

   556   return bReturn;

   557 }

   558 

   559 /*

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

   561 */

   562 static BOOL winceLockFileEx(

   563   HANDLE *phFile,

   564   DWORD dwFlags,

   565   DWORD dwReserved,

   566   DWORD nNumberOfBytesToLockLow,

   567   DWORD nNumberOfBytesToLockHigh,

   568   LPOVERLAPPED lpOverlapped

   569 ){

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

   571   ** to winceLockFile */

   572   if (lpOverlapped->Offset == SHARED_FIRST &&

   573       dwFlags == 1 &&

   574       nNumberOfBytesToLockLow == SHARED_SIZE){

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

   576   }

   577   return FALSE;

   578 }

   579 /*

   580 ** End of the special code for wince

   581 *****************************************************************************/

   582 #endif /* SQLITE_OS_WINCE */

   583 

   584 /*****************************************************************************

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

   586 ** by the sqlite3_io_methods object.

   587 ******************************************************************************/

   588 

   589 /*

   590 ** Close a file.

   591 **

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

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

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

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

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

   597 ** giving up and returning an error.

   598 */

   599 #define MX_CLOSE_ATTEMPT 3

   600 static int winClose(sqlite3_file *id){

   601   int rc, cnt = 0;

   602   winFile *pFile = (winFile*)id;

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

   604   do{

   605     rc = CloseHandle(pFile->h);

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

   607 #if SQLITE_OS_WINCE

   608 #define WINCE_DELETION_ATTEMPTS 3

   609   winceDestroyLock(pFile);

   610   if( pFile->zDeleteOnClose ){

   611     int cnt = 0;

   612     while(

   613            DeleteFileW(pFile->zDeleteOnClose)==0

   614         && GetFileAttributesW(pFile->zDeleteOnClose)!=0xffffffff 

   615         && cnt++ < WINCE_DELETION_ATTEMPTS

   616     ){

   617        Sleep(100);  /* Wait a little before trying again */

   618     }

   619     free(pFile->zDeleteOnClose);

   620   }

   621 #endif

   622   OpenCounter(-1);

   623   return rc ? SQLITE_OK : SQLITE_IOERR;

   624 }

   625 

   626 /*

   627 ** Some microsoft compilers lack this definition.

   628 */

   629 #ifndef INVALID_SET_FILE_POINTER

   630 # define INVALID_SET_FILE_POINTER ((DWORD)-1)

   631 #endif

   632 

   633 /*

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

   635 ** bytes were read successfully and SQLITE_IOERR if anything goes

   636 ** wrong.

   637 */

   638 static int winRead(

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

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

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

   642   sqlite3_int64 offset       /* Begin reading at this offset */

   643 ){

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

   645   LONG lowerBits = offset & 0xffffffff;

   646   DWORD rc;

   647   DWORD got;

   648   winFile *pFile = (winFile*)id;

   649   assert( id!=0 );

   650   SimulateIOError(return SQLITE_IOERR_READ);

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

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

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

   654     return SQLITE_FULL;

   655   }

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

   657     return SQLITE_IOERR_READ;

   658   }

   659   if( got==(DWORD)amt ){

   660     return SQLITE_OK;

   661   }else{

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

   663     return SQLITE_IOERR_SHORT_READ;

   664   }

   665 }

   666 

   667 /*

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

   669 ** or some other error code on failure.

   670 */

   671 static int winWrite(

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

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

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

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

   676 ){

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

   678   LONG lowerBits = offset & 0xffffffff;

   679   DWORD rc;

   680   DWORD wrote;

   681   winFile *pFile = (winFile*)id;

   682   assert( id!=0 );

   683   SimulateIOError(return SQLITE_IOERR_WRITE);

   684   SimulateDiskfullError(return SQLITE_FULL);

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

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

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

   688     return SQLITE_FULL;

   689   }

   690   assert( amt>0 );

   691   while(

   692      amt>0

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

   694      && wrote>0

   695   ){

   696     amt -= wrote;

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

   698   }

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

   700     return SQLITE_FULL;

   701   }

   702   return SQLITE_OK;

   703 }

   704 

   705 /*

   706 ** Truncate an open file to a specified size

   707 */

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

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

   710   LONG lowerBits = nByte & 0xffffffff;

   711   winFile *pFile = (winFile*)id;

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

   713   SimulateIOError(return SQLITE_IOERR_TRUNCATE);

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

   715   SetEndOfFile(pFile->h);

   716   return SQLITE_OK;

   717 }

   718 

   719 #ifdef SQLITE_TEST

   720 /*

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

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

   723 */

   724 int sqlite3_sync_count = 0;

   725 int sqlite3_fullsync_count = 0;

   726 #endif

   727 

   728 /*

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

   730 */

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

   732   winFile *pFile = (winFile*)id;

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

   734 #ifdef SQLITE_TEST

   735   if( flags & SQLITE_SYNC_FULL ){

   736     sqlite3_fullsync_count++;

   737   }

   738   sqlite3_sync_count++;

   739 #endif

   740   if( FlushFileBuffers(pFile->h) ){

   741     return SQLITE_OK;

   742   }else{

   743     return SQLITE_IOERR;

   744   }

   745 }

   746 

   747 /*

   748 ** Determine the current size of a file in bytes

   749 */

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

   751   winFile *pFile = (winFile*)id;

   752   DWORD upperBits, lowerBits;

   753   SimulateIOError(return SQLITE_IOERR_FSTAT);

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

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

   756   return SQLITE_OK;

   757 }

   758 

   759 /*

   760 ** LOCKFILE_FAIL_IMMEDIATELY is undefined on some Windows systems.

   761 */

   762 #ifndef LOCKFILE_FAIL_IMMEDIATELY

   763 # define LOCKFILE_FAIL_IMMEDIATELY 1

   764 #endif

   765 

   766 /*

   767 ** Acquire a reader lock.

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

   769 ** is Win95 or WinNT.

   770 */

   771 static int getReadLock(winFile *pFile){

   772   int res;

   773   if( isNT() ){

   774     OVERLAPPED ovlp;

   775     ovlp.Offset = SHARED_FIRST;

   776     ovlp.OffsetHigh = 0;

   777     ovlp.hEvent = 0;

   778     res = LockFileEx(pFile->h, LOCKFILE_FAIL_IMMEDIATELY,

   779                      0, SHARED_SIZE, 0, &ovlp);

   780   }else{

   781     int lk;

   782     sqlite3_randomness(sizeof(lk), &lk);

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

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

   785   }

   786   return res;

   787 }

   788 

   789 /*

   790 ** Undo a readlock

   791 */

   792 static int unlockReadLock(winFile *pFile){

   793   int res;

   794   if( isNT() ){

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

   796   }else{

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

   798   }

   799   return res;

   800 }

   801 

   802 /*

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

   804 ** of the following:

   805 **

   806 **     (1) SHARED_LOCK

   807 **     (2) RESERVED_LOCK

   808 **     (3) PENDING_LOCK

   809 **     (4) EXCLUSIVE_LOCK

   810 **

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

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

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

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

   815 ** transitions and the inserted intermediate states:

   816 **

   817 **    UNLOCKED -> SHARED

   818 **    SHARED -> RESERVED

   819 **    SHARED -> (PENDING) -> EXCLUSIVE

   820 **    RESERVED -> (PENDING) -> EXCLUSIVE

   821 **    PENDING -> EXCLUSIVE

   822 **

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

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

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

   826 ** must go straight to locking level 0.

   827 */

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

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

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

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

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

   833   winFile *pFile = (winFile*)id;

   834 

   835   assert( pFile!=0 );

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

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

   838 

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

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

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

   842   */

   843   if( pFile->locktype>=locktype ){

   844     return SQLITE_OK;

   845   }

   846 

   847   /* Make sure the locking sequence is correct

   848   */

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

   850   assert( locktype!=PENDING_LOCK );

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

   852 

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

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

   855   ** the PENDING_LOCK byte is temporary.

   856   */

   857   newLocktype = pFile->locktype;

   858   if( pFile->locktype==NO_LOCK

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

   860   ){

   861     int cnt = 3;

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

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

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

   865       */

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

   867       Sleep(1);

   868     }

   869     gotPendingLock = res;

   870   }

   871 

   872   /* Acquire a shared lock

   873   */

   874   if( locktype==SHARED_LOCK && res ){

   875     assert( pFile->locktype==NO_LOCK );

   876     res = getReadLock(pFile);

   877     if( res ){

   878       newLocktype = SHARED_LOCK;

   879     }

   880   }

   881 

   882   /* Acquire a RESERVED lock

   883   */

   884   if( locktype==RESERVED_LOCK && res ){

   885     assert( pFile->locktype==SHARED_LOCK );

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

   887     if( res ){

   888       newLocktype = RESERVED_LOCK;

   889     }

   890   }

   891 

   892   /* Acquire a PENDING lock

   893   */

   894   if( locktype==EXCLUSIVE_LOCK && res ){

   895     newLocktype = PENDING_LOCK;

   896     gotPendingLock = 0;

   897   }

   898 

   899   /* Acquire an EXCLUSIVE lock

   900   */

   901   if( locktype==EXCLUSIVE_LOCK && res ){

   902     assert( pFile->locktype>=SHARED_LOCK );

   903     res = unlockReadLock(pFile);

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

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

   906     if( res ){

   907       newLocktype = EXCLUSIVE_LOCK;

   908     }else{

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

   910       getReadLock(pFile);

   911     }

   912   }

   913 

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

   915   ** release it now.

   916   */

   917   if( gotPendingLock && locktype==SHARED_LOCK ){

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

   919   }

   920 

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

   922   ** return the appropriate result code.

   923   */

   924   if( res ){

   925     rc = SQLITE_OK;

   926   }else{

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

   928            locktype, newLocktype);

   929     rc = SQLITE_BUSY;

   930   }

   931   pFile->locktype = newLocktype;

   932   return rc;

   933 }

   934 

   935 /*

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

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

   938 ** non-zero, otherwise zero.

   939 */

   940 static int winCheckReservedLock(sqlite3_file *id, int *pResOut){

   941   int rc;

   942   winFile *pFile = (winFile*)id;

   943   assert( pFile!=0 );

   944   if( pFile->locktype>=RESERVED_LOCK ){

   945     rc = 1;

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

   947   }else{

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

   949     if( rc ){

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

   951     }

   952     rc = !rc;

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

   954   }

   955   *pResOut = rc;

   956   return SQLITE_OK;

   957 }

   958 

   959 /*

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

   961 ** must be either NO_LOCK or SHARED_LOCK.

   962 **

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

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

   965 **

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

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

   968 ** might return SQLITE_IOERR;

   969 */

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

   971   int type;

   972   winFile *pFile = (winFile*)id;

   973   int rc = SQLITE_OK;

   974   assert( pFile!=0 );

   975   assert( locktype<=SHARED_LOCK );

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

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

   978   type = pFile->locktype;

   979   if( type>=EXCLUSIVE_LOCK ){

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

   981     if( locktype==SHARED_LOCK && !getReadLock(pFile) ){

   982       /* This should never happen.  We should always be able to

   983       ** reacquire the read lock */

   984       rc = SQLITE_IOERR_UNLOCK;

   985     }

   986   }

   987   if( type>=RESERVED_LOCK ){

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

   989   }

   990   if( locktype==NO_LOCK && type>=SHARED_LOCK ){

   991     unlockReadLock(pFile);

   992   }

   993   if( type>=PENDING_LOCK ){

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

   995   }

   996   pFile->locktype = locktype;

   997   return rc;

   998 }

   999 

  1000 /*

  1001 ** Control and query of the open file handle.

  1002 */

  1003 static int winFileControl(sqlite3_file *id, int op, void *pArg){

  1004   switch( op ){

  1005     case SQLITE_FCNTL_LOCKSTATE: {

  1006       *(int*)pArg = ((winFile*)id)->locktype;

  1007       return SQLITE_OK;

  1008     }

  1009   }

  1010   return SQLITE_ERROR;

  1011 }

  1012 

  1013 /*

  1014 ** Return the sector size in bytes of the underlying block device for

  1015 ** the specified file. This is almost always 512 bytes, but may be

  1016 ** larger for some devices.

  1017 **

  1018 ** SQLite code assumes this function cannot fail. It also assumes that

  1019 ** if two files are created in the same file-system directory (i.e.

  1020 ** a database and its journal file) that the sector size will be the

  1021 ** same for both.

  1022 */

  1023 static int winSectorSize(sqlite3_file *id){

  1024   return SQLITE_DEFAULT_SECTOR_SIZE;

  1025 }

  1026 

  1027 /*

  1028 ** Return a vector of device characteristics.

  1029 */

  1030 static int winDeviceCharacteristics(sqlite3_file *id){

  1031   return 0;

  1032 }

  1033 

  1034 /*

  1035 ** This vector defines all the methods that can operate on an

  1036 ** sqlite3_file for win32.

  1037 */

  1038 static const sqlite3_io_methods winIoMethod = {

  1039   1,                        /* iVersion */

  1040   winClose,

  1041   winRead,

  1042   winWrite,

  1043   winTruncate,

  1044   winSync,

  1045   winFileSize,

  1046   winLock,

  1047   winUnlock,

  1048   winCheckReservedLock,

  1049   winFileControl,

  1050   winSectorSize,

  1051   winDeviceCharacteristics

  1052 };

  1053 

  1054 /***************************************************************************

  1055 ** Here ends the I/O methods that form the sqlite3_io_methods object.

  1056 **

  1057 ** The next block of code implements the VFS methods.

  1058 ****************************************************************************/

  1059 

  1060 /*

  1061 ** Convert a UTF-8 filename into whatever form the underlying

  1062 ** operating system wants filenames in.  Space to hold the result

  1063 ** is obtained from malloc and must be freed by the calling

  1064 ** function.

  1065 */

  1066 static void *convertUtf8Filename(const char *zFilename){

  1067   void *zConverted = 0;

  1068   if( isNT() ){

  1069     zConverted = utf8ToUnicode(zFilename);

  1070   }else{

  1071     zConverted = utf8ToMbcs(zFilename);

  1072   }

  1073   /* caller will handle out of memory */

  1074   return zConverted;

  1075 }

  1076 

  1077 /*

  1078 ** Create a temporary file name in zBuf.  zBuf must be big enough to

  1079 ** hold at pVfs->mxPathname characters.

  1080 */

  1081 static int getTempname(int nBuf, char *zBuf){

  1082   static char zChars[] =

  1083     "abcdefghijklmnopqrstuvwxyz"

  1084     "ABCDEFGHIJKLMNOPQRSTUVWXYZ"

  1085     "0123456789";

  1086   size_t i, j;

  1087   char zTempPath[MAX_PATH+1];

  1088   if( sqlite3_temp_directory ){

  1089     sqlite3_snprintf(MAX_PATH-30, zTempPath, "%s", sqlite3_temp_directory);

  1090   }else if( isNT() ){

  1091     char *zMulti;

  1092     WCHAR zWidePath[MAX_PATH];

  1093     GetTempPathW(MAX_PATH-30, zWidePath);

  1094     zMulti = unicodeToUtf8(zWidePath);

  1095     if( zMulti ){

  1096       sqlite3_snprintf(MAX_PATH-30, zTempPath, "%s", zMulti);

  1097       free(zMulti);

  1098     }else{

  1099       return SQLITE_NOMEM;

  1100     }

  1101   }else{

  1102     char *zUtf8;

  1103     char zMbcsPath[MAX_PATH];

  1104     GetTempPathA(MAX_PATH-30, zMbcsPath);

  1105     zUtf8 = mbcsToUtf8(zMbcsPath);

  1106     if( zUtf8 ){

  1107       sqlite3_snprintf(MAX_PATH-30, zTempPath, "%s", zUtf8);

  1108       free(zUtf8);

  1109     }else{

  1110       return SQLITE_NOMEM;

  1111     }

  1112   }

  1113   for(i=strlen(zTempPath); i>0 && zTempPath[i-1]=='\\'; i--){}

  1114   zTempPath[i] = 0;

  1115   sqlite3_snprintf(nBuf-30, zBuf,

  1116                    "%s\\"SQLITE_TEMP_FILE_PREFIX, zTempPath);

  1117   j = strlen(zBuf);

  1118   sqlite3_randomness(20, &zBuf[j]);

  1119   for(i=0; i<20; i++, j++){

  1120     zBuf[j] = (char)zChars[ ((unsigned char)zBuf[j])%(sizeof(zChars)-1) ];

  1121   }

  1122   zBuf[j] = 0;

  1123   OSTRACE2("TEMP FILENAME: %s\n", zBuf);

  1124   return SQLITE_OK; 

  1125 }

  1126 

  1127 /*

  1128 ** The return value of getLastErrorMsg

  1129 ** is zero if the error message fits in the buffer, or non-zero

  1130 ** otherwise (if the message was truncated).

  1131 */

  1132 static int getLastErrorMsg(int nBuf, char *zBuf){

  1133   DWORD error = GetLastError();

  1134 

  1135 #if SQLITE_OS_WINCE