Source code
Revision control
Copy as Markdown
Other Tools
/* -*- 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
#include <string.h>
#include "nsJARInputStream.h"
#include "nsJAR.h"
#include "nsIFile.h"
#include "nsIObserverService.h"
#include "mozilla/DebugOnly.h"
#include "mozilla/Logging.h"
#include "mozilla/Omnijar.h"
#include "mozilla/Unused.h"
#ifdef XP_UNIX
# include <sys/stat.h>
#elif defined(XP_WIN)
# include <io.h>
#endif
using namespace mozilla;
static LazyLogModule gJarLog("nsJAR");
#ifdef LOG
# undef LOG
#endif
#ifdef LOG_ENABLED
# undef LOG_ENABLED
#endif
#define LOG(args) MOZ_LOG(gJarLog, mozilla::LogLevel::Debug, args)
#define LOG_ENABLED() MOZ_LOG_TEST(gJarLog, mozilla::LogLevel::Debug)
//----------------------------------------------
// nsJAR constructor/destructor
//----------------------------------------------
// The following initialization makes a guess of 10 entries per jarfile.
nsJAR::nsJAR()
: mReleaseTime(PR_INTERVAL_NO_TIMEOUT),
mLock("nsJAR::mLock"),
mCache(nullptr) {}
nsJAR::~nsJAR() { Close(); }
NS_IMPL_QUERY_INTERFACE(nsJAR, nsIZipReader)
NS_IMPL_ADDREF(nsJAR)
// Custom Release method works with nsZipReaderCache...
// Release might be called from multi-thread, we have to
// take this function carefully to avoid delete-after-use.
MozExternalRefCountType nsJAR::Release(void) {
nsrefcnt count;
MOZ_ASSERT(0 != mRefCnt, "dup release");
RefPtr<nsZipReaderCache> cache;
if (mRefCnt == 2) { // don't use a lock too frequently
// Use a mutex here to guarantee mCache is not racing and the target
// instance is still valid to increase ref-count.
RecursiveMutexAutoLock lock(mLock);
cache = mCache;
mCache = nullptr;
}
if (cache) {
DebugOnly<nsresult> rv = cache->ReleaseZip(this);
MOZ_ASSERT(NS_SUCCEEDED(rv), "failed to release zip file");
}
count = --mRefCnt; // don't access any member variable after this line
NS_LOG_RELEASE(this, count, "nsJAR");
if (0 == count) {
mRefCnt = 1; /* stabilize */
/* enable this to find non-threadsafe destructors: */
/* NS_ASSERT_OWNINGTHREAD(nsJAR); */
delete this;
return 0;
}
return count;
}
//----------------------------------------------
// nsIZipReader implementation
//----------------------------------------------
NS_IMETHODIMP
nsJAR::Open(nsIFile* zipFile) {
NS_ENSURE_ARG_POINTER(zipFile);
RecursiveMutexAutoLock lock(mLock);
LOG(("Open[%p] %s", this, zipFile->HumanReadablePath().get()));
if (mZip) return NS_ERROR_FAILURE; // Already open!
mZipFile = zipFile;
mOuterZipEntry.Truncate();
// The omnijar is special, it is opened early on and closed late
RefPtr<nsZipArchive> zip = mozilla::Omnijar::GetReader(zipFile);
if (!zip) {
zip = nsZipArchive::OpenArchive(zipFile);
}
mZip = zip;
return mZip ? NS_OK : NS_ERROR_FAILURE;
}
NS_IMETHODIMP
nsJAR::OpenInner(nsIZipReader* aZipReader, const nsACString& aZipEntry) {
nsresult rv;
LOG(("OpenInner[%p] %s", this, PromiseFlatCString(aZipEntry).get()));
NS_ENSURE_ARG_POINTER(aZipReader);
nsCOMPtr<nsIFile> zipFile;
rv = aZipReader->GetFile(getter_AddRefs(zipFile));
NS_ENSURE_SUCCESS(rv, rv);
RefPtr<nsZipArchive> innerZip =
mozilla::Omnijar::GetInnerReader(zipFile, aZipEntry);
if (innerZip) {
RecursiveMutexAutoLock lock(mLock);
if (mZip) {
return NS_ERROR_FAILURE;
}
mZip = innerZip;
return NS_OK;
}
bool exist;
rv = aZipReader->HasEntry(aZipEntry, &exist);
NS_ENSURE_SUCCESS(rv, rv);
NS_ENSURE_TRUE(exist, NS_ERROR_FILE_NOT_FOUND);
RefPtr<nsZipHandle> handle;
{
nsJAR* outerJAR = static_cast<nsJAR*>(aZipReader);
RecursiveMutexAutoLock outerLock(outerJAR->mLock);
rv = nsZipHandle::Init(outerJAR->mZip.get(),
PromiseFlatCString(aZipEntry).get(),
getter_AddRefs(handle));
NS_ENSURE_SUCCESS(rv, rv);
}
RecursiveMutexAutoLock lock(mLock);
MOZ_ASSERT(!mZip, "Another thread tried to open this nsJAR racily!");
mZipFile = zipFile.forget();
mOuterZipEntry.Assign(aZipEntry);
mZip = nsZipArchive::OpenArchive(handle);
return mZip ? NS_OK : NS_ERROR_FAILURE;
}
NS_IMETHODIMP
nsJAR::OpenMemory(void* aData, uint32_t aLength) {
NS_ENSURE_ARG_POINTER(aData);
RecursiveMutexAutoLock lock(mLock);
if (mZip) return NS_ERROR_FAILURE; // Already open!
RefPtr<nsZipHandle> handle;
nsresult rv = nsZipHandle::Init(static_cast<uint8_t*>(aData), aLength,
getter_AddRefs(handle));
if (NS_FAILED(rv)) return rv;
mZip = nsZipArchive::OpenArchive(handle);
return mZip ? NS_OK : NS_ERROR_FAILURE;
}
NS_IMETHODIMP
nsJAR::GetFile(nsIFile** result) {
RecursiveMutexAutoLock lock(mLock);
LOG(("GetFile[%p]", this));
*result = mZipFile;
NS_IF_ADDREF(*result);
return NS_OK;
}
NS_IMETHODIMP
nsJAR::Close() {
RecursiveMutexAutoLock lock(mLock);
LOG(("Close[%p]", this));
if (!mZip) {
return NS_ERROR_FAILURE; // Never opened or already closed.
}
mZip = nullptr;
return NS_OK;
}
NS_IMETHODIMP
nsJAR::Test(const nsACString& aEntryName) {
RecursiveMutexAutoLock lock(mLock);
if (!mZip) {
return NS_ERROR_FAILURE;
}
return mZip->Test(
aEntryName.IsEmpty() ? nullptr : PromiseFlatCString(aEntryName).get());
}
NS_IMETHODIMP
nsJAR::Extract(const nsACString& aEntryName, nsIFile* outFile) {
// nsZipArchive and zlib are not thread safe
// we need to use a lock to prevent bug #51267
RecursiveMutexAutoLock lock(mLock);
if (!mZip) {
return NS_ERROR_FAILURE;
}
LOG(("Extract[%p] %s", this, PromiseFlatCString(aEntryName).get()));
nsZipItem* item = mZip->GetItem(PromiseFlatCString(aEntryName).get());
NS_ENSURE_TRUE(item, NS_ERROR_FILE_NOT_FOUND);
// Remove existing file or directory so we set permissions correctly.
// If it's a directory that already exists and contains files, throw
// an exception and return.
nsresult rv = outFile->Remove(false);
if (rv == NS_ERROR_FILE_DIR_NOT_EMPTY || rv == NS_ERROR_FAILURE) return rv;
if (item->IsDirectory()) {
rv = outFile->Create(nsIFile::DIRECTORY_TYPE, item->Mode());
// XXX Do this in nsZipArchive? It would be nice to keep extraction
// XXX code completely there, but that would require a way to get a
// XXX PRDir from outFile.
} else {
PRFileDesc* fd;
rv = outFile->OpenNSPRFileDesc(PR_WRONLY | PR_CREATE_FILE, item->Mode(),
&fd);
if (NS_FAILED(rv)) return rv;
// ExtractFile also closes the fd handle and resolves the symlink if needed
rv = mZip->ExtractFile(item, outFile, fd);
}
if (NS_FAILED(rv)) return rv;
// nsIFile needs milliseconds, while prtime is in microseconds.
// non-fatal if this fails, ignore errors
outFile->SetLastModifiedTime(item->LastModTime() / PR_USEC_PER_MSEC);
return NS_OK;
}
NS_IMETHODIMP
nsJAR::GetEntry(const nsACString& aEntryName, nsIZipEntry** result) {
RecursiveMutexAutoLock lock(mLock);
LOG(("GetEntry[%p] %s", this, PromiseFlatCString(aEntryName).get()));
if (!mZip) {
return NS_ERROR_FAILURE;
}
nsZipItem* zipItem = mZip->GetItem(PromiseFlatCString(aEntryName).get());
NS_ENSURE_TRUE(zipItem, NS_ERROR_FILE_NOT_FOUND);
nsJARItem* jarItem = new nsJARItem(zipItem);
NS_ADDREF(*result = jarItem);
return NS_OK;
}
NS_IMETHODIMP
nsJAR::HasEntry(const nsACString& aEntryName, bool* result) {
RecursiveMutexAutoLock lock(mLock);
LOG(("HasEntry[%p] %s", this, PromiseFlatCString(aEntryName).get()));
if (!mZip) {
return NS_ERROR_FAILURE;
}
*result = mZip->GetItem(PromiseFlatCString(aEntryName).get()) != nullptr;
return NS_OK;
}
NS_IMETHODIMP
nsJAR::FindEntries(const nsACString& aPattern,
nsIUTF8StringEnumerator** result) {
NS_ENSURE_ARG_POINTER(result);
RecursiveMutexAutoLock lock(mLock);
LOG(("FindEntries[%p] %s", this, PromiseFlatCString(aPattern).get()));
if (!mZip) {
return NS_ERROR_FAILURE;
}
nsZipFind* find;
nsresult rv = mZip->FindInit(
aPattern.IsEmpty() ? nullptr : PromiseFlatCString(aPattern).get(), &find);
NS_ENSURE_SUCCESS(rv, rv);
nsIUTF8StringEnumerator* zipEnum = new nsJAREnumerator(find);
NS_ADDREF(*result = zipEnum);
return NS_OK;
}
NS_IMETHODIMP
nsJAR::GetInputStream(const nsACString& aEntryName, nsIInputStream** result) {
NS_ENSURE_ARG_POINTER(result);
RecursiveMutexAutoLock lock(mLock);
if (!mZip) {
return NS_ERROR_FAILURE;
}
LOG(("GetInputStream[%p] %s", this, PromiseFlatCString(aEntryName).get()));
// Watch out for the jar:foo.zip!/ (aDir is empty) top-level special case!
nsZipItem* item = nullptr;
const nsCString& entry = PromiseFlatCString(aEntryName);
if (*entry.get()) {
// First check if item exists in jar
item = mZip->GetItem(entry.get());
if (!item) return NS_ERROR_FILE_NOT_FOUND;
}
nsJARInputStream* jis = new nsJARInputStream();
// addref now so we can call InitFile/InitDirectory()
NS_ADDREF(*result = jis);
nsresult rv = NS_OK;
if (!item || item->IsDirectory()) {
rv = jis->InitDirectory(this, entry.get());
} else {
RefPtr<nsZipHandle> fd = mZip->GetFD();
rv = jis->InitFile(fd, mZip->GetData(item), item);
}
if (NS_FAILED(rv)) {
NS_RELEASE(*result);
}
return rv;
}
nsresult nsJAR::GetFullJarPath(nsACString& aResult) {
RecursiveMutexAutoLock lock(mLock);
NS_ENSURE_ARG_POINTER(mZipFile);
nsresult rv = mZipFile->GetPersistentDescriptor(aResult);
if (NS_FAILED(rv)) {
return rv;
}
if (mOuterZipEntry.IsEmpty()) {
aResult.InsertLiteral("file:", 0);
} else {
aResult.InsertLiteral("jar:", 0);
aResult.AppendLiteral("!/");
aResult.Append(mOuterZipEntry);
}
return NS_OK;
}
nsresult nsJAR::GetNSPRFileDesc(PRFileDesc** aNSPRFileDesc) {
RecursiveMutexAutoLock lock(mLock);
if (!aNSPRFileDesc) {
return NS_ERROR_ILLEGAL_VALUE;
}
*aNSPRFileDesc = nullptr;
if (!mZip) {
return NS_ERROR_FAILURE;
}
RefPtr<nsZipHandle> handle = mZip->GetFD();
if (!handle) {
return NS_ERROR_FAILURE;
}
return handle->GetNSPRFileDesc(aNSPRFileDesc);
}
//----------------------------------------------
// nsJAR private implementation
//----------------------------------------------
nsresult nsJAR::LoadEntry(const nsACString& aFilename, nsCString& aBuf) {
//-- Get a stream for reading the file
nsresult rv;
nsCOMPtr<nsIInputStream> manifestStream;
rv = GetInputStream(aFilename, getter_AddRefs(manifestStream));
if (NS_FAILED(rv)) return NS_ERROR_FILE_NOT_FOUND;
//-- Read the manifest file into memory
char* buf;
uint64_t len64;
rv = manifestStream->Available(&len64);
if (NS_FAILED(rv)) return rv;
uint32_t len = (uint32_t)len64;
buf = (char*)malloc(len + 1);
if (!buf) return NS_ERROR_OUT_OF_MEMORY;
uint32_t bytesRead;
rv = manifestStream->Read(buf, len, &bytesRead);
if (bytesRead != len) {
rv = NS_ERROR_FILE_CORRUPTED;
}
if (NS_FAILED(rv)) {
free(buf);
return rv;
}
buf[len] = '\0'; // Null-terminate the buffer
aBuf.Adopt(buf, len);
return NS_OK;
}
int32_t nsJAR::ReadLine(const char** src) {
if (!*src) {
return 0;
}
//--Moves pointer to beginning of next line and returns line length
// not including CR/LF.
int32_t length;
const char* eol = strpbrk(*src, "\r\n");
if (eol == nullptr) // Probably reached end of file before newline
{
length = strlen(*src);
if (length == 0) // immediate end-of-file
*src = nullptr;
else // some data left on this line
*src += length;
} else {
length = eol - *src;
if (eol[0] == '\r' && eol[1] == '\n') // CR LF, so skip 2
*src = eol + 2;
else // Either CR or LF, so skip 1
*src = eol + 1;
}
return length;
}
NS_IMPL_ISUPPORTS(nsJAREnumerator, nsIUTF8StringEnumerator, nsIStringEnumerator)
//----------------------------------------------
// nsJAREnumerator::HasMore
//----------------------------------------------
NS_IMETHODIMP
nsJAREnumerator::HasMore(bool* aResult) {
// try to get the next element
if (!mName) {
NS_ASSERTION(mFind, "nsJAREnumerator: Missing zipFind.");
nsresult rv = mFind->FindNext(&mName, &mNameLen);
if (rv == NS_ERROR_FILE_NOT_FOUND) {
*aResult = false; // No more matches available
return NS_OK;
}
NS_ENSURE_SUCCESS(rv, NS_ERROR_FAILURE); // no error translation
}
*aResult = true;
return NS_OK;
}
//----------------------------------------------
// nsJAREnumerator::GetNext
//----------------------------------------------
NS_IMETHODIMP
nsJAREnumerator::GetNext(nsACString& aResult) {
// check if the current item is "stale"
if (!mName) {
bool bMore;
nsresult rv = HasMore(&bMore);
if (NS_FAILED(rv) || !bMore)
return NS_ERROR_FAILURE; // no error translation
}
aResult.Assign(mName, mNameLen);
mName = 0; // we just gave this one away
return NS_OK;
}
NS_IMPL_ISUPPORTS(nsJARItem, nsIZipEntry)
nsJARItem::nsJARItem(nsZipItem* aZipItem)
: mSize(aZipItem->Size()),
mRealsize(aZipItem->RealSize()),
mCrc32(aZipItem->CRC32()),
mLastModTime(aZipItem->LastModTime()),
mCompression(aZipItem->Compression()),
mPermissions(aZipItem->Mode()),
mIsDirectory(aZipItem->IsDirectory()),
mIsSynthetic(aZipItem->isSynthetic) {}
//------------------------------------------
// nsJARItem::GetCompression
//------------------------------------------
NS_IMETHODIMP
nsJARItem::GetCompression(uint16_t* aCompression) {
NS_ENSURE_ARG_POINTER(aCompression);
*aCompression = mCompression;
return NS_OK;
}
//------------------------------------------
// nsJARItem::GetSize
//------------------------------------------
NS_IMETHODIMP
nsJARItem::GetSize(uint32_t* aSize) {
NS_ENSURE_ARG_POINTER(aSize);
*aSize = mSize;
return NS_OK;
}
//------------------------------------------
// nsJARItem::GetRealSize
//------------------------------------------
NS_IMETHODIMP
nsJARItem::GetRealSize(uint32_t* aRealsize) {
NS_ENSURE_ARG_POINTER(aRealsize);
*aRealsize = mRealsize;
return NS_OK;
}
//------------------------------------------
// nsJARItem::GetCrc32
//------------------------------------------
NS_IMETHODIMP
nsJARItem::GetCRC32(uint32_t* aCrc32) {
NS_ENSURE_ARG_POINTER(aCrc32);
*aCrc32 = mCrc32;
return NS_OK;
}
//------------------------------------------
// nsJARItem::GetIsDirectory
//------------------------------------------
NS_IMETHODIMP
nsJARItem::GetIsDirectory(bool* aIsDirectory) {
NS_ENSURE_ARG_POINTER(aIsDirectory);
*aIsDirectory = mIsDirectory;
return NS_OK;
}
//------------------------------------------
// nsJARItem::GetIsSynthetic
//------------------------------------------
NS_IMETHODIMP
nsJARItem::GetIsSynthetic(bool* aIsSynthetic) {
NS_ENSURE_ARG_POINTER(aIsSynthetic);
*aIsSynthetic = mIsSynthetic;
return NS_OK;
}
//------------------------------------------
// nsJARItem::GetLastModifiedTime
//------------------------------------------
NS_IMETHODIMP
nsJARItem::GetLastModifiedTime(PRTime* aLastModTime) {
NS_ENSURE_ARG_POINTER(aLastModTime);
*aLastModTime = mLastModTime;
return NS_OK;
}
//------------------------------------------
// nsJARItem::GetPermissions
//------------------------------------------
NS_IMETHODIMP
nsJARItem::GetPermissions(uint32_t* aPermissions) {
NS_ENSURE_ARG_POINTER(aPermissions);
*aPermissions = mPermissions;
return NS_OK;
}
////////////////////////////////////////////////////////////////////////////////
// nsIZipReaderCache
NS_IMPL_ISUPPORTS(nsZipReaderCache, nsIZipReaderCache, nsIObserver,
nsISupportsWeakReference)
nsZipReaderCache::nsZipReaderCache()
: mLock("nsZipReaderCache.mLock"),
mCacheSize(0),
mZips()
#ifdef ZIP_CACHE_HIT_RATE
,
mZipCacheLookups(0),
mZipCacheHits(0),
mZipCacheFlushes(0),
mZipSyncMisses(0)
#endif
{
}
NS_IMETHODIMP
nsZipReaderCache::Init(uint32_t cacheSize) {
MutexAutoLock lock(mLock);
mCacheSize = cacheSize;
// Register as a memory pressure observer
nsCOMPtr<nsIObserverService> os =
do_GetService("@mozilla.org/observer-service;1");
if (os) {
os->AddObserver(this, "memory-pressure", true);
os->AddObserver(this, "chrome-flush-caches", true);
os->AddObserver(this, "flush-cache-entry", true);
}
// ignore failure of the observer registration.
return NS_OK;
}
nsZipReaderCache::~nsZipReaderCache() {
for (const auto& zip : mZips.Values()) {
zip->SetZipReaderCache(nullptr);
}
#ifdef ZIP_CACHE_HIT_RATE
printf(
"nsZipReaderCache size=%d hits=%d lookups=%d rate=%f%% flushes=%d missed "
"%d\n",
mCacheSize, mZipCacheHits, mZipCacheLookups,
(float)mZipCacheHits / mZipCacheLookups, mZipCacheFlushes,
mZipSyncMisses);
#endif
}
NS_IMETHODIMP
nsZipReaderCache::IsCached(nsIFile* zipFile, bool* aResult) {
NS_ENSURE_ARG_POINTER(zipFile);
nsresult rv;
MutexAutoLock lock(mLock);
nsAutoCString uri;
rv = zipFile->GetPersistentDescriptor(uri);
if (NS_FAILED(rv)) return rv;
uri.InsertLiteral("file:", 0);
*aResult = mZips.Contains(uri);
return NS_OK;
}
nsresult nsZipReaderCache::GetZip(nsIFile* zipFile, nsIZipReader** result,
bool failOnMiss) {
NS_ENSURE_ARG_POINTER(zipFile);
nsresult rv;
MutexAutoLock lock(mLock);
#ifdef ZIP_CACHE_HIT_RATE
mZipCacheLookups++;
#endif
nsAutoCString uri;
rv = zipFile->GetPersistentDescriptor(uri);
if (NS_FAILED(rv)) return rv;
uri.InsertLiteral("file:", 0);
RefPtr<nsJAR> zip;
mZips.Get(uri, getter_AddRefs(zip));
if (zip) {
#ifdef ZIP_CACHE_HIT_RATE
mZipCacheHits++;
#endif
zip->ClearReleaseTime();
} else {
if (failOnMiss) {
return NS_ERROR_CACHE_KEY_NOT_FOUND;
}
zip = new nsJAR();
zip->SetZipReaderCache(this);
rv = zip->Open(zipFile);
if (NS_FAILED(rv)) {
return rv;
}
MOZ_ASSERT(!mZips.Contains(uri));
mZips.InsertOrUpdate(uri, RefPtr{zip});
}
zip.forget(result);
return rv;
}
NS_IMETHODIMP
nsZipReaderCache::GetZipIfCached(nsIFile* zipFile, nsIZipReader** result) {
return GetZip(zipFile, result, true);
}
NS_IMETHODIMP
nsZipReaderCache::GetZip(nsIFile* zipFile, nsIZipReader** result) {
return GetZip(zipFile, result, false);
}
NS_IMETHODIMP
nsZipReaderCache::GetInnerZip(nsIFile* zipFile, const nsACString& entry,
nsIZipReader** result) {
NS_ENSURE_ARG_POINTER(zipFile);
nsCOMPtr<nsIZipReader> outerZipReader;
nsresult rv = GetZip(zipFile, getter_AddRefs(outerZipReader));
NS_ENSURE_SUCCESS(rv, rv);
MutexAutoLock lock(mLock);
#ifdef ZIP_CACHE_HIT_RATE
mZipCacheLookups++;
#endif
nsAutoCString uri;
rv = zipFile->GetPersistentDescriptor(uri);
if (NS_FAILED(rv)) return rv;
uri.InsertLiteral("jar:", 0);
uri.AppendLiteral("!/");
uri.Append(entry);
RefPtr<nsJAR> zip;
mZips.Get(uri, getter_AddRefs(zip));
if (zip) {
#ifdef ZIP_CACHE_HIT_RATE
mZipCacheHits++;
#endif
zip->ClearReleaseTime();
} else {
zip = new nsJAR();
zip->SetZipReaderCache(this);
rv = zip->OpenInner(outerZipReader, entry);
if (NS_FAILED(rv)) {
return rv;
}
MOZ_ASSERT(!mZips.Contains(uri));
mZips.InsertOrUpdate(uri, RefPtr{zip});
}
zip.forget(result);
return rv;
}
NS_IMETHODIMP
nsZipReaderCache::GetFd(nsIFile* zipFile, PRFileDesc** aRetVal) {
#if defined(XP_WIN)
MOZ_CRASH("Not implemented");
return NS_ERROR_NOT_IMPLEMENTED;
#else
if (!zipFile) {
return NS_ERROR_FAILURE;
}
nsresult rv;
nsAutoCString uri;
rv = zipFile->GetPersistentDescriptor(uri);
if (NS_FAILED(rv)) {
return rv;
}
uri.InsertLiteral("file:", 0);
MutexAutoLock lock(mLock);
RefPtr<nsJAR> zip;
mZips.Get(uri, getter_AddRefs(zip));
if (!zip) {
return NS_ERROR_FAILURE;
}
zip->ClearReleaseTime();
rv = zip->GetNSPRFileDesc(aRetVal);
// Do this to avoid possible deadlock on mLock with ReleaseZip().
{
MutexAutoUnlock unlock(mLock);
zip = nullptr;
}
return rv;
#endif /* XP_WIN */
}
nsresult nsZipReaderCache::ReleaseZip(nsJAR* zip) {
nsresult rv;
MutexAutoLock lock(mLock);
// It is possible that two thread compete for this zip. The dangerous
// case is where one thread Releases the zip and discovers that the ref
// count has gone to one. Before it can call this ReleaseZip method
// another thread calls our GetZip method. The ref count goes to two. That
// second thread then Releases the zip and the ref count goes to one. It
// then tries to enter this ReleaseZip method and blocks while the first
// thread is still here. The first thread continues and remove the zip from
// the cache and calls its Release method sending the ref count to 0 and
// deleting the zip. However, the second thread is still blocked at the
// start of ReleaseZip, but the 'zip' param now hold a reference to a
// deleted zip!
//
// So, we are going to try safeguarding here by searching our hashtable while
// locked here for the zip. We return fast if it is not found.
bool found = false;
for (const auto& current : mZips.Values()) {
if (zip == current) {
found = true;
break;
}
}
if (!found) {
#ifdef ZIP_CACHE_HIT_RATE
mZipSyncMisses++;
#endif
return NS_OK;
}
zip->SetReleaseTime();
if (mZips.Count() <= mCacheSize) return NS_OK;
// Find the oldest zip.
nsJAR* oldest = nullptr;
for (const auto& current : mZips.Values()) {
PRIntervalTime currentReleaseTime = current->GetReleaseTime();
if (currentReleaseTime != PR_INTERVAL_NO_TIMEOUT) {
if (oldest == nullptr || currentReleaseTime < oldest->GetReleaseTime()) {
oldest = current;
}
}
}
// Because of the craziness above it is possible that there is no zip that
// needs removing.
if (!oldest) return NS_OK;
#ifdef ZIP_CACHE_HIT_RATE
mZipCacheFlushes++;
#endif
// remove from hashtable
nsAutoCString uri;
rv = oldest->GetFullJarPath(uri);
if (NS_FAILED(rv)) {
return rv;
}
// Retrieving and removing the JAR should be done without an extra AddRef
// and Release, or we'll trigger nsJAR::Release's magic refcount 1 case
// an extra time.
RefPtr<nsJAR> removed;
mZips.Remove(uri, getter_AddRefs(removed));
NS_ASSERTION(removed, "botched");
NS_ASSERTION(oldest == removed, "removed wrong entry");
if (removed) removed->SetZipReaderCache(nullptr);
return NS_OK;
}
NS_IMETHODIMP
nsZipReaderCache::Observe(nsISupports* aSubject, const char* aTopic,
const char16_t* aSomeData) {
if (strcmp(aTopic, "memory-pressure") == 0) {
MutexAutoLock lock(mLock);
for (auto iter = mZips.Iter(); !iter.Done(); iter.Next()) {
RefPtr<nsJAR>& current = iter.Data();
if (current->GetReleaseTime() != PR_INTERVAL_NO_TIMEOUT) {
current->SetZipReaderCache(nullptr);
iter.Remove();
}
}
} else if (strcmp(aTopic, "chrome-flush-caches") == 0) {
MutexAutoLock lock(mLock);
for (const auto& current : mZips.Values()) {
current->SetZipReaderCache(nullptr);
}
mZips.Clear();
} else if (strcmp(aTopic, "flush-cache-entry") == 0) {
nsCOMPtr<nsIFile> file;
if (aSubject) {
file = do_QueryInterface(aSubject);
} else if (aSomeData) {
nsDependentString fileName(aSomeData);
Unused << NS_NewLocalFile(fileName, false, getter_AddRefs(file));
}
if (!file) return NS_OK;
nsAutoCString uri;
if (NS_FAILED(file->GetPersistentDescriptor(uri))) return NS_OK;
uri.InsertLiteral("file:", 0);
MutexAutoLock lock(mLock);
RefPtr<nsJAR> zip;
mZips.Get(uri, getter_AddRefs(zip));
if (!zip) return NS_OK;
#ifdef ZIP_CACHE_HIT_RATE
mZipCacheFlushes++;
#endif
zip->SetZipReaderCache(nullptr);
mZips.Remove(uri);
}
return NS_OK;
}
////////////////////////////////////////////////////////////////////////////////