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