#include "config.h"
#include "Database.h"
#include "ChangeVersionData.h"
#include "ChangeVersionWrapper.h"
#include "DOMWindow.h"
#include "DatabaseAuthorizer.h"
#include "DatabaseCallback.h"
#include "DatabaseContext.h"
#include "DatabaseManager.h"
#include "DatabaseTask.h"
#include "DatabaseThread.h"
#include "DatabaseTracker.h"
#include "Document.h"
#include "JSDOMWindow.h"
#include "Logging.h"
#include "Page.h"
#include "SQLError.h"
#include "SQLTransaction.h"
#include "SQLTransactionCallback.h"
#include "SQLTransactionErrorCallback.h"
#include "SQLiteDatabaseTracker.h"
#include "SQLiteStatement.h"
#include "SQLiteTransaction.h"
#include "ScriptExecutionContext.h"
#include "SecurityOrigin.h"
#include "VoidCallback.h"
#include <wtf/NeverDestroyed.h>
#include <wtf/PassRefPtr.h>
#include <wtf/RefPtr.h>
#include <wtf/StdLibExtras.h>
#include <wtf/text/CString.h>
namespace WebCore {
static const char versionKey[] = "WebKitDatabaseVersionKey";
static const char unqualifiedInfoTableName[] = "__WebKitDatabaseInfoTable__";
static const char* fullyQualifiedInfoTableName()
{
static const char qualifier[] = "main.";
static char qualifiedName[sizeof(qualifier) + sizeof(unqualifiedInfoTableName) - 1];
static std::once_flag onceFlag;
std::call_once(onceFlag, [] {
strcpy(qualifiedName, qualifier);
strcpy(qualifiedName + sizeof(qualifier) - 1, unqualifiedInfoTableName);
});
return qualifiedName;
}
static String formatErrorMessage(const char* message, int sqliteErrorCode, const char* sqliteErrorMessage)
{
return String::format("%s (%d %s)", message, sqliteErrorCode, sqliteErrorMessage);
}
static bool setTextValueInDatabase(SQLiteDatabase& db, const String& query, const String& value)
{
SQLiteStatement statement(db, query);
int result = statement.prepare();
if (result != SQLITE_OK) {
LOG_ERROR("Failed to prepare statement to set value in database (%s)", query.ascii().data());
return false;
}
statement.bindText(1, value);
result = statement.step();
if (result != SQLITE_DONE) {
LOG_ERROR("Failed to step statement to set value in database (%s)", query.ascii().data());
return false;
}
return true;
}
static bool retrieveTextResultFromDatabase(SQLiteDatabase& db, const String& query, String& resultString)
{
SQLiteStatement statement(db, query);
int result = statement.prepare();
if (result != SQLITE_OK) {
LOG_ERROR("Error (%i) preparing statement to read text result from database (%s)", result, query.ascii().data());
return false;
}
result = statement.step();
if (result == SQLITE_ROW) {
resultString = statement.getColumnText(0);
return true;
}
if (result == SQLITE_DONE) {
resultString = String();
return true;
}
LOG_ERROR("Error (%i) reading text result from database (%s)", result, query.ascii().data());
return false;
}
static StaticLock guidMutex;
typedef HashMap<DatabaseGuid, String> GuidVersionMap;
static GuidVersionMap& guidToVersionMap()
{
static NeverDestroyed<GuidVersionMap> map;
return map;
}
static inline void updateGuidVersionMap(DatabaseGuid guid, String newVersion)
{
guidToVersionMap().set(guid, newVersion.isEmpty() ? String() : newVersion.isolatedCopy());
}
typedef HashMap<DatabaseGuid, std::unique_ptr<HashSet<Database*>>> GuidDatabaseMap;
static GuidDatabaseMap& guidToDatabaseMap()
{
static NeverDestroyed<GuidDatabaseMap> map;
return map;
}
static DatabaseGuid guidForOriginAndName(const String& origin, const String& name)
{
String stringID = origin + "/" + name;
static NeverDestroyed<HashMap<String, int>> map;
DatabaseGuid guid = map.get().get(stringID);
if (!guid) {
static int currentNewGUID = 1;
guid = currentNewGUID++;
map.get().set(stringID, guid);
}
return guid;
}
Database::Database(RefPtr<DatabaseContext>&& databaseContext, const String& name, const String& expectedVersion, const String& displayName, unsigned long estimatedSize)
: m_scriptExecutionContext(databaseContext->scriptExecutionContext())
, m_databaseContext(WTFMove(databaseContext))
, m_deleted(false)
, m_name(name.isolatedCopy())
, m_expectedVersion(expectedVersion.isolatedCopy())
, m_displayName(displayName.isolatedCopy())
, m_estimatedSize(estimatedSize)
, m_opened(false)
, m_new(false)
, m_transactionInProgress(false)
, m_isTransactionQueueEnabled(true)
{
m_contextThreadSecurityOrigin = m_databaseContext->securityOrigin()->isolatedCopy();
m_databaseAuthorizer = DatabaseAuthorizer::create(unqualifiedInfoTableName);
if (m_name.isNull())
m_name = emptyString();
{
std::lock_guard<StaticLock> locker(guidMutex);
m_guid = guidForOriginAndName(securityOrigin()->toString(), name);
std::unique_ptr<HashSet<Database*>>& hashSet = guidToDatabaseMap().add(m_guid, nullptr).iterator->value;
if (!hashSet)
hashSet = std::make_unique<HashSet<Database*>>();
hashSet->add(this);
}
m_filename = DatabaseManager::singleton().fullPathForDatabase(securityOrigin(), m_name);
m_databaseThreadSecurityOrigin = m_contextThreadSecurityOrigin->isolatedCopy();
ASSERT(m_databaseContext->databaseThread());
}
Database::~Database()
{
if (!m_scriptExecutionContext->isContextThread()) {
PassRefPtr<ScriptExecutionContext> passedContext = m_scriptExecutionContext.release();
passedContext->postTask({ScriptExecutionContext::Task::CleanupTask, [passedContext] (ScriptExecutionContext& context) {
ASSERT_UNUSED(context, &context == passedContext);
RefPtr<ScriptExecutionContext> scriptExecutionContext(passedContext);
}});
}
ASSERT(!m_opened);
}
bool Database::openAndVerifyVersion(bool setVersionInNewDatabase, DatabaseError& error, String& errorMessage)
{
DatabaseTaskSynchronizer synchronizer;
if (!databaseContext()->databaseThread() || databaseContext()->databaseThread()->terminationRequested(&synchronizer))
return false;
bool success = false;
auto task = std::make_unique<DatabaseOpenTask>(*this, setVersionInNewDatabase, synchronizer, error, errorMessage, success);
databaseContext()->databaseThread()->scheduleImmediateTask(WTFMove(task));
synchronizer.waitForTaskCompletion();
return success;
}
void Database::interrupt()
{
m_sqliteDatabase.interrupt();
}
void Database::close()
{
if (!databaseContext()->databaseThread())
return;
DatabaseTaskSynchronizer synchronizer;
if (databaseContext()->databaseThread()->terminationRequested(&synchronizer)) {
LOG(StorageAPI, "Database handle %p is on a terminated DatabaseThread, cannot be marked for normal closure\n", this);
return;
}
databaseContext()->databaseThread()->scheduleImmediateTask(std::make_unique<DatabaseCloseTask>(*this, synchronizer));
synchronizer.waitForTaskCompletion();
}
void Database::performClose()
{
ASSERT(databaseContext()->databaseThread());
ASSERT(currentThread() == databaseContext()->databaseThread()->getThreadID());
{
LockHolder locker(m_transactionInProgressMutex);
RefPtr<SQLTransactionBackend> transaction;
while (!m_transactionQueue.isEmpty()) {
transaction = m_transactionQueue.takeFirst();
transaction->notifyDatabaseThreadIsShuttingDown();
}
m_isTransactionQueueEnabled = false;
m_transactionInProgress = false;
}
closeDatabase();
Ref<Database> protectedThis(*this);
databaseContext()->databaseThread()->recordDatabaseClosed(this);
databaseContext()->databaseThread()->unscheduleDatabaseTasks(this);
}
class DoneCreatingDatabaseOnExitCaller {
public:
DoneCreatingDatabaseOnExitCaller(Database* database)
: m_database(database)
, m_openSucceeded(false)
{
}
~DoneCreatingDatabaseOnExitCaller()
{
DatabaseTracker::tracker().doneCreatingDatabase(m_database);
}
void setOpenSucceeded() { m_openSucceeded = true; }
private:
Database* m_database;
bool m_openSucceeded;
};
bool Database::performOpenAndVerify(bool shouldSetVersionInNewDatabase, DatabaseError& error, String& errorMessage)
{
DoneCreatingDatabaseOnExitCaller onExitCaller(this);
ASSERT(errorMessage.isEmpty());
ASSERT(error == DatabaseError::None); error = DatabaseError::InvalidDatabaseState;
const int maxSqliteBusyWaitTime = 30000;
#if PLATFORM(IOS)
{
LockHolder locker(DatabaseTracker::openDatabaseMutex());
}
#endif
SQLiteTransactionInProgressAutoCounter transactionCounter;
if (!m_sqliteDatabase.open(m_filename, true)) {
errorMessage = formatErrorMessage("unable to open database", m_sqliteDatabase.lastError(), m_sqliteDatabase.lastErrorMsg());
return false;
}
if (!m_sqliteDatabase.turnOnIncrementalAutoVacuum())
LOG_ERROR("Unable to turn on incremental auto-vacuum (%d %s)", m_sqliteDatabase.lastError(), m_sqliteDatabase.lastErrorMsg());
m_sqliteDatabase.setBusyTimeout(maxSqliteBusyWaitTime);
String currentVersion;
{
std::lock_guard<StaticLock> locker(guidMutex);
auto entry = guidToVersionMap().find(m_guid);
if (entry != guidToVersionMap().end()) {
currentVersion = entry->value.isNull() ? emptyString() : entry->value.isolatedCopy();
LOG(StorageAPI, "Current cached version for guid %i is %s", m_guid, currentVersion.ascii().data());
} else {
LOG(StorageAPI, "No cached version for guid %i", m_guid);
SQLiteTransaction transaction(m_sqliteDatabase);
transaction.begin();
if (!transaction.inProgress()) {
errorMessage = formatErrorMessage("unable to open database, failed to start transaction", m_sqliteDatabase.lastError(), m_sqliteDatabase.lastErrorMsg());
m_sqliteDatabase.close();
return false;
}
String tableName(unqualifiedInfoTableName);
if (!m_sqliteDatabase.tableExists(tableName)) {
m_new = true;
if (!m_sqliteDatabase.executeCommand("CREATE TABLE " + tableName + " (key TEXT NOT NULL ON CONFLICT FAIL UNIQUE ON CONFLICT REPLACE,value TEXT NOT NULL ON CONFLICT FAIL);")) {
errorMessage = formatErrorMessage("unable to open database, failed to create 'info' table", m_sqliteDatabase.lastError(), m_sqliteDatabase.lastErrorMsg());
transaction.rollback();
m_sqliteDatabase.close();
return false;
}
} else if (!getVersionFromDatabase(currentVersion, false)) {
errorMessage = formatErrorMessage("unable to open database, failed to read current version", m_sqliteDatabase.lastError(), m_sqliteDatabase.lastErrorMsg());
transaction.rollback();
m_sqliteDatabase.close();
return false;
}
if (currentVersion.length()) {
LOG(StorageAPI, "Retrieved current version %s from database %s", currentVersion.ascii().data(), databaseDebugName().ascii().data());
} else if (!m_new || shouldSetVersionInNewDatabase) {
LOG(StorageAPI, "Setting version %s in database %s that was just created", m_expectedVersion.ascii().data(), databaseDebugName().ascii().data());
if (!setVersionInDatabase(m_expectedVersion, false)) {
errorMessage = formatErrorMessage("unable to open database, failed to write current version", m_sqliteDatabase.lastError(), m_sqliteDatabase.lastErrorMsg());
transaction.rollback();
m_sqliteDatabase.close();
return false;
}
currentVersion = m_expectedVersion;
}
updateGuidVersionMap(m_guid, currentVersion);
transaction.commit();
}
}
if (currentVersion.isNull()) {
LOG(StorageAPI, "Database %s does not have its version set", databaseDebugName().ascii().data());
currentVersion = emptyString();
}
if ((!m_new || shouldSetVersionInNewDatabase) && m_expectedVersion.length() && m_expectedVersion != currentVersion) {
errorMessage = "unable to open database, version mismatch, '" + m_expectedVersion + "' does not match the currentVersion of '" + currentVersion + "'";
m_sqliteDatabase.close();
return false;
}
ASSERT(m_databaseAuthorizer);
m_sqliteDatabase.setAuthorizer(m_databaseAuthorizer);
DatabaseTracker::tracker().addOpenDatabase(static_cast<Database*>(this));
m_opened = true;
error = DatabaseError::None; onExitCaller.setOpenSucceeded();
if (m_new && !shouldSetVersionInNewDatabase)
m_expectedVersion = emptyString();
if (databaseContext()->databaseThread())
databaseContext()->databaseThread()->recordDatabaseOpen(this);
return true;
}
void Database::closeDatabase()
{
if (!m_opened)
return;
m_sqliteDatabase.close();
m_opened = false;
DatabaseTracker::tracker().removeOpenDatabase(this);
{
std::lock_guard<StaticLock> locker(guidMutex);
auto it = guidToDatabaseMap().find(m_guid);
ASSERT(it != guidToDatabaseMap().end());
ASSERT(it->value);
ASSERT(it->value->contains(this));
it->value->remove(this);
if (it->value->isEmpty()) {
guidToDatabaseMap().remove(it);
guidToVersionMap().remove(m_guid);
}
}
}
bool Database::getVersionFromDatabase(String& version, bool shouldCacheVersion)
{
String query(String("SELECT value FROM ") + fullyQualifiedInfoTableName() + " WHERE key = '" + versionKey + "';");
m_databaseAuthorizer->disable();
bool result = retrieveTextResultFromDatabase(m_sqliteDatabase, query, version);
if (result) {
if (shouldCacheVersion)
setCachedVersion(version);
} else
LOG_ERROR("Failed to retrieve version from database %s", databaseDebugName().ascii().data());
m_databaseAuthorizer->enable();
return result;
}
bool Database::setVersionInDatabase(const String& version, bool shouldCacheVersion)
{
String query(String("INSERT INTO ") + fullyQualifiedInfoTableName() + " (key, value) VALUES ('" + versionKey + "', ?);");
m_databaseAuthorizer->disable();
bool result = setTextValueInDatabase(m_sqliteDatabase, query, version);
if (result) {
if (shouldCacheVersion)
setCachedVersion(version);
} else
LOG_ERROR("Failed to set version %s in database (%s)", version.ascii().data(), query.ascii().data());
m_databaseAuthorizer->enable();
return result;
}
void Database::setExpectedVersion(const String& version)
{
m_expectedVersion = version.isolatedCopy();
}
String Database::getCachedVersion() const
{
std::lock_guard<StaticLock> locker(guidMutex);
return guidToVersionMap().get(m_guid).isolatedCopy();
}
void Database::setCachedVersion(const String& actualVersion)
{
std::lock_guard<StaticLock> locker(guidMutex);
updateGuidVersionMap(m_guid, actualVersion);
}
bool Database::getActualVersionForTransaction(String &actualVersion)
{
ASSERT(m_sqliteDatabase.transactionInProgress());
return getVersionFromDatabase(actualVersion, true);
}
void Database::scheduleTransaction()
{
ASSERT(!m_transactionInProgressMutex.tryLock()); RefPtr<SQLTransactionBackend> transaction;
if (m_isTransactionQueueEnabled && !m_transactionQueue.isEmpty())
transaction = m_transactionQueue.takeFirst();
if (transaction && databaseContext()->databaseThread()) {
auto task = std::make_unique<DatabaseTransactionTask>(WTFMove(transaction));
LOG(StorageAPI, "Scheduling DatabaseTransactionTask %p for transaction %p\n", task.get(), task->transaction());
m_transactionInProgress = true;
databaseContext()->databaseThread()->scheduleTask(WTFMove(task));
} else
m_transactionInProgress = false;
}
RefPtr<SQLTransactionBackend> Database::runTransaction(Ref<SQLTransaction>&& transaction, bool readOnly, const ChangeVersionData* data)
{
LockHolder locker(m_transactionInProgressMutex);
if (!m_isTransactionQueueEnabled)
return nullptr;
RefPtr<SQLTransactionWrapper> wrapper;
if (data)
wrapper = ChangeVersionWrapper::create(data->oldVersion(), data->newVersion());
RefPtr<SQLTransactionBackend> transactionBackend = SQLTransactionBackend::create(this, WTFMove(transaction), WTFMove(wrapper), readOnly);
m_transactionQueue.append(transactionBackend);
if (!m_transactionInProgress)
scheduleTransaction();
return transactionBackend;
}
void Database::scheduleTransactionStep(SQLTransactionBackend* transaction)
{
if (!databaseContext()->databaseThread())
return;
auto task = std::make_unique<DatabaseTransactionTask>(transaction);
LOG(StorageAPI, "Scheduling DatabaseTransactionTask %p for the transaction step\n", task.get());
databaseContext()->databaseThread()->scheduleTask(WTFMove(task));
}
void Database::inProgressTransactionCompleted()
{
LockHolder locker(m_transactionInProgressMutex);
m_transactionInProgress = false;
scheduleTransaction();
}
bool Database::hasPendingTransaction()
{
LockHolder locker(m_transactionInProgressMutex);
return m_transactionInProgress || !m_transactionQueue.isEmpty();
}
SQLTransactionClient* Database::transactionClient() const
{
return databaseContext()->databaseThread()->transactionClient();
}
SQLTransactionCoordinator* Database::transactionCoordinator() const
{
return databaseContext()->databaseThread()->transactionCoordinator();
}
String Database::version() const
{
if (m_deleted)
return String();
return getCachedVersion();
}
void Database::markAsDeletedAndClose()
{
if (m_deleted || !databaseContext()->databaseThread())
return;
LOG(StorageAPI, "Marking %s (%p) as deleted", stringIdentifier().ascii().data(), this);
m_deleted = true;
close();
}
void Database::changeVersion(const String& oldVersion, const String& newVersion, RefPtr<SQLTransactionCallback>&& callback, RefPtr<SQLTransactionErrorCallback>&& errorCallback, RefPtr<VoidCallback>&& successCallback)
{
ChangeVersionData data(oldVersion, newVersion);
runTransaction(WTFMove(callback), WTFMove(errorCallback), WTFMove(successCallback), false, &data);
}
void Database::transaction(RefPtr<SQLTransactionCallback>&& callback, RefPtr<SQLTransactionErrorCallback>&& errorCallback, RefPtr<VoidCallback>&& successCallback)
{
runTransaction(WTFMove(callback), WTFMove(errorCallback), WTFMove(successCallback), false);
}
void Database::readTransaction(RefPtr<SQLTransactionCallback>&& callback, RefPtr<SQLTransactionErrorCallback>&& errorCallback, RefPtr<VoidCallback>&& successCallback)
{
runTransaction(WTFMove(callback), WTFMove(errorCallback), WTFMove(successCallback), true);
}
String Database::stringIdentifier() const
{
return m_name.isolatedCopy();
}
String Database::displayName() const
{
return m_displayName.isolatedCopy();
}
unsigned long Database::estimatedSize() const
{
return m_estimatedSize;
}
String Database::fileName() const
{
return m_filename.isolatedCopy();
}
DatabaseDetails Database::details() const
{
return DatabaseDetails(stringIdentifier(), displayName(), estimatedSize(), 0, 0, 0);
}
void Database::disableAuthorizer()
{
ASSERT(m_databaseAuthorizer);
m_databaseAuthorizer->disable();
}
void Database::enableAuthorizer()
{
ASSERT(m_databaseAuthorizer);
m_databaseAuthorizer->enable();
}
void Database::setAuthorizerPermissions(int permissions)
{
ASSERT(m_databaseAuthorizer);
m_databaseAuthorizer->setPermissions(permissions);
}
bool Database::lastActionChangedDatabase()
{
ASSERT(m_databaseAuthorizer);
return m_databaseAuthorizer->lastActionChangedDatabase();
}
bool Database::lastActionWasInsert()
{
ASSERT(m_databaseAuthorizer);
return m_databaseAuthorizer->lastActionWasInsert();
}
void Database::resetDeletes()
{
ASSERT(m_databaseAuthorizer);
m_databaseAuthorizer->resetDeletes();
}
bool Database::hadDeletes()
{
ASSERT(m_databaseAuthorizer);
return m_databaseAuthorizer->hadDeletes();
}
void Database::resetAuthorizer()
{
if (m_databaseAuthorizer)
m_databaseAuthorizer->reset();
}
void Database::runTransaction(RefPtr<SQLTransactionCallback>&& callback, RefPtr<SQLTransactionErrorCallback>&& errorCallback, RefPtr<VoidCallback>&& successCallback, bool readOnly, const ChangeVersionData* changeVersionData)
{
Ref<SQLTransaction> transaction = SQLTransaction::create(*this, WTFMove(callback), WTFMove(successCallback), errorCallback.copyRef(), readOnly);
RefPtr<SQLTransactionBackend> transactionBackend = runTransaction(WTFMove(transaction), readOnly, changeVersionData);
if (!transactionBackend && errorCallback) {
RefPtr<SQLTransactionErrorCallback> errorCallbackProtector = WTFMove(errorCallback);
m_scriptExecutionContext->postTask([errorCallbackProtector](ScriptExecutionContext&) {
errorCallbackProtector->handleEvent(SQLError::create(SQLError::UNKNOWN_ERR, "database has been closed").ptr());
});
}
}
void Database::scheduleTransactionCallback(SQLTransaction* transaction)
{
RefPtr<SQLTransaction> transactionProtector(transaction);
m_scriptExecutionContext->postTask([transactionProtector] (ScriptExecutionContext&) {
transactionProtector->performPendingCallback();
});
}
Vector<String> Database::performGetTableNames()
{
disableAuthorizer();
SQLiteStatement statement(sqliteDatabase(), "SELECT name FROM sqlite_master WHERE type='table';");
if (statement.prepare() != SQLITE_OK) {
LOG_ERROR("Unable to retrieve list of tables for database %s", databaseDebugName().ascii().data());
enableAuthorizer();
return Vector<String>();
}
Vector<String> tableNames;
int result;
while ((result = statement.step()) == SQLITE_ROW) {
String name = statement.getColumnText(0);
if (name != unqualifiedInfoTableName)
tableNames.append(name);
}
enableAuthorizer();
if (result != SQLITE_DONE) {
LOG_ERROR("Error getting tables for database %s", databaseDebugName().ascii().data());
return Vector<String>();
}
return tableNames;
}
void Database::incrementalVacuumIfNeeded()
{
SQLiteTransactionInProgressAutoCounter transactionCounter;
int64_t freeSpaceSize = m_sqliteDatabase.freeSpaceSize();
int64_t totalSize = m_sqliteDatabase.totalSize();
if (totalSize <= 10 * freeSpaceSize) {
int result = m_sqliteDatabase.runIncrementalVacuumCommand();
if (result != SQLITE_OK)
logErrorMessage(formatErrorMessage("error vacuuming database", result, m_sqliteDatabase.lastErrorMsg()));
}
}
void Database::logErrorMessage(const String& message)
{
m_scriptExecutionContext->addConsoleMessage(MessageSource::Storage, MessageLevel::Error, message);
}
Vector<String> Database::tableNames()
{
Vector<String> result;
DatabaseTaskSynchronizer synchronizer;
if (!databaseContext()->databaseThread() || databaseContext()->databaseThread()->terminationRequested(&synchronizer))
return result;
auto task = std::make_unique<DatabaseTableNamesTask>(*this, synchronizer, result);
databaseContext()->databaseThread()->scheduleImmediateTask(WTFMove(task));
synchronizer.waitForTaskCompletion();
return result;
}
SecurityOrigin* Database::securityOrigin() const
{
if (m_scriptExecutionContext->isContextThread())
return m_contextThreadSecurityOrigin.get();
if (currentThread() == databaseContext()->databaseThread()->getThreadID())
return m_databaseThreadSecurityOrigin.get();
return 0;
}
unsigned long long Database::maximumSize() const
{
return DatabaseTracker::tracker().getMaxSizeForDatabase(this);
}
#if !LOG_DISABLED || !ERROR_DISABLED
String Database::databaseDebugName() const
{
return m_contextThreadSecurityOrigin->toString() + "::" + m_name;
}
#endif
}