File indexing completed on 2024-06-23 05:14:14

 /* -*- mode: c++; c-basic-offset:4 -*-
     uiserver/uiserver.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2007 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include <config-kleopatra.h>
 
 #include "uiserver.h"
 #include "uiserver_p.h"
 
 #include "sessiondata.h"
 
 #include <Libkleo/GnuPG>
 #include <utils/detail_p.h>
 
 #include <Libkleo/KleoException>
 #include <Libkleo/Stl_Util>
 
 #include "kleopatra_debug.h"
 #include <KLocalizedString>
 
 #include <gpgme++/global.h>
 
 #include <QDir>
 #include <QEventLoop>
 #include <QFile>
 #include <QTcpSocket>
 #include <QTimer>
 
 #include <algorithm>
 #include <cerrno>
 
 using namespace Kleo;
 
 // static
 void UiServer::setLogStream(FILE *stream)
 {
     assuan_set_assuan_log_stream(stream);
 }
 
 UiServer::Private::Private(UiServer *qq)
     : QTcpServer()
     , q(qq)
     , file()
     , factories()
     , connections()
     , suggestedSocketName()
     , actualSocketName()
     , cryptoCommandsEnabled(false)
 {
     assuan_set_gpg_err_source(GPG_ERR_SOURCE_DEFAULT);
     assuan_sock_init();
 }
 
 bool UiServer::Private::isStaleAssuanSocket(const QString &fileName)
 {
     assuan_context_t ctx = nullptr;
     const bool error = assuan_new(&ctx) || assuan_socket_connect(ctx, QFile::encodeName(fileName).constData(), ASSUAN_INVALID_PID, 0);
     if (!error)
         assuan_release(ctx);
     return error;
 }
 
 UiServer::UiServer(const QString &socket, QObject *p)
     : QObject(p)
     , d(new Private(this))
 {
     d->suggestedSocketName = d->makeFileName(socket);
 }
 
 UiServer::~UiServer()
 {
     if (QFile::exists(d->actualSocketName)) {
         QFile::remove(d->actualSocketName);
     }
 }
 
 namespace
 {
 using Iterator = std::vector<std::shared_ptr<AssuanCommandFactory>>::iterator;
 static bool empty(std::pair<Iterator, Iterator> iters)
 {
     return iters.first == iters.second;
 }
 }
 
 bool UiServer::registerCommandFactory(const std::shared_ptr<AssuanCommandFactory> &cf)
 {
     if (cf && empty(std::equal_range(d->factories.begin(), d->factories.end(), cf, _detail::ByName<std::less>()))) {
         d->factories.push_back(cf);
         std::inplace_merge(d->factories.begin(), d->factories.end() - 1, d->factories.end(), _detail::ByName<std::less>());
         return true;
     } else {
         if (!cf) {
             qCWarning(KLEOPATRA_LOG) << "NULL factory";
         } else {
             qCWarning(KLEOPATRA_LOG) << (void *)cf.get() << " factory already registered";
         }
 
         return false;
     }
 }
 
 void UiServer::start()
 {
     d->makeListeningSocket();
 }
 
 void UiServer::stop()
 {
     d->close();
 
     if (d->file.exists()) {
         d->file.remove();
     }
 
     if (isStopped()) {
         SessionDataHandler::instance()->clear();
         Q_EMIT stopped();
     }
 }
 
 void UiServer::enableCryptoCommands(bool on)
 {
     if (on == d->cryptoCommandsEnabled) {
         return;
     }
     d->cryptoCommandsEnabled = on;
     std::for_each(d->connections.cbegin(), d->connections.cend(), [on](std::shared_ptr<AssuanServerConnection> conn) {
         conn->enableCryptoCommands(on);
     });
 }
 
 QString UiServer::socketName() const
 {
     return d->actualSocketName;
 }
 
 bool UiServer::waitForStopped(unsigned int ms)
 {
     if (isStopped()) {
         return true;
     }
     QEventLoop loop;
     QTimer timer;
     timer.setInterval(ms);
     timer.setSingleShot(true);
     connect(&timer, &QTimer::timeout, &loop, &QEventLoop::quit);
     connect(this, &UiServer::stopped, &loop, &QEventLoop::quit);
     loop.exec();
     return !timer.isActive();
 }
 
 bool UiServer::isStopped() const
 {
     return d->connections.empty() && !d->isListening();
 }
 
 bool UiServer::isStopping() const
 {
     return !d->connections.empty() && !d->isListening();
 }
 
 void UiServer::Private::slotConnectionClosed(Kleo::AssuanServerConnection *conn)
 {
     qCDebug(KLEOPATRA_LOG) << "UiServer: connection " << (void *)conn << " closed";
     connections.erase(std::remove_if(connections.begin(),
                                      connections.end(),
                                      [conn](const std::shared_ptr<AssuanServerConnection> &other) {
                                          return conn == other.get();
                                      }),
                       connections.end());
     if (q->isStopped()) {
         SessionDataHandler::instance()->clear();
         Q_EMIT q->stopped();
     }
 }
 
 void UiServer::Private::incomingConnection(qintptr fd)
 {
     try {
         qCDebug(KLEOPATRA_LOG) << "UiServer: client connect on fd " << fd;
         if (assuan_sock_check_nonce((assuan_fd_t)fd, &nonce)) {
             qCDebug(KLEOPATRA_LOG) << "UiServer: nonce check failed";
             assuan_sock_close((assuan_fd_t)fd);
             return;
         }
         const std::shared_ptr<AssuanServerConnection> c(new AssuanServerConnection((assuan_fd_t)fd, factories));
         connect(c.get(), &AssuanServerConnection::closed, this, &Private::slotConnectionClosed);
         connect(c.get(), &AssuanServerConnection::startKeyManagerRequested, q, &UiServer::startKeyManagerRequested, Qt::QueuedConnection);
         connect(c.get(), &AssuanServerConnection::startConfigDialogRequested, q, &UiServer::startConfigDialogRequested, Qt::QueuedConnection);
         c->enableCryptoCommands(cryptoCommandsEnabled);
         connections.push_back(c);
         qCDebug(KLEOPATRA_LOG) << "UiServer: client connection " << (void *)c.get() << " established successfully";
     } catch (const Exception &e) {
         qCDebug(KLEOPATRA_LOG) << "UiServer: client connection failed: " << e.what();
         QTcpSocket s;
         s.setSocketDescriptor(fd);
         QTextStream(&s) << "ERR " << e.error_code() << " " << e.what() << "\r\n";
         s.waitForBytesWritten();
         s.close();
     } catch (...) {
         qCDebug(KLEOPATRA_LOG) << "UiServer: client connection failed: unknown exception caught";
         // this should never happen...
         QTcpSocket s;
         s.setSocketDescriptor(fd);
         QTextStream(&s) << "ERR 63 unknown exception caught\r\n";
         s.waitForBytesWritten();
         s.close();
     }
 }
 
 QString UiServer::Private::makeFileName(const QString &socket) const
 {
     if (!socket.isEmpty()) {
         return socket;
     }
     const QString socketPath{QString::fromUtf8(GpgME::dirInfo("uiserver-socket"))};
     if (!socketPath.isEmpty()) {
         // Note: The socket directory exists after GpgME::dirInfo() has been called.
         return socketPath;
     }
     // GPGME (or GnuPG) is too old to return the socket path.
     // In this case we fallback to assume that the socket directory is
     // the home directory as we did in the past.  This is not correct but
     // probably the safest fallback we can do despite that it is a
     // bug to assume the socket directory in the home directory.  See
     // https://dev.gnupg.org/T5613
     const QString gnupgHome = gnupgHomeDirectory();
     if (gnupgHome.isEmpty()) {
         throw_<std::runtime_error>(i18n("Could not determine the GnuPG home directory. Consider setting the GNUPGHOME environment variable."));
     }
     // We should not create the home directory, but this only happens for very
     // old and long unsupported versions of gnupg.
     ensureDirectoryExists(gnupgHome);
     const QDir dir(gnupgHome);
     Q_ASSERT(dir.exists());
     return dir.absoluteFilePath(QStringLiteral("S.uiserver"));
 }
 
 void UiServer::Private::ensureDirectoryExists(const QString &path) const
 {
     const QFileInfo info(path);
     if (info.exists() && !info.isDir()) {
         throw_<std::runtime_error>(i18n("Cannot determine the GnuPG home directory: %1 exists but is not a directory.", path));
     }
     if (info.exists()) {
         return;
     }
     const QDir dummy; // there is no static QDir::mkpath()...
     errno = 0;
     if (!dummy.mkpath(path)) {
         throw_<std::runtime_error>(i18n("Could not create GnuPG home directory %1: %2", path, systemErrorString()));
     }
 }
 
 void UiServer::Private::makeListeningSocket()
 {
     // First, create a file (we do this only for the name, gmpfh)
     const QString fileName = suggestedSocketName;
 
     if (QFile::exists(fileName)) {
         if (isStaleAssuanSocket(fileName)) {
             QFile::remove(fileName);
         } else {
             throw_<std::runtime_error>(i18n("Detected another running gnupg UI server listening at %1.", fileName));
         }
     }
 
     doMakeListeningSocket(fileName.toUtf8());
 
     actualSocketName = suggestedSocketName;
 }
 
 #include "moc_uiserver_p.cpp"
 
 #include "moc_uiserver.cpp"