#include <zip_p.h>

Public Member Functions
	ZipPrivate ()

virtual	~ZipPrivate ()

Zip::ErrorCode	createArchive (QIODevice *device)

Zip::ErrorCode	closeArchive ()

void	reset ()

bool	zLibInit ()

Zip::ErrorCode	createEntry (const QFileInfo &file, const QString &root, Zip::CompressionLevel level)

Zip::CompressionLevel	detectCompressionByMime (const QString &ext)

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

void	setULong (quint32 v, char *buffer, unsigned int offset)

void	updateKeys (quint32 *keys, int c) const

void	initKeys (quint32 *keys) const

int	decryptByte (quint32 key2) const

QString	extractRoot (const QString &p)

Public Attributes
QMap< QString, ZipEntryP * > *	headers

QIODevice *	device

char	buffer1 [ZIP_READ_BUFFER]

char	buffer2 [ZIP_READ_BUFFER]

unsigned char *	uBuffer

const quint32 *	crcTable

QString	comment

QString	password

Detailed Description

Definition at line 54 of file zip_p.h.

Constructor & Destructor Documentation

ZipPrivate ( )

Definition at line 500 of file zip.cpp.

 {
   headers = 0;
   device = 0;
 
   // keep an unsigned pointer so we avoid to over bloat the code with casts
   uBuffer = (unsigned char*) buffer1;
   crcTable = (quint32*) get_crc_table();
 }

~ZipPrivate ( )

virtual

Definition at line 511 of file zip.cpp.

 {
   closeArchive();
 }

Here is the call graph for this function:

Member Function Documentation

Zip::ErrorCode closeArchive ( )

Closes the current archive and writes out pending data.

Todo:: See if we can detect QFile objects using the Qt Meta Object System

Todo:: SAME AS ABOVE: See if we can detect QFile objects using the Qt Meta Object System

Todo:: SAME AS ABOVE: See if we can detect QFile objects using the Qt Meta Object System

Todo:: SAME AS ABOVE: See if we can detect QFile objects using the Qt Meta Object System

Definition at line 1014 of file zip.cpp.

Referenced by Zip::closeArchive().

 {
   // Close current archive by writing out central directory
   // and free up resources
 
   if (device == 0)
     return Zip::Ok;
 
   if (headers == 0)
     return Zip::Ok;
 
   const ZipEntryP* h;
 
   unsigned int sz;
   quint32 szCentralDir = 0;
   quint32 offCentralDir = device->pos();
 
   for (QMap<QString,ZipEntryP*>::ConstIterator itr = headers->constBegin(); itr != headers->constEnd(); ++itr)
   {
     h = itr.value();
 
     // signature
     buffer1[0] = 'P';
     buffer1[1] = 'K';
     buffer1[2] = 0x01;
     buffer1[3] = 0x02;
 
     // version made by  (currently only MS-DOS/FAT - no symlinks or other stuff supported)
     buffer1[ZIP_CD_OFF_MADEBY] = buffer1[ZIP_CD_OFF_MADEBY + 1] = 0;
 
     // version needed to extract
     buffer1[ZIP_CD_OFF_VERSION] = ZIP_VERSION;
     buffer1[ZIP_CD_OFF_VERSION + 1] = 0;
 
     // general purpose flag
     buffer1[ZIP_CD_OFF_GPFLAG] = h->gpFlag[0];
     buffer1[ZIP_CD_OFF_GPFLAG + 1] = h->gpFlag[1];
 
     // compression method
     buffer1[ZIP_CD_OFF_CMET] = h->compMethod & 0xFF;
     buffer1[ZIP_CD_OFF_CMET + 1] = (h->compMethod >> 8) & 0xFF;
 
     // last mod file time
     buffer1[ZIP_CD_OFF_MODT] = h->modTime[0];
     buffer1[ZIP_CD_OFF_MODT + 1] = h->modTime[1];
 
     // last mod file date
     buffer1[ZIP_CD_OFF_MODD] = h->modDate[0];
     buffer1[ZIP_CD_OFF_MODD + 1] = h->modDate[1];
 
     // crc (4bytes) [16,17,18,19]
     setULong(h->crc, buffer1, ZIP_CD_OFF_CRC);
 
     // compressed size (4bytes: [20,21,22,23])
     setULong(h->szComp, buffer1, ZIP_CD_OFF_CSIZE);
 
     // uncompressed size [24,25,26,27]
     setULong(h->szUncomp, buffer1, ZIP_CD_OFF_USIZE);
 
     // filename
         //QByteArray fileNameBytes = itr.key().toAscii();
         QByteArray fileNameBytes = itr.key().toLatin1();
     sz = fileNameBytes.size();
     buffer1[ZIP_CD_OFF_NAMELEN] = sz & 0xFF;
     buffer1[ZIP_CD_OFF_NAMELEN + 1] = (sz >> 8) & 0xFF;
 
     // extra field length
     buffer1[ZIP_CD_OFF_XLEN] = buffer1[ZIP_CD_OFF_XLEN + 1] = 0;
 
     // file comment length
     buffer1[ZIP_CD_OFF_COMMLEN] = buffer1[ZIP_CD_OFF_COMMLEN + 1] = 0;
 
     // disk number start
     buffer1[ZIP_CD_OFF_DISKSTART] = buffer1[ZIP_CD_OFF_DISKSTART + 1] = 0;
 
     // internal file attributes
     buffer1[ZIP_CD_OFF_IATTR] = buffer1[ZIP_CD_OFF_IATTR + 1] = 0;
 
     // external file attributes
     buffer1[ZIP_CD_OFF_EATTR] =
     buffer1[ZIP_CD_OFF_EATTR + 1] =
     buffer1[ZIP_CD_OFF_EATTR + 2] =
     buffer1[ZIP_CD_OFF_EATTR + 3] = 0;
 
     // relative offset of local header [42->45]
     setULong(h->lhOffset, buffer1, ZIP_CD_OFF_LHOFF);
 
     if (device->write(buffer1, ZIP_CD_SIZE) != ZIP_CD_SIZE)
     {
       //! \todo See if we can detect QFile objects using the Qt Meta Object System
       /*
       if (!device->remove())
         qDebug() << tr("Unable to delete corrupted archive: %1").arg(device->fileName());
       */
       return Zip::WriteFailed;
     }
 
     // Write out filename
     if ((unsigned int)device->write(fileNameBytes) != sz)
     {
       //! \todo SAME AS ABOVE: See if we can detect QFile objects using the Qt Meta Object System
       /*
       if (!device->remove())
         qDebug() << tr("Unable to delete corrupted archive: %1").arg(device->fileName());
         */
       return Zip::WriteFailed;
     }
 
     szCentralDir += (ZIP_CD_SIZE + sz);
 
   } // central dir headers loop
 
 
   // Write end of central directory
 
   // signature
   buffer1[0] = 'P';
   buffer1[1] = 'K';
   buffer1[2] = 0x05;
   buffer1[3] = 0x06;
 
   // number of this disk
   buffer1[ZIP_EOCD_OFF_DISKNUM] = buffer1[ZIP_EOCD_OFF_DISKNUM + 1] = 0;
 
   // number of disk with central directory
   buffer1[ZIP_EOCD_OFF_CDDISKNUM] = buffer1[ZIP_EOCD_OFF_CDDISKNUM + 1] = 0;
 
   // number of entries in this disk
   sz = headers->count();
     buffer1[ZIP_EOCD_OFF_ENTRIES] = sz & 0xFF;
   buffer1[ZIP_EOCD_OFF_ENTRIES + 1] = (sz >> 8) & 0xFF;
 
   // total number of entries
   buffer1[ZIP_EOCD_OFF_CDENTRIES] = buffer1[ZIP_EOCD_OFF_ENTRIES];
   buffer1[ZIP_EOCD_OFF_CDENTRIES + 1] = buffer1[ZIP_EOCD_OFF_ENTRIES + 1];
 
   // size of central directory [12->15]
   setULong(szCentralDir, buffer1, ZIP_EOCD_OFF_CDSIZE);
 
   // central dir offset [16->19]
   setULong(offCentralDir, buffer1, ZIP_EOCD_OFF_CDOFF);
 
   // ZIP file comment length
     //QByteArray commentBytes = comment.toAscii();
     QByteArray commentBytes = comment.toLatin1();
   quint16 commentLength = commentBytes.size();
 
   if (commentLength == 0)
   {
     buffer1[ZIP_EOCD_OFF_COMMLEN] = buffer1[ZIP_EOCD_OFF_COMMLEN + 1] = 0;
   }
   else
   {
     buffer1[ZIP_EOCD_OFF_COMMLEN] = commentLength & 0xFF;
     buffer1[ZIP_EOCD_OFF_COMMLEN + 1] = (commentLength >> 8) & 0xFF;
   }
 
   if (device->write(buffer1, ZIP_EOCD_SIZE) != ZIP_EOCD_SIZE)
   {
     //! \todo SAME AS ABOVE: See if we can detect QFile objects using the Qt Meta Object System
     /*
     if (!device->remove())
       qDebug() << tr("Unable to delete corrupted archive: %1").arg(device->fileName());
       */
     return Zip::WriteFailed;
   }
 
   if (commentLength != 0)
   {
     if ((unsigned int)device->write(commentBytes) != commentLength)
     {
       //! \todo SAME AS ABOVE: See if we can detect QFile objects using the Qt Meta Object System
       /*
       if (!device->remove())
         qDebug() << tr("Unable to delete corrupted archive: %1").arg(device->fileName());
         */
       return Zip::WriteFailed;
     }
   }
 
   return Zip::Ok;
 }

