summaryrefslogtreecommitdiffstats
path: root/modules/libjar/zipwriter/nsZipWriter.cpp
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--modules/libjar/zipwriter/nsZipWriter.cpp1059
1 files changed, 1059 insertions, 0 deletions
diff --git a/modules/libjar/zipwriter/nsZipWriter.cpp b/modules/libjar/zipwriter/nsZipWriter.cpp
new file mode 100644
index 0000000000..43c890a7ea
--- /dev/null
+++ b/modules/libjar/zipwriter/nsZipWriter.cpp
@@ -0,0 +1,1059 @@
+/* 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 "nsZipWriter.h"
+
+#include <algorithm>
+
+#include "StreamFunctions.h"
+#include "nsZipDataStream.h"
+#include "nsISeekableStream.h"
+#include "nsIStreamListener.h"
+#include "nsIInputStreamPump.h"
+#include "nsComponentManagerUtils.h"
+#include "nsError.h"
+#include "nsStreamUtils.h"
+#include "nsThreadUtils.h"
+#include "nsNetUtil.h"
+#include "nsIChannel.h"
+#include "nsIFile.h"
+#include "prio.h"
+
+#define ZIP_EOCDR_HEADER_SIZE 22
+#define ZIP_EOCDR_HEADER_SIGNATURE 0x06054b50
+
+using namespace mozilla;
+
+/**
+ * nsZipWriter is used to create and add to zip files.
+ * It is based on the spec available at
+ * http://www.pkware.com/documents/casestudies/APPNOTE.TXT.
+ *
+ * The basic structure of a zip file created is slightly simpler than that
+ * illustrated in the spec because certain features of the zip format are
+ * unsupported:
+ *
+ * [local file header 1]
+ * [file data 1]
+ * .
+ * .
+ * .
+ * [local file header n]
+ * [file data n]
+ * [central directory]
+ * [end of central directory record]
+ */
+NS_IMPL_ISUPPORTS(nsZipWriter, nsIZipWriter, nsIRequestObserver)
+
+nsZipWriter::nsZipWriter() : mCDSOffset(0), mCDSDirty(false), mInQueue(false) {}
+
+nsZipWriter::~nsZipWriter() {
+ if (mStream && !mInQueue) Close();
+}
+
+NS_IMETHODIMP nsZipWriter::GetComment(nsACString& aComment) {
+ if (!mStream) return NS_ERROR_NOT_INITIALIZED;
+
+ aComment = mComment;
+ return NS_OK;
+}
+
+NS_IMETHODIMP nsZipWriter::SetComment(const nsACString& aComment) {
+ if (!mStream) return NS_ERROR_NOT_INITIALIZED;
+
+ mComment = aComment;
+ mCDSDirty = true;
+ return NS_OK;
+}
+
+NS_IMETHODIMP nsZipWriter::GetInQueue(bool* aInQueue) {
+ *aInQueue = mInQueue;
+ return NS_OK;
+}
+
+NS_IMETHODIMP nsZipWriter::GetFile(nsIFile** aFile) {
+ if (!mFile) return NS_ERROR_NOT_INITIALIZED;
+
+ nsCOMPtr<nsIFile> file;
+ nsresult rv = mFile->Clone(getter_AddRefs(file));
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ NS_ADDREF(*aFile = file);
+ return NS_OK;
+}
+
+/*
+ * Reads file entries out of an existing zip file.
+ */
+nsresult nsZipWriter::ReadFile(nsIFile* aFile) {
+ int64_t size;
+ nsresult rv = aFile->GetFileSize(&size);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ // If the file is too short, it cannot be a valid archive, thus we fail
+ // without even attempting to open it
+ NS_ENSURE_TRUE(size > ZIP_EOCDR_HEADER_SIZE, NS_ERROR_FILE_CORRUPTED);
+
+ nsCOMPtr<nsIInputStream> inputStream;
+ rv = NS_NewLocalFileInputStream(getter_AddRefs(inputStream), aFile);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ uint8_t buf[1024];
+ int64_t seek = size - 1024;
+ uint32_t length = 1024;
+
+ nsCOMPtr<nsISeekableStream> seekable = do_QueryInterface(inputStream);
+
+ while (true) {
+ if (seek < 0) {
+ length += (int32_t)seek;
+ seek = 0;
+ }
+
+ rv = seekable->Seek(nsISeekableStream::NS_SEEK_SET, seek);
+ if (NS_FAILED(rv)) {
+ inputStream->Close();
+ return rv;
+ }
+ rv = ZW_ReadData(inputStream, (char*)buf, length);
+ if (NS_FAILED(rv)) {
+ inputStream->Close();
+ return rv;
+ }
+
+ /*
+ * We have to backtrack from the end of the file until we find the
+ * CDS signature
+ */
+ // We know it's at least this far from the end
+ for (uint32_t pos = length - ZIP_EOCDR_HEADER_SIZE; (int32_t)pos >= 0;
+ pos--) {
+ uint32_t sig = PEEK32(buf + pos);
+ if (sig == ZIP_EOCDR_HEADER_SIGNATURE) {
+ // Skip down to entry count
+ pos += 10;
+ uint32_t entries = READ16(buf, &pos);
+ // Skip past CDS size
+ pos += 4;
+ mCDSOffset = READ32(buf, &pos);
+ uint32_t commentlen = READ16(buf, &pos);
+
+ if (commentlen == 0)
+ mComment.Truncate();
+ else if (pos + commentlen <= length)
+ mComment.Assign((const char*)buf + pos, commentlen);
+ else {
+ if ((seek + pos + commentlen) > size) {
+ inputStream->Close();
+ return NS_ERROR_FILE_CORRUPTED;
+ }
+ auto field = MakeUnique<char[]>(commentlen);
+ NS_ENSURE_TRUE(field, NS_ERROR_OUT_OF_MEMORY);
+ rv = seekable->Seek(nsISeekableStream::NS_SEEK_SET, seek + pos);
+ if (NS_FAILED(rv)) {
+ inputStream->Close();
+ return rv;
+ }
+ rv = ZW_ReadData(inputStream, field.get(), length);
+ if (NS_FAILED(rv)) {
+ inputStream->Close();
+ return rv;
+ }
+ mComment.Assign(field.get(), commentlen);
+ }
+
+ rv = seekable->Seek(nsISeekableStream::NS_SEEK_SET, mCDSOffset);
+ if (NS_FAILED(rv)) {
+ inputStream->Close();
+ return rv;
+ }
+
+ for (uint32_t entry = 0; entry < entries; entry++) {
+ nsZipHeader* header = new nsZipHeader();
+ if (!header) {
+ inputStream->Close();
+ mEntryHash.Clear();
+ mHeaders.Clear();
+ return NS_ERROR_OUT_OF_MEMORY;
+ }
+ rv = header->ReadCDSHeader(inputStream);
+ if (NS_FAILED(rv)) {
+ inputStream->Close();
+ mEntryHash.Clear();
+ mHeaders.Clear();
+ return rv;
+ }
+ mEntryHash.InsertOrUpdate(header->mName, mHeaders.Count());
+ if (!mHeaders.AppendObject(header)) return NS_ERROR_OUT_OF_MEMORY;
+ }
+
+ return inputStream->Close();
+ }
+ }
+
+ if (seek == 0) {
+ // We've reached the start with no signature found. Corrupt.
+ inputStream->Close();
+ return NS_ERROR_FILE_CORRUPTED;
+ }
+
+ // Overlap by the size of the end of cdr
+ seek -= (1024 - ZIP_EOCDR_HEADER_SIZE);
+ }
+ // Will never reach here in reality
+ MOZ_ASSERT_UNREACHABLE("Loop should never complete");
+ return NS_ERROR_UNEXPECTED;
+}
+
+NS_IMETHODIMP nsZipWriter::Open(nsIFile* aFile, int32_t aIoFlags) {
+ if (mStream) return NS_ERROR_ALREADY_INITIALIZED;
+
+ NS_ENSURE_ARG_POINTER(aFile);
+
+ // Need to be able to write to the file
+ if (aIoFlags & PR_RDONLY) return NS_ERROR_FAILURE;
+
+ nsresult rv = aFile->Clone(getter_AddRefs(mFile));
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ bool exists;
+ rv = mFile->Exists(&exists);
+ NS_ENSURE_SUCCESS(rv, rv);
+ if (!exists && !(aIoFlags & PR_CREATE_FILE)) return NS_ERROR_FILE_NOT_FOUND;
+
+ if (exists && !(aIoFlags & (PR_TRUNCATE | PR_WRONLY))) {
+ rv = ReadFile(mFile);
+ NS_ENSURE_SUCCESS(rv, rv);
+ mCDSDirty = false;
+ } else {
+ mCDSOffset = 0;
+ mCDSDirty = true;
+ mComment.Truncate();
+ }
+
+ // Silently drop PR_APPEND
+ aIoFlags &= 0xef;
+
+ nsCOMPtr<nsIOutputStream> stream;
+ rv = NS_NewLocalFileOutputStream(getter_AddRefs(stream), mFile, aIoFlags);
+ if (NS_FAILED(rv)) {
+ mHeaders.Clear();
+ mEntryHash.Clear();
+ return rv;
+ }
+
+ rv = NS_NewBufferedOutputStream(getter_AddRefs(mStream), stream.forget(),
+ 64 * 1024);
+ if (NS_FAILED(rv)) {
+ mHeaders.Clear();
+ mEntryHash.Clear();
+ return rv;
+ }
+
+ if (mCDSOffset > 0) {
+ rv = SeekCDS();
+ NS_ENSURE_SUCCESS(rv, rv);
+ }
+
+ return NS_OK;
+}
+
+NS_IMETHODIMP nsZipWriter::GetEntry(const nsACString& aZipEntry,
+ nsIZipEntry** _retval) {
+ int32_t pos;
+ if (mEntryHash.Get(aZipEntry, &pos))
+ NS_ADDREF(*_retval = mHeaders[pos]);
+ else
+ *_retval = nullptr;
+
+ return NS_OK;
+}
+
+NS_IMETHODIMP nsZipWriter::HasEntry(const nsACString& aZipEntry,
+ bool* _retval) {
+ *_retval = mEntryHash.Get(aZipEntry, nullptr);
+
+ return NS_OK;
+}
+
+NS_IMETHODIMP nsZipWriter::AddEntryDirectory(const nsACString& aZipEntry,
+ PRTime aModTime, bool aQueue) {
+ if (!mStream) return NS_ERROR_NOT_INITIALIZED;
+
+ if (aQueue) {
+ nsZipQueueItem item;
+ item.mOperation = OPERATION_ADD;
+ item.mZipEntry = aZipEntry;
+ item.mModTime = aModTime;
+ item.mPermissions = PERMISSIONS_DIR;
+ // XXX(Bug 1631371) Check if this should use a fallible operation as it
+ // pretended earlier.
+ mQueue.AppendElement(item);
+ return NS_OK;
+ }
+
+ if (mInQueue) return NS_ERROR_IN_PROGRESS;
+ return InternalAddEntryDirectory(aZipEntry, aModTime, PERMISSIONS_DIR);
+}
+
+NS_IMETHODIMP nsZipWriter::AddEntryFile(const nsACString& aZipEntry,
+ int32_t aCompression, nsIFile* aFile,
+ bool aQueue) {
+ NS_ENSURE_ARG_POINTER(aFile);
+ if (!mStream) return NS_ERROR_NOT_INITIALIZED;
+
+ nsresult rv;
+ if (aQueue) {
+ nsZipQueueItem item;
+ item.mOperation = OPERATION_ADD;
+ item.mZipEntry = aZipEntry;
+ item.mCompression = aCompression;
+ rv = aFile->Clone(getter_AddRefs(item.mFile));
+ NS_ENSURE_SUCCESS(rv, rv);
+ // XXX(Bug 1631371) Check if this should use a fallible operation as it
+ // pretended earlier.
+ mQueue.AppendElement(item);
+ return NS_OK;
+ }
+
+ if (mInQueue) return NS_ERROR_IN_PROGRESS;
+
+ bool exists;
+ rv = aFile->Exists(&exists);
+ NS_ENSURE_SUCCESS(rv, rv);
+ if (!exists) return NS_ERROR_FILE_NOT_FOUND;
+
+ bool isdir;
+ rv = aFile->IsDirectory(&isdir);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ PRTime modtime;
+ rv = aFile->GetLastModifiedTime(&modtime);
+ NS_ENSURE_SUCCESS(rv, rv);
+ modtime *= PR_USEC_PER_MSEC;
+
+ uint32_t permissions;
+ rv = aFile->GetPermissions(&permissions);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ if (isdir) return InternalAddEntryDirectory(aZipEntry, modtime, permissions);
+
+ if (mEntryHash.Get(aZipEntry, nullptr)) return NS_ERROR_FILE_ALREADY_EXISTS;
+
+ nsCOMPtr<nsIInputStream> inputStream;
+ rv = NS_NewLocalFileInputStream(getter_AddRefs(inputStream), aFile);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ rv = AddEntryStream(aZipEntry, modtime, aCompression, inputStream, false,
+ permissions);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ return inputStream->Close();
+}
+
+NS_IMETHODIMP nsZipWriter::AddEntryChannel(const nsACString& aZipEntry,
+ PRTime aModTime,
+ int32_t aCompression,
+ nsIChannel* aChannel, bool aQueue) {
+ NS_ENSURE_ARG_POINTER(aChannel);
+ if (!mStream) return NS_ERROR_NOT_INITIALIZED;
+
+ if (aQueue) {
+ nsZipQueueItem item;
+ item.mOperation = OPERATION_ADD;
+ item.mZipEntry = aZipEntry;
+ item.mModTime = aModTime;
+ item.mCompression = aCompression;
+ item.mPermissions = PERMISSIONS_FILE;
+ item.mChannel = aChannel;
+ // XXX(Bug 1631371) Check if this should use a fallible operation as it
+ // pretended earlier.
+ mQueue.AppendElement(item);
+ return NS_OK;
+ }
+
+ if (mInQueue) return NS_ERROR_IN_PROGRESS;
+ if (mEntryHash.Get(aZipEntry, nullptr)) return NS_ERROR_FILE_ALREADY_EXISTS;
+
+ nsCOMPtr<nsIInputStream> inputStream;
+ nsresult rv = aChannel->Open(getter_AddRefs(inputStream));
+
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ rv = AddEntryStream(aZipEntry, aModTime, aCompression, inputStream, false,
+ PERMISSIONS_FILE);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ return inputStream->Close();
+}
+
+NS_IMETHODIMP nsZipWriter::AddEntryStream(const nsACString& aZipEntry,
+ PRTime aModTime, int32_t aCompression,
+ nsIInputStream* aStream,
+ bool aQueue) {
+ return AddEntryStream(aZipEntry, aModTime, aCompression, aStream, aQueue,
+ PERMISSIONS_FILE);
+}
+
+nsresult nsZipWriter::AddEntryStream(const nsACString& aZipEntry,
+ PRTime aModTime, int32_t aCompression,
+ nsIInputStream* aStream, bool aQueue,
+ uint32_t aPermissions) {
+ NS_ENSURE_ARG_POINTER(aStream);
+ if (!mStream) return NS_ERROR_NOT_INITIALIZED;
+
+ if (aQueue) {
+ nsZipQueueItem item;
+ item.mOperation = OPERATION_ADD;
+ item.mZipEntry = aZipEntry;
+ item.mModTime = aModTime;
+ item.mCompression = aCompression;
+ item.mPermissions = aPermissions;
+ item.mStream = aStream;
+ // XXX(Bug 1631371) Check if this should use a fallible operation as it
+ // pretended earlier.
+ mQueue.AppendElement(item);
+ return NS_OK;
+ }
+
+ if (mInQueue) return NS_ERROR_IN_PROGRESS;
+ if (mEntryHash.Get(aZipEntry, nullptr)) return NS_ERROR_FILE_ALREADY_EXISTS;
+
+ RefPtr<nsZipHeader> header = new nsZipHeader();
+ NS_ENSURE_TRUE(header, NS_ERROR_OUT_OF_MEMORY);
+ nsresult rv = header->Init(
+ aZipEntry, aModTime, ZIP_ATTRS(aPermissions, ZIP_ATTRS_FILE), mCDSOffset);
+ if (NS_FAILED(rv)) {
+ SeekCDS();
+ return rv;
+ }
+
+ rv = header->WriteFileHeader(mStream);
+ if (NS_FAILED(rv)) {
+ SeekCDS();
+ return rv;
+ }
+
+ RefPtr<nsZipDataStream> stream = new nsZipDataStream();
+ if (!stream) {
+ SeekCDS();
+ return NS_ERROR_OUT_OF_MEMORY;
+ }
+ rv = stream->Init(this, mStream, header, aCompression);
+ if (NS_FAILED(rv)) {
+ SeekCDS();
+ return rv;
+ }
+
+ rv = stream->ReadStream(aStream);
+ if (NS_FAILED(rv)) SeekCDS();
+ return rv;
+}
+
+NS_IMETHODIMP nsZipWriter::RemoveEntry(const nsACString& aZipEntry,
+ bool aQueue) {
+ if (!mStream) return NS_ERROR_NOT_INITIALIZED;
+
+ if (aQueue) {
+ nsZipQueueItem item;
+ item.mOperation = OPERATION_REMOVE;
+ item.mZipEntry = aZipEntry;
+ // XXX(Bug 1631371) Check if this should use a fallible operation as it
+ // pretended earlier.
+ mQueue.AppendElement(item);
+ return NS_OK;
+ }
+
+ if (mInQueue) return NS_ERROR_IN_PROGRESS;
+
+ int32_t pos;
+ if (mEntryHash.Get(aZipEntry, &pos)) {
+ // Flush any remaining data before we seek.
+ nsresult rv = mStream->Flush();
+ NS_ENSURE_SUCCESS(rv, rv);
+ if (pos < mHeaders.Count() - 1) {
+ // This is not the last entry, pull back the data.
+ nsCOMPtr<nsISeekableStream> seekable = do_QueryInterface(mStream);
+ rv = seekable->Seek(nsISeekableStream::NS_SEEK_SET,
+ mHeaders[pos]->mOffset);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ nsCOMPtr<nsIInputStream> inputStream;
+ rv = NS_NewLocalFileInputStream(getter_AddRefs(inputStream), mFile);
+ NS_ENSURE_SUCCESS(rv, rv);
+ seekable = do_QueryInterface(inputStream);
+ rv = seekable->Seek(nsISeekableStream::NS_SEEK_SET,
+ mHeaders[pos + 1]->mOffset);
+ if (NS_FAILED(rv)) {
+ inputStream->Close();
+ return rv;
+ }
+
+ uint32_t count = mCDSOffset - mHeaders[pos + 1]->mOffset;
+ uint32_t read = 0;
+ char buf[4096];
+ while (count > 0) {
+ read = std::min(count, (uint32_t)sizeof(buf));
+
+ rv = inputStream->Read(buf, read, &read);
+ if (NS_FAILED(rv)) {
+ inputStream->Close();
+ Cleanup();
+ return rv;
+ }
+
+ rv = ZW_WriteData(mStream, buf, read);
+ if (NS_FAILED(rv)) {
+ inputStream->Close();
+ Cleanup();
+ return rv;
+ }
+
+ count -= read;
+ }
+ inputStream->Close();
+
+ // Rewrite header offsets and update hash
+ uint32_t shift = (mHeaders[pos + 1]->mOffset - mHeaders[pos]->mOffset);
+ mCDSOffset -= shift;
+ int32_t pos2 = pos + 1;
+ while (pos2 < mHeaders.Count()) {
+ mEntryHash.InsertOrUpdate(mHeaders[pos2]->mName, pos2 - 1);
+ mHeaders[pos2]->mOffset -= shift;
+ pos2++;
+ }
+ } else {
+ // Remove the last entry is just a case of moving the CDS
+ mCDSOffset = mHeaders[pos]->mOffset;
+ rv = SeekCDS();
+ NS_ENSURE_SUCCESS(rv, rv);
+ }
+
+ mEntryHash.Remove(mHeaders[pos]->mName);
+ mHeaders.RemoveObjectAt(pos);
+ mCDSDirty = true;
+
+ return NS_OK;
+ }
+
+ return NS_ERROR_FILE_NOT_FOUND;
+}
+
+NS_IMETHODIMP nsZipWriter::ProcessQueue(nsIRequestObserver* aObserver,
+ nsISupports* aContext) {
+ if (!mStream) return NS_ERROR_NOT_INITIALIZED;
+ if (mInQueue) return NS_ERROR_IN_PROGRESS;
+
+ mProcessObserver = aObserver;
+ mProcessContext = aContext;
+ mInQueue = true;
+
+ if (mProcessObserver) mProcessObserver->OnStartRequest(nullptr);
+
+ BeginProcessingNextItem();
+
+ return NS_OK;
+}
+
+NS_IMETHODIMP nsZipWriter::Close() {
+ if (!mStream) return NS_ERROR_NOT_INITIALIZED;
+ if (mInQueue) return NS_ERROR_IN_PROGRESS;
+
+ if (mCDSDirty) {
+ uint32_t size = 0;
+ for (int32_t i = 0; i < mHeaders.Count(); i++) {
+ nsresult rv = mHeaders[i]->WriteCDSHeader(mStream);
+ if (NS_FAILED(rv)) {
+ Cleanup();
+ return rv;
+ }
+ size += mHeaders[i]->GetCDSHeaderLength();
+ }
+
+ uint8_t buf[ZIP_EOCDR_HEADER_SIZE];
+ uint32_t pos = 0;
+ WRITE32(buf, &pos, ZIP_EOCDR_HEADER_SIGNATURE);
+ WRITE16(buf, &pos, 0);
+ WRITE16(buf, &pos, 0);
+ WRITE16(buf, &pos, mHeaders.Count());
+ WRITE16(buf, &pos, mHeaders.Count());
+ WRITE32(buf, &pos, size);
+ WRITE32(buf, &pos, mCDSOffset);
+ WRITE16(buf, &pos, mComment.Length());
+
+ nsresult rv = ZW_WriteData(mStream, (const char*)buf, pos);
+ if (NS_FAILED(rv)) {
+ Cleanup();
+ return rv;
+ }
+
+ rv = ZW_WriteData(mStream, mComment.get(), mComment.Length());
+ if (NS_FAILED(rv)) {
+ Cleanup();
+ return rv;
+ }
+
+ nsCOMPtr<nsISeekableStream> seekable = do_QueryInterface(mStream);
+ rv = seekable->SetEOF();
+ if (NS_FAILED(rv)) {
+ Cleanup();
+ return rv;
+ }
+
+ // Go back and rewrite the file headers
+ for (int32_t i = 0; i < mHeaders.Count(); i++) {
+ nsZipHeader* header = mHeaders[i];
+ if (!header->mWriteOnClose) continue;
+
+ rv = seekable->Seek(nsISeekableStream::NS_SEEK_SET, header->mOffset);
+ if (NS_FAILED(rv)) {
+ Cleanup();
+ return rv;
+ }
+ rv = header->WriteFileHeader(mStream);
+ if (NS_FAILED(rv)) {
+ Cleanup();
+ return rv;
+ }
+ }
+ }
+
+ nsresult rv = mStream->Close();
+ mStream = nullptr;
+ mHeaders.Clear();
+ mEntryHash.Clear();
+ mQueue.Clear();
+
+ return rv;
+}
+
+// Our nsIRequestObserver monitors removal operations performed on the queue
+NS_IMETHODIMP nsZipWriter::OnStartRequest(nsIRequest* aRequest) {
+ return NS_OK;
+}
+
+NS_IMETHODIMP nsZipWriter::OnStopRequest(nsIRequest* aRequest,
+ nsresult aStatusCode) {
+ if (NS_FAILED(aStatusCode)) {
+ FinishQueue(aStatusCode);
+ Cleanup();
+ }
+
+ nsresult rv = mStream->Flush();
+ if (NS_FAILED(rv)) {
+ FinishQueue(rv);
+ Cleanup();
+ return rv;
+ }
+ rv = SeekCDS();
+ if (NS_FAILED(rv)) {
+ FinishQueue(rv);
+ return rv;
+ }
+
+ BeginProcessingNextItem();
+
+ return NS_OK;
+}
+
+/*
+ * Make all stored(uncompressed) files align to given alignment size.
+ */
+NS_IMETHODIMP nsZipWriter::AlignStoredFiles(uint16_t aAlignSize) {
+ nsresult rv;
+
+ // Check for range and power of 2.
+ if (aAlignSize < 2 || aAlignSize > 32768 ||
+ (aAlignSize & (aAlignSize - 1)) != 0) {
+ return NS_ERROR_INVALID_ARG;
+ }
+
+ for (int i = 0; i < mHeaders.Count(); i++) {
+ nsZipHeader* header = mHeaders[i];
+
+ // Check whether this entry is file and compression method is stored.
+ bool isdir;
+ rv = header->GetIsDirectory(&isdir);
+ if (NS_FAILED(rv)) {
+ return rv;
+ }
+ if (isdir || header->mMethod != 0) {
+ continue;
+ }
+ // Pad extra field to align data starting position to specified size.
+ uint32_t old_len = header->mLocalFieldLength;
+ rv = header->PadExtraField(header->mOffset, aAlignSize);
+ if (NS_FAILED(rv)) {
+ continue;
+ }
+ // No padding means data already aligned.
+ uint32_t shift = header->mLocalFieldLength - old_len;
+ if (shift == 0) {
+ continue;
+ }
+
+ // Flush any remaining data before we start.
+ rv = mStream->Flush();
+ if (NS_FAILED(rv)) {
+ return rv;
+ }
+
+ // Open zip file for reading.
+ nsCOMPtr<nsIInputStream> inputStream;
+ rv = NS_NewLocalFileInputStream(getter_AddRefs(inputStream), mFile);
+ if (NS_FAILED(rv)) {
+ return rv;
+ }
+
+ nsCOMPtr<nsISeekableStream> in_seekable = do_QueryInterface(inputStream);
+ nsCOMPtr<nsISeekableStream> out_seekable = do_QueryInterface(mStream);
+
+ uint32_t data_offset =
+ header->mOffset + header->GetFileHeaderLength() - shift;
+ uint32_t count = mCDSOffset - data_offset;
+ uint32_t read;
+ char buf[4096];
+
+ // Shift data to aligned postion.
+ while (count > 0) {
+ read = std::min(count, (uint32_t)sizeof(buf));
+
+ rv = in_seekable->Seek(nsISeekableStream::NS_SEEK_SET,
+ data_offset + count - read);
+ if (NS_FAILED(rv)) {
+ break;
+ }
+
+ rv = inputStream->Read(buf, read, &read);
+ if (NS_FAILED(rv)) {
+ break;
+ }
+
+ rv = out_seekable->Seek(nsISeekableStream::NS_SEEK_SET,
+ data_offset + count - read + shift);
+ if (NS_FAILED(rv)) {
+ break;
+ }
+
+ rv = ZW_WriteData(mStream, buf, read);
+ if (NS_FAILED(rv)) {
+ break;
+ }
+
+ count -= read;
+ }
+ inputStream->Close();
+ if (NS_FAILED(rv)) {
+ Cleanup();
+ return rv;
+ }
+
+ // Update current header
+ rv = out_seekable->Seek(nsISeekableStream::NS_SEEK_SET, header->mOffset);
+ if (NS_FAILED(rv)) {
+ Cleanup();
+ return rv;
+ }
+ rv = header->WriteFileHeader(mStream);
+ if (NS_FAILED(rv)) {
+ Cleanup();
+ return rv;
+ }
+
+ // Update offset of all other headers
+ int pos = i + 1;
+ while (pos < mHeaders.Count()) {
+ mHeaders[pos]->mOffset += shift;
+ pos++;
+ }
+ mCDSOffset += shift;
+ rv = SeekCDS();
+ if (NS_FAILED(rv)) {
+ return rv;
+ }
+ mCDSDirty = true;
+ }
+
+ return NS_OK;
+}
+
+nsresult nsZipWriter::InternalAddEntryDirectory(const nsACString& aZipEntry,
+ PRTime aModTime,
+ uint32_t aPermissions) {
+ RefPtr<nsZipHeader> header = new nsZipHeader();
+ NS_ENSURE_TRUE(header, NS_ERROR_OUT_OF_MEMORY);
+
+ uint32_t zipAttributes = ZIP_ATTRS(aPermissions, ZIP_ATTRS_DIRECTORY);
+
+ nsresult rv = NS_OK;
+ if (aZipEntry.Last() != '/') {
+ nsCString dirPath;
+ dirPath.Assign(aZipEntry + "/"_ns);
+ rv = header->Init(dirPath, aModTime, zipAttributes, mCDSOffset);
+ } else {
+ rv = header->Init(aZipEntry, aModTime, zipAttributes, mCDSOffset);
+ }
+
+ if (NS_WARN_IF(NS_FAILED(rv))) {
+ Cleanup();
+ return rv;
+ }
+
+ if (mEntryHash.Get(header->mName, nullptr))
+ return NS_ERROR_FILE_ALREADY_EXISTS;
+
+ rv = header->WriteFileHeader(mStream);
+ if (NS_FAILED(rv)) {
+ Cleanup();
+ return rv;
+ }
+
+ mCDSDirty = true;
+ mCDSOffset += header->GetFileHeaderLength();
+ mEntryHash.InsertOrUpdate(header->mName, mHeaders.Count());
+
+ if (!mHeaders.AppendObject(header)) {
+ Cleanup();
+ return NS_ERROR_OUT_OF_MEMORY;
+ }
+
+ return NS_OK;
+}
+
+/*
+ * Recovering from an error while adding a new entry is simply a case of
+ * seeking back to the CDS. If we fail trying to do that though then cleanup
+ * and bail out.
+ */
+nsresult nsZipWriter::SeekCDS() {
+ nsresult rv;
+ nsCOMPtr<nsISeekableStream> seekable = do_QueryInterface(mStream, &rv);
+ if (NS_FAILED(rv)) {
+ Cleanup();
+ return rv;
+ }
+ rv = seekable->Seek(nsISeekableStream::NS_SEEK_SET, mCDSOffset);
+ if (NS_FAILED(rv)) Cleanup();
+ return rv;
+}
+
+/*
+ * In a bad error condition this essentially closes down the component as best
+ * it can.
+ */
+void nsZipWriter::Cleanup() {
+ mHeaders.Clear();
+ mEntryHash.Clear();
+ if (mStream) mStream->Close();
+ mStream = nullptr;
+ mFile = nullptr;
+}
+
+/*
+ * Called when writing a file to the zip is complete.
+ */
+nsresult nsZipWriter::EntryCompleteCallback(nsZipHeader* aHeader,
+ nsresult aStatus) {
+ if (NS_SUCCEEDED(aStatus)) {
+ mEntryHash.InsertOrUpdate(aHeader->mName, mHeaders.Count());
+ if (!mHeaders.AppendObject(aHeader)) {
+ mEntryHash.Remove(aHeader->mName);
+ SeekCDS();
+ return NS_ERROR_OUT_OF_MEMORY;
+ }
+ mCDSDirty = true;
+ mCDSOffset += aHeader->mCSize + aHeader->GetFileHeaderLength();
+
+ if (mInQueue) BeginProcessingNextItem();
+
+ return NS_OK;
+ }
+
+ nsresult rv = SeekCDS();
+ if (mInQueue) FinishQueue(aStatus);
+ return rv;
+}
+
+inline nsresult nsZipWriter::BeginProcessingAddition(nsZipQueueItem* aItem,
+ bool* complete) {
+ if (aItem->mFile) {
+ bool exists;
+ nsresult rv = aItem->mFile->Exists(&exists);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ if (!exists) return NS_ERROR_FILE_NOT_FOUND;
+
+ bool isdir;
+ rv = aItem->mFile->IsDirectory(&isdir);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ rv = aItem->mFile->GetLastModifiedTime(&aItem->mModTime);
+ NS_ENSURE_SUCCESS(rv, rv);
+ aItem->mModTime *= PR_USEC_PER_MSEC;
+
+ rv = aItem->mFile->GetPermissions(&aItem->mPermissions);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ if (!isdir) {
+ // Set up for fall through to stream reader
+ rv = NS_NewLocalFileInputStream(getter_AddRefs(aItem->mStream),
+ aItem->mFile);
+ NS_ENSURE_SUCCESS(rv, rv);
+ }
+ // If a dir then this will fall through to the plain dir addition
+ }
+
+ uint32_t zipAttributes = ZIP_ATTRS(aItem->mPermissions, ZIP_ATTRS_FILE);
+
+ if (aItem->mStream || aItem->mChannel) {
+ RefPtr<nsZipHeader> header = new nsZipHeader();
+ NS_ENSURE_TRUE(header, NS_ERROR_OUT_OF_MEMORY);
+
+ nsresult rv = header->Init(aItem->mZipEntry, aItem->mModTime, zipAttributes,
+ mCDSOffset);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ rv = header->WriteFileHeader(mStream);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ RefPtr<nsZipDataStream> stream = new nsZipDataStream();
+ NS_ENSURE_TRUE(stream, NS_ERROR_OUT_OF_MEMORY);
+ rv = stream->Init(this, mStream, header, aItem->mCompression);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ if (aItem->mStream) {
+ nsCOMPtr<nsIInputStreamPump> pump;
+ nsCOMPtr<nsIInputStream> tmpStream = aItem->mStream;
+ rv = NS_NewInputStreamPump(getter_AddRefs(pump), tmpStream.forget(), 0, 0,
+ true);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ rv = pump->AsyncRead(stream);
+ NS_ENSURE_SUCCESS(rv, rv);
+ } else {
+ rv = aItem->mChannel->AsyncOpen(stream);
+ NS_ENSURE_SUCCESS(rv, rv);
+ }
+
+ return NS_OK;
+ }
+
+ // Must be plain directory addition
+ *complete = true;
+ return InternalAddEntryDirectory(aItem->mZipEntry, aItem->mModTime,
+ aItem->mPermissions);
+}
+
+inline nsresult nsZipWriter::BeginProcessingRemoval(int32_t aPos) {
+ // Open the zip file for reading
+ nsCOMPtr<nsIInputStream> inputStream;
+ nsresult rv = NS_NewLocalFileInputStream(getter_AddRefs(inputStream), mFile);
+ NS_ENSURE_SUCCESS(rv, rv);
+ nsCOMPtr<nsIInputStreamPump> pump;
+ nsCOMPtr<nsIInputStream> tmpStream = inputStream;
+ rv = NS_NewInputStreamPump(getter_AddRefs(pump), tmpStream.forget(), 0, 0,
+ true);
+ if (NS_FAILED(rv)) {
+ inputStream->Close();
+ return rv;
+ }
+ nsCOMPtr<nsIStreamListener> listener;
+ rv = NS_NewSimpleStreamListener(getter_AddRefs(listener), mStream, this);
+ if (NS_FAILED(rv)) {
+ inputStream->Close();
+ return rv;
+ }
+
+ nsCOMPtr<nsISeekableStream> seekable = do_QueryInterface(mStream);
+ rv = seekable->Seek(nsISeekableStream::NS_SEEK_SET, mHeaders[aPos]->mOffset);
+ if (NS_FAILED(rv)) {
+ inputStream->Close();
+ return rv;
+ }
+
+ uint32_t shift = (mHeaders[aPos + 1]->mOffset - mHeaders[aPos]->mOffset);
+ mCDSOffset -= shift;
+ int32_t pos2 = aPos + 1;
+ while (pos2 < mHeaders.Count()) {
+ mEntryHash.InsertOrUpdate(mHeaders[pos2]->mName, pos2 - 1);
+ mHeaders[pos2]->mOffset -= shift;
+ pos2++;
+ }
+
+ mEntryHash.Remove(mHeaders[aPos]->mName);
+ mHeaders.RemoveObjectAt(aPos);
+ mCDSDirty = true;
+
+ rv = pump->AsyncRead(listener);
+ if (NS_FAILED(rv)) {
+ inputStream->Close();
+ Cleanup();
+ return rv;
+ }
+ return NS_OK;
+}
+
+/*
+ * Starts processing on the next item in the queue.
+ */
+void nsZipWriter::BeginProcessingNextItem() {
+ while (!mQueue.IsEmpty()) {
+ nsZipQueueItem next = mQueue[0];
+ mQueue.RemoveElementAt(0);
+
+ if (next.mOperation == OPERATION_REMOVE) {
+ int32_t pos = -1;
+ if (mEntryHash.Get(next.mZipEntry, &pos)) {
+ if (pos < mHeaders.Count() - 1) {
+ nsresult rv = BeginProcessingRemoval(pos);
+ if (NS_FAILED(rv)) FinishQueue(rv);
+ return;
+ }
+
+ mCDSOffset = mHeaders[pos]->mOffset;
+ nsresult rv = SeekCDS();
+ if (NS_FAILED(rv)) {
+ FinishQueue(rv);
+ return;
+ }
+ mEntryHash.Remove(mHeaders[pos]->mName);
+ mHeaders.RemoveObjectAt(pos);
+ } else {
+ FinishQueue(NS_ERROR_FILE_NOT_FOUND);
+ return;
+ }
+ } else if (next.mOperation == OPERATION_ADD) {
+ if (mEntryHash.Get(next.mZipEntry, nullptr)) {
+ FinishQueue(NS_ERROR_FILE_ALREADY_EXISTS);
+ return;
+ }
+
+ bool complete = false;
+ nsresult rv = BeginProcessingAddition(&next, &complete);
+ if (NS_FAILED(rv)) {
+ SeekCDS();
+ FinishQueue(rv);
+ return;
+ }
+ if (!complete) return;
+ }
+ }
+
+ FinishQueue(NS_OK);
+}
+
+/*
+ * Ends processing with the given status.
+ */
+void nsZipWriter::FinishQueue(nsresult aStatus) {
+ nsCOMPtr<nsIRequestObserver> observer = mProcessObserver;
+ // Clean up everything first in case the observer decides to queue more
+ // things
+ mProcessObserver = nullptr;
+ mProcessContext = nullptr;
+ mInQueue = false;
+
+ if (observer) observer->OnStopRequest(nullptr, aStatus);
+}