diff options
Diffstat (limited to 'tdeio/tdeio/kzip.cpp')
-rw-r--r-- | tdeio/tdeio/kzip.cpp | 1460 |
1 files changed, 1460 insertions, 0 deletions
diff --git a/tdeio/tdeio/kzip.cpp b/tdeio/tdeio/kzip.cpp new file mode 100644 index 000000000..85dcb76d1 --- /dev/null +++ b/tdeio/tdeio/kzip.cpp @@ -0,0 +1,1460 @@ +/* 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. +*/ + +/* + This class implements a tdeioslave to access ZIP files from KDE. + you can use it in IO_ReadOnly or in IO_WriteOnly mode, and it + behaves just as expected (i hope ;-) ). + It can also be used in IO_ReadWrite mode, in this case one can + append files to an existing zip archive. when you append new files, which + are not yet in the zip, it works as expected, they are appended at the end. + when you append a file, which is already in the file, the reference to the + old file is dropped and the new one is added to the zip. but the + old data from the file itself is not deleted, it is still in the + zipfile. so when you want to have a small and garbagefree zipfile, + just read the contents of the appended zipfile and write it to a new one + in IO_WriteOnly mode. especially take care of this, when you don't want + to leak information of how intermediate versions of files in the zip + were looking. + For more information on the zip fileformat go to + http://www.pkware.com/support/appnote.html . + +*/ + +#include "kzip.h" +#include "kfilterdev.h" +#include "klimitediodevice.h" +#include <kmimetype.h> +#include <ksavefile.h> +#include <kdebug.h> + +#include <tqasciidict.h> +#include <tqfile.h> +#include <tqdir.h> +#include <tqdatetime.h> +#include <tqptrlist.h> + +#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 TQDateTime& dt, char* buffer) +{ + if ( dt.isValid() ) + { + const TQ_UINT16 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 TQ_UINT16 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) +{ + TQ_UINT16 time = (uchar)buffer[0] | ( (uchar)buffer[1] << 8 ); + int h = time >> 11; + int m = ( time & 0x7ff ) >> 5; + int s = ( time & 0x1f ) * 2 ; + TQTime qt(h, m, s); + + TQ_UINT16 date = (uchar)buffer[2] | ( (uchar)buffer[3] << 8 ); + int y = ( date >> 9 ) + 1980; + int o = ( date & 0x1ff ) >> 5; + int d = ( date & 0x1f ); + TQDate qd(y, o, d); + + TQDateTime dt( qd, qt ); + return dt.toTime_t(); +} + +// == parsing routines for zip headers + +/** all relevant information about parsing file information */ +struct ParseFileInfo { + // file related info +// TQCString name; // filename + 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) + TQCString 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) { + kdDebug(7040) << "premature end of extended timestamp (#1)" << endl; + return false; + }/*end if*/ + int flags = *buffer; // read flags + buffer += 1; + size -= 1; + + if (flags & 1) { // contains modification time + if (size < 4) { + kdDebug(7040) << "premature end of extended timestamp (#2)" << endl; + 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) { + kdDebug(7040) << "premature end of extended timestamp (#3)" << endl; + 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) { + kdDebug(7040) << "premature end of extended timestamp (#4)" << endl; + 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) { + kdDebug(7040) << "premature end of Info-ZIP unix extra field old" << endl; + 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) { + kdDebug(7040) << "premature end of Info-ZIP unix extra field new" << endl; + 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) { + //kdDebug(7040) << "fieldsize: " << fieldsize << " size: " << size << endl; + kdDebug(7040) << "premature end of extra fields reached" << endl; + 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( 0L ), + m_currentDev( 0L ), + m_compression( 8 ), + m_extraField( KZip::NoExtraField ), + m_offset( 0L ), + m_saveFile( 0 ) {} + + unsigned long m_crc; // checksum + KZipFileEntry* m_currentFile; // file currently being written + TQIODevice* m_currentDev; // filterdev used to write to the above file + TQPtrList<KZipFileEntry> m_fileList; // flat list of all files, for the index (saves a recursive method ;) + int m_compression; + KZip::ExtraField m_extraField; + unsigned int 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. + KSaveFile* m_saveFile; +}; + +KZip::KZip( const TQString& filename ) + : KArchive( 0L ) +{ + //kdDebug(7040) << "KZip(filename) reached." << endl; + Q_ASSERT( !filename.isEmpty() ); + m_filename = filename; + d = new KZipPrivate; + // unusual: this ctor leaves the device set to 0. + // This is for the use of KSaveFile, see openArchive. + // KDE4: move KSaveFile support to base class, KArchive. +} + +KZip::KZip( TQIODevice * dev ) + : KArchive( dev ) +{ + //kdDebug(7040) << "KZip::KZip( TQIODevice * dev) reached." << endl; + d = new KZipPrivate; +} + +KZip::~KZip() +{ + // mjarrett: Closes to prevent ~KArchive from aborting w/o device + //kdDebug(7040) << "~KZip reached." << endl; + if( isOpened() ) + close(); + if ( !m_filename.isEmpty() ) { // we created the device ourselves + if ( d->m_saveFile ) // writing mode + delete d->m_saveFile; + else // reading mode + delete device(); // (the TQFile) + } + delete d; +} + +bool KZip::openArchive( int mode ) +{ + //kdDebug(7040) << "openarchive reached." << endl; + d->m_fileList.clear(); + + switch ( mode ) { + case IO_WriteOnly: + // The use of KSaveFile can't be done in the ctor (no mode known yet) + // Ideally we would reimplement open() and do it there (BIC) + if ( !m_filename.isEmpty() ) { + kdDebug(7040) << "Writing to a file using KSaveFile" << endl; + d->m_saveFile = new KSaveFile( m_filename ); + if ( d->m_saveFile->status() != 0 ) { + kdWarning(7040) << "KSaveFile creation for " << m_filename << " failed, " << strerror( d->m_saveFile->status() ) << endl; + delete d->m_saveFile; + d->m_saveFile = 0; + return false; + } + Q_ASSERT( d->m_saveFile->file() ); + setDevice( TQT_TQIODEVICE(d->m_saveFile->file()) ); + } + return true; + case IO_ReadOnly: + case IO_ReadWrite: + { + // ReadWrite mode still uses TQFile for now; we'd need to copy to the tempfile, in fact. + if ( !m_filename.isEmpty() ) { + setDevice( TQT_TQIODEVICE(new TQFile( m_filename )) ); + if ( !device()->open( mode ) ) + return false; + } + break; // continued below + } + default: + kdWarning(7040) << "Unsupported mode " << mode << endl; + return false; + } + + char buffer[47]; + + // Check that it's a valid ZIP file + // the above code opened the underlying device already. + TQIODevice* dev = device(); + + if (!dev) { + return false; + } + + uint offset = 0; // holds offset, where we read + int n; + + // contains information gathered from the local file headers + TQAsciiDict<ParseFileInfo> pfi_map(1009, true /*case sensitive */, true /*copy keys*/); + pfi_map.setAutoDelete(true); + + // 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 + { +kdDebug(7040) << "loop starts" << endl; +kdDebug(7040) << "dev->at() now : " << dev->at() << endl; + n = dev->readBlock( buffer, 4 ); + + if (n < 4) + { + kdWarning(7040) << "Invalid ZIP file. Unexpected end of file. (#1)" << endl; + + return false; + } + + if ( !memcmp( buffer, "PK\5\6", 4 ) ) // 'end of entries' + { + kdDebug(7040) << "PK56 found end of archive" << endl; + startOfFile = false; + break; + } + + if ( !memcmp( buffer, "PK\3\4", 4 ) ) // local file header + { + kdDebug(7040) << "PK34 found local file header" << endl; + startOfFile = false; + // can this fail ??? + dev->at( dev->at() + 2 ); // skip 'version needed to extract' + + // read static header stuff + n = dev->readBlock( buffer, 24 ); + if (n < 24) { + kdWarning(7040) << "Invalid ZIP file. Unexpected end of file. (#4)" << endl; + 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 ); + + TQ_LONG compr_size = (uchar)buffer[12] | (uchar)buffer[13] << 8 + | (uchar)buffer[14] << 16 | (uchar)buffer[15] << 24; + TQ_LONG uncomp_size = (uchar)buffer[16] | (uchar)buffer[17] << 8 + | (uchar)buffer[18] << 16 | (uchar)buffer[19] << 24; + int namelen = (uchar)buffer[20] | (uchar)buffer[21] << 8; + int extralen = (uchar)buffer[22] | (uchar)buffer[23] << 8; + + kdDebug(7040) << "general purpose bit flag: " << gpf << endl; + kdDebug(7040) << "compressed size: " << compr_size << endl; + kdDebug(7040) << "uncompressed size: " << uncomp_size << endl; + kdDebug(7040) << "namelen: " << namelen << endl; + kdDebug(7040) << "extralen: " << extralen << endl; + kdDebug(7040) << "archive size: " << dev->size() << endl; + + // read filename + TQCString filename(namelen + 1); + n = dev->readBlock(filename.data(), namelen); + if ( n < namelen ) { + kdWarning(7040) << "Invalid ZIP file. Name not completely read (#2)" << endl; + return false; + } + + ParseFileInfo *pfi = new ParseFileInfo(); + pfi->mtime = mtime; + pfi_map.insert(filename.data(), pfi); + + // read and parse the beginning of the extra field, + // skip rest of extra field in case it is too long + unsigned int extraFieldEnd = dev->at() + extralen; + pfi->extralen = extralen; + int handledextralen = QMIN(extralen, (int)sizeof buffer); + + kdDebug(7040) << "handledextralen: " << handledextralen << endl; + + n = dev->readBlock(buffer, handledextralen); + // no error msg necessary as we deliberately truncate the extra field + if (!parseExtraField(buffer, handledextralen, true, *pfi)) + { + kdWarning(7040) << "Invalid ZIP File. Broken ExtraField." << endl; + return false; + } + + // jump to end of extra field + dev->at( 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 + kdDebug(7040) << "trying to seek for next PK78" << endl; + bool foundSignature = false; + + while (!foundSignature) + { + n = dev->readBlock( buffer, 1 ); + if (n < 1) + { + kdWarning(7040) << "Invalid ZIP file. Unexpected end of file. (#2)" << endl; + return false; + } + + if ( buffer[0] != 'P' ) + continue; + + n = dev->readBlock( buffer, 3 ); + if (n < 3) + { + kdWarning(7040) << "Invalid ZIP file. Unexpected end of file. (#3)" << endl; + 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->at( dev->at() + 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->at( dev->at() - 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->at( dev->at() - 3 ); + } + + } + } + else + { + // here we skip the compressed data and jump to the next header + kdDebug(7040) << "general purpose bit flag indicates, that local file header contains valid size" << endl; + // 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 + pfi->guessed_symlink.resize(uncomp_size + 1); + kdDebug(7040) << "guessed symlink size: " << uncomp_size << endl; + n = dev->readBlock(pfi->guessed_symlink.data(), uncomp_size); + if (n < uncomp_size) { + kdWarning(7040) << "Invalid ZIP file. Unexpected end of file. (#5)" << endl; + return false; + } + } else { + + if ( compr_size > (TQ_LONG)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->readBlock( buffer, 1 ); + if (n < 1) + { + kdWarning(7040) << "Invalid ZIP file. Unexpected end of file. (#2)" << endl; + return false; + } + + if ( buffer[0] != 'P' ) + continue; + + n = dev->readBlock( buffer, 3 ); + if (n < 3) + { + kdWarning(7040) << "Invalid ZIP file. Unexpected end of file. (#3)" << endl; + 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->at( dev->at() + 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->at( dev->at() - 4 ); + // go back 4 bytes, so that the magic bytes can be found + // in the next cycle... + } + } + } + else + { +// kdDebug(7040) << "before interesting dev->at(): " << dev->at() << endl; + bool success; + success = dev->at( dev->at() + compr_size ); // can this fail ??? +/* kdDebug(7040) << "after interesting dev->at(): " << dev->at() << endl; + if ( success ) + kdDebug(7040) << "dev->at was successful... " << endl; + else + kdDebug(7040) << "dev->at failed... " << endl;*/ + } + + } + +// 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;*/ + } + } + else if ( !memcmp( buffer, "PK\1\2", 4 ) ) // central block + { + kdDebug(7040) << "PK12 found central block" << endl; + 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->at() - 4; + + //set offset for appending new files + if ( d->m_offset == 0L ) d->m_offset = offset; + + n = dev->readBlock( buffer + 4, 42 ); + if (n < 42) { + kdWarning(7040) << "Invalid ZIP file, central entry too short" << endl; // not long enough for valid entry + return false; + } + + //int gpf = (uchar)buffer[9] << 8 | (uchar)buffer[10]; + //kdDebug() << "general purpose flag=" << gpf << endl; + // length of the filename (well, pathname indeed) + int namelen = (uchar)buffer[29] << 8 | (uchar)buffer[28]; + TQCString bufferName( namelen + 1 ); + n = dev->readBlock( bufferName.data(), namelen ); + if ( n < namelen ) + kdWarning(7040) << "Invalid ZIP file. Name not completely read" << endl; + + ParseFileInfo *pfi = pfi_map[bufferName]; + if (!pfi) { // can that happen? + pfi_map.insert(bufferName.data(), pfi = new ParseFileInfo()); + } + TQString name( TQFile::decodeName(bufferName) ); + + //kdDebug(7040) << "name: " << name << endl; + // 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]; + + //kdDebug(7040) << "cmethod: " << cmethod << endl; + //kdDebug(7040) << "extralen: " << extralen << endl; + + // 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 + + //kdDebug(7040) << "localextralen: " << localextralen << endl; + + // offset, where the real data for uncompression starts + uint dataoffset = localheaderoffset + 30 + localextralen + namelen; //comment only in central header + + //kdDebug(7040) << "esize: " << esize << endl; + //kdDebug(7040) << "eoffset: " << eoffset << endl; + //kdDebug(7040) << "csize: " << csize << endl; + + 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; + } + + TQString entryName; + + if ( name.endsWith( "/" ) ) // 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.findRev( '/' ); + if ( pos == -1 ) + entryName = name; + else + entryName = name.mid( pos + 1 ); + Q_ASSERT( !entryName.isEmpty() ); + + KArchiveEntry* entry; + if ( isdir ) + { + TQString path = TQDir::cleanDirPath( name ); + KArchiveEntry* ent = rootDir()->entry( path ); + if ( ent && ent->isDirectory() ) + { + //kdDebug(7040) << "Directory already exists, NOT going to add it again" << endl; + entry = 0L; + } + else + { + entry = new KArchiveDirectory( this, entryName, access, (int)pfi->mtime, rootDir()->user(), rootDir()->group(), TQString::null ); + //kdDebug(7040) << "KArchiveDirectory created, entryName= " << entryName << ", name=" << name << endl; + } + } + else + { + TQString symlink; + if (S_ISLNK(access)) { + symlink = TQFile::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 ); + //kdDebug(7040) << "KZipFileEntry created, entryName= " << entryName << ", name=" << name << endl; + 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 cleanDirPath + TQString path = TQDir::cleanDirPath( 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->at(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) + kdDebug(7040) << "Try to skip start of file" << endl; + startOfFile = false; + bool foundSignature = false; + + while (!foundSignature) + { + n = dev->readBlock( buffer, 1 ); + if (n < 1) + { + kdWarning(7040) << "Invalid ZIP file. Unexpected end of file. " << k_funcinfo << endl; + return false; + } + + if ( buffer[0] != 'P' ) + continue; + + n = dev->readBlock( buffer, 3 ); + if (n < 3) + { + kdWarning(7040) << "Invalid ZIP file. Unexpected end of file. " << k_funcinfo << endl; + 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->at( dev->at() - 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->at( dev->at() - 3 ); + } + } + } + else + { + kdWarning(7040) << "Invalid ZIP file. Unrecognized header at offset " << offset << endl; + + return false; + } + } + //kdDebug(7040) << "*** done *** " << endl; + return true; +} + +bool KZip::closeArchive() +{ + if ( ! ( mode() & IO_WriteOnly ) ) + { + //kdDebug(7040) << "closearchive readonly reached." << endl; + return true; + } + + kdDebug() << k_funcinfo << "device=" << device() << endl; + //ReadWrite or WriteOnly + //write all central dir file entries + + if ( !device() ) // saving aborted + return false; + + // 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); + + TQ_LONG centraldiroffset = device()->at(); + //kdDebug(7040) << "closearchive: centraldiroffset: " << centraldiroffset << endl; + TQ_LONG atbackup = centraldiroffset; + TQPtrListIterator<KZipFileEntry> it( d->m_fileList ); + + for ( ; it.current() ; ++it ) + { //set crc and compressed size in each local file header + if ( !device()->at( it.current()->headerStart() + 14 ) ) + return false; + //kdDebug(7040) << "closearchive setcrcandcsize: filename: " + // << it.current()->path() + // << " encoding: "<< it.current()->encoding() << endl; + + uLong mycrc = it.current()->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.current()->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.current()->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()->writeBlock( buffer, 12 ) != 12 ) + return false; + } + device()->at( atbackup ); + + for ( it.toFirst(); it.current() ; ++it ) + { + //kdDebug(7040) << "closearchive: filename: " << it.current()->path() + // << " encoding: "<< it.current()->encoding() << endl; + + TQCString path = TQFile::encodeName(it.current()->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)); + tqmemmove(buffer, head, sizeof(head)); + + buffer[ 10 ] = char(it.current()->encoding()); // compression method + buffer[ 11 ] = char(it.current()->encoding() >> 8); + + transformToMsDos( it.current()->datetime(), &buffer[ 12 ] ); + + uLong mycrc = it.current()->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.current()->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.current()->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(it.current()->path().length()); // filename length + buffer[ 29 ] = char(it.current()->path().length() >> 8); + + buffer[ 30 ] = char(extra_field_len); + buffer[ 31 ] = char(extra_field_len >> 8); + + buffer[ 40 ] = char(it.current()->permissions()); + buffer[ 41 ] = char(it.current()->permissions() >> 8); + + int myhst = it.current()->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() ); + //kdDebug(7040) << "closearchive length to write: " << bufferSize << endl; + + // 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.current()->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()->writeBlock( buffer, bufferSize ) == bufferSize ); + delete[] buffer; + if ( !ok ) + return false; + } + TQ_LONG centraldirendoffset = device()->at(); + //kdDebug(7040) << "closearchive: centraldirendoffset: " << centraldirendoffset << endl; + //kdDebug(7040) << "closearchive: device()->at(): " << device()->at() << endl; + + //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(); + //kdDebug(7040) << "number of files (count): " << count << endl; + + + 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); + + //kdDebug(7040) << "end : centraldiroffset: " << centraldiroffset << endl; + //kdDebug(7040) << "end : centraldirsize: " << cdsize << endl; + + 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()->writeBlock( buffer, 22 ) != 22 ) + return false; + + if ( d->m_saveFile ) { + d->m_saveFile->close(); + setDevice( 0 ); + delete d->m_saveFile; + d->m_saveFile = 0; + } + + //kdDebug(7040) << __FILE__" reached." << endl; + return true; +} + +// Doesn't need to be reimplemented anymore. Remove for KDE-4.0 +bool KZip::writeFile( const TQString& name, const TQString& user, const TQString& group, uint size, const char* data ) +{ + mode_t mode = 0100644; + time_t the_time = time(0); + return KArchive::writeFile( name, user, group, size, mode, the_time, + the_time, the_time, data ); +} + +// Doesn't need to be reimplemented anymore. Remove for KDE-4.0 +bool KZip::writeFile( const TQString& name, const TQString& user, + const TQString& group, uint size, mode_t perm, + time_t atime, time_t mtime, time_t ctime, + const char* data ) { + return KArchive::writeFile(name, user, group, size, perm, atime, mtime, + ctime, data); +} + +// Doesn't need to be reimplemented anymore. Remove for KDE-4.0 +bool KZip::prepareWriting( const TQString& name, const TQString& user, const TQString& group, uint size ) +{ + mode_t dflt_perm = 0100644; + time_t the_time = time(0); + return prepareWriting(name,user,group,size,dflt_perm, + the_time,the_time,the_time); +} + +// Doesn't need to be reimplemented anymore. Remove for KDE-4.0 +bool KZip::prepareWriting(const TQString& name, const TQString& user, + const TQString& group, uint size, mode_t perm, + time_t atime, time_t mtime, time_t ctime) { + return KArchive::prepareWriting(name,user,group,size,perm,atime,mtime,ctime); +} + +bool KZip::prepareWriting_impl(const TQString &name, const TQString &user, + const TQString &group, uint /*size*/, mode_t perm, + time_t atime, time_t mtime, time_t ctime) { + //kdDebug(7040) << "prepareWriting reached." << endl; + if ( !isOpened() ) + { + tqWarning( "KZip::writeFile: You must open the zip file before writing to it\n"); + return false; + } + + if ( ! ( mode() & IO_WriteOnly ) ) // accept WriteOnly and ReadWrite + { + tqWarning( "KZip::writeFile: You must open the zip file for writing\n"); + return false; + } + + if ( !device() ) { // aborted + //kdWarning(7040) << "prepareWriting_impl: no device" << endl; + return false; + } + + // set right offset in zip. + if ( !device()->at( d->m_offset ) ) { + kdWarning(7040) << "prepareWriting_impl: cannot seek in ZIP file. Disk full?" << endl; + abort(); + return false; + } + + // 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 !!! + TQPtrListIterator<KZipFileEntry> it( d->m_fileList ); + + //kdDebug(7040) << "filename to write: " << name <<endl; + for ( ; it.current() ; ++it ) + { + //kdDebug(7040) << "prepfilename: " << it.current()->path() <<endl; + if (name == it.current()->path() ) + { + //kdDebug(7040) << "removing following entry: " << it.current()->path() <<endl; + d->m_fileList.remove(); + } + + } + // Find or create parent dir + KArchiveDirectory* parentDir = rootDir(); + TQString fileName( name ); + int i = name.findRev( '/' ); + if ( i != -1 ) + { + TQString dir = name.left( i ); + fileName = name.mid( i + 1 ); + //kdDebug(7040) << "KZip::prepareWriting ensuring " << dir << " exists. fileName=" << fileName << endl; + parentDir = findOrCreate( dir ); + } + + // construct a KZipFileEntry and add it to list + KZipFileEntry * e = new KZipFileEntry( this, fileName, perm, mtime, user, group, TQString::null, + name, device()->at() + 30 + name.length(), // start + 0 /*size unknown yet*/, d->m_compression, 0 /*csize unknown yet*/ ); + e->setHeaderStart( device()->at() ); + //kdDebug(7040) << "wrote file start: " << e->position() << " name: " << name << endl; + 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 doneWriting() + + // write out zip header + TQCString encodedName = TQFile::encodeName(name); + int bufferSize = extra_field_len + encodedName.length() + 30; + //kdDebug(7040) << "KZip::prepareWriting bufferSize=" << bufferSize << endl; + 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()->writeBlock( buffer, bufferSize ) == bufferSize ); + d->m_crc = 0L; + delete[] buffer; + + Q_ASSERT( b ); + if (!b) { + abort(); + 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(), "application/x-gzip", false ); + Q_ASSERT( d->m_currentDev ); + if ( !d->m_currentDev ) { + abort(); + return false; // ouch + } + static_cast<KFilterDev *>(d->m_currentDev)->setSkipHeaders(); // Just zlib, not gzip + + b = d->m_currentDev->open( IO_WriteOnly ); + Q_ASSERT( b ); + return b; +} + +bool KZip::doneWriting( uint size ) +{ + if ( d->m_currentFile->encoding() == 8 ) { + // Finish + (void)d->m_currentDev->writeBlock( 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 ); + //kdDebug(7040) << "donewriting reached." << endl; + //kdDebug(7040) << "filename: " << d->m_currentFile->path() << endl; + //kdDebug(7040) << "getpos (at): " << device()->at() << endl; + d->m_currentFile->setSize(size); + int extra_field_len = 0; + if ( d->m_extraField == ModificationTime ) + extra_field_len = 17; // value also used in doneWriting() + + int csize = device()->at() - + d->m_currentFile->headerStart() - 30 - + d->m_currentFile->path().length() - extra_field_len; + d->m_currentFile->setCompressedSize(csize); + //kdDebug(7040) << "usize: " << d->m_currentFile->size() << endl; + //kdDebug(7040) << "csize: " << d->m_currentFile->compressedSize() << endl; + //kdDebug(7040) << "headerstart: " << d->m_currentFile->headerStart() << endl; + + //kdDebug(7040) << "crc: " << d->m_crc << endl; + d->m_currentFile->setCRC32( d->m_crc ); + + d->m_currentFile = 0L; + + // update saved offset for appending new files + d->m_offset = device()->at(); + return true; +} + +bool KZip::writeSymLink(const TQString &name, const TQString &target, + const TQString &user, const TQString &group, + mode_t perm, time_t atime, time_t mtime, time_t ctime) { + return KArchive::writeSymLink(name,target,user,group,perm,atime,mtime,ctime); +} + +bool KZip::writeSymLink_impl(const TQString &name, const TQString &target, + const TQString &user, const TQString &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 (!prepareWriting(name, user, group, 0, perm, atime, mtime, ctime)) { + kdWarning() << "KZip::writeFile prepareWriting failed" << endl; + setCompression(c); + return false; + } + + TQCString symlink_target = TQFile::encodeName(target); + if (!writeData(symlink_target, symlink_target.length())) { + kdWarning() << "KZip::writeFile writeData failed" << endl; + setCompression(c); + return false; + } + + if (!doneWriting(symlink_target.length())) { + kdWarning() << "KZip::writeFile doneWriting failed" << endl; + setCompression(c); + return false; + } + + setCompression(c); + return true; +} + +void KZip::virtual_hook( int id, void* data ) +{ + switch (id) { + case VIRTUAL_WRITE_DATA: { + WriteDataParams* params = reinterpret_cast<WriteDataParams *>(data); + params->retval = writeData_impl( params->data, params->size ); + break; + } + case VIRTUAL_WRITE_SYMLINK: { + WriteSymlinkParams *params = reinterpret_cast<WriteSymlinkParams *>(data); + params->retval = writeSymLink_impl(*params->name,*params->target, + *params->user,*params->group,params->perm, + params->atime,params->mtime,params->ctime); + break; + } + case VIRTUAL_PREPARE_WRITING: { + PrepareWritingParams *params = reinterpret_cast<PrepareWritingParams *>(data); + params->retval = prepareWriting_impl(*params->name,*params->user, + *params->group,params->size,params->perm, + params->atime,params->mtime,params->ctime); + break; + } + default: + KArchive::virtual_hook( id, data ); + }/*end switch*/ +} + +// made virtual using virtual_hook +bool KZip::writeData(const char * c, uint i) +{ + return KArchive::writeData( c, i ); +} + +bool KZip::writeData_impl(const char * c, uint i) +{ + Q_ASSERT( d->m_currentFile ); + Q_ASSERT( d->m_currentDev ); + if (!d->m_currentFile || !d->m_currentDev) { + abort(); + 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 *) c , i); + + TQ_LONG written = d->m_currentDev->writeBlock( c, i ); + //kdDebug(7040) << "KZip::writeData wrote " << i << " bytes." << endl; + bool ok = written == (TQ_LONG)i; + if ( !ok ) + abort(); + return ok; +} + +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; +} + +void KZip::abort() +{ + if ( d->m_saveFile ) { + d->m_saveFile->abort(); + setDevice( 0 ); + } +} + + +/////////////// + +TQByteArray KZipFileEntry::data() const +{ + TQIODevice* dev = device(); + TQByteArray arr; + if ( dev ) { + arr = dev->readAll(); + delete dev; + } + return arr; +} + +TQIODevice* KZipFileEntry::device() const +{ + //kdDebug(7040) << "KZipFileEntry::device creating iodevice limited to pos=" << position() << ", csize=" << compressedSize() << endl; + // 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 + TQIODevice* filterDev = KFilterDev::device( limitedDev, "application/x-gzip" ); + if ( !filterDev ) + return 0L; // ouch + static_cast<KFilterDev *>(filterDev)->setSkipHeaders(); // Just zlib, not gzip + bool b = filterDev->open( IO_ReadOnly ); + Q_ASSERT( b ); + return filterDev; + } + + kdError() << "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." << endl; + return 0L; +} |