/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ /* vim: set ts=8 sts=2 et sw=2 tw=80: */ /* 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 "mozilla/dom/cache/DBSchema.h" #include "ipc/IPCMessageUtils.h" #include "mozilla/BasePrincipal.h" #include "mozilla/dom/HeadersBinding.h" #include "mozilla/dom/InternalHeaders.h" #include "mozilla/dom/InternalResponse.h" #include "mozilla/dom/RequestBinding.h" #include "mozilla/dom/ResponseBinding.h" #include "mozilla/dom/cache/CacheCommon.h" #include "mozilla/dom/cache/CacheTypes.h" #include "mozilla/dom/cache/SavedTypes.h" #include "mozilla/dom/cache/Types.h" #include "mozilla/dom/cache/TypeUtils.h" #include "mozilla/net/MozURL.h" #include "mozilla/ResultExtensions.h" #include "mozilla/StaticPrefs_extensions.h" #include "mozIStorageConnection.h" #include "mozIStorageStatement.h" #include "mozStorageHelper.h" #include "nsCharSeparatedTokenizer.h" #include "nsCOMPtr.h" #include "nsComponentManagerUtils.h" #include "nsHttp.h" #include "nsIContentPolicy.h" #include "nsICryptoHash.h" #include "nsNetCID.h" #include "nsPrintfCString.h" #include "nsTArray.h" namespace mozilla::dom::cache::db { const int32_t kFirstShippedSchemaVersion = 15; namespace { // ## Firefox 57 Cache API v25/v26/v27 Schema Hack Info // ### Overview // In Firefox 57 we introduced Cache API schema version 26 and Quota Manager // schema v3 to support tracking padding for opaque responses. Unfortunately, // Firefox 57 is a big release that may potentially result in users downgrading // to Firefox 56 due to 57 retiring add-ons. These schema changes have the // unfortunate side-effect of causing QuotaManager and all its clients to break // if the user downgrades to 56. In order to avoid making a bad situation // worse, we're now retrofitting 57 so that Firefox 56 won't freak out. // // ### Implementation // We're introducing a new schema version 27 that uses an on-disk schema version // of v25. We differentiate v25 from v27 by the presence of the column added // by v26. This translates to: // - v25: on-disk schema=25, no "response_padding_size" column in table // "entries". // - v26: on-disk schema=26, yes "response_padding_size" column in table // "entries". // - v27: on-disk schema=25, yes "response_padding_size" column in table // "entries". // // ### Fallout // Firefox 57 is happy because it sees schema 27 and everything is as it // expects. // // Firefox 56 non-DEBUG build is fine/happy, but DEBUG builds will not be. // - Our QuotaClient will invoke `NS_WARNING("Unknown Cache file found!");` // at QuotaManager init time. This is harmless but annoying and potentially // misleading. // - The DEBUG-only Validate() call will error out whenever an attempt is made // to open a DOM Cache database because it will notice the schema is broken // and there is no attempt at recovery. // const int32_t kHackyDowngradeSchemaVersion = 25; const int32_t kHackyPaddingSizePresentVersion = 27; // // Update this whenever the DB schema is changed. const int32_t kLatestSchemaVersion = 27; // --------- // The following constants define the SQL schema. These are defined in the // same order the SQL should be executed in CreateOrMigrateSchema(). They are // broken out as constants for convenient use in validation and migration. // --------- // The caches table is the single source of truth about what Cache // objects exist for the origin. The contents of the Cache are stored // in the entries table that references back to caches. // // The caches table is also referenced from storage. Rows in storage // represent named Cache objects. There are cases, however, where // a Cache can still exist, but not be in a named Storage. For example, // when content is still using the Cache after CacheStorage::Delete() // has been run. // // For now, the caches table mainly exists for data integrity with // foreign keys, but could be expanded to contain additional cache object // information. // // AUTOINCREMENT is necessary to prevent CacheId values from being reused. const char kTableCaches[] = "CREATE TABLE caches (" "id INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT " ")"; // Security blobs are quite large and duplicated for every Response from // the same https origin. This table is used to de-duplicate this data. const char kTableSecurityInfo[] = "CREATE TABLE security_info (" "id INTEGER NOT NULL PRIMARY KEY, " "hash BLOB NOT NULL, " // first 8-bytes of the sha1 hash of data column "data BLOB NOT NULL, " // full security info data, usually a few KB "refcount INTEGER NOT NULL" ")"; // Index the smaller hash value instead of the large security data blob. const char kIndexSecurityInfoHash[] = "CREATE INDEX security_info_hash_index ON security_info (hash)"; const char kTableEntries[] = "CREATE TABLE entries (" "id INTEGER NOT NULL PRIMARY KEY, " "request_method TEXT NOT NULL, " "request_url_no_query TEXT NOT NULL, " "request_url_no_query_hash BLOB NOT NULL, " // first 8-bytes of sha1 hash "request_url_query TEXT NOT NULL, " "request_url_query_hash BLOB NOT NULL, " // first 8-bytes of sha1 hash "request_referrer TEXT NOT NULL, " "request_headers_guard INTEGER NOT NULL, " "request_mode INTEGER NOT NULL, " "request_credentials INTEGER NOT NULL, " "request_contentpolicytype INTEGER NOT NULL, " "request_cache INTEGER NOT NULL, " "request_body_id TEXT NULL, " "response_type INTEGER NOT NULL, " "response_status INTEGER NOT NULL, " "response_status_text TEXT NOT NULL, " "response_headers_guard INTEGER NOT NULL, " "response_body_id TEXT NULL, " "response_security_info_id INTEGER NULL REFERENCES security_info(id), " "response_principal_info TEXT NOT NULL, " "cache_id INTEGER NOT NULL REFERENCES caches(id) ON DELETE CASCADE, " "request_redirect INTEGER NOT NULL, " "request_referrer_policy INTEGER NOT NULL, " "request_integrity TEXT NOT NULL, " "request_url_fragment TEXT NOT NULL, " "response_padding_size INTEGER NULL " // New columns must be added at the end of table to migrate and // validate properly. ")"; // Create an index to support the QueryCache() matching algorithm. This // needs to quickly find entries in a given Cache that match the request // URL. The url query is separated in order to support the ignoreSearch // option. Finally, we index hashes of the URL values instead of the // actual strings to avoid excessive disk bloat. The index will duplicate // the contents of the columsn in the index. The hash index will prune // the vast majority of values from the query result so that normal // scanning only has to be done on a few values to find an exact URL match. const char kIndexEntriesRequest[] = "CREATE INDEX entries_request_match_index " "ON entries (cache_id, request_url_no_query_hash, " "request_url_query_hash)"; const char kTableRequestHeaders[] = "CREATE TABLE request_headers (" "name TEXT NOT NULL, " "value TEXT NOT NULL, " "entry_id INTEGER NOT NULL REFERENCES entries(id) ON DELETE CASCADE" ")"; const char kTableResponseHeaders[] = "CREATE TABLE response_headers (" "name TEXT NOT NULL, " "value TEXT NOT NULL, " "entry_id INTEGER NOT NULL REFERENCES entries(id) ON DELETE CASCADE" ")"; // We need an index on response_headers, but not on request_headers, // because we quickly need to determine if a VARY header is present. const char kIndexResponseHeadersName[] = "CREATE INDEX response_headers_name_index " "ON response_headers (name)"; const char kTableResponseUrlList[] = "CREATE TABLE response_url_list (" "url TEXT NOT NULL, " "entry_id INTEGER NOT NULL REFERENCES entries(id) ON DELETE CASCADE" ")"; // NOTE: key allows NULL below since that is how "" is represented // in a BLOB column. We use BLOB to avoid encoding issues // with storing DOMStrings. const char kTableStorage[] = "CREATE TABLE storage (" "namespace INTEGER NOT NULL, " "key BLOB NULL, " "cache_id INTEGER NOT NULL REFERENCES caches(id), " "PRIMARY KEY(namespace, key) " ")"; // --------- // End schema definition // --------- const int32_t kMaxEntriesPerStatement = 255; const uint32_t kPageSize = 4 * 1024; // Grow the database in chunks to reduce fragmentation const uint32_t kGrowthSize = 32 * 1024; const uint32_t kGrowthPages = kGrowthSize / kPageSize; static_assert(kGrowthSize % kPageSize == 0, "Growth size must be multiple of page size"); // Only release free pages when we have more than this limit const int32_t kMaxFreePages = kGrowthPages; // Limit WAL journal to a reasonable size const uint32_t kWalAutoCheckpointSize = 512 * 1024; const uint32_t kWalAutoCheckpointPages = kWalAutoCheckpointSize / kPageSize; static_assert(kWalAutoCheckpointSize % kPageSize == 0, "WAL checkpoint size must be multiple of page size"); } // namespace // If any of the static_asserts below fail, it means that you have changed // the corresponding WebIDL enum in a way that may be incompatible with the // existing data stored in the DOM Cache. You would need to update the Cache // database schema accordingly and adjust the failing static_assert. static_assert(int(HeadersGuardEnum::None) == 0 && int(HeadersGuardEnum::Request) == 1 && int(HeadersGuardEnum::Request_no_cors) == 2 && int(HeadersGuardEnum::Response) == 3 && int(HeadersGuardEnum::Immutable) == 4 && HeadersGuardEnumValues::Count == 5, "HeadersGuardEnum values are as expected"); static_assert(int(ReferrerPolicy::_empty) == 0 && int(ReferrerPolicy::No_referrer) == 1 && int(ReferrerPolicy::No_referrer_when_downgrade) == 2 && int(ReferrerPolicy::Origin) == 3 && int(ReferrerPolicy::Origin_when_cross_origin) == 4 && int(ReferrerPolicy::Unsafe_url) == 5 && int(ReferrerPolicy::Same_origin) == 6 && int(ReferrerPolicy::Strict_origin) == 7 && int(ReferrerPolicy::Strict_origin_when_cross_origin) == 8 && ReferrerPolicyValues::Count == 9, "ReferrerPolicy values are as expected"); static_assert(int(RequestMode::Same_origin) == 0 && int(RequestMode::No_cors) == 1 && int(RequestMode::Cors) == 2 && int(RequestMode::Navigate) == 3 && RequestModeValues::Count == 4, "RequestMode values are as expected"); static_assert(int(RequestCredentials::Omit) == 0 && int(RequestCredentials::Same_origin) == 1 && int(RequestCredentials::Include) == 2 && RequestCredentialsValues::Count == 3, "RequestCredentials values are as expected"); static_assert(int(RequestCache::Default) == 0 && int(RequestCache::No_store) == 1 && int(RequestCache::Reload) == 2 && int(RequestCache::No_cache) == 3 && int(RequestCache::Force_cache) == 4 && int(RequestCache::Only_if_cached) == 5 && RequestCacheValues::Count == 6, "RequestCache values are as expected"); static_assert(int(RequestRedirect::Follow) == 0 && int(RequestRedirect::Error) == 1 && int(RequestRedirect::Manual) == 2 && RequestRedirectValues::Count == 3, "RequestRedirect values are as expected"); static_assert(int(ResponseType::Basic) == 0 && int(ResponseType::Cors) == 1 && int(ResponseType::Default) == 2 && int(ResponseType::Error) == 3 && int(ResponseType::Opaque) == 4 && int(ResponseType::Opaqueredirect) == 5 && ResponseTypeValues::Count == 6, "ResponseType values are as expected"); // If the static_asserts below fails, it means that you have changed the // Namespace enum in a way that may be incompatible with the existing data // stored in the DOM Cache. You would need to update the Cache database schema // accordingly and adjust the failing static_assert. static_assert(DEFAULT_NAMESPACE == 0 && CHROME_ONLY_NAMESPACE == 1 && NUMBER_OF_NAMESPACES == 2, "Namespace values are as expected"); // If the static_asserts below fails, it means that you have changed the // nsContentPolicy enum in a way that may be incompatible with the existing data // stored in the DOM Cache. You would need to update the Cache database schema // accordingly and adjust the failing static_assert. static_assert( nsIContentPolicy::TYPE_INVALID == 0 && nsIContentPolicy::TYPE_OTHER == 1 && nsIContentPolicy::TYPE_SCRIPT == 2 && nsIContentPolicy::TYPE_IMAGE == 3 && nsIContentPolicy::TYPE_STYLESHEET == 4 && nsIContentPolicy::TYPE_OBJECT == 5 && nsIContentPolicy::TYPE_DOCUMENT == 6 && nsIContentPolicy::TYPE_SUBDOCUMENT == 7 && nsIContentPolicy::TYPE_PING == 10 && nsIContentPolicy::TYPE_XMLHTTPREQUEST == 11 && nsIContentPolicy::TYPE_OBJECT_SUBREQUEST == 12 && nsIContentPolicy::TYPE_DTD == 13 && nsIContentPolicy::TYPE_FONT == 14 && nsIContentPolicy::TYPE_MEDIA == 15 && nsIContentPolicy::TYPE_WEBSOCKET == 16 && nsIContentPolicy::TYPE_CSP_REPORT == 17 && nsIContentPolicy::TYPE_XSLT == 18 && nsIContentPolicy::TYPE_BEACON == 19 && nsIContentPolicy::TYPE_FETCH == 20 && nsIContentPolicy::TYPE_IMAGESET == 21 && nsIContentPolicy::TYPE_WEB_MANIFEST == 22 && nsIContentPolicy::TYPE_INTERNAL_SCRIPT == 23 && nsIContentPolicy::TYPE_INTERNAL_WORKER == 24 && nsIContentPolicy::TYPE_INTERNAL_SHARED_WORKER == 25 && nsIContentPolicy::TYPE_INTERNAL_EMBED == 26 && nsIContentPolicy::TYPE_INTERNAL_OBJECT == 27 && nsIContentPolicy::TYPE_INTERNAL_FRAME == 28 && nsIContentPolicy::TYPE_INTERNAL_IFRAME == 29 && nsIContentPolicy::TYPE_INTERNAL_AUDIO == 30 && nsIContentPolicy::TYPE_INTERNAL_VIDEO == 31 && nsIContentPolicy::TYPE_INTERNAL_TRACK == 32 && nsIContentPolicy::TYPE_INTERNAL_XMLHTTPREQUEST == 33 && nsIContentPolicy::TYPE_INTERNAL_EVENTSOURCE == 34 && nsIContentPolicy::TYPE_INTERNAL_SERVICE_WORKER == 35 && nsIContentPolicy::TYPE_INTERNAL_SCRIPT_PRELOAD == 36 && nsIContentPolicy::TYPE_INTERNAL_IMAGE == 37 && nsIContentPolicy::TYPE_INTERNAL_IMAGE_PRELOAD == 38 && nsIContentPolicy::TYPE_INTERNAL_STYLESHEET == 39 && nsIContentPolicy::TYPE_INTERNAL_STYLESHEET_PRELOAD == 40 && nsIContentPolicy::TYPE_INTERNAL_IMAGE_FAVICON == 41 && nsIContentPolicy::TYPE_INTERNAL_WORKER_IMPORT_SCRIPTS == 42 && nsIContentPolicy::TYPE_SAVEAS_DOWNLOAD == 43 && nsIContentPolicy::TYPE_SPECULATIVE == 44 && nsIContentPolicy::TYPE_INTERNAL_MODULE == 45 && nsIContentPolicy::TYPE_INTERNAL_MODULE_PRELOAD == 46 && nsIContentPolicy::TYPE_INTERNAL_DTD == 47 && nsIContentPolicy::TYPE_INTERNAL_FORCE_ALLOWED_DTD == 48 && nsIContentPolicy::TYPE_INTERNAL_AUDIOWORKLET == 49 && nsIContentPolicy::TYPE_INTERNAL_PAINTWORKLET == 50 && nsIContentPolicy::TYPE_INTERNAL_FONT_PRELOAD == 51 && nsIContentPolicy::TYPE_INTERNAL_CHROMEUTILS_COMPILED_SCRIPT == 52 && nsIContentPolicy::TYPE_INTERNAL_FRAME_MESSAGEMANAGER_SCRIPT == 53 && nsIContentPolicy::TYPE_INTERNAL_FETCH_PRELOAD == 54, "nsContentPolicyType values are as expected"); namespace { typedef int32_t EntryId; struct IdCount { explicit IdCount(int32_t aId) : mId(aId), mCount(1) {} int32_t mId; int32_t mCount; }; using EntryIds = AutoTArray; static Result QueryAll(mozIStorageConnection& aConn, CacheId aCacheId); static Result QueryCache(mozIStorageConnection& aConn, CacheId aCacheId, const CacheRequest& aRequest, const CacheQueryParams& aParams, uint32_t aMaxResults = UINT32_MAX); static Result MatchByVaryHeader(mozIStorageConnection& aConn, const CacheRequest& aRequest, EntryId entryId); // Returns a success tuple containing the deleted body ids, deleted security ids // and deleted padding size. static Result, AutoTArray, int64_t>, nsresult> DeleteEntries(mozIStorageConnection& aConn, const nsTArray& aEntryIdList); static Result InsertSecurityInfo( mozIStorageConnection& aConn, nsICryptoHash& aCrypto, const nsACString& aData); static nsresult DeleteSecurityInfo(mozIStorageConnection& aConn, int32_t aId, int32_t aCount); static nsresult DeleteSecurityInfoList( mozIStorageConnection& aConn, const nsTArray& aDeletedStorageIdList); static nsresult InsertEntry(mozIStorageConnection& aConn, CacheId aCacheId, const CacheRequest& aRequest, const nsID* aRequestBodyId, const CacheResponse& aResponse, const nsID* aResponseBodyId); static Result ReadResponse( mozIStorageConnection& aConn, EntryId aEntryId); static Result ReadRequest(mozIStorageConnection& aConn, EntryId aEntryId); static void AppendListParamsToQuery(nsACString& aQuery, const nsTArray& aEntryIdList, uint32_t aPos, int32_t aLen); static nsresult BindListParamsToQuery(mozIStorageStatement& aState, const nsTArray& aEntryIdList, uint32_t aPos, int32_t aLen); static nsresult BindId(mozIStorageStatement& aState, const nsACString& aName, const nsID* aId); static Result ExtractId(mozIStorageStatement& aState, uint32_t aPos); static Result>, nsresult> CreateAndBindKeyStatement(mozIStorageConnection& aConn, const char* aQueryFormat, const nsAString& aKey); static Result HashCString(nsICryptoHash& aCrypto, const nsACString& aIn); Result GetEffectiveSchemaVersion( mozIStorageConnection& aConn); nsresult Validate(mozIStorageConnection& aConn); nsresult Migrate(mozIStorageConnection& aConn); } // namespace class MOZ_RAII AutoDisableForeignKeyChecking { public: explicit AutoDisableForeignKeyChecking(mozIStorageConnection* aConn) : mConn(aConn), mForeignKeyCheckingDisabled(false) { CACHE_TRY_INSPECT(const auto& state, quota::CreateAndExecuteSingleStepStatement( *mConn, "PRAGMA foreign_keys;"_ns), QM_VOID); CACHE_TRY_INSPECT(const int32_t& mode, MOZ_TO_RESULT_INVOKE(*state, GetInt32, 0), QM_VOID); if (mode) { CACHE_TRY(mConn->ExecuteSimpleSQL("PRAGMA foreign_keys = OFF;"_ns), QM_VOID); mForeignKeyCheckingDisabled = true; } } ~AutoDisableForeignKeyChecking() { if (mForeignKeyCheckingDisabled) { CACHE_TRY(mConn->ExecuteSimpleSQL("PRAGMA foreign_keys = ON;"_ns), QM_VOID); } } private: nsCOMPtr mConn; bool mForeignKeyCheckingDisabled; }; nsresult CreateOrMigrateSchema(mozIStorageConnection& aConn) { MOZ_ASSERT(!NS_IsMainThread()); CACHE_TRY_UNWRAP(int32_t schemaVersion, GetEffectiveSchemaVersion(aConn)); if (schemaVersion == kLatestSchemaVersion) { // We already have the correct schema version. Validate it matches // our expected schema and then proceed. CACHE_TRY(Validate(aConn)); return NS_OK; } // Turn off checking foreign keys before starting a transaction, and restore // it once we're done. AutoDisableForeignKeyChecking restoreForeignKeyChecking(&aConn); mozStorageTransaction trans(&aConn, false, mozIStorageConnection::TRANSACTION_IMMEDIATE); const bool migrating = schemaVersion != 0; if (migrating) { // A schema exists, but its not the current version. Attempt to // migrate it to our new schema. CACHE_TRY(Migrate(aConn)); } else { // There is no schema installed. Create the database from scratch. CACHE_TRY(aConn.ExecuteSimpleSQL(nsLiteralCString(kTableCaches))); CACHE_TRY(aConn.ExecuteSimpleSQL(nsLiteralCString(kTableSecurityInfo))); CACHE_TRY(aConn.ExecuteSimpleSQL(nsLiteralCString(kIndexSecurityInfoHash))); CACHE_TRY(aConn.ExecuteSimpleSQL(nsLiteralCString(kTableEntries))); CACHE_TRY(aConn.ExecuteSimpleSQL(nsLiteralCString(kIndexEntriesRequest))); CACHE_TRY(aConn.ExecuteSimpleSQL(nsLiteralCString(kTableRequestHeaders))); CACHE_TRY(aConn.ExecuteSimpleSQL(nsLiteralCString(kTableResponseHeaders))); CACHE_TRY( aConn.ExecuteSimpleSQL(nsLiteralCString(kIndexResponseHeadersName))); CACHE_TRY(aConn.ExecuteSimpleSQL(nsLiteralCString(kTableResponseUrlList))); CACHE_TRY(aConn.ExecuteSimpleSQL(nsLiteralCString(kTableStorage))); CACHE_TRY(aConn.SetSchemaVersion(kHackyDowngradeSchemaVersion)); CACHE_TRY_UNWRAP(schemaVersion, GetEffectiveSchemaVersion(aConn)); } CACHE_TRY(Validate(aConn)); CACHE_TRY(trans.Commit()); if (migrating) { // Migrations happen infrequently and reflect a chance in DB structure. // This is a good time to rebuild the database. It also helps catch // if a new migration is incorrect by fast failing on the corruption. // Unfortunately, this must be performed outside of the transaction. // XXX We don't propagate an error from vacuuming right now, due to Bug // 1687685, contrary to the comment above saying we are failing fast. CACHE_TRY(aConn.ExecuteSimpleSQL("VACUUM"_ns), NS_OK); } return NS_OK; } nsresult InitializeConnection(mozIStorageConnection& aConn) { MOZ_ASSERT(!NS_IsMainThread()); // This function needs to perform per-connection initialization tasks that // need to happen regardless of the schema. // Note, the default encoding of UTF-8 is preferred. mozStorage does all // the work necessary to convert UTF-16 nsString values for us. We don't // need ordering and the binary equality operations are correct. So, do // NOT set PRAGMA encoding to UTF-16. CACHE_TRY(aConn.ExecuteSimpleSQL(nsPrintfCString( // Use a smaller page size to improve perf/footprint; default is too large "PRAGMA page_size = %u; " // Enable auto_vacuum; this must happen after page_size and before WAL "PRAGMA auto_vacuum = INCREMENTAL; " "PRAGMA foreign_keys = ON; ", kPageSize))); // Limit fragmentation by growing the database by many pages at once. CACHE_TRY( ToResult(aConn.SetGrowthIncrement(kGrowthSize, ""_ns)) .orElse([](const nsresult rv) -> Result { if (rv == NS_ERROR_FILE_TOO_BIG) { NS_WARNING( "Not enough disk space to set sqlite growth increment."); return Ok{}; } return Err(rv); })); // Enable WAL journaling. This must be performed in a separate transaction // after changing the page_size and enabling auto_vacuum. CACHE_TRY(aConn.ExecuteSimpleSQL(nsPrintfCString( // WAL journal can grow to given number of *pages* "PRAGMA wal_autocheckpoint = %u; " // Always truncate the journal back to given number of *bytes* "PRAGMA journal_size_limit = %u; " // WAL must be enabled at the end to allow page size to be changed, etc. "PRAGMA journal_mode = WAL; ", kWalAutoCheckpointPages, kWalAutoCheckpointSize))); // Verify that we successfully set the vacuum mode to incremental. It // is very easy to put the database in a state where the auto_vacuum // pragma above fails silently. #ifdef DEBUG { CACHE_TRY_INSPECT(const auto& state, quota::CreateAndExecuteSingleStepStatement( aConn, "PRAGMA auto_vacuum;"_ns)); CACHE_TRY_INSPECT(const int32_t& mode, MOZ_TO_RESULT_INVOKE(*state, GetInt32, 0)); // integer value 2 is incremental mode CACHE_TRY(OkIf(mode == 2), NS_ERROR_UNEXPECTED); } #endif return NS_OK; } Result CreateCacheId(mozIStorageConnection& aConn) { MOZ_ASSERT(!NS_IsMainThread()); CACHE_TRY(aConn.ExecuteSimpleSQL("INSERT INTO caches DEFAULT VALUES;"_ns)); CACHE_TRY_INSPECT(const auto& state, quota::CreateAndExecuteSingleStepStatement< quota::SingleStepResult::ReturnNullIfNoResult>( aConn, "SELECT last_insert_rowid()"_ns)); CACHE_TRY(OkIf(state), Err(NS_ERROR_UNEXPECTED)); CACHE_TRY_INSPECT(const CacheId& id, MOZ_TO_RESULT_INVOKE(state, GetInt64, 0)); return id; } Result DeleteCacheId(mozIStorageConnection& aConn, CacheId aCacheId) { MOZ_ASSERT(!NS_IsMainThread()); // Delete the bodies explicitly as we need to read out the body IDs // anyway. These body IDs must be deleted one-by-one as content may // still be referencing them invidivually. CACHE_TRY_INSPECT(const auto& matches, QueryAll(aConn, aCacheId)); // XXX only deletedBodyIdList needs to be non-const CACHE_TRY_UNWRAP( (auto [deletedBodyIdList, deletedSecurityIdList, deletedPaddingSize]), DeleteEntries(aConn, matches)); CACHE_TRY(DeleteSecurityInfoList(aConn, deletedSecurityIdList)); // Delete the remainder of the cache using cascade semantics. CACHE_TRY_INSPECT(const auto& state, MOZ_TO_RESULT_INVOKE_TYPED( nsCOMPtr, aConn, CreateStatement, "DELETE FROM caches WHERE id=:id;"_ns)); CACHE_TRY(state->BindInt64ByName("id"_ns, aCacheId)); CACHE_TRY(state->Execute()); return DeletionInfo{std::move(deletedBodyIdList), deletedPaddingSize}; } Result, nsresult> FindOrphanedCacheIds( mozIStorageConnection& aConn) { CACHE_TRY_INSPECT(const auto& state, MOZ_TO_RESULT_INVOKE_TYPED( nsCOMPtr, aConn, CreateStatement, "SELECT id FROM caches " "WHERE id NOT IN (SELECT cache_id from storage);"_ns)); CACHE_TRY_RETURN( (quota::CollectElementsWhileHasResultTyped>( *state, [](auto& stmt) { CACHE_TRY_RETURN(MOZ_TO_RESULT_INVOKE(stmt, GetInt64, 0)); }))); } Result FindOverallPaddingSize(mozIStorageConnection& aConn) { CACHE_TRY_INSPECT(const auto& state, MOZ_TO_RESULT_INVOKE_TYPED( nsCOMPtr, aConn, CreateStatement, "SELECT response_padding_size FROM entries " "WHERE response_padding_size IS NOT NULL;"_ns)); int64_t overallPaddingSize = 0; CACHE_TRY(quota::CollectWhileHasResult( *state, [&overallPaddingSize](auto& stmt) -> Result { CACHE_TRY_INSPECT(const int64_t& padding_size, MOZ_TO_RESULT_INVOKE(stmt, GetInt64, 0)); MOZ_DIAGNOSTIC_ASSERT(padding_size >= 0); MOZ_DIAGNOSTIC_ASSERT(INT64_MAX - padding_size >= overallPaddingSize); overallPaddingSize += padding_size; return Ok{}; })); return overallPaddingSize; } Result, nsresult> GetKnownBodyIds(mozIStorageConnection& aConn) { MOZ_ASSERT(!NS_IsMainThread()); CACHE_TRY_INSPECT( const auto& state, MOZ_TO_RESULT_INVOKE_TYPED( nsCOMPtr, aConn, CreateStatement, "SELECT request_body_id, response_body_id FROM entries;"_ns)); AutoTArray idList; CACHE_TRY(quota::CollectWhileHasResult( *state, [&idList](auto& stmt) -> Result { // extract 0 to 2 nsID structs per row for (uint32_t i = 0; i < 2; ++i) { CACHE_TRY_INSPECT(const bool& isNull, MOZ_TO_RESULT_INVOKE(stmt, GetIsNull, i)); if (!isNull) { CACHE_TRY_INSPECT(const auto& id, ExtractId(stmt, i)); idList.AppendElement(id); } } return Ok{}; })); return std::move(idList); } Result, nsresult> CacheMatch( mozIStorageConnection& aConn, CacheId aCacheId, const CacheRequest& aRequest, const CacheQueryParams& aParams) { MOZ_ASSERT(!NS_IsMainThread()); CACHE_TRY_INSPECT(const auto& matches, QueryCache(aConn, aCacheId, aRequest, aParams, 1)); if (matches.IsEmpty()) { return Maybe(); } CACHE_TRY_UNWRAP(auto response, ReadResponse(aConn, matches[0])); response.mCacheId = aCacheId; return Some(std::move(response)); } Result, nsresult> CacheMatchAll( mozIStorageConnection& aConn, CacheId aCacheId, const Maybe& aMaybeRequest, const CacheQueryParams& aParams) { MOZ_ASSERT(!NS_IsMainThread()); CACHE_TRY_INSPECT( const auto& matches, ([&aConn, aCacheId, &aMaybeRequest, &aParams] { if (aMaybeRequest.isNothing()) { CACHE_TRY_RETURN(QueryAll(aConn, aCacheId)); } CACHE_TRY_RETURN( QueryCache(aConn, aCacheId, aMaybeRequest.ref(), aParams)); }())); // TODO: replace this with a bulk load using SQL IN clause (bug 1110458) CACHE_TRY_RETURN(TransformIntoNewArrayAbortOnErr( matches, [&aConn, aCacheId](const auto match) -> Result { CACHE_TRY_UNWRAP(auto savedResponse, ReadResponse(aConn, match)); savedResponse.mCacheId = aCacheId; return savedResponse; }, fallible)); } Result CachePut(mozIStorageConnection& aConn, CacheId aCacheId, const CacheRequest& aRequest, const nsID* aRequestBodyId, const CacheResponse& aResponse, const nsID* aResponseBodyId) { MOZ_ASSERT(!NS_IsMainThread()); CACHE_TRY_INSPECT( const auto& matches, QueryCache(aConn, aCacheId, aRequest, CacheQueryParams(false, false, false, false, u""_ns))); // XXX only deletedBodyIdList needs to be non-const CACHE_TRY_UNWRAP( (auto [deletedBodyIdList, deletedSecurityIdList, deletedPaddingSize]), DeleteEntries(aConn, matches)); CACHE_TRY(InsertEntry(aConn, aCacheId, aRequest, aRequestBodyId, aResponse, aResponseBodyId)); // Delete the security values after doing the insert to avoid churning // the security table when its not necessary. CACHE_TRY(DeleteSecurityInfoList(aConn, deletedSecurityIdList)); return DeletionInfo{std::move(deletedBodyIdList), deletedPaddingSize}; } Result, nsresult> CacheDelete( mozIStorageConnection& aConn, CacheId aCacheId, const CacheRequest& aRequest, const CacheQueryParams& aParams) { MOZ_ASSERT(!NS_IsMainThread()); CACHE_TRY_INSPECT(const auto& matches, QueryCache(aConn, aCacheId, aRequest, aParams)); if (matches.IsEmpty()) { return Maybe(); } // XXX only deletedBodyIdList needs to be non-const CACHE_TRY_UNWRAP( (auto [deletedBodyIdList, deletedSecurityIdList, deletedPaddingSize]), DeleteEntries(aConn, matches)); CACHE_TRY(DeleteSecurityInfoList(aConn, deletedSecurityIdList)); return Some(DeletionInfo{std::move(deletedBodyIdList), deletedPaddingSize}); } Result, nsresult> CacheKeys( mozIStorageConnection& aConn, CacheId aCacheId, const Maybe& aMaybeRequest, const CacheQueryParams& aParams) { MOZ_ASSERT(!NS_IsMainThread()); CACHE_TRY_INSPECT( const auto& matches, ([&aConn, aCacheId, &aMaybeRequest, &aParams] { if (aMaybeRequest.isNothing()) { CACHE_TRY_RETURN(QueryAll(aConn, aCacheId)); } CACHE_TRY_RETURN( QueryCache(aConn, aCacheId, aMaybeRequest.ref(), aParams)); }())); // TODO: replace this with a bulk load using SQL IN clause (bug 1110458) CACHE_TRY_RETURN(TransformIntoNewArrayAbortOnErr( matches, [&aConn, aCacheId](const auto match) -> Result { CACHE_TRY_UNWRAP(auto savedRequest, ReadRequest(aConn, match)); savedRequest.mCacheId = aCacheId; return savedRequest; }, fallible)); } Result, nsresult> StorageMatch( mozIStorageConnection& aConn, Namespace aNamespace, const CacheRequest& aRequest, const CacheQueryParams& aParams) { MOZ_ASSERT(!NS_IsMainThread()); // If we are given a cache to check, then simply find its cache ID // and perform the match. if (!aParams.cacheName().EqualsLiteral("")) { CACHE_TRY_INSPECT( const auto& maybeCacheId, StorageGetCacheId(aConn, aNamespace, aParams.cacheName())); if (maybeCacheId.isNothing()) { return Maybe(); } return CacheMatch(aConn, maybeCacheId.ref(), aRequest, aParams); } // Otherwise we need to get a list of all the cache IDs in this namespace. CACHE_TRY_INSPECT(const auto& state, MOZ_TO_RESULT_INVOKE_TYPED( nsCOMPtr, aConn, CreateStatement, "SELECT cache_id FROM storage WHERE " "namespace=:namespace ORDER BY rowid;"_ns)); CACHE_TRY(state->BindInt32ByName("namespace"_ns, aNamespace)); CACHE_TRY_INSPECT( const auto& cacheIdList, (quota::CollectElementsWhileHasResultTyped>( *state, [](auto& stmt) { CACHE_TRY_RETURN(MOZ_TO_RESULT_INVOKE(stmt, GetInt64, 0)); }))); // Now try to find a match in each cache in order for (const auto cacheId : cacheIdList) { CACHE_TRY_UNWRAP(auto matchedResponse, CacheMatch(aConn, cacheId, aRequest, aParams)); if (matchedResponse.isSome()) { return matchedResponse; } } return Maybe(); } Result, nsresult> StorageGetCacheId(mozIStorageConnection& aConn, Namespace aNamespace, const nsAString& aKey) { MOZ_ASSERT(!NS_IsMainThread()); // How we constrain the key column depends on the value of our key. Use // a format string for the query and let CreateAndBindKeyStatement() fill // it in for us. const char* const query = "SELECT cache_id FROM storage " "WHERE namespace=:namespace AND %s " "ORDER BY rowid;"; CACHE_TRY_INSPECT(const auto& state, CreateAndBindKeyStatement(aConn, query, aKey)); CACHE_TRY(state->BindInt32ByName("namespace"_ns, aNamespace)); CACHE_TRY_INSPECT(const bool& hasMoreData, MOZ_TO_RESULT_INVOKE(*state, ExecuteStep)); if (!hasMoreData) { return Maybe(); } CACHE_TRY_RETURN( MOZ_TO_RESULT_INVOKE(*state, GetInt64, 0).map(Some)); } nsresult StoragePutCache(mozIStorageConnection& aConn, Namespace aNamespace, const nsAString& aKey, CacheId aCacheId) { MOZ_ASSERT(!NS_IsMainThread()); CACHE_TRY_INSPECT(const auto& state, MOZ_TO_RESULT_INVOKE_TYPED( nsCOMPtr, aConn, CreateStatement, "INSERT INTO storage (namespace, key, cache_id) " "VALUES (:namespace, :key, :cache_id);"_ns)); CACHE_TRY(state->BindInt32ByName("namespace"_ns, aNamespace)); CACHE_TRY(state->BindStringAsBlobByName("key"_ns, aKey)); CACHE_TRY(state->BindInt64ByName("cache_id"_ns, aCacheId)); CACHE_TRY(state->Execute()); return NS_OK; } nsresult StorageForgetCache(mozIStorageConnection& aConn, Namespace aNamespace, const nsAString& aKey) { MOZ_ASSERT(!NS_IsMainThread()); // How we constrain the key column depends on the value of our key. Use // a format string for the query and let CreateAndBindKeyStatement() fill // it in for us. const char* const query = "DELETE FROM storage WHERE namespace=:namespace AND %s;"; CACHE_TRY_INSPECT(const auto& state, CreateAndBindKeyStatement(aConn, query, aKey)); CACHE_TRY(state->BindInt32ByName("namespace"_ns, aNamespace)); CACHE_TRY(state->Execute()); return NS_OK; } Result, nsresult> StorageGetKeys( mozIStorageConnection& aConn, Namespace aNamespace) { MOZ_ASSERT(!NS_IsMainThread()); CACHE_TRY_INSPECT( const auto& state, MOZ_TO_RESULT_INVOKE_TYPED( nsCOMPtr, aConn, CreateStatement, "SELECT key FROM storage WHERE namespace=:namespace ORDER BY rowid;"_ns)); CACHE_TRY(state->BindInt32ByName("namespace"_ns, aNamespace)); CACHE_TRY_RETURN(quota::CollectElementsWhileHasResult(*state, [](auto& stmt) { CACHE_TRY_RETURN( MOZ_TO_RESULT_INVOKE_TYPED(nsString, stmt, GetBlobAsString, 0)); })); } namespace { Result QueryAll(mozIStorageConnection& aConn, CacheId aCacheId) { MOZ_ASSERT(!NS_IsMainThread()); CACHE_TRY_INSPECT( const auto& state, MOZ_TO_RESULT_INVOKE_TYPED( nsCOMPtr, aConn, CreateStatement, "SELECT id FROM entries WHERE cache_id=:cache_id ORDER BY id;"_ns)); CACHE_TRY(state->BindInt64ByName("cache_id"_ns, aCacheId)); CACHE_TRY_RETURN((quota::CollectElementsWhileHasResultTyped( *state, [](auto& stmt) { CACHE_TRY_RETURN(MOZ_TO_RESULT_INVOKE(stmt, GetInt32, 0)); }))); } Result QueryCache(mozIStorageConnection& aConn, CacheId aCacheId, const CacheRequest& aRequest, const CacheQueryParams& aParams, uint32_t aMaxResults) { MOZ_ASSERT(!NS_IsMainThread()); MOZ_DIAGNOSTIC_ASSERT(aMaxResults > 0); if (!aParams.ignoreMethod() && !aRequest.method().LowerCaseEqualsLiteral("get")) { return Result{std::in_place}; } nsAutoCString query( "SELECT id, COUNT(response_headers.name) AS vary_count " "FROM entries " "LEFT OUTER JOIN response_headers ON " "entries.id=response_headers.entry_id " "AND response_headers.name='vary' COLLATE NOCASE " "WHERE entries.cache_id=:cache_id " "AND entries.request_url_no_query_hash=:url_no_query_hash "); if (!aParams.ignoreSearch()) { query.AppendLiteral("AND entries.request_url_query_hash=:url_query_hash "); } query.AppendLiteral("AND entries.request_url_no_query=:url_no_query "); if (!aParams.ignoreSearch()) { query.AppendLiteral("AND entries.request_url_query=:url_query "); } query.AppendLiteral("GROUP BY entries.id ORDER BY entries.id;"); CACHE_TRY_INSPECT(const auto& state, MOZ_TO_RESULT_INVOKE_TYPED(nsCOMPtr, aConn, CreateStatement, query)); CACHE_TRY(state->BindInt64ByName("cache_id"_ns, aCacheId)); CACHE_TRY_INSPECT( const auto& crypto, ToResultGet>( MOZ_SELECT_OVERLOAD(do_CreateInstance), NS_CRYPTO_HASH_CONTRACTID)); CACHE_TRY_INSPECT(const auto& urlWithoutQueryHash, HashCString(*crypto, aRequest.urlWithoutQuery())); CACHE_TRY(state->BindUTF8StringAsBlobByName("url_no_query_hash"_ns, urlWithoutQueryHash)); if (!aParams.ignoreSearch()) { CACHE_TRY_INSPECT(const auto& urlQueryHash, HashCString(*crypto, aRequest.urlQuery())); CACHE_TRY( state->BindUTF8StringAsBlobByName("url_query_hash"_ns, urlQueryHash)); } CACHE_TRY(state->BindUTF8StringByName("url_no_query"_ns, aRequest.urlWithoutQuery())); if (!aParams.ignoreSearch()) { CACHE_TRY(state->BindUTF8StringByName("url_query"_ns, aRequest.urlQuery())); } EntryIds entryIdList; CACHE_TRY(CollectWhile( [&state, &entryIdList, aMaxResults]() -> Result { if (entryIdList.Length() == aMaxResults) { return false; } CACHE_TRY_RETURN(MOZ_TO_RESULT_INVOKE(state, ExecuteStep)); }, [&state, &entryIdList, ignoreVary = aParams.ignoreVary(), &aConn, &aRequest]() -> Result { CACHE_TRY_INSPECT(const EntryId& entryId, MOZ_TO_RESULT_INVOKE(state, GetInt32, 0)); CACHE_TRY_INSPECT(const int32_t& varyCount, MOZ_TO_RESULT_INVOKE(state, GetInt32, 1)); if (!ignoreVary && varyCount > 0) { CACHE_TRY_INSPECT(const bool& matchedByVary, MatchByVaryHeader(aConn, aRequest, entryId)); if (!matchedByVary) { return Ok{}; } } entryIdList.AppendElement(entryId); return Ok{}; })); return entryIdList; } Result MatchByVaryHeader(mozIStorageConnection& aConn, const CacheRequest& aRequest, EntryId entryId) { MOZ_ASSERT(!NS_IsMainThread()); CACHE_TRY_INSPECT( const auto& varyValues, ([&aConn, entryId]() -> Result, nsresult> { CACHE_TRY_INSPECT( const auto& state, MOZ_TO_RESULT_INVOKE_TYPED(nsCOMPtr, aConn, CreateStatement, "SELECT value FROM response_headers " "WHERE name='vary' COLLATE NOCASE " "AND entry_id=:entry_id;"_ns)); CACHE_TRY(state->BindInt32ByName("entry_id"_ns, entryId)); CACHE_TRY_RETURN(( quota::CollectElementsWhileHasResultTyped>( *state, [](auto& stmt) { CACHE_TRY_RETURN(MOZ_TO_RESULT_INVOKE_TYPED( nsCString, stmt, GetUTF8String, 0)); }))); }())); // Should not have called this function if this was not the case MOZ_DIAGNOSTIC_ASSERT(!varyValues.IsEmpty()); CACHE_TRY_INSPECT(const auto& state, MOZ_TO_RESULT_INVOKE_TYPED( nsCOMPtr, aConn, CreateStatement, "SELECT name, value FROM request_headers " "WHERE entry_id=:entry_id;"_ns)); CACHE_TRY(state->BindInt32ByName("entry_id"_ns, entryId)); RefPtr cachedHeaders = new InternalHeaders(HeadersGuardEnum::None); CACHE_TRY(quota::CollectWhileHasResult( *state, [&cachedHeaders](auto& stmt) -> Result { CACHE_TRY_INSPECT( const auto& name, MOZ_TO_RESULT_INVOKE_TYPED(nsCString, stmt, GetUTF8String, 0)); CACHE_TRY_INSPECT( const auto& value, MOZ_TO_RESULT_INVOKE_TYPED(nsCString, stmt, GetUTF8String, 1)); ErrorResult errorResult; cachedHeaders->Append(name, value, errorResult); if (errorResult.Failed()) { return Err(errorResult.StealNSResult()); } return Ok{}; })); RefPtr queryHeaders = TypeUtils::ToInternalHeaders(aRequest.headers()); // Assume the vary headers match until we find a conflict bool varyHeadersMatch = true; for (const auto& varyValue : varyValues) { // Extract the header names inside the Vary header value. bool bailOut = false; for (const nsACString& header : nsCCharSeparatedTokenizer(varyValue, NS_HTTP_HEADER_SEP).ToRange()) { MOZ_DIAGNOSTIC_ASSERT(!header.EqualsLiteral("*"), "We should have already caught this in " "TypeUtils::ToPCacheResponseWithoutBody()"); ErrorResult errorResult; nsAutoCString queryValue; queryHeaders->Get(header, queryValue, errorResult); if (errorResult.Failed()) { errorResult.SuppressException(); MOZ_DIAGNOSTIC_ASSERT(queryValue.IsEmpty()); } nsAutoCString cachedValue; cachedHeaders->Get(header, cachedValue, errorResult); if (errorResult.Failed()) { errorResult.SuppressException(); MOZ_DIAGNOSTIC_ASSERT(cachedValue.IsEmpty()); } if (queryValue != cachedValue) { varyHeadersMatch = false; bailOut = true; break; } } if (bailOut) { break; } } return varyHeadersMatch; } static nsresult DeleteEntriesInternal( mozIStorageConnection& aConn, const nsTArray& aEntryIdList, nsTArray& aDeletedBodyIdListOut, nsTArray& aDeletedSecurityIdListOut, int64_t* aDeletedPaddingSizeOut, uint32_t aPos, uint32_t aLen) { MOZ_ASSERT(!NS_IsMainThread()); MOZ_DIAGNOSTIC_ASSERT(aDeletedPaddingSizeOut); if (aEntryIdList.IsEmpty()) { return NS_OK; } MOZ_DIAGNOSTIC_ASSERT(aPos < aEntryIdList.Length()); // Sqlite limits the number of entries allowed for an IN clause, // so split up larger operations. if (aLen > kMaxEntriesPerStatement) { int64_t overallDeletedPaddingSize = 0; uint32_t curPos = aPos; int32_t remaining = aLen; while (remaining > 0) { int64_t deletedPaddingSize = 0; int32_t max = kMaxEntriesPerStatement; int32_t curLen = std::min(max, remaining); nsresult rv = DeleteEntriesInternal( aConn, aEntryIdList, aDeletedBodyIdListOut, aDeletedSecurityIdListOut, &deletedPaddingSize, curPos, curLen); if (NS_FAILED(rv)) { return rv; } MOZ_DIAGNOSTIC_ASSERT(INT64_MAX - deletedPaddingSize >= overallDeletedPaddingSize); overallDeletedPaddingSize += deletedPaddingSize; curPos += curLen; remaining -= curLen; } *aDeletedPaddingSizeOut += overallDeletedPaddingSize; return NS_OK; } nsAutoCString query( "SELECT " "request_body_id, " "response_body_id, " "response_security_info_id, " "response_padding_size " "FROM entries WHERE id IN ("); AppendListParamsToQuery(query, aEntryIdList, aPos, aLen); query.AppendLiteral(")"); CACHE_TRY_INSPECT(const auto& state, MOZ_TO_RESULT_INVOKE_TYPED(nsCOMPtr, aConn, CreateStatement, query)); CACHE_TRY(BindListParamsToQuery(*state, aEntryIdList, aPos, aLen)); int64_t overallPaddingSize = 0; CACHE_TRY(quota::CollectWhileHasResult( *state, [&overallPaddingSize, &aDeletedBodyIdListOut, &aDeletedSecurityIdListOut](auto& stmt) -> Result { // extract 0 to 2 nsID structs per row for (uint32_t i = 0; i < 2; ++i) { CACHE_TRY_INSPECT(const bool& isNull, MOZ_TO_RESULT_INVOKE(stmt, GetIsNull, i)); if (!isNull) { CACHE_TRY_INSPECT(const auto& id, ExtractId(stmt, i)); aDeletedBodyIdListOut.AppendElement(id); } } { // and then a possible third entry for the security id CACHE_TRY_INSPECT(const bool& isNull, MOZ_TO_RESULT_INVOKE(stmt, GetIsNull, 2)); if (!isNull) { CACHE_TRY_INSPECT(const int32_t& securityId, MOZ_TO_RESULT_INVOKE(stmt, GetInt32, 2)); // XXXtt: Consider using map for aDeletedSecuityIdListOut. auto foundIt = std::find_if(aDeletedSecurityIdListOut.begin(), aDeletedSecurityIdListOut.end(), [securityId](const auto& deletedSecurityId) { return deletedSecurityId.mId == securityId; }); if (foundIt == aDeletedSecurityIdListOut.end()) { // Add a new entry for this ID with a count of 1, if it's not in // the list aDeletedSecurityIdListOut.AppendElement(IdCount(securityId)); } else { // Otherwise, increment the count for this ID foundIt->mCount += 1; } } } { // It's possible to have null padding size for non-opaque response CACHE_TRY_INSPECT(const bool& isNull, MOZ_TO_RESULT_INVOKE(stmt, GetIsNull, 3)); if (!isNull) { CACHE_TRY_INSPECT(const int64_t& paddingSize, MOZ_TO_RESULT_INVOKE(stmt, GetInt64, 3)); MOZ_DIAGNOSTIC_ASSERT(paddingSize >= 0); MOZ_DIAGNOSTIC_ASSERT(INT64_MAX - overallPaddingSize >= paddingSize); overallPaddingSize += paddingSize; } } return Ok{}; })); *aDeletedPaddingSizeOut = overallPaddingSize; // Dependent records removed via ON DELETE CASCADE query = "DELETE FROM entries WHERE id IN ("_ns; AppendListParamsToQuery(query, aEntryIdList, aPos, aLen); query.AppendLiteral(")"); { CACHE_TRY_INSPECT(const auto& state, MOZ_TO_RESULT_INVOKE_TYPED( nsCOMPtr, aConn, CreateStatement, query)); CACHE_TRY(BindListParamsToQuery(*state, aEntryIdList, aPos, aLen)); CACHE_TRY(state->Execute()); } return NS_OK; } Result, AutoTArray, int64_t>, nsresult> DeleteEntries(mozIStorageConnection& aConn, const nsTArray& aEntryIdList) { auto result = std::make_tuple(nsTArray{}, AutoTArray{}, int64_t{0}); CACHE_TRY(DeleteEntriesInternal(aConn, aEntryIdList, std::get<0>(result), std::get<1>(result), &std::get<2>(result), 0, aEntryIdList.Length())); return result; } Result InsertSecurityInfo(mozIStorageConnection& aConn, nsICryptoHash& aCrypto, const nsACString& aData) { MOZ_DIAGNOSTIC_ASSERT(!aData.IsEmpty()); // We want to use an index to find existing security blobs, but indexing // the full blob would be quite expensive. Instead, we index a small // hash value. Calculate this hash as the first 8 bytes of the SHA1 of // the full data. CACHE_TRY_INSPECT(const auto& hash, HashCString(aCrypto, aData)); // Next, search for an existing entry for this blob by comparing the hash // value first and then the full data. SQLite is smart enough to use // the index on the hash to search the table before doing the expensive // comparison of the large data column. (This was verified with EXPLAIN.) CACHE_TRY_INSPECT( const auto& selectStmt, quota::CreateAndExecuteSingleStepStatement< quota::SingleStepResult::ReturnNullIfNoResult>( aConn, // Note that hash and data are blobs, but we can use = here since the // columns are NOT NULL. "SELECT id, refcount FROM security_info WHERE hash=:hash AND " "data=:data;"_ns, [&hash, &aData](auto& state) -> Result { CACHE_TRY(state.BindUTF8StringAsBlobByName("hash"_ns, hash)); CACHE_TRY(state.BindUTF8StringAsBlobByName("data"_ns, aData)); return Ok{}; })); // This security info blob is already in the database if (selectStmt) { // get the existing security blob id to return CACHE_TRY_INSPECT(const int32_t& id, MOZ_TO_RESULT_INVOKE(selectStmt, GetInt32, 0)); CACHE_TRY_INSPECT(const int32_t& refcount, MOZ_TO_RESULT_INVOKE(selectStmt, GetInt32, 1)); // But first, update the refcount in the database. CACHE_TRY_INSPECT( const auto& state, MOZ_TO_RESULT_INVOKE_TYPED( nsCOMPtr, aConn, CreateStatement, "UPDATE security_info SET refcount=:refcount WHERE id=:id;"_ns)); CACHE_TRY(state->BindInt32ByName("refcount"_ns, refcount + 1)); CACHE_TRY(state->BindInt32ByName("id"_ns, id)); CACHE_TRY(state->Execute()); return id; } // This is a new security info blob. Create a new row in the security table // with an initial refcount of 1. CACHE_TRY_INSPECT(const auto& state, MOZ_TO_RESULT_INVOKE_TYPED( nsCOMPtr, aConn, CreateStatement, "INSERT INTO security_info (hash, data, refcount) " "VALUES (:hash, :data, 1);"_ns)); CACHE_TRY(state->BindUTF8StringAsBlobByName("hash"_ns, hash)); CACHE_TRY(state->BindUTF8StringAsBlobByName("data"_ns, aData)); CACHE_TRY(state->Execute()); { CACHE_TRY_INSPECT(const auto& state, quota::CreateAndExecuteSingleStepStatement( aConn, "SELECT last_insert_rowid()"_ns)); CACHE_TRY_RETURN(MOZ_TO_RESULT_INVOKE(*state, GetInt32, 0)); } } nsresult DeleteSecurityInfo(mozIStorageConnection& aConn, int32_t aId, int32_t aCount) { // First, we need to determine the current refcount for this security blob. CACHE_TRY_INSPECT( const int32_t& refcount, ([&aConn, aId]() -> Result { CACHE_TRY_INSPECT( const auto& state, quota::CreateAndExecuteSingleStepStatement( aConn, "SELECT refcount FROM security_info WHERE id=:id;"_ns, [aId](auto& state) -> Result { CACHE_TRY(state.BindInt32ByName("id"_ns, aId)); return Ok{}; })); CACHE_TRY_RETURN(MOZ_TO_RESULT_INVOKE(*state, GetInt32, 0)); }())); MOZ_DIAGNOSTIC_ASSERT(refcount >= aCount); // Next, calculate the new refcount int32_t newCount = refcount - aCount; // If the last reference to this security blob was removed we can // just remove the entire row. if (newCount == 0) { CACHE_TRY_INSPECT( const auto& state, MOZ_TO_RESULT_INVOKE_TYPED( nsCOMPtr, aConn, CreateStatement, "DELETE FROM security_info WHERE id=:id;"_ns)); CACHE_TRY(state->BindInt32ByName("id"_ns, aId)); CACHE_TRY(state->Execute()); return NS_OK; } // Otherwise update the refcount in the table to reflect the reduced // number of references to the security blob. CACHE_TRY_INSPECT( const auto& state, MOZ_TO_RESULT_INVOKE_TYPED( nsCOMPtr, aConn, CreateStatement, "UPDATE security_info SET refcount=:refcount WHERE id=:id;"_ns)); CACHE_TRY(state->BindInt32ByName("refcount"_ns, newCount)); CACHE_TRY(state->BindInt32ByName("id"_ns, aId)); CACHE_TRY(state->Execute()); return NS_OK; } nsresult DeleteSecurityInfoList( mozIStorageConnection& aConn, const nsTArray& aDeletedStorageIdList) { for (const auto& deletedStorageId : aDeletedStorageIdList) { CACHE_TRY(DeleteSecurityInfo(aConn, deletedStorageId.mId, deletedStorageId.mCount)); } return NS_OK; } nsresult InsertEntry(mozIStorageConnection& aConn, CacheId aCacheId, const CacheRequest& aRequest, const nsID* aRequestBodyId, const CacheResponse& aResponse, const nsID* aResponseBodyId) { MOZ_ASSERT(!NS_IsMainThread()); CACHE_TRY_INSPECT( const auto& crypto, ToResultGet>( MOZ_SELECT_OVERLOAD(do_CreateInstance), NS_CRYPTO_HASH_CONTRACTID)); int32_t securityId = -1; if (!aResponse.channelInfo().securityInfo().IsEmpty()) { CACHE_TRY_UNWRAP( securityId, InsertSecurityInfo(aConn, *crypto, aResponse.channelInfo().securityInfo())); } { CACHE_TRY_INSPECT(const auto& state, MOZ_TO_RESULT_INVOKE_TYPED(nsCOMPtr, aConn, CreateStatement, "INSERT INTO entries (" "request_method, " "request_url_no_query, " "request_url_no_query_hash, " "request_url_query, " "request_url_query_hash, " "request_url_fragment, " "request_referrer, " "request_referrer_policy, " "request_headers_guard, " "request_mode, " "request_credentials, " "request_contentpolicytype, " "request_cache, " "request_redirect, " "request_integrity, " "request_body_id, " "response_type, " "response_status, " "response_status_text, " "response_headers_guard, " "response_body_id, " "response_security_info_id, " "response_principal_info, " "response_padding_size, " "cache_id " ") VALUES (" ":request_method, " ":request_url_no_query, " ":request_url_no_query_hash, " ":request_url_query, " ":request_url_query_hash, " ":request_url_fragment, " ":request_referrer, " ":request_referrer_policy, " ":request_headers_guard, " ":request_mode, " ":request_credentials, " ":request_contentpolicytype, " ":request_cache, " ":request_redirect, " ":request_integrity, " ":request_body_id, " ":response_type, " ":response_status, " ":response_status_text, " ":response_headers_guard, " ":response_body_id, " ":response_security_info_id, " ":response_principal_info, " ":response_padding_size, " ":cache_id " ");"_ns)); CACHE_TRY( state->BindUTF8StringByName("request_method"_ns, aRequest.method())); CACHE_TRY(state->BindUTF8StringByName("request_url_no_query"_ns, aRequest.urlWithoutQuery())); CACHE_TRY_INSPECT(const auto& urlWithoutQueryHash, HashCString(*crypto, aRequest.urlWithoutQuery())); CACHE_TRY(state->BindUTF8StringAsBlobByName("request_url_no_query_hash"_ns, urlWithoutQueryHash)); CACHE_TRY(state->BindUTF8StringByName("request_url_query"_ns, aRequest.urlQuery())); CACHE_TRY_INSPECT(const auto& urlQueryHash, HashCString(*crypto, aRequest.urlQuery())); CACHE_TRY(state->BindUTF8StringAsBlobByName("request_url_query_hash"_ns, urlQueryHash)); CACHE_TRY(state->BindUTF8StringByName("request_url_fragment"_ns, aRequest.urlFragment())); CACHE_TRY( state->BindStringByName("request_referrer"_ns, aRequest.referrer())); CACHE_TRY(state->BindInt32ByName( "request_referrer_policy"_ns, static_cast(aRequest.referrerPolicy()))); CACHE_TRY( state->BindInt32ByName("request_headers_guard"_ns, static_cast(aRequest.headersGuard()))); CACHE_TRY(state->BindInt32ByName("request_mode"_ns, static_cast(aRequest.mode()))); CACHE_TRY( state->BindInt32ByName("request_credentials"_ns, static_cast(aRequest.credentials()))); CACHE_TRY(state->BindInt32ByName( "request_contentpolicytype"_ns, static_cast(aRequest.contentPolicyType()))); CACHE_TRY(state->BindInt32ByName( "request_cache"_ns, static_cast(aRequest.requestCache()))); CACHE_TRY(state->BindInt32ByName( "request_redirect"_ns, static_cast(aRequest.requestRedirect()))); CACHE_TRY( state->BindStringByName("request_integrity"_ns, aRequest.integrity())); CACHE_TRY(BindId(*state, "request_body_id"_ns, aRequestBodyId)); CACHE_TRY(state->BindInt32ByName("response_type"_ns, static_cast(aResponse.type()))); CACHE_TRY(state->BindInt32ByName("response_status"_ns, aResponse.status())); CACHE_TRY(state->BindUTF8StringByName("response_status_text"_ns, aResponse.statusText())); CACHE_TRY( state->BindInt32ByName("response_headers_guard"_ns, static_cast(aResponse.headersGuard()))); CACHE_TRY(BindId(*state, "response_body_id"_ns, aResponseBodyId)); if (aResponse.channelInfo().securityInfo().IsEmpty()) { CACHE_TRY(state->BindNullByName("response_security_info_id"_ns)); } else { CACHE_TRY( state->BindInt32ByName("response_security_info_id"_ns, securityId)); } nsAutoCString serializedInfo; // We only allow content serviceworkers right now. if (aResponse.principalInfo().isSome()) { const mozilla::ipc::PrincipalInfo& principalInfo = aResponse.principalInfo().ref(); MOZ_DIAGNOSTIC_ASSERT(principalInfo.type() == mozilla::ipc::PrincipalInfo::TContentPrincipalInfo); const mozilla::ipc::ContentPrincipalInfo& cInfo = principalInfo.get_ContentPrincipalInfo(); serializedInfo.Append(cInfo.spec()); nsAutoCString suffix; cInfo.attrs().CreateSuffix(suffix); serializedInfo.Append(suffix); } CACHE_TRY(state->BindUTF8StringByName("response_principal_info"_ns, serializedInfo)); if (aResponse.paddingSize() == InternalResponse::UNKNOWN_PADDING_SIZE) { MOZ_DIAGNOSTIC_ASSERT(aResponse.type() != ResponseType::Opaque); CACHE_TRY(state->BindNullByName("response_padding_size"_ns)); } else { MOZ_DIAGNOSTIC_ASSERT(aResponse.paddingSize() >= 0); MOZ_DIAGNOSTIC_ASSERT(aResponse.type() == ResponseType::Opaque); CACHE_TRY(state->BindInt64ByName("response_padding_size"_ns, aResponse.paddingSize())); } CACHE_TRY(state->BindInt64ByName("cache_id"_ns, aCacheId)); CACHE_TRY(state->Execute()); } CACHE_TRY_INSPECT( const int32_t& entryId, ([&aConn]() -> Result { CACHE_TRY_INSPECT(const auto& state, quota::CreateAndExecuteSingleStepStatement( aConn, "SELECT last_insert_rowid()"_ns)); CACHE_TRY_RETURN(MOZ_TO_RESULT_INVOKE(*state, GetInt32, 0)); }())); { CACHE_TRY_INSPECT( const auto& state, MOZ_TO_RESULT_INVOKE_TYPED(nsCOMPtr, aConn, CreateStatement, "INSERT INTO request_headers (" "name, " "value, " "entry_id " ") VALUES (:name, :value, :entry_id)"_ns)); for (const auto& requestHeader : aRequest.headers()) { CACHE_TRY(state->BindUTF8StringByName("name"_ns, requestHeader.name())); CACHE_TRY(state->BindUTF8StringByName("value"_ns, requestHeader.value())); CACHE_TRY(state->BindInt32ByName("entry_id"_ns, entryId)); CACHE_TRY(state->Execute()); } } { CACHE_TRY_INSPECT( const auto& state, MOZ_TO_RESULT_INVOKE_TYPED(nsCOMPtr, aConn, CreateStatement, "INSERT INTO response_headers (" "name, " "value, " "entry_id " ") VALUES (:name, :value, :entry_id)"_ns)); for (const auto& responseHeader : aResponse.headers()) { CACHE_TRY(state->BindUTF8StringByName("name"_ns, responseHeader.name())); CACHE_TRY( state->BindUTF8StringByName("value"_ns, responseHeader.value())); CACHE_TRY(state->BindInt32ByName("entry_id"_ns, entryId)); CACHE_TRY(state->Execute()); } } { CACHE_TRY_INSPECT(const auto& state, MOZ_TO_RESULT_INVOKE_TYPED( nsCOMPtr, aConn, CreateStatement, "INSERT INTO response_url_list (" "url, " "entry_id " ") VALUES (:url, :entry_id)"_ns)); for (const auto& responseUrl : aResponse.urlList()) { CACHE_TRY(state->BindUTF8StringByName("url"_ns, responseUrl)); CACHE_TRY(state->BindInt32ByName("entry_id"_ns, entryId)); CACHE_TRY(state->Execute()); } } return NS_OK; } /** * Gets a HeadersEntry from a storage statement by retrieving the first column * as the name and the second column as the value. */ Result GetHeadersEntryFromStatement( mozIStorageStatement& aStmt) { HeadersEntry header; CACHE_TRY_UNWRAP(header.name(), MOZ_TO_RESULT_INVOKE_TYPED(nsCString, aStmt, GetUTF8String, 0)); CACHE_TRY_UNWRAP(header.value(), MOZ_TO_RESULT_INVOKE_TYPED( nsCString, aStmt, GetUTF8String, 1)); return header; } Result ReadResponse(mozIStorageConnection& aConn, EntryId aEntryId) { MOZ_ASSERT(!NS_IsMainThread()); SavedResponse savedResponse; CACHE_TRY_INSPECT(const auto& state, quota::CreateAndExecuteSingleStepStatement( aConn, "SELECT " "entries.response_type, " "entries.response_status, " "entries.response_status_text, " "entries.response_headers_guard, " "entries.response_body_id, " "entries.response_principal_info, " "entries.response_padding_size, " "security_info.data " "FROM entries " "LEFT OUTER JOIN security_info " "ON entries.response_security_info_id=security_info.id " "WHERE entries.id=:id;"_ns, [aEntryId](auto& state) -> Result { CACHE_TRY(state.BindInt32ByName("id"_ns, aEntryId)); return Ok{}; })); CACHE_TRY_INSPECT(const int32_t& type, MOZ_TO_RESULT_INVOKE(*state, GetInt32, 0)); savedResponse.mValue.type() = static_cast(type); CACHE_TRY_INSPECT(const int32_t& status, MOZ_TO_RESULT_INVOKE(*state, GetInt32, 1)); savedResponse.mValue.status() = static_cast(status); CACHE_TRY(state->GetUTF8String(2, savedResponse.mValue.statusText())); CACHE_TRY_INSPECT(const int32_t& guard, MOZ_TO_RESULT_INVOKE(*state, GetInt32, 3)); savedResponse.mValue.headersGuard() = static_cast(guard); CACHE_TRY_INSPECT(const bool& nullBody, MOZ_TO_RESULT_INVOKE(*state, GetIsNull, 4)); savedResponse.mHasBodyId = !nullBody; if (savedResponse.mHasBodyId) { CACHE_TRY_UNWRAP(savedResponse.mBodyId, ExtractId(*state, 4)); } CACHE_TRY_INSPECT( const auto& serializedInfo, MOZ_TO_RESULT_INVOKE_TYPED(nsAutoCString, *state, GetUTF8String, 5)); savedResponse.mValue.principalInfo() = Nothing(); if (!serializedInfo.IsEmpty()) { nsAutoCString specNoSuffix; OriginAttributes attrs; if (!attrs.PopulateFromOrigin(serializedInfo, specNoSuffix)) { NS_WARNING("Something went wrong parsing a serialized principal!"); return Err(NS_ERROR_FAILURE); } RefPtr url; CACHE_TRY(net::MozURL::Init(getter_AddRefs(url), specNoSuffix)); #ifdef DEBUG nsDependentCSubstring scheme = url->Scheme(); MOZ_ASSERT( scheme == "http" || scheme == "https" || scheme == "file" || // A cached response entry may have a moz-extension principal if: // // - This is an extension background service worker. The response for // the main script is expected tobe a moz-extension content principal // (the pref "extensions.backgroundServiceWorker.enabled" must be // enabled, if the pref is toggled to false at runtime then any // service worker registered for a moz-extension principal will be // unregistered on the next startup). // // - An extension is redirecting a script being imported info a worker // created from a regular webpage to a web-accessible extension // script. The reponse for these redirects will have a moz-extension // principal. Although extensions can attempt to redirect the main // script of service workers, this will always cause the install // process to fail. scheme == "moz-extension"); #endif nsCString origin; url->Origin(origin); nsCString baseDomain; CACHE_TRY(url->BaseDomain(baseDomain)); savedResponse.mValue.principalInfo() = Some(mozilla::ipc::ContentPrincipalInfo(attrs, origin, specNoSuffix, Nothing(), baseDomain)); } CACHE_TRY_INSPECT(const bool& nullPadding, MOZ_TO_RESULT_INVOKE(*state, GetIsNull, 6)); if (nullPadding) { MOZ_DIAGNOSTIC_ASSERT(savedResponse.mValue.type() != ResponseType::Opaque); savedResponse.mValue.paddingSize() = InternalResponse::UNKNOWN_PADDING_SIZE; } else { MOZ_DIAGNOSTIC_ASSERT(savedResponse.mValue.type() == ResponseType::Opaque); CACHE_TRY_INSPECT(const int64_t& paddingSize, MOZ_TO_RESULT_INVOKE(*state, GetInt64, 6)); MOZ_DIAGNOSTIC_ASSERT(paddingSize >= 0); savedResponse.mValue.paddingSize() = paddingSize; } CACHE_TRY(state->GetBlobAsUTF8String( 7, savedResponse.mValue.channelInfo().securityInfo())); { CACHE_TRY_INSPECT(const auto& state, MOZ_TO_RESULT_INVOKE_TYPED( nsCOMPtr, aConn, CreateStatement, "SELECT " "name, " "value " "FROM response_headers " "WHERE entry_id=:entry_id;"_ns)); CACHE_TRY(state->BindInt32ByName("entry_id"_ns, aEntryId)); CACHE_TRY_UNWRAP(savedResponse.mValue.headers(), quota::CollectElementsWhileHasResult( *state, GetHeadersEntryFromStatement)); } { CACHE_TRY_INSPECT(const auto& state, MOZ_TO_RESULT_INVOKE_TYPED( nsCOMPtr, aConn, CreateStatement, "SELECT " "url " "FROM response_url_list " "WHERE entry_id=:entry_id;"_ns)); CACHE_TRY(state->BindInt32ByName("entry_id"_ns, aEntryId)); CACHE_TRY_UNWRAP(savedResponse.mValue.urlList(), quota::CollectElementsWhileHasResult( *state, [](auto& stmt) -> Result { CACHE_TRY_RETURN(MOZ_TO_RESULT_INVOKE_TYPED( nsCString, stmt, GetUTF8String, 0)); })); } return savedResponse; } Result ReadRequest(mozIStorageConnection& aConn, EntryId aEntryId) { MOZ_ASSERT(!NS_IsMainThread()); SavedRequest savedRequest; CACHE_TRY_INSPECT(const auto& state, quota::CreateAndExecuteSingleStepStatement< quota::SingleStepResult::ReturnNullIfNoResult>( aConn, "SELECT " "request_method, " "request_url_no_query, " "request_url_query, " "request_url_fragment, " "request_referrer, " "request_referrer_policy, " "request_headers_guard, " "request_mode, " "request_credentials, " "request_contentpolicytype, " "request_cache, " "request_redirect, " "request_integrity, " "request_body_id " "FROM entries " "WHERE id=:id;"_ns, [aEntryId](auto& state) -> Result { CACHE_TRY(state.BindInt32ByName("id"_ns, aEntryId)); return Ok{}; })); CACHE_TRY(OkIf(state), Err(NS_ERROR_UNEXPECTED)); CACHE_TRY(state->GetUTF8String(0, savedRequest.mValue.method())); CACHE_TRY(state->GetUTF8String(1, savedRequest.mValue.urlWithoutQuery())); CACHE_TRY(state->GetUTF8String(2, savedRequest.mValue.urlQuery())); CACHE_TRY(state->GetUTF8String(3, savedRequest.mValue.urlFragment())); CACHE_TRY(state->GetString(4, savedRequest.mValue.referrer())); CACHE_TRY_INSPECT(const int32_t& referrerPolicy, MOZ_TO_RESULT_INVOKE(state, GetInt32, 5)); savedRequest.mValue.referrerPolicy() = static_cast(referrerPolicy); CACHE_TRY_INSPECT(const int32_t& guard, MOZ_TO_RESULT_INVOKE(state, GetInt32, 6)); savedRequest.mValue.headersGuard() = static_cast(guard); CACHE_TRY_INSPECT(const int32_t& mode, MOZ_TO_RESULT_INVOKE(state, GetInt32, 7)); savedRequest.mValue.mode() = static_cast(mode); CACHE_TRY_INSPECT(const int32_t& credentials, MOZ_TO_RESULT_INVOKE(state, GetInt32, 8)); savedRequest.mValue.credentials() = static_cast(credentials); CACHE_TRY_INSPECT(const int32_t& requestContentPolicyType, MOZ_TO_RESULT_INVOKE(state, GetInt32, 9)); savedRequest.mValue.contentPolicyType() = static_cast(requestContentPolicyType); CACHE_TRY_INSPECT(const int32_t& requestCache, MOZ_TO_RESULT_INVOKE(state, GetInt32, 10)); savedRequest.mValue.requestCache() = static_cast(requestCache); CACHE_TRY_INSPECT(const int32_t& requestRedirect, MOZ_TO_RESULT_INVOKE(state, GetInt32, 11)); savedRequest.mValue.requestRedirect() = static_cast(requestRedirect); CACHE_TRY(state->GetString(12, savedRequest.mValue.integrity())); CACHE_TRY_INSPECT(const bool& nullBody, MOZ_TO_RESULT_INVOKE(state, GetIsNull, 13)); savedRequest.mHasBodyId = !nullBody; if (savedRequest.mHasBodyId) { CACHE_TRY_UNWRAP(savedRequest.mBodyId, ExtractId(*state, 13)); } { CACHE_TRY_INSPECT(const auto& state, MOZ_TO_RESULT_INVOKE_TYPED( nsCOMPtr, aConn, CreateStatement, "SELECT " "name, " "value " "FROM request_headers " "WHERE entry_id=:entry_id;"_ns)); CACHE_TRY(state->BindInt32ByName("entry_id"_ns, aEntryId)); CACHE_TRY_UNWRAP(savedRequest.mValue.headers(), quota::CollectElementsWhileHasResult( *state, GetHeadersEntryFromStatement)); } return savedRequest; } void AppendListParamsToQuery(nsACString& aQuery, const nsTArray& aEntryIdList, uint32_t aPos, int32_t aLen) { MOZ_ASSERT(!NS_IsMainThread()); MOZ_DIAGNOSTIC_ASSERT((aPos + aLen) <= aEntryIdList.Length()); // XXX This seems to be quite inefficient. Can't we do a BulkWrite? for (int32_t i = aPos; i < aLen; ++i) { if (i == 0) { aQuery.AppendLiteral("?"); } else { aQuery.AppendLiteral(",?"); } } } nsresult BindListParamsToQuery(mozIStorageStatement& aState, const nsTArray& aEntryIdList, uint32_t aPos, int32_t aLen) { MOZ_ASSERT(!NS_IsMainThread()); MOZ_DIAGNOSTIC_ASSERT((aPos + aLen) <= aEntryIdList.Length()); for (int32_t i = aPos; i < aLen; ++i) { CACHE_TRY(aState.BindInt32ByIndex(i, aEntryIdList[i])); } return NS_OK; } nsresult BindId(mozIStorageStatement& aState, const nsACString& aName, const nsID* aId) { MOZ_ASSERT(!NS_IsMainThread()); if (!aId) { CACHE_TRY(aState.BindNullByName(aName)); return NS_OK; } char idBuf[NSID_LENGTH]; aId->ToProvidedString(idBuf); CACHE_TRY(aState.BindUTF8StringByName(aName, nsDependentCString(idBuf))); return NS_OK; } Result ExtractId(mozIStorageStatement& aState, uint32_t aPos) { MOZ_ASSERT(!NS_IsMainThread()); CACHE_TRY_INSPECT( const auto& idString, MOZ_TO_RESULT_INVOKE_TYPED(nsAutoCString, aState, GetUTF8String, aPos)); nsID id; CACHE_TRY(OkIf(id.Parse(idString.get())), Err(NS_ERROR_UNEXPECTED)); return id; } Result>, nsresult> CreateAndBindKeyStatement(mozIStorageConnection& aConn, const char* const aQueryFormat, const nsAString& aKey) { MOZ_DIAGNOSTIC_ASSERT(aQueryFormat); // The key is stored as a blob to avoid encoding issues. An empty string // is mapped to NULL for blobs. Normally we would just write the query // as "key IS :key" to do the proper NULL checking, but that prevents // sqlite from using the key index. Therefore use "IS NULL" explicitly // if the key is empty, otherwise use "=:key" so that sqlite uses the // index. CACHE_TRY_UNWRAP( auto state, MOZ_TO_RESULT_INVOKE_TYPED( nsCOMPtr, aConn, CreateStatement, nsPrintfCString(aQueryFormat, aKey.IsEmpty() ? "key IS NULL" : "key=:key"))); if (!aKey.IsEmpty()) { CACHE_TRY(state->BindStringAsBlobByName("key"_ns, aKey)); } return WrapNotNull(std::move(state)); } Result HashCString(nsICryptoHash& aCrypto, const nsACString& aIn) { CACHE_TRY(aCrypto.Init(nsICryptoHash::SHA1)); CACHE_TRY(aCrypto.Update(reinterpret_cast(aIn.BeginReading()), aIn.Length())); nsAutoCString fullHash; CACHE_TRY(aCrypto.Finish(false /* based64 result */, fullHash)); return Result{std::in_place, Substring(fullHash, 0, 8)}; } } // namespace nsresult IncrementalVacuum(mozIStorageConnection& aConn) { // Determine how much free space is in the database. CACHE_TRY_INSPECT(const auto& state, quota::CreateAndExecuteSingleStepStatement( aConn, "PRAGMA freelist_count;"_ns)); CACHE_TRY_INSPECT(const int32_t& freePages, MOZ_TO_RESULT_INVOKE(*state, GetInt32, 0)); // We have a relatively small page size, so we want to be careful to avoid // fragmentation. We already use a growth incremental which will cause // sqlite to allocate and release multiple pages at the same time. We can // further reduce fragmentation by making our allocated chunks a bit // "sticky". This is done by creating some hysteresis where we allocate // pages/chunks as soon as we need them, but we only release pages/chunks // when we have a large amount of free space. This helps with the case // where a page is adding and remove resources causing it to dip back and // forth across a chunk boundary. // // So only proceed with releasing pages if we have more than our constant // threshold. if (freePages <= kMaxFreePages) { return NS_OK; } // Release the excess pages back to the sqlite VFS. This may also release // chunks of multiple pages back to the OS. const int32_t pagesToRelease = freePages - kMaxFreePages; CACHE_TRY(aConn.ExecuteSimpleSQL( nsPrintfCString("PRAGMA incremental_vacuum(%d);", pagesToRelease))); // Verify that our incremental vacuum actually did something #ifdef DEBUG { CACHE_TRY_INSPECT(const auto& state, quota::CreateAndExecuteSingleStepStatement( aConn, "PRAGMA freelist_count;"_ns)); CACHE_TRY_INSPECT(const int32_t& freePages, MOZ_TO_RESULT_INVOKE(*state, GetInt32, 0)); MOZ_ASSERT(freePages <= kMaxFreePages); } #endif return NS_OK; } namespace { // Wrapper around mozIStorageConnection::GetSchemaVersion() that compensates // for hacky downgrade schema version tricks. See the block comments for // kHackyDowngradeSchemaVersion and kHackyPaddingSizePresentVersion. Result GetEffectiveSchemaVersion( mozIStorageConnection& aConn) { CACHE_TRY_INSPECT(const int32_t& schemaVersion, MOZ_TO_RESULT_INVOKE(aConn, GetSchemaVersion)); if (schemaVersion == kHackyDowngradeSchemaVersion) { // This is the special case. Check for the existence of the // "response_padding_size" colum in table "entries". // // (pragma_table_info is a table-valued function format variant of // "PRAGMA table_info" supported since SQLite 3.16.0. Firefox 53 shipped // was the first release with this functionality, shipping 3.16.2.) // // If there are any result rows, then the column is present. CACHE_TRY_INSPECT(const bool& hasColumn, quota::CreateAndExecuteSingleStepStatement< quota::SingleStepResult::ReturnNullIfNoResult>( aConn, "SELECT name FROM pragma_table_info('entries') WHERE " "name = 'response_padding_size'"_ns)); if (hasColumn) { return kHackyPaddingSizePresentVersion; } } return schemaVersion; } #ifdef DEBUG struct Expect { // Expect exact SQL Expect(const char* aName, const char* aType, const char* aSql) : mName(aName), mType(aType), mSql(aSql), mIgnoreSql(false) {} // Ignore SQL Expect(const char* aName, const char* aType) : mName(aName), mType(aType), mIgnoreSql(true) {} const nsCString mName; const nsCString mType; const nsCString mSql; const bool mIgnoreSql; }; #endif nsresult Validate(mozIStorageConnection& aConn) { CACHE_TRY_INSPECT(const int32_t& schemaVersion, GetEffectiveSchemaVersion(aConn)); CACHE_TRY(OkIf(schemaVersion == kLatestSchemaVersion), NS_ERROR_FAILURE); #ifdef DEBUG // This is the schema we expect the database at the latest version to // contain. Update this list if you add a new table or index. const Expect expects[] = { Expect("caches", "table", kTableCaches), Expect("sqlite_sequence", "table"), // auto-gen by sqlite Expect("security_info", "table", kTableSecurityInfo), Expect("security_info_hash_index", "index", kIndexSecurityInfoHash), Expect("entries", "table", kTableEntries), Expect("entries_request_match_index", "index", kIndexEntriesRequest), Expect("request_headers", "table", kTableRequestHeaders), Expect("response_headers", "table", kTableResponseHeaders), Expect("response_headers_name_index", "index", kIndexResponseHeadersName), Expect("response_url_list", "table", kTableResponseUrlList), Expect("storage", "table", kTableStorage), Expect("sqlite_autoindex_storage_1", "index"), // auto-gen by sqlite }; // Read the schema from the sqlite_master table and compare. CACHE_TRY_INSPECT(const auto& state, MOZ_TO_RESULT_INVOKE_TYPED( nsCOMPtr, aConn, CreateStatement, "SELECT name, type, sql FROM sqlite_master;"_ns)); CACHE_TRY(quota::CollectWhileHasResult( *state, [&expects](auto& stmt) -> Result { CACHE_TRY_INSPECT( const auto& name, MOZ_TO_RESULT_INVOKE_TYPED(nsAutoCString, stmt, GetUTF8String, 0)); CACHE_TRY_INSPECT( const auto& type, MOZ_TO_RESULT_INVOKE_TYPED(nsAutoCString, stmt, GetUTF8String, 1)); CACHE_TRY_INSPECT( const auto& sql, MOZ_TO_RESULT_INVOKE_TYPED(nsAutoCString, stmt, GetUTF8String, 2)); bool foundMatch = false; for (const auto& expect : expects) { if (name == expect.mName) { if (type != expect.mType) { NS_WARNING( nsPrintfCString("Unexpected type for Cache schema entry %s", name.get()) .get()); return Err(NS_ERROR_FAILURE); } if (!expect.mIgnoreSql && sql != expect.mSql) { NS_WARNING( nsPrintfCString("Unexpected SQL for Cache schema entry %s", name.get()) .get()); return Err(NS_ERROR_FAILURE); } foundMatch = true; break; } } if (NS_WARN_IF(!foundMatch)) { NS_WARNING( nsPrintfCString("Unexpected schema entry %s in Cache database", name.get()) .get()); return Err(NS_ERROR_FAILURE); } return Ok{}; })); #endif return NS_OK; } // ----- // Schema migration code // ----- typedef nsresult (*MigrationFunc)(mozIStorageConnection&, bool&); struct Migration { int32_t mFromVersion; MigrationFunc mFunc; }; // Declare migration functions here. Each function should upgrade // the version by a single increment. Don't skip versions. nsresult MigrateFrom15To16(mozIStorageConnection& aConn, bool& aRewriteSchema); nsresult MigrateFrom16To17(mozIStorageConnection& aConn, bool& aRewriteSchema); nsresult MigrateFrom17To18(mozIStorageConnection& aConn, bool& aRewriteSchema); nsresult MigrateFrom18To19(mozIStorageConnection& aConn, bool& aRewriteSchema); nsresult MigrateFrom19To20(mozIStorageConnection& aConn, bool& aRewriteSchema); nsresult MigrateFrom20To21(mozIStorageConnection& aConn, bool& aRewriteSchema); nsresult MigrateFrom21To22(mozIStorageConnection& aConn, bool& aRewriteSchema); nsresult MigrateFrom22To23(mozIStorageConnection& aConn, bool& aRewriteSchema); nsresult MigrateFrom23To24(mozIStorageConnection& aConn, bool& aRewriteSchema); nsresult MigrateFrom24To25(mozIStorageConnection& aConn, bool& aRewriteSchema); nsresult MigrateFrom25To26(mozIStorageConnection& aConn, bool& aRewriteSchema); nsresult MigrateFrom26To27(mozIStorageConnection& aConn, bool& aRewriteSchema); // Configure migration functions to run for the given starting version. constexpr Migration sMigrationList[] = { Migration{15, MigrateFrom15To16}, Migration{16, MigrateFrom16To17}, Migration{17, MigrateFrom17To18}, Migration{18, MigrateFrom18To19}, Migration{19, MigrateFrom19To20}, Migration{20, MigrateFrom20To21}, Migration{21, MigrateFrom21To22}, Migration{22, MigrateFrom22To23}, Migration{23, MigrateFrom23To24}, Migration{24, MigrateFrom24To25}, Migration{25, MigrateFrom25To26}, Migration{26, MigrateFrom26To27}, }; nsresult RewriteEntriesSchema(mozIStorageConnection& aConn) { CACHE_TRY(aConn.ExecuteSimpleSQL("PRAGMA writable_schema = ON"_ns)); CACHE_TRY_INSPECT( const auto& state, MOZ_TO_RESULT_INVOKE_TYPED( nsCOMPtr, aConn, CreateStatement, "UPDATE sqlite_master SET sql=:sql WHERE name='entries'"_ns)); CACHE_TRY( state->BindUTF8StringByName("sql"_ns, nsDependentCString(kTableEntries))); CACHE_TRY(state->Execute()); CACHE_TRY(aConn.ExecuteSimpleSQL("PRAGMA writable_schema = OFF"_ns)); return NS_OK; } nsresult Migrate(mozIStorageConnection& aConn) { MOZ_ASSERT(!NS_IsMainThread()); CACHE_TRY_UNWRAP(int32_t currentVersion, GetEffectiveSchemaVersion(aConn)); bool rewriteSchema = false; while (currentVersion < kLatestSchemaVersion) { // Wiping old databases is handled in DBAction because it requires // making a whole new mozIStorageConnection. Make sure we don't // accidentally get here for one of those old databases. MOZ_DIAGNOSTIC_ASSERT(currentVersion >= kFirstShippedSchemaVersion); for (const auto& migration : sMigrationList) { if (migration.mFromVersion == currentVersion) { bool shouldRewrite = false; CACHE_TRY(migration.mFunc(aConn, shouldRewrite)); if (shouldRewrite) { rewriteSchema = true; } break; } } #ifdef MOZ_DIAGNOSTIC_ASSERT_ENABLED int32_t lastVersion = currentVersion; #endif CACHE_TRY_UNWRAP(currentVersion, GetEffectiveSchemaVersion(aConn)); MOZ_DIAGNOSTIC_ASSERT(currentVersion > lastVersion); } // Don't release assert this since people do sometimes share profiles // across schema versions. Our check in Validate() will catch it. MOZ_ASSERT(currentVersion == kLatestSchemaVersion); nsresult rv = NS_OK; if (rewriteSchema) { // Now overwrite the master SQL for the entries table to remove the column // default value. This is also necessary for our Validate() method to // pass on this database. rv = RewriteEntriesSchema(aConn); } return rv; } nsresult MigrateFrom15To16(mozIStorageConnection& aConn, bool& aRewriteSchema) { MOZ_ASSERT(!NS_IsMainThread()); // Add the request_redirect column with a default value of "follow". Note, // we only use a default value here because its required by ALTER TABLE and // we need to apply the default "follow" to existing records in the table. // We don't actually want to keep the default in the schema for future // INSERTs. CACHE_TRY(aConn.ExecuteSimpleSQL( "ALTER TABLE entries " "ADD COLUMN request_redirect INTEGER NOT NULL DEFAULT 0"_ns)); CACHE_TRY(aConn.SetSchemaVersion(16)); aRewriteSchema = true; return NS_OK; } nsresult MigrateFrom16To17(mozIStorageConnection& aConn, bool& aRewriteSchema) { MOZ_ASSERT(!NS_IsMainThread()); // This migration path removes the response_redirected and // response_redirected_url columns from the entries table. sqlite doesn't // support removing a column from a table using ALTER TABLE, so we need to // create a new table without those columns, fill it up with the existing // data, and then drop the original table and rename the new one to the old // one. // Create a new_entries table with the new fields as of version 17. CACHE_TRY(aConn.ExecuteSimpleSQL( "CREATE TABLE new_entries (" "id INTEGER NOT NULL PRIMARY KEY, " "request_method TEXT NOT NULL, " "request_url_no_query TEXT NOT NULL, " "request_url_no_query_hash BLOB NOT NULL, " "request_url_query TEXT NOT NULL, " "request_url_query_hash BLOB NOT NULL, " "request_referrer TEXT NOT NULL, " "request_headers_guard INTEGER NOT NULL, " "request_mode INTEGER NOT NULL, " "request_credentials INTEGER NOT NULL, " "request_contentpolicytype INTEGER NOT NULL, " "request_cache INTEGER NOT NULL, " "request_body_id TEXT NULL, " "response_type INTEGER NOT NULL, " "response_url TEXT NOT NULL, " "response_status INTEGER NOT NULL, " "response_status_text TEXT NOT NULL, " "response_headers_guard INTEGER NOT NULL, " "response_body_id TEXT NULL, " "response_security_info_id INTEGER NULL REFERENCES security_info(id), " "response_principal_info TEXT NOT NULL, " "cache_id INTEGER NOT NULL REFERENCES caches(id) ON DELETE CASCADE, " "request_redirect INTEGER NOT NULL" ")"_ns)); // Copy all of the data to the newly created table. CACHE_TRY( aConn.ExecuteSimpleSQL("INSERT INTO new_entries (" "id, " "request_method, " "request_url_no_query, " "request_url_no_query_hash, " "request_url_query, " "request_url_query_hash, " "request_referrer, " "request_headers_guard, " "request_mode, " "request_credentials, " "request_contentpolicytype, " "request_cache, " "request_redirect, " "request_body_id, " "response_type, " "response_url, " "response_status, " "response_status_text, " "response_headers_guard, " "response_body_id, " "response_security_info_id, " "response_principal_info, " "cache_id " ") SELECT " "id, " "request_method, " "request_url_no_query, " "request_url_no_query_hash, " "request_url_query, " "request_url_query_hash, " "request_referrer, " "request_headers_guard, " "request_mode, " "request_credentials, " "request_contentpolicytype, " "request_cache, " "request_redirect, " "request_body_id, " "response_type, " "response_url, " "response_status, " "response_status_text, " "response_headers_guard, " "response_body_id, " "response_security_info_id, " "response_principal_info, " "cache_id " "FROM entries;"_ns)); // Remove the old table. CACHE_TRY(aConn.ExecuteSimpleSQL("DROP TABLE entries;"_ns)); // Rename new_entries to entries. CACHE_TRY( aConn.ExecuteSimpleSQL("ALTER TABLE new_entries RENAME to entries;"_ns)); // Now, recreate our indices. CACHE_TRY(aConn.ExecuteSimpleSQL(nsDependentCString(kIndexEntriesRequest))); // Revalidate the foreign key constraints, and ensure that there are no // violations. CACHE_TRY_INSPECT(const bool& hasResult, quota::CreateAndExecuteSingleStepStatement< quota::SingleStepResult::ReturnNullIfNoResult>( aConn, "PRAGMA foreign_key_check;"_ns)); CACHE_TRY(OkIf(!hasResult), NS_ERROR_FAILURE); CACHE_TRY(aConn.SetSchemaVersion(17)); return NS_OK; } nsresult MigrateFrom17To18(mozIStorageConnection& aConn, bool& aRewriteSchema) { MOZ_ASSERT(!NS_IsMainThread()); // This migration is needed in order to remove "only-if-cached" RequestCache // values from the database. This enum value was removed from the spec in // https://github.com/whatwg/fetch/issues/39 but we unfortunately happily // accepted this value in the Request constructor. // // There is no good value to upgrade this to, so we just stick to "default". static_assert(int(RequestCache::Default) == 0, "This is where the 0 below comes from!"); CACHE_TRY( aConn.ExecuteSimpleSQL("UPDATE entries SET request_cache = 0 " "WHERE request_cache = 5;"_ns)); CACHE_TRY(aConn.SetSchemaVersion(18)); return NS_OK; } nsresult MigrateFrom18To19(mozIStorageConnection& aConn, bool& aRewriteSchema) { MOZ_ASSERT(!NS_IsMainThread()); // This migration is needed in order to update the RequestMode values for // Request objects corresponding to a navigation content policy type to // "navigate". static_assert(int(nsIContentPolicy::TYPE_DOCUMENT) == 6 && int(nsIContentPolicy::TYPE_SUBDOCUMENT) == 7 && int(nsIContentPolicy::TYPE_INTERNAL_FRAME) == 28 && int(nsIContentPolicy::TYPE_INTERNAL_IFRAME) == 29 && int(RequestMode::Navigate) == 3, "This is where the numbers below come from!"); // 8 is former TYPE_REFRESH. CACHE_TRY(aConn.ExecuteSimpleSQL( "UPDATE entries SET request_mode = 3 " "WHERE request_contentpolicytype IN (6, 7, 28, 29, 8);"_ns)); CACHE_TRY(aConn.SetSchemaVersion(19)); return NS_OK; } nsresult MigrateFrom19To20(mozIStorageConnection& aConn, bool& aRewriteSchema) { MOZ_ASSERT(!NS_IsMainThread()); // Add the request_referrer_policy column with a default value of // "no-referrer-when-downgrade". Note, we only use a default value here // because its required by ALTER TABLE and we need to apply the default // "no-referrer-when-downgrade" to existing records in the table. We don't // actually want to keep the default in the schema for future INSERTs. CACHE_TRY(aConn.ExecuteSimpleSQL( "ALTER TABLE entries " "ADD COLUMN request_referrer_policy INTEGER NOT NULL DEFAULT 2"_ns)); CACHE_TRY(aConn.SetSchemaVersion(20)); aRewriteSchema = true; return NS_OK; } nsresult MigrateFrom20To21(mozIStorageConnection& aConn, bool& aRewriteSchema) { MOZ_ASSERT(!NS_IsMainThread()); // This migration creates response_url_list table to store response_url and // removes the response_url column from the entries table. // sqlite doesn't support removing a column from a table using ALTER TABLE, // so we need to create a new table without those columns, fill it up with the // existing data, and then drop the original table and rename the new one to // the old one. // Create a new_entries table with the new fields as of version 21. CACHE_TRY(aConn.ExecuteSimpleSQL( "CREATE TABLE new_entries (" "id INTEGER NOT NULL PRIMARY KEY, " "request_method TEXT NOT NULL, " "request_url_no_query TEXT NOT NULL, " "request_url_no_query_hash BLOB NOT NULL, " "request_url_query TEXT NOT NULL, " "request_url_query_hash BLOB NOT NULL, " "request_referrer TEXT NOT NULL, " "request_headers_guard INTEGER NOT NULL, " "request_mode INTEGER NOT NULL, " "request_credentials INTEGER NOT NULL, " "request_contentpolicytype INTEGER NOT NULL, " "request_cache INTEGER NOT NULL, " "request_body_id TEXT NULL, " "response_type INTEGER NOT NULL, " "response_status INTEGER NOT NULL, " "response_status_text TEXT NOT NULL, " "response_headers_guard INTEGER NOT NULL, " "response_body_id TEXT NULL, " "response_security_info_id INTEGER NULL REFERENCES security_info(id), " "response_principal_info TEXT NOT NULL, " "cache_id INTEGER NOT NULL REFERENCES caches(id) ON DELETE CASCADE, " "request_redirect INTEGER NOT NULL, " "request_referrer_policy INTEGER NOT NULL" ")"_ns)); // Create a response_url_list table with the new fields as of version 21. CACHE_TRY(aConn.ExecuteSimpleSQL( "CREATE TABLE response_url_list (" "url TEXT NOT NULL, " "entry_id INTEGER NOT NULL REFERENCES entries(id) ON DELETE CASCADE" ")"_ns)); // Copy all of the data to the newly created entries table. CACHE_TRY( aConn.ExecuteSimpleSQL("INSERT INTO new_entries (" "id, " "request_method, " "request_url_no_query, " "request_url_no_query_hash, " "request_url_query, " "request_url_query_hash, " "request_referrer, " "request_headers_guard, " "request_mode, " "request_credentials, " "request_contentpolicytype, " "request_cache, " "request_redirect, " "request_referrer_policy, " "request_body_id, " "response_type, " "response_status, " "response_status_text, " "response_headers_guard, " "response_body_id, " "response_security_info_id, " "response_principal_info, " "cache_id " ") SELECT " "id, " "request_method, " "request_url_no_query, " "request_url_no_query_hash, " "request_url_query, " "request_url_query_hash, " "request_referrer, " "request_headers_guard, " "request_mode, " "request_credentials, " "request_contentpolicytype, " "request_cache, " "request_redirect, " "request_referrer_policy, " "request_body_id, " "response_type, " "response_status, " "response_status_text, " "response_headers_guard, " "response_body_id, " "response_security_info_id, " "response_principal_info, " "cache_id " "FROM entries;"_ns)); // Copy reponse_url to the newly created response_url_list table. CACHE_TRY( aConn.ExecuteSimpleSQL("INSERT INTO response_url_list (" "url, " "entry_id " ") SELECT " "response_url, " "id " "FROM entries;"_ns)); // Remove the old table. CACHE_TRY(aConn.ExecuteSimpleSQL("DROP TABLE entries;"_ns)); // Rename new_entries to entries. CACHE_TRY( aConn.ExecuteSimpleSQL("ALTER TABLE new_entries RENAME to entries;"_ns)); // Now, recreate our indices. CACHE_TRY(aConn.ExecuteSimpleSQL(nsLiteralCString(kIndexEntriesRequest))); // Revalidate the foreign key constraints, and ensure that there are no // violations. CACHE_TRY_INSPECT(const bool& hasResult, quota::CreateAndExecuteSingleStepStatement< quota::SingleStepResult::ReturnNullIfNoResult>( aConn, "PRAGMA foreign_key_check;"_ns)); CACHE_TRY(OkIf(!hasResult), NS_ERROR_FAILURE); CACHE_TRY(aConn.SetSchemaVersion(21)); aRewriteSchema = true; return NS_OK; } nsresult MigrateFrom21To22(mozIStorageConnection& aConn, bool& aRewriteSchema) { MOZ_ASSERT(!NS_IsMainThread()); // Add the request_integrity column. CACHE_TRY( aConn.ExecuteSimpleSQL("ALTER TABLE entries " "ADD COLUMN request_integrity TEXT NULL"_ns)); CACHE_TRY(aConn.SetSchemaVersion(22)); aRewriteSchema = true; return NS_OK; } nsresult MigrateFrom22To23(mozIStorageConnection& aConn, bool& aRewriteSchema) { MOZ_ASSERT(!NS_IsMainThread()); // The only change between 22 and 23 was a different snappy compression // format, but it's backwards-compatible. CACHE_TRY(aConn.SetSchemaVersion(23)); return NS_OK; } nsresult MigrateFrom23To24(mozIStorageConnection& aConn, bool& aRewriteSchema) { MOZ_ASSERT(!NS_IsMainThread()); // Add the request_url_fragment column. CACHE_TRY(aConn.ExecuteSimpleSQL( "ALTER TABLE entries " "ADD COLUMN request_url_fragment TEXT NOT NULL DEFAULT ''"_ns)); CACHE_TRY(aConn.SetSchemaVersion(24)); aRewriteSchema = true; return NS_OK; } nsresult MigrateFrom24To25(mozIStorageConnection& aConn, bool& aRewriteSchema) { MOZ_ASSERT(!NS_IsMainThread()); // The only change between 24 and 25 was a new nsIContentPolicy type. CACHE_TRY(aConn.SetSchemaVersion(25)); return NS_OK; } nsresult MigrateFrom25To26(mozIStorageConnection& aConn, bool& aRewriteSchema) { MOZ_ASSERT(!NS_IsMainThread()); // Add the response_padding_size column. // Note: only opaque repsonse should be non-null interger. CACHE_TRY(aConn.ExecuteSimpleSQL( "ALTER TABLE entries " "ADD COLUMN response_padding_size INTEGER NULL "_ns)); CACHE_TRY( aConn.ExecuteSimpleSQL("UPDATE entries SET response_padding_size = 0 " "WHERE response_type = 4"_ns // opaque response )); CACHE_TRY(aConn.SetSchemaVersion(26)); aRewriteSchema = true; return NS_OK; } nsresult MigrateFrom26To27(mozIStorageConnection& aConn, bool& aRewriteSchema) { MOZ_ASSERT(!NS_IsMainThread()); CACHE_TRY(aConn.SetSchemaVersion(kHackyDowngradeSchemaVersion)); return NS_OK; } } // anonymous namespace } // namespace mozilla::dom::cache::db