summaryrefslogtreecommitdiffstats
path: root/modules/libjar/zipwriter/nsZipHeader.cpp
diff options
context:
space:
mode:
authorMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
committerMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
commit5f8de423f190bbb79a62f804151bc24824fa32d8 (patch)
tree10027f336435511475e392454359edea8e25895d /modules/libjar/zipwriter/nsZipHeader.cpp
parent49ee0794b5d912db1f95dce6eb52d781dc210db5 (diff)
downloadUXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.gz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.lz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.xz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.zip
Add m-esr52 at 52.6.0
Diffstat (limited to 'modules/libjar/zipwriter/nsZipHeader.cpp')
-rw-r--r--modules/libjar/zipwriter/nsZipHeader.cpp389
1 files changed, 389 insertions, 0 deletions
diff --git a/modules/libjar/zipwriter/nsZipHeader.cpp b/modules/libjar/zipwriter/nsZipHeader.cpp
new file mode 100644
index 000000000..af2ee0335
--- /dev/null
+++ b/modules/libjar/zipwriter/nsZipHeader.cpp
@@ -0,0 +1,389 @@
+/* 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 "StreamFunctions.h"
+#include "nsZipHeader.h"
+#include "nsMemory.h"
+#include "prtime.h"
+
+#define ZIP_FILE_HEADER_SIGNATURE 0x04034b50
+#define ZIP_FILE_HEADER_SIZE 30
+#define ZIP_CDS_HEADER_SIGNATURE 0x02014b50
+#define ZIP_CDS_HEADER_SIZE 46
+
+#define FLAGS_IS_UTF8 0x800
+
+#define ZIP_EXTENDED_TIMESTAMP_FIELD 0x5455
+#define ZIP_EXTENDED_TIMESTAMP_MODTIME 0x01
+
+using namespace mozilla;
+
+/**
+ * nsZipHeader represents an entry from a zip file.
+ */
+NS_IMPL_ISUPPORTS(nsZipHeader, nsIZipEntry)
+
+NS_IMETHODIMP nsZipHeader::GetCompression(uint16_t *aCompression)
+{
+ NS_ASSERTION(mInited, "Not initalised");
+
+ *aCompression = mMethod;
+ return NS_OK;
+}
+
+NS_IMETHODIMP nsZipHeader::GetSize(uint32_t *aSize)
+{
+ NS_ASSERTION(mInited, "Not initalised");
+
+ *aSize = mCSize;
+ return NS_OK;
+}
+
+NS_IMETHODIMP nsZipHeader::GetRealSize(uint32_t *aRealSize)
+{
+ NS_ASSERTION(mInited, "Not initalised");
+
+ *aRealSize = mUSize;
+ return NS_OK;
+}
+
+NS_IMETHODIMP nsZipHeader::GetCRC32(uint32_t *aCRC32)
+{
+ NS_ASSERTION(mInited, "Not initalised");
+
+ *aCRC32 = mCRC;
+ return NS_OK;
+}
+
+NS_IMETHODIMP nsZipHeader::GetIsDirectory(bool *aIsDirectory)
+{
+ NS_ASSERTION(mInited, "Not initalised");
+
+ if (mName.Last() == '/')
+ *aIsDirectory = true;
+ else
+ *aIsDirectory = false;
+ return NS_OK;
+}
+
+NS_IMETHODIMP nsZipHeader::GetLastModifiedTime(PRTime *aLastModifiedTime)
+{
+ NS_ASSERTION(mInited, "Not initalised");
+
+ // Try to read timestamp from extra field
+ uint16_t blocksize;
+ const uint8_t *tsField = GetExtraField(ZIP_EXTENDED_TIMESTAMP_FIELD, false, &blocksize);
+ if (tsField && blocksize >= 5) {
+ uint32_t pos = 4;
+ uint8_t flags;
+ flags = READ8(tsField, &pos);
+ if (flags & ZIP_EXTENDED_TIMESTAMP_MODTIME) {
+ *aLastModifiedTime = (PRTime)(READ32(tsField, &pos))
+ * PR_USEC_PER_SEC;
+ return NS_OK;
+ }
+ }
+
+ // Use DOS date/time fields
+ // 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 = (mTime >> 11) & 0x1F;
+ time.tm_min = (mTime >> 5) & 0x3F;
+ time.tm_sec = (mTime & 0x1F) * 2;
+
+ time.tm_year = (mDate >> 9) + 1980;
+ time.tm_month = ((mDate >> 5) & 0x0F) - 1;
+ time.tm_mday = mDate & 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;
+
+ *aLastModifiedTime = PR_ImplodeTime(&time);
+
+ return NS_OK;
+}
+
+NS_IMETHODIMP nsZipHeader::GetIsSynthetic(bool *aIsSynthetic)
+{
+ NS_ASSERTION(mInited, "Not initalised");
+
+ *aIsSynthetic = false;
+ return NS_OK;
+}
+
+NS_IMETHODIMP nsZipHeader::GetPermissions(uint32_t *aPermissions)
+{
+ NS_ASSERTION(mInited, "Not initalised");
+
+ // Always give user read access at least, this matches nsIZipReader's behaviour
+ *aPermissions = ((mEAttr >> 16) & 0xfff) | 0x100;
+ return NS_OK;
+}
+
+void nsZipHeader::Init(const nsACString & aPath, PRTime aDate, uint32_t aAttr,
+ uint32_t aOffset)
+{
+ NS_ASSERTION(!mInited, "Already initalised");
+
+ PRExplodedTime time;
+ PR_ExplodeTime(aDate, PR_LocalTimeParameters, &time);
+
+ mTime = time.tm_sec / 2 + (time.tm_min << 5) + (time.tm_hour << 11);
+ mDate = time.tm_mday + ((time.tm_month + 1) << 5) +
+ ((time.tm_year - 1980) << 9);
+
+ // Store modification timestamp as extra field
+ // First fill CDS extra field
+ mFieldLength = 9;
+ mExtraField = MakeUnique<uint8_t[]>(mFieldLength);
+ if (!mExtraField) {
+ mFieldLength = 0;
+ } else {
+ uint32_t pos = 0;
+ WRITE16(mExtraField.get(), &pos, ZIP_EXTENDED_TIMESTAMP_FIELD);
+ WRITE16(mExtraField.get(), &pos, 5);
+ WRITE8(mExtraField.get(), &pos, ZIP_EXTENDED_TIMESTAMP_MODTIME);
+ WRITE32(mExtraField.get(), &pos, aDate / PR_USEC_PER_SEC);
+
+ // Fill local extra field
+ mLocalExtraField = MakeUnique<uint8_t[]>(mFieldLength);
+ if (mLocalExtraField) {
+ mLocalFieldLength = mFieldLength;
+ memcpy(mLocalExtraField.get(), mExtraField.get(), mLocalFieldLength);
+ }
+ }
+
+ mEAttr = aAttr;
+ mOffset = aOffset;
+ mName = aPath;
+ mComment = NS_LITERAL_CSTRING("");
+ // Claim a UTF-8 path in case it needs it.
+ mFlags |= FLAGS_IS_UTF8;
+ mInited = true;
+}
+
+uint32_t nsZipHeader::GetFileHeaderLength()
+{
+ return ZIP_FILE_HEADER_SIZE + mName.Length() + mLocalFieldLength;
+}
+
+nsresult nsZipHeader::WriteFileHeader(nsIOutputStream *aStream)
+{
+ NS_ASSERTION(mInited, "Not initalised");
+
+ uint8_t buf[ZIP_FILE_HEADER_SIZE];
+ uint32_t pos = 0;
+ WRITE32(buf, &pos, ZIP_FILE_HEADER_SIGNATURE);
+ WRITE16(buf, &pos, mVersionNeeded);
+ WRITE16(buf, &pos, mFlags);
+ WRITE16(buf, &pos, mMethod);
+ WRITE16(buf, &pos, mTime);
+ WRITE16(buf, &pos, mDate);
+ WRITE32(buf, &pos, mCRC);
+ WRITE32(buf, &pos, mCSize);
+ WRITE32(buf, &pos, mUSize);
+ WRITE16(buf, &pos, mName.Length());
+ WRITE16(buf, &pos, mLocalFieldLength);
+
+ nsresult rv = ZW_WriteData(aStream, (const char *)buf, pos);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ rv = ZW_WriteData(aStream, mName.get(), mName.Length());
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ if (mLocalFieldLength)
+ {
+ rv = ZW_WriteData(aStream, (const char *)mLocalExtraField.get(), mLocalFieldLength);
+ NS_ENSURE_SUCCESS(rv, rv);
+ }
+
+ return NS_OK;
+}
+
+uint32_t nsZipHeader::GetCDSHeaderLength()
+{
+ return ZIP_CDS_HEADER_SIZE + mName.Length() + mComment.Length() +
+ mFieldLength;
+}
+
+nsresult nsZipHeader::WriteCDSHeader(nsIOutputStream *aStream)
+{
+ NS_ASSERTION(mInited, "Not initalised");
+
+ uint8_t buf[ZIP_CDS_HEADER_SIZE];
+ uint32_t pos = 0;
+ WRITE32(buf, &pos, ZIP_CDS_HEADER_SIGNATURE);
+ WRITE16(buf, &pos, mVersionMade);
+ WRITE16(buf, &pos, mVersionNeeded);
+ WRITE16(buf, &pos, mFlags);
+ WRITE16(buf, &pos, mMethod);
+ WRITE16(buf, &pos, mTime);
+ WRITE16(buf, &pos, mDate);
+ WRITE32(buf, &pos, mCRC);
+ WRITE32(buf, &pos, mCSize);
+ WRITE32(buf, &pos, mUSize);
+ WRITE16(buf, &pos, mName.Length());
+ WRITE16(buf, &pos, mFieldLength);
+ WRITE16(buf, &pos, mComment.Length());
+ WRITE16(buf, &pos, mDisk);
+ WRITE16(buf, &pos, mIAttr);
+ WRITE32(buf, &pos, mEAttr);
+ WRITE32(buf, &pos, mOffset);
+
+ nsresult rv = ZW_WriteData(aStream, (const char *)buf, pos);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ rv = ZW_WriteData(aStream, mName.get(), mName.Length());
+ NS_ENSURE_SUCCESS(rv, rv);
+ if (mExtraField) {
+ rv = ZW_WriteData(aStream, (const char *)mExtraField.get(), mFieldLength);
+ NS_ENSURE_SUCCESS(rv, rv);
+ }
+ return ZW_WriteData(aStream, mComment.get(), mComment.Length());
+}
+
+nsresult nsZipHeader::ReadCDSHeader(nsIInputStream *stream)
+{
+ NS_ASSERTION(!mInited, "Already initalised");
+
+ uint8_t buf[ZIP_CDS_HEADER_SIZE];
+
+ nsresult rv = ZW_ReadData(stream, (char *)buf, ZIP_CDS_HEADER_SIZE);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ uint32_t pos = 0;
+ uint32_t signature = READ32(buf, &pos);
+ if (signature != ZIP_CDS_HEADER_SIGNATURE)
+ return NS_ERROR_FILE_CORRUPTED;
+
+ mVersionMade = READ16(buf, &pos);
+ mVersionNeeded = READ16(buf, &pos);
+ mFlags = READ16(buf, &pos);
+ mMethod = READ16(buf, &pos);
+ mTime = READ16(buf, &pos);
+ mDate = READ16(buf, &pos);
+ mCRC = READ32(buf, &pos);
+ mCSize = READ32(buf, &pos);
+ mUSize = READ32(buf, &pos);
+ uint16_t namelength = READ16(buf, &pos);
+ mFieldLength = READ16(buf, &pos);
+ uint16_t commentlength = READ16(buf, &pos);
+ mDisk = READ16(buf, &pos);
+ mIAttr = READ16(buf, &pos);
+ mEAttr = READ32(buf, &pos);
+ mOffset = READ32(buf, &pos);
+
+ if (namelength > 0) {
+ auto field = MakeUnique<char[]>(namelength);
+ NS_ENSURE_TRUE(field, NS_ERROR_OUT_OF_MEMORY);
+ rv = ZW_ReadData(stream, field.get(), namelength);
+ NS_ENSURE_SUCCESS(rv, rv);
+ mName.Assign(field.get(), namelength);
+ }
+ else
+ mName = NS_LITERAL_CSTRING("");
+
+ if (mFieldLength > 0) {
+ mExtraField = MakeUnique<uint8_t[]>(mFieldLength);
+ NS_ENSURE_TRUE(mExtraField, NS_ERROR_OUT_OF_MEMORY);
+ rv = ZW_ReadData(stream, (char *)mExtraField.get(), mFieldLength);
+ NS_ENSURE_SUCCESS(rv, rv);
+ }
+
+ if (commentlength > 0) {
+ auto field = MakeUnique<char[]>(commentlength);
+ NS_ENSURE_TRUE(field, NS_ERROR_OUT_OF_MEMORY);
+ rv = ZW_ReadData(stream, field.get(), commentlength);
+ NS_ENSURE_SUCCESS(rv, rv);
+ mComment.Assign(field.get(), commentlength);
+ }
+ else
+ mComment = NS_LITERAL_CSTRING("");
+
+ mInited = true;
+ return NS_OK;
+}
+
+const uint8_t * nsZipHeader::GetExtraField(uint16_t aTag, bool aLocal, uint16_t *aBlockSize)
+{
+ const uint8_t *buf = aLocal ? mLocalExtraField.get() : mExtraField.get();
+ uint32_t buflen = aLocal ? mLocalFieldLength : mFieldLength;
+ uint32_t pos = 0;
+ uint16_t tag, blocksize;
+
+ while (buf && (pos + 4) <= buflen) {
+ tag = READ16(buf, &pos);
+ blocksize = READ16(buf, &pos);
+
+ if (aTag == tag && (pos + blocksize) <= buflen) {
+ *aBlockSize = blocksize;
+ return buf + pos - 4;
+ }
+
+ pos += blocksize;
+ }
+
+ return nullptr;
+}
+
+/*
+ * Pad extra field to align data starting position to specified size.
+ */
+nsresult nsZipHeader::PadExtraField(uint32_t aOffset, uint16_t aAlignSize)
+{
+ uint32_t pad_size;
+ uint32_t pa_offset;
+ uint32_t pa_end;
+
+ // Check for range and power of 2.
+ if (aAlignSize < 2 || aAlignSize > 32768 ||
+ (aAlignSize & (aAlignSize - 1)) != 0) {
+ return NS_ERROR_INVALID_ARG;
+ }
+
+ // Point to current starting data position.
+ aOffset += ZIP_FILE_HEADER_SIZE + mName.Length() + mLocalFieldLength;
+
+ // Calculate aligned offset.
+ pa_offset = aOffset & ~(aAlignSize - 1);
+ pa_end = pa_offset + aAlignSize;
+ pad_size = pa_end - aOffset;
+ if (pad_size == 0) {
+ return NS_OK;
+ }
+
+ // Leave enough room(at least 4 bytes) for valid values in extra field.
+ while (pad_size < 4) {
+ pad_size += aAlignSize;
+ }
+ // Extra field length is 2 bytes.
+ if (mLocalFieldLength + pad_size > 65535) {
+ return NS_ERROR_FAILURE;
+ }
+
+ UniquePtr<uint8_t[]> field = Move(mLocalExtraField);
+ uint32_t pos = mLocalFieldLength;
+
+ mLocalExtraField = MakeUnique<uint8_t[]>(mLocalFieldLength + pad_size);
+ memcpy(mLocalExtraField.get(), field.get(), mLocalFieldLength);
+ // Use 0xFFFF as tag ID to avoid conflict with other IDs.
+ // For more information, please read "Extensible data fields" section in:
+ // http://www.pkware.com/documents/casestudies/APPNOTE.TXT
+ WRITE16(mLocalExtraField.get(), &pos, 0xFFFF);
+ WRITE16(mLocalExtraField.get(), &pos, pad_size - 4);
+ memset(mLocalExtraField.get() + pos, 0, pad_size - 4);
+ mLocalFieldLength += pad_size;
+
+ return NS_OK;
+}