File indexing completed on 2024-04-14 15:32:03

 /*
  *  SPDX-FileCopyrightText: 2013 Alejandro Fiestas Fiestas <afiestas@kde.org>
  *  SPDX-FileCopyrightText: 2014-2015 David Rosca <nowrep@gmail.com>
  *
  *  SPDX-License-Identifier: GPL-2.0-or-later
  */
 
 #include "obexftp.h"
 #include "bluedevil_kded.h"
 #include "bluedevildaemon.h"
 
 #include <QDBusConnection>
 #include <QDBusObjectPath>
 #include <QDBusPendingCallWatcher>
 #include <QDBusPendingReply>
 
 #include <KLocalizedString>
 
 #include <BluezQt/Device>
 #include <BluezQt/InitObexManagerJob>
 #include <BluezQt/ObexFileTransfer>
 #include <BluezQt/ObexManager>
 #include <BluezQt/ObexSession>
 #include <BluezQt/PendingCall>
 
 ObexFtp::ObexFtp(BlueDevilDaemon *daemon)
     : QDBusAbstractAdaptor(daemon)
     , m_daemon(daemon)
 {
     connect(m_daemon->obexManager(), &BluezQt::ObexManager::sessionRemoved, this, &ObexFtp::sessionRemoved);
 }
 
 bool ObexFtp::isOnline()
 {
     return m_daemon->obexManager()->isOperational();
 }
 
 QString ObexFtp::preferredTarget(const QString &address)
 {
     BluezQt::DevicePtr device = m_daemon->manager()->deviceForAddress(address);
 
     // Prefer pcsuite target on S60 devices
     if (device && device->uuids().contains(QStringLiteral("00005005-0000-1000-8000-0002EE000001"))) {
         return QStringLiteral("pcsuite");
     }
     return QStringLiteral("ftp");
 }
 
 QString ObexFtp::session(const QString &address, const QString &target, const QDBusMessage &msg)
 {
     if (!m_daemon->obexManager()->isOperational()) {
         return QString();
     }
 
     if (m_sessionMap.contains(address)) {
         return m_sessionMap[address];
     }
 
     qCDebug(BLUEDEVIL_KDED_LOG) << "Creating obexftp session for" << address;
 
     // At this point we always want delayed reply
     msg.setDelayedReply(true);
 
     if (m_pendingSessions.contains(address)) {
         m_pendingSessions[address].append(msg);
         return QString();
     }
 
     m_pendingSessions.insert(address, {msg});
 
     QVariantMap args;
     args[QStringLiteral("Target")] = target;
 
     BluezQt::PendingCall *call = m_daemon->obexManager()->createSession(address, args);
     call->setUserData(address);
     connect(call, &BluezQt::PendingCall::finished, this, &ObexFtp::createSessionFinished);
 
     return QString();
 }
 
 bool ObexFtp::cancelTransfer(const QString &transfer, const QDBusMessage &msg)
 {
     // We need this function because kio_obexftp is not owner of the transfer,
     // and thus cannot cancel it.
 
     msg.setDelayedReply(true);
 
     QDBusMessage call = QDBusMessage::createMethodCall(QStringLiteral("org.bluez.obex"), //
                                                        transfer,
                                                        QStringLiteral("org.bluez.obex.Transfer1"),
                                                        QStringLiteral("Cancel"));
 
     QDBusPendingCallWatcher *watcher = new QDBusPendingCallWatcher(QDBusConnection::sessionBus().asyncCall(call));
     watcher->setProperty("ObexFtpDaemon-msg", QVariant::fromValue(msg));
     connect(watcher, &QDBusPendingCallWatcher::finished, this, &ObexFtp::cancelTransferFinished);
 
     return false;
 }
 
 void ObexFtp::createSessionFinished(BluezQt::PendingCall *call)
 {
     QString path;
 
     if (call->error() == BluezQt::PendingCall::AlreadyExists) {
         // It may happen when kded crashes, or the session was created by different app
         // What to do here? We are not owners of the session...
         qCWarning(BLUEDEVIL_KDED_LOG) << "Obex session already exists but it was created by different process!";
     } else if (call->error()) {
         qCWarning(BLUEDEVIL_KDED_LOG) << "Error creating Obex session" << call->errorText();
     } else {
         path = call->value().value<QDBusObjectPath>().path();
         qCDebug(BLUEDEVIL_KDED_LOG) << "Created Obex session" << path;
     }
 
     const QString &address = call->userData().toString();
 
     // Send reply (empty session path in case of error)
     Q_FOREACH (const QDBusMessage &msg, m_pendingSessions[address]) {
         QDBusMessage reply = msg.createReply(path);
         QDBusConnection::sessionBus().send(reply);
     }
 
     m_pendingSessions.remove(address);
 
     if (!call->error()) {
         m_sessionMap.insert(address, path);
     }
 }
 
 void ObexFtp::cancelTransferFinished(QDBusPendingCallWatcher *watcher)
 {
     const QDBusPendingReply<> &reply = *watcher;
     QDBusMessage msg = watcher->property("ObexFtpDaemon-msg").value<QDBusMessage>();
 
     bool success = !reply.isError();
     QDBusConnection::sessionBus().send(msg.createReply(QVariant(success)));
 }
 
 void ObexFtp::sessionRemoved(BluezQt::ObexSessionPtr session)
 {
     const QString &path = session->objectPath().path();
     const QString &key = m_sessionMap.key(path);
 
     if (!m_sessionMap.contains(key)) {
         qCDebug(BLUEDEVIL_KDED_LOG) << "Removed Obex session is not ours" << path;
         return;
     }
 
     qCDebug(BLUEDEVIL_KDED_LOG) << "Removed Obex session" << path;
     m_sessionMap.remove(key);
 }