forked from mirrors/gecko-dev
0fbb64410b
Backed out changeset cacebe0fc34c (bug 1671367) Backed out changeset 37e2f1c36fc7 (bug 1671367) Backed out changeset c4a3fca623aa (bug 1671367) Backed out changeset 75e95ebade6a (bug 1671367) Backed out changeset bfc08841dafb (bug 1671367) Backed out changeset 445d4fd6004d (bug 1671367) Backed out changeset 90e38a8f77d6 (bug 1671367) Backed out changeset 7e5910c8a82e (bug 1671367)
990 lines
28 KiB
C++
990 lines
28 KiB
C++
/* -*- 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 "FileUtilsImpl.h"
|
|
|
|
#include "DBSchema.h"
|
|
#include "mozilla/dom/InternalResponse.h"
|
|
#include "mozilla/dom/quota/FileStreams.h"
|
|
#include "mozilla/dom/quota/QuotaManager.h"
|
|
#include "mozilla/dom/quota/QuotaObject.h"
|
|
#include "mozilla/SnappyCompressOutputStream.h"
|
|
#include "mozilla/Unused.h"
|
|
#include "nsIObjectInputStream.h"
|
|
#include "nsIObjectOutputStream.h"
|
|
#include "nsIFile.h"
|
|
#include "nsIUUIDGenerator.h"
|
|
#include "nsNetCID.h"
|
|
#include "nsNetUtil.h"
|
|
#include "nsServiceManagerUtils.h"
|
|
#include "nsString.h"
|
|
#include "nsThreadUtils.h"
|
|
|
|
namespace mozilla::dom::cache {
|
|
|
|
using mozilla::dom::quota::Client;
|
|
using mozilla::dom::quota::CloneFileAndAppend;
|
|
using mozilla::dom::quota::FileInputStream;
|
|
using mozilla::dom::quota::FileOutputStream;
|
|
using mozilla::dom::quota::PERSISTENCE_TYPE_DEFAULT;
|
|
using mozilla::dom::quota::QuotaManager;
|
|
using mozilla::dom::quota::QuotaObject;
|
|
|
|
namespace {
|
|
|
|
// Const variable for generate padding size.
|
|
// XXX This will be tweaked to something more meaningful in Bug 1383656.
|
|
const int64_t kRoundUpNumber = 20480;
|
|
|
|
enum BodyFileType { BODY_FILE_FINAL, BODY_FILE_TMP };
|
|
|
|
nsresult BodyIdToFile(nsIFile* aBaseDir, const nsID& aId, BodyFileType aType,
|
|
nsIFile** aBodyFileOut);
|
|
|
|
int64_t RoundUp(const int64_t aX, const int64_t aY);
|
|
|
|
// The alogrithm for generating padding refers to the mitigation approach in
|
|
// https://github.com/whatwg/storage/issues/31.
|
|
// First, generate a random number between 0 and 100kB.
|
|
// Next, round up the sum of random number and response size to the nearest
|
|
// 20kB.
|
|
// Finally, the virtual padding size will be the result minus the response size.
|
|
int64_t BodyGeneratePadding(const int64_t aBodyFileSize,
|
|
const uint32_t aPaddingInfo);
|
|
|
|
nsresult LockedDirectoryPaddingWrite(nsIFile* aBaseDir,
|
|
DirPaddingFile aPaddingFileType,
|
|
int64_t aPaddingSize);
|
|
|
|
} // namespace
|
|
|
|
// static
|
|
nsresult BodyCreateDir(nsIFile* aBaseDir) {
|
|
MOZ_DIAGNOSTIC_ASSERT(aBaseDir);
|
|
|
|
nsCOMPtr<nsIFile> aBodyDir;
|
|
nsresult rv = aBaseDir->Clone(getter_AddRefs(aBodyDir));
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
|
|
rv = aBodyDir->Append(u"morgue"_ns);
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
|
|
rv = aBodyDir->Create(nsIFile::DIRECTORY_TYPE, 0755);
|
|
if (rv == NS_ERROR_FILE_ALREADY_EXISTS) {
|
|
return NS_OK;
|
|
}
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
|
|
return rv;
|
|
}
|
|
|
|
// static
|
|
nsresult BodyDeleteDir(const QuotaInfo& aQuotaInfo, nsIFile* aBaseDir) {
|
|
MOZ_DIAGNOSTIC_ASSERT(aBaseDir);
|
|
|
|
nsCOMPtr<nsIFile> aBodyDir;
|
|
nsresult rv = aBaseDir->Clone(getter_AddRefs(aBodyDir));
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
|
|
rv = aBodyDir->Append(u"morgue"_ns);
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
|
|
rv = RemoveNsIFileRecursively(aQuotaInfo, aBodyDir);
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
|
|
return rv;
|
|
}
|
|
|
|
// static
|
|
nsresult BodyGetCacheDir(nsIFile* aBaseDir, const nsID& aId,
|
|
nsIFile** aCacheDirOut) {
|
|
MOZ_DIAGNOSTIC_ASSERT(aBaseDir);
|
|
MOZ_DIAGNOSTIC_ASSERT(aCacheDirOut);
|
|
|
|
*aCacheDirOut = nullptr;
|
|
|
|
nsresult rv = aBaseDir->Clone(aCacheDirOut);
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
MOZ_DIAGNOSTIC_ASSERT(*aCacheDirOut);
|
|
|
|
rv = (*aCacheDirOut)->Append(u"morgue"_ns);
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
|
|
// Some file systems have poor performance when there are too many files
|
|
// in a single directory. Mitigate this issue by spreading the body
|
|
// files out into sub-directories. We use the last byte of the ID for
|
|
// the name of the sub-directory.
|
|
rv = (*aCacheDirOut)->Append(IntToString(aId.m3[7]));
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
|
|
rv = (*aCacheDirOut)->Create(nsIFile::DIRECTORY_TYPE, 0755);
|
|
if (rv == NS_ERROR_FILE_ALREADY_EXISTS) {
|
|
return NS_OK;
|
|
}
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
|
|
return rv;
|
|
}
|
|
|
|
// static
|
|
nsresult BodyStartWriteStream(const QuotaInfo& aQuotaInfo, nsIFile* aBaseDir,
|
|
nsIInputStream* aSource, void* aClosure,
|
|
nsAsyncCopyCallbackFun aCallback, nsID* aIdOut,
|
|
nsISupports** aCopyContextOut) {
|
|
MOZ_DIAGNOSTIC_ASSERT(aBaseDir);
|
|
MOZ_DIAGNOSTIC_ASSERT(aSource);
|
|
MOZ_DIAGNOSTIC_ASSERT(aClosure);
|
|
MOZ_DIAGNOSTIC_ASSERT(aCallback);
|
|
MOZ_DIAGNOSTIC_ASSERT(aIdOut);
|
|
MOZ_DIAGNOSTIC_ASSERT(aCopyContextOut);
|
|
|
|
nsresult rv;
|
|
nsCOMPtr<nsIUUIDGenerator> idGen =
|
|
do_GetService("@mozilla.org/uuid-generator;1", &rv);
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
|
|
rv = idGen->GenerateUUIDInPlace(aIdOut);
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
|
|
nsCOMPtr<nsIFile> finalFile;
|
|
rv = BodyIdToFile(aBaseDir, *aIdOut, BODY_FILE_FINAL,
|
|
getter_AddRefs(finalFile));
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
|
|
bool exists;
|
|
rv = finalFile->Exists(&exists);
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
if (NS_WARN_IF(exists)) {
|
|
return NS_ERROR_FILE_ALREADY_EXISTS;
|
|
}
|
|
|
|
nsCOMPtr<nsIFile> tmpFile;
|
|
rv = BodyIdToFile(aBaseDir, *aIdOut, BODY_FILE_TMP, getter_AddRefs(tmpFile));
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
|
|
rv = tmpFile->Exists(&exists);
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
if (NS_WARN_IF(exists)) {
|
|
return NS_ERROR_FILE_ALREADY_EXISTS;
|
|
}
|
|
|
|
nsCOMPtr<nsIOutputStream> fileStream = CreateFileOutputStream(
|
|
PERSISTENCE_TYPE_DEFAULT, aQuotaInfo, Client::DOMCACHE, tmpFile);
|
|
if (NS_WARN_IF(!fileStream)) {
|
|
return NS_ERROR_UNEXPECTED;
|
|
}
|
|
|
|
RefPtr<SnappyCompressOutputStream> compressed =
|
|
new SnappyCompressOutputStream(fileStream);
|
|
|
|
nsCOMPtr<nsIEventTarget> target =
|
|
do_GetService(NS_STREAMTRANSPORTSERVICE_CONTRACTID);
|
|
|
|
rv = NS_AsyncCopy(aSource, compressed, target, NS_ASYNCCOPY_VIA_WRITESEGMENTS,
|
|
compressed->BlockSize(), aCallback, aClosure, true,
|
|
true, // close streams
|
|
aCopyContextOut);
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
|
|
return rv;
|
|
}
|
|
|
|
// static
|
|
void BodyCancelWrite(nsIFile* aBaseDir, nsISupports* aCopyContext) {
|
|
MOZ_DIAGNOSTIC_ASSERT(aBaseDir);
|
|
MOZ_DIAGNOSTIC_ASSERT(aCopyContext);
|
|
|
|
nsresult rv = NS_CancelAsyncCopy(aCopyContext, NS_ERROR_ABORT);
|
|
Unused << NS_WARN_IF(NS_FAILED(rv));
|
|
|
|
// The partially written file must be cleaned up after the async copy
|
|
// makes its callback.
|
|
}
|
|
|
|
// static
|
|
nsresult BodyFinalizeWrite(nsIFile* aBaseDir, const nsID& aId) {
|
|
MOZ_DIAGNOSTIC_ASSERT(aBaseDir);
|
|
|
|
nsCOMPtr<nsIFile> tmpFile;
|
|
nsresult rv =
|
|
BodyIdToFile(aBaseDir, aId, BODY_FILE_TMP, getter_AddRefs(tmpFile));
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
|
|
nsCOMPtr<nsIFile> finalFile;
|
|
rv = BodyIdToFile(aBaseDir, aId, BODY_FILE_FINAL, getter_AddRefs(finalFile));
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
|
|
nsAutoString finalFileName;
|
|
rv = finalFile->GetLeafName(finalFileName);
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
|
|
// It's fine to not notify the QuotaManager that the path has been changed,
|
|
// because its path will be updated and its size will be recalculated when
|
|
// opening file next time.
|
|
rv = tmpFile->RenameTo(nullptr, finalFileName);
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
|
|
return rv;
|
|
}
|
|
|
|
// static
|
|
nsresult BodyOpen(const QuotaInfo& aQuotaInfo, nsIFile* aBaseDir,
|
|
const nsID& aId, nsIInputStream** aStreamOut) {
|
|
MOZ_DIAGNOSTIC_ASSERT(aBaseDir);
|
|
MOZ_DIAGNOSTIC_ASSERT(aStreamOut);
|
|
|
|
nsCOMPtr<nsIFile> finalFile;
|
|
nsresult rv =
|
|
BodyIdToFile(aBaseDir, aId, BODY_FILE_FINAL, getter_AddRefs(finalFile));
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
|
|
bool exists;
|
|
rv = finalFile->Exists(&exists);
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
if (NS_WARN_IF(!exists)) {
|
|
return NS_ERROR_FILE_NOT_FOUND;
|
|
}
|
|
|
|
nsCOMPtr<nsIInputStream> fileStream = CreateFileInputStream(
|
|
PERSISTENCE_TYPE_DEFAULT, aQuotaInfo, Client::DOMCACHE, finalFile);
|
|
if (NS_WARN_IF(!fileStream)) {
|
|
return NS_ERROR_UNEXPECTED;
|
|
}
|
|
|
|
fileStream.forget(aStreamOut);
|
|
|
|
return rv;
|
|
}
|
|
|
|
// static
|
|
nsresult BodyMaybeUpdatePaddingSize(const QuotaInfo& aQuotaInfo,
|
|
nsIFile* aBaseDir, const nsID& aId,
|
|
const uint32_t aPaddingInfo,
|
|
int64_t* aPaddingSizeOut) {
|
|
MOZ_DIAGNOSTIC_ASSERT(aBaseDir);
|
|
MOZ_DIAGNOSTIC_ASSERT(aPaddingSizeOut);
|
|
|
|
nsCOMPtr<nsIFile> bodyFile;
|
|
nsresult rv =
|
|
BodyIdToFile(aBaseDir, aId, BODY_FILE_TMP, getter_AddRefs(bodyFile));
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
|
|
MOZ_DIAGNOSTIC_ASSERT(bodyFile);
|
|
|
|
QuotaManager* quotaManager = QuotaManager::Get();
|
|
MOZ_DIAGNOSTIC_ASSERT(quotaManager);
|
|
|
|
int64_t fileSize = 0;
|
|
RefPtr<QuotaObject> quotaObject =
|
|
quotaManager->GetQuotaObject(PERSISTENCE_TYPE_DEFAULT, aQuotaInfo,
|
|
Client::DOMCACHE, bodyFile, -1, &fileSize);
|
|
MOZ_DIAGNOSTIC_ASSERT(quotaObject);
|
|
MOZ_DIAGNOSTIC_ASSERT(fileSize >= 0);
|
|
// XXXtt: bug: https://bugzilla.mozilla.org/show_bug.cgi?id=1422815
|
|
if (!quotaObject) {
|
|
return NS_ERROR_UNEXPECTED;
|
|
}
|
|
|
|
if (*aPaddingSizeOut == InternalResponse::UNKNOWN_PADDING_SIZE) {
|
|
*aPaddingSizeOut = BodyGeneratePadding(fileSize, aPaddingInfo);
|
|
}
|
|
|
|
MOZ_DIAGNOSTIC_ASSERT(*aPaddingSizeOut >= 0);
|
|
|
|
if (!quotaObject->IncreaseSize(*aPaddingSizeOut)) {
|
|
return NS_ERROR_FILE_NO_DEVICE_SPACE;
|
|
}
|
|
|
|
return rv;
|
|
}
|
|
|
|
// static
|
|
nsresult BodyDeleteFiles(const QuotaInfo& aQuotaInfo, nsIFile* aBaseDir,
|
|
const nsTArray<nsID>& aIdList) {
|
|
nsresult rv = NS_OK;
|
|
for (const auto id : aIdList) {
|
|
nsCOMPtr<nsIFile> bodyDir;
|
|
rv = BodyGetCacheDir(aBaseDir, id, getter_AddRefs(bodyDir));
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
|
|
const auto removeFileForId = [&aQuotaInfo, &id](nsIFile* bodyFile,
|
|
const nsACString& leafName,
|
|
bool& fileDeleted) {
|
|
MOZ_DIAGNOSTIC_ASSERT(bodyFile);
|
|
|
|
nsID fileId;
|
|
if (NS_WARN_IF(!fileId.Parse(leafName.BeginReading()))) {
|
|
DebugOnly<nsresult> result =
|
|
RemoveNsIFile(aQuotaInfo, bodyFile, /* aTrackQuota */ false);
|
|
MOZ_ASSERT(NS_SUCCEEDED(result));
|
|
fileDeleted = true;
|
|
return NS_OK;
|
|
}
|
|
|
|
if (id.Equals(fileId)) {
|
|
DebugOnly<nsresult> result = RemoveNsIFile(aQuotaInfo, bodyFile);
|
|
MOZ_ASSERT(NS_SUCCEEDED(result));
|
|
fileDeleted = true;
|
|
return NS_OK;
|
|
}
|
|
|
|
fileDeleted = false;
|
|
return NS_OK;
|
|
};
|
|
rv = BodyTraverseFiles(aQuotaInfo, bodyDir, removeFileForId,
|
|
/* aCanRemoveFiles */ false,
|
|
/* aTrackQuota */ true);
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
}
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
namespace {
|
|
|
|
nsresult BodyIdToFile(nsIFile* aBaseDir, const nsID& aId, BodyFileType aType,
|
|
nsIFile** aBodyFileOut) {
|
|
MOZ_DIAGNOSTIC_ASSERT(aBaseDir);
|
|
MOZ_DIAGNOSTIC_ASSERT(aBodyFileOut);
|
|
|
|
*aBodyFileOut = nullptr;
|
|
|
|
nsresult rv = BodyGetCacheDir(aBaseDir, aId, aBodyFileOut);
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
MOZ_DIAGNOSTIC_ASSERT(*aBodyFileOut);
|
|
|
|
char idString[NSID_LENGTH];
|
|
aId.ToProvidedString(idString);
|
|
|
|
NS_ConvertASCIItoUTF16 fileName(idString);
|
|
|
|
if (aType == BODY_FILE_FINAL) {
|
|
fileName.AppendLiteral(".final");
|
|
} else {
|
|
fileName.AppendLiteral(".tmp");
|
|
}
|
|
|
|
rv = (*aBodyFileOut)->Append(fileName);
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
|
|
return rv;
|
|
}
|
|
|
|
int64_t RoundUp(const int64_t aX, const int64_t aY) {
|
|
MOZ_DIAGNOSTIC_ASSERT(aX >= 0);
|
|
MOZ_DIAGNOSTIC_ASSERT(aY > 0);
|
|
|
|
MOZ_DIAGNOSTIC_ASSERT(INT64_MAX - ((aX - 1) / aY) * aY >= aY);
|
|
return aY + ((aX - 1) / aY) * aY;
|
|
}
|
|
|
|
int64_t BodyGeneratePadding(const int64_t aBodyFileSize,
|
|
const uint32_t aPaddingInfo) {
|
|
// Generate padding
|
|
int64_t randomSize = static_cast<int64_t>(aPaddingInfo);
|
|
MOZ_DIAGNOSTIC_ASSERT(INT64_MAX - aBodyFileSize >= randomSize);
|
|
randomSize += aBodyFileSize;
|
|
|
|
return RoundUp(randomSize, kRoundUpNumber) - aBodyFileSize;
|
|
}
|
|
|
|
nsresult LockedDirectoryPaddingWrite(nsIFile* aBaseDir,
|
|
DirPaddingFile aPaddingFileType,
|
|
int64_t aPaddingSize) {
|
|
MOZ_DIAGNOSTIC_ASSERT(aBaseDir);
|
|
MOZ_DIAGNOSTIC_ASSERT(aPaddingSize >= 0);
|
|
|
|
nsCOMPtr<nsIFile> file;
|
|
nsresult rv = aBaseDir->Clone(getter_AddRefs(file));
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
|
|
if (aPaddingFileType == DirPaddingFile::TMP_FILE) {
|
|
rv = file->Append(nsLiteralString(PADDING_TMP_FILE_NAME));
|
|
} else {
|
|
rv = file->Append(nsLiteralString(PADDING_FILE_NAME));
|
|
}
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
|
|
nsCOMPtr<nsIOutputStream> outputStream;
|
|
rv = NS_NewLocalFileOutputStream(getter_AddRefs(outputStream), file);
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
|
|
nsCOMPtr<nsIObjectOutputStream> objectStream =
|
|
NS_NewObjectOutputStream(outputStream);
|
|
|
|
rv = objectStream->Write64(aPaddingSize);
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
|
|
return rv;
|
|
}
|
|
|
|
} // namespace
|
|
|
|
nsresult BodyDeleteOrphanedFiles(const QuotaInfo& aQuotaInfo, nsIFile* aBaseDir,
|
|
nsTArray<nsID>& aKnownBodyIdList) {
|
|
MOZ_DIAGNOSTIC_ASSERT(aBaseDir);
|
|
|
|
// body files are stored in a directory structure like:
|
|
//
|
|
// /morgue/01/{01fdddb2-884d-4c3d-95ba-0c8062f6c325}.final
|
|
// /morgue/02/{02fdddb2-884d-4c3d-95ba-0c8062f6c325}.tmp
|
|
|
|
nsCOMPtr<nsIFile> dir;
|
|
nsresult rv = aBaseDir->Clone(getter_AddRefs(dir));
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
|
|
// Add the root morgue directory
|
|
rv = dir->Append(u"morgue"_ns);
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
|
|
nsCOMPtr<nsIDirectoryEnumerator> entries;
|
|
rv = dir->GetDirectoryEntries(getter_AddRefs(entries));
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
|
|
// Iterate over all the intermediate morgue subdirs
|
|
nsCOMPtr<nsIFile> subdir;
|
|
while (NS_SUCCEEDED(rv = entries->GetNextFile(getter_AddRefs(subdir))) &&
|
|
subdir) {
|
|
bool isDir = false;
|
|
rv = subdir->IsDirectory(&isDir);
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
|
|
// If a file got in here somehow, try to remove it and move on
|
|
if (NS_WARN_IF(!isDir)) {
|
|
DebugOnly<nsresult> result =
|
|
RemoveNsIFile(aQuotaInfo, subdir, /* aTrackQuota */ false);
|
|
MOZ_ASSERT(NS_SUCCEEDED(result));
|
|
continue;
|
|
}
|
|
|
|
const auto removeOrphanedFiles =
|
|
[&aQuotaInfo, &aKnownBodyIdList](
|
|
nsIFile* bodyFile, const nsACString& leafName, bool& fileDeleted) {
|
|
MOZ_DIAGNOSTIC_ASSERT(bodyFile);
|
|
// Finally, parse the uuid out of the name. If its fails to parse,
|
|
// the ignore the file.
|
|
nsID id;
|
|
if (NS_WARN_IF(!id.Parse(leafName.BeginReading()))) {
|
|
DebugOnly<nsresult> result = RemoveNsIFile(aQuotaInfo, bodyFile);
|
|
MOZ_ASSERT(NS_SUCCEEDED(result));
|
|
fileDeleted = true;
|
|
return NS_OK;
|
|
}
|
|
|
|
if (!aKnownBodyIdList.Contains(id)) {
|
|
DebugOnly<nsresult> result = RemoveNsIFile(aQuotaInfo, bodyFile);
|
|
MOZ_ASSERT(NS_SUCCEEDED(result));
|
|
fileDeleted = true;
|
|
return NS_OK;
|
|
}
|
|
|
|
fileDeleted = false;
|
|
return NS_OK;
|
|
};
|
|
rv = BodyTraverseFiles(aQuotaInfo, subdir, removeOrphanedFiles,
|
|
/* aCanRemoveFiles */ true,
|
|
/* aTrackQuota */ true);
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
}
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
|
|
return rv;
|
|
}
|
|
|
|
namespace {
|
|
|
|
nsresult GetMarkerFileHandle(const QuotaInfo& aQuotaInfo, nsIFile** aFileOut) {
|
|
MOZ_DIAGNOSTIC_ASSERT(aFileOut);
|
|
|
|
nsCOMPtr<nsIFile> marker;
|
|
nsresult rv = aQuotaInfo.mDir->Clone(getter_AddRefs(marker));
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
|
|
rv = marker->Append(u"cache"_ns);
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
|
|
rv = marker->Append(u"context_open.marker"_ns);
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
|
|
marker.forget(aFileOut);
|
|
|
|
return rv;
|
|
}
|
|
|
|
} // namespace
|
|
|
|
nsresult CreateMarkerFile(const QuotaInfo& aQuotaInfo) {
|
|
nsCOMPtr<nsIFile> marker;
|
|
nsresult rv = GetMarkerFileHandle(aQuotaInfo, getter_AddRefs(marker));
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
|
|
rv = marker->Create(nsIFile::NORMAL_FILE_TYPE, 0644);
|
|
if (rv == NS_ERROR_FILE_ALREADY_EXISTS) {
|
|
rv = NS_OK;
|
|
}
|
|
|
|
// Note, we don't need to fsync here. We only care about actually
|
|
// writing the marker if later modifications to the Cache are
|
|
// actually flushed to the disk. If the OS crashes before the marker
|
|
// is written then we are ensured no other changes to the Cache were
|
|
// flushed either.
|
|
|
|
return rv;
|
|
}
|
|
|
|
nsresult DeleteMarkerFile(const QuotaInfo& aQuotaInfo) {
|
|
nsCOMPtr<nsIFile> marker;
|
|
nsresult rv = GetMarkerFileHandle(aQuotaInfo, getter_AddRefs(marker));
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
|
|
DebugOnly<nsresult> result =
|
|
RemoveNsIFile(aQuotaInfo, marker, /* aTrackQuota */ false);
|
|
MOZ_ASSERT(NS_SUCCEEDED(result));
|
|
|
|
// Again, no fsync is necessary. If the OS crashes before the file
|
|
// removal is flushed, then the Cache will search for stale data on
|
|
// startup. This will cause the next Cache access to be a bit slow, but
|
|
// it seems appropriate after an OS crash.
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
bool MarkerFileExists(const QuotaInfo& aQuotaInfo) {
|
|
nsCOMPtr<nsIFile> marker;
|
|
nsresult rv = GetMarkerFileHandle(aQuotaInfo, getter_AddRefs(marker));
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return false;
|
|
}
|
|
|
|
bool exists = false;
|
|
rv = marker->Exists(&exists);
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return false;
|
|
}
|
|
|
|
return exists;
|
|
}
|
|
|
|
// static
|
|
nsresult RemoveNsIFileRecursively(const QuotaInfo& aQuotaInfo, nsIFile* aFile,
|
|
const bool aTrackQuota) {
|
|
MOZ_DIAGNOSTIC_ASSERT(aFile);
|
|
|
|
bool isDirectory = false;
|
|
nsresult rv = aFile->IsDirectory(&isDirectory);
|
|
if (rv == NS_ERROR_FILE_NOT_FOUND ||
|
|
rv == NS_ERROR_FILE_TARGET_DOES_NOT_EXIST) {
|
|
return NS_OK;
|
|
}
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
|
|
if (!isDirectory) {
|
|
return RemoveNsIFile(aQuotaInfo, aFile, aTrackQuota);
|
|
}
|
|
|
|
// Unfortunately, we need to traverse all the entries and delete files one by
|
|
// one to update their usages to the QuotaManager.
|
|
nsCOMPtr<nsIDirectoryEnumerator> entries;
|
|
rv = aFile->GetDirectoryEntries(getter_AddRefs(entries));
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
|
|
nsCOMPtr<nsIFile> file;
|
|
while (NS_SUCCEEDED((rv = entries->GetNextFile(getter_AddRefs(file)))) &&
|
|
file) {
|
|
rv = RemoveNsIFileRecursively(aQuotaInfo, file, aTrackQuota);
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
}
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
|
|
// In the end, remove the folder
|
|
rv = aFile->Remove(/* recursive */ false);
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
|
|
return rv;
|
|
}
|
|
|
|
// static
|
|
nsresult RemoveNsIFile(const QuotaInfo& aQuotaInfo, nsIFile* aFile,
|
|
const bool aTrackQuota) {
|
|
MOZ_DIAGNOSTIC_ASSERT(aFile);
|
|
|
|
nsresult rv;
|
|
int64_t fileSize = 0;
|
|
if (aTrackQuota) {
|
|
rv = aFile->GetFileSize(&fileSize);
|
|
if (rv == NS_ERROR_FILE_NOT_FOUND ||
|
|
rv == NS_ERROR_FILE_TARGET_DOES_NOT_EXIST) {
|
|
return NS_OK;
|
|
}
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
}
|
|
|
|
rv = aFile->Remove(/* recursive */ false);
|
|
if (rv == NS_ERROR_FILE_NOT_FOUND ||
|
|
rv == NS_ERROR_FILE_TARGET_DOES_NOT_EXIST) {
|
|
MOZ_ASSERT(!aTrackQuota);
|
|
return NS_OK;
|
|
}
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
|
|
if (aTrackQuota && fileSize > 0) {
|
|
DecreaseUsageForQuotaInfo(aQuotaInfo, fileSize);
|
|
}
|
|
|
|
return rv;
|
|
}
|
|
|
|
// static
|
|
void DecreaseUsageForQuotaInfo(const QuotaInfo& aQuotaInfo,
|
|
const int64_t& aUpdatingSize) {
|
|
MOZ_DIAGNOSTIC_ASSERT(aUpdatingSize > 0);
|
|
|
|
QuotaManager* quotaManager = QuotaManager::Get();
|
|
MOZ_DIAGNOSTIC_ASSERT(quotaManager);
|
|
|
|
quotaManager->DecreaseUsageForOrigin(PERSISTENCE_TYPE_DEFAULT, aQuotaInfo,
|
|
Client::DOMCACHE, aUpdatingSize);
|
|
}
|
|
|
|
// static
|
|
bool DirectoryPaddingFileExists(nsIFile* aBaseDir,
|
|
DirPaddingFile aPaddingFileType) {
|
|
MOZ_DIAGNOSTIC_ASSERT(aBaseDir);
|
|
|
|
CACHE_TRY_INSPECT(
|
|
const auto& file,
|
|
CloneFileAndAppend(*aBaseDir, aPaddingFileType == DirPaddingFile::TMP_FILE
|
|
? nsLiteralString(PADDING_TMP_FILE_NAME)
|
|
: nsLiteralString(PADDING_FILE_NAME)),
|
|
false);
|
|
|
|
CACHE_TRY_RETURN(MOZ_TO_RESULT_INVOKE(file, Exists), false);
|
|
}
|
|
|
|
nsresult LockedDirectoryPaddingGet(nsIFile* aBaseDir,
|
|
int64_t* aPaddingSizeOut) {
|
|
MOZ_DIAGNOSTIC_ASSERT(aBaseDir);
|
|
MOZ_DIAGNOSTIC_ASSERT(aPaddingSizeOut);
|
|
|
|
CACHE_TRY_INSPECT(const int64_t& paddingSize,
|
|
LockedDirectoryPaddingGet(*aBaseDir));
|
|
|
|
*aPaddingSizeOut = paddingSize;
|
|
return NS_OK;
|
|
}
|
|
|
|
Result<int64_t, nsresult> LockedDirectoryPaddingGet(nsIFile& aBaseDir) {
|
|
MOZ_DIAGNOSTIC_ASSERT(
|
|
!DirectoryPaddingFileExists(&aBaseDir, DirPaddingFile::TMP_FILE));
|
|
|
|
CACHE_TRY_INSPECT(
|
|
const auto& file,
|
|
CloneFileAndAppend(aBaseDir, nsLiteralString(PADDING_FILE_NAME)));
|
|
|
|
nsCOMPtr<nsIInputStream> stream;
|
|
CACHE_TRY(NS_NewLocalFileInputStream(getter_AddRefs(stream), file));
|
|
|
|
nsCOMPtr<nsIInputStream> bufferedStream;
|
|
CACHE_TRY(NS_NewBufferedInputStream(getter_AddRefs(bufferedStream),
|
|
stream.forget(), 512));
|
|
|
|
nsCOMPtr<nsIObjectInputStream> objectStream =
|
|
NS_NewObjectInputStream(bufferedStream);
|
|
|
|
CACHE_TRY_RETURN(
|
|
MOZ_TO_RESULT_INVOKE(objectStream, Read64).map([](const uint64_t val) {
|
|
return int64_t(val);
|
|
}));
|
|
}
|
|
|
|
// static
|
|
nsresult LockedDirectoryPaddingInit(nsIFile* aBaseDir) {
|
|
MOZ_DIAGNOSTIC_ASSERT(aBaseDir);
|
|
|
|
nsresult rv = LockedDirectoryPaddingWrite(aBaseDir, DirPaddingFile::FILE, 0);
|
|
Unused << NS_WARN_IF(NS_FAILED(rv));
|
|
|
|
return rv;
|
|
}
|
|
|
|
// static
|
|
nsresult LockedUpdateDirectoryPaddingFile(nsIFile* aBaseDir,
|
|
mozIStorageConnection* aConn,
|
|
const int64_t aIncreaseSize,
|
|
const int64_t aDecreaseSize,
|
|
const bool aTemporaryFileExist) {
|
|
MOZ_DIAGNOSTIC_ASSERT(aBaseDir);
|
|
MOZ_DIAGNOSTIC_ASSERT(aConn);
|
|
MOZ_DIAGNOSTIC_ASSERT(aIncreaseSize >= 0);
|
|
MOZ_DIAGNOSTIC_ASSERT(aDecreaseSize >= 0);
|
|
|
|
int64_t currentPaddingSize = 0;
|
|
nsresult rv = NS_OK;
|
|
if (aTemporaryFileExist ||
|
|
NS_WARN_IF(NS_FAILED(
|
|
rv = LockedDirectoryPaddingGet(aBaseDir, ¤tPaddingSize)))) {
|
|
// Fail to read padding size from the dir padding file, so try to restore.
|
|
if (rv != NS_ERROR_FILE_NOT_FOUND &&
|
|
rv != NS_ERROR_FILE_TARGET_DOES_NOT_EXIST) {
|
|
// Not delete the temporary padding file here, because we're going to
|
|
// overwrite it below anyway.
|
|
rv = LockedDirectoryPaddingDeleteFile(aBaseDir, DirPaddingFile::FILE);
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
}
|
|
|
|
// We don't need to add the aIncreaseSize or aDecreaseSize here, because
|
|
// it's already encompassed within the database.
|
|
CACHE_TRY_UNWRAP(currentPaddingSize, db::FindOverallPaddingSize(*aConn));
|
|
} else {
|
|
bool shouldRevise = false;
|
|
if (aIncreaseSize > 0) {
|
|
if (INT64_MAX - currentPaddingSize < aDecreaseSize) {
|
|
shouldRevise = true;
|
|
} else {
|
|
currentPaddingSize += aIncreaseSize;
|
|
}
|
|
}
|
|
|
|
if (aDecreaseSize > 0) {
|
|
if (currentPaddingSize < aDecreaseSize) {
|
|
shouldRevise = true;
|
|
} else if (!shouldRevise) {
|
|
currentPaddingSize -= aDecreaseSize;
|
|
}
|
|
}
|
|
|
|
if (shouldRevise) {
|
|
// If somehow runing into this condition, the tracking padding size is
|
|
// incorrect.
|
|
// Delete padding file to indicate the padding size is incorrect for
|
|
// avoiding error happening in the following lines.
|
|
rv = LockedDirectoryPaddingDeleteFile(aBaseDir, DirPaddingFile::FILE);
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
|
|
CACHE_TRY_UNWRAP(currentPaddingSize, db::FindOverallPaddingSize(*aConn));
|
|
|
|
// XXXtt: we should have an easy way to update (increase or recalulate)
|
|
// padding size in the QM. For now, only correct the padding size in
|
|
// padding file and make QM be able to get the correct size in the next QM
|
|
// initialization.
|
|
// We still want to catch this in the debug build.
|
|
MOZ_ASSERT(false, "The padding size is unsync with QM");
|
|
}
|
|
|
|
#ifdef DEBUG
|
|
int64_t lastPaddingSize = currentPaddingSize;
|
|
CACHE_TRY_UNWRAP(currentPaddingSize, db::FindOverallPaddingSize(*aConn));
|
|
|
|
MOZ_DIAGNOSTIC_ASSERT(currentPaddingSize == lastPaddingSize);
|
|
#endif // DEBUG
|
|
}
|
|
|
|
MOZ_DIAGNOSTIC_ASSERT(currentPaddingSize >= 0);
|
|
|
|
rv = LockedDirectoryPaddingTemporaryWrite(aBaseDir, currentPaddingSize);
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
|
|
return rv;
|
|
}
|
|
|
|
// static
|
|
nsresult LockedDirectoryPaddingTemporaryWrite(nsIFile* aBaseDir,
|
|
int64_t aPaddingSize) {
|
|
MOZ_DIAGNOSTIC_ASSERT(aBaseDir);
|
|
MOZ_DIAGNOSTIC_ASSERT(aPaddingSize >= 0);
|
|
|
|
nsresult rv = LockedDirectoryPaddingWrite(aBaseDir, DirPaddingFile::TMP_FILE,
|
|
aPaddingSize);
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
|
|
return rv;
|
|
}
|
|
|
|
// static
|
|
nsresult LockedDirectoryPaddingFinalizeWrite(nsIFile* aBaseDir) {
|
|
MOZ_DIAGNOSTIC_ASSERT(aBaseDir);
|
|
MOZ_DIAGNOSTIC_ASSERT(
|
|
DirectoryPaddingFileExists(aBaseDir, DirPaddingFile::TMP_FILE));
|
|
|
|
nsCOMPtr<nsIFile> file;
|
|
nsresult rv = aBaseDir->Clone(getter_AddRefs(file));
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
|
|
rv = file->Append(nsLiteralString(PADDING_TMP_FILE_NAME));
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
|
|
rv = file->RenameTo(nullptr, nsLiteralString(PADDING_FILE_NAME));
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
|
|
return rv;
|
|
}
|
|
|
|
Result<int64_t, nsresult> LockedDirectoryPaddingRestore(
|
|
nsIFile& aBaseDir, mozIStorageConnection& aConn, const bool aMustRestore) {
|
|
// The content of padding file is untrusted, so remove it here.
|
|
CACHE_TRY(LockedDirectoryPaddingDeleteFile(&aBaseDir, DirPaddingFile::FILE));
|
|
|
|
CACHE_TRY_INSPECT(const int64_t& paddingSize,
|
|
db::FindOverallPaddingSize(aConn));
|
|
MOZ_DIAGNOSTIC_ASSERT(paddingSize >= 0);
|
|
|
|
CACHE_TRY(
|
|
LockedDirectoryPaddingWrite(&aBaseDir, DirPaddingFile::FILE, paddingSize),
|
|
(aMustRestore ? Err(tryTempError)
|
|
: Result<int64_t, nsresult>{paddingSize}));
|
|
|
|
CACHE_TRY(
|
|
LockedDirectoryPaddingDeleteFile(&aBaseDir, DirPaddingFile::TMP_FILE));
|
|
|
|
return paddingSize;
|
|
}
|
|
|
|
// static
|
|
nsresult LockedDirectoryPaddingDeleteFile(nsIFile* aBaseDir,
|
|
DirPaddingFile aPaddingFileType) {
|
|
MOZ_DIAGNOSTIC_ASSERT(aBaseDir);
|
|
|
|
nsCOMPtr<nsIFile> file;
|
|
nsresult rv = aBaseDir->Clone(getter_AddRefs(file));
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
|
|
if (aPaddingFileType == DirPaddingFile::TMP_FILE) {
|
|
rv = file->Append(nsLiteralString(PADDING_TMP_FILE_NAME));
|
|
} else {
|
|
rv = file->Append(nsLiteralString(PADDING_FILE_NAME));
|
|
}
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
|
|
rv = file->Remove(/* recursive */ false);
|
|
if (rv == NS_ERROR_FILE_NOT_FOUND ||
|
|
rv == NS_ERROR_FILE_TARGET_DOES_NOT_EXIST) {
|
|
return NS_OK;
|
|
}
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
|
|
return rv;
|
|
}
|
|
} // namespace mozilla::dom::cache
|