#include <unzip_p.h>

Public Member Functions
	UnzipPrivate ()

UnZip::ErrorCode	openArchive (QIODevice *device)

UnZip::ErrorCode	seekToCentralDirectory ()

UnZip::ErrorCode	parseCentralDirectoryRecord ()

UnZip::ErrorCode	parseLocalHeaderRecord (const QString &path, ZipEntryP &entry)

void	closeArchive ()

UnZip::ErrorCode	extractFile (const QString &path, ZipEntryP &entry, const QDir &dir, UnZip::ExtractionOptions options)

UnZip::ErrorCode	extractFile (const QString &path, ZipEntryP &entry, QIODevice *device, UnZip::ExtractionOptions options)

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

bool	testKeys (const ZipEntryP &header, quint32 *keys)

bool	createDirectory (const QString &path)

void	decryptBytes (quint32 keys, char buffer, qint64 read)

quint32	getULong (const unsigned char *data, quint32 offset) const

quint64	getULLong (const unsigned char *data, quint32 offset) const

quint16	getUShort (const unsigned char *data, quint32 offset) const

int	decryptByte (quint32 key2) const

void	updateKeys (quint32 *keys, int c) const

void	initKeys (const QString &pwd, quint32 *keys) const

QDateTime	convertDateTime (const unsigned char date[2], const unsigned char time[2]) const

Public Attributes
QString	password

bool	skipAllEncrypted

QMap< QString, ZipEntryP * > *	headers

QIODevice *	device

char	buffer1 [UNZIP_READ_BUFFER]

char	buffer2 [UNZIP_READ_BUFFER]

unsigned char *	uBuffer

const quint32 *	crcTable

quint32	cdOffset

quint32	eocdOffset

quint16	cdEntryCount

quint16	unsupportedEntryCount

QString	comment

Detailed Description

Definition at line 51 of file unzip_p.h.

Constructor & Destructor Documentation

UnzipPrivate ( )

Definition at line 485 of file unzip.cpp.

 {
   skipAllEncrypted = false;
   headers = 0;
   device = 0;
 
   uBuffer = (unsigned char*) buffer1;
   crcTable = (quint32*) get_crc_table();
 
   cdOffset = eocdOffset = 0;
   cdEntryCount = 0;
   unsupportedEntryCount = 0;
 }

Member Function Documentation

void closeArchive ( )

Definition at line 948 of file unzip.cpp.

Referenced by UnZip::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();
 }

Here is the caller graph for this function:

QDateTime convertDateTime	(	const unsigned char	date[2],
		const unsigned char	time[2]
	)		const

inline

Definition at line 1345 of file unzip.cpp.

Referenced by UnZip::entryList().

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

Here is the caller graph for this function:

bool createDirectory ( const QString & path )

Definition at line 1195 of file unzip.cpp.

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

int decryptByte ( quint32 key2 ) const

inline

Definition at line 1257 of file unzip.cpp.

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

void decryptBytes	(	quint32 *	keys,
		char *	buffer,
		qint64	read
	)

inline

Definition at line 1336 of file unzip.cpp.

 {
   for (int i=0; i<(int)read; ++i)
     updateKeys(keys, buffer[i] ^= decryptByte(keys[2]));
 }

UnZip::ErrorCode extractFile	(	const QString &	path,
		ZipEntryP &	entry,
		const QDir &	dir,
		UnZip::ExtractionOptions	options
	)

Todo:: Set creation/last_modified date/time

Definition at line 972 of file unzip.cpp.

Referenced by UnZip::extractAll(), and UnZip::extractFile().

 {
   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;
   }
 
   //! \todo Set creation/last_modified date/time
 
   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;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

UnZip::ErrorCode extractFile	(	const QString &	path,
		ZipEntryP &	entry,
		QIODevice *	device,
		UnZip::ExtractionOptions	options
	)

Encryption header size

Definition at line 1043 of file unzip.cpp.

 {
   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;
     }//! Encryption header size
     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;
 }

Here is the call graph for this function:

quint64 getULLong	(	const unsigned char *	data,
		quint32	offset
	)		const

inline

Definition at line 1232 of file unzip.cpp.

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

quint32 getULong	(	const unsigned char *	data,
		quint32	offset
	)		const

inline

Definition at line 1219 of file unzip.cpp.

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

quint16 getUShort	(	const unsigned char *	data,
		quint32	offset
	)		const

inline

Definition at line 1249 of file unzip.cpp.

 {
   return (quint16) data[offset] | (((quint16)data[offset+1]) << 8);
 }

void initKeys	(	const QString &	pwd,
		quint32 *	keys
	)		const

inline

Definition at line 1278 of file unzip.cpp.

 {
   keys[0] = 305419896L;
   keys[1] = 591751049L;
   keys[2] = 878082192L;
 
     //QByteArray pwdBytes = pwd.toAscii(); // Qt4
     QByteArray pwdBytes = pwd.toLatin1();  // Qt5
   int sz = pwdBytes.size();
   const char* ascii = pwdBytes.data();
 
   for (int i=0; i<sz; ++i)
     updateKeys(keys, (int)ascii[i]);
 }

UnZip::ErrorCode openArchive ( QIODevice * device )

Todo:: Ignore CD entry count? CD may be corrupted.

Definition at line 500 of file unzip.cpp.

Referenced by UnZip::openArchive().

 {
   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;
   }
 
   //! \todo Ignore CD entry count? CD may be corrupted.
   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;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

UnZip::ErrorCode parseCentralDirectoryRecord ( )

Definition at line 837 of file unzip.cpp.

 {
   // 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); // Qt4
     QString filename = QString::fromLatin1(buffer2, szName);  // Qt5
 
   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); // Qt4
         h->comment = QString::fromLatin1(buffer2, szComment);  // Qt5
   }
 
   h->lhOffset = getULong(uBuffer, UNZIP_CD_OFF_LHOFFSET);
 
   if (headers == 0)
     headers = new QMap<QString, ZipEntryP*>();
   headers->insert(filename, h);
 
   return UnZip::Ok;
 }

UnZip::ErrorCode parseLocalHeaderRecord	(	const QString &	path,
		ZipEntryP &	entry
	)

Definition at line 574 of file unzip.cpp.

 {
   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); // Qt4
     QString filename = QString::fromLatin1(buffer2, szName);  // Qt5
   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;
 }

Here is the call graph for this function:

UnZip::ErrorCode seekToCentralDirectory ( )

Definition at line 713 of file unzip.cpp.

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

bool testKeys	(	const ZipEntryP &	header,
		quint32 *	keys
	)

Definition at line 1317 of file unzip.cpp.

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

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

Definition at line 1298 of file unzip.cpp.

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

void updateKeys	(	quint32 *	keys,
		int	c
	)		const

inline

Definition at line 1266 of file unzip.cpp.

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