Unreviewed, rolling out r234489.
[WebKit-https.git] / Source / WebCore / platform / sql / SQLiteDatabase.cpp
1 /*
2  * Copyright (C) 2006, 2007, 2008 Apple Inc. All rights reserved.
3  * Copyright (C) 2007 Justin Haygood (jhaygood@reaktix.com)
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  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  *
14  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
15  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
17  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
18  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
19  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
20  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
21  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
22  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
23  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
24  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
25  */
26
27 #include "config.h"
28 #include "SQLiteDatabase.h"
29
30 #include "DatabaseAuthorizer.h"
31 #include "Logging.h"
32 #include "MemoryRelease.h"
33 #include "SQLiteFileSystem.h"
34 #include "SQLiteStatement.h"
35 #include <mutex>
36 #include <sqlite3.h>
37 #include <thread>
38 #include <wtf/Threading.h>
39 #include <wtf/text/CString.h>
40 #include <wtf/text/WTFString.h>
41
42 namespace WebCore {
43
44 static const char notOpenErrorMessage[] = "database is not open";
45
46 static void unauthorizedSQLFunction(sqlite3_context *context, int, sqlite3_value **)
47 {
48     const char* functionName = (const char*)sqlite3_user_data(context);
49     String errorMessage = String::format("Function %s is unauthorized", functionName);
50     sqlite3_result_error(context, errorMessage.utf8().data(), -1);
51 }
52
53 static void initializeSQLiteIfNecessary()
54 {
55     static std::once_flag flag;
56     std::call_once(flag, [] {
57         // It should be safe to call this outside of std::call_once, since it is documented to be
58         // completely threadsafe. But in the past it was not safe, and the SQLite developers still
59         // aren't confident that it really is, and we still support ancient versions of SQLite. So
60         // std::call_once is used to stay on the safe side. See bug #143245.
61         int ret = sqlite3_initialize();
62         if (ret != SQLITE_OK) {
63 #if SQLITE_VERSION_NUMBER >= 3007015
64             WTFLogAlways("Failed to initialize SQLite: %s", sqlite3_errstr(ret));
65 #else
66             WTFLogAlways("Failed to initialize SQLite");
67 #endif
68             CRASH();
69         }
70     });
71 }
72
73 SQLiteDatabase::SQLiteDatabase() = default;
74
75 SQLiteDatabase::~SQLiteDatabase()
76 {
77     close();
78 }
79
80 bool SQLiteDatabase::open(const String& filename, bool forWebSQLDatabase)
81 {
82     initializeSQLiteIfNecessary();
83
84     close();
85
86     m_openError = SQLiteFileSystem::openDatabase(filename, &m_db, forWebSQLDatabase);
87     if (m_openError != SQLITE_OK) {
88         m_openErrorMessage = m_db ? sqlite3_errmsg(m_db) : "sqlite_open returned null";
89         LOG_ERROR("SQLite database failed to load from %s\nCause - %s", filename.ascii().data(),
90             m_openErrorMessage.data());
91         sqlite3_close(m_db);
92         m_db = 0;
93         return false;
94     }
95
96     overrideUnauthorizedFunctions();
97
98     m_openError = sqlite3_extended_result_codes(m_db, 1);
99     if (m_openError != SQLITE_OK) {
100         m_openErrorMessage = sqlite3_errmsg(m_db);
101         LOG_ERROR("SQLite database error when enabling extended errors - %s", m_openErrorMessage.data());
102         sqlite3_close(m_db);
103         m_db = 0;
104         return false;
105     }
106
107     if (isOpen())
108         m_openingThread = &Thread::current();
109     else
110         m_openErrorMessage = "sqlite_open returned null";
111
112     if (!SQLiteStatement(*this, "PRAGMA temp_store = MEMORY;"_s).executeCommand())
113         LOG_ERROR("SQLite database could not set temp_store to memory");
114
115     SQLiteStatement walStatement(*this, "PRAGMA journal_mode=WAL;"_s);
116     if (walStatement.prepareAndStep() == SQLITE_ROW) {
117 #ifndef NDEBUG
118         String mode = walStatement.getColumnText(0);
119         if (!equalLettersIgnoringASCIICase(mode, "wal"))
120             LOG_ERROR("journal_mode of database should be 'WAL', but is '%s'", mode.utf8().data());
121 #endif
122     } else
123         LOG_ERROR("SQLite database failed to set journal_mode to WAL, error: %s", lastErrorMsg());
124
125     return isOpen();
126 }
127
128 void SQLiteDatabase::close()
129 {
130     if (m_db) {
131         // FIXME: This is being called on the main thread during JS GC. <rdar://problem/5739818>
132         // ASSERT(m_openingThread == &Thread::current());
133         sqlite3* db = m_db;
134         {
135             LockHolder locker(m_databaseClosingMutex);
136             m_db = 0;
137         }
138         sqlite3_close(db);
139     }
140
141     m_openingThread = nullptr;
142     m_openError = SQLITE_ERROR;
143     m_openErrorMessage = CString();
144 }
145
146 void SQLiteDatabase::overrideUnauthorizedFunctions()
147 {
148     static const std::pair<const char*, int> functionParameters[] = {
149         { "rtreenode", 2 },
150         { "rtreedepth", 1 },
151         { "eval", 1 },
152         { "eval", 2 },
153         { "printf", -1 },
154         { "fts3_tokenizer", 1 },
155         { "fts3_tokenizer", 2 },
156     };
157
158     for (auto& functionParameter : functionParameters)
159         sqlite3_create_function(m_db, functionParameter.first, functionParameter.second, SQLITE_UTF8, const_cast<char*>(functionParameter.first), unauthorizedSQLFunction, 0, 0);
160 }
161
162 void SQLiteDatabase::setFullsync(bool fsync)
163 {
164     if (fsync) 
165         executeCommand("PRAGMA fullfsync = 1;"_s);
166     else
167         executeCommand("PRAGMA fullfsync = 0;"_s);
168 }
169
170 int64_t SQLiteDatabase::maximumSize()
171 {
172     int64_t maxPageCount = 0;
173
174     {
175         LockHolder locker(m_authorizerLock);
176         enableAuthorizer(false);
177         SQLiteStatement statement(*this, "PRAGMA max_page_count"_s);
178         maxPageCount = statement.getColumnInt64(0);
179         enableAuthorizer(true);
180     }
181
182     return maxPageCount * pageSize();
183 }
184
185 void SQLiteDatabase::setMaximumSize(int64_t size)
186 {
187     if (size < 0)
188         size = 0;
189     
190     int currentPageSize = pageSize();
191
192     ASSERT(currentPageSize || !m_db);
193     int64_t newMaxPageCount = currentPageSize ? size / currentPageSize : 0;
194     
195     LockHolder locker(m_authorizerLock);
196     enableAuthorizer(false);
197
198     SQLiteStatement statement(*this, "PRAGMA max_page_count = " + String::number(newMaxPageCount));
199     statement.prepare();
200     if (statement.step() != SQLITE_ROW)
201         LOG_ERROR("Failed to set maximum size of database to %lli bytes", static_cast<long long>(size));
202
203     enableAuthorizer(true);
204
205 }
206
207 int SQLiteDatabase::pageSize()
208 {
209     // Since the page size of a database is locked in at creation and therefore cannot be dynamic, 
210     // we can cache the value for future use
211     if (m_pageSize == -1) {
212         LockHolder locker(m_authorizerLock);
213         enableAuthorizer(false);
214         
215         SQLiteStatement statement(*this, "PRAGMA page_size"_s);
216         m_pageSize = statement.getColumnInt(0);
217         
218         enableAuthorizer(true);
219     }
220
221     return m_pageSize;
222 }
223
224 int64_t SQLiteDatabase::freeSpaceSize()
225 {
226     int64_t freelistCount = 0;
227
228     {
229         LockHolder locker(m_authorizerLock);
230         enableAuthorizer(false);
231         // Note: freelist_count was added in SQLite 3.4.1.
232         SQLiteStatement statement(*this, "PRAGMA freelist_count"_s);
233         freelistCount = statement.getColumnInt64(0);
234         enableAuthorizer(true);
235     }
236
237     return freelistCount * pageSize();
238 }
239
240 int64_t SQLiteDatabase::totalSize()
241 {
242     int64_t pageCount = 0;
243
244     {
245         LockHolder locker(m_authorizerLock);
246         enableAuthorizer(false);
247         SQLiteStatement statement(*this, "PRAGMA page_count"_s);
248         pageCount = statement.getColumnInt64(0);
249         enableAuthorizer(true);
250     }
251
252     return pageCount * pageSize();
253 }
254
255 void SQLiteDatabase::setSynchronous(SynchronousPragma sync)
256 {
257     executeCommand("PRAGMA synchronous = " + String::number(sync));
258 }
259
260 void SQLiteDatabase::setBusyTimeout(int ms)
261 {
262     if (m_db)
263         sqlite3_busy_timeout(m_db, ms);
264     else
265         LOG(SQLDatabase, "BusyTimeout set on non-open database");
266 }
267
268 void SQLiteDatabase::setBusyHandler(int(*handler)(void*, int))
269 {
270     if (m_db)
271         sqlite3_busy_handler(m_db, handler, NULL);
272     else
273         LOG(SQLDatabase, "Busy handler set on non-open database");
274 }
275
276 bool SQLiteDatabase::executeCommand(const String& sql)
277 {
278     return SQLiteStatement(*this, sql).executeCommand();
279 }
280
281 bool SQLiteDatabase::returnsAtLeastOneResult(const String& sql)
282 {
283     return SQLiteStatement(*this, sql).returnsAtLeastOneResult();
284 }
285
286 bool SQLiteDatabase::tableExists(const String& tablename)
287 {
288     if (!isOpen())
289         return false;
290
291     String statement = "SELECT name FROM sqlite_master WHERE type = 'table' AND name = '" + tablename + "';";
292
293     SQLiteStatement sql(*this, statement);
294     sql.prepare();
295     return sql.step() == SQLITE_ROW;
296 }
297
298 void SQLiteDatabase::clearAllTables()
299 {
300     String query = "SELECT name FROM sqlite_master WHERE type='table';"_s;
301     Vector<String> tables;
302     if (!SQLiteStatement(*this, query).returnTextResults(0, tables)) {
303         LOG(SQLDatabase, "Unable to retrieve list of tables from database");
304         return;
305     }
306     
307     for (Vector<String>::iterator table = tables.begin(); table != tables.end(); ++table ) {
308         if (*table == "sqlite_sequence")
309             continue;
310         if (!executeCommand("DROP TABLE " + *table))
311             LOG(SQLDatabase, "Unable to drop table %s", (*table).ascii().data());
312     }
313 }
314
315 int SQLiteDatabase::runVacuumCommand()
316 {
317     if (!executeCommand("VACUUM;"_s))
318         LOG(SQLDatabase, "Unable to vacuum database - %s", lastErrorMsg());
319     return lastError();
320 }
321
322 int SQLiteDatabase::runIncrementalVacuumCommand()
323 {
324     LockHolder locker(m_authorizerLock);
325     enableAuthorizer(false);
326
327     if (!executeCommand("PRAGMA incremental_vacuum"_s))
328         LOG(SQLDatabase, "Unable to run incremental vacuum - %s", lastErrorMsg());
329
330     enableAuthorizer(true);
331     return lastError();
332 }
333
334 void SQLiteDatabase::interrupt()
335 {
336     LockHolder locker(m_databaseClosingMutex);
337     if (m_db)
338         sqlite3_interrupt(m_db);
339 }
340
341 int64_t SQLiteDatabase::lastInsertRowID()
342 {
343     if (!m_db)
344         return 0;
345     return sqlite3_last_insert_rowid(m_db);
346 }
347
348 void SQLiteDatabase::updateLastChangesCount()
349 {
350     if (!m_db)
351         return;
352
353     m_lastChangesCount = sqlite3_total_changes(m_db);
354 }
355
356 int SQLiteDatabase::lastChanges()
357 {
358     if (!m_db)
359         return 0;
360
361     return sqlite3_total_changes(m_db) - m_lastChangesCount;
362 }
363
364 int SQLiteDatabase::lastError()
365 {
366     return m_db ? sqlite3_errcode(m_db) : m_openError;
367 }
368
369 const char* SQLiteDatabase::lastErrorMsg()
370 {
371     if (m_db)
372         return sqlite3_errmsg(m_db);
373     return m_openErrorMessage.isNull() ? notOpenErrorMessage : m_openErrorMessage.data();
374 }
375
376 #ifndef NDEBUG
377 void SQLiteDatabase::disableThreadingChecks()
378 {
379     // Note that SQLite could be compiled with -DTHREADSAFE, or you may have turned off the mutexes.
380     m_sharable = true;
381 }
382 #endif
383
384 int SQLiteDatabase::authorizerFunction(void* userData, int actionCode, const char* parameter1, const char* parameter2, const char* /*databaseName*/, const char* /*trigger_or_view*/)
385 {
386     DatabaseAuthorizer* auth = static_cast<DatabaseAuthorizer*>(userData);
387     ASSERT(auth);
388
389     switch (actionCode) {
390         case SQLITE_CREATE_INDEX:
391             return auth->createIndex(parameter1, parameter2);
392         case SQLITE_CREATE_TABLE:
393             return auth->createTable(parameter1);
394         case SQLITE_CREATE_TEMP_INDEX:
395             return auth->createTempIndex(parameter1, parameter2);
396         case SQLITE_CREATE_TEMP_TABLE:
397             return auth->createTempTable(parameter1);
398         case SQLITE_CREATE_TEMP_TRIGGER:
399             return auth->createTempTrigger(parameter1, parameter2);
400         case SQLITE_CREATE_TEMP_VIEW:
401             return auth->createTempView(parameter1);
402         case SQLITE_CREATE_TRIGGER:
403             return auth->createTrigger(parameter1, parameter2);
404         case SQLITE_CREATE_VIEW:
405             return auth->createView(parameter1);
406         case SQLITE_DELETE:
407             return auth->allowDelete(parameter1);
408         case SQLITE_DROP_INDEX:
409             return auth->dropIndex(parameter1, parameter2);
410         case SQLITE_DROP_TABLE:
411             return auth->dropTable(parameter1);
412         case SQLITE_DROP_TEMP_INDEX:
413             return auth->dropTempIndex(parameter1, parameter2);
414         case SQLITE_DROP_TEMP_TABLE:
415             return auth->dropTempTable(parameter1);
416         case SQLITE_DROP_TEMP_TRIGGER:
417             return auth->dropTempTrigger(parameter1, parameter2);
418         case SQLITE_DROP_TEMP_VIEW:
419             return auth->dropTempView(parameter1);
420         case SQLITE_DROP_TRIGGER:
421             return auth->dropTrigger(parameter1, parameter2);
422         case SQLITE_DROP_VIEW:
423             return auth->dropView(parameter1);
424         case SQLITE_INSERT:
425             return auth->allowInsert(parameter1);
426         case SQLITE_PRAGMA:
427             return auth->allowPragma(parameter1, parameter2);
428         case SQLITE_READ:
429             return auth->allowRead(parameter1, parameter2);
430         case SQLITE_SELECT:
431             return auth->allowSelect();
432         case SQLITE_TRANSACTION:
433             return auth->allowTransaction();
434         case SQLITE_UPDATE:
435             return auth->allowUpdate(parameter1, parameter2);
436         case SQLITE_ATTACH:
437             return auth->allowAttach(parameter1);
438         case SQLITE_DETACH:
439             return auth->allowDetach(parameter1);
440         case SQLITE_ALTER_TABLE:
441             return auth->allowAlterTable(parameter1, parameter2);
442         case SQLITE_REINDEX:
443             return auth->allowReindex(parameter1);
444         case SQLITE_ANALYZE:
445             return auth->allowAnalyze(parameter1);
446         case SQLITE_CREATE_VTABLE:
447             return auth->createVTable(parameter1, parameter2);
448         case SQLITE_DROP_VTABLE:
449             return auth->dropVTable(parameter1, parameter2);
450         case SQLITE_FUNCTION:
451             return auth->allowFunction(parameter2);
452         default:
453             ASSERT_NOT_REACHED();
454             return SQLAuthDeny;
455     }
456 }
457
458 void SQLiteDatabase::setAuthorizer(DatabaseAuthorizer& authorizer)
459 {
460     if (!m_db) {
461         LOG_ERROR("Attempt to set an authorizer on a non-open SQL database");
462         ASSERT_NOT_REACHED();
463         return;
464     }
465
466     LockHolder locker(m_authorizerLock);
467
468     m_authorizer = &authorizer;
469     
470     enableAuthorizer(true);
471 }
472
473 void SQLiteDatabase::enableAuthorizer(bool enable)
474 {
475     if (m_authorizer && enable)
476         sqlite3_set_authorizer(m_db, SQLiteDatabase::authorizerFunction, m_authorizer.get());
477     else
478         sqlite3_set_authorizer(m_db, NULL, 0);
479 }
480
481 bool SQLiteDatabase::isAutoCommitOn() const
482 {
483     return sqlite3_get_autocommit(m_db);
484 }
485
486 bool SQLiteDatabase::turnOnIncrementalAutoVacuum()
487 {
488     SQLiteStatement statement(*this, "PRAGMA auto_vacuum"_s);
489     int autoVacuumMode = statement.getColumnInt(0);
490     int error = lastError();
491
492     // Check if we got an error while trying to get the value of the auto_vacuum flag.
493     // If we got a SQLITE_BUSY error, then there's probably another transaction in
494     // progress on this database. In this case, keep the current value of the
495     // auto_vacuum flag and try to set it to INCREMENTAL the next time we open this
496     // database. If the error is not SQLITE_BUSY, then we probably ran into a more
497     // serious problem and should return false (to log an error message).
498     if (error != SQLITE_ROW)
499         return false;
500
501     switch (autoVacuumMode) {
502     case AutoVacuumIncremental:
503         return true;
504     case AutoVacuumFull:
505         return executeCommand("PRAGMA auto_vacuum = 2"_s);
506     case AutoVacuumNone:
507     default:
508         if (!executeCommand("PRAGMA auto_vacuum = 2"_s))
509             return false;
510         runVacuumCommand();
511         error = lastError();
512         return (error == SQLITE_OK);
513     }
514 }
515
516 static void destroyCollationFunction(void* arg)
517 {
518     auto f = static_cast<WTF::Function<int(int, const void*, int, const void*)>*>(arg);
519     delete f;
520 }
521
522 static int callCollationFunction(void* arg, int aLength, const void* a, int bLength, const void* b)
523 {
524     auto f = static_cast<WTF::Function<int(int, const void*, int, const void*)>*>(arg);
525     return (*f)(aLength, a, bLength, b);
526 }
527
528 void SQLiteDatabase::setCollationFunction(const String& collationName, WTF::Function<int(int, const void*, int, const void*)>&& collationFunction)
529 {
530     auto functionObject = new WTF::Function<int(int, const void*, int, const void*)>(WTFMove(collationFunction));
531     sqlite3_create_collation_v2(m_db, collationName.utf8().data(), SQLITE_UTF8, functionObject, callCollationFunction, destroyCollationFunction);
532 }
533
534 void SQLiteDatabase::removeCollationFunction(const String& collationName)
535 {
536     sqlite3_create_collation_v2(m_db, collationName.utf8().data(), SQLITE_UTF8, nullptr, nullptr, nullptr);
537 }
538
539 } // namespace WebCore