UnzipPrivate Class Reference

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

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

closeArchive()

void closeArchive

(

)

Definition at line 948 of file unzip.cpp.

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

Referenced by UnZip::closeArchive().

Here is the caller graph for this function:

convertDateTime()

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

inline

Definition at line 1345 of file unzip.cpp.

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

Referenced by UnZip::entryList().

Here is the caller graph for this function:

createDirectory()

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

decryptByte()

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

decryptBytes()

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

extractFile() [1/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.

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

extractFile() [2/2]

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:

getULLong()

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

getULong()

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

getUShort()

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

initKeys()

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

openArchive()

UnZip::ErrorCode openArchive

(

QIODevice *

device

)

Todo:

Ignore CD entry count? CD may be corrupted.

Definition at line 500 of file unzip.cpp.

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

Referenced by UnZip::openArchive().

Here is the call graph for this function:

Here is the caller graph for this function:

parseCentralDirectoryRecord()

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

parseLocalHeaderRecord()

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:

seekToCentralDirectory()

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

testKeys()

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

testPassword()

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

updateKeys()

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

Member Data Documentation

buffer1

char buffer1[UNZIP_READ_BUFFER]

Definition at line 65 of file unzip_p.h.

buffer2

char buffer2[UNZIP_READ_BUFFER]

Definition at line 66 of file unzip_p.h.

cdEntryCount

quint16 cdEntryCount

Definition at line 77 of file unzip_p.h.

cdOffset

quint32 cdOffset

Definition at line 72 of file unzip_p.h.

comment

QString comment

Definition at line 82 of file unzip_p.h.

Referenced by UnZip::archiveComment().

crcTable

const quint32* crcTable

Definition at line 69 of file unzip_p.h.

device

QIODevice* device

Definition at line 63 of file unzip_p.h.

Referenced by UnZip::archiveComment(), UnZip::extractAll(), and UnZip::isOpen().

eocdOffset

quint32 eocdOffset

Definition at line 74 of file unzip_p.h.

headers

QMap<QString,ZipEntryP*>* headers

Definition at line 61 of file unzip_p.h.

Referenced by UnZip::contains(), UnZip::entryList(), UnZip::extractAll(), UnZip::extractFile(), UnZip::extractFile(), and UnZip::fileList().

password

QString password

Definition at line 57 of file unzip_p.h.

Referenced by UnZip::setPassword().

skipAllEncrypted

bool skipAllEncrypted

Definition at line 59 of file unzip_p.h.

Referenced by UnZip::extractAll().

uBuffer

unsigned char* uBuffer

Definition at line 68 of file unzip_p.h.

unsupportedEntryCount

quint16 unsupportedEntryCount

Definition at line 80 of file unzip_p.h.

---

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

• /exports/ffsm/src_latest/src/unzip_p.h
• /exports/ffsm/src_latest/src/unzip.cpp