summaryrefslogtreecommitdiffstats
path: root/utils/rbutilqt/quazip/quazipfile.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'utils/rbutilqt/quazip/quazipfile.cpp')
-rw-r--r--utils/rbutilqt/quazip/quazipfile.cpp570
1 files changed, 570 insertions, 0 deletions
diff --git a/utils/rbutilqt/quazip/quazipfile.cpp b/utils/rbutilqt/quazip/quazipfile.cpp
new file mode 100644
index 0000000000..b984de7279
--- /dev/null
+++ b/utils/rbutilqt/quazip/quazipfile.cpp
@@ -0,0 +1,570 @@
+/*
+Copyright (C) 2005-2014 Sergey A. Tachenov
+
+This file is part of QuaZIP.
+
+QuaZIP is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 2.1 of the License, or
+(at your option) any later version.
+
+QuaZIP is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with QuaZIP. If not, see <http://www.gnu.org/licenses/>.
+
+See COPYING file for the full LGPL text.
+
+Original ZIP package is copyrighted by Gilles Vollant, see
+quazip/(un)zip.h files for details, basically it's zlib license.
+ **/
+
+#include "quazipfile.h"
+
+#include "quazipfileinfo.h"
+
+using namespace std;
+
+#define QUAZIP_VERSION_MADE_BY 0x1Eu
+
+/// The implementation class for QuaZip.
+/**
+\internal
+
+This class contains all the private stuff for the QuaZipFile class, thus
+allowing to preserve binary compatibility between releases, the
+technique known as the Pimpl (private implementation) idiom.
+*/
+class QuaZipFilePrivate {
+ friend class QuaZipFile;
+ private:
+ Q_DISABLE_COPY(QuaZipFilePrivate)
+ /// The pointer to the associated QuaZipFile instance.
+ QuaZipFile *q;
+ /// The QuaZip object to work with.
+ QuaZip *zip;
+ /// The file name.
+ QString fileName;
+ /// Case sensitivity mode.
+ QuaZip::CaseSensitivity caseSensitivity;
+ /// Whether this file is opened in the raw mode.
+ bool raw;
+ /// Write position to keep track of.
+ /**
+ QIODevice::pos() is broken for non-seekable devices, so we need
+ our own position.
+ */
+ qint64 writePos;
+ /// Uncompressed size to write along with a raw file.
+ quint64 uncompressedSize;
+ /// CRC to write along with a raw file.
+ quint32 crc;
+ /// Whether \ref zip points to an internal QuaZip instance.
+ /**
+ This is true if the archive was opened by name, rather than by
+ supplying an existing QuaZip instance.
+ */
+ bool internal;
+ /// The last error.
+ int zipError;
+ /// Resets \ref zipError.
+ inline void resetZipError() const {setZipError(UNZ_OK);}
+ /// Sets the zip error.
+ /**
+ This function is marked as const although it changes one field.
+ This allows to call it from const functions that don't change
+ anything by themselves.
+ */
+ void setZipError(int zipError) const;
+ /// The constructor for the corresponding QuaZipFile constructor.
+ inline QuaZipFilePrivate(QuaZipFile *q):
+ q(q),
+ zip(NULL),
+ caseSensitivity(QuaZip::csDefault),
+ raw(false),
+ writePos(0),
+ uncompressedSize(0),
+ crc(0),
+ internal(true),
+ zipError(UNZ_OK) {}
+ /// The constructor for the corresponding QuaZipFile constructor.
+ inline QuaZipFilePrivate(QuaZipFile *q, const QString &zipName):
+ q(q),
+ caseSensitivity(QuaZip::csDefault),
+ raw(false),
+ writePos(0),
+ uncompressedSize(0),
+ crc(0),
+ internal(true),
+ zipError(UNZ_OK)
+ {
+ zip=new QuaZip(zipName);
+ }
+ /// The constructor for the corresponding QuaZipFile constructor.
+ inline QuaZipFilePrivate(QuaZipFile *q, const QString &zipName, const QString &fileName,
+ QuaZip::CaseSensitivity cs):
+ q(q),
+ raw(false),
+ writePos(0),
+ uncompressedSize(0),
+ crc(0),
+ internal(true),
+ zipError(UNZ_OK)
+ {
+ zip=new QuaZip(zipName);
+ this->fileName=fileName;
+ if (this->fileName.startsWith(QLatin1String("/")))
+ this->fileName = this->fileName.mid(1);
+ this->caseSensitivity=cs;
+ }
+ /// The constructor for the QuaZipFile constructor accepting a file name.
+ inline QuaZipFilePrivate(QuaZipFile *q, QuaZip *zip):
+ q(q),
+ zip(zip),
+ raw(false),
+ writePos(0),
+ uncompressedSize(0),
+ crc(0),
+ internal(false),
+ zipError(UNZ_OK) {}
+ /// The destructor.
+ inline ~QuaZipFilePrivate()
+ {
+ if (internal)
+ delete zip;
+ }
+};
+
+QuaZipFile::QuaZipFile():
+ p(new QuaZipFilePrivate(this))
+{
+}
+
+QuaZipFile::QuaZipFile(QObject *parent):
+ QIODevice(parent),
+ p(new QuaZipFilePrivate(this))
+{
+}
+
+QuaZipFile::QuaZipFile(const QString& zipName, QObject *parent):
+ QIODevice(parent),
+ p(new QuaZipFilePrivate(this, zipName))
+{
+}
+
+QuaZipFile::QuaZipFile(const QString& zipName, const QString& fileName,
+ QuaZip::CaseSensitivity cs, QObject *parent):
+ QIODevice(parent),
+ p(new QuaZipFilePrivate(this, zipName, fileName, cs))
+{
+}
+
+QuaZipFile::QuaZipFile(QuaZip *zip, QObject *parent):
+ QIODevice(parent),
+ p(new QuaZipFilePrivate(this, zip))
+{
+}
+
+QuaZipFile::~QuaZipFile()
+{
+ if (isOpen())
+ close();
+ delete p;
+}
+
+QString QuaZipFile::getZipName() const
+{
+ return p->zip==NULL ? QString() : p->zip->getZipName();
+}
+
+QuaZip *QuaZipFile::getZip() const
+{
+ return p->internal ? NULL : p->zip;
+}
+
+QString QuaZipFile::getActualFileName()const
+{
+ p->setZipError(UNZ_OK);
+ if (p->zip == NULL || (openMode() & WriteOnly))
+ return QString();
+ QString name=p->zip->getCurrentFileName();
+ if(name.isNull())
+ p->setZipError(p->zip->getZipError());
+ return name;
+}
+
+void QuaZipFile::setZipName(const QString& zipName)
+{
+ if(isOpen()) {
+ qWarning("QuaZipFile::setZipName(): file is already open - can not set ZIP name");
+ return;
+ }
+ if(p->zip!=NULL && p->internal)
+ delete p->zip;
+ p->zip=new QuaZip(zipName);
+ p->internal=true;
+}
+
+void QuaZipFile::setZip(QuaZip *zip)
+{
+ if(isOpen()) {
+ qWarning("QuaZipFile::setZip(): file is already open - can not set ZIP");
+ return;
+ }
+ if(p->zip!=NULL && p->internal)
+ delete p->zip;
+ p->zip=zip;
+ p->fileName=QString();
+ p->internal=false;
+}
+
+void QuaZipFile::setFileName(const QString& fileName, QuaZip::CaseSensitivity cs)
+{
+ if(p->zip==NULL) {
+ qWarning("QuaZipFile::setFileName(): call setZipName() first");
+ return;
+ }
+ if(!p->internal) {
+ qWarning("QuaZipFile::setFileName(): should not be used when not using internal QuaZip");
+ return;
+ }
+ if(isOpen()) {
+ qWarning("QuaZipFile::setFileName(): can not set file name for already opened file");
+ return;
+ }
+ p->fileName=fileName;
+ if (p->fileName.startsWith(QLatin1String("/")))
+ p->fileName = p->fileName.mid(1);
+ p->caseSensitivity=cs;
+}
+
+void QuaZipFilePrivate::setZipError(int zipError) const
+{
+ QuaZipFilePrivate *fakeThis = const_cast<QuaZipFilePrivate*>(this); // non-const
+ fakeThis->zipError=zipError;
+ if(zipError==UNZ_OK)
+ q->setErrorString(QString());
+ else
+ q->setErrorString(QuaZipFile::tr("ZIP/UNZIP API error %1").arg(zipError));
+}
+
+bool QuaZipFile::open(OpenMode mode)
+{
+ return open(mode, NULL);
+}
+
+bool QuaZipFile::open(OpenMode mode, int *method, int *level, bool raw, const char *password)
+{
+ p->resetZipError();
+ if(isOpen()) {
+ qWarning("QuaZipFile::open(): already opened");
+ return false;
+ }
+ if(mode&Unbuffered) {
+ qWarning("QuaZipFile::open(): Unbuffered mode is not supported");
+ return false;
+ }
+ if((mode&ReadOnly)&&!(mode&WriteOnly)) {
+ if(p->internal) {
+ if(!p->zip->open(QuaZip::mdUnzip)) {
+ p->setZipError(p->zip->getZipError());
+ return false;
+ }
+ if(!p->zip->setCurrentFile(p->fileName, p->caseSensitivity)) {
+ p->setZipError(p->zip->getZipError());
+ p->zip->close();
+ return false;
+ }
+ } else {
+ if(p->zip==NULL) {
+ qWarning("QuaZipFile::open(): zip is NULL");
+ return false;
+ }
+ if(p->zip->getMode()!=QuaZip::mdUnzip) {
+ qWarning("QuaZipFile::open(): file open mode %d incompatible with ZIP open mode %d",
+ (int)mode, (int)p->zip->getMode());
+ return false;
+ }
+ if(!p->zip->hasCurrentFile()) {
+ qWarning("QuaZipFile::open(): zip does not have current file");
+ return false;
+ }
+ }
+ p->setZipError(unzOpenCurrentFile3(p->zip->getUnzFile(), method, level, (int)raw, password));
+ if(p->zipError==UNZ_OK) {
+ setOpenMode(mode);
+ p->raw=raw;
+ return true;
+ } else
+ return false;
+ }
+ qWarning("QuaZipFile::open(): open mode %d not supported by this function", (int)mode);
+ return false;
+}
+
+bool QuaZipFile::open(OpenMode mode, const QuaZipNewInfo& info,
+ const char *password, quint32 crc,
+ int method, int level, bool raw,
+ int windowBits, int memLevel, int strategy)
+{
+ zip_fileinfo info_z;
+ p->resetZipError();
+ if(isOpen()) {
+ qWarning("QuaZipFile::open(): already opened");
+ return false;
+ }
+ if((mode&WriteOnly)&&!(mode&ReadOnly)) {
+ if(p->internal) {
+ qWarning("QuaZipFile::open(): write mode is incompatible with internal QuaZip approach");
+ return false;
+ }
+ if(p->zip==NULL) {
+ qWarning("QuaZipFile::open(): zip is NULL");
+ return false;
+ }
+ if(p->zip->getMode()!=QuaZip::mdCreate&&p->zip->getMode()!=QuaZip::mdAppend&&p->zip->getMode()!=QuaZip::mdAdd) {
+ qWarning("QuaZipFile::open(): file open mode %d incompatible with ZIP open mode %d",
+ (int)mode, (int)p->zip->getMode());
+ return false;
+ }
+ info_z.tmz_date.tm_year=info.dateTime.date().year();
+ info_z.tmz_date.tm_mon=info.dateTime.date().month() - 1;
+ info_z.tmz_date.tm_mday=info.dateTime.date().day();
+ info_z.tmz_date.tm_hour=info.dateTime.time().hour();
+ info_z.tmz_date.tm_min=info.dateTime.time().minute();
+ info_z.tmz_date.tm_sec=info.dateTime.time().second();
+ info_z.dosDate = 0;
+ info_z.internal_fa=(uLong)info.internalAttr;
+ info_z.external_fa=(uLong)info.externalAttr;
+ if (p->zip->isDataDescriptorWritingEnabled())
+ zipSetFlags(p->zip->getZipFile(), ZIP_WRITE_DATA_DESCRIPTOR);
+ else
+ zipClearFlags(p->zip->getZipFile(), ZIP_WRITE_DATA_DESCRIPTOR);
+ p->setZipError(zipOpenNewFileInZip4_64(p->zip->getZipFile(),
+ p->zip->isUtf8Enabled()
+ ? info.name.toUtf8().constData()
+ : p->zip->getFileNameCodec()->fromUnicode(info.name).constData(),
+ &info_z,
+ info.extraLocal.constData(), info.extraLocal.length(),
+ info.extraGlobal.constData(), info.extraGlobal.length(),
+ p->zip->isUtf8Enabled()
+ ? info.comment.toUtf8().constData()
+ : p->zip->getCommentCodec()->fromUnicode(info.comment).constData(),
+ method, level, (int)raw,
+ windowBits, memLevel, strategy,
+ password, (uLong)crc,
+ (p->zip->getOsCode() << 8) | QUAZIP_VERSION_MADE_BY,
+ 0,
+ p->zip->isZip64Enabled()));
+ if(p->zipError==UNZ_OK) {
+ p->writePos=0;
+ setOpenMode(mode);
+ p->raw=raw;
+ if(raw) {
+ p->crc=crc;
+ p->uncompressedSize=info.uncompressedSize;
+ }
+ return true;
+ } else
+ return false;
+ }
+ qWarning("QuaZipFile::open(): open mode %d not supported by this function", (int)mode);
+ return false;
+}
+
+bool QuaZipFile::isSequential()const
+{
+ return true;
+}
+
+qint64 QuaZipFile::pos()const
+{
+ if(p->zip==NULL) {
+ qWarning("QuaZipFile::pos(): call setZipName() or setZip() first");
+ return -1;
+ }
+ if(!isOpen()) {
+ qWarning("QuaZipFile::pos(): file is not open");
+ return -1;
+ }
+ if(openMode()&ReadOnly)
+ // QIODevice::pos() is broken for sequential devices,
+ // but thankfully bytesAvailable() returns the number of
+ // bytes buffered, so we know how far ahead we are.
+ return unztell64(p->zip->getUnzFile()) - QIODevice::bytesAvailable();
+ else
+ return p->writePos;
+}
+
+bool QuaZipFile::atEnd()const
+{
+ if(p->zip==NULL) {
+ qWarning("QuaZipFile::atEnd(): call setZipName() or setZip() first");
+ return false;
+ }
+ if(!isOpen()) {
+ qWarning("QuaZipFile::atEnd(): file is not open");
+ return false;
+ }
+ if(openMode()&ReadOnly)
+ // the same problem as with pos()
+ return QIODevice::bytesAvailable() == 0
+ && unzeof(p->zip->getUnzFile())==1;
+ else
+ return true;
+}
+
+qint64 QuaZipFile::size()const
+{
+ if(!isOpen()) {
+ qWarning("QuaZipFile::atEnd(): file is not open");
+ return -1;
+ }
+ if(openMode()&ReadOnly)
+ return p->raw?csize():usize();
+ else
+ return p->writePos;
+}
+
+qint64 QuaZipFile::csize()const
+{
+ unz_file_info64 info_z;
+ p->setZipError(UNZ_OK);
+ if(p->zip==NULL||p->zip->getMode()!=QuaZip::mdUnzip) return -1;
+ p->setZipError(unzGetCurrentFileInfo64(p->zip->getUnzFile(), &info_z, NULL, 0, NULL, 0, NULL, 0));
+ if(p->zipError!=UNZ_OK)
+ return -1;
+ return info_z.compressed_size;
+}
+
+qint64 QuaZipFile::usize()const
+{
+ unz_file_info64 info_z;
+ p->setZipError(UNZ_OK);
+ if(p->zip==NULL||p->zip->getMode()!=QuaZip::mdUnzip) return -1;
+ p->setZipError(unzGetCurrentFileInfo64(p->zip->getUnzFile(), &info_z, NULL, 0, NULL, 0, NULL, 0));
+ if(p->zipError!=UNZ_OK)
+ return -1;
+ return info_z.uncompressed_size;
+}
+
+bool QuaZipFile::getFileInfo(QuaZipFileInfo *info)
+{
+ QuaZipFileInfo64 info64;
+ if (getFileInfo(&info64)) {
+ info64.toQuaZipFileInfo(*info);
+ return true;
+ } else {
+ return false;
+ }
+}
+
+bool QuaZipFile::getFileInfo(QuaZipFileInfo64 *info)
+{
+ if(p->zip==NULL||p->zip->getMode()!=QuaZip::mdUnzip) return false;
+ p->zip->getCurrentFileInfo(info);
+ p->setZipError(p->zip->getZipError());
+ return p->zipError==UNZ_OK;
+}
+
+void QuaZipFile::close()
+{
+ p->resetZipError();
+ if(p->zip==NULL||!p->zip->isOpen()) return;
+ if(!isOpen()) {
+ qWarning("QuaZipFile::close(): file isn't open");
+ return;
+ }
+ if(openMode()&ReadOnly)
+ p->setZipError(unzCloseCurrentFile(p->zip->getUnzFile()));
+ else if(openMode()&WriteOnly)
+ if(isRaw()) p->setZipError(zipCloseFileInZipRaw64(p->zip->getZipFile(), p->uncompressedSize, p->crc));
+ else p->setZipError(zipCloseFileInZip(p->zip->getZipFile()));
+ else {
+ qWarning("Wrong open mode: %d", (int)openMode());
+ return;
+ }
+ if(p->zipError==UNZ_OK) setOpenMode(QIODevice::NotOpen);
+ else return;
+ if(p->internal) {
+ p->zip->close();
+ p->setZipError(p->zip->getZipError());
+ }
+}
+
+qint64 QuaZipFile::readData(char *data, qint64 maxSize)
+{
+ p->setZipError(UNZ_OK);
+ qint64 bytesRead=unzReadCurrentFile(p->zip->getUnzFile(), data, (unsigned)maxSize);
+ if (bytesRead < 0) {
+ p->setZipError((int) bytesRead);
+ return -1;
+ }
+ return bytesRead;
+}
+
+qint64 QuaZipFile::writeData(const char* data, qint64 maxSize)
+{
+ p->setZipError(ZIP_OK);
+ p->setZipError(zipWriteInFileInZip(p->zip->getZipFile(), data, (uint)maxSize));
+ if(p->zipError!=ZIP_OK) return -1;
+ else {
+ p->writePos+=maxSize;
+ return maxSize;
+ }
+}
+
+QString QuaZipFile::getFileName() const
+{
+ return p->fileName;
+}
+
+QuaZip::CaseSensitivity QuaZipFile::getCaseSensitivity() const
+{
+ return p->caseSensitivity;
+}
+
+bool QuaZipFile::isRaw() const
+{
+ return p->raw;
+}
+
+int QuaZipFile::getZipError() const
+{
+ return p->zipError;
+}
+
+qint64 QuaZipFile::bytesAvailable() const
+{
+ return size() - pos();
+}
+
+QByteArray QuaZipFile::getLocalExtraField()
+{
+ int size = unzGetLocalExtrafield(p->zip->getUnzFile(), NULL, 0);
+ QByteArray extra(size, '\0');
+ int err = unzGetLocalExtrafield(p->zip->getUnzFile(), extra.data(), static_cast<uint>(extra.size()));
+ if (err < 0) {
+ p->setZipError(err);
+ return QByteArray();
+ }
+ return extra;
+}
+
+QDateTime QuaZipFile::getExtModTime()
+{
+ return QuaZipFileInfo64::getExtTime(getLocalExtraField(), QUAZIP_EXTRA_EXT_MOD_TIME_FLAG);
+}
+
+QDateTime QuaZipFile::getExtAcTime()
+{
+ return QuaZipFileInfo64::getExtTime(getLocalExtraField(), QUAZIP_EXTRA_EXT_AC_TIME_FLAG);
+}
+
+QDateTime QuaZipFile::getExtCrTime()
+{
+ return QuaZipFileInfo64::getExtTime(getLocalExtraField(), QUAZIP_EXTRA_EXT_CR_TIME_FLAG);
+}