You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
310 lines
10 KiB
310 lines
10 KiB
/*
|
|
SPDX-FileCopyrightText: 2008 Ingo Klöcker <kloecker@kde.org>
|
|
SPDX-FileCopyrightText: 2009 Constantin Berzan <exit3219@gmail.com>
|
|
|
|
SPDX-License-Identifier: LGPL-2.0-or-later
|
|
*/
|
|
|
|
#include "pepagent.h"
|
|
#include "pepagent_debug.h"
|
|
#include "pep-introspectadaptor.h"
|
|
|
|
using namespace Akonadi;
|
|
|
|
PEP_STATUS pEpAgent::messageToSend(::message* msg)
|
|
{
|
|
qDebug() << "pEp wants to send a message";
|
|
return PEP_STATUS_OK;
|
|
}
|
|
|
|
pEpAgent::pEpAgent(const QString &id)
|
|
: ResourceBase(id)
|
|
{
|
|
Q_D(pEpAgent);
|
|
|
|
PEP_STATUS status;
|
|
QDBusConnection dbus = QDBusConnection::sessionBus();
|
|
const QString service = Akonadi::ServerManager::self()->agentServiceName(Akonadi::ServerManager::Agent, QStringLiteral("pEpAgent"));
|
|
|
|
/* -------------- Starting the pEp Engine ------------------- */
|
|
status = ::init(&m_session, NULL, NULL, NULL);
|
|
/* --------------------- Done ------------------------------- */
|
|
|
|
/* ------------- Extending DBus functions ------------------- */
|
|
m_pEpadaptor = new PepAdaptor(this);
|
|
dbus.registerObject(QStringLiteral("/security/pep"), QStringLiteral("security.pep"), this);
|
|
dbus.registerService(service);
|
|
/* --------------------- Done ------------------------------- */
|
|
|
|
// pEp management
|
|
m_syncThread = new pEpSyncThread(this);
|
|
|
|
// This here is just bureaucracy:
|
|
auto *collectionMonitor = new Akonadi::Monitor(this);
|
|
collectionMonitor->setObjectName(QStringLiteral("pEpCollectionMonitor"));
|
|
collectionMonitor->fetchCollection(true);
|
|
collectionMonitor->ignoreSession(Akonadi::Session::defaultSession());
|
|
collectionMonitor->collectionFetchScope().setAncestorRetrieval(Akonadi::CollectionFetchScope::All);
|
|
collectionMonitor->setMimeTypeMonitored(KMime::Message::mimeType());
|
|
|
|
connect(collectionMonitor, &Akonadi::Monitor::collectionAdded, this, &pEpAgent::mailCollectionAdded);
|
|
connect(collectionMonitor, qOverload<const Akonadi::Collection &>(&Akonadi::Monitor::collectionChanged), this, &pEpAgent::mailCollectionChanged);
|
|
|
|
connect(collectionMonitor, &Akonadi::Monitor::collectionRemoved, this, &pEpAgent::mailCollectionRemoved);
|
|
connect(Akonadi::AgentManager::self(), &Akonadi::AgentManager::instanceRemoved, this, &pEpAgent::slotInstanceRemoved);
|
|
|
|
QTimer::singleShot(0, this, &pEpAgent::initializeCollections);
|
|
|
|
mProgressCounter = 0;
|
|
mProgressTimer = new QTimer(this);
|
|
|
|
itemMonitor = new Akonadi::Monitor(this);
|
|
itemMonitor->setObjectName(QStringLiteral("pEpItemMonitor"));
|
|
itemMonitor->itemFetchScope().setFetchRemoteIdentification(true);
|
|
itemMonitor->itemFetchScope().setAncestorRetrieval(Akonadi::ItemFetchScope::Parent);
|
|
|
|
connect(itemMonitor, &Akonadi::Monitor::itemChanged, this, &pEpAgent::slotItemChanged);
|
|
}
|
|
|
|
void pEpAgent::initializeCollections()
|
|
{
|
|
|
|
qCDebug(PEPAGENT_LOG) << __FUNCTION__ << " Test";
|
|
qDebug() << __FUNCTION__ << " Test";
|
|
|
|
Akonadi::CollectionFetchJob *job = new Akonadi::CollectionFetchJob(Akonadi::Collection::root(),
|
|
Akonadi::CollectionFetchJob::Recursive,
|
|
this);
|
|
|
|
job->fetchScope(); //.setContentMimeTypes({ QStringLiteral("multipart/encrypted") });
|
|
|
|
connect(job, &Akonadi::CollectionFetchJob::result, this, &pEpAgent::initialCollectionFetchingDone);
|
|
}
|
|
|
|
void pEpAgent::emitProgress(int p)
|
|
{
|
|
qCDebug(PEPAGENT_LOG) << __FUNCTION__ << " Test";
|
|
qDebug() << __FUNCTION__ << " Test";
|
|
if (p == 0) {
|
|
mProgressTimer->stop();
|
|
Q_EMIT status(AgentBase::Idle, QString());
|
|
}
|
|
mProgressCounter = p;
|
|
Q_EMIT percent(p);
|
|
}
|
|
|
|
void pEpAgent::emitProgressMessage(const QString &message)
|
|
{
|
|
qCDebug(PEPAGENT_LOG) << __FUNCTION__ << " Test";
|
|
Q_EMIT status(AgentBase::Running, message);
|
|
if (status() == AgentBase::Idle) {
|
|
// If still idle after aborting, clear 'aborted' status.
|
|
Q_EMIT status(AgentBase::Idle, i18n("Ready to dispatch messages."));
|
|
}
|
|
}
|
|
|
|
void pEpAgent::itemsReceiviedForFiltering(const Akonadi::Item::List &items)
|
|
{
|
|
qDebug() << __FUNCTION__ << " Test";
|
|
|
|
if (items.isEmpty()) {
|
|
qCDebug(PEPAGENT_LOG) << "pEpAgent::itemsReceiviedForFiltering items is empty!";
|
|
return;
|
|
}
|
|
|
|
Akonadi::Item item = items.first();
|
|
if (!item.hasPayload()) {
|
|
qCDebug(PEPAGENT_LOG) << "pEpAgent::itemsReceiviedForFiltering item has no payload!";
|
|
return;
|
|
}
|
|
|
|
QString resource = sender()->property("resource").toString();
|
|
const Akonadi::Pop3ResourceAttribute *pop3ResourceAttribute = item.attribute<Akonadi::Pop3ResourceAttribute>();
|
|
if (pop3ResourceAttribute) {
|
|
resource = pop3ResourceAttribute->pop3AccountName();
|
|
}
|
|
|
|
emitProgressMessage(i18n("Filtering in %1", Akonadi::AgentManager::self()->instance(resource).name()));
|
|
|
|
emitProgress(++mProgressCounter);
|
|
|
|
mProgressTimer->start(1000);
|
|
}
|
|
|
|
void pEpAgent::clearMessage()
|
|
{
|
|
}
|
|
|
|
void pEpAgent::emitStatusReady()
|
|
{
|
|
if (status() == AgentBase::Idle) {
|
|
// If still idle after aborting, clear 'aborted' status.
|
|
Q_EMIT status(AgentBase::Idle, i18n("p≡p engine ready"));
|
|
}
|
|
}
|
|
|
|
bool pEpAgent::isFilterableCollection(const Akonadi::Collection &collection) const
|
|
{
|
|
// TODO: Do this smarter
|
|
if(QStringLiteral( "INBOX" ) == collection.name()) {
|
|
qDebug() << __FUNCTION__ << "Found an INBOX folder";
|
|
return true;
|
|
}
|
|
if( QStringLiteral("inbox") == collection.name() ) {
|
|
qDebug() << __FUNCTION__ << "Found an INBOX folder";
|
|
return true;
|
|
}
|
|
|
|
qDebug() << __FUNCTION__ << "Not yet supported folder name: " << collection.name();
|
|
return false;
|
|
}
|
|
|
|
void pEpAgent::scanCollection(const Akonadi::Collection &collection)
|
|
{
|
|
}
|
|
|
|
void pEpAgent::initialCollectionFetchingDone(KJob *job)
|
|
{
|
|
qDebug() << __FUNCTION__ << " Test";
|
|
|
|
if (job->error()) {
|
|
qDebug() << job->errorString();
|
|
return;
|
|
}
|
|
|
|
const auto fetchJob = qobject_cast<Akonadi::CollectionFetchJob *>(job);
|
|
const auto pop3ResourceMap = MailCommon::Kernel::pop3ResourceTargetCollection();
|
|
const auto lstCols = fetchJob->collections();
|
|
|
|
for (const Akonadi::Collection &collection : lstCols) { // All the folders of all the accounts
|
|
if(isFilterableCollection(collection)) {
|
|
qDebug() << "Checking for keys in collection: " << collection.name();
|
|
changeRecorder()->setCollectionMonitored(collection, true);
|
|
}
|
|
}
|
|
|
|
Q_EMIT status(AgentBase::Idle, i18n("Ready"));
|
|
Q_EMIT percent(100);
|
|
QTimer::singleShot(2000, this, &pEpAgent::clearMessage);
|
|
}
|
|
|
|
void pEpAgent::slotItemChanged(const Akonadi::Item &item)
|
|
{
|
|
qDebug() << __FUNCTION__ << " Test";
|
|
if (item.remoteId().isEmpty()) {
|
|
return;
|
|
}
|
|
|
|
// now we have the remoteId
|
|
itemMonitor->setItemMonitored(item, false);
|
|
filterItem(item, item.parentCollection());
|
|
}
|
|
|
|
void pEpAgent::filterItem(const Akonadi::Item &item, const Akonadi::Collection &collection)
|
|
{
|
|
qDebug() << __FUNCTION__;
|
|
auto job = new Akonadi::ItemFetchJob(item);
|
|
connect(job, &Akonadi::ItemFetchJob::itemsReceived, this, &pEpAgent::itemsReceiviedForFiltering);
|
|
job->fetchScope().fetchFullPayload();
|
|
job->fetchScope().setAncestorRetrieval(Akonadi::ItemFetchScope::Parent);
|
|
job->fetchScope().fetchAttribute<Akonadi::Pop3ResourceAttribute>();
|
|
job->setProperty("resource", collection.resource());
|
|
|
|
// TODO: Error handling?
|
|
}
|
|
|
|
void pEpAgent::mailCollectionRemoved(const Akonadi::Collection &collection)
|
|
{
|
|
qDebug() << __FUNCTION__;
|
|
changeRecorder()->setCollectionMonitored(collection, false);
|
|
}
|
|
|
|
void pEpAgent::mailCollectionChanged(const Akonadi::Collection &collection)
|
|
{
|
|
qDebug() << __FUNCTION__;
|
|
changeRecorder()->setCollectionMonitored(collection, isFilterableCollection(collection));
|
|
}
|
|
|
|
void pEpAgent::mailCollectionAdded(const Akonadi::Collection &collection, const Akonadi::Collection &)
|
|
{
|
|
qDebug() << __FUNCTION__;
|
|
if (isFilterableCollection(collection)) {
|
|
changeRecorder()->setCollectionMonitored(collection, true);
|
|
}
|
|
}
|
|
|
|
void pEpAgent::slotInstanceRemoved(const Akonadi::AgentInstance &instance)
|
|
{
|
|
qDebug() << __FUNCTION__;
|
|
//m_filterManager->agentRemoved(instance.identifier());
|
|
}
|
|
|
|
void pEpAgent::itemAdded(const Akonadi::Item &item, const Akonadi::Collection &collection)
|
|
{
|
|
qDebug() << __FUNCTION__;
|
|
/* The monitor mimetype filter would override the collection filter, therefor we have to check
|
|
* for the mimetype of the item here.
|
|
*/
|
|
if (item.mimeType() != KMime::Message::mimeType()) {
|
|
return;
|
|
}
|
|
|
|
if (item.remoteId().isEmpty()) {
|
|
itemMonitor->setItemMonitored(item);
|
|
} else {
|
|
qDebug() << __FUNCTION__ << ": Filter this\n";
|
|
filterItem(item, collection);
|
|
}
|
|
}
|
|
|
|
void pEpAgent::configure(WId windowId)
|
|
{
|
|
qDebug() << __FUNCTION__ << "Test";
|
|
}
|
|
|
|
void pEpAgent::retrieveCollections()
|
|
{
|
|
// TODO: Put information here, like person table content and so:
|
|
Akonadi::Collection::List collections;
|
|
Akonadi::Collection topLevel;
|
|
topLevel.setName(identifier());
|
|
topLevel.setRemoteId(identifier());
|
|
topLevel.setParentCollection(Akonadi::Collection::root());
|
|
topLevel.setContentMimeTypes({Akonadi::Collection::mimeType()});
|
|
topLevel.setRights(Akonadi::Collection::ReadOnly);
|
|
auto topLevelDisplayAttr = topLevel.attribute<Akonadi::EntityDisplayAttribute>(Akonadi::Collection::AddIfMissing);
|
|
topLevelDisplayAttr->setDisplayName(i18n("p≡p Engine"));
|
|
topLevelDisplayAttr->setActiveIconName(QStringLiteral("akonadi-pep"));
|
|
collections.push_back(topLevel);
|
|
collectionsRetrieved(std::move(collections));
|
|
}
|
|
|
|
|
|
int pEpAgent::decrypt_message(const QString &src, QString &dst, QStringList &keylist, int &flags)
|
|
{
|
|
qDebug() << "pEpAgent: Decrypting";
|
|
char *ms = src.toLatin1().data();
|
|
::message *m = NULL;
|
|
::message *md = new_message(PEP_dir_incoming);
|
|
stringlist_t *kl = new_stringlist("");
|
|
PEP_decrypt_flags_t fl = 0;
|
|
bool might_be_pep = true;
|
|
::mime_decode_message( ms, src.toLatin1().size(), &m, &might_be_pep );
|
|
::decrypt_message(m_session, m, &md, &kl, &fl);
|
|
if(md) {
|
|
::mime_encode_message(md, true, &ms, true);
|
|
}
|
|
flags = fl;
|
|
dst = QLatin1String(ms);
|
|
keylist.clear();
|
|
while(kl) {
|
|
keylist << QLatin1String(kl->value);
|
|
kl = kl->next;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
AKONADI_RESOURCE_MAIN(pEpAgent)
|
|
|
|
#include "moc_pepagent.cpp"
|