No OneTemporary
Actions

Size

24 KB

Subscribers

None

View Options

	diff --git a/src/decryptionresult.cpp b/src/decryptionresult.cpp
	index d1c991be..1e815cbe 100644
	--- a/src/decryptionresult.cpp
	+++ b/src/decryptionresult.cpp
	@@ -1,251 +1,252 @@
	/*
	decryptionresult.cpp - wraps a gpgme keygen result
	Copyright (C) 2004 Klarälvdalens Datakonsult AB
	2016 Bundesamt für Sicherheit in der Informationstechnik
	Software engineering by Intevation GmbH

	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.
	*/

	#ifdef HAVE_CONFIG_H
	#include "config.h"
	#endif

	#include <decryptionresult.h>
	#include "result_p.h"
	#include "util.h"

	#include <gpgme.h>

	#include <algorithm>
	#include <iterator>
	#include <cstring>
	#include <cstdlib>
	#include <istream>

	#include <string.h>

	class GpgME::DecryptionResult::Private
	{
	public:
	explicit Private(const _gpgme_op_decrypt_result &r) : res(r)
	{
	if (res.unsupported_algorithm) {
	res.unsupported_algorithm = strdup(res.unsupported_algorithm);
	}
	if (res.file_name) {
	res.file_name = strdup(res.file_name);
	}
	//FIXME: copying gpgme_recipient_t objects invalidates the keyid member,
	//thus we use _keyid for now (internal API)
	for (gpgme_recipient_t r = res.recipients ; r ; r = r->next) {
	recipients.push_back(*r);
	}
	res.recipients = 0;
	}
	~Private()
	{
	if (res.unsupported_algorithm) {
	std::free(res.unsupported_algorithm);
	}
	res.unsupported_algorithm = 0;
	if (res.file_name) {
	std::free(res.file_name);
	}
	res.file_name = 0;
	}

	_gpgme_op_decrypt_result res;
	std::vector<_gpgme_recipient> recipients;
	};

	GpgME::DecryptionResult::DecryptionResult(gpgme_ctx_t ctx, int error)
	: GpgME::Result(error), d()
	{
	init(ctx);
	}

	GpgME::DecryptionResult::DecryptionResult(gpgme_ctx_t ctx, const Error &error)
	: GpgME::Result(error), d()
	{
	init(ctx);
	}

	void GpgME::DecryptionResult::init(gpgme_ctx_t ctx)
	{
	if (!ctx) {
	return;
	}
	gpgme_decrypt_result_t res = gpgme_op_decrypt_result(ctx);
	if (!res) {
	return;
	}
	d.reset(new Private(*res));
	}

	make_standard_stuff(DecryptionResult)

	const char *GpgME::DecryptionResult::unsupportedAlgorithm() const
	{
	return d ? d->res.unsupported_algorithm : 0 ;
	}

	bool GpgME::DecryptionResult::isWrongKeyUsage() const
	{
	return d && d->res.wrong_key_usage;
	}

	bool GpgME::DecryptionResult::isDeVs() const
	{
	return d && d->res.is_de_vs;
	}

	const char *GpgME::DecryptionResult::fileName() const
	{
	return d ? d->res.file_name : 0 ;
	}

	unsigned int GpgME::DecryptionResult::numRecipients() const
	{
	return d ? d->recipients.size() : 0 ;
	}

	GpgME::DecryptionResult::Recipient GpgME::DecryptionResult::recipient(unsigned int idx) const
	{
	if (d && idx < d->recipients.size()) {
	return Recipient(&d->recipients[idx]);
	}
	return Recipient();
	}

	namespace
	{
	struct make_recipient {
	GpgME::DecryptionResult::Recipient operator()(_gpgme_recipient &t)
	{
	return GpgME::DecryptionResult::Recipient(&t);
	}
	};
	}

	std::vector<GpgME::DecryptionResult::Recipient> GpgME::DecryptionResult::recipients() const
	{
	std::vector<Recipient> result;
	if (d) {
	result.reserve(d->recipients.size());
	std::transform(d->recipients.begin(), d->recipients.end(),
	std::back_inserter(result),
	make_recipient());
	}
	return result;
	}

	class GpgME::DecryptionResult::Recipient::Private : public _gpgme_recipient
	{
	public:
	Private(gpgme_recipient_t reci) : _gpgme_recipient(*reci) {}
	};

	GpgME::DecryptionResult::Recipient::Recipient()
	: d()
	{

	}

	GpgME::DecryptionResult::Recipient::Recipient(gpgme_recipient_t r)
	: d()
	{
	if (r) {
	d.reset(new Private(r));
	}
	}

	bool GpgME::DecryptionResult::Recipient::isNull() const
	{
	return !d;
	}

	const char *GpgME::DecryptionResult::Recipient::keyID() const
	{
	//_keyid is internal API, but the public keyid is invalid after copying (see above)
	if (d) {
	return d->_keyid;
	}
	return 0;
	}

	const char *GpgME::DecryptionResult::Recipient::shortKeyID() const
	{
	//_keyid is internal API, but the public keyid is invalid after copying (see above)
	if (d) {
	return d->_keyid + 8;
	}
	return 0;
	}

	unsigned int GpgME::DecryptionResult::Recipient::publicKeyAlgorithm() const
	{
	if (d) {
	return d->pubkey_algo;
	}
	return 0;
	}

	const char *GpgME::DecryptionResult::Recipient::publicKeyAlgorithmAsString() const
	{
	if (d) {
	return gpgme_pubkey_algo_name(d->pubkey_algo);
	}
	return 0;
	}

	GpgME::Error GpgME::DecryptionResult::Recipient::status() const
	{
	if (d) {
	return Error(d->status);
	}
	return Error();
	}

	std::ostream &GpgME::operator<<(std::ostream &os, const DecryptionResult &result)
	{
	os << "GpgME::DecryptionResult(";
	if (!result.isNull()) {
	os << "\n error: " << result.error()
	<< "\n fileName: " << protect(result.fileName())
	<< "\n unsupportedAlgorithm: " << protect(result.unsupportedAlgorithm())
	<< "\n isWrongKeyUsage: " << result.isWrongKeyUsage()
	+ << "\n isDeVs " << result.isDeVs()
	<< "\n recipients:\n";
	const std::vector<DecryptionResult::Recipient> recipients = result.recipients();
	std::copy(recipients.begin(), recipients.end(),
	std::ostream_iterator<DecryptionResult::Recipient>(os, "\n"));
	}
	return os << ')';
	}

	std::ostream &GpgME::operator<<(std::ostream &os, const DecryptionResult::Recipient &reci)
	{
	os << "GpgME::DecryptionResult::Recipient(";
	if (!reci.isNull()) {
	os << "\n keyID: " << protect(reci.keyID())
	<< "\n shortKeyID: " << protect(reci.shortKeyID())
	<< "\n publicKeyAlgorithm: " << protect(reci.publicKeyAlgorithmAsString())
	<< "\n status: " << reci.status();
	}
	return os << ')';
	}
	diff --git a/src/verificationresult.cpp b/src/verificationresult.cpp
	index 6dacd9fb..2c42d074 100644
	--- a/src/verificationresult.cpp
	+++ b/src/verificationresult.cpp
	@@ -1,621 +1,622 @@
	/*
	verificationresult.cpp - wraps a gpgme verify result
	Copyright (C) 2004 Klarälvdalens Datakonsult AB
	2016 Bundesamt für Sicherheit in der Informationstechnik
	Software engineering by Intevation GmbH

	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.
	*/

	#ifdef HAVE_CONFIG_H
	#include "config.h"
	#endif

	#include <verificationresult.h>
	#include <notation.h>
	#include "result_p.h"
	#include "util.h"
	#include "key.h"
	#include "context.h"

	#include <gpgme.h>

	#include <istream>
	#include <algorithm>
	#include <iterator>
	#include <string>
	#include <cstring>
	#include <cstdlib>

	#include <string.h>

	class GpgME::VerificationResult::Private
	{
	public:
	explicit Private(const gpgme_verify_result_t r)
	{
	if (!r) {
	return;
	}
	if (r->file_name) {
	file_name = r->file_name;
	}
	// copy recursively, using compiler-generated copy ctor.
	// We just need to handle the pointers in the structs:
	for (gpgme_signature_t is = r->signatures ; is ; is = is->next) {
	gpgme_signature_t scopy = new _gpgme_signature(*is);
	if (is->fpr) {
	scopy->fpr = strdup(is->fpr);
	}
	// PENDING(marc) why does this crash on Windows in strdup()?
	# ifndef _WIN32
	if (is->pka_address) {
	scopy->pka_address = strdup(is->pka_address);
	}
	# else
	scopy->pka_address = 0;
	# endif
	scopy->next = 0;
	sigs.push_back(scopy);
	// copy keys
	if (scopy->key) {
	keys.push_back(Key(scopy->key, true));
	} else {
	keys.push_back(Key());
	}
	// copy notations:
	nota.push_back(std::vector<Nota>());
	purls.push_back(0);
	for (gpgme_sig_notation_t in = is->notations ; in ; in = in->next) {
	if (!in->name) {
	if (in->value) {
	purls.back() = strdup(in->value); // policy url
	}
	continue;
	}
	Nota n = { 0, 0, in->flags };
	n.name = strdup(in->name);
	if (in->value) {
	n.value = strdup(in->value);
	}
	nota.back().push_back(n);
	}
	}
	}
	~Private()
	{
	for (std::vector<gpgme_signature_t>::iterator it = sigs.begin() ; it != sigs.end() ; ++it) {
	std::free((*it)->fpr);
	std::free((*it)->pka_address);
	delete it; it = 0;
	}
	for (std::vector< std::vector<Nota> >::iterator it = nota.begin() ; it != nota.end() ; ++it) {
	for (std::vector<Nota>::iterator jt = it->begin() ; jt != it->end() ; ++jt) {
	std::free(jt->name); jt->name = 0;
	std::free(jt->value); jt->value = 0;
	}
	}
	std::for_each(purls.begin(), purls.end(), &std::free);
	}

	struct Nota {
	char *name;
	char *value;
	gpgme_sig_notation_flags_t flags;
	};

	std::vector<gpgme_signature_t> sigs;
	std::vector< std::vector<Nota> > nota;
	std::vector<GpgME::Key> keys;
	std::vector<char *> purls;
	std::string file_name;
	Protocol proto;
	};

	GpgME::VerificationResult::VerificationResult(gpgme_ctx_t ctx, int error)
	: GpgME::Result(error), d()
	{
	init(ctx);
	}

	GpgME::VerificationResult::VerificationResult(gpgme_ctx_t ctx, const Error &error)
	: GpgME::Result(error), d()
	{
	init(ctx);
	}

	void GpgME::VerificationResult::init(gpgme_ctx_t ctx)
	{
	if (!ctx) {
	return;
	}
	gpgme_verify_result_t res = gpgme_op_verify_result(ctx);
	if (!res) {
	return;
	}
	d.reset(new Private(res));
	gpgme_protocol_t proto = gpgme_get_protocol(ctx);
	d->proto = proto == GPGME_PROTOCOL_OpenPGP ? OpenPGP :
	proto == GPGME_PROTOCOL_CMS ? CMS :
	UnknownProtocol;
	}

	make_standard_stuff(VerificationResult)

	const char *GpgME::VerificationResult::fileName() const
	{
	return d ? d->file_name.c_str() : 0 ;
	}

	unsigned int GpgME::VerificationResult::numSignatures() const
	{
	return d ? d->sigs.size() : 0 ;
	}

	GpgME::Signature GpgME::VerificationResult::signature(unsigned int idx) const
	{
	return Signature(d, idx);
	}

	std::vector<GpgME::Signature> GpgME::VerificationResult::signatures() const
	{
	if (!d) {
	return std::vector<Signature>();
	}
	std::vector<Signature> result;
	result.reserve(d->sigs.size());
	for (unsigned int i = 0 ; i < d->sigs.size() ; ++i) {
	result.push_back(Signature(d, i));
	}
	return result;
	}

	GpgME::Signature::Signature(const std::shared_ptr<VerificationResult::Private> &parent, unsigned int i)
	: d(parent), idx(i)
	{
	}

	GpgME::Signature::Signature() : d(), idx(0) {}

	bool GpgME::Signature::isNull() const
	{
	return !d \|\| idx >= d->sigs.size() ;
	}

	GpgME::Signature::Summary GpgME::Signature::summary() const
	{
	if (isNull()) {
	return None;
	}
	gpgme_sigsum_t sigsum = d->sigs[idx]->summary;
	unsigned int result = 0;
	if (sigsum & GPGME_SIGSUM_VALID) {
	result \|= Valid;
	}
	if (sigsum & GPGME_SIGSUM_GREEN) {
	result \|= Green;
	}
	if (sigsum & GPGME_SIGSUM_RED) {
	result \|= Red;
	}
	if (sigsum & GPGME_SIGSUM_KEY_REVOKED) {
	result \|= KeyRevoked;
	}
	if (sigsum & GPGME_SIGSUM_KEY_EXPIRED) {
	result \|= KeyExpired;
	}
	if (sigsum & GPGME_SIGSUM_SIG_EXPIRED) {
	result \|= SigExpired;
	}
	if (sigsum & GPGME_SIGSUM_KEY_MISSING) {
	result \|= KeyMissing;
	}
	if (sigsum & GPGME_SIGSUM_CRL_MISSING) {
	result \|= CrlMissing;
	}
	if (sigsum & GPGME_SIGSUM_CRL_TOO_OLD) {
	result \|= CrlTooOld;
	}
	if (sigsum & GPGME_SIGSUM_BAD_POLICY) {
	result \|= BadPolicy;
	}
	if (sigsum & GPGME_SIGSUM_SYS_ERROR) {
	result \|= SysError;
	}
	if (sigsum & GPGME_SIGSUM_TOFU_CONFLICT) {
	result \|= TofuConflict;
	}
	return static_cast<Summary>(result);
	}

	const char *GpgME::Signature::fingerprint() const
	{
	return isNull() ? 0 : d->sigs[idx]->fpr ;
	}

	GpgME::Error GpgME::Signature::status() const
	{
	return Error(isNull() ? 0 : d->sigs[idx]->status);
	}

	time_t GpgME::Signature::creationTime() const
	{
	return static_cast<time_t>(isNull() ? 0 : d->sigs[idx]->timestamp);
	}

	time_t GpgME::Signature::expirationTime() const
	{
	return static_cast<time_t>(isNull() ? 0 : d->sigs[idx]->exp_timestamp);
	}

	bool GpgME::Signature::neverExpires() const
	{
	return expirationTime() == (time_t)0;
	}

	bool GpgME::Signature::isWrongKeyUsage() const
	{
	return !isNull() && d->sigs[idx]->wrong_key_usage;
	}

	bool GpgME::Signature::isVerifiedUsingChainModel() const
	{
	return !isNull() && d->sigs[idx]->chain_model;
	}

	bool GpgME::Signature::isDeVs() const
	{
	return !isNull() && d->sigs[idx]->is_de_vs;
	}

	GpgME::Signature::PKAStatus GpgME::Signature::pkaStatus() const
	{
	if (!isNull()) {
	return static_cast<PKAStatus>(d->sigs[idx]->pka_trust);
	}
	return UnknownPKAStatus;
	}

	const char *GpgME::Signature::pkaAddress() const
	{
	if (!isNull()) {
	return d->sigs[idx]->pka_address;
	}
	return 0;
	}

	GpgME::Signature::Validity GpgME::Signature::validity() const
	{
	if (isNull()) {
	return Unknown;
	}
	switch (d->sigs[idx]->validity) {
	default:
	case GPGME_VALIDITY_UNKNOWN: return Unknown;
	case GPGME_VALIDITY_UNDEFINED: return Undefined;
	case GPGME_VALIDITY_NEVER: return Never;
	case GPGME_VALIDITY_MARGINAL: return Marginal;
	case GPGME_VALIDITY_FULL: return Full;
	case GPGME_VALIDITY_ULTIMATE: return Ultimate;
	}
	}

	char GpgME::Signature::validityAsString() const
	{
	if (isNull()) {
	return '?';
	}
	switch (d->sigs[idx]->validity) {
	default:
	case GPGME_VALIDITY_UNKNOWN: return '?';
	case GPGME_VALIDITY_UNDEFINED: return 'q';
	case GPGME_VALIDITY_NEVER: return 'n';
	case GPGME_VALIDITY_MARGINAL: return 'm';
	case GPGME_VALIDITY_FULL: return 'f';
	case GPGME_VALIDITY_ULTIMATE: return 'u';
	}
	}

	GpgME::Error GpgME::Signature::nonValidityReason() const
	{
	return Error(isNull() ? 0 : d->sigs[idx]->validity_reason);
	}

	unsigned int GpgME::Signature::publicKeyAlgorithm() const
	{
	if (!isNull()) {
	return d->sigs[idx]->pubkey_algo;
	}
	return 0;
	}

	const char *GpgME::Signature::publicKeyAlgorithmAsString() const
	{
	if (!isNull()) {
	return gpgme_pubkey_algo_name(d->sigs[idx]->pubkey_algo);
	}
	return 0;
	}

	unsigned int GpgME::Signature::hashAlgorithm() const
	{
	if (!isNull()) {
	return d->sigs[idx]->hash_algo;
	}
	return 0;
	}

	const char *GpgME::Signature::hashAlgorithmAsString() const
	{
	if (!isNull()) {
	return gpgme_hash_algo_name(d->sigs[idx]->hash_algo);
	}
	return 0;
	}

	const char *GpgME::Signature::policyURL() const
	{
	return isNull() ? 0 : d->purls[idx] ;
	}

	GpgME::Notation GpgME::Signature::notation(unsigned int nidx) const
	{
	return GpgME::Notation(d, idx, nidx);
	}

	std::vector<GpgME::Notation> GpgME::Signature::notations() const
	{
	if (isNull()) {
	return std::vector<GpgME::Notation>();
	}
	std::vector<GpgME::Notation> result;
	result.reserve(d->nota[idx].size());
	for (unsigned int i = 0 ; i < d->nota[idx].size() ; ++i) {
	result.push_back(GpgME::Notation(d, idx, i));
	}
	return result;
	}

	GpgME::Key GpgME::Signature::key() const
	{
	if (isNull()) {
	return Key();
	}
	return d->keys[idx];
	}

	GpgME::Key GpgME::Signature::key(bool search, bool update) const
	{
	if (isNull()) {
	return Key();
	}

	GpgME::Key ret = key();
	if (ret.isNull() && search) {
	auto ctx = Context::createForProtocol (d->proto);
	if (ctx) {
	ctx->setKeyListMode(KeyListMode::Local \|
	KeyListMode::Signatures \|
	KeyListMode::SignatureNotations \|
	KeyListMode::Validate \|
	KeyListMode::WithTofu);
	Error e;
	ret = d->keys[idx] = ctx->key(fingerprint(), e, false);
	delete ctx;
	}
	}
	if (update) {
	d->keys[idx].update();
	ret = d->keys[idx];
	}
	return ret;
	}

	class GpgME::Notation::Private
	{
	public:
	Private() : d(), sidx(0), nidx(0), nota(0) {}
	Private(const std::shared_ptr<VerificationResult::Private> &priv, unsigned int sindex, unsigned int nindex)
	: d(priv), sidx(sindex), nidx(nindex), nota(0)
	{

	}
	Private(gpgme_sig_notation_t n)
	: d(), sidx(0), nidx(0), nota(n ? new _gpgme_sig_notation(*n) : 0)
	{
	if (nota && nota->name) {
	nota->name = strdup(nota->name);
	}
	if (nota && nota->value) {
	nota->value = strdup(nota->value);
	}
	}
	Private(const Private &other)
	: d(other.d), sidx(other.sidx), nidx(other.nidx), nota(other.nota)
	{
	if (nota) {
	nota->name = strdup(nota->name);
	nota->value = strdup(nota->value);
	}
	}
	~Private()
	{
	if (nota) {
	std::free(nota->name); nota->name = 0;
	std::free(nota->value); nota->value = 0;
	delete nota;
	}
	}

	std::shared_ptr<VerificationResult::Private> d;
	unsigned int sidx, nidx;
	gpgme_sig_notation_t nota;
	};

	GpgME::Notation::Notation(const std::shared_ptr<VerificationResult::Private> &parent, unsigned int sindex, unsigned int nindex)
	: d(new Private(parent, sindex, nindex))
	{

	}

	GpgME::Notation::Notation(gpgme_sig_notation_t nota)
	: d(new Private(nota))
	{

	}

	GpgME::Notation::Notation() : d() {}

	bool GpgME::Notation::isNull() const
	{
	if (!d) {
	return true;
	}
	if (d->d) {
	return d->sidx >= d->d->nota.size() \|\| d->nidx >= d->d->nota[d->sidx].size() ;
	}
	return !d->nota;
	}

	const char *GpgME::Notation::name() const
	{
	return
	isNull() ? 0 :
	d->d ? d->d->nota[d->sidx][d->nidx].name :
	d->nota ? d->nota->name : 0 ;
	}

	const char *GpgME::Notation::value() const
	{
	return
	isNull() ? 0 :
	d->d ? d->d->nota[d->sidx][d->nidx].value :
	d->nota ? d->nota->value : 0 ;
	}

	GpgME::Notation::Flags GpgME::Notation::flags() const
	{
	return
	convert_from_gpgme_sig_notation_flags_t(
	isNull() ? 0 :
	d->d ? d->d->nota[d->sidx][d->nidx].flags :
	d->nota ? d->nota->flags : 0);
	}

	bool GpgME::Notation::isHumanReadable() const
	{
	return flags() & HumanReadable;
	}

	bool GpgME::Notation::isCritical() const
	{
	return flags() & Critical;
	}

	std::ostream &GpgME::operator<<(std::ostream &os, const VerificationResult &result)
	{
	os << "GpgME::VerificationResult(";
	if (!result.isNull()) {
	os << "\n error: " << result.error()
	<< "\n fileName: " << protect(result.fileName())
	<< "\n signatures:\n";
	const std::vector<Signature> sigs = result.signatures();
	std::copy(sigs.begin(), sigs.end(),
	std::ostream_iterator<Signature>(os, "\n"));
	}
	return os << ')';
	}

	std::ostream &GpgME::operator<<(std::ostream &os, Signature::PKAStatus pkaStatus)
	{
	#define OUTPUT( x ) if ( !(pkaStatus & (GpgME::Signature:: x)) ) {} else do { os << #x " "; } while(0)
	os << "GpgME::Signature::PKAStatus(";
	OUTPUT(UnknownPKAStatus);
	OUTPUT(PKAVerificationFailed);
	OUTPUT(PKAVerificationSucceeded);
	#undef OUTPUT
	return os << ')';
	}

	std::ostream &GpgME::operator<<(std::ostream &os, Signature::Summary summary)
	{
	#define OUTPUT( x ) if ( !(summary & (GpgME::Signature:: x)) ) {} else do { os << #x " "; } while(0)
	os << "GpgME::Signature::Summary(";
	OUTPUT(Valid);
	OUTPUT(Green);
	OUTPUT(Red);
	OUTPUT(KeyRevoked);
	OUTPUT(KeyExpired);
	OUTPUT(SigExpired);
	OUTPUT(KeyMissing);
	OUTPUT(CrlMissing);
	OUTPUT(CrlTooOld);
	OUTPUT(BadPolicy);
	OUTPUT(SysError);
	OUTPUT(TofuConflict);
	#undef OUTPUT
	return os << ')';
	}

	std::ostream &GpgME::operator<<(std::ostream &os, const Signature &sig)
	{
	os << "GpgME::Signature(";
	if (!sig.isNull()) {
	os << "\n Summary: " << sig.summary()
	<< "\n Fingerprint: " << protect(sig.fingerprint())
	<< "\n Status: " << sig.status()
	<< "\n creationTime: " << sig.creationTime()
	<< "\n expirationTime: " << sig.expirationTime()
	<< "\n isWrongKeyUsage: " << sig.isWrongKeyUsage()
	<< "\n isVerifiedUsingChainModel: " << sig.isVerifiedUsingChainModel()
	<< "\n pkaStatus: " << sig.pkaStatus()
	<< "\n pkaAddress: " << protect(sig.pkaAddress())
	<< "\n validity: " << sig.validityAsString()
	<< "\n nonValidityReason: " << sig.nonValidityReason()
	<< "\n publicKeyAlgorithm: " << protect(sig.publicKeyAlgorithmAsString())
	<< "\n hashAlgorithm: " << protect(sig.hashAlgorithmAsString())
	<< "\n policyURL: " << protect(sig.policyURL())
	+ << "\n isDeVs " << sig.isDeVs()
	<< "\n notations:\n";
	const std::vector<Notation> nota = sig.notations();
	std::copy(nota.begin(), nota.end(),
	std::ostream_iterator<Notation>(os, "\n"));
	}
	return os << ')';
	}

	std::ostream &GpgME::operator<<(std::ostream &os, Notation::Flags flags)
	{
	os << "GpgME::Notation::Flags(";
	#define OUTPUT( x ) if ( !(flags & (GpgME::Notation:: x)) ) {} else do { os << #x " "; } while(0)
	OUTPUT(HumanReadable);
	OUTPUT(Critical);
	#undef OUTPUT
	return os << ')';
	}

	std::ostream &GpgME::operator<<(std::ostream &os, const Notation &nota)
	{
	os << "GpgME::Signature::Notation(";
	if (!nota.isNull()) {
	os << "\n name: " << protect(nota.name())
	<< "\n value: " << protect(nota.value())
	<< "\n flags: " << nota.flags()
	<< '\n';
	}
	return os << ")";
	}

File Metadata

Mime Type: text/x-diff
Expires: Sat, Feb 1, 9:23 AM (1 d, 8 h)
Storage Engine: local-disk
Storage Format: Raw Data
Storage Handle: 50/96/25bf9a90c68a719ce5df4784241f

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions