ZipPrivate Class Reference

#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()

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()

~ZipPrivate ( )

virtual

Definition at line 511 of file zip.cpp.

{
  closeArchive();
}

Here is the call graph for this function:

Member Function Documentation

closeArchive()

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.

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

Referenced by Zip::closeArchive(), createArchive(), and ~ZipPrivate().

Here is the call graph for this function:

Here is the caller graph for this function:

createArchive()

Zip::ErrorCode createArchive

(

QIODevice *

device

)

Definition at line 517 of file zip.cpp.

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

Referenced by Zip::createArchive().

Here is the call graph for this function:

Here is the caller graph for this function:

createEntry()

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.

{
  //! \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;
}

Referenced by Zip::addDirectory().

Here is the call graph for this function:

Here is the caller graph for this function:

decryptByte()

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

Referenced by createEntry(), and encryptBytes().

Here is the caller graph for this function:

detectCompressionByMime()

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

Referenced by createEntry().

Here is the caller graph for this function:

encryptBytes()

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

Referenced by createEntry().

Here is the call graph for this function:

Here is the caller graph for this function:

extractRoot()

QString extractRoot ( const QString &  p )

inline

Definition at line 1213 of file zip.cpp.

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

Referenced by Zip::addDirectory().

Here is the caller graph for this function:

initKeys()

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

Referenced by createEntry().

Here is the call graph for this function:

Here is the caller graph for this function:

reset()

void reset

(

)

Definition at line 1198 of file zip.cpp.

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

Referenced by Zip::closeArchive().

Here is the caller graph for this function:

setULong()

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

Referenced by closeArchive(), and createEntry().

Here is the caller graph for this function:

updateKeys()

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

Referenced by createEntry(), encryptBytes(), and initKeys().

Here is the caller graph for this function:

zLibInit()

bool zLibInit

(

)

Member Data Documentation

buffer1

char buffer1[ZIP_READ_BUFFER]

Definition at line 64 of file zip_p.h.

Referenced by closeArchive(), createEntry(), and ZipPrivate().

buffer2

char buffer2[ZIP_READ_BUFFER]

Definition at line 65 of file zip_p.h.

Referenced by createEntry().

comment

QString comment

Definition at line 71 of file zip_p.h.

Referenced by Zip::archiveComment(), closeArchive(), reset(), and Zip::setArchiveComment().

crcTable

const quint32* crcTable

Definition at line 69 of file zip_p.h.

Referenced by ZipPrivate().

device

QIODevice* device

Definition at line 62 of file zip_p.h.

Referenced by Zip::addDirectory(), closeArchive(), createArchive(), createEntry(), Zip::isOpen(), reset(), Zip::setArchiveComment(), and ZipPrivate().

headers

QMap<QString,ZipEntryP*>* headers

Definition at line 60 of file zip_p.h.

Referenced by closeArchive(), createArchive(), createEntry(), reset(), and ZipPrivate().

password

QString password

Definition at line 72 of file zip_p.h.

Referenced by Zip::clearPassword(), createEntry(), initKeys(), Zip::password(), and Zip::setPassword().

uBuffer

unsigned char* uBuffer

Definition at line 67 of file zip_p.h.

Referenced by createEntry(), and ZipPrivate().

---

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

• /exports/ffsm/src_latest/src/zip_p.h
• /exports/ffsm/src_latest/src/zip.cpp