From c876d3bbefe0dc00c27ca0c12d29da5874946962 Mon Sep 17 00:00:00 2001 From: Dominik Riebeling Date: Wed, 15 Dec 2021 21:04:28 +0100 Subject: rbutil: Merge rbutil with utils folder. rbutil uses several components from the utils folder, and can be considered part of utils too. Having it in a separate folder is an arbitrary split that doesn't help anymore these days, so merge them. This also allows other utils to easily use libtools.make without the need to navigate to a different folder. Change-Id: I3fc2f4de19e3e776553efb5dea5f779dfec0dc21 --- utils/rbutilqt/quazip/quazip.cpp | 846 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 846 insertions(+) create mode 100644 utils/rbutilqt/quazip/quazip.cpp (limited to 'utils/rbutilqt/quazip/quazip.cpp') diff --git a/utils/rbutilqt/quazip/quazip.cpp b/utils/rbutilqt/quazip/quazip.cpp new file mode 100644 index 0000000000..61c2ea87eb --- /dev/null +++ b/utils/rbutilqt/quazip/quazip.cpp @@ -0,0 +1,846 @@ +/* +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 . + +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 +#include +#include + +#include "quazip.h" + +#define QUAZIP_OS_UNIX 3u + +/// All the internal stuff for the QuaZip class. +/** + \internal + + This class keeps all the private stuff for the QuaZip class so it can + be changed without breaking binary compatibility, according to the + Pimpl idiom. + */ +class QuaZipPrivate { + friend class QuaZip; + private: + Q_DISABLE_COPY(QuaZipPrivate) + /// The pointer to the corresponding QuaZip instance. + QuaZip *q; + /// The codec for file names (used when UTF-8 is not enabled). + QTextCodec *fileNameCodec; + /// The codec for comments (used when UTF-8 is not enabled). + QTextCodec *commentCodec; + /// The archive file name. + QString zipName; + /// The device to access the archive. + QIODevice *ioDevice; + /// The global comment. + QString comment; + /// The open mode. + QuaZip::Mode mode; + union { + /// The internal handle for UNZIP modes. + unzFile unzFile_f; + /// The internal handle for ZIP modes. + zipFile zipFile_f; + }; + /// Whether a current file is set. + bool hasCurrentFile_f; + /// The last error. + int zipError; + /// Whether \ref QuaZip::setDataDescriptorWritingEnabled() "the data descriptor writing mode" is enabled. + bool dataDescriptorWritingEnabled; + /// The zip64 mode. + bool zip64; + /// The auto-close flag. + bool autoClose; + /// The UTF-8 flag. + bool utf8; + /// The OS code. + uint osCode; + inline QTextCodec *getDefaultFileNameCodec() + { + if (defaultFileNameCodec == NULL) { + return QTextCodec::codecForLocale(); + } else { + return defaultFileNameCodec; + } + } + /// The constructor for the corresponding QuaZip constructor. + inline QuaZipPrivate(QuaZip *q): + q(q), + fileNameCodec(getDefaultFileNameCodec()), + commentCodec(QTextCodec::codecForLocale()), + ioDevice(NULL), + mode(QuaZip::mdNotOpen), + hasCurrentFile_f(false), + zipError(UNZ_OK), + dataDescriptorWritingEnabled(true), + zip64(false), + autoClose(true), + utf8(false), + osCode(defaultOsCode) + { + unzFile_f = NULL; + zipFile_f = NULL; + lastMappedDirectoryEntry.num_of_file = 0; + lastMappedDirectoryEntry.pos_in_zip_directory = 0; + } + /// The constructor for the corresponding QuaZip constructor. + inline QuaZipPrivate(QuaZip *q, const QString &zipName): + q(q), + fileNameCodec(getDefaultFileNameCodec()), + commentCodec(QTextCodec::codecForLocale()), + zipName(zipName), + ioDevice(NULL), + mode(QuaZip::mdNotOpen), + hasCurrentFile_f(false), + zipError(UNZ_OK), + dataDescriptorWritingEnabled(true), + zip64(false), + autoClose(true), + utf8(false), + osCode(defaultOsCode) + { + unzFile_f = NULL; + zipFile_f = NULL; + lastMappedDirectoryEntry.num_of_file = 0; + lastMappedDirectoryEntry.pos_in_zip_directory = 0; + } + /// The constructor for the corresponding QuaZip constructor. + inline QuaZipPrivate(QuaZip *q, QIODevice *ioDevice): + q(q), + fileNameCodec(getDefaultFileNameCodec()), + commentCodec(QTextCodec::codecForLocale()), + ioDevice(ioDevice), + mode(QuaZip::mdNotOpen), + hasCurrentFile_f(false), + zipError(UNZ_OK), + dataDescriptorWritingEnabled(true), + zip64(false), + autoClose(true), + utf8(false), + osCode(defaultOsCode) + { + unzFile_f = NULL; + zipFile_f = NULL; + lastMappedDirectoryEntry.num_of_file = 0; + lastMappedDirectoryEntry.pos_in_zip_directory = 0; + } + /// Returns either a list of file names or a list of QuaZipFileInfo. + template + bool getFileInfoList(QList *result) const; + + /// Stores map of filenames and file locations for unzipping + inline void clearDirectoryMap(); + inline void addCurrentFileToDirectoryMap(const QString &fileName); + bool goToFirstUnmappedFile(); + QHash directoryCaseSensitive; + QHash directoryCaseInsensitive; + unz64_file_pos lastMappedDirectoryEntry; + static QTextCodec *defaultFileNameCodec; + static uint defaultOsCode; +}; + +QTextCodec *QuaZipPrivate::defaultFileNameCodec = NULL; +uint QuaZipPrivate::defaultOsCode = QUAZIP_OS_UNIX; + +void QuaZipPrivate::clearDirectoryMap() +{ + directoryCaseInsensitive.clear(); + directoryCaseSensitive.clear(); + lastMappedDirectoryEntry.num_of_file = 0; + lastMappedDirectoryEntry.pos_in_zip_directory = 0; +} + +void QuaZipPrivate::addCurrentFileToDirectoryMap(const QString &fileName) +{ + if (!hasCurrentFile_f || fileName.isEmpty()) { + return; + } + // Adds current file to filename map as fileName + unz64_file_pos fileDirectoryPos; + unzGetFilePos64(unzFile_f, &fileDirectoryPos); + directoryCaseSensitive.insert(fileName, fileDirectoryPos); + // Only add lowercase to directory map if not already there + // ensures only map the first one seen + QString lower = fileName.toLower(); + if (!directoryCaseInsensitive.contains(lower)) + directoryCaseInsensitive.insert(lower, fileDirectoryPos); + // Mark last one + if (fileDirectoryPos.pos_in_zip_directory > lastMappedDirectoryEntry.pos_in_zip_directory) + lastMappedDirectoryEntry = fileDirectoryPos; +} + +bool QuaZipPrivate::goToFirstUnmappedFile() +{ + zipError = UNZ_OK; + if (mode != QuaZip::mdUnzip) { + qWarning("QuaZipPrivate::goToNextUnmappedFile(): ZIP is not open in mdUnzip mode"); + return false; + } + // If not mapped anything, go to beginning + if (lastMappedDirectoryEntry.pos_in_zip_directory == 0) { + unzGoToFirstFile(unzFile_f); + } else { + // Goto the last one mapped, plus one + unzGoToFilePos64(unzFile_f, &lastMappedDirectoryEntry); + unzGoToNextFile(unzFile_f); + } + hasCurrentFile_f=zipError==UNZ_OK; + if(zipError==UNZ_END_OF_LIST_OF_FILE) + zipError=UNZ_OK; + return hasCurrentFile_f; +} + +QuaZip::QuaZip(): + p(new QuaZipPrivate(this)) +{ +} + +QuaZip::QuaZip(const QString& zipName): + p(new QuaZipPrivate(this, zipName)) +{ +} + +QuaZip::QuaZip(QIODevice *ioDevice): + p(new QuaZipPrivate(this, ioDevice)) +{ +} + +QuaZip::~QuaZip() +{ + if(isOpen()) + close(); + delete p; +} + +bool QuaZip::open(Mode mode, zlib_filefunc_def* ioApi) +{ + p->zipError=UNZ_OK; + if(isOpen()) { + qWarning("QuaZip::open(): ZIP already opened"); + return false; + } + QIODevice *ioDevice = p->ioDevice; + if (ioDevice == NULL) { + if (p->zipName.isEmpty()) { + qWarning("QuaZip::open(): set either ZIP file name or IO device first"); + return false; + } else { + ioDevice = new QFile(p->zipName); + } + } + unsigned flags = 0; + switch(mode) { + case mdUnzip: + if (ioApi == NULL) { + if (p->autoClose) + flags |= UNZ_AUTO_CLOSE; + p->unzFile_f=unzOpenInternal(ioDevice, NULL, 1, flags); + } else { + // QuaZIP pre-zip64 compatibility mode + p->unzFile_f=unzOpen2(ioDevice, ioApi); + if (p->unzFile_f != NULL) { + if (p->autoClose) { + unzSetFlags(p->unzFile_f, UNZ_AUTO_CLOSE); + } else { + unzClearFlags(p->unzFile_f, UNZ_AUTO_CLOSE); + } + } + } + if(p->unzFile_f!=NULL) { + if (ioDevice->isSequential()) { + unzClose(p->unzFile_f); + if (!p->zipName.isEmpty()) + delete ioDevice; + qWarning("QuaZip::open(): " + "only mdCreate can be used with " + "sequential devices"); + return false; + } + p->mode=mode; + p->ioDevice = ioDevice; + return true; + } else { + p->zipError=UNZ_OPENERROR; + if (!p->zipName.isEmpty()) + delete ioDevice; + return false; + } + case mdCreate: + case mdAppend: + case mdAdd: + if (ioApi == NULL) { + if (p->autoClose) + flags |= ZIP_AUTO_CLOSE; + if (p->dataDescriptorWritingEnabled) + flags |= ZIP_WRITE_DATA_DESCRIPTOR; + if (p->utf8) + flags |= ZIP_ENCODING_UTF8; + p->zipFile_f=zipOpen3(ioDevice, + mode==mdCreate?APPEND_STATUS_CREATE: + mode==mdAppend?APPEND_STATUS_CREATEAFTER: + APPEND_STATUS_ADDINZIP, + NULL, NULL, flags); + } else { + // QuaZIP pre-zip64 compatibility mode + p->zipFile_f=zipOpen2(ioDevice, + mode==mdCreate?APPEND_STATUS_CREATE: + mode==mdAppend?APPEND_STATUS_CREATEAFTER: + APPEND_STATUS_ADDINZIP, + NULL, + ioApi); + if (p->zipFile_f != NULL) { + zipSetFlags(p->zipFile_f, flags); + } + } + if(p->zipFile_f!=NULL) { + if (ioDevice->isSequential()) { + if (mode != mdCreate) { + zipClose(p->zipFile_f, NULL); + qWarning("QuaZip::open(): " + "only mdCreate can be used with " + "sequential devices"); + if (!p->zipName.isEmpty()) + delete ioDevice; + return false; + } + zipSetFlags(p->zipFile_f, ZIP_SEQUENTIAL); + } + p->mode=mode; + p->ioDevice = ioDevice; + return true; + } else { + p->zipError=UNZ_OPENERROR; + if (!p->zipName.isEmpty()) + delete ioDevice; + return false; + } + default: + qWarning("QuaZip::open(): unknown mode: %d", (int)mode); + if (!p->zipName.isEmpty()) + delete ioDevice; + return false; + break; + } +} + +void QuaZip::close() +{ + p->zipError=UNZ_OK; + switch(p->mode) { + case mdNotOpen: + qWarning("QuaZip::close(): ZIP is not open"); + return; + case mdUnzip: + p->zipError=unzClose(p->unzFile_f); + break; + case mdCreate: + case mdAppend: + case mdAdd: + p->zipError=zipClose(p->zipFile_f, p->comment.isNull() ? NULL : isUtf8Enabled() + ? p->comment.toUtf8().constData() + : p->commentCodec->fromUnicode(p->comment).constData()); + break; + default: + qWarning("QuaZip::close(): unknown mode: %d", (int)p->mode); + return; + } + // opened by name, need to delete the internal IO device + if (!p->zipName.isEmpty()) { + delete p->ioDevice; + p->ioDevice = NULL; + } + p->clearDirectoryMap(); + if(p->zipError==UNZ_OK) + p->mode=mdNotOpen; +} + +void QuaZip::setZipName(const QString& zipName) +{ + if(isOpen()) { + qWarning("QuaZip::setZipName(): ZIP is already open!"); + return; + } + p->zipName=zipName; + p->ioDevice = NULL; +} + +void QuaZip::setIoDevice(QIODevice *ioDevice) +{ + if(isOpen()) { + qWarning("QuaZip::setIoDevice(): ZIP is already open!"); + return; + } + p->ioDevice = ioDevice; + p->zipName = QString(); +} + +int QuaZip::getEntriesCount()const +{ + QuaZip *fakeThis=(QuaZip*)this; // non-const + fakeThis->p->zipError=UNZ_OK; + if(p->mode!=mdUnzip) { + qWarning("QuaZip::getEntriesCount(): ZIP is not open in mdUnzip mode"); + return -1; + } + unz_global_info64 globalInfo; + if((fakeThis->p->zipError=unzGetGlobalInfo64(p->unzFile_f, &globalInfo))!=UNZ_OK) + return p->zipError; + return (int)globalInfo.number_entry; +} + +QString QuaZip::getComment()const +{ + QuaZip *fakeThis=(QuaZip*)this; // non-const + fakeThis->p->zipError=UNZ_OK; + if(p->mode!=mdUnzip) { + qWarning("QuaZip::getComment(): ZIP is not open in mdUnzip mode"); + return QString(); + } + unz_global_info64 globalInfo; + QByteArray comment; + if((fakeThis->p->zipError=unzGetGlobalInfo64(p->unzFile_f, &globalInfo))!=UNZ_OK) + return QString(); + comment.resize(globalInfo.size_comment); + if((fakeThis->p->zipError=unzGetGlobalComment(p->unzFile_f, comment.data(), comment.size())) < 0) + return QString(); + fakeThis->p->zipError = UNZ_OK; + unsigned flags = 0; + return (unzGetFileFlags(p->unzFile_f, &flags) == UNZ_OK) && (flags & UNZ_ENCODING_UTF8) + ? QString::fromUtf8(comment) : p->commentCodec->toUnicode(comment); +} + +bool QuaZip::setCurrentFile(const QString& fileName, CaseSensitivity cs) +{ + p->zipError=UNZ_OK; + if(p->mode!=mdUnzip) { + qWarning("QuaZip::setCurrentFile(): ZIP is not open in mdUnzip mode"); + return false; + } + if(fileName.isEmpty()) { + p->hasCurrentFile_f=false; + return true; + } + // Unicode-aware reimplementation of the unzLocateFile function + if(p->unzFile_f==NULL) { + p->zipError=UNZ_PARAMERROR; + return false; + } + if(fileName.length()>MAX_FILE_NAME_LENGTH) { + p->zipError=UNZ_PARAMERROR; + return false; + } + // Find the file by name + bool sens = convertCaseSensitivity(cs) == Qt::CaseSensitive; + QString lower, current; + if(!sens) lower=fileName.toLower(); + p->hasCurrentFile_f=false; + + // Check the appropriate Map + unz64_file_pos fileDirPos; + fileDirPos.pos_in_zip_directory = 0; + if (sens) { + if (p->directoryCaseSensitive.contains(fileName)) + fileDirPos = p->directoryCaseSensitive.value(fileName); + } else { + if (p->directoryCaseInsensitive.contains(lower)) + fileDirPos = p->directoryCaseInsensitive.value(lower); + } + + if (fileDirPos.pos_in_zip_directory != 0) { + p->zipError = unzGoToFilePos64(p->unzFile_f, &fileDirPos); + p->hasCurrentFile_f = p->zipError == UNZ_OK; + } + + if (p->hasCurrentFile_f) + return p->hasCurrentFile_f; + + // Not mapped yet, start from where we have got to so far + for(bool more=p->goToFirstUnmappedFile(); more; more=goToNextFile()) { + current=getCurrentFileName(); + if(current.isEmpty()) return false; + if(sens) { + if(current==fileName) break; + } else { + if(current.toLower()==lower) break; + } + } + return p->hasCurrentFile_f; +} + +bool QuaZip::goToFirstFile() +{ + p->zipError=UNZ_OK; + if(p->mode!=mdUnzip) { + qWarning("QuaZip::goToFirstFile(): ZIP is not open in mdUnzip mode"); + return false; + } + p->zipError=unzGoToFirstFile(p->unzFile_f); + p->hasCurrentFile_f=p->zipError==UNZ_OK; + return p->hasCurrentFile_f; +} + +bool QuaZip::goToNextFile() +{ + p->zipError=UNZ_OK; + if(p->mode!=mdUnzip) { + qWarning("QuaZip::goToFirstFile(): ZIP is not open in mdUnzip mode"); + return false; + } + p->zipError=unzGoToNextFile(p->unzFile_f); + p->hasCurrentFile_f=p->zipError==UNZ_OK; + if(p->zipError==UNZ_END_OF_LIST_OF_FILE) + p->zipError=UNZ_OK; + return p->hasCurrentFile_f; +} + +bool QuaZip::getCurrentFileInfo(QuaZipFileInfo *info)const +{ + QuaZipFileInfo64 info64; + if (info == NULL) { // Very unlikely because of the overloads + return false; + } + if (getCurrentFileInfo(&info64)) { + info64.toQuaZipFileInfo(*info); + return true; + } else { + return false; + } +} + +bool QuaZip::getCurrentFileInfo(QuaZipFileInfo64 *info)const +{ + QuaZip *fakeThis=(QuaZip*)this; // non-const + fakeThis->p->zipError=UNZ_OK; + if(p->mode!=mdUnzip) { + qWarning("QuaZip::getCurrentFileInfo(): ZIP is not open in mdUnzip mode"); + return false; + } + unz_file_info64 info_z; + QByteArray fileName; + QByteArray extra; + QByteArray comment; + if(info==NULL) return false; + if(!isOpen()||!hasCurrentFile()) return false; + if((fakeThis->p->zipError=unzGetCurrentFileInfo64(p->unzFile_f, &info_z, NULL, 0, NULL, 0, NULL, 0))!=UNZ_OK) + return false; + fileName.resize(info_z.size_filename); + extra.resize(info_z.size_file_extra); + comment.resize(info_z.size_file_comment); + if((fakeThis->p->zipError=unzGetCurrentFileInfo64(p->unzFile_f, NULL, + fileName.data(), fileName.size(), + extra.data(), extra.size(), + comment.data(), comment.size()))!=UNZ_OK) + return false; + info->versionCreated=info_z.version; + info->versionNeeded=info_z.version_needed; + info->flags=info_z.flag; + info->method=info_z.compression_method; + info->crc=info_z.crc; + info->compressedSize=info_z.compressed_size; + info->uncompressedSize=info_z.uncompressed_size; + info->diskNumberStart=info_z.disk_num_start; + info->internalAttr=info_z.internal_fa; + info->externalAttr=info_z.external_fa; + info->name=(info->flags & UNZ_ENCODING_UTF8) ? QString::fromUtf8(fileName) : p->fileNameCodec->toUnicode(fileName); + info->comment=(info->flags & UNZ_ENCODING_UTF8) ? QString::fromUtf8(comment) : p->commentCodec->toUnicode(comment); + info->extra=extra; + info->dateTime=QDateTime( + QDate(info_z.tmu_date.tm_year, info_z.tmu_date.tm_mon+1, info_z.tmu_date.tm_mday), + QTime(info_z.tmu_date.tm_hour, info_z.tmu_date.tm_min, info_z.tmu_date.tm_sec)); + // Add to directory map + p->addCurrentFileToDirectoryMap(info->name); + return true; +} + +QString QuaZip::getCurrentFileName()const +{ + QuaZip *fakeThis=(QuaZip*)this; // non-const + fakeThis->p->zipError=UNZ_OK; + if(p->mode!=mdUnzip) { + qWarning("QuaZip::getCurrentFileName(): ZIP is not open in mdUnzip mode"); + return QString(); + } + if(!isOpen()||!hasCurrentFile()) return QString(); + QByteArray fileName(MAX_FILE_NAME_LENGTH, 0); + unz_file_info64 file_info; + if((fakeThis->p->zipError=unzGetCurrentFileInfo64(p->unzFile_f, &file_info, fileName.data(), fileName.size(), + NULL, 0, NULL, 0))!=UNZ_OK) + return QString(); + fileName.resize(file_info.size_filename); + QString result = (file_info.flag & UNZ_ENCODING_UTF8) + ? QString::fromUtf8(fileName) : p->fileNameCodec->toUnicode(fileName); + if (result.isEmpty()) + return result; + // Add to directory map + p->addCurrentFileToDirectoryMap(result); + return result; +} + +void QuaZip::setFileNameCodec(QTextCodec *fileNameCodec) +{ + p->fileNameCodec=fileNameCodec; +} + +void QuaZip::setFileNameCodec(const char *fileNameCodecName) +{ + p->fileNameCodec=QTextCodec::codecForName(fileNameCodecName); +} + +void QuaZip::setOsCode(uint osCode) +{ + p->osCode = osCode; +} + +uint QuaZip::getOsCode() const +{ + return p->osCode; +} + +QTextCodec *QuaZip::getFileNameCodec()const +{ + return p->fileNameCodec; +} + +void QuaZip::setCommentCodec(QTextCodec *commentCodec) +{ + p->commentCodec=commentCodec; +} + +void QuaZip::setCommentCodec(const char *commentCodecName) +{ + p->commentCodec=QTextCodec::codecForName(commentCodecName); +} + +QTextCodec *QuaZip::getCommentCodec()const +{ + return p->commentCodec; +} + +QString QuaZip::getZipName() const +{ + return p->zipName; +} + +QIODevice *QuaZip::getIoDevice() const +{ + if (!p->zipName.isEmpty()) // opened by name, using an internal QIODevice + return NULL; + return p->ioDevice; +} + +QuaZip::Mode QuaZip::getMode()const +{ + return p->mode; +} + +bool QuaZip::isOpen()const +{ + return p->mode!=mdNotOpen; +} + +int QuaZip::getZipError() const +{ + return p->zipError; +} + +void QuaZip::setComment(const QString& comment) +{ + p->comment=comment; +} + +bool QuaZip::hasCurrentFile()const +{ + return p->hasCurrentFile_f; +} + +unzFile QuaZip::getUnzFile() +{ + return p->unzFile_f; +} + +zipFile QuaZip::getZipFile() +{ + return p->zipFile_f; +} + +void QuaZip::setDataDescriptorWritingEnabled(bool enabled) +{ + p->dataDescriptorWritingEnabled = enabled; +} + +bool QuaZip::isDataDescriptorWritingEnabled() const +{ + return p->dataDescriptorWritingEnabled; +} + +template +TFileInfo QuaZip_getFileInfo(QuaZip *zip, bool *ok); + +template<> +QuaZipFileInfo QuaZip_getFileInfo(QuaZip *zip, bool *ok) +{ + QuaZipFileInfo info; + *ok = zip->getCurrentFileInfo(&info); + return info; +} + +template<> +QuaZipFileInfo64 QuaZip_getFileInfo(QuaZip *zip, bool *ok) +{ + QuaZipFileInfo64 info; + *ok = zip->getCurrentFileInfo(&info); + return info; +} + +template<> +QString QuaZip_getFileInfo(QuaZip *zip, bool *ok) +{ + QString name = zip->getCurrentFileName(); + *ok = !name.isEmpty(); + return name; +} + +template +bool QuaZipPrivate::getFileInfoList(QList *result) const +{ + QuaZipPrivate *fakeThis=const_cast(this); + fakeThis->zipError=UNZ_OK; + if (mode!=QuaZip::mdUnzip) { + qWarning("QuaZip::getFileNameList/getFileInfoList(): " + "ZIP is not open in mdUnzip mode"); + return false; + } + QString currentFile; + if (q->hasCurrentFile()) { + currentFile = q->getCurrentFileName(); + } + if (q->goToFirstFile()) { + do { + bool ok; + result->append(QuaZip_getFileInfo(q, &ok)); + if (!ok) + return false; + } while (q->goToNextFile()); + } + if (zipError != UNZ_OK) + return false; + if (currentFile.isEmpty()) { + if (!q->goToFirstFile()) + return false; + } else { + if (!q->setCurrentFile(currentFile)) + return false; + } + return true; +} + +QStringList QuaZip::getFileNameList() const +{ + QStringList list; + if (p->getFileInfoList(&list)) + return list; + else + return QStringList(); +} + +QList QuaZip::getFileInfoList() const +{ + QList list; + if (p->getFileInfoList(&list)) + return list; + else + return QList(); +} + +QList QuaZip::getFileInfoList64() const +{ + QList list; + if (p->getFileInfoList(&list)) + return list; + else + return QList(); +} + +Qt::CaseSensitivity QuaZip::convertCaseSensitivity(QuaZip::CaseSensitivity cs) +{ + if (cs == csDefault) { +#ifdef Q_OS_WIN + return Qt::CaseInsensitive; +#else + return Qt::CaseSensitive; +#endif + } else { + return cs == csSensitive ? Qt::CaseSensitive : Qt::CaseInsensitive; + } +} + +void QuaZip::setDefaultFileNameCodec(QTextCodec *codec) +{ + QuaZipPrivate::defaultFileNameCodec = codec; +} + +void QuaZip::setDefaultFileNameCodec(const char *codecName) +{ + setDefaultFileNameCodec(QTextCodec::codecForName(codecName)); +} + +void QuaZip::setDefaultOsCode(uint osCode) +{ + QuaZipPrivate::defaultOsCode = osCode; +} + +uint QuaZip::getDefaultOsCode() +{ + return QuaZipPrivate::defaultOsCode; +} + +void QuaZip::setZip64Enabled(bool zip64) +{ + p->zip64 = zip64; +} + +bool QuaZip::isZip64Enabled() const +{ + return p->zip64; +} + +void QuaZip::setUtf8Enabled(bool utf8) +{ + p->utf8 = utf8; +} + +bool QuaZip::isUtf8Enabled() const +{ + return p->utf8; +} + +bool QuaZip::isAutoClose() const +{ + return p->autoClose; +} + +void QuaZip::setAutoClose(bool autoClose) const +{ + p->autoClose = autoClose; +} -- cgit v1.2.3