Page MenuHome GnuPG
Files F36623371

No OneTemporary
Actions

View Options

diff --git a/assuanresult.h b/assuanresult.h
index dfe247db..87fa40ed 100644
--- a/assuanresult.h
+++ b/assuanresult.h
@@ -1,76 +1,76 @@
/*
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 <gpgme++/gpgmefw.h>
#include <gpgme++/result.h>
#include <gpgme++/gpgme++_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;
+ swap( other );
+ return *this;
}
void swap( AssuanResult & other ) {
- Result::swap( other );
- using std::swap;
- swap( this->d, other.d );
+ 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__
diff --git a/callbacks.cpp b/callbacks.cpp
index 6d4e498a..7d3f3ff0 100644
--- a/callbacks.cpp
+++ b/callbacks.cpp
@@ -1,184 +1,184 @@
/*
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 <gpgme++/interfaces/progressprovider.h>
#include <gpgme++/interfaces/passphraseprovider.h>
#include <gpgme++/interfaces/dataprovider.h>
#include <gpgme++/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 ) {
+ 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 ) {
+ 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 );
+ 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;
+ 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();
}
}
gpgme_data_cbs GpgME::data_provider_callbacks = {
&data_read_callback,
&data_write_callback,
&data_seek_callback,
&data_release_callback
};
diff --git a/callbacks.h b/callbacks.h
index 4c7c7831..b6ed82d1 100644
--- a/callbacks.h
+++ b/callbacks.h
@@ -1,44 +1,44 @@
/*
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 );
+ 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 );
+ const char * desc, int prev_was_bad, int fd );
}
namespace GpgME {
extern gpgme_data_cbs data_provider_callbacks;
extern gpgme_edit_cb_t edit_interactor_callback;
}
#endif // __GPGME_CALLBACKS_H__
diff --git a/context.cpp b/context.cpp
index 2f2d0763..5ac6bbed 100644
--- a/context.cpp
+++ b/context.cpp
@@ -1,1554 +1,1552 @@
/*
context.cpp - wraps a gpgme key context
Copyright (C) 2003, 2007 Klarälvdalens Datakonsult AB
This file is part of GPGME++.
GPGME++ is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
GPGME++ is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Library General Public License for more details.
You should have received a copy of the GNU Library General Public License
along with GPGME++; see the file COPYING.LIB. If not, write to the
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
Boston, MA 02110-1301, USA.
*/
#include "config-gpgme++.h"
#include <gpgme++/context.h>
#include <gpgme++/eventloopinteractor.h>
#include <gpgme++/trustitem.h>
#include <gpgme++/assuanresult.h>
#include <gpgme++/keylistresult.h>
#include <gpgme++/keygenerationresult.h>
#include <gpgme++/importresult.h>
#include <gpgme++/decryptionresult.h>
#include <gpgme++/verificationresult.h>
#include <gpgme++/signingresult.h>
#include <gpgme++/encryptionresult.h>
#include <gpgme++/engineinfo.h>
#include <gpgme++/editinteractor.h>
#include <gpgme++/vfsmountresult.h>
#include <gpgme++/interfaces/assuantransaction.h>
#include <gpgme++/defaultassuantransaction.h>
#include "callbacks.h"
#include "data_p.h"
#include "context_p.h"
#include "util.h"
#include <gpgme.h>
#include <boost/scoped_array.hpp>
#include <istream>
#ifndef NDEBUG
#include <iostream>
using std::cerr;
using std::endl;
#endif
#include <cassert>
+#include <qglobal.h>
+
namespace GpgME {
static inline unsigned int xtoi_1( const char * str ) {
const unsigned int ch = *str;
const unsigned int result =
ch <= '9' ? ch - '0' :
ch <= 'F' ? ch - 'A' + 10 :
/* else */ ch - 'a' + 10 ;
return result < 16 ? result : 0 ;
}
static inline int xtoi_2( const char * str ) {
return xtoi_1( str ) * 16U + xtoi_1( str + 1 );
}
#ifdef HAVE_GPGME_ASSUAN_ENGINE
static void percent_unescape( std::string & s, bool plus2space ) {
std::string::iterator src = s.begin(), dest = s.begin(), end = s.end();
while ( src != end ) {
if ( *src == '%' && end - src > 2 ) {
*dest++ = xtoi_2( &*++src );
src += 2;
} else if ( *src == '+' && plus2space ) {
*dest++ = ' ';
++src;
} else {
*dest++ = *src++;
}
}
s.erase( dest, end );
}
#endif
void initializeLibrary() {
gpgme_check_version( 0 );
}
Error initializeLibrary( int ) {
-#ifndef _WIN32_WCE
if ( gpgme_check_version( GPGME_VERSION ) ) {
-#endif
return Error();
-#ifndef _WIN32_WCE
} else {
return Error::fromCode( GPG_ERR_USER_1 );
}
-#endif
}
static void format_error( gpgme_error_t err, std::string & str ) {
char buffer[ 1024 ];
gpgme_strerror_r( err, buffer, sizeof buffer );
buffer[ sizeof buffer - 1 ] = '\0';
str = buffer;
}
const char * Error::source() const {
return gpgme_strsource( (gpgme_error_t)mErr );
}
const char * Error::asString() const {
if ( mMessage.empty() ) {
format_error( static_cast<gpgme_error_t>( mErr ), mMessage );
}
return mMessage.c_str();
}
int Error::code() const {
return gpgme_err_code( mErr );
}
int Error::sourceID() const {
return gpgme_err_source( mErr );
}
bool Error::isCanceled() const {
return code() == GPG_ERR_CANCELED;
}
int Error::toErrno() const {
//#ifdef HAVE_GPGME_GPG_ERROR_WRAPPERS
return gpgme_err_code_to_errno( static_cast<gpgme_err_code_t>( code() ) );
//#else
// return gpg_err_code_to_errno( static_cast<gpg_err_code_t>( code() ) );
//#endif
}
// static
bool Error::hasSystemError() {
#ifdef HAVE_GPGME_GPG_ERROR_WRAPPERS
return gpgme_err_code_from_syserror() == GPG_ERR_MISSING_ERRNO ;
#else
return gpg_err_code_from_syserror() == GPG_ERR_MISSING_ERRNO ;
#endif
}
// static
void Error::setSystemError( gpg_err_code_t err ) {
setErrno( gpgme_err_code_to_errno( err ) );
}
// static
void Error::setErrno( int err ) {
#ifdef HAVE_GPGME_GPG_ERROR_WRAPPERS
gpgme_err_set_errno( err );
#else
gpg_err_set_errno( err );
#endif
}
// static
Error Error::fromSystemError( unsigned int src ) {
#ifdef HAVE_GPGME_GPG_ERROR_WRAPPERS
return Error( gpgme_err_make( static_cast<gpgme_err_source_t>( src ), gpgme_err_code_from_syserror() ) );
#else
return Error( gpg_err_make( static_cast<gpg_err_source_t>( src ), gpg_err_code_from_syserror() ) );
#endif
}
// static
Error Error::fromErrno( int err, unsigned int src ) {
//#ifdef HAVE_GPGME_GPG_ERROR_WRAPPERS
return Error( gpgme_err_make( static_cast<gpgme_err_source_t>( src ), gpgme_err_code_from_errno( err ) ) );
//#else
// return Error( gpg_err_make( static_cast<gpg_err_source_t>( src ), gpg_err_from_from_errno( err ) ) );
//#endif
}
// static
Error Error::fromCode( unsigned int err, unsigned int src ) {
//#ifdef HAVE_GPGME_GPG_ERROR_WRAPPERS
return Error( gpgme_err_make( static_cast<gpgme_err_source_t>( src ), static_cast<gpgme_err_code_t>( err ) ) );
//#else
// return Error( gpg_err_make( static_cast<gpg_err_source_t>( src ), static_cast<gpgme_err_code_t>( err ) ) );
//#endif
}
std::ostream & operator<<( std::ostream & os, const Error & err ) {
return os << "GpgME::Error(" << err.encodedError() << " (" << err.asString() << "))";
}
Context::Context( gpgme_ctx_t ctx ) : d( new Private( ctx ) ) {
}
Context::~Context() {
delete d;
}
Context * Context::createForProtocol( Protocol proto ) {
gpgme_ctx_t ctx = 0;
if ( gpgme_new ( &ctx ) != 0 ) {
return 0;
}
switch ( proto ) {
case OpenPGP:
if ( gpgme_set_protocol( ctx, GPGME_PROTOCOL_OpenPGP ) != 0 ) {
- gpgme_release( ctx );
- return 0;
+ gpgme_release( ctx );
+ return 0;
}
break;
case CMS:
if ( gpgme_set_protocol( ctx, GPGME_PROTOCOL_CMS ) != 0 ) {
- gpgme_release( ctx );
- return 0;
+ gpgme_release( ctx );
+ return 0;
}
break;
default:
return 0;
}
return new Context( ctx );
}
std::auto_ptr<Context> Context::createForEngine( Engine eng, Error * error ) {
gpgme_ctx_t ctx = 0;
if ( const gpgme_error_t err = gpgme_new( &ctx ) ) {
if ( error ) {
*error = Error( err );
}
return std::auto_ptr<Context>();
}
switch ( eng ) {
case AssuanEngine:
#ifdef HAVE_GPGME_ASSUAN_ENGINE
if ( const gpgme_error_t err = gpgme_set_protocol( ctx, GPGME_PROTOCOL_ASSUAN ) ) {
gpgme_release( ctx );
if ( error ) {
*error = Error( err );
}
return std::auto_ptr<Context>();
}
break;
#else
if ( error ) {
*error = Error::fromCode( GPG_ERR_NOT_SUPPORTED );
}
return std::auto_ptr<Context>();
#endif
case G13Engine:
#ifdef HAVE_GPGME_G13_VFS
if ( const gpgme_error_t err = gpgme_set_protocol( ctx, GPGME_PROTOCOL_G13 ) ) {
gpgme_release( ctx );
if ( error ) {
*error = Error( err );
}
return std::auto_ptr<Context>();
}
break;
#else
if ( error ) {
*error = Error::fromCode( GPG_ERR_NOT_SUPPORTED );
}
return std::auto_ptr<Context>();
#endif
default:
if ( error ) {
*error = Error::fromCode( GPG_ERR_INV_ARG );
}
return std::auto_ptr<Context>();
}
if ( error ) {
*error = Error();
}
return std::auto_ptr<Context>( new Context( ctx ) );
}
//
//
// Context::Private
//
//
Context::Private::Private( gpgme_ctx_t c )
: ctx( c ),
iocbs( 0 ),
lastop( None ),
lasterr( GPG_ERR_NO_ERROR ),
lastAssuanInquireData( Data::null ),
lastAssuanTransaction(),
lastEditInteractor(),
lastCardEditInteractor()
{
}
Context::Private::~Private() {
if ( ctx ) {
gpgme_release( ctx );
}
ctx = 0;
delete iocbs;
}
//
//
// Context attributes:
//
//
Protocol Context::protocol() const {
gpgme_protocol_t p = gpgme_get_protocol( d->ctx );
switch ( p ) {
case GPGME_PROTOCOL_OpenPGP: return OpenPGP;
case GPGME_PROTOCOL_CMS: return CMS;
default: return UnknownProtocol;
}
}
void Context::setArmor( bool useArmor ) {
gpgme_set_armor( d->ctx, int( useArmor ) );
}
bool Context::armor() const {
return gpgme_get_armor( d->ctx );
}
void Context::setTextMode( bool useTextMode ) {
gpgme_set_textmode( d->ctx, int( useTextMode ) );
}
bool Context::textMode() const {
return gpgme_get_textmode( d->ctx );
}
void Context::setIncludeCertificates( int which ) {
if ( which == DefaultCertificates ) {
#ifdef HAVE_GPGME_INCLUDE_CERTS_DEFAULT
which = GPGME_INCLUDE_CERTS_DEFAULT;
#else
which = 1;
#endif
}
gpgme_set_include_certs( d->ctx, which );
}
int Context::includeCertificates() const {
return gpgme_get_include_certs( d->ctx );
}
void Context::setKeyListMode( unsigned int mode ) {
gpgme_set_keylist_mode( d->ctx, add_to_gpgme_keylist_mode_t( 0, mode ) );
}
void Context::addKeyListMode( unsigned int mode ) {
const unsigned int cur = gpgme_get_keylist_mode( d->ctx );
gpgme_set_keylist_mode( d->ctx, add_to_gpgme_keylist_mode_t( cur, mode ) );
}
unsigned int Context::keyListMode() const {
return convert_from_gpgme_keylist_mode_t( gpgme_get_keylist_mode( d->ctx ) );
}
void Context::setProgressProvider( ProgressProvider * provider ) {
gpgme_set_progress_cb( d->ctx, provider ? &progress_callback : 0, provider );
}
ProgressProvider * Context::progressProvider() const {
void * pp = 0;
gpgme_progress_cb_t pcb = &progress_callback;
gpgme_get_progress_cb( d->ctx, &pcb, &pp );
return static_cast<ProgressProvider*>( pp );
}
void Context::setPassphraseProvider( PassphraseProvider * provider ) {
gpgme_set_passphrase_cb( d->ctx, provider ? &passphrase_callback : 0, provider );
}
PassphraseProvider * Context::passphraseProvider() const {
void * pp = 0;
gpgme_passphrase_cb_t pcb = &passphrase_callback;
gpgme_get_passphrase_cb( d->ctx, &pcb, &pp );
return static_cast<PassphraseProvider*>( pp );
}
void Context::setManagedByEventLoopInteractor( bool manage ) {
if ( !EventLoopInteractor::instance() ) {
#ifndef NDEBUG
cerr << "Context::setManagedByEventLoopInteractor(): "
- "You must create an instance of EventLoopInteractor "
- "before using anything that needs one." << endl;
+ "You must create an instance of EventLoopInteractor "
+ "before using anything that needs one." << endl;
#endif
return;
}
if ( manage ) {
EventLoopInteractor::instance()->manage( this );
} else {
EventLoopInteractor::instance()->unmanage( this );
}
}
bool Context::managedByEventLoopInteractor() const {
return d->iocbs != 0;
}
void Context::installIOCallbacks( gpgme_io_cbs * iocbs ) {
if ( !iocbs ) {
uninstallIOCallbacks();
return;
}
gpgme_set_io_cbs( d->ctx, iocbs );
delete d->iocbs; d->iocbs = iocbs;
}
void Context::uninstallIOCallbacks() {
static gpgme_io_cbs noiocbs = { 0, 0, 0, 0, 0 };
// io.add == 0 means disable io callbacks:
gpgme_set_io_cbs( d->ctx, &noiocbs );
delete d->iocbs; d->iocbs = 0;
}
Error Context::setLocale( int cat, const char * val ) {
return Error( d->lasterr = gpgme_set_locale( d->ctx, cat, val ) );
}
EngineInfo Context::engineInfo() const {
#ifdef HAVE_GPGME_CTX_GETSET_ENGINE_INFO
return EngineInfo( gpgme_ctx_get_engine_info( d->ctx ) );
#else
return EngineInfo();
#endif
}
Error Context::setEngineFileName( const char * filename ) {
#ifdef HAVE_GPGME_CTX_GETSET_ENGINE_INFO
const char * const home_dir = engineInfo().homeDirectory();
return Error( gpgme_ctx_set_engine_info( d->ctx, gpgme_get_protocol( d->ctx ), filename, home_dir ) );
#else
return Error::fromCode( GPG_ERR_NOT_IMPLEMENTED );
#endif
}
Error Context::setEngineHomeDirectory( const char * home_dir ) {
#ifdef HAVE_GPGME_CTX_GETSET_ENGINE_INFO
const char * const filename = engineInfo().fileName();
return Error( gpgme_ctx_set_engine_info( d->ctx, gpgme_get_protocol( d->ctx ), filename, home_dir ) );
#else
return Error::fromCode( GPG_ERR_NOT_IMPLEMENTED );
#endif
}
//
//
// Key Management
//
//
Error Context::startKeyListing( const char * pattern, bool secretOnly ) {
d->lastop = Private::KeyList;
return Error( d->lasterr = gpgme_op_keylist_start( d->ctx, pattern, int( secretOnly ) ) );
}
Error Context::startKeyListing( const char * patterns[], bool secretOnly ) {
d->lastop = Private::KeyList;
#ifndef HAVE_GPGME_EXT_KEYLIST_MODE_EXTERNAL_NONBROKEN
if ( !patterns || !patterns[0] || !patterns[1] ) {
// max. one pattern -> use the non-ext version
return startKeyListing( patterns ? patterns[0] : 0, secretOnly );
}
#endif
return Error( d->lasterr = gpgme_op_keylist_ext_start( d->ctx, patterns, int( secretOnly ), 0 ) );
}
Key Context::nextKey( GpgME::Error & e ) {
d->lastop = Private::KeyList;
gpgme_key_t key;
e = Error( d->lasterr = gpgme_op_keylist_next( d->ctx, &key ) );
return Key( key, false );
}
KeyListResult Context::endKeyListing() {
d->lasterr = gpgme_op_keylist_end( d->ctx );
return keyListResult();
}
KeyListResult Context::keyListResult() const {
return KeyListResult( d->ctx, Error( d->lasterr ) );
}
Key Context::key( const char * fingerprint, GpgME::Error & e , bool secret /*, bool forceUpdate*/ ) {
d->lastop = Private::KeyList;
gpgme_key_t key;
e = Error( d->lasterr = gpgme_get_key( d->ctx, fingerprint, &key, int( secret )/*, int( forceUpdate )*/ ) );
return Key( key, false );
}
KeyGenerationResult Context::generateKey( const char * parameters, Data & pubKey ) {
d->lastop = Private::KeyGen;
Data::Private * const dp = pubKey.impl();
d->lasterr = gpgme_op_genkey( d->ctx, parameters, dp ? dp->data : 0, 0 );
return KeyGenerationResult( d->ctx, Error( d->lasterr ) );
}
Error Context::startKeyGeneration( const char * parameters, Data & pubKey ) {
d->lastop = Private::KeyGen;
Data::Private * const dp = pubKey.impl();
return Error( d->lasterr = gpgme_op_genkey_start( d->ctx, parameters, dp ? dp->data : 0, 0 ) );
}
KeyGenerationResult Context::keyGenerationResult() const {
if ( d->lastop & Private::KeyGen ) {
return KeyGenerationResult( d->ctx, Error( d->lasterr ) );
} else {
return KeyGenerationResult();
}
}
Error Context::exportPublicKeys( const char * pattern, Data & keyData ) {
d->lastop = Private::Export;
Data::Private * const dp = keyData.impl();
return Error( d->lasterr = gpgme_op_export( d->ctx, pattern, 0, dp ? dp->data : 0 ) );
}
Error Context::exportPublicKeys( const char * patterns[], Data & keyData ) {
d->lastop = Private::Export;
#ifndef HAVE_GPGME_EXT_KEYLIST_MODE_EXTERNAL_NONBROKEN
if ( !patterns || !patterns[0] || !patterns[1] ) {
// max. one pattern -> use the non-ext version
return exportPublicKeys( patterns ? patterns[0] : 0, keyData );
}
#endif
Data::Private * const dp = keyData.impl();
return Error( d->lasterr = gpgme_op_export_ext( d->ctx, patterns, 0, dp ? dp->data : 0 ) );
}
Error Context::startPublicKeyExport( const char * pattern, Data & keyData ) {
d->lastop = Private::Export;
Data::Private * const dp = keyData.impl();
return Error( d->lasterr = gpgme_op_export_start( d->ctx, pattern, 0, dp ? dp->data : 0 ) );
}
Error Context::startPublicKeyExport( const char * patterns[], Data & keyData ) {
d->lastop = Private::Export;
#ifndef HAVE_GPGME_EXT_KEYLIST_MODE_EXTERNAL_NONBROKEN
if ( !patterns || !patterns[0] || !patterns[1] ) {
// max. one pattern -> use the non-ext version
return startPublicKeyExport( patterns ? patterns[0] : 0, keyData );
}
#endif
Data::Private * const dp = keyData.impl();
return Error( d->lasterr = gpgme_op_export_ext_start( d->ctx, patterns, 0, dp ? dp->data : 0 ) );
}
ImportResult Context::importKeys( const Data & data ) {
d->lastop = Private::Import;
const Data::Private * const dp = data.impl();
d->lasterr = gpgme_op_import( d->ctx, dp ? dp->data : 0 );
return ImportResult( d->ctx, Error( d->lasterr ) );
}
ImportResult Context::importKeys( const std::vector<Key> & kk ) {
d->lastop = Private::Import;
d->lasterr = make_error( GPG_ERR_NOT_IMPLEMENTED );
bool shouldHaveResult = false;
#ifdef HAVE_GPGME_OP_IMPORT_KEYS
const boost::scoped_array<gpgme_key_t> keys( new gpgme_key_t[ kk.size() + 1 ] );
gpgme_key_t * keys_it = &keys[0];
for ( std::vector<Key>::const_iterator it = kk.begin(), end = kk.end() ; it != end ; ++it ) {
if ( it->impl() ) {
*keys_it++ = it->impl();
}
}
*keys_it++ = 0;
d->lasterr = gpgme_op_import_keys( d->ctx, keys.get() );
shouldHaveResult = true;
#endif
if ( ( gpgme_err_code( d->lasterr ) == GPG_ERR_NOT_IMPLEMENTED ||
gpgme_err_code( d->lasterr ) == GPG_ERR_NOT_SUPPORTED ) &&
protocol() == CMS ) {
// ok, try the workaround (export+import):
std::vector<const char*> fprs;
for ( std::vector<Key>::const_iterator it = kk.begin(), end = kk.end() ; it != end ; ++it ) {
if ( const char * fpr = it->primaryFingerprint() ) {
if ( *fpr ) {
fprs.push_back( fpr );
}
} else if ( const char * keyid = it->keyID() ) {
if ( *keyid ) {
fprs.push_back( keyid );
}
}
}
fprs.push_back( 0 );
Data data;
Data::Private * const dp = data.impl();
const gpgme_keylist_mode_t oldMode = gpgme_get_keylist_mode( d->ctx );
gpgme_set_keylist_mode( d->ctx, GPGME_KEYLIST_MODE_EXTERN );
d->lasterr = gpgme_op_export_ext( d->ctx, &fprs[0], 0, dp ? dp->data : 0 );
gpgme_set_keylist_mode( d->ctx, oldMode );
if ( !d->lasterr ) {
data.seek( 0, SEEK_SET );
d->lasterr = gpgme_op_import( d->ctx, dp ? dp->data : 0 );
shouldHaveResult = true;
}
}
if ( shouldHaveResult ) {
return ImportResult( d->ctx, Error( d->lasterr ) );
} else {
return ImportResult( Error( d->lasterr ) );
}
}
Error Context::startKeyImport( const Data & data ) {
d->lastop = Private::Import;
const Data::Private * const dp = data.impl();
return Error( d->lasterr = gpgme_op_import_start( d->ctx, dp ? dp->data : 0 ) );
}
Error Context::startKeyImport( const std::vector<Key> & kk ) {
d->lastop = Private::Import;
#ifdef HAVE_GPGME_OP_IMPORT_KEYS
const boost::scoped_array<gpgme_key_t> keys( new gpgme_key_t[ kk.size() + 1 ] );
gpgme_key_t * keys_it = &keys[0];
for ( std::vector<Key>::const_iterator it = kk.begin(), end = kk.end() ; it != end ; ++it ) {
if ( it->impl() ) {
*keys_it++ = it->impl();
}
}
*keys_it++ = 0;
return Error( d->lasterr = gpgme_op_import_keys_start( d->ctx, keys.get() ) );
#else
(void)kk;
return Error( d->lasterr = make_error( GPG_ERR_NOT_IMPLEMENTED ) );
#endif
}
ImportResult Context::importResult() const {
if ( d->lastop & Private::Import ) {
return ImportResult( d->ctx, Error( d->lasterr ) );
} else {
return ImportResult();
}
}
Error Context::deleteKey( const Key & key, bool allowSecretKeyDeletion ) {
d->lastop = Private::Delete;
return Error( d->lasterr = gpgme_op_delete( d->ctx, key.impl(), int( allowSecretKeyDeletion ) ) );
}
Error Context::startKeyDeletion( const Key & key, bool allowSecretKeyDeletion ) {
d->lastop = Private::Delete;
return Error( d->lasterr = gpgme_op_delete_start( d->ctx, key.impl(), int( allowSecretKeyDeletion ) ) );
}
Error Context::passwd( const Key & key ) {
d->lastop = Private::Passwd;
#ifdef HAVE_GPGME_OP_PASSWD
return Error( d->lasterr = gpgme_op_passwd( d->ctx, key.impl(), 0U ) );
#else
(void)key;
return Error( d->lasterr = make_error( GPG_ERR_NOT_IMPLEMENTED ) );
#endif
}
Error Context::startPasswd( const Key & key ) {
d->lastop = Private::Passwd;
#ifdef HAVE_GPGME_OP_PASSWD
return Error( d->lasterr = gpgme_op_passwd_start( d->ctx, key.impl(), 0U ) );
#else
(void)key;
return Error( d->lasterr = make_error( GPG_ERR_NOT_IMPLEMENTED ) );
#endif
}
Error Context::edit( const Key & key, std::auto_ptr<EditInteractor> func, Data & data ) {
d->lastop = Private::Edit;
d->lastEditInteractor = func;
Data::Private * const dp = data.impl();
return Error( d->lasterr = gpgme_op_edit( d->ctx, key.impl(),
d->lastEditInteractor.get() ? edit_interactor_callback : 0,
d->lastEditInteractor.get() ? d->lastEditInteractor->d : 0,
dp ? dp->data : 0 ) );
}
Error Context::startEditing( const Key & key, std::auto_ptr<EditInteractor> func, Data & data ) {
d->lastop = Private::Edit;
d->lastEditInteractor = func;
Data::Private * const dp = data.impl();
return Error( d->lasterr = gpgme_op_edit_start( d->ctx, key.impl(),
d->lastEditInteractor.get() ? edit_interactor_callback : 0,
d->lastEditInteractor.get() ? d->lastEditInteractor->d : 0,
dp ? dp->data : 0 ) );
}
EditInteractor * Context::lastEditInteractor() const {
return d->lastEditInteractor.get();
}
std::auto_ptr<EditInteractor> Context::takeLastEditInteractor() {
return d->lastEditInteractor;
}
Error Context::cardEdit( const Key & key, std::auto_ptr<EditInteractor> func, Data & data ) {
d->lastop = Private::CardEdit;
d->lastCardEditInteractor = func;
Data::Private * const dp = data.impl();
return Error( d->lasterr = gpgme_op_card_edit( d->ctx, key.impl(),
d->lastCardEditInteractor.get() ? edit_interactor_callback : 0,
d->lastCardEditInteractor.get() ? d->lastCardEditInteractor->d : 0,
dp ? dp->data : 0 ) );
}
Error Context::startCardEditing( const Key & key, std::auto_ptr<EditInteractor> func, Data & data ) {
d->lastop = Private::CardEdit;
d->lastCardEditInteractor = func;
Data::Private * const dp = data.impl();
return Error( d->lasterr = gpgme_op_card_edit_start( d->ctx, key.impl(),
d->lastCardEditInteractor.get() ? edit_interactor_callback : 0,
d->lastCardEditInteractor.get() ? d->lastCardEditInteractor->d : 0,
dp ? dp->data : 0 ) );
}
EditInteractor * Context::lastCardEditInteractor() const {
return d->lastCardEditInteractor.get();
}
std::auto_ptr<EditInteractor> Context::takeLastCardEditInteractor() {
return d->lastCardEditInteractor;
}
Error Context::startTrustItemListing( const char * pattern, int maxLevel ) {
d->lastop = Private::TrustList;
return Error( d->lasterr = gpgme_op_trustlist_start( d->ctx, pattern, maxLevel ) );
}
TrustItem Context::nextTrustItem( Error & e ) {
gpgme_trust_item_t ti = 0;
e = Error( d->lasterr = gpgme_op_trustlist_next( d->ctx, &ti ) );
return TrustItem( ti );
}
Error Context::endTrustItemListing() {
return Error( d->lasterr = gpgme_op_trustlist_end( d->ctx ) );
}
#ifdef HAVE_GPGME_ASSUAN_ENGINE
static gpgme_error_t assuan_transaction_data_callback( void * opaque, const void * data, size_t datalen ) {
assert( opaque );
AssuanTransaction * t = static_cast<AssuanTransaction*>( opaque );
return t->data( static_cast<const char*>( data ), datalen ).encodedError();
}
static gpgme_error_t assuan_transaction_inquire_callback( void * opaque, const char * name, const char * args, gpgme_data_t * r_data ) {
assert( opaque );
Context::Private * p = static_cast<Context::Private*>( opaque );
AssuanTransaction * t = p->lastAssuanTransaction.get();
assert( t );
Error err;
if ( name ) {
p->lastAssuanInquireData = t->inquire( name, args, err );
} else {
p->lastAssuanInquireData = Data::null;
}
if ( !p->lastAssuanInquireData.isNull() ) {
*r_data = p->lastAssuanInquireData.impl()->data;
}
return err.encodedError();
}
static gpgme_error_t assuan_transaction_status_callback( void * opaque, const char * status, const char * args ) {
assert( opaque );
AssuanTransaction * t = static_cast<AssuanTransaction*>( opaque );
std::string a = args;
percent_unescape( a, true ); // ### why doesn't gpgme do this??
return t->status( status, a.c_str() ).encodedError();
}
#endif
AssuanResult Context::assuanTransact( const char * command ) {
return assuanTransact( command, std::auto_ptr<AssuanTransaction>( new DefaultAssuanTransaction ) );
}
AssuanResult Context::assuanTransact( const char * command, std::auto_ptr<AssuanTransaction> transaction ) {
d->lastop = Private::AssuanTransact;
d->lastAssuanTransaction = transaction;
if ( !d->lastAssuanTransaction.get() ) {
return AssuanResult( Error( d->lasterr = make_error( GPG_ERR_INV_ARG ) ) );
}
#ifdef HAVE_GPGME_ASSUAN_ENGINE
d->lasterr = gpgme_op_assuan_transact( d->ctx, command,
assuan_transaction_data_callback,
d->lastAssuanTransaction.get(),
assuan_transaction_inquire_callback,
d, // sic!
assuan_transaction_status_callback,
d->lastAssuanTransaction.get() );
#else
(void)command;
d->lasterr = make_error( GPG_ERR_NOT_SUPPORTED );
#endif
return AssuanResult( d->ctx, d->lasterr );
}
Error Context::startAssuanTransaction( const char * command ) {
return startAssuanTransaction( command, std::auto_ptr<AssuanTransaction>( new DefaultAssuanTransaction ) );
}
Error Context::startAssuanTransaction( const char * command, std::auto_ptr<AssuanTransaction> transaction ) {
d->lastop = Private::AssuanTransact;
d->lastAssuanTransaction = transaction;
if ( !d->lastAssuanTransaction.get() ) {
return Error( d->lasterr = make_error( GPG_ERR_INV_ARG ) );
}
#ifdef HAVE_GPGME_ASSUAN_ENGINE
return Error( d->lasterr = gpgme_op_assuan_transact_start( d->ctx, command,
assuan_transaction_data_callback,
d->lastAssuanTransaction.get(),
assuan_transaction_inquire_callback,
d, // sic!
assuan_transaction_status_callback,
d->lastAssuanTransaction.get() ) );
#else
(void)command;
return Error( d->lasterr = make_error( GPG_ERR_NOT_SUPPORTED ) );
#endif
}
AssuanResult Context::assuanResult() const {
if ( d->lastop & Private::AssuanTransact ) {
return AssuanResult( d->ctx, d->lasterr );
} else {
return AssuanResult();
}
}
AssuanTransaction * Context::lastAssuanTransaction() const {
return d->lastAssuanTransaction.get();
}
std::auto_ptr<AssuanTransaction> Context::takeLastAssuanTransaction() {
return d->lastAssuanTransaction;
}
DecryptionResult Context::decrypt( const Data & cipherText, Data & plainText ) {
d->lastop = Private::Decrypt;
const Data::Private * const cdp = cipherText.impl();
Data::Private * const pdp = plainText.impl();
d->lasterr = gpgme_op_decrypt( d->ctx, cdp ? cdp->data : 0, pdp ? pdp->data : 0 );
return DecryptionResult( d->ctx, Error( d->lasterr ) );
}
Error Context::startDecryption( const Data & cipherText, Data & plainText ) {
d->lastop = Private::Decrypt;
const Data::Private * const cdp = cipherText.impl();
Data::Private * const pdp = plainText.impl();
return Error( d->lasterr = gpgme_op_decrypt_start( d->ctx, cdp ? cdp->data : 0, pdp ? pdp->data : 0 ) );
}
DecryptionResult Context::decryptionResult() const {
if ( d->lastop & Private::Decrypt ) {
return DecryptionResult( d->ctx, Error( d->lasterr ) );
} else {
return DecryptionResult();
}
}
VerificationResult Context::verifyDetachedSignature( const Data & signature, const Data & signedText ) {
d->lastop = Private::Verify;
const Data::Private * const sdp = signature.impl();
const Data::Private * const tdp = signedText.impl();
d->lasterr = gpgme_op_verify( d->ctx, sdp ? sdp->data : 0, tdp ? tdp->data : 0, 0 );
return VerificationResult( d->ctx, Error( d->lasterr ) );
}
VerificationResult Context::verifyOpaqueSignature( const Data & signedData, Data & plainText ) {
d->lastop = Private::Verify;
const Data::Private * const sdp = signedData.impl();
Data::Private * const pdp = plainText.impl();
d->lasterr = gpgme_op_verify( d->ctx, sdp ? sdp->data : 0, 0, pdp ? pdp->data : 0 );
return VerificationResult( d->ctx, Error( d->lasterr ) );
}
Error Context::startDetachedSignatureVerification( const Data & signature, const Data & signedText ) {
d->lastop = Private::Verify;
const Data::Private * const sdp = signature.impl();
const Data::Private * const tdp = signedText.impl();
return Error( d->lasterr = gpgme_op_verify_start( d->ctx, sdp ? sdp->data : 0, tdp ? tdp->data : 0, 0 ) );
}
Error Context::startOpaqueSignatureVerification( const Data & signedData, Data & plainText ) {
d->lastop = Private::Verify;
const Data::Private * const sdp = signedData.impl();
Data::Private * const pdp = plainText.impl();
return Error( d->lasterr = gpgme_op_verify_start( d->ctx, sdp ? sdp->data : 0, 0, pdp ? pdp->data : 0 ) );
}
VerificationResult Context::verificationResult() const {
if ( d->lastop & Private::Verify ) {
return VerificationResult( d->ctx, Error( d->lasterr ) );
} else {
return VerificationResult();
}
}
std::pair<DecryptionResult,VerificationResult> Context::decryptAndVerify( const Data & cipherText, Data & plainText ) {
d->lastop = Private::DecryptAndVerify;
const Data::Private * const cdp = cipherText.impl();
Data::Private * const pdp = plainText.impl();
d->lasterr = gpgme_op_decrypt_verify( d->ctx, cdp ? cdp->data : 0, pdp ? pdp->data : 0 );
return std::make_pair( DecryptionResult( d->ctx, Error( d->lasterr ) ),
VerificationResult( d->ctx, Error( d->lasterr ) ) );
}
Error Context::startCombinedDecryptionAndVerification( const Data & cipherText, Data & plainText ) {
d->lastop = Private::DecryptAndVerify;
const Data::Private * const cdp = cipherText.impl();
Data::Private * const pdp = plainText.impl();
return Error( d->lasterr = gpgme_op_decrypt_verify_start( d->ctx, cdp ? cdp->data : 0, pdp ? pdp->data : 0 ) );
}
#ifdef HAVE_GPGME_OP_GETAUDITLOG
unsigned int to_auditlog_flags( unsigned int flags ) {
unsigned int result = 0;
if ( flags & Context::HtmlAuditLog ) {
result |= GPGME_AUDITLOG_HTML;
}
if ( flags & Context::AuditLogWithHelp ) {
result |= GPGME_AUDITLOG_WITH_HELP;
}
return result;
}
#endif // HAVE_GPGME_OP_GETAUDITLOG
Error Context::startGetAuditLog( Data & output, unsigned int flags ) {
d->lastop = Private::GetAuditLog;
#ifdef HAVE_GPGME_OP_GETAUDITLOG
Data::Private * const odp = output.impl();
return Error( d->lasterr = gpgme_op_getauditlog_start( d->ctx, odp ? odp->data : 0, to_auditlog_flags( flags ) ) );
#else
(void)output; (void)flags;
return Error( d->lasterr = make_error( GPG_ERR_NOT_IMPLEMENTED ) );
#endif
}
Error Context::getAuditLog( Data & output, unsigned int flags ) {
d->lastop = Private::GetAuditLog;
#ifdef HAVE_GPGME_OP_GETAUDITLOG
Data::Private * const odp = output.impl();
return Error( d->lasterr = gpgme_op_getauditlog( d->ctx, odp ? odp->data : 0, to_auditlog_flags( flags ) ) );
#else
(void)output; (void)flags;
return Error( d->lasterr = make_error( GPG_ERR_NOT_IMPLEMENTED ) );
#endif
}
void Context::clearSigningKeys() {
gpgme_signers_clear( d->ctx );
}
Error Context::addSigningKey( const Key & key ) {
return Error( d->lasterr = gpgme_signers_add( d->ctx, key.impl() ) );
}
Key Context::signingKey( unsigned int idx ) const {
gpgme_key_t key = gpgme_signers_enum( d->ctx, idx );
return Key( key, false );
}
std::vector<Key> Context::signingKeys() const {
std::vector<Key> result;
gpgme_key_t key;
for ( unsigned int i = 0 ; ( key = gpgme_signers_enum( d->ctx, i ) ) ; ++i ) {
result.push_back( Key( key, false ) );
}
return result;
}
void Context::clearSignatureNotations() {
#ifdef HAVE_GPGME_SIG_NOTATION_CLEARADDGET
gpgme_sig_notation_clear( d->ctx );
#endif
}
GpgME::Error Context::addSignatureNotation( const char * name, const char * value, unsigned int flags ) {
#ifdef HAVE_GPGME_SIG_NOTATION_CLEARADDGET
return Error( gpgme_sig_notation_add( d->ctx, name, value, add_to_gpgme_sig_notation_flags_t( 0, flags ) ) );
#else
(void)name; (void)value; (void)flags;
return Error( make_error( GPG_ERR_NOT_IMPLEMENTED ) );
#endif
}
GpgME::Error Context::addSignaturePolicyURL( const char * url, bool critical ) {
#ifdef HAVE_GPGME_SIG_NOTATION_CLEARADDGET
return Error( gpgme_sig_notation_add( d->ctx, 0, url, critical ? GPGME_SIG_NOTATION_CRITICAL : 0 ) );
#else
(void)url; (void)critical;
return Error( make_error( GPG_ERR_NOT_IMPLEMENTED ) );
#endif
}
const char * Context::signaturePolicyURL() const {
#ifdef HAVE_GPGME_SIG_NOTATION_CLEARADDGET
for ( gpgme_sig_notation_t n = gpgme_sig_notation_get( d->ctx ) ; n ; n = n->next ) {
if ( !n->name ) {
return n->value;
}
}
#endif
return 0;
}
Notation Context::signatureNotation( unsigned int idx ) const {
#ifdef HAVE_GPGME_SIG_NOTATION_CLEARADDGET
for ( gpgme_sig_notation_t n = gpgme_sig_notation_get( d->ctx ) ; n ; n = n->next ) {
if ( n->name ) {
if ( idx-- == 0 ) {
return Notation( n );
}
}
}
#endif
return Notation();
}
std::vector<Notation> Context::signatureNotations() const {
std::vector<Notation> result;
#ifdef HAVE_GPGME_SIG_NOTATION_CLEARADDGET
for ( gpgme_sig_notation_t n = gpgme_sig_notation_get( d->ctx ) ; n ; n = n->next ) {
if ( n->name ) {
result.push_back( Notation( n ) );
}
}
#endif
return result;
}
static gpgme_sig_mode_t sigmode2sigmode( SignatureMode mode ) {
switch ( mode ) {
default:
case NormalSignatureMode: return GPGME_SIG_MODE_NORMAL;
case Detached: return GPGME_SIG_MODE_DETACH;
case Clearsigned: return GPGME_SIG_MODE_CLEAR;
}
}
SigningResult Context::sign( const Data & plainText, Data & signature, SignatureMode mode ) {
d->lastop = Private::Sign;
const Data::Private * const pdp = plainText.impl();
Data::Private * const sdp = signature.impl();
d->lasterr = gpgme_op_sign( d->ctx, pdp ? pdp->data : 0, sdp ? sdp->data : 0, sigmode2sigmode( mode ) );
return SigningResult( d->ctx, Error( d->lasterr ) );
}
Error Context::startSigning( const Data & plainText, Data & signature, SignatureMode mode ) {
d->lastop = Private::Sign;
const Data::Private * const pdp = plainText.impl();
Data::Private * const sdp = signature.impl();
return Error( d->lasterr = gpgme_op_sign_start( d->ctx, pdp ? pdp->data : 0, sdp ? sdp->data : 0, sigmode2sigmode( mode ) ) );
}
SigningResult Context::signingResult() const {
if ( d->lastop & Private::Sign ) {
return SigningResult( d->ctx, Error( d->lasterr ) );
} else {
return SigningResult();
}
}
static gpgme_encrypt_flags_t encryptflags2encryptflags( Context::EncryptionFlags flags ) {
unsigned int result = 0;
if ( flags & Context::AlwaysTrust ) {
result |= GPGME_ENCRYPT_ALWAYS_TRUST;
}
#ifdef HAVE_GPGME_ENCRYPT_NO_ENCRYPT_TO
if ( flags & Context::NoEncryptTo ) {
result |= GPGME_ENCRYPT_NO_ENCRYPT_TO;
}
#endif
return static_cast<gpgme_encrypt_flags_t>( result );
}
EncryptionResult Context::encrypt( const std::vector<Key> & recipients, const Data & plainText, Data & cipherText, EncryptionFlags flags ) {
d->lastop = Private::Encrypt;
#ifndef HAVE_GPGME_ENCRYPT_NO_ENCRYPT_TO
if ( flags & NoEncryptTo ) {
return EncryptionResult( Error( d->lasterr = make_error( GPG_ERR_NOT_IMPLEMENTED ) ) );
}
#endif
const Data::Private * const pdp = plainText.impl();
Data::Private * const cdp = cipherText.impl();
gpgme_key_t * const keys = new gpgme_key_t[ recipients.size() + 1 ];
gpgme_key_t * keys_it = keys;
for ( std::vector<Key>::const_iterator it = recipients.begin() ; it != recipients.end() ; ++it ) {
if ( it->impl() ) {
- *keys_it++ = it->impl();
+ *keys_it++ = it->impl();
}
}
*keys_it++ = 0;
d->lasterr = gpgme_op_encrypt( d->ctx, keys, encryptflags2encryptflags( flags ),
- pdp ? pdp->data : 0, cdp ? cdp->data : 0 );
+ pdp ? pdp->data : 0, cdp ? cdp->data : 0 );
delete[] keys;
return EncryptionResult( d->ctx, Error( d->lasterr ) );
}
Error Context::encryptSymmetrically( const Data & plainText, Data & cipherText ) {
d->lastop = Private::Encrypt;
const Data::Private * const pdp = plainText.impl();
Data::Private * const cdp = cipherText.impl();
return Error( d->lasterr = gpgme_op_encrypt( d->ctx, 0, (gpgme_encrypt_flags_t)0,
pdp ? pdp->data : 0, cdp ? cdp->data : 0 ) );
}
Error Context::startEncryption( const std::vector<Key> & recipients, const Data & plainText, Data & cipherText, EncryptionFlags flags ) {
d->lastop = Private::Encrypt;
#ifndef HAVE_GPGME_ENCRYPT_NO_ENCRYPT_TO
if ( flags & NoEncryptTo ) {
return Error( d->lasterr = make_error( GPG_ERR_NOT_IMPLEMENTED ) );
}
#endif
const Data::Private * const pdp = plainText.impl();
Data::Private * const cdp = cipherText.impl();
gpgme_key_t * const keys = new gpgme_key_t[ recipients.size() + 1 ];
gpgme_key_t * keys_it = keys;
for ( std::vector<Key>::const_iterator it = recipients.begin() ; it != recipients.end() ; ++it ) {
if ( it->impl() ) {
- *keys_it++ = it->impl();
+ *keys_it++ = it->impl();
}
}
*keys_it++ = 0;
d->lasterr = gpgme_op_encrypt_start( d->ctx, keys, encryptflags2encryptflags( flags ),
- pdp ? pdp->data : 0, cdp ? cdp->data : 0 );
+ pdp ? pdp->data : 0, cdp ? cdp->data : 0 );
delete[] keys;
return Error( d->lasterr );
}
EncryptionResult Context::encryptionResult() const {
if ( d->lastop & Private::Encrypt ) {
return EncryptionResult( d->ctx, Error( d->lasterr ) );
} else {
return EncryptionResult();
}
}
std::pair<SigningResult,EncryptionResult> Context::signAndEncrypt( const std::vector<Key> & recipients, const Data & plainText, Data & cipherText, EncryptionFlags flags ) {
d->lastop = Private::SignAndEncrypt;
const Data::Private * const pdp = plainText.impl();
Data::Private * const cdp = cipherText.impl();
gpgme_key_t * const keys = new gpgme_key_t[ recipients.size() + 1 ];
gpgme_key_t * keys_it = keys;
for ( std::vector<Key>::const_iterator it = recipients.begin() ; it != recipients.end() ; ++it ) {
if ( it->impl() ) {
- *keys_it++ = it->impl();
+ *keys_it++ = it->impl();
}
}
*keys_it++ = 0;
d->lasterr = gpgme_op_encrypt_sign( d->ctx, keys, encryptflags2encryptflags( flags ),
- pdp ? pdp->data : 0, cdp ? cdp->data : 0 );
+ pdp ? pdp->data : 0, cdp ? cdp->data : 0 );
delete[] keys;
return std::make_pair( SigningResult( d->ctx, Error( d->lasterr ) ),
EncryptionResult( d->ctx, Error( d->lasterr ) ) );
}
Error Context::startCombinedSigningAndEncryption( const std::vector<Key> & recipients, const Data & plainText, Data & cipherText, EncryptionFlags flags ) {
d->lastop = Private::SignAndEncrypt;
const Data::Private * const pdp = plainText.impl();
Data::Private * const cdp = cipherText.impl();
gpgme_key_t * const keys = new gpgme_key_t[ recipients.size() + 1 ];
gpgme_key_t * keys_it = keys;
for ( std::vector<Key>::const_iterator it = recipients.begin() ; it != recipients.end() ; ++it ) {
if ( it->impl() ) {
- *keys_it++ = it->impl();
+ *keys_it++ = it->impl();
}
}
*keys_it++ = 0;
d->lasterr = gpgme_op_encrypt_sign_start( d->ctx, keys, encryptflags2encryptflags( flags ),
- pdp ? pdp->data : 0, cdp ? cdp->data : 0 );
+ pdp ? pdp->data : 0, cdp ? cdp->data : 0 );
delete[] keys;
return Error( d->lasterr );
}
Error Context::createVFS(const char* containerFile, const std::vector< Key >& recipients) {
d->lastop = Private::CreateVFS;
#ifdef HAVE_GPGME_G13_VFS
gpgme_key_t * const keys = new gpgme_key_t[ recipients.size() + 1 ];
gpgme_key_t * keys_it = keys;
for ( std::vector<Key>::const_iterator it = recipients.begin() ; it != recipients.end() ; ++it ) {
if ( it->impl() ) {
*keys_it++ = it->impl();
}
}
*keys_it++ = 0;
gpgme_error_t op_err;
d->lasterr = gpgme_op_vfs_create( d->ctx, keys, containerFile, 0, &op_err );
delete[] keys;
Error error( d->lasterr );
if ( error ) {
return error;
}
return Error( d->lasterr = op_err );
#else
Q_UNUSED( containerFile );
Q_UNUSED( recipients );
return Error( d->lasterr = make_error( GPG_ERR_NOT_SUPPORTED ) );
#endif
}
VfsMountResult Context::mountVFS(const char* containerFile, const char* mountDir) {
d->lastop = Private::MountVFS;
#ifdef HAVE_GPGME_G13_VFS
gpgme_error_t op_err;
d->lasterr = gpgme_op_vfs_mount( d->ctx, containerFile, mountDir, 0, &op_err );
return VfsMountResult( d->ctx, Error( d->lasterr ), Error( op_err ) );
#else
Q_UNUSED( containerFile );
Q_UNUSED( mountDir );
return VfsMountResult( d->ctx, Error( d->lasterr = make_error( GPG_ERR_NOT_SUPPORTED ) ), Error() );
#endif
}
Error Context::cancelPendingOperation() {
#ifdef HAVE_GPGME_CANCEL_ASYNC
return Error( gpgme_cancel_async( d->ctx ) );
#else
return Error( gpgme_cancel( d->ctx ) );
#endif
}
bool Context::poll() {
gpgme_error_t e = GPG_ERR_NO_ERROR;
const bool finished = gpgme_wait( d->ctx, &e, 0 );
if ( finished ) {
d->lasterr = e;
}
return finished;
}
Error Context::wait() {
gpgme_error_t e = GPG_ERR_NO_ERROR;
gpgme_wait( d->ctx, &e, 1 );
return Error( d->lasterr = e );
}
Error Context::lastError() const {
return Error( d->lasterr );
}
std::ostream & operator<<( std::ostream & os, Protocol proto ) {
os << "GpgME::Protocol(";
switch ( proto ) {
case OpenPGP:
os << "OpenPGP";
break;
case CMS:
os << "CMS";
break;
default:
case UnknownProtocol:
os << "UnknownProtocol";
break;
}
return os << ')';
}
std::ostream & operator<<( std::ostream & os, Engine eng ) {
os << "GpgME::Engine(";
switch ( eng ) {
case GpgEngine:
os << "GpgEngine";
break;
case GpgSMEngine:
os << "GpgSMEngine";
break;
case GpgConfEngine:
os << "GpgConfEngine";
break;
case AssuanEngine:
os << "AssuanEngine";
break;
default:
case UnknownEngine:
os << "UnknownEngine";
break;
}
return os << ')';
}
std::ostream & operator<<( std::ostream & os, Context::CertificateInclusion incl ) {
os << "GpgME::Context::CertificateInclusion(" << static_cast<int>( incl );
switch ( incl ) {
case Context::DefaultCertificates:
os << "(DefaultCertificates)";
break;
case Context::AllCertificatesExceptRoot:
os << "(AllCertificatesExceptRoot)";
break;
case Context::AllCertificates:
os << "(AllCertificates)";
break;
case Context::NoCertificates:
os << "(NoCertificates)";
break;
case Context::OnlySenderCertificate:
os << "(OnlySenderCertificate)";
break;
}
return os << ')';
}
std::ostream & operator<<( std::ostream & os, KeyListMode mode ) {
os << "GpgME::KeyListMode(";
#define CHECK( x ) if ( !(mode & (x)) ) {} else do { os << #x " "; } while (0)
CHECK( Local );
CHECK( Extern );
CHECK( Signatures );
CHECK( Validate );
CHECK( Ephemeral );
#undef CHECK
return os << ')';
}
std::ostream & operator<<( std::ostream & os, SignatureMode mode ) {
os << "GpgME::SignatureMode(";
switch ( mode ) {
#define CHECK( x ) case x: os << #x; break
CHECK( NormalSignatureMode );
CHECK( Detached );
CHECK( Clearsigned );
#undef CHECK
default:
os << "???" "(" << static_cast<int>( mode ) << ')';
break;
}
return os << ')';
}
std::ostream & operator<<( std::ostream & os, Context::EncryptionFlags flags ) {
os << "GpgME::Context::EncryptionFlags(";
#define CHECK( x ) if ( !(flags & (Context::x)) ) {} else do { os << #x " "; } while (0)
CHECK( AlwaysTrust );
#undef CHECK
return os << ')';
}
std::ostream & operator<<( std::ostream & os, Context::AuditLogFlags flags ) {
os << "GpgME::Context::AuditLogFlags(";
#define CHECK( x ) if ( !(flags & (Context::x)) ) {} else do { os << #x " "; } while (0)
CHECK( HtmlAuditLog );
CHECK( AuditLogWithHelp );
#undef CHECK
return os << ')';
}
} // namespace GpgME
GpgME::Error GpgME::setDefaultLocale( int cat, const char * val ) {
return Error( gpgme_set_locale( 0, cat, val ) );
}
GpgME::EngineInfo GpgME::engineInfo( GpgME::Protocol proto ) {
gpgme_engine_info_t ei = 0;
if ( gpgme_get_engine_info( &ei ) ) {
return EngineInfo();
}
const gpgme_protocol_t p = proto == CMS ? GPGME_PROTOCOL_CMS : GPGME_PROTOCOL_OpenPGP ;
for ( gpgme_engine_info_t i = ei ; i ; i = i->next ) {
if ( i->protocol == p ) {
return EngineInfo( i );
}
}
return EngineInfo();
}
GpgME::Error GpgME::checkEngine( GpgME::Protocol proto ) {
const gpgme_protocol_t p = proto == CMS ? GPGME_PROTOCOL_CMS : GPGME_PROTOCOL_OpenPGP ;
return Error( gpgme_engine_check_version( p ) );
}
static gpgme_protocol_t UNKNOWN_PROTOCOL = static_cast<gpgme_protocol_t>( 255 );
static gpgme_protocol_t engine2protocol( const GpgME::Engine engine ) {
switch ( engine ) {
case GpgME::GpgEngine: return GPGME_PROTOCOL_OpenPGP;
case GpgME::GpgSMEngine: return GPGME_PROTOCOL_CMS;
case GpgME::GpgConfEngine:
#ifdef HAVE_GPGME_PROTOCOL_GPGCONF
return GPGME_PROTOCOL_GPGCONF;
#else
break;
#endif
case GpgME::AssuanEngine:
#ifdef HAVE_GPGME_ASSUAN_ENGINE
return GPGME_PROTOCOL_ASSUAN;
#else
break;
#endif
case GpgME::G13Engine:
#ifdef HAVE_GPGME_G13_VFS
return GPGME_PROTOCOL_G13;
#else
break;
#endif
case GpgME::UnknownEngine:
;
}
return UNKNOWN_PROTOCOL;
}
GpgME::EngineInfo GpgME::engineInfo( GpgME::Engine engine ) {
gpgme_engine_info_t ei = 0;
if ( gpgme_get_engine_info( &ei ) ) {
return EngineInfo();
}
const gpgme_protocol_t p = engine2protocol( engine );
for ( gpgme_engine_info_t i = ei ; i ; i = i->next ) {
if ( i->protocol == p ) {
return EngineInfo( i );
}
}
return EngineInfo();
}
GpgME::Error GpgME::checkEngine( GpgME::Engine engine ) {
const gpgme_protocol_t p = engine2protocol( engine );
return Error( gpgme_engine_check_version( p ) );
}
static const unsigned long supported_features = 0
| GpgME::ValidatingKeylistModeFeature
| GpgME::CancelOperationFeature
| GpgME::WrongKeyUsageFeature
#ifdef HAVE_GPGME_INCLUDE_CERTS_DEFAULT
| GpgME::DefaultCertificateInclusionFeature
#endif
#ifdef HAVE_GPGME_CTX_GETSET_ENGINE_INFO
| GpgME::GetSetEngineInfoFeature
#endif
#ifdef HAVE_GPGME_SIG_NOTATION_CLEARADDGET
| GpgME::ClearAddGetSignatureNotationsFeature
#endif
#ifdef HAVE_GPGME_DATA_SET_FILE_NAME
| GpgME::SetDataFileNameFeeature
#endif
#ifdef HAVE_GPGME_KEYLIST_MODE_SIG_NOTATIONS
| GpgME::SignatureNotationsKeylistModeFeature
#endif
#ifdef HAVE_GPGME_KEY_SIG_NOTATIONS
| GpgME::KeySignatureNotationsFeature
#endif
#ifdef HAVE_GPGME_KEY_T_IS_QUALIFIED
| GpgME::KeyIsQualifiedFeature
#endif
#ifdef HAVE_GPGME_SIG_NOTATION_CRITICAL
| GpgME::SignatureNotationsCriticalFlagFeature
#endif
#ifdef HAVE_GPGME_SIG_NOTATION_FLAGS_T
| GpgME::SignatureNotationsFlagsFeature
#endif
#ifdef HAVE_GPGME_SIG_NOTATION_HUMAN_READABLE
| GpgME::SignatureNotationsHumanReadableFlagFeature
#endif
#ifdef HAVE_GPGME_SUBKEY_T_IS_QUALIFIED
| GpgME::SubkeyIsQualifiedFeature
#endif
#ifdef HAVE_GPGME_ENGINE_INFO_T_HOME_DIR
| GpgME::EngineInfoHomeDirFeature
#endif
#ifdef HAVE_GPGME_DECRYPT_RESULT_T_FILE_NAME
| GpgME::DecryptionResultFileNameFeature
#endif
#ifdef HAVE_GPGME_DECRYPT_RESULT_T_RECIPIENTS
| GpgME::DecryptionResultRecipientsFeature
#endif
#ifdef HAVE_GPGME_VERIFY_RESULT_T_FILE_NAME
| GpgME::VerificationResultFileNameFeature
#endif
#ifdef HAVE_GPGME_SIGNATURE_T_PKA_FIELDS
| GpgME::SignaturePkaFieldsFeature
#endif
#ifdef HAVE_GPGME_SIGNATURE_T_ALGORITHM_FIELDS
| GpgME::SignatureAlgorithmFieldsFeature
#endif
#ifdef HAVE_GPGME_GET_FDPTR
| GpgME::FdPointerFeature
#endif
#ifdef HAVE_GPGME_OP_GETAUDITLOG
| GpgME::AuditLogFeature
#endif
#ifdef HAVE_GPGME_PROTOCOL_GPGCONF
| GpgME::GpgConfEngineFeature
#endif
#ifdef HAVE_GPGME_CANCEL_ASYNC
| GpgME::CancelOperationAsyncFeature
#endif
#ifdef HAVE_GPGME_ENCRYPT_NO_ENCRYPT_TO
| GpgME::NoEncryptToEncryptionFlagFeature
#endif
#ifdef HAVE_GPGME_SUBKEY_T_IS_CARDKEY
| GpgME::CardKeyFeature
#endif
#ifdef HAVE_GPGME_ASSUAN_ENGINE
| GpgME::AssuanEngineFeature
#endif
#ifdef HAVE_GPGME_KEYLIST_MODE_EPHEMERAL
| GpgME::EphemeralKeylistModeFeature
#endif
#ifdef HAVE_GPGME_OP_IMPORT_KEYS
| GpgME::ImportFromKeyserverFeature
#endif
#ifdef HAVE_GPGME_G13_VFS
| GpgME::G13VFSFeature
#endif
#ifdef HAVE_GPGME_OP_PASSWD
| GpgME::PasswdFeature
#endif
;
static const unsigned long supported_features2 = 0
;
bool GpgME::hasFeature( unsigned long features ) {
return features == ( features & supported_features );
}
bool GpgME::hasFeature( unsigned long features, unsigned long features2 ) {
return features == ( features & supported_features )
&& features2 == ( features2 & supported_features2 )
;
}
diff --git a/data.cpp b/data.cpp
index 3f42cd90..31542a2b 100644
--- a/data.cpp
+++ b/data.cpp
@@ -1,184 +1,184 @@
/*
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 <gpgme++/error.h>
#include <gpgme++/interfaces/dataprovider.h>
#include <gpgme.h>
#ifndef NDEBUG
#include <iostream>
#endif
GpgME::Data::Private::~Private() {
if ( data ) {
gpgme_data_release( data );
}
}
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;
+ // << ( 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 );
}
diff --git a/data.h b/data.h
index f55d43ea..c3768e32 100644
--- a/data.h
+++ b/data.h
@@ -1,99 +1,98 @@
/*
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 <gpgme++/gpgmefw.h>
-#include <gpgme++/gpgme++_export.h>
+#include <gpgme++/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 {};
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 Null null;
const Data & operator=( Data other ) {
- swap( other );
- return *this;
+ swap( other );
+ return *this;
}
void swap( Data & other ) {
- using std::swap;
- swap( this->d, other.d );
+ using std::swap;
+ swap( this->d, other.d );
}
bool isNull() const;
enum Encoding {
- AutoEncoding,
- BinaryEncoding,
- Base64Encoding,
- ArmorEncoding
+ 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__
diff --git a/decryptionresult.h b/decryptionresult.h
index d4ae1c2e..db328325 100644
--- a/decryptionresult.h
+++ b/decryptionresult.h
@@ -1,122 +1,122 @@
/*
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 <gpgme++/gpgmefw.h>
#include <gpgme++/result.h>
#include <gpgme++/gpgme++_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;
+ swap( other );
+ return *this;
}
void swap( DecryptionResult & other ) {
- Result::swap( other );
- using std::swap;
- swap( this->d, other.d );
+ 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;
+ swap( other );
+ return *this;
}
void swap( Recipient & other ) {
- using std::swap;
- swap( this->d, other.d );
+ 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__
diff --git a/encryptionresult.cpp b/encryptionresult.cpp
index 1cfcf140..cb194294 100644
--- a/encryptionresult.cpp
+++ b/encryptionresult.cpp
@@ -1,155 +1,155 @@
/*
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 <gpgme++/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->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 << ')';
}
diff --git a/encryptionresult.h b/encryptionresult.h
index bb5a08bd..9b0f27df 100644
--- a/encryptionresult.h
+++ b/encryptionresult.h
@@ -1,106 +1,106 @@
/*
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 <gpgme++/gpgmefw.h>
#include <gpgme++/result.h>
#include <gpgme++/gpgme++_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;
+ swap( other );
+ return *this;
}
void swap( EncryptionResult & other ) {
- Result::swap( other );
- using std::swap;
- swap( this->d, other.d );
+ 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;
+ swap( other );
+ return *this;
}
void swap( InvalidRecipient & other ) {
- using std::swap;
- swap( this->d, other.d );
+ 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__
diff --git a/engineinfo.h b/engineinfo.h
index dfd637ef..2046bb89 100644
--- a/engineinfo.h
+++ b/engineinfo.h
@@ -1,66 +1,66 @@
/*
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 <gpgme++/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;
+ swap( other );
+ return *this;
}
void swap( EngineInfo & other ) {
- using std::swap;
- swap( this->d, other.d );
+ 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__
diff --git a/error.h b/error.h
index 74572695..70f45c7c 100644
--- a/error.h
+++ b/error.h
@@ -1,76 +1,75 @@
/*
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 <gpgme++/gpgmefw.h>
-#include <gpgme++/gpgme++_export.h>
+#include <gpgme++/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__ */
diff --git a/eventloopinteractor.cpp b/eventloopinteractor.cpp
index 91eb49a9..70811075 100644
--- a/eventloopinteractor.cpp
+++ b/eventloopinteractor.cpp
@@ -1,197 +1,197 @@
/*
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 <gpgme++/eventloopinteractor.h>
#include <gpgme++/context.h>
#include "context_p.h"
#include <gpgme++/key.h>
#include <gpgme++/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 ) {}
+ 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 );
+ gpgme_io_cb_t fnc, void * fnc_data,
+ void ** r_tag );
static void eventIOCb( void *, gpgme_event_io_t type, void * type_data );
static gpgme_io_cbs iocbs;
};
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 )
+ 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 ) {
+ it != instance()->d->mCallbacks.end() ; ++it ) {
if ( *it == tag ) {
- instance()->unregisterWatcher( ( *it )->externalTag );
- delete *it; *it = 0;
- instance()->d->mCallbacks.erase( it );
- return;
+ 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?
+ // 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;
+ gpgme_error_t e = *static_cast<gpgme_error_t*>( type_data );
+ if ( ctx && ctx->impl() ) {
+ ctx->impl()->lasterr = e;
}
- instance()->operationDoneEvent( ctx, Error( 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 ) );
+ 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 );
+ 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 ) {
+ it != d->mCallbacks.end() ; ++it ) {
if ( ( *it )->fd == fd && ( ( *it )->dir ? Read : Write ) == dir ) {
- ( *( ( *it )->fnc ) )( ( *it )->fncData, fd );
- break;
+ ( *( ( *it )->fnc ) )( ( *it )->fncData, fd );
+ break;
}
}
}
} // namespace GpgME
diff --git a/eventloopinteractor.h b/eventloopinteractor.h
index 3705b201..1f78b82d 100644
--- a/eventloopinteractor.h
+++ b/eventloopinteractor.h
@@ -1,154 +1,154 @@
/*
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 <gpgme++/gpgme++_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...
+ // 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 */
+ 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__
diff --git a/global.h b/global.h
index 1a8f3a44..91fb0b05 100644
--- a/global.h
+++ b/global.h
@@ -1,140 +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 <gpgme++/gpgmefw.h>
#include <gpgme++/gpgme++_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_EXPORT_DEPRECATED bool hasFeature( unsigned long feature );
+ 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__
diff --git a/gpgme++_export.h b/gpgme++_export.h
deleted file mode 100644
index 9c611423..00000000
--- a/gpgme++_export.h
+++ /dev/null
@@ -1,69 +0,0 @@
-/* This file is part of the KDE project
- Copyright (C) 2007 David Faure <faure@kde.org>
-
- This library 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.
-
- This library 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 this library; 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_EXPORT_H
-#define GPGMEPP_EXPORT_H
-
-/* needed for GPGMEPP_EXPORT and KDE_IMPORT macros */
-/* HACK! Port this to generated export header */
-#include <qglobal.h>
-
-/* HACK */
-#ifndef KDE_DEPRECATED
-# define KDE_DEPRECATED __attribute__ ((__deprecated__))
-# define KDE_DEPRECATED_EXPORT KDECORE_EXPORT __attribute__ ((__deprecated__))
-# define KDE_DEPRECATED_NO_EXPORT KDECORE_NO_EXPORT __attribute__ ((__deprecated__))
-#endif
-
-#ifndef GPGMEPP_EXPORT
-# if defined(KDEPIM_STATIC_LIBS)
- /* No export/import for static libraries */
-# define GPGMEPP_EXPORT
-# elif defined(MAKE_GPGME___LIB) || defined(MAKE_GPGMEPP_LIB)
- /* We are building this library */
-# define GPGMEPP_EXPORT Q_DECL_EXPORT
-# else
- /* We are using this library */
-# define GPGMEPP_EXPORT
-# endif
-#endif
-
-# ifndef GPGMEPP_EXPORT_DEPRECATED
-# define GPGMEPP_EXPORT_DEPRECATED KDE_DEPRECATED GPGMEPP_EXPORT
-# endif
-
-# ifndef GPGMEPP_DEPRECATED
-# define GPGMEPP_DEPRECATED KDE_DEPRECATED
-# endif
-
-# 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
diff --git a/gpgsignkeyeditinteractor.cpp b/gpgsignkeyeditinteractor.cpp
index 973024ed..cc20cea0 100644
--- a/gpgsignkeyeditinteractor.cpp
+++ b/gpgsignkeyeditinteractor.cpp
@@ -1,306 +1,306 @@
/*
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::tuples::make_tuple( static_cast<SignKeyState>( state() ), status, std::string( args ) ) );
+ 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;
}
diff --git a/importresult.h b/importresult.h
index 3f9ab5f5..676ca72a 100644
--- a/importresult.h
+++ b/importresult.h
@@ -1,127 +1,127 @@
/*
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 <gpgme++/gpgmefw.h>
#include <gpgme++/result.h>
#include <gpgme++/gpgme++_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;
+ swap( other );
+ return *this;
}
void swap( ImportResult & other ) {
- Result::swap( other );
- using std::swap;
- swap( this->d, other.d );
+ 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;
+ swap( other );
+ return *this;
}
void swap( Import & other ) {
- using std::swap;
- swap( this->d, other.d );
- swap( this->idx, other.idx );
+ 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__
diff --git a/interfaces/assuantransaction.h b/interfaces/assuantransaction.h
index 05a60b2d..3ba1e22a 100644
--- a/interfaces/assuantransaction.h
+++ b/interfaces/assuantransaction.h
@@ -1,45 +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 <gpgme++/gpgme++_export.h>
+#include <qglobal.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__
diff --git a/interfaces/passphraseprovider.h b/interfaces/passphraseprovider.h
index a477e05d..b39ef7dc 100644
--- a/interfaces/passphraseprovider.h
+++ b/interfaces/passphraseprovider.h
@@ -1,38 +1,38 @@
/*
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;
+ bool previousWasBad, bool & canceled ) = 0;
};
} // namespace GpgME
#endif // __GPGMEPP_INTERFACES_PASSPHRASEPROVIDER_H__
diff --git a/interfaces/progressprovider.h b/interfaces/progressprovider.h
index bf3d9873..1f2a1b07 100644
--- a/interfaces/progressprovider.h
+++ b/interfaces/progressprovider.h
@@ -1,38 +1,38 @@
/*
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;
+ int current, int total ) = 0;
};
} // namespace GpgME
#endif // __GPGMEPP_INTERFACES_PROGRESSPROVIDER_H__
diff --git a/key.cpp b/key.cpp
index 957c37fc..75a3ace5 100644
--- a/key.cpp
+++ b/key.cpp
@@ -1,757 +1,757 @@
/*
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 <gpgme++/key.h>
#include "util.h"
#include <gpgme.h>
#include <string.h>
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 ) {
+ 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 );
+ 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 ) );
+ 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;
+ return nota->value;
}
}
#endif
return 0;
}
} // namespace GpgME
diff --git a/keygenerationresult.h b/keygenerationresult.h
index e92762c7..217fdee0 100644
--- a/keygenerationresult.h
+++ b/keygenerationresult.h
@@ -1,76 +1,76 @@
/*
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 <gpgme++/gpgmefw.h>
#include <gpgme++/result.h>
#include <gpgme++/gpgme++_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;
+ swap( other );
+ return *this;
}
void swap( KeyGenerationResult & other ) {
- Result::swap( other );
- using std::swap;
- swap( this->d, other.d );
+ 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__
diff --git a/keylistresult.h b/keylistresult.h
index a4ae988e..a9674ee6 100644
--- a/keylistresult.h
+++ b/keylistresult.h
@@ -1,76 +1,76 @@
/*
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 <gpgme++/gpgmefw.h>
#include <gpgme++/result.h>
#include <gpgme++/gpgme++_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;
+ swap( other );
+ return *this;
}
void swap( KeyListResult & other ) {
- Result::swap( other );
- using std::swap;
- swap( this->d, other.d );
+ 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__
diff --git a/notation.h b/notation.h
index 3c008a7d..0443546a 100644
--- a/notation.h
+++ b/notation.h
@@ -1,80 +1,80 @@
/*
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 <gpgme++/gpgmefw.h>
#include <gpgme++/verificationresult.h>
#include <gpgme++/gpgme++_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;
+ swap( other );
+ return *this;
}
void swap( Notation & other ) {
- using std::swap;
- swap( this->d, other.d );
+ 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
+ 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__
diff --git a/scdgetinfoassuantransaction.cpp b/scdgetinfoassuantransaction.cpp
index 1f802af3..080fc31f 100644
--- a/scdgetinfoassuantransaction.cpp
+++ b/scdgetinfoassuantransaction.cpp
@@ -1,154 +1,143 @@
/*
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"
-#ifndef _WIN32_WCE
#include <boost/algorithm/string/split.hpp>
#include <boost/algorithm/string/classification.hpp>
-#endif
#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;
-#ifdef _WIN32_WCE
- for ( std::string::size_type b = 0, e = s.find( '\n', 0 ); e != std::string::npos ; b = e + 1, e = s.find( '\n', b ) ) {
- if ( e > b ) {
- result.push_back( s.substr( b, e - b ) );
- }
- }
- return result;
-#else
return split( result, s, is_any_of( "\n" ), token_compress_on );
-#endif
}
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 * 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();
}
diff --git a/signingresult.cpp b/signingresult.cpp
index b2893cb8..965751bf 100644
--- a/signingresult.cpp
+++ b/signingresult.cpp
@@ -1,251 +1,251 @@
/*
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 <gpgme++/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->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->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 << ')';
}
diff --git a/signingresult.h b/signingresult.h
index fa59e1f8..128df7d1 100644
--- a/signingresult.h
+++ b/signingresult.h
@@ -1,152 +1,152 @@
/*
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 <gpgme++/global.h>
#include <gpgme++/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;
+ swap( other );
+ return *this;
}
void swap( SigningResult & other ) {
- Result::swap( other );
- using std::swap;
- swap( this->d, other.d );
+ 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;
+ swap( other );
+ return *this;
}
void swap( InvalidSigningKey & other ) {
- using std::swap;
- swap( this->d, other.d );
- swap( this->idx, other.idx );
+ 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;
+ swap( other );
+ return *this;
}
void swap( CreatedSignature & other ) {
- using std::swap;
- swap( this->d, other.d );
- swap( this->idx, other.idx );
+ 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__
diff --git a/trustitem.cpp b/trustitem.cpp
index 5291668d..2c7ee491 100644
--- a/trustitem.cpp
+++ b/trustitem.cpp
@@ -1,104 +1,104 @@
/*
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 <gpgme++/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 ;
+ d->item->type == 1 ? Key :
+ d->item->type == 2 ? UserID :
+ Unknown ;
}
}
} // namespace GpgME
diff --git a/trustitem.h b/trustitem.h
index c2d6dc95..28b9e065 100644
--- a/trustitem.h
+++ b/trustitem.h
@@ -1,77 +1,77 @@
/*
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 <gpgme++/gpgmefw.h>
#include <gpgme++/key.h>
#include <gpgme++/gpgme++_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;
+ swap( other );
+ return *this;
}
void swap( TrustItem & other ) {
- using std::swap;
- swap( this->d, other.d );
+ 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__
diff --git a/util.h b/util.h
index f5c79a61..c5cda043 100644
--- a/util.h
+++ b/util.h
@@ -1,172 +1,172 @@
/*
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 <gpgme++/global.h>
#include <gpgme++/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 |
+ GPGME_KEYLIST_MODE_EXTERN |
#ifdef HAVE_GPGME_KEYLIST_MODE_SIG_NOTATIONS
- GPGME_KEYLIST_MODE_SIG_NOTATIONS |
+ GPGME_KEYLIST_MODE_SIG_NOTATIONS |
#endif
#ifdef HAVE_GPGME_KEYLIST_MODE_EPHEMERAL
- GPGME_KEYLIST_MODE_EPHEMERAL |
+ GPGME_KEYLIST_MODE_EPHEMERAL |
#endif
- GPGME_KEYLIST_MODE_VALIDATE |
- GPGME_KEYLIST_MODE_SIGS ) ) {
+ 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;
+ result |= GPGME_SIG_NOTATION_HUMAN_READABLE;
#elif !defined(NDEBUG)
- //std::cerr << "GpgME::Context: ignoring HumanReadable signature notation flag (gpgme too old)" << std::endl;
+ //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;
+ result |= GPGME_SIG_NOTATION_CRITICAL;
#elif !defined(NDEBUG)
- //std::cerr << "GpgME::Context: ignoring Critical signature notation flag (gpgme too old)" << std::endl;
+ //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__
diff --git a/verificationresult.cpp b/verificationresult.cpp
index ee83838c..37b11219 100644
--- a/verificationresult.cpp
+++ b/verificationresult.cpp
@@ -1,552 +1,552 @@
/*
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 <gpgme++/verificationresult.h>
#include <gpgme++/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 );
+ 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 );
+ 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
+ if ( !in->name ) {
+ if ( in->value ) {
+ purls.back() = strdup( in->value ); // policy url
}
- continue;
- }
+ continue;
+ }
#ifdef HAVE_GPGME_SIG_NOTATION_FLAGS_T
- Nota n = { 0, 0, in->flags };
+ 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 );
+ n.name = strdup( in->name );
+ if ( in->value ) {
+ n.value = strdup( in->value );
}
- nota.back().push_back( n );
+ 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::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 )
+ : 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 )
+ : 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 )
+ : 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;
+ return true;
}
if ( d->d ) {
- return d->sidx >= d->d->nota.size() || d->nidx >= d->d->nota[d->sidx].size() ;
+ 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 ;
+ 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 ;
+ 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 << ")";
}
diff --git a/verificationresult.h b/verificationresult.h
index d4f9718e..92e1ece5 100644
--- a/verificationresult.h
+++ b/verificationresult.h
@@ -1,166 +1,166 @@
/*
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 <gpgme++/gpgmefw.h>
#include <gpgme++/result.h>
#include <gpgme++/gpgme++_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;
+ swap( other );
+ return *this;
}
void swap( VerificationResult & other ) {
- Result::swap( other );
- using std::swap;
- swap( this->d, other.d );
+ 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;
+ swap( other );
+ return *this;
}
void swap( Signature & other ) {
- using std::swap;
- swap( this->d, other.d );
- swap( this->idx, other.idx );
+ 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
+ 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__

File Metadata

Mime Type
text/x-diff
Expires
Thu, Feb 26, 6:45 PM (4 h, 43 m)
Storage Engine
local-disk
Storage Format
Raw Data
Storage Handle
da/67/76e40b63282c07a27dfad336b17a

Event Timeline