mirror of
https://github.com/classilla/tenfourfox.git
synced 2024-09-10 11:54:40 +00:00
1232 lines
31 KiB
C++
1232 lines
31 KiB
C++
/* -*- 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/. */
|
|
|
|
/*
|
|
* This module implements a simple archive extractor for the PKZIP format.
|
|
*
|
|
* The underlying nsZipArchive is NOT thread-safe. Do not pass references
|
|
* or pointers to it across thread boundaries.
|
|
*/
|
|
|
|
// This must be the first include in the file in order for the
|
|
// PL_ARENA_CONST_ALIGN_MASK macro to be effective.
|
|
#define PL_ARENA_CONST_ALIGN_MASK (sizeof(void*)-1)
|
|
#include "plarena.h"
|
|
|
|
#define READTYPE int32_t
|
|
#include "zlib.h"
|
|
#include "nsISupportsUtils.h"
|
|
#include "prio.h"
|
|
#include "plstr.h"
|
|
#include "mozilla/Logging.h"
|
|
#include "mozilla/UniquePtrExtensions.h"
|
|
#include "stdlib.h"
|
|
#include "nsWildCard.h"
|
|
#include "nsZipArchive.h"
|
|
#include "nsString.h"
|
|
#include "prenv.h"
|
|
#if defined(XP_WIN)
|
|
#include <windows.h>
|
|
#endif
|
|
|
|
// For placement new used for arena allocations of zip file list
|
|
#include <new>
|
|
#define ZIP_ARENABLOCKSIZE (1*1024)
|
|
|
|
#ifdef XP_UNIX
|
|
#include <sys/mman.h>
|
|
#include <sys/types.h>
|
|
#include <sys/stat.h>
|
|
#include <limits.h>
|
|
#include <unistd.h>
|
|
#elif defined(XP_WIN)
|
|
#include <io.h>
|
|
#endif
|
|
|
|
#ifdef __SYMBIAN32__
|
|
#include <sys/syslimits.h>
|
|
#endif /*__SYMBIAN32__*/
|
|
|
|
|
|
#ifndef XP_UNIX /* we need some constants defined in limits.h and unistd.h */
|
|
# ifndef S_IFMT
|
|
# define S_IFMT 0170000
|
|
# endif
|
|
# ifndef S_IFLNK
|
|
# define S_IFLNK 0120000
|
|
# endif
|
|
# ifndef PATH_MAX
|
|
# define PATH_MAX 1024
|
|
# endif
|
|
#endif /* XP_UNIX */
|
|
|
|
#ifdef XP_WIN
|
|
#include "private/pprio.h" // To get PR_ImportFile
|
|
#endif
|
|
|
|
using namespace mozilla;
|
|
|
|
static const uint32_t kMaxNameLength = PATH_MAX; /* Maximum name length */
|
|
// For synthetic zip entries. Date/time corresponds to 1980-01-01 00:00.
|
|
static const uint16_t kSyntheticTime = 0;
|
|
static const uint16_t kSyntheticDate = (1 + (1 << 5) + (0 << 9));
|
|
|
|
static uint16_t xtoint(const uint8_t *ii);
|
|
static uint32_t xtolong(const uint8_t *ll);
|
|
static uint32_t HashName(const char* aName, uint16_t nameLen);
|
|
#ifdef XP_UNIX
|
|
static nsresult ResolveSymlink(const char *path);
|
|
#endif
|
|
|
|
class ZipArchiveLogger {
|
|
public:
|
|
void Write(const nsACString &zip, const char *entry) const {
|
|
if (!fd) {
|
|
char *env = PR_GetEnv("MOZ_JAR_LOG_FILE");
|
|
if (!env)
|
|
return;
|
|
|
|
nsCOMPtr<nsIFile> logFile;
|
|
nsresult rv = NS_NewLocalFile(NS_ConvertUTF8toUTF16(env), false, getter_AddRefs(logFile));
|
|
if (NS_FAILED(rv))
|
|
return;
|
|
|
|
// Create the log file and its parent directory (in case it doesn't exist)
|
|
logFile->Create(nsIFile::NORMAL_FILE_TYPE, 0644);
|
|
|
|
PRFileDesc* file;
|
|
#ifdef XP_WIN
|
|
// PR_APPEND is racy on Windows, so open a handle ourselves with flags that
|
|
// will work, and use PR_ImportFile to make it a PRFileDesc.
|
|
// This can go away when bug 840435 is fixed.
|
|
nsAutoString path;
|
|
logFile->GetPath(path);
|
|
if (path.IsEmpty())
|
|
return;
|
|
HANDLE handle = CreateFileW(path.get(), FILE_APPEND_DATA, FILE_SHARE_WRITE,
|
|
nullptr, OPEN_ALWAYS, 0, nullptr);
|
|
if (handle == INVALID_HANDLE_VALUE)
|
|
return;
|
|
file = PR_ImportFile((PROsfd)handle);
|
|
if (!file)
|
|
return;
|
|
#else
|
|
rv = logFile->OpenNSPRFileDesc(PR_WRONLY|PR_CREATE_FILE|PR_APPEND, 0644, &file);
|
|
if (NS_FAILED(rv))
|
|
return;
|
|
#endif
|
|
fd = file;
|
|
}
|
|
nsCString buf(zip);
|
|
buf.Append(' ');
|
|
buf.Append(entry);
|
|
buf.Append('\n');
|
|
PR_Write(fd, buf.get(), buf.Length());
|
|
}
|
|
|
|
void AddRef() {
|
|
MOZ_ASSERT(refCnt >= 0);
|
|
++refCnt;
|
|
}
|
|
|
|
void Release() {
|
|
MOZ_ASSERT(refCnt > 0);
|
|
if ((0 == --refCnt) && fd) {
|
|
PR_Close(fd);
|
|
fd = nullptr;
|
|
}
|
|
}
|
|
private:
|
|
int refCnt;
|
|
mutable PRFileDesc *fd;
|
|
};
|
|
|
|
static ZipArchiveLogger zipLog;
|
|
|
|
//***********************************************************
|
|
// For every inflation the following allocations are done:
|
|
// malloc(1 * 9520)
|
|
// malloc(32768 * 1)
|
|
//***********************************************************
|
|
|
|
nsresult gZlibInit(z_stream *zs)
|
|
{
|
|
memset(zs, 0, sizeof(z_stream));
|
|
int zerr = inflateInit2(zs, -MAX_WBITS);
|
|
if (zerr != Z_OK) return NS_ERROR_OUT_OF_MEMORY;
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
nsZipHandle::nsZipHandle()
|
|
: mFileData(nullptr)
|
|
, mLen(0)
|
|
, mMap(nullptr)
|
|
, mRefCnt(0)
|
|
{
|
|
MOZ_COUNT_CTOR(nsZipHandle);
|
|
}
|
|
|
|
NS_IMPL_ADDREF(nsZipHandle)
|
|
NS_IMPL_RELEASE(nsZipHandle)
|
|
|
|
nsresult nsZipHandle::Init(nsIFile *file, nsZipHandle **ret,
|
|
PRFileDesc **aFd)
|
|
{
|
|
mozilla::AutoFDClose fd;
|
|
int32_t flags = PR_RDONLY;
|
|
#if defined(XP_WIN)
|
|
flags |= nsIFile::OS_READAHEAD;
|
|
#endif
|
|
nsresult rv = file->OpenNSPRFileDesc(flags, 0000, &fd.rwget());
|
|
if (NS_FAILED(rv))
|
|
return rv;
|
|
|
|
int64_t size = PR_Available64(fd);
|
|
if (size >= INT32_MAX)
|
|
return NS_ERROR_FILE_TOO_BIG;
|
|
|
|
PRFileMap *map = PR_CreateFileMap(fd, size, PR_PROT_READONLY);
|
|
if (!map)
|
|
return NS_ERROR_FAILURE;
|
|
|
|
uint8_t *buf = (uint8_t*) PR_MemMap(map, 0, (uint32_t) size);
|
|
// Bug 525755: PR_MemMap fails when fd points at something other than a normal file.
|
|
if (!buf) {
|
|
PR_CloseFileMap(map);
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
|
|
RefPtr<nsZipHandle> handle = new nsZipHandle();
|
|
if (!handle) {
|
|
PR_MemUnmap(buf, (uint32_t) size);
|
|
PR_CloseFileMap(map);
|
|
return NS_ERROR_OUT_OF_MEMORY;
|
|
}
|
|
|
|
#if defined(XP_WIN)
|
|
if (aFd) {
|
|
*aFd = fd.forget();
|
|
}
|
|
#else
|
|
handle->mNSPRFileDesc = fd.forget();
|
|
#endif
|
|
handle->mMap = map;
|
|
handle->mFile.Init(file);
|
|
handle->mLen = (uint32_t) size;
|
|
handle->mFileData = buf;
|
|
handle.forget(ret);
|
|
return NS_OK;
|
|
}
|
|
|
|
nsresult nsZipHandle::Init(nsZipArchive *zip, const char *entry,
|
|
nsZipHandle **ret)
|
|
{
|
|
RefPtr<nsZipHandle> handle = new nsZipHandle();
|
|
if (!handle)
|
|
return NS_ERROR_OUT_OF_MEMORY;
|
|
|
|
handle->mBuf = new nsZipItemPtr<uint8_t>(zip, entry);
|
|
if (!handle->mBuf)
|
|
return NS_ERROR_OUT_OF_MEMORY;
|
|
|
|
if (!handle->mBuf->Buffer())
|
|
return NS_ERROR_UNEXPECTED;
|
|
|
|
handle->mMap = nullptr;
|
|
handle->mFile.Init(zip, entry);
|
|
handle->mLen = handle->mBuf->Length();
|
|
handle->mFileData = handle->mBuf->Buffer();
|
|
handle.forget(ret);
|
|
return NS_OK;
|
|
}
|
|
|
|
nsresult nsZipHandle::Init(const uint8_t* aData, uint32_t aLen,
|
|
nsZipHandle **aRet)
|
|
{
|
|
RefPtr<nsZipHandle> handle = new nsZipHandle();
|
|
|
|
handle->mFileData = aData;
|
|
handle->mLen = aLen;
|
|
handle.forget(aRet);
|
|
return NS_OK;
|
|
}
|
|
|
|
int64_t nsZipHandle::SizeOfMapping()
|
|
{
|
|
return mLen;
|
|
}
|
|
|
|
nsresult nsZipHandle::GetNSPRFileDesc(PRFileDesc** aNSPRFileDesc)
|
|
{
|
|
if (!aNSPRFileDesc) {
|
|
return NS_ERROR_ILLEGAL_VALUE;
|
|
}
|
|
|
|
*aNSPRFileDesc = mNSPRFileDesc;
|
|
if (!mNSPRFileDesc) {
|
|
return NS_ERROR_NOT_AVAILABLE;
|
|
}
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
nsZipHandle::~nsZipHandle()
|
|
{
|
|
if (mMap) {
|
|
PR_MemUnmap((void *)mFileData, mLen);
|
|
PR_CloseFileMap(mMap);
|
|
}
|
|
mFileData = nullptr;
|
|
mMap = nullptr;
|
|
mBuf = nullptr;
|
|
MOZ_COUNT_DTOR(nsZipHandle);
|
|
}
|
|
|
|
//***********************************************************
|
|
// nsZipArchive -- public methods
|
|
//***********************************************************
|
|
|
|
//---------------------------------------------
|
|
// nsZipArchive::OpenArchive
|
|
//---------------------------------------------
|
|
nsresult nsZipArchive::OpenArchive(nsZipHandle *aZipHandle, PRFileDesc *aFd)
|
|
{
|
|
mFd = aZipHandle;
|
|
|
|
// Initialize our arena
|
|
PL_INIT_ARENA_POOL(&mArena, "ZipArena", ZIP_ARENABLOCKSIZE);
|
|
|
|
//-- get table of contents for archive
|
|
nsresult rv = BuildFileList(aFd);
|
|
if (NS_SUCCEEDED(rv)) {
|
|
if (aZipHandle->mFile)
|
|
aZipHandle->mFile.GetURIString(mURI);
|
|
}
|
|
return rv;
|
|
}
|
|
|
|
nsresult nsZipArchive::OpenArchive(nsIFile *aFile)
|
|
{
|
|
RefPtr<nsZipHandle> handle;
|
|
#if defined(XP_WIN)
|
|
mozilla::AutoFDClose fd;
|
|
nsresult rv = nsZipHandle::Init(aFile, getter_AddRefs(handle),
|
|
&fd.rwget());
|
|
#else
|
|
nsresult rv = nsZipHandle::Init(aFile, getter_AddRefs(handle));
|
|
#endif
|
|
if (NS_FAILED(rv))
|
|
return rv;
|
|
|
|
#if defined(XP_WIN)
|
|
return OpenArchive(handle, fd.get());
|
|
#else
|
|
return OpenArchive(handle);
|
|
#endif
|
|
}
|
|
|
|
//---------------------------------------------
|
|
// nsZipArchive::Test
|
|
//---------------------------------------------
|
|
nsresult nsZipArchive::Test(const char *aEntryName)
|
|
{
|
|
nsZipItem* currItem;
|
|
|
|
if (aEntryName) // only test specified item
|
|
{
|
|
currItem = GetItem(aEntryName);
|
|
if (!currItem)
|
|
return NS_ERROR_FILE_TARGET_DOES_NOT_EXIST;
|
|
//-- don't test (synthetic) directory items
|
|
if (currItem->IsDirectory())
|
|
return NS_OK;
|
|
return ExtractFile(currItem, 0, 0);
|
|
}
|
|
|
|
// test all items in archive
|
|
for (int i = 0; i < ZIP_TABSIZE; i++) {
|
|
for (currItem = mFiles[i]; currItem; currItem = currItem->next) {
|
|
//-- don't test (synthetic) directory items
|
|
if (currItem->IsDirectory())
|
|
continue;
|
|
nsresult rv = ExtractFile(currItem, 0, 0);
|
|
if (rv != NS_OK)
|
|
return rv;
|
|
}
|
|
}
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
//---------------------------------------------
|
|
// nsZipArchive::CloseArchive
|
|
//---------------------------------------------
|
|
nsresult nsZipArchive::CloseArchive()
|
|
{
|
|
if (mFd) {
|
|
PL_FinishArenaPool(&mArena);
|
|
mFd = nullptr;
|
|
}
|
|
|
|
// CAUTION:
|
|
// We don't need to delete each of the nsZipItem as the memory for
|
|
// the zip item and the filename it holds are both allocated from the Arena.
|
|
// Hence, destroying the Arena is like destroying all the memory
|
|
// for all the nsZipItem in one shot. But if the ~nsZipItem is doing
|
|
// anything more than cleaning up memory, we should start calling it.
|
|
// Let us also cleanup the mFiles table for re-use on the next 'open' call
|
|
memset(mFiles, 0, sizeof(mFiles));
|
|
mBuiltSynthetics = false;
|
|
return NS_OK;
|
|
}
|
|
|
|
//---------------------------------------------
|
|
// nsZipArchive::GetItem
|
|
//---------------------------------------------
|
|
nsZipItem* nsZipArchive::GetItem(const char * aEntryName)
|
|
{
|
|
if (aEntryName) {
|
|
uint32_t len = strlen(aEntryName);
|
|
//-- If the request is for a directory, make sure that synthetic entries
|
|
//-- are created for the directories without their own entry.
|
|
if (!mBuiltSynthetics) {
|
|
if ((len > 0) && (aEntryName[len-1] == '/')) {
|
|
if (BuildSynthetics() != NS_OK)
|
|
return 0;
|
|
}
|
|
}
|
|
MOZ_WIN_MEM_TRY_BEGIN
|
|
nsZipItem* item = mFiles[ HashName(aEntryName, len) ];
|
|
while (item) {
|
|
if ((len == item->nameLength) &&
|
|
(!memcmp(aEntryName, item->Name(), len))) {
|
|
|
|
// Successful GetItem() is a good indicator that the file is about to be read
|
|
zipLog.Write(mURI, aEntryName);
|
|
return item; //-- found it
|
|
}
|
|
item = item->next;
|
|
}
|
|
MOZ_WIN_MEM_TRY_CATCH(return nullptr)
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
//---------------------------------------------
|
|
// nsZipArchive::ExtractFile
|
|
// This extracts the item to the filehandle provided.
|
|
// If 'aFd' is null, it only tests the extraction.
|
|
// On extraction error(s) it removes the file.
|
|
// When needed, it also resolves the symlink.
|
|
//---------------------------------------------
|
|
nsresult nsZipArchive::ExtractFile(nsZipItem *item, const char *outname,
|
|
PRFileDesc* aFd)
|
|
{
|
|
if (!item)
|
|
return NS_ERROR_ILLEGAL_VALUE;
|
|
if (!mFd)
|
|
return NS_ERROR_FAILURE;
|
|
|
|
// Directory extraction is handled in nsJAR::Extract,
|
|
// so the item to be extracted should never be a directory
|
|
PR_ASSERT(!item->IsDirectory());
|
|
|
|
Bytef outbuf[ZIP_BUFLEN];
|
|
|
|
nsZipCursor cursor(item, this, outbuf, ZIP_BUFLEN, true);
|
|
|
|
nsresult rv = NS_OK;
|
|
|
|
while (true) {
|
|
uint32_t count = 0;
|
|
uint8_t* buf = cursor.Read(&count);
|
|
if (!buf) {
|
|
nsZipArchive::sFileCorruptedReason = "nsZipArchive: Read() failed to return a buffer";
|
|
rv = NS_ERROR_FILE_CORRUPTED;
|
|
break;
|
|
} else if (count == 0) {
|
|
break;
|
|
}
|
|
|
|
if (aFd && PR_Write(aFd, buf, count) < (READTYPE)count) {
|
|
rv = NS_ERROR_FILE_DISK_FULL;
|
|
break;
|
|
}
|
|
}
|
|
|
|
//-- delete the file on errors, or resolve symlink if needed
|
|
if (aFd) {
|
|
PR_Close(aFd);
|
|
if (rv != NS_OK)
|
|
PR_Delete(outname);
|
|
#ifdef XP_UNIX
|
|
else if (item->IsSymlink())
|
|
rv = ResolveSymlink(outname);
|
|
#endif
|
|
}
|
|
|
|
return rv;
|
|
}
|
|
|
|
//---------------------------------------------
|
|
// nsZipArchive::FindInit
|
|
//---------------------------------------------
|
|
nsresult
|
|
nsZipArchive::FindInit(const char * aPattern, nsZipFind **aFind)
|
|
{
|
|
if (!aFind)
|
|
return NS_ERROR_ILLEGAL_VALUE;
|
|
|
|
// null out param in case an error happens
|
|
*aFind = nullptr;
|
|
|
|
bool regExp = false;
|
|
char* pattern = 0;
|
|
|
|
// Create synthetic directory entries on demand
|
|
nsresult rv = BuildSynthetics();
|
|
if (rv != NS_OK)
|
|
return rv;
|
|
|
|
// validate the pattern
|
|
if (aPattern)
|
|
{
|
|
switch (NS_WildCardValid((char*)aPattern))
|
|
{
|
|
case INVALID_SXP:
|
|
return NS_ERROR_ILLEGAL_VALUE;
|
|
|
|
case NON_SXP:
|
|
regExp = false;
|
|
break;
|
|
|
|
case VALID_SXP:
|
|
regExp = true;
|
|
break;
|
|
|
|
default:
|
|
// undocumented return value from RegExpValid!
|
|
PR_ASSERT(false);
|
|
return NS_ERROR_ILLEGAL_VALUE;
|
|
}
|
|
|
|
pattern = PL_strdup(aPattern);
|
|
if (!pattern)
|
|
return NS_ERROR_OUT_OF_MEMORY;
|
|
}
|
|
|
|
*aFind = new nsZipFind(this, pattern, regExp);
|
|
if (!*aFind) {
|
|
PL_strfree(pattern);
|
|
return NS_ERROR_OUT_OF_MEMORY;
|
|
}
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
|
|
|
|
//---------------------------------------------
|
|
// nsZipFind::FindNext
|
|
//---------------------------------------------
|
|
nsresult nsZipFind::FindNext(const char ** aResult, uint16_t *aNameLen)
|
|
{
|
|
if (!mArchive || !aResult || !aNameLen)
|
|
return NS_ERROR_ILLEGAL_VALUE;
|
|
|
|
*aResult = 0;
|
|
*aNameLen = 0;
|
|
MOZ_WIN_MEM_TRY_BEGIN
|
|
// we start from last match, look for next
|
|
while (mSlot < ZIP_TABSIZE)
|
|
{
|
|
// move to next in current chain, or move to new slot
|
|
mItem = mItem ? mItem->next : mArchive->mFiles[mSlot];
|
|
|
|
bool found = false;
|
|
if (!mItem)
|
|
++mSlot; // no more in this chain, move to next slot
|
|
else if (!mPattern)
|
|
found = true; // always match
|
|
else if (mRegExp)
|
|
{
|
|
char buf[kMaxNameLength+1];
|
|
memcpy(buf, mItem->Name(), mItem->nameLength);
|
|
buf[mItem->nameLength]='\0';
|
|
found = (NS_WildCardMatch(buf, mPattern, false) == MATCH);
|
|
}
|
|
else
|
|
found = ((mItem->nameLength == strlen(mPattern)) &&
|
|
(memcmp(mItem->Name(), mPattern, mItem->nameLength) == 0));
|
|
if (found) {
|
|
// Need also to return the name length, as it is NOT zero-terminatdd...
|
|
*aResult = mItem->Name();
|
|
*aNameLen = mItem->nameLength;
|
|
return NS_OK;
|
|
}
|
|
}
|
|
MOZ_WIN_MEM_TRY_CATCH(return NS_ERROR_FAILURE)
|
|
return NS_ERROR_FILE_TARGET_DOES_NOT_EXIST;
|
|
}
|
|
|
|
#ifdef XP_UNIX
|
|
//---------------------------------------------
|
|
// ResolveSymlink
|
|
//---------------------------------------------
|
|
static nsresult ResolveSymlink(const char *path)
|
|
{
|
|
PRFileDesc * fIn = PR_Open(path, PR_RDONLY, 0000);
|
|
if (!fIn)
|
|
return NS_ERROR_FILE_DISK_FULL;
|
|
|
|
char buf[PATH_MAX+1];
|
|
int32_t length = PR_Read(fIn, (void*)buf, PATH_MAX);
|
|
PR_Close(fIn);
|
|
|
|
if ( (length <= 0)
|
|
|| ((buf[length] = 0, PR_Delete(path)) != 0)
|
|
|| (symlink(buf, path) != 0))
|
|
{
|
|
return NS_ERROR_FILE_DISK_FULL;
|
|
}
|
|
return NS_OK;
|
|
}
|
|
#endif
|
|
|
|
//***********************************************************
|
|
// nsZipArchive -- private implementation
|
|
//***********************************************************
|
|
|
|
//---------------------------------------------
|
|
// nsZipArchive::CreateZipItem
|
|
//---------------------------------------------
|
|
nsZipItem* nsZipArchive::CreateZipItem()
|
|
{
|
|
// Arena allocate the nsZipItem
|
|
void *mem;
|
|
PL_ARENA_ALLOCATE(mem, &mArena, sizeof(nsZipItem));
|
|
return (nsZipItem*)mem;
|
|
}
|
|
|
|
//---------------------------------------------
|
|
// nsZipArchive::BuildFileList
|
|
//---------------------------------------------
|
|
nsresult nsZipArchive::BuildFileList(PRFileDesc *aFd)
|
|
{
|
|
// Get archive size using end pos
|
|
const uint8_t* buf;
|
|
const uint8_t* startp = mFd->mFileData;
|
|
const uint8_t* endp = startp + mFd->mLen;
|
|
MOZ_WIN_MEM_TRY_BEGIN
|
|
uint32_t centralOffset = 4;
|
|
if (mFd->mLen > ZIPCENTRAL_SIZE && xtolong(startp + centralOffset) == CENTRALSIG) {
|
|
// Success means optimized jar layout from bug 559961 is in effect
|
|
uint32_t readaheadLength = xtolong(startp);
|
|
if (readaheadLength) {
|
|
#if defined(XP_UNIX)
|
|
madvise(const_cast<uint8_t*>(startp), readaheadLength, MADV_WILLNEED);
|
|
#elif defined(XP_WIN)
|
|
if (aFd) {
|
|
HANDLE hFile = (HANDLE) PR_FileDesc2NativeHandle(aFd);
|
|
mozilla::ReadAhead(hFile, 0, readaheadLength);
|
|
}
|
|
#endif
|
|
}
|
|
} else {
|
|
for (buf = endp - ZIPEND_SIZE; buf > startp; buf--)
|
|
{
|
|
if (xtolong(buf) == ENDSIG) {
|
|
centralOffset = xtolong(((ZipEnd *)buf)->offset_central_dir);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!centralOffset) {
|
|
nsZipArchive::sFileCorruptedReason = "nsZipArchive: no central offset";
|
|
return NS_ERROR_FILE_CORRUPTED;
|
|
}
|
|
|
|
buf = startp + centralOffset;
|
|
|
|
// avoid overflow of startp + centralOffset.
|
|
if (buf < startp) {
|
|
nsZipArchive::sFileCorruptedReason = "nsZipArchive: overflow looking for central directory";
|
|
return NS_ERROR_FILE_CORRUPTED;
|
|
}
|
|
|
|
//-- Read the central directory headers
|
|
uint32_t sig = 0;
|
|
while (buf + int32_t(sizeof(uint32_t)) <= endp &&
|
|
(sig = xtolong(buf)) == CENTRALSIG) {
|
|
// Make sure there is enough data available.
|
|
if (endp - buf < ZIPCENTRAL_SIZE) {
|
|
nsZipArchive::sFileCorruptedReason = "nsZipArchive: central directory too small";
|
|
return NS_ERROR_FILE_CORRUPTED;
|
|
}
|
|
|
|
// Read the fixed-size data.
|
|
ZipCentral* central = (ZipCentral*)buf;
|
|
|
|
uint16_t namelen = xtoint(central->filename_len);
|
|
uint16_t extralen = xtoint(central->extrafield_len);
|
|
uint16_t commentlen = xtoint(central->commentfield_len);
|
|
uint32_t diff = ZIPCENTRAL_SIZE + namelen + extralen + commentlen;
|
|
|
|
// Sanity check variable sizes and refuse to deal with
|
|
// anything too big: it's likely a corrupt archive.
|
|
if (namelen < 1 ||
|
|
namelen > kMaxNameLength) {
|
|
nsZipArchive::sFileCorruptedReason = "nsZipArchive: namelen out of range";
|
|
return NS_ERROR_FILE_CORRUPTED;
|
|
}
|
|
if (buf >= buf + diff || // No overflow
|
|
buf >= endp - diff) {
|
|
nsZipArchive::sFileCorruptedReason = "nsZipArchive: overflow looking for next item";
|
|
return NS_ERROR_FILE_CORRUPTED;
|
|
}
|
|
|
|
// Point to the next item at the top of loop
|
|
buf += diff;
|
|
|
|
nsZipItem* item = CreateZipItem();
|
|
if (!item)
|
|
return NS_ERROR_OUT_OF_MEMORY;
|
|
|
|
item->central = central;
|
|
item->nameLength = namelen;
|
|
item->isSynthetic = false;
|
|
|
|
// Add item to file table
|
|
uint32_t hash = HashName(item->Name(), namelen);
|
|
item->next = mFiles[hash];
|
|
mFiles[hash] = item;
|
|
|
|
sig = 0;
|
|
} /* while reading central directory records */
|
|
|
|
if (sig != ENDSIG) {
|
|
nsZipArchive::sFileCorruptedReason = "nsZipArchive: unexpected sig";
|
|
return NS_ERROR_FILE_CORRUPTED;
|
|
}
|
|
|
|
// Make the comment available for consumers.
|
|
if (endp - buf >= ZIPEND_SIZE) {
|
|
ZipEnd *zipend = (ZipEnd *)buf;
|
|
|
|
buf += ZIPEND_SIZE;
|
|
uint16_t commentlen = xtoint(zipend->commentfield_len);
|
|
if (endp - buf >= commentlen) {
|
|
mCommentPtr = (const char *)buf;
|
|
mCommentLen = commentlen;
|
|
}
|
|
}
|
|
|
|
MOZ_WIN_MEM_TRY_CATCH(return NS_ERROR_FAILURE)
|
|
return NS_OK;
|
|
}
|
|
|
|
//---------------------------------------------
|
|
// nsZipArchive::BuildSynthetics
|
|
//---------------------------------------------
|
|
nsresult nsZipArchive::BuildSynthetics()
|
|
{
|
|
if (mBuiltSynthetics)
|
|
return NS_OK;
|
|
mBuiltSynthetics = true;
|
|
|
|
MOZ_WIN_MEM_TRY_BEGIN
|
|
// Create synthetic entries for any missing directories.
|
|
// Do this when all ziptable has scanned to prevent double entries.
|
|
for (int i = 0; i < ZIP_TABSIZE; ++i)
|
|
{
|
|
for (nsZipItem* item = mFiles[i]; item != nullptr; item = item->next)
|
|
{
|
|
if (item->isSynthetic)
|
|
continue;
|
|
|
|
//-- add entries for directories in the current item's path
|
|
//-- go from end to beginning, because then we can stop trying
|
|
//-- to create diritems if we find that the diritem we want to
|
|
//-- create already exists
|
|
//-- start just before the last char so as to not add the item
|
|
//-- twice if it's a directory
|
|
uint16_t namelen = item->nameLength;
|
|
MOZ_ASSERT(namelen > 0, "Attempt to build synthetic for zero-length entry name!");
|
|
const char *name = item->Name();
|
|
for (uint16_t dirlen = namelen - 1; dirlen > 0; dirlen--)
|
|
{
|
|
if (name[dirlen-1] != '/')
|
|
continue;
|
|
|
|
// The character before this is '/', so if this is also '/' then we
|
|
// have an empty path component. Skip it.
|
|
if (name[dirlen] == '/')
|
|
continue;
|
|
|
|
// Is the directory already in the file table?
|
|
uint32_t hash = HashName(item->Name(), dirlen);
|
|
bool found = false;
|
|
for (nsZipItem* zi = mFiles[hash]; zi != nullptr; zi = zi->next)
|
|
{
|
|
if ((dirlen == zi->nameLength) &&
|
|
(0 == memcmp(item->Name(), zi->Name(), dirlen)))
|
|
{
|
|
// we've already added this dir and all its parents
|
|
found = true;
|
|
break;
|
|
}
|
|
}
|
|
// if the directory was found, break out of the directory
|
|
// creation loop now that we know all implicit directories
|
|
// are there -- otherwise, start creating the zip item
|
|
if (found)
|
|
break;
|
|
|
|
nsZipItem* diritem = CreateZipItem();
|
|
if (!diritem)
|
|
return NS_ERROR_OUT_OF_MEMORY;
|
|
|
|
// Point to the central record of the original item for the name part.
|
|
diritem->central = item->central;
|
|
diritem->nameLength = dirlen;
|
|
diritem->isSynthetic = true;
|
|
|
|
// add diritem to the file table
|
|
diritem->next = mFiles[hash];
|
|
mFiles[hash] = diritem;
|
|
} /* end processing of dirs in item's name */
|
|
}
|
|
}
|
|
MOZ_WIN_MEM_TRY_CATCH(return NS_ERROR_FAILURE)
|
|
return NS_OK;
|
|
}
|
|
|
|
nsZipHandle* nsZipArchive::GetFD()
|
|
{
|
|
if (!mFd)
|
|
return nullptr;
|
|
return mFd.get();
|
|
}
|
|
|
|
//---------------------------------------------
|
|
// nsZipArchive::GetDataOffset
|
|
//---------------------------------------------
|
|
uint32_t nsZipArchive::GetDataOffset(nsZipItem* aItem)
|
|
{
|
|
PR_ASSERT (aItem);
|
|
MOZ_WIN_MEM_TRY_BEGIN
|
|
//-- read local header to get variable length values and calculate
|
|
//-- the real data offset
|
|
uint32_t len = mFd->mLen;
|
|
const uint8_t* data = mFd->mFileData;
|
|
uint32_t offset = aItem->LocalOffset();
|
|
if (len < ZIPLOCAL_SIZE || offset > len - ZIPLOCAL_SIZE)
|
|
return 0;
|
|
|
|
// -- check signature before using the structure, in case the zip file is corrupt
|
|
ZipLocal* Local = (ZipLocal*)(data + offset);
|
|
if ((xtolong(Local->signature) != LOCALSIG))
|
|
return 0;
|
|
|
|
//-- NOTE: extralen is different in central header and local header
|
|
//-- for archives created using the Unix "zip" utility. To set
|
|
//-- the offset accurately we need the _local_ extralen.
|
|
offset += ZIPLOCAL_SIZE +
|
|
xtoint(Local->filename_len) +
|
|
xtoint(Local->extrafield_len);
|
|
|
|
return offset;
|
|
MOZ_WIN_MEM_TRY_CATCH(return 0)
|
|
}
|
|
|
|
//---------------------------------------------
|
|
// nsZipArchive::GetData
|
|
//---------------------------------------------
|
|
const uint8_t* nsZipArchive::GetData(nsZipItem* aItem)
|
|
{
|
|
PR_ASSERT (aItem);
|
|
MOZ_WIN_MEM_TRY_BEGIN
|
|
uint32_t offset = GetDataOffset(aItem);
|
|
|
|
// -- check if there is enough source data in the file
|
|
if (!offset ||
|
|
mFd->mLen < aItem->Size() ||
|
|
offset > mFd->mLen - aItem->Size() ||
|
|
(aItem->Compression() == STORED && aItem->Size() != aItem->RealSize())) {
|
|
return nullptr;
|
|
}
|
|
|
|
return mFd->mFileData + offset;
|
|
MOZ_WIN_MEM_TRY_CATCH(return nullptr)
|
|
}
|
|
|
|
// nsZipArchive::GetComment
|
|
bool nsZipArchive::GetComment(nsACString &aComment)
|
|
{
|
|
MOZ_WIN_MEM_TRY_BEGIN
|
|
aComment.Assign(mCommentPtr, mCommentLen);
|
|
MOZ_WIN_MEM_TRY_CATCH(return false)
|
|
return true;
|
|
}
|
|
|
|
//---------------------------------------------
|
|
// nsZipArchive::SizeOfMapping
|
|
//---------------------------------------------
|
|
int64_t nsZipArchive::SizeOfMapping()
|
|
{
|
|
return mFd ? mFd->SizeOfMapping() : 0;
|
|
}
|
|
|
|
//------------------------------------------
|
|
// nsZipArchive constructor and destructor
|
|
//------------------------------------------
|
|
|
|
nsZipArchive::nsZipArchive()
|
|
: mRefCnt(0)
|
|
, mCommentPtr(nullptr)
|
|
, mCommentLen(0)
|
|
, mBuiltSynthetics(false)
|
|
{
|
|
zipLog.AddRef();
|
|
|
|
MOZ_COUNT_CTOR(nsZipArchive);
|
|
|
|
// initialize the table to nullptr
|
|
memset(mFiles, 0, sizeof(mFiles));
|
|
}
|
|
|
|
NS_IMPL_ADDREF(nsZipArchive)
|
|
NS_IMPL_RELEASE(nsZipArchive)
|
|
|
|
nsZipArchive::~nsZipArchive()
|
|
{
|
|
CloseArchive();
|
|
|
|
MOZ_COUNT_DTOR(nsZipArchive);
|
|
|
|
zipLog.Release();
|
|
}
|
|
|
|
|
|
//------------------------------------------
|
|
// nsZipFind constructor and destructor
|
|
//------------------------------------------
|
|
|
|
nsZipFind::nsZipFind(nsZipArchive* aZip, char* aPattern, bool aRegExp)
|
|
: mArchive(aZip)
|
|
, mPattern(aPattern)
|
|
, mItem(nullptr)
|
|
, mSlot(0)
|
|
, mRegExp(aRegExp)
|
|
{
|
|
MOZ_COUNT_CTOR(nsZipFind);
|
|
}
|
|
|
|
nsZipFind::~nsZipFind()
|
|
{
|
|
PL_strfree(mPattern);
|
|
|
|
MOZ_COUNT_DTOR(nsZipFind);
|
|
}
|
|
|
|
//------------------------------------------
|
|
// helper functions
|
|
//------------------------------------------
|
|
|
|
/*
|
|
* HashName
|
|
*
|
|
* returns a hash key for the entry name
|
|
*/
|
|
static uint32_t HashName(const char* aName, uint16_t len)
|
|
{
|
|
PR_ASSERT(aName != 0);
|
|
|
|
const uint8_t* p = (const uint8_t*)aName;
|
|
const uint8_t* endp = p + len;
|
|
uint32_t val = 0;
|
|
while (p != endp) {
|
|
val = val*37 + *p++;
|
|
}
|
|
|
|
return (val % ZIP_TABSIZE);
|
|
}
|
|
|
|
/*
|
|
* x t o i n t
|
|
*
|
|
* Converts a two byte ugly endianed integer
|
|
* to our platform's integer.
|
|
*/
|
|
static uint16_t xtoint (const uint8_t *ii)
|
|
{
|
|
return (uint16_t) ((ii [0]) | (ii [1] << 8));
|
|
}
|
|
|
|
/*
|
|
* x t o l o n g
|
|
*
|
|
* Converts a four byte ugly endianed integer
|
|
* to our platform's integer.
|
|
*/
|
|
static uint32_t xtolong (const uint8_t *ll)
|
|
{
|
|
return (uint32_t)( (ll [0] << 0) |
|
|
(ll [1] << 8) |
|
|
(ll [2] << 16) |
|
|
(ll [3] << 24) );
|
|
}
|
|
|
|
/*
|
|
* GetModTime
|
|
*
|
|
* returns last modification time in microseconds
|
|
*/
|
|
static PRTime GetModTime(uint16_t aDate, uint16_t aTime)
|
|
{
|
|
// Note that on DST shift we can't handle correctly the hour that is valid
|
|
// in both DST zones
|
|
PRExplodedTime time;
|
|
|
|
time.tm_usec = 0;
|
|
|
|
time.tm_hour = (aTime >> 11) & 0x1F;
|
|
time.tm_min = (aTime >> 5) & 0x3F;
|
|
time.tm_sec = (aTime & 0x1F) * 2;
|
|
|
|
time.tm_year = (aDate >> 9) + 1980;
|
|
time.tm_month = ((aDate >> 5) & 0x0F) - 1;
|
|
time.tm_mday = aDate & 0x1F;
|
|
|
|
time.tm_params.tp_gmt_offset = 0;
|
|
time.tm_params.tp_dst_offset = 0;
|
|
|
|
PR_NormalizeTime(&time, PR_GMTParameters);
|
|
time.tm_params.tp_gmt_offset = PR_LocalTimeParameters(&time).tp_gmt_offset;
|
|
PR_NormalizeTime(&time, PR_GMTParameters);
|
|
time.tm_params.tp_dst_offset = PR_LocalTimeParameters(&time).tp_dst_offset;
|
|
|
|
return PR_ImplodeTime(&time);
|
|
}
|
|
|
|
nsZipItem::nsZipItem()
|
|
: next(nullptr)
|
|
, central(nullptr)
|
|
, nameLength(0)
|
|
, isSynthetic(false)
|
|
{}
|
|
|
|
uint32_t nsZipItem::LocalOffset()
|
|
{
|
|
return xtolong(central->localhdr_offset);
|
|
}
|
|
|
|
uint32_t nsZipItem::Size()
|
|
{
|
|
return isSynthetic ? 0 : xtolong(central->size);
|
|
}
|
|
|
|
uint32_t nsZipItem::RealSize()
|
|
{
|
|
return isSynthetic ? 0 : xtolong(central->orglen);
|
|
}
|
|
|
|
uint32_t nsZipItem::CRC32()
|
|
{
|
|
return isSynthetic ? 0 : xtolong(central->crc32);
|
|
}
|
|
|
|
uint16_t nsZipItem::Date()
|
|
{
|
|
return isSynthetic ? kSyntheticDate : xtoint(central->date);
|
|
}
|
|
|
|
uint16_t nsZipItem::Time()
|
|
{
|
|
return isSynthetic ? kSyntheticTime : xtoint(central->time);
|
|
}
|
|
|
|
uint16_t nsZipItem::Compression()
|
|
{
|
|
return isSynthetic ? STORED : xtoint(central->method);
|
|
}
|
|
|
|
bool nsZipItem::IsDirectory()
|
|
{
|
|
return isSynthetic || ((nameLength > 0) && ('/' == Name()[nameLength - 1]));
|
|
}
|
|
|
|
uint16_t nsZipItem::Mode()
|
|
{
|
|
if (isSynthetic) return 0755;
|
|
return ((uint16_t)(central->external_attributes[2]) | 0x100);
|
|
}
|
|
|
|
const uint8_t * nsZipItem::GetExtraField(uint16_t aTag, uint16_t *aBlockSize)
|
|
{
|
|
if (isSynthetic) return nullptr;
|
|
MOZ_WIN_MEM_TRY_BEGIN
|
|
const unsigned char *buf = ((const unsigned char*)central) + ZIPCENTRAL_SIZE +
|
|
nameLength;
|
|
uint32_t buflen = (uint32_t)xtoint(central->extrafield_len);
|
|
uint32_t pos = 0;
|
|
uint16_t tag, blocksize;
|
|
|
|
while (buf && (pos + 4) <= buflen) {
|
|
tag = xtoint(buf + pos);
|
|
blocksize = xtoint(buf + pos + 2);
|
|
|
|
if (aTag == tag && (pos + 4 + blocksize) <= buflen) {
|
|
*aBlockSize = blocksize;
|
|
return buf + pos;
|
|
}
|
|
|
|
pos += blocksize + 4;
|
|
}
|
|
|
|
MOZ_WIN_MEM_TRY_CATCH(return nullptr)
|
|
return nullptr;
|
|
}
|
|
|
|
|
|
PRTime nsZipItem::LastModTime()
|
|
{
|
|
if (isSynthetic) return GetModTime(kSyntheticDate, kSyntheticTime);
|
|
|
|
// Try to read timestamp from extra field
|
|
uint16_t blocksize;
|
|
const uint8_t *tsField = GetExtraField(EXTENDED_TIMESTAMP_FIELD, &blocksize);
|
|
if (tsField && blocksize >= 5 && tsField[4] & EXTENDED_TIMESTAMP_MODTIME) {
|
|
return (PRTime)(xtolong(tsField + 5)) * PR_USEC_PER_SEC;
|
|
}
|
|
|
|
return GetModTime(Date(), Time());
|
|
}
|
|
|
|
#ifdef XP_UNIX
|
|
bool nsZipItem::IsSymlink()
|
|
{
|
|
if (isSynthetic) return false;
|
|
return (xtoint(central->external_attributes+2) & S_IFMT) == S_IFLNK;
|
|
}
|
|
#endif
|
|
|
|
nsZipCursor::nsZipCursor(nsZipItem *item, nsZipArchive *aZip, uint8_t* aBuf,
|
|
uint32_t aBufSize, bool doCRC)
|
|
: mItem(item)
|
|
, mBuf(aBuf)
|
|
, mBufSize(aBufSize)
|
|
, mCRC(0)
|
|
, mDoCRC(doCRC)
|
|
{
|
|
if (mItem->Compression() == DEFLATED) {
|
|
#ifdef DEBUG
|
|
nsresult status =
|
|
#endif
|
|
gZlibInit(&mZs);
|
|
NS_ASSERTION(status == NS_OK, "Zlib failed to initialize");
|
|
NS_ASSERTION(aBuf, "Must pass in a buffer for DEFLATED nsZipItem");
|
|
}
|
|
|
|
mZs.avail_in = item->Size();
|
|
mZs.next_in = (Bytef*)aZip->GetData(item);
|
|
|
|
if (doCRC)
|
|
mCRC = crc32(0L, Z_NULL, 0);
|
|
}
|
|
|
|
nsZipCursor::~nsZipCursor()
|
|
{
|
|
if (mItem->Compression() == DEFLATED) {
|
|
inflateEnd(&mZs);
|
|
}
|
|
}
|
|
|
|
uint8_t* nsZipCursor::ReadOrCopy(uint32_t *aBytesRead, bool aCopy) {
|
|
int zerr;
|
|
uint8_t *buf = nullptr;
|
|
bool verifyCRC = true;
|
|
|
|
if (!mZs.next_in)
|
|
return nullptr;
|
|
MOZ_WIN_MEM_TRY_BEGIN
|
|
switch (mItem->Compression()) {
|
|
case STORED:
|
|
if (!aCopy) {
|
|
*aBytesRead = mZs.avail_in;
|
|
buf = mZs.next_in;
|
|
mZs.next_in += mZs.avail_in;
|
|
mZs.avail_in = 0;
|
|
} else {
|
|
*aBytesRead = mZs.avail_in > mBufSize ? mBufSize : mZs.avail_in;
|
|
memcpy(mBuf, mZs.next_in, *aBytesRead);
|
|
mZs.avail_in -= *aBytesRead;
|
|
mZs.next_in += *aBytesRead;
|
|
}
|
|
break;
|
|
case DEFLATED:
|
|
buf = mBuf;
|
|
mZs.next_out = buf;
|
|
mZs.avail_out = mBufSize;
|
|
|
|
zerr = inflate(&mZs, Z_PARTIAL_FLUSH);
|
|
if (zerr != Z_OK && zerr != Z_STREAM_END)
|
|
return nullptr;
|
|
|
|
*aBytesRead = mZs.next_out - buf;
|
|
verifyCRC = (zerr == Z_STREAM_END);
|
|
break;
|
|
default:
|
|
return nullptr;
|
|
}
|
|
|
|
if (mDoCRC) {
|
|
mCRC = crc32(mCRC, (const unsigned char*)buf, *aBytesRead);
|
|
if (verifyCRC && mCRC != mItem->CRC32())
|
|
return nullptr;
|
|
}
|
|
MOZ_WIN_MEM_TRY_CATCH(return nullptr)
|
|
return buf;
|
|
}
|
|
|
|
nsZipItemPtr_base::nsZipItemPtr_base(nsZipArchive *aZip,
|
|
const char * aEntryName, bool doCRC)
|
|
: mReturnBuf(nullptr)
|
|
, mReadlen(0)
|
|
{
|
|
// make sure the ziparchive hangs around
|
|
mZipHandle = aZip->GetFD();
|
|
|
|
nsZipItem* item = aZip->GetItem(aEntryName);
|
|
if (!item)
|
|
return;
|
|
|
|
uint32_t size = 0;
|
|
if (item->Compression() == DEFLATED) {
|
|
size = item->RealSize();
|
|
mAutoBuf = MakeUniqueFallible<uint8_t[]>(size);
|
|
if (!mAutoBuf) {
|
|
return;
|
|
}
|
|
}
|
|
|
|
nsZipCursor cursor(item, aZip, mAutoBuf.get(), size, doCRC);
|
|
mReturnBuf = cursor.Read(&mReadlen);
|
|
if (!mReturnBuf) {
|
|
return;
|
|
}
|
|
|
|
if (mReadlen != item->RealSize()) {
|
|
NS_ASSERTION(mReadlen == item->RealSize(), "nsZipCursor underflow");
|
|
mReturnBuf = nullptr;
|
|
return;
|
|
}
|
|
}
|
|
|
|
/* static */ const char*
|
|
nsZipArchive::sFileCorruptedReason = nullptr;
|