diff options
Diffstat (limited to 'netwerk/cache')
31 files changed, 9625 insertions, 0 deletions
diff --git a/netwerk/cache/moz.build b/netwerk/cache/moz.build new file mode 100644 index 0000000000..62a0c06ebe --- /dev/null +++ b/netwerk/cache/moz.build @@ -0,0 +1,50 @@ +# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*- +# vim: set filetype=python: +# 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/. + +with Files("**"): + BUG_COMPONENT = ("Core", "Networking: Cache") + +XPIDL_SOURCES += [ + "nsICache.idl", + "nsICacheEntryDescriptor.idl", + "nsICacheListener.idl", + "nsICacheService.idl", + "nsICacheSession.idl", + "nsICacheVisitor.idl", +] + +XPIDL_MODULE = "necko_cache" + +EXPORTS += [ + "nsApplicationCache.h", + "nsApplicationCacheService.h", + "nsCacheDevice.h", + "nsCacheService.h", + "nsDeleteDir.h", + "nsDiskCacheDeviceSQL.h", +] + +UNIFIED_SOURCES += [ + "nsApplicationCacheService.cpp", + "nsCache.cpp", + "nsCacheEntry.cpp", + "nsCacheEntryDescriptor.cpp", + "nsCacheMetaData.cpp", + "nsCacheService.cpp", + "nsCacheSession.cpp", + "nsCacheUtils.cpp", + "nsDeleteDir.cpp", + "nsDiskCacheDeviceSQL.cpp", +] + +FINAL_LIBRARY = "xul" + +LOCAL_INCLUDES += [ + "/netwerk/base", +] + +if CONFIG["CC_TYPE"] in ("clang", "gcc"): + CXXFLAGS += ["-Wno-error=shadow"] diff --git a/netwerk/cache/nsApplicationCache.h b/netwerk/cache/nsApplicationCache.h new file mode 100644 index 0000000000..37e3bc14e4 --- /dev/null +++ b/netwerk/cache/nsApplicationCache.h @@ -0,0 +1,33 @@ +/* vim:set ts=2 sw=2 sts=2 et cin: */ +/* 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 "nsIApplicationCache.h" +#include "nsWeakReference.h" +#include "mozilla/RefPtr.h" +#include "nsString.h" + +class nsOfflineCacheDevice; + +class nsApplicationCache : public nsIApplicationCache, + public nsSupportsWeakReference { + public: + NS_DECL_ISUPPORTS + NS_DECL_NSIAPPLICATIONCACHE + + nsApplicationCache(nsOfflineCacheDevice* device, const nsACString& group, + const nsACString& clientID); + + nsApplicationCache(); + + void MarkInvalid(); + + private: + virtual ~nsApplicationCache(); + + RefPtr<nsOfflineCacheDevice> mDevice; + nsCString mGroup; + nsCString mClientID; + bool mValid; +}; diff --git a/netwerk/cache/nsApplicationCacheService.cpp b/netwerk/cache/nsApplicationCacheService.cpp new file mode 100644 index 0000000000..af931706a3 --- /dev/null +++ b/netwerk/cache/nsApplicationCacheService.cpp @@ -0,0 +1,192 @@ +/* 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 "nsDiskCache.h" +#include "nsDiskCacheDeviceSQL.h" +#include "nsCacheService.h" +#include "nsApplicationCacheService.h" +#include "nsCRT.h" +#include "nsNetCID.h" +#include "nsNetUtil.h" +#include "nsIObserverService.h" +#include "mozilla/LoadContextInfo.h" + +using namespace mozilla; + +static NS_DEFINE_CID(kCacheServiceCID, NS_CACHESERVICE_CID); + +//----------------------------------------------------------------------------- +// nsApplicationCacheService +//----------------------------------------------------------------------------- + +NS_IMPL_ISUPPORTS(nsApplicationCacheService, nsIApplicationCacheService) + +nsApplicationCacheService::nsApplicationCacheService() { + nsCOMPtr<nsICacheService> serv = do_GetService(kCacheServiceCID); + mCacheService = nsCacheService::GlobalInstance(); +} + +NS_IMETHODIMP +nsApplicationCacheService::BuildGroupIDForInfo( + nsIURI* aManifestURL, nsILoadContextInfo* aLoadContextInfo, + nsACString& _result) { + nsresult rv; + + nsAutoCString originSuffix; + if (aLoadContextInfo) { + aLoadContextInfo->OriginAttributesPtr()->CreateSuffix(originSuffix); + } + + rv = nsOfflineCacheDevice::BuildApplicationCacheGroupID( + aManifestURL, originSuffix, _result); + NS_ENSURE_SUCCESS(rv, rv); + + return NS_OK; +} + +NS_IMETHODIMP +nsApplicationCacheService::BuildGroupIDForSuffix( + nsIURI* aManifestURL, nsACString const& aOriginSuffix, + nsACString& _result) { + nsresult rv; + + rv = nsOfflineCacheDevice::BuildApplicationCacheGroupID( + aManifestURL, aOriginSuffix, _result); + NS_ENSURE_SUCCESS(rv, rv); + + return NS_OK; +} + +NS_IMETHODIMP +nsApplicationCacheService::CreateApplicationCache(const nsACString& group, + nsIApplicationCache** out) { + if (!mCacheService) return NS_ERROR_UNEXPECTED; + + RefPtr<nsOfflineCacheDevice> device; + nsresult rv = mCacheService->GetOfflineDevice(getter_AddRefs(device)); + NS_ENSURE_SUCCESS(rv, rv); + return device->CreateApplicationCache(group, out); +} + +NS_IMETHODIMP +nsApplicationCacheService::CreateCustomApplicationCache( + const nsACString& group, nsIFile* profileDir, int32_t quota, + nsIApplicationCache** out) { + if (!mCacheService) return NS_ERROR_UNEXPECTED; + + RefPtr<nsOfflineCacheDevice> device; + nsresult rv = mCacheService->GetCustomOfflineDevice(profileDir, quota, + getter_AddRefs(device)); + NS_ENSURE_SUCCESS(rv, rv); + return device->CreateApplicationCache(group, out); +} + +NS_IMETHODIMP +nsApplicationCacheService::GetApplicationCache(const nsACString& clientID, + nsIApplicationCache** out) { + if (!mCacheService) return NS_ERROR_UNEXPECTED; + + RefPtr<nsOfflineCacheDevice> device; + nsresult rv = mCacheService->GetOfflineDevice(getter_AddRefs(device)); + NS_ENSURE_SUCCESS(rv, rv); + return device->GetApplicationCache(clientID, out); +} + +NS_IMETHODIMP +nsApplicationCacheService::GetActiveCache(const nsACString& group, + nsIApplicationCache** out) { + if (!mCacheService) return NS_ERROR_UNEXPECTED; + + RefPtr<nsOfflineCacheDevice> device; + nsresult rv = mCacheService->GetOfflineDevice(getter_AddRefs(device)); + NS_ENSURE_SUCCESS(rv, rv); + return device->GetActiveCache(group, out); +} + +NS_IMETHODIMP +nsApplicationCacheService::DeactivateGroup(const nsACString& group) { + if (!mCacheService) return NS_ERROR_UNEXPECTED; + + RefPtr<nsOfflineCacheDevice> device; + nsresult rv = mCacheService->GetOfflineDevice(getter_AddRefs(device)); + NS_ENSURE_SUCCESS(rv, rv); + return device->DeactivateGroup(group); +} + +NS_IMETHODIMP +nsApplicationCacheService::ChooseApplicationCache( + const nsACString& key, nsILoadContextInfo* aLoadContextInfo, + nsIApplicationCache** out) { + if (!mCacheService) return NS_ERROR_UNEXPECTED; + + RefPtr<nsOfflineCacheDevice> device; + nsresult rv = mCacheService->GetOfflineDevice(getter_AddRefs(device)); + if (NS_FAILED(rv)) { + // Silently fail and provide no appcache to the caller. + return NS_OK; + } + + return device->ChooseApplicationCache(key, aLoadContextInfo, out); +} + +NS_IMETHODIMP +nsApplicationCacheService::CacheOpportunistically(nsIApplicationCache* cache, + const nsACString& key) { + if (!mCacheService) return NS_ERROR_UNEXPECTED; + + RefPtr<nsOfflineCacheDevice> device; + nsresult rv = mCacheService->GetOfflineDevice(getter_AddRefs(device)); + NS_ENSURE_SUCCESS(rv, rv); + return device->CacheOpportunistically(cache, key); +} + +NS_IMETHODIMP +nsApplicationCacheService::Evict(nsILoadContextInfo* aInfo) { + if (!mCacheService) return NS_ERROR_UNEXPECTED; + + RefPtr<nsOfflineCacheDevice> device; + nsresult rv = mCacheService->GetOfflineDevice(getter_AddRefs(device)); + NS_ENSURE_SUCCESS(rv, rv); + return device->Evict(aInfo); +} + +NS_IMETHODIMP +nsApplicationCacheService::EvictMatchingOriginAttributes( + nsAString const& aPattern) { + if (!mCacheService) return NS_ERROR_UNEXPECTED; + + RefPtr<nsOfflineCacheDevice> device; + nsresult rv = mCacheService->GetOfflineDevice(getter_AddRefs(device)); + NS_ENSURE_SUCCESS(rv, rv); + + mozilla::OriginAttributesPattern pattern; + if (!pattern.Init(aPattern)) { + NS_ERROR( + "Could not parse OriginAttributesPattern JSON in " + "clear-origin-attributes-data notification"); + return NS_ERROR_FAILURE; + } + + return device->Evict(pattern); +} + +NS_IMETHODIMP +nsApplicationCacheService::GetGroups(nsTArray<nsCString>& keys) { + if (!mCacheService) return NS_ERROR_UNEXPECTED; + + RefPtr<nsOfflineCacheDevice> device; + nsresult rv = mCacheService->GetOfflineDevice(getter_AddRefs(device)); + NS_ENSURE_SUCCESS(rv, rv); + return device->GetGroups(keys); +} + +NS_IMETHODIMP +nsApplicationCacheService::GetGroupsTimeOrdered(nsTArray<nsCString>& keys) { + if (!mCacheService) return NS_ERROR_UNEXPECTED; + + RefPtr<nsOfflineCacheDevice> device; + nsresult rv = mCacheService->GetOfflineDevice(getter_AddRefs(device)); + NS_ENSURE_SUCCESS(rv, rv); + return device->GetGroupsTimeOrdered(keys); +} diff --git a/netwerk/cache/nsApplicationCacheService.h b/netwerk/cache/nsApplicationCacheService.h new file mode 100644 index 0000000000..d57a913726 --- /dev/null +++ b/netwerk/cache/nsApplicationCacheService.h @@ -0,0 +1,27 @@ +/* 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/. */ + +#ifndef _nsApplicationCacheService_h_ +#define _nsApplicationCacheService_h_ + +#include "nsIApplicationCacheService.h" +#include "mozilla/Attributes.h" + +class nsCacheService; + +class nsApplicationCacheService final : public nsIApplicationCacheService { + public: + nsApplicationCacheService(); + + NS_DECL_ISUPPORTS + NS_DECL_NSIAPPLICATIONCACHESERVICE + + static void AppClearDataObserverInit(); + + private: + ~nsApplicationCacheService() = default; + RefPtr<nsCacheService> mCacheService; +}; + +#endif // _nsApplicationCacheService_h_ diff --git a/netwerk/cache/nsCache.cpp b/netwerk/cache/nsCache.cpp new file mode 100644 index 0000000000..73b98dee1c --- /dev/null +++ b/netwerk/cache/nsCache.cpp @@ -0,0 +1,70 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- + * + * 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 "nsCache.h" +#include "nsReadableUtils.h" +#include "nsDependentSubstring.h" +#include "nsString.h" +#include "mozilla/IntegerPrintfMacros.h" + +/** + * Cache Service Utility Functions + */ + +mozilla::LazyLogModule gCacheLog("cache"); + +void CacheLogPrintPath(mozilla::LogLevel level, const char* format, + nsIFile* item) { + MOZ_LOG(gCacheLog, level, (format, item->HumanReadablePath().get())); +} + +uint32_t SecondsFromPRTime(PRTime prTime) { + int64_t microSecondsPerSecond = PR_USEC_PER_SEC; + return uint32_t(prTime / microSecondsPerSecond); +} + +PRTime PRTimeFromSeconds(uint32_t seconds) { + int64_t intermediateResult = seconds; + PRTime prTime = intermediateResult * PR_USEC_PER_SEC; + return prTime; +} + +nsresult ClientIDFromCacheKey(const nsACString& key, nsACString& result) { + nsReadingIterator<char> colon; + key.BeginReading(colon); + + nsReadingIterator<char> start; + key.BeginReading(start); + + nsReadingIterator<char> end; + key.EndReading(end); + + if (FindCharInReadable(':', colon, end)) { + result.Assign(Substring(start, colon)); + return NS_OK; + } + + NS_ASSERTION(false, "FindCharInRead failed to find ':'"); + return NS_ERROR_UNEXPECTED; +} + +nsresult ClientKeyFromCacheKey(const nsCString& key, nsACString& result) { + nsReadingIterator<char> start; + key.BeginReading(start); + + nsReadingIterator<char> end; + key.EndReading(end); + + if (FindCharInReadable(':', start, end)) { + ++start; // advance past clientID ':' delimiter + result.Assign(Substring(start, end)); + return NS_OK; + } + + NS_ASSERTION(false, "FindCharInRead failed to find ':'"); + result.Truncate(0); + return NS_ERROR_UNEXPECTED; +} diff --git a/netwerk/cache/nsCache.h b/netwerk/cache/nsCache.h new file mode 100644 index 0000000000..859dddb8f2 --- /dev/null +++ b/netwerk/cache/nsCache.h @@ -0,0 +1,39 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- + * + * 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/. */ + +/** + * Cache Service Utility Functions + */ + +#ifndef _nsCache_h_ +#define _nsCache_h_ + +#include "mozilla/Logging.h" +#include "nsISupports.h" +#include "nsIFile.h" +#include "nsAString.h" +#include "prtime.h" +#include "nsError.h" + +// PR_LOG args = "format string", arg, arg, ... +extern mozilla::LazyLogModule gCacheLog; +void CacheLogPrintPath(mozilla::LogLevel level, const char* format, + nsIFile* item); +#define CACHE_LOG_INFO(args) MOZ_LOG(gCacheLog, mozilla::LogLevel::Info, args) +#define CACHE_LOG_ERROR(args) MOZ_LOG(gCacheLog, mozilla::LogLevel::Error, args) +#define CACHE_LOG_WARNING(args) \ + MOZ_LOG(gCacheLog, mozilla::LogLevel::Warning, args) +#define CACHE_LOG_DEBUG(args) MOZ_LOG(gCacheLog, mozilla::LogLevel::Debug, args) +#define CACHE_LOG_PATH(level, format, item) \ + CacheLogPrintPath(level, format, item) + +extern uint32_t SecondsFromPRTime(PRTime prTime); +extern PRTime PRTimeFromSeconds(uint32_t seconds); + +extern nsresult ClientIDFromCacheKey(const nsACString& key, nsACString& result); +extern nsresult ClientKeyFromCacheKey(const nsCString& key, nsACString& result); + +#endif // _nsCache_h diff --git a/netwerk/cache/nsCacheDevice.h b/netwerk/cache/nsCacheDevice.h new file mode 100644 index 0000000000..fc68bcb8a2 --- /dev/null +++ b/netwerk/cache/nsCacheDevice.h @@ -0,0 +1,63 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- + * + * 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/. */ + +#ifndef _nsCacheDevice_h_ +#define _nsCacheDevice_h_ + +#include "nspr.h" +#include "nsError.h" +#include "nsICache.h" +#include "nsStringFwd.h" + +class nsIFile; +class nsCacheEntry; +class nsICacheVisitor; +class nsIInputStream; +class nsIOutputStream; + +/****************************************************************************** + * nsCacheDevice + *******************************************************************************/ +class nsCacheDevice { + public: + MOZ_COUNTED_DEFAULT_CTOR(nsCacheDevice) + MOZ_COUNTED_DTOR_VIRTUAL(nsCacheDevice) + + virtual nsresult Init() = 0; + virtual nsresult Shutdown() = 0; + + virtual const char* GetDeviceID(void) = 0; + virtual nsCacheEntry* FindEntry(nsCString* key, bool* collision) = 0; + + virtual nsresult DeactivateEntry(nsCacheEntry* entry) = 0; + virtual nsresult BindEntry(nsCacheEntry* entry) = 0; + virtual void DoomEntry(nsCacheEntry* entry) = 0; + + virtual nsresult OpenInputStreamForEntry(nsCacheEntry* entry, + nsCacheAccessMode mode, + uint32_t offset, + nsIInputStream** result) = 0; + + virtual nsresult OpenOutputStreamForEntry(nsCacheEntry* entry, + nsCacheAccessMode mode, + uint32_t offset, + nsIOutputStream** result) = 0; + + virtual nsresult GetFileForEntry(nsCacheEntry* entry, nsIFile** result) = 0; + + virtual nsresult OnDataSizeChange(nsCacheEntry* entry, int32_t deltaSize) = 0; + + virtual nsresult Visit(nsICacheVisitor* visitor) = 0; + + /** + * Device must evict entries associated with clientID. If clientID == + * nullptr, all entries must be evicted. Active entries must be doomed, + * rather than evicted. + */ + virtual nsresult EvictEntries(const char* clientID) = 0; +}; + +#endif // _nsCacheDevice_h_ diff --git a/netwerk/cache/nsCacheEntry.cpp b/netwerk/cache/nsCacheEntry.cpp new file mode 100644 index 0000000000..c91748ef72 --- /dev/null +++ b/netwerk/cache/nsCacheEntry.cpp @@ -0,0 +1,415 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- + * + * 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 "nsCache.h" +#include "nspr.h" +#include "nsCacheEntry.h" +#include "nsCacheEntryDescriptor.h" +#include "nsCacheMetaData.h" +#include "nsCacheRequest.h" +#include "nsThreadUtils.h" +#include "nsError.h" +#include "nsCacheService.h" +#include "nsCacheDevice.h" +#include "nsHashKeys.h" + +using namespace mozilla; + +nsCacheEntry::nsCacheEntry(const nsACString& key, bool streamBased, + nsCacheStoragePolicy storagePolicy) + : mKey(key), + mFetchCount(0), + mLastFetched(0), + mLastModified(0), + mLastValidated(0), + mExpirationTime(nsICache::NO_EXPIRATION_TIME), + mFlags(0), + mPredictedDataSize(-1), + mDataSize(0), + mCacheDevice(nullptr), + mCustomDevice(nullptr), + mData(nullptr), + mRequestQ{}, + mDescriptorQ{} { + MOZ_COUNT_CTOR(nsCacheEntry); + PR_INIT_CLIST(this); + PR_INIT_CLIST(&mRequestQ); + PR_INIT_CLIST(&mDescriptorQ); + + if (streamBased) MarkStreamBased(); + SetStoragePolicy(storagePolicy); + + MarkPublic(); +} + +nsCacheEntry::~nsCacheEntry() { + MOZ_COUNT_DTOR(nsCacheEntry); + + if (mData) nsCacheService::ReleaseObject_Locked(mData, mEventTarget); +} + +nsresult nsCacheEntry::Create(const char* key, bool streamBased, + nsCacheStoragePolicy storagePolicy, + nsCacheDevice* device, nsCacheEntry** result) { + nsCacheEntry* entry = + new nsCacheEntry(nsCString(key), streamBased, storagePolicy); + entry->SetCacheDevice(device); + *result = entry; + return NS_OK; +} + +void nsCacheEntry::Fetched() { + mLastFetched = SecondsFromPRTime(PR_Now()); + ++mFetchCount; + MarkEntryDirty(); +} + +const char* nsCacheEntry::GetDeviceID() { + if (mCacheDevice) return mCacheDevice->GetDeviceID(); + return nullptr; +} + +void nsCacheEntry::TouchData() { + mLastModified = SecondsFromPRTime(PR_Now()); + MarkDataDirty(); +} + +void nsCacheEntry::SetData(nsISupports* data) { + if (mData) { + nsCacheService::ReleaseObject_Locked(mData, mEventTarget); + mData = nullptr; + } + + if (data) { + NS_ADDREF(mData = data); + mEventTarget = GetCurrentEventTarget(); + } +} + +void nsCacheEntry::TouchMetaData() { + mLastModified = SecondsFromPRTime(PR_Now()); + MarkMetaDataDirty(); +} + +/** + * cache entry states + * 0 descriptors (new entry) + * 0 descriptors (existing, bound entry) + * n descriptors (existing, bound entry) valid + * n descriptors (existing, bound entry) not valid (wait until valid or + * doomed) + */ + +nsresult nsCacheEntry::RequestAccess(nsCacheRequest* request, + nsCacheAccessMode* accessGranted) { + nsresult rv = NS_OK; + + if (IsDoomed()) return NS_ERROR_CACHE_ENTRY_DOOMED; + + if (!IsInitialized()) { + // brand new, unbound entry + if (request->IsStreamBased()) MarkStreamBased(); + MarkInitialized(); + + *accessGranted = request->AccessRequested() & nsICache::ACCESS_WRITE; + NS_ASSERTION(*accessGranted, "new cache entry for READ-ONLY request"); + PR_APPEND_LINK(request, &mRequestQ); + return rv; + } + + if (IsStreamData() != request->IsStreamBased()) { + *accessGranted = nsICache::ACCESS_NONE; + return request->IsStreamBased() ? NS_ERROR_CACHE_DATA_IS_NOT_STREAM + : NS_ERROR_CACHE_DATA_IS_STREAM; + } + + if (PR_CLIST_IS_EMPTY(&mDescriptorQ)) { + // 1st descriptor for existing bound entry + *accessGranted = request->AccessRequested(); + if (*accessGranted & nsICache::ACCESS_WRITE) { + MarkInvalid(); + } else { + MarkValid(); + } + } else { + // nth request for existing, bound entry + *accessGranted = request->AccessRequested() & ~nsICache::ACCESS_WRITE; + if (!IsValid()) rv = NS_ERROR_CACHE_WAIT_FOR_VALIDATION; + } + PR_APPEND_LINK(request, &mRequestQ); + + return rv; +} + +nsresult nsCacheEntry::CreateDescriptor(nsCacheRequest* request, + nsCacheAccessMode accessGranted, + nsICacheEntryDescriptor** result) { + NS_ENSURE_ARG_POINTER(request && result); + + nsCacheEntryDescriptor* descriptor = + new nsCacheEntryDescriptor(this, accessGranted); + + // XXX check request is on q + PR_REMOVE_AND_INIT_LINK(request); // remove request regardless of success + + if (descriptor == nullptr) return NS_ERROR_OUT_OF_MEMORY; + + PR_APPEND_LINK(descriptor, &mDescriptorQ); + + CACHE_LOG_DEBUG((" descriptor %p created for request %p on entry %p\n", + descriptor, request, this)); + + *result = do_AddRef(descriptor).take(); + return NS_OK; +} + +bool nsCacheEntry::RemoveRequest(nsCacheRequest* request) { + // XXX if debug: verify this request belongs to this entry + PR_REMOVE_AND_INIT_LINK(request); + + // return true if this entry should stay active + return !((PR_CLIST_IS_EMPTY(&mRequestQ)) && + (PR_CLIST_IS_EMPTY(&mDescriptorQ))); +} + +bool nsCacheEntry::RemoveDescriptor(nsCacheEntryDescriptor* descriptor, + bool* doomEntry) { + NS_ASSERTION(descriptor->CacheEntry() == this, "### Wrong cache entry!!"); + + *doomEntry = descriptor->ClearCacheEntry(); + + PR_REMOVE_AND_INIT_LINK(descriptor); + + if (!PR_CLIST_IS_EMPTY(&mDescriptorQ)) + return true; // stay active if we still have open descriptors + + if (PR_CLIST_IS_EMPTY(&mRequestQ)) + return false; // no descriptors or requests, we can deactivate + + return true; // find next best request to give a descriptor to +} + +void nsCacheEntry::DetachDescriptors() { + nsCacheEntryDescriptor* descriptor = + (nsCacheEntryDescriptor*)PR_LIST_HEAD(&mDescriptorQ); + + while (descriptor != &mDescriptorQ) { + nsCacheEntryDescriptor* nextDescriptor = + (nsCacheEntryDescriptor*)PR_NEXT_LINK(descriptor); + + descriptor->ClearCacheEntry(); + PR_REMOVE_AND_INIT_LINK(descriptor); + descriptor = nextDescriptor; + } +} + +void nsCacheEntry::GetDescriptors( + nsTArray<RefPtr<nsCacheEntryDescriptor> >& outDescriptors) { + nsCacheEntryDescriptor* descriptor = + (nsCacheEntryDescriptor*)PR_LIST_HEAD(&mDescriptorQ); + + while (descriptor != &mDescriptorQ) { + nsCacheEntryDescriptor* nextDescriptor = + (nsCacheEntryDescriptor*)PR_NEXT_LINK(descriptor); + + outDescriptors.AppendElement(descriptor); + descriptor = nextDescriptor; + } +} + +/****************************************************************************** + * nsCacheEntryInfo - for implementing about:cache + *****************************************************************************/ + +NS_IMPL_ISUPPORTS(nsCacheEntryInfo, nsICacheEntryInfo) + +NS_IMETHODIMP +nsCacheEntryInfo::GetClientID(nsACString& aClientID) { + if (!mCacheEntry) { + aClientID.Truncate(); + return NS_ERROR_NOT_AVAILABLE; + } + + return ClientIDFromCacheKey(*mCacheEntry->Key(), aClientID); +} + +NS_IMETHODIMP +nsCacheEntryInfo::GetDeviceID(nsACString& aDeviceID) { + if (!mCacheEntry) { + aDeviceID.Truncate(); + return NS_ERROR_NOT_AVAILABLE; + } + + aDeviceID.Assign(mCacheEntry->GetDeviceID()); + return NS_OK; +} + +NS_IMETHODIMP +nsCacheEntryInfo::GetKey(nsACString& key) { + if (!mCacheEntry) return NS_ERROR_NOT_AVAILABLE; + + return ClientKeyFromCacheKey(*mCacheEntry->Key(), key); +} + +NS_IMETHODIMP +nsCacheEntryInfo::GetFetchCount(int32_t* fetchCount) { + NS_ENSURE_ARG_POINTER(fetchCount); + if (!mCacheEntry) return NS_ERROR_NOT_AVAILABLE; + + *fetchCount = mCacheEntry->FetchCount(); + return NS_OK; +} + +NS_IMETHODIMP +nsCacheEntryInfo::GetLastFetched(uint32_t* lastFetched) { + NS_ENSURE_ARG_POINTER(lastFetched); + if (!mCacheEntry) return NS_ERROR_NOT_AVAILABLE; + + *lastFetched = mCacheEntry->LastFetched(); + return NS_OK; +} + +NS_IMETHODIMP +nsCacheEntryInfo::GetLastModified(uint32_t* lastModified) { + NS_ENSURE_ARG_POINTER(lastModified); + if (!mCacheEntry) return NS_ERROR_NOT_AVAILABLE; + + *lastModified = mCacheEntry->LastModified(); + return NS_OK; +} + +NS_IMETHODIMP +nsCacheEntryInfo::GetExpirationTime(uint32_t* expirationTime) { + NS_ENSURE_ARG_POINTER(expirationTime); + if (!mCacheEntry) return NS_ERROR_NOT_AVAILABLE; + + *expirationTime = mCacheEntry->ExpirationTime(); + return NS_OK; +} + +NS_IMETHODIMP +nsCacheEntryInfo::GetDataSize(uint32_t* dataSize) { + NS_ENSURE_ARG_POINTER(dataSize); + if (!mCacheEntry) return NS_ERROR_NOT_AVAILABLE; + + *dataSize = mCacheEntry->DataSize(); + return NS_OK; +} + +NS_IMETHODIMP +nsCacheEntryInfo::IsStreamBased(bool* result) { + NS_ENSURE_ARG_POINTER(result); + if (!mCacheEntry) return NS_ERROR_NOT_AVAILABLE; + + *result = mCacheEntry->IsStreamData(); + return NS_OK; +} + +/****************************************************************************** + * nsCacheEntryHashTable + *****************************************************************************/ + +const PLDHashTableOps nsCacheEntryHashTable::ops = {HashKey, MatchEntry, + MoveEntry, ClearEntry}; + +nsCacheEntryHashTable::nsCacheEntryHashTable() + : table(&ops, sizeof(nsCacheEntryHashTableEntry), kInitialTableLength), + initialized(false) { + MOZ_COUNT_CTOR(nsCacheEntryHashTable); +} + +nsCacheEntryHashTable::~nsCacheEntryHashTable() { + MOZ_COUNT_DTOR(nsCacheEntryHashTable); + if (initialized) Shutdown(); +} + +void nsCacheEntryHashTable::Init() { + table.ClearAndPrepareForLength(kInitialTableLength); + initialized = true; +} + +void nsCacheEntryHashTable::Shutdown() { + if (initialized) { + table.ClearAndPrepareForLength(kInitialTableLength); + initialized = false; + } +} + +nsCacheEntry* nsCacheEntryHashTable::GetEntry(const nsCString* key) const { + NS_ASSERTION(initialized, "nsCacheEntryHashTable not initialized"); + if (!initialized) return nullptr; + + PLDHashEntryHdr* hashEntry = table.Search(key); + return hashEntry ? ((nsCacheEntryHashTableEntry*)hashEntry)->cacheEntry + : nullptr; +} + +nsresult nsCacheEntryHashTable::AddEntry(nsCacheEntry* cacheEntry) { + PLDHashEntryHdr* hashEntry; + + NS_ASSERTION(initialized, "nsCacheEntryHashTable not initialized"); + if (!initialized) return NS_ERROR_NOT_INITIALIZED; + if (!cacheEntry) return NS_ERROR_NULL_POINTER; + + hashEntry = table.Add(&(cacheEntry->mKey), fallible); + + if (!hashEntry) return NS_ERROR_FAILURE; + NS_ASSERTION(((nsCacheEntryHashTableEntry*)hashEntry)->cacheEntry == nullptr, + "### nsCacheEntryHashTable::AddEntry - entry already used"); + ((nsCacheEntryHashTableEntry*)hashEntry)->cacheEntry = cacheEntry; + + return NS_OK; +} + +void nsCacheEntryHashTable::RemoveEntry(nsCacheEntry* cacheEntry) { + NS_ASSERTION(initialized, "nsCacheEntryHashTable not initialized"); + NS_ASSERTION(cacheEntry, "### cacheEntry == nullptr"); + + if (!initialized) return; // NS_ERROR_NOT_INITIALIZED + +#if DEBUG + // XXX debug code to make sure we have the entry we're trying to remove + nsCacheEntry* check = GetEntry(&(cacheEntry->mKey)); + NS_ASSERTION(check == cacheEntry, + "### Attempting to remove unknown cache entry!!!"); +#endif + table.Remove(&(cacheEntry->mKey)); +} + +PLDHashTable::Iterator nsCacheEntryHashTable::Iter() { + return PLDHashTable::Iterator(&table); +} + +/** + * hash table operation callback functions + */ + +PLDHashNumber nsCacheEntryHashTable::HashKey(const void* key) { + return HashString(*static_cast<const nsCString*>(key)); +} + +bool nsCacheEntryHashTable::MatchEntry(const PLDHashEntryHdr* hashEntry, + const void* key) { + NS_ASSERTION(key != nullptr, + "### nsCacheEntryHashTable::MatchEntry : null key"); + nsCacheEntry* cacheEntry = + ((nsCacheEntryHashTableEntry*)hashEntry)->cacheEntry; + + return cacheEntry->mKey.Equals(*(nsCString*)key); +} + +void nsCacheEntryHashTable::MoveEntry(PLDHashTable* /* table */, + const PLDHashEntryHdr* from, + PLDHashEntryHdr* to) { + new (KnownNotNull, to) nsCacheEntryHashTableEntry( + std::move(*((nsCacheEntryHashTableEntry*)from))); + // No need to destroy `from`. +} + +void nsCacheEntryHashTable::ClearEntry(PLDHashTable* /* table */, + PLDHashEntryHdr* hashEntry) { + ((nsCacheEntryHashTableEntry*)hashEntry)->cacheEntry = nullptr; +} diff --git a/netwerk/cache/nsCacheEntry.h b/netwerk/cache/nsCacheEntry.h new file mode 100644 index 0000000000..ee2a2af35f --- /dev/null +++ b/netwerk/cache/nsCacheEntry.h @@ -0,0 +1,285 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- + * + * 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/. */ + +#ifndef _nsCacheEntry_h_ +#define _nsCacheEntry_h_ + +#include "nsICache.h" +#include "nsICacheEntryDescriptor.h" +#include "nsCacheMetaData.h" + +#include "nspr.h" +#include "PLDHashTable.h" +#include "nscore.h" +#include "nsCOMPtr.h" +#include "nsString.h" +#include "nsAString.h" + +class nsCacheDevice; +class nsCacheMetaData; +class nsCacheRequest; +class nsCacheEntryDescriptor; +class nsIEventTarget; + +/****************************************************************************** + * nsCacheEntry + *******************************************************************************/ +class nsCacheEntry : public PRCList { + public: + nsCacheEntry(const nsACString& key, bool streamBased, + nsCacheStoragePolicy storagePolicy); + ~nsCacheEntry(); + + static nsresult Create(const char* key, bool streamBased, + nsCacheStoragePolicy storagePolicy, + nsCacheDevice* device, nsCacheEntry** result); + + nsCString* Key() { return &mKey; } + + int32_t FetchCount() { return mFetchCount; } + void SetFetchCount(int32_t count) { mFetchCount = count; } + void Fetched(); + + uint32_t LastFetched() { return mLastFetched; } + void SetLastFetched(uint32_t lastFetched) { mLastFetched = lastFetched; } + + uint32_t LastModified() { return mLastModified; } + void SetLastModified(uint32_t lastModified) { mLastModified = lastModified; } + + uint32_t ExpirationTime() { return mExpirationTime; } + void SetExpirationTime(uint32_t expires) { mExpirationTime = expires; } + + uint32_t Size() { return mDataSize + mMetaData.Size() + mKey.Length(); } + + nsCacheDevice* CacheDevice() { return mCacheDevice; } + void SetCacheDevice(nsCacheDevice* device) { mCacheDevice = device; } + void SetCustomCacheDevice(nsCacheDevice* device) { mCustomDevice = device; } + nsCacheDevice* CustomCacheDevice() { return mCustomDevice; } + const char* GetDeviceID(); + + /** + * Data accessors + */ + nsISupports* Data() { return mData; } + void SetData(nsISupports* data); + + int64_t PredictedDataSize() { return mPredictedDataSize; } + void SetPredictedDataSize(int64_t size) { mPredictedDataSize = size; } + + uint32_t DataSize() { return mDataSize; } + void SetDataSize(uint32_t size) { mDataSize = size; } + + void TouchData(); + + /** + * Meta data accessors + */ + const char* GetMetaDataElement(const char* key) { + return mMetaData.GetElement(key); + } + nsresult SetMetaDataElement(const char* key, const char* value) { + return mMetaData.SetElement(key, value); + } + nsresult VisitMetaDataElements(nsICacheMetaDataVisitor* visitor) { + return mMetaData.VisitElements(visitor); + } + nsresult FlattenMetaData(char* buffer, uint32_t bufSize) { + return mMetaData.FlattenMetaData(buffer, bufSize); + } + nsresult UnflattenMetaData(const char* buffer, uint32_t bufSize) { + return mMetaData.UnflattenMetaData(buffer, bufSize); + } + uint32_t MetaDataSize() { return mMetaData.Size(); } + + void TouchMetaData(); + + /** + * Security Info accessors + */ + nsISupports* SecurityInfo() { return mSecurityInfo; } + void SetSecurityInfo(nsISupports* info) { mSecurityInfo = info; } + + // XXX enumerate MetaData method + + enum CacheEntryFlags { + eStoragePolicyMask = 0x000000FF, + eDoomedMask = 0x00000100, + eEntryDirtyMask = 0x00000200, + eDataDirtyMask = 0x00000400, + eMetaDataDirtyMask = 0x00000800, + eStreamDataMask = 0x00001000, + eActiveMask = 0x00002000, + eInitializedMask = 0x00004000, + eValidMask = 0x00008000, + eBindingMask = 0x00010000, + ePrivateMask = 0x00020000 + }; + + void MarkBinding() { mFlags |= eBindingMask; } + void ClearBinding() { mFlags &= ~eBindingMask; } + bool IsBinding() { return (mFlags & eBindingMask) != 0; } + + void MarkEntryDirty() { mFlags |= eEntryDirtyMask; } + void MarkEntryClean() { mFlags &= ~eEntryDirtyMask; } + void MarkDataDirty() { mFlags |= eDataDirtyMask; } + void MarkDataClean() { mFlags &= ~eDataDirtyMask; } + void MarkMetaDataDirty() { mFlags |= eMetaDataDirtyMask; } + void MarkMetaDataClean() { mFlags &= ~eMetaDataDirtyMask; } + void MarkStreamData() { mFlags |= eStreamDataMask; } + void MarkValid() { mFlags |= eValidMask; } + void MarkInvalid() { mFlags &= ~eValidMask; } + void MarkPrivate() { mFlags |= ePrivateMask; } + void MarkPublic() { mFlags &= ~ePrivateMask; } + // void MarkAllowedInMemory() { mFlags |= eAllowedInMemoryMask; } + // void MarkAllowedOnDisk() { mFlags |= eAllowedOnDiskMask; } + + bool IsDoomed() { return (mFlags & eDoomedMask) != 0; } + bool IsEntryDirty() { return (mFlags & eEntryDirtyMask) != 0; } + bool IsDataDirty() { return (mFlags & eDataDirtyMask) != 0; } + bool IsMetaDataDirty() { return (mFlags & eMetaDataDirtyMask) != 0; } + bool IsStreamData() { return (mFlags & eStreamDataMask) != 0; } + bool IsActive() { return (mFlags & eActiveMask) != 0; } + bool IsInitialized() { return (mFlags & eInitializedMask) != 0; } + bool IsValid() { return (mFlags & eValidMask) != 0; } + bool IsInvalid() { return (mFlags & eValidMask) == 0; } + bool IsInUse() { + return IsBinding() || + !(PR_CLIST_IS_EMPTY(&mRequestQ) && PR_CLIST_IS_EMPTY(&mDescriptorQ)); + } + bool IsNotInUse() { return !IsInUse(); } + bool IsPrivate() { return (mFlags & ePrivateMask) != 0; } + + bool IsAllowedInMemory() { + return (StoragePolicy() == nsICache::STORE_ANYWHERE) || + (StoragePolicy() == nsICache::STORE_IN_MEMORY); + } + + bool IsAllowedOnDisk() { + return !IsPrivate() && ((StoragePolicy() == nsICache::STORE_ANYWHERE) || + (StoragePolicy() == nsICache::STORE_ON_DISK)); + } + + bool IsAllowedOffline() { + return (StoragePolicy() == nsICache::STORE_OFFLINE); + } + + nsCacheStoragePolicy StoragePolicy() { + return (nsCacheStoragePolicy)(mFlags & eStoragePolicyMask); + } + + void SetStoragePolicy(nsCacheStoragePolicy policy) { + NS_ASSERTION(policy <= 0xFF, "too many bits in nsCacheStoragePolicy"); + mFlags &= ~eStoragePolicyMask; // clear storage policy bits + mFlags |= policy; + } + + // methods for nsCacheService + nsresult RequestAccess(nsCacheRequest* request, + nsCacheAccessMode* accessGranted); + nsresult CreateDescriptor(nsCacheRequest* request, + nsCacheAccessMode accessGranted, + nsICacheEntryDescriptor** result); + + bool RemoveRequest(nsCacheRequest* request); + bool RemoveDescriptor(nsCacheEntryDescriptor* descriptor, bool* doomEntry); + + void GetDescriptors( + nsTArray<RefPtr<nsCacheEntryDescriptor> >& outDescriptors); + + private: + friend class nsCacheEntryHashTable; + friend class nsCacheService; + + void DetachDescriptors(); + + // internal methods + void MarkDoomed() { mFlags |= eDoomedMask; } + void MarkStreamBased() { mFlags |= eStreamDataMask; } + void MarkInitialized() { mFlags |= eInitializedMask; } + void MarkActive() { mFlags |= eActiveMask; } + void MarkInactive() { mFlags &= ~eActiveMask; } + + nsCString mKey; + uint32_t mFetchCount; // 4 + uint32_t mLastFetched; // 4 + uint32_t mLastModified; // 4 + uint32_t mLastValidated; // 4 + uint32_t mExpirationTime; // 4 + uint32_t mFlags; // 4 + int64_t mPredictedDataSize; // Size given by ContentLength. + uint32_t mDataSize; // 4 + nsCacheDevice* mCacheDevice; // 4 + nsCacheDevice* mCustomDevice; // 4 + nsCOMPtr<nsISupports> mSecurityInfo; // + nsISupports* mData; // strong ref + nsCOMPtr<nsIEventTarget> mEventTarget; + nsCacheMetaData mMetaData; // 4 + PRCList mRequestQ; // 8 + PRCList mDescriptorQ; // 8 +}; + +/****************************************************************************** + * nsCacheEntryInfo + *******************************************************************************/ +class nsCacheEntryInfo : public nsICacheEntryInfo { + public: + NS_DECL_ISUPPORTS + NS_DECL_NSICACHEENTRYINFO + + explicit nsCacheEntryInfo(nsCacheEntry* entry) : mCacheEntry(entry) {} + + void DetachEntry() { mCacheEntry = nullptr; } + + private: + nsCacheEntry* mCacheEntry; + + virtual ~nsCacheEntryInfo() = default; +}; + +/****************************************************************************** + * nsCacheEntryHashTable + *******************************************************************************/ + +struct nsCacheEntryHashTableEntry : public PLDHashEntryHdr { + nsCacheEntry* cacheEntry; +}; + +class nsCacheEntryHashTable { + public: + nsCacheEntryHashTable(); + ~nsCacheEntryHashTable(); + + void Init(); + void Shutdown(); + + nsCacheEntry* GetEntry(const nsCString* key) const; + nsresult AddEntry(nsCacheEntry* entry); + void RemoveEntry(nsCacheEntry* entry); + + PLDHashTable::Iterator Iter(); + + private: + // PLDHashTable operation callbacks + static PLDHashNumber HashKey(const void* key); + + static bool MatchEntry(const PLDHashEntryHdr* entry, const void* key); + + static void MoveEntry(PLDHashTable* table, const PLDHashEntryHdr* from, + PLDHashEntryHdr* to); + + static void ClearEntry(PLDHashTable* table, PLDHashEntryHdr* entry); + + static void Finalize(PLDHashTable* table); + + // member variables + static const PLDHashTableOps ops; + PLDHashTable table; + bool initialized; + + static const uint32_t kInitialTableLength = 256; +}; + +#endif // _nsCacheEntry_h_ diff --git a/netwerk/cache/nsCacheEntryDescriptor.cpp b/netwerk/cache/nsCacheEntryDescriptor.cpp new file mode 100644 index 0000000000..c879e8b31b --- /dev/null +++ b/netwerk/cache/nsCacheEntryDescriptor.cpp @@ -0,0 +1,1307 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- + * + * 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 "nsICache.h" +#include "nsCache.h" +#include "nsCacheService.h" +#include "nsCacheEntryDescriptor.h" +#include "nsCacheEntry.h" +#include "nsReadableUtils.h" +#include "nsIOutputStream.h" +#include "nsCRT.h" +#include "nsThreadUtils.h" +#include <algorithm> +#include "mozilla/IntegerPrintfMacros.h" + +#define kMinDecompressReadBufLen 1024 +#define kMinCompressWriteBufLen 1024 + +/****************************************************************************** + * nsAsyncDoomEvent + *****************************************************************************/ + +class nsAsyncDoomEvent : public mozilla::Runnable { + public: + nsAsyncDoomEvent(nsCacheEntryDescriptor* descriptor, + nsICacheListener* listener) + : mozilla::Runnable("nsAsyncDoomEvent") { + mDescriptor = descriptor; + mListener = listener; + mEventTarget = GetCurrentEventTarget(); + // We addref the listener here and release it in nsNotifyDoomListener + // on the callers thread. If posting of nsNotifyDoomListener event fails + // we leak the listener which is better than releasing it on a wrong + // thread. + NS_IF_ADDREF(mListener); + } + + NS_IMETHOD Run() override { + nsresult status = NS_OK; + + { + nsCacheServiceAutoLock lock(LOCK_TELEM(NSASYNCDOOMEVENT_RUN)); + + if (mDescriptor->mCacheEntry) { + status = nsCacheService::gService->DoomEntry_Internal( + mDescriptor->mCacheEntry, true); + } else if (!mDescriptor->mDoomedOnClose) { + status = NS_ERROR_NOT_AVAILABLE; + } + } + + if (mListener) { + mEventTarget->Dispatch(new nsNotifyDoomListener(mListener, status), + NS_DISPATCH_NORMAL); + // posted event will release the reference on the correct thread + mListener = nullptr; + } + + return NS_OK; + } + + private: + RefPtr<nsCacheEntryDescriptor> mDescriptor; + nsICacheListener* mListener; + nsCOMPtr<nsIEventTarget> mEventTarget; +}; + +NS_IMPL_ISUPPORTS(nsCacheEntryDescriptor, nsICacheEntryDescriptor, + nsICacheEntryInfo) + +nsCacheEntryDescriptor::nsCacheEntryDescriptor(nsCacheEntry* entry, + nsCacheAccessMode accessGranted) + : mCacheEntry(entry), + mAccessGranted(accessGranted), + mOutputWrapper(nullptr), + mLock("nsCacheEntryDescriptor.mLock"), + mAsyncDoomPending(false), + mDoomedOnClose(false), + mClosingDescriptor(false) { + PR_INIT_CLIST(this); + // We need to make sure the cache service lives for the entire lifetime + // of the descriptor + mCacheService = nsCacheService::GlobalInstance(); +} + +nsCacheEntryDescriptor::~nsCacheEntryDescriptor() { + // No need to close if the cache entry has already been severed. This + // helps avoid a shutdown assertion (bug 285519) that is caused when + // consumers end up holding onto these objects past xpcom-shutdown. It's + // okay for them to do that because the cache service calls our Close + // method during xpcom-shutdown, so we don't need to complain about it. + if (mCacheEntry) Close(); + + NS_ASSERTION(mInputWrappers.IsEmpty(), "We have still some input wrapper!"); + NS_ASSERTION(!mOutputWrapper, "We have still an output wrapper!"); +} + +NS_IMETHODIMP +nsCacheEntryDescriptor::GetClientID(nsACString& aClientID) { + nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHEENTRYDESCRIPTOR_GETCLIENTID)); + if (!mCacheEntry) { + aClientID.Truncate(); + return NS_ERROR_NOT_AVAILABLE; + } + + return ClientIDFromCacheKey(*(mCacheEntry->Key()), aClientID); +} + +NS_IMETHODIMP +nsCacheEntryDescriptor::GetDeviceID(nsACString& aDeviceID) { + nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHEENTRYDESCRIPTOR_GETDEVICEID)); + if (!mCacheEntry) { + aDeviceID.Truncate(); + return NS_ERROR_NOT_AVAILABLE; + } + + aDeviceID.Assign(mCacheEntry->GetDeviceID()); + return NS_OK; +} + +NS_IMETHODIMP +nsCacheEntryDescriptor::GetKey(nsACString& result) { + nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHEENTRYDESCRIPTOR_GETKEY)); + if (!mCacheEntry) return NS_ERROR_NOT_AVAILABLE; + + return ClientKeyFromCacheKey(*(mCacheEntry->Key()), result); +} + +NS_IMETHODIMP +nsCacheEntryDescriptor::GetFetchCount(int32_t* result) { + NS_ENSURE_ARG_POINTER(result); + nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHEENTRYDESCRIPTOR_GETFETCHCOUNT)); + if (!mCacheEntry) return NS_ERROR_NOT_AVAILABLE; + + *result = mCacheEntry->FetchCount(); + return NS_OK; +} + +NS_IMETHODIMP +nsCacheEntryDescriptor::GetLastFetched(uint32_t* result) { + NS_ENSURE_ARG_POINTER(result); + nsCacheServiceAutoLock lock( + LOCK_TELEM(NSCACHEENTRYDESCRIPTOR_GETLASTFETCHED)); + if (!mCacheEntry) return NS_ERROR_NOT_AVAILABLE; + + *result = mCacheEntry->LastFetched(); + return NS_OK; +} + +NS_IMETHODIMP +nsCacheEntryDescriptor::GetLastModified(uint32_t* result) { + NS_ENSURE_ARG_POINTER(result); + nsCacheServiceAutoLock lock( + LOCK_TELEM(NSCACHEENTRYDESCRIPTOR_GETLASTMODIFIED)); + if (!mCacheEntry) return NS_ERROR_NOT_AVAILABLE; + + *result = mCacheEntry->LastModified(); + return NS_OK; +} + +NS_IMETHODIMP +nsCacheEntryDescriptor::GetExpirationTime(uint32_t* result) { + NS_ENSURE_ARG_POINTER(result); + nsCacheServiceAutoLock lock( + LOCK_TELEM(NSCACHEENTRYDESCRIPTOR_GETEXPIRATIONTIME)); + if (!mCacheEntry) return NS_ERROR_NOT_AVAILABLE; + + *result = mCacheEntry->ExpirationTime(); + return NS_OK; +} + +NS_IMETHODIMP +nsCacheEntryDescriptor::SetExpirationTime(uint32_t expirationTime) { + nsCacheServiceAutoLock lock( + LOCK_TELEM(NSCACHEENTRYDESCRIPTOR_SETEXPIRATIONTIME)); + if (!mCacheEntry) return NS_ERROR_NOT_AVAILABLE; + + mCacheEntry->SetExpirationTime(expirationTime); + mCacheEntry->MarkEntryDirty(); + return NS_OK; +} + +NS_IMETHODIMP nsCacheEntryDescriptor::IsStreamBased(bool* result) { + NS_ENSURE_ARG_POINTER(result); + nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHEENTRYDESCRIPTOR_ISSTREAMBASED)); + if (!mCacheEntry) return NS_ERROR_NOT_AVAILABLE; + + *result = mCacheEntry->IsStreamData(); + return NS_OK; +} + +NS_IMETHODIMP nsCacheEntryDescriptor::GetPredictedDataSize(int64_t* result) { + NS_ENSURE_ARG_POINTER(result); + nsCacheServiceAutoLock lock( + LOCK_TELEM(NSCACHEENTRYDESCRIPTOR_GETPREDICTEDDATASIZE)); + if (!mCacheEntry) return NS_ERROR_NOT_AVAILABLE; + + *result = mCacheEntry->PredictedDataSize(); + return NS_OK; +} + +NS_IMETHODIMP nsCacheEntryDescriptor::SetPredictedDataSize( + int64_t predictedSize) { + nsCacheServiceAutoLock lock( + LOCK_TELEM(NSCACHEENTRYDESCRIPTOR_SETPREDICTEDDATASIZE)); + if (!mCacheEntry) return NS_ERROR_NOT_AVAILABLE; + + mCacheEntry->SetPredictedDataSize(predictedSize); + return NS_OK; +} + +NS_IMETHODIMP nsCacheEntryDescriptor::GetDataSize(uint32_t* result) { + NS_ENSURE_ARG_POINTER(result); + nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHEENTRYDESCRIPTOR_GETDATASIZE)); + if (!mCacheEntry) return NS_ERROR_NOT_AVAILABLE; + + const char* val = mCacheEntry->GetMetaDataElement("uncompressed-len"); + if (!val) { + *result = mCacheEntry->DataSize(); + } else { + *result = atol(val); + } + + return NS_OK; +} + +NS_IMETHODIMP nsCacheEntryDescriptor::GetStorageDataSize(uint32_t* result) { + NS_ENSURE_ARG_POINTER(result); + nsCacheServiceAutoLock lock( + LOCK_TELEM(NSCACHEENTRYDESCRIPTOR_GETSTORAGEDATASIZE)); + if (!mCacheEntry) return NS_ERROR_NOT_AVAILABLE; + + *result = mCacheEntry->DataSize(); + + return NS_OK; +} + +nsresult nsCacheEntryDescriptor::RequestDataSizeChange(int32_t deltaSize) { + nsCacheServiceAutoLock lock( + LOCK_TELEM(NSCACHEENTRYDESCRIPTOR_REQUESTDATASIZECHANGE)); + if (!mCacheEntry) return NS_ERROR_NOT_AVAILABLE; + + nsresult rv; + rv = nsCacheService::OnDataSizeChange(mCacheEntry, deltaSize); + if (NS_SUCCEEDED(rv)) { + // XXX review for signed/unsigned math errors + uint32_t newDataSize = mCacheEntry->DataSize() + deltaSize; + mCacheEntry->SetDataSize(newDataSize); + mCacheEntry->TouchData(); + } + return rv; +} + +NS_IMETHODIMP +nsCacheEntryDescriptor::SetDataSize(uint32_t dataSize) { + nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHEENTRYDESCRIPTOR_SETDATASIZE)); + if (!mCacheEntry) return NS_ERROR_NOT_AVAILABLE; + + // XXX review for signed/unsigned math errors + int32_t deltaSize = dataSize - mCacheEntry->DataSize(); + + nsresult rv; + rv = nsCacheService::OnDataSizeChange(mCacheEntry, deltaSize); + // this had better be NS_OK, this call instance is advisory for memory cache + // objects + if (NS_SUCCEEDED(rv)) { + // XXX review for signed/unsigned math errors + uint32_t newDataSize = mCacheEntry->DataSize() + deltaSize; + mCacheEntry->SetDataSize(newDataSize); + mCacheEntry->TouchData(); + } else { + NS_WARNING("failed SetDataSize() on memory cache object!"); + } + + return rv; +} + +NS_IMETHODIMP +nsCacheEntryDescriptor::OpenInputStream(uint32_t offset, + nsIInputStream** result) { + NS_ENSURE_ARG_POINTER(result); + + RefPtr<nsInputStreamWrapper> cacheInput; + { + nsCacheServiceAutoLock lock( + LOCK_TELEM(NSCACHEENTRYDESCRIPTOR_OPENINPUTSTREAM)); + if (!mCacheEntry) return NS_ERROR_NOT_AVAILABLE; + if (!mCacheEntry->IsStreamData()) return NS_ERROR_CACHE_DATA_IS_NOT_STREAM; + + // Don't open any new stream when closing descriptor or clearing entries + if (mClosingDescriptor || nsCacheService::GetClearingEntries()) + return NS_ERROR_NOT_AVAILABLE; + + // ensure valid permissions + if (!(mAccessGranted & nsICache::ACCESS_READ)) + return NS_ERROR_CACHE_READ_ACCESS_DENIED; + + const char* val; + val = mCacheEntry->GetMetaDataElement("uncompressed-len"); + if (val) { + cacheInput = new nsDecompressInputStreamWrapper(this, offset); + } else { + cacheInput = new nsInputStreamWrapper(this, offset); + } + if (!cacheInput) return NS_ERROR_OUT_OF_MEMORY; + + mInputWrappers.AppendElement(cacheInput); + } + + cacheInput.forget(result); + return NS_OK; +} + +NS_IMETHODIMP +nsCacheEntryDescriptor::OpenOutputStream(uint32_t offset, + nsIOutputStream** result) { + NS_ENSURE_ARG_POINTER(result); + + RefPtr<nsOutputStreamWrapper> cacheOutput; + { + nsCacheServiceAutoLock lock( + LOCK_TELEM(NSCACHEENTRYDESCRIPTOR_OPENOUTPUTSTREAM)); + if (!mCacheEntry) return NS_ERROR_NOT_AVAILABLE; + if (!mCacheEntry->IsStreamData()) return NS_ERROR_CACHE_DATA_IS_NOT_STREAM; + + // Don't open any new stream when closing descriptor or clearing entries + if (mClosingDescriptor || nsCacheService::GetClearingEntries()) + return NS_ERROR_NOT_AVAILABLE; + + // ensure valid permissions + if (!(mAccessGranted & nsICache::ACCESS_WRITE)) + return NS_ERROR_CACHE_WRITE_ACCESS_DENIED; + + int32_t compressionLevel = nsCacheService::CacheCompressionLevel(); + const char* val; + val = mCacheEntry->GetMetaDataElement("uncompressed-len"); + if ((compressionLevel > 0) && val) { + cacheOutput = new nsCompressOutputStreamWrapper(this, offset); + } else { + // clear compression flag when compression disabled - see bug 715198 + if (val) { + mCacheEntry->SetMetaDataElement("uncompressed-len", nullptr); + } + cacheOutput = new nsOutputStreamWrapper(this, offset); + } + if (!cacheOutput) return NS_ERROR_OUT_OF_MEMORY; + + mOutputWrapper = cacheOutput; + } + + cacheOutput.forget(result); + return NS_OK; +} + +NS_IMETHODIMP +nsCacheEntryDescriptor::GetCacheElement(nsISupports** result) { + NS_ENSURE_ARG_POINTER(result); + nsCacheServiceAutoLock lock( + LOCK_TELEM(NSCACHEENTRYDESCRIPTOR_GETCACHEELEMENT)); + if (!mCacheEntry) return NS_ERROR_NOT_AVAILABLE; + if (mCacheEntry->IsStreamData()) return NS_ERROR_CACHE_DATA_IS_STREAM; + + NS_IF_ADDREF(*result = mCacheEntry->Data()); + return NS_OK; +} + +NS_IMETHODIMP +nsCacheEntryDescriptor::SetCacheElement(nsISupports* cacheElement) { + nsCacheServiceAutoLock lock( + LOCK_TELEM(NSCACHEENTRYDESCRIPTOR_SETCACHEELEMENT)); + if (!mCacheEntry) return NS_ERROR_NOT_AVAILABLE; + if (mCacheEntry->IsStreamData()) return NS_ERROR_CACHE_DATA_IS_STREAM; + + return nsCacheService::SetCacheElement(mCacheEntry, cacheElement); +} + +NS_IMETHODIMP +nsCacheEntryDescriptor::GetAccessGranted(nsCacheAccessMode* result) { + NS_ENSURE_ARG_POINTER(result); + *result = mAccessGranted; + return NS_OK; +} + +NS_IMETHODIMP +nsCacheEntryDescriptor::GetStoragePolicy(nsCacheStoragePolicy* result) { + NS_ENSURE_ARG_POINTER(result); + nsCacheServiceAutoLock lock( + LOCK_TELEM(NSCACHEENTRYDESCRIPTOR_GETSTORAGEPOLICY)); + if (!mCacheEntry) return NS_ERROR_NOT_AVAILABLE; + + *result = mCacheEntry->StoragePolicy(); + return NS_OK; +} + +NS_IMETHODIMP +nsCacheEntryDescriptor::SetStoragePolicy(nsCacheStoragePolicy policy) { + nsCacheServiceAutoLock lock( + LOCK_TELEM(NSCACHEENTRYDESCRIPTOR_SETSTORAGEPOLICY)); + if (!mCacheEntry) return NS_ERROR_NOT_AVAILABLE; + // XXX validate policy against session? + + bool storageEnabled = false; + storageEnabled = nsCacheService::IsStorageEnabledForPolicy_Locked(policy); + if (!storageEnabled) return NS_ERROR_FAILURE; + + // Don't change the storage policy of entries we can't write + if (!(mAccessGranted & nsICache::ACCESS_WRITE)) return NS_ERROR_NOT_AVAILABLE; + + // Don't allow a cache entry to move from memory-only to anything else + if (mCacheEntry->StoragePolicy() == nsICache::STORE_IN_MEMORY && + policy != nsICache::STORE_IN_MEMORY) + return NS_ERROR_NOT_AVAILABLE; + + mCacheEntry->SetStoragePolicy(policy); + mCacheEntry->MarkEntryDirty(); + return NS_OK; +} + +NS_IMETHODIMP +nsCacheEntryDescriptor::GetFile(nsIFile** result) { + NS_ENSURE_ARG_POINTER(result); + nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHEENTRYDESCRIPTOR_GETFILE)); + if (!mCacheEntry) return NS_ERROR_NOT_AVAILABLE; + + return nsCacheService::GetFileForEntry(mCacheEntry, result); +} + +NS_IMETHODIMP +nsCacheEntryDescriptor::GetSecurityInfo(nsISupports** result) { + NS_ENSURE_ARG_POINTER(result); + nsCacheServiceAutoLock lock( + LOCK_TELEM(NSCACHEENTRYDESCRIPTOR_GETSECURITYINFO)); + if (!mCacheEntry) return NS_ERROR_NOT_AVAILABLE; + + *result = mCacheEntry->SecurityInfo(); + NS_IF_ADDREF(*result); + return NS_OK; +} + +NS_IMETHODIMP +nsCacheEntryDescriptor::SetSecurityInfo(nsISupports* securityInfo) { + nsCacheServiceAutoLock lock( + LOCK_TELEM(NSCACHEENTRYDESCRIPTOR_SETSECURITYINFO)); + if (!mCacheEntry) return NS_ERROR_NOT_AVAILABLE; + + mCacheEntry->SetSecurityInfo(securityInfo); + mCacheEntry->MarkEntryDirty(); + return NS_OK; +} + +NS_IMETHODIMP +nsCacheEntryDescriptor::Doom() { + nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHEENTRYDESCRIPTOR_DOOM)); + if (!mCacheEntry) return NS_ERROR_NOT_AVAILABLE; + + return nsCacheService::DoomEntry(mCacheEntry); +} + +NS_IMETHODIMP +nsCacheEntryDescriptor::DoomAndFailPendingRequests(nsresult status) { + nsCacheServiceAutoLock lock( + LOCK_TELEM(NSCACHEENTRYDESCRIPTOR_DOOMANDFAILPENDINGREQUESTS)); + if (!mCacheEntry) return NS_ERROR_NOT_AVAILABLE; + + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP +nsCacheEntryDescriptor::AsyncDoom(nsICacheListener* listener) { + bool asyncDoomPending; + { + mozilla::MutexAutoLock lock(mLock); + asyncDoomPending = mAsyncDoomPending; + mAsyncDoomPending = true; + } + + if (asyncDoomPending) { + // AsyncDoom was already called. Notify listener if it is non-null, + // otherwise just return success. + if (listener) { + nsresult rv = NS_DispatchToCurrentThread( + new nsNotifyDoomListener(listener, NS_ERROR_NOT_AVAILABLE)); + if (NS_SUCCEEDED(rv)) NS_IF_ADDREF(listener); + return rv; + } + return NS_OK; + } + + nsCOMPtr<nsIRunnable> event = new nsAsyncDoomEvent(this, listener); + return nsCacheService::DispatchToCacheIOThread(event); +} + +NS_IMETHODIMP +nsCacheEntryDescriptor::MarkValid() { + nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHEENTRYDESCRIPTOR_MARKVALID)); + if (!mCacheEntry) return NS_ERROR_NOT_AVAILABLE; + + nsresult rv = nsCacheService::ValidateEntry(mCacheEntry); + return rv; +} + +NS_IMETHODIMP +nsCacheEntryDescriptor::Close() { + RefPtr<nsOutputStreamWrapper> outputWrapper; + nsTArray<RefPtr<nsInputStreamWrapper> > inputWrappers; + + { + nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHEENTRYDESCRIPTOR_CLOSE)); + if (!mCacheEntry) return NS_ERROR_NOT_AVAILABLE; + + // Make sure no other stream can be opened + mClosingDescriptor = true; + outputWrapper = mOutputWrapper; + for (size_t i = 0; i < mInputWrappers.Length(); i++) + inputWrappers.AppendElement(mInputWrappers[i]); + } + + // Call Close() on the streams outside the lock since it might need to call + // methods that grab the cache service lock, e.g. compressed output stream + // when it finalizes the entry + if (outputWrapper) { + if (NS_FAILED(outputWrapper->Close())) { + NS_WARNING("Dooming entry because Close() failed!!!"); + Doom(); + } + outputWrapper = nullptr; + } + + for (uint32_t i = 0; i < inputWrappers.Length(); i++) + inputWrappers[i]->Close(); + + inputWrappers.Clear(); + + nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHEENTRYDESCRIPTOR_CLOSE)); + if (!mCacheEntry) return NS_ERROR_NOT_AVAILABLE; + + // XXX perhaps closing descriptors should clear/sever transports + + // tell nsCacheService we're going away + nsCacheService::CloseDescriptor(this); + NS_ASSERTION(mCacheEntry == nullptr, "mCacheEntry not null"); + + return NS_OK; +} + +NS_IMETHODIMP +nsCacheEntryDescriptor::GetMetaDataElement(const char* key, char** result) { + NS_ENSURE_ARG_POINTER(key); + *result = nullptr; + + nsCacheServiceAutoLock lock( + LOCK_TELEM(NSCACHEENTRYDESCRIPTOR_GETMETADATAELEMENT)); + NS_ENSURE_TRUE(mCacheEntry, NS_ERROR_NOT_AVAILABLE); + + const char* value; + + value = mCacheEntry->GetMetaDataElement(key); + if (!value) return NS_ERROR_NOT_AVAILABLE; + + *result = NS_xstrdup(value); + + return NS_OK; +} + +NS_IMETHODIMP +nsCacheEntryDescriptor::SetMetaDataElement(const char* key, const char* value) { + NS_ENSURE_ARG_POINTER(key); + + nsCacheServiceAutoLock lock( + LOCK_TELEM(NSCACHEENTRYDESCRIPTOR_SETMETADATAELEMENT)); + NS_ENSURE_TRUE(mCacheEntry, NS_ERROR_NOT_AVAILABLE); + + // XXX allow null value, for clearing key? + + nsresult rv = mCacheEntry->SetMetaDataElement(key, value); + if (NS_SUCCEEDED(rv)) mCacheEntry->TouchMetaData(); + return rv; +} + +NS_IMETHODIMP +nsCacheEntryDescriptor::VisitMetaData(nsICacheMetaDataVisitor* visitor) { + nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHEENTRYDESCRIPTOR_VISITMETADATA)); + // XXX check callers, we're calling out of module + NS_ENSURE_ARG_POINTER(visitor); + if (!mCacheEntry) return NS_ERROR_NOT_AVAILABLE; + + return mCacheEntry->VisitMetaDataElements(visitor); +} + +/****************************************************************************** + * nsCacheInputStream - a wrapper for nsIInputStream keeps the cache entry + * open while referenced. + ******************************************************************************/ + +NS_IMPL_ADDREF(nsCacheEntryDescriptor::nsInputStreamWrapper) +NS_IMETHODIMP_(MozExternalRefCountType) +nsCacheEntryDescriptor::nsInputStreamWrapper::Release() { + // Holding a reference to descriptor ensures that cache service won't go + // away. Do not grab cache service lock if there is no descriptor. + RefPtr<nsCacheEntryDescriptor> desc; + + { + mozilla::MutexAutoLock lock(mLock); + desc = mDescriptor; + } + + if (desc) nsCacheService::Lock(LOCK_TELEM(NSINPUTSTREAMWRAPPER_RELEASE)); + + nsrefcnt count; + MOZ_ASSERT(0 != mRefCnt, "dup release"); + count = --mRefCnt; + NS_LOG_RELEASE(this, count, "nsCacheEntryDescriptor::nsInputStreamWrapper"); + + if (0 == count) { + // don't use desc here since mDescriptor might be already nulled out + if (mDescriptor) { + NS_ASSERTION(mDescriptor->mInputWrappers.Contains(this), + "Wrapper not found in array!"); + mDescriptor->mInputWrappers.RemoveElement(this); + } + + if (desc) nsCacheService::Unlock(); + + mRefCnt = 1; + delete (this); + return 0; + } + + if (desc) nsCacheService::Unlock(); + + return count; +} + +NS_INTERFACE_MAP_BEGIN(nsCacheEntryDescriptor::nsInputStreamWrapper) + NS_INTERFACE_MAP_ENTRY(nsIInputStream) + NS_INTERFACE_MAP_ENTRY(nsISupports) +NS_INTERFACE_MAP_END + +nsresult nsCacheEntryDescriptor::nsInputStreamWrapper::LazyInit() { + // Check if we have the descriptor. If not we can't even grab the cache + // lock since it is not ensured that the cache service still exists. + if (!mDescriptor) return NS_ERROR_NOT_AVAILABLE; + + nsCacheServiceAutoLock lock(LOCK_TELEM(NSINPUTSTREAMWRAPPER_LAZYINIT)); + + nsCacheAccessMode mode; + nsresult rv = mDescriptor->GetAccessGranted(&mode); + if (NS_FAILED(rv)) return rv; + + NS_ENSURE_TRUE(mode & nsICache::ACCESS_READ, NS_ERROR_UNEXPECTED); + + nsCacheEntry* cacheEntry = mDescriptor->CacheEntry(); + if (!cacheEntry) return NS_ERROR_NOT_AVAILABLE; + + rv = nsCacheService::OpenInputStreamForEntry(cacheEntry, mode, mStartOffset, + getter_AddRefs(mInput)); + + CACHE_LOG_DEBUG( + ("nsInputStreamWrapper::LazyInit " + "[entry=%p, wrapper=%p, mInput=%p, rv=%d]", + mDescriptor, this, mInput.get(), int(rv))); + + if (NS_FAILED(rv)) return rv; + + mInitialized = true; + return NS_OK; +} + +nsresult nsCacheEntryDescriptor::nsInputStreamWrapper::EnsureInit() { + if (mInitialized) { + NS_ASSERTION(mDescriptor, "Bad state"); + return NS_OK; + } + + return LazyInit(); +} + +void nsCacheEntryDescriptor::nsInputStreamWrapper::CloseInternal() { + mLock.AssertCurrentThreadOwns(); + if (!mDescriptor) { + NS_ASSERTION(!mInitialized, "Bad state"); + NS_ASSERTION(!mInput, "Bad state"); + return; + } + + nsCacheServiceAutoLock lock(LOCK_TELEM(NSINPUTSTREAMWRAPPER_CLOSEINTERNAL)); + + if (mDescriptor) { + mDescriptor->mInputWrappers.RemoveElement(this); + nsCacheService::ReleaseObject_Locked(mDescriptor); + mDescriptor = nullptr; + } + mInitialized = false; + mInput = nullptr; +} + +nsresult nsCacheEntryDescriptor::nsInputStreamWrapper::Close() { + mozilla::MutexAutoLock lock(mLock); + + return Close_Locked(); +} + +nsresult nsCacheEntryDescriptor::nsInputStreamWrapper::Close_Locked() { + nsresult rv = EnsureInit(); + if (NS_SUCCEEDED(rv)) { + rv = mInput->Close(); + } else { + NS_ASSERTION(!mInput, "Shouldn't have mInput when EnsureInit() failed"); + } + + // Call CloseInternal() even when EnsureInit() failed, e.g. in case we are + // closing streams with nsCacheService::CloseAllStream() + CloseInternal(); + return rv; +} + +nsresult nsCacheEntryDescriptor::nsInputStreamWrapper::Available( + uint64_t* avail) { + mozilla::MutexAutoLock lock(mLock); + + nsresult rv = EnsureInit(); + if (NS_FAILED(rv)) return rv; + + return mInput->Available(avail); +} + +nsresult nsCacheEntryDescriptor::nsInputStreamWrapper::Read( + char* buf, uint32_t count, uint32_t* countRead) { + mozilla::MutexAutoLock lock(mLock); + + return Read_Locked(buf, count, countRead); +} + +nsresult nsCacheEntryDescriptor::nsInputStreamWrapper::Read_Locked( + char* buf, uint32_t count, uint32_t* countRead) { + nsresult rv = EnsureInit(); + if (NS_SUCCEEDED(rv)) rv = mInput->Read(buf, count, countRead); + + CACHE_LOG_DEBUG( + ("nsInputStreamWrapper::Read " + "[entry=%p, wrapper=%p, mInput=%p, rv=%" PRId32 "]", + mDescriptor, this, mInput.get(), static_cast<uint32_t>(rv))); + + return rv; +} + +nsresult nsCacheEntryDescriptor::nsInputStreamWrapper::ReadSegments( + nsWriteSegmentFun writer, void* closure, uint32_t count, + uint32_t* countRead) { + // cache stream not buffered + return NS_ERROR_NOT_IMPLEMENTED; +} + +nsresult nsCacheEntryDescriptor::nsInputStreamWrapper::IsNonBlocking( + bool* result) { + // cache streams will never return NS_BASE_STREAM_WOULD_BLOCK + *result = false; + return NS_OK; +} + +/****************************************************************************** + * nsDecompressInputStreamWrapper - an input stream wrapper that decompresses + ******************************************************************************/ + +NS_IMPL_ADDREF(nsCacheEntryDescriptor::nsDecompressInputStreamWrapper) +NS_IMETHODIMP_(MozExternalRefCountType) +nsCacheEntryDescriptor::nsDecompressInputStreamWrapper::Release() { + // Holding a reference to descriptor ensures that cache service won't go + // away. Do not grab cache service lock if there is no descriptor. + RefPtr<nsCacheEntryDescriptor> desc; + + { + mozilla::MutexAutoLock lock(mLock); + desc = mDescriptor; + } + + if (desc) + nsCacheService::Lock(LOCK_TELEM(NSDECOMPRESSINPUTSTREAMWRAPPER_RELEASE)); + + nsrefcnt count; + MOZ_ASSERT(0 != mRefCnt, "dup release"); + count = --mRefCnt; + NS_LOG_RELEASE(this, count, + "nsCacheEntryDescriptor::nsDecompressInputStreamWrapper"); + + if (0 == count) { + // don't use desc here since mDescriptor might be already nulled out + if (mDescriptor) { + NS_ASSERTION(mDescriptor->mInputWrappers.Contains(this), + "Wrapper not found in array!"); + mDescriptor->mInputWrappers.RemoveElement(this); + } + + if (desc) nsCacheService::Unlock(); + + mRefCnt = 1; + delete (this); + return 0; + } + + if (desc) nsCacheService::Unlock(); + + return count; +} + +NS_INTERFACE_MAP_BEGIN(nsCacheEntryDescriptor::nsDecompressInputStreamWrapper) + NS_INTERFACE_MAP_ENTRY(nsIInputStream) + NS_INTERFACE_MAP_ENTRY(nsISupports) +NS_INTERFACE_MAP_END + +NS_IMETHODIMP nsCacheEntryDescriptor::nsDecompressInputStreamWrapper::Read( + char* buf, uint32_t count, uint32_t* countRead) { + mozilla::MutexAutoLock lock(mLock); + + int zerr = Z_OK; + nsresult rv = NS_OK; + + if (!mStreamInitialized) { + rv = InitZstream(); + if (NS_FAILED(rv)) { + return rv; + } + } + + mZstream.next_out = (Bytef*)buf; + mZstream.avail_out = count; + + if (mReadBufferLen < count) { + // Allocate a buffer for reading from the input stream. This will + // determine the max number of compressed bytes read from the + // input stream at one time. Making the buffer size proportional + // to the request size is not necessary, but helps minimize the + // number of read requests to the input stream. + uint32_t newBufLen = std::max(count, (uint32_t)kMinDecompressReadBufLen); + mReadBuffer = (unsigned char*)moz_xrealloc(mReadBuffer, newBufLen); + mReadBufferLen = newBufLen; + if (!mReadBuffer) { + mReadBufferLen = 0; + return NS_ERROR_OUT_OF_MEMORY; + } + } + + // read and inflate data until the output buffer is full, or + // there is no more data to read + while (NS_SUCCEEDED(rv) && zerr == Z_OK && mZstream.avail_out > 0 && + count > 0) { + if (mZstream.avail_in == 0) { + rv = nsInputStreamWrapper::Read_Locked((char*)mReadBuffer, mReadBufferLen, + &mZstream.avail_in); + if (NS_FAILED(rv) || !mZstream.avail_in) { + break; + } + mZstream.next_in = mReadBuffer; + } + zerr = inflate(&mZstream, Z_NO_FLUSH); + if (zerr == Z_STREAM_END) { + // The compressed data may have been stored in multiple + // chunks/streams. To allow for this case, re-initialize + // the inflate stream and continue decompressing from + // the next byte. + Bytef* saveNextIn = mZstream.next_in; + unsigned int saveAvailIn = mZstream.avail_in; + Bytef* saveNextOut = mZstream.next_out; + unsigned int saveAvailOut = mZstream.avail_out; + inflateReset(&mZstream); + mZstream.next_in = saveNextIn; + mZstream.avail_in = saveAvailIn; + mZstream.next_out = saveNextOut; + mZstream.avail_out = saveAvailOut; + zerr = Z_OK; + } else if (zerr != Z_OK) { + rv = NS_ERROR_INVALID_CONTENT_ENCODING; + } + } + if (NS_SUCCEEDED(rv)) { + *countRead = count - mZstream.avail_out; + } + return rv; +} + +nsresult nsCacheEntryDescriptor::nsDecompressInputStreamWrapper::Close() { + mozilla::MutexAutoLock lock(mLock); + + if (!mDescriptor) return NS_ERROR_NOT_AVAILABLE; + + EndZstream(); + if (mReadBuffer) { + free(mReadBuffer); + mReadBuffer = nullptr; + mReadBufferLen = 0; + } + return nsInputStreamWrapper::Close_Locked(); +} + +nsresult nsCacheEntryDescriptor::nsDecompressInputStreamWrapper::InitZstream() { + if (!mDescriptor) return NS_ERROR_NOT_AVAILABLE; + + if (mStreamEnded) return NS_ERROR_FAILURE; + + // Initialize zlib inflate stream + mZstream.zalloc = Z_NULL; + mZstream.zfree = Z_NULL; + mZstream.opaque = Z_NULL; + mZstream.next_out = Z_NULL; + mZstream.avail_out = 0; + mZstream.next_in = Z_NULL; + mZstream.avail_in = 0; + if (inflateInit(&mZstream) != Z_OK) { + return NS_ERROR_FAILURE; + } + mStreamInitialized = true; + return NS_OK; +} + +nsresult nsCacheEntryDescriptor::nsDecompressInputStreamWrapper::EndZstream() { + if (mStreamInitialized && !mStreamEnded) { + inflateEnd(&mZstream); + mStreamInitialized = false; + mStreamEnded = true; + } + return NS_OK; +} + +/****************************************************************************** + * nsOutputStreamWrapper - a wrapper for nsIOutputstream to track the amount of + * data written to a cache entry. + * - also keeps the cache entry open while referenced. + ******************************************************************************/ + +NS_IMPL_ADDREF(nsCacheEntryDescriptor::nsOutputStreamWrapper) +NS_IMETHODIMP_(MozExternalRefCountType) +nsCacheEntryDescriptor::nsOutputStreamWrapper::Release() { + // Holding a reference to descriptor ensures that cache service won't go + // away. Do not grab cache service lock if there is no descriptor. + RefPtr<nsCacheEntryDescriptor> desc; + + { + mozilla::MutexAutoLock lock(mLock); + desc = mDescriptor; + } + + if (desc) nsCacheService::Lock(LOCK_TELEM(NSOUTPUTSTREAMWRAPPER_RELEASE)); + + nsrefcnt count; + MOZ_ASSERT(0 != mRefCnt, "dup release"); + count = --mRefCnt; + NS_LOG_RELEASE(this, count, "nsCacheEntryDescriptor::nsOutputStreamWrapper"); + + if (0 == count) { + // don't use desc here since mDescriptor might be already nulled out + if (mDescriptor) mDescriptor->mOutputWrapper = nullptr; + + if (desc) nsCacheService::Unlock(); + + mRefCnt = 1; + delete (this); + return 0; + } + + if (desc) nsCacheService::Unlock(); + + return count; +} + +NS_INTERFACE_MAP_BEGIN(nsCacheEntryDescriptor::nsOutputStreamWrapper) + NS_INTERFACE_MAP_ENTRY(nsIOutputStream) + NS_INTERFACE_MAP_ENTRY(nsISupports) +NS_INTERFACE_MAP_END + +nsresult nsCacheEntryDescriptor::nsOutputStreamWrapper::LazyInit() { + // Check if we have the descriptor. If not we can't even grab the cache + // lock since it is not ensured that the cache service still exists. + if (!mDescriptor) return NS_ERROR_NOT_AVAILABLE; + + nsCacheServiceAutoLock lock(LOCK_TELEM(NSOUTPUTSTREAMWRAPPER_LAZYINIT)); + + nsCacheAccessMode mode; + nsresult rv = mDescriptor->GetAccessGranted(&mode); + if (NS_FAILED(rv)) return rv; + + NS_ENSURE_TRUE(mode & nsICache::ACCESS_WRITE, NS_ERROR_UNEXPECTED); + + nsCacheEntry* cacheEntry = mDescriptor->CacheEntry(); + if (!cacheEntry) return NS_ERROR_NOT_AVAILABLE; + + NS_ASSERTION(mOutput == nullptr, "mOutput set in LazyInit"); + + nsCOMPtr<nsIOutputStream> stream; + rv = nsCacheService::OpenOutputStreamForEntry(cacheEntry, mode, mStartOffset, + getter_AddRefs(stream)); + if (NS_FAILED(rv)) return rv; + + nsCacheDevice* device = cacheEntry->CacheDevice(); + if (device) { + // the entry has been truncated to mStartOffset bytes, inform device + int32_t size = cacheEntry->DataSize(); + rv = device->OnDataSizeChange(cacheEntry, mStartOffset - size); + if (NS_SUCCEEDED(rv)) cacheEntry->SetDataSize(mStartOffset); + } else { + rv = NS_ERROR_NOT_AVAILABLE; + } + + // If anything above failed, clean up internal state and get out of here + // (see bug #654926)... + if (NS_FAILED(rv)) { + nsCacheService::ReleaseObject_Locked(stream.forget().take()); + mDescriptor->mOutputWrapper = nullptr; + nsCacheService::ReleaseObject_Locked(mDescriptor); + mDescriptor = nullptr; + mInitialized = false; + return rv; + } + + mOutput = stream; + mInitialized = true; + return NS_OK; +} + +nsresult nsCacheEntryDescriptor::nsOutputStreamWrapper::EnsureInit() { + if (mInitialized) { + NS_ASSERTION(mDescriptor, "Bad state"); + return NS_OK; + } + + return LazyInit(); +} + +nsresult nsCacheEntryDescriptor::nsOutputStreamWrapper::OnWrite( + uint32_t count) { + if (count > INT32_MAX) return NS_ERROR_UNEXPECTED; + return mDescriptor->RequestDataSizeChange((int32_t)count); +} + +void nsCacheEntryDescriptor::nsOutputStreamWrapper::CloseInternal() { + mLock.AssertCurrentThreadOwns(); + if (!mDescriptor) { + NS_ASSERTION(!mInitialized, "Bad state"); + NS_ASSERTION(!mOutput, "Bad state"); + return; + } + + nsCacheServiceAutoLock lock(LOCK_TELEM(NSOUTPUTSTREAMWRAPPER_CLOSEINTERNAL)); + + if (mDescriptor) { + mDescriptor->mOutputWrapper = nullptr; + nsCacheService::ReleaseObject_Locked(mDescriptor); + mDescriptor = nullptr; + } + mInitialized = false; + mOutput = nullptr; +} + +NS_IMETHODIMP nsCacheEntryDescriptor::nsOutputStreamWrapper::Close() { + mozilla::MutexAutoLock lock(mLock); + + return Close_Locked(); +} + +nsresult nsCacheEntryDescriptor::nsOutputStreamWrapper::Close_Locked() { + nsresult rv = EnsureInit(); + if (NS_SUCCEEDED(rv)) { + rv = mOutput->Close(); + } else { + NS_ASSERTION(!mOutput, "Shouldn't have mOutput when EnsureInit() failed"); + } + + // Call CloseInternal() even when EnsureInit() failed, e.g. in case we are + // closing streams with nsCacheService::CloseAllStream() + CloseInternal(); + return rv; +} + +NS_IMETHODIMP nsCacheEntryDescriptor::nsOutputStreamWrapper::Flush() { + mozilla::MutexAutoLock lock(mLock); + + nsresult rv = EnsureInit(); + if (NS_FAILED(rv)) return rv; + + return mOutput->Flush(); +} + +NS_IMETHODIMP nsCacheEntryDescriptor::nsOutputStreamWrapper::Write( + const char* buf, uint32_t count, uint32_t* result) { + mozilla::MutexAutoLock lock(mLock); + return Write_Locked(buf, count, result); +} + +nsresult nsCacheEntryDescriptor::nsOutputStreamWrapper::Write_Locked( + const char* buf, uint32_t count, uint32_t* result) { + nsresult rv = EnsureInit(); + if (NS_FAILED(rv)) return rv; + + rv = OnWrite(count); + if (NS_FAILED(rv)) return rv; + + return mOutput->Write(buf, count, result); +} + +NS_IMETHODIMP nsCacheEntryDescriptor::nsOutputStreamWrapper::WriteFrom( + nsIInputStream* inStr, uint32_t count, uint32_t* result) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP nsCacheEntryDescriptor::nsOutputStreamWrapper::WriteSegments( + nsReadSegmentFun reader, void* closure, uint32_t count, uint32_t* result) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +NS_IMETHODIMP nsCacheEntryDescriptor::nsOutputStreamWrapper::IsNonBlocking( + bool* result) { + // cache streams will never return NS_BASE_STREAM_WOULD_BLOCK + *result = false; + return NS_OK; +} + +/****************************************************************************** + * nsCompressOutputStreamWrapper - an output stream wrapper that compresses + * data before it is written + ******************************************************************************/ + +NS_IMPL_ADDREF(nsCacheEntryDescriptor::nsCompressOutputStreamWrapper) +NS_IMETHODIMP_(MozExternalRefCountType) +nsCacheEntryDescriptor::nsCompressOutputStreamWrapper::Release() { + // Holding a reference to descriptor ensures that cache service won't go + // away. Do not grab cache service lock if there is no descriptor. + RefPtr<nsCacheEntryDescriptor> desc; + + { + mozilla::MutexAutoLock lock(mLock); + desc = mDescriptor; + } + + if (desc) + nsCacheService::Lock(LOCK_TELEM(NSCOMPRESSOUTPUTSTREAMWRAPPER_RELEASE)); + + nsrefcnt count; + MOZ_ASSERT(0 != mRefCnt, "dup release"); + count = --mRefCnt; + NS_LOG_RELEASE(this, count, + "nsCacheEntryDescriptor::nsCompressOutputStreamWrapper"); + + if (0 == count) { + // don't use desc here since mDescriptor might be already nulled out + if (mDescriptor) mDescriptor->mOutputWrapper = nullptr; + + if (desc) nsCacheService::Unlock(); + + mRefCnt = 1; + delete (this); + return 0; + } + + if (desc) nsCacheService::Unlock(); + + return count; +} + +NS_INTERFACE_MAP_BEGIN(nsCacheEntryDescriptor::nsCompressOutputStreamWrapper) + NS_INTERFACE_MAP_ENTRY(nsIOutputStream) + NS_INTERFACE_MAP_ENTRY(nsISupports) +NS_INTERFACE_MAP_END + +NS_IMETHODIMP nsCacheEntryDescriptor::nsCompressOutputStreamWrapper::Write( + const char* buf, uint32_t count, uint32_t* result) { + mozilla::MutexAutoLock lock(mLock); + + int zerr = Z_OK; + nsresult rv = NS_OK; + + if (!mStreamInitialized) { + rv = InitZstream(); + if (NS_FAILED(rv)) { + return rv; + } + } + + if (!mWriteBuffer) { + // Once allocated, this buffer is referenced by the zlib stream and + // cannot be grown. We use 2x(initial write request) to approximate + // a stream buffer size proportional to request buffers. + mWriteBufferLen = std::max(count * 2, (uint32_t)kMinCompressWriteBufLen); + mWriteBuffer = (unsigned char*)moz_xmalloc(mWriteBufferLen); + mZstream.next_out = mWriteBuffer; + mZstream.avail_out = mWriteBufferLen; + } + + // Compress (deflate) the requested buffer. Keep going + // until the entire buffer has been deflated. + mZstream.avail_in = count; + mZstream.next_in = (Bytef*)buf; + while (mZstream.avail_in > 0) { + zerr = deflate(&mZstream, Z_NO_FLUSH); + if (zerr == Z_STREAM_ERROR) { + deflateEnd(&mZstream); + mStreamEnded = true; + mStreamInitialized = false; + return NS_ERROR_FAILURE; + } + // Note: Z_BUF_ERROR is non-fatal and sometimes expected here. + + // If the compression stream output buffer is filled, write + // it out to the underlying stream wrapper. + if (mZstream.avail_out == 0) { + rv = WriteBuffer(); + if (NS_FAILED(rv)) { + deflateEnd(&mZstream); + mStreamEnded = true; + mStreamInitialized = false; + return rv; + } + } + } + *result = count; + mUncompressedCount += *result; + return NS_OK; +} + +NS_IMETHODIMP nsCacheEntryDescriptor::nsCompressOutputStreamWrapper::Close() { + mozilla::MutexAutoLock lock(mLock); + + if (!mDescriptor) return NS_ERROR_NOT_AVAILABLE; + + nsresult retval = NS_OK; + nsresult rv; + int zerr = 0; + + if (mStreamInitialized) { + // complete compression of any data remaining in the zlib stream + do { + zerr = deflate(&mZstream, Z_FINISH); + rv = WriteBuffer(); + if (NS_FAILED(rv)) retval = rv; + } while (zerr == Z_OK && rv == NS_OK); + deflateEnd(&mZstream); + mStreamInitialized = false; + } + // Do not allow to initialize stream after calling Close(). + mStreamEnded = true; + + if (mDescriptor->CacheEntry()) { + nsAutoCString uncompressedLenStr; + rv = mDescriptor->GetMetaDataElement("uncompressed-len", + getter_Copies(uncompressedLenStr)); + if (NS_SUCCEEDED(rv)) { + int32_t oldCount = uncompressedLenStr.ToInteger(&rv); + if (NS_SUCCEEDED(rv)) { + mUncompressedCount += oldCount; + } + } + uncompressedLenStr.Adopt(nullptr); + uncompressedLenStr.AppendInt(mUncompressedCount); + rv = mDescriptor->SetMetaDataElement("uncompressed-len", + uncompressedLenStr.get()); + if (NS_FAILED(rv)) retval = rv; + } + + if (mWriteBuffer) { + free(mWriteBuffer); + mWriteBuffer = nullptr; + mWriteBufferLen = 0; + } + + rv = nsOutputStreamWrapper::Close_Locked(); + if (NS_FAILED(rv)) retval = rv; + + return retval; +} + +nsresult nsCacheEntryDescriptor::nsCompressOutputStreamWrapper::InitZstream() { + if (!mDescriptor) return NS_ERROR_NOT_AVAILABLE; + + if (mStreamEnded) return NS_ERROR_FAILURE; + + // Determine compression level: Aggressive compression + // may impact performance on mobile devices, while a + // lower compression level still provides substantial + // space savings for many text streams. + int32_t compressionLevel = nsCacheService::CacheCompressionLevel(); + + // Initialize zlib deflate stream + mZstream.zalloc = Z_NULL; + mZstream.zfree = Z_NULL; + mZstream.opaque = Z_NULL; + if (deflateInit2(&mZstream, compressionLevel, Z_DEFLATED, MAX_WBITS, 8, + Z_DEFAULT_STRATEGY) != Z_OK) { + return NS_ERROR_FAILURE; + } + mZstream.next_in = Z_NULL; + mZstream.avail_in = 0; + + mStreamInitialized = true; + + return NS_OK; +} + +nsresult nsCacheEntryDescriptor::nsCompressOutputStreamWrapper::WriteBuffer() { + uint32_t bytesToWrite = mWriteBufferLen - mZstream.avail_out; + uint32_t result = 0; + nsresult rv = nsCacheEntryDescriptor::nsOutputStreamWrapper::Write_Locked( + (const char*)mWriteBuffer, bytesToWrite, &result); + mZstream.next_out = mWriteBuffer; + mZstream.avail_out = mWriteBufferLen; + return rv; +} diff --git a/netwerk/cache/nsCacheEntryDescriptor.h b/netwerk/cache/nsCacheEntryDescriptor.h new file mode 100644 index 0000000000..2274150cff --- /dev/null +++ b/netwerk/cache/nsCacheEntryDescriptor.h @@ -0,0 +1,220 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- + * + * 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/. */ + +#ifndef _nsCacheEntryDescriptor_h_ +#define _nsCacheEntryDescriptor_h_ + +#include "nsICacheEntryDescriptor.h" +#include "nsCacheEntry.h" +#include "nsIInputStream.h" +#include "nsIOutputStream.h" +#include "nsCacheService.h" +#include "zlib.h" +#include "mozilla/Mutex.h" + +/****************************************************************************** + * nsCacheEntryDescriptor + *******************************************************************************/ +class nsCacheEntryDescriptor final : public PRCList, + public nsICacheEntryDescriptor { + public: + NS_DECL_THREADSAFE_ISUPPORTS + NS_DECL_NSICACHEENTRYDESCRIPTOR + NS_DECL_NSICACHEENTRYINFO + + friend class nsAsyncDoomEvent; + friend class nsCacheService; + + nsCacheEntryDescriptor(nsCacheEntry* entry, nsCacheAccessMode mode); + + /** + * utility method to attempt changing data size of associated entry + */ + nsresult RequestDataSizeChange(int32_t deltaSize); + + /** + * methods callbacks for nsCacheService + */ + nsCacheEntry* CacheEntry(void) { return mCacheEntry; } + bool ClearCacheEntry(void) { + NS_ASSERTION(mInputWrappers.IsEmpty(), "Bad state"); + NS_ASSERTION(!mOutputWrapper, "Bad state"); + + bool doomEntry = false; + bool asyncDoomPending; + { + mozilla::MutexAutoLock lock(mLock); + asyncDoomPending = mAsyncDoomPending; + } + + if (asyncDoomPending && mCacheEntry) { + doomEntry = true; + mDoomedOnClose = true; + } + mCacheEntry = nullptr; + + return doomEntry; + } + + private: + virtual ~nsCacheEntryDescriptor(); + + /************************************************************************* + * input stream wrapper class - + * + * The input stream wrapper references the descriptor, but the descriptor + * doesn't need any references to the stream wrapper. + *************************************************************************/ + class nsInputStreamWrapper : public nsIInputStream { + friend class nsCacheEntryDescriptor; + + private: + nsCacheEntryDescriptor* mDescriptor; + nsCOMPtr<nsIInputStream> mInput; + uint32_t mStartOffset; + bool mInitialized; + mozilla::Mutex mLock; + + public: + NS_DECL_THREADSAFE_ISUPPORTS + NS_DECL_NSIINPUTSTREAM + + nsInputStreamWrapper(nsCacheEntryDescriptor* desc, uint32_t off) + : mDescriptor(desc), + mStartOffset(off), + mInitialized(false), + mLock("nsInputStreamWrapper.mLock") { + NS_ADDREF(mDescriptor); + } + + private: + virtual ~nsInputStreamWrapper() { NS_IF_RELEASE(mDescriptor); } + + nsresult LazyInit(); + nsresult EnsureInit(); + nsresult Read_Locked(char* buf, uint32_t count, uint32_t* countRead); + nsresult Close_Locked(); + void CloseInternal(); + }; + + class nsDecompressInputStreamWrapper : public nsInputStreamWrapper { + private: + unsigned char* mReadBuffer; + uint32_t mReadBufferLen; + z_stream mZstream; + bool mStreamInitialized; + bool mStreamEnded; + + public: + NS_DECL_ISUPPORTS_INHERITED + + nsDecompressInputStreamWrapper(nsCacheEntryDescriptor* desc, uint32_t off) + : nsInputStreamWrapper(desc, off), + mReadBuffer(nullptr), + mReadBufferLen(0), + mZstream{}, + mStreamInitialized(false), + mStreamEnded(false) {} + NS_IMETHOD Read(char* buf, uint32_t count, uint32_t* result) override; + NS_IMETHOD Close() override; + + private: + virtual ~nsDecompressInputStreamWrapper() { Close(); } + nsresult InitZstream(); + nsresult EndZstream(); + }; + + /************************************************************************* + * output stream wrapper class - + * + * The output stream wrapper references the descriptor, but the descriptor + * doesn't need any references to the stream wrapper. + *************************************************************************/ + class nsOutputStreamWrapper : public nsIOutputStream { + friend class nsCacheEntryDescriptor; + + protected: + nsCacheEntryDescriptor* mDescriptor; + nsCOMPtr<nsIOutputStream> mOutput; + uint32_t mStartOffset; + bool mInitialized; + mozilla::Mutex mLock; + + public: + NS_DECL_THREADSAFE_ISUPPORTS + NS_DECL_NSIOUTPUTSTREAM + + nsOutputStreamWrapper(nsCacheEntryDescriptor* desc, uint32_t off) + : mDescriptor(desc), + mStartOffset(off), + mInitialized(false), + mLock("nsOutputStreamWrapper.mLock") { + NS_ADDREF(mDescriptor); // owning ref + } + + private: + virtual ~nsOutputStreamWrapper() { + Close(); + + NS_ASSERTION(!mOutput, "Bad state"); + NS_ASSERTION(!mDescriptor, "Bad state"); + } + + nsresult LazyInit(); + nsresult EnsureInit(); + nsresult OnWrite(uint32_t count); + nsresult Write_Locked(const char* buf, uint32_t count, uint32_t* result); + nsresult Close_Locked(); + void CloseInternal(); + }; + + class nsCompressOutputStreamWrapper : public nsOutputStreamWrapper { + private: + unsigned char* mWriteBuffer; + uint32_t mWriteBufferLen; + z_stream mZstream; + bool mStreamInitialized; + bool mStreamEnded; + uint32_t mUncompressedCount; + + public: + NS_DECL_ISUPPORTS_INHERITED + + nsCompressOutputStreamWrapper(nsCacheEntryDescriptor* desc, uint32_t off) + : nsOutputStreamWrapper(desc, off), + mWriteBuffer(nullptr), + mWriteBufferLen(0), + mZstream{}, + mStreamInitialized(false), + mStreamEnded(false), + mUncompressedCount(0) {} + NS_IMETHOD Write(const char* buf, uint32_t count, + uint32_t* result) override; + NS_IMETHOD Close() override; + + private: + virtual ~nsCompressOutputStreamWrapper() { Close(); } + nsresult InitZstream(); + nsresult WriteBuffer(); + }; + + private: + /** + * nsCacheEntryDescriptor data members + */ + + nsCOMPtr<nsICacheServiceInternal> mCacheService; + nsCacheEntry* mCacheEntry; // we are a child of the entry + nsCacheAccessMode mAccessGranted; + nsTArray<nsInputStreamWrapper*> mInputWrappers; + nsOutputStreamWrapper* mOutputWrapper; + mozilla::Mutex mLock; + bool mAsyncDoomPending; + bool mDoomedOnClose; + bool mClosingDescriptor; +}; + +#endif // _nsCacheEntryDescriptor_h_ diff --git a/netwerk/cache/nsCacheMetaData.cpp b/netwerk/cache/nsCacheMetaData.cpp new file mode 100644 index 0000000000..386b569ea0 --- /dev/null +++ b/netwerk/cache/nsCacheMetaData.cpp @@ -0,0 +1,151 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- + * + * 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 "nsCacheMetaData.h" +#include "nsICacheEntryDescriptor.h" + +const char* nsCacheMetaData::GetElement(const char* key) { + const char* data = mBuffer; + const char* limit = mBuffer + mMetaSize; + + while (data < limit) { + // Point to the value part + const char* value = data + strlen(data) + 1; + MOZ_ASSERT(value < limit, "Cache Metadata corrupted"); + if (strcmp(data, key) == 0) return value; + + // Skip value part + data = value + strlen(value) + 1; + } + MOZ_ASSERT(data == limit, "Metadata corrupted"); + return nullptr; +} + +nsresult nsCacheMetaData::SetElement(const char* key, const char* value) { + const uint32_t keySize = strlen(key) + 1; + char* pos = (char*)GetElement(key); + + if (!value) { + // No value means remove the key/value pair completely, if existing + if (pos) { + uint32_t oldValueSize = strlen(pos) + 1; + uint32_t offset = pos - mBuffer; + uint32_t remainder = mMetaSize - (offset + oldValueSize); + + memmove(pos - keySize, pos + oldValueSize, remainder); + mMetaSize -= keySize + oldValueSize; + } + return NS_OK; + } + + const uint32_t valueSize = strlen(value) + 1; + uint32_t newSize = mMetaSize + valueSize; + if (pos) { + const uint32_t oldValueSize = strlen(pos) + 1; + const uint32_t offset = pos - mBuffer; + const uint32_t remainder = mMetaSize - (offset + oldValueSize); + + // Update the value in place + newSize -= oldValueSize; + nsresult rv = EnsureBuffer(newSize); + NS_ENSURE_SUCCESS(rv, rv); + + // Move the remainder to the right place + pos = mBuffer + offset; + memmove(pos + valueSize, pos + oldValueSize, remainder); + } else { + // allocate new meta data element + newSize += keySize; + nsresult rv = EnsureBuffer(newSize); + NS_ENSURE_SUCCESS(rv, rv); + + // Add after last element + pos = mBuffer + mMetaSize; + memcpy(pos, key, keySize); + pos += keySize; + } + + // Update value + memcpy(pos, value, valueSize); + mMetaSize = newSize; + + return NS_OK; +} + +nsresult nsCacheMetaData::FlattenMetaData(char* buffer, uint32_t bufSize) { + if (mMetaSize > bufSize) { + NS_ERROR("buffer size too small for meta data."); + return NS_ERROR_OUT_OF_MEMORY; + } + + if (!mBuffer) { + MOZ_ASSERT(mMetaSize == 0); + MOZ_ASSERT(bufSize == 0); + return NS_OK; + } + + memcpy(buffer, mBuffer, mMetaSize); + return NS_OK; +} + +nsresult nsCacheMetaData::UnflattenMetaData(const char* data, uint32_t size) { + if (data && size) { + // Check if the metadata ends with a zero byte. + if (data[size - 1] != '\0') { + NS_ERROR("Cache MetaData is not null terminated"); + return NS_ERROR_ILLEGAL_VALUE; + } + // Check that there are an even number of zero bytes + // to match the pattern { key \0 value \0 } + bool odd = false; + for (uint32_t i = 0; i < size; i++) { + if (data[i] == '\0') odd = !odd; + } + if (odd) { + NS_ERROR("Cache MetaData is malformed"); + return NS_ERROR_ILLEGAL_VALUE; + } + + nsresult rv = EnsureBuffer(size); + NS_ENSURE_SUCCESS(rv, rv); + + memcpy(mBuffer, data, size); + mMetaSize = size; + } + return NS_OK; +} + +nsresult nsCacheMetaData::VisitElements(nsICacheMetaDataVisitor* visitor) { + const char* data = mBuffer; + const char* limit = mBuffer + mMetaSize; + + while (data < limit) { + const char* key = data; + // Skip key part + data += strlen(data) + 1; + MOZ_ASSERT(data < limit, "Metadata corrupted"); + bool keepGoing; + nsresult rv = visitor->VisitMetaDataElement(key, data, &keepGoing); + if (NS_FAILED(rv) || !keepGoing) return NS_OK; + + // Skip value part + data += strlen(data) + 1; + } + MOZ_ASSERT(data == limit, "Metadata corrupted"); + return NS_OK; +} + +nsresult nsCacheMetaData::EnsureBuffer(uint32_t bufSize) { + if (mBufferSize < bufSize) { + char* buf = (char*)realloc(mBuffer, bufSize); + if (!buf) { + return NS_ERROR_OUT_OF_MEMORY; + } + mBuffer = buf; + mBufferSize = bufSize; + } + return NS_OK; +} diff --git a/netwerk/cache/nsCacheMetaData.h b/netwerk/cache/nsCacheMetaData.h new file mode 100644 index 0000000000..4cf84ad5fa --- /dev/null +++ b/netwerk/cache/nsCacheMetaData.h @@ -0,0 +1,45 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- + * + * 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/. */ + +#ifndef _nsCacheMetaData_h_ +#define _nsCacheMetaData_h_ + +#include "nspr.h" +#include "nscore.h" + +class nsICacheMetaDataVisitor; + +class nsCacheMetaData { + public: + nsCacheMetaData() : mBuffer(nullptr), mBufferSize(0), mMetaSize(0) {} + + ~nsCacheMetaData() { + mBufferSize = mMetaSize = 0; + free(mBuffer); + mBuffer = nullptr; + } + + const char* GetElement(const char* key); + + nsresult SetElement(const char* key, const char* value); + + uint32_t Size(void) { return mMetaSize; } + + nsresult FlattenMetaData(char* buffer, uint32_t bufSize); + + nsresult UnflattenMetaData(const char* buffer, uint32_t bufSize); + + nsresult VisitElements(nsICacheMetaDataVisitor* visitor); + + private: + nsresult EnsureBuffer(uint32_t size); + + char* mBuffer; + uint32_t mBufferSize; + uint32_t mMetaSize; +}; + +#endif // _nsCacheMetaData_h diff --git a/netwerk/cache/nsCacheRequest.h b/netwerk/cache/nsCacheRequest.h new file mode 100644 index 0000000000..1d5dcd3106 --- /dev/null +++ b/netwerk/cache/nsCacheRequest.h @@ -0,0 +1,146 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- + * + * 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/. */ + +#ifndef _nsCacheRequest_h_ +#define _nsCacheRequest_h_ + +#include "nspr.h" +#include "mozilla/CondVar.h" +#include "mozilla/Mutex.h" +#include "nsCOMPtr.h" +#include "nsICache.h" +#include "nsICacheListener.h" +#include "nsCacheSession.h" +#include "nsCacheService.h" + +class nsCacheRequest : public PRCList { + typedef mozilla::CondVar CondVar; + typedef mozilla::MutexAutoLock MutexAutoLock; + typedef mozilla::Mutex Mutex; + + private: + friend class nsCacheService; + friend class nsCacheEntry; + friend class nsProcessRequestEvent; + + nsCacheRequest(const nsACString& key, nsICacheListener* listener, + nsCacheAccessMode accessRequested, bool blockingMode, + nsCacheSession* session) + : mKey(key), + mInfo(0), + mListener(listener), + mLock("nsCacheRequest.mLock"), + mCondVar(mLock, "nsCacheRequest.mCondVar"), + mProfileDir(session->ProfileDir()) { + MOZ_COUNT_CTOR(nsCacheRequest); + PR_INIT_CLIST(this); + SetAccessRequested(accessRequested); + SetStoragePolicy(session->StoragePolicy()); + if (session->IsStreamBased()) MarkStreamBased(); + if (session->WillDoomEntriesIfExpired()) MarkDoomEntriesIfExpired(); + if (session->IsPrivate()) MarkPrivate(); + if (blockingMode == nsICache::BLOCKING) MarkBlockingMode(); + MarkWaitingForValidation(); + NS_IF_ADDREF(mListener); + } + + ~nsCacheRequest() { + MOZ_COUNT_DTOR(nsCacheRequest); + NS_ASSERTION(PR_CLIST_IS_EMPTY(this), "request still on a list"); + + if (mListener) + nsCacheService::ReleaseObject_Locked(mListener, mEventTarget); + } + + /** + * Simple Accessors + */ + enum CacheRequestInfo { + eStoragePolicyMask = 0x000000FF, + eStreamBasedMask = 0x00000100, + ePrivateMask = 0x00000200, + eDoomEntriesIfExpiredMask = 0x00001000, + eBlockingModeMask = 0x00010000, + eWaitingForValidationMask = 0x00100000, + eAccessRequestedMask = 0xFF000000 + }; + + void SetAccessRequested(nsCacheAccessMode mode) { + NS_ASSERTION(mode <= 0xFF, "too many bits in nsCacheAccessMode"); + mInfo &= ~eAccessRequestedMask; + mInfo |= mode << 24; + } + + nsCacheAccessMode AccessRequested() { + return (nsCacheAccessMode)((mInfo >> 24) & 0xFF); + } + + void MarkStreamBased() { mInfo |= eStreamBasedMask; } + bool IsStreamBased() { return (mInfo & eStreamBasedMask) != 0; } + + void MarkDoomEntriesIfExpired() { mInfo |= eDoomEntriesIfExpiredMask; } + bool WillDoomEntriesIfExpired() { + return (0 != (mInfo & eDoomEntriesIfExpiredMask)); + } + + void MarkBlockingMode() { mInfo |= eBlockingModeMask; } + bool IsBlocking() { return (0 != (mInfo & eBlockingModeMask)); } + bool IsNonBlocking() { return !(mInfo & eBlockingModeMask); } + + void SetStoragePolicy(nsCacheStoragePolicy policy) { + NS_ASSERTION(policy <= 0xFF, "too many bits in nsCacheStoragePolicy"); + mInfo &= ~eStoragePolicyMask; // clear storage policy bits + mInfo |= policy; // or in new bits + } + + nsCacheStoragePolicy StoragePolicy() { + return (nsCacheStoragePolicy)(mInfo & eStoragePolicyMask); + } + + void MarkPrivate() { mInfo |= ePrivateMask; } + void MarkPublic() { mInfo &= ~ePrivateMask; } + bool IsPrivate() { return (mInfo & ePrivateMask) != 0; } + + void MarkWaitingForValidation() { mInfo |= eWaitingForValidationMask; } + void DoneWaitingForValidation() { mInfo &= ~eWaitingForValidationMask; } + bool WaitingForValidation() { + return (mInfo & eWaitingForValidationMask) != 0; + } + + nsresult WaitForValidation(void) { + if (!WaitingForValidation()) { // flag already cleared + MarkWaitingForValidation(); // set up for next time + return NS_OK; // early exit; + } + { + MutexAutoLock lock(mLock); + while (WaitingForValidation()) { + mCondVar.Wait(); + } + MarkWaitingForValidation(); // set up for next time + } + return NS_OK; + } + + void WakeUp(void) { + DoneWaitingForValidation(); + MutexAutoLock lock(mLock); + mCondVar.Notify(); + } + + /** + * Data members + */ + nsCString mKey; + uint32_t mInfo; + nsICacheListener* mListener; // strong ref + nsCOMPtr<nsIEventTarget> mEventTarget; + Mutex mLock; + CondVar mCondVar; + nsCOMPtr<nsIFile> mProfileDir; +}; + +#endif // _nsCacheRequest_h_ diff --git a/netwerk/cache/nsCacheService.cpp b/netwerk/cache/nsCacheService.cpp new file mode 100644 index 0000000000..f7cb31d010 --- /dev/null +++ b/netwerk/cache/nsCacheService.cpp @@ -0,0 +1,1910 @@ +/* -*- 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 "nsCacheService.h" + +#include "mozilla/ArrayUtils.h" +#include "mozilla/Attributes.h" +#include "mozilla/Assertions.h" +#include "mozilla/DebugOnly.h" +#include "mozilla/FileUtils.h" + +#include "nsCache.h" +#include "nsCacheRequest.h" +#include "nsCacheEntry.h" +#include "nsCacheEntryDescriptor.h" +#include "nsCacheDevice.h" +#include "nsICacheVisitor.h" +#include "nsDiskCacheDeviceSQL.h" +#include "nsCacheUtils.h" +#include "../cache2/CacheObserver.h" +#include "nsIObserverService.h" +#include "nsIPrefBranch.h" +#include "nsIFile.h" +#include "nsIOService.h" +#include "nsDirectoryServiceDefs.h" +#include "nsAppDirectoryServiceDefs.h" +#include "nsThreadUtils.h" +#include "nsProxyRelease.h" +#include "nsDeleteDir.h" +#include "nsNetCID.h" +#include <math.h> // for log() +#include "mozilla/Services.h" +#include "mozilla/StaticPrefs_browser.h" + +#include "mozilla/net/NeckoCommon.h" +#include <algorithm> + +using namespace mozilla; +using namespace mozilla::net; + +/****************************************************************************** + * nsCacheProfilePrefObserver + *****************************************************************************/ +#define OFFLINE_CACHE_DIR_PREF "browser.cache.offline.parent_directory" +#define OFFLINE_CACHE_CAPACITY_PREF "browser.cache.offline.capacity" +#define OFFLINE_CACHE_CAPACITY 512000 + +#define CACHE_COMPRESSION_LEVEL 1 + +static const char* observerList[] = { + "profile-before-change", "profile-do-change", + NS_XPCOM_SHUTDOWN_OBSERVER_ID, "last-pb-context-exited", + "suspend_process_notification", "resume_process_notification"}; + +class nsCacheProfilePrefObserver : public nsIObserver { + virtual ~nsCacheProfilePrefObserver() = default; + + public: + NS_DECL_THREADSAFE_ISUPPORTS + NS_DECL_NSIOBSERVER + + nsCacheProfilePrefObserver() + : mHaveProfile(false), + mOfflineCacheEnabled(false), + mOfflineStorageCacheEnabled(false), + mOfflineCacheCapacity(0), + mCacheCompressionLevel(CACHE_COMPRESSION_LEVEL), + mSanitizeOnShutdown(false), + mClearCacheOnShutdown(false) {} + + nsresult Install(); + void Remove(); + nsresult ReadPrefs(nsIPrefBranch* branch); + + nsIFile* DiskCacheParentDirectory() { return mDiskCacheParentDirectory; } + + bool OfflineCacheEnabled(); + int32_t OfflineCacheCapacity() { return mOfflineCacheCapacity; } + nsIFile* OfflineCacheParentDirectory() { + return mOfflineCacheParentDirectory; + } + + int32_t CacheCompressionLevel(); + + bool SanitizeAtShutdown() { + return mSanitizeOnShutdown && mClearCacheOnShutdown; + } + + private: + bool mHaveProfile; + + nsCOMPtr<nsIFile> mDiskCacheParentDirectory; + + bool mOfflineCacheEnabled; + bool mOfflineStorageCacheEnabled; + int32_t mOfflineCacheCapacity; // in kilobytes + nsCOMPtr<nsIFile> mOfflineCacheParentDirectory; + + int32_t mCacheCompressionLevel; + + bool mSanitizeOnShutdown; + bool mClearCacheOnShutdown; +}; + +NS_IMPL_ISUPPORTS(nsCacheProfilePrefObserver, nsIObserver) + +class nsBlockOnCacheThreadEvent : public Runnable { + public: + nsBlockOnCacheThreadEvent() + : mozilla::Runnable("nsBlockOnCacheThreadEvent") {} + NS_IMETHOD Run() override { + nsCacheServiceAutoLock autoLock(LOCK_TELEM(NSBLOCKONCACHETHREADEVENT_RUN)); + CACHE_LOG_DEBUG(("nsBlockOnCacheThreadEvent [%p]\n", this)); + nsCacheService::gService->mNotified = true; + nsCacheService::gService->mCondVar.Notify(); + return NS_OK; + } +}; + +nsresult nsCacheProfilePrefObserver::Install() { + // install profile-change observer + nsCOMPtr<nsIObserverService> observerService = + mozilla::services::GetObserverService(); + if (!observerService) return NS_ERROR_FAILURE; + + nsresult rv, rv2 = NS_OK; + for (auto& observer : observerList) { + rv = observerService->AddObserver(this, observer, false); + if (NS_FAILED(rv)) rv2 = rv; + } + + // install preferences observer + nsCOMPtr<nsIPrefBranch> branch = do_GetService(NS_PREFSERVICE_CONTRACTID); + if (!branch) return NS_ERROR_FAILURE; + + // Determine if we have a profile already + // Install() is called *after* the profile-after-change notification + // when there is only a single profile, or it is specified on the + // commandline at startup. + // In that case, we detect the presence of a profile by the existence + // of the NS_APP_USER_PROFILE_50_DIR directory. + + nsCOMPtr<nsIFile> directory; + rv = NS_GetSpecialDirectory(NS_APP_USER_PROFILE_50_DIR, + getter_AddRefs(directory)); + if (NS_SUCCEEDED(rv)) mHaveProfile = true; + + rv = ReadPrefs(branch); + NS_ENSURE_SUCCESS(rv, rv); + + return rv2; +} + +void nsCacheProfilePrefObserver::Remove() { + // remove Observer Service observers + nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService(); + if (obs) { + for (auto& observer : observerList) { + obs->RemoveObserver(this, observer); + } + } +} + +NS_IMETHODIMP +nsCacheProfilePrefObserver::Observe(nsISupports* subject, const char* topic, + const char16_t* data_unicode) { + NS_ConvertUTF16toUTF8 data(data_unicode); + CACHE_LOG_INFO(("Observe [topic=%s data=%s]\n", topic, data.get())); + + if (!nsCacheService::IsInitialized()) { + if (!strcmp("resume_process_notification", topic)) { + // A suspended process has a closed cache, so re-open it here. + nsCacheService::GlobalInstance()->Init(); + } + return NS_OK; + } + + if (!strcmp(NS_XPCOM_SHUTDOWN_OBSERVER_ID, topic)) { + // xpcom going away, shutdown cache service + nsCacheService::GlobalInstance()->Shutdown(); + } else if (!strcmp("profile-before-change", topic)) { + // profile before change + mHaveProfile = false; + + // XXX shutdown devices + nsCacheService::OnProfileShutdown(); + } else if (!strcmp("suspend_process_notification", topic)) { + // A suspended process may never return, so shutdown the cache to reduce + // cache corruption. + nsCacheService::GlobalInstance()->Shutdown(); + } else if (!strcmp("profile-do-change", topic)) { + // profile after change + mHaveProfile = true; + nsCOMPtr<nsIPrefBranch> branch = do_GetService(NS_PREFSERVICE_CONTRACTID); + if (!branch) { + return NS_ERROR_FAILURE; + } + (void)ReadPrefs(branch); + nsCacheService::OnProfileChanged(); + + } else if (!strcmp("last-pb-context-exited", topic)) { + nsCacheService::LeavePrivateBrowsing(); + } + + return NS_OK; +} + +static already_AddRefed<nsIFile> GetCacheDirectory(const char* aSubdir, + bool aAllowProcDirCache) { + nsCOMPtr<nsIFile> directory; + + // try to get the disk cache parent directory + Unused << NS_GetSpecialDirectory(NS_APP_CACHE_PARENT_DIR, + getter_AddRefs(directory)); + if (!directory) { + // try to get the profile directory (there may not be a profile yet) + nsCOMPtr<nsIFile> profDir; + NS_GetSpecialDirectory(NS_APP_USER_PROFILE_50_DIR, getter_AddRefs(profDir)); + NS_GetSpecialDirectory(NS_APP_USER_PROFILE_LOCAL_50_DIR, + getter_AddRefs(directory)); + if (!directory) + directory = profDir; + else if (profDir) { + nsCacheService::MoveOrRemoveDiskCache(profDir, directory, aSubdir); + } + } + if (!directory && aAllowProcDirCache) { + Unused << NS_GetSpecialDirectory(NS_XPCOM_CURRENT_PROCESS_DIR, + getter_AddRefs(directory)); + } + return directory.forget(); +} + +nsresult nsCacheProfilePrefObserver::ReadPrefs(nsIPrefBranch* branch) { + if (!mDiskCacheParentDirectory) { + // use file cache in build tree only if asked, to avoid cache dir litter + bool allowProcDirCache = PR_GetEnv("NECKO_DEV_ENABLE_DISK_CACHE"); + mDiskCacheParentDirectory = GetCacheDirectory("Cache", allowProcDirCache); + } + + // read offline cache device prefs + mOfflineCacheEnabled = StaticPrefs::browser_cache_offline_enable(); + mOfflineStorageCacheEnabled = + StaticPrefs::browser_cache_offline_storage_enable(); + + mOfflineCacheCapacity = OFFLINE_CACHE_CAPACITY; + (void)branch->GetIntPref(OFFLINE_CACHE_CAPACITY_PREF, &mOfflineCacheCapacity); + mOfflineCacheCapacity = std::max(0, mOfflineCacheCapacity); + + (void)branch->GetComplexValue(OFFLINE_CACHE_DIR_PREF, // ignore error + NS_GET_IID(nsIFile), + getter_AddRefs(mOfflineCacheParentDirectory)); + + if (!mOfflineCacheParentDirectory) { +#ifdef DEBUG + bool allowProcDirCache = true; +#else + bool allowProcDirCache = false; +#endif + mOfflineCacheParentDirectory = + GetCacheDirectory("OfflineCache", allowProcDirCache); + } + + if (!mDiskCacheParentDirectory || !mOfflineCacheParentDirectory) { + return NS_ERROR_FAILURE; + } + + if (!mOfflineStorageCacheEnabled) { + // Dispatch cleanup task + nsCOMPtr<nsIRunnable> runnable = + NS_NewRunnableFunction("Delete OfflineCache", []() { + nsCOMPtr<nsIFile> dir; + nsCacheService::GetAppCacheDirectory(getter_AddRefs(dir)); + bool exists = false; + if (dir && NS_SUCCEEDED(dir->Exists(&exists)) && exists) { + // Delay delete by 1 minute to avoid IO thrash on startup. + CACHE_LOG_INFO( + ("Queuing Delete of AppCacheDirectory in 60 seconds")); + nsDeleteDir::DeleteDir(dir, false, 60000); + } + }); + Unused << nsCacheService::DispatchToCacheIOThread(runnable); + } + + return NS_OK; +} + +nsresult nsCacheService::DispatchToCacheIOThread(nsIRunnable* event) { + if (!gService || !gService->mCacheIOThread) return NS_ERROR_NOT_AVAILABLE; + return gService->mCacheIOThread->Dispatch(event, NS_DISPATCH_NORMAL); +} + +nsresult nsCacheService::SyncWithCacheIOThread() { + if (!gService || !gService->mCacheIOThread) return NS_ERROR_NOT_AVAILABLE; + gService->mLock.AssertCurrentThreadOwns(); + + nsCOMPtr<nsIRunnable> event = new nsBlockOnCacheThreadEvent(); + + // dispatch event - it will notify the monitor when it's done + nsresult rv = gService->mCacheIOThread->Dispatch(event, NS_DISPATCH_NORMAL); + if (NS_FAILED(rv)) { + NS_WARNING("Failed dispatching block-event"); + return NS_ERROR_UNEXPECTED; + } + + // wait until notified, then return + gService->mNotified = false; + while (!gService->mNotified) { + gService->mCondVar.Wait(); + } + + return NS_OK; +} + +bool nsCacheProfilePrefObserver::OfflineCacheEnabled() { + if ((mOfflineCacheCapacity == 0) || (!mOfflineCacheParentDirectory)) + return false; + + return mOfflineCacheEnabled && mOfflineStorageCacheEnabled; +} + +int32_t nsCacheProfilePrefObserver::CacheCompressionLevel() { + return mCacheCompressionLevel; +} + +/****************************************************************************** + * nsProcessRequestEvent + *****************************************************************************/ + +class nsProcessRequestEvent : public Runnable { + public: + explicit nsProcessRequestEvent(nsCacheRequest* aRequest) + : mozilla::Runnable("nsProcessRequestEvent") { + mRequest = aRequest; + } + + NS_IMETHOD Run() override { + nsresult rv; + + NS_ASSERTION(mRequest->mListener, + "Sync OpenCacheEntry() posted to background thread!"); + + nsCacheServiceAutoLock lock(LOCK_TELEM(NSPROCESSREQUESTEVENT_RUN)); + rv = nsCacheService::gService->ProcessRequest(mRequest, false, nullptr); + + // Don't delete the request if it was queued + if (!(mRequest->IsBlocking() && rv == NS_ERROR_CACHE_WAIT_FOR_VALIDATION)) + delete mRequest; + + return NS_OK; + } + + protected: + virtual ~nsProcessRequestEvent() = default; + + private: + nsCacheRequest* mRequest; +}; + +/****************************************************************************** + * nsDoomEvent + *****************************************************************************/ + +class nsDoomEvent : public Runnable { + public: + nsDoomEvent(nsCacheSession* session, const nsACString& key, + nsICacheListener* listener) + : mozilla::Runnable("nsDoomEvent") { + mKey = *session->ClientID(); + mKey.Append(':'); + mKey.Append(key); + mStoragePolicy = session->StoragePolicy(); + mListener = listener; + mEventTarget = GetCurrentEventTarget(); + // We addref the listener here and release it in nsNotifyDoomListener + // on the callers thread. If posting of nsNotifyDoomListener event fails + // we leak the listener which is better than releasing it on a wrong + // thread. + NS_IF_ADDREF(mListener); + } + + NS_IMETHOD Run() override { + nsCacheServiceAutoLock lock; + + bool foundActive = true; + nsresult status = NS_ERROR_NOT_AVAILABLE; + nsCacheEntry* entry; + entry = nsCacheService::gService->mActiveEntries.GetEntry(&mKey); + if (!entry) { + bool collision = false; + foundActive = false; + entry = nsCacheService::gService->SearchCacheDevices( + &mKey, mStoragePolicy, &collision); + } + + if (entry) { + status = NS_OK; + nsCacheService::gService->DoomEntry_Internal(entry, foundActive); + } + + if (mListener) { + mEventTarget->Dispatch(new nsNotifyDoomListener(mListener, status), + NS_DISPATCH_NORMAL); + // posted event will release the reference on the correct thread + mListener = nullptr; + } + + return NS_OK; + } + + private: + nsCString mKey; + nsCacheStoragePolicy mStoragePolicy; + nsICacheListener* mListener; + nsCOMPtr<nsIEventTarget> mEventTarget; +}; + +/****************************************************************************** + * nsCacheService + *****************************************************************************/ +nsCacheService* nsCacheService::gService = nullptr; + +NS_IMPL_ISUPPORTS(nsCacheService, nsICacheService, nsICacheServiceInternal) + +nsCacheService::nsCacheService() + : mObserver(nullptr), + mLock("nsCacheService.mLock"), + mCondVar(mLock, "nsCacheService.mCondVar"), + mNotified(false), + mTimeStampLock("nsCacheService.mTimeStampLock"), + mInitialized(false), + mClearingEntries(false), + mEnableOfflineDevice(false), + mOfflineDevice(nullptr), + mDoomedEntries{}, + mTotalEntries(0), + mCacheHits(0), + mCacheMisses(0), + mMaxKeyLength(0), + mMaxDataSize(0), + mMaxMetaSize(0), + mDeactivateFailures(0), + mDeactivatedUnboundEntries(0) { + NS_ASSERTION(gService == nullptr, "multiple nsCacheService instances!"); + gService = this; + + // create list of cache devices + PR_INIT_CLIST(&mDoomedEntries); +} + +nsCacheService::~nsCacheService() { + if (mInitialized) // Shutdown hasn't been called yet. + (void)Shutdown(); + + if (mObserver) { + mObserver->Remove(); + NS_RELEASE(mObserver); + } + + gService = nullptr; +} + +nsresult nsCacheService::Init() { + // Thie method must be called on the main thread because mCacheIOThread must + // only be modified on the main thread. + if (!NS_IsMainThread()) { + NS_ERROR("nsCacheService::Init called off the main thread"); + return NS_ERROR_NOT_SAME_THREAD; + } + + NS_ASSERTION(!mInitialized, "nsCacheService already initialized."); + if (mInitialized) return NS_ERROR_ALREADY_INITIALIZED; + + if (mozilla::net::IsNeckoChild()) { + return NS_ERROR_UNEXPECTED; + } + + nsresult rv; + + mStorageService = do_GetService("@mozilla.org/storage/service;1", &rv); + NS_ENSURE_SUCCESS(rv, rv); + + rv = NS_NewNamedThread("Cache I/O", getter_AddRefs(mCacheIOThread)); + if (NS_FAILED(rv)) { + NS_WARNING("Can't create cache IO thread"); + } + + rv = nsDeleteDir::Init(); + if (NS_FAILED(rv)) { + NS_WARNING("Can't initialize nsDeleteDir"); + } + + // initialize hashtable for active cache entries + mActiveEntries.Init(); + + // create profile/preference observer + if (!mObserver) { + mObserver = new nsCacheProfilePrefObserver(); + NS_ADDREF(mObserver); + mObserver->Install(); + } + + mEnableOfflineDevice = mObserver->OfflineCacheEnabled(); + + mInitialized = true; + return NS_OK; +} + +void nsCacheService::Shutdown() { + // This method must be called on the main thread because mCacheIOThread must + // only be modified on the main thread. + if (!NS_IsMainThread()) { + MOZ_CRASH("nsCacheService::Shutdown called off the main thread"); + } + + nsCOMPtr<nsIThread> cacheIOThread; + Telemetry::AutoTimer<Telemetry::NETWORK_DISK_CACHE_SHUTDOWN> totalTimer; + + bool shouldSanitize = false; + nsCOMPtr<nsIFile> parentDir; + + { + nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHESERVICE_SHUTDOWN)); + NS_ASSERTION( + mInitialized, + "can't shutdown nsCacheService unless it has been initialized."); + if (!mInitialized) return; + + mClearingEntries = true; + DoomActiveEntries(nullptr); + } + + CloseAllStreams(); + + { + nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHESERVICE_SHUTDOWN)); + NS_ASSERTION(mInitialized, "Bad state"); + + mInitialized = false; + + // Clear entries + ClearDoomList(); + + // Make sure to wait for any pending cache-operations before + // proceeding with destructive actions (bug #620660) + (void)SyncWithCacheIOThread(); + mActiveEntries.Shutdown(); + + // obtain the disk cache directory in case we need to sanitize it + parentDir = mObserver->DiskCacheParentDirectory(); + shouldSanitize = mObserver->SanitizeAtShutdown(); + + if (mOfflineDevice) mOfflineDevice->Shutdown(); + + NS_IF_RELEASE(mOfflineDevice); + + for (auto iter = mCustomOfflineDevices.Iter(); !iter.Done(); iter.Next()) { + iter.Data()->Shutdown(); + iter.Remove(); + } + + LogCacheStatistics(); + + mClearingEntries = false; + mCacheIOThread.swap(cacheIOThread); + } + + if (cacheIOThread) nsShutdownThread::BlockingShutdown(cacheIOThread); + + if (shouldSanitize) { + nsresult rv = parentDir->AppendNative("Cache"_ns); + if (NS_SUCCEEDED(rv)) { + bool exists; + if (NS_SUCCEEDED(parentDir->Exists(&exists)) && exists) + nsDeleteDir::DeleteDir(parentDir, false); + } + Telemetry::AutoTimer<Telemetry::NETWORK_DISK_CACHE_SHUTDOWN_CLEAR_PRIVATE> + timer; + nsDeleteDir::Shutdown(shouldSanitize); + } else { + Telemetry::AutoTimer<Telemetry::NETWORK_DISK_CACHE_DELETEDIR_SHUTDOWN> + timer; + nsDeleteDir::Shutdown(shouldSanitize); + } +} + +nsresult nsCacheService::Create(nsISupports* aOuter, const nsIID& aIID, + void** aResult) { + nsresult rv; + + if (aOuter != nullptr) return NS_ERROR_NO_AGGREGATION; + + RefPtr<nsCacheService> cacheService = new nsCacheService(); + rv = cacheService->Init(); + if (NS_SUCCEEDED(rv)) { + rv = cacheService->QueryInterface(aIID, aResult); + } + return rv; +} + +NS_IMETHODIMP +nsCacheService::CreateSession(const char* clientID, + nsCacheStoragePolicy storagePolicy, + bool streamBased, nsICacheSession** result) { + *result = nullptr; + + return NS_ERROR_NOT_IMPLEMENTED; +} + +nsresult nsCacheService::CreateSessionInternal( + const char* clientID, nsCacheStoragePolicy storagePolicy, bool streamBased, + nsICacheSession** result) { + RefPtr<nsCacheSession> session = + new nsCacheSession(clientID, storagePolicy, streamBased); + session.forget(result); + + return NS_OK; +} + +nsresult nsCacheService::EvictEntriesForSession(nsCacheSession* session) { + NS_ASSERTION(gService, "nsCacheService::gService is null."); + return gService->EvictEntriesForClient(session->ClientID()->get(), + session->StoragePolicy()); +} + +namespace { + +class EvictionNotifierRunnable : public Runnable { + public: + explicit EvictionNotifierRunnable(nsISupports* aSubject) + : mozilla::Runnable("EvictionNotifierRunnable"), mSubject(aSubject) {} + + NS_DECL_NSIRUNNABLE + + private: + nsCOMPtr<nsISupports> mSubject; +}; + +NS_IMETHODIMP +EvictionNotifierRunnable::Run() { + nsCOMPtr<nsIObserverService> obsSvc = mozilla::services::GetObserverService(); + if (obsSvc) { + obsSvc->NotifyObservers(mSubject, NS_CACHESERVICE_EMPTYCACHE_TOPIC_ID, + nullptr); + } + return NS_OK; +} + +} // namespace + +nsresult nsCacheService::EvictEntriesForClient( + const char* clientID, nsCacheStoragePolicy storagePolicy) { + RefPtr<EvictionNotifierRunnable> r = + new EvictionNotifierRunnable(NS_ISUPPORTS_CAST(nsICacheService*, this)); + NS_DispatchToMainThread(r); + + nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHESERVICE_EVICTENTRIESFORCLIENT)); + nsresult res = NS_OK; + + // Only clear the offline cache if it has been specifically asked for. + if (storagePolicy == nsICache::STORE_OFFLINE) { + if (mEnableOfflineDevice) { + nsresult rv = NS_OK; + if (!mOfflineDevice) rv = CreateOfflineDevice(); + if (mOfflineDevice) rv = mOfflineDevice->EvictEntries(clientID); + if (NS_FAILED(rv)) res = rv; + } + } + + return res; +} + +nsresult nsCacheService::IsStorageEnabledForPolicy( + nsCacheStoragePolicy storagePolicy, bool* result) { + if (gService == nullptr) return NS_ERROR_NOT_AVAILABLE; + nsCacheServiceAutoLock lock( + LOCK_TELEM(NSCACHESERVICE_ISSTORAGEENABLEDFORPOLICY)); + + *result = nsCacheService::IsStorageEnabledForPolicy_Locked(storagePolicy); + return NS_OK; +} + +nsresult nsCacheService::DoomEntry(nsCacheSession* session, + const nsACString& key, + nsICacheListener* listener) { + CACHE_LOG_DEBUG(("Dooming entry for session %p, key %s\n", session, + PromiseFlatCString(key).get())); + if (!gService || !gService->mInitialized) return NS_ERROR_NOT_INITIALIZED; + + return DispatchToCacheIOThread(new nsDoomEvent(session, key, listener)); +} + +bool nsCacheService::IsStorageEnabledForPolicy_Locked( + nsCacheStoragePolicy storagePolicy) { + if (gService->mEnableOfflineDevice && + storagePolicy == nsICache::STORE_OFFLINE) { + return true; + } + + return false; +} + +NS_IMETHODIMP nsCacheService::VisitEntries(nsICacheVisitor* visitor) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +nsresult nsCacheService::VisitEntriesInternal(nsICacheVisitor* visitor) { + NS_ENSURE_ARG_POINTER(visitor); + + nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHESERVICE_VISITENTRIES)); + + if (!mEnableOfflineDevice) return NS_ERROR_NOT_AVAILABLE; + + // XXX record the fact that a visitation is in progress, + // XXX i.e. keep list of visitors in progress. + + nsresult rv = NS_OK; + + if (mEnableOfflineDevice) { + if (!mOfflineDevice) { + rv = CreateOfflineDevice(); + if (NS_FAILED(rv)) return rv; + } + rv = mOfflineDevice->Visit(visitor); + if (NS_FAILED(rv)) return rv; + } + + // XXX notify any shutdown process that visitation is complete for THIS + // visitor. + // XXX keep queue of visitors + + return NS_OK; +} + +void nsCacheService::FireClearNetworkCacheStoredAnywhereNotification() { + MOZ_ASSERT(NS_IsMainThread()); + nsCOMPtr<nsIObserverService> obsvc = mozilla::services::GetObserverService(); + if (obsvc) { + obsvc->NotifyObservers(nullptr, "network-clear-cache-stored-anywhere", + nullptr); + } +} + +NS_IMETHODIMP nsCacheService::EvictEntries(nsCacheStoragePolicy storagePolicy) { + return NS_ERROR_NOT_IMPLEMENTED; +} + +nsresult nsCacheService::EvictEntriesInternal( + nsCacheStoragePolicy storagePolicy) { + if (storagePolicy == nsICache::STORE_ANYWHERE) { + // if not called on main thread, dispatch the notification to the main + // thread to notify observers + if (!NS_IsMainThread()) { + nsCOMPtr<nsIRunnable> event = NewRunnableMethod( + "nsCacheService::FireClearNetworkCacheStoredAnywhereNotification", + this, + &nsCacheService::FireClearNetworkCacheStoredAnywhereNotification); + NS_DispatchToMainThread(event); + } else { + // else you're already on main thread - notify observers + FireClearNetworkCacheStoredAnywhereNotification(); + } + } + return EvictEntriesForClient(nullptr, storagePolicy); +} + +NS_IMETHODIMP nsCacheService::GetCacheIOTarget( + nsIEventTarget** aCacheIOTarget) { + NS_ENSURE_ARG_POINTER(aCacheIOTarget); + + // Because mCacheIOThread can only be changed on the main thread, it can be + // read from the main thread without the lock. This is useful to prevent + // blocking the main thread on other cache operations. + if (!NS_IsMainThread()) { + Lock(LOCK_TELEM(NSCACHESERVICE_GETCACHEIOTARGET)); + } + + nsresult rv; + if (mCacheIOThread) { + *aCacheIOTarget = do_AddRef(mCacheIOThread).take(); + rv = NS_OK; + } else { + *aCacheIOTarget = nullptr; + rv = NS_ERROR_NOT_AVAILABLE; + } + + if (!NS_IsMainThread()) { + Unlock(); + } + + return rv; +} + +NS_IMETHODIMP nsCacheService::GetLockHeldTime(double* aLockHeldTime) { + MutexAutoLock lock(mTimeStampLock); + + if (mLockAcquiredTimeStamp.IsNull()) { + *aLockHeldTime = 0.0; + } else { + *aLockHeldTime = + (TimeStamp::Now() - mLockAcquiredTimeStamp).ToMilliseconds(); + } + + return NS_OK; +} + +/** + * Internal Methods + */ +nsresult nsCacheService::GetOfflineDevice(nsOfflineCacheDevice** aDevice) { + if (!mOfflineDevice) { + nsresult rv = CreateOfflineDevice(); + if (NS_FAILED(rv)) { + return rv; + } + } + + *aDevice = do_AddRef(mOfflineDevice).take(); + return NS_OK; +} + +nsresult nsCacheService::GetCustomOfflineDevice( + nsIFile* aProfileDir, int32_t aQuota, nsOfflineCacheDevice** aDevice) { + nsresult rv; + + nsAutoString profilePath; + rv = aProfileDir->GetPath(profilePath); + NS_ENSURE_SUCCESS(rv, rv); + + if (!mCustomOfflineDevices.Get(profilePath, aDevice)) { + rv = CreateCustomOfflineDevice(aProfileDir, aQuota, aDevice); + if (NS_FAILED(rv)) { + return rv; + } + + (*aDevice)->SetAutoShutdown(); + mCustomOfflineDevices.Put(profilePath, RefPtr{*aDevice}); + } + + return NS_OK; +} + +nsresult nsCacheService::CreateOfflineDevice() { + CACHE_LOG_INFO(("Creating default offline device")); + + if (mOfflineDevice) return NS_OK; + if (!nsCacheService::IsInitialized()) { + return NS_ERROR_NOT_AVAILABLE; + } + + return CreateCustomOfflineDevice(mObserver->OfflineCacheParentDirectory(), + mObserver->OfflineCacheCapacity(), + &mOfflineDevice); +} + +nsresult nsCacheService::CreateCustomOfflineDevice( + nsIFile* aProfileDir, int32_t aQuota, nsOfflineCacheDevice** aDevice) { + NS_ENSURE_ARG(aProfileDir); + + if (MOZ_LOG_TEST(gCacheLog, LogLevel::Info)) { + CACHE_LOG_INFO(("Creating custom offline device, %s, %d", + aProfileDir->HumanReadablePath().get(), aQuota)); + } + + if (!mInitialized) { + NS_WARNING("nsCacheService not initialized"); + return NS_ERROR_NOT_AVAILABLE; + } + + if (!mEnableOfflineDevice) return NS_ERROR_NOT_AVAILABLE; + + RefPtr<nsOfflineCacheDevice> device = new nsOfflineCacheDevice(); + + // set the preferences + device->SetCacheParentDirectory(aProfileDir); + device->SetCapacity(aQuota); + + nsresult rv = device->InitWithSqlite(mStorageService); + if (NS_FAILED(rv)) { + CACHE_LOG_DEBUG(("OfflineDevice->InitWithSqlite() failed (0x%.8" PRIx32 + ")\n", + static_cast<uint32_t>(rv))); + CACHE_LOG_DEBUG((" - disabling offline cache for this session.\n")); + device = nullptr; + } + + device.forget(aDevice); + return rv; +} + +nsresult nsCacheService::RemoveCustomOfflineDevice( + nsOfflineCacheDevice* aDevice) { + nsCOMPtr<nsIFile> profileDir = aDevice->BaseDirectory(); + if (!profileDir) return NS_ERROR_UNEXPECTED; + + nsAutoString profilePath; + nsresult rv = profileDir->GetPath(profilePath); + NS_ENSURE_SUCCESS(rv, rv); + + mCustomOfflineDevices.Remove(profilePath); + return NS_OK; +} + +nsresult nsCacheService::CreateRequest(nsCacheSession* session, + const nsACString& clientKey, + nsCacheAccessMode accessRequested, + bool blockingMode, + nsICacheListener* listener, + nsCacheRequest** request) { + NS_ASSERTION(request, "CreateRequest: request is null"); + + nsAutoCString key(*session->ClientID()); + key.Append(':'); + key.Append(clientKey); + + if (mMaxKeyLength < key.Length()) mMaxKeyLength = key.Length(); + + // create request + *request = + new nsCacheRequest(key, listener, accessRequested, blockingMode, session); + + if (!listener) return NS_OK; // we're sync, we're done. + + // get the request's thread + (*request)->mEventTarget = GetCurrentEventTarget(); + + return NS_OK; +} + +class nsCacheListenerEvent : public Runnable { + public: + nsCacheListenerEvent(nsICacheListener* listener, + nsICacheEntryDescriptor* descriptor, + nsCacheAccessMode accessGranted, nsresult status) + : mozilla::Runnable("nsCacheListenerEvent"), + mListener(listener) // transfers reference + , + mDescriptor(descriptor) // transfers reference (may be null) + , + mAccessGranted(accessGranted), + mStatus(status) {} + + NS_IMETHOD Run() override { + mListener->OnCacheEntryAvailable(mDescriptor, mAccessGranted, mStatus); + + NS_RELEASE(mListener); + NS_IF_RELEASE(mDescriptor); + return NS_OK; + } + + private: + // We explicitly leak mListener or mDescriptor if Run is not called + // because otherwise we cannot guarantee that they are destroyed on + // the right thread. + + nsICacheListener* mListener; + nsICacheEntryDescriptor* mDescriptor; + nsCacheAccessMode mAccessGranted; + nsresult mStatus; +}; + +nsresult nsCacheService::NotifyListener(nsCacheRequest* request, + nsICacheEntryDescriptor* descriptor, + nsCacheAccessMode accessGranted, + nsresult status) { + NS_ASSERTION(request->mEventTarget, "no thread set in async request!"); + + // Swap ownership, and release listener on target thread... + nsICacheListener* listener = request->mListener; + request->mListener = nullptr; + + nsCOMPtr<nsIRunnable> ev = + new nsCacheListenerEvent(listener, descriptor, accessGranted, status); + if (!ev) { + // Better to leak listener and descriptor if we fail because we don't + // want to destroy them inside the cache service lock or on potentially + // the wrong thread. + return NS_ERROR_OUT_OF_MEMORY; + } + + return request->mEventTarget->Dispatch(ev, NS_DISPATCH_NORMAL); +} + +nsresult nsCacheService::ProcessRequest(nsCacheRequest* request, + bool calledFromOpenCacheEntry, + nsICacheEntryDescriptor** result) { + // !!! must be called with mLock held !!! + nsresult rv; + nsCacheEntry* entry = nullptr; + nsCacheEntry* doomedEntry = nullptr; + nsCacheAccessMode accessGranted = nsICache::ACCESS_NONE; + if (result) *result = nullptr; + + while (true) { // Activate entry loop + rv = ActivateEntry(request, &entry, + &doomedEntry); // get the entry for this request + if (NS_FAILED(rv)) break; + + while (true) { // Request Access loop + NS_ASSERTION(entry, "no entry in Request Access loop!"); + // entry->RequestAccess queues request on entry + rv = entry->RequestAccess(request, &accessGranted); + if (rv != NS_ERROR_CACHE_WAIT_FOR_VALIDATION) break; + + if (request->IsBlocking()) { + if (request->mListener) { + // async exits - validate, doom, or close will resume + return rv; + } + + // XXX this is probably wrong... + Unlock(); + rv = request->WaitForValidation(); + Lock(LOCK_TELEM(NSCACHESERVICE_PROCESSREQUEST)); + } + + PR_REMOVE_AND_INIT_LINK(request); + if (NS_FAILED(rv)) + break; // non-blocking mode returns WAIT_FOR_VALIDATION error + // okay, we're ready to process this request, request access again + } + if (rv != NS_ERROR_CACHE_ENTRY_DOOMED) break; + + if (entry->IsNotInUse()) { + // this request was the last one keeping it around, so get rid of it + DeactivateEntry(entry); + } + // loop back around to look for another entry + } + + if (NS_SUCCEEDED(rv) && request->mProfileDir) { + // Custom cache directory has been demanded. Preset the cache device. + if (entry->StoragePolicy() != nsICache::STORE_OFFLINE) { + // Failsafe check: this is implemented only for offline cache atm. + rv = NS_ERROR_FAILURE; + } else { + RefPtr<nsOfflineCacheDevice> customCacheDevice; + rv = GetCustomOfflineDevice(request->mProfileDir, -1, + getter_AddRefs(customCacheDevice)); + if (NS_SUCCEEDED(rv)) entry->SetCustomCacheDevice(customCacheDevice); + } + } + + nsICacheEntryDescriptor* descriptor = nullptr; + + if (NS_SUCCEEDED(rv)) + rv = entry->CreateDescriptor(request, accessGranted, &descriptor); + + // If doomedEntry is set, ActivatEntry() doomed an existing entry and + // created a new one for that cache-key. However, any pending requests + // on the doomed entry were not processed and we need to do that here. + // This must be done after adding the created entry to list of active + // entries (which is done in ActivateEntry()) otherwise the hashkeys crash + // (see bug ##561313). It is also important to do this after creating a + // descriptor for this request, or some other request may end up being + // executed first for the newly created entry. + // Finally, it is worth to emphasize that if doomedEntry is set, + // ActivateEntry() created a new entry for the request, which will be + // initialized by RequestAccess() and they both should have returned NS_OK. + if (doomedEntry) { + (void)ProcessPendingRequests(doomedEntry); + if (doomedEntry->IsNotInUse()) DeactivateEntry(doomedEntry); + doomedEntry = nullptr; + } + + if (request->mListener) { // Asynchronous + + if (NS_FAILED(rv) && calledFromOpenCacheEntry && request->IsBlocking()) + return rv; // skip notifying listener, just return rv to caller + + // call listener to report error or descriptor + nsresult rv2 = NotifyListener(request, descriptor, accessGranted, rv); + if (NS_FAILED(rv2) && NS_SUCCEEDED(rv)) { + rv = rv2; // trigger delete request + } + } else { // Synchronous + *result = descriptor; + } + return rv; +} + +nsresult nsCacheService::OpenCacheEntry(nsCacheSession* session, + const nsACString& key, + nsCacheAccessMode accessRequested, + bool blockingMode, + nsICacheListener* listener, + nsICacheEntryDescriptor** result) { + CACHE_LOG_DEBUG( + ("Opening entry for session %p, key %s, mode %d, blocking %d\n", session, + PromiseFlatCString(key).get(), accessRequested, blockingMode)); + if (result) *result = nullptr; + + if (!gService || !gService->mInitialized) return NS_ERROR_NOT_INITIALIZED; + + nsCacheRequest* request = nullptr; + + nsresult rv = gService->CreateRequest(session, key, accessRequested, + blockingMode, listener, &request); + if (NS_FAILED(rv)) return rv; + + CACHE_LOG_DEBUG(("Created request %p\n", request)); + + // Process the request on the background thread if we are on the main thread + // and the the request is asynchronous + if (NS_IsMainThread() && listener && gService->mCacheIOThread) { + nsCOMPtr<nsIRunnable> ev = new nsProcessRequestEvent(request); + rv = DispatchToCacheIOThread(ev); + + // delete request if we didn't post the event + if (NS_FAILED(rv)) delete request; + } else { + nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHESERVICE_OPENCACHEENTRY)); + rv = gService->ProcessRequest(request, true, result); + + // delete requests that have completed + if (!(listener && blockingMode && + (rv == NS_ERROR_CACHE_WAIT_FOR_VALIDATION))) + delete request; + } + + return rv; +} + +nsresult nsCacheService::ActivateEntry(nsCacheRequest* request, + nsCacheEntry** result, + nsCacheEntry** doomedEntry) { + CACHE_LOG_DEBUG(("Activate entry for request %p\n", request)); + if (!mInitialized || mClearingEntries) return NS_ERROR_NOT_AVAILABLE; + + nsresult rv = NS_OK; + + NS_ASSERTION(request != nullptr, "ActivateEntry called with no request"); + if (result) *result = nullptr; + if (doomedEntry) *doomedEntry = nullptr; + if ((!request) || (!result) || (!doomedEntry)) return NS_ERROR_NULL_POINTER; + + // check if the request can be satisfied + if (!request->IsStreamBased()) return NS_ERROR_FAILURE; + if (!IsStorageEnabledForPolicy_Locked(request->StoragePolicy())) + return NS_ERROR_FAILURE; + + // search active entries (including those not bound to device) + nsCacheEntry* entry = mActiveEntries.GetEntry(&(request->mKey)); + CACHE_LOG_DEBUG(("Active entry for request %p is %p\n", request, entry)); + + if (!entry) { + // search cache devices for entry + bool collision = false; + entry = SearchCacheDevices(&(request->mKey), request->StoragePolicy(), + &collision); + CACHE_LOG_DEBUG( + ("Device search for request %p returned %p\n", request, entry)); + // When there is a hashkey collision just refuse to cache it... + if (collision) return NS_ERROR_CACHE_IN_USE; + + if (entry) entry->MarkInitialized(); + } else { + NS_ASSERTION(entry->IsActive(), "Inactive entry found in mActiveEntries!"); + } + + if (entry) { + ++mCacheHits; + entry->Fetched(); + } else { + ++mCacheMisses; + } + + if (entry && ((request->AccessRequested() == nsICache::ACCESS_WRITE) || + ((request->StoragePolicy() != nsICache::STORE_OFFLINE) && + (entry->mExpirationTime <= SecondsFromPRTime(PR_Now()) && + request->WillDoomEntriesIfExpired())))) + + { + // this is FORCE-WRITE request or the entry has expired + // we doom entry without processing pending requests, but store it in + // doomedEntry which causes pending requests to be processed below + rv = DoomEntry_Internal(entry, false); + *doomedEntry = entry; + if (NS_FAILED(rv)) { + // XXX what to do? Increment FailedDooms counter? + } + entry = nullptr; + } + + if (!entry) { + if (!(request->AccessRequested() & nsICache::ACCESS_WRITE)) { + // this is a READ-ONLY request + rv = NS_ERROR_CACHE_KEY_NOT_FOUND; + goto error; + } + + entry = new nsCacheEntry(request->mKey, request->IsStreamBased(), + request->StoragePolicy()); + if (!entry) return NS_ERROR_OUT_OF_MEMORY; + + if (request->IsPrivate()) entry->MarkPrivate(); + + entry->Fetched(); + ++mTotalEntries; + + // XXX we could perform an early bind in some cases based on storage policy + } + + if (!entry->IsActive()) { + rv = mActiveEntries.AddEntry(entry); + if (NS_FAILED(rv)) goto error; + CACHE_LOG_DEBUG(("Added entry %p to mActiveEntries\n", entry)); + entry->MarkActive(); // mark entry active, because it's now in + // mActiveEntries + } + *result = entry; + return NS_OK; + +error: + *result = nullptr; + delete entry; + return rv; +} + +nsCacheEntry* nsCacheService::SearchCacheDevices(nsCString* key, + nsCacheStoragePolicy policy, + bool* collision) { + Telemetry::AutoTimer<Telemetry::CACHE_DEVICE_SEARCH_2> timer; + nsCacheEntry* entry = nullptr; + + *collision = false; + if (policy == nsICache::STORE_OFFLINE || + (policy == nsICache::STORE_ANYWHERE && gIOService->IsOffline())) { + if (mEnableOfflineDevice) { + if (!mOfflineDevice) { + nsresult rv = CreateOfflineDevice(); + if (NS_FAILED(rv)) return nullptr; + } + + entry = mOfflineDevice->FindEntry(key, collision); + } + } + + return entry; +} + +nsCacheDevice* nsCacheService::EnsureEntryHasDevice(nsCacheEntry* entry) { + nsCacheDevice* device = entry->CacheDevice(); + // return device if found, possibly null if the entry is doomed i.e prevent + // doomed entries to bind to a device (see e.g. bugs #548406 and #596443) + if (device || entry->IsDoomed()) return device; + + if (!device && entry->IsStreamData() && entry->IsAllowedOffline() && + mEnableOfflineDevice) { + if (!mOfflineDevice) { + (void)CreateOfflineDevice(); // ignore the error (check for + // mOfflineDevice instead) + } + + device = entry->CustomCacheDevice() ? entry->CustomCacheDevice() + : mOfflineDevice; + + if (device) { + entry->MarkBinding(); + nsresult rv = device->BindEntry(entry); + entry->ClearBinding(); + if (NS_FAILED(rv)) device = nullptr; + } + } + + if (device) entry->SetCacheDevice(device); + return device; +} + +nsresult nsCacheService::DoomEntry(nsCacheEntry* entry) { + return gService->DoomEntry_Internal(entry, true); +} + +nsresult nsCacheService::DoomEntry_Internal(nsCacheEntry* entry, + bool doProcessPendingRequests) { + if (entry->IsDoomed()) return NS_OK; + + CACHE_LOG_DEBUG(("Dooming entry %p\n", entry)); + nsresult rv = NS_OK; + entry->MarkDoomed(); + + NS_ASSERTION(!entry->IsBinding(), "Dooming entry while binding device."); + nsCacheDevice* device = entry->CacheDevice(); + if (device) device->DoomEntry(entry); + + if (entry->IsActive()) { + // remove from active entries + mActiveEntries.RemoveEntry(entry); + CACHE_LOG_DEBUG(("Removed entry %p from mActiveEntries\n", entry)); + entry->MarkInactive(); + } + + // put on doom list to wait for descriptors to close + NS_ASSERTION(PR_CLIST_IS_EMPTY(entry), "doomed entry still on device list"); + PR_APPEND_LINK(entry, &mDoomedEntries); + + // handle pending requests only if we're supposed to + if (doProcessPendingRequests) { + // tell pending requests to get on with their lives... + rv = ProcessPendingRequests(entry); + + // All requests have been removed, but there may still be open descriptors + if (entry->IsNotInUse()) { + DeactivateEntry(entry); // tell device to get rid of it + } + } + return rv; +} + +void nsCacheService::OnProfileShutdown() { + if (!gService || !gService->mInitialized) { + // The cache service has been shut down, but someone is still holding + // a reference to it. Ignore this call. + return; + } + + { + nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHESERVICE_ONPROFILESHUTDOWN)); + gService->mClearingEntries = true; + gService->DoomActiveEntries(nullptr); + } + + gService->CloseAllStreams(); + + nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHESERVICE_ONPROFILESHUTDOWN)); + gService->ClearDoomList(); + + // Make sure to wait for any pending cache-operations before + // proceeding with destructive actions (bug #620660) + (void)SyncWithCacheIOThread(); + + if (gService->mOfflineDevice && gService->mEnableOfflineDevice) { + gService->mOfflineDevice->Shutdown(); + } + for (auto iter = gService->mCustomOfflineDevices.Iter(); !iter.Done(); + iter.Next()) { + iter.Data()->Shutdown(); + iter.Remove(); + } + + gService->mEnableOfflineDevice = false; + + gService->mClearingEntries = false; +} + +void nsCacheService::OnProfileChanged() { + if (!gService) return; + + CACHE_LOG_DEBUG(("nsCacheService::OnProfileChanged")); + + nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHESERVICE_ONPROFILECHANGED)); + + gService->mEnableOfflineDevice = gService->mObserver->OfflineCacheEnabled(); + + if (gService->mOfflineDevice) { + gService->mOfflineDevice->SetCacheParentDirectory( + gService->mObserver->OfflineCacheParentDirectory()); + gService->mOfflineDevice->SetCapacity( + gService->mObserver->OfflineCacheCapacity()); + + // XXX initialization of mOfflineDevice could be made lazily, if + // mEnableOfflineDevice is false + nsresult rv = + gService->mOfflineDevice->InitWithSqlite(gService->mStorageService); + if (NS_FAILED(rv)) { + NS_ERROR( + "nsCacheService::OnProfileChanged: Re-initializing offline device " + "failed"); + gService->mEnableOfflineDevice = false; + // XXX delete mOfflineDevice? + } + } +} + +void nsCacheService::SetOfflineCacheEnabled(bool enabled) { + if (!gService) return; + nsCacheServiceAutoLock lock( + LOCK_TELEM(NSCACHESERVICE_SETOFFLINECACHEENABLED)); + gService->mEnableOfflineDevice = enabled; +} + +void nsCacheService::SetOfflineCacheCapacity(int32_t capacity) { + if (!gService) return; + nsCacheServiceAutoLock lock( + LOCK_TELEM(NSCACHESERVICE_SETOFFLINECACHECAPACITY)); + + if (gService->mOfflineDevice) { + gService->mOfflineDevice->SetCapacity(capacity); + } + + gService->mEnableOfflineDevice = gService->mObserver->OfflineCacheEnabled(); +} + +/****************************************************************************** + * static methods for nsCacheEntryDescriptor + *****************************************************************************/ +void nsCacheService::CloseDescriptor(nsCacheEntryDescriptor* descriptor) { + // ask entry to remove descriptor + nsCacheEntry* entry = descriptor->CacheEntry(); + bool doomEntry; + bool stillActive = entry->RemoveDescriptor(descriptor, &doomEntry); + + if (!entry->IsValid()) { + gService->ProcessPendingRequests(entry); + } + + if (doomEntry) { + gService->DoomEntry_Internal(entry, true); + return; + } + + if (!stillActive) { + gService->DeactivateEntry(entry); + } +} + +nsresult nsCacheService::GetFileForEntry(nsCacheEntry* entry, + nsIFile** result) { + nsCacheDevice* device = gService->EnsureEntryHasDevice(entry); + if (!device) return NS_ERROR_UNEXPECTED; + + return device->GetFileForEntry(entry, result); +} + +nsresult nsCacheService::OpenInputStreamForEntry(nsCacheEntry* entry, + nsCacheAccessMode mode, + uint32_t offset, + nsIInputStream** result) { + nsCacheDevice* device = gService->EnsureEntryHasDevice(entry); + if (!device) return NS_ERROR_UNEXPECTED; + + return device->OpenInputStreamForEntry(entry, mode, offset, result); +} + +nsresult nsCacheService::OpenOutputStreamForEntry(nsCacheEntry* entry, + nsCacheAccessMode mode, + uint32_t offset, + nsIOutputStream** result) { + nsCacheDevice* device = gService->EnsureEntryHasDevice(entry); + if (!device) return NS_ERROR_UNEXPECTED; + + return device->OpenOutputStreamForEntry(entry, mode, offset, result); +} + +nsresult nsCacheService::OnDataSizeChange(nsCacheEntry* entry, + int32_t deltaSize) { + nsCacheDevice* device = gService->EnsureEntryHasDevice(entry); + if (!device) return NS_ERROR_UNEXPECTED; + + return device->OnDataSizeChange(entry, deltaSize); +} + +void nsCacheService::LockAcquired() { + MutexAutoLock lock(mTimeStampLock); + mLockAcquiredTimeStamp = TimeStamp::Now(); +} + +void nsCacheService::LockReleased() { + MutexAutoLock lock(mTimeStampLock); + mLockAcquiredTimeStamp = TimeStamp(); +} + +void nsCacheService::Lock() { + gService->mLock.Lock(); + gService->LockAcquired(); +} + +void nsCacheService::Lock(mozilla::Telemetry::HistogramID mainThreadLockerID) { + mozilla::Telemetry::HistogramID lockerID; + mozilla::Telemetry::HistogramID generalID; + + if (NS_IsMainThread()) { + lockerID = mainThreadLockerID; + generalID = mozilla::Telemetry::CACHE_SERVICE_LOCK_WAIT_MAINTHREAD_2; + } else { + lockerID = mozilla::Telemetry::HistogramCount; + generalID = mozilla::Telemetry::CACHE_SERVICE_LOCK_WAIT_2; + } + + TimeStamp start(TimeStamp::Now()); + + nsCacheService::Lock(); + + TimeStamp stop(TimeStamp::Now()); + + // Telemetry isn't thread safe on its own, but this is OK because we're + // protecting it with the cache lock. + if (lockerID != mozilla::Telemetry::HistogramCount) { + mozilla::Telemetry::AccumulateTimeDelta(lockerID, start, stop); + } + mozilla::Telemetry::AccumulateTimeDelta(generalID, start, stop); +} + +void nsCacheService::Unlock() { + gService->mLock.AssertCurrentThreadOwns(); + + nsTArray<nsISupports*> doomed = std::move(gService->mDoomedObjects); + + gService->LockReleased(); + gService->mLock.Unlock(); + + for (uint32_t i = 0; i < doomed.Length(); ++i) doomed[i]->Release(); +} + +void nsCacheService::ReleaseObject_Locked(nsISupports* obj, + nsIEventTarget* target) { + gService->mLock.AssertCurrentThreadOwns(); + + bool isCur; + if (!target || (NS_SUCCEEDED(target->IsOnCurrentThread(&isCur)) && isCur)) { + gService->mDoomedObjects.AppendElement(obj); + } else { + NS_ProxyRelease("nsCacheService::ReleaseObject_Locked::obj", target, + dont_AddRef(obj)); + } +} + +nsresult nsCacheService::SetCacheElement(nsCacheEntry* entry, + nsISupports* element) { + entry->SetData(element); + entry->TouchData(); + return NS_OK; +} + +nsresult nsCacheService::ValidateEntry(nsCacheEntry* entry) { + nsCacheDevice* device = gService->EnsureEntryHasDevice(entry); + if (!device) return NS_ERROR_UNEXPECTED; + + entry->MarkValid(); + nsresult rv = gService->ProcessPendingRequests(entry); + NS_ASSERTION(rv == NS_OK, "ProcessPendingRequests failed."); + // XXX what else should be done? + + return rv; +} + +int32_t nsCacheService::CacheCompressionLevel() { + int32_t level = gService->mObserver->CacheCompressionLevel(); + return level; +} + +void nsCacheService::DeactivateEntry(nsCacheEntry* entry) { + CACHE_LOG_DEBUG(("Deactivating entry %p\n", entry)); + nsresult rv = NS_OK; + NS_ASSERTION(entry->IsNotInUse(), "### deactivating an entry while in use!"); + nsCacheDevice* device = nullptr; + + if (mMaxDataSize < entry->DataSize()) mMaxDataSize = entry->DataSize(); + if (mMaxMetaSize < entry->MetaDataSize()) + mMaxMetaSize = entry->MetaDataSize(); + + if (entry->IsDoomed()) { + // remove from Doomed list + PR_REMOVE_AND_INIT_LINK(entry); + } else if (entry->IsActive()) { + // remove from active entries + mActiveEntries.RemoveEntry(entry); + CACHE_LOG_DEBUG( + ("Removed deactivated entry %p from mActiveEntries\n", entry)); + entry->MarkInactive(); + + // bind entry if necessary to store meta-data + device = EnsureEntryHasDevice(entry); + if (!device) { + CACHE_LOG_DEBUG( + ("DeactivateEntry: unable to bind active " + "entry %p\n", + entry)); + NS_WARNING("DeactivateEntry: unable to bind active entry\n"); + return; + } + } else { + // if mInitialized == false, + // then we're shutting down and this state is okay. + NS_ASSERTION(!mInitialized, "DeactivateEntry: bad cache entry state."); + } + + device = entry->CacheDevice(); + if (device) { + rv = device->DeactivateEntry(entry); + if (NS_FAILED(rv)) { + // increment deactivate failure count + ++mDeactivateFailures; + } + } else { + // increment deactivating unbound entry statistic + ++mDeactivatedUnboundEntries; + delete entry; // because no one else will + } +} + +nsresult nsCacheService::ProcessPendingRequests(nsCacheEntry* entry) { + nsresult rv = NS_OK; + nsCacheRequest* request = (nsCacheRequest*)PR_LIST_HEAD(&entry->mRequestQ); + nsCacheRequest* nextRequest; + bool newWriter = false; + + CACHE_LOG_DEBUG(( + "ProcessPendingRequests for %sinitialized %s %salid entry %p\n", + (entry->IsInitialized() ? "" : "Un"), (entry->IsDoomed() ? "DOOMED" : ""), + (entry->IsValid() ? "V" : "Inv"), entry)); + + if (request == &entry->mRequestQ) return NS_OK; // no queued requests + + if (!entry->IsDoomed() && entry->IsInvalid()) { + // 1st descriptor closed w/o MarkValid() + NS_ASSERTION(PR_CLIST_IS_EMPTY(&entry->mDescriptorQ), + "shouldn't be here with open descriptors"); + +#if DEBUG + // verify no ACCESS_WRITE requests(shouldn't have any of these) + while (request != &entry->mRequestQ) { + NS_ASSERTION(request->AccessRequested() != nsICache::ACCESS_WRITE, + "ACCESS_WRITE request should have been given a new entry"); + request = (nsCacheRequest*)PR_NEXT_LINK(request); + } + request = (nsCacheRequest*)PR_LIST_HEAD(&entry->mRequestQ); +#endif + // find first request with ACCESS_READ_WRITE (if any) and promote it to 1st + // writer + while (request != &entry->mRequestQ) { + if (request->AccessRequested() == nsICache::ACCESS_READ_WRITE) { + newWriter = true; + CACHE_LOG_DEBUG((" promoting request %p to 1st writer\n", request)); + break; + } + + request = (nsCacheRequest*)PR_NEXT_LINK(request); + } + + if (request == &entry->mRequestQ) // no requests asked for + // ACCESS_READ_WRITE, back to top + request = (nsCacheRequest*)PR_LIST_HEAD(&entry->mRequestQ); + + // XXX what should we do if there are only READ requests in queue? + // XXX serialize their accesses, give them only read access, but force them + // to check validate flag? + // XXX or do readers simply presume the entry is valid + // See fix for bug #467392 below + } + + nsCacheAccessMode accessGranted = nsICache::ACCESS_NONE; + + while (request != &entry->mRequestQ) { + nextRequest = (nsCacheRequest*)PR_NEXT_LINK(request); + CACHE_LOG_DEBUG((" %sync request %p for %p\n", + (request->mListener ? "As" : "S"), request, entry)); + + if (request->mListener) { + // Async request + PR_REMOVE_AND_INIT_LINK(request); + + if (entry->IsDoomed()) { + rv = ProcessRequest(request, false, nullptr); + if (rv == NS_ERROR_CACHE_WAIT_FOR_VALIDATION) + rv = NS_OK; + else + delete request; + + if (NS_FAILED(rv)) { + // XXX what to do? + } + } else if (entry->IsValid() || newWriter) { + rv = entry->RequestAccess(request, &accessGranted); + NS_ASSERTION(NS_SUCCEEDED(rv), + "if entry is valid, RequestAccess must succeed."); + // XXX if (newWriter) { + // NS_ASSERTION( accessGranted == + // request->AccessRequested(), "why not?"); + // } + + // entry->CreateDescriptor dequeues request, and queues descriptor + nsICacheEntryDescriptor* descriptor = nullptr; + rv = entry->CreateDescriptor(request, accessGranted, &descriptor); + + // post call to listener to report error or descriptor + rv = NotifyListener(request, descriptor, accessGranted, rv); + delete request; + if (NS_FAILED(rv)) { + // XXX what to do? + } + + } else { + // read-only request to an invalid entry - need to wait for + // the entry to become valid so we post an event to process + // the request again later (bug #467392) + nsCOMPtr<nsIRunnable> ev = new nsProcessRequestEvent(request); + rv = DispatchToCacheIOThread(ev); + if (NS_FAILED(rv)) { + delete request; // avoid leak + } + } + } else { + // Synchronous request + request->WakeUp(); + } + if (newWriter) break; // process remaining requests after validation + request = nextRequest; + } + + return NS_OK; +} + +bool nsCacheService::IsDoomListEmpty() { + nsCacheEntry* entry = (nsCacheEntry*)PR_LIST_HEAD(&mDoomedEntries); + return &mDoomedEntries == entry; +} + +void nsCacheService::ClearDoomList() { + nsCacheEntry* entry = (nsCacheEntry*)PR_LIST_HEAD(&mDoomedEntries); + + while (entry != &mDoomedEntries) { + nsCacheEntry* next = (nsCacheEntry*)PR_NEXT_LINK(entry); + + entry->DetachDescriptors(); + DeactivateEntry(entry); + entry = next; + } +} + +void nsCacheService::DoomActiveEntries(DoomCheckFn check) { + AutoTArray<nsCacheEntry*, 8> array; + + for (auto iter = mActiveEntries.Iter(); !iter.Done(); iter.Next()) { + nsCacheEntry* entry = + static_cast<nsCacheEntryHashTableEntry*>(iter.Get())->cacheEntry; + + if (check && !check(entry)) { + continue; + } + + array.AppendElement(entry); + + // entry is being removed from the active entry list + entry->MarkInactive(); + iter.Remove(); + } + + uint32_t count = array.Length(); + for (uint32_t i = 0; i < count; ++i) { + DoomEntry_Internal(array[i], true); + } +} + +void nsCacheService::CloseAllStreams() { + nsTArray<RefPtr<nsCacheEntryDescriptor::nsInputStreamWrapper> > inputs; + nsTArray<RefPtr<nsCacheEntryDescriptor::nsOutputStreamWrapper> > outputs; + + { + nsCacheServiceAutoLock lock(LOCK_TELEM(NSCACHESERVICE_CLOSEALLSTREAMS)); + + nsTArray<nsCacheEntry*> entries; + +#if DEBUG + // make sure there is no active entry + for (auto iter = mActiveEntries.Iter(); !iter.Done(); iter.Next()) { + auto entry = static_cast<nsCacheEntryHashTableEntry*>(iter.Get()); + entries.AppendElement(entry->cacheEntry); + } + NS_ASSERTION(entries.IsEmpty(), "Bad state"); +#endif + + // Get doomed entries + nsCacheEntry* entry = (nsCacheEntry*)PR_LIST_HEAD(&mDoomedEntries); + while (entry != &mDoomedEntries) { + nsCacheEntry* next = (nsCacheEntry*)PR_NEXT_LINK(entry); + entries.AppendElement(entry); + entry = next; + } + + // Iterate through all entries and collect input and output streams + for (size_t i = 0; i < entries.Length(); i++) { + entry = entries.ElementAt(i); + + nsTArray<RefPtr<nsCacheEntryDescriptor> > descs; + entry->GetDescriptors(descs); + + for (uint32_t j = 0; j < descs.Length(); j++) { + if (descs[j]->mOutputWrapper) + outputs.AppendElement(descs[j]->mOutputWrapper); + + for (size_t k = 0; k < descs[j]->mInputWrappers.Length(); k++) + inputs.AppendElement(descs[j]->mInputWrappers[k]); + } + } + } + + uint32_t i; + for (i = 0; i < inputs.Length(); i++) inputs[i]->Close(); + + for (i = 0; i < outputs.Length(); i++) outputs[i]->Close(); +} + +bool nsCacheService::GetClearingEntries() { + AssertOwnsLock(); + return gService->mClearingEntries; +} + +// static +void nsCacheService::GetCacheBaseDirectoty(nsIFile** result) { + *result = nullptr; + if (!gService || !gService->mObserver) return; + + nsCOMPtr<nsIFile> directory = gService->mObserver->DiskCacheParentDirectory(); + if (!directory) return; + + directory->Clone(result); +} + +// static +void nsCacheService::GetDiskCacheDirectory(nsIFile** result) { + nsCOMPtr<nsIFile> directory; + GetCacheBaseDirectoty(getter_AddRefs(directory)); + if (!directory) return; + + nsresult rv = directory->AppendNative("Cache"_ns); + if (NS_FAILED(rv)) return; + + directory.forget(result); +} + +// static +void nsCacheService::GetAppCacheDirectory(nsIFile** result) { + nsCOMPtr<nsIFile> directory; + GetCacheBaseDirectoty(getter_AddRefs(directory)); + if (!directory) return; + + nsresult rv = directory->AppendNative("OfflineCache"_ns); + if (NS_FAILED(rv)) return; + + directory.forget(result); +} + +void nsCacheService::LogCacheStatistics() { + uint32_t hitPercentage = 0; + double sum = (double)(mCacheHits + mCacheMisses); + if (sum != 0) { + hitPercentage = (uint32_t)((((double)mCacheHits) / sum) * 100); + } + CACHE_LOG_INFO(("\nCache Service Statistics:\n\n")); + CACHE_LOG_INFO((" TotalEntries = %d\n", mTotalEntries)); + CACHE_LOG_INFO((" Cache Hits = %d\n", mCacheHits)); + CACHE_LOG_INFO((" Cache Misses = %d\n", mCacheMisses)); + CACHE_LOG_INFO((" Cache Hit %% = %d%%\n", hitPercentage)); + CACHE_LOG_INFO((" Max Key Length = %d\n", mMaxKeyLength)); + CACHE_LOG_INFO((" Max Meta Size = %d\n", mMaxMetaSize)); + CACHE_LOG_INFO((" Max Data Size = %d\n", mMaxDataSize)); + CACHE_LOG_INFO(("\n")); + CACHE_LOG_INFO( + (" Deactivate Failures = %d\n", mDeactivateFailures)); + CACHE_LOG_INFO( + (" Deactivated Unbound Entries = %d\n", mDeactivatedUnboundEntries)); +} + +void nsCacheService::MoveOrRemoveDiskCache(nsIFile* aOldCacheDir, + nsIFile* aNewCacheDir, + const char* aCacheSubdir) { + bool same; + if (NS_FAILED(aOldCacheDir->Equals(aNewCacheDir, &same)) || same) return; + + nsCOMPtr<nsIFile> aOldCacheSubdir; + aOldCacheDir->Clone(getter_AddRefs(aOldCacheSubdir)); + + nsresult rv = aOldCacheSubdir->AppendNative(nsDependentCString(aCacheSubdir)); + if (NS_FAILED(rv)) return; + + bool exists; + if (NS_FAILED(aOldCacheSubdir->Exists(&exists)) || !exists) return; + + nsCOMPtr<nsIFile> aNewCacheSubdir; + aNewCacheDir->Clone(getter_AddRefs(aNewCacheSubdir)); + + rv = aNewCacheSubdir->AppendNative(nsDependentCString(aCacheSubdir)); + if (NS_FAILED(rv)) return; + + PathString newPath = aNewCacheSubdir->NativePath(); + + if (NS_SUCCEEDED(aNewCacheSubdir->Exists(&exists)) && !exists) { + // New cache directory does not exist, try to move the old one here + // rename needs an empty target directory + + // Make sure the parent of the target sub-dir exists + rv = aNewCacheDir->Create(nsIFile::DIRECTORY_TYPE, 0777); + if (NS_SUCCEEDED(rv) || NS_ERROR_FILE_ALREADY_EXISTS == rv) { + PathString oldPath = aOldCacheSubdir->NativePath(); +#ifdef XP_WIN + if (MoveFileW(oldPath.get(), newPath.get())) +#else + if (rename(oldPath.get(), newPath.get()) == 0) +#endif + { + return; + } + } + } + + // Delay delete by 1 minute to avoid IO thrash on startup. + nsDeleteDir::DeleteDir(aOldCacheSubdir, false, 60000); +} + +static bool IsEntryPrivate(nsCacheEntry* entry) { return entry->IsPrivate(); } + +void nsCacheService::LeavePrivateBrowsing() { + nsCacheServiceAutoLock lock; + + gService->DoomActiveEntries(IsEntryPrivate); +} diff --git a/netwerk/cache/nsCacheService.h b/netwerk/cache/nsCacheService.h new file mode 100644 index 0000000000..2f9ca28af0 --- /dev/null +++ b/netwerk/cache/nsCacheService.h @@ -0,0 +1,331 @@ +/* -*- 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/. */ + +#ifndef _nsCacheService_h_ +#define _nsCacheService_h_ + +#include "nsICacheService.h" +#include "nsCacheSession.h" +#include "nsCacheDevice.h" +#include "nsCacheEntry.h" +#include "nsThreadUtils.h" +#include "nsICacheListener.h" + +#include "prthread.h" +#include "nsString.h" +#include "nsTArray.h" +#include "nsRefPtrHashtable.h" +#include "mozilla/CondVar.h" +#include "mozilla/Mutex.h" +#include "mozilla/Telemetry.h" + +class nsCacheRequest; +class nsCacheProfilePrefObserver; +class nsOfflineCacheDevice; +class nsCacheServiceAutoLock; +class nsITimer; +class mozIStorageService; + +/****************************************************************************** + * nsNotifyDoomListener + *****************************************************************************/ + +class nsNotifyDoomListener : public mozilla::Runnable { + public: + nsNotifyDoomListener(nsICacheListener* listener, nsresult status) + : mozilla::Runnable("nsNotifyDoomListener"), + mListener(listener) // transfers reference + , + mStatus(status) {} + + NS_IMETHOD Run() override { + mListener->OnCacheEntryDoomed(mStatus); + NS_RELEASE(mListener); + return NS_OK; + } + + private: + nsICacheListener* mListener; + nsresult mStatus; +}; + +/****************************************************************************** + * nsCacheService + ******************************************************************************/ + +class nsCacheService final : public nsICacheServiceInternal { + virtual ~nsCacheService(); + + public: + NS_DECL_THREADSAFE_ISUPPORTS + NS_DECL_NSICACHESERVICE + NS_DECL_NSICACHESERVICEINTERNAL + + nsCacheService(); + + // Define a Create method to be used with a factory: + static nsresult Create(nsISupports* outer, const nsIID& iid, void** result); + + /** + * Methods called by nsCacheSession + */ + static nsresult OpenCacheEntry(nsCacheSession* session, const nsACString& key, + nsCacheAccessMode accessRequested, + bool blockingMode, nsICacheListener* listener, + nsICacheEntryDescriptor** result); + + static nsresult EvictEntriesForSession(nsCacheSession* session); + + static nsresult IsStorageEnabledForPolicy(nsCacheStoragePolicy storagePolicy, + bool* result); + + static nsresult DoomEntry(nsCacheSession* session, const nsACString& key, + nsICacheListener* listener); + + /** + * Methods called by nsCacheEntryDescriptor + */ + + static void CloseDescriptor(nsCacheEntryDescriptor* descriptor); + + static nsresult GetFileForEntry(nsCacheEntry* entry, nsIFile** result); + + static nsresult OpenInputStreamForEntry(nsCacheEntry* entry, + nsCacheAccessMode mode, + uint32_t offset, + nsIInputStream** result); + + static nsresult OpenOutputStreamForEntry(nsCacheEntry* entry, + nsCacheAccessMode mode, + uint32_t offset, + nsIOutputStream** result); + + static nsresult OnDataSizeChange(nsCacheEntry* entry, int32_t deltaSize); + + static nsresult SetCacheElement(nsCacheEntry* entry, nsISupports* element); + + static nsresult ValidateEntry(nsCacheEntry* entry); + + static int32_t CacheCompressionLevel(); + + static bool GetClearingEntries(); + + static void GetCacheBaseDirectoty(nsIFile** result); + static void GetDiskCacheDirectory(nsIFile** result); + static void GetAppCacheDirectory(nsIFile** result); + + /** + * Methods called by any cache classes + */ + + static nsCacheService* GlobalInstance() { return gService; } + + static nsresult DoomEntry(nsCacheEntry* entry); + + static bool IsStorageEnabledForPolicy_Locked(nsCacheStoragePolicy policy); + + /** + * Methods called by nsApplicationCacheService + */ + + nsresult GetOfflineDevice(nsOfflineCacheDevice** aDevice); + + /** + * Creates an offline cache device that works over a specific profile + * directory. A tool to preload offline cache for profiles different from the + * current application's profile directory. + */ + nsresult GetCustomOfflineDevice(nsIFile* aProfileDir, int32_t aQuota, + nsOfflineCacheDevice** aDevice); + + // This method may be called to release an object while the cache service + // lock is being held. If a non-null target is specified and the target + // does not correspond to the current thread, then the release will be + // proxied to the specified target. Otherwise, the object will be added to + // the list of objects to be released when the cache service is unlocked. + static void ReleaseObject_Locked(nsISupports* object, + nsIEventTarget* target = nullptr); + + static nsresult DispatchToCacheIOThread(nsIRunnable* event); + + // Calling this method will block the calling thread until all pending + // events on the cache-io thread has finished. The calling thread must + // hold the cache-lock + static nsresult SyncWithCacheIOThread(); + + /** + * Methods called by nsCacheProfilePrefObserver + */ + static void OnProfileShutdown(); + static void OnProfileChanged(); + + static void SetOfflineCacheEnabled(bool enabled); + // Sets the offline cache capacity (in kilobytes) + static void SetOfflineCacheCapacity(int32_t capacity); + + static void MoveOrRemoveDiskCache(nsIFile* aOldCacheDir, + nsIFile* aNewCacheDir, + const char* aCacheSubdir); + + nsresult Init(); + void Shutdown(); + + static bool IsInitialized() { + if (!gService) { + return false; + } + return gService->mInitialized; + } + + static void AssertOwnsLock() { gService->mLock.AssertCurrentThreadOwns(); } + + static void LeavePrivateBrowsing(); + bool IsDoomListEmpty(); + + typedef bool (*DoomCheckFn)(nsCacheEntry* entry); + + // Accessors to the disabled functionality + nsresult CreateSessionInternal(const char* clientID, + nsCacheStoragePolicy storagePolicy, + bool streamBased, nsICacheSession** result); + nsresult VisitEntriesInternal(nsICacheVisitor* visitor); + nsresult EvictEntriesInternal(nsCacheStoragePolicy storagePolicy); + + private: + friend class nsCacheServiceAutoLock; + friend class nsOfflineCacheDevice; + friend class nsProcessRequestEvent; + friend class nsBlockOnCacheThreadEvent; + friend class nsDoomEvent; + friend class nsAsyncDoomEvent; + friend class nsCacheEntryDescriptor; + + /** + * Internal Methods + */ + + static void Lock(); + static void Lock(::mozilla::Telemetry::HistogramID mainThreadLockerID); + static void Unlock(); + void LockAcquired(); + void LockReleased(); + + nsresult CreateDiskDevice(); + nsresult CreateOfflineDevice(); + nsresult CreateCustomOfflineDevice(nsIFile* aProfileDir, int32_t aQuota, + nsOfflineCacheDevice** aDevice); + nsresult CreateMemoryDevice(); + + nsresult RemoveCustomOfflineDevice(nsOfflineCacheDevice* aDevice); + + nsresult CreateRequest(nsCacheSession* session, const nsACString& clientKey, + nsCacheAccessMode accessRequested, bool blockingMode, + nsICacheListener* listener, nsCacheRequest** request); + + nsresult DoomEntry_Internal(nsCacheEntry* entry, + bool doProcessPendingRequests); + + nsresult EvictEntriesForClient(const char* clientID, + nsCacheStoragePolicy storagePolicy); + + // Notifies request listener asynchronously on the request's thread, and + // releases the descriptor on the request's thread. If this method fails, + // the descriptor is not released. + nsresult NotifyListener(nsCacheRequest* request, + nsICacheEntryDescriptor* descriptor, + nsCacheAccessMode accessGranted, nsresult error); + + nsresult ActivateEntry(nsCacheRequest* request, nsCacheEntry** entry, + nsCacheEntry** doomedEntry); + + nsCacheDevice* EnsureEntryHasDevice(nsCacheEntry* entry); + + nsCacheEntry* SearchCacheDevices(nsCString* key, nsCacheStoragePolicy policy, + bool* collision); + + void DeactivateEntry(nsCacheEntry* entry); + + nsresult ProcessRequest(nsCacheRequest* request, + bool calledFromOpenCacheEntry, + nsICacheEntryDescriptor** result); + + nsresult ProcessPendingRequests(nsCacheEntry* entry); + + void ClearDoomList(void); + void DoomActiveEntries(DoomCheckFn check); + void CloseAllStreams(); + void FireClearNetworkCacheStoredAnywhereNotification(); + + void LogCacheStatistics(); + + /** + * Data Members + */ + + static nsCacheService* gService; // there can be only one... + + nsCOMPtr<mozIStorageService> mStorageService; + + nsCacheProfilePrefObserver* mObserver; + + mozilla::Mutex mLock; + mozilla::CondVar mCondVar; + bool mNotified; + + mozilla::Mutex mTimeStampLock; + mozilla::TimeStamp mLockAcquiredTimeStamp; + + nsCOMPtr<nsIThread> mCacheIOThread; + + nsTArray<nsISupports*> mDoomedObjects; + + bool mInitialized; + bool mClearingEntries; + + bool mEnableOfflineDevice; + + nsOfflineCacheDevice* mOfflineDevice; + + nsRefPtrHashtable<nsStringHashKey, nsOfflineCacheDevice> + mCustomOfflineDevices; + + nsCacheEntryHashTable mActiveEntries; + PRCList mDoomedEntries; + + // stats + + uint32_t mTotalEntries; + uint32_t mCacheHits; + uint32_t mCacheMisses; + uint32_t mMaxKeyLength; + uint32_t mMaxDataSize; + uint32_t mMaxMetaSize; + + // Unexpected error totals + uint32_t mDeactivateFailures; + uint32_t mDeactivatedUnboundEntries; +}; + +/****************************************************************************** + * nsCacheServiceAutoLock + ******************************************************************************/ + +#define LOCK_TELEM(x) \ + (::mozilla::Telemetry::CACHE_SERVICE_LOCK_WAIT_MAINTHREAD_##x) + +// Instantiate this class to acquire the cache service lock for a particular +// execution scope. +class nsCacheServiceAutoLock { + public: + nsCacheServiceAutoLock() { nsCacheService::Lock(); } + explicit nsCacheServiceAutoLock( + mozilla::Telemetry::HistogramID mainThreadLockerID) { + nsCacheService::Lock(mainThreadLockerID); + } + ~nsCacheServiceAutoLock() { nsCacheService::Unlock(); } +}; + +#endif // _nsCacheService_h_ diff --git a/netwerk/cache/nsCacheSession.cpp b/netwerk/cache/nsCacheSession.cpp new file mode 100644 index 0000000000..3e4a1f92da --- /dev/null +++ b/netwerk/cache/nsCacheSession.cpp @@ -0,0 +1,121 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- + * + * 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 "nsCacheSession.h" +#include "nsCacheService.h" +#include "nsCRT.h" +#include "nsThreadUtils.h" + +NS_IMPL_ISUPPORTS(nsCacheSession, nsICacheSession) + +nsCacheSession::nsCacheSession(const char* clientID, + nsCacheStoragePolicy storagePolicy, + bool streamBased) + : mClientID(clientID), mInfo(0) { + SetStoragePolicy(storagePolicy); + + if (streamBased) + MarkStreamBased(); + else + SetStoragePolicy(nsICache::STORE_IN_MEMORY); + + MarkPublic(); + + MarkDoomEntriesIfExpired(); +} + +nsCacheSession::~nsCacheSession() { + /* destructor code */ + // notify service we are going away? +} + +NS_IMETHODIMP nsCacheSession::GetDoomEntriesIfExpired(bool* result) { + NS_ENSURE_ARG_POINTER(result); + *result = WillDoomEntriesIfExpired(); + return NS_OK; +} + +NS_IMETHODIMP nsCacheSession::SetProfileDirectory(nsIFile* profileDir) { + if (StoragePolicy() != nsICache::STORE_OFFLINE && profileDir) { + // Profile directory override is currently implemented only for + // offline cache. This is an early failure to prevent the request + // being processed before it would fail later because of inability + // to assign a cache base dir. + return NS_ERROR_UNEXPECTED; + } + + mProfileDir = profileDir; + return NS_OK; +} + +NS_IMETHODIMP nsCacheSession::GetProfileDirectory(nsIFile** profileDir) { + *profileDir = do_AddRef(mProfileDir).take(); + return NS_OK; +} + +NS_IMETHODIMP nsCacheSession::SetDoomEntriesIfExpired( + bool doomEntriesIfExpired) { + if (doomEntriesIfExpired) + MarkDoomEntriesIfExpired(); + else + ClearDoomEntriesIfExpired(); + return NS_OK; +} + +NS_IMETHODIMP +nsCacheSession::OpenCacheEntry(const nsACString& key, + nsCacheAccessMode accessRequested, + bool blockingMode, + nsICacheEntryDescriptor** result) { + nsresult rv; + + if (NS_IsMainThread()) + rv = NS_ERROR_NOT_AVAILABLE; + else + rv = + nsCacheService::OpenCacheEntry(this, key, accessRequested, blockingMode, + nullptr, // no listener + result); + return rv; +} + +NS_IMETHODIMP nsCacheSession::AsyncOpenCacheEntry( + const nsACString& key, nsCacheAccessMode accessRequested, + nsICacheListener* listener, bool noWait) { + nsresult rv; + rv = nsCacheService::OpenCacheEntry(this, key, accessRequested, !noWait, + listener, + nullptr); // no result + + if (rv == NS_ERROR_CACHE_WAIT_FOR_VALIDATION) rv = NS_OK; + return rv; +} + +NS_IMETHODIMP nsCacheSession::EvictEntries() { + return nsCacheService::EvictEntriesForSession(this); +} + +NS_IMETHODIMP nsCacheSession::IsStorageEnabled(bool* result) { + return nsCacheService::IsStorageEnabledForPolicy(StoragePolicy(), result); +} + +NS_IMETHODIMP nsCacheSession::DoomEntry(const nsACString& key, + nsICacheListener* listener) { + return nsCacheService::DoomEntry(this, key, listener); +} + +NS_IMETHODIMP nsCacheSession::GetIsPrivate(bool* aPrivate) { + *aPrivate = IsPrivate(); + return NS_OK; +} + +NS_IMETHODIMP nsCacheSession::SetIsPrivate(bool aPrivate) { + if (aPrivate) + MarkPrivate(); + else + MarkPublic(); + return NS_OK; +} diff --git a/netwerk/cache/nsCacheSession.h b/netwerk/cache/nsCacheSession.h new file mode 100644 index 0000000000..59bb748231 --- /dev/null +++ b/netwerk/cache/nsCacheSession.h @@ -0,0 +1,67 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- + * + * 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/. */ + +#ifndef _nsCacheSession_h_ +#define _nsCacheSession_h_ + +#include "nspr.h" +#include "nsError.h" +#include "nsCOMPtr.h" +#include "nsICacheSession.h" +#include "nsIFile.h" +#include "nsString.h" + +class nsCacheSession : public nsICacheSession { + virtual ~nsCacheSession(); + + public: + NS_DECL_ISUPPORTS + NS_DECL_NSICACHESESSION + + nsCacheSession(const char* clientID, nsCacheStoragePolicy storagePolicy, + bool streamBased); + + nsCString* ClientID() { return &mClientID; } + + enum SessionInfo { + eStoragePolicyMask = 0x000000FF, + eStreamBasedMask = 0x00000100, + eDoomEntriesIfExpiredMask = 0x00001000, + ePrivateMask = 0x00010000 + }; + + void MarkStreamBased() { mInfo |= eStreamBasedMask; } + void ClearStreamBased() { mInfo &= ~eStreamBasedMask; } + bool IsStreamBased() { return (mInfo & eStreamBasedMask) != 0; } + + void MarkDoomEntriesIfExpired() { mInfo |= eDoomEntriesIfExpiredMask; } + void ClearDoomEntriesIfExpired() { mInfo &= ~eDoomEntriesIfExpiredMask; } + bool WillDoomEntriesIfExpired() { + return (0 != (mInfo & eDoomEntriesIfExpiredMask)); + } + + void MarkPrivate() { mInfo |= ePrivateMask; } + void MarkPublic() { mInfo &= ~ePrivateMask; } + bool IsPrivate() { return (mInfo & ePrivateMask) != 0; } + nsCacheStoragePolicy StoragePolicy() { + return (nsCacheStoragePolicy)(mInfo & eStoragePolicyMask); + } + + void SetStoragePolicy(nsCacheStoragePolicy policy) { + NS_ASSERTION(policy <= 0xFF, "too many bits in nsCacheStoragePolicy"); + mInfo &= ~eStoragePolicyMask; // clear storage policy bits + mInfo |= policy; + } + + nsIFile* ProfileDir() { return mProfileDir; } + + private: + nsCString mClientID; + uint32_t mInfo; + nsCOMPtr<nsIFile> mProfileDir; +}; + +#endif // _nsCacheSession_h_ diff --git a/netwerk/cache/nsCacheUtils.cpp b/netwerk/cache/nsCacheUtils.cpp new file mode 100644 index 0000000000..88bcabce12 --- /dev/null +++ b/netwerk/cache/nsCacheUtils.cpp @@ -0,0 +1,78 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim:set ts=2 sw=2 sts=2 et cindent: */ +/* 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 "nsCache.h" +#include "nsCacheUtils.h" +#include "nsThreadUtils.h" + +using namespace mozilla; + +class nsDestroyThreadEvent : public Runnable { + public: + explicit nsDestroyThreadEvent(nsIThread* thread) + : mozilla::Runnable("nsDestroyThreadEvent"), mThread(thread) {} + NS_IMETHOD Run() override { + mThread->Shutdown(); + return NS_OK; + } + + private: + nsCOMPtr<nsIThread> mThread; +}; + +nsShutdownThread::nsShutdownThread(nsIThread* aThread) + : mozilla::Runnable("nsShutdownThread"), + mMonitor("nsShutdownThread.mMonitor"), + mShuttingDown(false), + mThread(aThread) {} + +nsresult nsShutdownThread::Shutdown(nsIThread* aThread) { + nsresult rv; + RefPtr<nsDestroyThreadEvent> ev = new nsDestroyThreadEvent(aThread); + rv = NS_DispatchToMainThread(ev); + if (NS_FAILED(rv)) { + NS_WARNING("Dispatching event in nsShutdownThread::Shutdown failed!"); + } + return rv; +} + +nsresult nsShutdownThread::BlockingShutdown(nsIThread* aThread) { + nsresult rv; + + RefPtr<nsShutdownThread> st = new nsShutdownThread(aThread); + nsCOMPtr<nsIThread> workerThread; + + rv = NS_NewNamedThread("thread shutdown", getter_AddRefs(workerThread)); + if (NS_FAILED(rv)) { + NS_WARNING("Can't create nsShutDownThread worker thread!"); + return rv; + } + + { + MonitorAutoLock mon(st->mMonitor); + rv = workerThread->Dispatch(st, NS_DISPATCH_NORMAL); + if (NS_FAILED(rv)) { + NS_WARNING( + "Dispatching event in nsShutdownThread::BlockingShutdown failed!"); + } else { + st->mShuttingDown = true; + while (st->mShuttingDown) { + mon.Wait(); + } + } + } + + return Shutdown(workerThread); +} + +NS_IMETHODIMP +nsShutdownThread::Run() { + MonitorAutoLock mon(mMonitor); + mThread->Shutdown(); + mShuttingDown = false; + mon.Notify(); + return NS_OK; +} diff --git a/netwerk/cache/nsCacheUtils.h b/netwerk/cache/nsCacheUtils.h new file mode 100644 index 0000000000..71f3056f89 --- /dev/null +++ b/netwerk/cache/nsCacheUtils.h @@ -0,0 +1,44 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set sw=2 ts=8 et 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/. */ + +#ifndef _nsCacheUtils_h_ +#define _nsCacheUtils_h_ + +#include "nsThreadUtils.h" +#include "nsCOMPtr.h" +#include "mozilla/Monitor.h" + +class nsIThread; + +/** + * A class with utility methods for shutting down nsIThreads easily. + */ +class nsShutdownThread : public mozilla::Runnable { + public: + explicit nsShutdownThread(nsIThread* aThread); + ~nsShutdownThread() = default; + + NS_IMETHOD Run() override; + + /** + * Shutdown ensures that aThread->Shutdown() is called on a main thread + */ + static nsresult Shutdown(nsIThread* aThread); + + /** + * BlockingShutdown ensures that by the time it returns, aThread->Shutdown() + * has been called and no pending events have been processed on the current + * thread. + */ + static nsresult BlockingShutdown(nsIThread* aThread); + + private: + mozilla::Monitor mMonitor; + bool mShuttingDown; + nsCOMPtr<nsIThread> mThread; +}; + +#endif diff --git a/netwerk/cache/nsDeleteDir.cpp b/netwerk/cache/nsDeleteDir.cpp new file mode 100644 index 0000000000..f99896b721 --- /dev/null +++ b/netwerk/cache/nsDeleteDir.cpp @@ -0,0 +1,362 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim:set ts=2 sw=2 sts=2 et cindent: */ +/* 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 "nsDeleteDir.h" +#include "nsIFile.h" +#include "nsString.h" +#include "mozilla/Telemetry.h" +#include "nsITimer.h" +#include "nsThreadUtils.h" +#include "nsISupportsPriority.h" +#include "nsCacheUtils.h" +#include "prtime.h" +#include <time.h> + +using namespace mozilla; + +class nsBlockOnBackgroundThreadEvent : public Runnable { + public: + nsBlockOnBackgroundThreadEvent() + : mozilla::Runnable("nsBlockOnBackgroundThreadEvent") {} + NS_IMETHOD Run() override { + MutexAutoLock lock(nsDeleteDir::gInstance->mLock); + nsDeleteDir::gInstance->mNotified = true; + nsDeleteDir::gInstance->mCondVar.Notify(); + return NS_OK; + } +}; + +nsDeleteDir* nsDeleteDir::gInstance = nullptr; + +nsDeleteDir::nsDeleteDir() + : mLock("nsDeleteDir.mLock"), + mCondVar(mLock, "nsDeleteDir.mCondVar"), + mNotified(false), + mShutdownPending(false), + mStopDeleting(false) { + NS_ASSERTION(gInstance == nullptr, "multiple nsCacheService instances!"); +} + +nsDeleteDir::~nsDeleteDir() { gInstance = nullptr; } + +nsresult nsDeleteDir::Init() { + if (gInstance) return NS_ERROR_ALREADY_INITIALIZED; + + gInstance = new nsDeleteDir(); + return NS_OK; +} + +nsresult nsDeleteDir::Shutdown(bool finishDeleting) { + if (!gInstance) return NS_ERROR_NOT_INITIALIZED; + + nsCOMArray<nsIFile> dirsToRemove; + nsCOMPtr<nsISerialEventTarget> eventTarget; + { + MutexAutoLock lock(gInstance->mLock); + NS_ASSERTION(!gInstance->mShutdownPending, + "Unexpected state in nsDeleteDir::Shutdown()"); + gInstance->mShutdownPending = true; + + if (!finishDeleting) gInstance->mStopDeleting = true; + + // remove all pending timers + for (int32_t i = gInstance->mTimers.Count(); i > 0; i--) { + nsCOMPtr<nsITimer> timer = gInstance->mTimers[i - 1]; + gInstance->mTimers.RemoveObjectAt(i - 1); + + nsCOMArray<nsIFile>* arg; + timer->GetClosure((reinterpret_cast<void**>(&arg))); + timer->Cancel(); + + if (finishDeleting) dirsToRemove.AppendObjects(*arg); + + // delete argument passed to the timer + delete arg; + } + + eventTarget.swap(gInstance->mBackgroundET); + if (eventTarget) { + // dispatch event and wait for it to run and notify us, so we know thread + // has completed all work and can be shutdown + nsCOMPtr<nsIRunnable> event = new nsBlockOnBackgroundThreadEvent(); + nsresult rv = eventTarget->Dispatch(event, NS_DISPATCH_EVENT_MAY_BLOCK); + if (NS_FAILED(rv)) { + NS_WARNING("Failed dispatching block-event"); + return NS_ERROR_UNEXPECTED; + } + + gInstance->mNotified = false; + while (!gInstance->mNotified) { + gInstance->mCondVar.Wait(); + } + } + } + + delete gInstance; + + for (int32_t i = 0; i < dirsToRemove.Count(); i++) + dirsToRemove[i]->Remove(true); + + return NS_OK; +} + +nsresult nsDeleteDir::InitThread() { + if (mBackgroundET) return NS_OK; + + nsresult rv = NS_CreateBackgroundTaskQueue("Cache Deleter", + getter_AddRefs(mBackgroundET)); + if (NS_FAILED(rv)) { + NS_WARNING("Can't create background task queue"); + return rv; + } + + return NS_OK; +} + +void nsDeleteDir::DestroyThread() { + if (!mBackgroundET) return; + + if (mTimers.Count()) + // more work to do, so don't delete thread. + return; + + mBackgroundET = nullptr; +} + +void nsDeleteDir::TimerCallback(nsITimer* aTimer, void* arg) { + Telemetry::AutoTimer<Telemetry::NETWORK_DISK_CACHE_DELETEDIR> timer; + { + MutexAutoLock lock(gInstance->mLock); + + int32_t idx = gInstance->mTimers.IndexOf(aTimer); + if (idx == -1) { + // Timer was canceled and removed during shutdown. + return; + } + + gInstance->mTimers.RemoveObjectAt(idx); + } + + UniquePtr<nsCOMArray<nsIFile>> dirList; + dirList.reset(static_cast<nsCOMArray<nsIFile>*>(arg)); + + bool shuttingDown = false; + + // Intentional extra braces to control variable sope. + { + // Low IO priority can only be set when running in the context of the + // current thread. So this shouldn't be moved to where we set the priority + // of the Cache deleter thread using the nsThread's NSPR priority constants. + nsAutoLowPriorityIO autoLowPriority; + for (int32_t i = 0; i < dirList->Count() && !shuttingDown; i++) { + gInstance->RemoveDir((*dirList)[i], &shuttingDown); + } + } + + { + MutexAutoLock lock(gInstance->mLock); + gInstance->DestroyThread(); + } +} + +nsresult nsDeleteDir::DeleteDir(nsIFile* dirIn, bool moveToTrash, + uint32_t delay) { + Telemetry::AutoTimer<Telemetry::NETWORK_DISK_CACHE_TRASHRENAME> timer; + + if (!gInstance) return NS_ERROR_NOT_INITIALIZED; + + nsresult rv; + nsCOMPtr<nsIFile> trash, dir; + + // Need to make a clone of this since we don't want to modify the input + // file object. + rv = dirIn->Clone(getter_AddRefs(dir)); + if (NS_FAILED(rv)) return rv; + + if (moveToTrash) { + rv = GetTrashDir(dir, &trash); + if (NS_FAILED(rv)) return rv; + nsAutoCString origLeaf; + rv = trash->GetNativeLeafName(origLeaf); + if (NS_FAILED(rv)) return rv; + + // Append random number to the trash directory and check if it exists. + srand(static_cast<unsigned>(PR_Now())); + nsAutoCString leaf; + for (int32_t i = 0; i < 10; i++) { + leaf = origLeaf; + leaf.AppendInt(rand()); + rv = trash->SetNativeLeafName(leaf); + if (NS_FAILED(rv)) return rv; + + bool exists; + if (NS_SUCCEEDED(trash->Exists(&exists)) && !exists) { + break; + } + + leaf.Truncate(); + } + + // Fail if we didn't find unused trash directory within the limit + if (!leaf.Length()) return NS_ERROR_FAILURE; + +#if defined(MOZ_WIDGET_ANDROID) + nsCOMPtr<nsIFile> parent; + rv = trash->GetParent(getter_AddRefs(parent)); + if (NS_FAILED(rv)) return rv; + rv = dir->MoveToNative(parent, leaf); +#else + // Important: must rename directory w/o changing parent directory: else on + // NTFS we'll wait (with cache lock) while nsIFile's ACL reset walks file + // tree: was hanging GUI for *minutes* on large cache dirs. + rv = dir->MoveToNative(nullptr, leaf); +#endif + if (NS_FAILED(rv)) return rv; + } else { + // we want to pass a clone of the original off to the worker thread. + trash.swap(dir); + } + + UniquePtr<nsCOMArray<nsIFile>> arg(new nsCOMArray<nsIFile>); + arg->AppendObject(trash); + + rv = gInstance->PostTimer(arg.get(), delay); + if (NS_FAILED(rv)) return rv; + + Unused << arg.release(); + return NS_OK; +} + +nsresult nsDeleteDir::GetTrashDir(nsIFile* target, nsCOMPtr<nsIFile>* result) { + nsresult rv; +#if defined(MOZ_WIDGET_ANDROID) + // Try to use the app cache folder for cache trash on Android + char* cachePath = getenv("CACHE_DIRECTORY"); + if (cachePath) { + rv = NS_NewNativeLocalFile(nsDependentCString(cachePath), true, + getter_AddRefs(*result)); + if (NS_FAILED(rv)) return rv; + + // Add a sub folder with the cache folder name + nsAutoCString leaf; + rv = target->GetNativeLeafName(leaf); + (*result)->AppendNative(leaf); + } else +#endif + { + rv = target->Clone(getter_AddRefs(*result)); + } + if (NS_FAILED(rv)) return rv; + + nsAutoCString leaf; + rv = (*result)->GetNativeLeafName(leaf); + if (NS_FAILED(rv)) return rv; + leaf.AppendLiteral(".Trash"); + + return (*result)->SetNativeLeafName(leaf); +} + +nsresult nsDeleteDir::RemoveOldTrashes(nsIFile* cacheDir) { + if (!gInstance) return NS_ERROR_NOT_INITIALIZED; + + nsresult rv; + + nsCOMPtr<nsIFile> trash; + rv = GetTrashDir(cacheDir, &trash); + if (NS_FAILED(rv)) return rv; + + nsAutoString trashName; + rv = trash->GetLeafName(trashName); + if (NS_FAILED(rv)) return rv; + + nsCOMPtr<nsIFile> parent; +#if defined(MOZ_WIDGET_ANDROID) + rv = trash->GetParent(getter_AddRefs(parent)); +#else + rv = cacheDir->GetParent(getter_AddRefs(parent)); +#endif + if (NS_FAILED(rv)) return rv; + + nsCOMPtr<nsIDirectoryEnumerator> iter; + rv = parent->GetDirectoryEntries(getter_AddRefs(iter)); + if (NS_FAILED(rv)) return rv; + + UniquePtr<nsCOMArray<nsIFile>> dirList; + + nsCOMPtr<nsIFile> file; + while (NS_SUCCEEDED(iter->GetNextFile(getter_AddRefs(file))) && file) { + nsAutoString leafName; + rv = file->GetLeafName(leafName); + if (NS_FAILED(rv)) continue; + + // match all names that begin with the trash name (i.e. "Cache.Trash") + if (Substring(leafName, 0, trashName.Length()).Equals(trashName)) { + if (!dirList) dirList = MakeUnique<nsCOMArray<nsIFile>>(); + dirList->AppendObject(file); + } + } + + if (dirList) { + rv = gInstance->PostTimer(dirList.get(), 90000); + if (NS_FAILED(rv)) return rv; + + Unused << dirList.release(); + } + + return NS_OK; +} + +nsresult nsDeleteDir::PostTimer(void* arg, uint32_t delay) { + nsresult rv; + + MutexAutoLock lock(mLock); + + rv = InitThread(); + if (NS_FAILED(rv)) return rv; + + nsCOMPtr<nsITimer> timer; + rv = NS_NewTimerWithFuncCallback(getter_AddRefs(timer), TimerCallback, arg, + delay, nsITimer::TYPE_ONE_SHOT, + "nsDeleteDir::PostTimer", mBackgroundET); + if (NS_FAILED(rv)) return rv; + + mTimers.AppendObject(timer); + return NS_OK; +} + +nsresult nsDeleteDir::RemoveDir(nsIFile* file, bool* stopDeleting) { + nsresult rv; + bool isLink; + + rv = file->IsSymlink(&isLink); + if (NS_FAILED(rv) || isLink) return NS_ERROR_UNEXPECTED; + + bool isDir; + rv = file->IsDirectory(&isDir); + if (NS_FAILED(rv)) return rv; + + if (isDir) { + nsCOMPtr<nsIDirectoryEnumerator> iter; + rv = file->GetDirectoryEntries(getter_AddRefs(iter)); + if (NS_FAILED(rv)) return rv; + + nsCOMPtr<nsIFile> file2; + while (NS_SUCCEEDED(iter->GetNextFile(getter_AddRefs(file2))) && file2) { + RemoveDir(file2, stopDeleting); + // No check for errors to remove as much as possible + + if (*stopDeleting) return NS_OK; + } + } + + file->Remove(false); + // No check for errors to remove as much as possible + + MutexAutoLock lock(mLock); + if (mStopDeleting) *stopDeleting = true; + + return NS_OK; +} diff --git a/netwerk/cache/nsDeleteDir.h b/netwerk/cache/nsDeleteDir.h new file mode 100644 index 0000000000..cf6de26dde --- /dev/null +++ b/netwerk/cache/nsDeleteDir.h @@ -0,0 +1,79 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim:set ts=2 sw=2 sts=2 et cindent: */ +/* 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/. */ + +#ifndef nsDeleteDir_h__ +#define nsDeleteDir_h__ + +#include "nsCOMPtr.h" +#include "nsCOMArray.h" +#include "mozilla/Mutex.h" +#include "mozilla/CondVar.h" + +class nsIFile; +class nsISerialEventTarget; +class nsITimer; + +class nsDeleteDir { + public: + nsDeleteDir(); + ~nsDeleteDir(); + + static nsresult Init(); + static nsresult Shutdown(bool finishDeleting); + + /** + * This routine attempts to delete a directory that may contain some files + * that are still in use. This latter point is only an issue on Windows and + * a few other systems. + * + * If the moveToTrash parameter is true we first rename the given directory + * "foo.Trash123" (where "foo" is the original directory name, and "123" is + * a random number, in order to support multiple concurrent deletes). The + * directory is then deleted, file-by-file, on a background thread. + * + * If the moveToTrash parameter is false, then the given directory is deleted + * directly. + * + * If 'delay' is non-zero, the directory will not be deleted until the + * specified number of milliseconds have passed. (The directory is still + * renamed immediately if 'moveToTrash' is passed, so upon return it is safe + * to create a directory with the same name). + */ + static nsresult DeleteDir(nsIFile* dir, bool moveToTrash, uint32_t delay = 0); + + /** + * Returns the trash directory corresponding to the given directory. + */ + static nsresult GetTrashDir(nsIFile* dir, nsCOMPtr<nsIFile>* result); + + /** + * Remove all trashes left from previous run. This function does nothing when + * called second and more times. + */ + static nsresult RemoveOldTrashes(nsIFile* cacheDir); + + static void TimerCallback(nsITimer* aTimer, void* arg); + + private: + friend class nsBlockOnBackgroundThreadEvent; + friend class nsDestroyThreadEvent; + + nsresult InitThread(); + void DestroyThread(); + nsresult PostTimer(void* arg, uint32_t delay); + nsresult RemoveDir(nsIFile* file, bool* stopDeleting); + + static nsDeleteDir* gInstance; + mozilla::Mutex mLock; + mozilla::CondVar mCondVar; + bool mNotified; + nsCOMArray<nsITimer> mTimers; + nsCOMPtr<nsISerialEventTarget> mBackgroundET; + bool mShutdownPending; + bool mStopDeleting; +}; + +#endif // nsDeleteDir_h__ diff --git a/netwerk/cache/nsDiskCache.h b/netwerk/cache/nsDiskCache.h new file mode 100644 index 0000000000..e01860b7bf --- /dev/null +++ b/netwerk/cache/nsDiskCache.h @@ -0,0 +1,72 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- + * + * 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/. */ + +#ifndef _nsDiskCache_h_ +#define _nsDiskCache_h_ + +#include "nsCacheEntry.h" + +#ifdef XP_WIN +# include <winsock.h> // for htonl/ntohl +#endif + +class nsDiskCache { + public: + enum { + kCurrentVersion = + 0x00010013 // format = 16 bits major version/16 bits minor version + }; + + enum { kData, kMetaData }; + + // Stores the reason why the cache is corrupt. + // Note: I'm only listing the enum values explicitly for easy mapping when + // looking at telemetry data. + enum CorruptCacheInfo { + kNotCorrupt = 0, + kInvalidArgPointer = 1, + kUnexpectedError = 2, + kOpenCacheMapError = 3, + kBlockFilesShouldNotExist = 4, + kOutOfMemory = 5, + kCreateCacheSubdirectories = 6, + kBlockFilesShouldExist = 7, + kHeaderSizeNotRead = 8, + kHeaderIsDirty = 9, + kVersionMismatch = 10, + kRecordsIncomplete = 11, + kHeaderIncomplete = 12, + kNotEnoughToRead = 13, + kEntryCountIncorrect = 14, + kCouldNotGetBlockFileForIndex = 15, + kCouldNotCreateBlockFile = 16, + kBlockFileSizeError = 17, + kBlockFileBitMapWriteError = 18, + kBlockFileSizeLessThanBitMap = 19, + kBlockFileBitMapReadError = 20, + kBlockFileEstimatedSizeError = 21, + kFlushHeaderError = 22, + kCacheCleanFilePathError = 23, + kCacheCleanOpenFileError = 24, + kCacheCleanTimerError = 25 + }; + + // Parameter initval initializes internal state of hash function. Hash values + // are different for the same text when different initval is used. It can be + // any random number. + // + // It can be used for generating 64-bit hash value: + // (uint64_t(Hash(key, initval1)) << 32) | Hash(key, initval2) + // + // It can be also used to hash multiple strings: + // h = Hash(string1, 0); + // h = Hash(string2, h); + // ... + static PLDHashNumber Hash(const char* key, PLDHashNumber initval = 0); + static nsresult Truncate(PRFileDesc* fd, uint32_t newEOF); +}; + +#endif // _nsDiskCache_h_ diff --git a/netwerk/cache/nsDiskCacheDeviceSQL.cpp b/netwerk/cache/nsDiskCacheDeviceSQL.cpp new file mode 100644 index 0000000000..b2523a4d3f --- /dev/null +++ b/netwerk/cache/nsDiskCacheDeviceSQL.cpp @@ -0,0 +1,2608 @@ +/* -*- Mode: C++; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim:set ts=2 sw=2 sts=2 et cin: */ +/* 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 <inttypes.h> + +#include "mozilla/ArrayUtils.h" +#include "mozilla/Attributes.h" +#include "mozilla/Sprintf.h" +#include "mozilla/ThreadLocal.h" + +#include "nsCache.h" +#include "nsDiskCache.h" +#include "nsDiskCacheDeviceSQL.h" +#include "nsCacheService.h" +#include "nsApplicationCache.h" +#include "../cache2/CacheHashUtils.h" + +#include "nsNetCID.h" +#include "nsNetUtil.h" +#include "nsIURI.h" +#include "nsEscape.h" +#include "nsIPrefBranch.h" +#include "nsString.h" +#include "nsPrintfCString.h" +#include "nsCRT.h" +#include "nsArrayUtils.h" +#include "nsIArray.h" +#include "nsIVariant.h" +#include "nsILoadContextInfo.h" +#include "nsThreadUtils.h" +#include "nsISerializable.h" +#include "nsIInputStream.h" +#include "nsIOutputStream.h" +#include "nsSerializationHelper.h" +#include "nsMemory.h" + +#include "mozIStorageService.h" +#include "mozIStorageStatement.h" +#include "mozIStorageFunction.h" +#include "mozStorageHelper.h" + +#include "nsICacheVisitor.h" +#include "nsISeekableStream.h" + +#include "mozilla/Telemetry.h" + +#include "mozilla/storage.h" +#include "nsVariant.h" +#include "mozilla/BasePrincipal.h" + +using namespace mozilla; +using namespace mozilla::storage; +using mozilla::OriginAttributes; + +static const char OFFLINE_CACHE_DEVICE_ID[] = {"offline"}; + +#define LOG(args) CACHE_LOG_DEBUG(args) + +static uint32_t gNextTemporaryClientID = 0; + +/***************************************************************************** + * helpers + */ + +static nsresult EnsureDir(nsIFile* dir) { + bool exists; + nsresult rv = dir->Exists(&exists); + if (NS_SUCCEEDED(rv) && !exists) + rv = dir->Create(nsIFile::DIRECTORY_TYPE, 0700); + return rv; +} + +static bool DecomposeCacheEntryKey(const nsCString* fullKey, const char** cid, + const char** key, nsCString& buf) { + buf = *fullKey; + + int32_t colon = buf.FindChar(':'); + if (colon == kNotFound) { + NS_ERROR("Invalid key"); + return false; + } + buf.SetCharAt('\0', colon); + + *cid = buf.get(); + *key = buf.get() + colon + 1; + + return true; +} + +class AutoResetStatement { + public: + explicit AutoResetStatement(mozIStorageStatement* s) : mStatement(s) {} + ~AutoResetStatement() { mStatement->Reset(); } + mozIStorageStatement* operator->() MOZ_NO_ADDREF_RELEASE_ON_RETURN { + return mStatement; + } + + private: + mozIStorageStatement* mStatement; +}; + +class EvictionObserver { + public: + EvictionObserver(mozIStorageConnection* db, + nsOfflineCacheEvictionFunction* evictionFunction) + : mDB(db), mEvictionFunction(evictionFunction) { + mEvictionFunction->Init(); + mDB->ExecuteSimpleSQL( + nsLiteralCString("CREATE TEMP TRIGGER cache_on_delete BEFORE DELETE" + " ON moz_cache FOR EACH ROW BEGIN SELECT" + " cache_eviction_observer(" + " OLD.ClientID, OLD.key, OLD.generation);" + " END;")); + } + + ~EvictionObserver() { + mDB->ExecuteSimpleSQL("DROP TRIGGER cache_on_delete;"_ns); + mEvictionFunction->Reset(); + } + + void Apply() { return mEvictionFunction->Apply(); } + + private: + mozIStorageConnection* mDB; + RefPtr<nsOfflineCacheEvictionFunction> mEvictionFunction; +}; + +#define DCACHE_HASH_MAX INT64_MAX +#define DCACHE_HASH_BITS 64 + +/** + * nsOfflineCache::Hash(const char * key) + * + * This algorithm of this method implies nsOfflineCacheRecords will be stored + * in a certain order on disk. If the algorithm changes, existing cache + * map files may become invalid, and therefore the kCurrentVersion needs + * to be revised. + */ +static uint64_t DCacheHash(const char* key) { + // initval 0x7416f295 was chosen randomly + return (uint64_t(CacheHash::Hash(key, strlen(key), 0)) << 32) | + CacheHash::Hash(key, strlen(key), 0x7416f295); +} + +/****************************************************************************** + * nsOfflineCacheEvictionFunction + */ + +NS_IMPL_ISUPPORTS(nsOfflineCacheEvictionFunction, mozIStorageFunction) + +// helper function for directly exposing the same data file binding +// path algorithm used in nsOfflineCacheBinding::Create +static nsresult GetCacheDataFile(nsIFile* cacheDir, const char* key, + int generation, nsCOMPtr<nsIFile>& file) { + cacheDir->Clone(getter_AddRefs(file)); + if (!file) return NS_ERROR_OUT_OF_MEMORY; + + uint64_t hash = DCacheHash(key); + + uint32_t dir1 = (uint32_t)(hash & 0x0F); + uint32_t dir2 = (uint32_t)((hash & 0xF0) >> 4); + + hash >>= 8; + + file->AppendNative(nsPrintfCString("%X", dir1)); + file->AppendNative(nsPrintfCString("%X", dir2)); + + char leaf[64]; + SprintfLiteral(leaf, "%014" PRIX64 "-%X", hash, generation); + return file->AppendNative(nsDependentCString(leaf)); +} + +namespace appcachedetail { + +typedef nsCOMArray<nsIFile> FileArray; +static MOZ_THREAD_LOCAL(FileArray*) tlsEvictionItems; + +} // namespace appcachedetail + +NS_IMETHODIMP +nsOfflineCacheEvictionFunction::OnFunctionCall(mozIStorageValueArray* values, + nsIVariant** _retval) { + LOG(("nsOfflineCacheEvictionFunction::OnFunctionCall\n")); + + *_retval = nullptr; + + uint32_t numEntries; + nsresult rv = values->GetNumEntries(&numEntries); + NS_ENSURE_SUCCESS(rv, rv); + NS_ASSERTION(numEntries == 3, "unexpected number of arguments"); + + uint32_t valueLen; + const char* clientID = values->AsSharedUTF8String(0, &valueLen); + const char* key = values->AsSharedUTF8String(1, &valueLen); + nsAutoCString fullKey(clientID); + fullKey.Append(':'); + fullKey.Append(key); + int generation = values->AsInt32(2); + + // If the key is currently locked, refuse to delete this row. + if (mDevice->IsLocked(fullKey)) { + // This code thought it was performing the equivalent of invoking the SQL + // "RAISE(IGNORE)" function. It was not. Please see bug 1470961 and any + // follow-ups to understand the plan for correcting this bug. + return NS_OK; + } + + nsCOMPtr<nsIFile> file; + rv = GetCacheDataFile(mDevice->CacheDirectory(), key, generation, file); + if (NS_FAILED(rv)) { + LOG(("GetCacheDataFile [key=%s generation=%d] failed [rv=%" PRIx32 "]!\n", + key, generation, static_cast<uint32_t>(rv))); + return rv; + } + + appcachedetail::FileArray* items = appcachedetail::tlsEvictionItems.get(); + MOZ_ASSERT(items); + if (items) { + items->AppendObject(file); + } + + return NS_OK; +} + +nsOfflineCacheEvictionFunction::nsOfflineCacheEvictionFunction( + nsOfflineCacheDevice* device) + : mDevice(device) { + mTLSInited = appcachedetail::tlsEvictionItems.init(); +} + +void nsOfflineCacheEvictionFunction::Init() { + if (mTLSInited) { + appcachedetail::tlsEvictionItems.set(new appcachedetail::FileArray()); + } +} + +void nsOfflineCacheEvictionFunction::Reset() { + if (!mTLSInited) { + return; + } + + appcachedetail::FileArray* items = appcachedetail::tlsEvictionItems.get(); + if (!items) { + return; + } + + appcachedetail::tlsEvictionItems.set(nullptr); + delete items; +} + +void nsOfflineCacheEvictionFunction::Apply() { + LOG(("nsOfflineCacheEvictionFunction::Apply\n")); + + if (!mTLSInited) { + return; + } + + appcachedetail::FileArray* pitems = appcachedetail::tlsEvictionItems.get(); + if (!pitems) { + return; + } + + appcachedetail::FileArray items = std::move(*pitems); + + for (int32_t i = 0; i < items.Count(); i++) { + if (MOZ_LOG_TEST(gCacheLog, LogLevel::Debug)) { + LOG((" removing %s\n", items[i]->HumanReadablePath().get())); + } + + items[i]->Remove(false); + } +} + +class nsOfflineCacheDiscardCache : public Runnable { + public: + nsOfflineCacheDiscardCache(nsOfflineCacheDevice* device, nsCString& group, + nsCString& clientID) + : mozilla::Runnable("nsOfflineCacheDiscardCache"), + mDevice(device), + mGroup(group), + mClientID(clientID) {} + + NS_IMETHOD Run() override { + if (mDevice->IsActiveCache(mGroup, mClientID)) { + mDevice->DeactivateGroup(mGroup); + } + + return mDevice->EvictEntries(mClientID.get()); + } + + private: + RefPtr<nsOfflineCacheDevice> mDevice; + nsCString mGroup; + nsCString mClientID; +}; + +/****************************************************************************** + * nsOfflineCacheDeviceInfo + */ + +class nsOfflineCacheDeviceInfo final : public nsICacheDeviceInfo { + public: + NS_DECL_ISUPPORTS + NS_DECL_NSICACHEDEVICEINFO + + explicit nsOfflineCacheDeviceInfo(nsOfflineCacheDevice* device) + : mDevice(device) {} + + private: + ~nsOfflineCacheDeviceInfo() = default; + + nsOfflineCacheDevice* mDevice; +}; + +NS_IMPL_ISUPPORTS(nsOfflineCacheDeviceInfo, nsICacheDeviceInfo) + +NS_IMETHODIMP +nsOfflineCacheDeviceInfo::GetDescription(nsACString& aDescription) { + aDescription.AssignLiteral("Offline cache device"); + return NS_OK; +} + +NS_IMETHODIMP +nsOfflineCacheDeviceInfo::GetUsageReport(nsACString& aUsageReport) { + nsAutoCString buffer; + buffer.AssignLiteral( + " <tr>\n" + " <th>Cache Directory:</th>\n" + " <td>"); + nsIFile* cacheDir = mDevice->CacheDirectory(); + if (!cacheDir) return NS_OK; + + nsAutoString path; + nsresult rv = cacheDir->GetPath(path); + if (NS_SUCCEEDED(rv)) + AppendUTF16toUTF8(path, buffer); + else + buffer.AppendLiteral("directory unavailable"); + + buffer.AppendLiteral( + "</td>\n" + " </tr>\n"); + + aUsageReport.Assign(buffer); + return NS_OK; +} + +NS_IMETHODIMP +nsOfflineCacheDeviceInfo::GetEntryCount(uint32_t* aEntryCount) { + *aEntryCount = mDevice->EntryCount(); + return NS_OK; +} + +NS_IMETHODIMP +nsOfflineCacheDeviceInfo::GetTotalSize(uint32_t* aTotalSize) { + *aTotalSize = mDevice->CacheSize(); + return NS_OK; +} + +NS_IMETHODIMP +nsOfflineCacheDeviceInfo::GetMaximumSize(uint32_t* aMaximumSize) { + *aMaximumSize = mDevice->CacheCapacity(); + return NS_OK; +} + +/****************************************************************************** + * nsOfflineCacheBinding + */ + +class nsOfflineCacheBinding final : public nsISupports { + ~nsOfflineCacheBinding() = default; + + public: + NS_DECL_THREADSAFE_ISUPPORTS + + static nsOfflineCacheBinding* Create(nsIFile* cacheDir, const nsCString* key, + int generation); + + enum { FLAG_NEW_ENTRY = 1 }; + + nsCOMPtr<nsIFile> mDataFile; + int mGeneration; + int mFlags; + + bool IsNewEntry() { return mFlags & FLAG_NEW_ENTRY; } + void MarkNewEntry() { mFlags |= FLAG_NEW_ENTRY; } + void ClearNewEntry() { mFlags &= ~FLAG_NEW_ENTRY; } +}; + +NS_IMPL_ISUPPORTS0(nsOfflineCacheBinding) + +nsOfflineCacheBinding* nsOfflineCacheBinding::Create(nsIFile* cacheDir, + const nsCString* fullKey, + int generation) { + nsCOMPtr<nsIFile> file; + cacheDir->Clone(getter_AddRefs(file)); + if (!file) return nullptr; + + nsAutoCString keyBuf; + const char *cid, *key; + if (!DecomposeCacheEntryKey(fullKey, &cid, &key, keyBuf)) return nullptr; + + uint64_t hash = DCacheHash(key); + + uint32_t dir1 = (uint32_t)(hash & 0x0F); + uint32_t dir2 = (uint32_t)((hash & 0xF0) >> 4); + + hash >>= 8; + + // XXX we might want to create these directories up-front + + file->AppendNative(nsPrintfCString("%X", dir1)); + Unused << file->Create(nsIFile::DIRECTORY_TYPE, 00700); + + file->AppendNative(nsPrintfCString("%X", dir2)); + Unused << file->Create(nsIFile::DIRECTORY_TYPE, 00700); + + nsresult rv; + char leaf[64]; + + if (generation == -1) { + file->AppendNative("placeholder"_ns); + + for (generation = 0;; ++generation) { + SprintfLiteral(leaf, "%014" PRIX64 "-%X", hash, generation); + + rv = file->SetNativeLeafName(nsDependentCString(leaf)); + if (NS_FAILED(rv)) return nullptr; + rv = file->Create(nsIFile::NORMAL_FILE_TYPE, 00600); + if (NS_FAILED(rv) && rv != NS_ERROR_FILE_ALREADY_EXISTS) return nullptr; + if (NS_SUCCEEDED(rv)) break; + } + } else { + SprintfLiteral(leaf, "%014" PRIX64 "-%X", hash, generation); + rv = file->AppendNative(nsDependentCString(leaf)); + if (NS_FAILED(rv)) return nullptr; + } + + nsOfflineCacheBinding* binding = new nsOfflineCacheBinding; + if (!binding) return nullptr; + + binding->mDataFile.swap(file); + binding->mGeneration = generation; + binding->mFlags = 0; + return binding; +} + +/****************************************************************************** + * nsOfflineCacheRecord + */ + +struct nsOfflineCacheRecord { + const char* clientID; + const char* key; + const uint8_t* metaData; + uint32_t metaDataLen; + int32_t generation; + int32_t dataSize; + int32_t fetchCount; + int64_t lastFetched; + int64_t lastModified; + int64_t expirationTime; +}; + +static nsCacheEntry* CreateCacheEntry(nsOfflineCacheDevice* device, + const nsCString* fullKey, + const nsOfflineCacheRecord& rec) { + nsCacheEntry* entry; + + if (device->IsLocked(*fullKey)) { + return nullptr; + } + + nsresult rv = nsCacheEntry::Create(fullKey->get(), // XXX enable sharing + nsICache::STREAM_BASED, + nsICache::STORE_OFFLINE, device, &entry); + if (NS_FAILED(rv)) return nullptr; + + entry->SetFetchCount((uint32_t)rec.fetchCount); + entry->SetLastFetched(SecondsFromPRTime(rec.lastFetched)); + entry->SetLastModified(SecondsFromPRTime(rec.lastModified)); + entry->SetExpirationTime(SecondsFromPRTime(rec.expirationTime)); + entry->SetDataSize((uint32_t)rec.dataSize); + + entry->UnflattenMetaData((const char*)rec.metaData, rec.metaDataLen); + + // Restore security info, if present + const char* info = entry->GetMetaDataElement("security-info"); + if (info) { + nsCOMPtr<nsISupports> infoObj; + rv = + NS_DeserializeObject(nsDependentCString(info), getter_AddRefs(infoObj)); + if (NS_FAILED(rv)) { + delete entry; + return nullptr; + } + entry->SetSecurityInfo(infoObj); + } + + // create a binding object for this entry + nsOfflineCacheBinding* binding = nsOfflineCacheBinding::Create( + device->CacheDirectory(), fullKey, rec.generation); + if (!binding) { + delete entry; + return nullptr; + } + entry->SetData(binding); + + return entry; +} + +/****************************************************************************** + * nsOfflineCacheEntryInfo + */ + +class nsOfflineCacheEntryInfo final : public nsICacheEntryInfo { + ~nsOfflineCacheEntryInfo() = default; + + public: + NS_DECL_ISUPPORTS + NS_DECL_NSICACHEENTRYINFO + + nsOfflineCacheRecord* mRec; +}; + +NS_IMPL_ISUPPORTS(nsOfflineCacheEntryInfo, nsICacheEntryInfo) + +NS_IMETHODIMP +nsOfflineCacheEntryInfo::GetClientID(nsACString& aClientID) { + aClientID.Assign(mRec->clientID); + return NS_OK; +} + +NS_IMETHODIMP +nsOfflineCacheEntryInfo::GetDeviceID(nsACString& aDeviceID) { + aDeviceID.Assign(OFFLINE_CACHE_DEVICE_ID); + return NS_OK; +} + +NS_IMETHODIMP +nsOfflineCacheEntryInfo::GetKey(nsACString& clientKey) { + clientKey.Assign(mRec->key); + return NS_OK; +} + +NS_IMETHODIMP +nsOfflineCacheEntryInfo::GetFetchCount(int32_t* aFetchCount) { + *aFetchCount = mRec->fetchCount; + return NS_OK; +} + +NS_IMETHODIMP +nsOfflineCacheEntryInfo::GetLastFetched(uint32_t* aLastFetched) { + *aLastFetched = SecondsFromPRTime(mRec->lastFetched); + return NS_OK; +} + +NS_IMETHODIMP +nsOfflineCacheEntryInfo::GetLastModified(uint32_t* aLastModified) { + *aLastModified = SecondsFromPRTime(mRec->lastModified); + return NS_OK; +} + +NS_IMETHODIMP +nsOfflineCacheEntryInfo::GetExpirationTime(uint32_t* aExpirationTime) { + *aExpirationTime = SecondsFromPRTime(mRec->expirationTime); + return NS_OK; +} + +NS_IMETHODIMP +nsOfflineCacheEntryInfo::IsStreamBased(bool* aStreamBased) { + *aStreamBased = true; + return NS_OK; +} + +NS_IMETHODIMP +nsOfflineCacheEntryInfo::GetDataSize(uint32_t* aDataSize) { + *aDataSize = mRec->dataSize; + return NS_OK; +} + +/****************************************************************************** + * nsApplicationCacheNamespace + */ + +NS_IMPL_ISUPPORTS(nsApplicationCacheNamespace, nsIApplicationCacheNamespace) + +NS_IMETHODIMP +nsApplicationCacheNamespace::Init(uint32_t itemType, + const nsACString& namespaceSpec, + const nsACString& data) { + mItemType = itemType; + mNamespaceSpec = namespaceSpec; + mData = data; + return NS_OK; +} + +NS_IMETHODIMP +nsApplicationCacheNamespace::GetItemType(uint32_t* out) { + *out = mItemType; + return NS_OK; +} + +NS_IMETHODIMP +nsApplicationCacheNamespace::GetNamespaceSpec(nsACString& out) { + out = mNamespaceSpec; + return NS_OK; +} + +NS_IMETHODIMP +nsApplicationCacheNamespace::GetData(nsACString& out) { + out = mData; + return NS_OK; +} + +/****************************************************************************** + * nsApplicationCache + */ + +NS_IMPL_ISUPPORTS(nsApplicationCache, nsIApplicationCache, + nsISupportsWeakReference) + +nsApplicationCache::nsApplicationCache() : mDevice(nullptr), mValid(true) {} + +nsApplicationCache::nsApplicationCache(nsOfflineCacheDevice* device, + const nsACString& group, + const nsACString& clientID) + : mDevice(device), mGroup(group), mClientID(clientID), mValid(true) {} + +nsApplicationCache::~nsApplicationCache() { + if (!mDevice) return; + + { + MutexAutoLock lock(mDevice->mLock); + mDevice->mCaches.Remove(mClientID); + } + + // If this isn't an active cache anymore, it can be destroyed. + if (mValid && !mDevice->IsActiveCache(mGroup, mClientID)) Discard(); +} + +void nsApplicationCache::MarkInvalid() { mValid = false; } + +NS_IMETHODIMP +nsApplicationCache::InitAsHandle(const nsACString& groupId, + const nsACString& clientId) { + NS_ENSURE_FALSE(mDevice, NS_ERROR_ALREADY_INITIALIZED); + NS_ENSURE_TRUE(mGroup.IsEmpty(), NS_ERROR_ALREADY_INITIALIZED); + + mGroup = groupId; + mClientID = clientId; + return NS_OK; +} + +NS_IMETHODIMP +nsApplicationCache::GetManifestURI(nsIURI** out) { + nsCOMPtr<nsIURI> uri; + nsresult rv = NS_NewURI(getter_AddRefs(uri), mGroup); + NS_ENSURE_SUCCESS(rv, rv); + + rv = NS_GetURIWithNewRef(uri, ""_ns, out); + NS_ENSURE_SUCCESS(rv, rv); + + return NS_OK; +} + +NS_IMETHODIMP +nsApplicationCache::GetGroupID(nsACString& out) { + out = mGroup; + return NS_OK; +} + +NS_IMETHODIMP +nsApplicationCache::GetClientID(nsACString& out) { + out = mClientID; + return NS_OK; +} + +NS_IMETHODIMP +nsApplicationCache::GetProfileDirectory(nsIFile** out) { + *out = do_AddRef(mDevice->BaseDirectory()).take(); + return NS_OK; +} + +NS_IMETHODIMP +nsApplicationCache::GetActive(bool* out) { + NS_ENSURE_TRUE(mDevice, NS_ERROR_NOT_AVAILABLE); + + *out = mDevice->IsActiveCache(mGroup, mClientID); + return NS_OK; +} + +NS_IMETHODIMP +nsApplicationCache::Activate() { + NS_ENSURE_TRUE(mValid, NS_ERROR_NOT_AVAILABLE); + NS_ENSURE_TRUE(mDevice, NS_ERROR_NOT_AVAILABLE); + + mDevice->ActivateCache(mGroup, mClientID); + + if (mDevice->AutoShutdown(this)) mDevice = nullptr; + + return NS_OK; +} + +NS_IMETHODIMP +nsApplicationCache::Discard() { + NS_ENSURE_TRUE(mValid, NS_ERROR_NOT_AVAILABLE); + NS_ENSURE_TRUE(mDevice, NS_ERROR_NOT_AVAILABLE); + + mValid = false; + + nsCOMPtr<nsIRunnable> ev = + new nsOfflineCacheDiscardCache(mDevice, mGroup, mClientID); + nsresult rv = nsCacheService::DispatchToCacheIOThread(ev); + return rv; +} + +NS_IMETHODIMP +nsApplicationCache::MarkEntry(const nsACString& key, uint32_t typeBits) { + NS_ENSURE_TRUE(mValid, NS_ERROR_NOT_AVAILABLE); + NS_ENSURE_TRUE(mDevice, NS_ERROR_NOT_AVAILABLE); + + return mDevice->MarkEntry(mClientID, key, typeBits); +} + +NS_IMETHODIMP +nsApplicationCache::UnmarkEntry(const nsACString& key, uint32_t typeBits) { + NS_ENSURE_TRUE(mValid, NS_ERROR_NOT_AVAILABLE); + NS_ENSURE_TRUE(mDevice, NS_ERROR_NOT_AVAILABLE); + + return mDevice->UnmarkEntry(mClientID, key, typeBits); +} + +NS_IMETHODIMP +nsApplicationCache::GetTypes(const nsACString& key, uint32_t* typeBits) { + NS_ENSURE_TRUE(mValid, NS_ERROR_NOT_AVAILABLE); + NS_ENSURE_TRUE(mDevice, NS_ERROR_NOT_AVAILABLE); + + return mDevice->GetTypes(mClientID, key, typeBits); +} + +NS_IMETHODIMP +nsApplicationCache::GatherEntries(uint32_t typeBits, + nsTArray<nsCString>& keys) { + NS_ENSURE_TRUE(mValid, NS_ERROR_NOT_AVAILABLE); + NS_ENSURE_TRUE(mDevice, NS_ERROR_NOT_AVAILABLE); + + return mDevice->GatherEntries(mClientID, typeBits, keys); +} + +NS_IMETHODIMP +nsApplicationCache::AddNamespaces(nsIArray* namespaces) { + NS_ENSURE_TRUE(mValid, NS_ERROR_NOT_AVAILABLE); + NS_ENSURE_TRUE(mDevice, NS_ERROR_NOT_AVAILABLE); + + if (!namespaces) return NS_OK; + + mozStorageTransaction transaction(mDevice->mDB, false); + + uint32_t length; + nsresult rv = namespaces->GetLength(&length); + NS_ENSURE_SUCCESS(rv, rv); + + for (uint32_t i = 0; i < length; i++) { + nsCOMPtr<nsIApplicationCacheNamespace> ns = + do_QueryElementAt(namespaces, i); + if (ns) { + rv = mDevice->AddNamespace(mClientID, ns); + NS_ENSURE_SUCCESS(rv, rv); + } + } + + rv = transaction.Commit(); + NS_ENSURE_SUCCESS(rv, rv); + + return NS_OK; +} + +NS_IMETHODIMP +nsApplicationCache::GetMatchingNamespace(const nsACString& key, + nsIApplicationCacheNamespace** out) + +{ + NS_ENSURE_TRUE(mValid, NS_ERROR_NOT_AVAILABLE); + NS_ENSURE_TRUE(mDevice, NS_ERROR_NOT_AVAILABLE); + + return mDevice->GetMatchingNamespace(mClientID, key, out); +} + +NS_IMETHODIMP +nsApplicationCache::GetUsage(uint32_t* usage) { + NS_ENSURE_TRUE(mValid, NS_ERROR_NOT_AVAILABLE); + NS_ENSURE_TRUE(mDevice, NS_ERROR_NOT_AVAILABLE); + + return mDevice->GetUsage(mClientID, usage); +} + +/****************************************************************************** + * nsCloseDBEvent + *****************************************************************************/ + +class nsCloseDBEvent : public Runnable { + public: + explicit nsCloseDBEvent(mozIStorageConnection* aDB) + : mozilla::Runnable("nsCloseDBEvent") { + mDB = aDB; + } + + NS_IMETHOD Run() override { + mDB->Close(); + return NS_OK; + } + + protected: + virtual ~nsCloseDBEvent() = default; + + private: + nsCOMPtr<mozIStorageConnection> mDB; +}; + +/****************************************************************************** + * nsOfflineCacheDevice + */ + +NS_IMPL_ISUPPORTS0(nsOfflineCacheDevice) + +nsOfflineCacheDevice::nsOfflineCacheDevice() + : mDB(nullptr), + mCacheCapacity(0), + mDeltaCounter(0), + mAutoShutdown(false), + mLock("nsOfflineCacheDevice.lock"), + mActiveCaches(4), + mLockedEntries(32) {} + +/* static */ +bool nsOfflineCacheDevice::GetStrictFileOriginPolicy() { + nsCOMPtr<nsIPrefBranch> prefs = do_GetService(NS_PREFSERVICE_CONTRACTID); + + bool retval; + if (prefs && NS_SUCCEEDED(prefs->GetBoolPref( + "security.fileuri.strict_origin_policy", &retval))) + return retval; + + // As default value use true (be more strict) + return true; +} + +uint32_t nsOfflineCacheDevice::CacheSize() { + NS_ENSURE_TRUE(Initialized(), 0); + + AutoResetStatement statement(mStatement_CacheSize); + + bool hasRows; + nsresult rv = statement->ExecuteStep(&hasRows); + NS_ENSURE_TRUE(NS_SUCCEEDED(rv) && hasRows, 0); + + return (uint32_t)statement->AsInt32(0); +} + +uint32_t nsOfflineCacheDevice::EntryCount() { + NS_ENSURE_TRUE(Initialized(), 0); + + AutoResetStatement statement(mStatement_EntryCount); + + bool hasRows; + nsresult rv = statement->ExecuteStep(&hasRows); + NS_ENSURE_TRUE(NS_SUCCEEDED(rv) && hasRows, 0); + + return (uint32_t)statement->AsInt32(0); +} + +nsresult nsOfflineCacheDevice::UpdateEntry(nsCacheEntry* entry) { + NS_ENSURE_TRUE(Initialized(), NS_ERROR_NOT_INITIALIZED); + + // Decompose the key into "ClientID" and "Key" + nsAutoCString keyBuf; + const char *cid, *key; + + if (!DecomposeCacheEntryKey(entry->Key(), &cid, &key, keyBuf)) + return NS_ERROR_UNEXPECTED; + + // Store security info, if it is serializable + nsCOMPtr<nsISupports> infoObj = entry->SecurityInfo(); + nsCOMPtr<nsISerializable> serializable = do_QueryInterface(infoObj); + if (infoObj && !serializable) return NS_ERROR_UNEXPECTED; + + if (serializable) { + nsCString info; + nsresult rv = NS_SerializeToString(serializable, info); + NS_ENSURE_SUCCESS(rv, rv); + + rv = entry->SetMetaDataElement("security-info", info.get()); + NS_ENSURE_SUCCESS(rv, rv); + } + + nsCString metaDataBuf; + uint32_t mdSize = entry->MetaDataSize(); + if (!metaDataBuf.SetLength(mdSize, fallible)) return NS_ERROR_OUT_OF_MEMORY; + char* md = metaDataBuf.BeginWriting(); + entry->FlattenMetaData(md, mdSize); + + nsOfflineCacheRecord rec; + rec.metaData = (const uint8_t*)md; + rec.metaDataLen = mdSize; + rec.dataSize = entry->DataSize(); + rec.fetchCount = entry->FetchCount(); + rec.lastFetched = PRTimeFromSeconds(entry->LastFetched()); + rec.lastModified = PRTimeFromSeconds(entry->LastModified()); + rec.expirationTime = PRTimeFromSeconds(entry->ExpirationTime()); + + AutoResetStatement statement(mStatement_UpdateEntry); + + nsresult rv; + rv = statement->BindBlobByIndex(0, rec.metaData, rec.metaDataLen); + nsresult tmp = statement->BindInt32ByIndex(1, rec.dataSize); + if (NS_FAILED(tmp)) { + rv = tmp; + } + tmp = statement->BindInt32ByIndex(2, rec.fetchCount); + if (NS_FAILED(tmp)) { + rv = tmp; + } + tmp = statement->BindInt64ByIndex(3, rec.lastFetched); + if (NS_FAILED(tmp)) { + rv = tmp; + } + tmp = statement->BindInt64ByIndex(4, rec.lastModified); + if (NS_FAILED(tmp)) { + rv = tmp; + } + tmp = statement->BindInt64ByIndex(5, rec.expirationTime); + if (NS_FAILED(tmp)) { + rv = tmp; + } + tmp = statement->BindUTF8StringByIndex(6, nsDependentCString(cid)); + if (NS_FAILED(tmp)) { + rv = tmp; + } + tmp = statement->BindUTF8StringByIndex(7, nsDependentCString(key)); + if (NS_FAILED(tmp)) { + rv = tmp; + } + NS_ENSURE_SUCCESS(rv, rv); + + bool hasRows; + rv = statement->ExecuteStep(&hasRows); + NS_ENSURE_SUCCESS(rv, rv); + + NS_ASSERTION(!hasRows, "UPDATE should not result in output"); + return rv; +} + +nsresult nsOfflineCacheDevice::UpdateEntrySize(nsCacheEntry* entry, + uint32_t newSize) { + NS_ENSURE_TRUE(Initialized(), NS_ERROR_NOT_INITIALIZED); + + // Decompose the key into "ClientID" and "Key" + nsAutoCString keyBuf; + const char *cid, *key; + if (!DecomposeCacheEntryKey(entry->Key(), &cid, &key, keyBuf)) + return NS_ERROR_UNEXPECTED; + + AutoResetStatement statement(mStatement_UpdateEntrySize); + + nsresult rv = statement->BindInt32ByIndex(0, newSize); + nsresult tmp = statement->BindUTF8StringByIndex(1, nsDependentCString(cid)); + if (NS_FAILED(tmp)) { + rv = tmp; + } + tmp = statement->BindUTF8StringByIndex(2, nsDependentCString(key)); + if (NS_FAILED(tmp)) { + rv = tmp; + } + NS_ENSURE_SUCCESS(rv, rv); + + bool hasRows; + rv = statement->ExecuteStep(&hasRows); + NS_ENSURE_SUCCESS(rv, rv); + + NS_ASSERTION(!hasRows, "UPDATE should not result in output"); + return rv; +} + +nsresult nsOfflineCacheDevice::DeleteEntry(nsCacheEntry* entry, + bool deleteData) { + NS_ENSURE_TRUE(Initialized(), NS_ERROR_NOT_INITIALIZED); + + if (deleteData) { + nsresult rv = DeleteData(entry); + if (NS_FAILED(rv)) return rv; + } + + // Decompose the key into "ClientID" and "Key" + nsAutoCString keyBuf; + const char *cid, *key; + if (!DecomposeCacheEntryKey(entry->Key(), &cid, &key, keyBuf)) + return NS_ERROR_UNEXPECTED; + + AutoResetStatement statement(mStatement_DeleteEntry); + + nsresult rv = statement->BindUTF8StringByIndex(0, nsDependentCString(cid)); + nsresult rv2 = statement->BindUTF8StringByIndex(1, nsDependentCString(key)); + NS_ENSURE_SUCCESS(rv, rv); + NS_ENSURE_SUCCESS(rv2, rv2); + + bool hasRows; + rv = statement->ExecuteStep(&hasRows); + NS_ENSURE_SUCCESS(rv, rv); + + NS_ASSERTION(!hasRows, "DELETE should not result in output"); + return rv; +} + +nsresult nsOfflineCacheDevice::DeleteData(nsCacheEntry* entry) { + nsOfflineCacheBinding* binding = (nsOfflineCacheBinding*)entry->Data(); + NS_ENSURE_STATE(binding); + + return binding->mDataFile->Remove(false); +} + +/** + * nsCacheDevice implementation + */ + +// This struct is local to nsOfflineCacheDevice::Init, but ISO C++98 doesn't +// allow a template (mozilla::ArrayLength) to be instantiated based on a local +// type. Boo-urns! +struct StatementSql { + nsCOMPtr<mozIStorageStatement>& statement; + const char* sql; + StatementSql(nsCOMPtr<mozIStorageStatement>& aStatement, const char* aSql) + : statement(aStatement), sql(aSql) {} +}; + +nsresult nsOfflineCacheDevice::Init() { + MOZ_ASSERT(false, "Need to be initialized with sqlite"); + return NS_ERROR_NOT_IMPLEMENTED; +} + +nsresult nsOfflineCacheDevice::InitWithSqlite(mozIStorageService* ss) { + NS_ENSURE_TRUE(!mDB, NS_ERROR_ALREADY_INITIALIZED); + + // SetCacheParentDirectory must have been called + NS_ENSURE_TRUE(mCacheDirectory, NS_ERROR_UNEXPECTED); + + // make sure the cache directory exists + nsresult rv = EnsureDir(mCacheDirectory); + NS_ENSURE_SUCCESS(rv, rv); + + // build path to index file + nsCOMPtr<nsIFile> indexFile; + rv = mCacheDirectory->Clone(getter_AddRefs(indexFile)); + NS_ENSURE_SUCCESS(rv, rv); + rv = indexFile->AppendNative("index.sqlite"_ns); + NS_ENSURE_SUCCESS(rv, rv); + + MOZ_ASSERT(ss, + "nsOfflineCacheDevice::InitWithSqlite called before " + "nsCacheService::Init() ?"); + NS_ENSURE_TRUE(ss, NS_ERROR_UNEXPECTED); + + rv = ss->OpenDatabase(indexFile, getter_AddRefs(mDB)); + NS_ENSURE_SUCCESS(rv, rv); + + mInitEventTarget = GetCurrentEventTarget(); + + mDB->ExecuteSimpleSQL("PRAGMA synchronous = OFF;"_ns); + + // XXX ... other initialization steps + + // XXX in the future we may wish to verify the schema for moz_cache + // perhaps using "PRAGMA table_info" ? + + // build the table + // + // "Generation" is the data file generation number. + // + rv = mDB->ExecuteSimpleSQL( + nsLiteralCString("CREATE TABLE IF NOT EXISTS moz_cache (\n" + " ClientID TEXT,\n" + " Key TEXT,\n" + " MetaData BLOB,\n" + " Generation INTEGER,\n" + " DataSize INTEGER,\n" + " FetchCount INTEGER,\n" + " LastFetched INTEGER,\n" + " LastModified INTEGER,\n" + " ExpirationTime INTEGER,\n" + " ItemType INTEGER DEFAULT 0\n" + ");\n")); + NS_ENSURE_SUCCESS(rv, rv); + + // Databases from 1.9.0 don't have the ItemType column. Add the column + // here, but don't worry about failures (the column probably already exists) + mDB->ExecuteSimpleSQL( + "ALTER TABLE moz_cache ADD ItemType INTEGER DEFAULT 0"_ns); + + // Create the table for storing cache groups. All actions on + // moz_cache_groups use the GroupID, so use it as the primary key. + rv = mDB->ExecuteSimpleSQL( + nsLiteralCString("CREATE TABLE IF NOT EXISTS moz_cache_groups (\n" + " GroupID TEXT PRIMARY KEY,\n" + " ActiveClientID TEXT\n" + ");\n")); + NS_ENSURE_SUCCESS(rv, rv); + + mDB->ExecuteSimpleSQL( + nsLiteralCString("ALTER TABLE moz_cache_groups " + "ADD ActivateTimeStamp INTEGER DEFAULT 0")); + + // ClientID: clientID joining moz_cache and moz_cache_namespaces + // tables. + // Data: Data associated with this namespace (e.g. a fallback URI + // for fallback entries). + // ItemType: the type of namespace. + rv = + mDB->ExecuteSimpleSQL(nsLiteralCString("CREATE TABLE IF NOT EXISTS" + " moz_cache_namespaces (\n" + " ClientID TEXT,\n" + " NameSpace TEXT,\n" + " Data TEXT,\n" + " ItemType INTEGER\n" + ");\n")); + NS_ENSURE_SUCCESS(rv, rv); + + // Databases from 1.9.0 have a moz_cache_index that should be dropped + rv = mDB->ExecuteSimpleSQL("DROP INDEX IF EXISTS moz_cache_index"_ns); + NS_ENSURE_SUCCESS(rv, rv); + + // Key/ClientID pairs should be unique in the database. All queries + // against moz_cache use the Key (which is also the most unique), so + // use it as the primary key for this index. + rv = mDB->ExecuteSimpleSQL( + nsLiteralCString("CREATE UNIQUE INDEX IF NOT EXISTS " + " moz_cache_key_clientid_index" + " ON moz_cache (Key, ClientID);")); + NS_ENSURE_SUCCESS(rv, rv); + + // Used for ClientID lookups and to keep ClientID/NameSpace pairs unique. + rv = mDB->ExecuteSimpleSQL( + nsLiteralCString("CREATE UNIQUE INDEX IF NOT EXISTS" + " moz_cache_namespaces_clientid_index" + " ON moz_cache_namespaces (ClientID, NameSpace);")); + NS_ENSURE_SUCCESS(rv, rv); + + // Used for namespace lookups. + rv = mDB->ExecuteSimpleSQL( + nsLiteralCString("CREATE INDEX IF NOT EXISTS" + " moz_cache_namespaces_namespace_index" + " ON moz_cache_namespaces (NameSpace);")); + NS_ENSURE_SUCCESS(rv, rv); + + mEvictionFunction = new nsOfflineCacheEvictionFunction(this); + if (!mEvictionFunction) return NS_ERROR_OUT_OF_MEMORY; + + rv = mDB->CreateFunction("cache_eviction_observer"_ns, 3, mEvictionFunction); + NS_ENSURE_SUCCESS(rv, rv); + + // create all (most) of our statements up front + StatementSql prepared[] = { + // clang-format off + StatementSql ( mStatement_CacheSize, "SELECT Sum(DataSize) from moz_cache;" ), + StatementSql ( mStatement_ApplicationCacheSize, "SELECT Sum(DataSize) from moz_cache WHERE ClientID = ?;" ), + StatementSql ( mStatement_EntryCount, "SELECT count(*) from moz_cache;" ), + StatementSql ( mStatement_UpdateEntry, "UPDATE moz_cache SET MetaData = ?, DataSize = ?, FetchCount = ?, LastFetched = ?, LastModified = ?, ExpirationTime = ? WHERE ClientID = ? AND Key = ?;" ), + StatementSql ( mStatement_UpdateEntrySize, "UPDATE moz_cache SET DataSize = ? WHERE ClientID = ? AND Key = ?;" ), + StatementSql ( mStatement_DeleteEntry, "DELETE FROM moz_cache WHERE ClientID = ? AND Key = ?;" ), + StatementSql ( mStatement_FindEntry, "SELECT MetaData, Generation, DataSize, FetchCount, LastFetched, LastModified, ExpirationTime, ItemType FROM moz_cache WHERE ClientID = ? AND Key = ?;" ), + StatementSql ( mStatement_BindEntry, "INSERT INTO moz_cache (ClientID, Key, MetaData, Generation, DataSize, FetchCount, LastFetched, LastModified, ExpirationTime) VALUES(?,?,?,?,?,?,?,?,?);" ), + + StatementSql ( mStatement_MarkEntry, "UPDATE moz_cache SET ItemType = (ItemType | ?) WHERE ClientID = ? AND Key = ?;" ), + StatementSql ( mStatement_UnmarkEntry, "UPDATE moz_cache SET ItemType = (ItemType & ~?) WHERE ClientID = ? AND Key = ?;" ), + StatementSql ( mStatement_GetTypes, "SELECT ItemType FROM moz_cache WHERE ClientID = ? AND Key = ?;"), + StatementSql ( mStatement_CleanupUnmarked, "DELETE FROM moz_cache WHERE ClientID = ? AND Key = ? AND ItemType = 0;" ), + StatementSql ( mStatement_GatherEntries, "SELECT Key FROM moz_cache WHERE ClientID = ? AND (ItemType & ?) > 0;" ), + + StatementSql ( mStatement_ActivateClient, "INSERT OR REPLACE INTO moz_cache_groups (GroupID, ActiveClientID, ActivateTimeStamp) VALUES (?, ?, ?);" ), + StatementSql ( mStatement_DeactivateGroup, "DELETE FROM moz_cache_groups WHERE GroupID = ?;" ), + StatementSql ( mStatement_FindClient, "/* do not warn (bug 1293375) */ SELECT ClientID, ItemType FROM moz_cache WHERE Key = ? ORDER BY LastFetched DESC, LastModified DESC;" ), + + // Search for namespaces that match the URI. Use the <= operator + // to ensure that we use the index on moz_cache_namespaces. + StatementSql ( mStatement_FindClientByNamespace, "/* do not warn (bug 1293375) */ SELECT ns.ClientID, ns.ItemType FROM" + " moz_cache_namespaces AS ns JOIN moz_cache_groups AS groups" + " ON ns.ClientID = groups.ActiveClientID" + " WHERE ns.NameSpace <= ?1 AND ?1 GLOB ns.NameSpace || '*'" + " ORDER BY ns.NameSpace DESC, groups.ActivateTimeStamp DESC;"), + StatementSql ( mStatement_FindNamespaceEntry, "SELECT NameSpace, Data, ItemType FROM moz_cache_namespaces" + " WHERE ClientID = ?1" + " AND NameSpace <= ?2 AND ?2 GLOB NameSpace || '*'" + " ORDER BY NameSpace DESC;"), + StatementSql ( mStatement_InsertNamespaceEntry, "INSERT INTO moz_cache_namespaces (ClientID, NameSpace, Data, ItemType) VALUES(?, ?, ?, ?);"), + StatementSql ( mStatement_EnumerateApps, "SELECT GroupID, ActiveClientID FROM moz_cache_groups WHERE GroupID LIKE ?1;"), + StatementSql ( mStatement_EnumerateGroups, "SELECT GroupID, ActiveClientID FROM moz_cache_groups;"), + StatementSql ( mStatement_EnumerateGroupsTimeOrder, "SELECT GroupID, ActiveClientID FROM moz_cache_groups ORDER BY ActivateTimeStamp;") + // clang-format on + }; + for (uint32_t i = 0; NS_SUCCEEDED(rv) && i < ArrayLength(prepared); ++i) { + LOG(("Creating statement: %s\n", prepared[i].sql)); + + rv = mDB->CreateStatement(nsDependentCString(prepared[i].sql), + getter_AddRefs(prepared[i].statement)); + NS_ENSURE_SUCCESS(rv, rv); + } + + rv = InitActiveCaches(); + NS_ENSURE_SUCCESS(rv, rv); + + return NS_OK; +} + +namespace { + +nsresult GetGroupForCache(const nsACString& clientID, nsCString& group) { + group.Assign(clientID); + group.Truncate(group.FindChar('|')); + NS_UnescapeURL(group); + + return NS_OK; +} + +} // namespace + +// static +nsresult nsOfflineCacheDevice::BuildApplicationCacheGroupID( + nsIURI* aManifestURL, nsACString const& aOriginSuffix, + nsACString& _result) { + nsCOMPtr<nsIURI> newURI; + nsresult rv = + NS_GetURIWithNewRef(aManifestURL, ""_ns, getter_AddRefs(newURI)); + NS_ENSURE_SUCCESS(rv, rv); + + nsAutoCString manifestSpec; + rv = newURI->GetAsciiSpec(manifestSpec); + NS_ENSURE_SUCCESS(rv, rv); + + _result.Assign(manifestSpec); + _result.Append('#'); + _result.Append(aOriginSuffix); + + return NS_OK; +} + +nsresult nsOfflineCacheDevice::InitActiveCaches() { + NS_ENSURE_TRUE(Initialized(), NS_ERROR_NOT_INITIALIZED); + + MutexAutoLock lock(mLock); + + AutoResetStatement statement(mStatement_EnumerateGroups); + + bool hasRows; + nsresult rv = statement->ExecuteStep(&hasRows); + NS_ENSURE_SUCCESS(rv, rv); + + while (hasRows) { + nsAutoCString group; + statement->GetUTF8String(0, group); + nsCString clientID; + statement->GetUTF8String(1, clientID); + + mActiveCaches.PutEntry(clientID); + mActiveCachesByGroup.Put(group, new nsCString(clientID)); + + rv = statement->ExecuteStep(&hasRows); + NS_ENSURE_SUCCESS(rv, rv); + } + + return NS_OK; +} + +nsresult nsOfflineCacheDevice::Shutdown() { + NS_ENSURE_TRUE(mDB, NS_ERROR_NOT_INITIALIZED); + + { + MutexAutoLock lock(mLock); + for (auto iter = mCaches.Iter(); !iter.Done(); iter.Next()) { + nsCOMPtr<nsIApplicationCache> obj = do_QueryReferent(iter.UserData()); + if (obj) { + auto appCache = static_cast<nsApplicationCache*>(obj.get()); + appCache->MarkInvalid(); + } + } + } + + { + EvictionObserver evictionObserver(mDB, mEvictionFunction); + + // Delete all rows whose clientID is not an active clientID. + nsresult rv = mDB->ExecuteSimpleSQL(nsLiteralCString( + "DELETE FROM moz_cache WHERE rowid IN" + " (SELECT moz_cache.rowid FROM" + " moz_cache LEFT OUTER JOIN moz_cache_groups ON" + " (moz_cache.ClientID = moz_cache_groups.ActiveClientID)" + " WHERE moz_cache_groups.GroupID ISNULL)")); + + if (NS_FAILED(rv)) + NS_WARNING("Failed to clean up unused application caches."); + else + evictionObserver.Apply(); + + // Delete all namespaces whose clientID is not an active clientID. + rv = mDB->ExecuteSimpleSQL(nsLiteralCString( + "DELETE FROM moz_cache_namespaces WHERE rowid IN" + " (SELECT moz_cache_namespaces.rowid FROM" + " moz_cache_namespaces LEFT OUTER JOIN moz_cache_groups ON" + " (moz_cache_namespaces.ClientID = " + "moz_cache_groups.ActiveClientID)" + " WHERE moz_cache_groups.GroupID ISNULL)")); + + if (NS_FAILED(rv)) NS_WARNING("Failed to clean up namespaces."); + + mEvictionFunction = nullptr; + + mStatement_CacheSize = nullptr; + mStatement_ApplicationCacheSize = nullptr; + mStatement_EntryCount = nullptr; + mStatement_UpdateEntry = nullptr; + mStatement_UpdateEntrySize = nullptr; + mStatement_DeleteEntry = nullptr; + mStatement_FindEntry = nullptr; + mStatement_BindEntry = nullptr; + mStatement_ClearDomain = nullptr; + mStatement_MarkEntry = nullptr; + mStatement_UnmarkEntry = nullptr; + mStatement_GetTypes = nullptr; + mStatement_FindNamespaceEntry = nullptr; + mStatement_InsertNamespaceEntry = nullptr; + mStatement_CleanupUnmarked = nullptr; + mStatement_GatherEntries = nullptr; + mStatement_ActivateClient = nullptr; + mStatement_DeactivateGroup = nullptr; + mStatement_FindClient = nullptr; + mStatement_FindClientByNamespace = nullptr; + mStatement_EnumerateApps = nullptr; + mStatement_EnumerateGroups = nullptr; + mStatement_EnumerateGroupsTimeOrder = nullptr; + } + + // Close Database on the correct thread + bool isOnCurrentThread = true; + if (mInitEventTarget) + isOnCurrentThread = mInitEventTarget->IsOnCurrentThread(); + + if (!isOnCurrentThread) { + nsCOMPtr<nsIRunnable> ev = new nsCloseDBEvent(mDB); + + if (ev) { + mInitEventTarget->Dispatch(ev, NS_DISPATCH_NORMAL); + } + } else { + mDB->Close(); + } + + mDB = nullptr; + mInitEventTarget = nullptr; + + return NS_OK; +} + +const char* nsOfflineCacheDevice::GetDeviceID() { + return OFFLINE_CACHE_DEVICE_ID; +} + +nsCacheEntry* nsOfflineCacheDevice::FindEntry(nsCString* fullKey, + bool* collision) { + NS_ENSURE_TRUE(Initialized(), nullptr); + + mozilla::Telemetry::AutoTimer<mozilla::Telemetry::CACHE_OFFLINE_SEARCH_2> + timer; + LOG(("nsOfflineCacheDevice::FindEntry [key=%s]\n", fullKey->get())); + + // SELECT * FROM moz_cache WHERE key = ? + + // Decompose the key into "ClientID" and "Key" + nsAutoCString keyBuf; + const char *cid, *key; + if (!DecomposeCacheEntryKey(fullKey, &cid, &key, keyBuf)) return nullptr; + + AutoResetStatement statement(mStatement_FindEntry); + + nsresult rv = statement->BindUTF8StringByIndex(0, nsDependentCString(cid)); + nsresult rv2 = statement->BindUTF8StringByIndex(1, nsDependentCString(key)); + NS_ENSURE_SUCCESS(rv, nullptr); + NS_ENSURE_SUCCESS(rv2, nullptr); + + bool hasRows; + rv = statement->ExecuteStep(&hasRows); + if (NS_FAILED(rv) || !hasRows) return nullptr; // entry not found + + nsOfflineCacheRecord rec; + statement->GetSharedBlob(0, &rec.metaDataLen, (const uint8_t**)&rec.metaData); + rec.generation = statement->AsInt32(1); + rec.dataSize = statement->AsInt32(2); + rec.fetchCount = statement->AsInt32(3); + rec.lastFetched = statement->AsInt64(4); + rec.lastModified = statement->AsInt64(5); + rec.expirationTime = statement->AsInt64(6); + + LOG(("entry: [%u %d %d %d %" PRId64 " %" PRId64 " %" PRId64 "]\n", + rec.metaDataLen, rec.generation, rec.dataSize, rec.fetchCount, + rec.lastFetched, rec.lastModified, rec.expirationTime)); + + nsCacheEntry* entry = CreateCacheEntry(this, fullKey, rec); + + if (entry) { + // make sure that the data file exists + nsOfflineCacheBinding* binding = (nsOfflineCacheBinding*)entry->Data(); + bool isFile; + rv = binding->mDataFile->IsFile(&isFile); + if (NS_FAILED(rv) || !isFile) { + DeleteEntry(entry, false); + delete entry; + return nullptr; + } + + // lock the entry + Lock(*fullKey); + } + + return entry; +} + +nsresult nsOfflineCacheDevice::DeactivateEntry(nsCacheEntry* entry) { + LOG(("nsOfflineCacheDevice::DeactivateEntry [key=%s]\n", + entry->Key()->get())); + + // This method is called to inform us that the nsCacheEntry object is going + // away. We should persist anything that needs to be persisted, or if the + // entry is doomed, we can go ahead and clear its storage. + + if (entry->IsDoomed()) { + // remove corresponding row and file if they exist + + // the row should have been removed in DoomEntry... we could assert that + // that happened. otherwise, all we have to do here is delete the file + // on disk. + DeleteData(entry); + } else if (((nsOfflineCacheBinding*)entry->Data())->IsNewEntry()) { + // UPDATE the database row + + // Only new entries are updated, since offline cache is updated in + // transactions. New entries are those who is returned from + // BindEntry(). + + LOG(("nsOfflineCacheDevice::DeactivateEntry updating new entry\n")); + UpdateEntry(entry); + } else { + LOG( + ("nsOfflineCacheDevice::DeactivateEntry " + "skipping update since entry is not dirty\n")); + } + + // Unlock the entry + Unlock(*entry->Key()); + + delete entry; + + return NS_OK; +} + +nsresult nsOfflineCacheDevice::BindEntry(nsCacheEntry* entry) { + NS_ENSURE_TRUE(Initialized(), NS_ERROR_NOT_INITIALIZED); + + LOG(("nsOfflineCacheDevice::BindEntry [key=%s]\n", entry->Key()->get())); + + NS_ENSURE_STATE(!entry->Data()); + + // This method is called to inform us that we have a new entry. The entry + // may collide with an existing entry in our DB, but if that happens we can + // assume that the entry is not being used. + + // INSERT the database row + + // XXX Assumption: if the row already exists, then FindEntry would have + // returned it. if that entry was doomed, then DoomEntry would have removed + // it from the table. so, we should always have to insert at this point. + + // Decompose the key into "ClientID" and "Key" + nsAutoCString keyBuf; + const char *cid, *key; + if (!DecomposeCacheEntryKey(entry->Key(), &cid, &key, keyBuf)) + return NS_ERROR_UNEXPECTED; + + // create binding, pick best generation number + RefPtr<nsOfflineCacheBinding> binding = + nsOfflineCacheBinding::Create(mCacheDirectory, entry->Key(), -1); + if (!binding) return NS_ERROR_OUT_OF_MEMORY; + binding->MarkNewEntry(); + + nsOfflineCacheRecord rec; + rec.clientID = cid; + rec.key = key; + rec.metaData = nullptr; // don't write any metadata now. + rec.metaDataLen = 0; + rec.generation = binding->mGeneration; + rec.dataSize = 0; + rec.fetchCount = entry->FetchCount(); + rec.lastFetched = PRTimeFromSeconds(entry->LastFetched()); + rec.lastModified = PRTimeFromSeconds(entry->LastModified()); + rec.expirationTime = PRTimeFromSeconds(entry->ExpirationTime()); + + AutoResetStatement statement(mStatement_BindEntry); + + nsresult rv = + statement->BindUTF8StringByIndex(0, nsDependentCString(rec.clientID)); + nsresult tmp = + statement->BindUTF8StringByIndex(1, nsDependentCString(rec.key)); + if (NS_FAILED(tmp)) { + rv = tmp; + } + tmp = statement->BindBlobByIndex(2, rec.metaData, rec.metaDataLen); + if (NS_FAILED(tmp)) { + rv = tmp; + } + tmp = statement->BindInt32ByIndex(3, rec.generation); + if (NS_FAILED(tmp)) { + rv = tmp; + } + tmp = statement->BindInt32ByIndex(4, rec.dataSize); + if (NS_FAILED(tmp)) { + rv = tmp; + } + tmp = statement->BindInt32ByIndex(5, rec.fetchCount); + if (NS_FAILED(tmp)) { + rv = tmp; + } + tmp = statement->BindInt64ByIndex(6, rec.lastFetched); + if (NS_FAILED(tmp)) { + rv = tmp; + } + tmp = statement->BindInt64ByIndex(7, rec.lastModified); + if (NS_FAILED(tmp)) { + rv = tmp; + } + tmp = statement->BindInt64ByIndex(8, rec.expirationTime); + if (NS_FAILED(tmp)) { + rv = tmp; + } + NS_ENSURE_SUCCESS(rv, rv); + + bool hasRows; + rv = statement->ExecuteStep(&hasRows); + NS_ENSURE_SUCCESS(rv, rv); + NS_ASSERTION(!hasRows, "INSERT should not result in output"); + + entry->SetData(binding); + + // lock the entry + Lock(*entry->Key()); + + return NS_OK; +} + +void nsOfflineCacheDevice::DoomEntry(nsCacheEntry* entry) { + LOG(("nsOfflineCacheDevice::DoomEntry [key=%s]\n", entry->Key()->get())); + + // This method is called to inform us that we should mark the entry to be + // deleted when it is no longer in use. + + // We can go ahead and delete the corresponding row in our table, + // but we must not delete the file on disk until we are deactivated. + // In another word, the file should be deleted if the entry had been + // deactivated. + + DeleteEntry(entry, !entry->IsActive()); +} + +nsresult nsOfflineCacheDevice::OpenInputStreamForEntry( + nsCacheEntry* entry, nsCacheAccessMode mode, uint32_t offset, + nsIInputStream** result) { + LOG(("nsOfflineCacheDevice::OpenInputStreamForEntry [key=%s]\n", + entry->Key()->get())); + + *result = nullptr; + + NS_ENSURE_TRUE(!offset || (offset < entry->DataSize()), NS_ERROR_INVALID_ARG); + + // return an input stream to the entry's data file. the stream + // may be read on a background thread. + + nsOfflineCacheBinding* binding = (nsOfflineCacheBinding*)entry->Data(); + NS_ENSURE_STATE(binding); + + nsCOMPtr<nsIInputStream> in; + NS_NewLocalFileInputStream(getter_AddRefs(in), binding->mDataFile, PR_RDONLY); + if (!in) return NS_ERROR_UNEXPECTED; + + // respect |offset| param + if (offset != 0) { + nsCOMPtr<nsISeekableStream> seekable = do_QueryInterface(in); + NS_ENSURE_TRUE(seekable, NS_ERROR_UNEXPECTED); + + seekable->Seek(nsISeekableStream::NS_SEEK_SET, offset); + } + + in.swap(*result); + return NS_OK; +} + +nsresult nsOfflineCacheDevice::OpenOutputStreamForEntry( + nsCacheEntry* entry, nsCacheAccessMode mode, uint32_t offset, + nsIOutputStream** result) { + LOG(("nsOfflineCacheDevice::OpenOutputStreamForEntry [key=%s]\n", + entry->Key()->get())); + + *result = nullptr; + + NS_ENSURE_TRUE(offset <= entry->DataSize(), NS_ERROR_INVALID_ARG); + + // return an output stream to the entry's data file. we can assume + // that the output stream will only be used on the main thread. + + nsOfflineCacheBinding* binding = (nsOfflineCacheBinding*)entry->Data(); + NS_ENSURE_STATE(binding); + + nsCOMPtr<nsIOutputStream> out; + NS_NewLocalFileOutputStream(getter_AddRefs(out), binding->mDataFile, + PR_WRONLY | PR_CREATE_FILE | PR_TRUNCATE, 00600); + if (!out) return NS_ERROR_UNEXPECTED; + + // respect |offset| param + nsCOMPtr<nsISeekableStream> seekable = do_QueryInterface(out); + NS_ENSURE_TRUE(seekable, NS_ERROR_UNEXPECTED); + if (offset != 0) seekable->Seek(nsISeekableStream::NS_SEEK_SET, offset); + + // truncate the file at the given offset + seekable->SetEOF(); + + nsCOMPtr<nsIOutputStream> bufferedOut; + nsresult rv = NS_NewBufferedOutputStream(getter_AddRefs(bufferedOut), + out.forget(), 16 * 1024); + NS_ENSURE_SUCCESS(rv, rv); + + bufferedOut.forget(result); + return NS_OK; +} + +nsresult nsOfflineCacheDevice::GetFileForEntry(nsCacheEntry* entry, + nsIFile** result) { + LOG(("nsOfflineCacheDevice::GetFileForEntry [key=%s]\n", + entry->Key()->get())); + + nsOfflineCacheBinding* binding = (nsOfflineCacheBinding*)entry->Data(); + NS_ENSURE_STATE(binding); + + NS_IF_ADDREF(*result = binding->mDataFile); + return NS_OK; +} + +nsresult nsOfflineCacheDevice::OnDataSizeChange(nsCacheEntry* entry, + int32_t deltaSize) { + LOG(("nsOfflineCacheDevice::OnDataSizeChange [key=%s delta=%d]\n", + entry->Key()->get(), deltaSize)); + + const int32_t DELTA_THRESHOLD = 1 << 14; // 16k + + // called to notify us of an impending change in the total size of the + // specified entry. + + uint32_t oldSize = entry->DataSize(); + NS_ASSERTION(deltaSize >= 0 || int32_t(oldSize) + deltaSize >= 0, "oops"); + uint32_t newSize = int32_t(oldSize) + deltaSize; + UpdateEntrySize(entry, newSize); + + mDeltaCounter += deltaSize; // this may go negative + + if (mDeltaCounter >= DELTA_THRESHOLD) { + if (CacheSize() > mCacheCapacity) { + // the entry will overrun the cache capacity, doom the entry + // and abort +#ifdef DEBUG + nsresult rv = +#endif + nsCacheService::DoomEntry(entry); + NS_ASSERTION(NS_SUCCEEDED(rv), "DoomEntry() failed."); + return NS_ERROR_ABORT; + } + + mDeltaCounter = 0; // reset counter + } + + return NS_OK; +} + +nsresult nsOfflineCacheDevice::Visit(nsICacheVisitor* visitor) { + NS_ENSURE_TRUE(Initialized(), NS_ERROR_NOT_INITIALIZED); + + // called to enumerate the offline cache. + + nsCOMPtr<nsICacheDeviceInfo> deviceInfo = new nsOfflineCacheDeviceInfo(this); + + bool keepGoing; + nsresult rv = + visitor->VisitDevice(OFFLINE_CACHE_DEVICE_ID, deviceInfo, &keepGoing); + if (NS_FAILED(rv)) return rv; + + if (!keepGoing) return NS_OK; + + // SELECT * from moz_cache; + + nsOfflineCacheRecord rec; + RefPtr<nsOfflineCacheEntryInfo> info = new nsOfflineCacheEntryInfo; + if (!info) return NS_ERROR_OUT_OF_MEMORY; + info->mRec = &rec; + + // XXX may want to list columns explicitly + nsCOMPtr<mozIStorageStatement> statement; + rv = mDB->CreateStatement("SELECT * FROM moz_cache;"_ns, + getter_AddRefs(statement)); + NS_ENSURE_SUCCESS(rv, rv); + + bool hasRows; + for (;;) { + rv = statement->ExecuteStep(&hasRows); + if (NS_FAILED(rv) || !hasRows) break; + + statement->GetSharedUTF8String(0, nullptr, &rec.clientID); + statement->GetSharedUTF8String(1, nullptr, &rec.key); + statement->GetSharedBlob(2, &rec.metaDataLen, + (const uint8_t**)&rec.metaData); + rec.generation = statement->AsInt32(3); + rec.dataSize = statement->AsInt32(4); + rec.fetchCount = statement->AsInt32(5); + rec.lastFetched = statement->AsInt64(6); + rec.lastModified = statement->AsInt64(7); + rec.expirationTime = statement->AsInt64(8); + + bool keepGoing; + rv = visitor->VisitEntry(OFFLINE_CACHE_DEVICE_ID, info, &keepGoing); + if (NS_FAILED(rv) || !keepGoing) break; + } + + info->mRec = nullptr; + return NS_OK; +} + +nsresult nsOfflineCacheDevice::EvictEntries(const char* clientID) { + NS_ENSURE_TRUE(Initialized(), NS_ERROR_NOT_INITIALIZED); + + LOG(("nsOfflineCacheDevice::EvictEntries [cid=%s]\n", + clientID ? clientID : "")); + + // called to evict all entries matching the given clientID. + + // need trigger to fire user defined function after a row is deleted + // so we can delete the corresponding data file. + EvictionObserver evictionObserver(mDB, mEvictionFunction); + + nsCOMPtr<mozIStorageStatement> statement; + nsresult rv; + if (clientID) { + rv = mDB->CreateStatement("DELETE FROM moz_cache WHERE ClientID=?;"_ns, + getter_AddRefs(statement)); + NS_ENSURE_SUCCESS(rv, rv); + + rv = statement->BindUTF8StringByIndex(0, nsDependentCString(clientID)); + NS_ENSURE_SUCCESS(rv, rv); + + rv = statement->Execute(); + NS_ENSURE_SUCCESS(rv, rv); + + rv = mDB->CreateStatement( + nsLiteralCString( + "DELETE FROM moz_cache_groups WHERE ActiveClientID=?;"), + getter_AddRefs(statement)); + NS_ENSURE_SUCCESS(rv, rv); + + rv = statement->BindUTF8StringByIndex(0, nsDependentCString(clientID)); + NS_ENSURE_SUCCESS(rv, rv); + + rv = statement->Execute(); + NS_ENSURE_SUCCESS(rv, rv); + + // TODO - Should update internal hashtables. + // Low priority, since this API is not widely used. + } else { + rv = mDB->CreateStatement("DELETE FROM moz_cache;"_ns, + getter_AddRefs(statement)); + NS_ENSURE_SUCCESS(rv, rv); + + rv = statement->Execute(); + NS_ENSURE_SUCCESS(rv, rv); + + rv = mDB->CreateStatement("DELETE FROM moz_cache_groups;"_ns, + getter_AddRefs(statement)); + NS_ENSURE_SUCCESS(rv, rv); + + rv = statement->Execute(); + NS_ENSURE_SUCCESS(rv, rv); + + MutexAutoLock lock(mLock); + mCaches.Clear(); + mActiveCaches.Clear(); + mActiveCachesByGroup.Clear(); + } + + evictionObserver.Apply(); + + statement = nullptr; + // Also evict any namespaces associated with this clientID. + if (clientID) { + rv = mDB->CreateStatement( + "DELETE FROM moz_cache_namespaces WHERE ClientID=?"_ns, + getter_AddRefs(statement)); + NS_ENSURE_SUCCESS(rv, rv); + + rv = statement->BindUTF8StringByIndex(0, nsDependentCString(clientID)); + NS_ENSURE_SUCCESS(rv, rv); + } else { + rv = mDB->CreateStatement("DELETE FROM moz_cache_namespaces;"_ns, + getter_AddRefs(statement)); + NS_ENSURE_SUCCESS(rv, rv); + } + + rv = statement->Execute(); + NS_ENSURE_SUCCESS(rv, rv); + + return NS_OK; +} + +nsresult nsOfflineCacheDevice::MarkEntry(const nsCString& clientID, + const nsACString& key, + uint32_t typeBits) { + NS_ENSURE_TRUE(Initialized(), NS_ERROR_NOT_INITIALIZED); + + LOG(("nsOfflineCacheDevice::MarkEntry [cid=%s, key=%s, typeBits=%d]\n", + clientID.get(), PromiseFlatCString(key).get(), typeBits)); + + AutoResetStatement statement(mStatement_MarkEntry); + nsresult rv = statement->BindInt32ByIndex(0, typeBits); + NS_ENSURE_SUCCESS(rv, rv); + rv = statement->BindUTF8StringByIndex(1, clientID); + NS_ENSURE_SUCCESS(rv, rv); + rv = statement->BindUTF8StringByIndex(2, key); + NS_ENSURE_SUCCESS(rv, rv); + + rv = statement->Execute(); + NS_ENSURE_SUCCESS(rv, rv); + + return NS_OK; +} + +nsresult nsOfflineCacheDevice::UnmarkEntry(const nsCString& clientID, + const nsACString& key, + uint32_t typeBits) { + NS_ENSURE_TRUE(Initialized(), NS_ERROR_NOT_INITIALIZED); + + LOG(("nsOfflineCacheDevice::UnmarkEntry [cid=%s, key=%s, typeBits=%d]\n", + clientID.get(), PromiseFlatCString(key).get(), typeBits)); + + AutoResetStatement statement(mStatement_UnmarkEntry); + nsresult rv = statement->BindInt32ByIndex(0, typeBits); + NS_ENSURE_SUCCESS(rv, rv); + rv = statement->BindUTF8StringByIndex(1, clientID); + NS_ENSURE_SUCCESS(rv, rv); + rv = statement->BindUTF8StringByIndex(2, key); + NS_ENSURE_SUCCESS(rv, rv); + + rv = statement->Execute(); + NS_ENSURE_SUCCESS(rv, rv); + + // Remove the entry if it is now empty. + + EvictionObserver evictionObserver(mDB, mEvictionFunction); + + AutoResetStatement cleanupStatement(mStatement_CleanupUnmarked); + rv = cleanupStatement->BindUTF8StringByIndex(0, clientID); + NS_ENSURE_SUCCESS(rv, rv); + rv = cleanupStatement->BindUTF8StringByIndex(1, key); + NS_ENSURE_SUCCESS(rv, rv); + + rv = cleanupStatement->Execute(); + NS_ENSURE_SUCCESS(rv, rv); + + evictionObserver.Apply(); + + return NS_OK; +} + +nsresult nsOfflineCacheDevice::GetMatchingNamespace( + const nsCString& clientID, const nsACString& key, + nsIApplicationCacheNamespace** out) { + NS_ENSURE_TRUE(Initialized(), NS_ERROR_NOT_INITIALIZED); + + LOG(("nsOfflineCacheDevice::GetMatchingNamespace [cid=%s, key=%s]\n", + clientID.get(), PromiseFlatCString(key).get())); + + nsresult rv; + + AutoResetStatement statement(mStatement_FindNamespaceEntry); + + rv = statement->BindUTF8StringByIndex(0, clientID); + NS_ENSURE_SUCCESS(rv, rv); + rv = statement->BindUTF8StringByIndex(1, key); + NS_ENSURE_SUCCESS(rv, rv); + + bool hasRows; + rv = statement->ExecuteStep(&hasRows); + NS_ENSURE_SUCCESS(rv, rv); + + *out = nullptr; + + bool found = false; + nsCString nsSpec; + int32_t nsType = 0; + nsCString nsData; + + while (hasRows) { + int32_t itemType; + rv = statement->GetInt32(2, &itemType); + NS_ENSURE_SUCCESS(rv, rv); + + if (!found || itemType > nsType) { + nsType = itemType; + + rv = statement->GetUTF8String(0, nsSpec); + NS_ENSURE_SUCCESS(rv, rv); + + rv = statement->GetUTF8String(1, nsData); + NS_ENSURE_SUCCESS(rv, rv); + + found = true; + } + + rv = statement->ExecuteStep(&hasRows); + NS_ENSURE_SUCCESS(rv, rv); + } + + if (found) { + nsCOMPtr<nsIApplicationCacheNamespace> ns = + new nsApplicationCacheNamespace(); + if (!ns) return NS_ERROR_OUT_OF_MEMORY; + rv = ns->Init(nsType, nsSpec, nsData); + NS_ENSURE_SUCCESS(rv, rv); + + ns.swap(*out); + } + + return NS_OK; +} + +nsresult nsOfflineCacheDevice::CacheOpportunistically(const nsCString& clientID, + const nsACString& key) { + // XXX: We should also be propagating this cache entry to other matching + // caches. See bug 444807. + + return MarkEntry(clientID, key, nsIApplicationCache::ITEM_OPPORTUNISTIC); +} + +nsresult nsOfflineCacheDevice::GetTypes(const nsCString& clientID, + const nsACString& key, + uint32_t* typeBits) { + NS_ENSURE_TRUE(Initialized(), NS_ERROR_NOT_INITIALIZED); + + LOG(("nsOfflineCacheDevice::GetTypes [cid=%s, key=%s]\n", clientID.get(), + PromiseFlatCString(key).get())); + + AutoResetStatement statement(mStatement_GetTypes); + nsresult rv = statement->BindUTF8StringByIndex(0, clientID); + NS_ENSURE_SUCCESS(rv, rv); + rv = statement->BindUTF8StringByIndex(1, key); + NS_ENSURE_SUCCESS(rv, rv); + + bool hasRows; + rv = statement->ExecuteStep(&hasRows); + NS_ENSURE_SUCCESS(rv, rv); + + if (!hasRows) return NS_ERROR_CACHE_KEY_NOT_FOUND; + + *typeBits = statement->AsInt32(0); + + return NS_OK; +} + +nsresult nsOfflineCacheDevice::GatherEntries(const nsCString& clientID, + uint32_t typeBits, + nsTArray<nsCString>& keys) { + NS_ENSURE_TRUE(Initialized(), NS_ERROR_NOT_INITIALIZED); + + LOG(("nsOfflineCacheDevice::GatherEntries [cid=%s, typeBits=%X]\n", + clientID.get(), typeBits)); + + AutoResetStatement statement(mStatement_GatherEntries); + nsresult rv = statement->BindUTF8StringByIndex(0, clientID); + NS_ENSURE_SUCCESS(rv, rv); + + rv = statement->BindInt32ByIndex(1, typeBits); + NS_ENSURE_SUCCESS(rv, rv); + + return RunSimpleQuery(mStatement_GatherEntries, 0, keys); +} + +nsresult nsOfflineCacheDevice::AddNamespace(const nsCString& clientID, + nsIApplicationCacheNamespace* ns) { + NS_ENSURE_TRUE(Initialized(), NS_ERROR_NOT_INITIALIZED); + + nsCString namespaceSpec; + nsresult rv = ns->GetNamespaceSpec(namespaceSpec); + NS_ENSURE_SUCCESS(rv, rv); + + nsCString data; + rv = ns->GetData(data); + NS_ENSURE_SUCCESS(rv, rv); + + uint32_t itemType; + rv = ns->GetItemType(&itemType); + NS_ENSURE_SUCCESS(rv, rv); + + LOG(("nsOfflineCacheDevice::AddNamespace [cid=%s, ns=%s, data=%s, type=%d]", + clientID.get(), namespaceSpec.get(), data.get(), itemType)); + + AutoResetStatement statement(mStatement_InsertNamespaceEntry); + + rv = statement->BindUTF8StringByIndex(0, clientID); + NS_ENSURE_SUCCESS(rv, rv); + + rv = statement->BindUTF8StringByIndex(1, namespaceSpec); + NS_ENSURE_SUCCESS(rv, rv); + + rv = statement->BindUTF8StringByIndex(2, data); + NS_ENSURE_SUCCESS(rv, rv); + + rv = statement->BindInt32ByIndex(3, itemType); + NS_ENSURE_SUCCESS(rv, rv); + + rv = statement->Execute(); + NS_ENSURE_SUCCESS(rv, rv); + + return NS_OK; +} + +nsresult nsOfflineCacheDevice::GetUsage(const nsACString& clientID, + uint32_t* usage) { + NS_ENSURE_TRUE(Initialized(), NS_ERROR_NOT_INITIALIZED); + + LOG(("nsOfflineCacheDevice::GetUsage [cid=%s]\n", + PromiseFlatCString(clientID).get())); + + *usage = 0; + + AutoResetStatement statement(mStatement_ApplicationCacheSize); + + nsresult rv = statement->BindUTF8StringByIndex(0, clientID); + NS_ENSURE_SUCCESS(rv, rv); + + bool hasRows; + rv = statement->ExecuteStep(&hasRows); + NS_ENSURE_SUCCESS(rv, rv); + + if (!hasRows) return NS_OK; + + *usage = static_cast<uint32_t>(statement->AsInt32(0)); + + return NS_OK; +} + +nsresult nsOfflineCacheDevice::GetGroups(nsTArray<nsCString>& keys) { + NS_ENSURE_TRUE(Initialized(), NS_ERROR_NOT_INITIALIZED); + + LOG(("nsOfflineCacheDevice::GetGroups")); + + return RunSimpleQuery(mStatement_EnumerateGroups, 0, keys); +} + +nsresult nsOfflineCacheDevice::GetGroupsTimeOrdered(nsTArray<nsCString>& keys) { + NS_ENSURE_TRUE(Initialized(), NS_ERROR_NOT_INITIALIZED); + + LOG(("nsOfflineCacheDevice::GetGroupsTimeOrder")); + + return RunSimpleQuery(mStatement_EnumerateGroupsTimeOrder, 0, keys); +} + +bool nsOfflineCacheDevice::IsLocked(const nsACString& key) { + MutexAutoLock lock(mLock); + return mLockedEntries.GetEntry(key); +} + +void nsOfflineCacheDevice::Lock(const nsACString& key) { + MutexAutoLock lock(mLock); + mLockedEntries.PutEntry(key); +} + +void nsOfflineCacheDevice::Unlock(const nsACString& key) { + MutexAutoLock lock(mLock); + mLockedEntries.RemoveEntry(key); +} + +nsresult nsOfflineCacheDevice::RunSimpleQuery(mozIStorageStatement* statement, + uint32_t resultIndex, + nsTArray<nsCString>& values) { + bool hasRows; + nsresult rv = statement->ExecuteStep(&hasRows); + NS_ENSURE_SUCCESS(rv, rv); + + nsTArray<nsCString> valArray; + while (hasRows) { + uint32_t length; + valArray.AppendElement(nsDependentCString( + statement->AsSharedUTF8String(resultIndex, &length))); + + rv = statement->ExecuteStep(&hasRows); + NS_ENSURE_SUCCESS(rv, rv); + } + + values = std::move(valArray); + return NS_OK; +} + +nsresult nsOfflineCacheDevice::CreateApplicationCache( + const nsACString& group, nsIApplicationCache** out) { + *out = nullptr; + + nsCString clientID; + // Some characters are special in the clientID. Escape the groupID + // before putting it in to the client key. + if (!NS_Escape(nsCString(group), clientID, url_Path)) { + return NS_ERROR_OUT_OF_MEMORY; + } + + PRTime now = PR_Now(); + + // Include the timestamp to guarantee uniqueness across runs, and + // the gNextTemporaryClientID for uniqueness within a second. + clientID.Append(nsPrintfCString("|%016" PRId64 "|%d", now / PR_USEC_PER_SEC, + gNextTemporaryClientID++)); + + nsCOMPtr<nsIApplicationCache> cache = + new nsApplicationCache(this, group, clientID); + if (!cache) return NS_ERROR_OUT_OF_MEMORY; + + nsWeakPtr weak = do_GetWeakReference(cache); + if (!weak) return NS_ERROR_OUT_OF_MEMORY; + + MutexAutoLock lock(mLock); + mCaches.Put(clientID, weak); + + cache.swap(*out); + + return NS_OK; +} + +nsresult nsOfflineCacheDevice::GetApplicationCache(const nsACString& clientID, + nsIApplicationCache** out) { + MutexAutoLock lock(mLock); + return GetApplicationCache_Unlocked(clientID, out); +} + +nsresult nsOfflineCacheDevice::GetApplicationCache_Unlocked( + const nsACString& clientID, nsIApplicationCache** out) { + *out = nullptr; + + nsCOMPtr<nsIApplicationCache> cache; + + nsWeakPtr weak; + if (mCaches.Get(clientID, getter_AddRefs(weak))) + cache = do_QueryReferent(weak); + + if (!cache) { + nsCString group; + nsresult rv = GetGroupForCache(clientID, group); + NS_ENSURE_SUCCESS(rv, rv); + + if (group.IsEmpty()) { + return NS_OK; + } + + cache = new nsApplicationCache(this, group, clientID); + weak = do_GetWeakReference(cache); + if (!weak) return NS_ERROR_OUT_OF_MEMORY; + + mCaches.Put(clientID, weak); + } + + cache.swap(*out); + + return NS_OK; +} + +nsresult nsOfflineCacheDevice::GetActiveCache(const nsACString& group, + nsIApplicationCache** out) { + *out = nullptr; + + MutexAutoLock lock(mLock); + + nsCString* clientID; + if (mActiveCachesByGroup.Get(group, &clientID)) + return GetApplicationCache_Unlocked(*clientID, out); + + return NS_OK; +} + +nsresult nsOfflineCacheDevice::DeactivateGroup(const nsACString& group) { + NS_ENSURE_TRUE(Initialized(), NS_ERROR_NOT_INITIALIZED); + + nsCString* active = nullptr; + + AutoResetStatement statement(mStatement_DeactivateGroup); + nsresult rv = statement->BindUTF8StringByIndex(0, group); + NS_ENSURE_SUCCESS(rv, rv); + + rv = statement->Execute(); + NS_ENSURE_SUCCESS(rv, rv); + + MutexAutoLock lock(mLock); + + if (mActiveCachesByGroup.Get(group, &active)) { + mActiveCaches.RemoveEntry(*active); + mActiveCachesByGroup.Remove(group); + active = nullptr; + } + + return NS_OK; +} + +nsresult nsOfflineCacheDevice::Evict(nsILoadContextInfo* aInfo) { + NS_ENSURE_TRUE(Initialized(), NS_ERROR_NOT_INITIALIZED); + + NS_ENSURE_ARG(aInfo); + + nsresult rv; + + mozilla::OriginAttributes const* oa = aInfo->OriginAttributesPtr(); + + if (oa->mInIsolatedMozBrowser == false) { + nsCOMPtr<nsICacheService> serv = do_GetService(kCacheServiceCID, &rv); + NS_ENSURE_SUCCESS(rv, rv); + + return nsCacheService::GlobalInstance()->EvictEntriesInternal( + nsICache::STORE_OFFLINE); + } + + nsAutoCString jaridsuffix; + jaridsuffix.Append('%'); + + nsAutoCString suffix; + oa->CreateSuffix(suffix); + jaridsuffix.Append('#'); + jaridsuffix.Append(suffix); + + AutoResetStatement statement(mStatement_EnumerateApps); + rv = statement->BindUTF8StringByIndex(0, jaridsuffix); + NS_ENSURE_SUCCESS(rv, rv); + + bool hasRows; + rv = statement->ExecuteStep(&hasRows); + NS_ENSURE_SUCCESS(rv, rv); + + while (hasRows) { + nsAutoCString group; + rv = statement->GetUTF8String(0, group); + NS_ENSURE_SUCCESS(rv, rv); + + nsCString clientID; + rv = statement->GetUTF8String(1, clientID); + NS_ENSURE_SUCCESS(rv, rv); + + nsCOMPtr<nsIRunnable> ev = + new nsOfflineCacheDiscardCache(this, group, clientID); + + rv = nsCacheService::DispatchToCacheIOThread(ev); + NS_ENSURE_SUCCESS(rv, rv); + + rv = statement->ExecuteStep(&hasRows); + NS_ENSURE_SUCCESS(rv, rv); + } + + return NS_OK; +} + +namespace { // anon + +class OriginMatch final : public mozIStorageFunction { + ~OriginMatch() = default; + mozilla::OriginAttributesPattern const mPattern; + + NS_DECL_ISUPPORTS + NS_DECL_MOZISTORAGEFUNCTION + explicit OriginMatch(mozilla::OriginAttributesPattern const& aPattern) + : mPattern(aPattern) {} +}; + +NS_IMPL_ISUPPORTS(OriginMatch, mozIStorageFunction) + +NS_IMETHODIMP +OriginMatch::OnFunctionCall(mozIStorageValueArray* aFunctionArguments, + nsIVariant** aResult) { + nsresult rv; + + nsAutoCString groupId; + rv = aFunctionArguments->GetUTF8String(0, groupId); + NS_ENSURE_SUCCESS(rv, rv); + + int32_t hash = groupId.Find("#"_ns); + if (hash == kNotFound) { + // Just ignore... + return NS_OK; + } + + ++hash; + + nsDependentCSubstring suffix(groupId.BeginReading() + hash, + groupId.Length() - hash); + + mozilla::OriginAttributes oa; + bool ok = oa.PopulateFromSuffix(suffix); + NS_ENSURE_TRUE(ok, NS_ERROR_UNEXPECTED); + + bool match = mPattern.Matches(oa); + + RefPtr<nsVariant> outVar(new nsVariant()); + rv = outVar->SetAsUint32(match ? 1 : 0); + NS_ENSURE_SUCCESS(rv, rv); + + outVar.forget(aResult); + return NS_OK; +} + +} // namespace + +nsresult nsOfflineCacheDevice::Evict( + mozilla::OriginAttributesPattern const& aPattern) { + NS_ENSURE_TRUE(Initialized(), NS_ERROR_NOT_INITIALIZED); + + nsresult rv; + + nsCOMPtr<mozIStorageFunction> function1(new OriginMatch(aPattern)); + rv = mDB->CreateFunction("ORIGIN_MATCH"_ns, 1, function1); + NS_ENSURE_SUCCESS(rv, rv); + + class AutoRemoveFunc { + public: + mozIStorageConnection* mDB; + explicit AutoRemoveFunc(mozIStorageConnection* aDB) : mDB(aDB) {} + ~AutoRemoveFunc() { mDB->RemoveFunction("ORIGIN_MATCH"_ns); } + }; + AutoRemoveFunc autoRemove(mDB); + + nsCOMPtr<mozIStorageStatement> statement; + rv = mDB->CreateStatement( + nsLiteralCString("SELECT GroupID, ActiveClientID FROM moz_cache_groups " + "WHERE ORIGIN_MATCH(GroupID);"), + getter_AddRefs(statement)); + NS_ENSURE_SUCCESS(rv, rv); + + AutoResetStatement statementScope(statement); + + bool hasRows; + rv = statement->ExecuteStep(&hasRows); + NS_ENSURE_SUCCESS(rv, rv); + + while (hasRows) { + nsAutoCString group; + rv = statement->GetUTF8String(0, group); + NS_ENSURE_SUCCESS(rv, rv); + + nsCString clientID; + rv = statement->GetUTF8String(1, clientID); + NS_ENSURE_SUCCESS(rv, rv); + + nsCOMPtr<nsIRunnable> ev = + new nsOfflineCacheDiscardCache(this, group, clientID); + + rv = nsCacheService::DispatchToCacheIOThread(ev); + NS_ENSURE_SUCCESS(rv, rv); + + rv = statement->ExecuteStep(&hasRows); + NS_ENSURE_SUCCESS(rv, rv); + } + + return NS_OK; +} + +bool nsOfflineCacheDevice::CanUseCache(nsIURI* keyURI, + const nsACString& clientID, + nsILoadContextInfo* loadContextInfo) { + { + MutexAutoLock lock(mLock); + if (!mActiveCaches.Contains(clientID)) return false; + } + + nsAutoCString groupID; + nsresult rv = GetGroupForCache(clientID, groupID); + NS_ENSURE_SUCCESS(rv, false); + + nsCOMPtr<nsIURI> groupURI; + rv = NS_NewURI(getter_AddRefs(groupURI), groupID); + if (NS_FAILED(rv)) { + return false; + } + + // When we are choosing an initial cache to load the top + // level document from, the URL of that document must have + // the same origin as the manifest, according to the spec. + // The following check is here because explicit, fallback + // and dynamic entries might have origin different from the + // manifest origin. + if (!NS_SecurityCompareURIs(keyURI, groupURI, GetStrictFileOriginPolicy())) { + return false; + } + + // Check the groupID we found is equal to groupID based + // on the load context demanding load from app cache. + // This is check of extended origin. + + nsAutoCString originSuffix; + loadContextInfo->OriginAttributesPtr()->CreateSuffix(originSuffix); + + nsAutoCString demandedGroupID; + rv = BuildApplicationCacheGroupID(groupURI, originSuffix, demandedGroupID); + NS_ENSURE_SUCCESS(rv, false); + + if (groupID != demandedGroupID) { + return false; + } + + return true; +} + +nsresult nsOfflineCacheDevice::ChooseApplicationCache( + const nsACString& key, nsILoadContextInfo* loadContextInfo, + nsIApplicationCache** out) { + NS_ENSURE_TRUE(Initialized(), NS_ERROR_NOT_INITIALIZED); + + NS_ENSURE_ARG(loadContextInfo); + + nsresult rv; + + *out = nullptr; + + nsCOMPtr<nsIURI> keyURI; + rv = NS_NewURI(getter_AddRefs(keyURI), key); + NS_ENSURE_SUCCESS(rv, rv); + + // First try to find a matching cache entry. + AutoResetStatement statement(mStatement_FindClient); + rv = statement->BindUTF8StringByIndex(0, key); + NS_ENSURE_SUCCESS(rv, rv); + + bool hasRows; + rv = statement->ExecuteStep(&hasRows); + NS_ENSURE_SUCCESS(rv, rv); + + while (hasRows) { + int32_t itemType; + rv = statement->GetInt32(1, &itemType); + NS_ENSURE_SUCCESS(rv, rv); + + if (!(itemType & nsIApplicationCache::ITEM_FOREIGN)) { + nsAutoCString clientID; + rv = statement->GetUTF8String(0, clientID); + NS_ENSURE_SUCCESS(rv, rv); + + if (CanUseCache(keyURI, clientID, loadContextInfo)) { + return GetApplicationCache(clientID, out); + } + } + + rv = statement->ExecuteStep(&hasRows); + NS_ENSURE_SUCCESS(rv, rv); + } + + // OK, we didn't find an exact match. Search for a client with a + // matching namespace. + + AutoResetStatement nsstatement(mStatement_FindClientByNamespace); + + rv = nsstatement->BindUTF8StringByIndex(0, key); + NS_ENSURE_SUCCESS(rv, rv); + + rv = nsstatement->ExecuteStep(&hasRows); + NS_ENSURE_SUCCESS(rv, rv); + + while (hasRows) { + int32_t itemType; + rv = nsstatement->GetInt32(1, &itemType); + NS_ENSURE_SUCCESS(rv, rv); + + // Don't associate with a cache based solely on a whitelist entry + if (!(itemType & nsIApplicationCacheNamespace::NAMESPACE_BYPASS)) { + nsAutoCString clientID; + rv = nsstatement->GetUTF8String(0, clientID); + NS_ENSURE_SUCCESS(rv, rv); + + if (CanUseCache(keyURI, clientID, loadContextInfo)) { + return GetApplicationCache(clientID, out); + } + } + + rv = nsstatement->ExecuteStep(&hasRows); + NS_ENSURE_SUCCESS(rv, rv); + } + + return NS_OK; +} + +nsresult nsOfflineCacheDevice::CacheOpportunistically( + nsIApplicationCache* cache, const nsACString& key) { + NS_ENSURE_ARG_POINTER(cache); + + nsresult rv; + + nsAutoCString clientID; + rv = cache->GetClientID(clientID); + NS_ENSURE_SUCCESS(rv, rv); + + return CacheOpportunistically(clientID, key); +} + +nsresult nsOfflineCacheDevice::ActivateCache(const nsACString& group, + const nsACString& clientID) { + NS_ENSURE_TRUE(Initialized(), NS_ERROR_NOT_INITIALIZED); + + AutoResetStatement statement(mStatement_ActivateClient); + nsresult rv = statement->BindUTF8StringByIndex(0, group); + NS_ENSURE_SUCCESS(rv, rv); + rv = statement->BindUTF8StringByIndex(1, clientID); + NS_ENSURE_SUCCESS(rv, rv); + rv = statement->BindInt32ByIndex(2, SecondsFromPRTime(PR_Now())); + NS_ENSURE_SUCCESS(rv, rv); + + rv = statement->Execute(); + NS_ENSURE_SUCCESS(rv, rv); + + MutexAutoLock lock(mLock); + + nsCString* active; + if (mActiveCachesByGroup.Get(group, &active)) { + mActiveCaches.RemoveEntry(*active); + mActiveCachesByGroup.Remove(group); + active = nullptr; + } + + if (!clientID.IsEmpty()) { + mActiveCaches.PutEntry(clientID); + mActiveCachesByGroup.Put(group, new nsCString(clientID)); + } + + return NS_OK; +} + +bool nsOfflineCacheDevice::IsActiveCache(const nsACString& group, + const nsACString& clientID) { + nsCString* active = nullptr; + MutexAutoLock lock(mLock); + return mActiveCachesByGroup.Get(group, &active) && *active == clientID; +} + +/** + * Preference accessors + */ + +void nsOfflineCacheDevice::SetCacheParentDirectory(nsIFile* parentDir) { + if (Initialized()) { + NS_ERROR("cannot switch cache directory once initialized"); + return; + } + + if (!parentDir) { + mCacheDirectory = nullptr; + return; + } + + // ensure parent directory exists + nsresult rv = EnsureDir(parentDir); + if (NS_FAILED(rv)) { + NS_WARNING("unable to create parent directory"); + return; + } + + mBaseDirectory = parentDir; + + // cache dir may not exist, but that's ok + nsCOMPtr<nsIFile> dir; + rv = parentDir->Clone(getter_AddRefs(dir)); + if (NS_FAILED(rv)) return; + rv = dir->AppendNative("OfflineCache"_ns); + if (NS_FAILED(rv)) return; + + mCacheDirectory = dir; +} + +void nsOfflineCacheDevice::SetCapacity(uint32_t capacity) { + mCacheCapacity = capacity * 1024; +} + +bool nsOfflineCacheDevice::AutoShutdown(nsIApplicationCache* aAppCache) { + if (!mAutoShutdown) return false; + + mAutoShutdown = false; + + Shutdown(); + + nsCOMPtr<nsICacheService> serv = do_GetService(kCacheServiceCID); + RefPtr<nsCacheService> cacheService = nsCacheService::GlobalInstance(); + cacheService->RemoveCustomOfflineDevice(this); + + nsAutoCString clientID; + aAppCache->GetClientID(clientID); + + MutexAutoLock lock(mLock); + mCaches.Remove(clientID); + + return true; +} diff --git a/netwerk/cache/nsDiskCacheDeviceSQL.h b/netwerk/cache/nsDiskCacheDeviceSQL.h new file mode 100644 index 0000000000..772bc21b83 --- /dev/null +++ b/netwerk/cache/nsDiskCacheDeviceSQL.h @@ -0,0 +1,263 @@ +/* vim:set ts=2 sw=2 sts=2 et cin: */ +/* 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/. */ + +#ifndef nsOfflineCacheDevice_h__ +#define nsOfflineCacheDevice_h__ + +#include "nsCacheDevice.h" +#include "nsIApplicationCache.h" +#include "mozIStorageConnection.h" +#include "mozIStorageFunction.h" +#include "nsIFile.h" +#include "nsCOMPtr.h" +#include "nsCOMArray.h" +#include "nsInterfaceHashtable.h" +#include "nsClassHashtable.h" +#include "nsIWeakReference.h" +#include "mozilla/Attributes.h" +#include "mozilla/Mutex.h" + +class nsIURI; +class nsOfflineCacheDevice; +class mozIStorageService; +class nsILoadContextInfo; +namespace mozilla { +class OriginAttributesPattern; +} + +class nsApplicationCacheNamespace final : public nsIApplicationCacheNamespace { + public: + NS_DECL_ISUPPORTS + NS_DECL_NSIAPPLICATIONCACHENAMESPACE + + nsApplicationCacheNamespace() : mItemType(0) {} + + private: + ~nsApplicationCacheNamespace() = default; + + uint32_t mItemType; + nsCString mNamespaceSpec; + nsCString mData; +}; + +class nsOfflineCacheEvictionFunction final : public mozIStorageFunction { + public: + NS_DECL_THREADSAFE_ISUPPORTS + NS_DECL_MOZISTORAGEFUNCTION + + explicit nsOfflineCacheEvictionFunction(nsOfflineCacheDevice* device); + + void Init(); + void Reset(); + void Apply(); + + private: + ~nsOfflineCacheEvictionFunction() = default; + + nsOfflineCacheDevice* mDevice; + bool mTLSInited; +}; + +class nsOfflineCacheDevice final : public nsCacheDevice, public nsISupports { + public: + nsOfflineCacheDevice(); + + NS_DECL_THREADSAFE_ISUPPORTS + + /** + * nsCacheDevice methods + */ + + virtual nsresult Init() override; + nsresult InitWithSqlite(mozIStorageService* ss); + virtual nsresult Shutdown() override; + + virtual const char* GetDeviceID(void) override; + virtual nsCacheEntry* FindEntry(nsCString* key, bool* collision) override; + virtual nsresult DeactivateEntry(nsCacheEntry* entry) override; + virtual nsresult BindEntry(nsCacheEntry* entry) override; + virtual void DoomEntry(nsCacheEntry* entry) override; + + virtual nsresult OpenInputStreamForEntry(nsCacheEntry* entry, + nsCacheAccessMode mode, + uint32_t offset, + nsIInputStream** result) override; + + virtual nsresult OpenOutputStreamForEntry(nsCacheEntry* entry, + nsCacheAccessMode mode, + uint32_t offset, + nsIOutputStream** result) override; + + virtual nsresult GetFileForEntry(nsCacheEntry* entry, + nsIFile** result) override; + + virtual nsresult OnDataSizeChange(nsCacheEntry* entry, + int32_t deltaSize) override; + + virtual nsresult Visit(nsICacheVisitor* visitor) override; + + virtual nsresult EvictEntries(const char* clientID) override; + + /* Entry ownership */ + nsresult GetOwnerDomains(const char* clientID, uint32_t* count, + char*** domains); + nsresult GetOwnerURIs(const char* clientID, const nsACString& ownerDomain, + uint32_t* count, char*** uris); + nsresult SetOwnedKeys(const char* clientID, const nsACString& ownerDomain, + const nsACString& ownerUrl, uint32_t count, + const char** keys); + nsresult GetOwnedKeys(const char* clientID, const nsACString& ownerDomain, + const nsACString& ownerUrl, uint32_t* count, + char*** keys); + nsresult AddOwnedKey(const char* clientID, const nsACString& ownerDomain, + const nsACString& ownerURI, const nsACString& key); + nsresult RemoveOwnedKey(const char* clientID, const nsACString& ownerDomain, + const nsACString& ownerURI, const nsACString& key); + nsresult KeyIsOwned(const char* clientID, const nsACString& ownerDomain, + const nsACString& ownerURI, const nsACString& key, + bool* isOwned); + + nsresult ClearKeysOwnedByDomain(const char* clientID, + const nsACString& ownerDomain); + nsresult EvictUnownedEntries(const char* clientID); + + static nsresult BuildApplicationCacheGroupID(nsIURI* aManifestURL, + nsACString const& aOriginSuffix, + nsACString& _result); + + nsresult ActivateCache(const nsACString& group, const nsACString& clientID); + bool IsActiveCache(const nsACString& group, const nsACString& clientID); + nsresult CreateApplicationCache(const nsACString& group, + nsIApplicationCache** out); + + nsresult GetApplicationCache(const nsACString& clientID, + nsIApplicationCache** out); + nsresult GetApplicationCache_Unlocked(const nsACString& clientID, + nsIApplicationCache** out); + + nsresult GetActiveCache(const nsACString& group, nsIApplicationCache** out); + + nsresult DeactivateGroup(const nsACString& group); + + nsresult ChooseApplicationCache(const nsACString& key, + nsILoadContextInfo* loadContext, + nsIApplicationCache** out); + + nsresult CacheOpportunistically(nsIApplicationCache* cache, + const nsACString& key); + + nsresult Evict(nsILoadContextInfo* aInfo); + nsresult Evict(mozilla::OriginAttributesPattern const& aPattern); + + nsresult GetGroups(nsTArray<nsCString>& keys); + + nsresult GetGroupsTimeOrdered(nsTArray<nsCString>& keys); + + bool IsLocked(const nsACString& key); + void Lock(const nsACString& key); + void Unlock(const nsACString& key); + + /** + * Preference accessors + */ + + void SetCacheParentDirectory(nsIFile* parentDir); + void SetCapacity(uint32_t capacity); + void SetAutoShutdown() { mAutoShutdown = true; } + bool AutoShutdown(nsIApplicationCache* aAppCache); + + nsIFile* BaseDirectory() { return mBaseDirectory; } + nsIFile* CacheDirectory() { return mCacheDirectory; } + uint32_t CacheCapacity() { return mCacheCapacity; } + uint32_t CacheSize(); + uint32_t EntryCount(); + + private: + ~nsOfflineCacheDevice() = default; + + friend class nsApplicationCache; + + static bool GetStrictFileOriginPolicy(); + + bool Initialized() { return mDB != nullptr; } + + nsresult InitActiveCaches(); + nsresult UpdateEntry(nsCacheEntry* entry); + nsresult UpdateEntrySize(nsCacheEntry* entry, uint32_t newSize); + nsresult DeleteEntry(nsCacheEntry* entry, bool deleteData); + nsresult DeleteData(nsCacheEntry* entry); + nsresult EnableEvictionObserver(); + nsresult DisableEvictionObserver(); + + bool CanUseCache(nsIURI* keyURI, const nsACString& clientID, + nsILoadContextInfo* loadContext); + + nsresult MarkEntry(const nsCString& clientID, const nsACString& key, + uint32_t typeBits); + nsresult UnmarkEntry(const nsCString& clientID, const nsACString& key, + uint32_t typeBits); + + nsresult CacheOpportunistically(const nsCString& clientID, + const nsACString& key); + nsresult GetTypes(const nsCString& clientID, const nsACString& key, + uint32_t* typeBits); + + nsresult GetMatchingNamespace(const nsCString& clientID, + const nsACString& key, + nsIApplicationCacheNamespace** out); + nsresult GatherEntries(const nsCString& clientID, uint32_t typeBits, + nsTArray<nsCString>& keys); + nsresult AddNamespace(const nsCString& clientID, + nsIApplicationCacheNamespace* ns); + + nsresult GetUsage(const nsACString& clientID, uint32_t* usage); + + nsresult RunSimpleQuery(mozIStorageStatement* statment, uint32_t resultIndex, + nsTArray<nsCString>& values); + + nsCOMPtr<mozIStorageConnection> mDB; + RefPtr<nsOfflineCacheEvictionFunction> mEvictionFunction; + + nsCOMPtr<mozIStorageStatement> mStatement_CacheSize; + nsCOMPtr<mozIStorageStatement> mStatement_ApplicationCacheSize; + nsCOMPtr<mozIStorageStatement> mStatement_EntryCount; + nsCOMPtr<mozIStorageStatement> mStatement_UpdateEntry; + nsCOMPtr<mozIStorageStatement> mStatement_UpdateEntrySize; + nsCOMPtr<mozIStorageStatement> mStatement_DeleteEntry; + nsCOMPtr<mozIStorageStatement> mStatement_FindEntry; + nsCOMPtr<mozIStorageStatement> mStatement_BindEntry; + nsCOMPtr<mozIStorageStatement> mStatement_ClearDomain; + nsCOMPtr<mozIStorageStatement> mStatement_MarkEntry; + nsCOMPtr<mozIStorageStatement> mStatement_UnmarkEntry; + nsCOMPtr<mozIStorageStatement> mStatement_GetTypes; + nsCOMPtr<mozIStorageStatement> mStatement_FindNamespaceEntry; + nsCOMPtr<mozIStorageStatement> mStatement_InsertNamespaceEntry; + nsCOMPtr<mozIStorageStatement> mStatement_CleanupUnmarked; + nsCOMPtr<mozIStorageStatement> mStatement_GatherEntries; + nsCOMPtr<mozIStorageStatement> mStatement_ActivateClient; + nsCOMPtr<mozIStorageStatement> mStatement_DeactivateGroup; + nsCOMPtr<mozIStorageStatement> mStatement_FindClient; + nsCOMPtr<mozIStorageStatement> mStatement_FindClientByNamespace; + nsCOMPtr<mozIStorageStatement> mStatement_EnumerateApps; + nsCOMPtr<mozIStorageStatement> mStatement_EnumerateGroups; + nsCOMPtr<mozIStorageStatement> mStatement_EnumerateGroupsTimeOrder; + + nsCOMPtr<nsIFile> mBaseDirectory; + nsCOMPtr<nsIFile> mCacheDirectory; + uint32_t mCacheCapacity; // in bytes + int32_t mDeltaCounter; + bool mAutoShutdown; + + mozilla::Mutex mLock; + + nsInterfaceHashtable<nsCStringHashKey, nsIWeakReference> mCaches; + nsClassHashtable<nsCStringHashKey, nsCString> mActiveCachesByGroup; + nsTHashtable<nsCStringHashKey> mActiveCaches; + nsTHashtable<nsCStringHashKey> mLockedEntries; + + nsCOMPtr<nsIEventTarget> mInitEventTarget; +}; + +#endif // nsOfflineCacheDevice_h__ diff --git a/netwerk/cache/nsICache.idl b/netwerk/cache/nsICache.idl new file mode 100644 index 0000000000..cd14c98312 --- /dev/null +++ b/netwerk/cache/nsICache.idl @@ -0,0 +1,142 @@ +/* -*- Mode: IDL; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * + * 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 "nsISupports.idl" + +typedef long nsCacheStoragePolicy; +typedef long nsCacheAccessMode; + +/** + * nsICache is a namespace for various cache constants. It does not represent + * an actual object. + */ +[builtinclass, uuid(d6c67f38-b39a-4582-8a48-4c4f8a56dfd0)] +interface nsICache : nsISupports +{ + /** + * Access Modes + * + * + * Mode Requested | Not Cached | Cached + * ------------------------------------------------------------------------ + * READ | KEY_NOT_FOUND | NS_OK + * | Mode = NONE | Mode = READ + * | No Descriptor | Descriptor + * ------------------------------------------------------------------------ + * WRITE | NS_OK | NS_OK (Cache service + * | Mode = WRITE | Mode = WRITE dooms existing + * | Descriptor | Descriptor cache entry) + * ------------------------------------------------------------------------ + * READ_WRITE | NS_OK | NS_OK + * (1st req.) | Mode = WRITE | Mode = READ_WRITE + * | Descriptor | Descriptor + * ------------------------------------------------------------------------ + * READ_WRITE | N/A | NS_OK + * (Nth req.) | | Mode = READ + * | | Descriptor + * ------------------------------------------------------------------------ + * + * + * Access Requested: + * + * READ - I only want to READ, if there isn't an entry just fail + * WRITE - I have something new I want to write into the cache, make + * me a new entry and doom the old one, if any. + * READ_WRITE - I want to READ, but I'm willing to update an existing + * entry if necessary, or create a new one if none exists. + * + * + * Access Granted: + * + * NONE - No descriptor is provided. You get zilch. Nada. Nothing. + * READ - You can READ from this descriptor. + * WRITE - You must WRITE to this descriptor because the cache entry + * was just created for you. + * READ_WRITE - You can READ the descriptor to determine if it's valid, + * you may WRITE if it needs updating. + * + * + * Comments: + * + * If you think that you might need to modify cached data or meta data, + * then you must open a cache entry requesting WRITE access. Only one + * cache entry descriptor, per cache entry, will be granted WRITE access. + * + * Usually, you will request READ_WRITE access in order to first test the + * meta data and informational fields to determine if a write (ie. going + * to the net) may actually be necessary. If you determine that it is + * not, then you would mark the cache entry as valid (using MarkValid) and + * then simply read the data from the cache. + * + * A descriptor granted WRITE access has exclusive access to the cache + * entry up to the point at which it marks it as valid. Once the cache + * entry has been "validated", other descriptors with READ access may be + * opened to the cache entry. + * + * If you make a request for READ_WRITE access to a cache entry, the cache + * service will downgrade your access to READ if there is already a + * cache entry descriptor open with WRITE access. + * + * If you make a request for only WRITE access to a cache entry and another + * descriptor with WRITE access is currently open, then the existing cache + * entry will be 'doomed', and you will be given a descriptor (with WRITE + * access only) to a new cache entry. + * + */ + const nsCacheAccessMode ACCESS_NONE = 0; + const nsCacheAccessMode ACCESS_READ = 1; + const nsCacheAccessMode ACCESS_WRITE = 2; + const nsCacheAccessMode ACCESS_READ_WRITE = 3; + + /** + * Storage Policy + * + * The storage policy of a cache entry determines the device(s) to which + * it belongs. See nsICacheSession and nsICacheEntryDescriptor for more + * details. + * + * STORE_ANYWHERE - Allows the cache entry to be stored in any device. + * The cache service decides which cache device to use + * based on "some resource management calculation." + * STORE_IN_MEMORY - Requires the cache entry to reside in non-persistent + * storage (ie. typically in system RAM). + * STORE_ON_DISK - Requires the cache entry to reside in persistent + * storage (ie. typically on a system's hard disk). + * STORE_OFFLINE - Requires the cache entry to reside in persistent, + * reliable storage for offline use. + */ + const nsCacheStoragePolicy STORE_ANYWHERE = 0; + const nsCacheStoragePolicy STORE_IN_MEMORY = 1; + const nsCacheStoragePolicy STORE_ON_DISK = 2; + // value 3 was used by STORE_ON_DISK_AS_FILE which was removed + const nsCacheStoragePolicy STORE_OFFLINE = 4; + + /** + * All entries for a cache session are stored as streams of data or + * as objects. These constant my be used to specify the type of entries + * when calling nsICacheService::CreateSession(). + */ + const long NOT_STREAM_BASED = 0; + const long STREAM_BASED = 1; + + /** + * The synchronous OpenCacheEntry() may be blocking or non-blocking. If a cache entry is + * waiting to be validated by another cache descriptor (so no new cache descriptors for that + * key can be created, OpenCacheEntry() will return NS_ERROR_CACHE_WAIT_FOR_VALIDATION in + * non-blocking mode. In blocking mode, it will wait until the cache entry for the key has + * been validated or doomed. If the cache entry is validated, then a descriptor for that + * entry will be created and returned. If the cache entry was doomed, then a descriptor + * will be created for a new cache entry for the key. + */ + const long NON_BLOCKING = 0; + const long BLOCKING = 1; + + /** + * Constant meaning no expiration time. + */ + const unsigned long NO_EXPIRATION_TIME = 0xFFFFFFFF; +}; + diff --git a/netwerk/cache/nsICacheEntryDescriptor.idl b/netwerk/cache/nsICacheEntryDescriptor.idl new file mode 100644 index 0000000000..085ab388a8 --- /dev/null +++ b/netwerk/cache/nsICacheEntryDescriptor.idl @@ -0,0 +1,164 @@ +/* -*- Mode: IDL; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * + * 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 "nsICacheVisitor.idl" +#include "nsICache.idl" + +interface nsISimpleEnumerator; +interface nsICacheListener; +interface nsIInputStream; +interface nsIOutputStream; +interface nsIFile; +interface nsICacheMetaDataVisitor; + + +[scriptable, uuid(90b17d31-46aa-4fb1-a206-473c966cbc18)] +interface nsICacheEntryDescriptor : nsICacheEntryInfo +{ + /** + * Set the time at which the cache entry should be considered invalid (in + * seconds since the Epoch). + */ + void setExpirationTime(in uint32_t expirationTime); + + /** + * Set the cache entry data size. This will fail if the cache entry + * IS stream based. + */ + void setDataSize(in unsigned long size); + + /** + * Open blocking input stream to cache data. This will fail if the cache + * entry IS NOT stream based. Use the stream transport service to + * asynchronously read this stream on a background thread. The returned + * stream MAY implement nsISeekableStream. + * + * @param offset + * read starting from this offset into the cached data. an offset + * beyond the end of the stream has undefined consequences. + * + * @return blocking, unbuffered input stream. + */ + nsIInputStream openInputStream(in unsigned long offset); + + /** + * Open blocking output stream to cache data. This will fail if the cache + * entry IS NOT stream based. Use the stream transport service to + * asynchronously write to this stream on a background thread. The returned + * stream MAY implement nsISeekableStream. + * + * If opening an output stream to existing cached data, the data will be + * truncated to the specified offset. + * + * @param offset + * write starting from this offset into the cached data. an offset + * beyond the end of the stream has undefined consequences. + * + * @return blocking, unbuffered output stream. + */ + nsIOutputStream openOutputStream(in unsigned long offset); + + /** + * Get/set the cache data element. This will fail if the cache entry + * IS stream based. The cache entry holds a strong reference to this + * object. The object will be released when the cache entry is destroyed. + */ + attribute nsISupports cacheElement; + + /** + * Stores the Content-Length specified in the HTTP header for this + * entry. Checked before we write to the cache entry, to prevent ever + * taking up space in the cache for an entry that we know up front + * is going to have to be evicted anyway. See bug 588507. + */ + attribute int64_t predictedDataSize; + + /** + * Get the access granted to this descriptor. See nsICache.idl for the + * definitions of the access modes and a thorough description of their + * corresponding meanings. + */ + readonly attribute nsCacheAccessMode accessGranted; + + /** + * Get/set the storage policy of the cache entry. See nsICache.idl for + * the definitions of the storage policies. + */ + attribute nsCacheStoragePolicy storagePolicy; + + /** + * Get the disk file associated with the cache entry. + */ + readonly attribute nsIFile file; + + /** + * Get/set security info on the cache entry for this descriptor. This fails + * if the storage policy is not STORE_IN_MEMORY. + */ + attribute nsISupports securityInfo; + + /** + * Get the size of the cache entry data, as stored. This may differ + * from the entry's dataSize, if the entry is compressed. + */ + readonly attribute unsigned long storageDataSize; + + /** + * Doom the cache entry this descriptor references in order to slate it for + * removal. Once doomed a cache entry cannot be undoomed. + * + * A descriptor with WRITE access can doom the cache entry and choose to + * fail pending requests. This means that pending requests will not get + * a cache descriptor. This is meant as a tool for clients that wish to + * instruct pending requests to skip the cache. + */ + void doom(); + void doomAndFailPendingRequests(in nsresult status); + + /** + * Asynchronously doom an entry. Listener will be notified about the status + * of the operation. Null may be passed if caller doesn't care about the + * result. + */ + void asyncDoom(in nsICacheListener listener); + + /** + * A writer must validate this cache object before any readers are given + * a descriptor to the object. + */ + void markValid(); + + /** + * Explicitly close the descriptor (optional). + */ + + void close(); + + /** + * Methods for accessing meta data. Meta data is a table of key/value + * string pairs. The strings do not have to conform to any particular + * charset, but they must be null terminated. + */ + string getMetaDataElement(in string key); + void setMetaDataElement(in string key, in string value); + + /** + * Visitor will be called with key/value pair for each meta data element. + */ + void visitMetaData(in nsICacheMetaDataVisitor visitor); +}; + + + +[scriptable, uuid(22f9a49c-3cf8-4c23-8006-54efb11ac562)] +interface nsICacheMetaDataVisitor : nsISupports +{ + /** + * Called for each key/value pair in the meta data for a cache entry + */ + boolean visitMetaDataElement(in string key, + in string value); +}; diff --git a/netwerk/cache/nsICacheListener.idl b/netwerk/cache/nsICacheListener.idl new file mode 100644 index 0000000000..cfb2dd4708 --- /dev/null +++ b/netwerk/cache/nsICacheListener.idl @@ -0,0 +1,32 @@ +/* -*- Mode: IDL; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * + * 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 "nsISupports.idl" +#include "nsICache.idl" + + +interface nsICacheEntryDescriptor; + +[scriptable, uuid(8eadf2ed-8cac-4961-8025-6da6d5827e74)] +interface nsICacheListener : nsISupports +{ + /** + * Called when the requested access (or appropriate subset) is + * acquired. The status parameter equals NS_OK on success. + * See nsICacheService.idl for accessGranted values. + */ + void onCacheEntryAvailable(in nsICacheEntryDescriptor descriptor, + in nsCacheAccessMode accessGranted, + in nsresult status); + + /** + * Called when nsCacheSession::DoomEntry() is completed. The status + * parameter is NS_OK when the entry was doomed, or NS_ERROR_NOT_AVAILABLE + * when there is no such entry. + */ + void onCacheEntryDoomed(in nsresult status); +}; diff --git a/netwerk/cache/nsICacheService.idl b/netwerk/cache/nsICacheService.idl new file mode 100644 index 0000000000..c062a7910f --- /dev/null +++ b/netwerk/cache/nsICacheService.idl @@ -0,0 +1,98 @@ +/* -*- Mode: IDL; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * + * 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 "nsISupports.idl" +#include "nsICache.idl" + +interface nsISimpleEnumerator; +interface nsICacheListener; +interface nsICacheSession; +interface nsICacheVisitor; +interface nsIEventTarget; + +/** + * @deprecated + * + * IMPORTANT NOTE: THIS INTERFACE IS NO LONGER SUPPORTED AND PLANNED TO BE + * REMOVED SOON. WE STRONGLY ENCORAGE TO MIGRATE THE EXISTING CODE AND FOR + * THE NEW CODE USE ONLY THE NEW HTTP CACHE API IN netwerk/cache2/. + */ +[scriptable, uuid(14dbe1e9-f3bc-45af-92f4-2c574fcd4e39)] +interface nsICacheService : nsISupports +{ + /** + * @throws NS_ERROR_NOT_IMPLEMENTED when the cache v2 is prefered to use. + * + * Create a cache session + * + * A cache session represents a client's access into the cache. The cache + * session is not "owned" by the cache service. Hence, it is possible to + * create duplicate cache sessions. Entries created by a cache session + * are invisible to other cache sessions, unless the cache sessions are + * equivalent. + * + * @param clientID - Specifies the name of the client using the cache. + * @param storagePolicy - Limits the storage policy for all entries + * accessed via the returned session. As a result, devices excluded + * by the storage policy will not be searched when opening entries + * from the returned session. + * @param streamBased - Indicates whether or not the data being cached + * can be represented as a stream. The storagePolicy must be + * consistent with the value of this field. For example, a non-stream- + * based cache entry can only have a storage policy of STORE_IN_MEMORY. + * @return new cache session. + */ + nsICacheSession createSession(in string clientID, + in nsCacheStoragePolicy storagePolicy, + in boolean streamBased); + + /** + * @throws NS_ERROR_NOT_IMPLEMENTED when the cache v2 is prefered to use. + * + * Visit entries stored in the cache. Used to implement about:cache. + */ + void visitEntries(in nsICacheVisitor visitor); + + /** + * @throws NS_ERROR_NOT_IMPLEMENTED when the cache v2 is prefered to use. + * + * Evicts all entries in all devices implied by the storage policy. + * + * @note This function may evict some items but will throw if it fails to evict + * everything. + */ + void evictEntries(in nsCacheStoragePolicy storagePolicy); + + /** + * Event target which is used for I/O operations + */ + readonly attribute nsIEventTarget cacheIOTarget; +}; + +%{C++ +/** + * Observer service notification that is sent when + * nsICacheService::evictEntries() or nsICacheSession::evictEntries() + * is called. + */ +#define NS_CACHESERVICE_EMPTYCACHE_TOPIC_ID "cacheservice:empty-cache" +%} + +[scriptable, builtinclass, uuid(d0fc8d38-db80-4928-bf1c-b0085ddfa9dc)] +interface nsICacheServiceInternal : nsICacheService +{ + /** + * This is an internal interface. It changes so frequently that it probably + * went away while you were reading this. + */ + + /** + * Milliseconds for which the service lock has been held. 0 if unlocked. + */ + readonly attribute double lockHeldTime; +}; + + diff --git a/netwerk/cache/nsICacheSession.idl b/netwerk/cache/nsICacheSession.idl new file mode 100644 index 0000000000..cb8871c28d --- /dev/null +++ b/netwerk/cache/nsICacheSession.idl @@ -0,0 +1,88 @@ +/* -*- Mode: IDL; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * + * 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 "nsISupports.idl" +#include "nsICache.idl" + +interface nsICacheEntryDescriptor; +interface nsICacheListener; +interface nsIFile; + +[scriptable, uuid(1dd7708c-de48-4ffe-b5aa-cd218c762887)] +interface nsICacheSession : nsISupports +{ + /** + * Expired entries will be doomed or evicted if this attribute is set to + * true. If false, expired entries will be returned (useful for offline- + * mode and clients, such as HTTP, that can update the valid lifetime of + * cached content). This attribute defaults to true. + */ + attribute boolean doomEntriesIfExpired; + + /** + * When set, entries created with this session will be placed to a cache + * based at this directory. Use when storing entries to a different + * profile than the active profile of the the current running application + * process. + */ + attribute nsIFile profileDirectory; + + /** + * A cache session can only give out one descriptor with WRITE access + * to a given cache entry at a time. Until the client calls MarkValid on + * its descriptor, other attempts to open the same cache entry will block. + */ + + /** + * Synchronous cache access. This method fails if it is called on the main + * thread. Use asyncOpenCacheEntry() instead. This returns a unique + * descriptor each time it is called, even if the same key is specified. + * When called by multiple threads for write access, only one writable + * descriptor will be granted. If 'blockingMode' is set to false, it will + * return NS_ERROR_CACHE_WAIT_FOR_VALIDATION rather than block when another + * descriptor has been given WRITE access but hasn't validated the entry yet. + */ + nsICacheEntryDescriptor openCacheEntry(in ACString key, + in nsCacheAccessMode accessRequested, + in boolean blockingMode); + + /** + * Asynchronous cache access. Does not block the calling thread. Instead, + * the listener will be notified when the descriptor is available. If + * 'noWait' is set to true, the listener will be notified immediately with + * status NS_ERROR_CACHE_WAIT_FOR_VALIDATION rather than queuing the request + * when another descriptor has been given WRITE access but hasn't validated + * the entry yet. + */ + void asyncOpenCacheEntry(in ACString key, + in nsCacheAccessMode accessRequested, + in nsICacheListener listener, + [optional] in boolean noWait); + + /** + * Evict all entries for this session's clientID according to its storagePolicy. + */ + void evictEntries(); + + /** + * Return whether any of the cache devices implied by the session storage policy + * are currently enabled for instantiation if they don't already exist. + */ + boolean isStorageEnabled(); + + /** + * Asynchronously doom an entry specified by the key. Listener will be + * notified about the status of the operation. Null may be passed if caller + * doesn't care about the result. + */ + void doomEntry(in ACString key, in nsICacheListener listener); + + /** + * Private entries will be doomed when the last private browsing session + * finishes. + */ + attribute boolean isPrivate; +}; diff --git a/netwerk/cache/nsICacheVisitor.idl b/netwerk/cache/nsICacheVisitor.idl new file mode 100644 index 0000000000..56b503d430 --- /dev/null +++ b/netwerk/cache/nsICacheVisitor.idl @@ -0,0 +1,123 @@ +/* -*- Mode: IDL; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * + * 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 "nsISupports.idl" + +/* XXX we should define device and entry info as well (stats, etc) */ + +interface nsICacheDeviceInfo; +interface nsICacheEntryInfo; + + +[scriptable, uuid(f8c08c4b-d778-49d1-a59b-866fdc500d95)] +interface nsICacheVisitor : nsISupports +{ + /** + * Called to provide information about a cache device. + * + * @param deviceID - specifies the device being visited. + * @param deviceInfo - specifies information about this device. + * + * @return true to start visiting all entries for this device. + * @return false to advance to the next device. + */ + boolean visitDevice(in string deviceID, + in nsICacheDeviceInfo deviceInfo); + + /** + * Called to provide information about a cache entry. + * + * @param deviceID - specifies the device being visited. + * @param entryInfo - specifies information about this entry. + * + * @return true to visit the next entry on the current device, or if the + * end of the device has been reached, advance to the next device. + * @return false to advance to the next device. + */ + boolean visitEntry(in string deviceID, + in nsICacheEntryInfo entryInfo); +}; + + +[scriptable, uuid(31d1c294-1dd2-11b2-be3a-c79230dca297)] +interface nsICacheDeviceInfo : nsISupports +{ + /** + * Get a human readable description of the cache device. + */ + readonly attribute ACString description; + + /** + * Get a usage report, statistics, miscellaneous data about + * the cache device. + */ + readonly attribute ACString usageReport; + + /** + * Get the number of stored cache entries. + */ + readonly attribute unsigned long entryCount; + + /** + * Get the total size of the stored cache entries. + */ + readonly attribute unsigned long totalSize; + + /** + * Get the upper limit of the size of the data the cache can store. + */ + readonly attribute unsigned long maximumSize; +}; + + +[scriptable, uuid(fab51c92-95c3-4468-b317-7de4d7588254)] +interface nsICacheEntryInfo : nsISupports +{ + /** + * Get the client id associated with this cache entry. + */ + readonly attribute ACString clientID; + + /** + * Get the id for the device that stores this cache entry. + */ + readonly attribute ACString deviceID; + + /** + * Get the key identifying the cache entry. + */ + readonly attribute ACString key; + + /** + * Get the number of times the cache entry has been opened. + */ + readonly attribute long fetchCount; + + /** + * Get the last time the cache entry was opened (in seconds since the Epoch). + */ + readonly attribute uint32_t lastFetched; + + /** + * Get the last time the cache entry was modified (in seconds since the Epoch). + */ + readonly attribute uint32_t lastModified; + + /** + * Get the expiration time of the cache entry (in seconds since the Epoch). + */ + readonly attribute uint32_t expirationTime; + + /** + * Get the cache entry data size. + */ + readonly attribute unsigned long dataSize; + + /** + * Find out whether or not the cache entry is stream based. + */ + boolean isStreamBased(); +}; |