/****************************************************************************

**

** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).

** All rights reserved.

** Contact: Nokia Corporation (qt-info@nokia.com)

**

** This file is part of the QtGui module of the Qt Toolkit.

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

** This file contains pre-release code and may not be distributed.

** You may use this file in accordance with the terms and conditions

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

** Alternatively, this file may be used under the terms of the GNU Lesser

** General Public License version 2.1 as published by the Free Software

** Foundation and appearing in the file LICENSE.LGPL included in the

** packaging of this file.  Please review the following information to

** ensure the GNU Lesser General Public License version 2.1 requirements

** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

**

** In addition, as a special exception, Nokia gives you certain additional

** rights.  These rights are described in the Nokia Qt LGPL Exception

** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

**

** If you have questions regarding the use of this file, please contact

** Nokia at qt-info@nokia.com.

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

****************************************************************************/

#include <qglobal.h>

#ifndef QT_NO_TEXTODFWRITER

#include "qzipreader_p.h"

#include "qzipwriter_p.h"

#include <qdatetime.h>

#include <qplatformdefs.h>

#include <qendian.h>

#include <qdebug.h>

#include <qdir.h>

#include <zlib.h>

#if defined(Q_OS_WIN)

#undef S_IFREG

#define S_IFREG 0100000

#  ifndef S_ISDIR

#    define S_ISDIR(x) ((x) & 0040000) > 0

#  endif

#  ifndef S_ISREG

#    define S_ISREG(x) ((x) & 0170000) == S_IFREG

#  endif

#  define S_IFLNK 020000

#  define S_ISLNK(x) ((x) & S_IFLNK) > 0

#  ifndef S_IRUSR

#    define S_IRUSR 0400

#  endif

#  ifndef S_IWUSR

#    define S_IWUSR 0200

#  endif

#  ifndef S_IXUSR

#    define S_IXUSR 0100

#  endif

#  define S_IRGRP 0040

#  define S_IWGRP 0020

#  define S_IXGRP 0010

#  define S_IROTH 0004

#  define S_IWOTH 0002

#  define S_IXOTH 0001

#endif

#if 0

#define ZDEBUG qDebug

#else

#define ZDEBUG if (0) qDebug

#endif

QT_BEGIN_NAMESPACE

static inline uint readUInt(const uchar *data)

{

    return (data[0]) + (data[1]<<8) + (data[2]<<16) + (data[3]<<24);

}

static inline ushort readUShort(const uchar *data)

{

    return (data[0]) + (data[1]<<8);

}

static inline void writeUInt(uchar *data, uint i)

{

    data[0] = i & 0xff;

    data[1] = (i>>8) & 0xff;

    data[2] = (i>>16) & 0xff;

    data[3] = (i>>24) & 0xff;

}

static inline void writeUShort(uchar *data, ushort i)

{

    data[0] = i & 0xff;

    data[1] = (i>>8) & 0xff;

}

static inline void copyUInt(uchar *dest, const uchar *src)

{

    dest[0] = src[0];

    dest[1] = src[1];

    dest[2] = src[2];

    dest[3] = src[3];

}

static inline void copyUShort(uchar *dest, const uchar *src)

{

    dest[0] = src[0];

    dest[1] = src[1];

}

static void writeMSDosDate(uchar *dest, const QDateTime& dt)

{

    if (dt.isValid()) {

        quint16 time =

            (dt.time().hour() << 11)    // 5 bit hour

            | (dt.time().minute() << 5)   // 6 bit minute

            | (dt.time().second() >> 1);  // 5 bit double seconds

        dest[0] = time & 0xff;

        dest[1] = time >> 8;

        quint16 date =

            ((dt.date().year() - 1980) << 9) // 7 bit year 1980-based

            | (dt.date().month() << 5)           // 4 bit month

            | (dt.date().day());                 // 5 bit day

        dest[2] = char(date);

        dest[3] = char(date >> 8);

    } else {

        dest[0] = 0;

        dest[1] = 0;

        dest[2] = 0;

        dest[3] = 0;

    }

}

static quint32 permissionsToMode(QFile::Permissions perms)

{

    quint32 mode = 0;

    if (perms & QFile::ReadOwner)

        mode |= S_IRUSR;

    if (perms & QFile::WriteOwner)

        mode |= S_IWUSR;

    if (perms & QFile::ExeOwner)

        mode |= S_IXUSR;

    if (perms & QFile::ReadUser)

        mode |= S_IRUSR;

    if (perms & QFile::WriteUser)

        mode |= S_IWUSR;

    if (perms & QFile::ExeUser)

        mode |= S_IXUSR;

    if (perms & QFile::ReadGroup)

        mode |= S_IRGRP;

    if (perms & QFile::WriteGroup)

        mode |= S_IWGRP;

    if (perms & QFile::ExeGroup)

        mode |= S_IXGRP;

    if (perms & QFile::ReadOther)

        mode |= S_IROTH;

    if (perms & QFile::WriteOther)

        mode |= S_IWOTH;

    if (perms & QFile::ExeOther)

        mode |= S_IXOTH;

    return mode;

}

static int inflate(Bytef *dest, ulong *destLen, const Bytef *source, ulong sourceLen)

{

    z_stream stream;

    int err;

    stream.next_in = (Bytef*)source;

    stream.avail_in = (uInt)sourceLen;

    if ((uLong)stream.avail_in != sourceLen)

        return Z_BUF_ERROR;

    stream.next_out = dest;

    stream.avail_out = (uInt)*destLen;

    if ((uLong)stream.avail_out != *destLen)

        return Z_BUF_ERROR;

    stream.zalloc = (alloc_func)0;

    stream.zfree = (free_func)0;

    err = inflateInit2(&stream, -MAX_WBITS);

    if (err != Z_OK)

        return err;

    err = inflate(&stream, Z_FINISH);

    if (err != Z_STREAM_END) {

        inflateEnd(&stream);

        if (err == Z_NEED_DICT || (err == Z_BUF_ERROR && stream.avail_in == 0))

            return Z_DATA_ERROR;

        return err;

    }

    *destLen = stream.total_out;

    err = inflateEnd(&stream);

    return err;

}

static int deflate (Bytef *dest, ulong *destLen, const Bytef *source, ulong sourceLen)

{

    z_stream stream;

    int err;

    stream.next_in = (Bytef*)source;

    stream.avail_in = (uInt)sourceLen;

    stream.next_out = dest;

    stream.avail_out = (uInt)*destLen;

    if ((uLong)stream.avail_out != *destLen) return Z_BUF_ERROR;

    stream.zalloc = (alloc_func)0;

    stream.zfree = (free_func)0;

    stream.opaque = (voidpf)0;

    err = deflateInit2(&stream, Z_DEFAULT_COMPRESSION, Z_DEFLATED, -MAX_WBITS, 8, Z_DEFAULT_STRATEGY);

    if (err != Z_OK) return err;

    err = deflate(&stream, Z_FINISH);

    if (err != Z_STREAM_END) {

        deflateEnd(&stream);

        return err == Z_OK ? Z_BUF_ERROR : err;

    }

    *destLen = stream.total_out;

    err = deflateEnd(&stream);

    return err;

}

static QFile::Permissions modeToPermissions(quint32 mode)

{

    QFile::Permissions ret;

    if (mode & S_IRUSR)

        ret |= QFile::ReadOwner;

    if (mode & S_IWUSR)

        ret |= QFile::WriteOwner;

    if (mode & S_IXUSR)

        ret |= QFile::ExeOwner;

    if (mode & S_IRUSR)

        ret |= QFile::ReadUser;

    if (mode & S_IWUSR)

        ret |= QFile::WriteUser;

    if (mode & S_IXUSR)

        ret |= QFile::ExeUser;

    if (mode & S_IRGRP)

        ret |= QFile::ReadGroup;

    if (mode & S_IWGRP)

        ret |= QFile::WriteGroup;

    if (mode & S_IXGRP)

        ret |= QFile::ExeGroup;

    if (mode & S_IROTH)

        ret |= QFile::ReadOther;

    if (mode & S_IWOTH)

        ret |= QFile::WriteOther;

    if (mode & S_IXOTH)

        ret |= QFile::ExeOther;

    return ret;

}

struct LocalFileHeader

{

    uchar signature[4]; //  0x04034b50

    uchar version_needed[2];

    uchar general_purpose_bits[2];

    uchar compression_method[2];

    uchar last_mod_file[4];

    uchar crc_32[4];

    uchar compressed_size[4];

    uchar uncompressed_size[4];

    uchar file_name_length[2];

    uchar extra_field_length[2];

};

struct DataDescriptor

{

    uchar crc_32[4];

    uchar compressed_size[4];

    uchar uncompressed_size[4];

};

struct CentralFileHeader

{

    uchar signature[4]; // 0x02014b50

    uchar version_made[2];

    uchar version_needed[2];

    uchar general_purpose_bits[2];

    uchar compression_method[2];

    uchar last_mod_file[4];

    uchar crc_32[4];

    uchar compressed_size[4];

    uchar uncompressed_size[4];

    uchar file_name_length[2];

    uchar extra_field_length[2];

    uchar file_comment_length[2];

    uchar disk_start[2];

    uchar internal_file_attributes[2];

    uchar external_file_attributes[4];

    uchar offset_local_header[4];

    LocalFileHeader toLocalHeader() const;

};

struct EndOfDirectory

{

    uchar signature[4]; // 0x06054b50

    uchar this_disk[2];

    uchar start_of_directory_disk[2];

    uchar num_dir_entries_this_disk[2];

    uchar num_dir_entries[2];

    uchar directory_size[4];

    uchar dir_start_offset[4];

    uchar comment_length[2];

};

struct FileHeader

{

    CentralFileHeader h;

    QByteArray file_name;

    QByteArray extra_field;

    QByteArray file_comment;

};

QZipReader::FileInfo::FileInfo()

    : isDir(false), isFile(true), isSymLink(false), crc32(0), size(0)

{

}

QZipReader::FileInfo::~FileInfo()

{

}

QZipReader::FileInfo::FileInfo(const FileInfo &other)

{

    operator=(other);

}

QZipReader::FileInfo& QZipReader::FileInfo::operator=(const FileInfo &other)

{

    filePath = other.filePath;

    isDir = other.isDir;

    isFile = other.isFile;

    isSymLink = other.isSymLink;

    permissions = other.permissions;

    crc32 = other.crc32;

    size = other.size;

    return *this;

}

class QZipPrivate

{

public:

    QZipPrivate(QIODevice *device, bool ownDev)

        : device(device), ownDevice(ownDev), dirtyFileTree(true), start_of_directory(0)

    {

    }

    ~QZipPrivate()

    {

        if (ownDevice)

            delete device;

    }

    void fillFileInfo(int index, QZipReader::FileInfo &fileInfo) const;

    QIODevice *device;

    bool ownDevice;

    bool dirtyFileTree;

    QList<FileHeader> fileHeaders;

    QByteArray comment;

    uint start_of_directory;

};

void QZipPrivate::fillFileInfo(int index, QZipReader::FileInfo &fileInfo) const

{

    FileHeader header = fileHeaders.at(index);

    fileInfo.filePath = QString::fromLocal8Bit(header.file_name);

    const quint32 mode = (qFromLittleEndian<quint32>(&header.h.external_file_attributes[0]) >> 16) & 0xFFFF;

    fileInfo.isDir = S_ISDIR(mode);

    fileInfo.isFile = S_ISREG(mode);

    fileInfo.isSymLink = S_ISLNK(mode);

    fileInfo.permissions = modeToPermissions(mode);

    fileInfo.crc32 = readUInt(header.h.crc_32);

    fileInfo.size = readUInt(header.h.uncompressed_size);

}

class QZipReaderPrivate : public QZipPrivate

{

public:

    QZipReaderPrivate(QIODevice *device, bool ownDev)

        : QZipPrivate(device, ownDev), status(QZipReader::NoError)

    {

    }

    void scanFiles();

    QZipReader::Status status;

};

class QZipWriterPrivate : public QZipPrivate

{

public:

    QZipWriterPrivate(QIODevice *device, bool ownDev)

        : QZipPrivate(device, ownDev),

        status(QZipWriter::NoError),

        permissions(QFile::ReadOwner | QFile::WriteOwner),

        compressionPolicy(QZipWriter::AlwaysCompress)

    {

    }

    QZipWriter::Status status;

    QFile::Permissions permissions;

    QZipWriter::CompressionPolicy compressionPolicy;

    enum EntryType { Directory, File, Symlink };

    void addEntry(EntryType type, const QString &fileName, const QByteArray &contents);

};

LocalFileHeader CentralFileHeader::toLocalHeader() const

{

    LocalFileHeader h;

    writeUInt(h.signature, 0x04034b50);

    copyUShort(h.version_needed, version_needed);

    copyUShort(h.general_purpose_bits, general_purpose_bits);

    copyUShort(h.compression_method, compression_method);

    copyUInt(h.last_mod_file, last_mod_file);

    copyUInt(h.crc_32, crc_32);

    copyUInt(h.compressed_size, compressed_size);

    copyUInt(h.uncompressed_size, uncompressed_size);

    copyUShort(h.file_name_length, file_name_length);

    copyUShort(h.extra_field_length, extra_field_length);

    return h;

}

void QZipReaderPrivate::scanFiles()

{

    if (!dirtyFileTree)

        return;

    if (! (device->isOpen() || device->open(QIODevice::ReadOnly))) {

        status = QZipReader::FileOpenError;

        return;

    }

    if ((device->openMode() & QIODevice::ReadOnly) == 0) { // only read the index from readable files.

        status = QZipReader::FileReadError;

        return;

    }

    dirtyFileTree = false;

    uchar tmp[4];

    device->read((char *)tmp, 4);

    if (readUInt(tmp) != 0x04034b50) {

        qWarning() << "QZip: not a zip file!";

        return;

    }

    // find EndOfDirectory header

    int i = 0;

    int start_of_directory = -1;

    int num_dir_entries = 0;

    EndOfDirectory eod;

    while (start_of_directory == -1) {

        int pos = device->size() - sizeof(EndOfDirectory) - i;

        if (pos < 0 || i > 65535) {

            qWarning() << "QZip: EndOfDirectory not found";

            return;

        }

        device->seek(pos);

        device->read((char *)&eod, sizeof(EndOfDirectory));

        if (readUInt(eod.signature) == 0x06054b50)

            break;

        ++i;

    }

    // have the eod

    start_of_directory = readUInt(eod.dir_start_offset);

    num_dir_entries = readUShort(eod.num_dir_entries);

    ZDEBUG("start_of_directory at %d, num_dir_entries=%d", start_of_directory, num_dir_entries);

    int comment_length = readUShort(eod.comment_length);

    if (comment_length != i)

        qWarning() << "QZip: failed to parse zip file.";

    comment = device->read(qMin(comment_length, i));

    device->seek(start_of_directory);

    for (i = 0; i < num_dir_entries; ++i) {

        FileHeader header;

        int read = device->read((char *) &header.h, sizeof(CentralFileHeader));

        if (read < (int)sizeof(CentralFileHeader)) {

            qWarning() << "QZip: Failed to read complete header, index may be incomplete";

            break;

        }

        if (readUInt(header.h.signature) != 0x02014b50) {

            qWarning() << "QZip: invalid header signature, index may be incomplete";

            break;

        }

        int l = readUShort(header.h.file_name_length);

        header.file_name = device->read(l);

        if (header.file_name.length() != l) {

            qWarning() << "QZip: Failed to read filename from zip index, index may be incomplete";

            break;

        }

        l = readUShort(header.h.extra_field_length);

        header.extra_field = device->read(l);

        if (header.extra_field.length() != l) {

            qWarning() << "QZip: Failed to read extra field in zip file, skipping file, index may be incomplete";