Add m-esr52 at 52.6.0

1 files changed, 1294 insertions, 0 deletions

diff --git a/modules/libjar/nsZipArchive.cpp b/modules/libjar/nsZipArchive.cpp
new file mode 100644
index 000000000..429de1011
--- /dev/null
+++ b/modules/libjar/nsZipArchive.cpp
@@ -0,0 +1,1294 @@
+/* -*- 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)
+      rv = logFile->Create(nsIFile::NORMAL_FILE_TYPE, 0644);
+      if (NS_FAILED(rv))
+        return;
+
+      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)
+  , mFileStart(nullptr)
+  , mTotalLen(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->mTotalLen = (uint32_t) size;
+  handle->mFileStart = buf;
+  rv = handle->findDataStart();
+  if (NS_FAILED(rv)) {
+    PR_MemUnmap(buf, (uint32_t) size);
+    PR_CloseFileMap(map);
+    return rv;
+  }
+  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->mTotalLen = handle->mBuf->Length();
+  handle->mFileStart = handle->mBuf->Buffer();
+  nsresult rv = handle->findDataStart();
+  if (NS_FAILED(rv)) {
+    return rv;
+  }
+  handle.forget(ret);
+  return NS_OK;
+}
+
+nsresult nsZipHandle::Init(const uint8_t* aData, uint32_t aLen,
+                           nsZipHandle **aRet)
+{
+  RefPtr<nsZipHandle> handle = new nsZipHandle();
+
+  handle->mFileStart = aData;
+  handle->mTotalLen = aLen;
+  nsresult rv = handle->findDataStart();
+  if (NS_FAILED(rv)) {
+    return rv;
+  }
+  handle.forget(aRet);
+  return NS_OK;
+}
+
+// This function finds the start of the ZIP data. If the file is a regular ZIP,
+// this is just the start of the file. If the file is a CRX file, the start of
+// the data is after the CRX header.
+// CRX header reference: (CRX version 2)
+//    Header requires little-endian byte ordering with 4-byte alignment.
+//    32 bits       : magicNumber   - Defined as a |char m[] = "Cr24"|.
+//                                    Equivilant to |uint32_t m = 0x34327243|.
+//    32 bits       : version       - Unsigned integer representing the CRX file
+//                                    format version. Currently equal to 2.
+//    32 bits       : pubKeyLength  - Unsigned integer representing the length
+//                                    of the public key in bytes.
+//    32 bits       : sigLength     - Unsigned integer representing the length
+//                                    of the signature in bytes.
+//    pubKeyLength  : publicKey     - Contents of the author's public key.
+//    sigLength     : signature     - Signature of the ZIP content.
+//                                    Signature is created using the RSA
+//                                    algorighm with the SHA-1 hash function.
+nsresult nsZipHandle::findDataStart()
+{
+  // In the CRX header, integers are 32 bits. Our pointer to the file is of
+  // type |uint8_t|, which is guaranteed to be 8 bits.
+  const uint32_t CRXIntSize = 4;
+
+MOZ_WIN_MEM_TRY_BEGIN
+  if (mTotalLen > CRXIntSize * 4 && xtolong(mFileStart) == kCRXMagic) {
+    const uint8_t* headerData = mFileStart;
+    headerData += CRXIntSize * 2; // Skip magic number and version number
+    uint32_t pubKeyLength = xtolong(headerData);
+    headerData += CRXIntSize;
+    uint32_t sigLength = xtolong(headerData);
+    uint32_t headerSize = CRXIntSize * 4 + pubKeyLength + sigLength;
+    if (mTotalLen > headerSize) {
+      mLen = mTotalLen - headerSize;
+      mFileData = mFileStart + headerSize;
+      return NS_OK;
+    }
+  }
+  mLen = mTotalLen;
+  mFileData = mFileStart;
+MOZ_WIN_MEM_TRY_CATCH(return NS_ERROR_FAILURE)
+  return NS_OK;
+}
+
+int64_t nsZipHandle::SizeOfMapping()
+{
+  return mTotalLen;
+}
+
+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 *)mFileStart, mTotalLen);
+    PR_CloseFileMap(mMap);
+  }
+  mFileStart = nullptr;
+  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
+  MOZ_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)) > buf) &&
+         (buf + int32_t(sizeof(uint32_t)) <= endp) &&
+         ((sig = xtolong(buf)) == CENTRALSIG)) {
+    // Make sure there is enough data available.
+    if ((buf > endp) || (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) && (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)
+{
+  MOZ_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)
+{
+  MOZ_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)
+{
+  MOZ_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;