GpgFrontend/gpgme
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Initial checkin of gpgmepp sources

Browse Source 
Based on git.kde.org/pim/gpgmepp rev. 0e3ebc02

* lang/cpp/src/assuanresult.cpp,
 lang/cpp/src/assuanresult.h,
 lang/cpp/src/callbacks.cpp,
 lang/cpp/src/callbacks.h,
 lang/cpp/src/configuration.cpp,
 lang/cpp/src/configuration.h,
 lang/cpp/src/context.cpp,
 lang/cpp/src/context.h,
 lang/cpp/src/context_glib.cpp,
 lang/cpp/src/context_p.h,
 lang/cpp/src/context_qt.cpp,
 lang/cpp/src/context_vanilla.cpp,
 lang/cpp/src/data.cpp,
 lang/cpp/src/data.h,
 lang/cpp/src/data_p.h,
 lang/cpp/src/decryptionresult.cpp,
 lang/cpp/src/decryptionresult.h,
 lang/cpp/src/defaultassuantransaction.cpp,
 lang/cpp/src/defaultassuantransaction.h,
 lang/cpp/src/editinteractor.cpp,
 lang/cpp/src/editinteractor.h,
 lang/cpp/src/encryptionresult.cpp,
 lang/cpp/src/encryptionresult.h,
 lang/cpp/src/engineinfo.cpp,
 lang/cpp/src/engineinfo.h,
 lang/cpp/src/error.h,
 lang/cpp/src/eventloopinteractor.cpp,
 lang/cpp/src/eventloopinteractor.h,
 lang/cpp/src/exception.cpp,
 lang/cpp/src/exception.h,
 lang/cpp/src/global.h,
 lang/cpp/src/gpgadduserideditinteractor.cpp,
 lang/cpp/src/gpgadduserideditinteractor.h,
 lang/cpp/src/gpgagentgetinfoassuantransaction.cpp,
 lang/cpp/src/gpgagentgetinfoassuantransaction.h,
 lang/cpp/src/gpgmefw.h,
 lang/cpp/src/gpgmepp_export.h,
 lang/cpp/src/gpgsetexpirytimeeditinteractor.cpp,
 lang/cpp/src/gpgsetexpirytimeeditinteractor.h,
 lang/cpp/src/gpgsetownertrusteditinteractor.cpp,
 lang/cpp/src/gpgsetownertrusteditinteractor.h,
 lang/cpp/src/gpgsignkeyeditinteractor.cpp,
 lang/cpp/src/gpgsignkeyeditinteractor.h,
 lang/cpp/src/importresult.cpp,
 lang/cpp/src/importresult.h,
 lang/cpp/src/key.cpp,
 lang/cpp/src/key.h,
 lang/cpp/src/keygenerationresult.cpp,
 lang/cpp/src/keygenerationresult.h,
 lang/cpp/src/keylistresult.cpp,
 lang/cpp/src/keylistresult.h,
 lang/cpp/src/notation.h,
 lang/cpp/src/result.h,
 lang/cpp/src/result_p.h,
 lang/cpp/src/scdgetinfoassuantransaction.cpp,
 lang/cpp/src/scdgetinfoassuantransaction.h,
 lang/cpp/src/signingresult.cpp,
 lang/cpp/src/signingresult.h,
 lang/cpp/src/trustitem.cpp,
 lang/cpp/src/trustitem.h,
 lang/cpp/src/util.h,
 lang/cpp/src/verificationresult.cpp,
 lang/cpp/src/verificationresult.h,
 lang/cpp/src/vfsmountresult.cpp,
 lang/cpp/src/vfsmountresult.h,
 lang/cpp/src/interfaces/assuantransaction.h,
 lang/cpp/src/interfaces/dataprovider.h,
 lang/cpp/src/interfaces/passphraseprovider.h,
 lang/cpp/src/interfaces/progressprovider.h: New.
This commit is contained in:
Andre Heinecke 2016-02-22 18:28:08 +01:00
parent e79199468a
commit 0855a1296a
69 changed files with 12197 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

98
lang/cpp/src/assuanresult.cpp Normal file
View File

@ -0,0 +1,98 @@
/*
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 <config-gpgme++.h>
#include <assuanresult.h>
#include "result_p.h"
#include <gpgme.h>
#include <istream>
using namespace GpgME;
#ifdef HAVE_GPGME_ASSUAN_ENGINE
class AssuanResult::Private
{
public:
explicit Private(const gpgme_assuan_result_t r)
{
if (!r) {
return;
}
error = r->err;
}
gpgme_error_t error;
};
#endif
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;
#ifdef HAVE_GPGME_ASSUAN_ENGINE
if (!ctx) {
return;
}
gpgme_assuan_result_t res = gpgme_op_assuan_result(ctx);
if (!res) {
return;
}
d.reset(new Private(res));
#endif
}
make_standard_stuff(AssuanResult)
Error AssuanResult::assuanError() const
{
#ifdef HAVE_GPGME_ASSUAN_ENGINE
if (d) {
return Error(d->error);
}
#endif
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 << ')';
}

80
lang/cpp/src/assuanresult.h Normal file
View File

@ -0,0 +1,80 @@
/*
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 <boost/shared_ptr.hpp>
#include <vector>
#include <iosfwd>
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);
boost::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__

187
lang/cpp/src/callbacks.cpp Normal file
View File

@ -0,0 +1,187 @@
/*
callbacks.cpp - callback targets for internal use:
Copyright (C) 2003,2004 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 <config-gpgme++.h>
#include "callbacks.h"
#include "util.h"
#include <interfaces/progressprovider.h>
#include <interfaces/passphraseprovider.h>
#include <interfaces/dataprovider.h>
#include <error.h>
#include <gpgme.h>
#include <gpg-error.h>
#include <cassert>
#include <cerrno>
#include <cstring>
#include <unistd.h>
#include <stdlib.h>
#ifndef HAVE_GPGME_SSIZE_T
# define gpgme_ssize_t ssize_t
#endif
#ifndef HAVE_GPGME_OFF_T
# define gpgme_off_t off_t
#endif
static inline gpgme_error_t make_err_from_syserror()
{
#ifdef HAVE_GPGME_GPG_ERROR_WRAPPERS
return gpgme_error_from_syserror();
#else
return gpg_error_from_syserror();
#endif
}
using GpgME::ProgressProvider;
using GpgME::PassphraseProvider;
using GpgME::DataProvider;
void progress_callback(void *opaque, const char *what,
int type, int current, int total)
{
ProgressProvider *provider = static_cast<ProgressProvider *>(opaque);
if (provider) {
provider->showProgress(what, type, current, total);
}
}
/* To avoid that a compiler optimizes certain memset calls away, these
macros may be used instead. */
#define wipememory2(_ptr,_set,_len) do { \
volatile char *_vptr=(volatile char *)(_ptr); \
size_t _vlen=(_len); \
while(_vlen) { *_vptr=(_set); _vptr++; _vlen--; } \
} while(0)
#define wipememory(_ptr,_len) wipememory2(_ptr,0,_len)
gpgme_error_t passphrase_callback(void *opaque, const char *uid_hint, const char *desc,
int prev_was_bad, int fd)
{
PassphraseProvider *provider = static_cast<PassphraseProvider *>(opaque);
bool canceled = false;
gpgme_error_t err = GPG_ERR_NO_ERROR;
char *passphrase = provider ? provider->getPassphrase(uid_hint, desc, prev_was_bad, canceled) : 0 ;
if (canceled) {
err = make_error(GPG_ERR_CANCELED);
} else {
if (passphrase && *passphrase) {
size_t passphrase_length = std::strlen(passphrase);
size_t written = 0;
do {
#ifdef HAVE_GPGME_IO_READWRITE
ssize_t now_written = gpgme_io_write(fd, passphrase + written, passphrase_length - written);
#else
ssize_t now_written = write(fd, passphrase + written, passphrase_length - written);
#endif
if (now_written < 0) {
err = make_err_from_syserror();
break;
}
written += now_written;
} while (written < passphrase_length);
}
}
if (passphrase && *passphrase) {
wipememory(passphrase, std::strlen(passphrase));
}
free(passphrase);
#ifdef HAVE_GPGME_IO_READWRITE
gpgme_io_write(fd, "\n", 1);
#else
write(fd, "\n", 1);
#endif
return err;
}
static gpgme_ssize_t
data_read_callback(void *opaque, void *buf, size_t buflen)
{
DataProvider *provider = static_cast<DataProvider *>(opaque);
if (!provider) {
#ifdef HAVE_GPGME_GPG_ERROR_WRAPPERS
gpgme_err_set_errno(gpgme_err_code_to_errno(GPG_ERR_EINVAL));
#else
gpg_err_set_errno(gpgme_err_code_to_errno(GPG_ERR_EINVAL));
#endif
return -1;
}
return (gpgme_ssize_t)provider->read(buf, buflen);
}
static gpgme_ssize_t
data_write_callback(void *opaque, const void *buf, size_t buflen)
{
DataProvider *provider = static_cast<DataProvider *>(opaque);
if (!provider) {
#ifdef HAVE_GPGME_GPG_ERROR_WRAPPERS
gpgme_err_set_errno(gpgme_err_code_to_errno(GPG_ERR_EINVAL));
#else
gpg_err_set_errno(gpgme_err_code_to_errno(GPG_ERR_EINVAL));
#endif
return -1;
}
return (gpgme_ssize_t)provider->write(buf, buflen);
}
static gpgme_off_t
data_seek_callback(void *opaque, gpgme_off_t offset, int whence)
{
DataProvider *provider = static_cast<DataProvider *>(opaque);
if (!provider) {
#ifdef HAVE_GPGME_GPG_ERROR_WRAPPERS
gpgme_err_set_errno(gpgme_err_code_to_errno(GPG_ERR_EINVAL));
#else
gpg_err_set_errno(gpgme_err_code_to_errno(GPG_ERR_EINVAL));
#endif
return -1;
}
if (whence != SEEK_SET && whence != SEEK_CUR && whence != SEEK_END) {
#ifdef HAVE_GPGME_GPG_ERROR_WRAPPERS
gpgme_err_set_errno(gpgme_err_code_to_errno(GPG_ERR_EINVAL));
#else
gpg_err_set_errno(gpgme_err_code_to_errno(GPG_ERR_EINVAL));
#endif
return -1;
}
return provider->seek((off_t)offset, whence);
}
static void data_release_callback(void *opaque)
{
DataProvider *provider = static_cast<DataProvider *>(opaque);
if (provider) {
provider->release();
}
}
const gpgme_data_cbs GpgME::data_provider_callbacks = {
&data_read_callback,
&data_write_callback,
&data_seek_callback,
&data_release_callback
};

45
lang/cpp/src/callbacks.h Normal file
View File

@ -0,0 +1,45 @@
/*
callbacks.h - callback targets for internal use:
Copyright (C) 2003 Klarälvdalens Datakonsult AB
This file is part of GPGME++.
This is an internal header file, subject to change without
notice. DO NOT USE.
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_CALLBACKS_H__
#define __GPGMEPP_CALLBACKS_H__
#include <gpgme.h>
extern "C" {
void progress_callback(void *opaque, const char *what,
int type, int current, int total);
gpgme_error_t passphrase_callback(void *opaque, const char *uid_hint,
const char *desc, int prev_was_bad, int fd);
}
namespace GpgME
{
extern const gpgme_data_cbs data_provider_callbacks;
extern const gpgme_edit_cb_t edit_interactor_callback;
}
#endif // __GPGME_CALLBACKS_H__

1139
lang/cpp/src/configuration.cpp Normal file
View File

File diff suppressed because it is too large Load Diff

297
lang/cpp/src/configuration.h Normal file
View File

@ -0,0 +1,297 @@
/*
configuration.h - wraps gpgme configuration components
Copyright (C) 2010 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_CONFIGURATION_H__
#define __GPGMEPP_CONFIGURATION_H__
#include "global.h"
#include "gpgmefw.h"
#include <boost/shared_ptr.hpp>
#include <boost/weak_ptr.hpp>
#include <boost/type_traits/remove_pointer.hpp>
#if 0
#include <boost/variant.hpp>
#include <boost/optional.hpp>
#endif
#include <iosfwd>
#include <vector>
#include <string>
#include <algorithm>
namespace GpgME
{
namespace Configuration
{
typedef boost::shared_ptr< boost::remove_pointer<gpgme_conf_comp_t>::type > shared_gpgme_conf_comp_t;
typedef boost::weak_ptr< boost::remove_pointer<gpgme_conf_comp_t>::type > weak_gpgme_conf_comp_t;
class Argument;
class Option;
class Component;
enum Level {
Basic,
Advanced,
Expert,
Invisible,
Internal,
NumLevels
};
enum Type {
NoType,
StringType,
IntegerType,
UnsignedIntegerType,
FilenameType = 32,
LdapServerType,
KeyFingerprintType,
PublicKeyType,
SecretKeyType,
AliasListType,
MaxType
};
enum Flag {
Group = (1 << 0),
Optional = (1 << 1),
List = (1 << 2),
Runtime = (1 << 3),
Default = (1 << 4),
DefaultDescription = (1 << 5),
NoArgumentDescription = (1 << 6),
NoChange = (1 << 7),
LastFlag = NoChange
};
//
// class Component
//
class GPGMEPP_EXPORT Component
{
public:
Component() : comp() {}
explicit Component(const shared_gpgme_conf_comp_t &comp)
: comp(comp) {}
// copy ctor is ok
const Component &operator=(const Component &other)
{
if (this != &other) {
Component(other).swap(*this);
}
return *this;
}
void swap(Component &other)
{
using std::swap;
swap(this->comp, other.comp);
}
bool isNull() const
{
return !comp;
}
static std::vector<Component> load(Error &err);
Error save() const;
const char *name() const;
const char *description() const;
const char *programName() const;
Option option(unsigned int index) const;
Option option(const char *name) const;
unsigned int numOptions() const;
std::vector<Option> options() const;
GPGMEPP_MAKE_SAFE_BOOL_OPERATOR(!isNull())
private:
shared_gpgme_conf_comp_t comp;
};
//
// class Option
//
class GPGMEPP_EXPORT Option
{
public:
Option() : comp(), opt(0) {}
Option(const shared_gpgme_conf_comp_t &comp, gpgme_conf_opt_t opt)
: comp(comp), opt(opt) {}
const Option &operator=(const Option &other)
{
if (this != &other) {
Option(other).swap(*this);
}
return *this;
}
void swap(Option &other)
{
using std::swap;
swap(this->comp, other.comp);
swap(this->opt, other.opt);
}
bool isNull() const
{
return comp.expired() || !opt;
}
Component parent() const;
unsigned int flags() const;
Level level() const;
const char *name() const;
const char *description() const;
const char *argumentName() const;
Type type() const;
Type alternateType() const;
Argument defaultValue() const;
const char *defaultDescription() const;
Argument noArgumentValue() const;
const char *noArgumentDescription() const;
/*! The value that is in the config file (or null, if it's not set). */
Argument activeValue() const;
/*! The value that is in this object, ie. either activeValue(), newValue(), or defaultValue() */
Argument currentValue() const;
Argument newValue() const;
bool set() const;
bool dirty() const;
Error setNewValue(const Argument &argument);
Error resetToDefaultValue();
Error resetToActiveValue();
Argument createNoneArgument(bool set) const;
Argument createStringArgument(const char *value) const;
Argument createStringArgument(const std::string &value) const;
Argument createIntArgument(int value) const;
Argument createUIntArgument(unsigned int value) const;
Argument createNoneListArgument(unsigned int count) const;
Argument createStringListArgument(const std::vector<const char *> &value) const;
Argument createStringListArgument(const std::vector<std::string> &value) const;
Argument createIntListArgument(const std::vector<int> &values) const;
Argument createUIntListArgument(const std::vector<unsigned int> &values) const;
GPGMEPP_MAKE_SAFE_BOOL_OPERATOR(!isNull())
private:
weak_gpgme_conf_comp_t comp;
gpgme_conf_opt_t opt;
};
//
// class Argument
//
class GPGMEPP_EXPORT Argument
{
friend class ::GpgME::Configuration::Option;
Argument(const shared_gpgme_conf_comp_t &comp, gpgme_conf_opt_t opt, gpgme_conf_arg_t arg, bool owns);
public:
Argument() : comp(), opt(0), arg(0) {}
//Argument( const shared_gpgme_conf_comp_t & comp, gpgme_conf_opt_t opt, gpgme_conf_arg_t arg );
Argument(const Argument &other);
~Argument();
const Argument &operator=(const Argument &other)
{
if (this != &other) {
Argument(other).swap(*this);
}
return *this;
}
void swap(Argument &other)
{
using std::swap;
swap(this->comp, other.comp);
swap(this->opt, other.opt);
swap(this->arg, other.arg);
}
bool isNull() const
{
return comp.expired() || !opt || !arg;
}
Option parent() const;
unsigned int numElements() const;
bool boolValue() const;
const char *stringValue(unsigned int index = 0) const;
int intValue(unsigned int index = 0) const;
unsigned int uintValue(unsigned int index = 0) const;
unsigned int numberOfTimesSet() const;
std::vector<const char *> stringValues() const;
std::vector<int> intValues() const;
std::vector<unsigned int> uintValues() const;
GPGMEPP_MAKE_SAFE_BOOL_OPERATOR(!isNull())
private:
weak_gpgme_conf_comp_t comp;
gpgme_conf_opt_t opt;
gpgme_conf_arg_t arg;
};
GPGMEPP_EXPORT std::ostream &operator<<(std::ostream &os, Level level);
GPGMEPP_EXPORT std::ostream &operator<<(std::ostream &os, Type type);
GPGMEPP_EXPORT std::ostream &operator<<(std::ostream &os, Flag flag);
GPGMEPP_EXPORT std::ostream &operator<<(std::ostream &os, const Component &component);
GPGMEPP_EXPORT std::ostream &operator<<(std::ostream &os, const Option &option);
GPGMEPP_EXPORT std::ostream &operator<<(std::ostream &os, const Argument &argument);
} // namespace Configuration
} // namespace GpgME
GPGMEPP_MAKE_STD_SWAP_SPECIALIZATION(Configuration::Component)
GPGMEPP_MAKE_STD_SWAP_SPECIALIZATION(Configuration::Option)
GPGMEPP_MAKE_STD_SWAP_SPECIALIZATION(Configuration::Argument)
#endif // __GPGMEPP_CONFIGURATION_H__

1707
lang/cpp/src/context.cpp Normal file
View File

File diff suppressed because it is too large Load Diff

353
lang/cpp/src/context.h Normal file
View File

@ -0,0 +1,353 @@
/*
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::auto_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;
void setPassphraseProvider(PassphraseProvider *provider);
PassphraseProvider *passphraseProvider() const;
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);
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::auto_ptr<EditInteractor> function, Data &out);
GpgME::Error startEditing(const Key &key, std::auto_ptr<EditInteractor> function, Data &out);
EditInteractor *lastEditInteractor() const;
std::auto_ptr<EditInteractor> takeLastEditInteractor();
//
// SmartCard Editing
//
GpgME::Error cardEdit(const Key &key, std::auto_ptr<EditInteractor> function, Data &out);
GpgME::Error startCardEditing(const Key &key, std::auto_ptr<EditInteractor> function, Data &out);
EditInteractor *lastCardEditInteractor() const;
std::auto_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::auto_ptr<AssuanTransaction> transaction);
AssuanResult assuanTransact(const char *command);
GpgME::Error startAssuanTransaction(const char *command, std::auto_ptr<AssuanTransaction> transaction);
GpgME::Error startAssuanTransaction(const char *command);
AssuanResult assuanResult() const;
AssuanTransaction *lastAssuanTransaction() const;
std::auto_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 };
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:
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__

44
lang/cpp/src/context_glib.cpp Normal file
View File

@ -0,0 +1,44 @@
/*
context_glib.cpp - wraps a gpgme key context, gpgme-glib-specific functions
Copyright (C) 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 <config-gpgme++.h>
#include <global.h>
#ifdef HAVE_GPGME_GET_FDPTR
extern "C" GIOChannel *gpgme_get_fdptr(int);
#endif
GIOChannel *GpgME::getGIOChannel(int fd)
{
#ifdef HAVE_GPGME_GET_FDPTR
return gpgme_get_fdptr(fd);
#else
(void)fd;
return 0;
#endif
}
QIODevice *GpgME::getQIODevice(int fd)
{
return 0;
}

84
lang/cpp/src/context_p.h Normal file
View File

@ -0,0 +1,84 @@
/*
context_p.h - wraps a gpgme context (private part)
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_P_H__
#define __GPGMEPP_CONTEXT_P_H__
#include <context.h>
#include <data.h>
#include <gpgme.h>
namespace GpgME
{
class Context::Private
{
public:
enum Operation {
None = 0,
Encrypt = 0x001,
Decrypt = 0x002,
Sign = 0x004,
Verify = 0x008,
DecryptAndVerify = Decrypt | Verify,
SignAndEncrypt = Sign | Encrypt,
Import = 0x010,
Export = 0x020, // no gpgme_export_result_t, but nevertheless...
Delete = 0x040, // no gpgme_delete_result_t, but nevertheless...
KeyGen = 0x080,
KeyList = 0x100,
TrustList = 0x200, // no gpgme_trustlist_result_t, but nevertheless...
Edit = 0x400, // no gpgme_edit_result_t, but nevertheless...
CardEdit = 0x800, // no gpgme_card_edit_result_t, but nevertheless...
GetAuditLog = 0x1000, // no gpgme_getauditlog_result_t, but nevertheless...
AssuanTransact = 0x2000,
Passwd = 0x4000, // no gpgme_passwd_result_t, but nevertheless...
CreateVFS = 0x4000,
MountVFS = 0x8000,
EndMarker
};
Private(gpgme_ctx_t c = 0);
~Private();
gpgme_ctx_t ctx;
gpgme_io_cbs *iocbs;
Operation lastop;
gpgme_error_t lasterr;
Data lastAssuanInquireData;
std::auto_ptr<AssuanTransaction> lastAssuanTransaction;
std::auto_ptr<EditInteractor> lastEditInteractor, lastCardEditInteractor;
};
} // namespace GpgME
#endif // __GPGMEPP_CONTEXT_P_H__

44
lang/cpp/src/context_qt.cpp Normal file
View File

@ -0,0 +1,44 @@
/*
context_qt.cpp - wraps a gpgme key context, gpgme-qt-specific functions
Copyright (C) 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 <config-gpgme++.h>
#include <global.h>
#ifdef HAVE_GPGME_GET_FDPTR
extern "C" QIODevice *gpgme_get_fdptr(int);
#endif
GIOChannel *GpgME::getGIOChannel(int)
{
return 0;
}
QIODevice *GpgME::getQIODevice(int fd)
{
#ifdef HAVE_GPGME_GET_FDPTR
return gpgme_get_fdptr(fd);
#else
(void)fd;
return 0;
#endif
}

35
lang/cpp/src/context_vanilla.cpp Normal file
View File

@ -0,0 +1,35 @@
/*
context_vanilla.cpp - wraps a gpgme key context, gpgme (vanilla)-specific functions
Copyright (C) 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 <config-gpgme++.h>
#include <global.h>
GIOChannel *GpgME::getGIOChannel(int)
{
return 0;
}
QIODevice *GpgME::getQIODevice(int)
{
return 0;
}

199
lang/cpp/src/data.cpp Normal file
View File

@ -0,0 +1,199 @@
/*
data.cpp - wraps a gpgme data object
Copyright (C) 2003 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 <config-gpgme++.h>
#include "data_p.h"
#include <error.h>
#include <interfaces/dataprovider.h>
#include <gpgme.h>
#ifndef NDEBUG
#include <iostream>
#endif
GpgME::Data::Private::~Private()
{
if (data) {
gpgme_data_release(data);
}
}
const GpgME::Data::Null GpgME::Data::null;
GpgME::Data::Data()
{
gpgme_data_t data;
const gpgme_error_t e = gpgme_data_new(&data);
d.reset(new Private(e ? 0 : data));
}
GpgME::Data::Data(const Null &)
: d(new Private(0))
{
}
GpgME::Data::Data(gpgme_data_t data)
: d(new Private(data))
{
}
GpgME::Data::Data(const char *buffer, size_t size, bool copy)
{
gpgme_data_t data;
const gpgme_error_t e = gpgme_data_new_from_mem(&data, buffer, size, int(copy));
d.reset(new Private(e ? 0 : data));
}
GpgME::Data::Data(const char *filename)
{
gpgme_data_t data;
const gpgme_error_t e = gpgme_data_new(&data);
d.reset(new Private(e ? 0 : data));
if (!e) {
setFileName(filename);
}
}
GpgME::Data::Data(const char *filename, off_t offset, size_t length)
{
gpgme_data_t data;
const gpgme_error_t e = gpgme_data_new_from_filepart(&data, filename, 0, offset, length);
d.reset(new Private(e ? 0 : data));
}
GpgME::Data::Data(FILE *fp)
{
gpgme_data_t data;
const gpgme_error_t e = gpgme_data_new_from_stream(&data, fp);
d.reset(new Private(e ? 0 : data));
}
GpgME::Data::Data(FILE *fp, off_t offset, size_t length)
{
gpgme_data_t data;
const gpgme_error_t e = gpgme_data_new_from_filepart(&data, 0, fp, offset, length);
d.reset(new Private(e ? 0 : data));
}
GpgME::Data::Data(int fd)
{
gpgme_data_t data;
const gpgme_error_t e = gpgme_data_new_from_fd(&data, fd);
d.reset(new Private(e ? 0 : data));
}
GpgME::Data::Data(DataProvider *dp)
{
d.reset(new Private);
if (!dp) {
return;
}
if (!dp->isSupported(DataProvider::Read)) {
d->cbs.read = 0;
}
if (!dp->isSupported(DataProvider::Write)) {
d->cbs.write = 0;
}
if (!dp->isSupported(DataProvider::Seek)) {
d->cbs.seek = 0;
}
if (!dp->isSupported(DataProvider::Release)) {
d->cbs.release = 0;
}
const gpgme_error_t e = gpgme_data_new_from_cbs(&d->data, &d->cbs, dp);
if (e) {
d->data = 0;
}
#ifndef NDEBUG
//std::cerr << "GpgME::Data(): DataProvider supports: "
// << ( d->cbs.read ? "read" : "no read" ) << ", "
// << ( d->cbs.write ? "write" : "no write" ) << ", "
// << ( d->cbs.seek ? "seek" : "no seek" ) << ", "
// << ( d->cbs.release ? "release" : "no release" ) << std::endl;
#endif
}
bool GpgME::Data::isNull() const
{
return !d || !d->data;
}
GpgME::Data::Encoding GpgME::Data::encoding() const
{
switch (gpgme_data_get_encoding(d->data)) {
case GPGME_DATA_ENCODING_NONE: return AutoEncoding;
case GPGME_DATA_ENCODING_BINARY: return BinaryEncoding;
case GPGME_DATA_ENCODING_BASE64: return Base64Encoding;
case GPGME_DATA_ENCODING_ARMOR: return ArmorEncoding;
}
return AutoEncoding;
}
GpgME::Error GpgME::Data::setEncoding(Encoding enc)
{
gpgme_data_encoding_t ge = GPGME_DATA_ENCODING_NONE;
switch (enc) {
case AutoEncoding: ge = GPGME_DATA_ENCODING_NONE; break;
case BinaryEncoding: ge = GPGME_DATA_ENCODING_BINARY; break;
case Base64Encoding: ge = GPGME_DATA_ENCODING_BASE64; break;
case ArmorEncoding: ge = GPGME_DATA_ENCODING_ARMOR; break;
}
return Error(gpgme_data_set_encoding(d->data, ge));
}
char *GpgME::Data::fileName() const
{
#ifdef HAVE_GPGME_DATA_SET_FILE_NAME
return gpgme_data_get_file_name(d->data);
#else
return 0;
#endif
}
GpgME::Error GpgME::Data::setFileName(const char *name)
{
#ifdef HAVE_GPGME_DATA_SET_FILE_NAME
return Error(gpgme_data_set_file_name(d->data, name));
#else
(void)name;
return Error();
#endif
}
ssize_t GpgME::Data::read(void *buffer, size_t length)
{
return gpgme_data_read(d->data, buffer, length);
}
ssize_t GpgME::Data::write(const void *buffer, size_t length)
{
return gpgme_data_write(d->data, buffer, length);
}
off_t GpgME::Data::seek(off_t offset, int whence)
{
return gpgme_data_seek(d->data, offset, whence);
}

110
lang/cpp/src/data.h Normal file
View File

@ -0,0 +1,110 @@
/*
data.h - wraps a gpgme data object
Copyright (C) 2003,2004 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.
*/
#ifndef __GPGMEPP_DATA_H__
#define __GPGMEPP_DATA_H__
#include "global.h"
#include <boost/shared_ptr.hpp>
#include <sys/types.h> // for size_t, off_t
#include <cstdio> // FILE
#include <algorithm>
namespace GpgME
{
class DataProvider;
class Error;
class GPGMEPP_EXPORT Data
{
struct Null {
Null() {}
};
public:
/* implicit */ Data(const Null &);
Data();
explicit Data(gpgme_data_t data);
// Memory-Based Data Buffers:
Data(const char *buffer, size_t size, bool copy = true);
explicit Data(const char *filename);
Data(const char *filename, off_t offset, size_t length);
Data(std::FILE *fp, off_t offset, size_t length);
// File-Based Data Buffers:
explicit Data(std::FILE *fp);
explicit Data(int fd);
// Callback-Based Data Buffers:
explicit Data(DataProvider *provider);
static const Null null;
const Data &operator=(Data other)
{
swap(other);
return *this;
}
void swap(Data &other)
{
using std::swap;
swap(this->d, other.d);
}
bool isNull() const;
enum Encoding {
AutoEncoding,
BinaryEncoding,
Base64Encoding,
ArmorEncoding
};
Encoding encoding() const;
Error setEncoding(Encoding encoding);
char *fileName() const;
Error setFileName(const char *name);
ssize_t read(void *buffer, size_t length);
ssize_t write(const void *buffer, size_t length);
off_t seek(off_t offset, int whence);
class Private;
Private *impl()
{
return d.get();
}
const Private *impl() const
{
return d.get();
}
private:
boost::shared_ptr<Private> d;
};
}
GPGMEPP_MAKE_STD_SWAP_SPECIALIZATION(Data)
#endif // __GPGMEPP_DATA_H__

40
lang/cpp/src/data_p.h Normal file
View File

@ -0,0 +1,40 @@
/*
data_p.h - wraps a gpgme data object, private part -*- c++ -*-
Copyright (C) 2003,2004 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.
*/
#ifndef __GPGMEPP_DATA_P_H__
#define __GPGMEPP_DATA_P_H__
#include <data.h>
#include "callbacks.h"
class GpgME::Data::Private
{
public:
explicit Private(gpgme_data_t d = 0)
: data(d), cbs(data_provider_callbacks) {}
~Private();
gpgme_data_t data;
gpgme_data_cbs cbs;
};
#endif // __GPGMEPP_DATA_P_H__

276
lang/cpp/src/decryptionresult.cpp Normal file
View File

@ -0,0 +1,276 @@
/*
decryptionresult.cpp - wraps a gpgme keygen result
Copyright (C) 2004 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 <config-gpgme++.h>
#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);
}
#ifdef HAVE_GPGME_DECRYPT_RESULT_T_FILE_NAME
if (res.file_name) {
res.file_name = strdup(res.file_name);
}
#endif
#ifdef HAVE_GPGME_DECRYPT_RESULT_T_RECIPIENTS
//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;
#endif
}
~Private()
{
if (res.unsupported_algorithm) {
std::free(res.unsupported_algorithm);
}
res.unsupported_algorithm = 0;
#ifdef HAVE_GPGME_DECRYPT_RESULT_T_FILE_NAME
if (res.file_name) {
std::free(res.file_name);
}
res.file_name = 0;
#endif
}
_gpgme_op_decrypt_result res;
#ifdef HAVE_GPGME_DECRYPT_RESULT_T_RECIPIENTS
std::vector<_gpgme_recipient> recipients;
#endif
};
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;
}
const char *GpgME::DecryptionResult::fileName() const
{
#ifdef HAVE_GPGME_DECRYPT_RESULT_T_FILE_NAME
return d ? d->res.file_name : 0 ;
#else
return 0;
#endif
}
unsigned int GpgME::DecryptionResult::numRecipients() const
{
#ifdef HAVE_GPGME_DECRYPT_RESULT_T_RECIPIENTS
return d ? d->recipients.size() : 0 ;
#else
return 0;
#endif
}
GpgME::DecryptionResult::Recipient GpgME::DecryptionResult::recipient(unsigned int idx) const
{
#ifdef HAVE_GPGME_DECRYPT_RESULT_T_RECIPIENTS
if (d && idx < d->recipients.size()) {
return Recipient(&d->recipients[idx]);
}
#endif
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;
#ifdef HAVE_GPGME_DECRYPT_RESULT_T_RECIPIENTS
if (d) {
result.reserve(d->recipients.size());
std::transform(d->recipients.begin(), d->recipients.end(),
std::back_inserter(result),
make_recipient());
}
#endif
return result;
}
#ifdef HAVE_GPGME_DECRYPT_RESULT_T_RECIPIENTS
class GpgME::DecryptionResult::Recipient::Private : public _gpgme_recipient
{
public:
Private(gpgme_recipient_t reci) : _gpgme_recipient(*reci) {}
};
#endif
GpgME::DecryptionResult::Recipient::Recipient()
: d()
{
}
GpgME::DecryptionResult::Recipient::Recipient(gpgme_recipient_t r)
: d()
{
#ifdef HAVE_GPGME_DECRYPT_RESULT_T_RECIPIENTS
if (r) {
d.reset(new Private(r));
}
#endif
}
bool GpgME::DecryptionResult::Recipient::isNull() const
{
return !d;
}
const char *GpgME::DecryptionResult::Recipient::keyID() const
{
#ifdef HAVE_GPGME_DECRYPT_RESULT_T_RECIPIENTS
//_keyid is internal API, but the public keyid is invalid after copying (see above)
if (d) {
return d->_keyid;
}
#endif
return 0;
}
const char *GpgME::DecryptionResult::Recipient::shortKeyID() const
{
#ifdef HAVE_GPGME_DECRYPT_RESULT_T_RECIPIENTS
//_keyid is internal API, but the public keyid is invalid after copying (see above)
if (d) {
return d->_keyid + 8;
}
#endif
return 0;
}
unsigned int GpgME::DecryptionResult::Recipient::publicKeyAlgorithm() const
{
#ifdef HAVE_GPGME_DECRYPT_RESULT_T_RECIPIENTS
if (d) {
return d->pubkey_algo;
}
#endif
return 0;
}
const char *GpgME::DecryptionResult::Recipient::publicKeyAlgorithmAsString() const
{
#ifdef HAVE_GPGME_DECRYPT_RESULT_T_RECIPIENTS
if (d) {
return gpgme_pubkey_algo_name(d->pubkey_algo);
}
#endif
return 0;
}
GpgME::Error GpgME::DecryptionResult::Recipient::status() const
{
#ifdef HAVE_GPGME_DECRYPT_RESULT_T_RECIPIENTS
if (d) {
return Error(d->status);
}
#endif
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 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 << ')';
}

131
lang/cpp/src/decryptionresult.h Normal file
View File

@ -0,0 +1,131 @@
/*
decryptionresult.h - wraps a gpgme keygen result
Copyright (C) 2004 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.
*/
#ifndef __GPGMEPP_DECRYPTIONRESULT_H__
#define __GPGMEPP_DECRYPTIONRESULT_H__
#include "gpgmefw.h"
#include "result.h"
#include "gpgmepp_export.h"
#include <boost/shared_ptr.hpp>
#include <vector>
#include <algorithm>
#include <iosfwd>
namespace GpgME
{
class Error;
class GPGMEPP_EXPORT DecryptionResult : public Result
{
public:
DecryptionResult();
DecryptionResult(gpgme_ctx_t ctx, int error);
DecryptionResult(gpgme_ctx_t ctx, const Error &err);
explicit DecryptionResult(const Error &err);
const DecryptionResult &operator=(DecryptionResult other)
{
swap(other);
return *this;
}
void swap(DecryptionResult &other)
{
Result::swap(other);
using std::swap;
swap(this->d, other.d);
}
bool isNull() const;
GPGMEPP_DEPRECATED const char *unsupportedAlgortihm() const
{
return unsupportedAlgorithm();
}
const char *unsupportedAlgorithm() const;
GPGMEPP_DEPRECATED bool wrongKeyUsage() const
{
return isWrongKeyUsage();
}
bool isWrongKeyUsage() const;
const char *fileName() const;
class Recipient;
unsigned int numRecipients() const;
Recipient recipient(unsigned int idx) const;
std::vector<Recipient> recipients() const;
private:
class Private;
void init(gpgme_ctx_t ctx);
boost::shared_ptr<Private> d;
};
GPGMEPP_EXPORT std::ostream &operator<<(std::ostream &os, const DecryptionResult &result);
class GPGMEPP_EXPORT DecryptionResult::Recipient
{
public:
Recipient();
explicit Recipient(gpgme_recipient_t reci);
const Recipient &operator=(Recipient other)
{
swap(other);
return *this;
}
void swap(Recipient &other)
{
using std::swap;
swap(this->d, other.d);
}
bool isNull() const;
const char *keyID() const;
const char *shortKeyID() const;
unsigned int publicKeyAlgorithm() const;
const char *publicKeyAlgorithmAsString() const;
Error status() const;
private:
class Private;
boost::shared_ptr<Private> d;
};
GPGMEPP_EXPORT std::ostream &operator<<(std::ostream &os, const DecryptionResult::Recipient &reci);
}
GPGMEPP_MAKE_STD_SWAP_SPECIALIZATION(DecryptionResult)
#endif // __GPGMEPP_DECRYPTIONRESULT_H__

81
lang/cpp/src/defaultassuantransaction.cpp Normal file
View File

@ -0,0 +1,81 @@
/*
defaultassuantransaction.cpp - default Assuan Transaction that just stores data and status lines
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 <config-gpgme++.h>
#include "defaultassuantransaction.h"
#include "error.h"
#include "data.h"
#include <sstream>
using namespace GpgME;
using namespace boost;
DefaultAssuanTransaction::DefaultAssuanTransaction()
: AssuanTransaction(),
m_status(),
m_data()
{
}
DefaultAssuanTransaction::~DefaultAssuanTransaction() {}
Error DefaultAssuanTransaction::data(const char *data, size_t len)
{
m_data.append(data, len);
return Error();
}
Data DefaultAssuanTransaction::inquire(const char *name, const char *args, Error &err)
{
(void)name; (void)args; (void)err;
return Data::null;
}
Error DefaultAssuanTransaction::status(const char *status, const char *args)
{
m_status.push_back(std::pair<std::string, std::string>(status, args));
return Error();
}
std::vector<std::string> DefaultAssuanTransaction::statusLine(const char *tag) const
{
std::vector<std::string> result;
for (std::vector< std::pair<std::string, std::string> >::const_iterator it = m_status.begin(), end = m_status.end() ; it != end ; ++it) {
if (it->first == tag) {
result.push_back(it->second);
}
}
return result;
}
std::string DefaultAssuanTransaction::firstStatusLine(const char *tag) const
{
for (std::vector< std::pair<std::string, std::string> >::const_iterator it = m_status.begin(), end = m_status.end() ; it != end ; ++it) {
if (it->first == tag) {
return it->second;
}
}
return std::string();
}

65
lang/cpp/src/defaultassuantransaction.h Normal file
View File

@ -0,0 +1,65 @@
/*
defaultassuantransaction.h - default Assuan Transaction that just stores data and status lines
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.
*/
#ifndef __GPGMEPP_DEFAULTASSUANTRANSACTION_H__
#define __GPGMEPP_DEFAULTASSUANTRANSACTION_H__
#include <interfaces/assuantransaction.h>
#include <string>
#include <vector>
#include <utility>
namespace GpgME
{
class GPGMEPP_EXPORT DefaultAssuanTransaction : public AssuanTransaction
{
public:
explicit DefaultAssuanTransaction();
~DefaultAssuanTransaction();
const std::vector< std::pair<std::string, std::string> > &statusLines() const
{
return m_status;
}
std::vector<std::string> statusLine(const char *tag) const;
std::string firstStatusLine(const char *tag) const;
const std::string &data() const
{
return m_data;
}
private:
/* reimp */ Error data(const char *data, size_t datalen);
/* reimp */ Data inquire(const char *name, const char *args, Error &err);
/* reimp */ Error status(const char *status, const char *args);
private:
std::vector< std::pair<std::string, std::string> > m_status;
std::string m_data;
};
} // namespace GpgME
#endif // __GPGMEPP_DEFAULTASSUANTRANSACTION_H__

364
lang/cpp/src/editinteractor.cpp Normal file
View File

@ -0,0 +1,364 @@
/*
editinteractor.cpp - Interface for edit interactors
Copyright (C) 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 <config-gpgme++.h>
#include "editinteractor.h"
#include "callbacks.h"
#include "error.h"
#ifdef HAVE_GPGME_GPG_ERROR_WRAPPERS
#include <gpgme.h>
#else
#include <gpg-error.h>
#endif
#ifdef _WIN32
# include <io.h>
#include <windows.h>
#else
# include <unistd.h>
#endif
#include <cerrno>
#include <cstring>
using namespace GpgME;
static const char *status_to_string(unsigned int status);
static Error status_to_error(unsigned int status);
class EditInteractor::Private
{
friend class ::GpgME::EditInteractor;
friend class ::GpgME::CallbackHelper;
EditInteractor *const q;
public:
explicit Private(EditInteractor *qq);
~Private();
private:
unsigned int state;
Error error;
std::FILE *debug;
};
class GpgME::CallbackHelper
{
private:
static int writeAll(int fd, const void *buf, size_t count)
{
size_t toWrite = count;
while (toWrite > 0) {
#ifdef HAVE_GPGME_IO_READWRITE
const int n = gpgme_io_write(fd, buf, toWrite);
#else
# ifdef Q_OS_WIN
DWORD n;
if (!WriteFile((HANDLE)fd, buf, toWrite, &n, NULL)) {
return -1;
}
# else
const int n = write(fd, buf, toWrite);
# endif
#endif
if (n < 0) {
return n;
}
toWrite -= n;
}
return count;
}
public:
static int edit_interactor_callback_impl(void *opaque, gpgme_status_code_t status, const char *args, int fd)
{
EditInteractor::Private *ei = (EditInteractor::Private *)opaque;
Error err = status_to_error(status);
if (!err) {
// advance to next state based on input:
const unsigned int oldState = ei->state;
ei->state = ei->q->nextState(status, args, err);
if (ei->debug) {
std::fprintf(ei->debug, "EditInteractor: %u -> nextState( %s, %s ) -> %u\n",
oldState, status_to_string(status), args ? args : "<null>", ei->state);
}
if (err) {
ei->state = oldState;
goto error;
}
if (ei->state != oldState &&
// if there was an error from before, we stop here (### this looks weird, can this happen at all?)
ei->error.code() == GPG_ERR_NO_ERROR) {
// successful state change -> call action
if (const char *const result = ei->q->action(err)) {
if (err) {
goto error;
}
if (ei->debug) {
std::fprintf(ei->debug, "EditInteractor: action result \"%s\"\n", result);
}
// if there's a result, write it:
if (*result) {
#ifdef HAVE_GPGME_GPG_ERROR_WRAPPERS
gpgme_err_set_errno(0);
#else
gpg_err_set_errno(0);
#endif
const ssize_t len = std::strlen(result);
if (writeAll(fd, result, len) != len) {
err = Error::fromSystemError();
if (ei->debug) {
std::fprintf(ei->debug, "EditInteractor: Could not write to fd %d (%s)\n", fd, err.asString());
}
goto error;
}
}
#ifdef HAVE_GPGME_GPG_ERROR_WRAPPERS
gpgme_err_set_errno(0);
#else
gpg_err_set_errno(0);
#endif
if (writeAll(fd, "\n", 1) != 1) {
err = Error::fromSystemError();
if (ei->debug) {
std::fprintf(ei->debug, "EditInteractor: Could not write to fd %d (%s)\n", fd, err.asString());
}
goto error;
}
} else {
if (err) {
goto error;
}
if (ei->debug) {
std::fprintf(ei->debug, "EditInteractor: no action result\n");
}
}
} else {
if (ei->debug) {
std::fprintf(ei->debug, "EditInteractor: no action executed\n");
}
}
}
error:
if (err) {
ei->error = err;
ei->state = EditInteractor::ErrorState;
}
if (ei->debug) {
std::fprintf(ei->debug, "EditInteractor: error now %u (%s)\n",
ei->error.encodedError(), gpgme_strerror(ei->error.encodedError()));
}
return ei->error.encodedError();
}
};
static gpgme_error_t edit_interactor_callback(void *opaque, gpgme_status_code_t status, const char *args, int fd)
{
return CallbackHelper::edit_interactor_callback_impl(opaque, status, args, fd);
}
const gpgme_edit_cb_t GpgME::edit_interactor_callback = ::edit_interactor_callback;
EditInteractor::Private::Private(EditInteractor *qq)
: q(qq),
state(StartState),
error(),
debug(0)
{
}
EditInteractor::Private::~Private() {}
EditInteractor::EditInteractor()
: d(new Private(this))
{
}
EditInteractor::~EditInteractor()
{
delete d;
}
unsigned int EditInteractor::state() const
{
return d->state;
}
Error EditInteractor::lastError() const
{
return d->error;
}
bool EditInteractor::needsNoResponse(unsigned int status) const
{
switch (status) {
case GPGME_STATUS_EOF:
case GPGME_STATUS_GOT_IT:
case GPGME_STATUS_NEED_PASSPHRASE:
case GPGME_STATUS_NEED_PASSPHRASE_SYM:
case GPGME_STATUS_GOOD_PASSPHRASE:
case GPGME_STATUS_BAD_PASSPHRASE:
case GPGME_STATUS_USERID_HINT:
case GPGME_STATUS_SIGEXPIRED:
case GPGME_STATUS_KEYEXPIRED:
return true;
default:
return false;
}
}
// static
Error status_to_error(unsigned int status)
{
switch (status) {
case GPGME_STATUS_MISSING_PASSPHRASE:
return Error::fromCode(GPG_ERR_NO_PASSPHRASE);
case GPGME_STATUS_ALREADY_SIGNED:
return Error::fromCode(GPG_ERR_ALREADY_SIGNED);
case GPGME_STATUS_KEYEXPIRED:
return Error::fromCode(GPG_ERR_CERT_EXPIRED);
case GPGME_STATUS_SIGEXPIRED:
return Error::fromCode(GPG_ERR_SIG_EXPIRED);
}
return Error();
}
void EditInteractor::setDebugChannel(std::FILE *debug)
{
d->debug = debug;
}
static const char *const status_strings[] = {
"EOF",
/* mkstatus processing starts here */
"ENTER",
"LEAVE",
"ABORT",
"GOODSIG",
"BADSIG",
"ERRSIG",
"BADARMOR",
"RSA_OR_IDEA",
"KEYEXPIRED",
"KEYREVOKED",
"TRUST_UNDEFINED",
"TRUST_NEVER",
"TRUST_MARGINAL",
"TRUST_FULLY",
"TRUST_ULTIMATE",
"SHM_INFO",
"SHM_GET",
"SHM_GET_BOOL",
"SHM_GET_HIDDEN",
"NEED_PASSPHRASE",
"VALIDSIG",
"SIG_ID",
"ENC_TO",
"NODATA",
"BAD_PASSPHRASE",
"NO_PUBKEY",
"NO_SECKEY",
"NEED_PASSPHRASE_SYM",
"DECRYPTION_FAILED",
"DECRYPTION_OKAY",
"MISSING_PASSPHRASE",
"GOOD_PASSPHRASE",
"GOODMDC",
"BADMDC",
"ERRMDC",
"IMPORTED",
"IMPORT_OK",
"IMPORT_PROBLEM",
"IMPORT_RES",
"FILE_START",
"FILE_DONE",
"FILE_ERROR",
"BEGIN_DECRYPTION",
"END_DECRYPTION",
"BEGIN_ENCRYPTION",
"END_ENCRYPTION",
"DELETE_PROBLEM",
"GET_BOOL",
"GET_LINE",
"GET_HIDDEN",
"GOT_IT",
"PROGRESS",
"SIG_CREATED",
"SESSION_KEY",
"NOTATION_NAME",
"NOTATION_DATA",
"POLICY_URL",
"BEGIN_STREAM",
"END_STREAM",
"KEY_CREATED",
"USERID_HINT",
"UNEXPECTED",
"INV_RECP",
"NO_RECP",
"ALREADY_SIGNED",
"SIGEXPIRED",
"EXPSIG",
"EXPKEYSIG",
"TRUNCATED",
"ERROR",
"NEWSIG",
"REVKEYSIG",
"SIG_SUBPACKET",
"NEED_PASSPHRASE_PIN",
"SC_OP_FAILURE",
"SC_OP_SUCCESS",
"CARDCTRL",
"BACKUP_KEY_CREATED",
"PKA_TRUST_BAD",
"PKA_TRUST_GOOD",
"PLAINTEXT",
};
static const unsigned int num_status_strings = sizeof status_strings / sizeof * status_strings ;
const char *status_to_string(unsigned int idx)
{
if (idx < num_status_strings) {
return status_strings[idx];
} else {
return "(unknown)";
}
}

68
lang/cpp/src/editinteractor.h Normal file
View File

@ -0,0 +1,68 @@
/*
editinteractor.h - Interface for edit interactors
Copyright (C) 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.
*/
#ifndef __GPGMEPP_EDITINTERACTOR_H__
#define __GPGMEPP_EDITINTERACTOR_H__
#include "gpgmepp_export.h"
#include <cstdio>
namespace GpgME
{
class Error;
class Context;
class CallbackHelper;
class GPGMEPP_EXPORT EditInteractor
{
friend class ::GpgME::Context;
friend class ::GpgME::CallbackHelper;
EditInteractor(const EditInteractor &);
EditInteractor &operator=(const EditInteractor &);
public:
EditInteractor();
virtual ~EditInteractor();
enum {
StartState = 0,
ErrorState = 0xFFFFFFFF
};
virtual const char *action(Error &err) const = 0;
virtual unsigned int nextState(unsigned int statusCode, const char *args, Error &err) const = 0;
unsigned int state() const;
Error lastError() const;
bool needsNoResponse(unsigned int statusCode) const;
void setDebugChannel(std::FILE *file);
private:
class Private;
Private *const d;
};
} // namespace GpgME
#endif // __GPGMEPP_EDITINTERACTOR_H__

161
lang/cpp/src/encryptionresult.cpp Normal file
View File

@ -0,0 +1,161 @@
/*
encryptionresult.cpp - wraps a gpgme verify result
Copyright (C) 2004 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 <config-gpgme++.h>
#include <encryptionresult.h>
#include "result_p.h"
#include "util.h"
#include <gpgme.h>
#include <cstring>
#include <cstdlib>
#include <istream>
#include <algorithm>
#include <iterator>
#include <string.h>
class GpgME::EncryptionResult::Private
{
public:
explicit Private(const gpgme_encrypt_result_t r)
{
if (!r) {
return;
}
for (gpgme_invalid_key_t ik = r->invalid_recipients ; ik ; ik = ik->next) {
gpgme_invalid_key_t copy = new _gpgme_invalid_key(*ik);
if (ik->fpr) {
copy->fpr = strdup(ik->fpr);
}
copy->next = 0;
invalid.push_back(copy);
}
}
~Private()
{
for (std::vector<gpgme_invalid_key_t>::iterator it = invalid.begin() ; it != invalid.end() ; ++it) {
std::free((*it)->fpr);
delete *it; *it = 0;
}
}
std::vector<gpgme_invalid_key_t> invalid;
};
GpgME::EncryptionResult::EncryptionResult(gpgme_ctx_t ctx, int error)
: GpgME::Result(error), d()
{
init(ctx);
}
GpgME::EncryptionResult::EncryptionResult(gpgme_ctx_t ctx, const Error &error)
: GpgME::Result(error), d()
{
init(ctx);
}
void GpgME::EncryptionResult::init(gpgme_ctx_t ctx)
{
if (!ctx) {
return;
}
gpgme_encrypt_result_t res = gpgme_op_encrypt_result(ctx);
if (!res) {
return;
}
d.reset(new Private(res));
}
make_standard_stuff(EncryptionResult)
unsigned int GpgME::EncryptionResult::numInvalidRecipients() const
{
return d ? d->invalid.size() : 0 ;
}
GpgME::InvalidRecipient GpgME::EncryptionResult::invalidEncryptionKey(unsigned int idx) const
{
return InvalidRecipient(d, idx);
}
std::vector<GpgME::InvalidRecipient> GpgME::EncryptionResult::invalidEncryptionKeys() const
{
if (!d) {
return std::vector<GpgME::InvalidRecipient>();
}
std::vector<GpgME::InvalidRecipient> result;
result.reserve(d->invalid.size());
for (unsigned int i = 0 ; i < d->invalid.size() ; ++i) {
result.push_back(InvalidRecipient(d, i));
}
return result;
}
GpgME::InvalidRecipient::InvalidRecipient(const boost::shared_ptr<EncryptionResult::Private> &parent, unsigned int i)
: d(parent), idx(i)
{
}
GpgME::InvalidRecipient::InvalidRecipient() : d(), idx(0) {}
bool GpgME::InvalidRecipient::isNull() const
{
return !d || idx >= d->invalid.size() ;
}
const char *GpgME::InvalidRecipient::fingerprint() const
{
return isNull() ? 0 : d->invalid[idx]->fpr ;
}
GpgME::Error GpgME::InvalidRecipient::reason() const
{
return Error(isNull() ? 0 : d->invalid[idx]->reason);
}
std::ostream &GpgME::operator<<(std::ostream &os, const EncryptionResult &result)
{
os << "GpgME::EncryptionResult(";
if (!result.isNull()) {
os << "\n error: " << result.error()
<< "\n invalid recipients:\n";
const std::vector<InvalidRecipient> ir = result.invalidEncryptionKeys();
std::copy(ir.begin(), ir.end(),
std::ostream_iterator<InvalidRecipient>(os, "\n"));
}
return os << ')';
}
std::ostream &GpgME::operator<<(std::ostream &os, const InvalidRecipient &ir)
{
os << "GpgME::InvalidRecipient(";
if (!ir.isNull()) {
os << "\n fingerprint: " << protect(ir.fingerprint())
<< "\n reason: " << ir.reason()
<< '\n';
}
return os << ')';
}

113
lang/cpp/src/encryptionresult.h Normal file
View File

@ -0,0 +1,113 @@
/*
encryptionresult.h - wraps a gpgme sign result
Copyright (C) 2004 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.
*/
#ifndef __GPGMEPP_ENCRYPTIONRESULT_H__
#define __GPGMEPP_ENCRYPTIONRESULT_H__
#include "gpgmefw.h"
#include "result.h"
#include "gpgmepp_export.h"
#include <boost/shared_ptr.hpp>
#include <vector>
#include <iosfwd>
namespace GpgME
{
class Error;
class InvalidRecipient;
class GPGMEPP_EXPORT EncryptionResult : public Result
{
public:
EncryptionResult();
EncryptionResult(gpgme_ctx_t ctx, int error);
EncryptionResult(gpgme_ctx_t ctx, const Error &error);
EncryptionResult(const Error &err);
const EncryptionResult &operator=(EncryptionResult other)
{
swap(other);
return *this;
}
void swap(EncryptionResult &other)
{
Result::swap(other);
using std::swap;
swap(this->d, other.d);
}
bool isNull() const;
unsigned int numInvalidRecipients() const;
InvalidRecipient invalidEncryptionKey(unsigned int index) const;
std::vector<InvalidRecipient> invalidEncryptionKeys() const;
class Private;
private:
void init(gpgme_ctx_t ctx);
boost::shared_ptr<Private> d;
};
GPGMEPP_EXPORT std::ostream &operator<<(std::ostream &os, const EncryptionResult &result);
class GPGMEPP_EXPORT InvalidRecipient
{
friend class ::GpgME::EncryptionResult;
InvalidRecipient(const boost::shared_ptr<EncryptionResult::Private> &parent, unsigned int index);
public:
InvalidRecipient();
const InvalidRecipient &operator=(InvalidRecipient other)
{
swap(other);
return *this;
}
void swap(InvalidRecipient &other)
{
using std::swap;
swap(this->d, other.d);
}
bool isNull() const;
const char *fingerprint() const;
Error reason() const;
private:
boost::shared_ptr<EncryptionResult::Private> d;
unsigned int idx;
};
GPGMEPP_EXPORT std::ostream &operator<<(std::ostream &os, const InvalidRecipient &recipient);
}
GPGMEPP_MAKE_STD_SWAP_SPECIALIZATION(EncryptionResult)
GPGMEPP_MAKE_STD_SWAP_SPECIALIZATION(InvalidRecipient)
#endif // __GPGMEPP_ENCRYPTIONRESULT_H__

89
lang/cpp/src/engineinfo.cpp Normal file
View File

@ -0,0 +1,89 @@
/*
engineinfo.h
Copyright (C) 2004 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 <config-gpgme++.h>
#include "engineinfo.h"
#include <gpgme.h>
class GpgME::EngineInfo::Private
{
public:
Private(gpgme_engine_info_t engine = 0) : info(engine) {}
~Private()
{
info = 0;
}
gpgme_engine_info_t info;
};
GpgME::EngineInfo::EngineInfo() : d() {}
GpgME::EngineInfo::EngineInfo(gpgme_engine_info_t engine)
: d(new Private(engine))
{
}
bool GpgME::EngineInfo::isNull() const
{
return !d || !d->info;
}
GpgME::Protocol GpgME::EngineInfo::protocol() const
{
if (isNull()) {
return UnknownProtocol;
}
switch (d->info->protocol) {
case GPGME_PROTOCOL_OpenPGP: return OpenPGP;
case GPGME_PROTOCOL_CMS: return CMS;
default:
return UnknownProtocol;
}
}
const char *GpgME::EngineInfo::fileName() const
{
return isNull() ? 0 : d->info->file_name;
}
const char *GpgME::EngineInfo::version() const
{
return isNull() ? 0 : d->info->version;
}
const char *GpgME::EngineInfo::requiredVersion() const
{
return isNull() ? 0 : d->info->req_version;
}
const char *GpgME::EngineInfo::homeDirectory() const
{
#ifdef HAVE_GPGME_ENGINE_INFO_T_HOME_DIR
return isNull() ? 0 : d->info->home_dir;
#else
return 0;
#endif
}

70
lang/cpp/src/engineinfo.h Normal file
View File

@ -0,0 +1,70 @@
/*
engineinfo.h
Copyright (C) 2004 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.
*/
#ifndef __GPGMEPP_ENGINEINFO_H__
#define __GPGMEPP_ENGINEINFO_H__
#include "global.h"
#include <boost/shared_ptr.hpp>
#include <algorithm>
namespace GpgME
{
class GPGMEPP_EXPORT EngineInfo
{
public:
EngineInfo();
explicit EngineInfo(gpgme_engine_info_t engine);
const EngineInfo &operator=(EngineInfo other)
{
swap(other);
return *this;
}
void swap(EngineInfo &other)
{
using std::swap;
swap(this->d, other.d);
}
bool isNull() const;
Protocol protocol() const;
const char *fileName() const;
const char *version() const;
const char *requiredVersion() const;
const char *homeDirectory() const;
private:
class Private;
boost::shared_ptr<Private> d;
};
}
GPGMEPP_MAKE_STD_SWAP_SPECIALIZATION(EngineInfo)
#endif // __GPGMEPP_ENGINEINFO_H__

78
lang/cpp/src/error.h Normal file
View File

@ -0,0 +1,78 @@
/*
error.h - wraps a gpgme error
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_ERROR_H__
#define __GPGMEPP_ERROR_H__
#include "global.h"
#include <string>
#include <iosfwd>
#include <gpg-error.h>
#ifndef GPGMEPP_ERR_SOURCE_DEFAULT
# define GPGMEPP_ERR_SOURCE_DEFAULT GPG_ERR_SOURCE_USER_1
#endif
namespace GpgME
{
class GPGMEPP_EXPORT Error
{
public:
Error() : mErr(0), mMessage() {}
explicit Error(unsigned int e) : mErr(e), mMessage() {}
const char *source() const;
const char *asString() const;
int code() const;
int sourceID() const;
bool isCanceled() const;
unsigned int encodedError() const
{
return mErr;
}
int toErrno() const;
static bool hasSystemError();
static Error fromSystemError(unsigned int src = GPGMEPP_ERR_SOURCE_DEFAULT);
static void setSystemError(gpg_err_code_t err);
static void setErrno(int err);
static Error fromErrno(int err, unsigned int src = GPGMEPP_ERR_SOURCE_DEFAULT);
static Error fromCode(unsigned int err, unsigned int src = GPGMEPP_ERR_SOURCE_DEFAULT);
GPGMEPP_MAKE_SAFE_BOOL_OPERATOR(mErr &&!isCanceled())
private:
unsigned int mErr;
mutable std::string mMessage;
};
GPGMEPP_EXPORT std::ostream &operator<<(std::ostream &os, const Error &err);
} // namespace GpgME
#endif /* __GPGMEPP_ERROR_H__ */

201
lang/cpp/src/eventloopinteractor.cpp Normal file
View File

@ -0,0 +1,201 @@
/*
eventloopinteractor.cpp
Copyright (C) 2003,2004 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 <config-gpgme++.h>
#include <eventloopinteractor.h>
#include <context.h>
#include "context_p.h"
#include <key.h>
#include <trustitem.h>
#include <gpgme.h>
#include <vector>
using std::vector;
#ifndef NDEBUG
# include <iostream>
#endif
#include <cassert>
namespace GpgME
{
//
// EventLoopInteractor::Private Declaration
//
class EventLoopInteractor::Private
{
public:
struct OneFD {
OneFD(int aFd, int aDir, gpgme_io_cb_t aFnc,
void *aFncData, void *aExternalTag)
: fd(aFd), dir(aDir), fnc(aFnc),
fncData(aFncData), externalTag(aExternalTag) {}
int fd;
int dir;
gpgme_io_cb_t fnc;
void *fncData;
void *externalTag;
};
vector<OneFD *> mCallbacks;
static void removeIOCb(void *tag);
static gpgme_error_t registerIOCb(void *data, int fd, int dir,
gpgme_io_cb_t fnc, void *fnc_data,
void **r_tag);
static void eventIOCb(void *, gpgme_event_io_t type, void *type_data);
static const gpgme_io_cbs iocbs;
};
const gpgme_io_cbs EventLoopInteractor::Private::iocbs = {
&EventLoopInteractor::Private::registerIOCb,
0,
&EventLoopInteractor::Private::removeIOCb,
&EventLoopInteractor::Private::eventIOCb,
0
};
//
// EventLoopInteractor::Private IO Callback Implementations
//
gpgme_error_t EventLoopInteractor::Private::registerIOCb(void *, int fd, int dir,
gpgme_io_cb_t fnc, void *fnc_data,
void **r_tag)
{
assert(instance()); assert(instance()->d);
bool ok = false;
void *etag = instance()->registerWatcher(fd, dir ? Read : Write, ok);
if (!ok) {
return gpgme_error(GPG_ERR_GENERAL);
}
instance()->d->mCallbacks.push_back(new OneFD(fd, dir, fnc, fnc_data, etag));
if (r_tag) {
*r_tag = instance()->d->mCallbacks.back();
}
return GPG_ERR_NO_ERROR;
}
void EventLoopInteractor::Private::removeIOCb(void *tag)
{
if (!instance() || !instance()->d) {
return;
}
for (vector<OneFD *>::iterator it = instance()->d->mCallbacks.begin();
it != instance()->d->mCallbacks.end() ; ++it) {
if (*it == tag) {
instance()->unregisterWatcher((*it)->externalTag);
delete *it; *it = 0;
instance()->d->mCallbacks.erase(it);
return;
}
}
}
void EventLoopInteractor::Private::eventIOCb(void *data, gpgme_event_io_t type, void *type_data)
{
assert(instance());
Context *ctx = static_cast<Context *>(data);
switch (type) {
case GPGME_EVENT_START: {
instance()->operationStartEvent(ctx);
// TODO: what's in type_data?
}
break;
case GPGME_EVENT_DONE: {
gpgme_error_t e = *static_cast<gpgme_error_t *>(type_data);
if (ctx && ctx->impl()) {
ctx->impl()->lasterr = e;
}
instance()->operationDoneEvent(ctx, Error(e));
}
break;
case GPGME_EVENT_NEXT_KEY: {
gpgme_key_t key = static_cast<gpgme_key_t>(type_data);
instance()->nextKeyEvent(ctx, Key(key, false));
}
break;
case GPGME_EVENT_NEXT_TRUSTITEM: {
gpgme_trust_item_t item = static_cast<gpgme_trust_item_t>(type_data);
instance()->nextTrustItemEvent(ctx, TrustItem(item));
gpgme_trust_item_unref(item);
}
break;
default: // warn
;
}
}
//
// EventLoopInteractor Implementation
//
EventLoopInteractor *EventLoopInteractor::mSelf = 0;
EventLoopInteractor::EventLoopInteractor() : d(new Private)
{
assert(!mSelf);
mSelf = this;
}
EventLoopInteractor::~EventLoopInteractor()
{
// warn if there are still callbacks registered
mSelf = 0;
delete d;
}
void EventLoopInteractor::manage(Context *context)
{
if (!context || context->managedByEventLoopInteractor()) {
return;
}
gpgme_io_cbs *iocbs = new gpgme_io_cbs(Private::iocbs);
iocbs->event_priv = context;
context->installIOCallbacks(iocbs);
}
void EventLoopInteractor::unmanage(Context *context)
{
if (context) {
context->uninstallIOCallbacks();
}
}
void EventLoopInteractor::actOn(int fd, Direction dir)
{
for (vector<Private::OneFD *>::const_iterator it = d->mCallbacks.begin();
it != d->mCallbacks.end() ; ++it) {
if ((*it)->fd == fd && ((*it)->dir ? Read : Write) == dir) {
(*((*it)->fnc))((*it)->fncData, fd);
break;
}
}
}
} // namespace GpgME

156
lang/cpp/src/eventloopinteractor.h Normal file
View File

@ -0,0 +1,156 @@
/*
eventloopinteractor.h
Copyright (C) 2003,2004 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_EVENTLOOPINTERACTOR_H__
#define __GPGMEPP_EVENTLOOPINTERACTOR_H__
#include "gpgmepp_export.h"
namespace GpgME
{
class Context;
class Error;
class TrustItem;
class Key;
/*! \file eventloopinteractor.h
\brief Abstract base class for gpgme's external event loop support
This class does most of the work involved with hooking GpgME++
up with external event loops, such as the GTK or Qt ones.
It actually provides two interfaces: An interface to the gpgme
IO Callback handling and one for gpgme events. The IO Callback
interface consists of the three methods \c actOn(), \c
registerWatcher() and \c unregisterWatcher(). The event
interface consists of the three methods \c nextTrustItemEvent(),
\c nextKeyEvent() and \c operationDoneEvent().
\sect General Usage
\c EventLoopInteractor is designed to be used as a
singleton. However, in order to make any use of it, you have to
subclass it and reimplement it's pure virtual methods (see
below). We suggest you keep the constructor protected and
provide a static \c instance() method that returns the single
instance. Alternatively, you can create an instance on the
stack, e.g. in \c main().
If you want \c EventLoopInteractor to manage a particular \c
Context, just call \c manage() on the \c Context. OTOH, if you
want to disable IO callbacks for a \c Context, use \c unmanage().
\sect IO Callback Interface
One part of this interface is represented by \c
registerWatcher() and \c unregisterWatcher(), both of which are
pure virtual. \c registerWatcher() should do anything necessary
to hook up watching of file descriptor \c fd for reading (\c dir
= \c Read) or writing (\c dir = Write) to the event loop you use
and return a tag identifying that particular watching process
uniquely. This could be the index into an array of objects you
use for that purpose or the address of such an object. E.g. in
Qt, you'd essentially just create a new \c QSocketNotifier:
\verbatim
void * registerWatcher( int fd, Direction dir ) {
return new QSocketNotifier( fd, dir == Read ? QSocketNotifier::Read : QSocketNotifier::Write );
// misses connecting to the activated() signal...
}
\endverbatim
which uses the address of the created object as unique tag. The
tag returned by \c registerWatcher is stored by \c
EventLoopInteractor and passed as argument to \c
unregisterWatcher(). So, in the picture above, you'd implement \c
unregisterWatcher() like this:
\verbatim
void unregisterWatcher( void * tag ) {
delete static_cast<QSocketNotifier*>( tag );
}
\endverbatim
The other part of the IO callback interface is \c actOn(), which
you should call if you receive notification from your event loop
about activity on file descriptor \c fd in direction \c dir. In
the picture above, you'd call this from the slot connected to
the socket notifier's \c activated() signal.
\note \c registerWatcher() as well as \c unregisterWatcher() may
be called from within \c actOn(), so be careful with
e.g. locking in threaded environments and keep in mind that the
object you used to find the \c fd and \c dir fo the \c actOn()
call might be deleted when \c actOn() returns!
\sect Event Handler Interface
*/
class GPGMEPP_EXPORT EventLoopInteractor
{
protected:
EventLoopInteractor();
public:
virtual ~EventLoopInteractor();
static EventLoopInteractor *instance()
{
return mSelf;
}
void manage(Context *context);
void unmanage(Context *context);
enum Direction { Read, Write };
protected:
//
// IO Notification Interface
//
/** Call this if your event loop detected activity on file
descriptor fd, with direction dir */
void actOn(int fd, Direction dir);
virtual void *registerWatcher(int fd, Direction dir, bool &ok) = 0;
virtual void unregisterWatcher(void *tag) = 0;
//
// Event Handler Interface
//
virtual void operationStartEvent(Context *context) = 0;
virtual void nextTrustItemEvent(Context *context, const TrustItem &item) = 0;
virtual void nextKeyEvent(Context *context, const Key &key) = 0;
virtual void operationDoneEvent(Context *context, const Error &e) = 0;
private:
class Private;
friend class Private;
Private *const d;
static EventLoopInteractor *mSelf;
};
}
#endif // __GPGMEPP_EVENTLOOPINTERACTOR_H__

58
lang/cpp/src/exception.cpp Normal file
View File

@ -0,0 +1,58 @@
/*
exception.cpp - exception wrapping a gpgme error
Copyright (C) 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++ -*-
#include "exception.h"
#include <gpgme.h>
#include <sstream>
using namespace GpgME;
using namespace std; // only safe b/c it's so small a file!
Exception::~Exception() throw() {}
// static
string Exception::make_message(const Error &err, const string &msg)
{
return make_message(err, msg, NoOptions);
}
// static
string Exception::make_message(const Error &err, const string &msg, Options opt)
{
if (opt & MessageOnly) {
return msg;
}
char error_string[128];
error_string[0] = '\0';
gpgme_strerror_r(err.encodedError(), error_string, sizeof error_string);
error_string[sizeof error_string - 1] = '\0';
stringstream ss;
ss << gpgme_strsource(err.encodedError()) << ": ";
if (!msg.empty()) {
ss << msg << ": ";
}
ss << error_string << " (" << static_cast<unsigned long>(err.encodedError()) << ')';
return ss.str();
}

68
lang/cpp/src/exception.h Normal file
View File

@ -0,0 +1,68 @@
/*
exception.h - exception wrapping a gpgme error
Copyright (C) 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_EXCEPTION_H__
#define __GPGMEPP_EXCEPTION_H__
#include "error.h"
#include <stdexcept>
#include <string>
namespace GpgME
{
class GPGMEPP_EXPORT Exception : public std::runtime_error
{
public:
enum Options {
NoOptions = 0x0,
MessageOnly = 0x1,
AllOptions = MessageOnly
};
explicit Exception(const GpgME::Error &err, const std::string &msg = std::string(), Options opt = NoOptions)
: std::runtime_error(make_message(err, msg, opt)), m_error(err), m_message(msg) {}
~Exception() throw();
Error error() const
{
return m_error;
}
const std::string &message() const
{
return m_message;
}
private:
static std::string make_message(const GpgME::Error &err, const std::string &msg);
static std::string make_message(const GpgME::Error &err, const std::string &msg, Options opt);
private:
const GpgME::Error m_error;
const std::string m_message;
};
} // namespace GpgME
#endif /* __GPGMEPP_EXCEPTION_H__ */

