From 36d22d82aa202bb199967e9512281e9a53db42c9 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Sun, 7 Apr 2024 21:33:14 +0200 Subject: Adding upstream version 115.7.0esr. Signed-off-by: Daniel Baumann --- modules/libjar/nsJARInputStream.cpp | 399 ++++++++++++++++++++++++++++++++++++ 1 file changed, 399 insertions(+) create mode 100644 modules/libjar/nsJARInputStream.cpp (limited to 'modules/libjar/nsJARInputStream.cpp') diff --git a/modules/libjar/nsJARInputStream.cpp b/modules/libjar/nsJARInputStream.cpp new file mode 100644 index 0000000000..fd00a3a419 --- /dev/null +++ b/modules/libjar/nsJARInputStream.cpp @@ -0,0 +1,399 @@ +/* -*- 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 + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#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 +#include +#if defined(XP_WIN) +# include +#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 nsACString& aJarDirSpec, + 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 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.AssignLiteral("300: "); + mBuffer.Append(aJarDirSpec); + mBuffer.AppendLiteral( + "\n200: 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::max(); + } + *_retval = std::min(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; + } + finished = (zerr == Z_STREAM_END); + } + + *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(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; +} -- cgit v1.2.3