Remove some iOS #ifdefs by adding SQLiteDatabaseTracker to all the builds
[WebKit-https.git] / Source / WebCore / Modules / webdatabase / DatabaseBackendBase.cpp
1 /*
2  * Copyright (C) 2011 Google Inc. All rights reserved.
3  * Copyright (C) 2013 Apple Inc. All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  *
9  * 1.  Redistributions of source code must retain the above copyright
10  *     notice, this list of conditions and the following disclaimer.
11  * 2.  Redistributions in binary form must reproduce the above copyright
12  *     notice, this list of conditions and the following disclaimer in the
13  *     documentation and/or other materials provided with the distribution.
14  * 3.  Neither the name of Apple Computer, Inc. ("Apple") nor the names of
15  *     its contributors may be used to endorse or promote products derived
16  *     from this software without specific prior written permission.
17  *
18  * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
19  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
20  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
21  * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
22  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
23  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
24  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
25  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
27  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28  */
29
30 #include "config.h"
31 #include "DatabaseBackendBase.h"
32
33 #if ENABLE(SQL_DATABASE)
34
35 #include "DatabaseAuthorizer.h"
36 #include "DatabaseBackendContext.h"
37 #include "DatabaseBase.h"
38 #include "DatabaseContext.h"
39 #include "DatabaseManager.h"
40 #include "DatabaseTracker.h"
41 #include "ExceptionCode.h"
42 #include "Logging.h"
43 #include "SQLiteDatabaseTracker.h"
44 #include "SQLiteStatement.h"
45 #include "SQLiteTransaction.h"
46 #include "SecurityOrigin.h"
47 #include <wtf/HashMap.h>
48 #include <wtf/HashSet.h>
49 #include <wtf/NeverDestroyed.h>
50 #include <wtf/PassRefPtr.h>
51 #include <wtf/RefPtr.h>
52 #include <wtf/StdLibExtras.h>
53 #include <wtf/text/CString.h>
54 #include <wtf/text/StringHash.h>
55
56 // Registering "opened" databases with the DatabaseTracker
57 // =======================================================
58 // The DatabaseTracker maintains a list of databases that have been
59 // "opened" so that the client can call interrupt or delete on every database
60 // associated with a DatabaseBackendContext.
61 //
62 // We will only call DatabaseTracker::addOpenDatabase() to add the database
63 // to the tracker as opened when we've succeeded in opening the database,
64 // and will set m_opened to true. Similarly, we only call
65 // DatabaseTracker::removeOpenDatabase() to remove the database from the
66 // tracker when we set m_opened to false in closeDatabase(). This sets up
67 // a simple symmetry between open and close operations, and a direct
68 // correlation to adding and removing databases from the tracker's list,
69 // thus ensuring that we have a correct list for the interrupt and
70 // delete operations to work on.
71 //
72 // The only databases instances not tracked by the tracker's open database
73 // list are the ones that have not been added yet, or the ones that we
74 // attempted an open on but failed to. Such instances only exist in the
75 // DatabaseServer's factory methods for creating database backends.
76 //
77 // The factory methods will either call openAndVerifyVersion() or
78 // performOpenAndVerify(). These methods will add the newly instantiated
79 // database backend if they succeed in opening the requested database.
80 // In the case of failure to open the database, the factory methods will
81 // simply discard the newly instantiated database backend when they return.
82 // The ref counting mechanims will automatically destruct the un-added
83 // (and un-returned) databases instances.
84
85 namespace WebCore {
86
87 static const char versionKey[] = "WebKitDatabaseVersionKey";
88 static const char infoTableName[] = "__WebKitDatabaseInfoTable__";
89
90 static String formatErrorMessage(const char* message, int sqliteErrorCode, const char* sqliteErrorMessage)
91 {
92     return String::format("%s (%d %s)", message, sqliteErrorCode, sqliteErrorMessage);
93 }
94
95 static bool retrieveTextResultFromDatabase(SQLiteDatabase& db, const String& query, String& resultString)
96 {
97     SQLiteStatement statement(db, query);
98     int result = statement.prepare();
99
100     if (result != SQLResultOk) {
101         LOG_ERROR("Error (%i) preparing statement to read text result from database (%s)", result, query.ascii().data());
102         return false;
103     }
104
105     result = statement.step();
106     if (result == SQLResultRow) {
107         resultString = statement.getColumnText(0);
108         return true;
109     }
110     if (result == SQLResultDone) {
111         resultString = String();
112         return true;
113     }
114
115     LOG_ERROR("Error (%i) reading text result from database (%s)", result, query.ascii().data());
116     return false;
117 }
118
119 static bool setTextValueInDatabase(SQLiteDatabase& db, const String& query, const String& value)
120 {
121     SQLiteStatement statement(db, query);
122     int result = statement.prepare();
123
124     if (result != SQLResultOk) {
125         LOG_ERROR("Failed to prepare statement to set value in database (%s)", query.ascii().data());
126         return false;
127     }
128
129     statement.bindText(1, value);
130
131     result = statement.step();
132     if (result != SQLResultDone) {
133         LOG_ERROR("Failed to step statement to set value in database (%s)", query.ascii().data());
134         return false;
135     }
136
137     return true;
138 }
139
140 // FIXME: move all guid-related functions to a DatabaseVersionTracker class.
141 static std::mutex& guidMutex()
142 {
143     static std::once_flag onceFlag;
144     static std::mutex* mutex;
145
146     std::call_once(onceFlag, []{
147         mutex = std::make_unique<std::mutex>().release();
148     });
149
150     return *mutex;
151 }
152
153 typedef HashMap<DatabaseGuid, String> GuidVersionMap;
154 static GuidVersionMap& guidToVersionMap()
155 {
156     // Ensure the the mutex is locked.
157     ASSERT(!guidMutex().try_lock());
158
159     static NeverDestroyed<GuidVersionMap> map;
160     return map;
161 }
162
163 // NOTE: Caller must lock guidMutex().
164 static inline void updateGuidVersionMap(DatabaseGuid guid, String newVersion)
165 {
166     // Ensure the the mutex is locked.
167     ASSERT(!guidMutex().try_lock());
168
169     // Note: It is not safe to put an empty string into the guidToVersionMap() map.
170     // That's because the map is cross-thread, but empty strings are per-thread.
171     // The copy() function makes a version of the string you can use on the current
172     // thread, but we need a string we can keep in a cross-thread data structure.
173     // FIXME: This is a quite-awkward restriction to have to program with.
174
175     // Map null string to empty string (see comment above).
176     guidToVersionMap().set(guid, newVersion.isEmpty() ? String() : newVersion.isolatedCopy());
177 }
178
179 typedef HashMap<DatabaseGuid, std::unique_ptr<HashSet<DatabaseBackendBase*>>> GuidDatabaseMap;
180
181 static GuidDatabaseMap& guidToDatabaseMap()
182 {
183     // Ensure the the mutex is locked.
184     ASSERT(!guidMutex().try_lock());
185
186     static NeverDestroyed<GuidDatabaseMap> map;
187     return map;
188 }
189
190 static DatabaseGuid guidForOriginAndName(const String& origin, const String& name)
191 {
192     // Ensure the the mutex is locked.
193     ASSERT(!guidMutex().try_lock());
194
195     String stringID = origin + "/" + name;
196
197     typedef HashMap<String, int> IDGuidMap;
198     static NeverDestroyed<HashMap<String, int>> map;
199     DatabaseGuid guid = map.get().get(stringID);
200     if (!guid) {
201         static int currentNewGUID = 1;
202         guid = currentNewGUID++;
203         map.get().set(stringID, guid);
204     }
205
206     return guid;
207 }
208
209 // static
210 const char* DatabaseBackendBase::databaseInfoTableName()
211 {
212     return infoTableName;
213 }
214
215 #if !LOG_DISABLED || !ERROR_DISABLED
216 String DatabaseBackendBase::databaseDebugName() const
217 {
218     return m_contextThreadSecurityOrigin->toString() + "::" + m_name;
219 }
220 #endif
221
222 DatabaseBackendBase::DatabaseBackendBase(PassRefPtr<DatabaseBackendContext> databaseContext, const String& name,
223     const String& expectedVersion, const String& displayName, unsigned long estimatedSize, DatabaseType databaseType)
224     : m_databaseContext(databaseContext)
225     , m_name(name.isolatedCopy())
226     , m_expectedVersion(expectedVersion.isolatedCopy())
227     , m_displayName(displayName.isolatedCopy())
228     , m_estimatedSize(estimatedSize)
229     , m_opened(false)
230     , m_new(false)
231     , m_isSyncDatabase(databaseType == DatabaseType::Sync)
232 {
233     m_contextThreadSecurityOrigin = m_databaseContext->securityOrigin()->isolatedCopy();
234
235     m_databaseAuthorizer = DatabaseAuthorizer::create(infoTableName);
236
237     if (m_name.isNull())
238         m_name = emptyString();
239
240     {
241         std::lock_guard<std::mutex> locker(guidMutex());
242
243         m_guid = guidForOriginAndName(securityOrigin()->toString(), name);
244         std::unique_ptr<HashSet<DatabaseBackendBase*>>& hashSet = guidToDatabaseMap().add(m_guid, nullptr).iterator->value;
245         if (!hashSet)
246             hashSet = std::make_unique<HashSet<DatabaseBackendBase*>>();
247         hashSet->add(this);
248     }
249
250     m_filename = DatabaseManager::manager().fullPathForDatabase(securityOrigin(), m_name);
251 }
252
253 DatabaseBackendBase::~DatabaseBackendBase()
254 {
255     // SQLite is "multi-thread safe", but each database handle can only be used
256     // on a single thread at a time.
257     //
258     // For DatabaseBackend, we open the SQLite database on the DatabaseThread,
259     // and hence we should also close it on that same thread. This means that the
260     // SQLite database need to be closed by another mechanism (see
261     // DatabaseContext::stopDatabases()). By the time we get here, the SQLite
262     // database should have already been closed.
263
264     ASSERT(!m_opened);
265 }
266
267 void DatabaseBackendBase::closeDatabase()
268 {
269     if (!m_opened)
270         return;
271
272     m_sqliteDatabase.close();
273     m_opened = false;
274     // See comment at the top this file regarding calling removeOpenDatabase().
275     DatabaseTracker::tracker().removeOpenDatabase(this);
276     {
277         std::lock_guard<std::mutex> locker(guidMutex());
278
279         auto it = guidToDatabaseMap().find(m_guid);
280         ASSERT(it != guidToDatabaseMap().end());
281         ASSERT(it->value);
282         ASSERT(it->value->contains(this));
283         it->value->remove(this);
284         if (it->value->isEmpty()) {
285             guidToDatabaseMap().remove(it);
286             guidToVersionMap().remove(m_guid);
287         }
288     }
289 }
290
291 String DatabaseBackendBase::version() const
292 {
293     // Note: In multi-process browsers the cached value may be accurate, but we cannot read the
294     // actual version from the database without potentially inducing a deadlock.
295     // FIXME: Add an async version getter to the DatabaseAPI.
296     return getCachedVersion();
297 }
298
299 class DoneCreatingDatabaseOnExitCaller {
300 public:
301     DoneCreatingDatabaseOnExitCaller(DatabaseBackendBase* database)
302         : m_database(database)
303         , m_openSucceeded(false)
304     {
305     }
306     ~DoneCreatingDatabaseOnExitCaller()
307     {
308         DatabaseTracker::tracker().doneCreatingDatabase(m_database);
309     }
310
311     void setOpenSucceeded() { m_openSucceeded = true; }
312
313 private:
314     DatabaseBackendBase* m_database;
315     bool m_openSucceeded;
316 };
317
318 bool DatabaseBackendBase::performOpenAndVerify(bool shouldSetVersionInNewDatabase, DatabaseError& error, String& errorMessage)
319 {
320     DoneCreatingDatabaseOnExitCaller onExitCaller(this);
321     ASSERT(errorMessage.isEmpty());
322     ASSERT(error == DatabaseError::None); // Better not have any errors already.
323     error = DatabaseError::InvalidDatabaseState; // Presumed failure. We'll clear it if we succeed below.
324
325     const int maxSqliteBusyWaitTime = 30000;
326
327 #if PLATFORM(IOS)
328     {
329         // Make sure we wait till the background removal of the empty database files finished before trying to open any database.
330         MutexLocker locker(DatabaseTracker::openDatabaseMutex());
331     }
332 #endif
333
334     SQLiteTransactionInProgressAutoCounter transactionCounter;
335
336     if (!m_sqliteDatabase.open(m_filename, true)) {
337         errorMessage = formatErrorMessage("unable to open database", m_sqliteDatabase.lastError(), m_sqliteDatabase.lastErrorMsg());
338         return false;
339     }
340     if (!m_sqliteDatabase.turnOnIncrementalAutoVacuum())
341         LOG_ERROR("Unable to turn on incremental auto-vacuum (%d %s)", m_sqliteDatabase.lastError(), m_sqliteDatabase.lastErrorMsg());
342
343     m_sqliteDatabase.setBusyTimeout(maxSqliteBusyWaitTime);
344
345     String currentVersion;
346     {
347         std::lock_guard<std::mutex> locker(guidMutex());
348
349         auto entry = guidToVersionMap().find(m_guid);
350         if (entry != guidToVersionMap().end()) {
351             // Map null string to empty string (see updateGuidVersionMap()).
352             currentVersion = entry->value.isNull() ? emptyString() : entry->value.isolatedCopy();
353             LOG(StorageAPI, "Current cached version for guid %i is %s", m_guid, currentVersion.ascii().data());
354         } else {
355             LOG(StorageAPI, "No cached version for guid %i", m_guid);
356
357             SQLiteTransaction transaction(m_sqliteDatabase);
358             transaction.begin();
359             if (!transaction.inProgress()) {
360                 errorMessage = formatErrorMessage("unable to open database, failed to start transaction", m_sqliteDatabase.lastError(), m_sqliteDatabase.lastErrorMsg());
361                 m_sqliteDatabase.close();
362                 return false;
363             }
364
365             String tableName(infoTableName);
366             if (!m_sqliteDatabase.tableExists(tableName)) {
367                 m_new = true;
368
369                 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);")) {
370                     errorMessage = formatErrorMessage("unable to open database, failed to create 'info' table", m_sqliteDatabase.lastError(), m_sqliteDatabase.lastErrorMsg());
371                     transaction.rollback();
372                     m_sqliteDatabase.close();
373                     return false;
374                 }
375             } else if (!getVersionFromDatabase(currentVersion, false)) {
376                 errorMessage = formatErrorMessage("unable to open database, failed to read current version", m_sqliteDatabase.lastError(), m_sqliteDatabase.lastErrorMsg());
377                 transaction.rollback();
378                 m_sqliteDatabase.close();
379                 return false;
380             }
381
382             if (currentVersion.length()) {
383                 LOG(StorageAPI, "Retrieved current version %s from database %s", currentVersion.ascii().data(), databaseDebugName().ascii().data());
384             } else if (!m_new || shouldSetVersionInNewDatabase) {
385                 LOG(StorageAPI, "Setting version %s in database %s that was just created", m_expectedVersion.ascii().data(), databaseDebugName().ascii().data());
386                 if (!setVersionInDatabase(m_expectedVersion, false)) {
387                     errorMessage = formatErrorMessage("unable to open database, failed to write current version", m_sqliteDatabase.lastError(), m_sqliteDatabase.lastErrorMsg());
388                     transaction.rollback();
389                     m_sqliteDatabase.close();
390                     return false;
391                 }
392                 currentVersion = m_expectedVersion;
393             }
394             updateGuidVersionMap(m_guid, currentVersion);
395             transaction.commit();
396         }
397     }
398
399     if (currentVersion.isNull()) {
400         LOG(StorageAPI, "Database %s does not have its version set", databaseDebugName().ascii().data());
401         currentVersion = "";
402     }
403
404     // If the expected version isn't the empty string, ensure that the current database version we have matches that version. Otherwise, set an exception.
405     // If the expected version is the empty string, then we always return with whatever version of the database we have.
406     if ((!m_new || shouldSetVersionInNewDatabase) && m_expectedVersion.length() && m_expectedVersion != currentVersion) {
407         errorMessage = "unable to open database, version mismatch, '" + m_expectedVersion + "' does not match the currentVersion of '" + currentVersion + "'";
408         m_sqliteDatabase.close();
409         return false;
410     }
411
412     ASSERT(m_databaseAuthorizer);
413     m_sqliteDatabase.setAuthorizer(m_databaseAuthorizer);
414
415     // See comment at the top this file regarding calling addOpenDatabase().
416     DatabaseTracker::tracker().addOpenDatabase(this);
417     m_opened = true;
418
419     // Declare success:
420     error = DatabaseError::None; // Clear the presumed error from above.
421     onExitCaller.setOpenSucceeded();
422
423     if (m_new && !shouldSetVersionInNewDatabase)
424         m_expectedVersion = ""; // The caller provided a creationCallback which will set the expected version.
425     return true;
426 }
427
428 SecurityOrigin* DatabaseBackendBase::securityOrigin() const
429 {
430     return m_contextThreadSecurityOrigin.get();
431 }
432
433 String DatabaseBackendBase::stringIdentifier() const
434 {
435     // Return a deep copy for ref counting thread safety
436     return m_name.isolatedCopy();
437 }
438
439 String DatabaseBackendBase::displayName() const
440 {
441     // Return a deep copy for ref counting thread safety
442     return m_displayName.isolatedCopy();
443 }
444
445 unsigned long DatabaseBackendBase::estimatedSize() const
446 {
447     return m_estimatedSize;
448 }
449
450 String DatabaseBackendBase::fileName() const
451 {
452     // Return a deep copy for ref counting thread safety
453     return m_filename.isolatedCopy();
454 }
455
456 DatabaseDetails DatabaseBackendBase::details() const
457 {
458     return DatabaseDetails(stringIdentifier(), displayName(), estimatedSize(), 0);
459 }
460
461 bool DatabaseBackendBase::getVersionFromDatabase(String& version, bool shouldCacheVersion)
462 {
463     String query(String("SELECT value FROM ") + infoTableName +  " WHERE key = '" + versionKey + "';");
464
465     m_databaseAuthorizer->disable();
466
467     bool result = retrieveTextResultFromDatabase(m_sqliteDatabase, query, version);
468     if (result) {
469         if (shouldCacheVersion)
470             setCachedVersion(version);
471     } else
472         LOG_ERROR("Failed to retrieve version from database %s", databaseDebugName().ascii().data());
473
474     m_databaseAuthorizer->enable();
475
476     return result;
477 }
478
479 bool DatabaseBackendBase::setVersionInDatabase(const String& version, bool shouldCacheVersion)
480 {
481     // The INSERT will replace an existing entry for the database with the new version number, due to the UNIQUE ON CONFLICT REPLACE
482     // clause in the CREATE statement (see Database::performOpenAndVerify()).
483     String query(String("INSERT INTO ") + infoTableName +  " (key, value) VALUES ('" + versionKey + "', ?);");
484
485     m_databaseAuthorizer->disable();
486
487     bool result = setTextValueInDatabase(m_sqliteDatabase, query, version);
488     if (result) {
489         if (shouldCacheVersion)
490             setCachedVersion(version);
491     } else
492         LOG_ERROR("Failed to set version %s in database (%s)", version.ascii().data(), query.ascii().data());
493
494     m_databaseAuthorizer->enable();
495
496     return result;
497 }
498
499 void DatabaseBackendBase::setExpectedVersion(const String& version)
500 {
501     m_expectedVersion = version.isolatedCopy();
502 }
503
504 String DatabaseBackendBase::getCachedVersion() const
505 {
506     std::lock_guard<std::mutex> locker(guidMutex());
507
508     return guidToVersionMap().get(m_guid).isolatedCopy();
509 }
510
511 void DatabaseBackendBase::setCachedVersion(const String& actualVersion)
512 {
513     // Update the in memory database version map.
514     std::lock_guard<std::mutex> locker(guidMutex());
515
516     updateGuidVersionMap(m_guid, actualVersion);
517 }
518
519 bool DatabaseBackendBase::getActualVersionForTransaction(String &actualVersion)
520 {
521     ASSERT(m_sqliteDatabase.transactionInProgress());
522     // Note: In multi-process browsers the cached value may be inaccurate.
523     // So we retrieve the value from the database and update the cached value here.
524     return getVersionFromDatabase(actualVersion, true);
525 }
526
527 void DatabaseBackendBase::disableAuthorizer()
528 {
529     ASSERT(m_databaseAuthorizer);
530     m_databaseAuthorizer->disable();
531 }
532
533 void DatabaseBackendBase::enableAuthorizer()
534 {
535     ASSERT(m_databaseAuthorizer);
536     m_databaseAuthorizer->enable();
537 }
538
539 void DatabaseBackendBase::setAuthorizerReadOnly()
540 {
541     ASSERT(m_databaseAuthorizer);
542     m_databaseAuthorizer->setReadOnly();
543 }
544
545 void DatabaseBackendBase::setAuthorizerPermissions(int permissions)
546 {
547     ASSERT(m_databaseAuthorizer);
548     m_databaseAuthorizer->setPermissions(permissions);
549 }
550
551 bool DatabaseBackendBase::lastActionChangedDatabase()
552 {
553     ASSERT(m_databaseAuthorizer);
554     return m_databaseAuthorizer->lastActionChangedDatabase();
555 }
556
557 bool DatabaseBackendBase::lastActionWasInsert()
558 {
559     ASSERT(m_databaseAuthorizer);
560     return m_databaseAuthorizer->lastActionWasInsert();
561 }
562
563 void DatabaseBackendBase::resetDeletes()
564 {
565     ASSERT(m_databaseAuthorizer);
566     m_databaseAuthorizer->resetDeletes();
567 }
568
569 bool DatabaseBackendBase::hadDeletes()
570 {
571     ASSERT(m_databaseAuthorizer);
572     return m_databaseAuthorizer->hadDeletes();
573 }
574
575 void DatabaseBackendBase::resetAuthorizer()
576 {
577     if (m_databaseAuthorizer)
578         m_databaseAuthorizer->reset();
579 }
580
581 unsigned long long DatabaseBackendBase::maximumSize() const
582 {
583     return DatabaseTracker::tracker().getMaxSizeForDatabase(this);
584 }
585
586 void DatabaseBackendBase::incrementalVacuumIfNeeded()
587 {
588     SQLiteTransactionInProgressAutoCounter transactionCounter;
589
590     int64_t freeSpaceSize = m_sqliteDatabase.freeSpaceSize();
591     int64_t totalSize = m_sqliteDatabase.totalSize();
592     if (totalSize <= 10 * freeSpaceSize) {
593         int result = m_sqliteDatabase.runIncrementalVacuumCommand();
594         if (result != SQLResultOk)
595             m_frontend->logErrorMessage(formatErrorMessage("error vacuuming database", result, m_sqliteDatabase.lastErrorMsg()));
596     }
597 }
598
599 void DatabaseBackendBase::interrupt()
600 {
601     m_sqliteDatabase.interrupt();
602 }
603
604 bool DatabaseBackendBase::isInterrupted()
605 {
606     MutexLocker locker(m_sqliteDatabase.databaseMutex());
607     return m_sqliteDatabase.isInterrupted();
608 }
609
610 } // namespace WebCore
611
612 #endif // ENABLE(SQL_DATABASE)