156
lang/cpp/src/global.h Normal file
View File

@ -0,0 +1,156 @@
/*
global.h - global gpgme functions and enums
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_GLOBAL_H__
#define __GPGMEPP_GLOBAL_H__
#include "gpgmefw.h"
#include "gpgmepp_export.h"
#include <iosfwd>
#include <QByteArray>
namespace GpgME
{
class Error;
class EngineInfo;
class Context;
}
struct _GIOChannel;
typedef struct _GIOChannel GIOChannel;
class QIODevice;
namespace GpgME
{
GPGMEPP_EXPORT void initializeLibrary();
/*!
Initializes the library, returns Error::code() ==
GPG_ERR_USER_1 if underlying gpgme is too old.
*/
GPGMEPP_EXPORT Error initializeLibrary(int);
enum Protocol { OpenPGP, CMS, UnknownProtocol };
enum Engine { GpgEngine, GpgSMEngine, GpgConfEngine, UnknownEngine, AssuanEngine, G13Engine };
enum KeyListMode {
Local = 0x1,
Extern = 0x2,
Signatures = 0x4,
SignatureNotations = 0x8,
Validate = 0x10,
Ephemeral = 0x20
};
enum SignatureMode { NormalSignatureMode, Detached, Clearsigned };
GPGMEPP_EXPORT std::ostream &operator<<(std::ostream &os, Protocol proto);
GPGMEPP_EXPORT std::ostream &operator<<(std::ostream &os, Engine eng);
GPGMEPP_EXPORT std::ostream &operator<<(std::ostream &os, KeyListMode mode);
GPGMEPP_EXPORT std::ostream &operator<<(std::ostream &os, SignatureMode mode);
GPGMEPP_EXPORT Error setDefaultLocale(int category, const char *value);
GPGMEPP_EXPORT Context *wait(Error &e, bool hang = true);
typedef void (*IdleFunction)(void);
GPGMEPP_EXPORT IdleFunction registerIdleFunction(IdleFunction idleFunction);
typedef void (*IOCallback)(void *data, int fd);
GPGMEPP_EXPORT EngineInfo engineInfo(Protocol proto);
GPGMEPP_EXPORT EngineInfo engineInfo(Engine engine);
GPGMEPP_EXPORT Error checkEngine(Protocol proto);
GPGMEPP_EXPORT Error checkEngine(Engine engine);
GPGMEPP_EXPORT GIOChannel *getGIOChannel(int fd);
GPGMEPP_EXPORT QIODevice *getQIODevice(int fd);
enum Feature {
ValidatingKeylistModeFeature = 0x00000001,
CancelOperationFeature = 0x00000002,
WrongKeyUsageFeature = 0x00000004,
DefaultCertificateInclusionFeature = 0x00000008,
GetSetEngineInfoFeature = 0x00000010,
EngineInfoHomeDirFeature = 0x00000020,
NoEncryptToEncryptionFlagFeature = 0x00000040,
EphemeralKeylistModeFeature = 0x00000080,
SetDataFileNameFeeature = 0x00000100,
VerificationResultFileNameFeature = 0x00000200,
DecryptionResultFileNameFeature = 0x00000400,
DecryptionResultRecipientsFeature = 0x00000800,
AuditLogFeature = 0x00001000,
GpgConfEngineFeature = 0x00002000,
CancelOperationAsyncFeature = 0x00004000,
AssuanEngineFeature = 0x00008000,
ClearAddGetSignatureNotationsFeature = 0x00010000,
SignatureNotationsKeylistModeFeature = 0x00020000,
KeySignatureNotationsFeature = 0x00040000,
SignatureNotationsFlagsFeature = 0x00080000,
SignatureNotationsCriticalFlagFeature = 0x00100000,
SignatureNotationsHumanReadableFlagFeature = 0x00200000,
CardKeyFeature = 0x00400000,
ImportFromKeyserverFeature = 0x00800000,
KeyIsQualifiedFeature = 0x01000200,
SubkeyIsQualifiedFeature = 0x02000000,
SignaturePkaFieldsFeature = 0x04000000,
SignatureAlgorithmFieldsFeature = 0x08000000,
FdPointerFeature = 0x10000000,
G13VFSFeature = 0x20000000,
PasswdFeature = 0x40000000, // gpgme >= 1.3.0
// unusable (max value)
FeatureMaxValue = 0x80000000
};
enum Feature2 {
Feature2MaxValue = 0x80000000
};
// use hasFeature( unsigned long, unsigned long ) instead
GPGMEPP_DEPRECATED_EXPORT bool hasFeature(unsigned long feature);
GPGMEPP_EXPORT bool hasFeature(unsigned long feature, unsigned long feature2);
} // namespace GpgME
# ifndef GPGMEPP_MAKE_STD_SWAP_SPECIALIZATION
# define GPGMEPP_MAKE_STD_SWAP_SPECIALIZATION( Class ) \
namespace std { template <> inline void swap< GpgME::Class >( GpgME::Class & lhs, GpgME::Class & rhs ) { lhs.swap( rhs ); } }
# endif
# ifndef GPGMEPP_MAKE_SAFE_BOOL_OPERATOR
# define GPGMEPP_MAKE_SAFE_BOOL_OPERATOR( Cond ) \
private: \
struct __safe_bool_dummy__ { void nonnull() {} }; \
typedef void ( __safe_bool_dummy__::*unspecified_bool_type )(); \
public: \
operator unspecified_bool_type() const { return ( Cond ) ? &__safe_bool_dummy__::nonnull : 0 ; }
# endif
#endif // __GPGMEPP_GLOBAL_H__

189
lang/cpp/src/gpgadduserideditinteractor.cpp Normal file
View File

@ -0,0 +1,189 @@
/*
gpgadduserideditinteractor.cpp - Edit Interactor to add a new UID to an OpenPGP key
Copyright (C) 2008 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 "gpgadduserideditinteractor.h"
#include "error.h"
#include <gpgme.h>
#include <cstring>
using std::strcmp;
// avoid conflict (msvc)
#ifdef ERROR
# undef ERROR
#endif
using namespace GpgME;
GpgAddUserIDEditInteractor::GpgAddUserIDEditInteractor()
: EditInteractor(),
m_name(),
m_email(),
m_comment()
{
}
GpgAddUserIDEditInteractor::~GpgAddUserIDEditInteractor() {}
void GpgAddUserIDEditInteractor::setNameUtf8(const std::string &name)
{
m_name = name;
}
void GpgAddUserIDEditInteractor::setEmailUtf8(const std::string &email)
{
m_email = email;
}
void GpgAddUserIDEditInteractor::setCommentUtf8(const std::string &comment)
{
m_comment = comment;
}
// work around --enable-final
namespace GpgAddUserIDEditInteractor_Private
{
enum {
START = EditInteractor::StartState,
COMMAND,
NAME,
EMAIL,
COMMENT,
QUIT,
SAVE,
ERROR = EditInteractor::ErrorState
};
}
const char *GpgAddUserIDEditInteractor::action(Error &err) const
{
using namespace GpgAddUserIDEditInteractor_Private;
switch (state()) {
case COMMAND:
return "adduid";
case NAME:
return m_name.c_str();
case EMAIL:
return m_email.c_str();
case COMMENT:
return m_comment.c_str();
case QUIT:
return "quit";
case SAVE:
return "Y";
case START:
case ERROR:
return 0;
default:
err = Error::fromCode(GPG_ERR_GENERAL);
return 0;
}
}
unsigned int GpgAddUserIDEditInteractor::nextState(unsigned int status, const char *args, Error &err) const
{
static const Error GENERAL_ERROR = Error::fromCode(GPG_ERR_GENERAL);
static const Error INV_NAME_ERROR = Error::fromCode(GPG_ERR_INV_NAME);
static const Error INV_EMAIL_ERROR = Error::fromCode(GPG_ERR_INV_USER_ID);
static const Error INV_COMMENT_ERROR = Error::fromCode(GPG_ERR_INV_USER_ID);
if (needsNoResponse(status)) {
return state();
}
using namespace GpgAddUserIDEditInteractor_Private;
switch (state()) {
case START:
if (status == GPGME_STATUS_GET_LINE &&
strcmp(args, "keyedit.prompt") == 0) {
return COMMAND;
}
err = GENERAL_ERROR;
return ERROR;
case COMMAND:
if (status == GPGME_STATUS_GET_LINE &&
strcmp(args, "keygen.name") == 0) {
return NAME;
}
err = GENERAL_ERROR;
return ERROR;
case NAME:
if (status == GPGME_STATUS_GET_LINE &&
strcmp(args, "keygen.email") == 0) {
return EMAIL;
}
err = GENERAL_ERROR;
if (status == GPGME_STATUS_GET_LINE &&
strcmp(args, "keygen.name") == 0) {
err = INV_NAME_ERROR;
}
return ERROR;
case EMAIL:
if (status == GPGME_STATUS_GET_LINE &&
strcmp(args, "keygen.comment") == 0) {
return COMMENT;
}
err = GENERAL_ERROR;
if (status == GPGME_STATUS_GET_LINE &&
strcmp(args, "keygen.email") == 0) {
err = INV_EMAIL_ERROR;
}
return ERROR;
case COMMENT:
if (status == GPGME_STATUS_GET_LINE &&
strcmp(args, "keyedit.prompt") == 0) {
return QUIT;
}
err = GENERAL_ERROR;
if (status == GPGME_STATUS_GET_LINE &&
strcmp(args, "keygen.comment") == 0) {
err = INV_COMMENT_ERROR;
}
return ERROR;
case QUIT:
if (status == GPGME_STATUS_GET_BOOL &&
strcmp(args, "keyedit.save.okay") == 0) {
return SAVE;
}
err = GENERAL_ERROR;
return ERROR;
case ERROR:
if (status == GPGME_STATUS_GET_LINE &&
strcmp(args, "keyedit.prompt") == 0) {
return QUIT;
}
err = lastError();
return ERROR;
default:
err = GENERAL_ERROR;
return ERROR;
}
}

67
lang/cpp/src/gpgadduserideditinteractor.h Normal file
View File

@ -0,0 +1,67 @@
/*
gpgadduserideditinteractor.h - Edit Interactor to add a new UID to an OpenPGP key
Copyright (C) 2008 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.
*/
#ifndef __GPGMEPP_GPGADDUSERIDEDITINTERACTOR_H__
#define __GPGMEPP_GPGADDUSERIDEDITINTERACTOR_H__
#include <editinteractor.h>
#include <string>
namespace GpgME
{
class GPGMEPP_EXPORT GpgAddUserIDEditInteractor : public EditInteractor
{
public:
explicit GpgAddUserIDEditInteractor();
~GpgAddUserIDEditInteractor();
void setNameUtf8(const std::string &name);
const std::string &nameUtf8() const
{
return m_name;
}
void setEmailUtf8(const std::string &email);
const std::string &emailUtf8() const
{
return m_email;
}
void setCommentUtf8(const std::string &comment);
const std::string &commentUtf8() const
{
return m_comment;
}
private:
/* reimp */ const char *action(Error &err) const;
/* reimp */ unsigned int nextState(unsigned int statusCode, const char *args, Error &err) const;
private:
std::string m_name, m_email, m_comment;
};
} // namespace GpgME
#endif // __GPGMEPP_GPGADDUSERIDEDITINTERACTOR_H__

123
lang/cpp/src/gpgagentgetinfoassuantransaction.cpp Normal file
View File

@ -0,0 +1,123 @@
/*
gpgagentgetinfoassuantransaction.cpp - Assuan Transaction to get information from gpg-agent
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 <config-gpgme++.h>
#include "gpgagentgetinfoassuantransaction.h"
#include "error.h"
#include "data.h"
#include "util.h"
#include <boost/static_assert.hpp>
#include <sstream>
using namespace GpgME;
using namespace boost;
GpgAgentGetInfoAssuanTransaction::GpgAgentGetInfoAssuanTransaction(InfoItem item)
: AssuanTransaction(),
m_item(item),
m_command(),
m_data()
{
}
GpgAgentGetInfoAssuanTransaction::~GpgAgentGetInfoAssuanTransaction() {}
std::string GpgAgentGetInfoAssuanTransaction::version() const
{
if (m_item == Version) {
return m_data;
} else {
return std::string();
}
}
unsigned int GpgAgentGetInfoAssuanTransaction::pid() const
{
if (m_item == Pid) {
return to_pid(m_data);
} else {
return 0U;
}
}
std::string GpgAgentGetInfoAssuanTransaction::socketName() const
{
if (m_item == SocketName) {
return m_data;
} else {
return std::string();
}
}
std::string GpgAgentGetInfoAssuanTransaction::sshSocketName() const
{
if (m_item == SshSocketName) {
return m_data;
} else {
return std::string();
}
}
static const char *const gpgagent_getinfo_tokens[] = {
"version",
"pid",
"socket_name",
"ssh_socket_name",
"scd_running",
};
BOOST_STATIC_ASSERT((sizeof gpgagent_getinfo_tokens / sizeof * gpgagent_getinfo_tokens == GpgAgentGetInfoAssuanTransaction::LastInfoItem));
void GpgAgentGetInfoAssuanTransaction::makeCommand() const
{
assert(m_item >= 0);
assert(m_item < LastInfoItem);
m_command = "GETINFO ";
m_command += gpgagent_getinfo_tokens[m_item];
}
const char *GpgAgentGetInfoAssuanTransaction::command() const
{
makeCommand();
return m_command.c_str();
}
Error GpgAgentGetInfoAssuanTransaction::data(const char *data, size_t len)
{
m_data.append(data, len);
return Error();
}
Data GpgAgentGetInfoAssuanTransaction::inquire(const char *name, const char *args, Error &err)
{
(void)name; (void)args; (void)err;
return Data::null;
}
Error GpgAgentGetInfoAssuanTransaction::status(const char *status, const char *args)
{
(void)status; (void)args;
return Error();
}

73
lang/cpp/src/gpgagentgetinfoassuantransaction.h Normal file
View File

@ -0,0 +1,73 @@
/*
gpgagentgetinfoassuantransaction.h - Assuan Transaction to get information from gpg-agent
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.
*/
#ifndef __GPGMEPP_GPGAGENTGETINFOASSUANTRANSACTION_H__
#define __GPGMEPP_GPGAGENTGETINFOASSUANTRANSACTION_H__
#include <interfaces/assuantransaction.h>
#include <string>
#include <vector>
namespace GpgME
{
class GPGMEPP_EXPORT GpgAgentGetInfoAssuanTransaction : public AssuanTransaction
{
public:
enum InfoItem {
Version, // string
Pid, // unsigned long
SocketName, // string (path)
SshSocketName, // string (path)
ScdRunning, // (none, returns GPG_ERR_GENERAL when scdaemon isn't running)
//CommandHasOption, // not supported
LastInfoItem
};
explicit GpgAgentGetInfoAssuanTransaction(InfoItem item);
~GpgAgentGetInfoAssuanTransaction();
std::string version() const;
unsigned int pid() const;
std::string socketName() const;
std::string sshSocketName() const;
private:
/* reimp */ const char *command() const;
/* reimp */ Error data(const char *data, size_t datalen);
/* reimp */ Data inquire(const char *name, const char *args, Error &err);
/* reimp */ Error status(const char *status, const char *args);
private:
void makeCommand() const;
private:
InfoItem m_item;
mutable std::string m_command;
std::string m_data;
};
} // namespace GpgME
#endif // __GPGMEPP_GPGAGENTGETINFOASSUANTRANSACTION_H__

70
lang/cpp/src/gpgmefw.h Normal file
View File

@ -0,0 +1,70 @@
/*
gpgmefw.h - Forwards declarations for gpgme (0.3 and 0.4)
Copyright (C) 2004 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.
*/
#ifndef __GPGMEPP_GPGMEFW_H__
#define __GPGMEPP_GPGMEFW_H__
struct gpgme_context;
typedef gpgme_context *gpgme_ctx_t;
struct gpgme_data;
typedef gpgme_data *gpgme_data_t;
struct gpgme_io_cbs;
struct _gpgme_key;
typedef struct _gpgme_key *gpgme_key_t;
struct _gpgme_trust_item;
typedef struct _gpgme_trust_item *gpgme_trust_item_t;
struct _gpgme_subkey;
typedef struct _gpgme_subkey *gpgme_sub_key_t;
struct _gpgme_user_id;
typedef struct _gpgme_user_id *gpgme_user_id_t;
struct _gpgme_key_sig;
typedef struct _gpgme_key_sig *gpgme_key_sig_t;
struct _gpgme_sig_notation;
typedef struct _gpgme_sig_notation *gpgme_sig_notation_t;
struct _gpgme_engine_info;
typedef struct _gpgme_engine_info *gpgme_engine_info_t;
struct _gpgme_op_keylist_result;
typedef struct _gpgme_op_keylist_result *gpgme_keylist_result_t;
struct _gpgme_recipient;
typedef struct _gpgme_recipient *gpgme_recipient_t;
struct gpgme_conf_opt;
typedef struct gpgme_conf_opt *gpgme_conf_opt_t;
struct gpgme_conf_comp;
typedef struct gpgme_conf_comp *gpgme_conf_comp_t;
struct gpgme_conf_arg;
typedef struct gpgme_conf_arg *gpgme_conf_arg_t;
#endif // __GPGMEPP_GPGMEFW_H__

41
lang/cpp/src/gpgmepp_export.h Normal file
View File

@ -0,0 +1,41 @@
#ifndef GPGMEPP_EXPORT_H
#define GPGMEPP_EXPORT_H
#ifdef GPGMEPP_STATIC_DEFINE
# define GPGMEPP_EXPORT
# define GPGMEPP_NO_EXPORT
#else
# ifndef GPGMEPP_EXPORT
# ifdef KF5Gpgmepp_EXPORTS
/* We are building this library */
# define GPGMEPP_EXPORT __attribute__((visibility("default")))
# else
/* We are using this library */
# define GPGMEPP_EXPORT __attribute__((visibility("default")))
# endif
# endif
# ifndef GPGMEPP_NO_EXPORT
# define GPGMEPP_NO_EXPORT __attribute__((visibility("hidden")))
# endif
#endif
#ifndef GPGMEPP_DEPRECATED
# define GPGMEPP_DEPRECATED __attribute__ ((__deprecated__))
#endif
#ifndef GPGMEPP_DEPRECATED_EXPORT
# define GPGMEPP_DEPRECATED_EXPORT GPGMEPP_EXPORT GPGMEPP_DEPRECATED
#endif
#ifndef GPGMEPP_DEPRECATED_NO_EXPORT
# define GPGMEPP_DEPRECATED_NO_EXPORT GPGMEPP_NO_EXPORT GPGMEPP_DEPRECATED
#endif
#define DEFINE_NO_DEPRECATED 0
#if DEFINE_NO_DEPRECATED
# define GPGMEPP_NO_DEPRECATED
#endif
#endif

141
lang/cpp/src/gpgsetexpirytimeeditinteractor.cpp Normal file
View File

@ -0,0 +1,141 @@
/*
gpgsetexpirytimeeditinteractor.cpp - Edit Interactor to change the expiry time of an OpenPGP key
Copyright (C) 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 "gpgsetexpirytimeeditinteractor.h"
#include "error.h"
#include <gpgme.h>
#include <cstring>
using std::strcmp;
// avoid conflict (msvc)
#ifdef ERROR
# undef ERROR
#endif
using namespace GpgME;
GpgSetExpiryTimeEditInteractor::GpgSetExpiryTimeEditInteractor(const std::string &t)
: EditInteractor(),
m_strtime(t)
{
}
GpgSetExpiryTimeEditInteractor::~GpgSetExpiryTimeEditInteractor() {}
// work around --enable-final
namespace GpgSetExpiryTimeEditInteractor_Private
{
enum {
START = EditInteractor::StartState,
COMMAND,
DATE,
QUIT,
SAVE,
ERROR = EditInteractor::ErrorState
};
}
const char *GpgSetExpiryTimeEditInteractor::action(Error &err) const
{
using namespace GpgSetExpiryTimeEditInteractor_Private;
switch (state()) {
case COMMAND:
return "expire";
case DATE:
return m_strtime.c_str();
case QUIT:
return "quit";
case SAVE:
return "Y";
case START:
case ERROR:
return 0;
default:
err = Error::fromCode(GPG_ERR_GENERAL);
return 0;
}
}
unsigned int GpgSetExpiryTimeEditInteractor::nextState(unsigned int status, const char *args, Error &err) const
{
static const Error GENERAL_ERROR = Error::fromCode(GPG_ERR_GENERAL);
static const Error INV_TIME_ERROR = Error::fromCode(GPG_ERR_INV_TIME);
if (needsNoResponse(status)) {
return state();
}
using namespace GpgSetExpiryTimeEditInteractor_Private;
switch (state()) {
case START:
if (status == GPGME_STATUS_GET_LINE &&
strcmp(args, "keyedit.prompt") == 0) {
return COMMAND;
}
err = GENERAL_ERROR;
return ERROR;
case COMMAND:
if (status == GPGME_STATUS_GET_LINE &&
strcmp(args, "keygen.valid") == 0) {
return DATE;
}
err = GENERAL_ERROR;
return ERROR;
case DATE:
if (status == GPGME_STATUS_GET_LINE &&
strcmp(args, "keyedit.prompt") == 0) {
return QUIT;
} else if (status == GPGME_STATUS_GET_LINE &&
strcmp(args, "keygen.valid")) {
err = INV_TIME_ERROR;
return ERROR;
}
err = GENERAL_ERROR;
return ERROR;
case QUIT:
if (status == GPGME_STATUS_GET_BOOL &&
strcmp(args, "keyedit.save.okay") == 0) {
return SAVE;
}
err = GENERAL_ERROR;
return ERROR;
case ERROR:
if (status == GPGME_STATUS_GET_LINE &&
strcmp(args, "keyedit.prompt") == 0) {
return QUIT;
}
err = lastError();
return ERROR;
default:
err = GENERAL_ERROR;
return ERROR;
}
}

49
lang/cpp/src/gpgsetexpirytimeeditinteractor.h Normal file
View File

@ -0,0 +1,49 @@
/*
gpgsetexpirytimeeditinteractor.h - Edit Interactor to change the expiry time of an OpenPGP key
Copyright (C) 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.
*/
#ifndef __GPGMEPP_GPGSETEXPIRYTIMEEDITINTERACTOR_H__
#define __GPGMEPP_GPGSETEXPIRYTIMEEDITINTERACTOR_H__
#include <editinteractor.h>
#include <string>
namespace GpgME
{
class GPGMEPP_EXPORT GpgSetExpiryTimeEditInteractor : public EditInteractor
{
public:
explicit GpgSetExpiryTimeEditInteractor(const std::string &timeString = "0");
~GpgSetExpiryTimeEditInteractor();
private:
/* reimp */ const char *action(Error &err) const;
/* reimp */ unsigned int nextState(unsigned int statusCode, const char *args, Error &err) const;
private:
const std::string m_strtime;
};
} // namespace GpgME
#endif // __GPGMEPP_GPGSETEXPIRYTIMEEDITINTERACTOR_H___

