diff --git a/src/kleo-assuan.h b/src/kleo-assuan.h
deleted file mode 100644
index 9d9838ba0..000000000
--- a/src/kleo-assuan.h
+++ /dev/null
@@ -1,13 +0,0 @@
-/* -*- mode: c++; c-basic-offset:4 -*-
-    kleo-assuan.h
-
-    This file is part of Kleopatra, the KDE keymanager
-    SPDX-FileCopyrightText: 2008 Klarälvdalens Datakonsult AB
-
-    SPDX-License-Identifier: GPL-2.0-or-later
-*/
-
-#pragma once
-
-#include <assuan.h>
-
diff --git a/src/uiserver/assuanserverconnection.h b/src/uiserver/assuanserverconnection.h
index 482dce8a6..fa6673fb2 100644
--- a/src/uiserver/assuanserverconnection.h
+++ b/src/uiserver/assuanserverconnection.h
@@ -1,49 +1,49 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     uiserver/assuanserverconnection.h
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2007 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #pragma once
 
 #include <QObject>
 
-#include <kleo-assuan.h> // for assuan_fd_t
+#include <assuan.h> // for assuan_fd_t
 
 #include <utils/pimpl_ptr.h>
 
 #include <memory>
 #include <string>
 #include <vector>
 
 namespace Kleo
 {
 
 class AssuanCommandFactory;
 
 class AssuanServerConnection : public QObject
 {
     Q_OBJECT
 public:
     AssuanServerConnection(assuan_fd_t fd, const std::vector< std::shared_ptr<AssuanCommandFactory> > &factories, QObject *parent = nullptr);
     ~AssuanServerConnection() override;
 
 public Q_SLOTS:
     void enableCryptoCommands(bool enable = true);
 
 Q_SIGNALS:
     void closed(Kleo::AssuanServerConnection *which);
     void startKeyManagerRequested();
     void startConfigDialogRequested();
 
 public:
     class Private;
 private:
     kdtools::pimpl_ptr<Private> d;
 };
 
 }
 
diff --git a/src/uiserver/uiserver_p.h b/src/uiserver/uiserver_p.h
index 4dfd61618..9aa575258 100644
--- a/src/uiserver/uiserver_p.h
+++ b/src/uiserver/uiserver_p.h
@@ -1,74 +1,74 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     uiserver/uiserver_p.h
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2007 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 #pragma once
 
 #include "uiserver.h"
 
 #include "assuanserverconnection.h"
 #include "assuancommand.h"
 
 #include <utils/wsastarter.h>
 
 #include <QTcpServer>
 #include <QFile>
 
-#include <kleo-assuan.h>
+#include <assuan.h>
 
 #include <memory>
 #include <algorithm>
 #include <vector>
 
 namespace
 {
 template <typename Ex>
 void throw_(const QString &message)
 {
     throw Ex(message.toUtf8().constData());
 }
 }
 
 namespace Kleo
 {
 
 class UiServer::Private : public QTcpServer
 {
     Q_OBJECT
     friend class ::Kleo::UiServer;
     UiServer *const q;
 public:
     explicit Private(UiServer *qq);
     static bool isStaleAssuanSocket(const QString &socketName);
 
 private:
     void makeListeningSocket();
     // platform-specific creation impl for makeListeningSocket():
     void doMakeListeningSocket(const QByteArray &encodedFileName);
     QString makeFileName(const QString &hint = QString()) const;
     void ensureDirectoryExists(const QString &path) const;
     static QString systemErrorString();
 
 protected:
     void incomingConnection(qintptr fd) override;
 
 private Q_SLOTS:
     void slotConnectionClosed(Kleo::AssuanServerConnection *conn);
 
 private:
     QFile file;
     std::vector< std::shared_ptr<AssuanCommandFactory> > factories;
     std::vector< std::shared_ptr<AssuanServerConnection> > connections;
     QString suggestedSocketName;
     QString actualSocketName;
     assuan_sock_nonce_t nonce;
     const WSAStarter _wsastarter;
     bool cryptoCommandsEnabled;
 };
 
 }
 
diff --git a/src/utils/detail_p.h b/src/utils/detail_p.h
index 403b7ba55..f068003c7 100644
--- a/src/utils/detail_p.h
+++ b/src/utils/detail_p.h
@@ -1,88 +1,88 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     utils/detail_p.h
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2007 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #pragma once
 
