1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/os/persistentdata/persistentstorage/sql/SQLite364/os_win.c Fri Jun 15 03:10:57 2012 +0200
1.3 @@ -0,0 +1,1639 @@
1.4 +/*
1.5 +** 2004 May 22
1.6 +**
1.7 +** The author disclaims copyright to this source code. In place of
1.8 +** a legal notice, here is a blessing:
1.9 +**
1.10 +** May you do good and not evil.
1.11 +** May you find forgiveness for yourself and forgive others.
1.12 +** May you share freely, never taking more than you give.
1.13 +**
1.14 +******************************************************************************
1.15 +**
1.16 +** This file contains code that is specific to windows.
1.17 +**
1.18 +** $Id: os_win.c,v 1.135 2008/10/12 02:27:39 shane Exp $
1.19 +*/
1.20 +#include "sqliteInt.h"
1.21 +#if SQLITE_OS_WIN /* This file is used for windows only */
1.22 +
1.23 +
1.24 +/*
1.25 +** A Note About Memory Allocation:
1.26 +**
1.27 +** This driver uses malloc()/free() directly rather than going through
1.28 +** the SQLite-wrappers sqlite3_malloc()/sqlite3_free(). Those wrappers
1.29 +** are designed for use on embedded systems where memory is scarce and
1.30 +** malloc failures happen frequently. Win32 does not typically run on
1.31 +** embedded systems, and when it does the developers normally have bigger
1.32 +** problems to worry about than running out of memory. So there is not
1.33 +** a compelling need to use the wrappers.
1.34 +**
1.35 +** But there is a good reason to not use the wrappers. If we use the
1.36 +** wrappers then we will get simulated malloc() failures within this
1.37 +** driver. And that causes all kinds of problems for our tests. We
1.38 +** could enhance SQLite to deal with simulated malloc failures within
1.39 +** the OS driver, but the code to deal with those failure would not
1.40 +** be exercised on Linux (which does not need to malloc() in the driver)
1.41 +** and so we would have difficulty writing coverage tests for that
1.42 +** code. Better to leave the code out, we think.
1.43 +**
1.44 +** The point of this discussion is as follows: When creating a new
1.45 +** OS layer for an embedded system, if you use this file as an example,
1.46 +** avoid the use of malloc()/free(). Those routines work ok on windows
1.47 +** desktops but not so well in embedded systems.
1.48 +*/
1.49 +
1.50 +#include <winbase.h>
1.51 +
1.52 +#ifdef __CYGWIN__
1.53 +# include <sys/cygwin.h>
1.54 +#endif
1.55 +
1.56 +/*
1.57 +** Macros used to determine whether or not to use threads.
1.58 +*/
1.59 +#if defined(THREADSAFE) && THREADSAFE
1.60 +# define SQLITE_W32_THREADS 1
1.61 +#endif
1.62 +
1.63 +/*
1.64 +** Include code that is common to all os_*.c files
1.65 +*/
1.66 +#include "os_common.h"
1.67 +
1.68 +/*
1.69 +** Some microsoft compilers lack this definition.
1.70 +*/
1.71 +#ifndef INVALID_FILE_ATTRIBUTES
1.72 +# define INVALID_FILE_ATTRIBUTES ((DWORD)-1)
1.73 +#endif
1.74 +
1.75 +/*
1.76 +** Determine if we are dealing with WindowsCE - which has a much
1.77 +** reduced API.
1.78 +*/
1.79 +#if defined(SQLITE_OS_WINCE)
1.80 +# define AreFileApisANSI() 1
1.81 +#endif
1.82 +
1.83 +/*
1.84 +** WinCE lacks native support for file locking so we have to fake it
1.85 +** with some code of our own.
1.86 +*/
1.87 +#if SQLITE_OS_WINCE
1.88 +typedef struct winceLock {
1.89 + int nReaders; /* Number of reader locks obtained */
1.90 + BOOL bPending; /* Indicates a pending lock has been obtained */
1.91 + BOOL bReserved; /* Indicates a reserved lock has been obtained */
1.92 + BOOL bExclusive; /* Indicates an exclusive lock has been obtained */
1.93 +} winceLock;
1.94 +#endif
1.95 +
1.96 +/*
1.97 +** The winFile structure is a subclass of sqlite3_file* specific to the win32
1.98 +** portability layer.
1.99 +*/
1.100 +typedef struct winFile winFile;
1.101 +struct winFile {
1.102 + const sqlite3_io_methods *pMethod;/* Must be first */
1.103 + HANDLE h; /* Handle for accessing the file */
1.104 + unsigned char locktype; /* Type of lock currently held on this file */
1.105 + short sharedLockByte; /* Randomly chosen byte used as a shared lock */
1.106 +#if SQLITE_OS_WINCE
1.107 + WCHAR *zDeleteOnClose; /* Name of file to delete when closing */
1.108 + HANDLE hMutex; /* Mutex used to control access to shared lock */
1.109 + HANDLE hShared; /* Shared memory segment used for locking */
1.110 + winceLock local; /* Locks obtained by this instance of winFile */
1.111 + winceLock *shared; /* Global shared lock memory for the file */
1.112 +#endif
1.113 +};
1.114 +
1.115 +
1.116 +/*
1.117 +** The following variable is (normally) set once and never changes
1.118 +** thereafter. It records whether the operating system is Win95
1.119 +** or WinNT.
1.120 +**
1.121 +** 0: Operating system unknown.
1.122 +** 1: Operating system is Win95.
1.123 +** 2: Operating system is WinNT.
1.124 +**
1.125 +** In order to facilitate testing on a WinNT system, the test fixture
1.126 +** can manually set this value to 1 to emulate Win98 behavior.
1.127 +*/
1.128 +#ifdef SQLITE_TEST
1.129 +int sqlite3_os_type = 0;
1.130 +#else
1.131 +static int sqlite3_os_type = 0;
1.132 +#endif
1.133 +
1.134 +/*
1.135 +** Return true (non-zero) if we are running under WinNT, Win2K, WinXP,
1.136 +** or WinCE. Return false (zero) for Win95, Win98, or WinME.
1.137 +**
1.138 +** Here is an interesting observation: Win95, Win98, and WinME lack
1.139 +** the LockFileEx() API. But we can still statically link against that
1.140 +** API as long as we don't call it win running Win95/98/ME. A call to
1.141 +** this routine is used to determine if the host is Win95/98/ME or
1.142 +** WinNT/2K/XP so that we will know whether or not we can safely call
1.143 +** the LockFileEx() API.
1.144 +*/
1.145 +#if SQLITE_OS_WINCE
1.146 +# define isNT() (1)
1.147 +#else
1.148 + static int isNT(void){
1.149 + if( sqlite3_os_type==0 ){
1.150 + OSVERSIONINFO sInfo;
1.151 + sInfo.dwOSVersionInfoSize = sizeof(sInfo);
1.152 + GetVersionEx(&sInfo);
1.153 + sqlite3_os_type = sInfo.dwPlatformId==VER_PLATFORM_WIN32_NT ? 2 : 1;
1.154 + }
1.155 + return sqlite3_os_type==2;
1.156 + }
1.157 +#endif /* SQLITE_OS_WINCE */
1.158 +
1.159 +/*
1.160 +** Convert a UTF-8 string to microsoft unicode (UTF-16?).
1.161 +**
1.162 +** Space to hold the returned string is obtained from malloc.
1.163 +*/
1.164 +static WCHAR *utf8ToUnicode(const char *zFilename){
1.165 + int nChar;
1.166 + WCHAR *zWideFilename;
1.167 +
1.168 + nChar = MultiByteToWideChar(CP_UTF8, 0, zFilename, -1, NULL, 0);
1.169 + zWideFilename = malloc( nChar*sizeof(zWideFilename[0]) );
1.170 + if( zWideFilename==0 ){
1.171 + return 0;
1.172 + }
1.173 + nChar = MultiByteToWideChar(CP_UTF8, 0, zFilename, -1, zWideFilename, nChar);
1.174 + if( nChar==0 ){
1.175 + free(zWideFilename);
1.176 + zWideFilename = 0;
1.177 + }
1.178 + return zWideFilename;
1.179 +}
1.180 +
1.181 +/*
1.182 +** Convert microsoft unicode to UTF-8. Space to hold the returned string is
1.183 +** obtained from malloc().
1.184 +*/
1.185 +static char *unicodeToUtf8(const WCHAR *zWideFilename){
1.186 + int nByte;
1.187 + char *zFilename;
1.188 +
1.189 + nByte = WideCharToMultiByte(CP_UTF8, 0, zWideFilename, -1, 0, 0, 0, 0);
1.190 + zFilename = malloc( nByte );
1.191 + if( zFilename==0 ){
1.192 + return 0;
1.193 + }
1.194 + nByte = WideCharToMultiByte(CP_UTF8, 0, zWideFilename, -1, zFilename, nByte,
1.195 + 0, 0);
1.196 + if( nByte == 0 ){
1.197 + free(zFilename);
1.198 + zFilename = 0;
1.199 + }
1.200 + return zFilename;
1.201 +}
1.202 +
1.203 +/*
1.204 +** Convert an ansi string to microsoft unicode, based on the
1.205 +** current codepage settings for file apis.
1.206 +**
1.207 +** Space to hold the returned string is obtained
1.208 +** from malloc.
1.209 +*/
1.210 +static WCHAR *mbcsToUnicode(const char *zFilename){
1.211 + int nByte;
1.212 + WCHAR *zMbcsFilename;
1.213 + int codepage = AreFileApisANSI() ? CP_ACP : CP_OEMCP;
1.214 +
1.215 + nByte = MultiByteToWideChar(codepage, 0, zFilename, -1, NULL,0)*sizeof(WCHAR);
1.216 + zMbcsFilename = malloc( nByte*sizeof(zMbcsFilename[0]) );
1.217 + if( zMbcsFilename==0 ){
1.218 + return 0;
1.219 + }
1.220 + nByte = MultiByteToWideChar(codepage, 0, zFilename, -1, zMbcsFilename, nByte);
1.221 + if( nByte==0 ){
1.222 + free(zMbcsFilename);
1.223 + zMbcsFilename = 0;
1.224 + }
1.225 + return zMbcsFilename;
1.226 +}
1.227 +
1.228 +/*
1.229 +** Convert microsoft unicode to multibyte character string, based on the
1.230 +** user's Ansi codepage.
1.231 +**
1.232 +** Space to hold the returned string is obtained from
1.233 +** malloc().
1.234 +*/
1.235 +static char *unicodeToMbcs(const WCHAR *zWideFilename){
1.236 + int nByte;
1.237 + char *zFilename;
1.238 + int codepage = AreFileApisANSI() ? CP_ACP : CP_OEMCP;
1.239 +
1.240 + nByte = WideCharToMultiByte(codepage, 0, zWideFilename, -1, 0, 0, 0, 0);
1.241 + zFilename = malloc( nByte );
1.242 + if( zFilename==0 ){
1.243 + return 0;
1.244 + }
1.245 + nByte = WideCharToMultiByte(codepage, 0, zWideFilename, -1, zFilename, nByte,
1.246 + 0, 0);
1.247 + if( nByte == 0 ){
1.248 + free(zFilename);
1.249 + zFilename = 0;
1.250 + }
1.251 + return zFilename;
1.252 +}
1.253 +
1.254 +/*
1.255 +** Convert multibyte character string to UTF-8. Space to hold the
1.256 +** returned string is obtained from malloc().
1.257 +*/
1.258 +static char *mbcsToUtf8(const char *zFilename){
1.259 + char *zFilenameUtf8;
1.260 + WCHAR *zTmpWide;
1.261 +
1.262 + zTmpWide = mbcsToUnicode(zFilename);
1.263 + if( zTmpWide==0 ){
1.264 + return 0;
1.265 + }
1.266 + zFilenameUtf8 = unicodeToUtf8(zTmpWide);
1.267 + free(zTmpWide);
1.268 + return zFilenameUtf8;
1.269 +}
1.270 +
1.271 +/*
1.272 +** Convert UTF-8 to multibyte character string. Space to hold the
1.273 +** returned string is obtained from malloc().
1.274 +*/
1.275 +static char *utf8ToMbcs(const char *zFilename){
1.276 + char *zFilenameMbcs;
1.277 + WCHAR *zTmpWide;
1.278 +
1.279 + zTmpWide = utf8ToUnicode(zFilename);
1.280 + if( zTmpWide==0 ){
1.281 + return 0;
1.282 + }
1.283 + zFilenameMbcs = unicodeToMbcs(zTmpWide);
1.284 + free(zTmpWide);
1.285 + return zFilenameMbcs;
1.286 +}
1.287 +
1.288 +#if SQLITE_OS_WINCE
1.289 +/*************************************************************************
1.290 +** This section contains code for WinCE only.
1.291 +*/
1.292 +/*
1.293 +** WindowsCE does not have a localtime() function. So create a
1.294 +** substitute.
1.295 +*/
1.296 +#include <time.h>
1.297 +struct tm *__cdecl localtime(const time_t *t)
1.298 +{
1.299 + static struct tm y;
1.300 + FILETIME uTm, lTm;
1.301 + SYSTEMTIME pTm;
1.302 + sqlite3_int64 t64;
1.303 + t64 = *t;
1.304 + t64 = (t64 + 11644473600)*10000000;
1.305 + uTm.dwLowDateTime = t64 & 0xFFFFFFFF;
1.306 + uTm.dwHighDateTime= t64 >> 32;
1.307 + FileTimeToLocalFileTime(&uTm,&lTm);
1.308 + FileTimeToSystemTime(&lTm,&pTm);
1.309 + y.tm_year = pTm.wYear - 1900;
1.310 + y.tm_mon = pTm.wMonth - 1;
1.311 + y.tm_wday = pTm.wDayOfWeek;
1.312 + y.tm_mday = pTm.wDay;
1.313 + y.tm_hour = pTm.wHour;
1.314 + y.tm_min = pTm.wMinute;
1.315 + y.tm_sec = pTm.wSecond;
1.316 + return &y;
1.317 +}
1.318 +
1.319 +/* This will never be called, but defined to make the code compile */
1.320 +#define GetTempPathA(a,b)
1.321 +
1.322 +#define LockFile(a,b,c,d,e) winceLockFile(&a, b, c, d, e)
1.323 +#define UnlockFile(a,b,c,d,e) winceUnlockFile(&a, b, c, d, e)
1.324 +#define LockFileEx(a,b,c,d,e,f) winceLockFileEx(&a, b, c, d, e, f)
1.325 +
1.326 +#define HANDLE_TO_WINFILE(a) (winFile*)&((char*)a)[-offsetof(winFile,h)]
1.327 +
1.328 +/*
1.329 +** Acquire a lock on the handle h
1.330 +*/
1.331 +static void winceMutexAcquire(HANDLE h){
1.332 + DWORD dwErr;
1.333 + do {
1.334 + dwErr = WaitForSingleObject(h, INFINITE);
1.335 + } while (dwErr != WAIT_OBJECT_0 && dwErr != WAIT_ABANDONED);
1.336 +}
1.337 +/*
1.338 +** Release a lock acquired by winceMutexAcquire()
1.339 +*/
1.340 +#define winceMutexRelease(h) ReleaseMutex(h)
1.341 +
1.342 +/*
1.343 +** Create the mutex and shared memory used for locking in the file
1.344 +** descriptor pFile
1.345 +*/
1.346 +static BOOL winceCreateLock(const char *zFilename, winFile *pFile){
1.347 + WCHAR *zTok;
1.348 + WCHAR *zName = utf8ToUnicode(zFilename);
1.349 + BOOL bInit = TRUE;
1.350 +
1.351 + /* Initialize the local lockdata */
1.352 + ZeroMemory(&pFile->local, sizeof(pFile->local));
1.353 +
1.354 + /* Replace the backslashes from the filename and lowercase it
1.355 + ** to derive a mutex name. */
1.356 + zTok = CharLowerW(zName);
1.357 + for (;*zTok;zTok++){
1.358 + if (*zTok == '\\') *zTok = '_';
1.359 + }
1.360 +
1.361 + /* Create/open the named mutex */
1.362 + pFile->hMutex = CreateMutexW(NULL, FALSE, zName);
1.363 + if (!pFile->hMutex){
1.364 + free(zName);
1.365 + return FALSE;
1.366 + }
1.367 +
1.368 + /* Acquire the mutex before continuing */
1.369 + winceMutexAcquire(pFile->hMutex);
1.370 +
1.371 + /* Since the names of named mutexes, semaphores, file mappings etc are
1.372 + ** case-sensitive, take advantage of that by uppercasing the mutex name
1.373 + ** and using that as the shared filemapping name.
1.374 + */
1.375 + CharUpperW(zName);
1.376 + pFile->hShared = CreateFileMappingW(INVALID_HANDLE_VALUE, NULL,
1.377 + PAGE_READWRITE, 0, sizeof(winceLock),
1.378 + zName);
1.379 +
1.380 + /* Set a flag that indicates we're the first to create the memory so it
1.381 + ** must be zero-initialized */
1.382 + if (GetLastError() == ERROR_ALREADY_EXISTS){
1.383 + bInit = FALSE;
1.384 + }
1.385 +
1.386 + free(zName);
1.387 +
1.388 + /* If we succeeded in making the shared memory handle, map it. */
1.389 + if (pFile->hShared){
1.390 + pFile->shared = (winceLock*)MapViewOfFile(pFile->hShared,
1.391 + FILE_MAP_READ|FILE_MAP_WRITE, 0, 0, sizeof(winceLock));
1.392 + /* If mapping failed, close the shared memory handle and erase it */
1.393 + if (!pFile->shared){
1.394 + CloseHandle(pFile->hShared);
1.395 + pFile->hShared = NULL;
1.396 + }
1.397 + }
1.398 +
1.399 + /* If shared memory could not be created, then close the mutex and fail */
1.400 + if (pFile->hShared == NULL){
1.401 + winceMutexRelease(pFile->hMutex);
1.402 + CloseHandle(pFile->hMutex);
1.403 + pFile->hMutex = NULL;
1.404 + return FALSE;
1.405 + }
1.406 +
1.407 + /* Initialize the shared memory if we're supposed to */
1.408 + if (bInit) {
1.409 + ZeroMemory(pFile->shared, sizeof(winceLock));
1.410 + }
1.411 +
1.412 + winceMutexRelease(pFile->hMutex);
1.413 + return TRUE;
1.414 +}
1.415 +
1.416 +/*
1.417 +** Destroy the part of winFile that deals with wince locks
1.418 +*/
1.419 +static void winceDestroyLock(winFile *pFile){
1.420 + if (pFile->hMutex){
1.421 + /* Acquire the mutex */
1.422 + winceMutexAcquire(pFile->hMutex);
1.423 +
1.424 + /* The following blocks should probably assert in debug mode, but they
1.425 + are to cleanup in case any locks remained open */
1.426 + if (pFile->local.nReaders){
1.427 + pFile->shared->nReaders --;
1.428 + }
1.429 + if (pFile->local.bReserved){
1.430 + pFile->shared->bReserved = FALSE;
1.431 + }
1.432 + if (pFile->local.bPending){
1.433 + pFile->shared->bPending = FALSE;
1.434 + }
1.435 + if (pFile->local.bExclusive){
1.436 + pFile->shared->bExclusive = FALSE;
1.437 + }
1.438 +
1.439 + /* De-reference and close our copy of the shared memory handle */
1.440 + UnmapViewOfFile(pFile->shared);
1.441 + CloseHandle(pFile->hShared);
1.442 +
1.443 + /* Done with the mutex */
1.444 + winceMutexRelease(pFile->hMutex);
1.445 + CloseHandle(pFile->hMutex);
1.446 + pFile->hMutex = NULL;
1.447 + }
1.448 +}
1.449 +
1.450 +/*
1.451 +** An implementation of the LockFile() API of windows for wince
1.452 +*/
1.453 +static BOOL winceLockFile(
1.454 + HANDLE *phFile,
1.455 + DWORD dwFileOffsetLow,
1.456 + DWORD dwFileOffsetHigh,
1.457 + DWORD nNumberOfBytesToLockLow,
1.458 + DWORD nNumberOfBytesToLockHigh
1.459 +){
1.460 + winFile *pFile = HANDLE_TO_WINFILE(phFile);
1.461 + BOOL bReturn = FALSE;
1.462 +
1.463 + if (!pFile->hMutex) return TRUE;
1.464 + winceMutexAcquire(pFile->hMutex);
1.465 +
1.466 + /* Wanting an exclusive lock? */
1.467 + if (dwFileOffsetLow == SHARED_FIRST
1.468 + && nNumberOfBytesToLockLow == SHARED_SIZE){
1.469 + if (pFile->shared->nReaders == 0 && pFile->shared->bExclusive == 0){
1.470 + pFile->shared->bExclusive = TRUE;
1.471 + pFile->local.bExclusive = TRUE;
1.472 + bReturn = TRUE;
1.473 + }
1.474 + }
1.475 +
1.476 + /* Want a read-only lock? */
1.477 + else if ((dwFileOffsetLow >= SHARED_FIRST &&
1.478 + dwFileOffsetLow < SHARED_FIRST + SHARED_SIZE) &&
1.479 + nNumberOfBytesToLockLow == 1){
1.480 + if (pFile->shared->bExclusive == 0){
1.481 + pFile->local.nReaders ++;
1.482 + if (pFile->local.nReaders == 1){
1.483 + pFile->shared->nReaders ++;
1.484 + }
1.485 + bReturn = TRUE;
1.486 + }
1.487 + }
1.488 +
1.489 + /* Want a pending lock? */
1.490 + else if (dwFileOffsetLow == PENDING_BYTE && nNumberOfBytesToLockLow == 1){
1.491 + /* If no pending lock has been acquired, then acquire it */
1.492 + if (pFile->shared->bPending == 0) {
1.493 + pFile->shared->bPending = TRUE;
1.494 + pFile->local.bPending = TRUE;
1.495 + bReturn = TRUE;
1.496 + }
1.497 + }
1.498 + /* Want a reserved lock? */
1.499 + else if (dwFileOffsetLow == RESERVED_BYTE && nNumberOfBytesToLockLow == 1){
1.500 + if (pFile->shared->bReserved == 0) {
1.501 + pFile->shared->bReserved = TRUE;
1.502 + pFile->local.bReserved = TRUE;
1.503 + bReturn = TRUE;
1.504 + }
1.505 + }
1.506 +
1.507 + winceMutexRelease(pFile->hMutex);
1.508 + return bReturn;
1.509 +}
1.510 +
1.511 +/*
1.512 +** An implementation of the UnlockFile API of windows for wince
1.513 +*/
1.514 +static BOOL winceUnlockFile(
1.515 + HANDLE *phFile,
1.516 + DWORD dwFileOffsetLow,
1.517 + DWORD dwFileOffsetHigh,
1.518 + DWORD nNumberOfBytesToUnlockLow,
1.519 + DWORD nNumberOfBytesToUnlockHigh
1.520 +){
1.521 + winFile *pFile = HANDLE_TO_WINFILE(phFile);
1.522 + BOOL bReturn = FALSE;
1.523 +
1.524 + if (!pFile->hMutex) return TRUE;
1.525 + winceMutexAcquire(pFile->hMutex);
1.526 +
1.527 + /* Releasing a reader lock or an exclusive lock */
1.528 + if (dwFileOffsetLow >= SHARED_FIRST &&
1.529 + dwFileOffsetLow < SHARED_FIRST + SHARED_SIZE){
1.530 + /* Did we have an exclusive lock? */
1.531 + if (pFile->local.bExclusive){
1.532 + pFile->local.bExclusive = FALSE;
1.533 + pFile->shared->bExclusive = FALSE;
1.534 + bReturn = TRUE;
1.535 + }
1.536 +
1.537 + /* Did we just have a reader lock? */
1.538 + else if (pFile->local.nReaders){
1.539 + pFile->local.nReaders --;
1.540 + if (pFile->local.nReaders == 0)
1.541 + {
1.542 + pFile->shared->nReaders --;
1.543 + }
1.544 + bReturn = TRUE;
1.545 + }
1.546 + }
1.547 +
1.548 + /* Releasing a pending lock */
1.549 + else if (dwFileOffsetLow == PENDING_BYTE && nNumberOfBytesToUnlockLow == 1){
1.550 + if (pFile->local.bPending){
1.551 + pFile->local.bPending = FALSE;
1.552 + pFile->shared->bPending = FALSE;
1.553 + bReturn = TRUE;
1.554 + }
1.555 + }
1.556 + /* Releasing a reserved lock */
1.557 + else if (dwFileOffsetLow == RESERVED_BYTE && nNumberOfBytesToUnlockLow == 1){
1.558 + if (pFile->local.bReserved) {
1.559 + pFile->local.bReserved = FALSE;
1.560 + pFile->shared->bReserved = FALSE;
1.561 + bReturn = TRUE;
1.562 + }
1.563 + }
1.564 +
1.565 + winceMutexRelease(pFile->hMutex);
1.566 + return bReturn;
1.567 +}
1.568 +
1.569 +/*
1.570 +** An implementation of the LockFileEx() API of windows for wince
1.571 +*/
1.572 +static BOOL winceLockFileEx(
1.573 + HANDLE *phFile,
1.574 + DWORD dwFlags,
1.575 + DWORD dwReserved,
1.576 + DWORD nNumberOfBytesToLockLow,
1.577 + DWORD nNumberOfBytesToLockHigh,
1.578 + LPOVERLAPPED lpOverlapped
1.579 +){
1.580 + /* If the caller wants a shared read lock, forward this call
1.581 + ** to winceLockFile */
1.582 + if (lpOverlapped->Offset == SHARED_FIRST &&
1.583 + dwFlags == 1 &&
1.584 + nNumberOfBytesToLockLow == SHARED_SIZE){
1.585 + return winceLockFile(phFile, SHARED_FIRST, 0, 1, 0);
1.586 + }
1.587 + return FALSE;
1.588 +}
1.589 +/*
1.590 +** End of the special code for wince
1.591 +*****************************************************************************/
1.592 +#endif /* SQLITE_OS_WINCE */
1.593 +
1.594 +/*****************************************************************************
1.595 +** The next group of routines implement the I/O methods specified
1.596 +** by the sqlite3_io_methods object.
1.597 +******************************************************************************/
1.598 +
1.599 +/*
1.600 +** Close a file.
1.601 +**
1.602 +** It is reported that an attempt to close a handle might sometimes
1.603 +** fail. This is a very unreasonable result, but windows is notorious
1.604 +** for being unreasonable so I do not doubt that it might happen. If
1.605 +** the close fails, we pause for 100 milliseconds and try again. As
1.606 +** many as MX_CLOSE_ATTEMPT attempts to close the handle are made before
1.607 +** giving up and returning an error.
1.608 +*/
1.609 +#define MX_CLOSE_ATTEMPT 3
1.610 +static int winClose(sqlite3_file *id){
1.611 + int rc, cnt = 0;
1.612 + winFile *pFile = (winFile*)id;
1.613 + OSTRACE2("CLOSE %d\n", pFile->h);
1.614 + do{
1.615 + rc = CloseHandle(pFile->h);
1.616 + }while( rc==0 && ++cnt < MX_CLOSE_ATTEMPT && (Sleep(100), 1) );
1.617 +#if SQLITE_OS_WINCE
1.618 +#define WINCE_DELETION_ATTEMPTS 3
1.619 + winceDestroyLock(pFile);
1.620 + if( pFile->zDeleteOnClose ){
1.621 + int cnt = 0;
1.622 + while(
1.623 + DeleteFileW(pFile->zDeleteOnClose)==0
1.624 + && GetFileAttributesW(pFile->zDeleteOnClose)!=0xffffffff
1.625 + && cnt++ < WINCE_DELETION_ATTEMPTS
1.626 + ){
1.627 + Sleep(100); /* Wait a little before trying again */
1.628 + }
1.629 + free(pFile->zDeleteOnClose);
1.630 + }
1.631 +#endif
1.632 + OpenCounter(-1);
1.633 + return rc ? SQLITE_OK : SQLITE_IOERR;
1.634 +}
1.635 +
1.636 +/*
1.637 +** Some microsoft compilers lack this definition.
1.638 +*/
1.639 +#ifndef INVALID_SET_FILE_POINTER
1.640 +# define INVALID_SET_FILE_POINTER ((DWORD)-1)
1.641 +#endif
1.642 +
1.643 +/*
1.644 +** Read data from a file into a buffer. Return SQLITE_OK if all
1.645 +** bytes were read successfully and SQLITE_IOERR if anything goes
1.646 +** wrong.
1.647 +*/
1.648 +static int winRead(
1.649 + sqlite3_file *id, /* File to read from */
1.650 + void *pBuf, /* Write content into this buffer */
1.651 + int amt, /* Number of bytes to read */
1.652 + sqlite3_int64 offset /* Begin reading at this offset */
1.653 +){
1.654 + LONG upperBits = (offset>>32) & 0x7fffffff;
1.655 + LONG lowerBits = offset & 0xffffffff;
1.656 + DWORD rc;
1.657 + DWORD got;
1.658 + winFile *pFile = (winFile*)id;
1.659 + assert( id!=0 );
1.660 + SimulateIOError(return SQLITE_IOERR_READ);
1.661 + OSTRACE3("READ %d lock=%d\n", pFile->h, pFile->locktype);
1.662 + rc = SetFilePointer(pFile->h, lowerBits, &upperBits, FILE_BEGIN);
1.663 + if( rc==INVALID_SET_FILE_POINTER && GetLastError()!=NO_ERROR ){
1.664 + return SQLITE_FULL;
1.665 + }
1.666 + if( !ReadFile(pFile->h, pBuf, amt, &got, 0) ){
1.667 + return SQLITE_IOERR_READ;
1.668 + }
1.669 + if( got==(DWORD)amt ){
1.670 + return SQLITE_OK;
1.671 + }else{
1.672 + memset(&((char*)pBuf)[got], 0, amt-got);
1.673 + return SQLITE_IOERR_SHORT_READ;
1.674 + }
1.675 +}
1.676 +
1.677 +/*
1.678 +** Write data from a buffer into a file. Return SQLITE_OK on success
1.679 +** or some other error code on failure.
1.680 +*/
1.681 +static int winWrite(
1.682 + sqlite3_file *id, /* File to write into */
1.683 + const void *pBuf, /* The bytes to be written */
1.684 + int amt, /* Number of bytes to write */
1.685 + sqlite3_int64 offset /* Offset into the file to begin writing at */
1.686 +){
1.687 + LONG upperBits = (offset>>32) & 0x7fffffff;
1.688 + LONG lowerBits = offset & 0xffffffff;
1.689 + DWORD rc;
1.690 + DWORD wrote;
1.691 + winFile *pFile = (winFile*)id;
1.692 + assert( id!=0 );
1.693 + SimulateIOError(return SQLITE_IOERR_WRITE);
1.694 + SimulateDiskfullError(return SQLITE_FULL);
1.695 + OSTRACE3("WRITE %d lock=%d\n", pFile->h, pFile->locktype);
1.696 + rc = SetFilePointer(pFile->h, lowerBits, &upperBits, FILE_BEGIN);
1.697 + if( rc==INVALID_SET_FILE_POINTER && GetLastError()!=NO_ERROR ){
1.698 + return SQLITE_FULL;
1.699 + }
1.700 + assert( amt>0 );
1.701 + while(
1.702 + amt>0
1.703 + && (rc = WriteFile(pFile->h, pBuf, amt, &wrote, 0))!=0
1.704 + && wrote>0
1.705 + ){
1.706 + amt -= wrote;
1.707 + pBuf = &((char*)pBuf)[wrote];
1.708 + }
1.709 + if( !rc || amt>(int)wrote ){
1.710 + return SQLITE_FULL;
1.711 + }
1.712 + return SQLITE_OK;
1.713 +}
1.714 +
1.715 +/*
1.716 +** Truncate an open file to a specified size
1.717 +*/
1.718 +static int winTruncate(sqlite3_file *id, sqlite3_int64 nByte){
1.719 + DWORD rc;
1.720 + LONG upperBits = (nByte>>32) & 0x7fffffff;
1.721 + LONG lowerBits = nByte & 0xffffffff;
1.722 + winFile *pFile = (winFile*)id;
1.723 + OSTRACE3("TRUNCATE %d %lld\n", pFile->h, nByte);
1.724 + SimulateIOError(return SQLITE_IOERR_TRUNCATE);
1.725 + rc = SetFilePointer(pFile->h, lowerBits, &upperBits, FILE_BEGIN);
1.726 + if( INVALID_SET_FILE_POINTER != rc ){
1.727 + /* SetEndOfFile will fail if nByte is negative */
1.728 + if( SetEndOfFile(pFile->h) ){
1.729 + return SQLITE_OK;
1.730 + }
1.731 + }
1.732 + return SQLITE_IOERR_TRUNCATE;
1.733 +}
1.734 +
1.735 +#ifdef SQLITE_TEST
1.736 +/*
1.737 +** Count the number of fullsyncs and normal syncs. This is used to test
1.738 +** that syncs and fullsyncs are occuring at the right times.
1.739 +*/
1.740 +int sqlite3_sync_count = 0;
1.741 +int sqlite3_fullsync_count = 0;
1.742 +#endif
1.743 +
1.744 +/*
1.745 +** Make sure all writes to a particular file are committed to disk.
1.746 +*/
1.747 +static int winSync(sqlite3_file *id, int flags){
1.748 + winFile *pFile = (winFile*)id;
1.749 + OSTRACE3("SYNC %d lock=%d\n", pFile->h, pFile->locktype);
1.750 +#ifdef SQLITE_TEST
1.751 + if( flags & SQLITE_SYNC_FULL ){
1.752 + sqlite3_fullsync_count++;
1.753 + }
1.754 + sqlite3_sync_count++;
1.755 +#endif
1.756 + if( FlushFileBuffers(pFile->h) ){
1.757 + return SQLITE_OK;
1.758 + }else{
1.759 + return SQLITE_IOERR;
1.760 + }
1.761 +}
1.762 +
1.763 +/*
1.764 +** Determine the current size of a file in bytes
1.765 +*/
1.766 +static int winFileSize(sqlite3_file *id, sqlite3_int64 *pSize){
1.767 + winFile *pFile = (winFile*)id;
1.768 + DWORD upperBits, lowerBits;
1.769 + SimulateIOError(return SQLITE_IOERR_FSTAT);
1.770 + lowerBits = GetFileSize(pFile->h, &upperBits);
1.771 + *pSize = (((sqlite3_int64)upperBits)<<32) + lowerBits;
1.772 + return SQLITE_OK;
1.773 +}
1.774 +
1.775 +/*
1.776 +** LOCKFILE_FAIL_IMMEDIATELY is undefined on some Windows systems.
1.777 +*/
1.778 +#ifndef LOCKFILE_FAIL_IMMEDIATELY
1.779 +# define LOCKFILE_FAIL_IMMEDIATELY 1
1.780 +#endif
1.781 +
1.782 +/*
1.783 +** Acquire a reader lock.
1.784 +** Different API routines are called depending on whether or not this
1.785 +** is Win95 or WinNT.
1.786 +*/
1.787 +static int getReadLock(winFile *pFile){
1.788 + int res;
1.789 + if( isNT() ){
1.790 + OVERLAPPED ovlp;
1.791 + ovlp.Offset = SHARED_FIRST;
1.792 + ovlp.OffsetHigh = 0;
1.793 + ovlp.hEvent = 0;
1.794 + res = LockFileEx(pFile->h, LOCKFILE_FAIL_IMMEDIATELY,
1.795 + 0, SHARED_SIZE, 0, &ovlp);
1.796 + }else{
1.797 + int lk;
1.798 + sqlite3_randomness(sizeof(lk), &lk);
1.799 + pFile->sharedLockByte = (lk & 0x7fffffff)%(SHARED_SIZE - 1);
1.800 + res = LockFile(pFile->h, SHARED_FIRST+pFile->sharedLockByte, 0, 1, 0);
1.801 + }
1.802 + return res;
1.803 +}
1.804 +
1.805 +/*
1.806 +** Undo a readlock
1.807 +*/
1.808 +static int unlockReadLock(winFile *pFile){
1.809 + int res;
1.810 + if( isNT() ){
1.811 + res = UnlockFile(pFile->h, SHARED_FIRST, 0, SHARED_SIZE, 0);
1.812 + }else{
1.813 + res = UnlockFile(pFile->h, SHARED_FIRST + pFile->sharedLockByte, 0, 1, 0);
1.814 + }
1.815 + return res;
1.816 +}
1.817 +
1.818 +/*
1.819 +** Lock the file with the lock specified by parameter locktype - one
1.820 +** of the following:
1.821 +**
1.822 +** (1) SHARED_LOCK
1.823 +** (2) RESERVED_LOCK
1.824 +** (3) PENDING_LOCK
1.825 +** (4) EXCLUSIVE_LOCK
1.826 +**
1.827 +** Sometimes when requesting one lock state, additional lock states
1.828 +** are inserted in between. The locking might fail on one of the later
1.829 +** transitions leaving the lock state different from what it started but
1.830 +** still short of its goal. The following chart shows the allowed
1.831 +** transitions and the inserted intermediate states:
1.832 +**
1.833 +** UNLOCKED -> SHARED
1.834 +** SHARED -> RESERVED
1.835 +** SHARED -> (PENDING) -> EXCLUSIVE
1.836 +** RESERVED -> (PENDING) -> EXCLUSIVE
1.837 +** PENDING -> EXCLUSIVE
1.838 +**
1.839 +** This routine will only increase a lock. The winUnlock() routine
1.840 +** erases all locks at once and returns us immediately to locking level 0.
1.841 +** It is not possible to lower the locking level one step at a time. You
1.842 +** must go straight to locking level 0.
1.843 +*/
1.844 +static int winLock(sqlite3_file *id, int locktype){
1.845 + int rc = SQLITE_OK; /* Return code from subroutines */
1.846 + int res = 1; /* Result of a windows lock call */
1.847 + int newLocktype; /* Set pFile->locktype to this value before exiting */
1.848 + int gotPendingLock = 0;/* True if we acquired a PENDING lock this time */
1.849 + winFile *pFile = (winFile*)id;
1.850 +
1.851 + assert( pFile!=0 );
1.852 + OSTRACE5("LOCK %d %d was %d(%d)\n",
1.853 + pFile->h, locktype, pFile->locktype, pFile->sharedLockByte);
1.854 +
1.855 + /* If there is already a lock of this type or more restrictive on the
1.856 + ** OsFile, do nothing. Don't use the end_lock: exit path, as
1.857 + ** sqlite3OsEnterMutex() hasn't been called yet.
1.858 + */
1.859 + if( pFile->locktype>=locktype ){
1.860 + return SQLITE_OK;
1.861 + }
1.862 +
1.863 + /* Make sure the locking sequence is correct
1.864 + */
1.865 + assert( pFile->locktype!=NO_LOCK || locktype==SHARED_LOCK );
1.866 + assert( locktype!=PENDING_LOCK );
1.867 + assert( locktype!=RESERVED_LOCK || pFile->locktype==SHARED_LOCK );
1.868 +
1.869 + /* Lock the PENDING_LOCK byte if we need to acquire a PENDING lock or
1.870 + ** a SHARED lock. If we are acquiring a SHARED lock, the acquisition of
1.871 + ** the PENDING_LOCK byte is temporary.
1.872 + */
1.873 + newLocktype = pFile->locktype;
1.874 + if( pFile->locktype==NO_LOCK
1.875 + || (locktype==EXCLUSIVE_LOCK && pFile->locktype==RESERVED_LOCK)
1.876 + ){
1.877 + int cnt = 3;
1.878 + while( cnt-->0 && (res = LockFile(pFile->h, PENDING_BYTE, 0, 1, 0))==0 ){
1.879 + /* Try 3 times to get the pending lock. The pending lock might be
1.880 + ** held by another reader process who will release it momentarily.
1.881 + */
1.882 + OSTRACE2("could not get a PENDING lock. cnt=%d\n", cnt);
1.883 + Sleep(1);
1.884 + }
1.885 + gotPendingLock = res;
1.886 + }
1.887 +
1.888 + /* Acquire a shared lock
1.889 + */
1.890 + if( locktype==SHARED_LOCK && res ){
1.891 + assert( pFile->locktype==NO_LOCK );
1.892 + res = getReadLock(pFile);
1.893 + if( res ){
1.894 + newLocktype = SHARED_LOCK;
1.895 + }
1.896 + }
1.897 +
1.898 + /* Acquire a RESERVED lock
1.899 + */
1.900 + if( locktype==RESERVED_LOCK && res ){
1.901 + assert( pFile->locktype==SHARED_LOCK );
1.902 + res = LockFile(pFile->h, RESERVED_BYTE, 0, 1, 0);
1.903 + if( res ){
1.904 + newLocktype = RESERVED_LOCK;
1.905 + }
1.906 + }
1.907 +
1.908 + /* Acquire a PENDING lock
1.909 + */
1.910 + if( locktype==EXCLUSIVE_LOCK && res ){
1.911 + newLocktype = PENDING_LOCK;
1.912 + gotPendingLock = 0;
1.913 + }
1.914 +
1.915 + /* Acquire an EXCLUSIVE lock
1.916 + */
1.917 + if( locktype==EXCLUSIVE_LOCK && res ){
1.918 + assert( pFile->locktype>=SHARED_LOCK );
1.919 + res = unlockReadLock(pFile);
1.920 + OSTRACE2("unreadlock = %d\n", res);
1.921 + res = LockFile(pFile->h, SHARED_FIRST, 0, SHARED_SIZE, 0);
1.922 + if( res ){
1.923 + newLocktype = EXCLUSIVE_LOCK;
1.924 + }else{
1.925 + OSTRACE2("error-code = %d\n", GetLastError());
1.926 + getReadLock(pFile);
1.927 + }
1.928 + }
1.929 +
1.930 + /* If we are holding a PENDING lock that ought to be released, then
1.931 + ** release it now.
1.932 + */
1.933 + if( gotPendingLock && locktype==SHARED_LOCK ){
1.934 + UnlockFile(pFile->h, PENDING_BYTE, 0, 1, 0);
1.935 + }
1.936 +
1.937 + /* Update the state of the lock has held in the file descriptor then
1.938 + ** return the appropriate result code.
1.939 + */
1.940 + if( res ){
1.941 + rc = SQLITE_OK;
1.942 + }else{
1.943 + OSTRACE4("LOCK FAILED %d trying for %d but got %d\n", pFile->h,
1.944 + locktype, newLocktype);
1.945 + rc = SQLITE_BUSY;
1.946 + }
1.947 + pFile->locktype = newLocktype;
1.948 + return rc;
1.949 +}
1.950 +
1.951 +/*
1.952 +** This routine checks if there is a RESERVED lock held on the specified
1.953 +** file by this or any other process. If such a lock is held, return
1.954 +** non-zero, otherwise zero.
1.955 +*/
1.956 +static int winCheckReservedLock(sqlite3_file *id, int *pResOut){
1.957 + int rc;
1.958 + winFile *pFile = (winFile*)id;
1.959 + assert( pFile!=0 );
1.960 + if( pFile->locktype>=RESERVED_LOCK ){
1.961 + rc = 1;
1.962 + OSTRACE3("TEST WR-LOCK %d %d (local)\n", pFile->h, rc);
1.963 + }else{
1.964 + rc = LockFile(pFile->h, RESERVED_BYTE, 0, 1, 0);
1.965 + if( rc ){
1.966 + UnlockFile(pFile->h, RESERVED_BYTE, 0, 1, 0);
1.967 + }
1.968 + rc = !rc;
1.969 + OSTRACE3("TEST WR-LOCK %d %d (remote)\n", pFile->h, rc);
1.970 + }
1.971 + *pResOut = rc;
1.972 + return SQLITE_OK;
1.973 +}
1.974 +
1.975 +/*
1.976 +** Lower the locking level on file descriptor id to locktype. locktype
1.977 +** must be either NO_LOCK or SHARED_LOCK.
1.978 +**
1.979 +** If the locking level of the file descriptor is already at or below
1.980 +** the requested locking level, this routine is a no-op.
1.981 +**
1.982 +** It is not possible for this routine to fail if the second argument
1.983 +** is NO_LOCK. If the second argument is SHARED_LOCK then this routine
1.984 +** might return SQLITE_IOERR;
1.985 +*/
1.986 +static int winUnlock(sqlite3_file *id, int locktype){
1.987 + int type;
1.988 + winFile *pFile = (winFile*)id;
1.989 + int rc = SQLITE_OK;
1.990 + assert( pFile!=0 );
1.991 + assert( locktype<=SHARED_LOCK );
1.992 + OSTRACE5("UNLOCK %d to %d was %d(%d)\n", pFile->h, locktype,
1.993 + pFile->locktype, pFile->sharedLockByte);
1.994 + type = pFile->locktype;
1.995 + if( type>=EXCLUSIVE_LOCK ){
1.996 + UnlockFile(pFile->h, SHARED_FIRST, 0, SHARED_SIZE, 0);
1.997 + if( locktype==SHARED_LOCK && !getReadLock(pFile) ){
1.998 + /* This should never happen. We should always be able to
1.999 + ** reacquire the read lock */
1.1000 + rc = SQLITE_IOERR_UNLOCK;
1.1001 + }
1.1002 + }
1.1003 + if( type>=RESERVED_LOCK ){
1.1004 + UnlockFile(pFile->h, RESERVED_BYTE, 0, 1, 0);
1.1005 + }
1.1006 + if( locktype==NO_LOCK && type>=SHARED_LOCK ){
1.1007 + unlockReadLock(pFile);
1.1008 + }
1.1009 + if( type>=PENDING_LOCK ){
1.1010 + UnlockFile(pFile->h, PENDING_BYTE, 0, 1, 0);
1.1011 + }
1.1012 + pFile->locktype = locktype;
1.1013 + return rc;
1.1014 +}
1.1015 +
1.1016 +/*
1.1017 +** Control and query of the open file handle.
1.1018 +*/
1.1019 +static int winFileControl(sqlite3_file *id, int op, void *pArg){
1.1020 + switch( op ){
1.1021 + case SQLITE_FCNTL_LOCKSTATE: {
1.1022 + *(int*)pArg = ((winFile*)id)->locktype;
1.1023 + return SQLITE_OK;
1.1024 + }
1.1025 + }
1.1026 + return SQLITE_ERROR;
1.1027 +}
1.1028 +
1.1029 +/*
1.1030 +** Return the sector size in bytes of the underlying block device for
1.1031 +** the specified file. This is almost always 512 bytes, but may be
1.1032 +** larger for some devices.
1.1033 +**
1.1034 +** SQLite code assumes this function cannot fail. It also assumes that
1.1035 +** if two files are created in the same file-system directory (i.e.
1.1036 +** a database and its journal file) that the sector size will be the
1.1037 +** same for both.
1.1038 +*/
1.1039 +static int winSectorSize(sqlite3_file *id){
1.1040 + return SQLITE_DEFAULT_SECTOR_SIZE;
1.1041 +}
1.1042 +
1.1043 +/*
1.1044 +** Return a vector of device characteristics.
1.1045 +*/
1.1046 +static int winDeviceCharacteristics(sqlite3_file *id){
1.1047 + return 0;
1.1048 +}
1.1049 +
1.1050 +/*
1.1051 +** This vector defines all the methods that can operate on an
1.1052 +** sqlite3_file for win32.
1.1053 +*/
1.1054 +static const sqlite3_io_methods winIoMethod = {
1.1055 + 1, /* iVersion */
1.1056 + winClose,
1.1057 + winRead,
1.1058 + winWrite,
1.1059 + winTruncate,
1.1060 + winSync,
1.1061 + winFileSize,
1.1062 + winLock,
1.1063 + winUnlock,
1.1064 + winCheckReservedLock,
1.1065 + winFileControl,
1.1066 + winSectorSize,
1.1067 + winDeviceCharacteristics
1.1068 +};
1.1069 +
1.1070 +/***************************************************************************
1.1071 +** Here ends the I/O methods that form the sqlite3_io_methods object.
1.1072 +**
1.1073 +** The next block of code implements the VFS methods.
1.1074 +****************************************************************************/
1.1075 +
1.1076 +/*
1.1077 +** Convert a UTF-8 filename into whatever form the underlying
1.1078 +** operating system wants filenames in. Space to hold the result
1.1079 +** is obtained from malloc and must be freed by the calling
1.1080 +** function.
1.1081 +*/
1.1082 +static void *convertUtf8Filename(const char *zFilename){
1.1083 + void *zConverted = 0;
1.1084 + if( isNT() ){
1.1085 + zConverted = utf8ToUnicode(zFilename);
1.1086 + }else{
1.1087 + zConverted = utf8ToMbcs(zFilename);
1.1088 + }
1.1089 + /* caller will handle out of memory */
1.1090 + return zConverted;
1.1091 +}
1.1092 +
1.1093 +/*
1.1094 +** Create a temporary file name in zBuf. zBuf must be big enough to
1.1095 +** hold at pVfs->mxPathname characters.
1.1096 +*/
1.1097 +static int getTempname(int nBuf, char *zBuf){
1.1098 + static char zChars[] =
1.1099 + "abcdefghijklmnopqrstuvwxyz"
1.1100 + "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
1.1101 + "0123456789";
1.1102 + size_t i, j;
1.1103 + char zTempPath[MAX_PATH+1];
1.1104 + if( sqlite3_temp_directory ){
1.1105 + sqlite3_snprintf(MAX_PATH-30, zTempPath, "%s", sqlite3_temp_directory);
1.1106 + }else if( isNT() ){
1.1107 + char *zMulti;
1.1108 + WCHAR zWidePath[MAX_PATH];
1.1109 + GetTempPathW(MAX_PATH-30, zWidePath);
1.1110 + zMulti = unicodeToUtf8(zWidePath);
1.1111 + if( zMulti ){
1.1112 + sqlite3_snprintf(MAX_PATH-30, zTempPath, "%s", zMulti);
1.1113 + free(zMulti);
1.1114 + }else{
1.1115 + return SQLITE_NOMEM;
1.1116 + }
1.1117 + }else{
1.1118 + char *zUtf8;
1.1119 + char zMbcsPath[MAX_PATH];
1.1120 + GetTempPathA(MAX_PATH-30, zMbcsPath);
1.1121 + zUtf8 = mbcsToUtf8(zMbcsPath);
1.1122 + if( zUtf8 ){
1.1123 + sqlite3_snprintf(MAX_PATH-30, zTempPath, "%s", zUtf8);
1.1124 + free(zUtf8);
1.1125 + }else{
1.1126 + return SQLITE_NOMEM;
1.1127 + }
1.1128 + }
1.1129 + for(i=strlen(zTempPath); i>0 && zTempPath[i-1]=='\\'; i--){}
1.1130 + zTempPath[i] = 0;
1.1131 + sqlite3_snprintf(nBuf-30, zBuf,
1.1132 + "%s\\"SQLITE_TEMP_FILE_PREFIX, zTempPath);
1.1133 + j = strlen(zBuf);
1.1134 + sqlite3_randomness(20, &zBuf[j]);
1.1135 + for(i=0; i<20; i++, j++){
1.1136 + zBuf[j] = (char)zChars[ ((unsigned char)zBuf[j])%(sizeof(zChars)-1) ];
1.1137 + }
1.1138 + zBuf[j] = 0;
1.1139 + OSTRACE2("TEMP FILENAME: %s\n", zBuf);
1.1140 + return SQLITE_OK;
1.1141 +}
1.1142 +
1.1143 +/*
1.1144 +** The return value of getLastErrorMsg
1.1145 +** is zero if the error message fits in the buffer, or non-zero
1.1146 +** otherwise (if the message was truncated).
1.1147 +*/
1.1148 +static int getLastErrorMsg(int nBuf, char *zBuf){
1.1149 + DWORD error = GetLastError();
1.1150 +
1.1151 +#if SQLITE_OS_WINCE
1.1152 + sqlite3_snprintf(nBuf, zBuf, "OsError 0x%x (%u)", error, error);
1.1153 +#else
1.1154 + /* FormatMessage returns 0 on failure. Otherwise it
1.1155 + ** returns the number of TCHARs written to the output
1.1156 + ** buffer, excluding the terminating null char.
1.1157 + */
1.1158 + if (!FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM,
1.1159 + NULL,
1.1160 + error,
1.1161 + 0,
1.1162 + zBuf,
1.1163 + nBuf-1,
1.1164 + 0))
1.1165 + {
1.1166 + sqlite3_snprintf(nBuf, zBuf, "OsError 0x%x (%u)", error, error);
1.1167 + }
1.1168 +#endif
1.1169 +
1.1170 + return 0;
1.1171 +}
1.1172 +
1.1173 +
1.1174 +/*
1.1175 +** Open a file.
1.1176 +*/
1.1177 +static int winOpen(
1.1178 + sqlite3_vfs *pVfs, /* Not used */
1.1179 + const char *zName, /* Name of the file (UTF-8) */
1.1180 + sqlite3_file *id, /* Write the SQLite file handle here */
1.1181 + int flags, /* Open mode flags */
1.1182 + int *pOutFlags /* Status return flags */
1.1183 +){
1.1184 + HANDLE h;
1.1185 + DWORD dwDesiredAccess;
1.1186 + DWORD dwShareMode;
1.1187 + DWORD dwCreationDisposition;
1.1188 + DWORD dwFlagsAndAttributes = 0;
1.1189 +#if SQLITE_OS_WINCE
1.1190 + int isTemp = 0;
1.1191 +#endif
1.1192 + winFile *pFile = (winFile*)id;
1.1193 + void *zConverted; /* Filename in OS encoding */
1.1194 + const char *zUtf8Name = zName; /* Filename in UTF-8 encoding */
1.1195 + char zTmpname[MAX_PATH+1]; /* Buffer used to create temp filename */
1.1196 +
1.1197 + /* If the second argument to this function is NULL, generate a
1.1198 + ** temporary file name to use
1.1199 + */
1.1200 + if( !zUtf8Name ){
1.1201 + int rc = getTempname(MAX_PATH+1, zTmpname);
1.1202 + if( rc!=SQLITE_OK ){
1.1203 + return rc;
1.1204 + }
1.1205 + zUtf8Name = zTmpname;
1.1206 + }
1.1207 +
1.1208 + /* Convert the filename to the system encoding. */
1.1209 + zConverted = convertUtf8Filename(zUtf8Name);
1.1210 + if( zConverted==0 ){
1.1211 + return SQLITE_NOMEM;
1.1212 + }
1.1213 +
1.1214 + if( flags & SQLITE_OPEN_READWRITE ){
1.1215 + dwDesiredAccess = GENERIC_READ | GENERIC_WRITE;
1.1216 + }else{
1.1217 + dwDesiredAccess = GENERIC_READ;
1.1218 + }
1.1219 + if( flags & SQLITE_OPEN_CREATE ){
1.1220 + dwCreationDisposition = OPEN_ALWAYS;
1.1221 + }else{
1.1222 + dwCreationDisposition = OPEN_EXISTING;
1.1223 + }
1.1224 + if( flags & SQLITE_OPEN_MAIN_DB ){
1.1225 + dwShareMode = FILE_SHARE_READ | FILE_SHARE_WRITE;
1.1226 + }else{
1.1227 + dwShareMode = 0;
1.1228 + }
1.1229 + if( flags & SQLITE_OPEN_DELETEONCLOSE ){
1.1230 +#if SQLITE_OS_WINCE
1.1231 + dwFlagsAndAttributes = FILE_ATTRIBUTE_HIDDEN;
1.1232 + isTemp = 1;
1.1233 +#else
1.1234 + dwFlagsAndAttributes = FILE_ATTRIBUTE_TEMPORARY
1.1235 + | FILE_ATTRIBUTE_HIDDEN
1.1236 + | FILE_FLAG_DELETE_ON_CLOSE;
1.1237 +#endif
1.1238 + }else{
1.1239 + dwFlagsAndAttributes = FILE_ATTRIBUTE_NORMAL;
1.1240 + }
1.1241 + /* Reports from the internet are that performance is always
1.1242 + ** better if FILE_FLAG_RANDOM_ACCESS is used. Ticket #2699. */
1.1243 +#if SQLITE_OS_WINCE
1.1244 + dwFlagsAndAttributes |= FILE_FLAG_RANDOM_ACCESS;
1.1245 +#endif
1.1246 + if( isNT() ){
1.1247 + h = CreateFileW((WCHAR*)zConverted,
1.1248 + dwDesiredAccess,
1.1249 + dwShareMode,
1.1250 + NULL,
1.1251 + dwCreationDisposition,
1.1252 + dwFlagsAndAttributes,
1.1253 + NULL
1.1254 + );
1.1255 + }else{
1.1256 + h = CreateFileA((char*)zConverted,
1.1257 + dwDesiredAccess,
1.1258 + dwShareMode,
1.1259 + NULL,
1.1260 + dwCreationDisposition,
1.1261 + dwFlagsAndAttributes,
1.1262 + NULL
1.1263 + );
1.1264 + }
1.1265 + if( h==INVALID_HANDLE_VALUE ){
1.1266 + free(zConverted);
1.1267 + if( flags & SQLITE_OPEN_READWRITE ){
1.1268 + return winOpen(0, zName, id,
1.1269 + ((flags|SQLITE_OPEN_READONLY)&~SQLITE_OPEN_READWRITE), pOutFlags);
1.1270 + }else{
1.1271 + return SQLITE_CANTOPEN;
1.1272 + }
1.1273 + }
1.1274 + if( pOutFlags ){
1.1275 + if( flags & SQLITE_OPEN_READWRITE ){
1.1276 + *pOutFlags = SQLITE_OPEN_READWRITE;
1.1277 + }else{
1.1278 + *pOutFlags = SQLITE_OPEN_READONLY;
1.1279 + }
1.1280 + }
1.1281 + memset(pFile, 0, sizeof(*pFile));
1.1282 + pFile->pMethod = &winIoMethod;
1.1283 + pFile->h = h;
1.1284 +#if SQLITE_OS_WINCE
1.1285 + if( (flags & (SQLITE_OPEN_READWRITE|SQLITE_OPEN_MAIN_DB)) ==
1.1286 + (SQLITE_OPEN_READWRITE|SQLITE_OPEN_MAIN_DB)
1.1287 + && !winceCreateLock(zName, pFile)
1.1288 + ){
1.1289 + CloseHandle(h);
1.1290 + free(zConverted);
1.1291 + return SQLITE_CANTOPEN;
1.1292 + }
1.1293 + if( isTemp ){
1.1294 + pFile->zDeleteOnClose = zConverted;
1.1295 + }else
1.1296 +#endif
1.1297 + {
1.1298 + free(zConverted);
1.1299 + }
1.1300 + OpenCounter(+1);
1.1301 + return SQLITE_OK;
1.1302 +}
1.1303 +
1.1304 +/*
1.1305 +** Delete the named file.
1.1306 +**
1.1307 +** Note that windows does not allow a file to be deleted if some other
1.1308 +** process has it open. Sometimes a virus scanner or indexing program
1.1309 +** will open a journal file shortly after it is created in order to do
1.1310 +** whatever it does. While this other process is holding the
1.1311 +** file open, we will be unable to delete it. To work around this
1.1312 +** problem, we delay 100 milliseconds and try to delete again. Up
1.1313 +** to MX_DELETION_ATTEMPTs deletion attempts are run before giving
1.1314 +** up and returning an error.
1.1315 +*/
1.1316 +#define MX_DELETION_ATTEMPTS 5
1.1317 +static int winDelete(
1.1318 + sqlite3_vfs *pVfs, /* Not used on win32 */
1.1319 + const char *zFilename, /* Name of file to delete */
1.1320 + int syncDir /* Not used on win32 */
1.1321 +){
1.1322 + int cnt = 0;
1.1323 + DWORD rc;
1.1324 + DWORD error;
1.1325 + void *zConverted = convertUtf8Filename(zFilename);
1.1326 + if( zConverted==0 ){
1.1327 + return SQLITE_NOMEM;
1.1328 + }
1.1329 + SimulateIOError(return SQLITE_IOERR_DELETE);
1.1330 + if( isNT() ){
1.1331 + do{
1.1332 + DeleteFileW(zConverted);
1.1333 + }while( ( ((rc = GetFileAttributesW(zConverted)) != INVALID_FILE_ATTRIBUTES)
1.1334 + || ((error = GetLastError()) == ERROR_ACCESS_DENIED))
1.1335 + && (++cnt < MX_DELETION_ATTEMPTS)
1.1336 + && (Sleep(100), 1) );
1.1337 + }else{
1.1338 + do{
1.1339 + DeleteFileA(zConverted);
1.1340 + }while( ( ((rc = GetFileAttributesA(zConverted)) != INVALID_FILE_ATTRIBUTES)
1.1341 + || ((error = GetLastError()) == ERROR_ACCESS_DENIED))
1.1342 + && (++cnt < MX_DELETION_ATTEMPTS)
1.1343 + && (Sleep(100), 1) );
1.1344 + }
1.1345 + free(zConverted);
1.1346 + OSTRACE2("DELETE \"%s\"\n", zFilename);
1.1347 + return ( (rc == INVALID_FILE_ATTRIBUTES)
1.1348 + && (error == ERROR_FILE_NOT_FOUND)) ? SQLITE_OK : SQLITE_IOERR_DELETE;
1.1349 +}
1.1350 +
1.1351 +/*
1.1352 +** Check the existance and status of a file.
1.1353 +*/
1.1354 +static int winAccess(
1.1355 + sqlite3_vfs *pVfs, /* Not used on win32 */
1.1356 + const char *zFilename, /* Name of file to check */
1.1357 + int flags, /* Type of test to make on this file */
1.1358 + int *pResOut /* OUT: Result */
1.1359 +){
1.1360 + DWORD attr;
1.1361 + int rc;
1.1362 + void *zConverted = convertUtf8Filename(zFilename);
1.1363 + if( zConverted==0 ){
1.1364 + return SQLITE_NOMEM;
1.1365 + }
1.1366 + if( isNT() ){
1.1367 + attr = GetFileAttributesW((WCHAR*)zConverted);
1.1368 + }else{
1.1369 + attr = GetFileAttributesA((char*)zConverted);
1.1370 + }
1.1371 + free(zConverted);
1.1372 + switch( flags ){
1.1373 + case SQLITE_ACCESS_READ:
1.1374 + case SQLITE_ACCESS_EXISTS:
1.1375 + rc = attr!=INVALID_FILE_ATTRIBUTES;
1.1376 + break;
1.1377 + case SQLITE_ACCESS_READWRITE:
1.1378 + rc = (attr & FILE_ATTRIBUTE_READONLY)==0;
1.1379 + break;
1.1380 + default:
1.1381 + assert(!"Invalid flags argument");
1.1382 + }
1.1383 + *pResOut = rc;
1.1384 + return SQLITE_OK;
1.1385 +}
1.1386 +
1.1387 +
1.1388 +/*
1.1389 +** Turn a relative pathname into a full pathname. Write the full
1.1390 +** pathname into zOut[]. zOut[] will be at least pVfs->mxPathname
1.1391 +** bytes in size.
1.1392 +*/
1.1393 +static int winFullPathname(
1.1394 + sqlite3_vfs *pVfs, /* Pointer to vfs object */
1.1395 + const char *zRelative, /* Possibly relative input path */
1.1396 + int nFull, /* Size of output buffer in bytes */
1.1397 + char *zFull /* Output buffer */
1.1398 +){
1.1399 +
1.1400 +#if defined(__CYGWIN__)
1.1401 + cygwin_conv_to_full_win32_path(zRelative, zFull);
1.1402 + return SQLITE_OK;
1.1403 +#endif
1.1404 +
1.1405 +#if SQLITE_OS_WINCE
1.1406 + /* WinCE has no concept of a relative pathname, or so I am told. */
1.1407 + sqlite3_snprintf(pVfs->mxPathname, zFull, "%s", zRelative);
1.1408 + return SQLITE_OK;
1.1409 +#endif
1.1410 +
1.1411 +#if !SQLITE_OS_WINCE && !defined(__CYGWIN__)
1.1412 + int nByte;
1.1413 + void *zConverted;
1.1414 + char *zOut;
1.1415 + zConverted = convertUtf8Filename(zRelative);
1.1416 + if( isNT() ){
1.1417 + WCHAR *zTemp;
1.1418 + nByte = GetFullPathNameW((WCHAR*)zConverted, 0, 0, 0) + 3;
1.1419 + zTemp = malloc( nByte*sizeof(zTemp[0]) );
1.1420 + if( zTemp==0 ){
1.1421 + free(zConverted);
1.1422 + return SQLITE_NOMEM;
1.1423 + }
1.1424 + GetFullPathNameW((WCHAR*)zConverted, nByte, zTemp, 0);
1.1425 + free(zConverted);
1.1426 + zOut = unicodeToUtf8(zTemp);
1.1427 + free(zTemp);
1.1428 + }else{
1.1429 + char *zTemp;
1.1430 + nByte = GetFullPathNameA((char*)zConverted, 0, 0, 0) + 3;
1.1431 + zTemp = malloc( nByte*sizeof(zTemp[0]) );
1.1432 + if( zTemp==0 ){
1.1433 + free(zConverted);
1.1434 + return SQLITE_NOMEM;
1.1435 + }
1.1436 + GetFullPathNameA((char*)zConverted, nByte, zTemp, 0);
1.1437 + free(zConverted);
1.1438 + zOut = mbcsToUtf8(zTemp);
1.1439 + free(zTemp);
1.1440 + }
1.1441 + if( zOut ){
1.1442 + sqlite3_snprintf(pVfs->mxPathname, zFull, "%s", zOut);
1.1443 + free(zOut);
1.1444 + return SQLITE_OK;
1.1445 + }else{
1.1446 + return SQLITE_NOMEM;
1.1447 + }
1.1448 +#endif
1.1449 +}
1.1450 +
1.1451 +#ifndef SQLITE_OMIT_LOAD_EXTENSION
1.1452 +/*
1.1453 +** Interfaces for opening a shared library, finding entry points
1.1454 +** within the shared library, and closing the shared library.
1.1455 +*/
1.1456 +/*
1.1457 +** Interfaces for opening a shared library, finding entry points
1.1458 +** within the shared library, and closing the shared library.
1.1459 +*/
1.1460 +static void *winDlOpen(sqlite3_vfs *pVfs, const char *zFilename){
1.1461 + HANDLE h;
1.1462 + void *zConverted = convertUtf8Filename(zFilename);
1.1463 + if( zConverted==0 ){
1.1464 + return 0;
1.1465 + }
1.1466 + if( isNT() ){
1.1467 + h = LoadLibraryW((WCHAR*)zConverted);
1.1468 + }else{
1.1469 + h = LoadLibraryA((char*)zConverted);
1.1470 + }
1.1471 + free(zConverted);
1.1472 + return (void*)h;
1.1473 +}
1.1474 +static void winDlError(sqlite3_vfs *pVfs, int nBuf, char *zBufOut){
1.1475 + getLastErrorMsg(nBuf, zBufOut);
1.1476 +}
1.1477 +void *winDlSym(sqlite3_vfs *pVfs, void *pHandle, const char *zSymbol){
1.1478 +#if SQLITE_OS_WINCE
1.1479 + /* The GetProcAddressA() routine is only available on wince. */
1.1480 + return GetProcAddressA((HANDLE)pHandle, zSymbol);
1.1481 +#else
1.1482 + /* All other windows platforms expect GetProcAddress() to take
1.1483 + ** an Ansi string regardless of the _UNICODE setting */
1.1484 + return GetProcAddress((HANDLE)pHandle, zSymbol);
1.1485 +#endif
1.1486 +}
1.1487 +void winDlClose(sqlite3_vfs *pVfs, void *pHandle){
1.1488 + FreeLibrary((HANDLE)pHandle);
1.1489 +}
1.1490 +#else /* if SQLITE_OMIT_LOAD_EXTENSION is defined: */
1.1491 + #define winDlOpen 0
1.1492 + #define winDlError 0
1.1493 + #define winDlSym 0
1.1494 + #define winDlClose 0
1.1495 +#endif
1.1496 +
1.1497 +
1.1498 +/*
1.1499 +** Write up to nBuf bytes of randomness into zBuf.
1.1500 +*/
1.1501 +static int winRandomness(sqlite3_vfs *pVfs, int nBuf, char *zBuf){
1.1502 + int n = 0;
1.1503 + if( sizeof(SYSTEMTIME)<=nBuf-n ){
1.1504 + SYSTEMTIME x;
1.1505 + GetSystemTime(&x);
1.1506 + memcpy(&zBuf[n], &x, sizeof(x));
1.1507 + n += sizeof(x);
1.1508 + }
1.1509 + if( sizeof(DWORD)<=nBuf-n ){
1.1510 + DWORD pid = GetCurrentProcessId();
1.1511 + memcpy(&zBuf[n], &pid, sizeof(pid));
1.1512 + n += sizeof(pid);
1.1513 + }
1.1514 + if( sizeof(DWORD)<=nBuf-n ){
1.1515 + DWORD cnt = GetTickCount();
1.1516 + memcpy(&zBuf[n], &cnt, sizeof(cnt));
1.1517 + n += sizeof(cnt);
1.1518 + }
1.1519 + if( sizeof(LARGE_INTEGER)<=nBuf-n ){
1.1520 + LARGE_INTEGER i;
1.1521 + QueryPerformanceCounter(&i);
1.1522 + memcpy(&zBuf[n], &i, sizeof(i));
1.1523 + n += sizeof(i);
1.1524 + }
1.1525 + return n;
1.1526 +}
1.1527 +
1.1528 +
1.1529 +/*
1.1530 +** Sleep for a little while. Return the amount of time slept.
1.1531 +*/
1.1532 +static int winSleep(sqlite3_vfs *pVfs, int microsec){
1.1533 + Sleep((microsec+999)/1000);
1.1534 + return ((microsec+999)/1000)*1000;
1.1535 +}
1.1536 +
1.1537 +/*
1.1538 +** The following variable, if set to a non-zero value, becomes the result
1.1539 +** returned from sqlite3OsCurrentTime(). This is used for testing.
1.1540 +*/
1.1541 +#ifdef SQLITE_TEST
1.1542 +int sqlite3_current_time = 0;
1.1543 +#endif
1.1544 +
1.1545 +/*
1.1546 +** Find the current time (in Universal Coordinated Time). Write the
1.1547 +** current time and date as a Julian Day number into *prNow and
1.1548 +** return 0. Return 1 if the time and date cannot be found.
1.1549 +*/
1.1550 +int winCurrentTime(sqlite3_vfs *pVfs, double *prNow){
1.1551 + FILETIME ft;
1.1552 + /* FILETIME structure is a 64-bit value representing the number of
1.1553 + 100-nanosecond intervals since January 1, 1601 (= JD 2305813.5).
1.1554 + */
1.1555 + double now;
1.1556 +#if SQLITE_OS_WINCE
1.1557 + SYSTEMTIME time;
1.1558 + GetSystemTime(&time);
1.1559 + /* if SystemTimeToFileTime() fails, it returns zero. */
1.1560 + if (!SystemTimeToFileTime(&time,&ft)){
1.1561 + return 1;
1.1562 + }
1.1563 +#else
1.1564 + GetSystemTimeAsFileTime( &ft );
1.1565 +#endif
1.1566 + now = ((double)ft.dwHighDateTime) * 4294967296.0;
1.1567 + *prNow = (now + ft.dwLowDateTime)/864000000000.0 + 2305813.5;
1.1568 +#ifdef SQLITE_TEST
1.1569 + if( sqlite3_current_time ){
1.1570 + *prNow = sqlite3_current_time/86400.0 + 2440587.5;
1.1571 + }
1.1572 +#endif
1.1573 + return 0;
1.1574 +}
1.1575 +
1.1576 +/*
1.1577 +** The idea is that this function works like a combination of
1.1578 +** GetLastError() and FormatMessage() on windows (or errno and
1.1579 +** strerror_r() on unix). After an error is returned by an OS
1.1580 +** function, SQLite calls this function with zBuf pointing to
1.1581 +** a buffer of nBuf bytes. The OS layer should populate the
1.1582 +** buffer with a nul-terminated UTF-8 encoded error message
1.1583 +** describing the last IO error to have occured within the calling
1.1584 +** thread.
1.1585 +**
1.1586 +** If the error message is too large for the supplied buffer,
1.1587 +** it should be truncated. The return value of xGetLastError
1.1588 +** is zero if the error message fits in the buffer, or non-zero
1.1589 +** otherwise (if the message was truncated). If non-zero is returned,
1.1590 +** then it is not necessary to include the nul-terminator character
1.1591 +** in the output buffer.
1.1592 +**
1.1593 +** Not supplying an error message will have no adverse effect
1.1594 +** on SQLite. It is fine to have an implementation that never
1.1595 +** returns an error message:
1.1596 +**
1.1597 +** int xGetLastError(sqlite3_vfs *pVfs, int nBuf, char *zBuf){
1.1598 +** assert(zBuf[0]=='\0');
1.1599 +** return 0;
1.1600 +** }
1.1601 +**
1.1602 +** However if an error message is supplied, it will be incorporated
1.1603 +** by sqlite into the error message available to the user using
1.1604 +** sqlite3_errmsg(), possibly making IO errors easier to debug.
1.1605 +*/
1.1606 +static int winGetLastError(sqlite3_vfs *pVfs, int nBuf, char *zBuf){
1.1607 + return getLastErrorMsg(nBuf, zBuf);
1.1608 +}
1.1609 +
1.1610 +/*
1.1611 +** Initialize and deinitialize the operating system interface.
1.1612 +*/
1.1613 +int sqlite3_os_init(void){
1.1614 + static sqlite3_vfs winVfs = {
1.1615 + 1, /* iVersion */
1.1616 + sizeof(winFile), /* szOsFile */
1.1617 + MAX_PATH, /* mxPathname */
1.1618 + 0, /* pNext */
1.1619 + "win32", /* zName */
1.1620 + 0, /* pAppData */
1.1621 +
1.1622 + winOpen, /* xOpen */
1.1623 + winDelete, /* xDelete */
1.1624 + winAccess, /* xAccess */
1.1625 + winFullPathname, /* xFullPathname */
1.1626 + winDlOpen, /* xDlOpen */
1.1627 + winDlError, /* xDlError */
1.1628 + winDlSym, /* xDlSym */
1.1629 + winDlClose, /* xDlClose */
1.1630 + winRandomness, /* xRandomness */
1.1631 + winSleep, /* xSleep */
1.1632 + winCurrentTime, /* xCurrentTime */
1.1633 + winGetLastError /* xGetLastError */
1.1634 + };
1.1635 + sqlite3_vfs_register(&winVfs, 1);
1.1636 + return SQLITE_OK;
1.1637 +}
1.1638 +int sqlite3_os_end(void){
1.1639 + return SQLITE_OK;
1.1640 +}
1.1641 +
1.1642 +#endif /* SQLITE_OS_WIN */