ZIP archive. More...

#include <quazip/quazip.h>

Collaboration diagram for QuaZip:

Public Types
enum	Constants { MAX_FILE_NAME_LENGTH =256 }
	Useful constants. More...

enum	Mode { mdNotOpen, mdUnzip, mdCreate, mdAppend, mdAdd }
	Open mode of the ZIP file. More...

enum	CaseSensitivity { csDefault =0, csSensitive =1, csInsensitive =2 }
	Case sensitivity for the file names. More...

Public Member Functions
	QuaZip ()
	Constructs QuaZip object. More...

	QuaZip (const QString &zipName)
	Constructs QuaZip object associated with ZIP file zipName. More...

	QuaZip (QIODevice *ioDevice)
	Constructs QuaZip object associated with ZIP file represented by ioDevice. More...

	~QuaZip ()
	Destroys QuaZip object. More...

bool	open (Mode mode, zlib_filefunc_def *ioApi=NULL)
	Opens ZIP file. More...

void	close ()
	Closes ZIP file. More...

void	setFileNameCodec (QTextCodec *fileNameCodec)
	Sets the codec used to encode/decode file names inside archive. More...

void	setFileNameCodec (const char *fileNameCodecName)
	Sets the codec used to encode/decode file names inside archive. More...

QTextCodec *	getFileNameCodec () const
	Returns the codec used to encode/decode comments inside archive. More...

void	setCommentCodec (QTextCodec *commentCodec)
	Sets the codec used to encode/decode comments inside archive. More...

void	setCommentCodec (const char *commentCodecName)
	Sets the codec used to encode/decode comments inside archive. More...

QTextCodec *	getCommentCodec () const
	Returns the codec used to encode/decode comments inside archive. More...

QString	getZipName () const
	Returns the name of the ZIP file. More...

void	setZipName (const QString &zipName)
	Sets the name of the ZIP file. More...

QIODevice *	getIoDevice () const
	Returns the device representing this ZIP file. More...

void	setIoDevice (QIODevice *ioDevice)
	Sets the device representing the ZIP file. More...

Mode	getMode () const
	Returns the mode in which ZIP file was opened. More...

bool	isOpen () const
	Returns `true` if ZIP file is open, `false` otherwise. More...

int	getZipError () const
	Returns the error code of the last operation. More...

int	getEntriesCount () const
	Returns number of the entries in the ZIP central directory. More...

QString	getComment () const
	Returns global comment in the ZIP file. More...

void	setComment (const QString &comment)
	Sets the global comment in the ZIP file. More...

bool	goToFirstFile ()
	Sets the current file to the first file in the archive. More...

bool	goToNextFile ()
	Sets the current file to the next file in the archive. More...

bool	setCurrentFile (const QString &fileName, CaseSensitivity cs=csDefault)
	Sets current file by its name. More...

bool	hasCurrentFile () const
	Returns `true` if the current file has been set. More...

bool	getCurrentFileInfo (QuaZipFileInfo *info) const
	Retrieves information about the current file. More...

bool	getCurrentFileInfo (QuaZipFileInfo64 *info) const
	Retrieves information about the current file. More...

QString	getCurrentFileName () const
	Returns the current file name. More...

unzFile	getUnzFile ()
	Returns `unzFile` handle. More...

zipFile	getZipFile ()
	Returns `zipFile` handle. More...

void	setDataDescriptorWritingEnabled (bool enabled)
	Changes the data descriptor writing mode. More...

bool	isDataDescriptorWritingEnabled () const
	Returns the data descriptor default writing mode. More...

QStringList	getFileNameList () const
	Returns a list of files inside the archive. More...

QList< QuaZipFileInfo >	getFileInfoList () const
	Returns information list about all files inside the archive. More...

QList< QuaZipFileInfo64 >	getFileInfoList64 () const
	Returns information list about all files inside the archive. More...

void	setZip64Enabled (bool zip64)
	Enables the zip64 mode. More...

bool	isZip64Enabled () const
	Returns whether the zip64 mode is enabled. More...

bool	isAutoClose () const
	Returns the auto-close flag. More...

void	setAutoClose (bool autoClose) const
	Sets or unsets the auto-close flag. More...

Static Public Member Functions
static Qt::CaseSensitivity	convertCaseSensitivity (CaseSensitivity cs)
	Returns the actual case sensitivity for the specified QuaZIP one. More...

static void	setDefaultFileNameCodec (QTextCodec *codec)
	Sets the default file name codec to use. More...

static void	setDefaultFileNameCodec (const char *codecName)
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. Equivalent to calling setDefltFileNameCodec(QTextCodec::codecForName(codecName)). More...

Private Member Functions
	QuaZip (const QuaZip &that)