Here is the caller graph for this function:

Zip::ErrorCode createArchive ( QIODevice * device )

Definition at line 517 of file zip.cpp.

Referenced by Zip::createArchive().

 {
   Q_ASSERT(dev != 0);
 
   if (device != 0)
     closeArchive();
 
   device = dev;
 
   if (!device->isOpen())
   {
     if (!device->open(QIODevice::ReadOnly)) {
       delete device;
       device = 0;
       qDebug() << "Unable to open device for writing.";
       return Zip::OpenFailed;
     }
   }
 
   headers = new QMap<QString,ZipEntryP*>;
   return Zip::Ok;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

Zip::ErrorCode createEntry	(	const QFileInfo &	file,
		const QString &	root,
		Zip::CompressionLevel	level
	)

Todo:: Automatic level detection (cpu, extension & file size)

Definition at line 541 of file zip.cpp.

Referenced by Zip::addDirectory().

 {
   //! \todo Automatic level detection (cpu, extension & file size)
 
   // Directories and very small files are always stored
   // (small files would get bigger due to the compression headers overhead)
 
   // Need this for zlib
   bool isPNGFile = false;
   bool dirOnly = file.isDir();
 
   QString entryName = root;
 
   // Directory entry
   if (dirOnly)
     level = Zip::Store;
   else
   {
     entryName.append(file.fileName());
 
     QString ext = file.completeSuffix().toLower();
     isPNGFile = ext == "png";
 
     if (file.size() < ZIP_COMPRESSION_THRESHOLD)
       level = Zip::Store;
     else
       switch (level)
       {
       case Zip::AutoCPU:
         level = Zip::Deflate5;
         break;
       case Zip::AutoMIME:
         level = detectCompressionByMime(ext);
         break;
       case Zip::AutoFull:
         level = detectCompressionByMime(ext);
         break;
       default:
         ;
       }
   }
 
   // entryName contains the path as it should be written
   // in the zip file records
   // qDebug() << QString("addDir(file=%1, root=%2, entry=%3)").arg(file.absoluteFilePath(), root, entryName);
 
   // create header and store it to write a central directory later
   ZipEntryP* h = new ZipEntryP;
 
   h->compMethod = (level == Zip::Store) ? 0 : 0x0008;
 
   // Set encryption bit and set the data descriptor bit
   // so we can use mod time instead of crc for password check
   bool encrypt = !dirOnly && !password.isEmpty();
   if (encrypt)
     h->gpFlag[0] |= 9;
 
   QDateTime dt = file.lastModified();
   QDate d = dt.date();
   h->modDate[1] = ((d.year() - 1980) << 1) & 254;
   h->modDate[1] |= ((d.month() >> 3) & 1);
   h->modDate[0] = ((d.month() & 7) << 5) & 224;
   h->modDate[0] |= d.day();
 
   QTime t = dt.time();
   h->modTime[1] = (t.hour() << 3) & 248;
   h->modTime[1] |= ((t.minute() >> 3) & 7);
   h->modTime[0] = ((t.minute() & 7) << 5) & 224;
   h->modTime[0] |= t.second() / 2;
 
   h->szUncomp = dirOnly ? 0 : file.size();
 
   // **** Write local file header ****
 
   // signature
   buffer1[0] = 'P'; buffer1[1] = 'K';
   buffer1[2] = 0x3; buffer1[3] = 0x4;
 
   // version needed to extract
   buffer1[ZIP_LH_OFF_VERS] = ZIP_VERSION;
   buffer1[ZIP_LH_OFF_VERS + 1] = 0;
 
   // general purpose flag
   buffer1[ZIP_LH_OFF_GPFLAG] = h->gpFlag[0];
   buffer1[ZIP_LH_OFF_GPFLAG + 1] = h->gpFlag[1];
 
   // compression method
   buffer1[ZIP_LH_OFF_CMET] = h->compMethod & 0xFF;
   buffer1[ZIP_LH_OFF_CMET + 1] = (h->compMethod>>8) & 0xFF;
 
   // last mod file time
   buffer1[ZIP_LH_OFF_MODT] = h->modTime[0];
   buffer1[ZIP_LH_OFF_MODT + 1] = h->modTime[1];
 
   // last mod file date
   buffer1[ZIP_LH_OFF_MODD] = h->modDate[0];
   buffer1[ZIP_LH_OFF_MODD + 1] = h->modDate[1];
 
   // skip crc (4bytes) [14,15,16,17]
 
   // skip compressed size but include evtl. encryption header (4bytes: [18,19,20,21])
   buffer1[ZIP_LH_OFF_CSIZE] =
   buffer1[ZIP_LH_OFF_CSIZE + 1] =
   buffer1[ZIP_LH_OFF_CSIZE + 2] =
   buffer1[ZIP_LH_OFF_CSIZE + 3] = 0;
 
   h->szComp = encrypt ? ZIP_LOCAL_ENC_HEADER_SIZE : 0;
 
   // uncompressed size [22,23,24,25]
   setULong(h->szUncomp, buffer1, ZIP_LH_OFF_USIZE);
 
   // filename length
     //QByteArray entryNameBytes = entryName.toAscii();
     QByteArray entryNameBytes = entryName.toLatin1(); // Qt5
   int sz = entryNameBytes.size();
 
   buffer1[ZIP_LH_OFF_NAMELEN] = sz & 0xFF;
   buffer1[ZIP_LH_OFF_NAMELEN + 1] = (sz >> 8) & 0xFF;
 
   // extra field length
   buffer1[ZIP_LH_OFF_XLEN] = buffer1[ZIP_LH_OFF_XLEN + 1] = 0;
 
   // Store offset to write crc and compressed size
   h->lhOffset = device->pos();
   quint32 crcOffset = h->lhOffset + ZIP_LH_OFF_CRC;
 
   if (device->write(buffer1, ZIP_LOCAL_HEADER_SIZE) != ZIP_LOCAL_HEADER_SIZE)
   {
     delete h;
     return Zip::WriteFailed;
   }
 
   // Write out filename
   if (device->write(entryNameBytes) != sz)
   {
     delete h;
     return Zip::WriteFailed;
   }
 
   // Encryption keys
   quint32 keys[3] = { 0, 0, 0 };
 
   if (encrypt)
   {
     // **** encryption header ****
 
     // XOR with PI to ensure better random numbers
     // with poorly implemented rand() as suggested by Info-Zip
     srand(time(NULL) ^ 3141592654UL);
     int randByte;
 
     initKeys(keys);
     for (int i=0; i<10; ++i)
     {
       randByte = (rand() >> 7) & 0xff;
       buffer1[i] = decryptByte(keys[2]) ^ randByte;
       updateKeys(keys, randByte);
     }
 
     // Encrypt encryption header
     initKeys(keys);
     for (int i=0; i<10; ++i)
     {
       randByte = decryptByte(keys[2]);
       updateKeys(keys, buffer1[i]);
       buffer1[i] ^= randByte;
     }
 
     // We don't know the CRC at this time, so we use the modification time
     // as the last two bytes
     randByte = decryptByte(keys[2]);
     updateKeys(keys, h->modTime[0]);
     buffer1[10] ^= randByte;
 
     randByte = decryptByte(keys[2]);
     updateKeys(keys, h->modTime[1]);
     buffer1[11] ^= randByte;
 
     // Write out encryption header
     if (device->write(buffer1, ZIP_LOCAL_ENC_HEADER_SIZE) != ZIP_LOCAL_ENC_HEADER_SIZE)
     {
       delete h;
       return Zip::WriteFailed;
     }
   }
 
   qint64 written = 0;
   quint32 crc = crc32(0L, Z_NULL, 0);
 
   if (!dirOnly)
   {
     QFile actualFile(file.absoluteFilePath());
     if (!actualFile.open(QIODevice::ReadOnly))
     {
       qDebug() << QString("An error occurred while opening %1").arg(file.absoluteFilePath());
       return Zip::OpenFailed;
     }
 
     // Write file data
     qint64 read = 0;
     qint64 totRead = 0;
     qint64 toRead = actualFile.size();
 
     if (level == Zip::Store)
     {
       while ( (read = actualFile.read(buffer1, ZIP_READ_BUFFER)) > 0 )
       {
         crc = crc32(crc, uBuffer, read);
 
         if (password != 0)
           encryptBytes(keys, buffer1, read);
 
         if ( (written = device->write(buffer1, read)) != read )
         {
           actualFile.close();
           delete h;
           return Zip::WriteFailed;
         }
       }
     }
     else
     {
       z_stream zstr;
 
       // Initialize zalloc, zfree and opaque before calling the init function
       zstr.zalloc = Z_NULL;
       zstr.zfree = Z_NULL;
       zstr.opaque = Z_NULL;
 
       int zret;
 
       // Use deflateInit2 with negative windowBits to get raw compression
       if ((zret = deflateInit2_(
           &zstr,
           (int)level,
           Z_DEFLATED,
           -MAX_WBITS,
           8,
           isPNGFile ? Z_RLE : Z_DEFAULT_STRATEGY,
           ZLIB_VERSION,
           sizeof(z_stream)
         )) != Z_OK )
       {
         actualFile.close();
         qDebug() << "Could not initialize zlib for compression";
         delete h;
         return Zip::ZlibError;
       }
 
       qint64 compressed;
 
       int flush = Z_NO_FLUSH;
 
       do
       {
         read = actualFile.read(buffer1, ZIP_READ_BUFFER);
         totRead += read;
 
         if (read == 0)
           break;
         if (read < 0)
         {
           actualFile.close();
           deflateEnd(&zstr);
           qDebug() << QString("Error while reading %1").arg(file.absoluteFilePath());
           delete h;
           return Zip::ReadFailed;
         }
 
         crc = crc32(crc, uBuffer, read);
 
         zstr.next_in = (Bytef*) buffer1;
         zstr.avail_in = (uInt)read;
 
         // Tell zlib if this is the last chunk we want to encode
         // by setting the flush parameter to Z_FINISH
         flush = (totRead == toRead) ? Z_FINISH : Z_NO_FLUSH;
 
         // Run deflate() on input until output buffer not full
         // finish compression if all of source has been read in
             do
             {
           zstr.next_out = (Bytef*) buffer2;
           zstr.avail_out = ZIP_READ_BUFFER;
 
           zret = deflate(&zstr, flush);
           // State not clobbered
           Q_ASSERT(zret != Z_STREAM_ERROR);
 
           // Write compressed data to file and empty buffer
           compressed = ZIP_READ_BUFFER - zstr.avail_out;
 
           if (password != 0)
             encryptBytes(keys, buffer2, compressed);
 
           if (device->write(buffer2, compressed) != compressed)
           {
             deflateEnd(&zstr);
             actualFile.close();
             qDebug() << QString("Error while writing %1").arg(file.absoluteFilePath());
             delete h;
             return Zip::WriteFailed;
           }
 
           written += compressed;
 
         } while (zstr.avail_out == 0);
 
         // All input will be used
         Q_ASSERT(zstr.avail_in == 0);
 
       } while (flush != Z_FINISH);
 
       // Stream will be complete
       Q_ASSERT(zret == Z_STREAM_END);
 
       deflateEnd(&zstr);
 
     } // if (level != STORE)
 
     actualFile.close();
   }
 
   // Store end of entry offset
   quint32 current = device->pos();
 
   // Update crc and compressed size in local header
   if (!device->seek(crcOffset))
   {
     delete h;
     return Zip::SeekFailed;
   }
 
   h->crc = dirOnly ? 0 : crc;
   h->szComp += written;
 
   setULong(h->crc, buffer1, 0);
   setULong(h->szComp, buffer1, 4);
   if ( device->write(buffer1, 8) != 8)
   {
     delete h;
     return Zip::WriteFailed;
   }
 
   // Seek to end of entry
   if (!device->seek(current))
   {
     delete h;
     return Zip::SeekFailed;
   }
 
   if ((h->gpFlag[0] & 8) == 8)
   {
     // Write data descriptor
 
     // Signature: PK\7\8
     buffer1[0] = 'P';
     buffer1[1] = 'K';
     buffer1[2] = 0x07;
     buffer1[3] = 0x08;
 
     // CRC
     setULong(h->crc, buffer1, ZIP_DD_OFF_CRC32);
 
     // Compressed size
     setULong(h->szComp, buffer1, ZIP_DD_OFF_CSIZE);
 
     // Uncompressed size
     setULong(h->szUncomp, buffer1, ZIP_DD_OFF_USIZE);
 
     if (device->write(buffer1, ZIP_DD_SIZE_WS) != ZIP_DD_SIZE_WS)
     {
       delete h;
       return Zip::WriteFailed;
     }
   }
 
   headers->insert(entryName, h);
   return Zip::Ok;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

int decryptByte ( quint32 key2 ) const

inline

Definition at line 923 of file zip.cpp.

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

Zip::CompressionLevel detectCompressionByMime ( const QString & ext )

Definition at line 979 of file zip.cpp.

 {
   // files really hard to compress
   if ((ext == "png") ||
     (ext == "jpg") ||
     (ext == "jpeg") ||
     (ext == "mp3") ||
     (ext == "ogg") ||
     (ext == "ogm") ||
     (ext == "avi") ||
     (ext == "mov") ||
     (ext == "rm") ||
     (ext == "ra") ||
     (ext == "zip") ||
     (ext == "rar") ||
     (ext == "bz2") ||
     (ext == "gz") ||
     (ext == "7z") ||
     (ext == "z") ||
     (ext == "jar")
   ) return Zip::Store;
 
   // files slow and hard to compress
   if ((ext == "exe") ||
     (ext == "bin") ||
     (ext == "rpm") ||
     (ext == "deb")
   ) return Zip::Deflate2;
 
   return Zip::Deflate9;
 }

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

inline

Definition at line 966 of file zip.cpp.

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

QString extractRoot ( const QString & p )

inline

Definition at line 1213 of file zip.cpp.

Referenced by Zip::addDirectory().

 {
   QDir d(QDir::cleanPath(p));
   if (!d.exists())
     return QString();
 
   if (!d.cdUp())
     return QString();
 
   return d.absolutePath();
 }

Here is the caller graph for this function:

void initKeys ( quint32 * keys ) const

inline

Definition at line 939 of file zip.cpp.

 {
   // Encryption keys initialization constants are taken from the
   // PKZip file format specification docs
   keys[0] = 305419896L;
   keys[1] = 591751049L;
   keys[2] = 878082192L;
 
     //QByteArray pwdBytes = password.toAscii();
     QByteArray pwdBytes = password.toLatin1();
   int sz = pwdBytes.size();
   const char* ascii = pwdBytes.data();
 
   for (int i=0; i<sz; ++i)
     updateKeys(keys, (int)ascii[i]);
 }

Here is the call graph for this function:

void reset ( )

Definition at line 1198 of file zip.cpp.

Referenced by Zip::closeArchive().

 {
   comment.clear();
 
   if (headers != 0)
   {
     qDeleteAll(*headers);
     delete headers;
     headers = 0;
   }
 
   delete device; device = 0;
 }

Here is the caller graph for this function:

void setULong	(	quint32	v,
		char *	buffer,
		unsigned int	offset
	)

inline

Definition at line 930 of file zip.cpp.

 {
   buffer[offset+3] = ((v >> 24) & 0xFF);
   buffer[offset+2] = ((v >> 16) & 0xFF);
   buffer[offset+1] = ((v >> 8) & 0xFF);
   buffer[offset] = (v & 0xFF);
 }

void updateKeys	(	quint32 *	keys,
		int	c
	)		const

inline

Definition at line 957 of file zip.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);
 }