151
lang/cpp/src/gpgsetownertrusteditinteractor.cpp Normal file
View File

@ -0,0 +1,151 @@
/*
gpgsetownertrusteditinteractor.cpp - Edit Interactor to change the expiry time of an OpenPGP key
Copyright (C) 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 "gpgsetownertrusteditinteractor.h"
#include "error.h"
#include <gpgme.h>
#include <cstring>
using std::strcmp;
// avoid conflict (msvc)
#ifdef ERROR
# undef ERROR
#endif
using namespace GpgME;
GpgSetOwnerTrustEditInteractor::GpgSetOwnerTrustEditInteractor(Key::OwnerTrust ot)
: EditInteractor(),
m_ownertrust(ot)
{
}
GpgSetOwnerTrustEditInteractor::~GpgSetOwnerTrustEditInteractor() {}
// work around --enable-final
namespace GpgSetOwnerTrustEditInteractor_Private
{
enum {
START = EditInteractor::StartState,
COMMAND,
VALUE,
REALLY_ULTIMATE,
QUIT,
SAVE,
ERROR = EditInteractor::ErrorState
};
}
const char *GpgSetOwnerTrustEditInteractor::action(Error &err) const
{
static const char truststrings[][2] = { "1", "1", "2", "3", "4", "5" };
using namespace GpgSetOwnerTrustEditInteractor_Private;
switch (state()) {
case COMMAND:
return "trust";
case VALUE:
return truststrings[m_ownertrust];
case REALLY_ULTIMATE:
return "Y";
case QUIT:
return "quit";
case SAVE:
return "Y";
case START:
case ERROR:
return 0;
default:
err = Error::fromCode(GPG_ERR_GENERAL);
return 0;
}
}
unsigned int GpgSetOwnerTrustEditInteractor::nextState(unsigned int status, const char *args, Error &err) const
{
static const Error GENERAL_ERROR = Error::fromCode(GPG_ERR_GENERAL);
//static const Error INV_TIME_ERROR = Error::fromCode( GPG_ERR_INV_TIME );
if (needsNoResponse(status)) {
return state();
}
using namespace GpgSetOwnerTrustEditInteractor_Private;
switch (state()) {
case START:
if (status == GPGME_STATUS_GET_LINE &&
strcmp(args, "keyedit.prompt") == 0) {
return COMMAND;
}
err = GENERAL_ERROR;
return ERROR;
case COMMAND:
if (status == GPGME_STATUS_GET_LINE &&
strcmp(args, "edit_ownertrust.value") == 0) {
return VALUE;
}
err = GENERAL_ERROR;
return ERROR;
case VALUE:
if (status == GPGME_STATUS_GET_LINE &&
strcmp(args, "keyedit.prompt") == 0) {
return QUIT;
} else if (status == GPGME_STATUS_GET_BOOL &&
strcmp(args, "edit_ownertrust.set_ultimate.okay") == 0) {
return REALLY_ULTIMATE;
}
err = GENERAL_ERROR;
return ERROR;
case REALLY_ULTIMATE:
if (status == GPGME_STATUS_GET_LINE &&
strcmp(args, "keyedit.prompt") == 0) {
return QUIT;
}
err = GENERAL_ERROR;
return ERROR;
case QUIT:
if (status == GPGME_STATUS_GET_BOOL &&
strcmp(args, "keyedit.save.okay") == 0) {
return SAVE;
}
err = GENERAL_ERROR;
return ERROR;
case ERROR:
if (status == GPGME_STATUS_GET_LINE &&
strcmp(args, "keyedit.prompt") == 0) {
return QUIT;
}
err = lastError();
return ERROR;
default:
err = GENERAL_ERROR;
return ERROR;
};
}

50
lang/cpp/src/gpgsetownertrusteditinteractor.h Normal file
View File

@ -0,0 +1,50 @@
/*
gpgsetownertrusteditinteractor.h - Edit Interactor to change the owner trust of an OpenPGP key
Copyright (C) 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.
*/
#ifndef __GPGMEPP_GPGSETOWNERTRUSTEDITINTERACTOR_H__
#define __GPGMEPP_GPGSETOWNERTRUSTEDITINTERACTOR_H__
#include <editinteractor.h>
#include <key.h>
#include <string>
namespace GpgME
{
class GPGMEPP_EXPORT GpgSetOwnerTrustEditInteractor : public EditInteractor
{
public:
explicit GpgSetOwnerTrustEditInteractor(Key::OwnerTrust ownertrust);
~GpgSetOwnerTrustEditInteractor();
private:
/* reimp */ const char *action(Error &err) const;
/* reimp */ unsigned int nextState(unsigned int statusCode, const char *args, Error &err) const;
private:
const Key::OwnerTrust m_ownertrust;
};
} // namespace GpgME
#endif // __GPGMEPP_GPGSETOWNERTRUSTEDITINTERACTOR_H__

322
lang/cpp/src/gpgsignkeyeditinteractor.cpp Normal file
View File

@ -0,0 +1,322 @@
/*
gpgsignkeyeditinteractor.cpp - Edit Interactor to change the expiry time of an OpenPGP key
Copyright (C) 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 "gpgsignkeyeditinteractor.h"
#include "error.h"
#include "key.h"
#include <gpgme.h>
#include <boost/tuple/tuple.hpp>
#include <boost/tuple/tuple_comparison.hpp>
#include <map>
#include <string>
#include <sstream>
#include <cassert>
#include <cstring>
using std::strcmp;
// avoid conflict (msvc)
#ifdef ERROR
# undef ERROR
#endif
#ifdef _MSC_VER
#undef snprintf
#define snprintf _snprintf
#endif
using namespace boost;
using namespace GpgME;
class GpgSignKeyEditInteractor::Private
{
public:
Private();
std::string scratch;
bool started;
int options;
std::vector<unsigned int> userIDs;
std::vector<unsigned int>::const_iterator currentId, nextId;
unsigned int checkLevel;
const char *command() const
{
const bool local = (options & Exportable) == 0;
const bool nonRevoc = options & NonRevocable;
const bool trust = options & Trust;
//TODO: check if all combinations are valid
if (local && nonRevoc && trust) {
return "ltnrsign";
}
if (local && nonRevoc) {
return "lnrsign";
}
if (local && trust) {
return "ltsign";
}
if (local) {
return "lsign";
}
if (nonRevoc && trust) {
return "tnrsign";
}
if (nonRevoc) {
return "nrsign";
}
if (trust) {
return "tsign";
}
return "sign";
}
bool signAll() const
{
return userIDs.empty();
}
unsigned int nextUserID()
{
assert(nextId != userIDs.end());
currentId = nextId++;
return currentUserID();
}
bool allUserIDsListed() const
{
return nextId == userIDs.end();
}
unsigned int currentUserID() const
{
assert(currentId != userIDs.end());
return *currentId + 1;
}
};
GpgSignKeyEditInteractor::Private::Private()
:
started(false),
options(0),
userIDs(),
currentId(),
nextId(),
checkLevel(0)
{
}
GpgSignKeyEditInteractor::GpgSignKeyEditInteractor()
: EditInteractor(), d(new Private)
{
}
GpgSignKeyEditInteractor::~GpgSignKeyEditInteractor()
{
delete d;
}
// work around --enable-final
namespace GpgSignKeyEditInteractor_Private
{
enum SignKeyState {
START = EditInteractor::StartState,
COMMAND,
UIDS_ANSWER_SIGN_ALL,
UIDS_LIST_SEPARATELY,
// all these free slots belong to UIDS_LIST_SEPARATELY, too
// (we increase state() by one for each UID, so that action() is called)
UIDS_LIST_SEPARATELY_DONE = 1000000,
SET_EXPIRE,
SET_CHECK_LEVEL,
SET_TRUST_VALUE,
SET_TRUST_DEPTH,
SET_TRUST_REGEXP,
CONFIRM,
QUIT,
SAVE,
ERROR = EditInteractor::ErrorState
};
typedef std::map<tuple<SignKeyState, unsigned int, std::string>, SignKeyState> TransitionMap;
}
static const char *answer(bool b)
{
return b ? "Y" : "N";
}
static GpgSignKeyEditInteractor_Private::TransitionMap makeTable()
{
using namespace GpgSignKeyEditInteractor_Private;
TransitionMap tab;
const unsigned int GET_BOOL = GPGME_STATUS_GET_BOOL;
const unsigned int GET_LINE = GPGME_STATUS_GET_LINE;
#define addEntry( s1, status, str, s2 ) tab[make_tuple( s1, status, str)] = s2
addEntry(START, GET_LINE, "keyedit.prompt", COMMAND);
addEntry(COMMAND, GET_BOOL, "keyedit.sign_all.okay", UIDS_ANSWER_SIGN_ALL);
addEntry(COMMAND, GET_BOOL, "sign_uid.okay", CONFIRM);
addEntry(UIDS_ANSWER_SIGN_ALL, GET_BOOL, "sign_uid.okay", CONFIRM);
addEntry(UIDS_ANSWER_SIGN_ALL, GET_LINE, "sign_uid.expire", SET_EXPIRE);
addEntry(UIDS_ANSWER_SIGN_ALL, GET_LINE, "sign_uid.class", SET_CHECK_LEVEL);
addEntry(SET_TRUST_VALUE, GET_LINE, "trustsign_prompt.trust_depth", SET_TRUST_DEPTH);
addEntry(SET_TRUST_DEPTH, GET_LINE, "trustsign_prompt.trust_regexp", SET_TRUST_REGEXP);
addEntry(SET_TRUST_REGEXP, GET_LINE, "sign_uid.okay", CONFIRM);
addEntry(SET_CHECK_LEVEL, GET_BOOL, "sign_uid.okay", CONFIRM);
addEntry(SET_EXPIRE, GET_BOOL, "sign_uid.class", SET_CHECK_LEVEL);
addEntry(CONFIRM, GET_BOOL, "sign_uid.local_promote_okay", CONFIRM);
addEntry(CONFIRM, GET_BOOL, "sign_uid.okay", CONFIRM);
addEntry(CONFIRM, GET_LINE, "keyedit.prompt", COMMAND);
addEntry(CONFIRM, GET_LINE, "trustsign_prompt.trust_value", SET_TRUST_VALUE);
addEntry(CONFIRM, GET_LINE, "sign_uid.expire", SET_EXPIRE);
addEntry(CONFIRM, GET_LINE, "sign_uid.class", SET_CHECK_LEVEL);
addEntry(UIDS_LIST_SEPARATELY_DONE, GET_BOOL, "sign_uid.local_promote_okay", CONFIRM);
addEntry(UIDS_LIST_SEPARATELY_DONE, GET_LINE, "keyedit.prompt", COMMAND);
addEntry(UIDS_LIST_SEPARATELY_DONE, GET_LINE, "trustsign_prompt.trust_value", SET_TRUST_VALUE);
addEntry(UIDS_LIST_SEPARATELY_DONE, GET_LINE, "sign_uid.expire", SET_EXPIRE);
addEntry(UIDS_LIST_SEPARATELY_DONE, GET_LINE, "sign_uid.class", SET_CHECK_LEVEL);
addEntry(UIDS_LIST_SEPARATELY_DONE, GET_BOOL, "sign_uid.okay", CONFIRM);
addEntry(CONFIRM, GET_LINE, "keyedit.prompt", QUIT);
addEntry(ERROR, GET_LINE, "keyedit.prompt", QUIT);
addEntry(QUIT, GET_BOOL, "keyedit.save.okay", SAVE);
#undef addEntry
return tab;
}
const char *GpgSignKeyEditInteractor::action(Error &err) const
{
static const char check_level_strings[][2] = { "0", "1", "2", "3" };
using namespace GpgSignKeyEditInteractor_Private;
using namespace std;
switch (const unsigned int st = state()) {
case COMMAND:
return d->command();
case UIDS_ANSWER_SIGN_ALL:
return answer(d->signAll());
case UIDS_LIST_SEPARATELY_DONE:
return d->command();
case SET_EXPIRE:
return answer(true);
case SET_TRUST_VALUE:
// TODO
case SET_TRUST_DEPTH:
//TODO
case SET_TRUST_REGEXP:
//TODO
return 0;
case SET_CHECK_LEVEL:
return check_level_strings[d->checkLevel];
case CONFIRM:
return answer(true);
case QUIT:
return "quit";
case SAVE:
return answer(true);
default:
if (st >= UIDS_LIST_SEPARATELY && st < UIDS_LIST_SEPARATELY_DONE) {
std::stringstream ss;
ss << d->nextUserID();
d->scratch = ss.str();
return d->scratch.c_str();
}
// fall through
case ERROR:
err = Error::fromCode(GPG_ERR_GENERAL);
return 0;
}
}
unsigned int GpgSignKeyEditInteractor::nextState(unsigned int status, const char *args, Error &err) const
{
d->started = true;
using namespace GpgSignKeyEditInteractor_Private;
static const Error GENERAL_ERROR = Error::fromCode(GPG_ERR_GENERAL);
//static const Error INV_TIME_ERROR = Error::fromCode( GPG_ERR_INV_TIME );
static const TransitionMap table(makeTable());
if (needsNoResponse(status)) {
return state();
}
using namespace GpgSignKeyEditInteractor_Private;
//lookup transition in map
const TransitionMap::const_iterator it = table.find(boost::make_tuple(static_cast<SignKeyState>(state()), status, std::string(args)));
if (it != table.end()) {
return it->second;
}
//handle cases that cannot be handled via the map
switch (const unsigned int st = state()) {
case UIDS_ANSWER_SIGN_ALL:
if (status == GPGME_STATUS_GET_LINE &&
strcmp(args, "keyedit.prompt") == 0) {
if (!d->signAll()) {
return UIDS_LIST_SEPARATELY;
}
err = Error::fromCode(GPG_ERR_UNUSABLE_PUBKEY);
return ERROR;
}
break;
default:
if (st >= UIDS_LIST_SEPARATELY && st < UIDS_LIST_SEPARATELY_DONE) {
if (status == GPGME_STATUS_GET_LINE &&
strcmp(args, "keyedit.prompt") == 0) {
return d->allUserIDsListed() ? UIDS_LIST_SEPARATELY_DONE : st + 1 ;
}
}
break;
case CONFIRM:
case ERROR:
err = lastError();
return ERROR;
}
err = GENERAL_ERROR;
return ERROR;
}
void GpgSignKeyEditInteractor::setCheckLevel(unsigned int checkLevel)
{
assert(!d->started);
assert(checkLevel <= 3);
d->checkLevel = checkLevel;
}
void GpgSignKeyEditInteractor::setUserIDsToSign(const std::vector<unsigned int> &userIDsToSign)
{
assert(!d->started);
d->userIDs = userIDsToSign;
d->nextId = d->userIDs.begin();
d->currentId = d->userIDs.end();
}
void GpgSignKeyEditInteractor::setSigningOptions(int options)
{
assert(!d->started);
d->options = options;
}

64
lang/cpp/src/gpgsignkeyeditinteractor.h Normal file
View File

@ -0,0 +1,64 @@
/*
gpgsignkeyeditinteractor.h - Edit Interactor to change the owner trust of an OpenPGP key
Copyright (C) 2008 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.
*/
#ifndef __GPGMEPP_GPGSIGNKEYEDITINTERACTOR_H__
#define __GPGMEPP_GPGSIGNKEYEDITINTERACTOR_H__
#include <editinteractor.h>
#include <string>
#include <vector>
namespace GpgME
{
class Key;
class UserID;
class GPGMEPP_EXPORT GpgSignKeyEditInteractor : public EditInteractor
{
public:
enum SignOption {
Exportable = 0x1,
NonRevocable = 0x2,
Trust = 0x4
};
GpgSignKeyEditInteractor();
~GpgSignKeyEditInteractor();
void setCheckLevel(unsigned int checkLevel);
void setUserIDsToSign(const std::vector<unsigned int> &userIDsToSign);
void setSigningOptions(int options);
private:
/* reimp */ const char *action(Error &err) const;
/* reimp */ unsigned int nextState(unsigned int statusCode, const char *args, Error &err) const;
private:
class Private;
Private *const d;
};
} // namespace GpgME
#endif // __GPGMEPP_GPGSIGNKEYEDITINTERACTOR_H__

216
lang/cpp/src/importresult.cpp Normal file
View File

@ -0,0 +1,216 @@
/*
importresult.cpp - wraps a gpgme import result
Copyright (C) 2004 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 <config-gpgme++.h>
#include <importresult.h>
#include "result_p.h"
#include <gpgme.h>
#include <cstdlib>
#include <cstring>
#include <string.h>
class GpgME::ImportResult::Private
{
public:
Private(const _gpgme_op_import_result &r) : res(r)
{
// copy recursively, using compiler-generated copy ctor.
// We just need to handle the pointers in the structs:
for (gpgme_import_status_t is = r.imports ; is ; is = is->next) {
gpgme_import_status_t copy = new _gpgme_import_status(*is);
copy->fpr = strdup(is->fpr);
copy->next = 0;
imports.push_back(copy);
}
res.imports = 0;
}
~Private()
{
for (std::vector<gpgme_import_status_t>::iterator it = imports.begin() ; it != imports.end() ; ++it) {
std::free((*it)->fpr);
delete *it; *it = 0;
}
}
_gpgme_op_import_result res;
std::vector<gpgme_import_status_t> imports;
};
GpgME::ImportResult::ImportResult(gpgme_ctx_t ctx, int error)
: GpgME::Result(error), d()
{
init(ctx);
}
GpgME::ImportResult::ImportResult(gpgme_ctx_t ctx, const Error &error)
: GpgME::Result(error), d()
{
init(ctx);
}
void GpgME::ImportResult::init(gpgme_ctx_t ctx)
{
if (!ctx) {
return;
}
gpgme_import_result_t res = gpgme_op_import_result(ctx);
if (!res) {
return;
}
d.reset(new Private(*res));
}
make_standard_stuff(ImportResult)
int GpgME::ImportResult::numConsidered() const
{
return d ? d->res.considered : 0 ;
}
int GpgME::ImportResult::numKeysWithoutUserID() const
{
return d ? d->res.no_user_id : 0 ;
}
int GpgME::ImportResult::numImported() const
{
return d ? d->res.imported : 0 ;
}
int GpgME::ImportResult::numRSAImported() const
{
return d ? d->res.imported_rsa : 0 ;
}
int GpgME::ImportResult::numUnchanged() const
{
return d ? d->res.unchanged : 0 ;
}
int GpgME::ImportResult::newUserIDs() const
{
return d ? d->res.new_user_ids : 0 ;
}
int GpgME::ImportResult::newSubkeys() const
{
return d ? d->res.new_sub_keys : 0 ;
}
int GpgME::ImportResult::newSignatures() const
{
return d ? d->res.new_signatures : 0 ;
}
int GpgME::ImportResult::newRevocations() const
{
return d ? d->res.new_revocations : 0 ;
}
int GpgME::ImportResult::numSecretKeysConsidered() const
{
return d ? d->res.secret_read : 0 ;
}
int GpgME::ImportResult::numSecretKeysImported() const
{
return d ? d->res.secret_imported : 0 ;
}
int GpgME::ImportResult::numSecretKeysUnchanged() const
{
return d ? d->res.secret_unchanged : 0 ;
}
int GpgME::ImportResult::notImported() const
{
return d ? d->res.not_imported : 0 ;
}
GpgME::Import GpgME::ImportResult::import(unsigned int idx) const
{
return Import(d, idx);
}
std::vector<GpgME::Import> GpgME::ImportResult::imports() const
{
if (!d) {
return std::vector<Import>();
}
std::vector<Import> result;
result.reserve(d->imports.size());
for (unsigned int i = 0 ; i < d->imports.size() ; ++i) {
result.push_back(Import(d, i));
}
return result;
}
GpgME::Import::Import(const boost::shared_ptr<ImportResult::Private> &parent, unsigned int i)
: d(parent), idx(i)
{
}
GpgME::Import::Import() : d(), idx(0) {}
bool GpgME::Import::isNull() const
{
return !d || idx >= d->imports.size() ;
}
const char *GpgME::Import::fingerprint() const
{
return isNull() ? 0 : d->imports[idx]->fpr ;
}
GpgME::Error GpgME::Import::error() const
{
return Error(isNull() ? 0 : d->imports[idx]->result);
}
GpgME::Import::Status GpgME::Import::status() const
{
if (isNull()) {
return Unknown;
}
const unsigned int s = d->imports[idx]->status;
unsigned int result = Unknown;
if (s & GPGME_IMPORT_NEW) {
result |= NewKey;
}
if (s & GPGME_IMPORT_UID) {
result |= NewUserIDs;
}
if (s & GPGME_IMPORT_SIG) {
result |= NewSignatures;
}
if (s & GPGME_IMPORT_SUBKEY) {
result |= NewSubkeys;
}
if (s & GPGME_IMPORT_SECRET) {
result |= ContainedSecretKey;
}
return static_cast<Status>(result);
}

134
lang/cpp/src/importresult.h Normal file
View File

@ -0,0 +1,134 @@
/*
importresult.h - wraps a gpgme import result
Copyright (C) 2004 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.
*/
#ifndef __GPGMEPP_IMPORTRESULT_H__
#define __GPGMEPP_IMPORTRESULT_H__
#include "gpgmefw.h"
#include "result.h"
#include "gpgmepp_export.h"
#include <boost/shared_ptr.hpp>
#include <vector>
namespace GpgME
{
class Error;
class Import;
class GPGMEPP_EXPORT ImportResult : public Result
{
public:
ImportResult();
ImportResult(gpgme_ctx_t ctx, int error);
ImportResult(gpgme_ctx_t ctx, const Error &error);
explicit ImportResult(const Error &error);
const ImportResult &operator=(ImportResult other)
{
swap(other);
return *this;
}
void swap(ImportResult &other)
{
Result::swap(other);
using std::swap;
swap(this->d, other.d);
}
bool isNull() const;
int numConsidered() const;
int numKeysWithoutUserID() const;
int numImported() const;
int numRSAImported() const;
int numUnchanged() const;
int newUserIDs() const;
int newSubkeys() const;
int newSignatures() const;
int newRevocations() const;
int numSecretKeysConsidered() const;
int numSecretKeysImported() const;
int numSecretKeysUnchanged() const;
int notImported() const;
Import import(unsigned int idx) const;
std::vector<Import> imports() const;
class Private;
private:
void init(gpgme_ctx_t ctx);
boost::shared_ptr<Private> d;
};
class GPGMEPP_EXPORT Import
{
friend class ::GpgME::ImportResult;
Import(const boost::shared_ptr<ImportResult::Private> &parent, unsigned int idx);
public:
Import();
const Import &operator=(Import other)
{
swap(other);
return *this;
}
void swap(Import &other)
{
using std::swap;
swap(this->d, other.d);
swap(this->idx, other.idx);
}
bool isNull() const;
const char *fingerprint() const;
Error error() const;
enum Status {
Unknown = 0x0,
NewKey = 0x1,
NewUserIDs = 0x2,
NewSignatures = 0x4,
NewSubkeys = 0x8,
ContainedSecretKey = 0x10
};
Status status() const;
private:
boost::shared_ptr<ImportResult::Private> d;
unsigned int idx;
};
}
GPGMEPP_MAKE_STD_SWAP_SPECIALIZATION(ImportResult)
GPGMEPP_MAKE_STD_SWAP_SPECIALIZATION(Import)
#endif // __GPGMEPP_IMPORTRESULT_H__

47
lang/cpp/src/interfaces/assuantransaction.h Normal file
View File

@ -0,0 +1,47 @@
/*
assuantransaction.h - Interface for ASSUAN transactions
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_INTERFACES_ASSUANTRANSACTION_H__
#define __GPGMEPP_INTERFACES_ASSUANTRANSACTION_H__
#include "gpgmepp_export.h"
namespace GpgME
{
class Error;
class Data;
class GPGMEPP_EXPORT AssuanTransaction
{
public:
virtual ~AssuanTransaction() {}
virtual Error data(const char *data, size_t datalen) = 0;
virtual Data inquire(const char *name, const char *args, Error &err) = 0;
virtual Error status(const char *status, const char *args) = 0;
};
} // namespace GpgME
#endif // __GPGMEPP_INTERFACES_ASSUANTRANSACTION_H__

53
lang/cpp/src/interfaces/dataprovider.h Normal file
View File

@ -0,0 +1,53 @@
/*
interface/dataprovider.h - Interface for data sources
Copyright (C) 2003 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.
*/
#ifndef __GPGMEPP_INTERFACES_DATAPROVIDER_H__
#define __GPGMEPP_INTERFACES_DATAPROVIDER_H__
#include <sys/types.h>
#include "gpgmepp_export.h"
#include <gpg-error.h>
namespace GpgME
{
class GPGMEPP_EXPORT DataProvider
{
public:
virtual ~DataProvider() {}
enum Operation {
Read, Write, Seek, Release
};
virtual bool isSupported(Operation op) const = 0;
virtual ssize_t read(void *buffer, size_t bufSize) = 0;
virtual ssize_t write(const void *buffer, size_t bufSize) = 0;
virtual off_t seek(off_t offset, int whence) = 0;
virtual void release() = 0;
};
} // namespace GpgME
#endif // __GPGMEPP_INTERFACES_DATAPROVIDER_H__

40
lang/cpp/src/interfaces/passphraseprovider.h Normal file
View File

@ -0,0 +1,40 @@
/*
interface/passphraseprovider.h - Interface for passphrase callbacks
Copyright (C) 2003,2004 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.
*/
#ifndef __GPGMEPP_INTERFACES_PASSPHRASEPROVIDER_H__
#define __GPGMEPP_INTERFACES_PASSPHRASEPROVIDER_H__
namespace GpgME
{
class PassphraseProvider
{
public:
virtual ~PassphraseProvider() {}
virtual char *getPassphrase(const char *useridHint, const char *description,
bool previousWasBad, bool &canceled) = 0;
};
} // namespace GpgME
#endif // __GPGMEPP_INTERFACES_PASSPHRASEPROVIDER_H__

40
lang/cpp/src/interfaces/progressprovider.h Normal file
View File

@ -0,0 +1,40 @@
/*
interface/progressprovider.h - Interface for progress reports
Copyright (C) 2003 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.
*/
#ifndef __GPGMEPP_INTERFACES_PROGRESSPROVIDER_H__
#define __GPGMEPP_INTERFACES_PROGRESSPROVIDER_H__
namespace GpgME
{
class ProgressProvider
{
public:
virtual ~ProgressProvider() {}
virtual void showProgress(const char *what, int type,
int current, int total) = 0;
};
} // namespace GpgME
#endif // __GPGMEPP_INTERFACES_PROGRESSPROVIDER_H__

847
lang/cpp/src/key.cpp Normal file
View File

@ -0,0 +1,847 @@
/*
key.cpp - wraps a gpgme key
Copyright (C) 2003, 2005 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 "config-gpgme++.h"
#include <key.h>
#include "util.h"
#include <gpgme.h>
#include <string.h>
const GpgME::Key::Null GpgME::Key::null;
namespace GpgME
{
Key::Key() : key() {}
Key::Key(const Null &) : key() {}
Key::Key(const shared_gpgme_key_t &k) : key(k) {}
Key::Key(gpgme_key_t k, bool ref)
: key(k
? shared_gpgme_key_t(k, &gpgme_key_unref)
: shared_gpgme_key_t())
{
if (ref && impl()) {
gpgme_key_ref(impl());
}
}
UserID Key::userID(unsigned int index) const
{
return UserID(key, index);
}
Subkey Key::subkey(unsigned int index) const
{
return Subkey(key, index);
}
unsigned int Key::numUserIDs() const
{
if (!key) {
return 0;
}
unsigned int count = 0;
for (gpgme_user_id_t uid = key->uids ; uid ; uid = uid->next) {
++count;
}
return count;
}
unsigned int Key::numSubkeys() const
{
if (!key) {
return 0;
}
unsigned int count = 0;
for (gpgme_sub_key_t subkey = key->subkeys ; subkey ; subkey = subkey->next) {
++count;
}
return count;
}
std::vector<UserID> Key::userIDs() const
{
if (!key) {
return std::vector<UserID>();
}
std::vector<UserID> v;
v.reserve(numUserIDs());
for (gpgme_user_id_t uid = key->uids ; uid ; uid = uid->next) {
v.push_back(UserID(key, uid));
}
return v;
}
std::vector<Subkey> Key::subkeys() const
{
if (!key) {
return std::vector<Subkey>();
}
std::vector<Subkey> v;
v.reserve(numSubkeys());
for (gpgme_sub_key_t subkey = key->subkeys ; subkey ; subkey = subkey->next) {
v.push_back(Subkey(key, subkey));
}
return v;
}
Key::OwnerTrust Key::ownerTrust() const
{
if (!key) {
return Unknown;
}
switch (key->owner_trust) {
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 Key::ownerTrustAsString() const
{
if (!key) {
return '?';
}
switch (key->owner_trust) {
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';
}
}
Protocol Key::protocol() const
{
if (!key) {
return UnknownProtocol;
}
switch (key->protocol) {
case GPGME_PROTOCOL_CMS: return CMS;
case GPGME_PROTOCOL_OpenPGP: return OpenPGP;
default: return UnknownProtocol;
}
}
const char *Key::protocolAsString() const
{
return key ? gpgme_get_protocol_name(key->protocol) : 0 ;
}
bool Key::isRevoked() const
{
return key && key->revoked;
}
bool Key::isExpired() const
{
return key && key->expired;
}
bool Key::isDisabled() const
{
return key && key->disabled;
}
bool Key::isInvalid() const
{
return key && key->invalid;
}
bool Key::hasSecret() const
{
return key && key->secret;
}
bool Key::isRoot() const
{
return key && key->subkeys && key->subkeys->fpr && key->chain_id &&
strcasecmp(key->subkeys->fpr, key->chain_id) == 0;
}
bool Key::canEncrypt() const
{
return key && key->can_encrypt;
}
bool Key::canSign() const
{
#ifndef GPGME_CAN_SIGN_ON_SECRET_OPENPGP_KEYLISTING_NOT_BROKEN
if (key && key->protocol == GPGME_PROTOCOL_OpenPGP) {
return true;
}
#endif
return canReallySign();
}
bool Key::canReallySign() const
{
return key && key->can_sign;
}
bool Key::canCertify() const
{
return key && key->can_certify;
}
bool Key::canAuthenticate() const
{
return key && key->can_authenticate;
}
bool Key::isQualified() const
{
#ifdef HAVE_GPGME_KEY_T_IS_QUALIFIED
return key && key->is_qualified;
#else
return false;
#endif
}
const char *Key::issuerSerial() const
{
return key ? key->issuer_serial : 0 ;
}
const char *Key::issuerName() const
{
return key ? key->issuer_name : 0 ;
}
const char *Key::chainID() const
{
return key ? key->chain_id : 0 ;
}
const char *Key::keyID() const
{
return key && key->subkeys ? key->subkeys->keyid : 0 ;
}
const char *Key::shortKeyID() const
{
if (!key || !key->subkeys || !key->subkeys->keyid) {
return 0;
}
const int len = strlen(key->subkeys->keyid);
if (len > 8) {
return key->subkeys->keyid + len - 8; // return the last 8 bytes (in hex notation)
} else {
return key->subkeys->keyid;
}
}
const char *Key::primaryFingerprint() const
{
const char *fpr = key && key->subkeys ? key->subkeys->fpr : 0 ;
if (fpr) {
return fpr;
} else {
return keyID();
}
}
unsigned int Key::keyListMode() const
{
return key ? convert_from_gpgme_keylist_mode_t(key->keylist_mode) : 0 ;
}
const Key &Key::mergeWith(const Key &other)
{
// ### incomplete. Just merges has* and can*, nothing else atm
// ### detach also missing
if (!this->primaryFingerprint() ||
!other.primaryFingerprint() ||
strcasecmp(this->primaryFingerprint(), other.primaryFingerprint()) != 0) {
return *this; // only merge the Key object which describe the same key
}
const gpgme_key_t me = impl();
const gpgme_key_t him = other.impl();
if (!me || !him) {
return *this;
}
me->revoked |= him->revoked;
me->expired |= him->expired;
me->disabled |= him->disabled;
me->invalid |= him->invalid;
me->can_encrypt |= him->can_encrypt;
me->can_sign |= him->can_sign;
me->can_certify |= him->can_certify;
me->secret |= him->secret;
me->can_authenticate |= him->can_authenticate;
#ifdef HAVE_GPGME_KEY_T_IS_QUALIFIED
me->is_qualified |= him->is_qualified;
#endif
me->keylist_mode |= him->keylist_mode;
#ifdef HAVE_GPGME_SUBKEY_T_IS_CARDKEY
// make sure the gpgme_sub_key_t::is_cardkey flag isn't lost:
for (gpgme_sub_key_t mysk = me->subkeys ; mysk ; mysk = mysk->next) {
for (gpgme_sub_key_t hissk = him->subkeys ; hissk ; hissk = hissk->next) {
if (strcmp(mysk->fpr, hissk->fpr) == 0) {
mysk->is_cardkey |= hissk->is_cardkey;
break;
}
}
}
#endif
return *this;
}
//
//
// class Subkey
//
//
gpgme_sub_key_t find_subkey(const shared_gpgme_key_t &key, unsigned int idx)
{
if (key) {
for (gpgme_sub_key_t s = key->subkeys ; s ; s = s->next, --idx) {
if (idx == 0) {
return s;
}
}
}
return 0;
}
gpgme_sub_key_t verify_subkey(const shared_gpgme_key_t &key, gpgme_sub_key_t subkey)
{
if (key) {
for (gpgme_sub_key_t s = key->subkeys ; s ; s = s->next) {
if (s == subkey) {
return subkey;
}
}
}
return 0;
}
Subkey::Subkey() : key(), subkey(0) {}
Subkey::Subkey(const shared_gpgme_key_t &k, unsigned int idx)
: key(k), subkey(find_subkey(k, idx))
{
}
Subkey::Subkey(const shared_gpgme_key_t &k, gpgme_sub_key_t sk)
: key(k), subkey(verify_subkey(k, sk))
{
}
Key Subkey::parent() const
{
return Key(key);
}
const char *Subkey::keyID() const
{
return subkey ? subkey->keyid : 0 ;
}
const char *Subkey::fingerprint() const
{
return subkey ? subkey->fpr : 0 ;
}
unsigned int Subkey::publicKeyAlgorithm() const
{
return subkey ? subkey->pubkey_algo : 0 ;
}
const char *Subkey::publicKeyAlgorithmAsString() const
{
return gpgme_pubkey_algo_name(subkey ? subkey->pubkey_algo : (gpgme_pubkey_algo_t)0);
}
bool Subkey::canEncrypt() const
{
return subkey && subkey->can_encrypt;
}
bool Subkey::canSign() const
{
return subkey && subkey->can_sign;
}
bool Subkey::canCertify() const
{
return subkey && subkey->can_certify;
}
bool Subkey::canAuthenticate() const
{
return subkey && subkey->can_authenticate;
}
bool Subkey::isQualified() const
{
#ifdef HAVE_GPGME_SUBKEY_T_IS_QUALIFIED
return subkey && subkey->is_qualified;
#else
return false;
#endif
}
bool Subkey::isCardKey() const
{
#ifdef HAVE_GPGME_SUBKEY_T_IS_CARDKEY
return subkey && subkey->is_cardkey;
#else
return false;
#endif
}
const char *Subkey::cardSerialNumber() const
{
#ifdef HAVE_GPGME_SUBKEY_T_IS_CARDKEY
return subkey ? subkey->card_number : 0 ;
#else
return 0;
#endif
}
bool Subkey::isSecret() const
{
return subkey && subkey->secret;
}
unsigned int Subkey::length() const
{
return subkey ? subkey->length : 0 ;
}
time_t Subkey::creationTime() const
{
return static_cast<time_t>(subkey ? subkey->timestamp : 0);
}
time_t Subkey::expirationTime() const
{
return static_cast<time_t>(subkey ? subkey->expires : 0);
}
bool Subkey::neverExpires() const
{
return expirationTime() == time_t(0);
}
bool Subkey::isRevoked() const
{
return subkey && subkey->revoked;
}
bool Subkey::isInvalid() const
{
return subkey && subkey->invalid;
}
bool Subkey::isExpired() const
{
return subkey && subkey->expired;
}
bool Subkey::isDisabled() const
{
return subkey && subkey->disabled;
}
//
//
// class UserID
//
//
gpgme_user_id_t find_uid(const shared_gpgme_key_t &key, unsigned int idx)
{
if (key) {
for (gpgme_user_id_t u = key->uids ; u ; u = u->next, --idx) {
if (idx == 0) {
return u;
}
}
}
return 0;
}
gpgme_user_id_t verify_uid(const shared_gpgme_key_t &key, gpgme_user_id_t uid)
{
if (key) {
for (gpgme_user_id_t u = key->uids ; u ; u = u->next) {
if (u == uid) {
return uid;
}
}
}
return 0;
}
UserID::UserID() : key(), uid(0) {}
UserID::UserID(const shared_gpgme_key_t &k, gpgme_user_id_t u)
: key(k), uid(verify_uid(k, u))
{
}
UserID::UserID(const shared_gpgme_key_t &k, unsigned int idx)
: key(k), uid(find_uid(k, idx))
{
}
Key UserID::parent() const
{
return Key(key);
}
UserID::Signature UserID::signature(unsigned int index) const
{
return Signature(key, uid, index);
}
unsigned int UserID::numSignatures() const
{
if (!uid) {
return 0;
}
unsigned int count = 0;
for (gpgme_key_sig_t sig = uid->signatures ; sig ; sig = sig->next) {
++count;
}
return count;
}
std::vector<UserID::Signature> UserID::signatures() const
{
if (!uid) {
return std::vector<Signature>();
}
std::vector<Signature> v;
v.reserve(numSignatures());
for (gpgme_key_sig_t sig = uid->signatures ; sig ; sig = sig->next) {
v.push_back(Signature(key, uid, sig));
}
return v;
}
const char *UserID::id() const
{
return uid ? uid->uid : 0 ;
}
const char *UserID::name() const
{
return uid ? uid->name : 0 ;
}
const char *UserID::email() const
{
return uid ? uid->email : 0 ;
}
const char *UserID::comment() const
{
return uid ? uid->comment : 0 ;
}
UserID::Validity UserID::validity() const
{
if (!uid) {
return Unknown;
}
switch (uid->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 UserID::validityAsString() const
{
if (!uid) {
return '?';
}
switch (uid->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';
}
}
bool UserID::isRevoked() const
{
return uid && uid->revoked;
}
bool UserID::isInvalid() const
{
return uid && uid->invalid;
}
//
//
// class Signature
//
//
gpgme_key_sig_t find_signature(gpgme_user_id_t uid, unsigned int idx)
{
if (uid) {
for (gpgme_key_sig_t s = uid->signatures ; s ; s = s->next, --idx) {
if (idx == 0) {
return s;
}
}
}
return 0;
}
gpgme_key_sig_t verify_signature(gpgme_user_id_t uid, gpgme_key_sig_t sig)
{
if (uid) {
for (gpgme_key_sig_t s = uid->signatures ; s ; s = s->next) {
if (s == sig) {
return sig;
}
}
}
return 0;
}
UserID::Signature::Signature() : key(), uid(0), sig(0) {}
UserID::Signature::Signature(const shared_gpgme_key_t &k, gpgme_user_id_t u, unsigned int idx)
: key(k), uid(verify_uid(k, u)), sig(find_signature(uid, idx))
{
}
UserID::Signature::Signature(const shared_gpgme_key_t &k, gpgme_user_id_t u, gpgme_key_sig_t s)
: key(k), uid(verify_uid(k, u)), sig(verify_signature(uid, s))
{
}
UserID UserID::Signature::parent() const
{
return UserID(key, uid);
}
const char *UserID::Signature::signerKeyID() const
{
return sig ? sig->keyid : 0 ;
}
const char *UserID::Signature::algorithmAsString() const
{
return gpgme_pubkey_algo_name(sig ? sig->pubkey_algo : (gpgme_pubkey_algo_t)0);
}
unsigned int UserID::Signature::algorithm() const
{
return sig ? sig->pubkey_algo : 0 ;
}
time_t UserID::Signature::creationTime() const
{
return static_cast<time_t>(sig ? sig->timestamp : 0);
}
time_t UserID::Signature::expirationTime() const
{
return static_cast<time_t>(sig ? sig->expires : 0);
}
bool UserID::Signature::neverExpires() const
{
return expirationTime() == time_t(0);
}
bool UserID::Signature::isRevokation() const
{
return sig && sig->revoked;
}
bool UserID::Signature::isInvalid() const
{
return sig && sig->invalid;
}
bool UserID::Signature::isExpired() const
{
return sig && sig->expired;
}
bool UserID::Signature::isExportable() const
{
return sig && sig->exportable;
}
const char *UserID::Signature::signerUserID() const
{
return sig ? sig->uid : 0 ;
}
const char *UserID::Signature::signerName() const
{
return sig ? sig->name : 0 ;
}
const char *UserID::Signature::signerEmail() const
{
return sig ? sig->email : 0 ;
}
const char *UserID::Signature::signerComment() const
{
return sig ? sig->comment : 0 ;
}
unsigned int UserID::Signature::certClass() const
{
return sig ? sig->sig_class : 0 ;
}
UserID::Signature::Status UserID::Signature::status() const
{
if (!sig) {
return GeneralError;
}
switch (gpgme_err_code(sig->status)) {
case GPG_ERR_NO_ERROR: return NoError;
case GPG_ERR_SIG_EXPIRED: return SigExpired;
case GPG_ERR_KEY_EXPIRED: return KeyExpired;
case GPG_ERR_BAD_SIGNATURE: return BadSignature;
case GPG_ERR_NO_PUBKEY: return NoPublicKey;
default:
case GPG_ERR_GENERAL: return GeneralError;
}
}
std::string UserID::Signature::statusAsString() const
{
if (!sig) {
return std::string();
}
char buf[ 1024 ];
gpgme_strerror_r(sig->status, buf, sizeof buf);
buf[ sizeof buf - 1 ] = '\0';
return std::string(buf);
}
GpgME::Notation UserID::Signature::notation(unsigned int idx) const
{
if (!sig) {
return GpgME::Notation();
}
#ifdef HAVE_GPGME_KEY_SIG_NOTATIONS
for (gpgme_sig_notation_t nota = sig->notations ; nota ; nota = nota->next) {
if (nota->name) {
if (idx-- == 0) {
return GpgME::Notation(nota);
}
}
}
#endif
return GpgME::Notation();
}
unsigned int UserID::Signature::numNotations() const
{
if (!sig) {
return 0;
}
unsigned int count = 0;
#ifdef HAVE_GPGME_KEY_SIG_NOTATIONS
for (gpgme_sig_notation_t nota = sig->notations ; nota ; nota = nota->next) {
if (nota->name) {
++count; // others are policy URLs...
}
}
#endif
return count;
}
std::vector<Notation> UserID::Signature::notations() const
{
if (!sig) {
return std::vector<GpgME::Notation>();
}
std::vector<GpgME::Notation> v;
#ifdef HAVE_GPGME_KEY_SIG_NOTATIONS
v.reserve(numNotations());
for (gpgme_sig_notation_t nota = sig->notations ; nota ; nota = nota->next) {
if (nota->name) {
v.push_back(GpgME::Notation(nota));
}
}
#endif
return v;
}
const char *UserID::Signature::policyURL() const
{
#ifdef HAVE_GPGME_KEY_SIG_NOTATIONS
if (!sig) {
return 0;
}
for (gpgme_sig_notation_t nota = sig->notations ; nota ; nota = nota->next) {
if (!nota->name) {
return nota->value;
}
}
#endif
return 0;
}
} // namespace GpgME

358
lang/cpp/src/key.h Normal file
View File

@ -0,0 +1,358 @@
/*
key.h - wraps a gpgme key
Copyright (C) 2003, 2005 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_KEY_H__
#define __GPGMEPP_KEY_H__
#include "global.h"
#include "notation.h"
#include "gpgmefw.h"
#include <boost/shared_ptr.hpp>
#include <boost/type_traits/remove_pointer.hpp>
#include <sys/time.h>
#include <vector>
#include <algorithm>
#include <string>
namespace GpgME
{
class Context;
class Subkey;
class UserID;
typedef boost::shared_ptr< boost::remove_pointer<gpgme_key_t>::type > shared_gpgme_key_t;
//
// class Key
//
class GPGMEPP_EXPORT Key
{
friend class ::GpgME::Context;
struct Null {
Null() {}
};
public:
Key();
/* implicit */ Key(const Null &);
Key(const shared_gpgme_key_t &key);
Key(gpgme_key_t key, bool acquireRef);
static const Null null;
const Key &operator=(Key other)
{
swap(other);
return *this;
}
const Key &mergeWith(const Key &other);
void swap(Key &other)
{
using std::swap;
swap(this->key, other.key);
}
bool isNull() const
{
return !key;
}
UserID userID(unsigned int index) const;
Subkey subkey(unsigned int index) const;
unsigned int numUserIDs() const;
unsigned int numSubkeys() const;
std::vector<UserID> userIDs() const;
std::vector<Subkey> subkeys() const;
bool isRevoked() const;
bool isExpired() const;
bool isDisabled() const;
bool isInvalid() const;
bool canEncrypt() const;
/*!
This function contains a workaround for old gpgme's: all secret
OpenPGP keys canSign() == true, which canReallySign() doesn't
have. I don't have time to find what breaks when I remove this
workaround, but since Kleopatra merges secret into public keys,
the workaround is not necessary there (and actively harms), I've
added a new function instead.
*/
bool canSign() const;
bool canReallySign() const;
bool canCertify() const;
bool canAuthenticate() const;
bool isQualified() const;
bool hasSecret() const;
GPGMEPP_DEPRECATED bool isSecret() const
{
return hasSecret();
}
/*!
@return true if this is a X.509 root certificate (currently
equivalent to something like
strcmp( chainID(), subkey(0).fingerprint() ) == 0 )
*/
bool isRoot() const;
enum OwnerTrust { Unknown = 0, Undefined = 1, Never = 2,
Marginal = 3, Full = 4, Ultimate = 5
};
OwnerTrust ownerTrust() const;
char ownerTrustAsString() const;
Protocol protocol() const;
const char *protocolAsString() const;
const char *issuerSerial() const;
const char *issuerName() const;
const char *chainID() const;
const char *keyID() const;
const char *shortKeyID() const;
const char *primaryFingerprint() const;
unsigned int keyListMode() const;
private:
gpgme_key_t impl() const
{
return key.get();
}
shared_gpgme_key_t key;
};
//
// class Subkey
//
class GPGMEPP_EXPORT Subkey
{
public:
Subkey();
Subkey(const shared_gpgme_key_t &key, gpgme_sub_key_t subkey);
Subkey(const shared_gpgme_key_t &key, unsigned int idx);
const Subkey &operator=(Subkey other)
{
swap(other);
return *this;
}
void swap(Subkey &other)
{
using std::swap;
swap(this->key, other.key);
swap(this->subkey, other.subkey);
}
bool isNull() const
{
return !key || !subkey;
}
Key parent() const;
const char *keyID() const;
const char *fingerprint() const;
time_t creationTime() const;
time_t expirationTime() const;
bool neverExpires() const;
bool isRevoked() const;
bool isExpired() const;
bool isInvalid() const;
bool isDisabled() const;
bool canEncrypt() const;
bool canSign() const;
bool canCertify() const;
bool canAuthenticate() const;
bool isQualified() const;
bool isCardKey() const;
bool isSecret() const;
unsigned int publicKeyAlgorithm() const;
const char *publicKeyAlgorithmAsString() const;
unsigned int length() const;
const char *cardSerialNumber() const;
private:
shared_gpgme_key_t key;
gpgme_sub_key_t subkey;
};
//
// class UserID
//
class GPGMEPP_EXPORT UserID
{
public:
class Signature;
UserID();
UserID(const shared_gpgme_key_t &key, gpgme_user_id_t uid);
UserID(const shared_gpgme_key_t &key, unsigned int idx);
const UserID &operator=(UserID other)
{
swap(other);
return *this;
}
void swap(UserID &other)
{
using std::swap;
swap(this->key, other.key);
swap(this->uid, other.uid);
}
bool isNull() const
{
return !key || !uid;
}
Key parent() const;
unsigned int numSignatures() const;
Signature signature(unsigned int index) const;
std::vector<Signature> signatures() const;
const char *id() const;
const char *name() const;
const char *email() const;
const char *comment() const;
enum Validity { Unknown = 0, Undefined = 1, Never = 2,
Marginal = 3, Full = 4, Ultimate = 5
};
Validity validity() const;
char validityAsString() const;
bool isRevoked() const;
bool isInvalid() const;
private:
shared_gpgme_key_t key;
gpgme_user_id_t uid;
};
//
// class UserID::Signature
//
class GPGMEPP_EXPORT UserID::Signature
{
public:
typedef GPGMEPP_DEPRECATED GpgME::Notation Notation;
Signature();
Signature(const shared_gpgme_key_t &key, gpgme_user_id_t uid, gpgme_key_sig_t sig);
Signature(const shared_gpgme_key_t &key, gpgme_user_id_t uid, unsigned int idx);
const Signature &operator=(Signature other)
{
swap(other);
return *this;
}
void swap(Signature &other)
{
using std::swap;
swap(this->key, other.key);
swap(this->uid, other.uid);
swap(this->sig, other.sig);
}
bool isNull() const
{
return !sig || !uid || !key ;
}
UserID parent() const;
const char *signerKeyID() const;
const char *algorithmAsString() const;
unsigned int algorithm() const;
time_t creationTime() const;
time_t expirationTime() const;
bool neverExpires() const;
bool isRevokation() const;
bool isInvalid() const;
bool isExpired() const;
bool isExportable() const;
const char *signerUserID() const;
const char *signerName() const;
const char *signerEmail() const;
const char *signerComment() const;
unsigned int certClass() const;
enum Status { NoError = 0, SigExpired, KeyExpired,
BadSignature, NoPublicKey, GeneralError
};
Status status() const;
std::string statusAsString() const;
const char *policyURL() const;
unsigned int numNotations() const;
GpgME::Notation notation(unsigned int idx) const;
std::vector<GpgME::Notation> notations() const;
private:
shared_gpgme_key_t key;
gpgme_user_id_t uid;
gpgme_key_sig_t sig;
};
} // namespace GpgME
GPGMEPP_MAKE_STD_SWAP_SPECIALIZATION(Key)
GPGMEPP_MAKE_STD_SWAP_SPECIALIZATION(Subkey)
GPGMEPP_MAKE_STD_SWAP_SPECIALIZATION(UserID)
GPGMEPP_MAKE_STD_SWAP_SPECIALIZATION(UserID::Signature)
#endif // __GPGMEPP_KEY_H__

94
lang/cpp/src/keygenerationresult.cpp Normal file
View File

@ -0,0 +1,94 @@
/*
keygenerationresult.cpp - wraps a gpgme keygen result
Copyright (C) 2004 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 <config-gpgme++.h>
#include <keygenerationresult.h>
#include "result_p.h"
#include <gpgme.h>
#include <cstring>
#include <cstdlib>
#include <string.h>
class GpgME::KeyGenerationResult::Private
{
public:
Private(const _gpgme_op_genkey_result &r) : res(r)
{
if (res.fpr) {
res.fpr = strdup(res.fpr);
}
}
~Private()
{
if (res.fpr) {
std::free(res.fpr);
}
res.fpr = 0;
}
_gpgme_op_genkey_result res;
};
GpgME::KeyGenerationResult::KeyGenerationResult(gpgme_ctx_t ctx, int error)
: GpgME::Result(error), d()
{
init(ctx);
}
GpgME::KeyGenerationResult::KeyGenerationResult(gpgme_ctx_t ctx, const Error &error)
: GpgME::Result(error), d()
{
init(ctx);
}
void GpgME::KeyGenerationResult::init(gpgme_ctx_t ctx)
{
if (!ctx) {
return;
}
gpgme_genkey_result_t res = gpgme_op_genkey_result(ctx);
if (!res) {
return;
}
d.reset(new Private(*res));
}
make_standard_stuff(KeyGenerationResult)
bool GpgME::KeyGenerationResult::isPrimaryKeyGenerated() const
{
return d && d->res.primary;
}
bool GpgME::KeyGenerationResult::isSubkeyGenerated() const
{
return d && d->res.sub;
}
const char *GpgME::KeyGenerationResult::fingerprint() const
{
return d ? d->res.fpr : 0 ;
}

82
lang/cpp/src/keygenerationresult.h Normal file
View File

@ -0,0 +1,82 @@
/*
keygenerationresult.h - wraps a gpgme keygen result
Copyright (C) 2004 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.
*/
#ifndef __GPGMEPP_KEYGENERATIONRESULT_H__
#define __GPGMEPP_KEYGENERATIONRESULT_H__
#include "gpgmefw.h"
#include "result.h"
#include "gpgmepp_export.h"
#include <boost/shared_ptr.hpp>
namespace GpgME
{
class Error;
class GPGMEPP_EXPORT KeyGenerationResult : public Result
{
public:
KeyGenerationResult();
KeyGenerationResult(gpgme_ctx_t ctx, int error);
KeyGenerationResult(gpgme_ctx_t ctx, const Error &error);
explicit KeyGenerationResult(const Error &err);
const KeyGenerationResult &operator=(KeyGenerationResult other)
{
swap(other);
return *this;
}
void swap(KeyGenerationResult &other)
{
Result::swap(other);
using std::swap;
swap(this->d, other.d);
}
bool isNull() const;
GPGMEPP_DEPRECATED bool primaryKeyGenerated() const
{
return isPrimaryKeyGenerated();
}
GPGMEPP_DEPRECATED bool subkeyGenerated() const
{
return isSubkeyGenerated();
}
bool isPrimaryKeyGenerated() const;
bool isSubkeyGenerated() const;
const char *fingerprint() const;
private:
class Private;
void init(gpgme_ctx_t ctx);
boost::shared_ptr<Private> d;
};
}
GPGMEPP_MAKE_STD_SWAP_SPECIALIZATION(KeyGenerationResult)
#endif // __GPGMEPP_KEYGENERATIONRESULT_H__

109
lang/cpp/src/keylistresult.cpp Normal file
View File

@ -0,0 +1,109 @@
/*
keylistresult.cpp - wraps a gpgme keylist result
Copyright (C) 2004 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 <config-gpgme++.h>
#include <keylistresult.h>
#include "result_p.h"
#include <gpgme.h>
#include <cstring>
#include <cassert>
class GpgME::KeyListResult::Private
{
public:
Private(const _gpgme_op_keylist_result &r) : res(r) {}
Private(const Private &other) : res(other.res) {}
_gpgme_op_keylist_result res;
};
GpgME::KeyListResult::KeyListResult(gpgme_ctx_t ctx, int error)
: GpgME::Result(error), d()
{
init(ctx);
}
GpgME::KeyListResult::KeyListResult(gpgme_ctx_t ctx, const Error &error)
: GpgME::Result(error), d()
{
init(ctx);
}
void GpgME::KeyListResult::init(gpgme_ctx_t ctx)
{
if (!ctx) {
return;
}
gpgme_keylist_result_t res = gpgme_op_keylist_result(ctx);
if (!res) {
return;
}
d.reset(new Private(*res));
}
GpgME::KeyListResult::KeyListResult(const Error &error, const _gpgme_op_keylist_result &res)
: GpgME::Result(error), d(new Private(res))
{
}
make_standard_stuff(KeyListResult)
void GpgME::KeyListResult::detach()
{
if (!d || d.unique()) {
return;
}
d.reset(new Private(*d));
}
void GpgME::KeyListResult::mergeWith(const KeyListResult &other)
{
if (other.isNull()) {
return;
}
if (isNull()) { // just assign
operator=(other);
return;
}
// merge the truncated flag (try to keep detaching to a minimum):
if (other.isTruncated() && !this->isTruncated()) {
assert(other.d);
detach();
if (!d) {
d.reset(new Private(*other.d));
} else {
d->res.truncated = true;
}
}
if (! bool(error())) { // only merge the error when there was none yet.
Result::operator=(other);
}
}
bool GpgME::KeyListResult::isTruncated() const
{
return d && d->res.truncated;
}

81
lang/cpp/src/keylistresult.h Normal file
View File

@ -0,0 +1,81 @@
/*
keylistresult.h - wraps a gpgme keylist result
Copyright (C) 2004 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.
*/
#ifndef __GPGMEPP_KEYLISTRESULT_H__
#define __GPGMEPP_KEYLISTRESULT_H__
#include "gpgmefw.h"
#include "result.h"
#include "gpgmepp_export.h"
#include <boost/shared_ptr.hpp>
namespace GpgME
{
class Error;
class GPGMEPP_EXPORT KeyListResult : public Result
{
public:
KeyListResult();
KeyListResult(gpgme_ctx_t ctx, int error);
KeyListResult(gpgme_ctx_t ctx, const Error &error);
explicit KeyListResult(const Error &err);
KeyListResult(const Error &err, const _gpgme_op_keylist_result &res);
const KeyListResult &operator=(KeyListResult other)
{
swap(other);
return *this;
}
void swap(KeyListResult &other)
{
Result::swap(other);
using std::swap;
swap(this->d, other.d);
}
const KeyListResult &operator+=(const KeyListResult &other)
{
mergeWith(other);
return *this;
}
void mergeWith(const KeyListResult &other);
bool isNull() const;
bool isTruncated() const;
private:
void detach();
void init(gpgme_ctx_t ctx);
class Private;
boost::shared_ptr<Private> d;
};
}
GPGMEPP_MAKE_STD_SWAP_SPECIALIZATION(KeyListResult)
#endif // __GPGMEPP_KEYLISTRESULT_H__

84
lang/cpp/src/notation.h Normal file
View File

@ -0,0 +1,84 @@
/*
notation.h - wraps a gpgme verify result
Copyright (C) 2004, 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.
*/
#ifndef __GPGMEPP_NOTATION_H__
#define __GPGMEPP_NOTATION_H__
#include "gpgmefw.h"
#include "verificationresult.h"
#include "gpgmepp_export.h"
#include <boost/shared_ptr.hpp>
#include <iosfwd>
namespace GpgME
{
class GPGMEPP_EXPORT Notation
{
friend class ::GpgME::Signature;
Notation(const boost::shared_ptr<VerificationResult::Private> &parent, unsigned int sindex, unsigned int nindex);
public:
Notation();
explicit Notation(gpgme_sig_notation_t nota);
const Notation &operator=(Notation other)
{
swap(other);
return *this;
}
void swap(Notation &other)
{
using std::swap;
swap(this->d, other.d);
}
bool isNull() const;
const char *name() const;
const char *value() const;
enum Flags {
NoFlags = 0,
HumanReadable = 1,
Critical = 2
};
Flags flags() const;
bool isHumanReadable() const;
bool isCritical() const;
private:
class Private;
boost::shared_ptr<Private> d;
};
GPGMEPP_EXPORT std::ostream &operator<<(std::ostream &os, const Notation &nota);
GPGMEPP_EXPORT std::ostream &operator<<(std::ostream &os, Notation::Flags flags);
}
GPGMEPP_MAKE_STD_SWAP_SPECIALIZATION(Notation)
#endif // __GPGMEPP_NOTATION_H__

58
lang/cpp/src/result.h Normal file
View File

@ -0,0 +1,58 @@
/*
result.h - base class for results
Copyright (C) 2004 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.
*/
#ifndef __GPGMEPP_RESULT_H__
#define __GPGMEPP_RESULT_H__
#include "gpgmefw.h"
#include "error.h"
#include <algorithm> // std::swap
namespace GpgME
{
class GPGMEPP_EXPORT Result
{
protected:
explicit Result() : mError() {}
explicit Result(int error) : mError(error) {}
explicit Result(const Error &error) : mError(error) {}
void swap(Result &other)
{
std::swap(other.mError, mError);
}
public:
const Error &error() const
{
return mError;
}
protected:
Error mError;
};
}
#endif // __GPGMEPP_RESULT_H__

43
lang/cpp/src/result_p.h Normal file
View File

@ -0,0 +1,43 @@
/*
result.h - base class for results
Copyright (C) 2004 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.
*/
#ifndef __GPGMEPP_RESULT_P_H__
#define __GPGMEPP_RESULT_P_H__
#define make_default_ctor(x) \
GpgME::x::x() : GpgME::Result(), d() {}
#define make_error_ctor(x) \
GpgME::x::x( const Error & error ) \
: GpgME::Result( error ), d() \
{ \
\
}
#define make_isNull(x) bool GpgME::x::isNull() const { return !d && !bool(error()); }
#define make_standard_stuff(x) \
make_default_ctor(x) \
make_error_ctor(x) \
make_isNull(x)
#endif // __GPGMEPP_RESULT_P_H__

156
lang/cpp/src/scdgetinfoassuantransaction.cpp Normal file
View File

@ -0,0 +1,156 @@
/*
scdgetinfoassuantransaction.cpp - Assuan Transaction to get information from scdaemon
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 <config-gpgme++.h>
#include "scdgetinfoassuantransaction.h"
#include "error.h"
#include "data.h"
#include "util.h"
#include <boost/algorithm/string/split.hpp>
#include <boost/algorithm/string/classification.hpp>
#include <boost/static_assert.hpp>
#include <sstream>
using namespace GpgME;
using namespace boost;
ScdGetInfoAssuanTransaction::ScdGetInfoAssuanTransaction(InfoItem item)
: AssuanTransaction(),
m_item(item),
m_command(),
m_data()
{
}
ScdGetInfoAssuanTransaction::~ScdGetInfoAssuanTransaction() {}
static std::vector<std::string> to_reader_list(const std::string &s)
{
std::vector<std::string> result;
return split(result, s, is_any_of("\n"), token_compress_on);
}
static std::vector<std::string> to_app_list(const std::string &s)
{
return to_reader_list(s);
}
std::string ScdGetInfoAssuanTransaction::version() const
{
if (m_item == Version) {
return m_data;
} else {
return std::string();
}
}
unsigned int ScdGetInfoAssuanTransaction::pid() const
{
if (m_item == Pid) {
return to_pid(m_data);
} else {
return 0U;
}
}
std::string ScdGetInfoAssuanTransaction::socketName() const
{
if (m_item == SocketName) {
return m_data;
} else {
return std::string();
}
}
char ScdGetInfoAssuanTransaction::status() const
{
if (m_item == Status && !m_data.empty()) {
return m_data[0];
} else {
return '\0';
}
}
std::vector<std::string> ScdGetInfoAssuanTransaction::readerList() const
{
if (m_item == ReaderList) {
return to_reader_list(m_data);
} else {
return std::vector<std::string>();
}
}
std::vector<std::string> ScdGetInfoAssuanTransaction::applicationList() const
{
if (m_item == ApplicationList) {
return to_app_list(m_data);
} else {
return std::vector<std::string>();
}
}
static const char *const scd_getinfo_tokens[] = {
"version",
"pid",
"socket_name",
"status",
"reader_list",
"deny_admin",
"app_list",
};
BOOST_STATIC_ASSERT((sizeof scd_getinfo_tokens / sizeof * scd_getinfo_tokens == ScdGetInfoAssuanTransaction::LastInfoItem));
void ScdGetInfoAssuanTransaction::makeCommand() const
{
assert(m_item >= 0);
assert(m_item < LastInfoItem);
m_command = "SCD GETINFO ";
m_command += scd_getinfo_tokens[m_item];
}
const char *ScdGetInfoAssuanTransaction::command() const
{
makeCommand();
return m_command.c_str();
}
Error ScdGetInfoAssuanTransaction::data(const char *data, size_t len)
{
m_data.append(data, len);
return Error();
}
Data ScdGetInfoAssuanTransaction::inquire(const char *name, const char *args, Error &err)
{
(void)name; (void)args; (void)err;
return Data::null;
}
Error ScdGetInfoAssuanTransaction::status(const char *status, const char *args)
{
(void)status; (void)args;
return Error();
}

76
lang/cpp/src/scdgetinfoassuantransaction.h Normal file
View File

@ -0,0 +1,76 @@
/*
scdgetinfoassuantransaction.h - Assuan Transaction to get information from scdaemon
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.
*/
#ifndef __GPGMEPP_SCDGETINFOASSUANTRANSACTION_H__
#define __GPGMEPP_SCDGETINFOASSUANTRANSACTION_H__
#include <interfaces/assuantransaction.h>
#include <string>
#include <vector>
namespace GpgME
{
class GPGMEPP_EXPORT ScdGetInfoAssuanTransaction : public AssuanTransaction
{
public:
enum InfoItem {
Version, // string
Pid, // unsigned long
SocketName, // string (path)
Status, // char (status)
ReaderList, // string list
DenyAdmin, // (none, returns GPG_ERR_GENERAL when admin commands are allowed)
ApplicationList, // string list
LastInfoItem
};
explicit ScdGetInfoAssuanTransaction(InfoItem item);
~ScdGetInfoAssuanTransaction();
std::string version() const;
unsigned int pid() const;
std::string socketName() const;
char status() const;
std::vector<std::string> readerList() const;
std::vector<std::string> applicationList() const;
private:
/* reimp */ const char *command() const;
/* reimp */ Error data(const char *data, size_t datalen);
/* reimp */ Data inquire(const char *name, const char *args, Error &err);
/* reimp */ Error status(const char *status, const char *args);
private:
void makeCommand() const;
private:
InfoItem m_item;
mutable std::string m_command;
std::string m_data;
};
} // namespace GpgME
#endif // __GPGMEPP_SCDGETINFOASSUANTRANSACTION_H__

267
lang/cpp/src/signingresult.cpp Normal file
View File

@ -0,0 +1,267 @@
/*
signingresult.cpp - wraps a gpgme verify result
Copyright (C) 2004 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 <config-gpgme++.h>
#include <signingresult.h>
#include "result_p.h"
#include "util.h"
#include <gpgme.h>
#include <cstring>
#include <cstdlib>
#include <algorithm>
#include <istream>
#include <iterator>
#include <string.h>
class GpgME::SigningResult::Private
{
public:
Private(const gpgme_sign_result_t r)
{
if (!r) {
return;
}
for (gpgme_new_signature_t is = r->signatures ; is ; is = is->next) {
gpgme_new_signature_t copy = new _gpgme_new_signature(*is);
if (is->fpr) {
copy->fpr = strdup(is->fpr);
}
copy->next = 0;
created.push_back(copy);
}
for (gpgme_invalid_key_t ik = r->invalid_signers ; ik ; ik = ik->next) {
gpgme_invalid_key_t copy = new _gpgme_invalid_key(*ik);
if (ik->fpr) {
copy->fpr = strdup(ik->fpr);
}
copy->next = 0;
invalid.push_back(copy);
}
}
~Private()
{
for (std::vector<gpgme_new_signature_t>::iterator it = created.begin() ; it != created.end() ; ++it) {
std::free((*it)->fpr);
delete *it; *it = 0;
}
for (std::vector<gpgme_invalid_key_t>::iterator it = invalid.begin() ; it != invalid.end() ; ++it) {
std::free((*it)->fpr);
delete *it; *it = 0;
}
}
std::vector<gpgme_new_signature_t> created;
std::vector<gpgme_invalid_key_t> invalid;
};
GpgME::SigningResult::SigningResult(gpgme_ctx_t ctx, int error)
: GpgME::Result(error), d()
{
init(ctx);
}
GpgME::SigningResult::SigningResult(gpgme_ctx_t ctx, const Error &error)
: GpgME::Result(error), d()
{
init(ctx);
}
void GpgME::SigningResult::init(gpgme_ctx_t ctx)
{
if (!ctx) {
return;
}
gpgme_sign_result_t res = gpgme_op_sign_result(ctx);
if (!res) {
return;
}
d.reset(new Private(res));
}
make_standard_stuff(SigningResult)
GpgME::CreatedSignature GpgME::SigningResult::createdSignature(unsigned int idx) const
{
return CreatedSignature(d, idx);
}
std::vector<GpgME::CreatedSignature> GpgME::SigningResult::createdSignatures() const
{
if (!d) {
return std::vector<CreatedSignature>();
}
std::vector<CreatedSignature> result;
result.reserve(d->created.size());
for (unsigned int i = 0 ; i < d->created.size() ; ++i) {
result.push_back(CreatedSignature(d, i));
}
return result;
}
GpgME::InvalidSigningKey GpgME::SigningResult::invalidSigningKey(unsigned int idx) const
{
return InvalidSigningKey(d, idx);
}
std::vector<GpgME::InvalidSigningKey> GpgME::SigningResult::invalidSigningKeys() const
{
if (!d) {
return std::vector<GpgME::InvalidSigningKey>();
}
std::vector<GpgME::InvalidSigningKey> result;
result.reserve(d->invalid.size());
for (unsigned int i = 0 ; i < d->invalid.size() ; ++i) {
result.push_back(InvalidSigningKey(d, i));
}
return result;
}
GpgME::InvalidSigningKey::InvalidSigningKey(const boost::shared_ptr<SigningResult::Private> &parent, unsigned int i)
: d(parent), idx(i)
{
}
GpgME::InvalidSigningKey::InvalidSigningKey() : d(), idx(0) {}
bool GpgME::InvalidSigningKey::isNull() const
{
return !d || idx >= d->invalid.size() ;
}
const char *GpgME::InvalidSigningKey::fingerprint() const
{
return isNull() ? 0 : d->invalid[idx]->fpr ;
}
GpgME::Error GpgME::InvalidSigningKey::reason() const
{
return Error(isNull() ? 0 : d->invalid[idx]->reason);
}
GpgME::CreatedSignature::CreatedSignature(const boost::shared_ptr<SigningResult::Private> &parent, unsigned int i)
: d(parent), idx(i)
{
}
GpgME::CreatedSignature::CreatedSignature() : d(), idx(0) {}
bool GpgME::CreatedSignature::isNull() const
{
return !d || idx >= d->created.size() ;
}
const char *GpgME::CreatedSignature::fingerprint() const
{
return isNull() ? 0 : d->created[idx]->fpr ;
}
time_t GpgME::CreatedSignature::creationTime() const
{
return static_cast<time_t>(isNull() ? 0 : d->created[idx]->timestamp);
}
GpgME::SignatureMode GpgME::CreatedSignature::mode() const
{
if (isNull()) {
return NormalSignatureMode;
}
switch (d->created[idx]->type) {
default:
case GPGME_SIG_MODE_NORMAL: return NormalSignatureMode;
case GPGME_SIG_MODE_DETACH: return Detached;
case GPGME_SIG_MODE_CLEAR: return Clearsigned;
}
}
unsigned int GpgME::CreatedSignature::publicKeyAlgorithm() const
{
return isNull() ? 0 : d->created[idx]->pubkey_algo ;
}
const char *GpgME::CreatedSignature::publicKeyAlgorithmAsString() const
{
return gpgme_pubkey_algo_name(isNull() ? (gpgme_pubkey_algo_t)0 : d->created[idx]->pubkey_algo);
}
unsigned int GpgME::CreatedSignature::hashAlgorithm() const
{
return isNull() ? 0 : d->created[idx]->hash_algo ;
}
const char *GpgME::CreatedSignature::hashAlgorithmAsString() const
{
return gpgme_hash_algo_name(isNull() ? (gpgme_hash_algo_t)0 : d->created[idx]->hash_algo);
}
unsigned int GpgME::CreatedSignature::signatureClass() const
{
return isNull() ? 0 : d->created[idx]->sig_class ;
}
std::ostream &GpgME::operator<<(std::ostream &os, const SigningResult &result)
{
os << "GpgME::SigningResult(";
if (!result.isNull()) {
os << "\n error: " << result.error()
<< "\n createdSignatures:\n";
const std::vector<CreatedSignature> cs = result.createdSignatures();
std::copy(cs.begin(), cs.end(),
std::ostream_iterator<CreatedSignature>(os, "\n"));
os << " invalidSigningKeys:\n";
const std::vector<InvalidSigningKey> isk = result.invalidSigningKeys();
std::copy(isk.begin(), isk.end(),
std::ostream_iterator<InvalidSigningKey>(os, "\n"));
}
return os << ')';
}
std::ostream &GpgME::operator<<(std::ostream &os, const CreatedSignature &sig)
{
os << "GpgME::CreatedSignature(";
if (!sig.isNull()) {
os << "\n fingerprint: " << protect(sig.fingerprint())
<< "\n creationTime: " << sig.creationTime()
<< "\n mode: " << sig.mode()
<< "\n publicKeyAlgorithm: " << protect(sig.publicKeyAlgorithmAsString())
<< "\n hashAlgorithm: " << protect(sig.hashAlgorithmAsString())
<< "\n signatureClass: " << sig.signatureClass()
<< '\n';
}
return os << ')';
}
std::ostream &GpgME::operator<<(std::ostream &os, const InvalidSigningKey &key)
{
os << "GpgME::InvalidSigningKey(";
if (!key.isNull()) {
os << "\n fingerprint: " << protect(key.fingerprint())
<< "\n reason: " << key.reason()
<< '\n';
}
return os << ')';
}

162
lang/cpp/src/signingresult.h Normal file
View File

@ -0,0 +1,162 @@
/*
signingresult.h - wraps a gpgme sign result
Copyright (C) 2004 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.
*/
#ifndef __GPGMEPP_SIGNINGRESULT_H__
#define __GPGMEPP_SIGNINGRESULT_H__
#include "global.h"
#include "result.h"
#include <time.h>
#include <boost/shared_ptr.hpp>
#include <vector>
#include <iosfwd>
namespace GpgME
{
class Error;
class CreatedSignature;
class InvalidSigningKey;
class GPGMEPP_EXPORT SigningResult : public Result
{
public:
SigningResult();
SigningResult(gpgme_ctx_t ctx, int error);
SigningResult(gpgme_ctx_t ctx, const Error &error);
explicit SigningResult(const Error &err);
const SigningResult &operator=(SigningResult other)
{
swap(other);
return *this;
}
void swap(SigningResult &other)
{
Result::swap(other);
using std::swap;
swap(this->d, other.d);
}
bool isNull() const;
CreatedSignature createdSignature(unsigned int index) const;
std::vector<CreatedSignature> createdSignatures() const;
InvalidSigningKey invalidSigningKey(unsigned int index) const;
std::vector<InvalidSigningKey> invalidSigningKeys() const;
class Private;
private:
void init(gpgme_ctx_t ctx);
boost::shared_ptr<Private> d;
};
GPGMEPP_EXPORT std::ostream &operator<<(std::ostream &os, const SigningResult &result);
class GPGMEPP_EXPORT InvalidSigningKey
{
friend class ::GpgME::SigningResult;
InvalidSigningKey(const boost::shared_ptr<SigningResult::Private> &parent, unsigned int index);
public:
InvalidSigningKey();
const InvalidSigningKey &operator=(InvalidSigningKey other)
{
swap(other);
return *this;
}
void swap(InvalidSigningKey &other)
{
using std::swap;
swap(this->d, other.d);
swap(this->idx, other.idx);
}
bool isNull() const;
const char *fingerprint() const;
Error reason() const;
private:
boost::shared_ptr<SigningResult::Private> d;
unsigned int idx;
};
GPGMEPP_EXPORT std::ostream &operator<<(std::ostream &os, const InvalidSigningKey &key);
class GPGMEPP_EXPORT CreatedSignature
{
friend class ::GpgME::SigningResult;
CreatedSignature(const boost::shared_ptr<SigningResult::Private> &parent, unsigned int index);
public:
CreatedSignature();
const CreatedSignature &operator=(CreatedSignature other)
{
swap(other);
return *this;
}
void swap(CreatedSignature &other)
{
using std::swap;
swap(this->d, other.d);
swap(this->idx, other.idx);
}
bool isNull() const;
const char *fingerprint() const;
time_t creationTime() const;
SignatureMode mode() const;
unsigned int publicKeyAlgorithm() const;
const char *publicKeyAlgorithmAsString() const;
unsigned int hashAlgorithm() const;
const char *hashAlgorithmAsString() const;
unsigned int signatureClass() const;
private:
boost::shared_ptr<SigningResult::Private> d;
unsigned int idx;
};
GPGMEPP_EXPORT std::ostream &operator<<(std::ostream &os, const CreatedSignature &sig);
}
GPGMEPP_MAKE_STD_SWAP_SPECIALIZATION(SigningResult)
GPGMEPP_MAKE_STD_SWAP_SPECIALIZATION(InvalidSigningKey)
GPGMEPP_MAKE_STD_SWAP_SPECIALIZATION(CreatedSignature)
#endif // __GPGMEPP_SIGNINGRESULT_H__