QuaZip &	operator= (const QuaZip &that)

Private Attributes
QuaZipPrivate *	p

Friends
class	QuaZipPrivate

Detailed Description

This class implements basic interface to the ZIP archive. It can be used to read table contents of the ZIP archive and retreiving information about the files inside it.

You can also use this class to open files inside archive by passing pointer to the instance of this class to the constructor of the QuaZipFile class. But see QuaZipFile::QuaZipFile(QuaZip*, QObject*) for the possible pitfalls.

This class is indended to provide interface to the ZIP subpackage of the ZIP/UNZIP package as well as to the UNZIP subpackage. But currently it supports only UNZIP.

The use of this class is simple - just create instance using constructor, then set ZIP archive file name using setFile() function (if you did not passed the name to the constructor), then open() and then use different functions to work with it! Well, if you are paranoid, you may also wish to call close before destructing the instance, to check for errors on close.

You may also use getUnzFile() and getZipFile() functions to get the ZIP archive handle and use it with ZIP/UNZIP package API directly.

This class supports localized file names inside ZIP archive, but you have to set up proper codec with setCodec() function. By default, locale codec will be used, which is probably ok for UNIX systems, but will almost certainly fail with ZIP archives created in Windows. This is because Windows ZIP programs have strange habit of using DOS encoding for file names in ZIP archives. For example, ZIP archive with cyrillic names created in Windows will have file names in IBM866 encoding instead of WINDOWS-1251. I think that calling one function is not much trouble, but for true platform independency it would be nice to have some mechanism for file name encoding auto detection using locale information. Does anyone know a good way to do it?

Definition at line 84 of file quazip.h.

Member Enumeration Documentation

enum QuaZip::CaseSensitivity

This is what you specify when accessing files in the archive. Works perfectly fine with any characters thanks to Qt's great unicode support. This is different from ZIP/UNZIP API, where only US-ASCII characters was supported.

Enumerator
csDefault	Default for platform. Case sensitive for UNIX, not for Windows.
csSensitive	Case sensitive.
csInsensitive	Case insensitive.

Definition at line 114 of file quazip.h.

                          {
       csDefault=0, 
       csSensitive=1, 
       csInsensitive=2 
     };

enum QuaZip::Constants

Enumerator

MAX_FILE_NAME_LENGTH

Maximum file name length.

Taken from UNZ_MAXFILENAMEINZIP constant in unzip.c.

Definition at line 88 of file quazip.h.

                    {
       MAX_FILE_NAME_LENGTH=256 
     };

enum QuaZip::Mode

Enumerator
mdNotOpen	ZIP file is not open. This is the initial mode.
mdUnzip	ZIP file is open for reading files inside it.
mdCreate	ZIP file was created with open() call.
mdAppend	ZIP file was opened in append mode. This refers to `APPEND_STATUS_CREATEAFTER` mode in ZIP/UNZIP package and means that zip is appended to some existing file what is useful when that file contains self-extractor code. This is obviously not what you whant to use to add files to the existing ZIP archive.
mdAdd	ZIP file was opened for adding files in the archive.

Definition at line 94 of file quazip.h.

               {
       mdNotOpen, 
       mdUnzip, 
       mdCreate, 
       mdAppend, 
       mdAdd 
     };

Constructor & Destructor Documentation

QuaZip::QuaZip ( const QuaZip & that )

private

QuaZip::QuaZip ( )

Call setName() before opening constructed object.

Definition at line 193 of file quazip.cpp.

               :
   p(new QuaZipPrivate(this))
 {
 }

QuaZip::QuaZip ( const QString & zipName )

Definition at line 198 of file quazip.cpp.

                                     :
   p(new QuaZipPrivate(this, zipName))
 {
 }

QuaZip::QuaZip ( QIODevice * ioDevice )

The IO device must be seekable, otherwise an error will occur when opening.

Definition at line 203 of file quazip.cpp.

                                  :
   p(new QuaZipPrivate(this, ioDevice))
 {
 }

QuaZip::~QuaZip ( )

Calls close() if necessary.

Definition at line 208 of file quazip.cpp.

References close(), isOpen(), and p.

 {
   if(isOpen())
     close();
   delete p;
 }

Here is the call graph for this function:

Member Function Documentation

void QuaZip::close ( )

Call getZipError() to determine if the close was successful.

If the file was opened by name, then the underlying QIODevice is closed and deleted.

If the underlying QIODevice was set explicitly using setIoDevice() or the appropriate constructor, then it is closed if the auto-close flag is set (which it is by default). Call setAutoClose() to clear the auto-close flag if this behavior is undesirable.

Since Qt 5.1, the QSaveFile was introduced. It breaks the QIODevice API by making close() private and crashing the application if it is called from the base class where it is public. It is an excellent example of poor design that illustrates why you should never ever break an is-a relationship between the base class and a subclass. QuaZIP works around this bug by checking if the QIODevice is an instance of QSaveFile, using qobject_cast<>, and if it is, calls QSaveFile::commit() instead of close(). It is a really ugly hack, but at least it makes your programs work instead of crashing. Note that if the auto-close flag is cleared, then this is a non-issue, and commit() isn't called.

Definition at line 324 of file quazip.cpp.

References QuaZipPrivate::clearDirectoryMap(), QuaZipPrivate::comment, QuaZipPrivate::commentCodec, QuaZipPrivate::ioDevice, mdAdd, mdAppend, mdCreate, mdNotOpen, mdUnzip, QuaZipPrivate::mode, p, UNZ_OK, unzClose(), zipClose(), QuaZipPrivate::zipError, and QuaZipPrivate::zipName.

Referenced by QuaZipFile::close(), JlCompress::compressDir(), JlCompress::compressFile(), JlCompress::compressFiles(), JlCompress::extractDir(), JlCompress::extractFile(), JlCompress::extractFiles(), JlCompress::getFileList(), QuaZipFile::open(), and ~QuaZip().

 {
   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
           : 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;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

Qt::CaseSensitivity QuaZip::convertCaseSensitivity ( QuaZip::CaseSensitivity cs )

static

Parameters

cs	The value to convert.

Returns: If CaseSensitivity::csDefault, then returns the default file name case sensitivity for the platform. Otherwise, just returns the appropriate value from the Qt::CaseSensitivity enum.

Definition at line 747 of file quazip.cpp.

References csDefault, and csSensitive.

Referenced by QuaZipDir::exists(), and setCurrentFile().

 {
   if (cs == csDefault) {
 #ifdef Q_WS_WIN
       return Qt::CaseInsensitive;
 #else
       return Qt::CaseSensitive;
 #endif
   } else {
       return cs == csSensitive ? Qt::CaseSensitive : Qt::CaseInsensitive;
   }
 }

Here is the caller graph for this function:

QString QuaZip::getComment ( ) const

Definition at line 389 of file quazip.cpp.

References QuaZipPrivate::commentCodec, mdUnzip, QuaZipPrivate::mode, p, unz_global_info64_s::size_comment, UNZ_OK, unzGetGlobalComment(), unzGetGlobalInfo64(), and QuaZipPrivate::zipError.

 {
   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;
   return p->commentCodec->toUnicode(comment);
 }

Here is the call graph for this function:

QTextCodec * QuaZip::getCommentCodec ( ) const

Definition at line 597 of file quazip.cpp.

References QuaZipPrivate::commentCodec, and p.

Referenced by QuaZipFile::open().

 {
   return p->commentCodec;
 }

Here is the caller graph for this function:

bool QuaZip::getCurrentFileInfo ( QuaZipFileInfo * info ) const

Fills the structure pointed by info. Returns true on success, false otherwise. In the latter case structure pointed by info remains untouched. If there was an error, getZipError() returns error code.

Should be used only in QuaZip::mdUnzip mode.

Does nothing and returns false in any of the following cases.

ZIP is not open;
ZIP does not have current file.

In both cases getZipError() returns UNZ_OK since there is no ZIP/UNZIP API call.

This overload doesn't support zip64, but will work OK on zip64 archives except that if one of the sizes (compressed or uncompressed) is greater than 0xFFFFFFFFu, it will be set to exactly 0xFFFFFFFFu.

See Also: getCurrentFileInfo(QuaZipFileInfo64* info)const; QuaZipFileInfo64::toQuaZipFileInfo(QuaZipFileInfo&)const

Definition at line 492 of file quazip.cpp.

References QuaZipFileInfo64::toQuaZipFileInfo().

Referenced by JlCompress::extractFile(), QuaZipFile::getFileInfo(), JlCompress::getFileList(), QuaZip_getFileInfo(), and QuaZipDir_getFileInfo().

 {
     QuaZipFileInfo64 info64;
     if (info == NULL) { // Very unlikely because of the overloads
         return false;
     }
     if (getCurrentFileInfo(&info64)) {
         info64.toQuaZipFileInfo(*info);
         return true;
     } else {
         return false;
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool QuaZip::getCurrentFileInfo ( QuaZipFileInfo64 * info ) const

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

This function supports zip64. If the archive doesn't use zip64, it is completely equivalent to getCurrentFileInfo(QuaZipFileInfo* info) except for the argument type.

See Also

Definition at line 506 of file quazip.cpp.

 {
   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=p->fileNameCodec->toUnicode(fileName);
   info->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;
 }

Here is the call graph for this function:

QString QuaZip::getCurrentFileName ( ) const

Equivalent to calling getCurrentFileInfo() and then getting name field of the QuaZipFileInfo structure, but faster and more convenient.

Should be used only in QuaZip::mdUnzip mode.

Definition at line 551 of file quazip.cpp.

References QuaZipPrivate::addCurrentFileToDirectoryMap(), QuaZipPrivate::fileNameCodec, hasCurrentFile(), isOpen(), MAX_FILE_NAME_LENGTH, mdUnzip, QuaZipPrivate::mode, p, UNZ_OK, unzGetCurrentFileInfo64(), and QuaZipPrivate::zipError.

Referenced by JlCompress::extractDir(), QuaZipFile::getActualFileName(), QuaZipPrivate::getFileInfoList(), QuaZip_getFileInfo(), and setCurrentFile().

 {
   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);
   if((fakeThis->p->zipError=unzGetCurrentFileInfo64(p->unzFile_f, NULL, fileName.data(), fileName.size(),
       NULL, 0, NULL, 0))!=UNZ_OK)
     return QString();
   QString result = p->fileNameCodec->toUnicode(fileName.constData());
   if (result.isEmpty())
       return result;
   // Add to directory map
   p->addCurrentFileToDirectoryMap(result);
   return result;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

int QuaZip::getEntriesCount ( ) const

Returns negative error code in the case of error. The same error code will be returned by subsequent getZipError() call.

Definition at line 375 of file quazip.cpp.

References mdUnzip, QuaZipPrivate::mode, unz_global_info64_s::number_entry, p, UNZ_OK, unzGetGlobalInfo64(), and QuaZipPrivate::zipError.

 {
   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;
 }

Here is the call graph for this function:

QList< QuaZipFileInfo > QuaZip::getFileInfoList ( ) const

Returns: A list of QuaZipFileInfo objects or an empty list if there was an error or if the archive is empty (call getZipError() to figure out which).

This function doesn't support zip64, but will still work with zip64 archives, converting results using QuaZipFileInfo64::toQuaZipFileInfo(). If all file sizes are below 4 GB, it will work just fine.

See Also: getFileNameList(); getFileInfoList64()

Definition at line 729 of file quazip.cpp.

References QuaZipPrivate::getFileInfoList(), and p.

 {
     QList<QuaZipFileInfo> list;
     if (p->getFileInfoList(&list))
         return list;
     else
         return QList<QuaZipFileInfo>();
 }

Here is the call graph for this function:

QList< QuaZipFileInfo64 > QuaZip::getFileInfoList64 ( ) const

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

This function supports zip64.

See Also: getFileNameList(); getFileInfoList()

Definition at line 738 of file quazip.cpp.

References QuaZipPrivate::getFileInfoList(), and p.

 {
     QList<QuaZipFileInfo64> list;
     if (p->getFileInfoList(&list))
         return list;
     else
         return QList<QuaZipFileInfo64>();
 }

Here is the call graph for this function:

QTextCodec * QuaZip::getFileNameCodec ( ) const

Definition at line 582 of file quazip.cpp.

References QuaZipPrivate::fileNameCodec, and p.

Referenced by QuaZipFile::open().

 {
   return p->fileNameCodec;
 }

Here is the caller graph for this function:

QStringList QuaZip::getFileNameList ( ) const

Returns: A list of file names or an empty list if there was an error or if the archive is empty (call getZipError() to figure out which).

See Also: getFileInfoList()

Definition at line 720 of file quazip.cpp.

References QuaZipPrivate::getFileInfoList(), and p.

 {
     QStringList list;
     if (p->getFileInfoList(&list))
         return list;
     else
         return QStringList();
 }

Here is the call graph for this function:

QIODevice * QuaZip::getIoDevice ( ) const

Returns null string if no device has been set explicitly, for example when opening a ZIP file by name.

See Also: setIoDevice(), getZipName(), setZipName()

Definition at line 607 of file quazip.cpp.

References QuaZipPrivate::ioDevice, p, and QuaZipPrivate::zipName.

 {
   if (!p->zipName.isEmpty()) // opened by name, using an internal QIODevice
     return NULL;
   return p->ioDevice;
 }

QuaZip::Mode QuaZip::getMode ( ) const

Definition at line 614 of file quazip.cpp.

References QuaZipPrivate::mode, and p.

Referenced by JlCompress::compressFile(), JlCompress::compressSubDir(), QuaZipFile::csize(), JlCompress::extractFile(), QuaZipFile::getFileInfo(), QuaZipFile::open(), and QuaZipFile::usize().

 {
   return p->mode;
 }

Here is the caller graph for this function:

unzFile QuaZip::getUnzFile ( )

You can use this handle to directly call UNZIP part of the ZIP/UNZIP package functions (see unzip.h).

Warning: When using the handle returned by this function, please keep in mind that QuaZip class is unable to detect any changes you make in the ZIP file state (e. g. changing current file, or closing the handle). So please do not do anything with this handle that is possible to do with the functions of this class. Or at least return the handle in the original state before calling some another function of this class (including implicit destructor calls and calls from the QuaZipFile objects that refer to this QuaZip instance!). So if you have changed the current file in the ZIP archive - then change it back or you may experience some strange behavior or even crashes.

Definition at line 639 of file quazip.cpp.

References p.

Referenced by QuaZipFile::atEnd(), QuaZipFile::close(), QuaZipFile::csize(), QuaZipFile::open(), QuaZipFile::pos(), QuaZipFile::readData(), and QuaZipFile::usize().

 {
   return p->unzFile_f;
 }

Here is the caller graph for this function:

int QuaZip::getZipError ( ) const

Returns UNZ_OK if the last operation was successful.

Error code resets to UNZ_OK every time you call any function that accesses something inside ZIP archive, even if it is const (like getEntriesCount()). open() and close() calls reset error code too. See documentation for the specific functions for details on error detection.

Definition at line 624 of file quazip.cpp.

References p, and QuaZipPrivate::zipError.

Referenced by QuaZipFile::close(), JlCompress::compressDir(), JlCompress::compressFile(), JlCompress::compressFiles(), JlCompress::extractDir(), JlCompress::extractFile(), JlCompress::extractFiles(), QuaZipFile::getActualFileName(), QuaZipFile::getFileInfo(), JlCompress::getFileList(), and QuaZipFile::open().

 {
   return p->zipError;
 }

Here is the caller graph for this function:

zipFile QuaZip::getZipFile ( )

You can use this handle to directly call ZIP part of the ZIP/UNZIP package functions (see zip.h). Warnings about the getUnzFile() function also apply to this function.

Definition at line 644 of file quazip.cpp.

References p.

Referenced by QuaZipFile::close(), QuaZipFile::open(), and QuaZipFile::writeData().

 {
   return p->zipFile_f;
 }

Here is the caller graph for this function:

QString QuaZip::getZipName ( ) const

Returns null string if no ZIP file name has been set, for example when the QuaZip instance is set up to use a QIODevice instead.

See Also: setZipName(), setIoDevice(), getIoDevice()

Definition at line 602 of file quazip.cpp.

References p, and QuaZipPrivate::zipName.

Referenced by JlCompress::compressSubDir(), and QuaZipFile::getZipName().

 {
   return p->zipName;
 }

Here is the caller graph for this function:

bool QuaZip::goToFirstFile ( )

Returns true on success, false otherwise. Call getZipError() to get the error code.

Definition at line 466 of file quazip.cpp.

References QuaZipPrivate::hasCurrentFile_f, mdUnzip, QuaZipPrivate::mode, p, UNZ_OK, unzGoToFirstFile(), and QuaZipPrivate::zipError.

Referenced by JlCompress::extractDir(), QuaZipPrivate::getFileInfoList(), and JlCompress::getFileList().

 {
   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;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool QuaZip::goToNextFile ( )

Returns true on success, false otherwise. Call getZipError() to determine if there was an error.

Should be used only in QuaZip::mdUnzip mode.

Note: If the end of file was reached, getZipError() will return UNZ_OK instead of UNZ_END_OF_LIST_OF_FILE. This is to make things like this easier:
for(bool more=zip.goToFirstFile(); more; more=zip.goToNextFile()) {

// do something

}

if(zip.getZipError()==UNZ_OK) {

// ok, there was no error

}

Definition at line 478 of file quazip.cpp.

References QuaZipPrivate::hasCurrentFile_f, mdUnzip, QuaZipPrivate::mode, p, UNZ_END_OF_LIST_OF_FILE, UNZ_OK, unzGoToNextFile(), and QuaZipPrivate::zipError.

Referenced by JlCompress::extractDir(), QuaZipPrivate::getFileInfoList(), JlCompress::getFileList(), and setCurrentFile().

 {
   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;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool QuaZip::hasCurrentFile ( ) const

Definition at line 634 of file quazip.cpp.

References QuaZipPrivate::hasCurrentFile_f, and p.

Referenced by getCurrentFileInfo(), getCurrentFileName(), QuaZipPrivate::getFileInfoList(), and QuaZipFile::open().

 {
   return p->hasCurrentFile_f;
 }

Here is the caller graph for this function:

bool QuaZip::isAutoClose ( ) const

See Also: setAutoClose()

Definition at line 780 of file quazip.cpp.

References QuaZipPrivate::autoClose, and p.

 {
     return p->autoClose;
 }

bool QuaZip::isDataDescriptorWritingEnabled ( ) const

See Also: setDataDescriptorWritingEnabled()

Definition at line 654 of file quazip.cpp.

References QuaZipPrivate::dataDescriptorWritingEnabled, and p.

Referenced by QuaZipFile::open().

 {
     return p->dataDescriptorWritingEnabled;
 }

Here is the caller graph for this function:

bool QuaZip::isOpen ( ) const

Definition at line 619 of file quazip.cpp.

References mdNotOpen, QuaZipPrivate::mode, and p.

Referenced by QuaZipFile::close(), getCurrentFileInfo(), getCurrentFileName(), open(), setIoDevice(), setZipName(), and ~QuaZip().

 {
   return p->mode!=mdNotOpen;
 }

Here is the caller graph for this function:

bool QuaZip::isZip64Enabled ( ) const

Returns: true if and only if the zip64 mode is enabled.

See Also: setZip64Enabled()

Definition at line 775 of file quazip.cpp.

References p, and QuaZipPrivate::zip64.

Referenced by QuaZipFile::open().

 {
     return p->zip64;
 }

Here is the caller graph for this function:

bool QuaZip::open	(	Mode	mode,
		zlib_filefunc_def *	ioApi = `NULL`
	)

Argument mode specifies open mode of the ZIP archive. See Mode for details. Note that there is zipOpen2() function in the ZIP/UNZIP API which accepts globalcomment argument, but it does not use it anywhere, so this open() function does not have this argument. See setComment() if you need to set global comment.

If the ZIP file is accessed via explicitly set QIODevice, then this device is opened in the necessary mode. If the device was already opened by some other means, then QuaZIP checks if the open mode is compatible to the mode needed for the requested operation. If necessary, seeking is performed to position the device properly.

Returns: true if successful, false otherwise.

Note: ZIP/UNZIP API open calls do not return error code - they just return NULL indicating an error. But to make things easier, quazip.h header defines additional error code UNZ_ERROROPEN and getZipError() will return it if the open call of the ZIP/UNZIP API returns NULL.

Argument ioApi specifies IO function set for ZIP/UNZIP package to use. See unzip.h, zip.h and ioapi.h for details. Note that IO API for QuaZip is different from the original package. The file path argument was changed to be of type voidpf, and QuaZip passes a QIODevice pointer there. This QIODevice is either set explicitly via setIoDevice() or the QuaZip(QIODevice*) constructor, or it is created internally when opening the archive by its file name. The default API (qioapi.cpp) just delegates everything to the QIODevice API. Not only this allows to use a QIODevice instead of file name, but also has a nice side effect of raising the file size limit from 2G to 4G (in non-zip64 archives).

Note: If the zip64 support is needed, the ioApi argument must be NULL because due to the backwards compatibility issues it can be used to provide a 32-bit API only.; If the no-auto-close feature is used, then the ioApi argument should be NULL because the old API doesn't support the 'fake close' operation, causing slight memory leaks and other possible troubles (like closing the output device in case when an error occurs during opening).

In short: just forget about the ioApi argument and you'll be fine.

Definition at line 215 of file quazip.cpp.

References APPEND_STATUS_ADDINZIP, APPEND_STATUS_CREATE, APPEND_STATUS_CREATEAFTER, QuaZipPrivate::autoClose, QuaZipPrivate::dataDescriptorWritingEnabled, QuaZipPrivate::ioDevice, isOpen(), mdAdd, mdAppend, mdCreate, mdUnzip, QuaZipPrivate::mode, p, UNZ_AUTO_CLOSE, UNZ_OK, UNZ_OPENERROR, unzClearFlags(), unzClose(), unzOpen2(), unzOpenInternal(), unzSetFlags(), ZIP_AUTO_CLOSE, ZIP_SEQUENTIAL, ZIP_WRITE_DATA_DESCRIPTOR, zipClose(), QuaZipPrivate::zipError, QuaZipPrivate::zipName, zipOpen2(), zipOpen3(), and zipSetFlags().

Referenced by KbFirmware::_fileForBoard(), JlCompress::compressDir(), JlCompress::compressFile(), JlCompress::compressFiles(), JlCompress::extractDir(), JlCompress::extractFile(), JlCompress::extractFiles(), JlCompress::getFileList(), and QuaZipFile::open().

 {
   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;
           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;
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

QuaZip& QuaZip::operator= ( const QuaZip & that )

private

void QuaZip::setAutoClose ( bool autoClose ) const

By default, QuaZIP opens the underlying QIODevice when open() is called, and closes it when close() is called. In some cases, when the device is set explicitly using setIoDevice(), it may be desirable to leave the device open. If the auto-close flag is unset using this method, then the device isn't closed automatically if it was set explicitly.

If it is needed to clear this flag, it is recommended to do so before opening the archive because otherwise QuaZIP may close the device during the open() call if an error is encountered after the device is opened.

If the device was not set explicitly, but rather the setZipName() or the appropriate constructor was used to set the ZIP file name instead, then the auto-close flag has no effect, and the internal device is closed nevertheless because there is no other way to close it.

See Also: isAutoClose(); setIoDevice()

Definition at line 785 of file quazip.cpp.

References QuaZipPrivate::autoClose, and p.

 {
     p->autoClose = autoClose;
 }

void QuaZip::setComment ( const QString & comment )

The comment will be written to the archive on close operation. QuaZip makes a distinction between a null QByteArray() comment and an empty "" comment in the QuaZip::mdAdd mode. A null comment is the default and it means "don't change the comment". An empty comment removes the original comment.

See Also: open()

Definition at line 629 of file quazip.cpp.

References QuaZipPrivate::comment, and p.

 {
   p->comment=comment;
 }

void QuaZip::setCommentCodec ( QTextCodec * commentCodec )

This codec defaults to locale codec, which is probably ok.

Definition at line 587 of file quazip.cpp.

References QuaZipPrivate::commentCodec, and p.

 {
   p->commentCodec=commentCodec;
 }

void QuaZip::setCommentCodec ( const char * commentCodecName )

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. Equivalent to calling setCommentCodec(QTextCodec::codecForName(codecName));

Definition at line 592 of file quazip.cpp.

References QuaZipPrivate::commentCodec, and p.

 {
   p->commentCodec=QTextCodec::codecForName(commentCodecName);
 }

bool QuaZip::setCurrentFile	(	const QString &	fileName,
		CaseSensitivity	cs = `csDefault`
	)

Returns true if successful, false otherwise. Argument cs specifies case sensitivity of the file name. Call getZipError() in the case of a failure to get error code.

This is not a wrapper to unzLocateFile() function. That is because I had to implement locale-specific case-insensitive comparison.

Here are the differences from the original implementation:

If the file was not found, error code is UNZ_OK, not UNZ_END_OF_LIST_OF_FILE (see also goToNextFile()).
If this function fails, it unsets the current file rather than resetting it back to what it was before the call.

If fileName is null string then this function unsets the current file and return true. Note that you should close the file first if it is open! See QuaZipFile::QuaZipFile(QuaZip*,QObject*) for the details.

Should be used only in QuaZip::mdUnzip mode.

See Also: setFileNameCodec(), CaseSensitivity

Definition at line 408 of file quazip.cpp.

References convertCaseSensitivity(), current, QuaZipPrivate::directoryCaseInsensitive, QuaZipPrivate::directoryCaseSensitive, getCurrentFileName(), QuaZipPrivate::goToFirstUnmappedFile(), goToNextFile(), QuaZipPrivate::hasCurrentFile_f, MAX_FILE_NAME_LENGTH, mdUnzip, QuaZipPrivate::mode, p, unz64_file_pos_s::pos_in_zip_directory, UNZ_OK, UNZ_PARAMERROR, unzGoToFilePos64(), and QuaZipPrivate::zipError.

Referenced by KbFirmware::_fileForBoard(), JlCompress::extractFile(), QuaZipPrivate::getFileInfoList(), and QuaZipFile::open().

 {
   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;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void QuaZip::setDataDescriptorWritingEnabled ( bool enabled )

According to the ZIP format specification, a file inside archive may have a data descriptor immediately following the file data. This is reflected by a special flag in the local file header and in the central directory. By default, QuaZIP sets this flag and writes the data descriptor unless both method and level were set to 0, in which case it operates in 1.0-compatible mode and never writes data descriptors.

By setting this flag to false, it is possible to disable data descriptor writing, thus increasing compatibility with archive readers that don't understand this feature of the ZIP file format.

Setting this flag affects all the QuaZipFile instances that are opened after this flag is set.

The data descriptor writing mode is enabled by default.

Note that if the ZIP archive is written into a QIODevice for which QIODevice::isSequential() returns true, then the data descriptor is mandatory and will be written even if this flag is set to false.

Parameters

enabled If true, enable local descriptor writing, disable it otherwise.

See Also: QuaZipFile::isDataDescriptorWritingEnabled()

Definition at line 649 of file quazip.cpp.

References QuaZipPrivate::dataDescriptorWritingEnabled, and p.

 {
     p->dataDescriptorWritingEnabled = enabled;
 }

void QuaZip::setDefaultFileNameCodec ( QTextCodec * codec )

static

The default codec is used by the constructors, so calling this function won't affect the QuaZip instances already created at that moment.

The codec specified here can be overriden by calling setFileNameCodec(). If neither function is called, QTextCodec::codecForLocale() will be used to decode or encode file names. Use this function with caution if the application uses other libraries that depend on QuaZIP. Those libraries can either call this function by themselves, thus overriding your setting or can rely on the default encoding, thus failing mysteriously if you change it. For these reasons, it isn't recommended to use this function if you are developing a library, not an application. Instead, ask your library users to call it in case they need specific encoding.

In most cases, using setFileNameCodec() instead is the right choice. However, if you depend on third-party code that uses QuaZIP, then the reasons stated above can actually become a reason to use this function in case the third-party code in question fails because it doesn't understand the encoding you need and doesn't provide a way to specify it. This applies to the JlCompress class as well, as it was contributed and doesn't support explicit encoding parameters.

In short: use setFileNameCodec() when you can, resort to setDefaultFileNameCodec() when you don't have access to the QuaZip instance.

Parameters

codec The codec to use by default. If NULL, resets to default.

Definition at line 760 of file quazip.cpp.

References QuaZipPrivate::defaultFileNameCodec.

Referenced by setDefaultFileNameCodec().

 {
     QuaZipPrivate::defaultFileNameCodec = codec;
 }

Here is the caller graph for this function:

void QuaZip::setDefaultFileNameCodec ( const char * codecName )

static

Definition at line 765 of file quazip.cpp.

References setDefaultFileNameCodec().

 {
     setDefaultFileNameCodec(QTextCodec::codecForName(codecName));
 }

Here is the call graph for this function:

void QuaZip::setFileNameCodec ( QTextCodec * fileNameCodec )

This is necessary to access files in the ZIP archive created under Windows with non-latin characters in file names. For example, file names with cyrillic letters will be in IBM866 encoding.

Definition at line 572 of file quazip.cpp.

References QuaZipPrivate::fileNameCodec, and p.

 {
   p->fileNameCodec=fileNameCodec;
 }

void QuaZip::setFileNameCodec ( const char * fileNameCodecName )

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. Equivalent to calling setFileNameCodec(QTextCodec::codecForName(codecName));

Definition at line 577 of file quazip.cpp.

References QuaZipPrivate::fileNameCodec, and p.

 {
   p->fileNameCodec=QTextCodec::codecForName(fileNameCodecName);
 }

void QuaZip::setIoDevice ( QIODevice * ioDevice )

Does nothing if the ZIP file is open.

Does not reset error code returned by getZipError().

See Also: getIoDevice(), getZipName(), setZipName()

Definition at line 365 of file quazip.cpp.

References QuaZipPrivate::ioDevice, isOpen(), p, and QuaZipPrivate::zipName.

 {
   if(isOpen()) {
     qWarning("QuaZip::setIoDevice(): ZIP is already open!");
     return;
   }
   p->ioDevice = ioDevice;
   p->zipName = QString();
 }

Here is the call graph for this function:

void QuaZip::setZip64Enabled ( bool zip64 )

Parameters

zip64 If true, the zip64 mode is enabled, disabled otherwise.

Once this is enabled, all new files (until the mode is disabled again) will be created in the zip64 mode, thus enabling the ability to write files larger than 4 GB. By default, the zip64 mode is off due to compatibility reasons.

Note that this does not affect the ability to read zip64 archives in any way.

See Also: isZip64Enabled()

Definition at line 770 of file quazip.cpp.

References p, and QuaZipPrivate::zip64.

 {
     p->zip64 = zip64;
 }

void QuaZip::setZipName ( const QString & zipName )

Does nothing if the ZIP file is open.

Does not reset error code returned by getZipError().

See Also: setIoDevice(), getIoDevice(), getZipName()

Definition at line 355 of file quazip.cpp.

References QuaZipPrivate::ioDevice, isOpen(), p, and QuaZipPrivate::zipName.

 {
   if(isOpen()) {
     qWarning("QuaZip::setZipName(): ZIP is already open!");
     return;
   }
   p->zipName=zipName;
   p->ioDevice = NULL;
 }

Here is the call graph for this function:

Friends And Related Function Documentation

friend class QuaZipPrivate

friend

Definition at line 85 of file quazip.h.

Field Documentation

QuaZipPrivate* QuaZip::p

private

The documentation for this class was generated from the following files:

src/ckb/quazip/quazip.h
src/ckb/quazip/quazip.cpp

Public Types

Public Member Functions

Static Public Member Functions

Private Member Functions

Private Attributes

Friends

Detailed Description

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Friends And Related Function Documentation

Field Documentation