/* -*- 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 <stdio.h>

#include "nsError.h"

#include "nsIMutableArray.h"

#include "nsAutoPtr.h"

#include "nsIMemoryReporter.h"

#include "nsThreadUtils.h"

#include "nsIFile.h"

#include "nsIFileURL.h"

#include "mozilla/Telemetry.h"

#include "mozilla/Mutex.h"

#include "mozilla/CondVar.h"

#include "mozilla/Attributes.h"

#include "mozilla/ErrorNames.h"

#include "mozIStorageAggregateFunction.h"

#include "mozIStorageCompletionCallback.h"

#include "mozIStorageFunction.h"

#include "mozStorageAsyncStatementExecution.h"

#include "mozStorageSQLFunctions.h"

#include "mozStorageConnection.h"

#include "mozStorageService.h"

#include "mozStorageStatement.h"

#include "mozStorageAsyncStatement.h"

#include "mozStorageArgValueArray.h"

#include "mozStoragePrivateHelpers.h"

#include "mozStorageStatementData.h"

#include "StorageBaseStatementInternal.h"

#include "SQLCollations.h"

#include "FileSystemModule.h"

#include "mozStorageHelper.h"

#include "GeckoProfiler.h"

#include "mozilla/Logging.h"

#include "prprf.h"

#include "nsProxyRelease.h"

#include <algorithm>

#define MIN_AVAILABLE_BYTES_PER_CHUNKED_GROWTH 524288000 // 500 MiB

// Maximum size of the pages cache per connection.

#define MAX_CACHE_SIZE_KIBIBYTES 2048 // 2 MiB

PRLogModuleInfo* gStorageLog = nullptr;

// Checks that the protected code is running on the main-thread only if the

// connection was also opened on it.

#ifdef DEBUG

#define CHECK_MAINTHREAD_ABUSE() \

do { \

nsCOMPtr<nsIThread> mainThread = do_GetMainThread(); \

NS_WARN_IF_FALSE(threadOpenedOn == mainThread || !NS_IsMainThread(), \

"Using Storage synchronous API on main-thread, but the connection was opened on another thread."); \

} while(0)

#else

#define CHECK_MAINTHREAD_ABUSE() do { /* Nothing */ } while(0)

#endif