-#include <kleo-assuan.h>
+#include <assuan.h>
 
 
 #ifdef _WIN32
 #include <io.h>
 #endif
 
 namespace Kleo
 {
 namespace _detail
 {
 
 template <template <typename U> class Op>
 struct ByName {
     using result_type = bool;
 
     template <typename T>
     bool operator()(const T &lhs, const T &rhs) const
     {
         return Op<int>()(qstricmp(lhs->name(), rhs->name()), 0);
     }
     template <typename T>
     bool operator()(const T &lhs, const char *rhs) const
     {
         return Op<int>()(qstricmp(lhs->name(), rhs), 0);
     }
     template <typename T>
     bool operator()(const char *lhs, const T &rhs) const
     {
         return Op<int>()(qstricmp(lhs, rhs->name()), 0);
     }
     bool operator()(const char *lhs, const char *rhs) const
     {
         return Op<int>()(qstricmp(lhs, rhs), 0);
     }
 };
 
 // inspired by GnuPG's translate_sys2libc_fd, this converts a HANDLE
 // to int fd on Windows, and is a NO-OP on POSIX:
 static inline int translate_sys2libc_fd(assuan_fd_t fd, bool for_write)
 {
     if (fd == ASSUAN_INVALID_FD) {
         return -1;
     }
 #if defined(_WIN32)
     return _open_osfhandle((intptr_t)fd, for_write);
 #else
     (void)for_write;
     return fd;
 #endif
 }
 
 static inline assuan_fd_t translate_libc2sys_fd(int fd)
 {
     if (fd == -1) {
         return ASSUAN_INVALID_FD;
     }
 #if defined(_WIN32)
     return (assuan_fd_t)_get_osfhandle(fd);
 #else
     return fd;
 #endif
 }
 
 //returns an integer representation of the assuan_fd_t,
 //suitable for debug output
 static inline qulonglong assuanFD2int(assuan_fd_t fd)
 {
 #ifdef _WIN32
     return reinterpret_cast<qulonglong>(fd);
 #else
     return static_cast<qulonglong>(fd);
 #endif
 }
 }
 }
 
diff --git a/src/utils/input.h b/src/utils/input.h
index 49418d5f2..d1fd27c5e 100644
--- a/src/utils/input.h
+++ b/src/utils/input.h
@@ -1,59 +1,59 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     utils/input.h
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2007 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #pragma once
 
-#include <kleo-assuan.h> // for assuan_fd_t
+#include <assuan.h> // for assuan_fd_t
 
 #include <memory>
 
 class QIODevice;
 class QString;
 #include <QStringList>
 class QByteArray;
 class QFile;
 class QDir;
 
 namespace Kleo
 {
 class Output;
 class Input
 {
 public:
     virtual ~Input();
 
     virtual QString label() const = 0;
     virtual void setLabel(const QString &label) = 0;
     virtual std::shared_ptr<QIODevice> ioDevice() const = 0;
     virtual unsigned int classification() const = 0;
     virtual unsigned long long size() const = 0;
     virtual QString errorString() const = 0;
     /** Whether or not the input failed. */
     virtual bool failed() const { return false; }
 
     void finalize(); // equivalent to ioDevice()->close();
 
     static std::shared_ptr<Input> createFromPipeDevice(assuan_fd_t fd, const QString &label);
     static std::shared_ptr<Input> createFromFile(const QString &filename, bool dummy = false);
     static std::shared_ptr<Input> createFromFile(const std::shared_ptr<QFile> &file);
     static std::shared_ptr<Input> createFromOutput(const std::shared_ptr<Output> &output); // implemented in output.cpp
     static std::shared_ptr<Input> createFromProcessStdOut(const QString &command);
     static std::shared_ptr<Input> createFromProcessStdOut(const QString &command, const QStringList &args);
     static std::shared_ptr<Input> createFromProcessStdOut(const QString &command, const QStringList &args, const QDir &workingDirectory);
     static std::shared_ptr<Input> createFromProcessStdOut(const QString &command, const QByteArray &stdin_);
     static std::shared_ptr<Input> createFromProcessStdOut(const QString &command, const QStringList &args, const QByteArray &stdin_);
     static std::shared_ptr<Input> createFromProcessStdOut(const QString &command, const QStringList &args, const QDir &workingDirectory, const QByteArray &stdin_);
 #ifndef QT_NO_CLIPBOARD
     static std::shared_ptr<Input> createFromClipboard();
 #endif
     static std::shared_ptr<Input> createFromByteArray(QByteArray *data, const QString &label);
 };
 }
 
 
diff --git a/src/utils/output.h b/src/utils/output.h
index f1b9b065b..9fee4747b 100644
--- a/src/utils/output.h
+++ b/src/utils/output.h
@@ -1,81 +1,81 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     utils/output.h
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2007 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #pragma once
 
-#include <kleo-assuan.h> // for assuan_fd_t
+#include <assuan.h> // for assuan_fd_t
 
 #include <utils/pimpl_ptr.h>
 
 #include <QString>
 #include <QStringList>
 
 #include <memory>
 
 class QIODevice;
 class QDir;
 class QWidget;
 
 namespace Kleo
 {
 
 class OverwritePolicy
 {
 public:
     enum Policy {
         Allow,
         Deny,
         Ask
     };
 
     explicit OverwritePolicy(QWidget *parent, Policy initialPolicy = Ask);
     ~OverwritePolicy();
 
     Policy policy() const;
     void setPolicy(Policy);
 
     QWidget *parentWidget() const;
 
 private:
     class Private;
     kdtools::pimpl_ptr<Private> d;
 };
 
 class Output
 {
 public:
     virtual ~Output();
 
     virtual void setLabel(const QString &label) = 0;
     virtual QString label() const = 0;
     virtual std::shared_ptr<QIODevice> ioDevice() const = 0;
     virtual QString errorString() const = 0;
     virtual bool isFinalized() const = 0;
     virtual void finalize() = 0;
     virtual void cancel() = 0;
     virtual bool binaryOpt() const = 0;
     virtual void setBinaryOpt(bool value) = 0;
     /** Whether or not the output failed. */
     virtual bool failed() const { return false; }
     virtual QString fileName() const { return {}; }
 
     static std::shared_ptr<Output> createFromFile(const QString &fileName, const std::shared_ptr<OverwritePolicy> &);
     static std::shared_ptr<Output> createFromFile(const QString &fileName, bool forceOverwrite);
     static std::shared_ptr<Output> createFromPipeDevice(assuan_fd_t fd, const QString &label);
     static std::shared_ptr<Output> createFromProcessStdIn(const QString &command);
     static std::shared_ptr<Output> createFromProcessStdIn(const QString &command, const QStringList &args);
     static std::shared_ptr<Output> createFromProcessStdIn(const QString &command, const QStringList &args, const QDir &workingDirectory);
 #ifndef QT_NO_CLIPBOARD
     static std::shared_ptr<Output> createFromClipboard();
 #endif
     static std::shared_ptr<Output> createFromByteArray(QByteArray *data, const QString &label);
 };
 }
 
 
diff --git a/tests/test_uiserver.cpp b/tests/test_uiserver.cpp
index 28fdb04d6..e3686c954 100644
--- a/tests/test_uiserver.cpp
+++ b/tests/test_uiserver.cpp
@@ -1,270 +1,270 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     tests/test_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
 */
 
 //
 // Usage: test_uiserver <socket> --verify-detached <signed data> <signature>
 //
 
 #include <config-kleopatra.h>
 
