2008-11-04 00:08:39 +01:00
|
|
|
/******************************************************************************
|
|
|
|
* Copyright 2007 by Aaron Seigo <aseigo@kde.org> *
|
2011-07-08 19:36:29 +02:00
|
|
|
* Copyright 2010 by Marco Martin <notmart@gmail.com> *
|
|
|
|
* Copyright 2010 by Kevin Ottens <ervin@kde.org> *
|
|
|
|
* Copyright 2009 by Rob Scheepmaker *
|
2008-11-04 00:08:39 +01:00
|
|
|
* *
|
|
|
|
* This library is free software; you can redistribute it and/or *
|
|
|
|
* modify it under the terms of the GNU Library General Public *
|
|
|
|
* License as published by the Free Software Foundation; either *
|
|
|
|
* version 2 of the License, or (at your option) any later version. *
|
|
|
|
* *
|
|
|
|
* 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 "package.h"
|
|
|
|
|
2011-12-06 20:08:22 +01:00
|
|
|
#include <qtemporarydir.h>
|
2008-11-04 00:08:39 +01:00
|
|
|
|
2008-11-04 03:20:46 +01:00
|
|
|
#include <karchive.h>
|
2011-07-15 12:57:46 +02:00
|
|
|
#include <kdebug.h>
|
2008-11-04 03:04:34 +01:00
|
|
|
#include <kdesktopfile.h>
|
2011-07-15 12:57:46 +02:00
|
|
|
#include <kservicetypetrader.h>
|
2012-12-09 14:12:55 +01:00
|
|
|
#include <kstandarddirs.h>
|
2012-06-12 12:59:34 +02:00
|
|
|
#include <ktar.h>
|
|
|
|
#include <kzip.h>
|
2008-11-04 00:08:39 +01:00
|
|
|
|
2011-09-02 10:50:04 +02:00
|
|
|
#include "config-plasma.h"
|
|
|
|
|
2012-06-12 12:59:34 +02:00
|
|
|
#include <qstandardpaths.h>
|
2012-06-21 09:19:32 +02:00
|
|
|
#include <qmimedatabase.h>
|
2011-07-15 12:57:46 +02:00
|
|
|
|
2011-07-19 21:37:39 +02:00
|
|
|
#include "packagestructure.h"
|
2011-07-15 13:34:10 +02:00
|
|
|
#include "pluginloader.h"
|
2009-09-02 04:27:16 +02:00
|
|
|
#include "private/package_p.h"
|
2011-07-15 12:57:46 +02:00
|
|
|
#include "private/packages_p.h"
|
2012-12-09 14:12:55 +01:00
|
|
|
#include "private/packagejob_p.h"
|
2008-11-04 00:08:39 +01:00
|
|
|
|
|
|
|
namespace Plasma
|
|
|
|
{
|
|
|
|
|
2011-07-19 21:37:39 +02:00
|
|
|
Package::Package(PackageStructure *structure)
|
2011-07-15 12:57:46 +02:00
|
|
|
: d(new PackagePrivate())
|
2008-11-04 00:08:39 +01:00
|
|
|
{
|
2011-07-19 21:37:39 +02:00
|
|
|
d->structure = structure;
|
2011-07-21 15:04:56 +02:00
|
|
|
if (d->structure) {
|
|
|
|
d->structure.data()->initPackage(this);
|
|
|
|
}
|
2008-11-04 00:08:39 +01:00
|
|
|
}
|
|
|
|
|
2010-09-03 21:44:28 +02:00
|
|
|
Package::Package(const Package &other)
|
2011-07-22 17:24:40 +02:00
|
|
|
: d(other.d)
|
2010-09-03 21:44:28 +02:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2008-11-04 00:08:39 +01:00
|
|
|
Package::~Package()
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2010-09-03 21:44:28 +02:00
|
|
|
Package &Package::operator=(const Package &rhs)
|
|
|
|
{
|
|
|
|
if (&rhs != this) {
|
2011-07-22 17:24:40 +02:00
|
|
|
d = rhs.d;
|
2010-09-03 21:44:28 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
2008-11-04 00:08:39 +01:00
|
|
|
bool Package::isValid() const
|
|
|
|
{
|
2013-02-05 16:32:34 +01:00
|
|
|
if (d->checkedValid) {
|
|
|
|
return d->valid;
|
2008-11-04 00:08:39 +01:00
|
|
|
}
|
|
|
|
|
2013-02-05 16:32:34 +01:00
|
|
|
d->valid = false;
|
|
|
|
|
2010-11-04 20:18:32 +01:00
|
|
|
//search for the file in all prefixes and in all possible paths for each prefix
|
|
|
|
//even if it's a big nested loop, usually there is one prefix and one location
|
|
|
|
//so shouldn't cause too much disk access
|
2011-07-22 17:24:40 +02:00
|
|
|
QHashIterator<QByteArray, ContentStructure> it(d->contents);
|
2011-07-15 12:57:46 +02:00
|
|
|
while (it.hasNext()) {
|
|
|
|
it.next();
|
|
|
|
if (!it.value().required) {
|
|
|
|
continue;
|
|
|
|
}
|
2010-12-15 07:29:36 +01:00
|
|
|
|
2010-11-03 23:12:30 +01:00
|
|
|
bool failed = true;
|
2011-07-15 12:57:46 +02:00
|
|
|
foreach (const QString &path, it.value().paths) {
|
|
|
|
foreach (const QString &prefix, d->contentsPrefixPaths) {
|
|
|
|
if (QFile::exists(d->path + prefix + path)) {
|
2010-11-04 20:18:32 +01:00
|
|
|
failed = false;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2013-02-05 16:32:34 +01:00
|
|
|
|
2010-11-04 20:18:32 +01:00
|
|
|
if (!failed) {
|
2010-11-03 23:12:30 +01:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (failed) {
|
2011-07-15 12:57:46 +02:00
|
|
|
kWarning() << "Could not find required" << (it.value().directory ? "directory" : "file") << it.key();
|
2008-11-04 00:08:39 +01:00
|
|
|
d->valid = false;
|
2013-02-05 16:32:34 +01:00
|
|
|
break;
|
2008-11-04 00:08:39 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-02-05 16:32:34 +01:00
|
|
|
return d->valid;
|
2011-07-15 12:57:46 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
QString Package::name(const char *key) const
|
|
|
|
{
|
2011-07-21 14:41:01 +02:00
|
|
|
#ifndef PLASMA_NO_PACKAGE_EXTRADATA
|
2011-07-22 17:24:40 +02:00
|
|
|
QHash<QByteArray, ContentStructure>::const_iterator it = d->contents.constFind(key);
|
2011-07-15 12:57:46 +02:00
|
|
|
if (it == d->contents.constEnd()) {
|
|
|
|
return QString();
|
|
|
|
}
|
|
|
|
|
|
|
|
return it.value().name;
|
2011-07-21 14:41:01 +02:00
|
|
|
#else
|
|
|
|
Q_UNUSED(key);
|
|
|
|
return QString();
|
|
|
|
#endif
|
2011-07-15 12:57:46 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
bool Package::isRequired(const char *key) const
|
|
|
|
{
|
2011-07-22 17:24:40 +02:00
|
|
|
QHash<QByteArray, ContentStructure>::const_iterator it = d->contents.constFind(key);
|
2011-07-15 12:57:46 +02:00
|
|
|
if (it == d->contents.constEnd()) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
return it.value().required;
|
|
|
|
}
|
|
|
|
|
|
|
|
QStringList Package::mimeTypes(const char *key) const
|
|
|
|
{
|
2011-07-21 14:41:01 +02:00
|
|
|
#ifndef PLASMA_NO_PACKAGE_EXTRADATA
|
2011-07-22 17:24:40 +02:00
|
|
|
QHash<QByteArray, ContentStructure>::const_iterator it = d->contents.constFind(key);
|
2011-07-15 12:57:46 +02:00
|
|
|
if (it == d->contents.constEnd()) {
|
|
|
|
return QStringList();
|
|
|
|
}
|
|
|
|
|
|
|
|
if (it.value().mimeTypes.isEmpty()) {
|
|
|
|
return d->mimeTypes;
|
|
|
|
}
|
|
|
|
|
|
|
|
return it.value().mimeTypes;
|
2011-07-21 14:41:01 +02:00
|
|
|
#else
|
|
|
|
return QStringList();
|
|
|
|
#endif
|
2011-07-15 12:57:46 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
QString Package::defaultPackageRoot() const
|
|
|
|
{
|
|
|
|
return d->defaultPackageRoot;
|
|
|
|
}
|
|
|
|
|
|
|
|
void Package::setDefaultPackageRoot(const QString &packageRoot)
|
|
|
|
{
|
2011-07-22 17:24:40 +02:00
|
|
|
d.detach();
|
2011-07-15 12:57:46 +02:00
|
|
|
d->defaultPackageRoot = packageRoot;
|
|
|
|
if (!d->defaultPackageRoot.isEmpty() && !d->defaultPackageRoot.endsWith('/')) {
|
|
|
|
d->defaultPackageRoot.append('/');
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
QString Package::servicePrefix() const
|
|
|
|
{
|
|
|
|
return d->servicePrefix;
|
|
|
|
}
|
|
|
|
|
|
|
|
void Package::setServicePrefix(const QString &servicePrefix)
|
|
|
|
{
|
2011-07-22 17:24:40 +02:00
|
|
|
d.detach();
|
2011-07-15 12:57:46 +02:00
|
|
|
d->servicePrefix = servicePrefix;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool Package::allowExternalPaths() const
|
|
|
|
{
|
|
|
|
return d->externalPaths;
|
|
|
|
}
|
|
|
|
|
|
|
|
void Package::setAllowExternalPaths(bool allow)
|
|
|
|
{
|
2011-07-22 17:24:40 +02:00
|
|
|
d.detach();
|
2011-07-15 12:57:46 +02:00
|
|
|
d->externalPaths = allow;
|
|
|
|
}
|
|
|
|
|
|
|
|
KPluginInfo Package::metadata() const
|
|
|
|
{
|
|
|
|
if (!d->metadata && !d->path.isEmpty()) {
|
2011-07-19 21:37:39 +02:00
|
|
|
const QString metadataPath = filePath("metadata");
|
|
|
|
if (!metadataPath.isEmpty()) {
|
|
|
|
d->createPackageMetadata(metadataPath);
|
|
|
|
} else {
|
|
|
|
QFileInfo fileInfo(d->path);
|
|
|
|
|
|
|
|
if (fileInfo.isDir()) {
|
|
|
|
d->createPackageMetadata(d->path);
|
|
|
|
} else if (fileInfo.exists()) {
|
|
|
|
KArchive *archive = 0;
|
2012-06-21 09:19:32 +02:00
|
|
|
QMimeDatabase db;
|
|
|
|
QMimeType mimeType = db.mimeTypeForFile(d->path);
|
2011-07-19 21:37:39 +02:00
|
|
|
|
2012-06-21 09:19:32 +02:00
|
|
|
if (mimeType.inherits("application/zip")) {
|
2011-07-19 21:37:39 +02:00
|
|
|
archive = new KZip(d->path);
|
2012-06-21 09:19:32 +02:00
|
|
|
} else if (mimeType.inherits("application/x-compressed-tar") || mimeType.inherits("application/x-gzip") ||
|
|
|
|
mimeType.inherits("application/x-tar") || mimeType.inherits("application/x-bzip-compressed-tar") ||
|
|
|
|
mimeType.inherits("application/x-xz") || mimeType.inherits("application/x-lzma")) {
|
2011-07-19 21:37:39 +02:00
|
|
|
archive = new KTar(d->path);
|
|
|
|
} else {
|
2012-06-21 09:19:32 +02:00
|
|
|
kWarning() << "Could not open package file, unsupported archive format:" << d->path << mimeType.name();
|
2011-07-19 21:37:39 +02:00
|
|
|
}
|
2011-07-15 12:57:46 +02:00
|
|
|
|
2011-07-19 21:37:39 +02:00
|
|
|
if (archive && archive->open(QIODevice::ReadOnly)) {
|
|
|
|
const KArchiveDirectory *source = archive->directory();
|
2011-12-06 20:08:22 +01:00
|
|
|
QTemporaryDir tempdir;
|
|
|
|
source->copyTo(tempdir.path() + '/');
|
|
|
|
d->createPackageMetadata(tempdir.path() + '/');
|
2011-07-19 21:37:39 +02:00
|
|
|
} else {
|
|
|
|
kWarning() << "Could not open package file:" << d->path;
|
|
|
|
}
|
2010-11-03 23:12:30 +01:00
|
|
|
|
2011-07-19 21:37:39 +02:00
|
|
|
delete archive;
|
|
|
|
}
|
2008-11-04 00:08:39 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-07-15 12:57:46 +02:00
|
|
|
if (!d->metadata) {
|
|
|
|
d->metadata = new KPluginInfo();
|
|
|
|
}
|
|
|
|
|
|
|
|
return *d->metadata;
|
2008-11-04 00:08:39 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
QString Package::filePath(const char *fileType, const QString &filename) const
|
|
|
|
{
|
|
|
|
if (!d->valid) {
|
2010-09-05 00:50:50 +02:00
|
|
|
//kDebug() << "package is not valid";
|
2008-11-04 00:08:39 +01:00
|
|
|
return QString();
|
|
|
|
}
|
|
|
|
|
2011-07-22 17:24:40 +02:00
|
|
|
const QString discoveryKey(fileType + filename);
|
|
|
|
if (d->discoveries.contains(discoveryKey)) {
|
|
|
|
//qDebug() << "looking for" << discoveryKey << d->discoveries.value(discoveryKey);
|
|
|
|
return d->discoveries[discoveryKey];
|
|
|
|
}
|
|
|
|
|
2010-11-03 23:12:30 +01:00
|
|
|
QStringList paths;
|
2008-11-04 00:08:39 +01:00
|
|
|
|
2010-03-09 06:57:57 +01:00
|
|
|
if (qstrlen(fileType) != 0) {
|
2013-02-01 13:20:20 +01:00
|
|
|
kDebug()<<d->contents.keys();
|
2011-07-15 12:57:46 +02:00
|
|
|
if (!d->contents.contains(fileType)) {
|
2013-02-01 13:20:20 +01:00
|
|
|
kDebug() << "package does not contain" << fileType << filename;
|
2011-07-15 12:57:46 +02:00
|
|
|
return QString();
|
|
|
|
}
|
|
|
|
|
|
|
|
paths = d->contents[fileType].paths;
|
2010-03-09 06:57:57 +01:00
|
|
|
|
2010-11-03 23:12:30 +01:00
|
|
|
if (paths.isEmpty()) {
|
2010-09-05 00:50:50 +02:00
|
|
|
//kDebug() << "no matching path came of it, while looking for" << fileType << filename;
|
2011-07-22 17:24:40 +02:00
|
|
|
d->discoveries.insert(discoveryKey, QString());
|
2010-03-09 06:57:57 +01:00
|
|
|
return QString();
|
|
|
|
}
|
2010-11-04 20:18:32 +01:00
|
|
|
} else {
|
2010-12-15 08:13:20 +01:00
|
|
|
//when filetype is empty paths is always empty, so try with an empty string
|
2010-11-04 20:18:32 +01:00
|
|
|
paths << QString();
|
2008-11-04 00:08:39 +01:00
|
|
|
}
|
|
|
|
|
2010-11-04 20:18:32 +01:00
|
|
|
//Nested loop, but in the medium case resolves to just one iteration
|
2010-12-15 08:13:20 +01:00
|
|
|
//kDebug() << "prefixes:" << prefixes.count() << prefixes;
|
2011-07-15 12:57:46 +02:00
|
|
|
foreach (const QString &contentsPrefix, d->contentsPrefixPaths) {
|
|
|
|
const QString prefix(d->path + contentsPrefix);
|
2008-11-04 00:08:39 +01:00
|
|
|
|
2010-11-04 20:18:32 +01:00
|
|
|
foreach (const QString &path, paths) {
|
|
|
|
QString file = prefix + path;
|
2008-11-04 00:08:39 +01:00
|
|
|
|
2010-11-04 20:18:32 +01:00
|
|
|
if (!filename.isEmpty()) {
|
|
|
|
file.append("/").append(filename);
|
2010-11-03 23:12:30 +01:00
|
|
|
}
|
|
|
|
|
2010-12-15 08:13:20 +01:00
|
|
|
//kDebug() << "testing" << file << QFile::exists("/bin/ls") << QFile::exists(file);
|
2010-11-04 20:18:32 +01:00
|
|
|
if (QFile::exists(file)) {
|
2011-07-15 12:57:46 +02:00
|
|
|
if (d->externalPaths) {
|
2010-12-15 08:13:20 +01:00
|
|
|
//kDebug() << "found" << file;
|
2011-07-22 17:24:40 +02:00
|
|
|
d->discoveries.insert(discoveryKey, file);
|
2010-11-04 20:18:32 +01:00
|
|
|
return file;
|
|
|
|
}
|
|
|
|
|
|
|
|
// ensure that we don't return files outside of our base path
|
|
|
|
// due to symlink or ../ games
|
|
|
|
QDir dir(file);
|
|
|
|
QString canonicalized = dir.canonicalPath() + QDir::separator();
|
|
|
|
|
2011-07-15 12:57:46 +02:00
|
|
|
//kDebug() << "testing that" << canonicalized << "is in" << d->path;
|
|
|
|
if (canonicalized.startsWith(d->path)) {
|
2010-12-15 08:13:20 +01:00
|
|
|
//kDebug() << "found" << file;
|
2011-07-22 17:24:40 +02:00
|
|
|
d->discoveries.insert(discoveryKey, file);
|
2010-11-04 20:18:32 +01:00
|
|
|
return file;
|
|
|
|
}
|
2010-11-03 23:12:30 +01:00
|
|
|
}
|
2008-11-04 00:08:39 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-07-15 12:57:46 +02:00
|
|
|
//kDebug() << fileType << filename << "does not exist in" << prefixes << "at root" << d->path;
|
2008-11-04 00:08:39 +01:00
|
|
|
return QString();
|
|
|
|
}
|
|
|
|
|
2011-07-15 12:57:46 +02:00
|
|
|
QStringList Package::entryList(const char *key) const
|
2008-11-04 00:08:39 +01:00
|
|
|
{
|
|
|
|
if (!d->valid) {
|
|
|
|
return QStringList();
|
|
|
|
}
|
|
|
|
|
2011-07-22 17:24:40 +02:00
|
|
|
QHash<QByteArray, ContentStructure>::const_iterator it = d->contents.constFind(key);
|
2011-07-15 12:57:46 +02:00
|
|
|
if (it == d->contents.constEnd()) {
|
2011-07-15 14:17:42 +02:00
|
|
|
//kDebug() << "couldn't find" << key;
|
2011-07-15 12:57:46 +02:00
|
|
|
return QStringList();
|
|
|
|
}
|
|
|
|
|
2011-07-15 14:17:42 +02:00
|
|
|
//kDebug() << "going to list" << key;
|
2011-07-15 12:57:46 +02:00
|
|
|
QStringList list;
|
|
|
|
foreach (const QString &prefix, d->contentsPrefixPaths) {
|
2011-07-15 14:17:42 +02:00
|
|
|
//kDebug() << " looking in" << prefix;
|
2011-07-15 12:57:46 +02:00
|
|
|
foreach (const QString &path, it.value().paths) {
|
2011-07-15 14:17:42 +02:00
|
|
|
//kDebug() << " looking in" << path;
|
2011-07-15 12:57:46 +02:00
|
|
|
if (it.value().directory) {
|
2011-07-15 14:17:42 +02:00
|
|
|
//kDebug() << "it's a directory, so trying out" << d->path + prefix + path;
|
2011-07-15 12:57:46 +02:00
|
|
|
QDir dir(d->path + prefix + path);
|
|
|
|
|
|
|
|
if (d->externalPaths) {
|
|
|
|
list += dir.entryList(QDir::Files | QDir::Readable);
|
|
|
|
} else {
|
|
|
|
// ensure that we don't return files outside of our base path
|
|
|
|
// due to symlink or ../ games
|
|
|
|
QString canonicalized = dir.canonicalPath();
|
2011-07-15 14:17:42 +02:00
|
|
|
if (canonicalized.startsWith(d->path)) {
|
2011-07-15 12:57:46 +02:00
|
|
|
list += dir.entryList(QDir::Files | QDir::Readable);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
const QString fullPath = d->path + prefix + path;
|
2011-07-15 14:17:42 +02:00
|
|
|
//kDebug() << "it's a file at" << fullPath << QFile::exists(fullPath);
|
2011-07-15 12:57:46 +02:00
|
|
|
if (!QFile::exists(fullPath)) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (d->externalPaths) {
|
|
|
|
list += fullPath;
|
|
|
|
} else {
|
|
|
|
QDir dir(fullPath);
|
|
|
|
QString canonicalized = dir.canonicalPath() + QDir::separator();
|
|
|
|
|
|
|
|
//kDebug() << "testing that" << canonicalized << "is in" << d->path;
|
|
|
|
if (canonicalized.startsWith(d->path)) {
|
|
|
|
list += fullPath;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return list;
|
2008-11-04 00:08:39 +01:00
|
|
|
}
|
|
|
|
|
2009-05-13 01:05:40 +02:00
|
|
|
void Package::setPath(const QString &path)
|
|
|
|
{
|
2012-12-09 14:12:55 +01:00
|
|
|
kDebug() << "Package::setPath() " << path;
|
2011-07-22 17:24:40 +02:00
|
|
|
if (path == d->path) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
d.detach();
|
|
|
|
d->discoveries.clear();
|
2011-07-15 12:57:46 +02:00
|
|
|
if (path.isEmpty()) {
|
|
|
|
d->path.clear();
|
|
|
|
d->valid = false;
|
2011-07-22 17:24:40 +02:00
|
|
|
|
|
|
|
if (d->structure) {
|
|
|
|
d->structure.data()->pathChanged(this);
|
|
|
|
}
|
|
|
|
|
2011-07-15 12:57:46 +02:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2013-02-05 16:32:34 +01:00
|
|
|
QStringList paths;
|
|
|
|
if (QDir::isRelativePath(path)) {
|
|
|
|
QString p;
|
2011-07-15 12:57:46 +02:00
|
|
|
if (!d->defaultPackageRoot.isEmpty()) {
|
2013-02-05 16:32:34 +01:00
|
|
|
p = path % "/";
|
|
|
|
} else {
|
|
|
|
p = d->defaultPackageRoot % "/" % path % "/";
|
2011-07-15 12:57:46 +02:00
|
|
|
}
|
|
|
|
|
2013-02-05 16:32:34 +01:00
|
|
|
if (QDir::isRelativePath(p)) {
|
|
|
|
paths << QStandardPaths::locateAll(QStandardPaths::GenericDataLocation, path, QStandardPaths::LocateDirectory);
|
|
|
|
} else {
|
|
|
|
const QDir dir(p);
|
|
|
|
if (QFile::exists(dir.canonicalPath())) {
|
|
|
|
paths << p;
|
2011-07-15 12:57:46 +02:00
|
|
|
}
|
|
|
|
}
|
2013-02-05 16:32:34 +01:00
|
|
|
} else {
|
|
|
|
const QDir dir(path);
|
|
|
|
if (QFile::exists(dir.canonicalPath())) {
|
|
|
|
paths << path;
|
|
|
|
}
|
2010-09-03 21:44:28 +02:00
|
|
|
}
|
2011-07-15 12:57:46 +02:00
|
|
|
|
2013-02-05 16:32:34 +01:00
|
|
|
const QString previousPath = d->path;
|
|
|
|
foreach (const QString &p, paths) {
|
|
|
|
d->checkedValid = false;
|
|
|
|
d->path = p;
|
|
|
|
if (!d->path.endsWith('/')) {
|
|
|
|
d->path.append('/');
|
|
|
|
}
|
2011-07-15 12:57:46 +02:00
|
|
|
|
2013-02-05 16:32:34 +01:00
|
|
|
if (isValid()) {
|
|
|
|
break;
|
2011-07-15 12:57:46 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-02-05 16:32:34 +01:00
|
|
|
if (d->path == previousPath) {
|
2011-07-15 12:57:46 +02:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
delete d->metadata;
|
|
|
|
d->metadata = 0;
|
2011-07-22 17:24:40 +02:00
|
|
|
|
|
|
|
if (d->structure) {
|
|
|
|
d->structure.data()->pathChanged(this);
|
|
|
|
}
|
2009-05-13 01:05:40 +02:00
|
|
|
}
|
|
|
|
|
2008-11-04 00:08:39 +01:00
|
|
|
const QString Package::path() const
|
|
|
|
{
|
2011-07-15 12:57:46 +02:00
|
|
|
return d->path;
|
|
|
|
}
|
|
|
|
|
|
|
|
QStringList Package::contentsPrefixPaths() const
|
|
|
|
{
|
|
|
|
return d->contentsPrefixPaths;
|
|
|
|
}
|
|
|
|
|
|
|
|
void Package::setContentsPrefixPaths(const QStringList &prefixPaths)
|
|
|
|
{
|
2011-07-22 17:24:40 +02:00
|
|
|
d.detach();
|
2011-07-15 12:57:46 +02:00
|
|
|
d->contentsPrefixPaths = prefixPaths;
|
|
|
|
if (d->contentsPrefixPaths.isEmpty()) {
|
|
|
|
d->contentsPrefixPaths << QString();
|
2012-10-31 12:13:43 +01:00
|
|
|
} else {
|
|
|
|
// the code assumes that the prefixes have a trailing slash
|
|
|
|
// so let's make that true here
|
|
|
|
QMutableStringListIterator it(d->contentsPrefixPaths);
|
|
|
|
while (it.hasNext()) {
|
|
|
|
it.next();
|
|
|
|
|
|
|
|
if (!it.value().endsWith('/')) {
|
|
|
|
it.setValue(it.value() % '/');
|
|
|
|
}
|
|
|
|
}
|
2011-07-15 12:57:46 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
QString Package::contentsHash() const
|
|
|
|
{
|
|
|
|
if (!d->valid) {
|
|
|
|
kWarning() << "can not create hash due to Package being invalid";
|
|
|
|
return QString();
|
|
|
|
}
|
|
|
|
|
|
|
|
QCryptographicHash hash(QCryptographicHash::Sha1);
|
|
|
|
QString metadataPath = d->path + "metadata.desktop";
|
|
|
|
if (QFile::exists(metadataPath)) {
|
|
|
|
QFile f(metadataPath);
|
|
|
|
if (f.open(QIODevice::ReadOnly)) {
|
|
|
|
while (!f.atEnd()) {
|
|
|
|
hash.addData(f.read(1024));
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
kWarning() << "could not add" << f.fileName() << "to the hash; file could not be opened for reading.";
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
kWarning() << "no metadata at" << metadataPath;
|
|
|
|
}
|
|
|
|
|
|
|
|
foreach (QString prefix, d->contentsPrefixPaths) {
|
|
|
|
const QString basePath = d->path + prefix;
|
|
|
|
QDir dir(basePath);
|
|
|
|
|
|
|
|
if (!dir.exists()) {
|
|
|
|
return QString();
|
|
|
|
}
|
|
|
|
|
|
|
|
d->updateHash(basePath, QString(), dir, hash);
|
|
|
|
}
|
|
|
|
|
2011-07-15 14:24:35 +02:00
|
|
|
return hash.result().toHex();
|
2011-07-15 12:57:46 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
void Package::addDirectoryDefinition(const char *key, const QString &path, const QString &name)
|
|
|
|
{
|
|
|
|
ContentStructure s;
|
|
|
|
|
|
|
|
if (d->contents.contains(key)) {
|
|
|
|
s = d->contents[key];
|
|
|
|
}
|
|
|
|
|
2011-07-21 14:41:01 +02:00
|
|
|
#ifndef PLASMA_NO_PACKAGE_EXTRADATA
|
2011-07-15 12:57:46 +02:00
|
|
|
if (!name.isEmpty()) {
|
|
|
|
s.name = name;
|
|
|
|
}
|
2011-07-21 14:41:01 +02:00
|
|
|
#else
|
|
|
|
Q_UNUSED(name)
|
|
|
|
#endif
|
2011-07-15 12:57:46 +02:00
|
|
|
|
|
|
|
s.paths.append(path);
|
|
|
|
s.directory = true;
|
|
|
|
|
|
|
|
d->contents[key] = s;
|
|
|
|
}
|
|
|
|
|
|
|
|
void Package::addFileDefinition(const char *key, const QString &path, const QString &name)
|
|
|
|
{
|
|
|
|
ContentStructure s;
|
|
|
|
|
|
|
|
if (d->contents.contains(key)) {
|
|
|
|
s = d->contents[key];
|
|
|
|
}
|
|
|
|
|
2011-07-21 14:41:01 +02:00
|
|
|
#ifndef PLASMA_NO_PACKAGE_EXTRADATA
|
2011-07-15 12:57:46 +02:00
|
|
|
if (!name.isEmpty()) {
|
|
|
|
s.name = name;
|
|
|
|
}
|
2011-07-21 14:41:01 +02:00
|
|
|
#else
|
|
|
|
Q_UNUSED(name)
|
|
|
|
#endif
|
2011-07-15 12:57:46 +02:00
|
|
|
|
|
|
|
s.paths.append(path);
|
|
|
|
s.directory = false;
|
|
|
|
|
|
|
|
d->contents[key] = s;
|
|
|
|
}
|
|
|
|
|
|
|
|
void Package::removeDefinition(const char *key)
|
|
|
|
{
|
|
|
|
d->contents.remove(key);
|
|
|
|
}
|
|
|
|
|
|
|
|
void Package::setRequired(const char *key, bool required)
|
|
|
|
{
|
2011-07-22 17:24:40 +02:00
|
|
|
QHash<QByteArray, ContentStructure>::iterator it = d->contents.find(key);
|
2011-07-15 12:57:46 +02:00
|
|
|
if (it == d->contents.end()) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2011-07-22 17:24:40 +02:00
|
|
|
d.detach();
|
2011-07-15 12:57:46 +02:00
|
|
|
it.value().required = required;
|
2008-11-04 00:08:39 +01:00
|
|
|
}
|
|
|
|
|
2011-07-15 12:57:46 +02:00
|
|
|
void Package::setDefaultMimeTypes(QStringList mimeTypes)
|
2008-11-04 00:08:39 +01:00
|
|
|
{
|
2011-07-21 14:41:01 +02:00
|
|
|
#ifndef PLASMA_NO_PACKAGE_EXTRADATA
|
2011-07-22 17:24:40 +02:00
|
|
|
d.detach();
|
2011-07-15 12:57:46 +02:00
|
|
|
d->mimeTypes = mimeTypes;
|
2011-07-21 14:41:01 +02:00
|
|
|
#endif
|
2011-07-15 12:57:46 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
void Package::setMimeTypes(const char *key, QStringList mimeTypes)
|
|
|
|
{
|
2011-07-21 14:41:01 +02:00
|
|
|
#ifndef PLASMA_NO_PACKAGE_EXTRADATA
|
2011-07-22 17:24:40 +02:00
|
|
|
QHash<QByteArray, ContentStructure>::iterator it = d->contents.find(key);
|
2011-07-15 12:57:46 +02:00
|
|
|
if (it == d->contents.end()) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2011-07-22 17:24:40 +02:00
|
|
|
d.detach();
|
2011-07-15 12:57:46 +02:00
|
|
|
it.value().mimeTypes = mimeTypes;
|
2011-07-21 14:41:01 +02:00
|
|
|
#endif
|
2011-07-15 12:57:46 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
QList<const char*> Package::directories() const
|
|
|
|
{
|
|
|
|
QList<const char*> dirs;
|
2011-07-22 17:24:40 +02:00
|
|
|
QHash<QByteArray, ContentStructure>::const_iterator it = d->contents.constBegin();
|
2011-07-15 12:57:46 +02:00
|
|
|
while (it != d->contents.constEnd()) {
|
|
|
|
if (it.value().directory) {
|
|
|
|
dirs << it.key();
|
|
|
|
}
|
|
|
|
++it;
|
|
|
|
}
|
|
|
|
return dirs;
|
|
|
|
}
|
|
|
|
|
|
|
|
QList<const char*> Package::requiredDirectories() const
|
|
|
|
{
|
|
|
|
QList<const char*> dirs;
|
2011-07-22 17:24:40 +02:00
|
|
|
QHash<QByteArray, ContentStructure>::const_iterator it = d->contents.constBegin();
|
2011-07-15 12:57:46 +02:00
|
|
|
while (it != d->contents.constEnd()) {
|
|
|
|
if (it.value().directory &&
|
|
|
|
it.value().required) {
|
|
|
|
dirs << it.key();
|
|
|
|
}
|
|
|
|
++it;
|
|
|
|
}
|
|
|
|
return dirs;
|
|
|
|
}
|
|
|
|
|
|
|
|
QList<const char*> Package::files() const
|
|
|
|
{
|
|
|
|
QList<const char*> files;
|
2011-07-22 17:24:40 +02:00
|
|
|
QHash<QByteArray, ContentStructure>::const_iterator it = d->contents.constBegin();
|
2011-07-15 12:57:46 +02:00
|
|
|
while (it != d->contents.constEnd()) {
|
|
|
|
if (!it.value().directory) {
|
|
|
|
files << it.key();
|
|
|
|
}
|
|
|
|
++it;
|
|
|
|
}
|
|
|
|
return files;
|
|
|
|
}
|
|
|
|
|
|
|
|
QList<const char*> Package::requiredFiles() const
|
|
|
|
{
|
|
|
|
QList<const char*> files;
|
2011-07-22 17:24:40 +02:00
|
|
|
QHash<QByteArray, ContentStructure>::const_iterator it = d->contents.constBegin();
|
2011-07-15 12:57:46 +02:00
|
|
|
while (it != d->contents.constEnd()) {
|
|
|
|
if (!it.value().directory && it.value().required) {
|
|
|
|
files << it.key();
|
|
|
|
}
|
|
|
|
++it;
|
|
|
|
}
|
|
|
|
|
|
|
|
return files;
|
|
|
|
}
|
|
|
|
|
2012-12-09 14:12:55 +01:00
|
|
|
KJob* Package::install(const QString &sourcePackage, const QString &packageRoot)
|
2011-07-19 21:37:39 +02:00
|
|
|
{
|
2012-12-09 14:12:55 +01:00
|
|
|
const QString src = sourcePackage;
|
|
|
|
const QString dest = packageRoot.isEmpty() ? defaultPackageRoot() : packageRoot;
|
|
|
|
//kDebug() << "Source: " << src;
|
|
|
|
//kDebug() << "PackageRoot: " << dest;
|
|
|
|
d->path = packageRoot + "plasma-applet-org.kde.microblog-qml";
|
|
|
|
KJob *j = d->structure.data()->install(this, src, dest);
|
|
|
|
//connect(j, SIGNAL(finished(bool)), SLOT(installFinished(bool)));
|
|
|
|
return j;
|
2011-07-19 21:37:39 +02:00
|
|
|
}
|
|
|
|
|
2012-12-09 14:12:55 +01:00
|
|
|
KJob* Package::uninstall(const QString &packageName, const QString &packageRoot)
|
2011-07-15 12:57:46 +02:00
|
|
|
{
|
|
|
|
|
2012-12-09 14:12:55 +01:00
|
|
|
const QString pname = metadata().pluginName();
|
2011-07-15 12:57:46 +02:00
|
|
|
|
2012-12-09 14:12:55 +01:00
|
|
|
QString proot = path();
|
|
|
|
proot.replace(pname, "");
|
|
|
|
kDebug() << "Package::uninstalling ... " << packageRoot << proot << pname << packageName;
|
|
|
|
return d->structure.data()->uninstall(this, packageRoot);
|
2011-07-15 12:57:46 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
PackagePrivate::PackagePrivate()
|
2011-07-22 17:24:40 +02:00
|
|
|
: QSharedData(),
|
|
|
|
servicePrefix("plasma-applet-"),
|
2011-07-15 12:57:46 +02:00
|
|
|
metadata(0),
|
|
|
|
externalPaths(false),
|
2013-02-05 16:32:34 +01:00
|
|
|
valid(false),
|
|
|
|
checkedValid(false)
|
2011-07-15 12:57:46 +02:00
|
|
|
{
|
|
|
|
contentsPrefixPaths << "contents/";
|
|
|
|
}
|
|
|
|
|
|
|
|
PackagePrivate::PackagePrivate(const PackagePrivate &other)
|
2011-07-22 17:24:40 +02:00
|
|
|
: QSharedData()
|
2011-07-15 12:57:46 +02:00
|
|
|
{
|
|
|
|
*this = other;
|
2011-07-21 14:57:43 +02:00
|
|
|
metadata = 0;
|
2011-07-15 12:57:46 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
PackagePrivate::~PackagePrivate()
|
|
|
|
{
|
|
|
|
delete metadata;
|
|
|
|
}
|
|
|
|
|
|
|
|
PackagePrivate &PackagePrivate::operator=(const PackagePrivate &rhs)
|
|
|
|
{
|
2011-07-22 17:24:40 +02:00
|
|
|
if (&rhs == this) {
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
2011-07-21 14:57:43 +02:00
|
|
|
structure = rhs.structure;
|
2011-07-15 12:57:46 +02:00
|
|
|
path = rhs.path;
|
|
|
|
contentsPrefixPaths = rhs.contentsPrefixPaths;
|
|
|
|
servicePrefix = rhs.servicePrefix;
|
|
|
|
contents = rhs.contents;
|
2011-07-21 14:41:01 +02:00
|
|
|
#ifndef PLASMA_NO_PACKAGE_EXTRADATA
|
2011-07-15 12:57:46 +02:00
|
|
|
mimeTypes = rhs.mimeTypes;
|
2011-07-21 14:41:01 +02:00
|
|
|
#endif
|
2011-07-15 12:57:46 +02:00
|
|
|
defaultPackageRoot = rhs.defaultPackageRoot;
|
|
|
|
servicePrefix = rhs.servicePrefix;
|
|
|
|
metadata = 0;
|
|
|
|
externalPaths = rhs.externalPaths;
|
|
|
|
valid = rhs.valid;
|
|
|
|
return *this;
|
2008-11-04 00:08:39 +01:00
|
|
|
}
|
|
|
|
|
2011-05-27 12:26:59 +02:00
|
|
|
void PackagePrivate::updateHash(const QString &basePath, const QString &subPath, const QDir &dir, QCryptographicHash &hash)
|
2009-09-21 23:37:44 +02:00
|
|
|
{
|
|
|
|
// hash is calculated as a function of:
|
|
|
|
// * files ordered alphabetically by name, with each file's:
|
|
|
|
// * path relative to the content root
|
|
|
|
// * file data
|
|
|
|
// * directories ordered alphabetically by name, with each dir's:
|
|
|
|
// * path relative to the content root
|
|
|
|
// * file listing (recursing)
|
|
|
|
// symlinks (in both the file and dir case) are handled by adding
|
|
|
|
// the name of the symlink itself and the abs path of what it points to
|
|
|
|
|
|
|
|
const QDir::SortFlags sorting = QDir::Name | QDir::IgnoreCase;
|
|
|
|
const QDir::Filters filters = QDir::Hidden | QDir::System | QDir::NoDotAndDotDot;
|
|
|
|
foreach (const QString &file, dir.entryList(QDir::Files | filters, sorting)) {
|
|
|
|
if (!subPath.isEmpty()) {
|
2011-05-27 12:26:59 +02:00
|
|
|
hash.addData(subPath.toUtf8());
|
2009-09-21 23:37:44 +02:00
|
|
|
}
|
|
|
|
|
2011-05-27 12:26:59 +02:00
|
|
|
hash.addData(file.toUtf8());
|
2009-09-21 23:37:44 +02:00
|
|
|
|
|
|
|
QFileInfo info(dir.path() + '/' + file);
|
|
|
|
if (info.isSymLink()) {
|
2011-05-27 12:26:59 +02:00
|
|
|
hash.addData(info.symLinkTarget().toUtf8());
|
2009-09-21 23:37:44 +02:00
|
|
|
} else {
|
|
|
|
QFile f(info.filePath());
|
|
|
|
if (f.open(QIODevice::ReadOnly)) {
|
|
|
|
while (!f.atEnd()) {
|
2011-05-27 12:26:59 +02:00
|
|
|
hash.addData(f.read(1024));
|
2009-09-21 23:37:44 +02:00
|
|
|
}
|
|
|
|
} else {
|
2009-09-21 23:48:19 +02:00
|
|
|
kWarning() << "could not add" << f.fileName() << "to the hash; file could not be opened for reading. "
|
|
|
|
<< "permissions fail?" << info.permissions() << info.isFile();
|
2009-09-21 23:37:44 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
foreach (const QString &subDirPath, dir.entryList(QDir::Dirs | filters, sorting)) {
|
|
|
|
const QString relativePath = subPath + subDirPath + '/';
|
2011-05-27 12:26:59 +02:00
|
|
|
hash.addData(relativePath.toUtf8());
|
2009-09-21 23:37:44 +02:00
|
|
|
|
|
|
|
QDir subDir(dir.path());
|
|
|
|
subDir.cd(subDirPath);
|
|
|
|
|
|
|
|
if (subDir.path() != subDir.canonicalPath()) {
|
2011-05-27 12:26:59 +02:00
|
|
|
hash.addData(subDir.canonicalPath().toUtf8());
|
2009-09-21 23:37:44 +02:00
|
|
|
} else {
|
|
|
|
updateHash(basePath, relativePath, subDir, hash);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-07-15 12:57:46 +02:00
|
|
|
void PackagePrivate::createPackageMetadata(const QString &path)
|
2009-09-21 23:37:44 +02:00
|
|
|
{
|
2011-07-15 12:57:46 +02:00
|
|
|
delete metadata;
|
2009-09-21 23:48:19 +02:00
|
|
|
|
2011-07-15 12:57:46 +02:00
|
|
|
QString metadataPath(path + "/metadata.desktop");
|
|
|
|
if (!QFile::exists(metadataPath)) {
|
|
|
|
kWarning() << "No metadata file in the package, expected it at:" << metadataPath;
|
|
|
|
metadataPath.clear();
|
2010-12-15 07:29:36 +01:00
|
|
|
}
|
|
|
|
|
2011-07-15 12:57:46 +02:00
|
|
|
metadata = new KPluginInfo(metadataPath);
|
2009-09-21 23:37:44 +02:00
|
|
|
}
|
|
|
|
|
2008-11-04 00:08:39 +01:00
|
|
|
} // Namespace
|