summaryrefslogtreecommitdiffstats
path: root/storage/QuotaVFS.cpp
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-07 19:33:14 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-07 19:33:14 +0000
commit36d22d82aa202bb199967e9512281e9a53db42c9 (patch)
tree105e8c98ddea1c1e4784a60a5a6410fa416be2de /storage/QuotaVFS.cpp
parentInitial commit. (diff)
downloadfirefox-esr-36d22d82aa202bb199967e9512281e9a53db42c9.tar.xz
firefox-esr-36d22d82aa202bb199967e9512281e9a53db42c9.zip
Adding upstream version 115.7.0esr.upstream/115.7.0esr
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'storage/QuotaVFS.cpp')
-rw-r--r--storage/QuotaVFS.cpp621
1 files changed, 621 insertions, 0 deletions
diff --git a/storage/QuotaVFS.cpp b/storage/QuotaVFS.cpp
new file mode 100644
index 0000000000..a736953fa2
--- /dev/null
+++ b/storage/QuotaVFS.cpp
@@ -0,0 +1,621 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ * vim: sw=2 ts=2 et lcs=trail\:.,tab\:>~ :
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "sqlite3.h"
+#include "mozilla/dom/quota/PersistenceType.h"
+#include "mozilla/dom/quota/QuotaManager.h"
+#include "mozilla/dom/quota/QuotaObject.h"
+#include "mozilla/dom/quota/ResultExtensions.h"
+#include "nsDirectoryServiceDefs.h"
+#include "nsEscape.h"
+#include "mozilla/StaticPrefs_storage.h"
+
+#if defined(XP_WIN) || defined(XP_UNIX)
+# include "mozilla/StaticPrefs_dom.h"
+#endif
+
+// The last VFS version for which this file has been updated.
+#define LAST_KNOWN_VFS_VERSION 3
+
+// The last io_methods version for which this file has been updated.
+#define LAST_KNOWN_IOMETHODS_VERSION 3
+
+namespace {
+
+using namespace mozilla;
+using namespace mozilla::dom::quota;
+
+struct QuotaFile {
+ // Base class. Must be first
+ sqlite3_file base;
+
+ // quota object for this file
+ RefPtr<QuotaObject> quotaObject;
+
+ // The chunk size for this file. See the documentation for
+ // sqlite3_file_control() and FCNTL_CHUNK_SIZE.
+ int fileChunkSize;
+
+ // This contains the vfs that actually does work
+ sqlite3_file pReal[1];
+};
+
+already_AddRefed<QuotaObject> GetQuotaObjectFromName(const char* zName) {
+ MOZ_ASSERT(zName);
+
+ const char* directoryLockIdParam =
+ sqlite3_uri_parameter(zName, "directoryLockId");
+ if (!directoryLockIdParam) {
+ return nullptr;
+ }
+
+ nsresult rv;
+ const int64_t directoryLockId =
+ nsDependentCString(directoryLockIdParam).ToInteger64(&rv);
+ MOZ_RELEASE_ASSERT(NS_SUCCEEDED(rv));
+
+ QuotaManager* quotaManager = QuotaManager::Get();
+ MOZ_ASSERT(quotaManager);
+
+ return quotaManager->GetQuotaObject(directoryLockId,
+ NS_ConvertUTF8toUTF16(zName));
+}
+
+void MaybeEstablishQuotaControl(const char* zName, QuotaFile* pFile,
+ int flags) {
+ MOZ_ASSERT(pFile);
+ MOZ_ASSERT(!pFile->quotaObject);
+
+ if (!(flags & (SQLITE_OPEN_URI | SQLITE_OPEN_WAL))) {
+ return;
+ }
+ pFile->quotaObject = GetQuotaObjectFromName(zName);
+}
+
+/*
+** Close a QuotaFile.
+*/
+int QuotaClose(sqlite3_file* pFile) {
+ QuotaFile* p = (QuotaFile*)pFile;
+ int rc;
+ rc = p->pReal->pMethods->xClose(p->pReal);
+ if (rc == SQLITE_OK) {
+ delete p->base.pMethods;
+ p->base.pMethods = nullptr;
+ p->quotaObject = nullptr;
+#ifdef DEBUG
+ p->fileChunkSize = 0;
+#endif
+ }
+ return rc;
+}
+
+/*
+** Read data from a QuotaFile.
+*/
+int QuotaRead(sqlite3_file* pFile, void* zBuf, int iAmt, sqlite_int64 iOfst) {
+ QuotaFile* p = (QuotaFile*)pFile;
+ int rc;
+ rc = p->pReal->pMethods->xRead(p->pReal, zBuf, iAmt, iOfst);
+ return rc;
+}
+
+/*
+** Return the current file-size of a QuotaFile.
+*/
+int QuotaFileSize(sqlite3_file* pFile, sqlite_int64* pSize) {
+ QuotaFile* p = (QuotaFile*)pFile;
+ int rc;
+ rc = p->pReal->pMethods->xFileSize(p->pReal, pSize);
+ return rc;
+}
+
+/*
+** Write data to a QuotaFile.
+*/
+int QuotaWrite(sqlite3_file* pFile, const void* zBuf, int iAmt,
+ sqlite_int64 iOfst) {
+ QuotaFile* p = (QuotaFile*)pFile;
+ int rc;
+ if (p->quotaObject) {
+ MOZ_ASSERT(INT64_MAX - iOfst >= iAmt);
+ if (!p->quotaObject->MaybeUpdateSize(iOfst + iAmt, /* aTruncate */ false)) {
+ return SQLITE_FULL;
+ }
+ }
+ rc = p->pReal->pMethods->xWrite(p->pReal, zBuf, iAmt, iOfst);
+ if (p->quotaObject && rc != SQLITE_OK) {
+ NS_WARNING(
+ "xWrite failed on a quota-controlled file, attempting to "
+ "update its current size...");
+ sqlite_int64 currentSize;
+ if (QuotaFileSize(pFile, &currentSize) == SQLITE_OK) {
+ DebugOnly<bool> res =
+ p->quotaObject->MaybeUpdateSize(currentSize, /* aTruncate */ true);
+ MOZ_ASSERT(res);
+ }
+ }
+ return rc;
+}
+
+/*
+** Truncate a QuotaFile.
+*/
+int QuotaTruncate(sqlite3_file* pFile, sqlite_int64 size) {
+ QuotaFile* p = (QuotaFile*)pFile;
+ int rc;
+ if (p->quotaObject) {
+ if (p->fileChunkSize > 0) {
+ // Round up to the smallest multiple of the chunk size that will hold all
+ // the data.
+ size =
+ ((size + p->fileChunkSize - 1) / p->fileChunkSize) * p->fileChunkSize;
+ }
+ if (!p->quotaObject->MaybeUpdateSize(size, /* aTruncate */ true)) {
+ return SQLITE_FULL;
+ }
+ }
+ rc = p->pReal->pMethods->xTruncate(p->pReal, size);
+ if (p->quotaObject) {
+ if (rc == SQLITE_OK) {
+#ifdef DEBUG
+ // Make sure xTruncate set the size exactly as we calculated above.
+ sqlite_int64 newSize;
+ MOZ_ASSERT(QuotaFileSize(pFile, &newSize) == SQLITE_OK);
+ MOZ_ASSERT(newSize == size);
+#endif
+ } else {
+ NS_WARNING(
+ "xTruncate failed on a quota-controlled file, attempting to "
+ "update its current size...");
+ if (QuotaFileSize(pFile, &size) == SQLITE_OK) {
+ DebugOnly<bool> res =
+ p->quotaObject->MaybeUpdateSize(size, /* aTruncate */ true);
+ MOZ_ASSERT(res);
+ }
+ }
+ }
+ return rc;
+}
+
+/*
+** Sync a QuotaFile.
+*/
+int QuotaSync(sqlite3_file* pFile, int flags) {
+ QuotaFile* p = (QuotaFile*)pFile;
+ return p->pReal->pMethods->xSync(p->pReal, flags);
+}
+
+/*
+** Lock a QuotaFile.
+*/
+int QuotaLock(sqlite3_file* pFile, int eLock) {
+ QuotaFile* p = (QuotaFile*)pFile;
+ int rc;
+ rc = p->pReal->pMethods->xLock(p->pReal, eLock);
+ return rc;
+}
+
+/*
+** Unlock a QuotaFile.
+*/
+int QuotaUnlock(sqlite3_file* pFile, int eLock) {
+ QuotaFile* p = (QuotaFile*)pFile;
+ int rc;
+ rc = p->pReal->pMethods->xUnlock(p->pReal, eLock);
+ return rc;
+}
+
+/*
+** Check if another file-handle holds a RESERVED lock on a QuotaFile.
+*/
+int QuotaCheckReservedLock(sqlite3_file* pFile, int* pResOut) {
+ QuotaFile* p = (QuotaFile*)pFile;
+ int rc = p->pReal->pMethods->xCheckReservedLock(p->pReal, pResOut);
+ return rc;
+}
+
+/*
+** File control method. For custom operations on a QuotaFile.
+*/
+int QuotaFileControl(sqlite3_file* pFile, int op, void* pArg) {
+ QuotaFile* p = (QuotaFile*)pFile;
+ int rc;
+ // Hook SQLITE_FCNTL_SIZE_HINT for quota-controlled files and do the necessary
+ // work before passing to the SQLite VFS.
+ if (op == SQLITE_FCNTL_SIZE_HINT && p->quotaObject) {
+ sqlite3_int64 hintSize = *static_cast<sqlite3_int64*>(pArg);
+ sqlite3_int64 currentSize;
+ rc = QuotaFileSize(pFile, &currentSize);
+ if (rc != SQLITE_OK) {
+ return rc;
+ }
+ if (hintSize > currentSize) {
+ rc = QuotaTruncate(pFile, hintSize);
+ if (rc != SQLITE_OK) {
+ return rc;
+ }
+ }
+ }
+ rc = p->pReal->pMethods->xFileControl(p->pReal, op, pArg);
+ // Grab the file chunk size after the SQLite VFS has approved.
+ if (op == SQLITE_FCNTL_CHUNK_SIZE && rc == SQLITE_OK) {
+ p->fileChunkSize = *static_cast<int*>(pArg);
+ }
+#ifdef DEBUG
+ if (op == SQLITE_FCNTL_SIZE_HINT && p->quotaObject && rc == SQLITE_OK) {
+ sqlite3_int64 hintSize = *static_cast<sqlite3_int64*>(pArg);
+ if (p->fileChunkSize > 0) {
+ hintSize = ((hintSize + p->fileChunkSize - 1) / p->fileChunkSize) *
+ p->fileChunkSize;
+ }
+ sqlite3_int64 currentSize;
+ MOZ_ASSERT(QuotaFileSize(pFile, &currentSize) == SQLITE_OK);
+ MOZ_ASSERT(currentSize >= hintSize);
+ }
+#endif
+ return rc;
+}
+
+/*
+** Return the sector-size in bytes for a QuotaFile.
+*/
+int QuotaSectorSize(sqlite3_file* pFile) {
+ QuotaFile* p = (QuotaFile*)pFile;
+ int rc;
+ rc = p->pReal->pMethods->xSectorSize(p->pReal);
+ return rc;
+}
+
+/*
+** Return the device characteristic flags supported by a QuotaFile.
+*/
+int QuotaDeviceCharacteristics(sqlite3_file* pFile) {
+ QuotaFile* p = (QuotaFile*)pFile;
+ int rc;
+ rc = p->pReal->pMethods->xDeviceCharacteristics(p->pReal);
+ return rc;
+}
+
+/*
+** Shared-memory operations.
+*/
+int QuotaShmLock(sqlite3_file* pFile, int ofst, int n, int flags) {
+ QuotaFile* p = (QuotaFile*)pFile;
+ return p->pReal->pMethods->xShmLock(p->pReal, ofst, n, flags);
+}
+
+int QuotaShmMap(sqlite3_file* pFile, int iRegion, int szRegion, int isWrite,
+ void volatile** pp) {
+ QuotaFile* p = (QuotaFile*)pFile;
+ int rc;
+ rc = p->pReal->pMethods->xShmMap(p->pReal, iRegion, szRegion, isWrite, pp);
+ return rc;
+}
+
+void QuotaShmBarrier(sqlite3_file* pFile) {
+ QuotaFile* p = (QuotaFile*)pFile;
+ p->pReal->pMethods->xShmBarrier(p->pReal);
+}
+
+int QuotaShmUnmap(sqlite3_file* pFile, int delFlag) {
+ QuotaFile* p = (QuotaFile*)pFile;
+ int rc;
+ rc = p->pReal->pMethods->xShmUnmap(p->pReal, delFlag);
+ return rc;
+}
+
+int QuotaFetch(sqlite3_file* pFile, sqlite3_int64 iOff, int iAmt, void** pp) {
+ QuotaFile* p = (QuotaFile*)pFile;
+ MOZ_ASSERT(p->pReal->pMethods->iVersion >= 3);
+ return p->pReal->pMethods->xFetch(p->pReal, iOff, iAmt, pp);
+}
+
+int QuotaUnfetch(sqlite3_file* pFile, sqlite3_int64 iOff, void* pResOut) {
+ QuotaFile* p = (QuotaFile*)pFile;
+ MOZ_ASSERT(p->pReal->pMethods->iVersion >= 3);
+ return p->pReal->pMethods->xUnfetch(p->pReal, iOff, pResOut);
+}
+
+int QuotaOpen(sqlite3_vfs* vfs, const char* zName, sqlite3_file* pFile,
+ int flags, int* pOutFlags) {
+ sqlite3_vfs* orig_vfs = static_cast<sqlite3_vfs*>(vfs->pAppData);
+ int rc;
+ QuotaFile* p = (QuotaFile*)pFile;
+
+ MaybeEstablishQuotaControl(zName, p, flags);
+
+ rc = orig_vfs->xOpen(orig_vfs, zName, p->pReal, flags, pOutFlags);
+ if (rc != SQLITE_OK) return rc;
+ if (p->pReal->pMethods) {
+ sqlite3_io_methods* pNew = new sqlite3_io_methods;
+ const sqlite3_io_methods* pSub = p->pReal->pMethods;
+ memset(pNew, 0, sizeof(*pNew));
+ // If the io_methods version is higher than the last known one, you should
+ // update this VFS adding appropriate IO methods for any methods added in
+ // the version change.
+ pNew->iVersion = pSub->iVersion;
+ MOZ_ASSERT(pNew->iVersion <= LAST_KNOWN_IOMETHODS_VERSION);
+ pNew->xClose = QuotaClose;
+ pNew->xRead = QuotaRead;
+ pNew->xWrite = QuotaWrite;
+ pNew->xTruncate = QuotaTruncate;
+ pNew->xSync = QuotaSync;
+ pNew->xFileSize = QuotaFileSize;
+ pNew->xLock = QuotaLock;
+ pNew->xUnlock = QuotaUnlock;
+ pNew->xCheckReservedLock = QuotaCheckReservedLock;
+ pNew->xFileControl = QuotaFileControl;
+ pNew->xSectorSize = QuotaSectorSize;
+ pNew->xDeviceCharacteristics = QuotaDeviceCharacteristics;
+ if (pNew->iVersion >= 2) {
+ // Methods added in version 2.
+ pNew->xShmMap = pSub->xShmMap ? QuotaShmMap : nullptr;
+ pNew->xShmLock = pSub->xShmLock ? QuotaShmLock : nullptr;
+ pNew->xShmBarrier = pSub->xShmBarrier ? QuotaShmBarrier : nullptr;
+ pNew->xShmUnmap = pSub->xShmUnmap ? QuotaShmUnmap : nullptr;
+ }
+ if (pNew->iVersion >= 3) {
+ // Methods added in version 3.
+ // SQLite 3.7.17 calls these methods without checking for nullptr first,
+ // so we always define them. Verify that we're not going to call
+ // nullptrs, though.
+ MOZ_ASSERT(pSub->xFetch);
+ pNew->xFetch = QuotaFetch;
+ MOZ_ASSERT(pSub->xUnfetch);
+ pNew->xUnfetch = QuotaUnfetch;
+ }
+ pFile->pMethods = pNew;
+ }
+ return rc;
+}
+
+int QuotaDelete(sqlite3_vfs* vfs, const char* zName, int syncDir) {
+ sqlite3_vfs* orig_vfs = static_cast<sqlite3_vfs*>(vfs->pAppData);
+ int rc;
+ RefPtr<QuotaObject> quotaObject;
+
+ if (StringEndsWith(nsDependentCString(zName), "-wal"_ns)) {
+ quotaObject = GetQuotaObjectFromName(zName);
+ }
+
+ rc = orig_vfs->xDelete(orig_vfs, zName, syncDir);
+ if (rc == SQLITE_OK && quotaObject) {
+ MOZ_ALWAYS_TRUE(quotaObject->MaybeUpdateSize(0, /* aTruncate */ true));
+ }
+
+ return rc;
+}
+
+int QuotaAccess(sqlite3_vfs* vfs, const char* zName, int flags, int* pResOut) {
+ sqlite3_vfs* orig_vfs = static_cast<sqlite3_vfs*>(vfs->pAppData);
+ return orig_vfs->xAccess(orig_vfs, zName, flags, pResOut);
+}
+
+int QuotaFullPathname(sqlite3_vfs* vfs, const char* zName, int nOut,
+ char* zOut) {
+#if defined(XP_WIN)
+ // SQLite uses GetFullPathnameW which also normailizes file path. If a file
+ // component ends with a dot, it would be removed. However, it's not desired.
+ //
+ // And that would result SQLite uses wrong database and quotaObject.
+ // Note that we are safe to avoid the GetFullPathnameW call for \\?\ prefixed
+ // paths.
+ // And note that this hack will be removed once the issue is fixed directly in
+ // SQLite.
+
+ // zName that starts with "//?/" is the case when a file URI was passed and
+ // zName that starts with "\\?\" is the case when a normal path was passed
+ // (not file URI).
+ if (StaticPrefs::dom_quotaManager_overrideXFullPathname() &&
+ ((zName[0] == '/' && zName[1] == '/' && zName[2] == '?' &&
+ zName[3] == '/') ||
+ (zName[0] == '\\' && zName[1] == '\\' && zName[2] == '?' &&
+ zName[3] == '\\'))) {
+ MOZ_ASSERT(nOut >= vfs->mxPathname);
+ MOZ_ASSERT(static_cast<size_t>(nOut) > strlen(zName));
+
+ size_t index = 0;
+ while (zName[index] != '\0') {
+ if (zName[index] == '/') {
+ zOut[index] = '\\';
+ } else {
+ zOut[index] = zName[index];
+ }
+
+ index++;
+ }
+ zOut[index] = '\0';
+
+ return SQLITE_OK;
+ }
+#elif defined(XP_UNIX)
+ // SQLite canonicalizes (resolves path components) file paths on Unix which
+ // doesn't work well with file path sanity checks in quota manager. This is
+ // especially a problem on mac where /var is a symlink to /private/var.
+ // Since QuotaVFS is used only by quota clients which never access databases
+ // outside of PROFILE/storage, we override Unix xFullPathname with own
+ // implementation that doesn't do any canonicalization.
+
+ if (StaticPrefs::dom_quotaManager_overrideXFullPathnameUnix()) {
+ if (nOut < 0) {
+ // Match the return code used by SQLite's xFullPathname implementation
+ // here and below.
+ return SQLITE_CANTOPEN;
+ }
+
+ QM_TRY_INSPECT(
+ const auto& path, ([&zName]() -> Result<nsString, nsresult> {
+ NS_ConvertUTF8toUTF16 name(zName);
+
+ if (name.First() == '/') {
+ return std::move(name);
+ }
+
+ QM_TRY_INSPECT(const auto& file,
+ MOZ_TO_RESULT_INVOKE_TYPED(nsCOMPtr<nsIFile>,
+ NS_GetSpecialDirectory,
+ NS_OS_CURRENT_WORKING_DIR));
+
+ QM_TRY(MOZ_TO_RESULT(file->Append(name)));
+
+ QM_TRY_RETURN(
+ MOZ_TO_RESULT_INVOKE_MEMBER_TYPED(nsString, file, GetPath));
+ }()),
+ SQLITE_CANTOPEN);
+
+ QM_TRY_INSPECT(const auto& quotaFile, QM_NewLocalFile(path),
+ SQLITE_CANTOPEN);
+
+ QM_TRY_INSPECT(
+ const auto& quotaPath,
+ MOZ_TO_RESULT_INVOKE_MEMBER_TYPED(nsString, quotaFile, GetPath),
+ SQLITE_CANTOPEN);
+
+ NS_ConvertUTF16toUTF8 sqlitePath(quotaPath);
+
+ if (sqlitePath.Length() > (unsigned int)nOut) {
+ return SQLITE_CANTOPEN;
+ }
+
+ nsCharTraits<char>::copy(zOut, sqlitePath.get(), sqlitePath.Length());
+ zOut[sqlitePath.Length()] = '\0';
+
+ return SQLITE_OK;
+ }
+#endif
+
+ sqlite3_vfs* orig_vfs = static_cast<sqlite3_vfs*>(vfs->pAppData);
+ return orig_vfs->xFullPathname(orig_vfs, zName, nOut, zOut);
+}
+
+void* QuotaDlOpen(sqlite3_vfs* vfs, const char* zFilename) {
+ sqlite3_vfs* orig_vfs = static_cast<sqlite3_vfs*>(vfs->pAppData);
+ return orig_vfs->xDlOpen(orig_vfs, zFilename);
+}
+
+void QuotaDlError(sqlite3_vfs* vfs, int nByte, char* zErrMsg) {
+ sqlite3_vfs* orig_vfs = static_cast<sqlite3_vfs*>(vfs->pAppData);
+ orig_vfs->xDlError(orig_vfs, nByte, zErrMsg);
+}
+
+void (*QuotaDlSym(sqlite3_vfs* vfs, void* pHdle, const char* zSym))(void) {
+ sqlite3_vfs* orig_vfs = static_cast<sqlite3_vfs*>(vfs->pAppData);
+ return orig_vfs->xDlSym(orig_vfs, pHdle, zSym);
+}
+
+void QuotaDlClose(sqlite3_vfs* vfs, void* pHandle) {
+ sqlite3_vfs* orig_vfs = static_cast<sqlite3_vfs*>(vfs->pAppData);
+ orig_vfs->xDlClose(orig_vfs, pHandle);
+}
+
+int QuotaRandomness(sqlite3_vfs* vfs, int nByte, char* zOut) {
+ sqlite3_vfs* orig_vfs = static_cast<sqlite3_vfs*>(vfs->pAppData);
+ return orig_vfs->xRandomness(orig_vfs, nByte, zOut);
+}
+
+int QuotaSleep(sqlite3_vfs* vfs, int microseconds) {
+ sqlite3_vfs* orig_vfs = static_cast<sqlite3_vfs*>(vfs->pAppData);
+ return orig_vfs->xSleep(orig_vfs, microseconds);
+}
+
+int QuotaCurrentTime(sqlite3_vfs* vfs, double* prNow) {
+ sqlite3_vfs* orig_vfs = static_cast<sqlite3_vfs*>(vfs->pAppData);
+ return orig_vfs->xCurrentTime(orig_vfs, prNow);
+}
+
+int QuotaGetLastError(sqlite3_vfs* vfs, int nBuf, char* zBuf) {
+ sqlite3_vfs* orig_vfs = static_cast<sqlite3_vfs*>(vfs->pAppData);
+ return orig_vfs->xGetLastError(orig_vfs, nBuf, zBuf);
+}
+
+int QuotaCurrentTimeInt64(sqlite3_vfs* vfs, sqlite3_int64* piNow) {
+ sqlite3_vfs* orig_vfs = static_cast<sqlite3_vfs*>(vfs->pAppData);
+ return orig_vfs->xCurrentTimeInt64(orig_vfs, piNow);
+}
+
+static int QuotaSetSystemCall(sqlite3_vfs* vfs, const char* zName,
+ sqlite3_syscall_ptr pFunc) {
+ sqlite3_vfs* orig_vfs = static_cast<sqlite3_vfs*>(vfs->pAppData);
+ return orig_vfs->xSetSystemCall(orig_vfs, zName, pFunc);
+}
+
+static sqlite3_syscall_ptr QuotaGetSystemCall(sqlite3_vfs* vfs,
+ const char* zName) {
+ sqlite3_vfs* orig_vfs = static_cast<sqlite3_vfs*>(vfs->pAppData);
+ return orig_vfs->xGetSystemCall(orig_vfs, zName);
+}
+
+static const char* QuotaNextSystemCall(sqlite3_vfs* vfs, const char* zName) {
+ sqlite3_vfs* orig_vfs = static_cast<sqlite3_vfs*>(vfs->pAppData);
+ return orig_vfs->xNextSystemCall(orig_vfs, zName);
+}
+
+} // namespace
+
+namespace mozilla {
+namespace storage {
+
+const char* GetQuotaVFSName() { return "quotavfs"; }
+
+UniquePtr<sqlite3_vfs> ConstructQuotaVFS(const char* aBaseVFSName) {
+ MOZ_ASSERT(aBaseVFSName);
+
+ if (sqlite3_vfs_find(GetQuotaVFSName()) != nullptr) {
+ return nullptr;
+ }
+ sqlite3_vfs* vfs = sqlite3_vfs_find(aBaseVFSName);
+ if (!vfs) {
+ return nullptr;
+ }
+
+ auto qvfs = MakeUnique<sqlite3_vfs>();
+ memset(qvfs.get(), 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.
+ qvfs->iVersion = vfs->iVersion;
+ MOZ_ASSERT(vfs->iVersion <= LAST_KNOWN_VFS_VERSION);
+ qvfs->szOsFile = static_cast<int>(sizeof(QuotaFile) - sizeof(sqlite3_file) +
+ vfs->szOsFile);
+ qvfs->mxPathname = vfs->mxPathname;
+ qvfs->zName = GetQuotaVFSName();
+ qvfs->pAppData = vfs;
+ qvfs->xOpen = QuotaOpen;
+ qvfs->xDelete = QuotaDelete;
+ qvfs->xAccess = QuotaAccess;
+ qvfs->xFullPathname = QuotaFullPathname;
+ qvfs->xDlOpen = QuotaDlOpen;
+ qvfs->xDlError = QuotaDlError;
+ qvfs->xDlSym = QuotaDlSym;
+ qvfs->xDlClose = QuotaDlClose;
+ qvfs->xRandomness = QuotaRandomness;
+ qvfs->xSleep = QuotaSleep;
+ qvfs->xCurrentTime = QuotaCurrentTime;
+ qvfs->xGetLastError = QuotaGetLastError;
+ if (qvfs->iVersion >= 2) {
+ // Methods added in version 2.
+ qvfs->xCurrentTimeInt64 = QuotaCurrentTimeInt64;
+ }
+ if (qvfs->iVersion >= 3) {
+ // Methods added in version 3.
+ qvfs->xSetSystemCall = QuotaSetSystemCall;
+ qvfs->xGetSystemCall = QuotaGetSystemCall;
+ qvfs->xNextSystemCall = QuotaNextSystemCall;
+ }
+ return qvfs;
+}
+
+already_AddRefed<QuotaObject> GetQuotaObjectForFile(sqlite3_file* pFile) {
+ MOZ_ASSERT(pFile);
+
+ QuotaFile* p = (QuotaFile*)pFile;
+ RefPtr<QuotaObject> result = p->quotaObject;
+ return result.forget();
+}
+
+} // namespace storage
+} // namespace mozilla