-#include <kleo-assuan.h>
+#include <assuan.h>
 #include <gpg-error.h>
 
 #include <Libkleo/Hex>
 #include <Libkleo/KleoException>
 
 #include "utils/wsastarter.h"
 
 #ifndef Q_OS_WIN32
 # include <unistd.h>
 # include <sys/types.h>
 # include <sys/stat.h>
 # include <fcntl.h>
 # include <errno.h>
 #endif
 
 #include <cstdlib>
 #include <iostream>
 #include <map>
 #include <string>
 #include <vector>
 
 using namespace Kleo;
 
 #ifdef Q_OS_WIN32
 static const bool HAVE_FD_PASSING = false;
 #else
 static const bool HAVE_FD_PASSING = true;
 #endif
 
 static const unsigned int ASSUAN_CONNECT_FLAGS = HAVE_FD_PASSING ? 1 : 0;
 
 static std::vector<int> inFDs, outFDs, msgFDs;
 static std::vector<std::string> inFiles, outFiles, msgFiles;
 static std::map<std::string, std::string> inquireData;
 
 static void usage(const std::string &msg = std::string())
 {
     std::cerr << msg << std::endl <<
               "\n"
               "Usage: test_uiserver <socket> [<io>] [<options>] [<inquire>] command [<args>]\n"
               "where:\n"
 #ifdef Q_OS_WIN32
               "      <io>: [--input[-fd] <file>] [--output[-fd] <file>] [--message[-fd] <file>]\n"
 #else
               "      <io>: [--input <file>] [--output <file>] [--message <file>]\n"
 #endif
               " <options>: *[--option name=value]\n"
               " <inquire>: [--inquire keyword=<file>]\n";
     exit(1);
 }
 
 static gpg_error_t data(void *void_ctx, const void *buffer, size_t len)
 {
     (void)void_ctx; (void)buffer; (void)len;
     return 0; // ### implement me
 }
 
 static gpg_error_t status(void *void_ctx, const char *line)
 {
     (void)void_ctx; (void)line;
     return 0;
 }
 
 static gpg_error_t inquire(void *void_ctx, const char *keyword)
 {
     assuan_context_t ctx = (assuan_context_t)void_ctx;
     Q_ASSERT(ctx);
     const std::map<std::string, std::string>::const_iterator it = inquireData.find(keyword);
     if (it == inquireData.end()) {
         return gpg_error(GPG_ERR_UNKNOWN_COMMAND);
     }
 
     if (!it->second.empty() && it->second[0] == '@') {
         return gpg_error(GPG_ERR_NOT_IMPLEMENTED);
     }
 
     if (const gpg_error_t err = assuan_send_data(ctx, it->second.c_str(), it->second.size())) {
         qDebug("assuan_write_data: %s", gpg_strerror(err));
         return err;
     }
 
     return 0;
 }
 
 int main(int argc, char *argv[])
 {
 
     const Kleo::WSAStarter _wsastarter;
 
     assuan_set_gpg_err_source(GPG_ERR_SOURCE_DEFAULT);
 
     if (argc < 3) {
         usage();    // need socket and command, at least
     }
 
     const char *socket = argv[1];
 
     std::vector<const char *> options;
 
     std::string command;
     for (int optind = 2; optind < argc; ++optind) {
         const char *const arg = argv[optind];
         if (qstrcmp(arg, "--input") == 0) {
             const std::string file = argv[++optind];
             inFiles.push_back(file);
         } else if (qstrcmp(arg, "--output") == 0) {
             const std::string file = argv[++optind];
             outFiles.push_back(file);
         } else if (qstrcmp(arg, "--message") == 0) {
             const std::string file = argv[++optind];
             msgFiles.push_back(file);
 #ifndef Q_OS_WIN32
         } else if (qstrcmp(arg, "--input-fd") == 0) {
             int inFD;
             if ((inFD = open(argv[++optind], O_RDONLY)) == -1) {
                 perror("--input-fd open()");
                 return 1;
             }
             inFDs.push_back(inFD);
         } else if (qstrcmp(arg, "--output-fd") == 0) {
             int outFD;
             if ((outFD = open(argv[++optind], O_WRONLY | O_CREAT, 0666)) ==  -1) {
                 perror("--output-fd open()");
                 return 1;
             }
             outFDs.push_back(outFD);
         } else if (qstrcmp(arg, "--message-fd") == 0) {
             int msgFD;
             if ((msgFD = open(argv[++optind], O_RDONLY)) ==  -1) {
                 perror("--message-fd open()");
                 return 1;
             }
             msgFDs.push_back(msgFD);
 #endif
         } else if (qstrcmp(arg, "--option") == 0) {
             options.push_back(argv[++optind]);
         } else if (qstrcmp(arg, "--inquire") == 0) {
             const std::string inqval = argv[++optind];
             const size_t pos = inqval.find('=');
             // ### implement indirection with "@file"...
             inquireData[inqval.substr(0, pos)] = inqval.substr(pos + 1);
         } else {
             while (optind < argc) {
                 if (!command.empty()) {
                     command += ' ';
                 }
                 command += argv[optind++];
             }
         }
     }
     if (command.empty()) {
         usage("Command expected, but only options found");
     }
 
     assuan_context_t ctx = nullptr;
 
     if (const gpg_error_t err = assuan_new(&ctx)) {
         qDebug("%s", Exception(err, "assuan_new").what());
         return 1;
     }
 
     if (const gpg_error_t err = assuan_socket_connect(ctx, socket, -1, ASSUAN_CONNECT_FLAGS)) {
         qDebug("%s", Exception(err, "assuan_socket_connect").what());
         return 1;
     }
 
     assuan_set_log_stream(ctx, stderr);
 
 #ifndef Q_OS_WIN32
     for (std::vector<int>::const_iterator it = inFDs.begin(), end = inFDs.end(); it != end; ++it) {
         if (const gpg_error_t err = assuan_sendfd(ctx, *it)) {
             qDebug("%s", Exception(err, "assuan_sendfd( inFD )").what());
             return 1;
         }
 
         if (const gpg_error_t err = assuan_transact(ctx, "INPUT FD", nullptr, nullptr, nullptr, nullptr, nullptr, nullptr)) {
             qDebug("%s", Exception(err, "INPUT FD").what());
             return 1;
         }
     }
 
     for (std::vector<int>::const_iterator it = msgFDs.begin(), end = msgFDs.end(); it != end; ++it) {
         if (const gpg_error_t err = assuan_sendfd(ctx, *it)) {
             qDebug("%s", Exception(err, "assuan_sendfd( msgFD )").what());
             return 1;
         }
 
         if (const gpg_error_t err = assuan_transact(ctx, "MESSAGE FD", nullptr, nullptr, nullptr, nullptr, nullptr, nullptr)) {
             qDebug("%s", Exception(err, "MESSAGE FD").what());
             return 1;
         }
     }
 
     for (std::vector<int>::const_iterator it = outFDs.begin(), end = outFDs.end(); it != end; ++it) {
         if (const gpg_error_t err = assuan_sendfd(ctx, *it)) {
             qDebug("%s", Exception(err, "assuan_sendfd( outFD )").what());
             return 1;
         }
 
         if (const gpg_error_t err = assuan_transact(ctx, "OUTPUT FD", nullptr, nullptr, nullptr, nullptr, nullptr, nullptr)) {
             qDebug("%s", Exception(err, "OUTPUT FD").what());
             return 1;
         }
     }
 #endif
 
     for (std::vector<std::string>::const_iterator it = inFiles.begin(), end = inFiles.end(); it != end; ++it) {
         char buffer[1024];
         sprintf(buffer, "INPUT FILE=%s", hexencode(*it).c_str());
 
         if (const gpg_error_t err = assuan_transact(ctx, buffer, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr)) {
             qDebug("%s", Exception(err, buffer).what());
             return 1;
         }
     }
 
     for (std::vector<std::string>::const_iterator it = msgFiles.begin(), end = msgFiles.end(); it != end; ++it) {
         char buffer[1024];
         sprintf(buffer, "MESSAGE FILE=%s", hexencode(*it).c_str());
 
         if (const gpg_error_t err = assuan_transact(ctx, buffer, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr)) {
             qDebug("%s", Exception(err, buffer).what());
             return 1;
         }
     }
 
     for (std::vector<std::string>::const_iterator it = outFiles.begin(), end = outFiles.end(); it != end; ++it) {
         char buffer[1024];
         sprintf(buffer, "OUTPUT FILE=%s", hexencode(*it).c_str());
 
         if (const gpg_error_t err = assuan_transact(ctx, buffer, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr)) {
             qDebug("%s", Exception(err, buffer).what());
             return 1;
         }
     }
 
     for (const char *opt : std::as_const(options)) {
         std::string line = "OPTION ";
         line += opt;
         if (const gpg_error_t err = assuan_transact(ctx, line.c_str(), nullptr, nullptr, nullptr, nullptr, nullptr, nullptr)) {
             qDebug("%s", Exception(err, line).what());
             return 1;
         }
     }
 
     if (const gpg_error_t err = assuan_transact(ctx, command.c_str(), data, ctx, inquire, ctx, status, ctx)) {
         qDebug("%s", Exception(err, command).what());
         return 1;
     }
 
     assuan_release(ctx);
 
     return 0;
 }