Page MenuHome GnuPG
Files F20320807

No OneTemporary
Actions

View Options

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;
}

File Metadata

Mime Type
text/x-diff
Expires
Fri, Mar 14, 4:37 AM (1 d, 11 h)
Storage Engine
local-disk
Storage Format
Raw Data
Storage Handle
70/d2/1170b2232def69538b65342cd65b

Event Timeline