diff --git a/src/karchive.cpp b/src/karchive.cpp index db42b58..1e1c210 100644 --- a/src/karchive.cpp +++ b/src/karchive.cpp @@ -1,966 +1,975 @@ /* This file is part of the KDE libraries Copyright (C) 2000-2005 David Faure Copyright (C) 2003 Leo Savernik Moved from ktar.cpp by Roberto Teixeira 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 "karchive.h" #include "karchive_p.h" #include "klimitediodevice_p.h" #include "loggingcategory.h" #include // QT_STATBUF, QT_LSTAT #include #include #include #include #include #include #include #include #include #include #include #ifdef Q_OS_UNIX #include #include #include // PATH_MAX #include #endif #ifdef Q_OS_WIN #include // DWORD, GetUserNameW #endif // Q_OS_WIN //////////////////////////////////////////////////////////////////////// /////////////////////////// KArchive /////////////////////////////////// //////////////////////////////////////////////////////////////////////// KArchive::KArchive(const QString &fileName) : d(new KArchivePrivate) { if (fileName.isEmpty()) { qCWarning(KArchiveLog) << "KArchive: No file name specified"; } d->fileName = fileName; // This constructor leaves the device set to 0. // This is for the use of QSaveFile, see open(). } KArchive::KArchive(QIODevice *dev) : d(new KArchivePrivate) { if (!dev) { qCWarning(KArchiveLog) << "KArchive: Null device specified"; } d->dev = dev; } KArchive::~KArchive() { Q_ASSERT(!isOpen()); // the derived class destructor must have closed already delete d; } bool KArchive::open(QIODevice::OpenMode mode) { Q_ASSERT(mode != QIODevice::NotOpen); if (isOpen()) { close(); } if (!d->fileName.isEmpty()) { Q_ASSERT(!d->dev); if (!createDevice(mode)) { return false; } } if (!d->dev) { setErrorString(tr("No filename or device was specified")); return false; } if (!d->dev->isOpen() && !d->dev->open(mode)) { setErrorString(tr("Could not set device mode to %1").arg(mode)); return false; } d->mode = mode; Q_ASSERT(!d->rootDir); d->rootDir = nullptr; return openArchive(mode); } bool KArchive::createDevice(QIODevice::OpenMode mode) { switch (mode) { case QIODevice::WriteOnly: if (!d->fileName.isEmpty()) { // The use of QSaveFile can't be done in the ctor (no mode known yet) //qCDebug(KArchiveLog) << "Writing to a file using QSaveFile"; d->saveFile = new QSaveFile(d->fileName); if (!d->saveFile->open(QIODevice::WriteOnly)) { setErrorString( tr("QSaveFile creation for %1 failed: %2") .arg(d->fileName) .arg(d->saveFile->errorString())); delete d->saveFile; d->saveFile = nullptr; return false; } d->dev = d->saveFile; Q_ASSERT(d->dev); } break; case QIODevice::ReadOnly: case QIODevice::ReadWrite: // ReadWrite mode still uses QFile for now; we'd need to copy to the tempfile, in fact. if (!d->fileName.isEmpty()) { d->dev = new QFile(d->fileName); d->deviceOwned = true; } break; // continued below default: setErrorString(tr("Unsupported mode %1").arg(d->mode)); return false; } return true; } bool KArchive::close() { if (!isOpen()) { setErrorString(tr("Archive already closed")); return false; // already closed (return false or true? arguable...) } // moved by holger to allow kzip to write the zip central dir // to the file in closeArchive() // DF: added d->dev so that we skip closeArchive if saving aborted. bool closeSucceeded = true; if (d->dev) { closeSucceeded = closeArchive(); if (d->mode == QIODevice::WriteOnly && !closeSucceeded) { d->abortWriting(); } } if (d->dev && d->dev != d->saveFile) { d->dev->close(); } // if d->saveFile is not null then it is equal to d->dev. if (d->saveFile) { closeSucceeded = d->saveFile->commit(); delete d->saveFile; d->saveFile = nullptr; } if (d->deviceOwned) { delete d->dev; // we created it ourselves in open() } delete d->rootDir; d->rootDir = nullptr; d->mode = QIODevice::NotOpen; d->dev = nullptr; return closeSucceeded; } QString KArchive::errorString() const { return d->errorStr; } const KArchiveDirectory *KArchive::directory() const { // rootDir isn't const so that parsing-on-demand is possible return const_cast(this)->rootDir(); } bool KArchive::addLocalFile(const QString &fileName, const QString &destName) { QFileInfo fileInfo(fileName); if (!fileInfo.isFile() && !fileInfo.isSymLink()) { setErrorString( tr("%1 doesn't exist or is not a regular file.") .arg(fileName)); return false; } #if defined(Q_OS_UNIX) #define STAT_METHOD QT_LSTAT #else #define STAT_METHOD QT_STAT #endif QT_STATBUF fi; if (STAT_METHOD(QFile::encodeName(fileName).constData(), &fi) == -1) { setErrorString( tr("Failed accessing the file %1 for adding to the archive. The error was: %2") .arg(fileName) .arg(QLatin1Literal{strerror(errno)})); return false; } if (fileInfo.isSymLink()) { QString symLinkTarget; // Do NOT use fileInfo.readLink() for unix symlinks! // It returns the -full- path to the target, while we want the target string "as is". #if defined(Q_OS_UNIX) && !defined(Q_OS_OS2EMX) const QByteArray encodedFileName = QFile::encodeName(fileName); QByteArray s; #if defined(PATH_MAX) s.resize(PATH_MAX + 1); #else int path_max = pathconf(encodedFileName.data(), _PC_PATH_MAX); if (path_max <= 0) { path_max = 4096; } s.resize(path_max); #endif int len = readlink(encodedFileName.data(), s.data(), s.size() - 1); if (len >= 0) { s[len] = '\0'; symLinkTarget = QFile::decodeName(s.constData()); } #endif if (symLinkTarget.isEmpty()) { // Mac or Windows symLinkTarget = fileInfo.symLinkTarget(); } return writeSymLink(destName, symLinkTarget, fileInfo.owner(), fileInfo.group(), fi.st_mode, fileInfo.lastRead(), fileInfo.lastModified(), fileInfo.created()); }/*end if*/ qint64 size = fileInfo.size(); // the file must be opened before prepareWriting is called, otherwise // if the opening fails, no content will follow the already written // header and the tar file is effectively f*cked up QFile file(fileName); if (!file.open(QIODevice::ReadOnly)) { setErrorString( tr("Couldn't open file %1: %2") .arg(fileName) .arg(file.errorString())); return false; } if (!prepareWriting(destName, fileInfo.owner(), fileInfo.group(), size, fi.st_mode, fileInfo.lastRead(), fileInfo.lastModified(), fileInfo.created())) { //qCWarning(KArchiveLog) << " prepareWriting" << destName << "failed"; return false; } // Read and write data in chunks to minimize memory usage QByteArray array; array.resize(int(qMin(qint64(1024 * 1024), size))); qint64 n; qint64 total = 0; while ((n = file.read(array.data(), array.size())) > 0) { if (!writeData(array.data(), n)) { //qCWarning(KArchiveLog) << "writeData failed"; return false; } total += n; } Q_ASSERT(total == size); if (!finishWriting(size)) { //qCWarning(KArchiveLog) << "finishWriting failed"; return false; } return true; } bool KArchive::addLocalDirectory(const QString &path, const QString &destName) { QDir dir(path); if (!dir.exists()) { setErrorString( tr("Directory %1 does not exist") .arg(path)); return false; } dir.setFilter(dir.filter() | QDir::Hidden); const QStringList files = dir.entryList(); for (QStringList::ConstIterator it = files.begin(); it != files.end(); ++it) { if (*it != QLatin1String(".") && *it != QLatin1String("..")) { QString fileName = path + QLatin1Char('/') + *it; // qCDebug(KArchiveLog) << "storing " << fileName; QString dest = destName.isEmpty() ? *it : (destName + QLatin1Char('/') + *it); QFileInfo fileInfo(fileName); if (fileInfo.isFile() || fileInfo.isSymLink()) { addLocalFile(fileName, dest); } else if (fileInfo.isDir()) { addLocalDirectory(fileName, dest); } // We omit sockets } } return true; } bool KArchive::writeFile(const QString &name, const QByteArray &data, mode_t perm, const QString &user, const QString &group, const QDateTime &atime, const QDateTime &mtime, const QDateTime &ctime) { const qint64 size = data.size(); if (!prepareWriting(name, user, group, size, perm, atime, mtime, ctime)) { //qCWarning(KArchiveLog) << "prepareWriting failed"; return false; } // Write data // Note: if data is null, don't call write, it would terminate the KCompressionDevice if (data.constData() && size && !writeData(data.constData(), size)) { //qCWarning(KArchiveLog) << "writeData failed"; return false; } if (!finishWriting(size)) { //qCWarning(KArchiveLog) << "finishWriting failed"; return false; } return true; } bool KArchive::writeData(const char *data, qint64 size) { bool ok = device()->write(data, size) == size; if (!ok) { setErrorString( tr("Writing failed: %1") .arg(device()->errorString())); d->abortWriting(); } return ok; } // The writeDir -> doWriteDir pattern allows to avoid propagating the default // values into all virtual methods of subclasses, and it allows more extensibility: // if a new argument is needed, we can add a writeDir overload which stores the // additional argument in the d pointer, and doWriteDir reimplementations can fetch // it from there. bool KArchive::writeDir(const QString &name, const QString &user, const QString &group, mode_t perm, const QDateTime &atime, const QDateTime &mtime, const QDateTime &ctime) { return doWriteDir(name, user, group, perm | 040000, atime, mtime, ctime); } bool KArchive::writeSymLink(const QString &name, const QString &target, const QString &user, const QString &group, mode_t perm, const QDateTime &atime, const QDateTime &mtime, const QDateTime &ctime) { return doWriteSymLink(name, target, user, group, perm, atime, mtime, ctime); } bool KArchive::prepareWriting(const QString &name, const QString &user, const QString &group, qint64 size, mode_t perm, const QDateTime &atime, const QDateTime &mtime, const QDateTime &ctime) { bool ok = doPrepareWriting(name, user, group, size, perm, atime, mtime, ctime); if (!ok) { d->abortWriting(); } return ok; } bool KArchive::finishWriting(qint64 size) { return doFinishWriting(size); } void KArchive::setErrorString(const QString &errorStr) { d->errorStr = errorStr; } static QString getCurrentUserName() { #if defined(Q_OS_UNIX) struct passwd *pw = getpwuid(getuid()); return pw ? QFile::decodeName(pw->pw_name) : QString::number(getuid()); #elif defined(Q_OS_WIN) wchar_t buffer[255]; DWORD size = 255; bool ok = GetUserNameW(buffer, &size); if (!ok) { return QString(); } return QString::fromWCharArray(buffer); #else return QString(); #endif } static QString getCurrentGroupName() { #if defined(Q_OS_UNIX) struct group *grp = getgrgid(getgid()); return grp ? QFile::decodeName(grp->gr_name) : QString::number(getgid()); #elif defined(Q_OS_WIN) return QString(); #else return QString(); #endif } KArchiveDirectory *KArchive::rootDir() { if (!d->rootDir) { //qCDebug(KArchiveLog) << "Making root dir "; QString username = ::getCurrentUserName(); QString groupname = ::getCurrentGroupName(); d->rootDir = new KArchiveDirectory(this, QStringLiteral("/"), int(0777 + S_IFDIR), QDateTime(), username, groupname, QString()); } return d->rootDir; } KArchiveDirectory *KArchive::findOrCreate(const QString &path) { //qCDebug(KArchiveLog) << path; if (path.isEmpty() || path == QLatin1String("/") || path == QLatin1String(".")) { // root dir => found //qCDebug(KArchiveLog) << "returning rootdir"; return rootDir(); } // Important note : for tar files containing absolute paths // (i.e. beginning with "/"), this means the leading "/" will // be removed (no KDirectory for it), which is exactly the way // the "tar" program works (though it displays a warning about it) // See also KArchiveDirectory::entry(). // Already created ? => found const KArchiveEntry *ent = rootDir()->entry(path); if (ent) { if (ent->isDirectory()) //qCDebug(KArchiveLog) << "found it"; { const KArchiveDirectory *dir = static_cast(ent); return const_cast(dir); } else { - //qCWarning(KArchiveLog) << "Found" << path << "but it's not a directory"; + const KArchiveFile *file = static_cast(ent); + if (file->size() > 0) { + qCWarning(KArchiveLog) << path << "is normal file, but there are file paths in the archive assuming it is a directory, bailing out"; + return nullptr; + } + + qCDebug(KArchiveLog) << path << " is an empty file, assuming it is actually a directory and replacing"; + KArchiveEntry *myEntry = const_cast(ent); + rootDir()->removeEntry(myEntry); + delete myEntry; } } // Otherwise go up and try again int pos = path.lastIndexOf(QLatin1Char('/')); KArchiveDirectory *parent; QString dirname; if (pos == -1) { // no more slash => create in root dir parent = rootDir(); dirname = path; } else { QString left = path.left(pos); dirname = path.mid(pos + 1); parent = findOrCreate(left); // recursive call... until we find an existing dir. } //qCDebug(KArchiveLog) << "found parent " << parent->name() << " adding " << dirname << " to ensure " << path; // Found -> add the missing piece KArchiveDirectory *e = new KArchiveDirectory(this, dirname, d->rootDir->permissions(), d->rootDir->date(), d->rootDir->user(), d->rootDir->group(), QString()); parent->addEntry(e); return e; // now a directory to exists } void KArchive::setDevice(QIODevice *dev) { if (d->deviceOwned) { delete d->dev; } d->dev = dev; d->deviceOwned = false; } void KArchive::setRootDir(KArchiveDirectory *rootDir) { Q_ASSERT(!d->rootDir); // Call setRootDir only once during parsing please ;) d->rootDir = rootDir; } QIODevice::OpenMode KArchive::mode() const { return d->mode; } QIODevice *KArchive::device() const { return d->dev; } bool KArchive::isOpen() const { return d->mode != QIODevice::NotOpen; } QString KArchive::fileName() const { return d->fileName; } void KArchivePrivate::abortWriting() { if (saveFile) { saveFile->cancelWriting(); delete saveFile; saveFile = nullptr; dev = nullptr; } } // this is a hacky wrapper to check if time_t value is invalid QDateTime KArchivePrivate::time_tToDateTime(uint time_t) { if (time_t == uint(-1)) { return QDateTime(); } return QDateTime::fromTime_t(time_t); } //////////////////////////////////////////////////////////////////////// /////////////////////// KArchiveEntry ////////////////////////////////// //////////////////////////////////////////////////////////////////////// class KArchiveEntryPrivate { public: KArchiveEntryPrivate(KArchive *_archive, const QString &_name, int _access, const QDateTime &_date, const QString &_user, const QString &_group, const QString &_symlink) : name(_name) , date(_date) , access(_access) , user(_user) , group(_group) , symlink(_symlink) , archive(_archive) { } QString name; QDateTime date; mode_t access; QString user; QString group; QString symlink; KArchive *archive; }; KArchiveEntry::KArchiveEntry(KArchive *t, const QString &name, int access, const QDateTime &date, const QString &user, const QString &group, const QString &symlink) : d(new KArchiveEntryPrivate(t, name, access, date, user, group, symlink)) { } KArchiveEntry::~KArchiveEntry() { delete d; } QDateTime KArchiveEntry::date() const { return d->date; } QString KArchiveEntry::name() const { return d->name; } mode_t KArchiveEntry::permissions() const { return d->access; } QString KArchiveEntry::user() const { return d->user; } QString KArchiveEntry::group() const { return d->group; } QString KArchiveEntry::symLinkTarget() const { return d->symlink; } bool KArchiveEntry::isFile() const { return false; } bool KArchiveEntry::isDirectory() const { return false; } KArchive *KArchiveEntry::archive() const { return d->archive; } //////////////////////////////////////////////////////////////////////// /////////////////////// KArchiveFile /////////////////////////////////// //////////////////////////////////////////////////////////////////////// class KArchiveFilePrivate { public: KArchiveFilePrivate(qint64 _pos, qint64 _size) : pos(_pos) , size(_size) { } qint64 pos; qint64 size; }; KArchiveFile::KArchiveFile(KArchive *t, const QString &name, int access, const QDateTime &date, const QString &user, const QString &group, const QString &symlink, qint64 pos, qint64 size) : KArchiveEntry(t, name, access, date, user, group, symlink) , d(new KArchiveFilePrivate(pos, size)) { } KArchiveFile::~KArchiveFile() { delete d; } qint64 KArchiveFile::position() const { return d->pos; } qint64 KArchiveFile::size() const { return d->size; } void KArchiveFile::setSize(qint64 s) { d->size = s; } QByteArray KArchiveFile::data() const { bool ok = archive()->device()->seek(d->pos); if (!ok) { //qCWarning(KArchiveLog) << "Failed to sync to" << d->pos << "to read" << name(); } // Read content QByteArray arr; if (d->size) { arr = archive()->device()->read(d->size); Q_ASSERT(arr.size() == d->size); } return arr; } QIODevice *KArchiveFile::createDevice() const { return new KLimitedIODevice(archive()->device(), d->pos, d->size); } bool KArchiveFile::isFile() const { return true; } static QFileDevice::Permissions withExecutablePerms( QFileDevice::Permissions filePerms, mode_t perms) { if (perms & 01) filePerms |= QFileDevice::ExeOther; if (perms & 010) filePerms |= QFileDevice::ExeGroup; if (perms & 0100) filePerms |= QFileDevice::ExeOwner; return filePerms; } bool KArchiveFile::copyTo(const QString &dest) const { QFile f(dest + QLatin1Char('/') + name()); if (f.open(QIODevice::ReadWrite | QIODevice::Truncate)) { QIODevice *inputDev = createDevice(); // Read and write data in chunks to minimize memory usage const qint64 chunkSize = 1024 * 1024; qint64 remainingSize = d->size; QByteArray array; array.resize(int(qMin(chunkSize, remainingSize))); while (remainingSize > 0) { const qint64 currentChunkSize = qMin(chunkSize, remainingSize); const qint64 n = inputDev->read(array.data(), currentChunkSize); Q_UNUSED(n) // except in Q_ASSERT Q_ASSERT(n == currentChunkSize); f.write(array.data(), currentChunkSize); remainingSize -= currentChunkSize; } f.setPermissions(withExecutablePerms(f.permissions(), permissions())); f.close(); delete inputDev; return true; } return false; } //////////////////////////////////////////////////////////////////////// //////////////////////// KArchiveDirectory ///////////////////////////////// //////////////////////////////////////////////////////////////////////// class KArchiveDirectoryPrivate { public: ~KArchiveDirectoryPrivate() { qDeleteAll(entries); } QHash entries; }; KArchiveDirectory::KArchiveDirectory(KArchive *t, const QString &name, int access, const QDateTime &date, const QString &user, const QString &group, const QString &symlink) : KArchiveEntry(t, name, access, date, user, group, symlink) , d(new KArchiveDirectoryPrivate) { } KArchiveDirectory::~KArchiveDirectory() { delete d; } QStringList KArchiveDirectory::entries() const { return d->entries.keys(); } const KArchiveEntry *KArchiveDirectory::entry(const QString &_name) const { QString name = QDir::cleanPath(_name); int pos = name.indexOf(QLatin1Char('/')); if (pos == 0) { // ouch absolute path (see also KArchive::findOrCreate) if (name.length() > 1) { name = name.mid(1); // remove leading slash pos = name.indexOf(QLatin1Char('/')); // look again } else { // "/" return this; } } // trailing slash ? -> remove if (pos != -1 && pos == name.length() - 1) { name = name.left(pos); pos = name.indexOf(QLatin1Char('/')); // look again } if (pos != -1) { const QString left = name.left(pos); const QString right = name.mid(pos + 1); //qCDebug(KArchiveLog) << "left=" << left << "right=" << right; const KArchiveEntry *e = d->entries.value(left); if (!e || !e->isDirectory()) { return nullptr; } return static_cast(e)->entry(right); } return d->entries.value(name); } const KArchiveFile *KArchiveDirectory::file(const QString &name) const { const KArchiveEntry *e = entry(name); if (e && e->isFile()) { return static_cast(e); } return nullptr; } void KArchiveDirectory::addEntry(KArchiveEntry *entry) { if (d->entries.value(entry->name())) { - /*qCWarning(KArchiveLog) << "directory " << name() - << "has entry" << entry->name() << "already";*/ + qCWarning(KArchiveLog) << "directory " << name() + << "has entry" << entry->name() << "already"; delete entry; return; } d->entries.insert(entry->name(), entry); } void KArchiveDirectory::removeEntry(KArchiveEntry *entry) { if (!entry) { return; } QHash::Iterator it = d->entries.find(entry->name()); // nothing removed? if (it == d->entries.end()) { qCWarning(KArchiveLog) << "directory " << name() << "has no entry with name " << entry->name(); return; } if (it.value() != entry) { qCWarning(KArchiveLog) << "directory " << name() << "has another entry for name " << entry->name(); return; } d->entries.erase(it); } bool KArchiveDirectory::isDirectory() const { return true; } static bool sortByPosition(const KArchiveFile *file1, const KArchiveFile *file2) { return file1->position() < file2->position(); } bool KArchiveDirectory::copyTo(const QString &dest, bool recursiveCopy) const { QDir root; const QString destDir(QDir(dest).absolutePath()); // get directory path without any "." or ".." QList fileList; QMap fileToDir; // placeholders for iterated items QStack dirStack; QStack dirNameStack; dirStack.push(this); // init stack at current directory dirNameStack.push(destDir); // ... with given path do { const KArchiveDirectory *curDir = dirStack.pop(); // extract only to specified folder if it is located within archive's extraction folder // otherwise put file under root position in extraction folder QString curDirName = dirNameStack.pop(); if (!QDir(curDirName).absolutePath().startsWith(destDir)) { qCWarning(KArchiveLog) << "Attempted export into folder" << curDirName << "which is outside of the extraction root folder" << destDir << "." << "Changing export of contained files to extraction root folder."; curDirName = destDir; } if (!root.mkpath(curDirName)) { return false; } const QStringList dirEntries = curDir->entries(); for (QStringList::const_iterator it = dirEntries.begin(); it != dirEntries.end(); ++it) { const KArchiveEntry *curEntry = curDir->entry(*it); if (!curEntry->symLinkTarget().isEmpty()) { QString linkName = curDirName + QLatin1Char('/') + curEntry->name(); // To create a valid link on Windows, linkName must have a .lnk file extension. #ifdef Q_OS_WIN if (!linkName.endsWith(QLatin1String(".lnk"))) { linkName += QLatin1String(".lnk"); } #endif QFile symLinkTarget(curEntry->symLinkTarget()); if (!symLinkTarget.link(linkName)) { //qCDebug(KArchiveLog) << "symlink(" << curEntry->symLinkTarget() << ',' << linkName << ") failed:" << strerror(errno); } } else { if (curEntry->isFile()) { const KArchiveFile *curFile = dynamic_cast(curEntry); if (curFile) { fileList.append(curFile); fileToDir.insert(curFile->position(), curDirName); } } if (curEntry->isDirectory() && recursiveCopy) { const KArchiveDirectory *ad = dynamic_cast(curEntry); if (ad) { dirStack.push(ad); dirNameStack.push(curDirName + QLatin1Char('/') + curEntry->name()); } } } } } while (!dirStack.isEmpty()); qSort(fileList.begin(), fileList.end(), sortByPosition); // sort on d->pos, so we have a linear access for (QList::const_iterator it = fileList.constBegin(), end = fileList.constEnd(); it != end; ++it) { const KArchiveFile *f = *it; qint64 pos = f->position(); if (!f->copyTo(fileToDir[pos])) { return false; } } return true; } void KArchive::virtual_hook(int, void *) { /*BASE::virtual_hook( id, data )*/; } void KArchiveEntry::virtual_hook(int, void *) { /*BASE::virtual_hook( id, data );*/ } void KArchiveFile::virtual_hook(int id, void *data) { KArchiveEntry::virtual_hook(id, data); } void KArchiveDirectory::virtual_hook(int id, void *data) { KArchiveEntry::virtual_hook(id, data); } diff --git a/src/kzip.cpp b/src/kzip.cpp index 7dd8846..970c9a5 100644 --- a/src/kzip.cpp +++ b/src/kzip.cpp @@ -1,1456 +1,1462 @@ /* This file is part of the KDE libraries Copyright (C) 2000 David Faure Copyright (C) 2002 Holger Schroeder 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 "karchive_p.h" #include "kfilterdev.h" #include "klimitediodevice_p.h" #include "loggingcategory.h" #include #include #include #include #include #include #include #include #include #include #include #ifndef QT_STAT_LNK # define QT_STAT_LNK 0120000 #endif // QT_STAT_LNK static const int max_path_len = 4095; // maximum number of character a path may contain static void transformToMsDos(const QDateTime &_dt, char *buffer) { const QDateTime dt = _dt.isValid() ? _dt : QDateTime::currentDateTime(); 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); } static uint 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 // TODO: use quint32 instead of a uint? uint atime; // last access time (UNIX format) uint mtime; // modification time (UNIX format) uint 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(nullptr); } }; /** 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) { //qCDebug(KArchiveLog) << "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) { //qCDebug(KArchiveLog) << "premature end of extended timestamp (#2)"; return false; }/*end if*/ pfi.mtime = uint((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) { //qCDebug(KArchiveLog) << "premature end of extended timestamp (#3)"; return true; }/*end if*/ pfi.atime = uint((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) { //qCDebug(KArchiveLog) << "premature end of extended timestamp (#4)"; return true; }/*end if*/ pfi.ctime = uint((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) { //qCDebug(KArchiveLog) << "premature end of Info-ZIP unix extra field old"; return false; } pfi.atime = uint((uchar)buffer[0] | (uchar)buffer[1] << 8 | (uchar)buffer[2] << 16 | (uchar)buffer[3] << 24); buffer += 4; pfi.mtime = uint((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; } if (size < 4) { qCDebug(KArchiveLog) << "premature end of Info-ZIP unix extra field new"; return false; } 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) { //qCDebug(KArchiveLog) << "fieldsize: " << fieldsize << " size: " << size; //qCDebug(KArchiveLog) << "premature end of extra fields reached"; break; } 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; } /** * Checks if a token for a central or local header has been found and resets * the device to the begin of the token. If a token for the data descriptor is * found it is assumed there is a central or local header token starting right * behind the data descriptor, and the device is set accordingly to the begin * of that token. * To be called when a 'P' has been found. * @param buffer start of buffer with the 3 bytes behind 'P' * @param dev device that is read from * @return true if a local or central header begin is or could be reached */ static bool handlePossibleHeaderBegin(const char *buffer, QIODevice *dev) { // 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 // TODO: optimize using 32bit const data for comparison instead of byte-wise, // given we run at least on 32bit CPUs if (buffer[0] == 'K') { if (buffer[1] == 7 && buffer[2] == 8) { // data descriptor token found dev->seek(dev->pos() + 12); // skip the 'data_descriptor' return true; } if ((buffer[1] == 1 && buffer[2] == 2) || (buffer[1] == 3 && buffer[2] == 4)) { // central/local header token found dev->seek(dev->pos() - 4); // go back 4 bytes, so that the magic bytes can be found // in the next cycle... return true; } } return false; } /** * Reads the device forwards from the current pos until a token for a central or * local header has been found or is to be assumed. * @param dev device that is read from * @return true if a local or central header token could be reached, false on error */ static bool seekToNextHeaderToken(QIODevice *dev) { bool headerTokenFound = false; char buffer[3]; while (!headerTokenFound) { int n = dev->read(buffer, 1); if (n < 1) { //qCWarning(KArchiveLog) << "Invalid ZIP file. Unexpected end of file. (#2)"; return false; } if (buffer[0] != 'P') { continue; } n = dev->read(buffer, 3); if (n < 3) { //qCWarning(KArchiveLog) << "Invalid ZIP file. Unexpected end of file. (#3)"; return false; } if (handlePossibleHeaderBegin(buffer, dev)) { headerTokenFound = true; } else { for (int i = 0; i < 3; ++i) { if (buffer[i] == '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 + i); break; } } } } return true; } //////////////////////////////////////////////////////////////////////// /////////////////////////// KZip /////////////////////////////////////// //////////////////////////////////////////////////////////////////////// class Q_DECL_HIDDEN KZip::KZipPrivate { public: KZipPrivate() : m_crc(0) , m_currentFile(nullptr) , m_currentDev(nullptr) , 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 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() { //qCDebug(KArchiveLog) << this; if (isOpen()) { close(); } delete d; } bool KZip::openArchive(QIODevice::OpenMode mode) { //qCDebug(KArchiveLog); 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 // contains information gathered from the local file headers QHash 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 //qCDebug(KArchiveLog) << "loop starts"; //qCDebug(KArchiveLog) << "dev->pos() now : " << dev->pos(); int n = dev->read(buffer, 4); if (n < 4) { setErrorString(tr("Invalid ZIP file. Unexpected end of file. (Error code: %1)").arg(1)); return false; } if (!memcmp(buffer, "PK\5\6", 4)) { // 'end of entries' //qCDebug(KArchiveLog) << "PK56 found end of archive"; startOfFile = false; break; } if (!memcmp(buffer, "PK\3\4", 4)) { // local file header //qCDebug(KArchiveLog) << "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) { setErrorString(tr("Invalid ZIP file. Unexpected end of file. (Error code: %1)").arg(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; uint 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; /* qCDebug(KArchiveLog) << "general purpose bit flag: " << gpf; qCDebug(KArchiveLog) << "compressed size: " << compr_size; qCDebug(KArchiveLog) << "uncompressed size: " << uncomp_size; qCDebug(KArchiveLog) << "namelen: " << namelen; qCDebug(KArchiveLog) << "extralen: " << extralen; qCDebug(KArchiveLog) << "archive size: " << dev->size(); */ // read fileName Q_ASSERT(namelen > 0); QByteArray fileName = dev->read(namelen); if (fileName.size() < namelen) { setErrorString(tr("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) // qCDebug(KArchiveLog) << "handledextralen: " << handledextralen; n = dev->read(buffer, handledextralen); // no error msg necessary as we deliberately truncate the extra field if (!parseExtraField(buffer, handledextralen, true, pfi)) { setErrorString(tr("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 if (!seekToNextHeaderToken(dev)) { setErrorString(tr("Could not seek to next header token")); return false; } } else { // here we skip the compressed data and jump to the next header //qCDebug(KArchiveLog) << "general purpose bit flag indicates, that local file header contains valid size"; bool foundSignature = false; // 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) { setErrorString(tr("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 if (!seekToNextHeaderToken(dev)) { setErrorString(tr("Could not seek to next header token")); return false; } foundSignature = true; } else { // qCDebug(KArchiveLog) << "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... /* qCDebug(KArchiveLog) << "after interesting dev->pos(): " << dev->pos(); if (success) qCDebug(KArchiveLog) << "dev->at was successful... "; else qCDebug(KArchiveLog) << "dev->at failed... ";*/ } } // test for optional data descriptor if (!foundSignature) { // qCDebug(KArchiveLog) << "Testing for optional data descriptor"; // read static data descriptor n = dev->read(buffer, 4); if (n < 4) { setErrorString(tr("Invalid ZIP file. Unexpected end of file. (#1)")); return false; } if (buffer[0] != 'P' || !handlePossibleHeaderBegin(buffer + 1, dev)) { // assume data descriptor without signature dev->seek(dev->pos() + 8); // skip rest of the 'data_descriptor' } } // 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 //qCDebug(KArchiveLog) << "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 == 0) { d->m_offset = offset; } n = dev->read(buffer + 4, 42); if (n < 42) { setErrorString(tr( "Invalid ZIP file, central entry too short " "(not long enough for valid entry)")); return false; } //int gpf = (uchar)buffer[9] << 8 | (uchar)buffer[10]; //qCDebug(KArchiveLog) << "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) { //qCWarning(KArchiveLog) << "Invalid ZIP file. Name not completely read"; } ParseFileInfo pfi = pfi_map.value(bufferName, ParseFileInfo()); QString name(QFile::decodeName(bufferName)); //qCDebug(KArchiveLog) << "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]; //qCDebug(KArchiveLog) << "cmethod: " << cmethod; //qCDebug(KArchiveLog) << "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 //qCDebug(KArchiveLog) << "localextralen: " << localextralen; // offset, where the real data for uncompression starts uint dataoffset = localheaderoffset + 30 + localextralen + namelen; //comment only in central header //qCDebug(KArchiveLog) << "esize: " << esize; //qCDebug(KArchiveLog) << "eoffset: " << eoffset; //qCDebug(KArchiveLog) << "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 { access |= S_IFDIR | 0700; } } 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()) { //qCDebug(KArchiveLog) << "Directory already exists, NOT going to add it again"; entry = nullptr; } else { QDateTime mtime = KArchivePrivate::time_tToDateTime(pfi.mtime); entry = new KArchiveDirectory(this, entryName, access, mtime, rootDir()->user(), rootDir()->group(), QString()); //qCDebug(KArchiveLog) << "KArchiveDirectory created, entryName= " << entryName << ", name=" << name; } } else { QString symlink; if ((access & QT_STAT_MASK) == QT_STAT_LNK) { symlink = QFile::decodeName(pfi.guessed_symlink); } QDateTime mtime = KArchivePrivate::time_tToDateTime(pfi.mtime); entry = new KZipFileEntry(this, entryName, access, mtime, rootDir()->user(), rootDir()->group(), symlink, name, dataoffset, ucsize, cmethod, csize); static_cast(entry)->setHeaderStart(localheaderoffset); static_cast(entry)->setCRC32(crc32); //qCDebug(KArchiveLog) << "KZipFileEntry created, entryName= " << entryName << ", name=" << name; d->m_fileList.append(static_cast(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); + if (tdir) { + tdir->addEntry(entry); + } else { + setErrorString(tr("File %1 is in folder %2, but %3 is actually a file.").arg(entryName, path, path)); + delete entry; + return false; + } } } //calculate offset to next entry offset += 46 + commlen + extralen + namelen; bool b = dev->seek(offset); Q_ASSERT(b); if (!b) { setErrorString(tr("Could not seek to next entry")); 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) //qCDebug(KArchiveLog) << "Try to skip start of file"; startOfFile = false; bool foundSignature = false; while (!foundSignature) { n = dev->read(buffer, 1); if (n < 1) { setErrorString(tr("Invalid ZIP file. Unexpected end of file.")); return false; } if (buffer[0] != 'P') { continue; } n = dev->read(buffer, 3); if (n < 3) { setErrorString(tr("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 { for (int i = 0; i < 3; ++i) { if (buffer[i] == '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 + i); break; } } } } } else { setErrorString( tr("Invalid ZIP file. Unrecognized header at offset %1") .arg(offset)); return false; } } //qCDebug(KArchiveLog) << "*** done *** "; return true; } bool KZip::closeArchive() { if (!(mode() & QIODevice::WriteOnly)) { //qCDebug(KArchiveLog) << "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, nullptr, 0); qint64 centraldiroffset = device()->pos(); //qCDebug(KArchiveLog) << "closearchive: centraldiroffset: " << centraldiroffset; qint64 atbackup = centraldiroffset; QMutableListIterator 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)) { setErrorString( tr("Could not seek to next file header: %1") .arg(device()->errorString())); return false; } //qCDebug(KArchiveLog) << "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) { setErrorString( tr("Could not write file header: %1") .arg(device()->errorString())); return false; } } device()->seek(atbackup); it.toFront(); while (it.hasNext()) { it.next(); //qCDebug(KArchiveLog) << "fileName:" << it.current()->path() // << "encoding:" << it.current()->encoding(); QByteArray path = QFile::encodeName(it.value()->path()); const int extra_field_len = (d->m_extraField == ModificationTime) ? 9 : 0; const 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()->date(), &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.constData(), path.length()); //qCDebug(KArchiveLog) << "closearchive length to write: " << bufferSize; // extra field if (d->m_extraField == ModificationTime) { char *extfield = buffer + 46 + path.length(); // "Extended timestamp" header (0x5455) extfield[0] = 'U'; extfield[1] = 'T'; extfield[2] = 5; // data size 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().toTime_t(); 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) { setErrorString( tr("Could not write file header: %1") .arg(device()->errorString())); return false; } } qint64 centraldirendoffset = device()->pos(); //qCDebug(KArchiveLog) << "closearchive: centraldirendoffset: " << centraldirendoffset; //qCDebug(KArchiveLog) << "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(); //qCDebug(KArchiveLog) << "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); //qCDebug(KArchiveLog) << "end : centraldiroffset: " << centraldiroffset; //qCDebug(KArchiveLog) << "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) { setErrorString( tr("Could not write central dir record: %1") .arg(device()->errorString())); return false; } return true; } bool KZip::doWriteDir(const QString &name, const QString &user, const QString &group, mode_t perm, const QDateTime &atime, const QDateTime &mtime, const QDateTime &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, QByteArray(), perm, user, group, atime, mtime, ctime); } bool KZip::doPrepareWriting(const QString &name, const QString &user, const QString &group, qint64 /*size*/, mode_t perm, const QDateTime &accessTime, const QDateTime &modificationTime, const QDateTime &creationTime) { //qCDebug(KArchiveLog); if (!isOpen()) { setErrorString(tr("Application error: ZIP file must be open before being written into")); qCWarning(KArchiveLog) << "doPrepareWriting failed: !isOpen()"; return false; } if (!(mode() & QIODevice::WriteOnly)) { // accept WriteOnly and ReadWrite setErrorString(tr("Application error: attempted to write into non-writable ZIP file")); qCWarning(KArchiveLog) << "doPrepareWriting failed: !(mode() & QIODevice::WriteOnly)"; return false; } if (!device()) { setErrorString(tr("Cannot create a device. Disk full?")); return false; } // set right offset in zip. if (!device()->seek(d->m_offset)) { setErrorString(tr("Cannot seek in ZIP file. Disk full?")); return false; } uint atime = accessTime.toTime_t(); uint mtime = modificationTime.toTime_t(); uint ctime = creationTime.toTime_t(); // 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); //qCDebug(KArchiveLog) << "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 it(d->m_fileList); //qCDebug(KArchiveLog) << "fileName to write: " << name; while (it.hasNext()) { it.next(); //qCDebug(KArchiveLog) << "prepfileName: " << it.current()->path(); if (name == it.value()->path()) { // also remove from the parentDir parentDir->removeEntry(it.value()); //qCDebug(KArchiveLog) << "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, modificationTime, 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()); //qCDebug(KArchiveLog) << "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; //qCDebug(KArchiveLog) << "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->date(), &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.constData(), 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 = 0; delete[] buffer; if (!b) { setErrorString(tr("Could not write to the archive. Disk full?")); 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; } KCompressionDevice::CompressionType type = KFilterDev::compressionTypeForMimeType(QStringLiteral("application/x-gzip")); auto compressionDevice = new KCompressionDevice(device(), false, type); d->m_currentDev = compressionDevice; compressionDevice->setSkipHeaders(); // Just zlib, not gzip b = d->m_currentDev->open(QIODevice::WriteOnly); Q_ASSERT(b); if (!b) { setErrorString( tr("Could not open compression device: %1") .arg(d->m_currentDev->errorString())); } return b; } bool KZip::doFinishWriting(qint64 size) { if (d->m_currentFile->encoding() == 8) { // Finish (void)d->m_currentDev->write(nullptr, 0); delete d->m_currentDev; } // If 0, d->m_currentDev was device() - don't delete ;) d->m_currentDev = nullptr; Q_ASSERT(d->m_currentFile); //qCDebug(KArchiveLog) << "fileName: " << d->m_currentFile->path(); //qCDebug(KArchiveLog) << "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); //qCDebug(KArchiveLog) << "usize: " << d->m_currentFile->size(); //qCDebug(KArchiveLog) << "csize: " << d->m_currentFile->compressedSize(); //qCDebug(KArchiveLog) << "headerstart: " << d->m_currentFile->headerStart(); //qCDebug(KArchiveLog) << "crc: " << d->m_crc; d->m_currentFile->setCRC32(d->m_crc); d->m_currentFile = nullptr; // 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, const QDateTime &atime, const QDateTime &mtime, const QDateTime &ctime) { // reassure that symlink flag is set, otherwise strange things happen on // extraction perm |= QT_STAT_LNK; Compression c = compression(); setCompression(NoCompression); // link targets are never compressed if (!doPrepareWriting(name, user, group, 0, perm, atime, mtime, ctime)) { setCompression(c); return false; } QByteArray symlink_target = QFile::encodeName(target); if (!writeData(symlink_target.constData(), symlink_target.length())) { setCompression(c); return false; } if (!finishWriting(symlink_target.length())) { 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) { setErrorString(tr("No file or device")); 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); //qCDebug(KArchiveLog) << "wrote" << size << "bytes."; const bool ok = written == size; if (!ok) { setErrorString( tr("Error writing data: %1") .arg(d->m_currentDev->errorString())); } 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; } //////////////////////////////////////////////////////////////////////// ////////////////////// KZipFileEntry//////////////////////////////////// //////////////////////////////////////////////////////////////////////// class Q_DECL_HIDDEN 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, const QDateTime &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 { //qCDebug(KArchiveLog) << "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 KCompressionDevice::CompressionType type = KFilterDev::compressionTypeForMimeType(QStringLiteral("application/x-gzip")); KCompressionDevice *filterDev = new KCompressionDevice(limitedDev, true, type); if (!filterDev) { return nullptr; // ouch } filterDev->setSkipHeaders(); // Just zlib, not gzip bool b = filterDev->open(QIODevice::ReadOnly); Q_UNUSED(b); Q_ASSERT(b); return filterDev; } qCCritical(KArchiveLog) << "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."; delete limitedDev; return nullptr; }