自学教程：C++ sqlite3_vfs_find函数代码示例

void sqlite3_bctbx_vfs_register( int makeDefault){	sqlite3_vfs* pVfsToUse = sqlite3_bctbx_vfs_create();	#if _WIN32	sqlite3_vfs* pDefault = sqlite3_vfs_find("win32");	#else	sqlite3_vfs* pDefault = sqlite3_vfs_find("unix-none");	#endif	pVfsToUse->xCurrentTime = pDefault->xCurrentTime;		pVfsToUse->xAccess =  pDefault->xAccess;	pVfsToUse->xFullPathname = pDefault->xFullPathname;	pVfsToUse->xDelete = pDefault->xDelete;	pVfsToUse->xSleep = pDefault->xSleep;	pVfsToUse->xRandomness = pDefault->xRandomness;	pVfsToUse->xGetLastError = pDefault->xGetLastError; /* Not implemented by sqlite3 :place holder */	/*Functions below should not be a problem sincve we are declaring ourselves	 in version 1 */	/* used in version 2	xCurrentTimeInt64;*/	/* used in version 3	xGetSystemCall	xSetSystemCall	xNextSystemCall*/	sqlite3_vfs_register(pVfsToUse, makeDefault);}

sqlite3_vfs* ConstructTelemetryVFS(){#if defined(XP_WIN)#define EXPECTED_VFS     "win32"#define EXPECTED_VFS_NFS "win32"#else#define EXPECTED_VFS     "unix"#define EXPECTED_VFS_NFS "unix-excl"#endif    bool expected_vfs;  sqlite3_vfs *vfs;  if (Preferences::GetBool(PREF_NFS_FILESYSTEM)) {    vfs = sqlite3_vfs_find(EXPECTED_VFS_NFS);    expected_vfs = (vfs != nullptr);  }  else {    vfs = sqlite3_vfs_find(nullptr);    expected_vfs = vfs->zName && !strcmp(vfs->zName, EXPECTED_VFS);  }  if (!expected_vfs) {    return nullptr;  }  sqlite3_vfs *tvfs = new ::sqlite3_vfs;  memset(tvfs, 0, sizeof(::sqlite3_vfs));  // If the VFS version is higher than the last known one, you should update  // this VFS adding appropriate methods for any methods added in the version  // change.  tvfs->iVersion = vfs->iVersion;  MOZ_ASSERT(vfs->iVersion <= LAST_KNOWN_VFS_VERSION);  tvfs->szOsFile = sizeof(telemetry_file) - sizeof(sqlite3_file) + vfs->szOsFile;  tvfs->mxPathname = vfs->mxPathname;  tvfs->zName = "telemetry-vfs";  tvfs->pAppData = vfs;  tvfs->xOpen = xOpen;  tvfs->xDelete = xDelete;  tvfs->xAccess = xAccess;  tvfs->xFullPathname = xFullPathname;  tvfs->xDlOpen = xDlOpen;  tvfs->xDlError = xDlError;  tvfs->xDlSym = xDlSym;  tvfs->xDlClose = xDlClose;  tvfs->xRandomness = xRandomness;  tvfs->xSleep = xSleep;  tvfs->xCurrentTime = xCurrentTime;  tvfs->xGetLastError = xGetLastError;  if (tvfs->iVersion >= 2) {    // Methods added in version 2.    tvfs->xCurrentTimeInt64 = xCurrentTimeInt64;  }  if (tvfs->iVersion >= 3) {    // Methods added in version 3.    tvfs->xSetSystemCall = xSetSystemCall;    tvfs->xGetSystemCall = xGetSystemCall;    tvfs->xNextSystemCall = xNextSystemCall;  }  return tvfs;}

sqlite3_vfs* ConstructTelemetryVFS(){#if defined(XP_WIN)#define EXPECTED_VFS     "win32"#define EXPECTED_VFS_NFS "win32"#else#define EXPECTED_VFS     "unix"#define EXPECTED_VFS_NFS "unix-excl"#endif    bool expected_vfs;  sqlite3_vfs *vfs;  if (Preferences::GetBool(PREF_NFS_FILESYSTEM)) {    vfs = sqlite3_vfs_find(EXPECTED_VFS_NFS);    expected_vfs = (vfs != nullptr);  }  else {    vfs = sqlite3_vfs_find(nullptr);    expected_vfs = vfs->zName && !strcmp(vfs->zName, EXPECTED_VFS);  }  if (!expected_vfs) {    return nullptr;  }  sqlite3_vfs *tvfs = new ::sqlite3_vfs;  memset(tvfs, 0, sizeof(::sqlite3_vfs));  // If you update this version number, you must add appropriate VFS methods  // for any methods added in the version change.  tvfs->iVersion = 3;  MOZ_ASSERT(vfs->iVersion == tvfs->iVersion);  tvfs->szOsFile = sizeof(telemetry_file) - sizeof(sqlite3_file) + vfs->szOsFile;  tvfs->mxPathname = vfs->mxPathname;  tvfs->zName = "telemetry-vfs";  tvfs->pAppData = vfs;  tvfs->xOpen = xOpen;  tvfs->xDelete = xDelete;  tvfs->xAccess = xAccess;  tvfs->xFullPathname = xFullPathname;  tvfs->xDlOpen = xDlOpen;  tvfs->xDlError = xDlError;  tvfs->xDlSym = xDlSym;  tvfs->xDlClose = xDlClose;  tvfs->xRandomness = xRandomness;  tvfs->xSleep = xSleep;  tvfs->xCurrentTime = xCurrentTime;  tvfs->xGetLastError = xGetLastError;  // Methods added in version 2.  tvfs->xCurrentTimeInt64 = xCurrentTimeInt64;  // Methods added in version 3.  tvfs->xSetSystemCall = xSetSystemCall;  tvfs->xGetSystemCall = xGetSystemCall;  tvfs->xNextSystemCall = xNextSystemCall;  return tvfs;}

/*** Clients invoke this routine to construct a new trace-vfs shim.**** Return SQLITE_OK on success.  **** SQLITE_NOMEM is returned in the case of a memory allocation error.** SQLITE_NOTFOUND is returned if zOldVfsName does not exist.*/int vfstrace_register(   const char *zTraceName,           /* Name of the newly constructed VFS */   const char *zOldVfsName,          /* Name of the underlying VFS */   int (*xOut)(const char*,void*),   /* Output routine.  ex: fputs */   void *pOutArg,                    /* 2nd argument to xOut.  ex: stderr */   int makeDefault                   /* True to make the new VFS the default */){  sqlite3_vfs *pNew;  sqlite3_vfs *pRoot;  vfstrace_info *pInfo;  int nName;  int nByte;  pRoot = sqlite3_vfs_find(zOldVfsName);  if( pRoot==0 ) return SQLITE_NOTFOUND;  nName = strlen(zTraceName);  nByte = sizeof(*pNew) + sizeof(*pInfo) + nName + 1;  pNew = sqlite3_malloc( nByte );  if( pNew==0 ) return SQLITE_NOMEM;  memset(pNew, 0, nByte);  pInfo = (vfstrace_info*)&pNew[1];  pNew->iVersion = pRoot->iVersion;  pNew->szOsFile = pRoot->szOsFile + sizeof(vfstrace_file);  pNew->mxPathname = pRoot->mxPathname;  pNew->zName = (char*)&pInfo[1];  memcpy((char*)&pInfo[1], zTraceName, nName+1);  pNew->pAppData = pInfo;  pNew->xOpen = vfstraceOpen;  pNew->xDelete = vfstraceDelete;  pNew->xAccess = vfstraceAccess;  pNew->xFullPathname = vfstraceFullPathname;  pNew->xDlOpen = pRoot->xDlOpen==0 ? 0 : vfstraceDlOpen;  pNew->xDlError = pRoot->xDlError==0 ? 0 : vfstraceDlError;  pNew->xDlSym = pRoot->xDlSym==0 ? 0 : vfstraceDlSym;  pNew->xDlClose = pRoot->xDlClose==0 ? 0 : vfstraceDlClose;  pNew->xRandomness = vfstraceRandomness;  pNew->xSleep = vfstraceSleep;  pNew->xCurrentTime = vfstraceCurrentTime;  pNew->xGetLastError = pRoot->xGetLastError==0 ? 0 : vfstraceGetLastError;  if( pNew->iVersion>=2 ){    pNew->xCurrentTimeInt64 = pRoot->xCurrentTimeInt64==0 ? 0 :                                   vfstraceCurrentTimeInt64;    if( pNew->iVersion>=3 ){      pNew->xSetSystemCall = pRoot->xSetSystemCall==0 ? 0 :                                    vfstraceSetSystemCall;      pNew->xGetSystemCall = pRoot->xGetSystemCall==0 ? 0 :                                    vfstraceGetSystemCall;      pNew->xNextSystemCall = pRoot->xNextSystemCall==0 ? 0 :                                    vfstraceNextSystemCall;    }  }  pInfo->pRootVfs = pRoot;  pInfo->xOut = xOut;  pInfo->pOutArg = pOutArg;  pInfo->zVfsName = pNew->zName;  pInfo->pTraceVfs = pNew;  vfstrace_printf(pInfo, "%s.enabled_for(/"%s/")/n",       pInfo->zVfsName, pRoot->zName);  return sqlite3_vfs_register(pNew, makeDefault);}

void SQLiteFileSystem::registerSQLiteVFS() {  sqlite3_vfs* wrappedVfs = sqlite3_vfs_find("win32");  // These are implemented by delegating to |wrappedVfs|.  // TODO(shess): Implement local versions.  ASSERT(wrappedVfs->xRandomness);  ASSERT(wrappedVfs->xSleep);  ASSERT(wrappedVfs->xCurrentTime);  static sqlite3_vfs chromium_vfs = {1,                                     wrappedVfs->szOsFile,                                     wrappedVfs->mxPathname,                                     0,                                     "chromium_vfs",                                     wrappedVfs,                                     chromiumOpen,                                     chromiumDelete,                                     chromiumAccess,                                     chromiumFullPathname,                                     chromiumDlOpen,                                     chromiumDlError,                                     chromiumDlSym,                                     chromiumDlClose,                                     chromiumRandomness,                                     chromiumSleep,                                     chromiumCurrentTime,                                     chromiumGetLastError};  sqlite3_vfs_register(&chromium_vfs, 0);}

void SQLiteFileSystem::registerSQLiteVFS(){    sqlite3_vfs* unix_vfs = sqlite3_vfs_find("unix");    static sqlite3_vfs chromium_vfs = {        1,        unix_vfs->szOsFile,        unix_vfs->mxPathname,        0,        "chromium_vfs",        unix_vfs->pAppData,        chromiumOpen,        chromiumDelete,        chromiumAccess,        chromiumFullPathname,        chromiumDlOpen,        unix_vfs->xDlError,        unix_vfs->xDlSym,        unix_vfs->xDlClose,        unix_vfs->xRandomness,        unix_vfs->xSleep,        unix_vfs->xCurrentTime,        unix_vfs->xGetLastError    };    sqlite3_vfs_register(&chromium_vfs, 0);}

/* ** Sleep for nMicro microseconds. Return the number of microseconds ** actually slept. */static int fsSleep(sqlite3_vfs *pVfs, int nMicro){	sqlite3_vfs* parent = sqlite3_vfs_find(0);	if ( parent )		return parent->xSleep(parent, nMicro);	else		return SQLITE_ERROR;}

void SQLiteFileSystem::registerSQLiteVFS(){    // FIXME: Make sure there aren't any unintended consequences when VFS code is called in the browser process.    if (!ChromiumBridge::sandboxEnabled()) {        ASSERT_NOT_REACHED();        return;    }    sqlite3_vfs* win32_vfs = sqlite3_vfs_find("win32");    static sqlite3_vfs chromium_vfs = {        1,        win32_vfs->szOsFile,        win32_vfs->mxPathname,        0,        "chromium_vfs",        win32_vfs->pAppData,        chromiumOpen,        chromiumDelete,        chromiumAccess,        chromiumFullPathname,        chromiumDlOpen,        win32_vfs->xDlError,        win32_vfs->xDlSym,        win32_vfs->xDlClose,        win32_vfs->xRandomness,        win32_vfs->xSleep,        win32_vfs->xCurrentTime,        win32_vfs->xGetLastError    };    sqlite3_vfs_register(&chromium_vfs, 1);}

bool CSimpleEncryptedVFS::Setup(){	if (GetDelegate() != nullptr)	{		return true;	}	sqlite3_vfs *vfs = sqlite3_vfs_find("win32");	if (vfs == nullptr)	{		return false;	}	iVersion = vfs->iVersion;	szOsFile = sizeof(FileInfo) + vfs->szOsFile - sizeof(sqlite3_file);	mxPathname = vfs->mxPathname;	pNext = nullptr;	zName = "CSimpleEncryptedVFS";	pAppData = nullptr;	if (SQLITE_OK != sqlite3_vfs_register(this, 1))	{		return false;	}	SetDelegate(vfs);	return true;}

int register_little_ro_vfs(int makeDflt) {    struct sqlite3_vfs *un;    un = sqlite3_vfs_find("unix");    if (un == NULL) return -1;    sqlite3_vfs_register(init_little_ro_vfs(un), makeDflt);    return 0;}

void SQLiteFileSystem::registerSQLiteVFS(){    sqlite3_vfs* wrappedVfs = sqlite3_vfs_find("win32");    static sqlite3_vfs chromium_vfs = {        1,        wrappedVfs->szOsFile,        wrappedVfs->mxPathname,        0,        "chromium_vfs",        wrappedVfs,        chromiumOpen,        chromiumDelete,        chromiumAccess,        chromiumFullPathname,        chromiumDlOpen,        chromiumDlError,        chromiumDlSym,        chromiumDlClose,        chromiumRandomness,        chromiumSleep,        chromiumCurrentTime,        chromiumGetLastError    };    sqlite3_vfs_register(&chromium_vfs, 0);}

/*** Usage:   btree_open FILENAME NCACHE**** Open a new database*/static int btree_open(  void *NotUsed,  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */  int argc,              /* Number of arguments */  const char **argv      /* Text of each argument */){  Btree *pBt;  int rc, nCache;  char zBuf[100];  if( argc!=3 ){    Tcl_AppendResult(interp, "wrong # args: should be /"", argv[0],       " FILENAME NCACHE FLAGS/"", 0);    return TCL_ERROR;  }  if( Tcl_GetInt(interp, argv[2], &nCache) ) return TCL_ERROR;  nRefSqlite3++;  if( nRefSqlite3==1 ){    sDb.pVfs = sqlite3_vfs_find(0);    sDb.mutex = sqlite3MutexAlloc(SQLITE_MUTEX_RECURSIVE);    sqlite3_mutex_enter(sDb.mutex);  }  rc = sqlite3BtreeOpen(sDb.pVfs, argv[1], &sDb, &pBt, 0,      SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE | SQLITE_OPEN_MAIN_DB);  if( rc!=SQLITE_OK ){    Tcl_AppendResult(interp, errorName(rc), 0);    return TCL_ERROR;  }  sqlite3BtreeSetCacheSize(pBt, nCache);  sqlite3_snprintf(sizeof(zBuf), zBuf,"%p", pBt);  Tcl_AppendResult(interp, zBuf, 0);  return TCL_OK;}

/*** Usage:   pager_open FILENAME N-PAGE**** Open a new pager*/static int pager_open(  void *NotUsed,  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */  int argc,              /* Number of arguments */  const char **argv      /* Text of each argument */){  u16 pageSize;  Pager *pPager;  int nPage;  int rc;  char zBuf[100];  if( argc!=3 ){    Tcl_AppendResult(interp, "wrong # args: should be /"", argv[0],       " FILENAME N-PAGE/"", 0);    return TCL_ERROR;  }  if( Tcl_GetInt(interp, argv[2], &nPage) ) return TCL_ERROR;  rc = sqlite3PagerOpen(sqlite3_vfs_find(0), &pPager, argv[1], 0, 0,      SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE | SQLITE_OPEN_MAIN_DB,      pager_test_reiniter);  if( rc!=SQLITE_OK ){    Tcl_AppendResult(interp, errorName(rc), 0);    return TCL_ERROR;  }  sqlite3PagerSetCachesize(pPager, nPage);  pageSize = test_pagesize;  sqlite3PagerSetPagesize(pPager, &pageSize, -1);  sqlite3_snprintf(sizeof(zBuf),zBuf,"%p",pPager);  Tcl_AppendResult(interp, zBuf, 0);  return TCL_OK;}

/* ** Return the current time as a Julian Day number in *pTimeOut. */static int fsCurrentTime(sqlite3_vfs *pVfs, double *pTimeOut){	sqlite3_vfs* parent = sqlite3_vfs_find(0);	if ( parent )		return parent->xCurrentTime(parent, pTimeOut);	else		return SQLITE_ERROR;}

sqlite3_vfs* OGRSQLiteCreateVFS(pfnNotifyFileOpenedType pfn, void* pfnUserData){    sqlite3_vfs* pDefaultVFS = sqlite3_vfs_find(NULL);    sqlite3_vfs* pMyVFS = (sqlite3_vfs*) CPLCalloc(1, sizeof(sqlite3_vfs));    OGRSQLiteVFSAppDataStruct* pVFSAppData =        (OGRSQLiteVFSAppDataStruct*) CPLCalloc(1, sizeof(OGRSQLiteVFSAppDataStruct));    sprintf(pVFSAppData->szVFSName, "OGRSQLITEVFS_%p", pVFSAppData);    pVFSAppData->pDefaultVFS = pDefaultVFS;    pVFSAppData->pfn = pfn;    pVFSAppData->pfnUserData = pfnUserData;    pVFSAppData->nCounter = 0;    pMyVFS->iVersion = 1;    pMyVFS->szOsFile = sizeof(OGRSQLiteFileStruct);    pMyVFS->mxPathname = pDefaultVFS->mxPathname;    pMyVFS->zName = pVFSAppData->szVFSName;    pMyVFS->pAppData = pVFSAppData;    pMyVFS->xOpen = OGRSQLiteVFSOpen;    pMyVFS->xDelete = OGRSQLiteVFSDelete;    pMyVFS->xAccess = OGRSQLiteVFSAccess;    pMyVFS->xFullPathname = OGRSQLiteVFSFullPathname;    pMyVFS->xDlOpen = OGRSQLiteVFSDlOpen;    pMyVFS->xDlError = OGRSQLiteVFSDlError;    pMyVFS->xDlSym = OGRSQLiteVFSDlSym;    pMyVFS->xDlClose = OGRSQLiteVFSDlClose;    pMyVFS->xRandomness = OGRSQLiteVFSRandomness;    pMyVFS->xSleep = OGRSQLiteVFSSleep;    pMyVFS->xCurrentTime = OGRSQLiteVFSCurrentTime;    pMyVFS->xGetLastError = OGRSQLiteVFSGetLastError;    return pMyVFS;}

/*** CAPI: Initialize the multiplex VFS shim - sqlite3_multiplex_initialize()**** Use the VFS named zOrigVfsName as the VFS that does the actual work.  ** Use the default if zOrigVfsName==NULL.  **** The multiplex VFS shim is named "multiplex".  It will become the default** VFS if makeDefault is non-zero.**** THIS ROUTINE IS NOT THREADSAFE.  Call this routine exactly once** during start-up.*/int sqlite3_multiplex_initialize(const char *zOrigVfsName, int makeDefault){  sqlite3_vfs *pOrigVfs;  if( gMultiplex.isInitialized ) return SQLITE_MISUSE;  pOrigVfs = sqlite3_vfs_find(zOrigVfsName);  if( pOrigVfs==0 ) return SQLITE_ERROR;  assert( pOrigVfs!=&gMultiplex.sThisVfs );  gMultiplex.pMutex = sqlite3_mutex_alloc(SQLITE_MUTEX_FAST);  if( !gMultiplex.pMutex ){    return SQLITE_NOMEM;  }  gMultiplex.pGroups = NULL;  gMultiplex.isInitialized = 1;  gMultiplex.pOrigVfs = pOrigVfs;  gMultiplex.sThisVfs = *pOrigVfs;  gMultiplex.sThisVfs.szOsFile += sizeof(multiplexConn);  gMultiplex.sThisVfs.zName = SQLITE_MULTIPLEX_VFS_NAME;  gMultiplex.sThisVfs.xOpen = multiplexOpen;  gMultiplex.sThisVfs.xDelete = multiplexDelete;  gMultiplex.sThisVfs.xAccess = multiplexAccess;  gMultiplex.sThisVfs.xFullPathname = multiplexFullPathname;  gMultiplex.sThisVfs.xDlOpen = multiplexDlOpen;  gMultiplex.sThisVfs.xDlError = multiplexDlError;  gMultiplex.sThisVfs.xDlSym = multiplexDlSym;  gMultiplex.sThisVfs.xDlClose = multiplexDlClose;  gMultiplex.sThisVfs.xRandomness = multiplexRandomness;  gMultiplex.sThisVfs.xSleep = multiplexSleep;  gMultiplex.sThisVfs.xCurrentTime = multiplexCurrentTime;  gMultiplex.sThisVfs.xGetLastError = multiplexGetLastError;  gMultiplex.sThisVfs.xCurrentTimeInt64 = multiplexCurrentTimeInt64;  gMultiplex.sIoMethodsV1.iVersion = 1;  gMultiplex.sIoMethodsV1.xClose = multiplexClose;  gMultiplex.sIoMethodsV1.xRead = multiplexRead;  gMultiplex.sIoMethodsV1.xWrite = multiplexWrite;  gMultiplex.sIoMethodsV1.xTruncate = multiplexTruncate;  gMultiplex.sIoMethodsV1.xSync = multiplexSync;  gMultiplex.sIoMethodsV1.xFileSize = multiplexFileSize;  gMultiplex.sIoMethodsV1.xLock = multiplexLock;  gMultiplex.sIoMethodsV1.xUnlock = multiplexUnlock;  gMultiplex.sIoMethodsV1.xCheckReservedLock = multiplexCheckReservedLock;  gMultiplex.sIoMethodsV1.xFileControl = multiplexFileControl;  gMultiplex.sIoMethodsV1.xSectorSize = multiplexSectorSize;  gMultiplex.sIoMethodsV1.xDeviceCharacteristics =                                            multiplexDeviceCharacteristics;  gMultiplex.sIoMethodsV2 = gMultiplex.sIoMethodsV1;  gMultiplex.sIoMethodsV2.iVersion = 2;  gMultiplex.sIoMethodsV2.xShmMap = multiplexShmMap;  gMultiplex.sIoMethodsV2.xShmLock = multiplexShmLock;  gMultiplex.sIoMethodsV2.xShmBarrier = multiplexShmBarrier;  gMultiplex.sIoMethodsV2.xShmUnmap = multiplexShmUnmap;  sqlite3_vfs_register(&gMultiplex.sThisVfs, makeDefault);  sqlite3_auto_extension((void*)multiplexFuncInit);  return SQLITE_OK;}

/* ** This routine is called when the extension is loaded.** Register the new VFS.*/int sqlite3MemdbInit(void){  sqlite3_vfs *pLower = sqlite3_vfs_find(0);  int sz = pLower->szOsFile;  memdb_vfs.pAppData = pLower;  /* In all known configurations of SQLite, the size of a default  ** sqlite3_file is greater than the size of a memdb sqlite3_file.  ** Should that ever change, remove the following NEVER() */  if( NEVER(sz<sizeof(MemFile)) ) sz = sizeof(MemFile);  memdb_vfs.szOsFile = sz;  return sqlite3_vfs_register(&memdb_vfs, 0);}

/*** Sleep for a little while.  Return the amount of time slept.*/EXPORT_C int sqlite3_sleep(int ms){  sqlite3_vfs *pVfs;  int rc;  pVfs = sqlite3_vfs_find(0);  /* This function works in milliseconds, but the underlying OsSleep()   ** API uses microseconds. Hence the 1000's.  */  rc = (sqlite3OsSleep(pVfs, 1000*ms)/1000);  return rc;}

//Miscellaneous testsvoid Test3()	{	sqlite3_vfs* vfs = sqlite3_vfs_find(KSymbianVfsNameZ);	TEST(vfs != NULL);	//Full path name - the full file name is specified	char fname[KMaxFileName];	const char* testFileName1 = "c://test//abv.db";	int err = sqlite3OsFullPathname(vfs, testFileName1, KMaxFileName, fname);	TEST2(err, SQLITE_OK);	err = strncasecmp(fname, testFileName1, strlen(testFileName1));	TEST2(err, 0);	//Full path name - no drive, the full file name is not specified	const char* testFileName2 = "abv.db";	const char* expectedFileName2 = "c://private//21F12127//abv.db";//"21F12127", the UID of the current test app	err = sqlite3OsFullPathname(vfs, testFileName2, KMaxFileName, fname);	TEST2(err, SQLITE_OK);	err = strncasecmp(fname, expectedFileName2, strlen(expectedFileName2));	TEST2(err, 0);	//Full path name - drive present, the full file name is not specified	const char* testFileName3 = "z:abv.db";	const char* expectedFileName3 = "z://private//21F12127//abv.db";//"21F12127", the UID of the current test app	err = sqlite3OsFullPathname(vfs, testFileName3, KMaxFileName, fname);	TEST2(err, SQLITE_OK);	err = strncasecmp(fname, expectedFileName3, strlen(expectedFileName3));	TEST2(err, 0);	//Is directory writable - test 1	int res = 0;	err = sqlite3OsAccess(vfs, "c://test", SQLITE_ACCESS_READWRITE, &res);	TEST2(err, SQLITE_OK);	TEST2(res, 1);	//Is directory writable - test 2	err = sqlite3OsAccess(vfs, "c://test//", SQLITE_ACCESS_READWRITE, &res);	TEST2(err, SQLITE_OK);	TEST2(res, 1);	//Is directory writable - test 3	//Not a valid test. It is the media that's read only, not the directory.	//err = sqlite3OsAccess(vfs, "z://test//", SQLITE_ACCESS_READWRITE, &res);	//TEST2(err, SQLITE_OK);	//TEST2(res, 0);	//Random seed	const int KBufLen = 100;	char buf[KBufLen];	err = sqlite3OsRandomness(vfs, KBufLen, buf);	TEST2(err, KBufLen);	//Sleep	TUint32 start = User::FastCounter();	const TInt KSleepTime = 200000;//us	(void)sqlite3OsSleep(vfs, KSleepTime);	TUint32 end = User::FastCounter();	TInt ms = CalcMs(start, end);	TheTest.Printf(_L(" === sqlite3OsSleep() time=%d ms/r/n"), ms);	//TEST(ms >= 80 && ms <= 320);// -60%..+60%	}

void VfsOpenTempFileFileIoErrTest()	{    //Delete all temp files in this test private data cage.	TInt err = DoDeleteTempFiles();    TEST(err == KErrNone || err == KErrNotFound);        sqlite3_vfs* vfs = sqlite3_vfs_find(NULL);    TEST(vfs != NULL);    sqlite3_file* osFile = (sqlite3_file*)User::Alloc(vfs->szOsFile);    TEST(osFile != NULL);    	err = SQLITE_ERROR;	TInt cnt = 1;	while(err != SQLITE_OK)		{		TInt processHandleCnt = 0;		TInt threadHandleCnt = 0;		RThread().HandleCount(processHandleCnt, threadHandleCnt);		TInt allocCellsCnt = User::CountAllocCells();        TheTest.Printf(_L("%d "), cnt);		(void)TheFs.SetErrorCondition(KErrGeneral, cnt);        int outFlags = 0;        err = sqlite3OsOpen(vfs, NULL, osFile, SQLITE_OPEN_READWRITE, &outFlags);        if(err == SQLITE_OK)            {			//Since this is a temp file, its creation will be delayed till the first file write operation.			err = sqlite3OsWrite(osFile, "1234", 4, 0);			(void)sqlite3OsClose(osFile);            }		(void)TheFs.SetErrorCondition(KErrNone);		if(err != SQLITE_OK)			{			TInt processHandleCnt2 = 0;			TInt threadHandleCnt2 = 0;			RThread().HandleCount(processHandleCnt2, threadHandleCnt2);			TEST2(processHandleCnt2, processHandleCnt);			TEST2(threadHandleCnt2, threadHandleCnt);			TInt allocCellsCnt2 = User::CountAllocCells();			TEST2(allocCellsCnt2, allocCellsCnt);	        ++cnt;			}        //If the iteration has failed, then no temp file should exist in the test private data cage.        //If the iteration has succeeded, then sqlite3OsClose() should have deleted the temp file.        TInt err2 = DoDeleteTempFiles();        TEST2(err2, KErrNotFound);		}    TEST2(err, SQLITE_OK);    TheTest.Printf(_L("/r/n=== TVfs::Open(<temp file>) file I/O error simulation test succeeded at iteration %d/r/n"), cnt);    User::Free(osFile);	}

/* Return the current wall-clock time */static sqlite3_int64 realTime(void){  static sqlite3_vfs *clockVfs = 0;  sqlite3_int64 t;  if( clockVfs==0 ) clockVfs = sqlite3_vfs_find(0);  if( clockVfs->iVersion>=1 && clockVfs->xCurrentTimeInt64!=0 ){    clockVfs->xCurrentTimeInt64(clockVfs, &t);  }else{    double r;    clockVfs->xCurrentTime(clockVfs, &r);    t = (sqlite3_int64)(r*86400000.0);  }  return t;}

/*** This procedure registers the devsym vfs with SQLite. If the argument is** true, the devsym vfs becomes the new default vfs. It is the only publicly** available function in this file.*/void devsym_register(int iDeviceChar, int iSectorSize){  if( g.pVfs==0 ){    g.pVfs = sqlite3_vfs_find(0);    devsym_vfs.szOsFile += g.pVfs->szOsFile;    sqlite3_vfs_register(&devsym_vfs, 0);  }  if( iDeviceChar>=0 ){    g.iDeviceChar = iDeviceChar;  }  if( iSectorSize>=0 ){    g.iSectorSize = iSectorSize;  }}

/*** Configure the jt VFS as a wrapper around the VFS named by parameter ** zWrap. If the isDefault parameter is true, then the jt VFS is installed** as the new default VFS for SQLite connections. If isDefault is not** true, then the jt VFS is installed as non-default. In this case it** is available via its name, "jt".*/int jt_register(char *zWrap, int isDefault){  g.pVfs = sqlite3_vfs_find(zWrap);  if( g.pVfs==0 ){    return SQLITE_ERROR;  }  jt_vfs.szOsFile = sizeof(jt_file) + g.pVfs->szOsFile;  if( g.pVfs->iVersion==1 ){    jt_vfs.iVersion = 1;  }else if( g.pVfs->xCurrentTimeInt64==0 ){    jt_vfs.xCurrentTimeInt64 = 0;  }  sqlite3_vfs_register(&jt_vfs, isDefault);  return SQLITE_OK;}

int sqlite3_embedded_initialize(const char* zOrigVfsName, int makeDefault) {  sqlite3_vfs* pOrigVfs;  if (gEmbedded.isInitialized) return SQLITE_MISUSE;  pOrigVfs = sqlite3_vfs_find(zOrigVfsName);  if (pOrigVfs==0) return SQLITE_ERROR;  assert(pOrigVfs!=&gEmbedded.sThisVfs);  gEmbedded.pMutex = sqlite3_mutex_alloc(SQLITE_MUTEX_FAST);  if (!gEmbedded.pMutex) {    return SQLITE_NOMEM;  }  gEmbedded.isInitialized = 1;  gEmbedded.pOrigVfs = pOrigVfs;  gEmbedded.sThisVfs = *pOrigVfs;  gEmbedded.sThisVfs.szOsFile += sizeof(embeddedConn);  gEmbedded.sThisVfs.zName = "embedded";  gEmbedded.sThisVfs.xOpen = embeddedOpen;  gEmbedded.sThisVfs.xDelete = embeddedDelete;  gEmbedded.sThisVfs.xAccess = embeddedAccess;  gEmbedded.sThisVfs.xFullPathname = embeddedFullPathname;  gEmbedded.sThisVfs.xDlOpen = embeddedDlOpen;  gEmbedded.sThisVfs.xDlError = embeddedDlError;  gEmbedded.sThisVfs.xDlSym = embeddedDlSym;  gEmbedded.sThisVfs.xDlClose = embeddedDlClose;  gEmbedded.sThisVfs.xRandomness = embeddedRandomness;  gEmbedded.sThisVfs.xSleep = embeddedSleep;  gEmbedded.sThisVfs.xCurrentTime = embeddedCurrentTime;  gEmbedded.sThisVfs.xGetLastError = embeddedGetLastError;  gEmbedded.sThisVfs.xCurrentTimeInt64 = embeddedCurrentTimeInt64;  gEmbedded.sIoMethodsV1.iVersion = 1;  gEmbedded.sIoMethodsV1.xClose = embeddedClose;  gEmbedded.sIoMethodsV1.xRead = embeddedRead;  gEmbedded.sIoMethodsV1.xWrite = embeddedWrite;  gEmbedded.sIoMethodsV1.xTruncate = embeddedTruncate;  gEmbedded.sIoMethodsV1.xSync = embeddedSync;  gEmbedded.sIoMethodsV1.xFileSize = embeddedFileSize;  gEmbedded.sIoMethodsV1.xLock = embeddedLock;  gEmbedded.sIoMethodsV1.xUnlock = embeddedUnlock;  gEmbedded.sIoMethodsV1.xCheckReservedLock = embeddedCheckReservedLock;  gEmbedded.sIoMethodsV1.xFileControl = embeddedFileControl;  gEmbedded.sIoMethodsV1.xSectorSize = embeddedSectorSize;  gEmbedded.sIoMethodsV1.xDeviceCharacteristics =    embeddedDeviceCharacteristics;  sqlite3_vfs_register(&gEmbedded.sThisVfs, makeDefault);  return SQLITE_OK;}

/*** Usage:   fake_big_file  N  FILENAME**** Write a few bytes at the N megabyte point of FILENAME.  This will** create a large file.  If the file was a valid SQLite database, then** the next time the database is opened, SQLite will begin allocating** new pages after N.  If N is 2096 or bigger, this will test the** ability of SQLite to write to large files.*/static int fake_big_file(  void *NotUsed,  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */  int argc,              /* Number of arguments */  const char **argv      /* Text of each argument */){  sqlite3_vfs *pVfs;  sqlite3_file *fd = 0;  int rc;  int n;  i64 offset;  char *zFile;  int nFile;  if( argc!=3 ){    Tcl_AppendResult(interp, "wrong # args: should be /"", argv[0],       " N-MEGABYTES FILE/"", 0);    return TCL_ERROR;  }  if( Tcl_GetInt(interp, argv[1], &n) ) return TCL_ERROR;  /* this does not work with MDB */  return TCL_ERROR;  pVfs = sqlite3_vfs_find(0);  nFile = (int)strlen(argv[2]);  zFile = sqlite3_malloc( nFile+2 );  if( zFile==0 ) return TCL_ERROR;  memcpy(zFile, argv[2], nFile+1);  zFile[nFile+1] = 0;  rc = sqlite3OsOpenMalloc(pVfs, zFile, &fd,       (SQLITE_OPEN_CREATE|SQLITE_OPEN_READWRITE|SQLITE_OPEN_MAIN_DB), 0  );  if( rc ){    Tcl_AppendResult(interp, "open failed: ", sqlite3ErrName(rc), 0);    sqlite3_free(zFile);    return TCL_ERROR;  }  offset = n;  offset *= 1024*1024;  rc = sqlite3OsWrite(fd, "Hello, World!", 14, offset);  sqlite3OsCloseFree(fd);  sqlite3_free(zFile);  if( rc ){    Tcl_AppendResult(interp, "write failed: ", sqlite3ErrName(rc), 0);    return TCL_ERROR;  }  return TCL_OK;}

/*** Register the VFS that reads from the g.aFile[] set of files.*/static void inmemVfsRegister(void){  static sqlite3_vfs inmemVfs;  sqlite3_vfs *pDefault = sqlite3_vfs_find(0);  inmemVfs.iVersion = 3;  inmemVfs.szOsFile = sizeof(VHandle);  inmemVfs.mxPathname = 200;  inmemVfs.zName = "inmem";  inmemVfs.xOpen = inmemOpen;  inmemVfs.xDelete = inmemDelete;  inmemVfs.xAccess = inmemAccess;  inmemVfs.xFullPathname = inmemFullPathname;  inmemVfs.xRandomness = pDefault->xRandomness;  inmemVfs.xSleep = pDefault->xSleep;  inmemVfs.xCurrentTimeInt64 = pDefault->xCurrentTimeInt64;  sqlite3_vfs_register(&inmemVfs, 0);};

//Lock/unlock testsvoid Test5()	{	sqlite3_vfs* vfs = sqlite3_vfs_find(KSymbianVfsNameZ);	TEST(vfs != NULL);  	sqlite3_file* osFile = (sqlite3_file*)User::Alloc(vfs->szOsFile);	TEST(osFile != NULL);		//Creating a new file	int res = 0;	int err = sqlite3OsAccess(vfs, KTestFile1Z, SQLITE_ACCESS_EXISTS, &res);	TEST2(err, SQLITE_OK);	TEST2(res, 0);	err = sqlite3OsOpen(vfs, KTestFile1Z, osFile, SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, 0);	TEST2(err, SQLITE_OK);	//Lock/unlock	//SHARED_LOCK	err = sqlite3OsLock(osFile, SHARED_LOCK);	TEST2(err, SQLITE_OK);	err = sqlite3OsCheckReservedLock(osFile, &res);	TEST2(err, SQLITE_OK);	TEST2(res, 0);	//RESERVED_LOCK	err = sqlite3OsLock(osFile, RESERVED_LOCK);	TEST2(err, SQLITE_OK);	err = sqlite3OsCheckReservedLock(osFile, &res);	TEST2(err, SQLITE_OK);	TEST2(res, 1);	//PENDING_LOCK	err = sqlite3OsLock(osFile, PENDING_LOCK);	TEST2(err, SQLITE_OK);	//EXCLUSIVE_LOCK	err = sqlite3OsLock(osFile, EXCLUSIVE_LOCK);	TEST2(err, SQLITE_OK);	//back to SHARED_LOCK	err = sqlite3OsLock(osFile, SHARED_LOCK);	TEST2(err, SQLITE_OK);	//UNLOCK	err = sqlite3OsUnlock(osFile, NO_LOCK);	//Close the file	err = sqlite3OsClose(osFile);	TEST2(err, SQLITE_OK);	//	err = sqlite3OsDelete(vfs, KTestFile1Z, 0);	TEST2(err, SQLITE_OK);	User::Free(osFile);	}

int spmemvfs_init( spmemvfs_cb_t * cb ){	sqlite3_vfs * parent = NULL;	if( g_spmemvfs.parent ) return SQLITE_OK;	parent = sqlite3_vfs_find( 0 );	g_spmemvfs.parent = parent;	g_spmemvfs.base.mxPathname = parent->mxPathname;	g_spmemvfs.base.szOsFile = sizeof( spmemfile_t );	g_spmemvfs.cb = * cb;	return sqlite3_vfs_register( (sqlite3_vfs*)&g_spmemvfs, 0 );}

	NitSqliteVFS(const char* osVfsName = NULL)	{		os = sqlite3_vfs_find(osVfsName);		static const sqlite3_io_methods fileMethods =		{			1,			FileClose,			FileRead,			FileWrite,			FileTruncate,			FileSync,			FileSize,			FileLock,			FileUnlock,			FileCheckReservedLock,			FileControl,			FileSectorSize,			FileDeviceCharacteristics,		};		methods = &fileMethods;		iVersion			= 3;		szOsFile			= sizeof(DBFile);		mxPathname			= MAX_PATH;		pNext				= 0;		zName				= "nit";		pAppData			= 0;		xOpen				= VFSOpen;		xDelete				= VFSDelete;		xAccess				= VFSAccess;		xFullPathname		= VFSFullPathname;		xDlOpen				= 0;		xDlError			= 0;		xDlClose			= 0;		xRandomness			= VFSRandomness;		xSleep				= VFSSleep;		xCurrentTime		= VFSCurrentTime;		xCurrentTimeInt64	= VFSCurrentTimeInt64;		xGetLastError		= VFSGetLastError;		xSetSystemCall		= 0;		xGetSystemCall		= 0;		xNextSystemCall		= 0;	}

sqlite3_vfs* ConstructTelemetryVFS(){#if defined(XP_WIN)#define EXPECTED_VFS "win32"#else#define EXPECTED_VFS "unix"#endif  sqlite3_vfs *vfs = sqlite3_vfs_find(NULL);  const bool expected_vfs = vfs->zName && !strcmp(vfs->zName, EXPECTED_VFS);  if (!expected_vfs) {    return NULL;  }  sqlite3_vfs *tvfs = new ::sqlite3_vfs;  memset(tvfs, 0, sizeof(::sqlite3_vfs));  tvfs->iVersion = 3;  // If the SQLite VFS version is updated, this shim must be updated as well.  MOZ_ASSERT(vfs->iVersion == tvfs->iVersion);  tvfs->szOsFile = sizeof(telemetry_file) - sizeof(sqlite3_file) + vfs->szOsFile;  tvfs->mxPathname = vfs->mxPathname;  tvfs->zName = "telemetry-vfs";  tvfs->pAppData = vfs;  tvfs->xOpen = xOpen;  tvfs->xDelete = xDelete;  tvfs->xAccess = xAccess;  tvfs->xFullPathname = xFullPathname;  tvfs->xDlOpen = xDlOpen;  tvfs->xDlError = xDlError;  tvfs->xDlSym = xDlSym;  tvfs->xDlClose = xDlClose;  tvfs->xRandomness = xRandomness;  tvfs->xSleep = xSleep;  tvfs->xCurrentTime = xCurrentTime;  tvfs->xGetLastError = xGetLastError;  // Added in version 2.  tvfs->xCurrentTimeInt64 = xCurrentTimeInt64;  // Added in version 3.  tvfs->xSetSystemCall = xSetSystemCall;  tvfs->xGetSystemCall = xGetSystemCall;  tvfs->xNextSystemCall = xNextSystemCall;  return tvfs;}