Symaptic: os/persistentdata/persistentstorage/sqlite3api/SQLite/os

sl@0	1	/*
sl@0	2	** 2004 May 22
sl@0	3	**
sl@0	4	** The author disclaims copyright to this source code. In place of
sl@0	5	** a legal notice, here is a blessing:
sl@0	6	**
sl@0	7	** May you do good and not evil.
sl@0	8	** May you find forgiveness for yourself and forgive others.
sl@0	9	** May you share freely, never taking more than you give.
sl@0	10	**
sl@0	11	******************************************************************************
sl@0	12	**
sl@0	13	** This file contains code that is specific to windows.
sl@0	14	**
sl@0	15	** $Id: os_win.c,v 1.134 2008/09/30 04:20:08 shane Exp $
sl@0	16	*/
sl@0	17	#include "sqliteInt.h"
sl@0	18	#if SQLITE_OS_WIN /* This file is used for windows only */
sl@0	19
sl@0	20
sl@0	21	/*
sl@0	22	** A Note About Memory Allocation:
sl@0	23	**
sl@0	24	** This driver uses malloc()/free() directly rather than going through
sl@0	25	** the SQLite-wrappers sqlite3_malloc()/sqlite3_free(). Those wrappers
sl@0	26	** are designed for use on embedded systems where memory is scarce and
sl@0	27	** malloc failures happen frequently. Win32 does not typically run on
sl@0	28	** embedded systems, and when it does the developers normally have bigger
sl@0	29	** problems to worry about than running out of memory. So there is not
sl@0	30	** a compelling need to use the wrappers.
sl@0	31	**
sl@0	32	** But there is a good reason to not use the wrappers. If we use the
sl@0	33	** wrappers then we will get simulated malloc() failures within this
sl@0	34	** driver. And that causes all kinds of problems for our tests. We
sl@0	35	** could enhance SQLite to deal with simulated malloc failures within
sl@0	36	** the OS driver, but the code to deal with those failure would not
sl@0	37	** be exercised on Linux (which does not need to malloc() in the driver)
sl@0	38	** and so we would have difficulty writing coverage tests for that
sl@0	39	** code. Better to leave the code out, we think.
sl@0	40	**
sl@0	41	** The point of this discussion is as follows: When creating a new
sl@0	42	** OS layer for an embedded system, if you use this file as an example,
sl@0	43	** avoid the use of malloc()/free(). Those routines work ok on windows
sl@0	44	** desktops but not so well in embedded systems.
sl@0	45	*/
sl@0	46
sl@0	47	#include <winbase.h>
sl@0	48
sl@0	49	#ifdef __CYGWIN__
sl@0	50	# include <sys/cygwin.h>
sl@0	51	#endif
sl@0	52
sl@0	53	/*
sl@0	54	** Macros used to determine whether or not to use threads.
sl@0	55	*/
sl@0	56	#if defined(THREADSAFE) && THREADSAFE
sl@0	57	# define SQLITE_W32_THREADS 1
sl@0	58	#endif
sl@0	59
sl@0	60	/*
sl@0	61	** Include code that is common to all os_*.c files
sl@0	62	*/
sl@0	63	#include "os_common.h"
sl@0	64
sl@0	65	/*
sl@0	66	** Some microsoft compilers lack this definition.
sl@0	67	*/
sl@0	68	#ifndef INVALID_FILE_ATTRIBUTES
sl@0	69	# define INVALID_FILE_ATTRIBUTES ((DWORD)-1)
sl@0	70	#endif
sl@0	71
sl@0	72	/*
sl@0	73	** Determine if we are dealing with WindowsCE - which has a much
sl@0	74	** reduced API.
sl@0	75	*/
sl@0	76	#if defined(SQLITE_OS_WINCE)
sl@0	77	# define AreFileApisANSI() 1
sl@0	78	#endif
sl@0	79
sl@0	80	/*
sl@0	81	** WinCE lacks native support for file locking so we have to fake it
sl@0	82	** with some code of our own.
sl@0	83	*/
sl@0	84	#if SQLITE_OS_WINCE
sl@0	85	typedef struct winceLock {
sl@0	86	int nReaders; /* Number of reader locks obtained */
sl@0	87	BOOL bPending; /* Indicates a pending lock has been obtained */
sl@0	88	BOOL bReserved; /* Indicates a reserved lock has been obtained */
sl@0	89	BOOL bExclusive; /* Indicates an exclusive lock has been obtained */
sl@0	90	} winceLock;
sl@0	91	#endif
sl@0	92
sl@0	93	/*
sl@0	94	** The winFile structure is a subclass of sqlite3_file* specific to the win32
sl@0	95	** portability layer.
sl@0	96	*/
sl@0	97	typedef struct winFile winFile;
sl@0	98	struct winFile {
sl@0	99	const sqlite3_io_methods pMethod;/ Must be first */
sl@0	100	HANDLE h; /* Handle for accessing the file */
sl@0	101	unsigned char locktype; /* Type of lock currently held on this file */
sl@0	102	short sharedLockByte; /* Randomly chosen byte used as a shared lock */
sl@0	103	#if SQLITE_OS_WINCE
sl@0	104	WCHAR zDeleteOnClose; / Name of file to delete when closing */
sl@0	105	HANDLE hMutex; /* Mutex used to control access to shared lock */
sl@0	106	HANDLE hShared; /* Shared memory segment used for locking */
sl@0	107	winceLock local; /* Locks obtained by this instance of winFile */
sl@0	108	winceLock shared; / Global shared lock memory for the file */
sl@0	109	#endif
sl@0	110	};
sl@0	111
sl@0	112
sl@0	113	/*
sl@0	114	** The following variable is (normally) set once and never changes
sl@0	115	** thereafter. It records whether the operating system is Win95
sl@0	116	** or WinNT.
sl@0	117	**
sl@0	118	** 0: Operating system unknown.
sl@0	119	** 1: Operating system is Win95.
sl@0	120	** 2: Operating system is WinNT.
sl@0	121	**
sl@0	122	** In order to facilitate testing on a WinNT system, the test fixture
sl@0	123	** can manually set this value to 1 to emulate Win98 behavior.
sl@0	124	*/
sl@0	125	#ifdef SQLITE_TEST
sl@0	126	int sqlite3_os_type = 0;
sl@0	127	#else
sl@0	128	static int sqlite3_os_type = 0;
sl@0	129	#endif
sl@0	130
sl@0	131	/*
sl@0	132	** Return true (non-zero) if we are running under WinNT, Win2K, WinXP,
sl@0	133	** or WinCE. Return false (zero) for Win95, Win98, or WinME.
sl@0	134	**
sl@0	135	** Here is an interesting observation: Win95, Win98, and WinME lack
sl@0	136	** the LockFileEx() API. But we can still statically link against that
sl@0	137	** API as long as we don't call it win running Win95/98/ME. A call to
sl@0	138	** this routine is used to determine if the host is Win95/98/ME or
sl@0	139	** WinNT/2K/XP so that we will know whether or not we can safely call
sl@0	140	** the LockFileEx() API.
sl@0	141	*/
sl@0	142	#if SQLITE_OS_WINCE
sl@0	143	# define isNT() (1)
sl@0	144	#else
sl@0	145	static int isNT(void){
sl@0	146	if( sqlite3_os_type==0 ){
sl@0	147	OSVERSIONINFO sInfo;
sl@0	148	sInfo.dwOSVersionInfoSize = sizeof(sInfo);
sl@0	149	GetVersionEx(&sInfo);
sl@0	150	sqlite3_os_type = sInfo.dwPlatformId==VER_PLATFORM_WIN32_NT ? 2 : 1;
sl@0	151	}
sl@0	152	return sqlite3_os_type==2;
sl@0	153	}
sl@0	154	#endif /* SQLITE_OS_WINCE */
sl@0	155
sl@0	156	/*
sl@0	157	** Convert a UTF-8 string to microsoft unicode (UTF-16?).
sl@0	158	**
sl@0	159	** Space to hold the returned string is obtained from malloc.
sl@0	160	*/
sl@0	161	static WCHAR utf8ToUnicode(const char zFilename){
sl@0	162	int nChar;
sl@0	163	WCHAR *zWideFilename;
sl@0	164
sl@0	165	nChar = MultiByteToWideChar(CP_UTF8, 0, zFilename, -1, NULL, 0);
sl@0	166	zWideFilename = malloc( nChar*sizeof(zWideFilename[0]) );
sl@0	167	if( zWideFilename==0 ){
sl@0	168	return 0;
sl@0	169	}
sl@0	170	nChar = MultiByteToWideChar(CP_UTF8, 0, zFilename, -1, zWideFilename, nChar);
sl@0	171	if( nChar==0 ){
sl@0	172	free(zWideFilename);
sl@0	173	zWideFilename = 0;
sl@0	174	}
sl@0	175	return zWideFilename;
sl@0	176	}
sl@0	177
sl@0	178	/*
sl@0	179	** Convert microsoft unicode to UTF-8. Space to hold the returned string is
sl@0	180	** obtained from malloc().
sl@0	181	*/
sl@0	182	static char unicodeToUtf8(const WCHAR zWideFilename){
sl@0	183	int nByte;
sl@0	184	char *zFilename;
sl@0	185
sl@0	186	nByte = WideCharToMultiByte(CP_UTF8, 0, zWideFilename, -1, 0, 0, 0, 0);
sl@0	187	zFilename = malloc( nByte );
sl@0	188	if( zFilename==0 ){
sl@0	189	return 0;
sl@0	190	}
sl@0	191	nByte = WideCharToMultiByte(CP_UTF8, 0, zWideFilename, -1, zFilename, nByte,
sl@0	192	0, 0);
sl@0	193	if( nByte == 0 ){
sl@0	194	free(zFilename);
sl@0	195	zFilename = 0;
sl@0	196	}
sl@0	197	return zFilename;
sl@0	198	}
sl@0	199
sl@0	200	/*
sl@0	201	** Convert an ansi string to microsoft unicode, based on the
sl@0	202	** current codepage settings for file apis.
sl@0	203	**
sl@0	204	** Space to hold the returned string is obtained
sl@0	205	** from malloc.
sl@0	206	*/
sl@0	207	static WCHAR mbcsToUnicode(const char zFilename){
sl@0	208	int nByte;
sl@0	209	WCHAR *zMbcsFilename;
sl@0	210	int codepage = AreFileApisANSI() ? CP_ACP : CP_OEMCP;
sl@0	211
sl@0	212	nByte = MultiByteToWideChar(codepage, 0, zFilename, -1, NULL,0)*sizeof(WCHAR);
sl@0	213	zMbcsFilename = malloc( nByte*sizeof(zMbcsFilename[0]) );
sl@0	214	if( zMbcsFilename==0 ){
sl@0	215	return 0;
sl@0	216	}
sl@0	217	nByte = MultiByteToWideChar(codepage, 0, zFilename, -1, zMbcsFilename, nByte);
sl@0	218	if( nByte==0 ){
sl@0	219	free(zMbcsFilename);
sl@0	220	zMbcsFilename = 0;
sl@0	221	}
sl@0	222	return zMbcsFilename;
sl@0	223	}
sl@0	224
sl@0	225	/*
sl@0	226	** Convert microsoft unicode to multibyte character string, based on the
sl@0	227	** user's Ansi codepage.
sl@0	228	**
sl@0	229	** Space to hold the returned string is obtained from
sl@0	230	** malloc().
sl@0	231	*/
sl@0	232	static char unicodeToMbcs(const WCHAR zWideFilename){
sl@0	233	int nByte;
sl@0	234	char *zFilename;
sl@0	235	int codepage = AreFileApisANSI() ? CP_ACP : CP_OEMCP;
sl@0	236
sl@0	237	nByte = WideCharToMultiByte(codepage, 0, zWideFilename, -1, 0, 0, 0, 0);
sl@0	238	zFilename = malloc( nByte );
sl@0	239	if( zFilename==0 ){
sl@0	240	return 0;
sl@0	241	}
sl@0	242	nByte = WideCharToMultiByte(codepage, 0, zWideFilename, -1, zFilename, nByte,
sl@0	243	0, 0);
sl@0	244	if( nByte == 0 ){
sl@0	245	free(zFilename);
sl@0	246	zFilename = 0;
sl@0	247	}
sl@0	248	return zFilename;
sl@0	249	}
sl@0	250
sl@0	251	/*
sl@0	252	** Convert multibyte character string to UTF-8. Space to hold the
sl@0	253	** returned string is obtained from malloc().
sl@0	254	*/
sl@0	255	static char mbcsToUtf8(const char zFilename){
sl@0	256	char *zFilenameUtf8;
sl@0	257	WCHAR *zTmpWide;
sl@0	258
sl@0	259	zTmpWide = mbcsToUnicode(zFilename);
sl@0	260	if( zTmpWide==0 ){
sl@0	261	return 0;
sl@0	262	}
sl@0	263	zFilenameUtf8 = unicodeToUtf8(zTmpWide);
sl@0	264	free(zTmpWide);
sl@0	265	return zFilenameUtf8;
sl@0	266	}
sl@0	267
sl@0	268	/*
sl@0	269	** Convert UTF-8 to multibyte character string. Space to hold the
sl@0	270	** returned string is obtained from malloc().
sl@0	271	*/
sl@0	272	static char utf8ToMbcs(const char zFilename){
sl@0	273	char *zFilenameMbcs;
sl@0	274	WCHAR *zTmpWide;
sl@0	275
sl@0	276	zTmpWide = utf8ToUnicode(zFilename);
sl@0	277	if( zTmpWide==0 ){
sl@0	278	return 0;
sl@0	279	}
sl@0	280	zFilenameMbcs = unicodeToMbcs(zTmpWide);
sl@0	281	free(zTmpWide);
sl@0	282	return zFilenameMbcs;
sl@0	283	}
sl@0	284
sl@0	285	#if SQLITE_OS_WINCE
sl@0	286	/*************************************************************************
sl@0	287	** This section contains code for WinCE only.
sl@0	288	*/
sl@0	289	/*
sl@0	290	** WindowsCE does not have a localtime() function. So create a
sl@0	291	** substitute.
sl@0	292	*/
sl@0	293	#include <time.h>
sl@0	294	struct tm __cdecl localtime(const time_t t)
sl@0	295	{
sl@0	296	static struct tm y;
sl@0	297	FILETIME uTm, lTm;
sl@0	298	SYSTEMTIME pTm;
sl@0	299	sqlite3_int64 t64;
sl@0	300	t64 = *t;
sl@0	301	t64 = (t64 + 11644473600)*10000000;
sl@0	302	uTm.dwLowDateTime = t64 & 0xFFFFFFFF;
sl@0	303	uTm.dwHighDateTime= t64 >> 32;
sl@0	304	FileTimeToLocalFileTime(&uTm,&lTm);
sl@0	305	FileTimeToSystemTime(&lTm,&pTm);
sl@0	306	y.tm_year = pTm.wYear - 1900;
sl@0	307	y.tm_mon = pTm.wMonth - 1;
sl@0	308	y.tm_wday = pTm.wDayOfWeek;
sl@0	309	y.tm_mday = pTm.wDay;
sl@0	310	y.tm_hour = pTm.wHour;
sl@0	311	y.tm_min = pTm.wMinute;
sl@0	312	y.tm_sec = pTm.wSecond;
sl@0	313	return &y;
sl@0	314	}
sl@0	315
sl@0	316	/* This will never be called, but defined to make the code compile */
sl@0	317	#define GetTempPathA(a,b)
sl@0	318
sl@0	319	#define LockFile(a,b,c,d,e) winceLockFile(&a, b, c, d, e)
sl@0	320	#define UnlockFile(a,b,c,d,e) winceUnlockFile(&a, b, c, d, e)
sl@0	321	#define LockFileEx(a,b,c,d,e,f) winceLockFileEx(&a, b, c, d, e, f)
sl@0	322
sl@0	323	#define HANDLE_TO_WINFILE(a) (winFile)&((char)a)[-offsetof(winFile,h)]
sl@0	324
sl@0	325	/*
sl@0	326	** Acquire a lock on the handle h
sl@0	327	*/
sl@0	328	static void winceMutexAcquire(HANDLE h){
sl@0	329	DWORD dwErr;
sl@0	330	do {
sl@0	331	dwErr = WaitForSingleObject(h, INFINITE);
sl@0	332	} while (dwErr != WAIT_OBJECT_0 && dwErr != WAIT_ABANDONED);
sl@0	333	}
sl@0	334	/*
sl@0	335	** Release a lock acquired by winceMutexAcquire()
sl@0	336	*/
sl@0	337	#define winceMutexRelease(h) ReleaseMutex(h)
sl@0	338
sl@0	339	/*
sl@0	340	** Create the mutex and shared memory used for locking in the file
sl@0	341	** descriptor pFile
sl@0	342	*/
sl@0	343	static BOOL winceCreateLock(const char zFilename, winFile pFile){
sl@0	344	WCHAR *zTok;
sl@0	345	WCHAR *zName = utf8ToUnicode(zFilename);
sl@0	346	BOOL bInit = TRUE;
sl@0	347
sl@0	348	/* Initialize the local lockdata */
sl@0	349	ZeroMemory(&pFile->local, sizeof(pFile->local));
sl@0	350
sl@0	351	/* Replace the backslashes from the filename and lowercase it
sl@0	352	** to derive a mutex name. */
sl@0	353	zTok = CharLowerW(zName);
sl@0	354	for (;*zTok;zTok++){
sl@0	355	if (zTok == '\\') zTok = '_';
sl@0	356	}
sl@0	357
sl@0	358	/* Create/open the named mutex */
sl@0	359	pFile->hMutex = CreateMutexW(NULL, FALSE, zName);
sl@0	360	if (!pFile->hMutex){
sl@0	361	free(zName);
sl@0	362	return FALSE;
sl@0	363	}
sl@0	364
sl@0	365	/* Acquire the mutex before continuing */
sl@0	366	winceMutexAcquire(pFile->hMutex);
sl@0	367
sl@0	368	/* Since the names of named mutexes, semaphores, file mappings etc are
sl@0	369	** case-sensitive, take advantage of that by uppercasing the mutex name
sl@0	370	** and using that as the shared filemapping name.
sl@0	371	*/
sl@0	372	CharUpperW(zName);
sl@0	373	pFile->hShared = CreateFileMappingW(INVALID_HANDLE_VALUE, NULL,
sl@0	374	PAGE_READWRITE, 0, sizeof(winceLock),
sl@0	375	zName);
sl@0	376
sl@0	377	/* Set a flag that indicates we're the first to create the memory so it
sl@0	378	** must be zero-initialized */
sl@0	379	if (GetLastError() == ERROR_ALREADY_EXISTS){
sl@0	380	bInit = FALSE;
sl@0	381	}
sl@0	382
sl@0	383	free(zName);
sl@0	384
sl@0	385	/* If we succeeded in making the shared memory handle, map it. */
sl@0	386	if (pFile->hShared){
sl@0	387	pFile->shared = (winceLock*)MapViewOfFile(pFile->hShared,
sl@0	388	FILE_MAP_READ\|FILE_MAP_WRITE, 0, 0, sizeof(winceLock));
sl@0	389	/* If mapping failed, close the shared memory handle and erase it */
sl@0	390	if (!pFile->shared){
sl@0	391	CloseHandle(pFile->hShared);
sl@0	392	pFile->hShared = NULL;
sl@0	393	}
sl@0	394	}
sl@0	395
sl@0	396	/* If shared memory could not be created, then close the mutex and fail */
sl@0	397	if (pFile->hShared == NULL){
sl@0	398	winceMutexRelease(pFile->hMutex);
sl@0	399	CloseHandle(pFile->hMutex);
sl@0	400	pFile->hMutex = NULL;
sl@0	401	return FALSE;
sl@0	402	}
sl@0	403
sl@0	404	/* Initialize the shared memory if we're supposed to */
sl@0	405	if (bInit) {
sl@0	406	ZeroMemory(pFile->shared, sizeof(winceLock));
sl@0	407	}
sl@0	408
sl@0	409	winceMutexRelease(pFile->hMutex);
sl@0	410	return TRUE;
sl@0	411	}
sl@0	412
sl@0	413	/*
sl@0	414	** Destroy the part of winFile that deals with wince locks
sl@0	415	*/
sl@0	416	static void winceDestroyLock(winFile *pFile){
sl@0	417	if (pFile->hMutex){
sl@0	418	/* Acquire the mutex */
sl@0	419	winceMutexAcquire(pFile->hMutex);
sl@0	420
sl@0	421	/* The following blocks should probably assert in debug mode, but they
sl@0	422	are to cleanup in case any locks remained open */
sl@0	423	if (pFile->local.nReaders){
sl@0	424	pFile->shared->nReaders --;
sl@0	425	}
sl@0	426	if (pFile->local.bReserved){
sl@0	427	pFile->shared->bReserved = FALSE;
sl@0	428	}
sl@0	429	if (pFile->local.bPending){
sl@0	430	pFile->shared->bPending = FALSE;
sl@0	431	}
sl@0	432	if (pFile->local.bExclusive){
sl@0	433	pFile->shared->bExclusive = FALSE;
sl@0	434	}
sl@0	435
sl@0	436	/* De-reference and close our copy of the shared memory handle */
sl@0	437	UnmapViewOfFile(pFile->shared);
sl@0	438	CloseHandle(pFile->hShared);
sl@0	439
sl@0	440	/* Done with the mutex */
sl@0	441	winceMutexRelease(pFile->hMutex);
sl@0	442	CloseHandle(pFile->hMutex);
sl@0	443	pFile->hMutex = NULL;
sl@0	444	}
sl@0	445	}
sl@0	446
sl@0	447	/*
sl@0	448	** An implementation of the LockFile() API of windows for wince
sl@0	449	*/
sl@0	450	static BOOL winceLockFile(
sl@0	451	HANDLE *phFile,
sl@0	452	DWORD dwFileOffsetLow,
sl@0	453	DWORD dwFileOffsetHigh,
sl@0	454	DWORD nNumberOfBytesToLockLow,
sl@0	455	DWORD nNumberOfBytesToLockHigh
sl@0	456	){
sl@0	457	winFile *pFile = HANDLE_TO_WINFILE(phFile);
sl@0	458	BOOL bReturn = FALSE;
sl@0	459
sl@0	460	if (!pFile->hMutex) return TRUE;
sl@0	461	winceMutexAcquire(pFile->hMutex);
sl@0	462
sl@0	463	/* Wanting an exclusive lock? */
sl@0	464	if (dwFileOffsetLow == SHARED_FIRST
sl@0	465	&& nNumberOfBytesToLockLow == SHARED_SIZE){
sl@0	466	if (pFile->shared->nReaders == 0 && pFile->shared->bExclusive == 0){
sl@0	467	pFile->shared->bExclusive = TRUE;
sl@0	468	pFile->local.bExclusive = TRUE;
sl@0	469	bReturn = TRUE;
sl@0	470	}
sl@0	471	}
sl@0	472
sl@0	473	/* Want a read-only lock? */
sl@0	474	else if ((dwFileOffsetLow >= SHARED_FIRST &&
sl@0	475	dwFileOffsetLow < SHARED_FIRST + SHARED_SIZE) &&
sl@0	476	nNumberOfBytesToLockLow == 1){
sl@0	477	if (pFile->shared->bExclusive == 0){
sl@0	478	pFile->local.nReaders ++;
sl@0	479	if (pFile->local.nReaders == 1){
sl@0	480	pFile->shared->nReaders ++;
sl@0	481	}
sl@0	482	bReturn = TRUE;
sl@0	483	}
sl@0	484	}
sl@0	485
sl@0	486	/* Want a pending lock? */
sl@0	487	else if (dwFileOffsetLow == PENDING_BYTE && nNumberOfBytesToLockLow == 1){
sl@0	488	/* If no pending lock has been acquired, then acquire it */
sl@0	489	if (pFile->shared->bPending == 0) {
sl@0	490	pFile->shared->bPending = TRUE;
sl@0	491	pFile->local.bPending = TRUE;
sl@0	492	bReturn = TRUE;
sl@0	493	}
sl@0	494	}
sl@0	495	/* Want a reserved lock? */
sl@0	496	else if (dwFileOffsetLow == RESERVED_BYTE && nNumberOfBytesToLockLow == 1){
sl@0	497	if (pFile->shared->bReserved == 0) {
sl@0	498	pFile->shared->bReserved = TRUE;
sl@0	499	pFile->local.bReserved = TRUE;
sl@0	500	bReturn = TRUE;
sl@0	501	}
sl@0	502	}
sl@0	503
sl@0	504	winceMutexRelease(pFile->hMutex);
sl@0	505	return bReturn;
sl@0	506	}
sl@0	507
sl@0	508	/*
sl@0	509	** An implementation of the UnlockFile API of windows for wince
sl@0	510	*/
sl@0	511	static BOOL winceUnlockFile(
sl@0	512	HANDLE *phFile,
sl@0	513	DWORD dwFileOffsetLow,
sl@0	514	DWORD dwFileOffsetHigh,
sl@0	515	DWORD nNumberOfBytesToUnlockLow,
sl@0	516	DWORD nNumberOfBytesToUnlockHigh
sl@0	517	){
sl@0	518	winFile *pFile = HANDLE_TO_WINFILE(phFile);
sl@0	519	BOOL bReturn = FALSE;
sl@0	520
sl@0	521	if (!pFile->hMutex) return TRUE;
sl@0	522	winceMutexAcquire(pFile->hMutex);
sl@0	523
sl@0	524	/* Releasing a reader lock or an exclusive lock */
sl@0	525	if (dwFileOffsetLow >= SHARED_FIRST &&
sl@0	526	dwFileOffsetLow < SHARED_FIRST + SHARED_SIZE){
sl@0	527	/* Did we have an exclusive lock? */
sl@0	528	if (pFile->local.bExclusive){
sl@0	529	pFile->local.bExclusive = FALSE;
sl@0	530	pFile->shared->bExclusive = FALSE;
sl@0	531	bReturn = TRUE;
sl@0	532	}
sl@0	533
sl@0	534	/* Did we just have a reader lock? */
sl@0	535	else if (pFile->local.nReaders){
sl@0	536	pFile->local.nReaders --;
sl@0	537	if (pFile->local.nReaders == 0)
sl@0	538	{
sl@0	539	pFile->shared->nReaders --;
sl@0	540	}
sl@0	541	bReturn = TRUE;
sl@0	542	}
sl@0	543	}
sl@0	544
sl@0	545	/* Releasing a pending lock */
sl@0	546	else if (dwFileOffsetLow == PENDING_BYTE && nNumberOfBytesToUnlockLow == 1){
sl@0	547	if (pFile->local.bPending){
sl@0	548	pFile->local.bPending = FALSE;
sl@0	549	pFile->shared->bPending = FALSE;
sl@0	550	bReturn = TRUE;
sl@0	551	}
sl@0	552	}
sl@0	553	/* Releasing a reserved lock */
sl@0	554	else if (dwFileOffsetLow == RESERVED_BYTE && nNumberOfBytesToUnlockLow == 1){
sl@0	555	if (pFile->local.bReserved) {
sl@0	556	pFile->local.bReserved = FALSE;
sl@0	557	pFile->shared->bReserved = FALSE;
sl@0	558	bReturn = TRUE;
sl@0	559	}
sl@0	560	}
sl@0	561
sl@0	562	winceMutexRelease(pFile->hMutex);
sl@0	563	return bReturn;
sl@0	564	}
sl@0	565
sl@0	566	/*
sl@0	567	** An implementation of the LockFileEx() API of windows for wince
sl@0	568	*/
sl@0	569	static BOOL winceLockFileEx(
sl@0	570	HANDLE *phFile,
sl@0	571	DWORD dwFlags,
sl@0	572	DWORD dwReserved,
sl@0	573	DWORD nNumberOfBytesToLockLow,
sl@0	574	DWORD nNumberOfBytesToLockHigh,
sl@0	575	LPOVERLAPPED lpOverlapped
sl@0	576	){
sl@0	577	/* If the caller wants a shared read lock, forward this call
sl@0	578	** to winceLockFile */
sl@0	579	if (lpOverlapped->Offset == SHARED_FIRST &&
sl@0	580	dwFlags == 1 &&
sl@0	581	nNumberOfBytesToLockLow == SHARED_SIZE){
sl@0	582	return winceLockFile(phFile, SHARED_FIRST, 0, 1, 0);
sl@0	583	}
sl@0	584	return FALSE;
sl@0	585	}
sl@0	586	/*
sl@0	587	** End of the special code for wince
sl@0	588	*****************************************************************************/
sl@0	589	#endif /* SQLITE_OS_WINCE */
sl@0	590
sl@0	591	/*****************************************************************************
sl@0	592	** The next group of routines implement the I/O methods specified
sl@0	593	** by the sqlite3_io_methods object.
sl@0	594	******************************************************************************/
sl@0	595
sl@0	596	/*
sl@0	597	** Close a file.
sl@0	598	**
sl@0	599	** It is reported that an attempt to close a handle might sometimes
sl@0	600	** fail. This is a very unreasonable result, but windows is notorious
sl@0	601	** for being unreasonable so I do not doubt that it might happen. If
sl@0	602	** the close fails, we pause for 100 milliseconds and try again. As
sl@0	603	** many as MX_CLOSE_ATTEMPT attempts to close the handle are made before
sl@0	604	** giving up and returning an error.
sl@0	605	*/
sl@0	606	#define MX_CLOSE_ATTEMPT 3
sl@0	607	static int winClose(sqlite3_file *id){
sl@0	608	int rc, cnt = 0;
sl@0	609	winFile pFile = (winFile)id;
sl@0	610	OSTRACE2("CLOSE %d\n", pFile->h);
sl@0	611	do{
sl@0	612	rc = CloseHandle(pFile->h);
sl@0	613	}while( rc==0 && ++cnt < MX_CLOSE_ATTEMPT && (Sleep(100), 1) );
sl@0	614	#if SQLITE_OS_WINCE
sl@0	615	#define WINCE_DELETION_ATTEMPTS 3
sl@0	616	winceDestroyLock(pFile);
sl@0	617	if( pFile->zDeleteOnClose ){
sl@0	618	int cnt = 0;
sl@0	619	while(
sl@0	620	DeleteFileW(pFile->zDeleteOnClose)==0
sl@0	621	&& GetFileAttributesW(pFile->zDeleteOnClose)!=0xffffffff
sl@0	622	&& cnt++ < WINCE_DELETION_ATTEMPTS
sl@0	623	){
sl@0	624	Sleep(100); /* Wait a little before trying again */
sl@0	625	}
sl@0	626	free(pFile->zDeleteOnClose);
sl@0	627	}
sl@0	628	#endif
sl@0	629	OpenCounter(-1);
sl@0	630	return rc ? SQLITE_OK : SQLITE_IOERR;
sl@0	631	}
sl@0	632
sl@0	633	/*
sl@0	634	** Some microsoft compilers lack this definition.
sl@0	635	*/
sl@0	636	#ifndef INVALID_SET_FILE_POINTER
sl@0	637	# define INVALID_SET_FILE_POINTER ((DWORD)-1)
sl@0	638	#endif
sl@0	639
sl@0	640	/*
sl@0	641	** Read data from a file into a buffer. Return SQLITE_OK if all
sl@0	642	** bytes were read successfully and SQLITE_IOERR if anything goes
sl@0	643	** wrong.
sl@0	644	*/
sl@0	645	static int winRead(
sl@0	646	sqlite3_file id, / File to read from */
sl@0	647	void pBuf, / Write content into this buffer */
sl@0	648	int amt, /* Number of bytes to read */
sl@0	649	sqlite3_int64 offset /* Begin reading at this offset */
sl@0	650	){
sl@0	651	LONG upperBits = (offset>>32) & 0x7fffffff;
sl@0	652	LONG lowerBits = offset & 0xffffffff;
sl@0	653	DWORD rc;
sl@0	654	DWORD got;
sl@0	655	winFile pFile = (winFile)id;
sl@0	656	assert( id!=0 );
sl@0	657	SimulateIOError(return SQLITE_IOERR_READ);
sl@0	658	OSTRACE3("READ %d lock=%d\n", pFile->h, pFile->locktype);
sl@0	659	rc = SetFilePointer(pFile->h, lowerBits, &upperBits, FILE_BEGIN);
sl@0	660	if( rc==INVALID_SET_FILE_POINTER && GetLastError()!=NO_ERROR ){
sl@0	661	return SQLITE_FULL;
sl@0	662	}
sl@0	663	if( !ReadFile(pFile->h, pBuf, amt, &got, 0) ){
sl@0	664	return SQLITE_IOERR_READ;
sl@0	665	}
sl@0	666	if( got==(DWORD)amt ){
sl@0	667	return SQLITE_OK;
sl@0	668	}else{
sl@0	669	memset(&((char*)pBuf)[got], 0, amt-got);
sl@0	670	return SQLITE_IOERR_SHORT_READ;
sl@0	671	}
sl@0	672	}
sl@0	673
sl@0	674	/*
sl@0	675	** Write data from a buffer into a file. Return SQLITE_OK on success
sl@0	676	** or some other error code on failure.
sl@0	677	*/
sl@0	678	static int winWrite(
sl@0	679	sqlite3_file id, / File to write into */
sl@0	680	const void pBuf, / The bytes to be written */
sl@0	681	int amt, /* Number of bytes to write */
sl@0	682	sqlite3_int64 offset /* Offset into the file to begin writing at */
sl@0	683	){
sl@0	684	LONG upperBits = (offset>>32) & 0x7fffffff;
sl@0	685	LONG lowerBits = offset & 0xffffffff;
sl@0	686	DWORD rc;
sl@0	687	DWORD wrote;
sl@0	688	winFile pFile = (winFile)id;
sl@0	689	assert( id!=0 );
sl@0	690	SimulateIOError(return SQLITE_IOERR_WRITE);
sl@0	691	SimulateDiskfullError(return SQLITE_FULL);
sl@0	692	OSTRACE3("WRITE %d lock=%d\n", pFile->h, pFile->locktype);
sl@0	693	rc = SetFilePointer(pFile->h, lowerBits, &upperBits, FILE_BEGIN);
sl@0	694	if( rc==INVALID_SET_FILE_POINTER && GetLastError()!=NO_ERROR ){
sl@0	695	return SQLITE_FULL;
sl@0	696	}
sl@0	697	assert( amt>0 );
sl@0	698	while(
sl@0	699	amt>0
sl@0	700	&& (rc = WriteFile(pFile->h, pBuf, amt, &wrote, 0))!=0
sl@0	701	&& wrote>0
sl@0	702	){
sl@0	703	amt -= wrote;
sl@0	704	pBuf = &((char*)pBuf)[wrote];
sl@0	705	}
sl@0	706	if( !rc \|\| amt>(int)wrote ){
sl@0	707	return SQLITE_FULL;
sl@0	708	}
sl@0	709	return SQLITE_OK;
sl@0	710	}
sl@0	711
sl@0	712	/*
sl@0	713	** Truncate an open file to a specified size
sl@0	714	*/
sl@0	715	static int winTruncate(sqlite3_file *id, sqlite3_int64 nByte){
sl@0	716	LONG upperBits = (nByte>>32) & 0x7fffffff;
sl@0	717	LONG lowerBits = nByte & 0xffffffff;
sl@0	718	winFile pFile = (winFile)id;
sl@0	719	OSTRACE3("TRUNCATE %d %lld\n", pFile->h, nByte);
sl@0	720	SimulateIOError(return SQLITE_IOERR_TRUNCATE);
sl@0	721	SetFilePointer(pFile->h, lowerBits, &upperBits, FILE_BEGIN);
sl@0	722	SetEndOfFile(pFile->h);
sl@0	723	return SQLITE_OK;
sl@0	724	}
sl@0	725
sl@0	726	#ifdef SQLITE_TEST
sl@0	727	/*
sl@0	728	** Count the number of fullsyncs and normal syncs. This is used to test
sl@0	729	** that syncs and fullsyncs are occuring at the right times.
sl@0	730	*/
sl@0	731	int sqlite3_sync_count = 0;
sl@0	732	int sqlite3_fullsync_count = 0;
sl@0	733	#endif
sl@0	734
sl@0	735	/*
sl@0	736	** Make sure all writes to a particular file are committed to disk.
sl@0	737	*/
sl@0	738	static int winSync(sqlite3_file *id, int flags){
sl@0	739	winFile pFile = (winFile)id;
sl@0	740	OSTRACE3("SYNC %d lock=%d\n", pFile->h, pFile->locktype);
sl@0	741	#ifdef SQLITE_TEST
sl@0	742	if( flags & SQLITE_SYNC_FULL ){
sl@0	743	sqlite3_fullsync_count++;
sl@0	744	}
sl@0	745	sqlite3_sync_count++;
sl@0	746	#endif
sl@0	747	if( FlushFileBuffers(pFile->h) ){
sl@0	748	return SQLITE_OK;
sl@0	749	}else{
sl@0	750	return SQLITE_IOERR;
sl@0	751	}
sl@0	752	}
sl@0	753
sl@0	754	/*
sl@0	755	** Determine the current size of a file in bytes
sl@0	756	*/
sl@0	757	static int winFileSize(sqlite3_file id, sqlite3_int64 pSize){
sl@0	758	winFile pFile = (winFile)id;
sl@0	759	DWORD upperBits, lowerBits;
sl@0	760	SimulateIOError(return SQLITE_IOERR_FSTAT);
sl@0	761	lowerBits = GetFileSize(pFile->h, &upperBits);
sl@0	762	*pSize = (((sqlite3_int64)upperBits)<<32) + lowerBits;
sl@0	763	return SQLITE_OK;
sl@0	764	}
sl@0	765
sl@0	766	/*
sl@0	767	** LOCKFILE_FAIL_IMMEDIATELY is undefined on some Windows systems.
sl@0	768	*/
sl@0	769	#ifndef LOCKFILE_FAIL_IMMEDIATELY
sl@0	770	# define LOCKFILE_FAIL_IMMEDIATELY 1
sl@0	771	#endif
sl@0	772
sl@0	773	/*
sl@0	774	** Acquire a reader lock.
sl@0	775	** Different API routines are called depending on whether or not this
sl@0	776	** is Win95 or WinNT.
sl@0	777	*/
sl@0	778	static int getReadLock(winFile *pFile){
sl@0	779	int res;
sl@0	780	if( isNT() ){
sl@0	781	OVERLAPPED ovlp;
sl@0	782	ovlp.Offset = SHARED_FIRST;
sl@0	783	ovlp.OffsetHigh = 0;
sl@0	784	ovlp.hEvent = 0;
sl@0	785	res = LockFileEx(pFile->h, LOCKFILE_FAIL_IMMEDIATELY,
sl@0	786	0, SHARED_SIZE, 0, &ovlp);
sl@0	787	}else{
sl@0	788	int lk;
sl@0	789	sqlite3_randomness(sizeof(lk), &lk);
sl@0	790	pFile->sharedLockByte = (lk & 0x7fffffff)%(SHARED_SIZE - 1);
sl@0	791	res = LockFile(pFile->h, SHARED_FIRST+pFile->sharedLockByte, 0, 1, 0);
sl@0	792	}
sl@0	793	return res;
sl@0	794	}
sl@0	795
sl@0	796	/*
sl@0	797	** Undo a readlock
sl@0	798	*/
sl@0	799	static int unlockReadLock(winFile *pFile){
sl@0	800	int res;
sl@0	801	if( isNT() ){
sl@0	802	res = UnlockFile(pFile->h, SHARED_FIRST, 0, SHARED_SIZE, 0);
sl@0	803	}else{
sl@0	804	res = UnlockFile(pFile->h, SHARED_FIRST + pFile->sharedLockByte, 0, 1, 0);
sl@0	805	}
sl@0	806	return res;
sl@0	807	}
sl@0	808
sl@0	809	/*
sl@0	810	** Lock the file with the lock specified by parameter locktype - one
sl@0	811	** of the following:
sl@0	812	**
sl@0	813	** (1) SHARED_LOCK
sl@0	814	** (2) RESERVED_LOCK
sl@0	815	** (3) PENDING_LOCK
sl@0	816	** (4) EXCLUSIVE_LOCK
sl@0	817	**
sl@0	818	** Sometimes when requesting one lock state, additional lock states
sl@0	819	** are inserted in between. The locking might fail on one of the later
sl@0	820	** transitions leaving the lock state different from what it started but
sl@0	821	** still short of its goal. The following chart shows the allowed
sl@0	822	** transitions and the inserted intermediate states:
sl@0	823	**
sl@0	824	** UNLOCKED -> SHARED
sl@0	825	** SHARED -> RESERVED
sl@0	826	** SHARED -> (PENDING) -> EXCLUSIVE
sl@0	827	** RESERVED -> (PENDING) -> EXCLUSIVE
sl@0	828	** PENDING -> EXCLUSIVE
sl@0	829	**
sl@0	830	** This routine will only increase a lock. The winUnlock() routine
sl@0	831	** erases all locks at once and returns us immediately to locking level 0.
sl@0	832	** It is not possible to lower the locking level one step at a time. You
sl@0	833	** must go straight to locking level 0.
sl@0	834	*/
sl@0	835	static int winLock(sqlite3_file *id, int locktype){
sl@0	836	int rc = SQLITE_OK; /* Return code from subroutines */
sl@0	837	int res = 1; /* Result of a windows lock call */
sl@0	838	int newLocktype; /* Set pFile->locktype to this value before exiting */
sl@0	839	int gotPendingLock = 0;/* True if we acquired a PENDING lock this time */
sl@0	840	winFile pFile = (winFile)id;
sl@0	841
sl@0	842	assert( pFile!=0 );
sl@0	843	OSTRACE5("LOCK %d %d was %d(%d)\n",
sl@0	844	pFile->h, locktype, pFile->locktype, pFile->sharedLockByte);
sl@0	845
sl@0	846	/* If there is already a lock of this type or more restrictive on the
sl@0	847	** OsFile, do nothing. Don't use the end_lock: exit path, as
sl@0	848	** sqlite3OsEnterMutex() hasn't been called yet.
sl@0	849	*/
sl@0	850	if( pFile->locktype>=locktype ){
sl@0	851	return SQLITE_OK;
sl@0	852	}
sl@0	853
sl@0	854	/* Make sure the locking sequence is correct
sl@0	855	*/
sl@0	856	assert( pFile->locktype!=NO_LOCK \|\| locktype==SHARED_LOCK );
sl@0	857	assert( locktype!=PENDING_LOCK );
sl@0	858	assert( locktype!=RESERVED_LOCK \|\| pFile->locktype==SHARED_LOCK );
sl@0	859
sl@0	860	/* Lock the PENDING_LOCK byte if we need to acquire a PENDING lock or
sl@0	861	** a SHARED lock. If we are acquiring a SHARED lock, the acquisition of
sl@0	862	** the PENDING_LOCK byte is temporary.
sl@0	863	*/
sl@0	864	newLocktype = pFile->locktype;
sl@0	865	if( pFile->locktype==NO_LOCK
sl@0	866	\|\| (locktype==EXCLUSIVE_LOCK && pFile->locktype==RESERVED_LOCK)
sl@0	867	){
sl@0	868	int cnt = 3;
sl@0	869	while( cnt-->0 && (res = LockFile(pFile->h, PENDING_BYTE, 0, 1, 0))==0 ){
sl@0	870	/* Try 3 times to get the pending lock. The pending lock might be
sl@0	871	** held by another reader process who will release it momentarily.
sl@0	872	*/
sl@0	873	OSTRACE2("could not get a PENDING lock. cnt=%d\n", cnt);
sl@0	874	Sleep(1);
sl@0	875	}
sl@0	876	gotPendingLock = res;
sl@0	877	}
sl@0	878
sl@0	879	/* Acquire a shared lock
sl@0	880	*/
sl@0	881	if( locktype==SHARED_LOCK && res ){
sl@0	882	assert( pFile->locktype==NO_LOCK );
sl@0	883	res = getReadLock(pFile);
sl@0	884	if( res ){
sl@0	885	newLocktype = SHARED_LOCK;
sl@0	886	}
sl@0	887	}
sl@0	888
sl@0	889	/* Acquire a RESERVED lock
sl@0	890	*/
sl@0	891	if( locktype==RESERVED_LOCK && res ){
sl@0	892	assert( pFile->locktype==SHARED_LOCK );
sl@0	893	res = LockFile(pFile->h, RESERVED_BYTE, 0, 1, 0);
sl@0	894	if( res ){
sl@0	895	newLocktype = RESERVED_LOCK;
sl@0	896	}
sl@0	897	}
sl@0	898
sl@0	899	/* Acquire a PENDING lock
sl@0	900	*/
sl@0	901	if( locktype==EXCLUSIVE_LOCK && res ){
sl@0	902	newLocktype = PENDING_LOCK;
sl@0	903	gotPendingLock = 0;
sl@0	904	}
sl@0	905
sl@0	906	/* Acquire an EXCLUSIVE lock
sl@0	907	*/
sl@0	908	if( locktype==EXCLUSIVE_LOCK && res ){
sl@0	909	assert( pFile->locktype>=SHARED_LOCK );
sl@0	910	res = unlockReadLock(pFile);
sl@0	911	OSTRACE2("unreadlock = %d\n", res);
sl@0	912	res = LockFile(pFile->h, SHARED_FIRST, 0, SHARED_SIZE, 0);
sl@0	913	if( res ){
sl@0	914	newLocktype = EXCLUSIVE_LOCK;
sl@0	915	}else{
sl@0	916	OSTRACE2("error-code = %d\n", GetLastError());
sl@0	917	getReadLock(pFile);
sl@0	918	}
sl@0	919	}
sl@0	920
sl@0	921	/* If we are holding a PENDING lock that ought to be released, then
sl@0	922	** release it now.
sl@0	923	*/
sl@0	924	if( gotPendingLock && locktype==SHARED_LOCK ){
sl@0	925	UnlockFile(pFile->h, PENDING_BYTE, 0, 1, 0);
sl@0	926	}
sl@0	927
sl@0	928	/* Update the state of the lock has held in the file descriptor then
sl@0	929	** return the appropriate result code.
sl@0	930	*/
sl@0	931	if( res ){
sl@0	932	rc = SQLITE_OK;
sl@0	933	}else{
sl@0	934	OSTRACE4("LOCK FAILED %d trying for %d but got %d\n", pFile->h,
sl@0	935	locktype, newLocktype);
sl@0	936	rc = SQLITE_BUSY;
sl@0	937	}
sl@0	938	pFile->locktype = newLocktype;
sl@0	939	return rc;
sl@0	940	}
sl@0	941
sl@0	942	/*
sl@0	943	** This routine checks if there is a RESERVED lock held on the specified
sl@0	944	** file by this or any other process. If such a lock is held, return
sl@0	945	** non-zero, otherwise zero.
sl@0	946	*/
sl@0	947	static int winCheckReservedLock(sqlite3_file id, int pResOut){
sl@0	948	int rc;
sl@0	949	winFile pFile = (winFile)id;
sl@0	950	assert( pFile!=0 );
sl@0	951	if( pFile->locktype>=RESERVED_LOCK ){
sl@0	952	rc = 1;
sl@0	953	OSTRACE3("TEST WR-LOCK %d %d (local)\n", pFile->h, rc);
sl@0	954	}else{
sl@0	955	rc = LockFile(pFile->h, RESERVED_BYTE, 0, 1, 0);
sl@0	956	if( rc ){
sl@0	957	UnlockFile(pFile->h, RESERVED_BYTE, 0, 1, 0);
sl@0	958	}
sl@0	959	rc = !rc;
sl@0	960	OSTRACE3("TEST WR-LOCK %d %d (remote)\n", pFile->h, rc);
sl@0	961	}
sl@0	962	*pResOut = rc;
sl@0	963	return SQLITE_OK;
sl@0	964	}
sl@0	965
sl@0	966	/*
sl@0	967	** Lower the locking level on file descriptor id to locktype. locktype
sl@0	968	** must be either NO_LOCK or SHARED_LOCK.
sl@0	969	**
sl@0	970	** If the locking level of the file descriptor is already at or below
sl@0	971	** the requested locking level, this routine is a no-op.
sl@0	972	**
sl@0	973	** It is not possible for this routine to fail if the second argument
sl@0	974	** is NO_LOCK. If the second argument is SHARED_LOCK then this routine
sl@0	975	** might return SQLITE_IOERR;
sl@0	976	*/
sl@0	977	static int winUnlock(sqlite3_file *id, int locktype){
sl@0	978	int type;
sl@0	979	winFile pFile = (winFile)id;
sl@0	980	int rc = SQLITE_OK;
sl@0	981	assert( pFile!=0 );
sl@0	982	assert( locktype<=SHARED_LOCK );
sl@0	983	OSTRACE5("UNLOCK %d to %d was %d(%d)\n", pFile->h, locktype,
sl@0	984	pFile->locktype, pFile->sharedLockByte);
sl@0	985	type = pFile->locktype;
sl@0	986	if( type>=EXCLUSIVE_LOCK ){
sl@0	987	UnlockFile(pFile->h, SHARED_FIRST, 0, SHARED_SIZE, 0);
sl@0	988	if( locktype==SHARED_LOCK && !getReadLock(pFile) ){
sl@0	989	/* This should never happen. We should always be able to
sl@0	990	** reacquire the read lock */
sl@0	991	rc = SQLITE_IOERR_UNLOCK;
sl@0	992	}
sl@0	993	}
sl@0	994	if( type>=RESERVED_LOCK ){
sl@0	995	UnlockFile(pFile->h, RESERVED_BYTE, 0, 1, 0);
sl@0	996	}
sl@0	997	if( locktype==NO_LOCK && type>=SHARED_LOCK ){
sl@0	998	unlockReadLock(pFile);
sl@0	999	}
sl@0	1000	if( type>=PENDING_LOCK ){
sl@0	1001	UnlockFile(pFile->h, PENDING_BYTE, 0, 1, 0);
sl@0	1002	}
sl@0	1003	pFile->locktype = locktype;
sl@0	1004	return rc;
sl@0	1005	}
sl@0	1006
sl@0	1007	/*
sl@0	1008	** Control and query of the open file handle.
sl@0	1009	*/
sl@0	1010	static int winFileControl(sqlite3_file id, int op, void pArg){
sl@0	1011	switch( op ){
sl@0	1012	case SQLITE_FCNTL_LOCKSTATE: {
sl@0	1013	(int)pArg = ((winFile*)id)->locktype;
sl@0	1014	return SQLITE_OK;
sl@0	1015	}
sl@0	1016	}
sl@0	1017	return SQLITE_ERROR;
sl@0	1018	}
sl@0	1019
sl@0	1020	/*
sl@0	1021	** Return the sector size in bytes of the underlying block device for
sl@0	1022	** the specified file. This is almost always 512 bytes, but may be
sl@0	1023	** larger for some devices.
sl@0	1024	**
sl@0	1025	** SQLite code assumes this function cannot fail. It also assumes that
sl@0	1026	** if two files are created in the same file-system directory (i.e.
sl@0	1027	** a database and its journal file) that the sector size will be the
sl@0	1028	** same for both.
sl@0	1029	*/
sl@0	1030	static int winSectorSize(sqlite3_file *id){
sl@0	1031	return SQLITE_DEFAULT_SECTOR_SIZE;
sl@0	1032	}
sl@0	1033
sl@0	1034	/*
sl@0	1035	** Return a vector of device characteristics.
sl@0	1036	*/
sl@0	1037	static int winDeviceCharacteristics(sqlite3_file *id){
sl@0	1038	return 0;
sl@0	1039	}
sl@0	1040
sl@0	1041	/*
sl@0	1042	** This vector defines all the methods that can operate on an
sl@0	1043	** sqlite3_file for win32.
sl@0	1044	*/
sl@0	1045	static const sqlite3_io_methods winIoMethod = {
sl@0	1046	1, /* iVersion */
sl@0	1047	winClose,
sl@0	1048	winRead,
sl@0	1049	winWrite,
sl@0	1050	winTruncate,
sl@0	1051	winSync,
sl@0	1052	winFileSize,
sl@0	1053	winLock,
sl@0	1054	winUnlock,
sl@0	1055	winCheckReservedLock,
sl@0	1056	winFileControl,
sl@0	1057	winSectorSize,
sl@0	1058	winDeviceCharacteristics
sl@0	1059	};
sl@0	1060
sl@0	1061	/***************************************************************************
sl@0	1062	** Here ends the I/O methods that form the sqlite3_io_methods object.
sl@0	1063	**
sl@0	1064	** The next block of code implements the VFS methods.
sl@0	1065	****************************************************************************/
sl@0	1066
sl@0	1067	/*
sl@0	1068	** Convert a UTF-8 filename into whatever form the underlying
sl@0	1069	** operating system wants filenames in. Space to hold the result
sl@0	1070	** is obtained from malloc and must be freed by the calling
sl@0	1071	** function.
sl@0	1072	*/
sl@0	1073	static void convertUtf8Filename(const char zFilename){
sl@0	1074	void *zConverted = 0;
sl@0	1075	if( isNT() ){
sl@0	1076	zConverted = utf8ToUnicode(zFilename);
sl@0	1077	}else{
sl@0	1078	zConverted = utf8ToMbcs(zFilename);
sl@0	1079	}
sl@0	1080	/* caller will handle out of memory */
sl@0	1081	return zConverted;
sl@0	1082	}
sl@0	1083
sl@0	1084	/*
sl@0	1085	** Create a temporary file name in zBuf. zBuf must be big enough to
sl@0	1086	** hold at pVfs->mxPathname characters.
sl@0	1087	*/
sl@0	1088	static int getTempname(int nBuf, char *zBuf){
sl@0	1089	static char zChars[] =
sl@0	1090	"abcdefghijklmnopqrstuvwxyz"
sl@0	1091	"ABCDEFGHIJKLMNOPQRSTUVWXYZ"
sl@0	1092	"0123456789";
sl@0	1093	size_t i, j;
sl@0	1094	char zTempPath[MAX_PATH+1];
sl@0	1095	if( sqlite3_temp_directory ){
sl@0	1096	sqlite3_snprintf(MAX_PATH-30, zTempPath, "%s", sqlite3_temp_directory);
sl@0	1097	}else if( isNT() ){
sl@0	1098	char *zMulti;
sl@0	1099	WCHAR zWidePath[MAX_PATH];
sl@0	1100	GetTempPathW(MAX_PATH-30, zWidePath);
sl@0	1101	zMulti = unicodeToUtf8(zWidePath);
sl@0	1102	if( zMulti ){
sl@0	1103	sqlite3_snprintf(MAX_PATH-30, zTempPath, "%s", zMulti);
sl@0	1104	free(zMulti);
sl@0	1105	}else{
sl@0	1106	return SQLITE_NOMEM;
sl@0	1107	}
sl@0	1108	}else{
sl@0	1109	char *zUtf8;
sl@0	1110	char zMbcsPath[MAX_PATH];
sl@0	1111	GetTempPathA(MAX_PATH-30, zMbcsPath);
sl@0	1112	zUtf8 = mbcsToUtf8(zMbcsPath);
sl@0	1113	if( zUtf8 ){
sl@0	1114	sqlite3_snprintf(MAX_PATH-30, zTempPath, "%s", zUtf8);
sl@0	1115	free(zUtf8);
sl@0	1116	}else{
sl@0	1117	return SQLITE_NOMEM;
sl@0	1118	}
sl@0	1119	}
sl@0	1120	for(i=strlen(zTempPath); i>0 && zTempPath[i-1]=='\\'; i--){}
sl@0	1121	zTempPath[i] = 0;
sl@0	1122	sqlite3_snprintf(nBuf-30, zBuf,
sl@0	1123	"%s\\"SQLITE_TEMP_FILE_PREFIX, zTempPath);
sl@0	1124	j = strlen(zBuf);
sl@0	1125	sqlite3_randomness(20, &zBuf[j]);
sl@0	1126	for(i=0; i<20; i++, j++){
sl@0	1127	zBuf[j] = (char)zChars[ ((unsigned char)zBuf[j])%(sizeof(zChars)-1) ];
sl@0	1128	}
sl@0	1129	zBuf[j] = 0;
sl@0	1130	OSTRACE2("TEMP FILENAME: %s\n", zBuf);
sl@0	1131	return SQLITE_OK;
sl@0	1132	}
sl@0	1133
sl@0	1134	/*
sl@0	1135	** The return value of getLastErrorMsg
sl@0	1136	** is zero if the error message fits in the buffer, or non-zero
sl@0	1137	** otherwise (if the message was truncated).
sl@0	1138	*/
sl@0	1139	static int getLastErrorMsg(int nBuf, char *zBuf){
sl@0	1140	DWORD error = GetLastError();
sl@0	1141
sl@0	1142	#if SQLITE_OS_WINCE
sl@0	1143	sqlite3_snprintf(nBuf, zBuf, "OsError 0x%x (%u)", error, error);
sl@0	1144	#else
sl@0	1145	/* FormatMessage returns 0 on failure. Otherwise it
sl@0	1146	** returns the number of TCHARs written to the output
sl@0	1147	** buffer, excluding the terminating null char.
sl@0	1148	*/
sl@0	1149	if (!FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM,
sl@0	1150	NULL,
sl@0	1151	error,
sl@0	1152	0,
sl@0	1153	zBuf,
sl@0	1154	nBuf-1,
sl@0	1155	0))
sl@0	1156	{
sl@0	1157	sqlite3_snprintf(nBuf, zBuf, "OsError 0x%x (%u)", error, error);
sl@0	1158	}
sl@0	1159	#endif
sl@0	1160
sl@0	1161	return 0;
sl@0	1162	}
sl@0	1163
sl@0	1164
sl@0	1165	/*
sl@0	1166	** Open a file.
sl@0	1167	*/
sl@0	1168	static int winOpen(
sl@0	1169	sqlite3_vfs pVfs, / Not used */
sl@0	1170	const char zName, / Name of the file (UTF-8) */
sl@0	1171	sqlite3_file id, / Write the SQLite file handle here */
sl@0	1172	int flags, /* Open mode flags */
sl@0	1173	int pOutFlags / Status return flags */
sl@0	1174	){
sl@0	1175	HANDLE h;
sl@0	1176	DWORD dwDesiredAccess;
sl@0	1177	DWORD dwShareMode;
sl@0	1178	DWORD dwCreationDisposition;
sl@0	1179	DWORD dwFlagsAndAttributes = 0;
sl@0	1180	#if SQLITE_OS_WINCE
sl@0	1181	int isTemp = 0;
sl@0	1182	#endif
sl@0	1183	winFile pFile = (winFile)id;
sl@0	1184	void zConverted; / Filename in OS encoding */
sl@0	1185	const char zUtf8Name = zName; / Filename in UTF-8 encoding */
sl@0	1186	char zTmpname[MAX_PATH+1]; /* Buffer used to create temp filename */
sl@0	1187
sl@0	1188	/* If the second argument to this function is NULL, generate a
sl@0	1189	** temporary file name to use
sl@0	1190	*/
sl@0	1191	if( !zUtf8Name ){
sl@0	1192	int rc = getTempname(MAX_PATH+1, zTmpname);
sl@0	1193	if( rc!=SQLITE_OK ){
sl@0	1194	return rc;
sl@0	1195	}
sl@0	1196	zUtf8Name = zTmpname;
sl@0	1197	}
sl@0	1198
sl@0	1199	/* Convert the filename to the system encoding. */
sl@0	1200	zConverted = convertUtf8Filename(zUtf8Name);
sl@0	1201	if( zConverted==0 ){
sl@0	1202	return SQLITE_NOMEM;
sl@0	1203	}
sl@0	1204
sl@0	1205	if( flags & SQLITE_OPEN_READWRITE ){
sl@0	1206	dwDesiredAccess = GENERIC_READ \| GENERIC_WRITE;
sl@0	1207	}else{
sl@0	1208	dwDesiredAccess = GENERIC_READ;
sl@0	1209	}
sl@0	1210	if( flags & SQLITE_OPEN_CREATE ){
sl@0	1211	dwCreationDisposition = OPEN_ALWAYS;
sl@0	1212	}else{
sl@0	1213	dwCreationDisposition = OPEN_EXISTING;
sl@0	1214	}
sl@0	1215	if( flags & SQLITE_OPEN_MAIN_DB ){
sl@0	1216	dwShareMode = FILE_SHARE_READ \| FILE_SHARE_WRITE;
sl@0	1217	}else{
sl@0	1218	dwShareMode = 0;
sl@0	1219	}
sl@0	1220	if( flags & SQLITE_OPEN_DELETEONCLOSE ){
sl@0	1221	#if SQLITE_OS_WINCE
sl@0	1222	dwFlagsAndAttributes = FILE_ATTRIBUTE_HIDDEN;
sl@0	1223	isTemp = 1;
sl@0	1224	#else
sl@0	1225	dwFlagsAndAttributes = FILE_ATTRIBUTE_TEMPORARY
sl@0	1226	\| FILE_ATTRIBUTE_HIDDEN
sl@0	1227	\| FILE_FLAG_DELETE_ON_CLOSE;
sl@0	1228	#endif
sl@0	1229	}else{
sl@0	1230	dwFlagsAndAttributes = FILE_ATTRIBUTE_NORMAL;
sl@0	1231	}
sl@0	1232	/* Reports from the internet are that performance is always
sl@0	1233	** better if FILE_FLAG_RANDOM_ACCESS is used. Ticket #2699. */
sl@0	1234	#if SQLITE_OS_WINCE
sl@0	1235	dwFlagsAndAttributes \|= FILE_FLAG_RANDOM_ACCESS;
sl@0	1236	#endif
sl@0	1237	if( isNT() ){
sl@0	1238	h = CreateFileW((WCHAR*)zConverted,
sl@0	1239	dwDesiredAccess,
sl@0	1240	dwShareMode,
sl@0	1241	NULL,
sl@0	1242	dwCreationDisposition,
sl@0	1243	dwFlagsAndAttributes,
sl@0	1244	NULL
sl@0	1245	);
sl@0	1246	}else{
sl@0	1247	h = CreateFileA((char*)zConverted,
sl@0	1248	dwDesiredAccess,
sl@0	1249	dwShareMode,
sl@0	1250	NULL,
sl@0	1251	dwCreationDisposition,
sl@0	1252	dwFlagsAndAttributes,
sl@0	1253	NULL
sl@0	1254	);
sl@0	1255	}
sl@0	1256	if( h==INVALID_HANDLE_VALUE ){
sl@0	1257	free(zConverted);
sl@0	1258	if( flags & SQLITE_OPEN_READWRITE ){
sl@0	1259	return winOpen(0, zName, id,
sl@0	1260	((flags\|SQLITE_OPEN_READONLY)&~SQLITE_OPEN_READWRITE), pOutFlags);
sl@0	1261	}else{
sl@0	1262	return SQLITE_CANTOPEN;
sl@0	1263	}
sl@0	1264	}
sl@0	1265	if( pOutFlags ){
sl@0	1266	if( flags & SQLITE_OPEN_READWRITE ){
sl@0	1267	*pOutFlags = SQLITE_OPEN_READWRITE;
sl@0	1268	}else{
sl@0	1269	*pOutFlags = SQLITE_OPEN_READONLY;
sl@0	1270	}
sl@0	1271	}
sl@0	1272	memset(pFile, 0, sizeof(*pFile));
sl@0	1273	pFile->pMethod = &winIoMethod;
sl@0	1274	pFile->h = h;
sl@0	1275	#if SQLITE_OS_WINCE
sl@0	1276	if( (flags & (SQLITE_OPEN_READWRITE\|SQLITE_OPEN_MAIN_DB)) ==
sl@0	1277	(SQLITE_OPEN_READWRITE\|SQLITE_OPEN_MAIN_DB)
sl@0	1278	&& !winceCreateLock(zName, pFile)
sl@0	1279	){
sl@0	1280	CloseHandle(h);
sl@0	1281	free(zConverted);
sl@0	1282	return SQLITE_CANTOPEN;
sl@0	1283	}
sl@0	1284	if( isTemp ){
sl@0	1285	pFile->zDeleteOnClose = zConverted;
sl@0	1286	}else
sl@0	1287	#endif
sl@0	1288	{
sl@0	1289	free(zConverted);
sl@0	1290	}
sl@0	1291	OpenCounter(+1);
sl@0	1292	return SQLITE_OK;
sl@0	1293	}
sl@0	1294
sl@0	1295	/*
sl@0	1296	** Delete the named file.
sl@0	1297	**
sl@0	1298	** Note that windows does not allow a file to be deleted if some other
sl@0	1299	** process has it open. Sometimes a virus scanner or indexing program
sl@0	1300	** will open a journal file shortly after it is created in order to do
sl@0	1301	** whatever it does. While this other process is holding the
sl@0	1302	** file open, we will be unable to delete it. To work around this
sl@0	1303	** problem, we delay 100 milliseconds and try to delete again. Up
sl@0	1304	** to MX_DELETION_ATTEMPTs deletion attempts are run before giving
sl@0	1305	** up and returning an error.
sl@0	1306	*/
sl@0	1307	#define MX_DELETION_ATTEMPTS 5
sl@0	1308	static int winDelete(
sl@0	1309	sqlite3_vfs pVfs, / Not used on win32 */
sl@0	1310	const char zFilename, / Name of file to delete */
sl@0	1311	int syncDir /* Not used on win32 */
sl@0	1312	){
sl@0	1313	int cnt = 0;
sl@0	1314	DWORD rc;
sl@0	1315	DWORD error;
sl@0	1316	void *zConverted = convertUtf8Filename(zFilename);
sl@0	1317	if( zConverted==0 ){
sl@0	1318	return SQLITE_NOMEM;
sl@0	1319	}
sl@0	1320	SimulateIOError(return SQLITE_IOERR_DELETE);
sl@0	1321	if( isNT() ){
sl@0	1322	do{
sl@0	1323	DeleteFileW(zConverted);
sl@0	1324	}while( ( ((rc = GetFileAttributesW(zConverted)) != INVALID_FILE_ATTRIBUTES)
sl@0	1325	\|\| ((error = GetLastError()) == ERROR_ACCESS_DENIED))
sl@0	1326	&& (++cnt < MX_DELETION_ATTEMPTS)
sl@0	1327	&& (Sleep(100), 1) );
sl@0	1328	}else{
sl@0	1329	do{
sl@0	1330	DeleteFileA(zConverted);
sl@0	1331	}while( ( ((rc = GetFileAttributesA(zConverted)) != INVALID_FILE_ATTRIBUTES)
sl@0	1332	\|\| ((error = GetLastError()) == ERROR_ACCESS_DENIED))
sl@0	1333	&& (++cnt < MX_DELETION_ATTEMPTS)
sl@0	1334	&& (Sleep(100), 1) );
sl@0	1335	}
sl@0	1336	free(zConverted);
sl@0	1337	OSTRACE2("DELETE \"%s\"\n", zFilename);
sl@0	1338	return ( (rc == INVALID_FILE_ATTRIBUTES)
sl@0	1339	&& (error == ERROR_FILE_NOT_FOUND)) ? SQLITE_OK : SQLITE_IOERR_DELETE;
sl@0	1340	}
sl@0	1341
sl@0	1342	/*
sl@0	1343	** Check the existance and status of a file.
sl@0	1344	*/
sl@0	1345	static int winAccess(
sl@0	1346	sqlite3_vfs pVfs, / Not used on win32 */
sl@0	1347	const char zFilename, / Name of file to check */
sl@0	1348	int flags, /* Type of test to make on this file */
sl@0	1349	int pResOut / OUT: Result */
sl@0	1350	){
sl@0	1351	DWORD attr;
sl@0	1352	int rc;
sl@0	1353	void *zConverted = convertUtf8Filename(zFilename);
sl@0	1354	if( zConverted==0 ){
sl@0	1355	return SQLITE_NOMEM;
sl@0	1356	}
sl@0	1357	if( isNT() ){
sl@0	1358	attr = GetFileAttributesW((WCHAR*)zConverted);
sl@0	1359	}else{
sl@0	1360	attr = GetFileAttributesA((char*)zConverted);
sl@0	1361	}
sl@0	1362	free(zConverted);
sl@0	1363	switch( flags ){
sl@0	1364	case SQLITE_ACCESS_READ:
sl@0	1365	case SQLITE_ACCESS_EXISTS:
sl@0	1366	rc = attr!=INVALID_FILE_ATTRIBUTES;
sl@0	1367	break;
sl@0	1368	case SQLITE_ACCESS_READWRITE:
sl@0	1369	rc = (attr & FILE_ATTRIBUTE_READONLY)==0;
sl@0	1370	break;
sl@0	1371	default:
sl@0	1372	assert(!"Invalid flags argument");
sl@0	1373	}
sl@0	1374	*pResOut = rc;
sl@0	1375	return SQLITE_OK;
sl@0	1376	}
sl@0	1377
sl@0	1378
sl@0	1379	/*
sl@0	1380	** Turn a relative pathname into a full pathname. Write the full
sl@0	1381	** pathname into zOut[]. zOut[] will be at least pVfs->mxPathname
sl@0	1382	** bytes in size.
sl@0	1383	*/
sl@0	1384	static int winFullPathname(
sl@0	1385	sqlite3_vfs pVfs, / Pointer to vfs object */
sl@0	1386	const char zRelative, / Possibly relative input path */
sl@0	1387	int nFull, /* Size of output buffer in bytes */
sl@0	1388	char zFull / Output buffer */
sl@0	1389	){
sl@0	1390
sl@0	1391	#if defined(__CYGWIN__)
sl@0	1392	cygwin_conv_to_full_win32_path(zRelative, zFull);
sl@0	1393	return SQLITE_OK;
sl@0	1394	#endif
sl@0	1395
sl@0	1396	#if SQLITE_OS_WINCE
sl@0	1397	/* WinCE has no concept of a relative pathname, or so I am told. */
sl@0	1398	sqlite3_snprintf(pVfs->mxPathname, zFull, "%s", zRelative);
sl@0	1399	return SQLITE_OK;
sl@0	1400	#endif
sl@0	1401
sl@0	1402	#if !SQLITE_OS_WINCE && !defined(__CYGWIN__)
sl@0	1403	int nByte;
sl@0	1404	void *zConverted;
sl@0	1405	char *zOut;
sl@0	1406	zConverted = convertUtf8Filename(zRelative);
sl@0	1407	if( isNT() ){
sl@0	1408	WCHAR *zTemp;
sl@0	1409	nByte = GetFullPathNameW((WCHAR*)zConverted, 0, 0, 0) + 3;
sl@0	1410	zTemp = malloc( nByte*sizeof(zTemp[0]) );
sl@0	1411	if( zTemp==0 ){
sl@0	1412	free(zConverted);
sl@0	1413	return SQLITE_NOMEM;
sl@0	1414	}
sl@0	1415	GetFullPathNameW((WCHAR*)zConverted, nByte, zTemp, 0);
sl@0	1416	free(zConverted);
sl@0	1417	zOut = unicodeToUtf8(zTemp);
sl@0	1418	free(zTemp);
sl@0	1419	}else{
sl@0	1420	char *zTemp;
sl@0	1421	nByte = GetFullPathNameA((char*)zConverted, 0, 0, 0) + 3;
sl@0	1422	zTemp = malloc( nByte*sizeof(zTemp[0]) );
sl@0	1423	if( zTemp==0 ){
sl@0	1424	free(zConverted);
sl@0	1425	return SQLITE_NOMEM;
sl@0	1426	}
sl@0	1427	GetFullPathNameA((char*)zConverted, nByte, zTemp, 0);
sl@0	1428	free(zConverted);
sl@0	1429	zOut = mbcsToUtf8(zTemp);
sl@0	1430	free(zTemp);
sl@0	1431	}
sl@0	1432	if( zOut ){
sl@0	1433	sqlite3_snprintf(pVfs->mxPathname, zFull, "%s", zOut);
sl@0	1434	free(zOut);
sl@0	1435	return SQLITE_OK;
sl@0	1436	}else{
sl@0	1437	return SQLITE_NOMEM;
sl@0	1438	}
sl@0	1439	#endif
sl@0	1440	}
sl@0	1441
sl@0	1442	#ifndef SQLITE_OMIT_LOAD_EXTENSION
sl@0	1443	/*
sl@0	1444	** Interfaces for opening a shared library, finding entry points
sl@0	1445	** within the shared library, and closing the shared library.
sl@0	1446	*/
sl@0	1447	/*
sl@0	1448	** Interfaces for opening a shared library, finding entry points
sl@0	1449	** within the shared library, and closing the shared library.
sl@0	1450	*/
sl@0	1451	static void winDlOpen(sqlite3_vfs pVfs, const char *zFilename){
sl@0	1452	HANDLE h;
sl@0	1453	void *zConverted = convertUtf8Filename(zFilename);
sl@0	1454	if( zConverted==0 ){
sl@0	1455	return 0;
sl@0	1456	}
sl@0	1457	if( isNT() ){
sl@0	1458	h = LoadLibraryW((WCHAR*)zConverted);
sl@0	1459	}else{
sl@0	1460	h = LoadLibraryA((char*)zConverted);
sl@0	1461	}
sl@0	1462	free(zConverted);
sl@0	1463	return (void*)h;
sl@0	1464	}
sl@0	1465	static void winDlError(sqlite3_vfs pVfs, int nBuf, char zBufOut){
sl@0	1466	getLastErrorMsg(nBuf, zBufOut);
sl@0	1467	}
sl@0	1468	void winDlSym(sqlite3_vfs pVfs, void pHandle, const char zSymbol){
sl@0	1469	#if SQLITE_OS_WINCE
sl@0	1470	/* The GetProcAddressA() routine is only available on wince. */
sl@0	1471	return GetProcAddressA((HANDLE)pHandle, zSymbol);
sl@0	1472	#else
sl@0	1473	/* All other windows platforms expect GetProcAddress() to take
sl@0	1474	** an Ansi string regardless of the _UNICODE setting */
sl@0	1475	return GetProcAddress((HANDLE)pHandle, zSymbol);
sl@0	1476	#endif
sl@0	1477	}
sl@0	1478	void winDlClose(sqlite3_vfs pVfs, void pHandle){
sl@0	1479	FreeLibrary((HANDLE)pHandle);
sl@0	1480	}
sl@0	1481	#else /* if SQLITE_OMIT_LOAD_EXTENSION is defined: */
sl@0	1482	#define winDlOpen 0
sl@0	1483	#define winDlError 0
sl@0	1484	#define winDlSym 0
sl@0	1485	#define winDlClose 0
sl@0	1486	#endif
sl@0	1487
sl@0	1488
sl@0	1489	/*
sl@0	1490	** Write up to nBuf bytes of randomness into zBuf.
sl@0	1491	*/
sl@0	1492	static int winRandomness(sqlite3_vfs pVfs, int nBuf, char zBuf){
sl@0	1493	int n = 0;
sl@0	1494	if( sizeof(SYSTEMTIME)<=nBuf-n ){
sl@0	1495	SYSTEMTIME x;
sl@0	1496	GetSystemTime(&x);
sl@0	1497	memcpy(&zBuf[n], &x, sizeof(x));
sl@0	1498	n += sizeof(x);
sl@0	1499	}
sl@0	1500	if( sizeof(DWORD)<=nBuf-n ){
sl@0	1501	DWORD pid = GetCurrentProcessId();
sl@0	1502	memcpy(&zBuf[n], &pid, sizeof(pid));
sl@0	1503	n += sizeof(pid);
sl@0	1504	}
sl@0	1505	if( sizeof(DWORD)<=nBuf-n ){
sl@0	1506	DWORD cnt = GetTickCount();
sl@0	1507	memcpy(&zBuf[n], &cnt, sizeof(cnt));
sl@0	1508	n += sizeof(cnt);
sl@0	1509	}
sl@0	1510	if( sizeof(LARGE_INTEGER)<=nBuf-n ){
sl@0	1511	LARGE_INTEGER i;
sl@0	1512	QueryPerformanceCounter(&i);
sl@0	1513	memcpy(&zBuf[n], &i, sizeof(i));
sl@0	1514	n += sizeof(i);
sl@0	1515	}
sl@0	1516	return n;
sl@0	1517	}
sl@0	1518
sl@0	1519
sl@0	1520	/*
sl@0	1521	** Sleep for a little while. Return the amount of time slept.
sl@0	1522	*/
sl@0	1523	static int winSleep(sqlite3_vfs *pVfs, int microsec){
sl@0	1524	Sleep((microsec+999)/1000);
sl@0	1525	return ((microsec+999)/1000)*1000;
sl@0	1526	}
sl@0	1527
sl@0	1528	/*
sl@0	1529	** The following variable, if set to a non-zero value, becomes the result
sl@0	1530	** returned from sqlite3OsCurrentTime(). This is used for testing.
sl@0	1531	*/
sl@0	1532	#ifdef SQLITE_TEST
sl@0	1533	int sqlite3_current_time = 0;
sl@0	1534	#endif
sl@0	1535
sl@0	1536	/*
sl@0	1537	** Find the current time (in Universal Coordinated Time). Write the
sl@0	1538	** current time and date as a Julian Day number into *prNow and
sl@0	1539	** return 0. Return 1 if the time and date cannot be found.
sl@0	1540	*/
sl@0	1541	int winCurrentTime(sqlite3_vfs pVfs, double prNow){
sl@0	1542	FILETIME ft;
sl@0	1543	/* FILETIME structure is a 64-bit value representing the number of
sl@0	1544	100-nanosecond intervals since January 1, 1601 (= JD 2305813.5).
sl@0	1545	*/
sl@0	1546	double now;
sl@0	1547	#if SQLITE_OS_WINCE
sl@0	1548	SYSTEMTIME time;
sl@0	1549	GetSystemTime(&time);
sl@0	1550	/* if SystemTimeToFileTime() fails, it returns zero. */
sl@0	1551	if (!SystemTimeToFileTime(&time,&ft)){
sl@0	1552	return 1;
sl@0	1553	}
sl@0	1554	#else
sl@0	1555	GetSystemTimeAsFileTime( &ft );
sl@0	1556	#endif
sl@0	1557	now = ((double)ft.dwHighDateTime) * 4294967296.0;
sl@0	1558	*prNow = (now + ft.dwLowDateTime)/864000000000.0 + 2305813.5;
sl@0	1559	#ifdef SQLITE_TEST
sl@0	1560	if( sqlite3_current_time ){
sl@0	1561	*prNow = sqlite3_current_time/86400.0 + 2440587.5;
sl@0	1562	}
sl@0	1563	#endif
sl@0	1564	return 0;
sl@0	1565	}
sl@0	1566
sl@0	1567	/*
sl@0	1568	** The idea is that this function works like a combination of
sl@0	1569	** GetLastError() and FormatMessage() on windows (or errno and
sl@0	1570	** strerror_r() on unix). After an error is returned by an OS
sl@0	1571	** function, SQLite calls this function with zBuf pointing to
sl@0	1572	** a buffer of nBuf bytes. The OS layer should populate the
sl@0	1573	** buffer with a nul-terminated UTF-8 encoded error message
sl@0	1574	** describing the last IO error to have occured within the calling
sl@0	1575	** thread.
sl@0	1576	**
sl@0	1577	** If the error message is too large for the supplied buffer,
sl@0	1578	** it should be truncated. The return value of xGetLastError
sl@0	1579	** is zero if the error message fits in the buffer, or non-zero
sl@0	1580	** otherwise (if the message was truncated). If non-zero is returned,
sl@0	1581	** then it is not necessary to include the nul-terminator character
sl@0	1582	** in the output buffer.
sl@0	1583	**
sl@0	1584	** Not supplying an error message will have no adverse effect
sl@0	1585	** on SQLite. It is fine to have an implementation that never
sl@0	1586	** returns an error message:
sl@0	1587	**
sl@0	1588	** int xGetLastError(sqlite3_vfs pVfs, int nBuf, char zBuf){
sl@0	1589	** assert(zBuf[0]=='\0');
sl@0	1590	** return 0;
sl@0	1591	** }
sl@0	1592	**
sl@0	1593	** However if an error message is supplied, it will be incorporated
sl@0	1594	** by sqlite into the error message available to the user using
sl@0	1595	** sqlite3_errmsg(), possibly making IO errors easier to debug.
sl@0	1596	*/
sl@0	1597	static int winGetLastError(sqlite3_vfs pVfs, int nBuf, char zBuf){
sl@0	1598	return getLastErrorMsg(nBuf, zBuf);
sl@0	1599	}
sl@0	1600
sl@0	1601	/*
sl@0	1602	** Initialize and deinitialize the operating system interface.
sl@0	1603	*/
sl@0	1604	int sqlite3_os_init(void){
sl@0	1605	static sqlite3_vfs winVfs = {
sl@0	1606	1, /* iVersion */
sl@0	1607	sizeof(winFile), /* szOsFile */
sl@0	1608	MAX_PATH, /* mxPathname */
sl@0	1609	0, /* pNext */
sl@0	1610	"win32", /* zName */
sl@0	1611	0, /* pAppData */
sl@0	1612
sl@0	1613	winOpen, /* xOpen */
sl@0	1614	winDelete, /* xDelete */
sl@0	1615	winAccess, /* xAccess */
sl@0	1616	winFullPathname, /* xFullPathname */
sl@0	1617	winDlOpen, /* xDlOpen */
sl@0	1618	winDlError, /* xDlError */
sl@0	1619	winDlSym, /* xDlSym */
sl@0	1620	winDlClose, /* xDlClose */
sl@0	1621	winRandomness, /* xRandomness */
sl@0	1622	winSleep, /* xSleep */
sl@0	1623	winCurrentTime, /* xCurrentTime */
sl@0	1624	winGetLastError /* xGetLastError */
sl@0	1625	};
sl@0	1626	sqlite3_vfs_register(&winVfs, 1);
sl@0	1627	return SQLITE_OK;
sl@0	1628	}
sl@0	1629	int sqlite3_os_end(void){
sl@0	1630	return SQLITE_OK;
sl@0	1631	}
sl@0	1632
sl@0	1633	#endif /* SQLITE_OS_WIN */

author	sl
	Tue, 10 Jun 2014 14:32:02 +0200
changeset 1	260cb5ec6c19
permissions	-rw-r--r--