File indexing completed on 2024-05-05 03:56:07

 /*
     This file is part of the KDE project
     SPDX-FileCopyrightText: 2004 Kevin Ottens <ervin ipsquad net>
 
     SPDX-License-Identifier: LGPL-2.0-or-later
 */
 
 #include "kio_remote.h"
 #include "debug.h"
 #include <stdlib.h>
 
 #include <QCoreApplication>
 
 // Pseudo plugin class to embed meta data
 class KIOPluginForMetaData : public QObject
 {
     Q_OBJECT
     Q_PLUGIN_METADATA(IID "org.kde.kio.worker.remote" FILE "remote.json")
 };
 
 extern "C" {
 int Q_DECL_EXPORT kdemain(int argc, char **argv)
 {
     // necessary to use other kio workers
     QCoreApplication app(argc, argv);
     app.setApplicationName(QStringLiteral("kio_remote"));
 
     // start the worker
     RemoteProtocol worker(argv[1], argv[2], argv[3]);
     worker.dispatchLoop();
     return 0;
 }
 }
 
 RemoteProtocol::RemoteProtocol(const QByteArray &protocol, const QByteArray &pool, const QByteArray &app)
     : WorkerBase(protocol, pool, app)
 {
 }
 
 RemoteProtocol::~RemoteProtocol()
 {
 }
 
 KIO::WorkerResult RemoteProtocol::listDir(const QUrl &url)
 {
     qCDebug(KIOREMOTE_LOG) << "RemoteProtocol::listDir: " << url;
 
     if (url.path().length() <= 1) {
         return listRoot();
     }
 
     int second_slash_idx = url.path().indexOf(QLatin1Char('/'), 1);
     const QString root_dirname = url.path().mid(1, second_slash_idx - 1);
 
     QUrl target = m_impl.findBaseURL(root_dirname);
     qCDebug(KIOREMOTE_LOG) << "possible redirection target : " << target;
     if (target.isValid()) {
         if (second_slash_idx < 0) {
             second_slash_idx = url.path().size();
         }
         const QString urlPath = url.path().remove(0, second_slash_idx);
         if (!urlPath.isEmpty()) {
             target.setPath(QStringLiteral("%1/%2").arg(target.path(), urlPath));
         }
         qCDebug(KIOREMOTE_LOG) << "complete redirection target : " << target;
         redirection(target);
         return KIO::WorkerResult::pass();
     }
 
     return KIO::WorkerResult::fail(KIO::ERR_MALFORMED_URL, url.toDisplayString());
 }
 
 KIO::WorkerResult RemoteProtocol::listRoot()
 {
     KIO::UDSEntry entry;
 
     KIO::UDSEntryList remote_entries;
     m_impl.listRoot(remote_entries);
 
     totalSize(remote_entries.count() + 2);
 
     m_impl.createTopLevelEntry(entry);
     listEntry(entry);
 
     KIO::UDSEntryList::ConstIterator it = remote_entries.constBegin();
     const KIO::UDSEntryList::ConstIterator end = remote_entries.constEnd();
     for (; it != end; ++it) {
         listEntry(*it);
     }
 
     entry.clear();
     return KIO::WorkerResult::pass();
 }
 
 KIO::WorkerResult RemoteProtocol::stat(const QUrl &url)
 {
     qCDebug(KIOREMOTE_LOG) << "RemoteProtocol::stat: " << url;
 
     QString path = url.path();
     if (path.isEmpty() || path == QLatin1String("/")) {
         // The root is "virtual" - it's not a single physical directory
         KIO::UDSEntry entry;
         m_impl.createTopLevelEntry(entry);
         statEntry(entry);
         return KIO::WorkerResult::pass();
     }
 
     int second_slash_idx = url.path().indexOf(QLatin1Char('/'), 1);
     const QString root_dirname = url.path().mid(1, second_slash_idx - 1);
 
     if (second_slash_idx == -1 || ((int)url.path().length()) == second_slash_idx + 1) {
         KIO::UDSEntry entry;
         if (m_impl.statNetworkFolder(entry, root_dirname)) {
             statEntry(entry);
             return KIO::WorkerResult::pass();
         }
     } else {
         QUrl target = m_impl.findBaseURL(root_dirname);
         qCDebug(KIOREMOTE_LOG) << "possible redirection target : " << target;
         if (target.isValid()) {
             if (second_slash_idx < 0) {
                 second_slash_idx = url.path().size();
             }
             const QString urlPath = url.path().remove(0, second_slash_idx);
             if (!urlPath.isEmpty()) {
                 target.setPath(QStringLiteral("%1/%2").arg(target.path(), urlPath));
             }
             qCDebug(KIOREMOTE_LOG) << "complete redirection target : " << target;
             redirection(target);
             return KIO::WorkerResult::pass();
         }
     }
 
     return KIO::WorkerResult::fail(KIO::ERR_MALFORMED_URL, url.toDisplayString());
 }
 
 KIO::WorkerResult RemoteProtocol::del(const QUrl &url, bool /*isFile*/)
 {
     qCDebug(KIOREMOTE_LOG) << "RemoteProtocol::del: " << url;
 
     if (m_impl.deleteNetworkFolder(url.fileName())) {
         return KIO::WorkerResult::pass();
     }
 
     return KIO::WorkerResult::fail(KIO::ERR_CANNOT_DELETE, url.toDisplayString());
 }
 
 KIO::WorkerResult RemoteProtocol::get(const QUrl &url)
 {
     qCDebug(KIOREMOTE_LOG) << "RemoteProtocol::get: " << url;
 
     const QString file = m_impl.findDesktopFile(url.fileName());
     qCDebug(KIOREMOTE_LOG) << "desktop file : " << file;
 
     if (!file.isEmpty()) {
         redirection(QUrl::fromLocalFile(file));
         return KIO::WorkerResult::pass();
     }
 
     return KIO::WorkerResult::fail(KIO::ERR_MALFORMED_URL, url.toDisplayString());
 }
 
 KIO::WorkerResult RemoteProtocol::rename(const QUrl &src, const QUrl &dest, KIO::JobFlags flags)
 {
     if (src.scheme() != QLatin1String("remote") || dest.scheme() != QLatin1String("remote")) {
         return KIO::WorkerResult::fail(KIO::ERR_UNSUPPORTED_ACTION, src.toDisplayString());
     }
 
     if (m_impl.renameFolders(src.fileName(), dest.fileName(), flags & KIO::Overwrite)) {
         return KIO::WorkerResult::pass();
     }
 
     return KIO::WorkerResult::fail(KIO::ERR_CANNOT_RENAME, src.toDisplayString());
 }
 
 KIO::WorkerResult RemoteProtocol::symlink(const QString &target, const QUrl &dest, KIO::JobFlags flags)
 {
     if (m_impl.changeFolderTarget(dest.fileName(), target, flags & KIO::Overwrite)) {
         return KIO::WorkerResult::pass();
     }
 
     return KIO::WorkerResult::fail(KIO::ERR_CANNOT_SYMLINK, dest.toDisplayString());
 }
 
 #include "kio_remote.moc"