namespace mozilla {

namespace storage {

namespace {

int

nsresultToSQLiteResult(nsresult aXPCOMResultCode)

{

if (NS_SUCCEEDED(aXPCOMResultCode)) {

return SQLITE_OK;

}

switch (aXPCOMResultCode) {

case NS_ERROR_FILE_CORRUPTED:

return SQLITE_CORRUPT;

case NS_ERROR_FILE_ACCESS_DENIED:

return SQLITE_CANTOPEN;

case NS_ERROR_STORAGE_BUSY:

return SQLITE_BUSY;

case NS_ERROR_FILE_IS_LOCKED:

return SQLITE_LOCKED;

case NS_ERROR_FILE_READ_ONLY:

return SQLITE_READONLY;

case NS_ERROR_STORAGE_IOERR:

return SQLITE_IOERR;

case NS_ERROR_FILE_NO_DEVICE_SPACE:

return SQLITE_FULL;

case NS_ERROR_OUT_OF_MEMORY:

return SQLITE_NOMEM;

case NS_ERROR_UNEXPECTED:

return SQLITE_MISUSE;

case NS_ERROR_ABORT:

return SQLITE_ABORT;

case NS_ERROR_STORAGE_CONSTRAINT:

return SQLITE_CONSTRAINT;

default:

return SQLITE_ERROR;

}

MOZ_MAKE_COMPILER_ASSUME_IS_UNREACHABLE("Must return in switch above!");

}

////////////////////////////////////////////////////////////////////////////////

//// Variant Specialization Functions (variantToSQLiteT)

int

sqlite3_T_int(sqlite3_context *aCtx,

int aValue)

{

::sqlite3_result_int(aCtx, aValue);

return SQLITE_OK;

}

int

sqlite3_T_int64(sqlite3_context *aCtx,

sqlite3_int64 aValue)

{

::sqlite3_result_int64(aCtx, aValue);

return SQLITE_OK;

}

int

sqlite3_T_double(sqlite3_context *aCtx,

double aValue)

{

::sqlite3_result_double(aCtx, aValue);

return SQLITE_OK;

}

int

sqlite3_T_text(sqlite3_context *aCtx,

const nsCString &aValue)

{

::sqlite3_result_text(aCtx,

aValue.get(),

aValue.Length(),

SQLITE_TRANSIENT);

return SQLITE_OK;

}

int

sqlite3_T_text16(sqlite3_context *aCtx,

const nsString &aValue)

{

::sqlite3_result_text16(aCtx,

aValue.get(),

aValue.Length() * 2, // Number of bytes.

SQLITE_TRANSIENT);

return SQLITE_OK;

}

int

sqlite3_T_null(sqlite3_context *aCtx)

{

::sqlite3_result_null(aCtx);

return SQLITE_OK;

}

int

sqlite3_T_blob(sqlite3_context *aCtx,

const void *aData,

int aSize)

{

::sqlite3_result_blob(aCtx, aData, aSize, free);

return SQLITE_OK;

}

#include "variantToSQLiteT_impl.h"

////////////////////////////////////////////////////////////////////////////////

//// Modules

struct Module

{

const char* name;

int (*registerFunc)(sqlite3*, const char*);

};

Module gModules[] = {

{ "filesystem", RegisterFileSystemModule }

};

////////////////////////////////////////////////////////////////////////////////

//// Local Functions

void tracefunc (void *aClosure, const char *aStmt)

{

MOZ_LOG(gStorageLog, LogLevel::Debug, ("sqlite3_trace on %p for '%s'", aClosure,

aStmt));

}

void

basicFunctionHelper(sqlite3_context *aCtx,

int aArgc,

sqlite3_value **aArgv)

{

void *userData = ::sqlite3_user_data(aCtx);

mozIStorageFunction *func = static_cast<mozIStorageFunction *>(userData);

RefPtr<ArgValueArray> arguments(new ArgValueArray(aArgc, aArgv));

if (!arguments)

return;

nsCOMPtr<nsIVariant> result;

nsresult rv = func->OnFunctionCall(arguments, getter_AddRefs(result));

if (NS_FAILED(rv)) {

nsAutoCString errorMessage;

GetErrorName(rv, errorMessage);

errorMessage.InsertLiteral("User function returned ", 0);

errorMessage.Append('!');

NS_WARNING(errorMessage.get());

::sqlite3_result_error(aCtx, errorMessage.get(), -1);

::sqlite3_result_error_code(aCtx, nsresultToSQLiteResult(rv));

return;

}

int retcode = variantToSQLiteT(aCtx, result);

if (retcode == SQLITE_IGNORE) {

::sqlite3_result_int(aCtx, SQLITE_IGNORE);

} else if (retcode != SQLITE_OK) {

NS_WARNING("User function returned invalid data type!");

::sqlite3_result_error(aCtx,

"User function returned invalid data type",

-1);

}

}

void

aggregateFunctionStepHelper(sqlite3_context *aCtx,

int aArgc,

sqlite3_value **aArgv)

{

void *userData = ::sqlite3_user_data(aCtx);

mozIStorageAggregateFunction *func =

static_cast<mozIStorageAggregateFunction *>(userData);

RefPtr<ArgValueArray> arguments(new ArgValueArray(aArgc, aArgv));

if (!arguments)

return;

if (NS_FAILED(func->OnStep(arguments)))

NS_WARNING("User aggregate step function returned error code!");

}

void

aggregateFunctionFinalHelper(sqlite3_context *aCtx)

{

void *userData = ::sqlite3_user_data(aCtx);

mozIStorageAggregateFunction *func =

static_cast<mozIStorageAggregateFunction *>(userData);

RefPtr<nsIVariant> result;

if (NS_FAILED(func->OnFinal(getter_AddRefs(result)))) {

NS_WARNING("User aggregate final function returned error code!");

::sqlite3_result_error(aCtx,

"User aggregate final function returned error code",

-1);

return;

}

if (variantToSQLiteT(aCtx, result) != SQLITE_OK) {

NS_WARNING("User aggregate final function returned invalid data type!");

::sqlite3_result_error(aCtx,

"User aggregate final function returned invalid data type",

-1);

}

}

/**

* This code is heavily based on the sample at:

* http://www.sqlite.org/unlock_notify.html

*/

class UnlockNotification

{

public:

UnlockNotification()

: mMutex("UnlockNotification mMutex")

, mCondVar(mMutex, "UnlockNotification condVar")

, mSignaled(false)

{

}

void Wait()

{

MutexAutoLock lock(mMutex);

while (!mSignaled) {

(void)mCondVar.Wait();

}

}

void Signal()

{

MutexAutoLock lock(mMutex);

mSignaled = true;

(void)mCondVar.Notify();

}

private:

Mutex mMutex;

CondVar mCondVar;

bool mSignaled;

};

void

UnlockNotifyCallback(void **aArgs,

int aArgsSize)

{

for (int i = 0; i < aArgsSize; i++) {

UnlockNotification *notification =

static_cast<UnlockNotification *>(aArgs[i]);

notification->Signal();

}

}

int

WaitForUnlockNotify(sqlite3* aDatabase)

{

UnlockNotification notification;

int srv = ::sqlite3_unlock_notify(aDatabase, UnlockNotifyCallback,

&notification);

MOZ_ASSERT(srv == SQLITE_LOCKED || srv == SQLITE_OK);

if (srv == SQLITE_OK) {

notification.Wait();

}

return srv;

}

} // namespace

////////////////////////////////////////////////////////////////////////////////

//// Local Classes

namespace {

class AsyncCloseConnection final: public nsRunnable

{

public:

AsyncCloseConnection(Connection *aConnection,

sqlite3 *aNativeConnection,

nsIRunnable *aCallbackEvent,

already_AddRefed<nsIThread> aAsyncExecutionThread)

: mConnection(aConnection)

, mNativeConnection(aNativeConnection)

, mCallbackEvent(aCallbackEvent)

, mAsyncExecutionThread(aAsyncExecutionThread)

{

}

NS_METHOD Run()

{

#ifdef DEBUG

// This code is executed on the background thread

bool onAsyncThread = false;

(void)mAsyncExecutionThread->IsOnCurrentThread(&onAsyncThread);

MOZ_ASSERT(onAsyncThread);

#endif // DEBUG

nsCOMPtr<nsIRunnable> event = NS_NewRunnableMethodWithArg<nsCOMPtr<nsIThread>>

(mConnection, &Connection::shutdownAsyncThread, mAsyncExecutionThread);

(void)NS_DispatchToMainThread(event);

// Internal close.

(void)mConnection->internalClose(mNativeConnection);

// Callback

if (mCallbackEvent) {

nsCOMPtr<nsIThread> thread;

(void)NS_GetMainThread(getter_AddRefs(thread));

(void)thread->Dispatch(mCallbackEvent, NS_DISPATCH_NORMAL);

}

return NS_OK;

}

~AsyncCloseConnection() {

nsCOMPtr<nsIThread> thread;

(void)NS_GetMainThread(getter_AddRefs(thread));

// Handle ambiguous nsISupports inheritance.

Connection *rawConnection = nullptr;

mConnection.swap(rawConnection);

(void)NS_ProxyRelease(thread,

NS_ISUPPORTS_CAST(mozIStorageConnection *,

rawConnection));

(void)NS_ProxyRelease(thread, mCallbackEvent);

}

private:

RefPtr<Connection> mConnection;

sqlite3 *mNativeConnection;

nsCOMPtr<nsIRunnable> mCallbackEvent;

nsCOMPtr<nsIThread> mAsyncExecutionThread;

};

/**

* An event used to initialize the clone of a connection.

*

* Must be executed on the clone's async execution thread.

*/

class AsyncInitializeClone final: public nsRunnable

{

public:

/**

* @param aConnection The connection being cloned.

* @param aClone The clone.

* @param aReadOnly If |true|, the clone is read only.

* @param aCallback A callback to trigger once initialization

* is complete. This event will be called on

* aClone->threadOpenedOn.

*/

AsyncInitializeClone(Connection* aConnection,

Connection* aClone,

const bool aReadOnly,

mozIStorageCompletionCallback* aCallback)

: mConnection(aConnection)

, mClone(aClone)

, mReadOnly(aReadOnly)

, mCallback(aCallback)

{

MOZ_ASSERT(NS_IsMainThread());

}

NS_IMETHOD Run() {

MOZ_ASSERT (NS_GetCurrentThread() == mClone->getAsyncExecutionTarget());

nsresult rv = mConnection->initializeClone(mClone, mReadOnly);

if (NS_FAILED(rv)) {

return Dispatch(rv, nullptr);

}

return Dispatch(NS_OK,

NS_ISUPPORTS_CAST(mozIStorageAsyncConnection*, mClone));

}

private:

nsresult Dispatch(nsresult aResult, nsISupports* aValue) {

RefPtr<CallbackComplete> event = new CallbackComplete(aResult,

aValue,

mCallback.forget());

return mClone->threadOpenedOn->Dispatch(event, NS_DISPATCH_NORMAL);

}

~AsyncInitializeClone() {

nsCOMPtr<nsIThread> thread;

DebugOnly<nsresult> rv = NS_GetMainThread(getter_AddRefs(thread));

MOZ_ASSERT(NS_SUCCEEDED(rv));

// Handle ambiguous nsISupports inheritance.

Connection *rawConnection = nullptr;

mConnection.swap(rawConnection);

(void)NS_ProxyRelease(thread, NS_ISUPPORTS_CAST(mozIStorageConnection *,

rawConnection));

Connection *rawClone = nullptr;

mClone.swap(rawClone);

(void)NS_ProxyRelease(thread, NS_ISUPPORTS_CAST(mozIStorageConnection *,

rawClone));

// Generally, the callback will be released by CallbackComplete.

// However, if for some reason Run() is not executed, we still

// need to ensure that it is released here.

mozIStorageCompletionCallback *rawCallback = nullptr;

mCallback.swap(rawCallback);

(void)NS_ProxyRelease(thread, rawCallback);

}

RefPtr<Connection> mConnection;

RefPtr<Connection> mClone;

const bool mReadOnly;

nsCOMPtr<mozIStorageCompletionCallback> mCallback;

};

} // namespace

////////////////////////////////////////////////////////////////////////////////

//// Connection

Connection::Connection(Service *aService,

int aFlags,

bool aAsyncOnly)

: sharedAsyncExecutionMutex("Connection::sharedAsyncExecutionMutex")

, sharedDBMutex("Connection::sharedDBMutex")

, threadOpenedOn(do_GetCurrentThread())

, mDBConn(nullptr)

, mAsyncExecutionThreadShuttingDown(false)

, mAsyncExecutionThreadIsAlive(false)

, mConnectionClosed(false)

, mTransactionInProgress(false)

, mProgressHandler(nullptr)

, mFlags(aFlags)

, mStorageService(aService)

, mAsyncOnly(aAsyncOnly)

{

mStorageService->registerConnection(this);

}

Connection::~Connection()

{

(void)Close();

MOZ_ASSERT(!mAsyncExecutionThread,

"AsyncClose has not been invoked on this connection!");

MOZ_ASSERT(!mAsyncExecutionThreadIsAlive,

"The async execution thread should have been shutdown!");

}

NS_IMPL_ADDREF(Connection)

NS_INTERFACE_MAP_BEGIN(Connection)

NS_INTERFACE_MAP_ENTRY(mozIStorageAsyncConnection)

NS_INTERFACE_MAP_ENTRY(nsIInterfaceRequestor)

NS_INTERFACE_MAP_ENTRY_CONDITIONAL(mozIStorageConnection, !mAsyncOnly)

NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, mozIStorageConnection)

NS_INTERFACE_MAP_END

// This is identical to what NS_IMPL_RELEASE provides, but with the

// extra |1 == count| case.

NS_IMETHODIMP_(MozExternalRefCountType) Connection::Release(void)

{

NS_PRECONDITION(0 != mRefCnt, "dup release");

nsrefcnt count = --mRefCnt;

NS_LOG_RELEASE(this, count, "Connection");

if (1 == count) {

// If the refcount is 1, the single reference must be from

// gService->mConnections (in class |Service|). Which means we can

// unregister it safely.

mStorageService->unregisterConnection(this);

} else if (0 == count) {

mRefCnt = 1; /* stabilize */

#if 0 /* enable this to find non-threadsafe destructors: */

NS_ASSERT_OWNINGTHREAD(Connection);

#endif

delete (this);

return 0;

}

return count;

}

int32_t

Connection::getSqliteRuntimeStatus(int32_t aStatusOption, int32_t* aMaxValue)

{

MOZ_ASSERT(mDBConn, "A connection must exist at this point");

int curr = 0, max = 0;

DebugOnly<int> rc = ::sqlite3_db_status(mDBConn, aStatusOption, &curr, &max, 0);

MOZ_ASSERT(NS_SUCCEEDED(convertResultCode(rc)));

if (aMaxValue)

*aMaxValue = max;

return curr;

}

nsIEventTarget *

Connection::getAsyncExecutionTarget()

{

MutexAutoLock lockedScope(sharedAsyncExecutionMutex);

// If we are shutting down the asynchronous thread, don't hand out any more

// references to the thread.

if (mAsyncExecutionThreadShuttingDown)

return nullptr;

if (!mAsyncExecutionThread) {

nsresult rv = ::NS_NewThread(getter_AddRefs(mAsyncExecutionThread));

if (NS_FAILED(rv)) {

NS_WARNING("Failed to create async thread.");

return nullptr;

}

static nsThreadPoolNaming naming;

naming.SetThreadPoolName(NS_LITERAL_CSTRING("mozStorage"),

mAsyncExecutionThread);

}

mAsyncExecutionThreadIsAlive = true;

return mAsyncExecutionThread;

}

nsresult

Connection::initialize()

{

NS_ASSERTION (!mDBConn, "Initialize called on already opened database!");

PROFILER_LABEL("mozStorageConnection", "initialize",

js::ProfileEntry::Category::STORAGE);

// in memory database requested, sqlite uses a magic file name

int srv = ::sqlite3_open_v2(":memory:", &mDBConn, mFlags, nullptr);

if (srv != SQLITE_OK) {

mDBConn = nullptr;

return convertResultCode(srv);

}

// Do not set mDatabaseFile or mFileURL here since this is a "memory"

// database.

nsresult rv = initializeInternal();

NS_ENSURE_SUCCESS(rv, rv);

return NS_OK;

}

nsresult

Connection::initialize(nsIFile *aDatabaseFile)

{

NS_ASSERTION (aDatabaseFile, "Passed null file!");

NS_ASSERTION (!mDBConn, "Initialize called on already opened database!");

PROFILER_LABEL("mozStorageConnection", "initialize",

js::ProfileEntry::Category::STORAGE);

mDatabaseFile = aDatabaseFile;

nsAutoString path;

nsresult rv = aDatabaseFile->GetPath(path);

NS_ENSURE_SUCCESS(rv, rv);

int srv = ::sqlite3_open_v2(NS_ConvertUTF16toUTF8(path).get(), &mDBConn,

mFlags, nullptr);

if (srv != SQLITE_OK) {

mDBConn = nullptr;

return convertResultCode(srv);

}

// Do not set mFileURL here since this is database does not have an associated

// URL.

mDatabaseFile = aDatabaseFile;

rv = initializeInternal();

NS_ENSURE_SUCCESS(rv, rv);

return NS_OK;

}

nsresult

Connection::initialize(nsIFileURL *aFileURL)

{

NS_ASSERTION (aFileURL, "Passed null file URL!");

NS_ASSERTION (!mDBConn, "Initialize called on already opened database!");

PROFILER_LABEL("mozStorageConnection", "initialize",

js::ProfileEntry::Category::STORAGE);

nsCOMPtr<nsIFile> databaseFile;

nsresult rv = aFileURL->GetFile(getter_AddRefs(databaseFile));

NS_ENSURE_SUCCESS(rv, rv);

nsAutoCString spec;

rv = aFileURL->GetSpec(spec);

NS_ENSURE_SUCCESS(rv, rv);

int srv = ::sqlite3_open_v2(spec.get(), &mDBConn, mFlags, nullptr);

if (srv != SQLITE_OK) {

mDBConn = nullptr;

return convertResultCode(srv);

}

// Set both mDatabaseFile and mFileURL here.

mFileURL = aFileURL;

mDatabaseFile = databaseFile;

rv = initializeInternal();

NS_ENSURE_SUCCESS(rv, rv);

return NS_OK;

}

nsresult

Connection::initializeInternal()

{

MOZ_ASSERT(mDBConn);

if (mFileURL) {

const char* dbPath = ::sqlite3_db_filename(mDBConn, "main");

MOZ_ASSERT(dbPath);

const char* telemetryFilename =

::sqlite3_uri_parameter(dbPath, "telemetryFilename");

if (telemetryFilename) {

if (NS_WARN_IF(*telemetryFilename == '\0')) {

return NS_ERROR_INVALID_ARG;

}

mTelemetryFilename = telemetryFilename;

}

}

if (mTelemetryFilename.IsEmpty()) {

mTelemetryFilename = getFilename();

MOZ_ASSERT(!mTelemetryFilename.IsEmpty());

}

// Properly wrap the database handle's mutex.

sharedDBMutex.initWithMutex(sqlite3_db_mutex(mDBConn));

if (!gStorageLog)

gStorageLog = ::PR_NewLogModule("mozStorage");

// SQLite tracing can slow down queries (especially long queries)

// significantly. Don't trace unless the user is actively monitoring SQLite.

if (MOZ_LOG_TEST(gStorageLog, LogLevel::Debug)) {

::sqlite3_trace(mDBConn, tracefunc, this);

MOZ_LOG(gStorageLog, LogLevel::Debug, ("Opening connection to '%s' (%p)",

mTelemetryFilename.get(), this));

}

int64_t pageSize = Service::getDefaultPageSize();

// Set page_size to the preferred default value. This is effective only if

// the database has just been created, otherwise, if the database does not

// use WAL journal mode, a VACUUM operation will updated its page_size.

nsAutoCString pageSizeQuery(MOZ_STORAGE_UNIQUIFY_QUERY_STR

"PRAGMA page_size = ");

pageSizeQuery.AppendInt(pageSize);

nsresult rv = ExecuteSimpleSQL(pageSizeQuery);

NS_ENSURE_SUCCESS(rv, rv);

// Setting the cache_size forces the database open, verifying if it is valid

// or corrupt. So this is executed regardless it being actually needed.

// The cache_size is calculated from the actual page_size, to save memory.

nsAutoCString cacheSizeQuery(MOZ_STORAGE_UNIQUIFY_QUERY_STR

"PRAGMA cache_size = ");

cacheSizeQuery.AppendInt(-MAX_CACHE_SIZE_KIBIBYTES);

int srv = executeSql(mDBConn, cacheSizeQuery.get());

if (srv != SQLITE_OK) {

::sqlite3_close(mDBConn);

mDBConn = nullptr;

return convertResultCode(srv);

}

// Register our built-in SQL functions.

srv = registerFunctions(mDBConn);

if (srv != SQLITE_OK) {

::sqlite3_close(mDBConn);

mDBConn = nullptr;

return convertResultCode(srv);

}

// Register our built-in SQL collating sequences.

srv = registerCollations(mDBConn, mStorageService);

if (srv != SQLITE_OK) {

::sqlite3_close(mDBConn);

mDBConn = nullptr;

return convertResultCode(srv);

}

// Set the synchronous PRAGMA, according to the preference.

switch (Service::getSynchronousPref()) {

case 2:

(void)ExecuteSimpleSQL(NS_LITERAL_CSTRING(

"PRAGMA synchronous = FULL;"));

break;

case 0:

(void)ExecuteSimpleSQL(NS_LITERAL_CSTRING(

"PRAGMA synchronous = OFF;"));

break;

case 1:

default:

(void)ExecuteSimpleSQL(NS_LITERAL_CSTRING(

"PRAGMA synchronous = NORMAL;"));

break;

}

return NS_OK;

}

nsresult

Connection::databaseElementExists(enum DatabaseElementType aElementType,

const nsACString &aElementName,

bool *_exists)

{

if (!mDBConn) return NS_ERROR_NOT_INITIALIZED;

// When constructing the query, make sure to SELECT the correct db's sqlite_master

// if the user is prefixing the element with a specific db. ex: sample.test

nsCString query("SELECT name FROM (SELECT * FROM ");

nsDependentCSubstring element;

int32_t ind = aElementName.FindChar('.');

if (ind == kNotFound) {

element.Assign(aElementName);

}

else {

nsDependentCSubstring db(Substring(aElementName, 0, ind + 1));

element.Assign(Substring(aElementName, ind + 1, aElementName.Length()));

query.Append(db);

}

query.AppendLiteral("sqlite_master UNION ALL SELECT * FROM sqlite_temp_master) WHERE type = '");

switch (aElementType) {

case INDEX:

query.AppendLiteral("index");

break;

case TABLE:

query.AppendLiteral("table");

break;

}

query.AppendLiteral("' AND name ='");

query.Append(element);

query.Append('\'');

sqlite3_stmt *stmt;

int srv = prepareStatement(mDBConn, query, &stmt);

if (srv != SQLITE_OK)

return convertResultCode(srv);

srv = stepStatement(mDBConn, stmt);

// we just care about the return value from step

(void)::sqlite3_finalize(stmt);

if (srv == SQLITE_ROW) {

*_exists = true;

return NS_OK;

}

if (srv == SQLITE_DONE) {

*_exists = false;

return NS_OK;

}

return convertResultCode(srv);

}

bool

Connection::findFunctionByInstance(nsISupports *aInstance)

{

sharedDBMutex.assertCurrentThreadOwns();

for (auto iter = mFunctions.Iter(); !iter.Done(); iter.Next()) {

if (iter.UserData().function == aInstance) {

return true;

}

}

return false;

}

/* static */ int

Connection::sProgressHelper(void *aArg)

{

Connection *_this = static_cast<Connection *>(aArg);

return _this->progressHandler();

}

int

Connection::progressHandler()

{

sharedDBMutex.assertCurrentThreadOwns();

if (mProgressHandler) {

bool result;

nsresult rv = mProgressHandler->OnProgress(this, &result);

if (NS_FAILED(rv)) return 0; // Don't break request

return result ? 1 : 0;

}

return 0;

}

nsresult

Connection::setClosedState()

{

// Ensure that we are on the correct thread to close the database.

bool onOpenedThread;

nsresult rv = threadOpenedOn->IsOnCurrentThread(&onOpenedThread);

NS_ENSURE_SUCCESS(rv, rv);

if (!onOpenedThread) {

NS_ERROR("Must close the database on the thread that you opened it with!");

return NS_ERROR_UNEXPECTED;

}

// Flag that we are shutting down the async thread, so that

// getAsyncExecutionTarget knows not to expose/create the async thread.

{

MutexAutoLock lockedScope(sharedAsyncExecutionMutex);

NS_ENSURE_FALSE(mAsyncExecutionThreadShuttingDown, NS_ERROR_UNEXPECTED);

mAsyncExecutionThreadShuttingDown = true;

}

// Set the property to null before closing the connection, otherwise the other

// functions in the module may try to use the connection after it is closed.

mDBConn = nullptr;

return NS_OK;

}

bool

Connection::connectionReady()

{

return mDBConn != nullptr;

}

bool

Connection::isClosing()

{

bool shuttingDown = false;

{

MutexAutoLock lockedScope(sharedAsyncExecutionMutex);

shuttingDown = mAsyncExecutionThreadShuttingDown;

}

return shuttingDown && !isClosed();

}

bool

Connection::isClosed()

{

MutexAutoLock lockedScope(sharedAsyncExecutionMutex);

return mConnectionClosed;

}

void

Connection::shutdownAsyncThread(nsIThread *aThread) {

MOZ_ASSERT(!mAsyncExecutionThread);

MOZ_ASSERT(mAsyncExecutionThreadIsAlive);

MOZ_ASSERT(mAsyncExecutionThreadShuttingDown);

DebugOnly<nsresult> rv = aThread->Shutdown();

MOZ_ASSERT(NS_SUCCEEDED(rv));

mAsyncExecutionThreadIsAlive = false;

}

nsresult

Connection::internalClose(sqlite3 *aNativeConnection)

{

// Sanity checks to make sure we are in the proper state before calling this.

// aNativeConnection can be null if OpenAsyncDatabase failed and is now just

// cleaning up the async thread.

MOZ_ASSERT(!isClosed());

#ifdef DEBUG

{ // Make sure we have marked our async thread as shutting down.

MutexAutoLock lockedScope(sharedAsyncExecutionMutex);

NS_ASSERTION(mAsyncExecutionThreadShuttingDown,

"Did not call setClosedState!");

}

#endif // DEBUG

if (MOZ_LOG_TEST(gStorageLog, LogLevel::Debug)) {

nsAutoCString leafName(":memory");

if (mDatabaseFile)

(void)mDatabaseFile->GetNativeLeafName(leafName);

MOZ_LOG(gStorageLog, LogLevel::Debug, ("Closing connection to '%s'",

leafName.get()));

}

// At this stage, we may still have statements that need to be

// finalized. Attempt to close the database connection. This will

// always disconnect any virtual tables and cleanly finalize their

// internal statements. Once this is done, closing may fail due to

// unfinalized client statements, in which case we need to finalize

// these statements and close again.

{

MutexAutoLock lockedScope(sharedAsyncExecutionMutex);

mConnectionClosed = true;

}

// Nothing else needs to be done if we don't have a connection here.

if (!aNativeConnection)

return NS_OK;

int srv = sqlite3_close(aNativeConnection);

if (srv == SQLITE_BUSY) {

// We still have non-finalized statements. Finalize them.

sqlite3_stmt *stmt = nullptr;

while ((stmt = ::sqlite3_next_stmt(aNativeConnection, stmt))) {

MOZ_LOG(gStorageLog, LogLevel::Debug,

("Auto-finalizing SQL statement '%s' (%x)",

::sqlite3_sql(stmt),

stmt));

#ifdef DEBUG

char *msg = ::PR_smprintf("SQL statement '%s' (%x) should have been finalized before closing the connection",

::sqlite3_sql(stmt),

stmt);

NS_WARNING(msg);

::PR_smprintf_free(msg);

#endif // DEBUG

srv = ::sqlite3_finalize(stmt);

#ifdef DEBUG

if (srv != SQLITE_OK) {

char *msg = ::PR_smprintf("Could not finalize SQL statement '%s' (%x)",

::sqlite3_sql(stmt),

stmt);

NS_WARNING(msg);

::PR_smprintf_free(msg);

}

#endif // DEBUG

// Ensure that the loop continues properly, whether closing has succeeded

// or not.

if (srv == SQLITE_OK) {

stmt = nullptr;

}

}

// Now that all statements have been finalized, we

// should be able to close.

srv = ::sqlite3_close(aNativeConnection);

}

if (srv != SQLITE_OK) {