mirror of
https://repo.dactyloidae.xyz/Dactyloidae/UXP.git
synced 2026-09-06 15:58:39 +09:00
import FIREFOX_52_6_0esr_RELEASE from mozilla-esr52 hg repo
This commit is contained in:
Roy Tam
commit
dcd9973243
150858 changed files with 23884658 additions and 0 deletions
375
modules/libjar/nsJARInputStream.cpp
Normal file
375
modules/libjar/nsJARInputStream.cpp
Normal file
|
|
@ -0,0 +1,375 @@
|
|||
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
|
||||
/* 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 "nsEscape.h"
|
||||
#include "nsIFile.h"
|
||||
#include "nsDebug.h"
|
||||
#include <algorithm>
|
||||
#if defined(XP_WIN)
|
||||
#include <windows.h>
|
||||
#endif
|
||||
|
||||
/*---------------------------------------------
|
||||
* nsISupports implementation
|
||||
*--------------------------------------------*/
|
||||
|
||||
NS_IMPL_ISUPPORTS(nsJARInputStream, nsIInputStream)
|
||||
|
||||
/*----------------------------------------------------------
|
||||
* nsJARInputStream implementation
|
||||
*--------------------------------------------------------*/
|
||||
|
||||
nsresult
|
||||
nsJARInputStream::InitFile(nsJAR *aJar, nsZipItem *item)
|
||||
{
|
||||
nsresult rv = NS_OK;
|
||||
MOZ_ASSERT(aJar, "Argument may not be null");
|
||||
MOZ_ASSERT(item, "Argument may not be null");
|
||||
|
||||
// Mark it as closed, in case something fails in initialisation
|
||||
mMode = MODE_CLOSED;
|
||||
//-- prepare for the compression type
|
||||
switch (item->Compression()) {
|
||||
case STORED:
|
||||
mMode = MODE_COPY;
|
||||
break;
|
||||
|
||||
case DEFLATED:
|
||||
rv = gZlibInit(&mZs);
|
||||
NS_ENSURE_SUCCESS(rv, rv);
|
||||
|
||||
mMode = MODE_INFLATE;
|
||||
mInCrc = item->CRC32();
|
||||
mOutCrc = crc32(0L, Z_NULL, 0);
|
||||
break;
|
||||
|
||||
default:
|
||||
return NS_ERROR_NOT_IMPLEMENTED;
|
||||
}
|
||||
|
||||
// Must keep handle to filepointer and mmap structure as long as we need access to the mmapped data
|
||||
mFd = aJar->mZip->GetFD();
|
||||
mZs.next_in = (Bytef *)aJar->mZip->GetData(item);
|
||||
if (!mZs.next_in) {
|
||||
nsZipArchive::sFileCorruptedReason = "nsJARInputStream: !mZs.next_in";
|
||||
return NS_ERROR_FILE_CORRUPTED;
|
||||
}
|
||||
mZs.avail_in = item->Size();
|
||||
mOutSize = item->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;
|
||||
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('\\');
|
||||
MOZ_FALLTHROUGH;
|
||||
default:
|
||||
escDirName.Append(*curr);
|
||||
}
|
||||
++curr;
|
||||
}
|
||||
nsAutoCString pattern = escDirName + NS_LITERAL_CSTRING("?*~") +
|
||||
escDirName + NS_LITERAL_CSTRING("?*/?*");
|
||||
rv = mJar->mZip->FindInit(pattern.get(), &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));
|
||||
}
|
||||
delete find;
|
||||
|
||||
if (rv != NS_ERROR_FILE_TARGET_DOES_NOT_EXIST && 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;
|
||||
|
||||
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:
|
||||
*_retval = mOutSize - mZs.total_out;
|
||||
break;
|
||||
}
|
||||
|
||||
return 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;
|
||||
MOZ_WIN_MEM_TRY_BEGIN
|
||||
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 (mFd) {
|
||||
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) {
|
||||
uint32_t count = std::min(aCount, mOutSize - uint32_t(mZs.total_out));
|
||||
if (count) {
|
||||
memcpy(aBuffer, mZs.next_in + mZs.total_out, count);
|
||||
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;
|
||||
}
|
||||
MOZ_WIN_MEM_TRY_CATCH(rv = 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)
|
||||
{
|
||||
// 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;
|
||||
|
||||
// now inflate
|
||||
int zerr = inflate(&mZs, Z_SYNC_FLUSH);
|
||||
if ((zerr != Z_OK) && (zerr != Z_STREAM_END)) {
|
||||
nsZipArchive::sFileCorruptedReason = "nsJARInputStream: error while inflating";
|
||||
return NS_ERROR_FILE_CORRUPTED;
|
||||
}
|
||||
|
||||
*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 (zerr == Z_STREAM_END || mZs.total_out == mOutSize) {
|
||||
inflateEnd(&mZs);
|
||||
|
||||
// stop returning valid data as soon as we know we have a bad CRC
|
||||
if (mOutCrc != mInCrc) {
|
||||
nsZipArchive::sFileCorruptedReason = "nsJARInputStream: crc mismatch";
|
||||
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) {
|
||||
// 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_TARGET_DOES_NOT_EXIST);
|
||||
|
||||
// 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) {
|
||||
memcpy(aBuffer, mBuffer.get() + mCurPos, writeLength);
|
||||
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;
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue