unzip.cpp

Go to the documentation of this file.

/****************************************************************************
** Filename: unzip.cpp
** Last updated [dd/mm/yyyy]: 07/09/2008
**
** pkzip 2.0 decompression.
**
** Some of the code has been inspired by other open source projects,
** (mainly Info-Zip and Gilles Vollant's minizip).
** Compression and decompression actually uses the zlib library.
**
** Copyright (C) 2007-2008 Angius Fabrizio. All rights reserved.
**
** This file is part of the OSDaB project (http://osdab.sourceforge.net/).
**
** This file may be distributed and/or modified under the terms of the
** GNU General Public License version 2 as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL included in the
** packaging of this file.
**
** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
**
** See the file LICENSE.GPL that came with this software distribution or
** visit http://www.gnu.org/copyleft/gpl.html for GPL licensing information.
**
**********************************************************************/

#include "unzip.h"
#include "unzip_p.h"
#include "zipentry_p.h"

#include <QString>
#include <QStringList>
#include <QDir>
#include <QFile>
#include <QCoreApplication>

// You can remove this #include if you replace the qDebug() statements.
#include <QtDebug>


#define UNZIP_LOCAL_HEADER_SIZE 26

#define UNZIP_CD_ENTRY_SIZE_NS 42

#define UNZIP_DD_SIZE 12

#define UNZIP_EOCD_SIZE 22

#define UNZIP_LOCAL_ENC_HEADER_SIZE 12

// Some offsets inside a CD record (excluding signature)
#define UNZIP_CD_OFF_VERSION 0
#define UNZIP_CD_OFF_GPFLAG 4
#define UNZIP_CD_OFF_CMETHOD 6
#define UNZIP_CD_OFF_MODT 8
#define UNZIP_CD_OFF_MODD 10
#define UNZIP_CD_OFF_CRC32 12
#define UNZIP_CD_OFF_CSIZE 16
#define UNZIP_CD_OFF_USIZE 20
#define UNZIP_CD_OFF_NAMELEN 24
#define UNZIP_CD_OFF_XLEN 26
#define UNZIP_CD_OFF_COMMLEN 28
#define UNZIP_CD_OFF_LHOFFSET 38

// Some offsets inside a local header record (excluding signature)
#define UNZIP_LH_OFF_VERSION 0
#define UNZIP_LH_OFF_GPFLAG 2
#define UNZIP_LH_OFF_CMETHOD 4
#define UNZIP_LH_OFF_MODT 6
#define UNZIP_LH_OFF_MODD 8
#define UNZIP_LH_OFF_CRC32 10
#define UNZIP_LH_OFF_CSIZE 14
#define UNZIP_LH_OFF_USIZE 18
#define UNZIP_LH_OFF_NAMELEN 22
#define UNZIP_LH_OFF_XLEN 24

// Some offsets inside a data descriptor record (excluding signature)
#define UNZIP_DD_OFF_CRC32 0
#define UNZIP_DD_OFF_CSIZE 4
#define UNZIP_DD_OFF_USIZE 8

// Some offsets inside a EOCD record
#define UNZIP_EOCD_OFF_ENTRIES 6
#define UNZIP_EOCD_OFF_CDOFF 12
#define UNZIP_EOCD_OFF_COMMLEN 16

#define UNZIP_VERSION 0x1B

#define UNZIP_VERSION_STRICT 0x14

#define CRC32(c, b) crcTable[((int)c^b) & 0xff] ^ (c >> 8)

#define UNZIP_CHECK_FOR_VALID_DATA \
        {\
                if (headers != 0)\
                {\
                        qDebug() << "Corrupted zip archive. Some files might be extracted.";\
                        ec = headers->size() != 0 ? UnZip::PartiallyCorrupted : UnZip::Corrupted;\
                        break;\
                }\
                else\
                {\
                        delete device;\
                        device = 0;\
                        qDebug() << "Corrupted or invalid zip archive";\
                        ec = UnZip::Corrupted;\
                        break;\
                }\
        }


/************************************************************************
 Public interface
*************************************************************************/

UnZip::UnZip()
{
        d = new UnzipPrivate;
}

UnZip::~UnZip()
{
        closeArchive();
        delete d;
}

bool UnZip::isOpen() const
{
        return d->device != 0;
}

UnZip::ErrorCode UnZip::openArchive(const QString& filename)
{
        QFile* file = new QFile(filename);

        if (!file->exists()) {
                delete file;
                return UnZip::FileNotFound;
        }

        if (!file->open(QIODevice::ReadOnly)) {
                delete file;
                return UnZip::OpenFailed;
        }

        return openArchive(file);
}

UnZip::ErrorCode UnZip::openArchive(QIODevice* device)
{
        if (device == 0)
        {
                qDebug() << "Invalid device.";
                return UnZip::InvalidDevice;
        }

        return d->openArchive(device);
}

void UnZip::closeArchive()
{
        d->closeArchive();
}

QString UnZip::archiveComment() const
{
        if (d->device == 0)
                return QString();
        return d->comment;
}

QString UnZip::formatError(UnZip::ErrorCode c) const
{
        switch (c)
        {
        case Ok: return QCoreApplication::translate("UnZip", "ZIP operation completed successfully."); break;
        case ZlibInit: return QCoreApplication::translate("UnZip", "Failed to initialize or load zlib library."); break;
        case ZlibError: return QCoreApplication::translate("UnZip", "zlib library error."); break;
        case OpenFailed: return QCoreApplication::translate("UnZip", "Unable to create or open file."); break;
        case PartiallyCorrupted: return QCoreApplication::translate("UnZip", "Partially corrupted archive. Some files might be extracted."); break;
        case Corrupted: return QCoreApplication::translate("UnZip", "Corrupted archive."); break;
        case WrongPassword: return QCoreApplication::translate("UnZip", "Wrong password."); break;
        case NoOpenArchive: return QCoreApplication::translate("UnZip", "No archive has been created yet."); break;
        case FileNotFound: return QCoreApplication::translate("UnZip", "File or directory does not exist."); break;
        case ReadFailed: return QCoreApplication::translate("UnZip", "File read error."); break;
        case WriteFailed: return QCoreApplication::translate("UnZip", "File write error."); break;
        case SeekFailed: return QCoreApplication::translate("UnZip", "File seek error."); break;
        case CreateDirFailed: return QCoreApplication::translate("UnZip", "Unable to create a directory."); break;
        case InvalidDevice: return QCoreApplication::translate("UnZip", "Invalid device."); break;
        case InvalidArchive: return QCoreApplication::translate("UnZip", "Invalid or incompatible zip archive."); break;
        case HeaderConsistencyError: return QCoreApplication::translate("UnZip", "Inconsistent headers. Archive might be corrupted."); break;
        default: ;
        }

        return QCoreApplication::translate("UnZip", "Unknown error.");
}

bool UnZip::contains(const QString& file) const
{
        if (d->headers == 0)
                return false;

        return d->headers->contains(file);
}

QStringList UnZip::fileList() const
{
        return d->headers == 0 ? QStringList() : d->headers->keys();
}

QList<UnZip::ZipEntry> UnZip::entryList() const
{
        QList<UnZip::ZipEntry> list;

        if (d->headers != 0)
        {
                for (QMap<QString,ZipEntryP*>::ConstIterator it = d->headers->constBegin(); it != d->headers->constEnd(); ++it)
                {
                        const ZipEntryP* entry = it.value();
                        Q_ASSERT(entry != 0);

                        ZipEntry z;

                        z.filename = it.key();
                        if (!entry->comment.isEmpty())
                                z.comment = entry->comment;
                        z.compressedSize = entry->szComp;
                        z.uncompressedSize = entry->szUncomp;
                        z.crc32 = entry->crc;
                        z.lastModified = d->convertDateTime(entry->modDate, entry->modTime);

                        z.compression = entry->compMethod == 0 ? NoCompression : entry->compMethod == 8 ? Deflated : UnknownCompression;
                        z.type = z.filename.endsWith("/") ? Directory : File;

                        z.encrypted = entry->isEncrypted();

                        list.append(z);
                }
        }

        return list;
}

UnZip::ErrorCode UnZip::extractAll(const QString& dirname, ExtractionOptions options)
{
        return extractAll(QDir(dirname), options);
}

UnZip::ErrorCode UnZip::extractAll(const QDir& dir, ExtractionOptions options)
{
        // this should only happen if we didn't call openArchive() yet
        if (d->device == 0)
                return NoOpenArchive;

        if (d->headers == 0)
                return Ok;

        bool end = false;
        for (QMap<QString,ZipEntryP*>::Iterator itr = d->headers->begin(); itr != d->headers->end(); ++itr)
        {
                ZipEntryP* entry = itr.value();
                Q_ASSERT(entry != 0);

                if ((entry->isEncrypted()) && d->skipAllEncrypted)
                        continue;

                switch (d->extractFile(itr.key(), *entry, dir, options))
                {
                case Corrupted:
                        qDebug() << "Removing corrupted entry" << itr.key();
                        d->headers->erase(itr++);
                        if (itr == d->headers->end())
                                end = true;
                        break;
                case CreateDirFailed:
                        break;
                case Skip:
                        break;
                case SkipAll:
                        d->skipAllEncrypted = true;
                        break;
                default:
                        ;
                }

                if (end)
                        break;
        }

        return Ok;
}

UnZip::ErrorCode UnZip::extractFile(const QString& filename, const QString& dirname, ExtractionOptions options)
{
        return extractFile(filename, QDir(dirname), options);
}

UnZip::ErrorCode UnZip::extractFile(const QString& filename, const QDir& dir, ExtractionOptions options)
{
        QMap<QString,ZipEntryP*>::Iterator itr = d->headers->find(filename);
        if (itr != d->headers->end())
        {
                ZipEntryP* entry = itr.value();
                Q_ASSERT(entry != 0);
                return d->extractFile(itr.key(), *entry, dir, options);
        }

        return FileNotFound;
}

UnZip::ErrorCode UnZip::extractFile(const QString& filename, QIODevice* dev, ExtractionOptions options)
{
        if (dev == 0)
                return InvalidDevice;

        QMap<QString,ZipEntryP*>::Iterator itr = d->headers->find(filename);
        if (itr != d->headers->end()) {
                ZipEntryP* entry = itr.value();
                Q_ASSERT(entry != 0);
                return d->extractFile(itr.key(), *entry, dev, options);
        }

        return FileNotFound;
}

UnZip::ErrorCode UnZip::extractFiles(const QStringList& filenames, const QString& dirname, ExtractionOptions options)
{
        QDir dir(dirname);
        ErrorCode ec;

        for (QStringList::ConstIterator itr = filenames.constBegin(); itr != filenames.constEnd(); ++itr)
        {
                ec = extractFile(*itr, dir, options);
                if (ec == FileNotFound)
                        continue;
                if (ec != Ok)
                        return ec;
        }

        return Ok;
}

UnZip::ErrorCode UnZip::extractFiles(const QStringList& filenames, const QDir& dir, ExtractionOptions options)
{
        ErrorCode ec;

        for (QStringList::ConstIterator itr = filenames.constBegin(); itr != filenames.constEnd(); ++itr)
        {
                ec = extractFile(*itr, dir, options);
                if (ec == FileNotFound)
                        continue;
                if (ec != Ok)
                        return ec;
        }

        return Ok;
}

void UnZip::setPassword(const QString& pwd)
{
        d->password = pwd;
}

UnZip::ZipEntry::ZipEntry()
{
        compressedSize = uncompressedSize = crc32 = 0;
        compression = NoCompression;
        type = File;
        encrypted = false;
}


/************************************************************************
 Private interface
*************************************************************************/

UnzipPrivate::UnzipPrivate()
{
        skipAllEncrypted = false;
        headers = 0;
        device = 0;

        uBuffer = (unsigned char*) buffer1;
        crcTable = (quint32*) get_crc_table();

        cdOffset = eocdOffset = 0;
        cdEntryCount = 0;
        unsupportedEntryCount = 0;
}

UnZip::ErrorCode UnzipPrivate::openArchive(QIODevice* dev)
{
        Q_ASSERT(dev != 0);

        if (device != 0)
                closeArchive();

        device = dev;

        if (!(device->isOpen() || device->open(QIODevice::ReadOnly)))
        {
                delete device;
                device = 0;

                qDebug() << "Unable to open device for reading";
                return UnZip::OpenFailed;
        }

        UnZip::ErrorCode ec;

        ec = seekToCentralDirectory();
        if (ec != UnZip::Ok)
        {
                closeArchive();
                return ec;
        }

        if (cdEntryCount == 0)
        {
                return UnZip::Ok;
        }

        bool continueParsing = true;

        while (continueParsing)
        {
                if (device->read(buffer1, 4) != 4)
                        UNZIP_CHECK_FOR_VALID_DATA

                if (! (buffer1[0] == 'P' && buffer1[1] == 'K' && buffer1[2] == 0x01  && buffer1[3] == 0x02) )
                        break;

                if ( (ec = parseCentralDirectoryRecord()) != UnZip::Ok )
                        break;
        }

        if (ec != UnZip::Ok)
                closeArchive();

        return ec;
}

/*
        \internal Parses a local header record and makes some consistency check
        with the information stored in the Central Directory record for this entry
        that has been previously parsed.
        \todo Optional consistency check (as a ExtractionOptions flag)

        local file header signature     4 bytes  (0x04034b50)
        version needed to extract       2 bytes
        general purpose bit flag        2 bytes
        compression method              2 bytes
        last mod file time              2 bytes
        last mod file date              2 bytes
        crc-32                          4 bytes
        compressed size                 4 bytes
        uncompressed size               4 bytes
        file name length                2 bytes
        extra field length              2 bytes

        file name (variable size)
        extra field (variable size)
*/
UnZip::ErrorCode UnzipPrivate::parseLocalHeaderRecord(const QString& path, ZipEntryP& entry)
{
        if (!device->seek(entry.lhOffset))
                return UnZip::SeekFailed;

        // Test signature
        if (device->read(buffer1, 4) != 4)
                return UnZip::ReadFailed;

        if ((buffer1[0] != 'P') || (buffer1[1] != 'K') || (buffer1[2] != 0x03) || (buffer1[3] != 0x04))
                return UnZip::InvalidArchive;

        if (device->read(buffer1, UNZIP_LOCAL_HEADER_SIZE) != UNZIP_LOCAL_HEADER_SIZE)
                return UnZip::ReadFailed;

        /*
                Check 3rd general purpose bit flag.

                "bit 3: If this bit is set, the fields crc-32, compressed size
                and uncompressed size are set to zero in the local
                header.  The correct values are put in the data descriptor
                immediately following the compressed data."
        */
        bool hasDataDescriptor = entry.hasDataDescriptor();

        bool checkFailed = false;

        if (!checkFailed)
                checkFailed = entry.compMethod != getUShort(uBuffer, UNZIP_LH_OFF_CMETHOD);
        if (!checkFailed)
                checkFailed = entry.gpFlag[0] != uBuffer[UNZIP_LH_OFF_GPFLAG];
        if (!checkFailed)
                checkFailed = entry.gpFlag[1] != uBuffer[UNZIP_LH_OFF_GPFLAG + 1];
        if (!checkFailed)
                checkFailed = entry.modTime[0] != uBuffer[UNZIP_LH_OFF_MODT];
        if (!checkFailed)
                checkFailed = entry.modTime[1] != uBuffer[UNZIP_LH_OFF_MODT + 1];
        if (!checkFailed)
                checkFailed = entry.modDate[0] != uBuffer[UNZIP_LH_OFF_MODD];
        if (!checkFailed)
                checkFailed = entry.modDate[1] != uBuffer[UNZIP_LH_OFF_MODD + 1];
        if (!hasDataDescriptor)
        {
                if (!checkFailed)
                        checkFailed = entry.crc != getULong(uBuffer, UNZIP_LH_OFF_CRC32);
                if (!checkFailed)
                        checkFailed = entry.szComp != getULong(uBuffer, UNZIP_LH_OFF_CSIZE);
                if (!checkFailed)
                        checkFailed = entry.szUncomp != getULong(uBuffer, UNZIP_LH_OFF_USIZE);
        }

        if (checkFailed)
                return UnZip::HeaderConsistencyError;

        // Check filename
        quint16 szName = getUShort(uBuffer, UNZIP_LH_OFF_NAMELEN);
        if (szName == 0)
                return UnZip::HeaderConsistencyError;

        if (device->read(buffer2, szName) != szName)
                return UnZip::ReadFailed;

        QString filename = QString::fromAscii(buffer2, szName);
        if (filename != path)
        {
                qDebug() << "Filename in local header mismatches.";
                return UnZip::HeaderConsistencyError;
        }

        // Skip extra field
        quint16 szExtra = getUShort(uBuffer, UNZIP_LH_OFF_XLEN);
        if (szExtra != 0)
        {
                if (!device->seek(device->pos() + szExtra))
                        return UnZip::SeekFailed;
        }

        entry.dataOffset = device->pos();

        if (hasDataDescriptor)
        {
                /*
                        The data descriptor has this OPTIONAL signature: PK\7\8
                        We try to skip the compressed data relying on the size set in the
                        Central Directory record.
                */
                if (!device->seek(device->pos() + entry.szComp))
                        return UnZip::SeekFailed;

                // Read 4 bytes and check if there is a data descriptor signature
                if (device->read(buffer2, 4) != 4)
                        return UnZip::ReadFailed;

                bool hasSignature = buffer2[0] == 'P' && buffer2[1] == 'K' && buffer2[2] == 0x07 && buffer2[3] == 0x08;
                if (hasSignature)
                {
                        if (device->read(buffer2, UNZIP_DD_SIZE) != UNZIP_DD_SIZE)
                                return UnZip::ReadFailed;
                }
                else
                {
                        if (device->read(buffer2 + 4, UNZIP_DD_SIZE - 4) != UNZIP_DD_SIZE - 4)
                                return UnZip::ReadFailed;
                }

                // DD: crc, compressed size, uncompressed size
                if (
                        entry.crc != getULong((unsigned char*)buffer2, UNZIP_DD_OFF_CRC32) ||
                        entry.szComp != getULong((unsigned char*)buffer2, UNZIP_DD_OFF_CSIZE) ||
                        entry.szUncomp != getULong((unsigned char*)buffer2, UNZIP_DD_OFF_USIZE)
                        )
                        return UnZip::HeaderConsistencyError;
        }

        return UnZip::Ok;
}

UnZip::ErrorCode UnzipPrivate::seekToCentralDirectory()
{
        qint64 length = device->size();
        qint64 offset = length - UNZIP_EOCD_SIZE;

        if (length < UNZIP_EOCD_SIZE)
                return UnZip::InvalidArchive;

        if (!device->seek( offset ))
                return UnZip::SeekFailed;

        if (device->read(buffer1, UNZIP_EOCD_SIZE) != UNZIP_EOCD_SIZE)
                return UnZip::ReadFailed;

        bool eocdFound = (buffer1[0] == 'P' && buffer1[1] == 'K' && buffer1[2] == 0x05 && buffer1[3] == 0x06);

        if (eocdFound)
        {
                // Zip file has no comment (the only variable length field in the EOCD record)
                eocdOffset = offset;
        }
        else
        {
                qint64 read;
                char* p = 0;

                offset -= UNZIP_EOCD_SIZE;

                if (offset <= 0)
                        return UnZip::InvalidArchive;

                if (!device->seek( offset ))
                        return UnZip::SeekFailed;

                while ((read = device->read(buffer1, UNZIP_EOCD_SIZE)) >= 0)
                {
                        if ( (p = strstr(buffer1, "PK\5\6")) != 0)
                        {
                                // Seek to the start of the EOCD record so we can read it fully
                                // Yes... we could simply read the missing bytes and append them to the buffer
                                // but this is far easier so heck it!
                                device->seek( offset + (p - buffer1) );
                                eocdFound = true;
                                eocdOffset = offset + (p - buffer1);

                                // Read EOCD record
                                if (device->read(buffer1, UNZIP_EOCD_SIZE) != UNZIP_EOCD_SIZE)
                                        return UnZip::ReadFailed;

                                break;
                        }

                        // TODO: This is very slow and only a temporary bug fix. Need some pattern matching algorithm here.
                        offset -= 1 /*UNZIP_EOCD_SIZE*/;
                        if (offset <= 0)
                                return UnZip::InvalidArchive;

                        if (!device->seek( offset ))
                                return UnZip::SeekFailed;
                }
        }

        if (!eocdFound)
                return UnZip::InvalidArchive;

        // Parse EOCD to locate CD offset
        offset = getULong((const unsigned char*)buffer1, UNZIP_EOCD_OFF_CDOFF + 4);

        cdOffset = offset;

        cdEntryCount = getUShort((const unsigned char*)buffer1, UNZIP_EOCD_OFF_ENTRIES + 4);

        quint16 commentLength = getUShort((const unsigned char*)buffer1, UNZIP_EOCD_OFF_COMMLEN + 4);
        if (commentLength != 0)
        {
                QByteArray c = device->read(commentLength);
                if (c.count() != commentLength)
                        return UnZip::ReadFailed;

                comment = c;
        }

        // Seek to the start of the CD record
        if (!device->seek( cdOffset ))
                return UnZip::SeekFailed;

        return UnZip::Ok;
}

UnZip::ErrorCode UnzipPrivate::parseCentralDirectoryRecord()
{
        // Read CD record
        if (device->read(buffer1, UNZIP_CD_ENTRY_SIZE_NS) != UNZIP_CD_ENTRY_SIZE_NS)
                return UnZip::ReadFailed;

        bool skipEntry = false;

        // Get compression type so we can skip non compatible algorithms
        quint16 compMethod = getUShort(uBuffer, UNZIP_CD_OFF_CMETHOD);

        // Get variable size fields length so we can skip the whole record
        // if necessary
        quint16 szName = getUShort(uBuffer, UNZIP_CD_OFF_NAMELEN);
        quint16 szExtra = getUShort(uBuffer, UNZIP_CD_OFF_XLEN);
        quint16 szComment = getUShort(uBuffer, UNZIP_CD_OFF_COMMLEN);

        quint32 skipLength = szName + szExtra + szComment;

        UnZip::ErrorCode ec = UnZip::Ok;

        if ((compMethod != 0) && (compMethod != 8))
        {
                qDebug() << "Unsupported compression method. Skipping file.";
                skipEntry = true;
        }

        // Header parsing may be a problem if version is bigger than UNZIP_VERSION
        if (!skipEntry && buffer1[UNZIP_CD_OFF_VERSION] > UNZIP_VERSION)
        {
                qDebug() << "Unsupported PKZip version. Skipping file.";
                skipEntry = true;
        }

        if (!skipEntry && szName == 0)
        {
                qDebug() << "Skipping file with no name.";
                skipEntry = true;
        }

        if (!skipEntry && device->read(buffer2, szName) != szName)
        {
                ec = UnZip::ReadFailed;
                skipEntry = true;
        }

        if (skipEntry)
        {
                if (ec == UnZip::Ok)
                {
                        if (!device->seek( device->pos() + skipLength ))
                                ec = UnZip::SeekFailed;

                        unsupportedEntryCount++;
                }

                return ec;
        }

        QString filename = QString::fromAscii(buffer2, szName);

        ZipEntryP* h = new ZipEntryP;
        h->compMethod = compMethod;

        h->gpFlag[0] = buffer1[UNZIP_CD_OFF_GPFLAG];
        h->gpFlag[1] = buffer1[UNZIP_CD_OFF_GPFLAG + 1];

        h->modTime[0] = buffer1[UNZIP_CD_OFF_MODT];
        h->modTime[1] = buffer1[UNZIP_CD_OFF_MODT + 1];

        h->modDate[0] = buffer1[UNZIP_CD_OFF_MODD];
        h->modDate[1] = buffer1[UNZIP_CD_OFF_MODD + 1];

        h->crc = getULong(uBuffer, UNZIP_CD_OFF_CRC32);
        h->szComp = getULong(uBuffer, UNZIP_CD_OFF_CSIZE);
        h->szUncomp = getULong(uBuffer, UNZIP_CD_OFF_USIZE);

        // Skip extra field (if any)
        if (szExtra != 0)
        {
                if (!device->seek( device->pos() + szExtra ))
                {
                        delete h;
                        return UnZip::SeekFailed;
                }
        }

        // Read comment field (if any)
        if (szComment != 0)
        {
                if (device->read(buffer2, szComment) != szComment)
                {
                        delete h;
                        return UnZip::ReadFailed;
                }

                h->comment = QString::fromAscii(buffer2, szComment);
        }

        h->lhOffset = getULong(uBuffer, UNZIP_CD_OFF_LHOFFSET);

        if (headers == 0)
                headers = new QMap<QString, ZipEntryP*>();
        headers->insert(filename, h);

        return UnZip::Ok;
}

void UnzipPrivate::closeArchive()
{
        if (device == 0)
                return;

        skipAllEncrypted = false;

        if (headers != 0)
        {
                qDeleteAll(*headers);
                delete headers;
                headers = 0;
        }

        delete device; device = 0;

        cdOffset = eocdOffset = 0;
        cdEntryCount = 0;
        unsupportedEntryCount = 0;

        comment.clear();
}

UnZip::ErrorCode UnzipPrivate::extractFile(const QString& path, ZipEntryP& entry, const QDir& dir, UnZip::ExtractionOptions options)
{
        QString name(path);
        QString dirname;
        QString directory;

        int pos = name.lastIndexOf('/');

        // This entry is for a directory
        if (pos == name.length() - 1)
        {
                if (options.testFlag(UnZip::SkipPaths))
                        return UnZip::Ok;

                directory = QString("%1/%2").arg(dir.absolutePath()).arg(QDir::cleanPath(name));
                if (!createDirectory(directory))
                {
                        qDebug() << QString("Unable to create directory: %1").arg(directory);
                        return UnZip::CreateDirFailed;
                }

                return UnZip::Ok;
        }

        // Extract path from entry
        if (pos > 0)
        {
                // get directory part
                dirname = name.left(pos);
                if (options.testFlag(UnZip::SkipPaths))
                {
                        directory = dir.absolutePath();
                }
                else
                {
                        directory = QString("%1/%2").arg(dir.absolutePath()).arg(QDir::cleanPath(dirname));
                        if (!createDirectory(directory))
                        {
                                qDebug() << QString("Unable to create directory: %1").arg(directory);
                                return UnZip::CreateDirFailed;
                        }
                }
                name = name.right(name.length() - pos - 1);
        } else directory = dir.absolutePath();

        name = QString("%1/%2").arg(directory).arg(name);

        QFile outFile(name);

        if (!outFile.open(QIODevice::WriteOnly))
        {
                qDebug() << QString("Unable to open %1 for writing").arg(name);
                return UnZip::OpenFailed;
        }


        UnZip::ErrorCode ec = extractFile(path, entry, &outFile, options);

        outFile.close();

        if (ec != UnZip::Ok)
        {
                if (!outFile.remove())
                        qDebug() << QString("Unable to remove corrupted file: %1").arg(name);
        }

        return ec;
}

UnZip::ErrorCode UnzipPrivate::extractFile(const QString& path, ZipEntryP& entry, QIODevice* dev, UnZip::ExtractionOptions options)
{
        Q_UNUSED(options);
        Q_ASSERT(dev != 0);

        if (!entry.lhEntryChecked)
        {
                UnZip::ErrorCode ec = parseLocalHeaderRecord(path, entry);
                entry.lhEntryChecked = true;

                if (ec != UnZip::Ok)
                        return ec;
        }

        if (!device->seek(entry.dataOffset))
                return UnZip::SeekFailed;

        // Encryption keys
        quint32 keys[3];

        if (entry.isEncrypted())
        {
                UnZip::ErrorCode e = testPassword(keys, path, entry);
                if (e != UnZip::Ok)
                {
                        qDebug() << QString("Unable to decrypt %1").arg(path);
                        return e;
                }
                entry.szComp -= UNZIP_LOCAL_ENC_HEADER_SIZE; // remove encryption header size
        }

        if (entry.szComp == 0)
        {
                if (entry.crc != 0)
                        return UnZip::Corrupted;

                return UnZip::Ok;
        }

        uInt rep = entry.szComp / UNZIP_READ_BUFFER;
        uInt rem = entry.szComp % UNZIP_READ_BUFFER;
        uInt cur = 0;

        // extract data
        qint64 read;
        quint64 tot = 0;

        quint32 myCRC = crc32(0L, Z_NULL, 0);

        if (entry.compMethod == 0)
        {
                while ( (read = device->read(buffer1, cur < rep ? UNZIP_READ_BUFFER : rem)) > 0 )
                {
                        if (entry.isEncrypted())
                                decryptBytes(keys, buffer1, read);

                        myCRC = crc32(myCRC, uBuffer, read);

                        if (dev->write(buffer1, read) != read)
                                return UnZip::WriteFailed;

                        cur++;
                        tot += read;

                        if (tot == entry.szComp)
                                break;
                }

                if (read < 0)
                        return UnZip::ReadFailed;
        }
        else if (entry.compMethod == 8)
        {
                /* Allocate inflate state */
                z_stream zstr;
                zstr.zalloc = Z_NULL;
                zstr.zfree = Z_NULL;
                zstr.opaque = Z_NULL;
                zstr.next_in = Z_NULL;
                zstr.avail_in = 0;

                int zret;

                // Use inflateInit2 with negative windowBits to get raw decompression
                if ( (zret = inflateInit2_(&zstr, -MAX_WBITS, ZLIB_VERSION, sizeof(z_stream))) != Z_OK )
                        return UnZip::ZlibError;

                int szDecomp;

                // Decompress until deflate stream ends or end of file
                do
                {
                        read = device->read(buffer1, cur < rep ? UNZIP_READ_BUFFER : rem);
                        if (read == 0)
                                break;
                        if (read < 0)
                        {
                                (void)inflateEnd(&zstr);
                                return UnZip::ReadFailed;
                        }

                        if (entry.isEncrypted())
                                decryptBytes(keys, buffer1, read);

                        cur++;
                        tot += read;

                        zstr.avail_in = (uInt) read;
                        zstr.next_in = (Bytef*) buffer1;


                        // Run inflate() on input until output buffer not full
                        do {
                                zstr.avail_out = UNZIP_READ_BUFFER;
                                zstr.next_out = (Bytef*) buffer2;;

                                zret = inflate(&zstr, Z_NO_FLUSH);

                                switch (zret) {
                                        case Z_NEED_DICT:
                                        case Z_DATA_ERROR:
                                        case Z_MEM_ERROR:
                                                inflateEnd(&zstr);
                                                return UnZip::WriteFailed;
                                        default:
                                                ;
                                }

                                szDecomp = UNZIP_READ_BUFFER - zstr.avail_out;
                                if (dev->write(buffer2, szDecomp) != szDecomp)
                                {
                                        inflateEnd(&zstr);
                                        return UnZip::ZlibError;
                                }

                                myCRC = crc32(myCRC, (const Bytef*) buffer2, szDecomp);

                        } while (zstr.avail_out == 0);

                }
                while (zret != Z_STREAM_END);

                inflateEnd(&zstr);
        }

        if (myCRC != entry.crc)
                return UnZip::Corrupted;

        return UnZip::Ok;
}

bool UnzipPrivate::createDirectory(const QString& path)
{
        QDir d(path);
        if (!d.exists())
        {
                int sep = path.lastIndexOf("/");
                if (sep <= 0) return true;

                if (!createDirectory(path.left(sep)))
                        return false;

                if (!d.mkdir(path))
                {
                        qDebug() << QString("Unable to create directory: %1").arg(path);
                        return false;
                }
        }

        return true;
}

quint32 UnzipPrivate::getULong(const unsigned char* data, quint32 offset) const
{
        quint32 res = (quint32) data[offset];
        res |= (((quint32)data[offset+1]) << 8);
        res |= (((quint32)data[offset+2]) << 16);
        res |= (((quint32)data[offset+3]) << 24);

        return res;
}

quint64 UnzipPrivate::getULLong(const unsigned char* data, quint32 offset) const
{
        quint64 res = (quint64) data[offset];
        res |= (((quint64)data[offset+1]) << 8);
        res |= (((quint64)data[offset+2]) << 16);
        res |= (((quint64)data[offset+3]) << 24);
        res |= (((quint64)data[offset+1]) << 32);
        res |= (((quint64)data[offset+2]) << 40);
        res |= (((quint64)data[offset+3]) << 48);
        res |= (((quint64)data[offset+3]) << 56);

        return res;
}

quint16 UnzipPrivate::getUShort(const unsigned char* data, quint32 offset) const
{
        return (quint16) data[offset] | (((quint16)data[offset+1]) << 8);
}

int UnzipPrivate::decryptByte(quint32 key2) const
{
        quint16 temp = ((quint16)(key2) & 0xffff) | 2;
        return (int)(((temp * (temp ^ 1)) >> 8) & 0xff);
}

void UnzipPrivate::updateKeys(quint32* keys, int c) const
{
        keys[0] = CRC32(keys[0], c);
        keys[1] += keys[0] & 0xff;
        keys[1] = keys[1] * 134775813L + 1;
        keys[2] = CRC32(keys[2], ((int)keys[1]) >> 24);
}

void UnzipPrivate::initKeys(const QString& pwd, quint32* keys) const
{
        keys[0] = 305419896L;
        keys[1] = 591751049L;
        keys[2] = 878082192L;

        QByteArray pwdBytes = pwd.toAscii();
        int sz = pwdBytes.size();
        const char* ascii = pwdBytes.data();

        for (int i=0; i<sz; ++i)
                updateKeys(keys, (int)ascii[i]);
}

UnZip::ErrorCode UnzipPrivate::testPassword(quint32* keys, const QString& file, const ZipEntryP& header)
{
        Q_UNUSED(file);

        // read encryption keys
        if (device->read(buffer1, 12) != 12)
                return UnZip::Corrupted;

        // Replace this code if you want to i.e. call some dialog and ask the user for a password
        initKeys(password, keys);
        if (testKeys(header, keys))
                return UnZip::Ok;

        return UnZip::Skip;
}

bool UnzipPrivate::testKeys(const ZipEntryP& header, quint32* keys)
{
        char lastByte;

        // decrypt encryption header
        for (int i=0; i<11; ++i)
                updateKeys(keys, lastByte = buffer1[i] ^ decryptByte(keys[2]));
        updateKeys(keys, lastByte = buffer1[11] ^ decryptByte(keys[2]));

        // if there is an extended header (bit in the gp flag) buffer[11] is a byte from the file time
        // with no extended header we have to check the crc high-order byte
        char c = ((header.gpFlag[0] & 0x08) == 8) ? header.modTime[1] : header.crc >> 24;

        return (lastByte == c);
}

void UnzipPrivate::decryptBytes(quint32* keys, char* buffer, qint64 read)
{
        for (int i=0; i<(int)read; ++i)
                updateKeys(keys, buffer[i] ^= decryptByte(keys[2]));
}

QDateTime UnzipPrivate::convertDateTime(const unsigned char date[2], const unsigned char time[2]) const
{
        QDateTime dt;

        // Usual PKZip low-byte to high-byte order

        // Date: 7 bits = years from 1980, 4 bits = month, 5 bits = day
        quint16 year = (date[1] >> 1) & 127;
        quint16 month = ((date[1] << 3) & 14) | ((date[0] >> 5) & 7);
        quint16 day = date[0] & 31;

        // Time: 5 bits hour, 6 bits minutes, 5 bits seconds with a 2sec precision
        quint16 hour = (time[1] >> 3) & 31;
        quint16 minutes = ((time[1] << 3) & 56) | ((time[0] >> 5) & 7);
        quint16 seconds = (time[0] & 31) * 2;

        dt.setDate(QDate(1980 + year, month, day));
        dt.setTime(QTime(hour, minutes, seconds));
        return dt;
}

---