/* 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 = std::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;

}