[Pkg-gnupg-commit] [gpgme] 264/412: Qt: Add support for EncryptJobs with generic flags
Daniel Kahn Gillmor
dkg at fifthhorseman.net
Thu Sep 22 21:27:00 UTC 2016
This is an automated email from the git hooks/post-receive script.
dkg pushed a commit to branch master
in repository gpgme.
commit 34b456c3fb9e59788b07a75441da482bb28bda87
Author: Andre Heinecke <aheinecke at intevation.de>
Date: Tue Aug 9 13:10:08 2016 +0200
Qt: Add support for EncryptJobs with generic flags
* lang/qt/src/encryptjob.h, lang/qt/src/signencryptjob.h,
lang/qt/src/qgpgmeencryptjob.h, lang/qt/src/qgpgmeencryptjob.cpp,
lang/qt/src/qgpgmesignencryptjob.cpp,
lang/qt/src/qgpgmeencryptjob.cpp: Add start and exec overloads
that accept generic EncryptFlags.
--
While this technically is an ABI break (vtable change) there
are no known classes outside qgpgme that inherit encryptjob
or signencryptjob. And the new functions should be added
to the bottom of the vtable.
---
lang/qt/src/encryptjob.h | 19 ++++++++++++++++++-
lang/qt/src/qgpgmeencryptjob.cpp | 32 +++++++++++++++++++++-----------
lang/qt/src/qgpgmeencryptjob.h | 10 ++++++++++
lang/qt/src/qgpgmesignencryptjob.cpp | 32 ++++++++++++++++++++++----------
lang/qt/src/qgpgmesignencryptjob.h | 12 ++++++++++++
lang/qt/src/signencryptjob.h | 17 +++++++++++++++++
6 files changed, 100 insertions(+), 22 deletions(-)
diff --git a/lang/qt/src/encryptjob.h b/lang/qt/src/encryptjob.h
index 060ff8d..4ff9c82 100644
--- a/lang/qt/src/encryptjob.h
+++ b/lang/qt/src/encryptjob.h
@@ -39,6 +39,12 @@
#include <memory>
#include <vector>
+#ifdef BUILDING_QGPGME
+# include "context.h"
+#else
+# include <gpgme++/context.h>
+#endif
+
class QByteArray;
class QIODevice;
@@ -103,13 +109,24 @@ public:
virtual GpgME::EncryptionResult exec(const std::vector<GpgME::Key> &recipients,
const QByteArray &plainText,
bool alwaysTrust, QByteArray &cipherText) = 0;
-
/*!
This is a hack to request BASE64 output (instead of whatever
comes out normally).
*/
virtual void setOutputIsBase64Encoded(bool) = 0;
+ /** Like start but with an additional argument for EncryptionFlags for
+ * more flexibility. */
+ virtual void start(const std::vector<GpgME::Key> &recipients,
+ const std::shared_ptr<QIODevice> &plainText,
+ const std::shared_ptr<QIODevice> &cipherText = std::shared_ptr<QIODevice>(),
+ const GpgME::Context::EncryptionFlags flags = GpgME::Context::None) = 0;
+
+ /** Like exec but with an additional argument for EncryptionFlags for
+ * more flexibility. */
+ virtual GpgME::EncryptionResult exec(const std::vector<GpgME::Key> &recipients,
+ const QByteArray &plainText,
+ const GpgME::Context::EncryptionFlags flags, QByteArray &cipherText) = 0;
Q_SIGNALS:
void result(const GpgME::EncryptionResult &result, const QByteArray &cipherText, const QString &auditLogAsHtml = QString(), const GpgME::Error &auditLogError = GpgME::Error());
};
diff --git a/lang/qt/src/qgpgmeencryptjob.cpp b/lang/qt/src/qgpgmeencryptjob.cpp
index 8d0bfd4..82c8ed8 100644
--- a/lang/qt/src/qgpgmeencryptjob.cpp
+++ b/lang/qt/src/qgpgmeencryptjob.cpp
@@ -65,7 +65,7 @@ static QGpgMEEncryptJob::result_type encrypt(Context *ctx, QThread *thread,
const std::vector<Key> &recipients,
const std::weak_ptr<QIODevice> &plainText_,
const std::weak_ptr<QIODevice> &cipherText_,
- bool alwaysTrust,
+ const Context::EncryptionFlags eflags,
bool outputIsBsse64Encoded)
{
@@ -78,9 +78,6 @@ static QGpgMEEncryptJob::result_type encrypt(Context *ctx, QThread *thread,
QGpgME::QIODeviceDataProvider in(plainText);
const Data indata(&in);
- const Context::EncryptionFlags eflags =
- alwaysTrust ? Context::AlwaysTrust : Context::None;
-
if (!cipherText) {
QGpgME::QByteArrayDataProvider out;
Data outdata(&out);
@@ -109,41 +106,54 @@ static QGpgMEEncryptJob::result_type encrypt(Context *ctx, QThread *thread,
}
-static QGpgMEEncryptJob::result_type encrypt_qba(Context *ctx, const std::vector<Key> &recipients, const QByteArray &plainText, bool alwaysTrust, bool outputIsBsse64Encoded)
+static QGpgMEEncryptJob::result_type encrypt_qba(Context *ctx, const std::vector<Key> &recipients, const QByteArray &plainText, const Context::EncryptionFlags eflags, bool outputIsBsse64Encoded)
{
const std::shared_ptr<QBuffer> buffer(new QBuffer);
buffer->setData(plainText);
if (!buffer->open(QIODevice::ReadOnly)) {
assert(!"This should never happen: QBuffer::open() failed");
}
- return encrypt(ctx, 0, recipients, buffer, std::shared_ptr<QIODevice>(), alwaysTrust, outputIsBsse64Encoded);
+ return encrypt(ctx, 0, recipients, buffer, std::shared_ptr<QIODevice>(), eflags, outputIsBsse64Encoded);
}
Error QGpgMEEncryptJob::start(const std::vector<Key> &recipients, const QByteArray &plainText, bool alwaysTrust)
{
- run(std::bind(&encrypt_qba, std::placeholders::_1, recipients, plainText, alwaysTrust, mOutputIsBase64Encoded));
+ run(std::bind(&encrypt_qba, std::placeholders::_1, recipients, plainText,
+ alwaysTrust ? Context::AlwaysTrust : Context::None, mOutputIsBase64Encoded));
return Error();
}
-void QGpgMEEncryptJob::start(const std::vector<Key> &recipients, const std::shared_ptr<QIODevice> &plainText, const std::shared_ptr<QIODevice> &cipherText, bool alwaysTrust)
+void QGpgMEEncryptJob::start(const std::vector<Key> &recipients, const std::shared_ptr<QIODevice> &plainText,
+ const std::shared_ptr<QIODevice> &cipherText, const Context::EncryptionFlags eflags)
{
run(std::bind(&encrypt,
std::placeholders::_1, std::placeholders::_2,
recipients,
std::placeholders::_3, std::placeholders::_4,
- alwaysTrust,
+ eflags,
mOutputIsBase64Encoded),
plainText, cipherText);
}
-EncryptionResult QGpgMEEncryptJob::exec(const std::vector<Key> &recipients, const QByteArray &plainText, bool alwaysTrust, QByteArray &cipherText)
+EncryptionResult QGpgMEEncryptJob::exec(const std::vector<Key> &recipients, const QByteArray &plainText,
+ const Context::EncryptionFlags eflags, QByteArray &cipherText)
{
- const result_type r = encrypt_qba(context(), recipients, plainText, alwaysTrust, mOutputIsBase64Encoded);
+ const result_type r = encrypt_qba(context(), recipients, plainText, eflags, mOutputIsBase64Encoded);
cipherText = std::get<1>(r);
resultHook(r);
return mResult;
}
+void QGpgMEEncryptJob::start(const std::vector<Key> &recipients, const std::shared_ptr<QIODevice> &plainText, const std::shared_ptr<QIODevice> &cipherText, bool alwaysTrust)
+{
+ return start(recipients, plainText, cipherText, alwaysTrust ? Context::AlwaysTrust : Context::None);
+}
+
+EncryptionResult QGpgMEEncryptJob::exec(const std::vector<Key> &recipients, const QByteArray &plainText, bool alwaysTrust, QByteArray &cipherText)
+{
+ return exec(recipients, plainText, alwaysTrust ? Context::AlwaysTrust : Context::None, cipherText);
+}
+
void QGpgMEEncryptJob::resultHook(const result_type &tuple)
{
mResult = std::get<0>(tuple);
diff --git a/lang/qt/src/qgpgmeencryptjob.h b/lang/qt/src/qgpgmeencryptjob.h
index d35a41b..42c1c78 100644
--- a/lang/qt/src/qgpgmeencryptjob.h
+++ b/lang/qt/src/qgpgmeencryptjob.h
@@ -82,6 +82,16 @@ public:
GpgME::EncryptionResult exec(const std::vector<GpgME::Key> &recipients,
const QByteArray &plainText, bool alwaysTrust,
QByteArray &cipherText) Q_DECL_OVERRIDE;
+ /* from EncryptJob */
+ void start(const std::vector<GpgME::Key> &recipients,
+ const std::shared_ptr<QIODevice> &plainText,
+ const std::shared_ptr<QIODevice> &cipherText,
+ const GpgME::Context::EncryptionFlags flags) Q_DECL_OVERRIDE;
+
+ /* from EncryptJob */
+ GpgME::EncryptionResult exec(const std::vector<GpgME::Key> &recipients,
+ const QByteArray &plainText, const GpgME::Context::EncryptionFlags flags,
+ QByteArray &cipherText) Q_DECL_OVERRIDE;
/* from EncryptJob */
void setOutputIsBase64Encoded(bool on) Q_DECL_OVERRIDE;
diff --git a/lang/qt/src/qgpgmesignencryptjob.cpp b/lang/qt/src/qgpgmesignencryptjob.cpp
index d19ab0f..d2e45b1 100644
--- a/lang/qt/src/qgpgmesignencryptjob.cpp
+++ b/lang/qt/src/qgpgmesignencryptjob.cpp
@@ -62,7 +62,9 @@ void QGpgMESignEncryptJob::setOutputIsBase64Encoded(bool on)
mOutputIsBase64Encoded = on;
}
-static QGpgMESignEncryptJob::result_type sign_encrypt(Context *ctx, QThread *thread, const std::vector<Key> &signers, const std::vector<Key> &recipients, const std::weak_ptr<QIODevice> &plainText_, const std::weak_ptr<QIODevice> &cipherText_, bool alwaysTrust, bool outputIsBsse64Encoded)
+static QGpgMESignEncryptJob::result_type sign_encrypt(Context *ctx, QThread *thread, const std::vector<Key> &signers,
+ const std::vector<Key> &recipients, const std::weak_ptr<QIODevice> &plainText_,
+ const std::weak_ptr<QIODevice> &cipherText_, const Context::EncryptionFlags eflags, bool outputIsBsse64Encoded)
{
const std::shared_ptr<QIODevice> &plainText = plainText_.lock();
const std::shared_ptr<QIODevice> &cipherText = cipherText_.lock();
@@ -73,9 +75,6 @@ static QGpgMESignEncryptJob::result_type sign_encrypt(Context *ctx, QThread *thr
QGpgME::QIODeviceDataProvider in(plainText);
const Data indata(&in);
- const Context::EncryptionFlags eflags =
- alwaysTrust ? Context::AlwaysTrust : Context::None;
-
ctx->clearSigningKeys();
Q_FOREACH (const Key &signer, signers)
if (!signer.isNull())
@@ -111,35 +110,48 @@ static QGpgMESignEncryptJob::result_type sign_encrypt(Context *ctx, QThread *thr
}
-static QGpgMESignEncryptJob::result_type sign_encrypt_qba(Context *ctx, const std::vector<Key> &signers, const std::vector<Key> &recipients, const QByteArray &plainText, bool alwaysTrust, bool outputIsBsse64Encoded)
+static QGpgMESignEncryptJob::result_type sign_encrypt_qba(Context *ctx, const std::vector<Key> &signers,
+ const std::vector<Key> &recipients, const QByteArray &plainText, const Context::EncryptionFlags eflags, bool outputIsBsse64Encoded)
{
const std::shared_ptr<QBuffer> buffer(new QBuffer);
buffer->setData(plainText);
if (!buffer->open(QIODevice::ReadOnly)) {
assert(!"This should never happen: QBuffer::open() failed");
}
- return sign_encrypt(ctx, 0, signers, recipients, buffer, std::shared_ptr<QIODevice>(), alwaysTrust, outputIsBsse64Encoded);
+ return sign_encrypt(ctx, 0, signers, recipients, buffer, std::shared_ptr<QIODevice>(), eflags, outputIsBsse64Encoded);
}
Error QGpgMESignEncryptJob::start(const std::vector<Key> &signers, const std::vector<Key> &recipients, const QByteArray &plainText, bool alwaysTrust)
{
- run(std::bind(&sign_encrypt_qba, std::placeholders::_1, signers, recipients, plainText, alwaysTrust, mOutputIsBase64Encoded));
+ run(std::bind(&sign_encrypt_qba, std::placeholders::_1, signers, recipients, plainText, alwaysTrust ? Context::AlwaysTrust : Context::None, mOutputIsBase64Encoded));
return Error();
}
+void QGpgMESignEncryptJob::start(const std::vector<Key> &signers, const std::vector<Key> &recipients,
+ const std::shared_ptr<QIODevice> &plainText, const std::shared_ptr<QIODevice> &cipherText, const Context::EncryptionFlags eflags)
+{
+ run(std::bind(&sign_encrypt, std::placeholders::_1, std::placeholders::_2, signers, recipients, std::placeholders::_3, std::placeholders::_4, eflags, mOutputIsBase64Encoded), plainText, cipherText);
+}
+
void QGpgMESignEncryptJob::start(const std::vector<Key> &signers, const std::vector<Key> &recipients, const std::shared_ptr<QIODevice> &plainText, const std::shared_ptr<QIODevice> &cipherText, bool alwaysTrust)
{
- run(std::bind(&sign_encrypt, std::placeholders::_1, std::placeholders::_2, signers, recipients, std::placeholders::_3, std::placeholders::_4, alwaysTrust, mOutputIsBase64Encoded), plainText, cipherText);
+ return start(signers, recipients, plainText, cipherText, alwaysTrust ? Context::AlwaysTrust : Context::None);
}
-std::pair<SigningResult, EncryptionResult> QGpgMESignEncryptJob::exec(const std::vector<Key> &signers, const std::vector<Key> &recipients, const QByteArray &plainText, bool alwaysTrust, QByteArray &cipherText)
+std::pair<SigningResult, EncryptionResult> QGpgMESignEncryptJob::exec(const std::vector<Key> &signers, const std::vector<Key> &recipients, const QByteArray &plainText, const Context::EncryptionFlags eflags, QByteArray &cipherText)
{
- const result_type r = sign_encrypt_qba(context(), signers, recipients, plainText, alwaysTrust, mOutputIsBase64Encoded);
+ const result_type r = sign_encrypt_qba(context(), signers, recipients, plainText, eflags, mOutputIsBase64Encoded);
cipherText = std::get<2>(r);
resultHook(r);
return mResult;
}
+std::pair<SigningResult, EncryptionResult> QGpgMESignEncryptJob::exec(const std::vector<Key> &signers, const std::vector<Key> &recipients, const QByteArray &plainText, bool alwaysTrust, QByteArray &cipherText)
+{
+ return exec(signers, recipients, plainText, alwaysTrust ? Context::AlwaysTrust : Context::None, cipherText);
+}
+
+
#if 0
TODO port?
diff --git a/lang/qt/src/qgpgmesignencryptjob.h b/lang/qt/src/qgpgmesignencryptjob.h
index 49177d3..e76c245 100644
--- a/lang/qt/src/qgpgmesignencryptjob.h
+++ b/lang/qt/src/qgpgmesignencryptjob.h
@@ -87,12 +87,24 @@ public:
const std::shared_ptr<QIODevice> &cipherText,
bool alwaysTrust) Q_DECL_OVERRIDE;
+ void start(const std::vector<GpgME::Key> &signers,
+ const std::vector<GpgME::Key> &recipients,
+ const std::shared_ptr<QIODevice> &plainText,
+ const std::shared_ptr<QIODevice> &cipherText,
+ const GpgME::Context::EncryptionFlags flags) Q_DECL_OVERRIDE;
+
std::pair<GpgME::SigningResult, GpgME::EncryptionResult>
exec(const std::vector<GpgME::Key> &signers,
const std::vector<GpgME::Key> &recipients,
const QByteArray &plainText, bool alwaysTrust,
QByteArray &cipherText) Q_DECL_OVERRIDE;
+ std::pair<GpgME::SigningResult, GpgME::EncryptionResult>
+ exec(const std::vector<GpgME::Key> &signers,
+ const std::vector<GpgME::Key> &recipients,
+ const QByteArray &plainText, const GpgME::Context::EncryptionFlags flags,
+ QByteArray &cipherText) Q_DECL_OVERRIDE;
+
/* from SignEncryptJob */
void setOutputIsBase64Encoded(bool on) Q_DECL_OVERRIDE;
diff --git a/lang/qt/src/signencryptjob.h b/lang/qt/src/signencryptjob.h
index 4818d2a..b0aafe3 100644
--- a/lang/qt/src/signencryptjob.h
+++ b/lang/qt/src/signencryptjob.h
@@ -38,8 +38,10 @@
#ifdef BUILDING_QGPGME
# include "global.h"
+# include "context.h"
#else
# include <gpgme++/global.h>
+# include <gpgme++/context.h>
#endif
#include <memory>
@@ -123,6 +125,21 @@ public:
*/
virtual void setOutputIsBase64Encoded(bool) = 0;
+ /** Like start but with an additional argument for EncryptionFlags for
+ * more flexibility. */
+ virtual void start(const std::vector<GpgME::Key> &signers,
+ const std::vector<GpgME::Key> &recipients,
+ const std::shared_ptr<QIODevice> &plainText,
+ const std::shared_ptr<QIODevice> &cipherText = std::shared_ptr<QIODevice>(),
+ const GpgME::Context::EncryptionFlags flags = GpgME::Context::None) = 0;
+
+ /** Like exec but with an additional argument for EncryptionFlags for
+ * more flexibility. */
+ virtual std::pair<GpgME::SigningResult, GpgME::EncryptionResult>
+ exec(const std::vector<GpgME::Key> &signers,
+ const std::vector<GpgME::Key> &recipients,
+ const QByteArray &plainText,
+ const GpgME::Context::EncryptionFlags flags, QByteArray &cipherText) = 0;
Q_SIGNALS:
void result(const GpgME::SigningResult &signingresult,
const GpgME::EncryptionResult &encryptionresult,
--
Alioth's /usr/local/bin/git-commit-notice on /srv/git.debian.org/git/pkg-gnupg/gpgme.git
More information about the Pkg-gnupg-commit
mailing list