1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
2 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
3 /* This Source Code Form is subject to the terms of the Mozilla Public
4 * License, v. 2.0. If a copy of the MPL was not distributed with this
5 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
7 #include "mozilla/dom/cache/DBAction.h"
9 #include "mozilla/Assertions.h"
10 #include "mozilla/dom/cache/Connection.h"
11 #include "mozilla/dom/cache/DBSchema.h"
12 #include "mozilla/dom/cache/FileUtils.h"
13 #include "mozilla/dom/cache/QuotaClient.h"
14 #include "mozilla/dom/quota/PersistenceType.h"
15 #include "mozilla/dom/quota/ResultExtensions.h"
16 #include "mozilla/net/nsFileProtocolHandler.h"
17 #include "mozilla/AppShutdown.h"
18 #include "mozIStorageConnection.h"
19 #include "mozIStorageService.h"
20 #include "mozStorageCID.h"
23 #include "nsIURIMutator.h"
24 #include "nsIFileURL.h"
26 namespace mozilla::dom::cache
{
28 using mozilla::dom::quota::CloneFileAndAppend
;
29 using mozilla::dom::quota::IsDatabaseCorruptionError
;
33 nsresult
WipeDatabase(const CacheDirectoryMetadata
& aDirectoryMetadata
,
35 QM_TRY_INSPECT(const auto& dbDir
, MOZ_TO_RESULT_INVOKE_MEMBER_TYPED(
36 nsCOMPtr
<nsIFile
>, aDBFile
, GetParent
));
38 QM_TRY(MOZ_TO_RESULT(RemoveNsIFile(aDirectoryMetadata
, aDBFile
)));
40 // Note, the -wal journal file will be automatically deleted by sqlite when
41 // the new database is created. No need to explicitly delete it here.
43 // Delete the morgue as well.
44 QM_TRY(MOZ_TO_RESULT(BodyDeleteDir(aDirectoryMetadata
, *dbDir
)));
46 QM_TRY(MOZ_TO_RESULT(WipePaddingFile(aDirectoryMetadata
, dbDir
)));
53 DBAction::DBAction(Mode aMode
) : mMode(aMode
) {}
55 DBAction::~DBAction() = default;
57 void DBAction::RunOnTarget(
58 SafeRefPtr
<Resolver
> aResolver
,
59 const Maybe
<CacheDirectoryMetadata
>& aDirectoryMetadata
,
60 Data
* aOptionalData
, const Maybe
<CipherKey
>& aMaybeCipherKey
) {
61 MOZ_ASSERT(!NS_IsMainThread());
62 MOZ_DIAGNOSTIC_ASSERT(aResolver
);
63 MOZ_DIAGNOSTIC_ASSERT(aDirectoryMetadata
);
64 MOZ_DIAGNOSTIC_ASSERT(aDirectoryMetadata
->mDir
);
66 if (IsCanceled() || AppShutdown::IsInOrBeyond(ShutdownPhase::AppShutdownQM
)) {
67 aResolver
->Resolve(NS_ERROR_ABORT
);
71 const auto resolveErr
= [&aResolver
](const nsresult rv
) {
72 aResolver
->Resolve(rv
);
75 QM_TRY_INSPECT(const auto& dbDir
,
76 CloneFileAndAppend(*(aDirectoryMetadata
->mDir
), u
"cache"_ns
),
79 nsCOMPtr
<mozIStorageConnection
> conn
;
81 // Attempt to reuse the connection opened by a previous Action.
83 conn
= aOptionalData
->GetConnection();
86 // If there is no previous Action, then we must open one.
89 OpenConnection(*aDirectoryMetadata
, *dbDir
, aMaybeCipherKey
),
91 MOZ_DIAGNOSTIC_ASSERT(conn
);
93 // Save this connection in the shared Data object so later Actions can
94 // use it. This avoids opening a new connection for every Action.
96 // Since we know this connection will be around for as long as the
97 // Cache is open, use our special wrapped connection class. This
98 // will let us perform certain operations once the Cache origin
100 nsCOMPtr
<mozIStorageConnection
> wrapped
= new Connection(conn
);
101 aOptionalData
->SetConnection(wrapped
);
105 RunWithDBOnTarget(std::move(aResolver
), *aDirectoryMetadata
, dbDir
, conn
);
108 Result
<nsCOMPtr
<mozIStorageConnection
>, nsresult
> DBAction::OpenConnection(
109 const CacheDirectoryMetadata
& aDirectoryMetadata
, nsIFile
& aDBDir
,
110 const Maybe
<CipherKey
>& aMaybeCipherKey
) {
111 MOZ_ASSERT(!NS_IsMainThread());
112 MOZ_DIAGNOSTIC_ASSERT(aDirectoryMetadata
.mDirectoryLockId
>= 0);
114 QM_TRY_INSPECT(const bool& exists
,
115 MOZ_TO_RESULT_INVOKE_MEMBER(aDBDir
, Exists
));
118 QM_TRY(OkIf(mMode
== Create
), Err(NS_ERROR_FILE_NOT_FOUND
));
119 QM_TRY(MOZ_TO_RESULT(aDBDir
.Create(nsIFile::DIRECTORY_TYPE
, 0755)));
122 QM_TRY_INSPECT(const auto& dbFile
,
123 CloneFileAndAppend(aDBDir
, kCachesSQLiteFilename
));
125 QM_TRY_RETURN(OpenDBConnection(aDirectoryMetadata
, *dbFile
, aMaybeCipherKey
));
128 SyncDBAction::SyncDBAction(Mode aMode
) : DBAction(aMode
) {}
130 SyncDBAction::~SyncDBAction() = default;
132 void SyncDBAction::RunWithDBOnTarget(
133 SafeRefPtr
<Resolver
> aResolver
,
134 const CacheDirectoryMetadata
& aDirectoryMetadata
, nsIFile
* aDBDir
,
135 mozIStorageConnection
* aConn
) {
136 MOZ_ASSERT(!NS_IsMainThread());
137 MOZ_DIAGNOSTIC_ASSERT(aResolver
);
138 MOZ_DIAGNOSTIC_ASSERT(aDBDir
);
139 MOZ_DIAGNOSTIC_ASSERT(aConn
);
141 nsresult rv
= RunSyncWithDBOnTarget(aDirectoryMetadata
, aDBDir
, aConn
);
142 aResolver
->Resolve(rv
);
145 Result
<nsCOMPtr
<mozIStorageConnection
>, nsresult
> OpenDBConnection(
146 const CacheDirectoryMetadata
& aDirectoryMetadata
, nsIFile
& aDBFile
,
147 const Maybe
<CipherKey
>& aMaybeCipherKey
) {
148 MOZ_ASSERT(!NS_IsMainThread());
149 MOZ_DIAGNOSTIC_ASSERT(aDirectoryMetadata
.mDirectoryLockId
>= -1);
150 MOZ_DIAGNOSTIC_ASSERT_IF(aDirectoryMetadata
.mIsPrivate
, aMaybeCipherKey
);
152 // Use our default file:// protocol handler directly to construct the database
153 // URL. This avoids any problems if a plugin registers a custom file://
154 // handler. If such a custom handler used javascript, then we would have a
155 // bad time running off the main thread here.
156 auto handler
= MakeRefPtr
<nsFileProtocolHandler
>();
157 QM_TRY(MOZ_TO_RESULT(handler
->Init()));
159 QM_TRY_INSPECT(const auto& mutator
, MOZ_TO_RESULT_INVOKE_MEMBER_TYPED(
160 nsCOMPtr
<nsIURIMutator
>, handler
,
161 NewFileURIMutator
, &aDBFile
));
163 const nsCString directoryLockIdClause
=
164 "&directoryLockId="_ns
+
165 IntToCString(aDirectoryMetadata
.mDirectoryLockId
);
167 const auto keyClause
= [&aMaybeCipherKey
] {
168 nsAutoCString keyClause
;
169 if (aMaybeCipherKey
) {
170 keyClause
.AssignLiteral("&key=");
171 for (uint8_t byte
: CipherStrategy::SerializeKey(*aMaybeCipherKey
)) {
172 keyClause
.AppendPrintf("%02x", byte
);
178 nsCOMPtr
<nsIFileURL
> dbFileUrl
;
179 QM_TRY(MOZ_TO_RESULT(
180 NS_MutateURI(mutator
)
181 .SetQuery("cache=private"_ns
+ directoryLockIdClause
+ keyClause
)
182 .Finalize(dbFileUrl
)));
184 QM_TRY_INSPECT(const auto& storageService
,
185 MOZ_TO_RESULT_GET_TYPED(nsCOMPtr
<mozIStorageService
>,
186 MOZ_SELECT_OVERLOAD(do_GetService
),
187 MOZ_STORAGE_SERVICE_CONTRACTID
),
188 Err(NS_ERROR_UNEXPECTED
));
194 MOZ_TO_RESULT_INVOKE_MEMBER_TYPED(
195 nsCOMPtr
<mozIStorageConnection
>, storageService
,
196 OpenDatabaseWithFileURL
, dbFileUrl
, ""_ns
,
197 mozIStorageService::CONNECTION_DEFAULT
),
199 IsDatabaseCorruptionError
,
201 ([&aDirectoryMetadata
, &aDBFile
, &storageService
,
202 &dbFileUrl
](const nsresult rv
)
203 -> Result
<nsCOMPtr
<mozIStorageConnection
>, nsresult
> {
204 NS_WARNING("Cache database corrupted. Recreating empty database.");
206 // There is nothing else we can do to recover. Also, this data
207 // can be deleted by QuotaManager at any time anyways.
208 QM_TRY(MOZ_TO_RESULT(WipeDatabase(aDirectoryMetadata
, aDBFile
)));
210 QM_TRY_RETURN(MOZ_TO_RESULT_INVOKE_MEMBER_TYPED(
211 nsCOMPtr
<mozIStorageConnection
>, storageService
,
212 OpenDatabaseWithFileURL
, dbFileUrl
, ""_ns
,
213 mozIStorageService::CONNECTION_DEFAULT
));
216 // Check the schema to make sure it is not too old.
217 QM_TRY_INSPECT(const int32_t& schemaVersion
,
218 MOZ_TO_RESULT_INVOKE_MEMBER(conn
, GetSchemaVersion
));
219 if (schemaVersion
> 0 && schemaVersion
< db::kFirstShippedSchemaVersion
) {
220 // Close existing connection before wiping database.
223 QM_TRY(MOZ_TO_RESULT(WipeDatabase(aDirectoryMetadata
, aDBFile
)));
225 QM_TRY_UNWRAP(conn
, MOZ_TO_RESULT_INVOKE_MEMBER_TYPED(
226 nsCOMPtr
<mozIStorageConnection
>, storageService
,
227 OpenDatabaseWithFileURL
, dbFileUrl
, ""_ns
,
228 mozIStorageService::CONNECTION_DEFAULT
));
231 QM_TRY(MOZ_TO_RESULT(db::InitializeConnection(*conn
)));
236 } // namespace mozilla::dom::cache