1 files changed, 258 insertions, 0 deletions
diff --git a/src/plugins/sqldrivers/sqlite/qsql_sqlite_vfs.cpp b/src/plugins/sqldrivers/sqlite/qsql_sqlite_vfs.cpp
new file mode 100644
index 0000000000..bbba3cd14f
--- /dev/null
+++ b/src/plugins/sqldrivers/sqlite/qsql_sqlite_vfs.cpp
@@ -0,0 +1,258 @@
+// Copyright (C) 2023 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+
+#include "qsql_sqlite_vfs_p.h"
+
+#include <QFile>
+
+#include <limits.h> // defines PATH_MAX on unix
+#include <sqlite3.h>
+#include <stdio.h> // defines FILENAME_MAX everywhere
+
+#ifndef PATH_MAX
+#  define PATH_MAX FILENAME_MAX
+#endif
+#if SQLITE_VERSION_NUMBER < 3040000
+typedef const char *sqlite3_filename;
+#endif
+
+namespace {
+struct Vfs : sqlite3_vfs {
+    sqlite3_vfs *pVfs;
+    sqlite3_io_methods ioMethods;
+};
+
+struct File : sqlite3_file {
+    class QtFile : public QFile {
+    public:
+        QtFile(const QString &name, bool removeOnClose)
+            : QFile(name)
+            , removeOnClose(removeOnClose)
+        {}
+
+        ~QtFile() override
+        {
+            if (removeOnClose)
+                remove();
+        }
+    private:
+        bool removeOnClose;
+    };
+    QtFile *pFile;
+};
+
+
+int xClose(sqlite3_file *sfile)
+{
+    auto file = static_cast<File *>(sfile);
+    delete file->pFile;
+    file->pFile = nullptr;
+    return SQLITE_OK;
+}
+
+int xRead(sqlite3_file *sfile, void *ptr, int iAmt, sqlite3_int64 iOfst)
+{
+    auto file = static_cast<File *>(sfile);
+    if (!file->pFile->seek(iOfst))
+        return SQLITE_IOERR_READ;
+
+    auto sz = file->pFile->read(static_cast<char *>(ptr), iAmt);
+    if (sz < iAmt) {
+        memset(static_cast<char *>(ptr) + sz, 0, size_t(iAmt - sz));
+        return SQLITE_IOERR_SHORT_READ;
+    }
+    return SQLITE_OK;
+}
+
+int xWrite(sqlite3_file *sfile, const void *data, int iAmt, sqlite3_int64 iOfst)
+{
+    auto file = static_cast<File *>(sfile);
+    if (!file->pFile->seek(iOfst))
+        return SQLITE_IOERR_SEEK;
+    return file->pFile->write(reinterpret_cast<const char*>(data), iAmt) == iAmt ? SQLITE_OK : SQLITE_IOERR_WRITE;
+}
+
+int xTruncate(sqlite3_file *sfile, sqlite3_int64 size)
+{
+    auto file = static_cast<File *>(sfile);
+    return file->pFile->resize(size) ? SQLITE_OK : SQLITE_IOERR_TRUNCATE;
+}
+
+int xSync(sqlite3_file *sfile, int /*flags*/)
+{
+    static_cast<File *>(sfile)->pFile->flush();
+    return SQLITE_OK;
+}
+
+int xFileSize(sqlite3_file *sfile, sqlite3_int64 *pSize)
+{
+    auto file = static_cast<File *>(sfile);
+    *pSize = file->pFile->size();
+    return SQLITE_OK;
+}
+
+// No lock/unlock for QFile, QLockFile doesn't work for me
+
+int xLock(sqlite3_file *, int) { return SQLITE_OK; }
+
+int xUnlock(sqlite3_file *, int) { return SQLITE_OK; }
+
+int xCheckReservedLock(sqlite3_file *, int *pResOut)
+{
+    *pResOut = 0;
+    return SQLITE_OK;
+}
+
+int xFileControl(sqlite3_file *, int, void *) { return SQLITE_NOTFOUND; }
+
+int xSectorSize(sqlite3_file *)
+{
+    return 4096;
+}
+
+int xDeviceCharacteristics(sqlite3_file *)
+{
+    return 0; // no SQLITE_IOCAP_XXX
+}
+
+int xOpen(sqlite3_vfs *svfs, sqlite3_filename zName, sqlite3_file *sfile,
+          int flags, int *pOutFlags)
+{
+    auto vfs = static_cast<Vfs *>(svfs);
+    auto file = static_cast<File *>(sfile);
+    memset(file, 0, sizeof(File));
+    QIODeviceBase::OpenMode mode = QIODeviceBase::NotOpen;
+    if (!zName || (flags & SQLITE_OPEN_MEMORY))
+        return SQLITE_PERM;
+    if ((flags & SQLITE_OPEN_READONLY) &&
+        !(flags & SQLITE_OPEN_READWRITE) &&
+        !(flags & SQLITE_OPEN_CREATE) &&
+        !(flags & SQLITE_OPEN_DELETEONCLOSE)) {
+        mode |= QIODeviceBase::OpenModeFlag::ReadOnly;
+    } else {
+        /*
+            ** ^The [SQLITE_OPEN_EXCLUSIVE] flag is always used in conjunction
+            ** with the [SQLITE_OPEN_CREATE] flag, which are both directly
+            ** analogous to the O_EXCL and O_CREAT flags of the POSIX open()
+            ** API.  The SQLITE_OPEN_EXCLUSIVE flag, when paired with the
+            ** SQLITE_OPEN_CREATE, is used to indicate that file should always
+            ** be created, and that it is an error if it already exists.
+            ** It is <i>not</i> used to indicate the file should be opened
+            ** for exclusive access.
+         */
+        if ((flags & SQLITE_OPEN_CREATE) && (flags & SQLITE_OPEN_EXCLUSIVE))
+            mode |= QIODeviceBase::OpenModeFlag::NewOnly;
+
+        if (flags & SQLITE_OPEN_READWRITE)
+            mode |= QIODeviceBase::OpenModeFlag::ReadWrite;
+    }
+
+    file->pMethods = &vfs->ioMethods;
+    file->pFile = new File::QtFile(QString::fromUtf8(zName), bool(flags & SQLITE_OPEN_DELETEONCLOSE));
+    if (!file->pFile->open(mode))
+        return SQLITE_CANTOPEN;
+    if (pOutFlags)
+        *pOutFlags = flags;
+
+    return SQLITE_OK;
+}
+
+int xDelete(sqlite3_vfs *, const char *zName, int)
+{
+    return QFile::remove(QString::fromUtf8(zName)) ? SQLITE_OK : SQLITE_ERROR;
+}
+
+int xAccess(sqlite3_vfs */*svfs*/, const char *zName, int flags, int *pResOut)
+{
+    *pResOut = 0;
+    switch (flags) {
+    case SQLITE_ACCESS_EXISTS:
+    case SQLITE_ACCESS_READ:
+        *pResOut = QFile::exists(QString::fromUtf8(zName));
+        break;
+    default:
+        break;
+    }
+    return SQLITE_OK;
+}
+
+int xFullPathname(sqlite3_vfs *, const char *zName, int nOut, char *zOut)
+{
+    if (!zName)
+        return SQLITE_ERROR;
+
+    int i = 0;
+    for (;zName[i] && i < nOut; ++i)
+        zOut[i] = zName[i];
+
+    if (i >= nOut)
+        return SQLITE_ERROR;
+
+    zOut[i] = '\0';
+    return SQLITE_OK;
+}
+
+int xRandomness(sqlite3_vfs *svfs, int nByte, char *zOut)
+{
+    auto vfs = static_cast<Vfs *>(svfs)->pVfs;
+    return vfs->xRandomness(vfs, nByte, zOut);
+}
+
+int xSleep(sqlite3_vfs *svfs, int microseconds)
+{
+    auto vfs = static_cast<Vfs *>(svfs)->pVfs;
+    return vfs->xSleep(vfs, microseconds);
+}
+
+int xCurrentTime(sqlite3_vfs *svfs, double *zOut)
+{
+    auto vfs = static_cast<Vfs *>(svfs)->pVfs;
+    return vfs->xCurrentTime(vfs, zOut);
+}
+
+int xGetLastError(sqlite3_vfs *, int, char *)
+{
+   return 0;
+}
+
+int xCurrentTimeInt64(sqlite3_vfs *svfs, sqlite3_int64 *zOut)
+{
+   auto vfs = static_cast<Vfs *>(svfs)->pVfs;
+   return vfs->xCurrentTimeInt64(vfs, zOut);
+}
+} // namespace {
+
+void register_qt_vfs()
+{
+    static Vfs vfs;
+    memset(&vfs, 0, sizeof(Vfs));
+    vfs.iVersion = 1;
+    vfs.szOsFile = sizeof(File);
+    vfs.mxPathname = PATH_MAX;
+    vfs.zName = "QtVFS";
+    vfs.xOpen = &xOpen;
+    vfs.xDelete = &xDelete;
+    vfs.xAccess = &xAccess;
+    vfs.xFullPathname = &xFullPathname;
+    vfs.xRandomness = &xRandomness;
+    vfs.xSleep = &xSleep;
+    vfs.xCurrentTime = &xCurrentTime;
+    vfs.xGetLastError = &xGetLastError;
+    vfs.xCurrentTimeInt64 = &xCurrentTimeInt64;
+    vfs.pVfs = sqlite3_vfs_find(nullptr);
+    vfs.ioMethods.iVersion = 1;
+    vfs.ioMethods.xClose = &xClose;
+    vfs.ioMethods.xRead = &xRead;
+    vfs.ioMethods.xWrite = &xWrite;
+    vfs.ioMethods.xTruncate = &xTruncate;
+    vfs.ioMethods.xSync = &xSync;
+    vfs.ioMethods.xFileSize = &xFileSize;
+    vfs.ioMethods.xLock = &xLock;
+    vfs.ioMethods.xUnlock = &xUnlock;
+    vfs.ioMethods.xCheckReservedLock = &xCheckReservedLock;
+    vfs.ioMethods.xFileControl = &xFileControl;
+    vfs.ioMethods.xSectorSize = &xSectorSize;
+    vfs.ioMethods.xDeviceCharacteristics = &xDeviceCharacteristics;
+
+    sqlite3_vfs_register(&vfs, 0);
+}