Katana_mirror/kdelibs
1
0
Fork 0
mirror of https://bitbucket.org/smil3y/kdelibs.git synced 2025-02-24 19:02:48 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions
kdelibs/kdecore/io/kzip.cpp
Ivailo Monev 814163a8dc initial import
2014-11-13 01:04:59 +02:00

1385 lines
46 KiB
C++
Raw Blame History

/* This file is part of the KDE libraries
Copyright (C) 2000 David Faure <faure@kde.org>
Copyright (C) 2002 Holger Schroeder <holger-kde@holgis.net>
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License version 2 as published by the Free Software Foundation.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Library General Public License for more details.
You should have received a copy of the GNU Library General Public License
along with this library; see the file COPYING.LIB. If not, write to
the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
Boston, MA 02110-1301, USA.
*/
#include "kzip.h"
#include "kfilterdev.h"
#include "klimitediodevice_p.h"
#include <kdebug.h>
#include <QtCore/QHash>
#include <QtCore/QByteArray>
#include <QtCore/QFile>
#include <QtCore/QDir>
#include <QtCore/QDate>
#include <QtCore/QList>
#include <zlib.h>
#include <time.h>
#include <string.h>
const int max_path_len = 4095; // maximum number of character a path may contain
static void transformToMsDos(const QDateTime& dt, char* buffer)
{
if ( dt.isValid() )
{
const quint16 time =
( dt.time().hour() << 11 ) // 5 bit hour
| ( dt.time().minute() << 5 ) // 6 bit minute
| ( dt.time().second() >> 1 ); // 5 bit double seconds
buffer[0] = char(time);
buffer[1] = char(time >> 8);
const quint16 date =
( ( dt.date().year() - 1980 ) << 9 ) // 7 bit year 1980-based
| ( dt.date().month() << 5 ) // 4 bit month
| ( dt.date().day() ); // 5 bit day
buffer[2] = char(date);
buffer[3] = char(date >> 8);
}
else // !dt.isValid(), assume 1980-01-01 midnight
{
buffer[0] = 0;
buffer[1] = 0;
buffer[2] = 33;
buffer[3] = 0;
}
}
static time_t transformFromMsDos(const char* buffer)
{
quint16 time = (uchar)buffer[0] | ( (uchar)buffer[1] << 8 );
int h = time >> 11;
int m = ( time & 0x7ff ) >> 5;
int s = ( time & 0x1f ) * 2 ;
QTime qt(h, m, s);
quint16 date = (uchar)buffer[2] | ( (uchar)buffer[3] << 8 );
int y = ( date >> 9 ) + 1980;
int o = ( date & 0x1ff ) >> 5;
int d = ( date & 0x1f );
QDate qd(y, o, d);
QDateTime dt( qd, qt );
return dt.toTime_t();
}
// == parsing routines for zip headers
/** all relevant information about parsing file information */
struct ParseFileInfo {
// file related info
mode_t perm; // permissions of this file
time_t atime; // last access time (UNIX format)
time_t mtime; // modification time (UNIX format)
time_t ctime; // creation time (UNIX format)
int uid; // user id (-1 if not specified)
int gid; // group id (-1 if not specified)
QByteArray guessed_symlink; // guessed symlink target
int extralen; // length of extra field
// parsing related info
bool exttimestamp_seen; // true if extended timestamp extra field
// has been parsed
bool newinfounix_seen; // true if Info-ZIP Unix New extra field has
// been parsed
ParseFileInfo() : perm(0100644), uid(-1), gid(-1), extralen(0),
exttimestamp_seen(false), newinfounix_seen(false) {
ctime = mtime = atime = time(0);
}
};
/** updates the parse information with the given extended timestamp extra field.
* @param buffer start content of buffer known to contain an extended
* timestamp extra field (without magic & size)
* @param size size of field content (must not count magic and size entries)
* @param islocal true if this is a local field, false if central
* @param pfi ParseFileInfo object to be updated
* @return true if processing was successful
*/
static bool parseExtTimestamp(const char *buffer, int size, bool islocal,
ParseFileInfo &pfi) {
if (size < 1) {
kDebug(7040) << "premature end of extended timestamp (#1)";
return false;
}/*end if*/
int flags = *buffer; // read flags
buffer += 1;
size -= 1;
if (flags & 1) { // contains modification time
if (size < 4) {
kDebug(7040) << "premature end of extended timestamp (#2)";
return false;
}/*end if*/
pfi.mtime = time_t((uchar)buffer[0] | (uchar)buffer[1] << 8
| (uchar)buffer[2] << 16 | (uchar)buffer[3] << 24);
buffer += 4;
size -= 4;
}/*end if*/
// central extended field cannot contain more than the modification time
// even if other flags are set
if (!islocal) {
pfi.exttimestamp_seen = true;
return true;
}/*end if*/
if (flags & 2) { // contains last access time
if (size < 4) {
kDebug(7040) << "premature end of extended timestamp (#3)";
return true;
}/*end if*/
pfi.atime = time_t((uchar)buffer[0] | (uchar)buffer[1] << 8
| (uchar)buffer[2] << 16 | (uchar)buffer[3] << 24);
buffer += 4;
size -= 4;
}/*end if*/
if (flags & 4) { // contains creation time
if (size < 4) {
kDebug(7040) << "premature end of extended timestamp (#4)";
return true;
}/*end if*/
pfi.ctime = time_t((uchar)buffer[0] | (uchar)buffer[1] << 8
| (uchar)buffer[2] << 16 | (uchar)buffer[3] << 24);
buffer += 4;
}/*end if*/
pfi.exttimestamp_seen = true;
return true;
}
/** updates the parse information with the given Info-ZIP Unix old extra field.
* @param buffer start of content of buffer known to contain an Info-ZIP
* Unix old extra field (without magic & size)
* @param size size of field content (must not count magic and size entries)
* @param islocal true if this is a local field, false if central
* @param pfi ParseFileInfo object to be updated
* @return true if processing was successful
*/
static bool parseInfoZipUnixOld(const char *buffer, int size, bool islocal,
ParseFileInfo &pfi) {
// spec mandates to omit this field if one of the newer fields are available
if (pfi.exttimestamp_seen || pfi.newinfounix_seen) return true;
if (size < 8) {
kDebug(7040) << "premature end of Info-ZIP unix extra field old";
return false;
}/*end if*/
pfi.atime = time_t((uchar)buffer[0] | (uchar)buffer[1] << 8
| (uchar)buffer[2] << 16 | (uchar)buffer[3] << 24);
buffer += 4;
pfi.mtime = time_t((uchar)buffer[0] | (uchar)buffer[1] << 8
| (uchar)buffer[2] << 16 | (uchar)buffer[3] << 24);
buffer += 4;
if (islocal && size >= 12) {
pfi.uid = (uchar)buffer[0] | (uchar)buffer[1] << 8;
buffer += 2;
pfi.gid = (uchar)buffer[0] | (uchar)buffer[1] << 8;
buffer += 2;
}/*end if*/
return true;
}
#if 0 // not needed yet
/** updates the parse information with the given Info-ZIP Unix new extra field.
* @param buffer start of content of buffer known to contain an Info-ZIP
* Unix new extra field (without magic & size)
* @param size size of field content (must not count magic and size entries)
* @param islocal true if this is a local field, false if central
* @param pfi ParseFileInfo object to be updated
* @return true if processing was successful
*/
static bool parseInfoZipUnixNew(const char *buffer, int size, bool islocal,
ParseFileInfo &pfi) {
if (!islocal) { // contains nothing in central field
pfi.newinfounix = true;
return true;
}/*end if*/
if (size < 4) {
kDebug(7040) << "premature end of Info-ZIP unix extra field new";
return false;
}/*end if*/
pfi.uid = (uchar)buffer[0] | (uchar)buffer[1] << 8;
buffer += 2;
pfi.gid = (uchar)buffer[0] | (uchar)buffer[1] << 8;
buffer += 2;
pfi.newinfounix = true;
return true;
}
#endif
/**
* parses the extra field
* @param buffer start of buffer where the extra field is to be found
* @param size size of the extra field
* @param islocal true if this is part of a local header, false if of central
* @param pfi ParseFileInfo object which to write the results into
* @return true if parsing was successful
*/
static bool parseExtraField(const char *buffer, int size, bool islocal,
ParseFileInfo &pfi) {
// extra field in central directory doesn't contain useful data, so we
// don't bother parsing it
if (!islocal) return true;
while (size >= 4) { // as long as a potential extra field can be read
int magic = (uchar)buffer[0] | (uchar)buffer[1] << 8;
buffer += 2;
int fieldsize = (uchar)buffer[0] | (uchar)buffer[1] << 8;
buffer += 2;
size -= 4;
if (fieldsize > size) {
//kDebug(7040) << "fieldsize: " << fieldsize << " size: " << size;
kDebug(7040) << "premature end of extra fields reached";
break;
}/*end if*/
switch (magic) {
case 0x5455: // extended timestamp
if (!parseExtTimestamp(buffer, fieldsize, islocal, pfi)) return false;
break;
case 0x5855: // old Info-ZIP unix extra field
if (!parseInfoZipUnixOld(buffer, fieldsize, islocal, pfi)) return false;
break;
#if 0 // not needed yet
case 0x7855: // new Info-ZIP unix extra field
if (!parseInfoZipUnixNew(buffer, fieldsize, islocal, pfi)) return false;
break;
#endif
default:
/* ignore everything else */;
}/*end switch*/
buffer += fieldsize;
size -= fieldsize;
}/*wend*/
return true;
}
////////////////////////////////////////////////////////////////////////
/////////////////////////// KZip ///////////////////////////////////////
////////////////////////////////////////////////////////////////////////
class KZip::KZipPrivate
{
public:
KZipPrivate()
: m_crc( 0 ),
m_currentFile( 0 ),
m_currentDev( 0 ),
m_compression( 8 ),
m_extraField( KZip::NoExtraField ),
m_offset( 0 )
{}
unsigned long m_crc; // checksum
KZipFileEntry* m_currentFile; // file currently being written
QIODevice* m_currentDev; // filterdev used to write to the above file
QList<KZipFileEntry*> m_fileList; // flat list of all files, for the index (saves a recursive method ;)
int m_compression;
KZip::ExtraField m_extraField;
// m_offset holds the offset of the place in the zip,
// where new data can be appended. after openarchive it points to 0, when in
// writeonly mode, or it points to the beginning of the central directory.
// each call to writefile updates this value.
quint64 m_offset;
};
KZip::KZip( const QString& fileName )
: KArchive( fileName ),d(new KZipPrivate)
{
}
KZip::KZip( QIODevice * dev )
: KArchive( dev ),d(new KZipPrivate)
{
}
KZip::~KZip()
{
//kDebug(7040) << this;
if( isOpen() )
close();
delete d;
}
bool KZip::openArchive( QIODevice::OpenMode mode )
{
//kDebug(7040);
d->m_fileList.clear();
if ( mode == QIODevice::WriteOnly )
return true;
char buffer[47];
// Check that it's a valid ZIP file
// KArchive::open() opened the underlying device already.
quint64 offset = 0; // holds offset, where we read
int n;
// contains information gathered from the local file headers
QHash<QByteArray, ParseFileInfo> pfi_map;
QIODevice* dev = device();
// We set a bool for knowing if we are allowed to skip the start of the file
bool startOfFile = true;
for (;;) // repeat until 'end of entries' signature is reached
{
//kDebug(7040) << "loop starts";
//kDebug(7040) << "dev->pos() now : " << dev->pos();
n = dev->read( buffer, 4 );
if (n < 4)
{
kWarning(7040) << "Invalid ZIP file. Unexpected end of file. (#1)";
return false;
}
if ( !memcmp( buffer, "PK\5\6", 4 ) ) // 'end of entries'
{
//kDebug(7040) << "PK56 found end of archive";
startOfFile = false;
break;
}
if ( !memcmp( buffer, "PK\3\4", 4 ) ) // local file header
{
//kDebug(7040) << "PK34 found local file header";
startOfFile = false;
// can this fail ???
dev->seek( dev->pos() + 2 ); // skip 'version needed to extract'
// read static header stuff
n = dev->read( buffer, 24 );
if (n < 24) {
kWarning(7040) << "Invalid ZIP file. Unexpected end of file. (#4)";
return false;
}
int gpf = (uchar)buffer[0]; // "general purpose flag" not "general protection fault" ;-)
int compression_mode = (uchar)buffer[2] | (uchar)buffer[3] << 8;
time_t mtime = transformFromMsDos( buffer+4 );
const qint64 compr_size = uint(uchar(buffer[12])) | uint(uchar(buffer[13])) << 8 |
uint(uchar(buffer[14])) << 16 | uint(uchar(buffer[15])) << 24;
const qint64 uncomp_size = uint(uchar(buffer[16])) | uint(uchar(buffer[17])) << 8 |
uint(uchar(buffer[18])) << 16 | uint(uchar(buffer[19])) << 24;
const int namelen = uint(uchar(buffer[20])) | uint(uchar(buffer[21])) << 8;
const int extralen = uint(uchar(buffer[22])) | uint(uchar(buffer[23])) << 8;
/*
kDebug(7040) << "general purpose bit flag: " << gpf;
kDebug(7040) << "compressed size: " << compr_size;
kDebug(7040) << "uncompressed size: " << uncomp_size;
kDebug(7040) << "namelen: " << namelen;
kDebug(7040) << "extralen: " << extralen;
kDebug(7040) << "archive size: " << dev->size();
*/
// read fileName
Q_ASSERT( namelen > 0 );
QByteArray fileName = dev->read(namelen);
if ( fileName.size() < namelen ) {
kWarning(7040) << "Invalid ZIP file. Name not completely read (#2)";
return false;
}
ParseFileInfo pfi;
pfi.mtime = mtime;
// read and parse the beginning of the extra field,
// skip rest of extra field in case it is too long
unsigned int extraFieldEnd = dev->pos() + extralen;
pfi.extralen = extralen;
int handledextralen = qMin(extralen, (int)sizeof buffer);
//if ( handledextralen )
// kDebug(7040) << "handledextralen: " << handledextralen;
n = dev->read(buffer, handledextralen);
// no error msg necessary as we deliberately truncate the extra field
if (!parseExtraField(buffer, handledextralen, true, pfi))
{
kWarning(7040) << "Invalid ZIP File. Broken ExtraField.";
return false;
}
// jump to end of extra field
dev->seek( extraFieldEnd );
// we have to take care of the 'general purpose bit flag'.
// if bit 3 is set, the header doesn't contain the length of
// the file and we look for the signature 'PK\7\8'.
if ( gpf & 8 )
{
// here we have to read through the compressed data to find
// the next PKxx
//kDebug(7040) << "trying to seek for next PK78";
bool foundSignature = false;
while (!foundSignature)
{
n = dev->read( buffer, 1 );
if (n < 1)
{
kWarning(7040) << "Invalid ZIP file. Unexpected end of file. (#2)";
return false;
}
if ( buffer[0] != 'P' )
continue;
n = dev->read( buffer, 3 );
if (n < 3)
{
kWarning(7040) << "Invalid ZIP file. Unexpected end of file. (#3)";
return false;
}
// we have to detect three magic tokens here:
// PK34 for the next local header in case there is no data descriptor
// PK12 for the central header in case there is no data descriptor
// PK78 for the data descriptor in case it is following the compressed data
if ( buffer[0] == 'K' && buffer[1] == 7 && buffer[2] == 8 )
{
foundSignature = true;
dev->seek( dev->pos() + 12 ); // skip the 'data_descriptor'
}
else if ( ( buffer[0] == 'K' && buffer[1] == 1 && buffer[2] == 2 )
|| ( buffer[0] == 'K' && buffer[1] == 3 && buffer[2] == 4 ) )
{
foundSignature = true;
dev->seek( dev->pos() - 4 ); // go back 4 bytes, so that the magic bytes can be found...
}
else if ( buffer[0] == 'P' || buffer[1] == 'P' || buffer[2] == 'P' )
{
// We have another P character so we must go back a little to check if it is a magic
dev->seek( dev->pos() - 3 );
}
}
}
else
{
// here we skip the compressed data and jump to the next header
//kDebug(7040) << "general purpose bit flag indicates, that local file header contains valid size";
// check if this could be a symbolic link
if (compression_mode == NoCompression
&& uncomp_size <= max_path_len
&& uncomp_size > 0) {
// read content and store it
// If it's not a symlink, then we'll just discard the data for now.
pfi.guessed_symlink = dev->read(uncomp_size);
if (pfi.guessed_symlink.size() < uncomp_size) {
kWarning(7040) << "Invalid ZIP file. Unexpected end of file. (#5)";
return false;
}
} else {
if ( compr_size > dev->size() )
{
// here we cannot trust the compressed size, so scan through the compressed
// data to find the next header
bool foundSignature = false;
while (!foundSignature)
{
n = dev->read( buffer, 1 );
if (n < 1)
{
kWarning(7040) << "Invalid ZIP file. Unexpected end of file. (#2)";
return false;
}
if ( buffer[0] != 'P' )
continue;
n = dev->read( buffer, 3 );
if (n < 3)
{
kWarning(7040) << "Invalid ZIP file. Unexpected end of file. (#3)";
return false;
}
// we have to detect three magic tokens here:
// PK34 for the next local header in case there is no data descriptor
// PK12 for the central header in case there is no data descriptor
// PK78 for the data descriptor in case it is following the compressed data
if ( buffer[0] == 'K' && buffer[1] == 7 && buffer[2] == 8 )
{
foundSignature = true;
dev->seek( dev->pos() + 12 ); // skip the 'data_descriptor'
}
if ( ( buffer[0] == 'K' && buffer[1] == 1 && buffer[2] == 2 )
|| ( buffer[0] == 'K' && buffer[1] == 3 && buffer[2] == 4 ) )
{
foundSignature = true;
dev->seek( dev->pos() - 4 );
// go back 4 bytes, so that the magic bytes can be found
// in the next cycle...
}
}
}
else
{
// kDebug(7040) << "before interesting dev->pos(): " << dev->pos();
bool success = dev->seek( dev->pos() + compr_size ); // can this fail ???
Q_UNUSED( success ); // prevent warning in release builds.
Q_ASSERT( success ); // let's see...
/* kDebug(7040) << "after interesting dev->pos(): " << dev->pos();
if ( success )
kDebug(7040) << "dev->at was successful... ";
else
kDebug(7040) << "dev->at failed... ";*/
}
}
// not needed any more
/* // here we calculate the length of the file in the zip
// with headers and jump to the next header.
uint skip = compr_size + namelen + extralen;
offset += 30 + skip;*/
}
pfi_map.insert(fileName, pfi);
}
else if ( !memcmp( buffer, "PK\1\2", 4 ) ) // central block
{
//kDebug(7040) << "PK12 found central block";
startOfFile = false;
// so we reached the central header at the end of the zip file
// here we get all interesting data out of the central header
// of a file
offset = dev->pos() - 4;
//set offset for appending new files
if ( d->m_offset == 0L ) d->m_offset = offset;
n = dev->read( buffer + 4, 42 );
if (n < 42) {
kWarning(7040) << "Invalid ZIP file, central entry too short"; // not long enough for valid entry
return false;
}
//int gpf = (uchar)buffer[9] << 8 | (uchar)buffer[10];
//kDebug() << "general purpose flag=" << gpf;
// length of the fileName (well, pathname indeed)
int namelen = (uchar)buffer[29] << 8 | (uchar)buffer[28];
Q_ASSERT( namelen > 0 );
QByteArray bufferName = dev->read( namelen );
if ( bufferName.size() < namelen )
kWarning(7040) << "Invalid ZIP file. Name not completely read";
ParseFileInfo pfi = pfi_map.value( bufferName, ParseFileInfo() );
QString name( QFile::decodeName(bufferName) );
//kDebug(7040) << "name: " << name;
// only in central header ! see below.
// length of extra attributes
int extralen = (uchar)buffer[31] << 8 | (uchar)buffer[30];
// length of comment for this file
int commlen = (uchar)buffer[33] << 8 | (uchar)buffer[32];
// compression method of this file
int cmethod = (uchar)buffer[11] << 8 | (uchar)buffer[10];
//kDebug(7040) << "cmethod: " << cmethod;
//kDebug(7040) << "extralen: " << extralen;
// crc32 of the file
uint crc32 = (uchar)buffer[19] << 24 | (uchar)buffer[18] << 16 |
(uchar)buffer[17] << 8 | (uchar)buffer[16];
// uncompressed file size
uint ucsize = (uchar)buffer[27] << 24 | (uchar)buffer[26] << 16 |
(uchar)buffer[25] << 8 | (uchar)buffer[24];
// compressed file size
uint csize = (uchar)buffer[23] << 24 | (uchar)buffer[22] << 16 |
(uchar)buffer[21] << 8 | (uchar)buffer[20];
// offset of local header
uint localheaderoffset = (uchar)buffer[45] << 24 | (uchar)buffer[44] << 16 |
(uchar)buffer[43] << 8 | (uchar)buffer[42];
// some clever people use different extra field lengths
// in the central header and in the local header... funny.
// so we need to get the localextralen to calculate the offset
// from localheaderstart to dataoffset
int localextralen = pfi.extralen; // FIXME: this will not work if
// no local header exists
//kDebug(7040) << "localextralen: " << localextralen;
// offset, where the real data for uncompression starts
uint dataoffset = localheaderoffset + 30 + localextralen + namelen; //comment only in central header
//kDebug(7040) << "esize: " << esize;
//kDebug(7040) << "eoffset: " << eoffset;
//kDebug(7040) << "csize: " << csize;
int os_madeby = (uchar)buffer[5];
bool isdir = false;
int access = 0100644;
if (os_madeby == 3) { // good ole unix
access = (uchar)buffer[40] | (uchar)buffer[41] << 8;
}
QString entryName;
if (name.endsWith(QLatin1Char('/'))) { // Entries with a trailing slash are directories
isdir = true;
name = name.left( name.length() - 1 );
if (os_madeby != 3) access = S_IFDIR | 0755;
else Q_ASSERT(access & S_IFDIR);
}
int pos = name.lastIndexOf(QLatin1Char('/'));
if ( pos == -1 )
entryName = name;
else
entryName = name.mid( pos + 1 );
Q_ASSERT( !entryName.isEmpty() );
KArchiveEntry* entry;
if ( isdir )
{
QString path = QDir::cleanPath( name );
const KArchiveEntry* ent = rootDir()->entry( path );
if ( ent && ent->isDirectory() )
{
//kDebug(7040) << "Directory already exists, NOT going to add it again";
entry = 0;
}
else
{
entry = new KArchiveDirectory( this, entryName, access, (int)pfi.mtime, rootDir()->user(), rootDir()->group(), QString() );
//kDebug(7040) << "KArchiveDirectory created, entryName= " << entryName << ", name=" << name;
}
}
else
{
QString symlink;
if (S_ISLNK(access)) {
symlink = QFile::decodeName(pfi.guessed_symlink);
}
entry = new KZipFileEntry( this, entryName, access, pfi.mtime,
rootDir()->user(), rootDir()->group(),
symlink, name, dataoffset,
ucsize, cmethod, csize );
static_cast<KZipFileEntry *>(entry)->setHeaderStart( localheaderoffset );
static_cast<KZipFileEntry*>(entry)->setCRC32(crc32);
//kDebug(7040) << "KZipFileEntry created, entryName= " << entryName << ", name=" << name;
d->m_fileList.append( static_cast<KZipFileEntry *>( entry ) );
}
if ( entry )
{
if ( pos == -1 )
{
rootDir()->addEntry(entry);
}
else
{
// In some tar files we can find dir/./file => call cleanPath
QString path = QDir::cleanPath( name.left( pos ) );
// Ensure container directory exists, create otherwise
KArchiveDirectory * tdir = findOrCreate( path );
tdir->addEntry(entry);
}
}
//calculate offset to next entry
offset += 46 + commlen + extralen + namelen;
bool b = dev->seek(offset);
Q_ASSERT( b );
if ( !b )
return false;
}
else if ( startOfFile )
{
// The file does not start with any ZIP header (e.g. self-extractable ZIP files)
// Therefore we need to find the first PK\003\004 (local header)
//kDebug(7040) << "Try to skip start of file";
startOfFile = false;
bool foundSignature = false;
while (!foundSignature)
{
n = dev->read( buffer, 1 );
if (n < 1)
{
kWarning(7040) << "Invalid ZIP file. Unexpected end of file. " ;
return false;
}
if ( buffer[0] != 'P' )
continue;
n = dev->read( buffer, 3 );
if (n < 3)
{
kWarning(7040) << "Invalid ZIP file. Unexpected end of file. " ;
return false;
}
// We have to detect the magic token for a local header: PK\003\004
/*
* Note: we do not need to check the other magics, if the ZIP file has no
* local header, then it has not any files!
*/
if ( buffer[0] == 'K' && buffer[1] == 3 && buffer[2] == 4 )
{
foundSignature = true;
dev->seek( dev->pos() - 4 ); // go back 4 bytes, so that the magic bytes can be found...
}
else if ( buffer[0] == 'P' || buffer[1] == 'P' || buffer[2] == 'P' )
{
// We have another P character so we must go back a little to check if it is a magic
dev->seek( dev->pos() - 3 );
}
}
}
else
{
kWarning(7040) << "Invalid ZIP file. Unrecognized header at offset " << offset;
return false;
}
}
//kDebug(7040) << "*** done *** ";
return true;
}
bool KZip::closeArchive()
{
if ( ! ( mode() & QIODevice::WriteOnly ) )
{
//kDebug(7040) << "readonly";
return true;
}
//ReadWrite or WriteOnly
//write all central dir file entries
// to be written at the end of the file...
char buffer[ 22 ]; // first used for 12, then for 22 at the end
uLong crc = crc32(0L, Z_NULL, 0);
qint64 centraldiroffset = device()->pos();
//kDebug(7040) << "closearchive: centraldiroffset: " << centraldiroffset;
qint64 atbackup = centraldiroffset;
QMutableListIterator<KZipFileEntry*> it( d->m_fileList );
while(it.hasNext())
{ //set crc and compressed size in each local file header
it.next();
if ( !device()->seek( it.value()->headerStart() + 14 ) )
return false;
//kDebug(7040) << "closearchive setcrcandcsize: fileName:"
// << it.current()->path()
// << "encoding:" << it.current()->encoding();
uLong mycrc = it.value()->crc32();
buffer[0] = char(mycrc); // crc checksum, at headerStart+14
buffer[1] = char(mycrc >> 8);
buffer[2] = char(mycrc >> 16);
buffer[3] = char(mycrc >> 24);
int mysize1 = it.value()->compressedSize();
buffer[4] = char(mysize1); // compressed file size, at headerStart+18
buffer[5] = char(mysize1 >> 8);
buffer[6] = char(mysize1 >> 16);
buffer[7] = char(mysize1 >> 24);
int myusize = it.value()->size();
buffer[8] = char(myusize); // uncompressed file size, at headerStart+22
buffer[9] = char(myusize >> 8);
buffer[10] = char(myusize >> 16);
buffer[11] = char(myusize >> 24);
if ( device()->write( buffer, 12 ) != 12 )
return false;
}
device()->seek( atbackup );
it.toFront();
while (it.hasNext())
{
it.next();
//kDebug(7040) << "fileName:" << it.current()->path()
// << "encoding:" << it.current()->encoding();
QByteArray path = QFile::encodeName(it.value()->path());
const int extra_field_len = 9;
int bufferSize = extra_field_len + path.length() + 46;
char* buffer = new char[ bufferSize ];
memset(buffer, 0, 46); // zero is a nice default for most header fields
const char head[] =
{
'P', 'K', 1, 2, // central file header signature
0x14, 3, // version made by (3 == UNIX)
0x14, 0 // version needed to extract
};
// I do not know why memcpy is not working here
//memcpy(buffer, head, sizeof(head));
memmove(buffer, head, sizeof(head));
buffer[ 10 ] = char(it.value()->encoding()); // compression method
buffer[ 11 ] = char(it.value()->encoding() >> 8);
transformToMsDos( it.value()->datetime(), &buffer[ 12 ] );
uLong mycrc = it.value()->crc32();
buffer[ 16 ] = char(mycrc); // crc checksum
buffer[ 17 ] = char(mycrc >> 8);
buffer[ 18 ] = char(mycrc >> 16);
buffer[ 19 ] = char(mycrc >> 24);
int mysize1 = it.value()->compressedSize();
buffer[ 20 ] = char(mysize1); // compressed file size
buffer[ 21 ] = char(mysize1 >> 8);
buffer[ 22 ] = char(mysize1 >> 16);
buffer[ 23 ] = char(mysize1 >> 24);
int mysize = it.value()->size();
buffer[ 24 ] = char(mysize); // uncompressed file size
buffer[ 25 ] = char(mysize >> 8);
buffer[ 26 ] = char(mysize >> 16);
buffer[ 27 ] = char(mysize >> 24);
buffer[ 28 ] = char(path.length()); // fileName length
buffer[ 29 ] = char(path.length() >> 8);
buffer[ 30 ] = char(extra_field_len);
buffer[ 31 ] = char(extra_field_len >> 8);
buffer[ 40 ] = char(it.value()->permissions());
buffer[ 41 ] = char(it.value()->permissions() >> 8);
int myhst = it.value()->headerStart();
buffer[ 42 ] = char(myhst); //relative offset of local header
buffer[ 43 ] = char(myhst >> 8);
buffer[ 44 ] = char(myhst >> 16);
buffer[ 45 ] = char(myhst >> 24);
// file name
strncpy( buffer + 46, path, path.length() );
//kDebug(7040) << "closearchive length to write: " << bufferSize;
// extra field
char *extfield = buffer + 46 + path.length();
extfield[0] = 'U';
extfield[1] = 'T';
extfield[2] = 5;
extfield[3] = 0;
extfield[4] = 1 | 2 | 4; // specify flags from local field
// (unless I misread the spec)
// provide only modification time
unsigned long time = (unsigned long)it.value()->date();
extfield[5] = char(time);
extfield[6] = char(time >> 8);
extfield[7] = char(time >> 16);
extfield[8] = char(time >> 24);
crc = crc32(crc, (Bytef *)buffer, bufferSize );
bool ok = ( device()->write( buffer, bufferSize ) == bufferSize );
delete[] buffer;
if ( !ok )
return false;
}
qint64 centraldirendoffset = device()->pos();
//kDebug(7040) << "closearchive: centraldirendoffset: " << centraldirendoffset;
//kDebug(7040) << "closearchive: device()->pos(): " << device()->pos();
//write end of central dir record.
buffer[ 0 ] = 'P'; //end of central dir signature
buffer[ 1 ] = 'K';
buffer[ 2 ] = 5;
buffer[ 3 ] = 6;
buffer[ 4 ] = 0; // number of this disk
buffer[ 5 ] = 0;
buffer[ 6 ] = 0; // number of disk with start of central dir
buffer[ 7 ] = 0;
int count = d->m_fileList.count();
//kDebug(7040) << "number of files (count): " << count;
buffer[ 8 ] = char(count); // total number of entries in central dir of
buffer[ 9 ] = char(count >> 8); // this disk
buffer[ 10 ] = buffer[ 8 ]; // total number of entries in the central dir
buffer[ 11 ] = buffer[ 9 ];
int cdsize = centraldirendoffset - centraldiroffset;
buffer[ 12 ] = char(cdsize); // size of the central dir
buffer[ 13 ] = char(cdsize >> 8);
buffer[ 14 ] = char(cdsize >> 16);
buffer[ 15 ] = char(cdsize >> 24);
//kDebug(7040) << "end : centraldiroffset: " << centraldiroffset;
//kDebug(7040) << "end : centraldirsize: " << cdsize;
buffer[ 16 ] = char(centraldiroffset); // central dir offset
buffer[ 17 ] = char(centraldiroffset >> 8);
buffer[ 18 ] = char(centraldiroffset >> 16);
buffer[ 19 ] = char(centraldiroffset >> 24);
buffer[ 20 ] = 0; //zipfile comment length
buffer[ 21 ] = 0;
if ( device()->write( buffer, 22 ) != 22 )
return false;
return true;
}
bool KZip::doWriteDir( const QString &name, const QString &user, const QString &group,
mode_t perm, time_t atime, time_t mtime, time_t ctime ) {
// Zip files have no explicit directories, they are implicitly created during extraction time
// when file entries have paths in them.
// However, to support empty directories, we must create a dummy file entry which ends with '/'.
QString dirName = name;
if (!name.endsWith(QLatin1Char('/')))
dirName = dirName.append(QLatin1Char('/'));
return writeFile(dirName, user, group, 0, 0, perm, atime, mtime, ctime);
}
bool KZip::doPrepareWriting(const QString &name, const QString &user,
const QString &group, qint64 /*size*/, mode_t perm,
time_t atime, time_t mtime, time_t ctime) {
//kDebug(7040);
if ( !isOpen() )
{
qWarning( "KZip::writeFile: You must open the zip file before writing to it\n");
return false;
}
if ( ! ( mode() & QIODevice::WriteOnly ) ) // accept WriteOnly and ReadWrite
{
qWarning( "KZip::writeFile: You must open the zip file for writing\n");
return false;
}
Q_ASSERT( device() );
// set right offset in zip.
if ( !device()->seek( d->m_offset ) ) {
kWarning(7040) << "doPrepareWriting: cannot seek in ZIP file. Disk full?";
return false;
}
// Find or create parent dir
KArchiveDirectory* parentDir = rootDir();
QString fileName( name );
int i = name.lastIndexOf(QLatin1Char('/'));
if (i != -1) {
QString dir = name.left( i );
fileName = name.mid( i + 1 );
//kDebug(7040) << "ensuring" << dir << "exists. fileName=" << fileName;
parentDir = findOrCreate( dir );
}
// delete entries in the filelist with the same fileName as the one we want
// to save, so that we don't have duplicate file entries when viewing the zip
// with konqi...
// CAUTION: the old file itself is still in the zip and won't be removed !!!
QMutableListIterator<KZipFileEntry*> it( d->m_fileList );
//kDebug(7040) << "fileName to write: " << name;
while(it.hasNext())
{
it.next();
//kDebug(7040) << "prepfileName: " << it.current()->path();
if (name == it.value()->path() )
{
// also remove from the parentDir
parentDir->removeEntry(it.value());
//kDebug(7040) << "removing following entry: " << it.current()->path();
delete it.value();
it.remove();
}
}
// construct a KZipFileEntry and add it to list
KZipFileEntry * e = new KZipFileEntry( this, fileName, perm, mtime, user, group, QString(),
name, device()->pos() + 30 + name.length(), // start
0 /*size unknown yet*/, d->m_compression, 0 /*csize unknown yet*/ );
e->setHeaderStart( device()->pos() );
//kDebug(7040) << "wrote file start: " << e->position() << " name: " << name;
parentDir->addEntry( e );
d->m_currentFile = e;
d->m_fileList.append( e );
int extra_field_len = 0;
if ( d->m_extraField == ModificationTime )
extra_field_len = 17; // value also used in finishWriting()
// write out zip header
QByteArray encodedName = QFile::encodeName(name);
int bufferSize = extra_field_len + encodedName.length() + 30;
//kDebug(7040) << "bufferSize=" << bufferSize;
char* buffer = new char[ bufferSize ];
buffer[ 0 ] = 'P'; //local file header signature
buffer[ 1 ] = 'K';
buffer[ 2 ] = 3;
buffer[ 3 ] = 4;
buffer[ 4 ] = 0x14; // version needed to extract
buffer[ 5 ] = 0;
buffer[ 6 ] = 0; // general purpose bit flag
buffer[ 7 ] = 0;
buffer[ 8 ] = char(e->encoding()); // compression method
buffer[ 9 ] = char(e->encoding() >> 8);
transformToMsDos( e->datetime(), &buffer[ 10 ] );
buffer[ 14 ] = 'C'; //dummy crc
buffer[ 15 ] = 'R';
buffer[ 16 ] = 'C';
buffer[ 17 ] = 'q';
buffer[ 18 ] = 'C'; //compressed file size
buffer[ 19 ] = 'S';
buffer[ 20 ] = 'I';
buffer[ 21 ] = 'Z';
buffer[ 22 ] = 'U'; //uncompressed file size
buffer[ 23 ] = 'S';
buffer[ 24 ] = 'I';
buffer[ 25 ] = 'Z';
buffer[ 26 ] = (uchar)(encodedName.length()); //fileName length
buffer[ 27 ] = (uchar)(encodedName.length() >> 8);
buffer[ 28 ] = (uchar)(extra_field_len); // extra field length
buffer[ 29 ] = (uchar)(extra_field_len >> 8);
// file name
strncpy( buffer + 30, encodedName, encodedName.length() );
// extra field
if ( d->m_extraField == ModificationTime )
{
char *extfield = buffer + 30 + encodedName.length();
// "Extended timestamp" header (0x5455)
extfield[0] = 'U';
extfield[1] = 'T';
extfield[2] = 13; // data size
extfield[3] = 0;
extfield[4] = 1 | 2 | 4; // contains mtime, atime, ctime
extfield[5] = char(mtime);
extfield[6] = char(mtime >> 8);
extfield[7] = char(mtime >> 16);
extfield[8] = char(mtime >> 24);
extfield[9] = char(atime);
extfield[10] = char(atime >> 8);
extfield[11] = char(atime >> 16);
extfield[12] = char(atime >> 24);
extfield[13] = char(ctime);
extfield[14] = char(ctime >> 8);
extfield[15] = char(ctime >> 16);
extfield[16] = char(ctime >> 24);
}
// Write header
bool b = (device()->write( buffer, bufferSize ) == bufferSize );
d->m_crc = 0L;
delete[] buffer;
Q_ASSERT( b );
if (!b) {
return false;
}
// Prepare device for writing the data
// Either device() if no compression, or a KFilterDev to compress
if ( d->m_compression == 0 ) {
d->m_currentDev = device();
return true;
}
d->m_currentDev = KFilterDev::device( device(), QString::fromLatin1("application/x-gzip"), false );
Q_ASSERT( d->m_currentDev );
if ( !d->m_currentDev ) {
return false; // ouch
}
static_cast<KFilterDev *>(d->m_currentDev)->setSkipHeaders(); // Just zlib, not gzip
b = d->m_currentDev->open( QIODevice::WriteOnly );
Q_ASSERT( b );
return b;
}
bool KZip::doFinishWriting( qint64 size )
{
if ( d->m_currentFile->encoding() == 8 ) {
// Finish
(void)d->m_currentDev->write( 0, 0 );
delete d->m_currentDev;
}
// If 0, d->m_currentDev was device() - don't delete ;)
d->m_currentDev = 0L;
Q_ASSERT( d->m_currentFile );
//kDebug(7040) << "fileName: " << d->m_currentFile->path();
//kDebug(7040) << "getpos (at): " << device()->pos();
d->m_currentFile->setSize(size);
int extra_field_len = 0;
if ( d->m_extraField == ModificationTime )
extra_field_len = 17; // value also used in finishWriting()
const QByteArray encodedName = QFile::encodeName(d->m_currentFile->path());
int csize = device()->pos() -
d->m_currentFile->headerStart() - 30 -
encodedName.length() - extra_field_len;
d->m_currentFile->setCompressedSize(csize);
//kDebug(7040) << "usize: " << d->m_currentFile->size();
//kDebug(7040) << "csize: " << d->m_currentFile->compressedSize();
//kDebug(7040) << "headerstart: " << d->m_currentFile->headerStart();
//kDebug(7040) << "crc: " << d->m_crc;
d->m_currentFile->setCRC32( d->m_crc );
d->m_currentFile = 0L;
// update saved offset for appending new files
d->m_offset = device()->pos();
return true;
}
bool KZip::doWriteSymLink(const QString &name, const QString &target,
const QString &user, const QString &group,
mode_t perm, time_t atime, time_t mtime, time_t ctime) {
// reassure that symlink flag is set, otherwise strange things happen on
// extraction
perm |= S_IFLNK;
Compression c = compression();
setCompression(NoCompression); // link targets are never compressed
if (!doPrepareWriting(name, user, group, 0, perm, atime, mtime, ctime)) {
kWarning() << "prepareWriting failed";
setCompression(c);
return false;
}
QByteArray symlink_target = QFile::encodeName(target);
if (!writeData(symlink_target, symlink_target.length())) {
kWarning() << "writeData failed";
setCompression(c);
return false;
}
if (!finishWriting(symlink_target.length())) {
kWarning() << "finishWriting failed";
setCompression(c);
return false;
}
setCompression(c);
return true;
}
void KZip::virtual_hook( int id, void* data )
{
KArchive::virtual_hook( id, data );
}
bool KZip::writeData(const char * data, qint64 size)
{
Q_ASSERT( d->m_currentFile );
Q_ASSERT( d->m_currentDev );
if (!d->m_currentFile || !d->m_currentDev) {
return false;
}
// crc to be calculated over uncompressed stuff...
// and they didn't mention it in their docs...
d->m_crc = crc32(d->m_crc, (const Bytef *) data , size);
qint64 written = d->m_currentDev->write( data, size );
//kDebug(7040) << "wrote" << size << "bytes.";
return written == size;
}
void KZip::setCompression( Compression c )
{
d->m_compression = ( c == NoCompression ) ? 0 : 8;
}
KZip::Compression KZip::compression() const
{
return ( d->m_compression == 8 ) ? DeflateCompression : NoCompression;
}
void KZip::setExtraField( ExtraField ef )
{
d->m_extraField = ef;
}
KZip::ExtraField KZip::extraField() const
{
return d->m_extraField;
}
////////////////////////////////////////////////////////////////////////
////////////////////// KZipFileEntry////////////////////////////////////
////////////////////////////////////////////////////////////////////////
class KZipFileEntry::KZipFileEntryPrivate
{
public:
KZipFileEntryPrivate()
: crc(0),
compressedSize(0),
headerStart(0),
encoding(0)
{}
unsigned long crc;
qint64 compressedSize;
qint64 headerStart;
int encoding;
QString path;
};
KZipFileEntry::KZipFileEntry(KZip* zip, const QString& name, int access, int date,
const QString& user, const QString& group, const QString& symlink,
const QString& path, qint64 start, qint64 uncompressedSize,
int encoding, qint64 compressedSize)
: KArchiveFile(zip, name, access, date, user, group, symlink, start, uncompressedSize ),
d(new KZipFileEntryPrivate)
{
d->path = path;
d->encoding = encoding;
d->compressedSize = compressedSize;
}
KZipFileEntry::~KZipFileEntry()
{
delete d;
}
int KZipFileEntry::encoding() const
{
return d->encoding;
}
qint64 KZipFileEntry::compressedSize() const
{
return d->compressedSize;
}
void KZipFileEntry::setCompressedSize(qint64 compressedSize)
{
d->compressedSize = compressedSize;
}
void KZipFileEntry::setHeaderStart(qint64 headerstart)
{
d->headerStart = headerstart;
}
qint64 KZipFileEntry::headerStart() const
{
return d->headerStart;
}
unsigned long KZipFileEntry::crc32() const
{
return d->crc;
}
void KZipFileEntry::setCRC32(unsigned long crc32)
{
d->crc=crc32;
}
const QString &KZipFileEntry::path() const
{
return d->path;
}
QByteArray KZipFileEntry::data() const
{
QIODevice* dev = createDevice();
QByteArray arr;
if ( dev ) {
arr = dev->readAll();
delete dev;
}
return arr;
}
QIODevice* KZipFileEntry::createDevice() const
{
//kDebug(7040) << "creating iodevice limited to pos=" << position() << ", csize=" << compressedSize();
// Limit the reading to the appropriate part of the underlying device (e.g. file)
KLimitedIODevice* limitedDev = new KLimitedIODevice( archive()->device(), position(), compressedSize() );
if ( encoding() == 0 || compressedSize() == 0 ) // no compression (or even no data)
return limitedDev;
if ( encoding() == 8 )
{
// On top of that, create a device that uncompresses the zlib data
QIODevice* filterDev = KFilterDev::device( limitedDev, QString::fromLatin1("application/x-gzip") );
if ( !filterDev )
return 0L; // ouch
static_cast<KFilterDev *>(filterDev)->setSkipHeaders(); // Just zlib, not gzip
bool b = filterDev->open( QIODevice::ReadOnly );
Q_UNUSED( b );
Q_ASSERT( b );
return filterDev;
}
kError() << "This zip file contains files compressed with method"
<< encoding() << ", this method is currently not supported by KZip,"
<< "please use a command-line tool to handle this file.";
return 0L;
}
Reference in a new issue View git blame Copy permalink