No OneTemporary
Actions

Size

70 KB

Subscribers

None

View Options

	diff --git a/lang/cpp/src/Makefile.am b/lang/cpp/src/Makefile.am
	index 188585a7..e65a8752 100644
	--- a/lang/cpp/src/Makefile.am
	+++ b/lang/cpp/src/Makefile.am
	@@ -1,99 +1,99 @@
	# Makefile.am for GPGMEPP.
	# Copyright (C) 2016 Intevation GmbH
	#
	# This file is part of GPGMEPP.
	#
	# GPGME-CL is free software; you can redistribute it and/or modify it
	# under the terms of the GNU General Public License as published by
	# the Free Software Foundation; either version 2 of the License, or
	# (at your option) any later version.
	#
	# GPGME-CL is distributed in the hope that it will be useful,
	# but WITHOUT ANY WARRANTY; without even the implied warranty of
	# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	# GNU Lesser General Public License for more details.
	#
	# You should have received a copy of the GNU General Public License
	# along with this program; if not, write to the Free Software
	# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
	# 02111-1307, USA

	EXTRA_DIST = GpgmeppConfig.cmake.in.in GpgmeppConfigVersion.cmake.in \
	gpgmepp_version.h.in

	lib_LTLIBRARIES = libgpgmepp.la

	main_sources = \
	exception.cpp context.cpp key.cpp trustitem.cpp data.cpp callbacks.cpp \
	- eventloopinteractor.cpp editinteractor.cpp assuanresult.cpp \
	+ eventloopinteractor.cpp editinteractor.cpp \
	keylistresult.cpp keygenerationresult.cpp importresult.cpp \
	decryptionresult.cpp verificationresult.cpp \
	signingresult.cpp encryptionresult.cpp \
	engineinfo.cpp gpgsetexpirytimeeditinteractor.cpp \
	gpgsetownertrusteditinteractor.cpp gpgsignkeyeditinteractor.cpp \
	gpgadduserideditinteractor.cpp defaultassuantransaction.cpp \
	scdgetinfoassuantransaction.cpp gpgagentgetinfoassuantransaction.cpp \
	vfsmountresult.cpp configuration.cpp tofuinfo.cpp

	gpgmepp_headers = \
	- assuanresult.h configuration.h context.h data.h decryptionresult.h \
	+ configuration.h context.h data.h decryptionresult.h \
	defaultassuantransaction.h editinteractor.h encryptionresult.h \
	engineinfo.h error.h eventloopinteractor.h exception.h global.h \
	gpgadduserideditinteractor.h gpgagentgetinfoassuantransaction.h \
	gpgmefw.h gpgsetexpirytimeeditinteractor.h \
	gpgsetownertrusteditinteractor.h gpgsignkeyeditinteractor.h \
	importresult.h keygenerationresult.h key.h keylistresult.h \
	notation.h result.h scdgetinfoassuantransaction.h signingresult.h \
	trustitem.h verificationresult.h vfsmountresult.h gpgmepp_export.h \
	tofuinfo.h

	private_gpgmepp_headers = \
	result_p.h context_p.h util.h callbacks.h data_p.h

	interface_headers= \
	interfaces/assuantransaction.h interfaces/dataprovider.h \
	interfaces/passphraseprovider.h interfaces/progressprovider.h

	gpgmeppincludedir = $(includedir)/gpgme++
	gpgmeppinclude_HEADERS = $(gpgmepp_headers)
	nobase_gpgmeppinclude_HEADERS = $(interface_headers)
	nodist_include_HEADERS = gpgmepp_version.h

	libgpgmepp_la_SOURCES = $(main_sources) $(gpgmepp_headers) context_vanilla.cpp \
	$(interface_headers) $(private_gpgmepp_headers)

	AM_CPPFLAGS = -I$(top_builddir)/src @GPG_ERROR_CFLAGS@ @LIBASSUAN_CFLAGS@ \
	-DBUILDING_GPGMEPP

	libgpgmepp_la_LIBADD = ../../../src/libgpgme.la @LIBASSUAN_LIBS@
	libgpgmepp_la_LDFLAGS = -version-info \
	@LIBGPGMEPP_LT_CURRENT@:@LIBGPGMEPP_LT_REVISION@:@LIBGPGMEPP_LT_AGE@

	if HAVE_W32_SYSTEM
	libsuffix=.dll.a
	else
	libsuffix=.so
	endif

	GpgmeppConfig.cmake: GpgmeppConfig.cmake.in
	sed -e 's\|[@]resolved_libdir@\|$(libdir)\|g' < "$<" > "$@"
	sed -e 's\|[@]libsuffix@\|$(libsuffix)\|g' < "$@" > "$@".2
	mv "$@".2 "$@"

	install-cmake-files: GpgmeppConfig.cmake GpgmeppConfigVersion.cmake
	-$(INSTALL) -d $(DESTDIR)$(libdir)/cmake/Gpgmepp
	$(INSTALL) GpgmeppConfig.cmake \
	$(DESTDIR)$(libdir)/cmake/Gpgmepp/GpgmeppConfig.cmake
	$(INSTALL) GpgmeppConfigVersion.cmake \
	$(DESTDIR)$(libdir)/cmake/Gpgmepp/GpgmeppConfigVersion.cmake

	uninstall-cmake-files:
	-rm $(DESTDIR)$(libdir)/cmake/Gpgmepp/GpgmeppConfigVersion.cmake
	-rm $(DESTDIR)$(libdir)/cmake/Gpgmepp/GpgmeppConfig.cmake
	-rmdir $(DESTDIR)$(libdir)/cmake/Gpgmepp/

	install-data-local: install-cmake-files

	uninstall-local: uninstall-cmake-files

	CLEANFILES = GpgmeppConfig.cmake
	diff --git a/lang/cpp/src/assuanresult.cpp b/lang/cpp/src/assuanresult.cpp
	deleted file mode 100644
	index 3d6d0a3a..00000000
	--- a/lang/cpp/src/assuanresult.cpp
	+++ /dev/null
	@@ -1,90 +0,0 @@
	-/*
	- assuanresult.cpp - wraps a gpgme assuan result
	- Copyright (C) 2009 Klarälvdalens Datakonsult AB
	-
	- This file is part of GPGME++.
	-
	- GPGME++ is free software; you can redistribute it and/or
	- modify it under the terms of the GNU Library General Public
	- License as published by the Free Software Foundation; either
	- version 2 of the License, or (at your option) any later version.
	-
	- GPGME++ is distributed in the hope that it will be useful,
	- but WITHOUT ANY WARRANTY; without even the implied warranty of
	- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	- GNU Library General Public License for more details.
	-
	- You should have received a copy of the GNU Library General Public License
	- along with GPGME++; see the file COPYING.LIB. If not, write to the
	- Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
	- Boston, MA 02110-1301, USA.
	-*/
	-
	-#include <assuanresult.h>
	-#include "result_p.h"
	-
	-#include <gpgme.h>
	-
	-#include <istream>
	-
	-using namespace GpgME;
	-
	-class AssuanResult::Private
	-{
	-public:
	- explicit Private(const gpgme_assuan_result_t r)
	- {
	- if (!r) {
	- return;
	- }
	- error = r->err;
	- }
	-
	- gpgme_error_t error;
	-};
	-
	-AssuanResult::AssuanResult(gpgme_ctx_t ctx, int error)
	- : Result(error), d()
	-{
	- init(ctx);
	-}
	-
	-AssuanResult::AssuanResult(gpgme_ctx_t ctx, const Error &error)
	- : Result(error), d()
	-{
	- init(ctx);
	-}
	-
	-void AssuanResult::init(gpgme_ctx_t ctx)
	-{
	- (void)ctx;
	- if (!ctx) {
	- return;
	- }
	- gpgme_assuan_result_t res = gpgme_op_assuan_result(ctx);
	- if (!res) {
	- return;
	- }
	- d.reset(new Private(res));
	-}
	-
	-make_standard_stuff(AssuanResult)
	-
	-Error AssuanResult::assuanError() const
	-{
	- if (d) {
	- return Error(d->error);
	- }
	- return Error();
	-}
	-
	-std::ostream &GpgME::operator<<(std::ostream &os, const AssuanResult &result)
	-{
	- os << "GpgME::AssuanResult(";
	- if (!result.isNull()) {
	- os << "\n error: " << result.error()
	- << "\n assuanError: " << result.assuanError()
	- << "\n";
	- }
	- return os << ')';
	-}
	diff --git a/lang/cpp/src/assuanresult.h b/lang/cpp/src/assuanresult.h
	deleted file mode 100644
	index e59b5ac2..00000000
	--- a/lang/cpp/src/assuanresult.h
	+++ /dev/null
	@@ -1,79 +0,0 @@
	-/*
	- assuanresult.h - wraps a gpgme assuan result
	- Copyright (C) 2009 Klarälvdalens Datakonsult AB <info@kdab.com>
	- Author: Marc Mutz <marc@kdab.com>
	-
	- This file is part of GPGME++.
	-
	- GPGME++ is free software; you can redistribute it and/or
	- modify it under the terms of the GNU Library General Public
	- License as published by the Free Software Foundation; either
	- version 2 of the License, or (at your option) any later version.
	-
	- GPGME++ is distributed in the hope that it will be useful,
	- but WITHOUT ANY WARRANTY; without even the implied warranty of
	- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	- GNU Library General Public License for more details.
	-
	- You should have received a copy of the GNU Library General Public License
	- along with GPGME++; see the file COPYING.LIB. If not, write to the
	- Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
	- Boston, MA 02110-1301, USA.
	-*/
	-
	-#ifndef __GPGMEPP_ASSUANRESULT_H__
	-#define __GPGMEPP_ASSUANRESULT_H__
	-
	-#include "gpgmefw.h"
	-#include "result.h"
	-#include "gpgmepp_export.h"
	-
	-#include <time.h>
	-
	-#include <vector>
	-#include <iosfwd>
	-#include <memory>
	-
	-namespace GpgME
	-{
	-
	-class Error;
	-
	-class GPGMEPP_EXPORT AssuanResult : public Result
	-{
	-public:
	- AssuanResult();
	- AssuanResult(gpgme_ctx_t ctx, int error);
	- AssuanResult(gpgme_ctx_t ctx, const Error &error);
	- explicit AssuanResult(const Error &err);
	-
	- const AssuanResult &operator=(AssuanResult other)
	- {
	- swap(other);
	- return *this;
	- }
	-
	- void swap(AssuanResult &other)
	- {
	- Result::swap(other);
	- using std::swap;
	- swap(this->d, other.d);
	- }
	-
	- bool isNull() const;
	-
	- Error assuanError() const;
	-
	- class Private;
	-private:
	- void init(gpgme_ctx_t ctx);
	- std::shared_ptr<Private> d;
	-};
	-
	-GPGMEPP_EXPORT std::ostream &operator<<(std::ostream &os, const AssuanResult &result);
	-
	-}
	-
	-GPGMEPP_MAKE_STD_SWAP_SPECIALIZATION(AssuanResult)
	-
	-#endif // __GPGMEPP_ASSUANRESULT_H__
	diff --git a/lang/cpp/src/context.cpp b/lang/cpp/src/context.cpp
	index 11080cfa..4e66d3b9 100644
	--- a/lang/cpp/src/context.cpp
	+++ b/lang/cpp/src/context.cpp
	@@ -1,1548 +1,1556 @@
	/*
	context.cpp - wraps a gpgme key context
	Copyright (C) 2003, 2007 Klarälvdalens Datakonsult AB

	This file is part of GPGME++.

	GPGME++ is free software; you can redistribute it and/or
	modify it under the terms of the GNU Library General Public
	License as published by the Free Software Foundation; either
	version 2 of the License, or (at your option) any later version.

	GPGME++ is distributed in the hope that it will be useful,
	but WITHOUT ANY WARRANTY; without even the implied warranty of
	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	GNU Library General Public License for more details.

	You should have received a copy of the GNU Library General Public License
	along with GPGME++; see the file COPYING.LIB. If not, write to the
	Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
	Boston, MA 02110-1301, USA.
	*/

	#include <context.h>
	#include <eventloopinteractor.h>
	#include <trustitem.h>
	-#include <assuanresult.h>
	#include <keylistresult.h>
	#include <keygenerationresult.h>
	#include <importresult.h>
	#include <decryptionresult.h>
	#include <verificationresult.h>
	#include <signingresult.h>
	#include <encryptionresult.h>
	#include <engineinfo.h>
	#include <editinteractor.h>
	#include <vfsmountresult.h>

	#include <interfaces/assuantransaction.h>
	#include <defaultassuantransaction.h>

	#include "callbacks.h"
	#include "data_p.h"
	#include "context_p.h"
	#include "util.h"

	#include <gpgme.h>

	#include <istream>
	#ifndef NDEBUG
	#include <iostream>
	using std::cerr;
	using std::endl;
	#endif

	#include <cassert>

	namespace GpgME
	{

	static inline unsigned int xtoi_1(const char *str)
	{
	const unsigned int ch = *str;
	const unsigned int result =
	ch <= '9' ? ch - '0' :
	ch <= 'F' ? ch - 'A' + 10 :
	/* else */ ch - 'a' + 10 ;
	return result < 16 ? result : 0 ;
	}
	static inline int xtoi_2(const char *str)
	{
	return xtoi_1(str) * 16U + xtoi_1(str + 1);
	}

	static void percent_unescape(std::string &s, bool plus2space)
	{
	std::string::iterator src = s.begin(), dest = s.begin(), end = s.end();
	while (src != end) {
	if (*src == '%' && end - src > 2) {
	dest++ = xtoi_2(&++src);
	src += 2;
	} else if (*src == '+' && plus2space) {
	*dest++ = ' ';
	++src;
	} else {
	dest++ = src++;
	}
	}
	s.erase(dest, end);
	}

	void initializeLibrary()
	{
	gpgme_check_version(0);
	}

	Error initializeLibrary(int)
	{
	if (gpgme_check_version(GPGME_VERSION)) {
	return Error();
	} else {
	return Error::fromCode(GPG_ERR_USER_1);
	}
	}

	static void format_error(gpgme_error_t err, std::string &str)
	{
	char buffer[ 1024 ];
	gpgme_strerror_r(err, buffer, sizeof buffer);
	buffer[ sizeof buffer - 1 ] = '\0';
	str = buffer;
	}

	const char *Error::source() const
	{
	return gpgme_strsource((gpgme_error_t)mErr);
	}

	const char *Error::asString() const
	{
	if (mMessage.empty()) {
	format_error(static_cast<gpgme_error_t>(mErr), mMessage);
	}
	return mMessage.c_str();
	}

	int Error::code() const
	{
	return gpgme_err_code(mErr);
	}

	int Error::sourceID() const
	{
	return gpgme_err_source(mErr);
	}

	bool Error::isCanceled() const
	{
	return code() == GPG_ERR_CANCELED;
	}

	int Error::toErrno() const
	{
	//#ifdef HAVE_GPGME_GPG_ERROR_WRAPPERS
	return gpgme_err_code_to_errno(static_cast<gpgme_err_code_t>(code()));
	//#else
	// return gpg_err_code_to_errno( static_cast<gpg_err_code_t>( code() ) );
	//#endif
	}

	// static
	bool Error::hasSystemError()
	{
	return gpgme_err_code_from_syserror() == GPG_ERR_MISSING_ERRNO ;
	}

	// static
	void Error::setSystemError(gpg_err_code_t err)
	{
	setErrno(gpgme_err_code_to_errno(err));
	}

	// static
	void Error::setErrno(int err)
	{
	gpgme_err_set_errno(err);
	}

	// static
	Error Error::fromSystemError(unsigned int src)
	{
	return Error(gpgme_err_make(static_cast<gpgme_err_source_t>(src), gpgme_err_code_from_syserror()));
	}

	// static
	Error Error::fromErrno(int err, unsigned int src)
	{
	return Error(gpgme_err_make(static_cast<gpgme_err_source_t>(src), gpgme_err_code_from_errno(err)));
	}

	// static
	Error Error::fromCode(unsigned int err, unsigned int src)
	{
	return Error(gpgme_err_make(static_cast<gpgme_err_source_t>(src), static_cast<gpgme_err_code_t>(err)));
	}

	std::ostream &operator<<(std::ostream &os, const Error &err)
	{
	return os << "GpgME::Error(" << err.encodedError() << " (" << err.asString() << "))";
	}

	Context::Context(gpgme_ctx_t ctx) : d(new Private(ctx))
	{
	}

	Context::~Context()
	{
	delete d;
	}

	Context *Context::createForProtocol(Protocol proto)
	{
	gpgme_ctx_t ctx = 0;
	if (gpgme_new(&ctx) != 0) {
	return 0;
	}

	switch (proto) {
	case OpenPGP:
	if (gpgme_set_protocol(ctx, GPGME_PROTOCOL_OpenPGP) != 0) {
	gpgme_release(ctx);
	return 0;
	}
	break;
	case CMS:
	if (gpgme_set_protocol(ctx, GPGME_PROTOCOL_CMS) != 0) {
	gpgme_release(ctx);
	return 0;
	}
	break;
	default:
	return 0;
	}

	return new Context(ctx);
	}

	std::unique_ptr<Context> Context::createForEngine(Engine eng, Error *error)
	{
	gpgme_ctx_t ctx = 0;
	if (const gpgme_error_t err = gpgme_new(&ctx)) {
	if (error) {
	*error = Error(err);
	}
	return std::unique_ptr<Context>();
	}

	switch (eng) {
	case AssuanEngine:
	if (const gpgme_error_t err = gpgme_set_protocol(ctx, GPGME_PROTOCOL_ASSUAN)) {
	gpgme_release(ctx);
	if (error) {
	*error = Error(err);
	}
	return std::unique_ptr<Context>();
	}
	break;
	case G13Engine:
	if (const gpgme_error_t err = gpgme_set_protocol(ctx, GPGME_PROTOCOL_G13)) {
	gpgme_release(ctx);
	if (error) {
	*error = Error(err);
	}
	return std::unique_ptr<Context>();
	}
	break;
	default:
	if (error) {
	*error = Error::fromCode(GPG_ERR_INV_ARG);
	}
	return std::unique_ptr<Context>();
	}

	if (error) {
	*error = Error();
	}

	return std::unique_ptr<Context>(new Context(ctx));
	}

	//
	//
	// Context::Private
	//
	//

	Context::Private::Private(gpgme_ctx_t c)
	: ctx(c),
	iocbs(0),
	lastop(None),
	lasterr(GPG_ERR_NO_ERROR),
	lastAssuanInquireData(Data::null),
	lastAssuanTransaction(),
	lastEditInteractor(),
	lastCardEditInteractor()
	{

	}

	Context::Private::~Private()
	{
	if (ctx) {
	gpgme_release(ctx);
	}
	ctx = 0;
	delete iocbs;
	}

	//
	//
	// Context attributes:
	//
	//

	Protocol Context::protocol() const
	{
	gpgme_protocol_t p = gpgme_get_protocol(d->ctx);
	switch (p) {
	case GPGME_PROTOCOL_OpenPGP: return OpenPGP;
	case GPGME_PROTOCOL_CMS: return CMS;
	default: return UnknownProtocol;
	}
	}

	void Context::setArmor(bool useArmor)
	{
	gpgme_set_armor(d->ctx, int(useArmor));
	}
	bool Context::armor() const
	{
	return gpgme_get_armor(d->ctx);
	}

	void Context::setTextMode(bool useTextMode)
	{
	gpgme_set_textmode(d->ctx, int(useTextMode));
	}
	bool Context::textMode() const
	{
	return gpgme_get_textmode(d->ctx);
	}

	void Context::setOffline(bool useOfflineMode)
	{
	gpgme_set_offline(d->ctx, int(useOfflineMode));
	}
	bool Context::offline() const
	{
	return gpgme_get_offline(d->ctx);
	}

	void Context::setIncludeCertificates(int which)
	{
	if (which == DefaultCertificates) {
	which = GPGME_INCLUDE_CERTS_DEFAULT;
	}
	gpgme_set_include_certs(d->ctx, which);
	}

	int Context::includeCertificates() const
	{
	return gpgme_get_include_certs(d->ctx);
	}

	void Context::setKeyListMode(unsigned int mode)
	{
	gpgme_set_keylist_mode(d->ctx, add_to_gpgme_keylist_mode_t(0, mode));
	}

	void Context::addKeyListMode(unsigned int mode)
	{
	const unsigned int cur = gpgme_get_keylist_mode(d->ctx);
	gpgme_set_keylist_mode(d->ctx, add_to_gpgme_keylist_mode_t(cur, mode));
	}

	unsigned int Context::keyListMode() const
	{
	return convert_from_gpgme_keylist_mode_t(gpgme_get_keylist_mode(d->ctx));
	}

	void Context::setProgressProvider(ProgressProvider *provider)
	{
	gpgme_set_progress_cb(d->ctx, provider ? &progress_callback : 0, provider);
	}
	ProgressProvider *Context::progressProvider() const
	{
	void *pp = 0;
	gpgme_progress_cb_t pcb = &progress_callback;
	gpgme_get_progress_cb(d->ctx, &pcb, &pp);
	return static_cast<ProgressProvider *>(pp);
	}

	void Context::setPassphraseProvider(PassphraseProvider *provider)
	{
	gpgme_set_passphrase_cb(d->ctx, provider ? &passphrase_callback : 0, provider);
	}

	PassphraseProvider *Context::passphraseProvider() const
	{
	void *pp = 0;
	gpgme_passphrase_cb_t pcb = &passphrase_callback;
	gpgme_get_passphrase_cb(d->ctx, &pcb, &pp);
	return static_cast<PassphraseProvider *>(pp);
	}

	void Context::setManagedByEventLoopInteractor(bool manage)
	{
	if (!EventLoopInteractor::instance()) {
	#ifndef NDEBUG
	cerr << "Context::setManagedByEventLoopInteractor(): "
	"You must create an instance of EventLoopInteractor "
	"before using anything that needs one." << endl;
	#endif
	return;
	}
	if (manage) {
	EventLoopInteractor::instance()->manage(this);
	} else {
	EventLoopInteractor::instance()->unmanage(this);
	}
	}
	bool Context::managedByEventLoopInteractor() const
	{
	return d->iocbs != 0;
	}

	void Context::installIOCallbacks(gpgme_io_cbs *iocbs)
	{
	if (!iocbs) {
	uninstallIOCallbacks();
	return;
	}
	gpgme_set_io_cbs(d->ctx, iocbs);
	delete d->iocbs; d->iocbs = iocbs;
	}

	void Context::uninstallIOCallbacks()
	{
	static gpgme_io_cbs noiocbs = { 0, 0, 0, 0, 0 };
	// io.add == 0 means disable io callbacks:
	gpgme_set_io_cbs(d->ctx, &noiocbs);
	delete d->iocbs; d->iocbs = 0;
	}

	Error Context::setLocale(int cat, const char *val)
	{
	return Error(d->lasterr = gpgme_set_locale(d->ctx, cat, val));
	}

	EngineInfo Context::engineInfo() const
	{
	return EngineInfo(gpgme_ctx_get_engine_info(d->ctx));
	}

	Error Context::setEngineFileName(const char *filename)
	{
	const char *const home_dir = engineInfo().homeDirectory();
	return Error(gpgme_ctx_set_engine_info(d->ctx, gpgme_get_protocol(d->ctx), filename, home_dir));
	}

	Error Context::setEngineHomeDirectory(const char *home_dir)
	{
	const char *const filename = engineInfo().fileName();
	return Error(gpgme_ctx_set_engine_info(d->ctx, gpgme_get_protocol(d->ctx), filename, home_dir));
	}

	//
	//
	// Key Management
	//
	//

	Error Context::startKeyListing(const char *pattern, bool secretOnly)
	{
	d->lastop = Private::KeyList;
	return Error(d->lasterr = gpgme_op_keylist_start(d->ctx, pattern, int(secretOnly)));
	}

	Error Context::startKeyListing(const char *patterns[], bool secretOnly)
	{
	d->lastop = Private::KeyList;
	#ifndef HAVE_GPGME_EXT_KEYLIST_MODE_EXTERNAL_NONBROKEN
	if (!patterns \|\| !patterns[0] \|\| !patterns[1]) {
	// max. one pattern -> use the non-ext version
	return startKeyListing(patterns ? patterns[0] : 0, secretOnly);
	}
	#endif
	return Error(d->lasterr = gpgme_op_keylist_ext_start(d->ctx, patterns, int(secretOnly), 0));
	}

	Key Context::nextKey(GpgME::Error &e)
	{
	d->lastop = Private::KeyList;
	gpgme_key_t key;
	e = Error(d->lasterr = gpgme_op_keylist_next(d->ctx, &key));
	return Key(key, false);
	}

	KeyListResult Context::endKeyListing()
	{
	d->lasterr = gpgme_op_keylist_end(d->ctx);
	return keyListResult();
	}

	KeyListResult Context::keyListResult() const
	{
	return KeyListResult(d->ctx, Error(d->lasterr));
	}

	Key Context::key(const char fingerprint, GpgME::Error &e , bool secret /, bool forceUpdate*/)
	{
	d->lastop = Private::KeyList;
	gpgme_key_t key;
	e = Error(d->lasterr = gpgme_get_key(d->ctx, fingerprint, &key, int(secret)/, int( forceUpdate )/));
	return Key(key, false);
	}

	KeyGenerationResult Context::generateKey(const char *parameters, Data &pubKey)
	{
	d->lastop = Private::KeyGen;
	Data::Private *const dp = pubKey.impl();
	d->lasterr = gpgme_op_genkey(d->ctx, parameters, dp ? dp->data : 0, 0);
	return KeyGenerationResult(d->ctx, Error(d->lasterr));
	}

	Error Context::startKeyGeneration(const char *parameters, Data &pubKey)
	{
	d->lastop = Private::KeyGen;
	Data::Private *const dp = pubKey.impl();
	return Error(d->lasterr = gpgme_op_genkey_start(d->ctx, parameters, dp ? dp->data : 0, 0));
	}

	KeyGenerationResult Context::keyGenerationResult() const
	{
	if (d->lastop & Private::KeyGen) {
	return KeyGenerationResult(d->ctx, Error(d->lasterr));
	} else {
	return KeyGenerationResult();
	}
	}

	Error Context::exportPublicKeys(const char *pattern, Data &keyData)
	{
	d->lastop = Private::Export;
	Data::Private *const dp = keyData.impl();
	return Error(d->lasterr = gpgme_op_export(d->ctx, pattern, 0, dp ? dp->data : 0));
	}

	Error Context::exportPublicKeys(const char *patterns[], Data &keyData)
	{
	d->lastop = Private::Export;
	#ifndef HAVE_GPGME_EXT_KEYLIST_MODE_EXTERNAL_NONBROKEN
	if (!patterns \|\| !patterns[0] \|\| !patterns[1]) {
	// max. one pattern -> use the non-ext version
	return exportPublicKeys(patterns ? patterns[0] : 0, keyData);
	}
	#endif
	Data::Private *const dp = keyData.impl();
	return Error(d->lasterr = gpgme_op_export_ext(d->ctx, patterns, 0, dp ? dp->data : 0));
	}

	Error Context::startPublicKeyExport(const char *pattern, Data &keyData)
	{
	d->lastop = Private::Export;
	Data::Private *const dp = keyData.impl();
	return Error(d->lasterr = gpgme_op_export_start(d->ctx, pattern, 0, dp ? dp->data : 0));
	}

	Error Context::startPublicKeyExport(const char *patterns[], Data &keyData)
	{
	d->lastop = Private::Export;
	#ifndef HAVE_GPGME_EXT_KEYLIST_MODE_EXTERNAL_NONBROKEN
	if (!patterns \|\| !patterns[0] \|\| !patterns[1]) {
	// max. one pattern -> use the non-ext version
	return startPublicKeyExport(patterns ? patterns[0] : 0, keyData);
	}
	#endif
	Data::Private *const dp = keyData.impl();
	return Error(d->lasterr = gpgme_op_export_ext_start(d->ctx, patterns, 0, dp ? dp->data : 0));
	}

	ImportResult Context::importKeys(const Data &data)
	{
	d->lastop = Private::Import;
	const Data::Private *const dp = data.impl();
	d->lasterr = gpgme_op_import(d->ctx, dp ? dp->data : 0);
	return ImportResult(d->ctx, Error(d->lasterr));
	}

	ImportResult Context::importKeys(const std::vector<Key> &kk)
	{
	d->lastop = Private::Import;
	d->lasterr = make_error(GPG_ERR_NOT_IMPLEMENTED);

	bool shouldHaveResult = false;
	gpgme_key_t * const keys = new gpgme_key_t[ kk.size() + 1 ];
	gpgme_key_t *keys_it = &keys[0];
	for (std::vector<Key>::const_iterator it = kk.begin(), end = kk.end() ; it != end ; ++it) {
	if (it->impl()) {
	*keys_it++ = it->impl();
	}
	}
	*keys_it++ = 0;
	d->lasterr = gpgme_op_import_keys(d->ctx, keys);
	shouldHaveResult = true;
	if ((gpgme_err_code(d->lasterr) == GPG_ERR_NOT_IMPLEMENTED \|\|
	gpgme_err_code(d->lasterr) == GPG_ERR_NOT_SUPPORTED) &&
	protocol() == CMS) {
	// ok, try the workaround (export+import):
	std::vector<const char *> fprs;
	for (std::vector<Key>::const_iterator it = kk.begin(), end = kk.end() ; it != end ; ++it) {
	if (const char *fpr = it->primaryFingerprint()) {
	if (*fpr) {
	fprs.push_back(fpr);
	}
	} else if (const char *keyid = it->keyID()) {
	if (*keyid) {
	fprs.push_back(keyid);
	}
	}
	}
	fprs.push_back(0);
	Data data;
	Data::Private *const dp = data.impl();
	const gpgme_keylist_mode_t oldMode = gpgme_get_keylist_mode(d->ctx);
	gpgme_set_keylist_mode(d->ctx, GPGME_KEYLIST_MODE_EXTERN);
	d->lasterr = gpgme_op_export_ext(d->ctx, &fprs[0], 0, dp ? dp->data : 0);
	gpgme_set_keylist_mode(d->ctx, oldMode);
	if (!d->lasterr) {
	data.seek(0, SEEK_SET);
	d->lasterr = gpgme_op_import(d->ctx, dp ? dp->data : 0);
	shouldHaveResult = true;
	}
	}
	delete[] keys;
	if (shouldHaveResult) {
	return ImportResult(d->ctx, Error(d->lasterr));
	} else {
	return ImportResult(Error(d->lasterr));
	}
	}

	Error Context::startKeyImport(const Data &data)
	{
	d->lastop = Private::Import;
	const Data::Private *const dp = data.impl();
	return Error(d->lasterr = gpgme_op_import_start(d->ctx, dp ? dp->data : 0));
	}

	Error Context::startKeyImport(const std::vector<Key> &kk)
	{
	d->lastop = Private::Import;
	gpgme_key_t * const keys = new gpgme_key_t[ kk.size() + 1 ];
	gpgme_key_t *keys_it = &keys[0];
	for (std::vector<Key>::const_iterator it = kk.begin(), end = kk.end() ; it != end ; ++it) {
	if (it->impl()) {
	*keys_it++ = it->impl();
	}
	}
	*keys_it++ = 0;
	Error err = Error(d->lasterr = gpgme_op_import_keys_start(d->ctx, keys));
	delete[] keys;
	return err;
	}

	ImportResult Context::importResult() const
	{
	if (d->lastop & Private::Import) {
	return ImportResult(d->ctx, Error(d->lasterr));
	} else {
	return ImportResult();
	}
	}

	Error Context::deleteKey(const Key &key, bool allowSecretKeyDeletion)
	{
	d->lastop = Private::Delete;
	return Error(d->lasterr = gpgme_op_delete(d->ctx, key.impl(), int(allowSecretKeyDeletion)));
	}

	Error Context::startKeyDeletion(const Key &key, bool allowSecretKeyDeletion)
	{
	d->lastop = Private::Delete;
	return Error(d->lasterr = gpgme_op_delete_start(d->ctx, key.impl(), int(allowSecretKeyDeletion)));
	}

	Error Context::passwd(const Key &key)
	{
	d->lastop = Private::Passwd;
	return Error(d->lasterr = gpgme_op_passwd(d->ctx, key.impl(), 0U));
	}

	Error Context::startPasswd(const Key &key)
	{
	d->lastop = Private::Passwd;
	return Error(d->lasterr = gpgme_op_passwd_start(d->ctx, key.impl(), 0U));
	}

	Error Context::edit(const Key &key, std::unique_ptr<EditInteractor> func, Data &data)
	{
	d->lastop = Private::Edit;
	d->lastEditInteractor = std::move(func);
	Data::Private *const dp = data.impl();
	return Error(d->lasterr = gpgme_op_edit(d->ctx, key.impl(),
	d->lastEditInteractor.get() ? edit_interactor_callback : 0,
	d->lastEditInteractor.get() ? d->lastEditInteractor->d : 0,
	dp ? dp->data : 0));
	}

	Error Context::startEditing(const Key &key, std::unique_ptr<EditInteractor> func, Data &data)
	{
	d->lastop = Private::Edit;
	d->lastEditInteractor = std::move(func);
	Data::Private *const dp = data.impl();
	return Error(d->lasterr = gpgme_op_edit_start(d->ctx, key.impl(),
	d->lastEditInteractor.get() ? edit_interactor_callback : 0,
	d->lastEditInteractor.get() ? d->lastEditInteractor->d : 0,
	dp ? dp->data : 0));
	}

	EditInteractor *Context::lastEditInteractor() const
	{
	return d->lastEditInteractor.get();
	}

	std::unique_ptr<EditInteractor> Context::takeLastEditInteractor()
	{
	return std::move(d->lastEditInteractor);
	}

	Error Context::cardEdit(const Key &key, std::unique_ptr<EditInteractor> func, Data &data)
	{
	d->lastop = Private::CardEdit;
	d->lastCardEditInteractor = std::move(func);
	Data::Private *const dp = data.impl();
	return Error(d->lasterr = gpgme_op_card_edit(d->ctx, key.impl(),
	d->lastCardEditInteractor.get() ? edit_interactor_callback : 0,
	d->lastCardEditInteractor.get() ? d->lastCardEditInteractor->d : 0,
	dp ? dp->data : 0));
	}

	Error Context::startCardEditing(const Key &key, std::unique_ptr<EditInteractor> func, Data &data)
	{
	d->lastop = Private::CardEdit;
	d->lastCardEditInteractor = std::move(func);
	Data::Private *const dp = data.impl();
	return Error(d->lasterr = gpgme_op_card_edit_start(d->ctx, key.impl(),
	d->lastCardEditInteractor.get() ? edit_interactor_callback : 0,
	d->lastCardEditInteractor.get() ? d->lastCardEditInteractor->d : 0,
	dp ? dp->data : 0));
	}

	EditInteractor *Context::lastCardEditInteractor() const
	{
	return d->lastCardEditInteractor.get();
	}

	std::unique_ptr<EditInteractor> Context::takeLastCardEditInteractor()
	{
	return std::move(d->lastCardEditInteractor);
	}

	Error Context::startTrustItemListing(const char *pattern, int maxLevel)
	{
	d->lastop = Private::TrustList;
	return Error(d->lasterr = gpgme_op_trustlist_start(d->ctx, pattern, maxLevel));
	}

	TrustItem Context::nextTrustItem(Error &e)
	{
	gpgme_trust_item_t ti = 0;
	e = Error(d->lasterr = gpgme_op_trustlist_next(d->ctx, &ti));
	return TrustItem(ti);
	}

	Error Context::endTrustItemListing()
	{
	return Error(d->lasterr = gpgme_op_trustlist_end(d->ctx));
	}

	static gpgme_error_t assuan_transaction_data_callback(void opaque, const void data, size_t datalen)
	{
	assert(opaque);
	AssuanTransaction t = static_cast<AssuanTransaction >(opaque);
	return t->data(static_cast<const char *>(data), datalen).encodedError();
	}

	static gpgme_error_t assuan_transaction_inquire_callback(void opaque, const char name, const char args, gpgme_data_t r_data)
	{
	assert(opaque);
	Context::Private p = static_cast<Context::Private >(opaque);
	AssuanTransaction *t = p->lastAssuanTransaction.get();
	assert(t);
	Error err;
	if (name) {
	p->lastAssuanInquireData = t->inquire(name, args, err);
	} else {
	p->lastAssuanInquireData = Data::null;
	}
	if (!p->lastAssuanInquireData.isNull()) {
	*r_data = p->lastAssuanInquireData.impl()->data;
	}
	return err.encodedError();
	}

	static gpgme_error_t assuan_transaction_status_callback(void opaque, const char status, const char *args)
	{
	assert(opaque);
	AssuanTransaction t = static_cast<AssuanTransaction >(opaque);
	std::string a = args;
	percent_unescape(a, true); // ### why doesn't gpgme do this??
	return t->status(status, a.c_str()).encodedError();
	}

	-AssuanResult Context::assuanTransact(const char *command)
	+Error Context::assuanTransact(const char *command)
	{
	return assuanTransact(command, std::unique_ptr<AssuanTransaction>(new DefaultAssuanTransaction));
	}

	-AssuanResult Context::assuanTransact(const char *command, std::unique_ptr<AssuanTransaction> transaction)
	+Error Context::assuanTransact(const char *command, std::unique_ptr<AssuanTransaction> transaction)
	{
	+ gpgme_error_t err, operr;
	+
	d->lastop = Private::AssuanTransact;
	d->lastAssuanTransaction = std::move(transaction);
	if (!d->lastAssuanTransaction.get()) {
	- return AssuanResult(Error(d->lasterr = make_error(GPG_ERR_INV_ARG)));
	+ return Error(d->lasterr = make_error(GPG_ERR_INV_ARG));
	}
	- d->lasterr = gpgme_op_assuan_transact(d->ctx, command,
	- assuan_transaction_data_callback,
	- d->lastAssuanTransaction.get(),
	- assuan_transaction_inquire_callback,
	- d, // sic!
	- assuan_transaction_status_callback,
	- d->lastAssuanTransaction.get());
	- return AssuanResult(d->ctx, d->lasterr);
	+ err = gpgme_op_assuan_transact_ext
	+ (d->ctx,
	+ command,
	+ assuan_transaction_data_callback,
	+ d->lastAssuanTransaction.get(),
	+ assuan_transaction_inquire_callback,
	+ d,
	+ assuan_transaction_status_callback,
	+ d->lastAssuanTransaction.get(),
	+ &operr);
	+
	+ if (!err)
	+ err = operr;
	+ d->lasterr = err;
	+
	+ return Error(d->lasterr);
	}

	Error Context::startAssuanTransaction(const char *command)
	{
	return startAssuanTransaction(command, std::unique_ptr<AssuanTransaction>(new DefaultAssuanTransaction));
	}

	Error Context::startAssuanTransaction(const char *command, std::unique_ptr<AssuanTransaction> transaction)
	{
	+ gpgme_error_t err;
	+
	d->lastop = Private::AssuanTransact;
	d->lastAssuanTransaction = std::move(transaction);
	if (!d->lastAssuanTransaction.get()) {
	return Error(d->lasterr = make_error(GPG_ERR_INV_ARG));
	}
	- return Error(d->lasterr = gpgme_op_assuan_transact_start(d->ctx, command,
	- assuan_transaction_data_callback,
	- d->lastAssuanTransaction.get(),
	- assuan_transaction_inquire_callback,
	- d, // sic!
	- assuan_transaction_status_callback,
	- d->lastAssuanTransaction.get()));
	-}
	+ err = gpgme_op_assuan_transact_start
	+ (d->ctx,
	+ command,
	+ assuan_transaction_data_callback,
	+ d->lastAssuanTransaction.get(),
	+ assuan_transaction_inquire_callback,
	+ d,
	+ assuan_transaction_status_callback,
	+ d->lastAssuanTransaction.get());

	-AssuanResult Context::assuanResult() const
	-{
	- if (d->lastop & Private::AssuanTransact) {
	- return AssuanResult(d->ctx, d->lasterr);
	- } else {
	- return AssuanResult();
	- }
	+ d->lasterr = err;
	+
	+ return Error(d->lasterr);
	}

	AssuanTransaction *Context::lastAssuanTransaction() const
	{
	return d->lastAssuanTransaction.get();
	}

	std::unique_ptr<AssuanTransaction> Context::takeLastAssuanTransaction()
	{
	return std::move(d->lastAssuanTransaction);
	}

	DecryptionResult Context::decrypt(const Data &cipherText, Data &plainText)
	{
	d->lastop = Private::Decrypt;
	const Data::Private *const cdp = cipherText.impl();
	Data::Private *const pdp = plainText.impl();
	d->lasterr = gpgme_op_decrypt(d->ctx, cdp ? cdp->data : 0, pdp ? pdp->data : 0);
	return DecryptionResult(d->ctx, Error(d->lasterr));
	}

	Error Context::startDecryption(const Data &cipherText, Data &plainText)
	{
	d->lastop = Private::Decrypt;
	const Data::Private *const cdp = cipherText.impl();
	Data::Private *const pdp = plainText.impl();
	return Error(d->lasterr = gpgme_op_decrypt_start(d->ctx, cdp ? cdp->data : 0, pdp ? pdp->data : 0));
	}

	DecryptionResult Context::decryptionResult() const
	{
	if (d->lastop & Private::Decrypt) {
	return DecryptionResult(d->ctx, Error(d->lasterr));
	} else {
	return DecryptionResult();
	}
	}

	VerificationResult Context::verifyDetachedSignature(const Data &signature, const Data &signedText)
	{
	d->lastop = Private::Verify;
	const Data::Private *const sdp = signature.impl();
	const Data::Private *const tdp = signedText.impl();
	d->lasterr = gpgme_op_verify(d->ctx, sdp ? sdp->data : 0, tdp ? tdp->data : 0, 0);
	return VerificationResult(d->ctx, Error(d->lasterr));
	}

	VerificationResult Context::verifyOpaqueSignature(const Data &signedData, Data &plainText)
	{
	d->lastop = Private::Verify;
	const Data::Private *const sdp = signedData.impl();
	Data::Private *const pdp = plainText.impl();
	d->lasterr = gpgme_op_verify(d->ctx, sdp ? sdp->data : 0, 0, pdp ? pdp->data : 0);
	return VerificationResult(d->ctx, Error(d->lasterr));
	}

	Error Context::startDetachedSignatureVerification(const Data &signature, const Data &signedText)
	{
	d->lastop = Private::Verify;
	const Data::Private *const sdp = signature.impl();
	const Data::Private *const tdp = signedText.impl();
	return Error(d->lasterr = gpgme_op_verify_start(d->ctx, sdp ? sdp->data : 0, tdp ? tdp->data : 0, 0));
	}

	Error Context::startOpaqueSignatureVerification(const Data &signedData, Data &plainText)
	{
	d->lastop = Private::Verify;
	const Data::Private *const sdp = signedData.impl();
	Data::Private *const pdp = plainText.impl();
	return Error(d->lasterr = gpgme_op_verify_start(d->ctx, sdp ? sdp->data : 0, 0, pdp ? pdp->data : 0));
	}

	VerificationResult Context::verificationResult() const
	{
	if (d->lastop & Private::Verify) {
	return VerificationResult(d->ctx, Error(d->lasterr));
	} else {
	return VerificationResult();
	}
	}

	std::pair<DecryptionResult, VerificationResult> Context::decryptAndVerify(const Data &cipherText, Data &plainText)
	{
	d->lastop = Private::DecryptAndVerify;
	const Data::Private *const cdp = cipherText.impl();
	Data::Private *const pdp = plainText.impl();
	d->lasterr = gpgme_op_decrypt_verify(d->ctx, cdp ? cdp->data : 0, pdp ? pdp->data : 0);
	return std::make_pair(DecryptionResult(d->ctx, Error(d->lasterr)),
	VerificationResult(d->ctx, Error(d->lasterr)));
	}

	Error Context::startCombinedDecryptionAndVerification(const Data &cipherText, Data &plainText)
	{
	d->lastop = Private::DecryptAndVerify;
	const Data::Private *const cdp = cipherText.impl();
	Data::Private *const pdp = plainText.impl();
	return Error(d->lasterr = gpgme_op_decrypt_verify_start(d->ctx, cdp ? cdp->data : 0, pdp ? pdp->data : 0));
	}

	unsigned int to_auditlog_flags(unsigned int flags)
	{
	unsigned int result = 0;
	if (flags & Context::HtmlAuditLog) {
	result \|= GPGME_AUDITLOG_HTML;
	}
	if (flags & Context::AuditLogWithHelp) {
	result \|= GPGME_AUDITLOG_WITH_HELP;
	}
	return result;
	}

	Error Context::startGetAuditLog(Data &output, unsigned int flags)
	{
	d->lastop = Private::GetAuditLog;
	Data::Private *const odp = output.impl();
	return Error(d->lasterr = gpgme_op_getauditlog_start(d->ctx, odp ? odp->data : 0, to_auditlog_flags(flags)));
	}

	Error Context::getAuditLog(Data &output, unsigned int flags)
	{
	d->lastop = Private::GetAuditLog;
	Data::Private *const odp = output.impl();
	return Error(d->lasterr = gpgme_op_getauditlog(d->ctx, odp ? odp->data : 0, to_auditlog_flags(flags)));
	}

	void Context::clearSigningKeys()
	{
	gpgme_signers_clear(d->ctx);
	}

	Error Context::addSigningKey(const Key &key)
	{
	return Error(d->lasterr = gpgme_signers_add(d->ctx, key.impl()));
	}

	Key Context::signingKey(unsigned int idx) const
	{
	gpgme_key_t key = gpgme_signers_enum(d->ctx, idx);
	return Key(key, false);
	}

	std::vector<Key> Context::signingKeys() const
	{
	std::vector<Key> result;
	gpgme_key_t key;
	for (unsigned int i = 0 ; (key = gpgme_signers_enum(d->ctx, i)) ; ++i) {
	result.push_back(Key(key, false));
	}
	return result;
	}

	void Context::clearSignatureNotations()
	{
	gpgme_sig_notation_clear(d->ctx);
	}

	GpgME::Error Context::addSignatureNotation(const char name, const char value, unsigned int flags)
	{
	return Error(gpgme_sig_notation_add(d->ctx, name, value, add_to_gpgme_sig_notation_flags_t(0, flags)));
	}

	GpgME::Error Context::addSignaturePolicyURL(const char *url, bool critical)
	{
	return Error(gpgme_sig_notation_add(d->ctx, 0, url, critical ? GPGME_SIG_NOTATION_CRITICAL : 0));
	}

	const char *Context::signaturePolicyURL() const
	{
	for (gpgme_sig_notation_t n = gpgme_sig_notation_get(d->ctx) ; n ; n = n->next) {
	if (!n->name) {
	return n->value;
	}
	}
	}

	Notation Context::signatureNotation(unsigned int idx) const
	{
	for (gpgme_sig_notation_t n = gpgme_sig_notation_get(d->ctx) ; n ; n = n->next) {
	if (n->name) {
	if (idx-- == 0) {
	return Notation(n);
	}
	}
	}
	return Notation();
	}

	std::vector<Notation> Context::signatureNotations() const
	{
	std::vector<Notation> result;
	for (gpgme_sig_notation_t n = gpgme_sig_notation_get(d->ctx) ; n ; n = n->next) {
	if (n->name) {
	result.push_back(Notation(n));
	}
	}
	return result;
	}

	static gpgme_sig_mode_t sigmode2sigmode(SignatureMode mode)
	{
	switch (mode) {
	default:
	case NormalSignatureMode: return GPGME_SIG_MODE_NORMAL;
	case Detached: return GPGME_SIG_MODE_DETACH;
	case Clearsigned: return GPGME_SIG_MODE_CLEAR;
	}
	}

	SigningResult Context::sign(const Data &plainText, Data &signature, SignatureMode mode)
	{
	d->lastop = Private::Sign;
	const Data::Private *const pdp = plainText.impl();
	Data::Private *const sdp = signature.impl();
	d->lasterr = gpgme_op_sign(d->ctx, pdp ? pdp->data : 0, sdp ? sdp->data : 0, sigmode2sigmode(mode));
	return SigningResult(d->ctx, Error(d->lasterr));
	}

	Error Context::startSigning(const Data &plainText, Data &signature, SignatureMode mode)
	{
	d->lastop = Private::Sign;
	const Data::Private *const pdp = plainText.impl();
	Data::Private *const sdp = signature.impl();
	return Error(d->lasterr = gpgme_op_sign_start(d->ctx, pdp ? pdp->data : 0, sdp ? sdp->data : 0, sigmode2sigmode(mode)));
	}

	SigningResult Context::signingResult() const
	{
	if (d->lastop & Private::Sign) {
	return SigningResult(d->ctx, Error(d->lasterr));
	} else {
	return SigningResult();
	}
	}

	static gpgme_encrypt_flags_t encryptflags2encryptflags(Context::EncryptionFlags flags)
	{
	unsigned int result = 0;
	if (flags & Context::AlwaysTrust) {
	result \|= GPGME_ENCRYPT_ALWAYS_TRUST;
	}
	if (flags & Context::NoEncryptTo) {
	result \|= GPGME_ENCRYPT_NO_ENCRYPT_TO;
	}
	if (flags & Context::Prepare) {
	result \|= GPGME_ENCRYPT_PREPARE;
	}
	if (flags & Context::ExpectSign) {
	result \|= GPGME_ENCRYPT_EXPECT_SIGN;
	}
	if (flags & Context::NoCompress) {
	result \|= GPGME_ENCRYPT_NO_COMPRESS;
	}
	if (flags & Context::Symmetric) {
	result \|= GPGME_ENCRYPT_SYMMETRIC;
	}
	return static_cast<gpgme_encrypt_flags_t>(result);
	}

	gpgme_key_t *Context::getKeysFromRecipients(const std::vector<Key> &recipients)
	{
	if (recipients.empty()) {
	return nullptr;
	}
	gpgme_key_t *ret = new gpgme_key_t[ recipients.size() + 1 ];
	gpgme_key_t *keys_it = ret;
	for (std::vector<Key>::const_iterator it = recipients.begin() ; it != recipients.end() ; ++it) {
	if (it->impl()) {
	*keys_it++ = it->impl();
	}
	}
	*keys_it++ = 0;
	return ret;
	}

	EncryptionResult Context::encrypt(const std::vector<Key> &recipients, const Data &plainText, Data &cipherText, EncryptionFlags flags)
	{
	d->lastop = Private::Encrypt;
	if (flags & NoEncryptTo) {
	return EncryptionResult(Error(d->lasterr = make_error(GPG_ERR_NOT_IMPLEMENTED)));
	}
	const Data::Private *const pdp = plainText.impl();
	Data::Private *const cdp = cipherText.impl();
	gpgme_key_t *const keys = getKeysFromRecipients(recipients);
	d->lasterr = gpgme_op_encrypt(d->ctx, keys, encryptflags2encryptflags(flags),
	pdp ? pdp->data : 0, cdp ? cdp->data : 0);
	if (keys) {
	delete[] keys;
	}
	return EncryptionResult(d->ctx, Error(d->lasterr));
	}

	Error Context::encryptSymmetrically(const Data &plainText, Data &cipherText)
	{
	d->lastop = Private::Encrypt;
	const Data::Private *const pdp = plainText.impl();
	Data::Private *const cdp = cipherText.impl();
	return Error(d->lasterr = gpgme_op_encrypt(d->ctx, 0, (gpgme_encrypt_flags_t)0,
	pdp ? pdp->data : 0, cdp ? cdp->data : 0));
	}

	Error Context::startEncryption(const std::vector<Key> &recipients, const Data &plainText, Data &cipherText, EncryptionFlags flags)
	{
	d->lastop = Private::Encrypt;
	if (flags & NoEncryptTo) {
	return Error(d->lasterr = make_error(GPG_ERR_NOT_IMPLEMENTED));
	}
	const Data::Private *const pdp = plainText.impl();
	Data::Private *const cdp = cipherText.impl();
	gpgme_key_t *const keys = getKeysFromRecipients(recipients);
	d->lasterr = gpgme_op_encrypt_start(d->ctx, keys, encryptflags2encryptflags(flags),
	pdp ? pdp->data : 0, cdp ? cdp->data : 0);
	if (keys) {
	delete[] keys;
	}
	return Error(d->lasterr);
	}

	EncryptionResult Context::encryptionResult() const
	{
	if (d->lastop & Private::Encrypt) {
	return EncryptionResult(d->ctx, Error(d->lasterr));
	} else {
	return EncryptionResult();
	}
	}

	std::pair<SigningResult, EncryptionResult> Context::signAndEncrypt(const std::vector<Key> &recipients, const Data &plainText, Data &cipherText, EncryptionFlags flags)
	{
	d->lastop = Private::SignAndEncrypt;
	const Data::Private *const pdp = plainText.impl();
	Data::Private *const cdp = cipherText.impl();
	gpgme_key_t *const keys = getKeysFromRecipients(recipients);
	d->lasterr = gpgme_op_encrypt_sign(d->ctx, keys, encryptflags2encryptflags(flags),
	pdp ? pdp->data : 0, cdp ? cdp->data : 0);
	if (keys) {
	delete[] keys;
	}
	return std::make_pair(SigningResult(d->ctx, Error(d->lasterr)),
	EncryptionResult(d->ctx, Error(d->lasterr)));
	}

	Error Context::startCombinedSigningAndEncryption(const std::vector<Key> &recipients, const Data &plainText, Data &cipherText, EncryptionFlags flags)
	{
	d->lastop = Private::SignAndEncrypt;
	const Data::Private *const pdp = plainText.impl();
	Data::Private *const cdp = cipherText.impl();
	gpgme_key_t *const keys = getKeysFromRecipients(recipients);
	d->lasterr = gpgme_op_encrypt_sign_start(d->ctx, keys, encryptflags2encryptflags(flags),
	pdp ? pdp->data : 0, cdp ? cdp->data : 0);
	if (keys) {
	delete[] keys;
	}
	return Error(d->lasterr);
	}

	Error Context::createVFS(const char *containerFile, const std::vector< Key > &recipients)
	{
	d->lastop = Private::CreateVFS;
	gpgme_key_t *const keys = new gpgme_key_t[ recipients.size() + 1 ];
	gpgme_key_t *keys_it = keys;
	for (std::vector<Key>::const_iterator it = recipients.begin() ; it != recipients.end() ; ++it) {
	if (it->impl()) {
	*keys_it++ = it->impl();
	}
	}
	*keys_it++ = 0;

	gpgme_error_t op_err;
	d->lasterr = gpgme_op_vfs_create(d->ctx, keys, containerFile, 0, &op_err);
	delete[] keys;
	Error error(d->lasterr);
	if (error) {
	return error;
	}
	return Error(d->lasterr = op_err);
	}

	VfsMountResult Context::mountVFS(const char containerFile, const char mountDir)
	{
	d->lastop = Private::MountVFS;
	gpgme_error_t op_err;
	d->lasterr = gpgme_op_vfs_mount(d->ctx, containerFile, mountDir, 0, &op_err);
	return VfsMountResult(d->ctx, Error(d->lasterr), Error(op_err));
	}

	Error Context::cancelPendingOperation()
	{
	return Error(gpgme_cancel_async(d->ctx));
	}

	bool Context::poll()
	{
	gpgme_error_t e = GPG_ERR_NO_ERROR;
	const bool finished = gpgme_wait(d->ctx, &e, 0);
	if (finished) {
	d->lasterr = e;
	}
	return finished;
	}

	Error Context::wait()
	{
	gpgme_error_t e = GPG_ERR_NO_ERROR;
	gpgme_wait(d->ctx, &e, 1);
	return Error(d->lasterr = e);
	}

	Error Context::lastError() const
	{
	return Error(d->lasterr);
	}

	Context::PinentryMode Context::pinentryMode() const
	{
	switch (gpgme_get_pinentry_mode (d->ctx)) {
	case GPGME_PINENTRY_MODE_ASK:
	return PinentryAsk;
	case GPGME_PINENTRY_MODE_CANCEL:
	return PinentryCancel;
	case GPGME_PINENTRY_MODE_ERROR:
	return PinentryError;
	case GPGME_PINENTRY_MODE_LOOPBACK:
	return PinentryLoopback;
	case GPGME_PINENTRY_MODE_DEFAULT:
	default:
	return PinentryDefault;
	}
	}

	Error Context::setPinentryMode(PinentryMode which)
	{
	gpgme_pinentry_mode_t mode;
	switch (which) {
	case PinentryAsk:
	mode = GPGME_PINENTRY_MODE_ASK;
	break;
	case PinentryCancel:
	mode = GPGME_PINENTRY_MODE_CANCEL;
	break;
	case PinentryError:
	mode = GPGME_PINENTRY_MODE_ERROR;
	break;
	case PinentryLoopback:
	mode = GPGME_PINENTRY_MODE_LOOPBACK;
	break;
	case PinentryDefault:
	default:
	mode = GPGME_PINENTRY_MODE_DEFAULT;
	}
	return Error(d->lasterr = gpgme_set_pinentry_mode(d->ctx, mode));
	}

	std::ostream &operator<<(std::ostream &os, Protocol proto)
	{
	os << "GpgME::Protocol(";
	switch (proto) {
	case OpenPGP:
	os << "OpenPGP";
	break;
	case CMS:
	os << "CMS";
	break;
	default:
	case UnknownProtocol:
	os << "UnknownProtocol";
	break;
	}
	return os << ')';
	}

	std::ostream &operator<<(std::ostream &os, Engine eng)
	{
	os << "GpgME::Engine(";
	switch (eng) {
	case GpgEngine:
	os << "GpgEngine";
	break;
	case GpgSMEngine:
	os << "GpgSMEngine";
	break;
	case GpgConfEngine:
	os << "GpgConfEngine";
	break;
	case AssuanEngine:
	os << "AssuanEngine";
	break;
	default:
	case UnknownEngine:
	os << "UnknownEngine";
	break;
	}
	return os << ')';
	}

	std::ostream &operator<<(std::ostream &os, Context::CertificateInclusion incl)
	{
	os << "GpgME::Context::CertificateInclusion(" << static_cast<int>(incl);
	switch (incl) {
	case Context::DefaultCertificates:
	os << "(DefaultCertificates)";
	break;
	case Context::AllCertificatesExceptRoot:
	os << "(AllCertificatesExceptRoot)";
	break;
	case Context::AllCertificates:
	os << "(AllCertificates)";
	break;
	case Context::NoCertificates:
	os << "(NoCertificates)";
	break;
	case Context::OnlySenderCertificate:
	os << "(OnlySenderCertificate)";
	break;
	}
	return os << ')';
	}

	std::ostream &operator<<(std::ostream &os, KeyListMode mode)
	{
	os << "GpgME::KeyListMode(";
	#define CHECK( x ) if ( !(mode & (x)) ) {} else do { os << #x " "; } while (0)
	CHECK(Local);
	CHECK(Extern);
	CHECK(Signatures);
	CHECK(Validate);
	CHECK(Ephemeral);
	#undef CHECK
	return os << ')';
	}

	std::ostream &operator<<(std::ostream &os, SignatureMode mode)
	{
	os << "GpgME::SignatureMode(";
	switch (mode) {
	#define CHECK( x ) case x: os << #x; break
	CHECK(NormalSignatureMode);
	CHECK(Detached);
	CHECK(Clearsigned);
	#undef CHECK
	default:
	os << "???" "(" << static_cast<int>(mode) << ')';
	break;
	}
	return os << ')';
	}

	std::ostream &operator<<(std::ostream &os, Context::EncryptionFlags flags)
	{
	os << "GpgME::Context::EncryptionFlags(";
	#define CHECK( x ) if ( !(flags & (Context::x)) ) {} else do { os << #x " "; } while (0)
	CHECK(AlwaysTrust);
	CHECK(NoEncryptTo);
	CHECK(Prepare);
	CHECK(ExpectSign);
	CHECK(NoCompress);
	CHECK(Symmetric);
	#undef CHECK
	return os << ')';
	}

	std::ostream &operator<<(std::ostream &os, Context::AuditLogFlags flags)
	{
	os << "GpgME::Context::AuditLogFlags(";
	#define CHECK( x ) if ( !(flags & (Context::x)) ) {} else do { os << #x " "; } while (0)
	CHECK(HtmlAuditLog);
	CHECK(AuditLogWithHelp);
	#undef CHECK
	return os << ')';
	}

	} // namespace GpgME

	GpgME::Error GpgME::setDefaultLocale(int cat, const char *val)
	{
	return Error(gpgme_set_locale(0, cat, val));
	}

	GpgME::EngineInfo GpgME::engineInfo(GpgME::Protocol proto)
	{
	gpgme_engine_info_t ei = 0;
	if (gpgme_get_engine_info(&ei)) {
	return EngineInfo();
	}

	const gpgme_protocol_t p = proto == CMS ? GPGME_PROTOCOL_CMS : GPGME_PROTOCOL_OpenPGP ;

	for (gpgme_engine_info_t i = ei ; i ; i = i->next) {
	if (i->protocol == p) {
	return EngineInfo(i);
	}
	}

	return EngineInfo();
	}

	GpgME::Error GpgME::checkEngine(GpgME::Protocol proto)
	{
	const gpgme_protocol_t p = proto == CMS ? GPGME_PROTOCOL_CMS : GPGME_PROTOCOL_OpenPGP ;

	return Error(gpgme_engine_check_version(p));
	}

	static const gpgme_protocol_t UNKNOWN_PROTOCOL = static_cast<gpgme_protocol_t>(255);

	static gpgme_protocol_t engine2protocol(const GpgME::Engine engine)
	{
	switch (engine) {
	case GpgME::GpgEngine: return GPGME_PROTOCOL_OpenPGP;
	case GpgME::GpgSMEngine: return GPGME_PROTOCOL_CMS;
	case GpgME::GpgConfEngine:
	return GPGME_PROTOCOL_GPGCONF;
	case GpgME::AssuanEngine:
	return GPGME_PROTOCOL_ASSUAN;
	case GpgME::G13Engine:
	return GPGME_PROTOCOL_G13;
	case GpgME::UnknownEngine:
	;
	}
	return UNKNOWN_PROTOCOL;
	}

	GpgME::EngineInfo GpgME::engineInfo(GpgME::Engine engine)
	{
	gpgme_engine_info_t ei = 0;
	if (gpgme_get_engine_info(&ei)) {
	return EngineInfo();
	}

	const gpgme_protocol_t p = engine2protocol(engine);

	for (gpgme_engine_info_t i = ei ; i ; i = i->next) {
	if (i->protocol == p) {
	return EngineInfo(i);
	}
	}

	return EngineInfo();
	}

	GpgME::Error GpgME::checkEngine(GpgME::Engine engine)
	{
	const gpgme_protocol_t p = engine2protocol(engine);

	return Error(gpgme_engine_check_version(p));
	}

	static const unsigned long supported_features = 0
	\| GpgME::ValidatingKeylistModeFeature
	\| GpgME::CancelOperationFeature
	\| GpgME::WrongKeyUsageFeature
	\| GpgME::DefaultCertificateInclusionFeature
	\| GpgME::GetSetEngineInfoFeature
	\| GpgME::ClearAddGetSignatureNotationsFeature
	\| GpgME::SetDataFileNameFeeature
	\| GpgME::SignatureNotationsKeylistModeFeature
	\| GpgME::KeySignatureNotationsFeature
	\| GpgME::KeyIsQualifiedFeature
	\| GpgME::SignatureNotationsCriticalFlagFeature
	\| GpgME::SignatureNotationsFlagsFeature
	\| GpgME::SignatureNotationsHumanReadableFlagFeature
	\| GpgME::SubkeyIsQualifiedFeature
	\| GpgME::EngineInfoHomeDirFeature
	\| GpgME::DecryptionResultFileNameFeature
	\| GpgME::DecryptionResultRecipientsFeature
	\| GpgME::VerificationResultFileNameFeature
	\| GpgME::SignaturePkaFieldsFeature
	\| GpgME::SignatureAlgorithmFieldsFeature
	\| GpgME::FdPointerFeature
	\| GpgME::AuditLogFeature
	\| GpgME::GpgConfEngineFeature
	\| GpgME::CancelOperationAsyncFeature
	\| GpgME::NoEncryptToEncryptionFlagFeature
	\| GpgME::CardKeyFeature
	\| GpgME::AssuanEngineFeature
	\| GpgME::EphemeralKeylistModeFeature
	\| GpgME::ImportFromKeyserverFeature
	\| GpgME::G13VFSFeature
	\| GpgME::PasswdFeature
	;

	static const unsigned long supported_features2 = 0
	\| GpgME::BinaryAndFineGrainedIdentify
	;

	bool GpgME::hasFeature(unsigned long features)
	{
	return features == (features & supported_features);
	}

	bool GpgME::hasFeature(unsigned long features, unsigned long features2)
	{
	return features == (features & supported_features)
	&& features2 == (features2 & supported_features2)
	;
	}
	diff --git a/lang/cpp/src/context.h b/lang/cpp/src/context.h
	index 29eba91b..6518d4cf 100644
	--- a/lang/cpp/src/context.h
	+++ b/lang/cpp/src/context.h
	@@ -1,390 +1,388 @@
	/*
	context.h - wraps a gpgme key context
	Copyright (C) 2003, 2007 Klarälvdalens Datakonsult AB

	This file is part of GPGME++.

	GPGME++ is free software; you can redistribute it and/or
	modify it under the terms of the GNU Library General Public
	License as published by the Free Software Foundation; either
	version 2 of the License, or (at your option) any later version.

	GPGME++ is distributed in the hope that it will be useful,
	but WITHOUT ANY WARRANTY; without even the implied warranty of
	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	GNU Library General Public License for more details.

	You should have received a copy of the GNU Library General Public License
	along with GPGME++; see the file COPYING.LIB. If not, write to the
	Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
	Boston, MA 02110-1301, USA.
	*/

	// -- c++ --
	#ifndef __GPGMEPP_CONTEXT_H__
	#define __GPGMEPP_CONTEXT_H__

	#include "global.h"

	#include "error.h"
	#include "verificationresult.h" // for Signature::Notation

	#include <memory>
	#include <vector>
	#include <utility>
	#include <iosfwd>

	namespace GpgME
	{

	class Key;
	class Data;
	class TrustItem;
	class ProgressProvider;
	class PassphraseProvider;
	class EventLoopInteractor;
	class EditInteractor;
	class AssuanTransaction;

	-class AssuanResult;
	class KeyListResult;
	class KeyGenerationResult;
	class ImportResult;
	class DecryptionResult;
	class VerificationResult;
	class SigningResult;
	class EncryptionResult;
	class VfsMountResult;

	class EngineInfo;

	class GPGMEPP_EXPORT Context
	{
	explicit Context(gpgme_ctx_t);
	public:
	//using GpgME::Protocol;

	//
	// Creation and destruction:
	//

	static Context *createForProtocol(Protocol proto);
	static std::unique_ptr<Context> createForEngine(Engine engine, Error *err = 0);
	virtual ~Context();

	//
	// Context Attributes
	//

	Protocol protocol() const;

	void setArmor(bool useArmor);
	bool armor() const;

	void setTextMode(bool useTextMode);
	bool textMode() const;

	void setOffline(bool useOfflineMode);
	bool offline() const;

	enum CertificateInclusion {
	DefaultCertificates = -256,
	AllCertificatesExceptRoot = -2,
	AllCertificates = -1,
	NoCertificates = 0,
	OnlySenderCertificate = 1
	};
	void setIncludeCertificates(int which);
	int includeCertificates() const;

	//using GpgME::KeyListMode;
	void setKeyListMode(unsigned int keyListMode);
	void addKeyListMode(unsigned int keyListMode);
	unsigned int keyListMode() const;

	/** Set the passphrase provider
	*
	* To avoid problems where a class using a context registers
	* itself as the provider the Context does not take ownership
	* of the provider and the caller must ensure that the provider
	* is deleted if it is no longer needed.
	*/
	void setPassphraseProvider(PassphraseProvider *provider);
	PassphraseProvider *passphraseProvider() const;

	/** Set the progress provider
	*
	* To avoid problems where a class using a context registers
	* itself as the provider the Context does not take ownership
	* of the provider and the caller must ensure that the provider
	* is deleted if it is no longer needed.
	*/
	void setProgressProvider(ProgressProvider *provider);
	ProgressProvider *progressProvider() const;

	void setManagedByEventLoopInteractor(bool managed);
	bool managedByEventLoopInteractor() const;

	GpgME::Error setLocale(int category, const char *value);

	EngineInfo engineInfo() const;
	GpgME::Error setEngineFileName(const char *filename);
	GpgME::Error setEngineHomeDirectory(const char *filename);

	enum PinentryMode{
	PinentryDefault = 0,
	PinentryAsk = 1,
	PinentryCancel = 2,
	PinentryError = 3,
	PinentryLoopback = 4
	};
	GpgME::Error setPinentryMode(PinentryMode which);
	PinentryMode pinentryMode() const;

	private:
	friend class ::GpgME::EventLoopInteractor;
	void installIOCallbacks(gpgme_io_cbs *iocbs);
	void uninstallIOCallbacks();

	public:
	//
	//
	// Key Management
	//
	//

	//
	// Key Listing
	//

	GpgME::Error startKeyListing(const char *pattern = 0, bool secretOnly = false);
	GpgME::Error startKeyListing(const char *patterns[], bool secretOnly = false);

	Key nextKey(GpgME::Error &e);

	KeyListResult endKeyListing();
	KeyListResult keyListResult() const;

	Key key(const char *fingerprint, GpgME::Error &e, bool secret = false);

	//
	// Key Generation
	//

	KeyGenerationResult generateKey(const char *parameters, Data &pubKey);
	GpgME::Error startKeyGeneration(const char *parameters, Data &pubkey);
	KeyGenerationResult keyGenerationResult() const;

	//
	// Key Export
	//

	GpgME::Error exportPublicKeys(const char *pattern, Data &keyData);
	GpgME::Error exportPublicKeys(const char *pattern[], Data &keyData);
	GpgME::Error startPublicKeyExport(const char *pattern, Data &keyData);
	GpgME::Error startPublicKeyExport(const char *pattern[], Data &keyData);

	//
	// Key Import
	//

	ImportResult importKeys(const Data &data);
	ImportResult importKeys(const std::vector<Key> &keys);
	GpgME::Error startKeyImport(const Data &data);
	GpgME::Error startKeyImport(const std::vector<Key> &keys);
	ImportResult importResult() const;

	//
	// Key Deletion
	//

	GpgME::Error deleteKey(const Key &key, bool allowSecretKeyDeletion = false);
	GpgME::Error startKeyDeletion(const Key &key, bool allowSecretKeyDeletion = false);

	//
	// Passphrase changing
	//

	GpgME::Error passwd(const Key &key);
	GpgME::Error startPasswd(const Key &key);

	//
	// Key Editing
	//

	GpgME::Error edit(const Key &key, std::unique_ptr<EditInteractor> function, Data &out);
	GpgME::Error startEditing(const Key &key, std::unique_ptr<EditInteractor> function, Data &out);

	EditInteractor *lastEditInteractor() const;
	std::unique_ptr<EditInteractor> takeLastEditInteractor();

	//
	// SmartCard Editing
	//

	GpgME::Error cardEdit(const Key &key, std::unique_ptr<EditInteractor> function, Data &out);
	GpgME::Error startCardEditing(const Key &key, std::unique_ptr<EditInteractor> function, Data &out);

	EditInteractor *lastCardEditInteractor() const;
	std::unique_ptr<EditInteractor> takeLastCardEditInteractor();

	//
	// Trust Item Management
	//

	GpgME::Error startTrustItemListing(const char *pattern, int maxLevel);
	TrustItem nextTrustItem(GpgME::Error &e);
	GpgME::Error endTrustItemListing();

	//
	// Assuan Transactions
	//

	- AssuanResult assuanTransact(const char *command, std::unique_ptr<AssuanTransaction> transaction);
	- AssuanResult assuanTransact(const char *command);
	+ GpgME::Error assuanTransact(const char *command, std::unique_ptr<AssuanTransaction> transaction);
	+ GpgME::Error assuanTransact(const char *command);
	GpgME::Error startAssuanTransaction(const char *command, std::unique_ptr<AssuanTransaction> transaction);
	GpgME::Error startAssuanTransaction(const char *command);
	- AssuanResult assuanResult() const;

	AssuanTransaction *lastAssuanTransaction() const;
	std::unique_ptr<AssuanTransaction> takeLastAssuanTransaction();

	//
	//
	// Crypto Operations
	//
	//

	//
	// Decryption
	//

	DecryptionResult decrypt(const Data &cipherText, Data &plainText);
	GpgME::Error startDecryption(const Data &cipherText, Data &plainText);
	DecryptionResult decryptionResult() const;

	//
	// Signature Verification
	//

	VerificationResult verifyDetachedSignature(const Data &signature, const Data &signedText);
	VerificationResult verifyOpaqueSignature(const Data &signedData, Data &plainText);
	GpgME::Error startDetachedSignatureVerification(const Data &signature, const Data &signedText);
	GpgME::Error startOpaqueSignatureVerification(const Data &signedData, Data &plainText);
	VerificationResult verificationResult() const;

	//
	// Combined Decryption and Signature Verification
	//

	std::pair<DecryptionResult, VerificationResult> decryptAndVerify(const Data &cipherText, Data &plainText);
	GpgME::Error startCombinedDecryptionAndVerification(const Data &cipherText, Data &plainText);
	// use verificationResult() and decryptionResult() to retrieve the result objects...

	//
	// Signing
	//

	void clearSigningKeys();
	GpgME::Error addSigningKey(const Key &signer);
	Key signingKey(unsigned int index) const;
	std::vector<Key> signingKeys() const;

	void clearSignatureNotations();
	GpgME::Error addSignatureNotation(const char name, const char value, unsigned int flags = 0);
	GpgME::Error addSignaturePolicyURL(const char *url, bool critical = false);
	const char *signaturePolicyURL() const;
	Notation signatureNotation(unsigned int index) const;
	std::vector<Notation> signatureNotations() const;

	//using GpgME::SignatureMode;
	SigningResult sign(const Data &plainText, Data &signature, SignatureMode mode);
	GpgME::Error startSigning(const Data &plainText, Data &signature, SignatureMode mode);
	SigningResult signingResult() const;

	//
	// Encryption
	//

	enum EncryptionFlags {
	None = 0,
	AlwaysTrust = 1,
	NoEncryptTo = 2,
	Prepare = 4,
	ExpectSign = 8,
	NoCompress = 16,
	Symmetric = 32
	};
	EncryptionResult encrypt(const std::vector<Key> &recipients, const Data &plainText, Data &cipherText, EncryptionFlags flags);
	GpgME::Error encryptSymmetrically(const Data &plainText, Data &cipherText);
	GpgME::Error startEncryption(const std::vector<Key> &recipients, const Data &plainText, Data &cipherText, EncryptionFlags flags);
	EncryptionResult encryptionResult() const;

	//
	// Combined Signing and Encryption
	//

	std::pair<SigningResult, EncryptionResult> signAndEncrypt(const std::vector<Key> &recipients, const Data &plainText, Data &cipherText, EncryptionFlags flags);
	GpgME::Error startCombinedSigningAndEncryption(const std::vector<Key> &recipients, const Data &plainText, Data &cipherText, EncryptionFlags flags);
	// use encryptionResult() and signingResult() to retrieve the result objects...

	//
	//
	// Audit Log
	//
	//
	enum AuditLogFlags {
	HtmlAuditLog = 1,
	AuditLogWithHelp = 128
	};
	GpgME::Error startGetAuditLog(Data &output, unsigned int flags = 0);
	GpgME::Error getAuditLog(Data &output, unsigned int flags = 0);

	//
	//
	// G13 crypto container operations
	//
	//
	GpgME::Error createVFS(const char *containerFile, const std::vector<Key> &recipients);
	VfsMountResult mountVFS(const char containerFile, const char mountDir);

	//
	//
	// Run Control
	//
	//

	bool poll();
	GpgME::Error wait();
	GpgME::Error lastError() const;
	GpgME::Error cancelPendingOperation();

	class Private;
	const Private *impl() const
	{
	return d;
	}
	Private *impl()
	{
	return d;
	}
	private:
	// Helper functions that need to be context because they rely
	// on the "Friendlyness" of context to access the gpgme types.
	gpgme_key_t *getKeysFromRecipients(const std::vector<Key> &recipients);

	private:
	Private *const d;

	private: // disable...
	Context(const Context &);
	const Context &operator=(const Context &);
	};

	GPGMEPP_EXPORT std::ostream &operator<<(std::ostream &os, Context::CertificateInclusion incl);
	GPGMEPP_EXPORT std::ostream &operator<<(std::ostream &os, Context::EncryptionFlags flags);
	GPGMEPP_EXPORT std::ostream &operator<<(std::ostream &os, Context::AuditLogFlags flags);

	} // namespace GpgME

	#endif // __GPGMEPP_CONTEXT_H__
	diff --git a/lang/cpp/src/vfsmountresult.h b/lang/cpp/src/vfsmountresult.h
	index abdd655d..b46eeb1c 100644
	--- a/lang/cpp/src/vfsmountresult.h
	+++ b/lang/cpp/src/vfsmountresult.h
	@@ -1,76 +1,76 @@
	/*
	vfsmountresult.h - wraps a gpgme vfs mount result
	Copyright (C) 2009 Klarälvdalens Datakonsult AB <info@kdab.com>
	Author: Marc Mutz <marc@kdab.com>, Volker Krause <volker@kdab.com>

	This file is part of GPGME++.

	GPGME++ is free software; you can redistribute it and/or
	modify it under the terms of the GNU Library General Public
	License as published by the Free Software Foundation; either
	version 2 of the License, or (at your option) any later version.

	GPGME++ is distributed in the hope that it will be useful,
	but WITHOUT ANY WARRANTY; without even the implied warranty of
	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	GNU Library General Public License for more details.

	You should have received a copy of the GNU Library General Public License
	along with GPGME++; see the file COPYING.LIB. If not, write to the
	Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
	Boston, MA 02110-1301, USA.
	*/

	#ifndef __GPGMEPP_VFSMOUNTRESULT_H__
	#define __GPGMEPP_VFSMOUNTRESULT_H__

	#include "gpgmefw.h"
	#include "result.h"
	#include "gpgmepp_export.h"

	#include <memory>

	#include <vector>
	#include <iosfwd>

	namespace GpgME
	{

	class Error;

	class GPGMEPP_EXPORT VfsMountResult : public Result
	{
	public:
	VfsMountResult();
	VfsMountResult(gpgme_ctx_t ctx, const Error &error, const Error &opError);
	explicit VfsMountResult(const Error &err);

	const VfsMountResult &operator=(VfsMountResult other)
	{
	swap(other);
	return *this;
	}

	void swap(VfsMountResult &other)
	{
	Result::swap(other);
	using std::swap;
	swap(this->d, other.d);
	}

	bool isNull() const;
	const char *mountDir() const;

	class Private;
	private:
	void init(gpgme_ctx_t ctx);
	std::shared_ptr<Private> d;
	};

	GPGMEPP_EXPORT std::ostream &operator<<(std::ostream &os, const VfsMountResult &result);

	}

	GPGMEPP_MAKE_STD_SWAP_SPECIALIZATION(VfsMountResult)

	-#endif // __GPGMEPP_ASSUANRESULT_H__
	+#endif // __GPGMEPP_VFSMOUNTRESULT_H__

File Metadata

Mime Type: text/x-diff
Expires: Tue, Dec 30, 5:51 PM (1 d, 21 h)
Storage Engine: local-disk
Storage Format: Raw Data
Storage Handle: 0d/25/268818263565397c080bac7ff5c4

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions