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

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