116
lang/cpp/src/trustitem.cpp Normal file
View File

@ -0,0 +1,116 @@
/*
trustitem.cpp - wraps a gpgme trust item
Copyright (C) 2003 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 <config-gpgme++.h>
#include <trustitem.h>
#include <gpgme.h>
#include <cassert>
namespace GpgME
{
class TrustItem::Private
{
public:
Private(gpgme_trust_item_t aItem)
: item(aItem)
{
}
gpgme_trust_item_t item;
};
TrustItem::TrustItem(gpgme_trust_item_t item)
{
d = new Private(item);
if (d->item) {
gpgme_trust_item_ref(d->item);
}
}
TrustItem::TrustItem(const TrustItem &other)
{
d = new Private(other.d->item);
if (d->item) {
gpgme_trust_item_ref(d->item);
}
}
TrustItem::~TrustItem()
{
if (d->item) {
gpgme_trust_item_unref(d->item);
}
delete d; d = 0;
}
bool TrustItem::isNull() const
{
return !d || !d->item;
}
gpgme_trust_item_t TrustItem::impl() const
{
return d->item;
}
const char *TrustItem::keyID() const
{
return d->item ? d->item->keyid : 0 ;
}
const char *TrustItem::userID() const
{
return d->item ? d->item->name : 0 ;
}
const char *TrustItem::ownerTrustAsString() const
{
return d->item ? d->item->owner_trust : 0 ;
}
const char *TrustItem::validityAsString() const
{
return d->item ? d->item->validity : 0 ;
}
int TrustItem::trustLevel() const
{
return d->item ? d->item->level : 0 ;
}
TrustItem::Type TrustItem::type() const
{
if (!d->item) {
return Unknown;
} else {
return
d->item->type == 1 ? Key :
d->item->type == 2 ? UserID :
Unknown ;
}
}
} // namespace GpgME

81
lang/cpp/src/trustitem.h Normal file
View File

@ -0,0 +1,81 @@
/*
trustitem.h - wraps a gpgme trust item
Copyright (C) 2003 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_TRUSTITEM_H__
#define __GPGMEPP_TRUSTITEM_H__
#include "gpgmefw.h"
#include <key.h>
#include "gpgmepp_export.h"
#include <algorithm>
namespace GpgME
{
class Context;
class GPGMEPP_EXPORT TrustItem
{
friend class ::GpgME::Context;
public:
explicit TrustItem(gpgme_trust_item_t item = 0);
TrustItem(const TrustItem &other);
virtual ~TrustItem();
const TrustItem &operator=(TrustItem other)
{
swap(other);
return *this;
}
void swap(TrustItem &other)
{
using std::swap;
swap(this->d, other.d);
}
bool isNull() const;
const char *keyID() const;
const char *userID() const;
const char *ownerTrustAsString() const;
const char *validityAsString() const;
int trustLevel() const;
enum Type { Unknown = 0, Key = 1, UserID = 2 };
Type type() const;
private:
gpgme_trust_item_t impl() const;
class Private;
Private *d;
};
} // namepace GpgME
GPGMEPP_MAKE_STD_SWAP_SPECIALIZATION(TrustItem)
#endif // __GPGMEPP_TRUSTITEM_H__

179
lang/cpp/src/util.h Normal file
View File

@ -0,0 +1,179 @@
/*
util.h - some inline helper functions
Copyright (C) 2004 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_UTIL_H__
#define __GPGMEPP_UTIL_H__
#include "global.h"
#include "notation.h"
#include <gpgme.h>
#ifndef NDEBUG
#include <iostream>
#endif
#include <sstream>
#include <string>
static inline const char *protect(const char *s)
{
return s ? s : "<null>" ;
}
static inline gpgme_error_t make_error(gpgme_err_code_t code)
{
return gpgme_err_make((gpgme_err_source_t)22, code);
}
static inline unsigned long to_pid(const std::string &s)
{
std::stringstream ss(s);
unsigned int result;
if (ss >> result) {
return result;
} else {
return 0U;
}
}
static inline gpgme_keylist_mode_t add_to_gpgme_keylist_mode_t(unsigned int oldmode, unsigned int newmodes)
{
if (newmodes & GpgME::Local) {
oldmode |= GPGME_KEYLIST_MODE_LOCAL;
}
if (newmodes & GpgME::Extern) {
oldmode |= GPGME_KEYLIST_MODE_EXTERN;
}
if (newmodes & GpgME::Signatures) {
oldmode |= GPGME_KEYLIST_MODE_SIGS;
}
if (newmodes & GpgME::SignatureNotations) {
#ifdef HAVE_GPGME_KEYLIST_MODE_SIG_NOTATIONS
oldmode |= GPGME_KEYLIST_MODE_SIG_NOTATIONS;
#elif !defined(NDEBUG)
;//std::cerr << "GpgME: ignoring SignatureNotations keylist flag (gpgme too old)." << std::endl;
#endif
}
if (newmodes & GpgME::Ephemeral) {
#ifdef HAVE_GPGME_KEYLIST_MODE_EPHEMERAL
oldmode |= GPGME_KEYLIST_MODE_EPHEMERAL;
#elif !defined(NDEBUG)
;//std::cerr << "GpgME: ignoring Ephemeral keylist flag (gpgme too old)." << std::endl;
#endif
}
if (newmodes & GpgME::Validate) {
oldmode |= GPGME_KEYLIST_MODE_VALIDATE;
}
#ifndef NDEBUG
if (newmodes & ~(GpgME::Local | GpgME::Extern | GpgME::Signatures | GpgME::SignatureNotations | GpgME::Ephemeral | GpgME::Validate)) {
//std::cerr << "GpgME::Context: keylist mode must be one of Local, "
//"Extern, Signatures, SignatureNotations, or Validate, or a combination thereof!" << std::endl;
}
#endif
return static_cast<gpgme_keylist_mode_t>(oldmode);
}
static inline unsigned int convert_from_gpgme_keylist_mode_t(unsigned int mode)
{
unsigned int result = 0;
if (mode & GPGME_KEYLIST_MODE_LOCAL) {
result |= GpgME::Local;
}
if (mode & GPGME_KEYLIST_MODE_EXTERN) {
result |= GpgME::Extern;
}
if (mode & GPGME_KEYLIST_MODE_SIGS) {
result |= GpgME::Signatures;
}
#ifdef HAVE_GPGME_KEYLIST_MODE_SIG_NOTATIONS
if (mode & GPGME_KEYLIST_MODE_SIG_NOTATIONS) {
result |= GpgME::SignatureNotations;
}
#endif
#ifdef HAVE_GPGME_KEYLIST_MODE_EPHEMERAL
if (mode & GPGME_KEYLIST_MODE_EPHEMERAL) {
result |= GpgME::Ephemeral;
}
#endif
if (mode & GPGME_KEYLIST_MODE_VALIDATE) {
result |= GpgME::Validate;
}
#ifndef NDEBUG
if (mode & ~(GPGME_KEYLIST_MODE_LOCAL |
GPGME_KEYLIST_MODE_EXTERN |
#ifdef HAVE_GPGME_KEYLIST_MODE_SIG_NOTATIONS
GPGME_KEYLIST_MODE_SIG_NOTATIONS |
#endif
#ifdef HAVE_GPGME_KEYLIST_MODE_EPHEMERAL
GPGME_KEYLIST_MODE_EPHEMERAL |
#endif
GPGME_KEYLIST_MODE_VALIDATE |
GPGME_KEYLIST_MODE_SIGS)) {
//std::cerr << "GpgME: WARNING: gpgme_get_keylist_mode() returned an unknown flag!" << std::endl;
}
#endif // NDEBUG
return result;
}
static inline GpgME::Notation::Flags convert_from_gpgme_sig_notation_flags_t(unsigned int flags)
{
#ifdef HAVE_GPGME_SIG_NOTATION_FLAGS_T
unsigned int result = 0;
#ifdef HAVE_GPGME_SIG_NOTATION_HUMAN_READABLE
if (flags & GPGME_SIG_NOTATION_HUMAN_READABLE) {
result |= GpgME::Notation::HumanReadable ;
}
#endif
#ifdef HAVE_GPGME_SIG_NOTATION_CRITICAL
if (flags & GPGME_SIG_NOTATION_CRITICAL) {
result |= GpgME::Notation::Critical ;
}
#endif
return static_cast<GpgME::Notation::Flags>(result);
#else
return GpgME::Notation::NoFlags;
#endif
}
#ifdef HAVE_GPGME_SIG_NOTATION_FLAGS_T
static inline gpgme_sig_notation_flags_t add_to_gpgme_sig_notation_flags_t(unsigned int oldflags, unsigned int newflags)
{
unsigned int result = oldflags;
if (newflags & GpgME::Notation::HumanReadable) {
#ifdef HAVE_GPGME_SIG_NOTATION_HUMAN_READABLE
result |= GPGME_SIG_NOTATION_HUMAN_READABLE;
#elif !defined(NDEBUG)
//std::cerr << "GpgME::Context: ignoring HumanReadable signature notation flag (gpgme too old)" << std::endl;
#endif
}
if (newflags & GpgME::Notation::Critical) {
#ifdef HAVE_GPGME_SIG_NOTATION_CRITICAL
result |= GPGME_SIG_NOTATION_CRITICAL;
#elif !defined(NDEBUG)
//std::cerr << "GpgME::Context: ignoring Critical signature notation flag (gpgme too old)" << std::endl;
#endif
}
return static_cast<gpgme_sig_notation_flags_t>(result);
}
#endif
#endif // __GPGMEPP_UTIL_H__

590
lang/cpp/src/verificationresult.cpp Normal file
View File

@ -0,0 +1,590 @@
/*
verificationresult.cpp - wraps a gpgme verify result
Copyright (C) 2004 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 <config-gpgme++.h>
#include <verificationresult.h>
#include <notation.h>
#include "result_p.h"
#include "util.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;
}
#ifdef HAVE_GPGME_VERIFY_RESULT_T_FILE_NAME
if (r->file_name) {
file_name = r->file_name;
}
#endif
// 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);
}
#ifdef HAVE_GPGME_SIGNATURE_T_PKA_FIELDS
// 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
#endif
scopy->next = 0;
sigs.push_back(scopy);
// 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;
}
#ifdef HAVE_GPGME_SIG_NOTATION_FLAGS_T
Nota n = { 0, 0, in->flags };
#else
Nota n = { 0, 0 };
#endif
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);
#ifdef HAVE_GPGME_SIGNATURE_T_PKA_FIELDS
std::free((*it)->pka_address);
#endif
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;
#ifdef HAVE_GPGME_SIG_NOTATION_FLAGS_T
gpgme_sig_notation_flags_t flags;
#endif
};
std::vector<gpgme_signature_t> sigs;
std::vector< std::vector<Nota> > nota;
std::vector<char *> purls;
std::string file_name;
};
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));
}
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 boost::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;
}
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
{
#ifdef HAVE_GPGME_SIGNATURE_T_CHAIN_MODEL
return !isNull() && d->sigs[idx]->chain_model;
#else
return false;
#endif
}
GpgME::Signature::PKAStatus GpgME::Signature::pkaStatus() const
{
#ifdef HAVE_GPGME_SIGNATURE_T_PKA_FIELDS
if (!isNull()) {
return static_cast<PKAStatus>(d->sigs[idx]->pka_trust);
}
#endif
return UnknownPKAStatus;
}
const char *GpgME::Signature::pkaAddress() const
{
#ifdef HAVE_GPGME_SIGNATURE_T_PKA_FIELDS
if (!isNull()) {
return d->sigs[idx]->pka_address;
}
#endif
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
{
#ifdef HAVE_GPGME_SIGNATURE_T_ALGORITHM_FIELDS
if (!isNull()) {
return d->sigs[idx]->pubkey_algo;
}
#endif
return 0;
}
const char *GpgME::Signature::publicKeyAlgorithmAsString() const
{
#ifdef HAVE_GPGME_SIGNATURE_T_ALGORITHM_FIELDS
if (!isNull()) {
return gpgme_pubkey_algo_name(d->sigs[idx]->pubkey_algo);
}
#endif
return 0;
}
unsigned int GpgME::Signature::hashAlgorithm() const
{
#ifdef HAVE_GPGME_SIGNATURE_T_ALGORITHM_FIELDS
if (!isNull()) {
return d->sigs[idx]->hash_algo;
}
#endif
return 0;
}
const char *GpgME::Signature::hashAlgorithmAsString() const
{
#ifdef HAVE_GPGME_SIGNATURE_T_ALGORITHM_FIELDS
if (!isNull()) {
return gpgme_hash_algo_name(d->sigs[idx]->hash_algo);
}
#endif
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;
}
class GpgME::Notation::Private
{
public:
Private() : d(), sidx(0), nidx(0), nota(0) {}
Private(const boost::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;
}
}
boost::shared_ptr<VerificationResult::Private> d;
unsigned int sidx, nidx;
gpgme_sig_notation_t nota;
};
GpgME::Notation::Notation(const boost::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(
#ifdef HAVE_GPGME_SIG_NOTATION_FLAGS_T
isNull() ? 0 :
d->d ? d->d->nota[d->sidx][d->nidx].flags :
d->nota ? d->nota->flags : 0);
#else
0);
#endif
}
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);
#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 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 << ")";
}

173
lang/cpp/src/verificationresult.h Normal file
View File

@ -0,0 +1,173 @@
/*
verificationresult.h - wraps a gpgme verify result
Copyright (C) 2004 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.
*/
#ifndef __GPGMEPP_VERIFICATIONRESULT_H__
#define __GPGMEPP_VERIFICATIONRESULT_H__
#include "gpgmefw.h"
#include "result.h"
#include "gpgmepp_export.h"
#include <time.h>
#include <boost/shared_ptr.hpp>
#include <vector>
#include <iosfwd>
namespace GpgME
{
class Error;
class Signature;
class Notation;
class GPGMEPP_EXPORT VerificationResult : public Result
{
public:
VerificationResult();
VerificationResult(gpgme_ctx_t ctx, int error);
VerificationResult(gpgme_ctx_t ctx, const Error &error);
explicit VerificationResult(const Error &err);
const VerificationResult &operator=(VerificationResult other)
{
swap(other);
return *this;
}
void swap(VerificationResult &other)
{
Result::swap(other);
using std::swap;
swap(this->d, other.d);
}
bool isNull() const;
const char *fileName() const;
unsigned int numSignatures() const;
Signature signature(unsigned int index) const;
std::vector<Signature> signatures() const;
class Private;
private:
void init(gpgme_ctx_t ctx);
boost::shared_ptr<Private> d;
};
GPGMEPP_EXPORT std::ostream &operator<<(std::ostream &os, const VerificationResult &result);
class GPGMEPP_EXPORT Signature
{
friend class ::GpgME::VerificationResult;
Signature(const boost::shared_ptr<VerificationResult::Private> &parent, unsigned int index);
public:
typedef GPGMEPP_DEPRECATED GpgME::Notation Notation;
Signature();
const Signature &operator=(Signature other)
{
swap(other);
return *this;
}
void swap(Signature &other)
{
using std::swap;
swap(this->d, other.d);
swap(this->idx, other.idx);
}
bool isNull() const;
enum Summary {
None = 0x000,
Valid = 0x001,
Green = 0x002,
Red = 0x004,
KeyRevoked = 0x008,
KeyExpired = 0x010,
SigExpired = 0x020,
KeyMissing = 0x040,
CrlMissing = 0x080,
CrlTooOld = 0x100,
BadPolicy = 0x200,
SysError = 0x400
};
Summary summary() const;
const char *fingerprint() const;
Error status() const;
time_t creationTime() const;
time_t expirationTime() const;
bool neverExpires() const;
GPGMEPP_DEPRECATED bool wrongKeyUsage() const
{
return isWrongKeyUsage();
}
bool isWrongKeyUsage() const;
bool isVerifiedUsingChainModel() const;
enum PKAStatus {
UnknownPKAStatus, PKAVerificationFailed, PKAVerificationSucceeded
};
PKAStatus pkaStatus() const;
const char *pkaAddress() const;
enum Validity {
Unknown, Undefined, Never, Marginal, Full, Ultimate
};
Validity validity() const;
char validityAsString() const;
Error nonValidityReason() const;
unsigned int publicKeyAlgorithm() const;
const char *publicKeyAlgorithmAsString() const;
unsigned int hashAlgorithm() const;
const char *hashAlgorithmAsString() const;
const char *policyURL() const;
GpgME::Notation notation(unsigned int index) const;
std::vector<GpgME::Notation> notations() const;
private:
boost::shared_ptr<VerificationResult::Private> d;
unsigned int idx;
};
GPGMEPP_EXPORT std::ostream &operator<<(std::ostream &os, const Signature &sig);
GPGMEPP_EXPORT std::ostream &operator<<(std::ostream &os, Signature::PKAStatus pkaStatus);
GPGMEPP_EXPORT std::ostream &operator<<(std::ostream &os, Signature::Summary summary);
}
GPGMEPP_MAKE_STD_SWAP_SPECIALIZATION(VerificationResult)
GPGMEPP_MAKE_STD_SWAP_SPECIALIZATION(Signature)
#endif // __GPGMEPP_VERIFICATIONRESULT_H__

98
lang/cpp/src/vfsmountresult.cpp Normal file
View File

@ -0,0 +1,98 @@
/*
vfsmountresult.cpp - 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.
*/
#include <config-gpgme++.h>
#include <vfsmountresult.h>
#include "result_p.h"
#include <gpgme.h>
#include <istream>
#include <string.h>
using namespace GpgME;
#ifdef HAVE_GPGME_G13_VFS
class VfsMountResult::Private
{
public:
explicit Private(const gpgme_vfs_mount_result_t r) : mountDir(0)
{
if (r && r->mount_dir) {
mountDir = strdup(r->mount_dir);
}
}
~Private()
{
std::free(mountDir);
}
char *mountDir;
};
#endif
VfsMountResult::VfsMountResult(gpgme_ctx_t ctx, const Error &error, const Error &opError)
: Result(error ? error : opError), d()
{
init(ctx);
}
void VfsMountResult::init(gpgme_ctx_t ctx)
{
(void)ctx;
#ifdef HAVE_GPGME_G13_VFS
if (!ctx) {
return;
}
gpgme_vfs_mount_result_t res = gpgme_op_vfs_mount_result(ctx);
if (!res) {
return;
}
d.reset(new Private(res));
#endif
}
make_standard_stuff(VfsMountResult)
const char *VfsMountResult::mountDir() const
{
#ifdef HAVE_GPGME_G13_VFS
if (d) {
return d->mountDir;
}
#endif
return 0;
}
std::ostream &GpgME::operator<<(std::ostream &os, const VfsMountResult &result)
{
os << "GpgME::VfsMountResult(";
if (!result.isNull()) {
os << "\n error: " << result.error()
<< "\n mount dir: " << result.mountDir()
<< "\n";
}
return os << ')';
}

76
lang/cpp/src/vfsmountresult.h Normal file
View File

@ -0,0 +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 <boost/shared_ptr.hpp>
#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);
boost::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__