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 tests
void 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 tests
void 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;
}
