Source code
Revision control
Copy as Markdown
Other Tools
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* nsJARInputStream.cpp
*
* 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 "nsJARInputStream.h"
#include "zipstruct.h" // defines ZIP compression codes
#include "nsZipArchive.h"
#include "mozilla/MmapFaultHandler.h"
#include "mozilla/StaticPrefs_network.h"
#include "mozilla/UniquePtr.h"
#include "mozilla/UniquePtrExtensions.h"
#include "nsEscape.h"
#include "nsDebug.h"
#include <algorithm>
#include <limits>
#if defined(XP_WIN)
# include <windows.h>
#endif
/*---------------------------------------------
* nsISupports implementation
*--------------------------------------------*/
NS_IMPL_ISUPPORTS(nsJARInputStream, nsIInputStream)
/*----------------------------------------------------------
* nsJARInputStream implementation
* Takes ownership of |fd|, even on failure
*--------------------------------------------------------*/
nsresult nsJARInputStream::InitFile(nsZipHandle* aFd, const uint8_t* aData,
nsZipItem* aItem) {
nsresult rv = NS_OK;
MOZ_DIAGNOSTIC_ASSERT(aFd, "Argument may not be null");
if (!aFd) {
return NS_ERROR_INVALID_ARG;
}
MOZ_ASSERT(aItem, "Argument may not be null");
// Mark it as closed, in case something fails in initialisation
mMode = MODE_CLOSED;
//-- prepare for the compression type
switch (aItem->Compression()) {
case STORED:
mMode = MODE_COPY;
break;
case DEFLATED:
rv = gZlibInit(&mZs);
NS_ENSURE_SUCCESS(rv, rv);
mMode = MODE_INFLATE;
mInCrc = aItem->CRC32();
mOutCrc = crc32(0L, Z_NULL, 0);
break;
default:
mFd = aFd;
return NS_ERROR_NOT_IMPLEMENTED;
}
// Must keep handle to filepointer and mmap structure as long as we need
// access to the mmapped data
mFd = aFd;
mZs.next_in = (Bytef*)aData;
if (!mZs.next_in) {
return NS_ERROR_FILE_CORRUPTED;
}
mZs.avail_in = aItem->Size();
mOutSize = aItem->RealSize();
mZs.total_out = 0;
return NS_OK;
}
nsresult nsJARInputStream::InitDirectory(nsJAR* aJar, const char* aDir) {
MOZ_ASSERT(aJar, "Argument may not be null");
MOZ_ASSERT(aDir, "Argument may not be null");
// Mark it as closed, in case something fails in initialisation
mMode = MODE_CLOSED;
// Keep the zipReader for getting the actual zipItems
mJar = aJar;
mJar->mLock.AssertCurrentThreadIn();
mozilla::UniquePtr<nsZipFind> find;
nsresult rv;
// We can get aDir's contents as strings via FindEntries
// with the following pattern (see nsIZipReader.findEntries docs)
// assuming dirName is properly escaped:
//
// dirName + "?*~" + dirName + "?*/?*"
nsDependentCString dirName(aDir);
mNameLen = dirName.Length();
// iterate through dirName and copy it to escDirName, escaping chars
// which are special at the "top" level of the regexp so FindEntries
// works correctly
nsAutoCString escDirName;
const char* curr = dirName.BeginReading();
const char* end = dirName.EndReading();
while (curr != end) {
switch (*curr) {
case '*':
case '?':
case '$':
case '[':
case ']':
case '^':
case '~':
case '(':
case ')':
case '\\':
escDirName.Append('\\');
[[fallthrough]];
default:
escDirName.Append(*curr);
}
++curr;
}
nsAutoCString pattern = escDirName + "?*~"_ns + escDirName + "?*/?*"_ns;
rv = mJar->mZip->FindInit(pattern.get(), getter_Transfers(find));
if (NS_FAILED(rv)) return rv;
const char* name;
uint16_t nameLen;
while ((rv = find->FindNext(&name, &nameLen)) == NS_OK) {
// Must copy, to make it zero-terminated
mArray.AppendElement(nsCString(name, nameLen));
}
if (rv != NS_ERROR_FILE_NOT_FOUND && NS_FAILED(rv)) {
return NS_ERROR_FAILURE; // no error translation
}
// Sort it
mArray.Sort();
mBuffer.AppendLiteral(
"200: filename content-length last-modified file-type\n");
// Open for reading
mMode = MODE_DIRECTORY;
mZs.total_out = 0;
mArrPos = 0;
return NS_OK;
}
NS_IMETHODIMP
nsJARInputStream::Available(uint64_t* _retval) {
// A lot of callers don't check the error code.
// They just use the _retval value.
*_retval = 0;
uint64_t maxAvailableSize = 0;
switch (mMode) {
case MODE_NOTINITED:
break;
case MODE_CLOSED:
return NS_BASE_STREAM_CLOSED;
case MODE_DIRECTORY:
*_retval = mBuffer.Length();
break;
case MODE_INFLATE:
case MODE_COPY:
maxAvailableSize = mozilla::StaticPrefs::network_jar_max_available_size();
if (!maxAvailableSize) {
maxAvailableSize = std::numeric_limits<uint64_t>::max();
}
*_retval = std::min<uint64_t>(mOutSize - mZs.total_out, maxAvailableSize);
break;
}
return NS_OK;
}
NS_IMETHODIMP
nsJARInputStream::StreamStatus() {
return mMode == MODE_CLOSED ? NS_BASE_STREAM_CLOSED : NS_OK;
}
NS_IMETHODIMP
nsJARInputStream::Read(char* aBuffer, uint32_t aCount, uint32_t* aBytesRead) {
NS_ENSURE_ARG_POINTER(aBuffer);
NS_ENSURE_ARG_POINTER(aBytesRead);
*aBytesRead = 0;
nsresult rv = NS_OK;
MMAP_FAULT_HANDLER_BEGIN_HANDLE(mFd)
switch (mMode) {
case MODE_NOTINITED:
return NS_OK;
case MODE_CLOSED:
return NS_BASE_STREAM_CLOSED;
case MODE_DIRECTORY:
return ReadDirectory(aBuffer, aCount, aBytesRead);
case MODE_INFLATE:
if (mZs.total_out < mOutSize) {
rv = ContinueInflate(aBuffer, aCount, aBytesRead);
}
// be aggressive about releasing the file!
// note that sometimes, we will release mFd before we've finished
// deflating - this is because zlib buffers the input
if (mZs.avail_in == 0) {
mFd = nullptr;
}
break;
case MODE_COPY:
if (mFd) {
MOZ_DIAGNOSTIC_ASSERT(mOutSize >= mZs.total_out,
"Did we read more than expected?");
uint32_t count = std::min(aCount, mOutSize - uint32_t(mZs.total_out));
if (count) {
std::copy(mZs.next_in + mZs.total_out,
mZs.next_in + mZs.total_out + count, aBuffer);
mZs.total_out += count;
}
*aBytesRead = count;
}
// be aggressive about releasing the file!
// note that sometimes, we will release mFd before we've finished copying.
if (mZs.total_out >= mOutSize) {
mFd = nullptr;
}
break;
}
MMAP_FAULT_HANDLER_CATCH(NS_ERROR_FAILURE)
return rv;
}
NS_IMETHODIMP
nsJARInputStream::ReadSegments(nsWriteSegmentFun writer, void* closure,
uint32_t count, uint32_t* _retval) {
// don't have a buffer to read from, so this better not be called!
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP
nsJARInputStream::IsNonBlocking(bool* aNonBlocking) {
*aNonBlocking = false;
return NS_OK;
}
NS_IMETHODIMP
nsJARInputStream::Close() {
if (mMode == MODE_INFLATE) {
inflateEnd(&mZs);
}
mMode = MODE_CLOSED;
mFd = nullptr;
return NS_OK;
}
nsresult nsJARInputStream::ContinueInflate(char* aBuffer, uint32_t aCount,
uint32_t* aBytesRead) {
bool finished = false;
// No need to check the args, ::Read did that, but assert them at least
NS_ASSERTION(aBuffer, "aBuffer parameter must not be null");
NS_ASSERTION(aBytesRead, "aBytesRead parameter must not be null");
// Keep old total_out count
const uint32_t oldTotalOut = mZs.total_out;
// make sure we aren't reading too much
mZs.avail_out = std::min(aCount, (mOutSize - oldTotalOut));
mZs.next_out = (unsigned char*)aBuffer;
if (mMode == MODE_INFLATE) {
// now inflate
int zerr = inflate(&mZs, Z_SYNC_FLUSH);
if ((zerr != Z_OK) && (zerr != Z_STREAM_END)) {
return NS_ERROR_FILE_CORRUPTED;
}
// If inflating did not read anything more, then the stream is finished.
finished = (zerr == Z_STREAM_END) ||
(mZs.avail_out && mZs.total_out == oldTotalOut);
}
*aBytesRead = (mZs.total_out - oldTotalOut);
// Calculate the CRC on the output
mOutCrc = crc32(mOutCrc, (unsigned char*)aBuffer, *aBytesRead);
// be aggressive about ending the inflation
// for some reason we don't always get Z_STREAM_END
if (finished || mZs.total_out >= mOutSize) {
if (mMode == MODE_INFLATE) {
int zerr = inflateEnd(&mZs);
if (zerr != Z_OK) {
return NS_ERROR_FILE_CORRUPTED;
}
// Stream is finished but has a different size from what
// we expected.
if (mozilla::StaticPrefs::network_jar_require_size_match() &&
mZs.total_out != mOutSize) {
return NS_ERROR_FILE_CORRUPTED;
}
}
// stop returning valid data as soon as we know we have a bad CRC
if (mOutCrc != mInCrc) {
return NS_ERROR_FILE_CORRUPTED;
}
}
return NS_OK;
}
nsresult nsJARInputStream::ReadDirectory(char* aBuffer, uint32_t aCount,
uint32_t* aBytesRead) {
// No need to check the args, ::Read did that, but assert them at least
NS_ASSERTION(aBuffer, "aBuffer parameter must not be null");
NS_ASSERTION(aBytesRead, "aBytesRead parameter must not be null");
// If the buffer contains data, copy what's there up to the desired amount
uint32_t numRead = CopyDataToBuffer(aBuffer, aCount);
if (aCount > 0) {
mozilla::RecursiveMutexAutoLock lock(mJar->mLock);
// empty the buffer and start writing directory entry lines to it
mBuffer.Truncate();
mCurPos = 0;
const uint32_t arrayLen = mArray.Length();
for (; aCount > mBuffer.Length(); mArrPos++) {
// have we consumed all the directory contents?
if (arrayLen <= mArrPos) break;
const char* entryName = mArray[mArrPos].get();
uint32_t entryNameLen = mArray[mArrPos].Length();
nsZipItem* ze = mJar->mZip->GetItem(entryName);
NS_ENSURE_TRUE(ze, NS_ERROR_FILE_NOT_FOUND);
// Last Modified Time
PRExplodedTime tm;
PR_ExplodeTime(ze->LastModTime(), PR_GMTParameters, &tm);
char itemLastModTime[65];
PR_FormatTimeUSEnglish(itemLastModTime, sizeof(itemLastModTime),
" %a,%%20%d%%20%b%%20%Y%%20%H:%M:%S%%20GMT ", &tm);
// write a 201: line to the buffer for this item
// 200: filename content-length last-modified file-type
mBuffer.AppendLiteral("201: ");
// Names must be escaped and relative, so use the pre-calculated length
// of the directory name as the offset into the string
// NS_EscapeURL adds the escaped URL to the give string buffer
NS_EscapeURL(entryName + mNameLen, entryNameLen - mNameLen,
esc_Minimal | esc_AlwaysCopy, mBuffer);
mBuffer.Append(' ');
mBuffer.AppendInt(ze->RealSize(), 10);
mBuffer.Append(itemLastModTime); // starts/ends with ' '
if (ze->IsDirectory())
mBuffer.AppendLiteral("DIRECTORY\n");
else
mBuffer.AppendLiteral("FILE\n");
}
// Copy up to the desired amount of data to buffer
numRead += CopyDataToBuffer(aBuffer, aCount);
}
*aBytesRead = numRead;
return NS_OK;
}
uint32_t nsJARInputStream::CopyDataToBuffer(char*& aBuffer, uint32_t& aCount) {
const uint32_t writeLength =
std::min<uint32_t>(aCount, mBuffer.Length() - mCurPos);
if (writeLength > 0) {
std::copy(mBuffer.get() + mCurPos, mBuffer.get() + mCurPos + writeLength,
aBuffer);
mCurPos += writeLength;
aCount -= writeLength;
aBuffer += writeLength;
}
// return number of bytes copied to the buffer so the
// Read method can return the number of bytes copied
return writeLength;
}