diff --git a/gpgme++/ConfigureChecks.cmake b/gpgme++/ConfigureChecks.cmake
index f7a7bcfd8..74cae3415 100644
--- a/gpgme++/ConfigureChecks.cmake
+++ b/gpgme++/ConfigureChecks.cmake
@@ -1,335 +1,346 @@
 # gpgme configure checks
 include(CheckFunctionExists)
 
 if ( GPGME_FOUND )
 
 set(CMAKE_REQUIRED_INCLUDES ${GPGME_INCLUDES})
 set(CMAKE_REQUIRED_LIBRARIES)
 foreach( _FLAVOUR VANILLA PTHREAD QT PTH GLIB )
   if ( NOT CMAKE_REQUIRED_LIBRARIES )
     if ( GPGME_${_FLAVOUR}_FOUND )
       set(CMAKE_REQUIRED_LIBRARIES ${GPGME_VANILLA_LIBRARIES})
     endif( GPGME_${_FLAVOUR}_FOUND )
   endif( NOT CMAKE_REQUIRED_LIBRARIES )
 endforeach( _FLAVOUR )
 
 # check if gpgme has gpgme_data_{get,set}_file_name (new in 1.1.0)
 check_cxx_source_compiles ("
   #include <gpgme.h>
   int main() {
     gpgme_data_t data = 0;
     const char * filename = 0;
     const gpgme_error_t err = gpgme_data_set_file_name( data, filename );
     char * filename2 = gpgme_data_get_file_name( data );
     (void)filename2; (void)err;
     return 0;
   }
 " HAVE_GPGME_DATA_SET_FILE_NAME
 )
 
 # check if gpgme has GPGME_INCLUDE_CERTS_DEFAULT
 check_cxx_source_compiles ("
   #include <gpgme.h>
   int main() {
     int i = GPGME_INCLUDE_CERTS_DEFAULT;
     return 0;
   }
 " HAVE_GPGME_INCLUDE_CERTS_DEFAULT
 )
 
 # check if gpgme has GPGME_KEYLIST_MODE_SIG_NOTATIONS
 check_cxx_source_compiles ("
   #include <gpgme.h>
   int main() {
     gpgme_keylist_mode_t mode = GPGME_KEYLIST_MODE_SIG_NOTATIONS;
     return 0;
   }
 " HAVE_GPGME_KEYLIST_MODE_SIG_NOTATIONS
 )
 
 # check if gpgme_key_sig_t has notations
 check_cxx_source_compiles ("
   #include <gpgme.h>
   int main() {
     gpgme_key_sig_t key_sig = 0;
     gpgme_sig_notation_t notation = key_sig->notations;
     return 0;
   }
 " HAVE_GPGME_KEY_SIG_NOTATIONS
 )
 
 # check if gpgme has gpgme_key_t->is_qualified
 check_cxx_source_compiles ("
   #include <gpgme.h>
   void test(gpgme_key_t& key) {
     unsigned int iq;
     iq = key->is_qualified;
   }
   int main() { return 0; }
 " HAVE_GPGME_KEY_T_IS_QUALIFIED 
 )
 
 # check if gpgme has gpgme_sig_notation_t->critical
 check_cxx_source_compiles ("
   #include <gpgme.h>
   int main() {
     gpgme_sig_notation_t sig_notation = 0;
     unsigned int cr1 = sig_notation->critical;
     unsigned int cr2 = GPGME_SIG_NOTATION_CRITICAL;
     return 0;
   }
 " HAVE_GPGME_SIG_NOTATION_CRITICAL
 )
 
 # check if gpgme has gpgme_sig_notation_t->flags
 check_cxx_source_compiles ("
   #include <gpgme.h>
   int main() {
     gpgme_sig_notation_t sig_notation = 0;
     gpgme_sig_notation_flags_t f = sig_notation->flags;
     return 0;
   }
 " HAVE_GPGME_SIG_NOTATION_FLAGS_T
 )
 
 # check if gpgme has gpgme_sig_notation_t->human_readable
 check_cxx_source_compiles ("
   #include <gpgme.h>
   int main() {
     gpgme_sig_notation_t sig_notation = 0;
     unsigned int cr1 = sig_notation->human_readable;
     unsigned int cr2 = GPGME_SIG_NOTATION_HUMAN_READABLE;
     return 0;
   }
 " HAVE_GPGME_SIG_NOTATION_HUMAN_READABLE
 )
 
 # check if gpgme has gpgme_subkey_t->is_qualified
 check_cxx_source_compiles ("
   #include <gpgme.h>
   void test(gpgme_subkey_t& subkey) {
     unsigned int iq;
     iq = subkey->is_qualified;
   }
   int main() { return 0; }
 " HAVE_GPGME_SUBKEY_T_IS_QUALIFIED 
 )
 
 # check if gpgme has gpgme_engine_info_t->home_dir
 check_cxx_source_compiles ("
   #include <gpgme.h>
   int main() {
     gpgme_engine_info_t ei = 0;
     const char * hd = ei->home_dir;
     return 0;
   }
 " HAVE_GPGME_ENGINE_INFO_T_HOME_DIR
 )
 
 #check if gpgme has gpgme_ctx_{get,set}_engine_info()
 check_cxx_source_compiles ("
   #include <gpgme.h>
   int main() {
     gpgme_ctx_t ctx = 0;
     const gpgme_engine_info_t ei = gpgme_ctx_get_engine_info( ctx );
     const char * filename = 0;
     const char * home_dir = 0;
     const gpgme_error_t e
       = gpgme_ctx_set_engine_info( ctx, GPGME_PROTOCOL_OpenPGP, filename, home_dir );
     return 0;
   }
 " HAVE_GPGME_CTX_GETSET_ENGINE_INFO
 )
 
 # missing, but not needed yet (only for edit interaction)
 #+    GPGME_STATUS_SIG_SUBPACKET,
 #+    GPGME_STATUS_NEED_PASSPHRASE_PIN,
 #+    GPGME_STATUS_SC_OP_FAILURE,
 #+    GPGME_STATUS_SC_OP_SUCCESS,
 #+    GPGME_STATUS_CARDCTRL,
 #+    GPGME_STATUS_BACKUP_KEY_CREATED,
 #+    GPGME_STATUS_PKA_TRUST_BAD,
 #+    GPGME_STATUS_PKA_TRUST_GOOD,
 #+
 #+    GPGME_STATUS_PLAINTEXT
 
 # check if gpgme has gpgme_sig_notation_{clear,add,get}
 check_cxx_source_compiles ("
   #include <gpgme.h>
   int main() {
     gpgme_ctx_t ctx = 0;
     const gpgme_sig_notation_t nota = gpgme_sig_notation_get( ctx );
     const char * const name = 0;
     const char * const value = 0;
     const gpgme_sig_notation_flags_t flags = 0;
     const gpgme_error_t err = gpgme_sig_notation_add( ctx, name, value, flags );
     gpgme_sig_notation_clear( ctx );
     return 0;
   }
 " HAVE_GPGME_SIG_NOTATION_CLEARADDGET
 )
 
 # check if gpgme has gpgme_decrypt_result_t->file_name
 check_cxx_source_compiles ("
   #include <gpgme.h>
   int main() {
     gpgme_decrypt_result_t res = 0;
     const char * const fn = res->file_name;
     (void)fn;
   }
 " HAVE_GPGME_DECRYPT_RESULT_T_FILE_NAME
 )
 
 # check if gpgme has gpgme_recipient_t and gpgme_decrypt_result_t->recipients
 check_cxx_source_compiles ("
   #include <gpgme.h>
   int main() {
     gpgme_decrypt_result_t res = 0;
     gpgme_recipient_t r = res->recipients;
     const char * kid = r->keyid;
     r = r->next;
     const gpgme_pubkey_algo_t algo = r->pubkey_algo;
     const gpgme_error_t err = r->status;
     return 0;
   }
 " HAVE_GPGME_DECRYPT_RESULT_T_RECIPIENTS
 )
 
 # check if gpgme has gpgme_verify_result_t->file_name
 check_cxx_source_compiles ("
   #include <gpgme.h>
   int main() {
     gpgme_verify_result_t res = 0;
     const char * fn = res->file_name;
     (void)fn;
     return 0;
   }
 " HAVE_GPGME_VERIFY_RESULT_T_FILE_NAME
 )
 
 # check if gpgme has gpgme_signature_t->pka_{trust,address}
 check_cxx_source_compiles ("
   #include <gpgme.h>
   int main() {
     gpgme_signature_t sig = 0;
     unsigned int pkat = sig->pka_trust;
     const char * pkaa = sig->pka_address;
     return 0;
   }
 " HAVE_GPGME_SIGNATURE_T_PKA_FIELDS
 )
 
 # check if gpgme has gpgme_signature_t->{hash,pubkey}_algo
 check_cxx_source_compiles ("
   #include <gpgme.h>
   int main() {
     gpgme_signature_t sig = 0;
     gpgme_pubkey_algo_t pk = sig->pubkey_algo;
     gpgme_hash_algo_t h = sig->hash_algo;
     return 0;
   }
 " HAVE_GPGME_SIGNATURE_T_ALGORITHM_FIELDS
 )
 
 # check if gpgme has gpgme_signature_t->chain_model
 check_cxx_source_compiles ("
   #include <gpgme.h>
   int main() {
     gpgme_signature_t sig = 0;
     unsigned int cm = sig->chain_model;
     return 0;
   }
 " HAVE_GPGME_SIGNATURE_T_CHAIN_MODEL
 )
 
 # check if gpgme has gpgme_get_fdptr
 check_function_exists( "gpgme_get_fdptr" HAVE_GPGME_GET_FDPTR )
 
 # check if gpgme has gpgme_op_getauditlog
 check_function_exists ("gpgme_op_getauditlog" HAVE_GPGME_OP_GETAUDITLOG )
 
 # check if gpgme has GPGME_PROTOCOL_GPGCONF
 check_cxx_source_compiles ("
   #include <gpgme.h>
   int main() {
     gpgme_protocol_t proto = GPGME_PROTOCOL_GPGCONF;
     return 0;
   }
 " HAVE_GPGME_PROTOCOL_GPGCONF
 )
 
 # check if gpgme has gpgme_cancel_async
 check_function_exists ("gpgme_cancel_async" HAVE_GPGME_CANCEL_ASYNC )
 
 # check if gpg-error has GPG_ERR_NO_PASSPHRASE
 check_cxx_source_compiles ("
   #include <gpg-error.h>
   int main() {
     gpg_error_t err = GPG_ERR_NO_PASSPHRASE;
     return 0;
   }
 " HAVE_GPG_ERR_NO_PASSPHRASE )
 
 # check if gpg-error has GPG_ERR_ALREADY_SIGNED
 check_cxx_source_compiles ("
   #include <gpg-error.h>
   int main() {
     gpg_error_t err = GPG_ERR_ALREADY_SIGNED;
     return 0;
   }
 " HAVE_GPG_ERR_ALREADY_SIGNED )
 
 # check if gpgme has GPGME_ENCRYPT_NO_ENCRYPT_TO
 check_cxx_source_compiles ("
   #include <gpgme.h>
   int main() {
     gpgme_encrypt_flags_t f = GPGME_ENCRYPT_NO_ENCRYPT_TO;
     return 0;
   }
 " HAVE_GPGME_ENCRYPT_NO_ENCRYPT_TO )
 
 # check if gpgme has gpgme_subkey_t->is_cardkey and ->card_number
 check_cxx_source_compiles ("
   #include <gpgme.h>
   int main() {
     gpgme_subkey_t sk = 0;
     const char * card_number = sk->card_number;
     const unsigned int is_cardkey = sk->is_cardkey;
     return 0;
   }
 " HAVE_GPGME_SUBKEY_T_IS_CARDKEY )
 
 # check if gpgme has assuan protocol support
 check_cxx_source_compiles ("
   #include <gpgme.h>
 
   static gpgme_error_t data_cb(void *, const void *, size_t) { return 0; }
   static gpgme_error_t inquire_cb(void *, const char *, const char *, gpgme_data_t *) { return 0; }
   static gpgme_error_t status_cb(void *, const char *, const char *) { return 0; }
 
   int main() {
      const gpgme_protocol_t proto = GPGME_PROTOCOL_ASSUAN;
      gpgme_ctx_t ctx = 0;
      gpgme_assuan_data_cb_t d = data_cb;
      gpgme_assuan_inquire_cb_t i = inquire_cb;
      gpgme_assuan_status_cb_t s = status_cb;
      gpgme_assuan_result_t r = gpgme_op_assuan_result( ctx );
      void * opaque = 0;
      gpgme_error_t err = gpgme_op_assuan_transact_start( ctx, \"FOO\", d, opaque, i, opaque, s, opaque );
      err = gpgme_op_assuan_transact( ctx, \"FOO\", d, opaque, i, opaque, s, opaque );
      return 0;
   }
 " HAVE_GPGME_ASSUAN_ENGINE )
 
 check_cxx_source_compiles ("
   #include <gpgme.h>
   int main() {
     gpgme_keylist_mode_t mode = GPGME_KEYLIST_MODE_EPHEMERAL;
     return 0;
   }
 " HAVE_GPGME_KEYLIST_MODE_EPHEMERAL )
 
+# check if gpgme has import-from-keyserver support
+check_cxx_source_compiles ("
+  #include <gpgme.h>
+  int main() {
+     gpgme_ctx_t ctx = 0;
+     gpgme_key_t keys[2] = { 0, 0 };
+     const gpgme_error_t err = gpgme_op_import_keys( ctx, keys );
+     return err ? 1 : 0 ;
+  }
+" HAVE_GPGME_OP_IMPORT_KEYS )
+
 set(CMAKE_REQUIRED_INCLUDES)
 set(CMAKE_REQUIRED_LIBRARIES)
 
 endif( GPGME_FOUND )
diff --git a/gpgme++/config-gpgme++.h.cmake b/gpgme++/config-gpgme++.h.cmake
index 9490138d0..95b0ff06c 100644
--- a/gpgme++/config-gpgme++.h.cmake
+++ b/gpgme++/config-gpgme++.h.cmake
@@ -1,88 +1,91 @@
 /* Define to 1 if your gpgme has the gpgme_data_{set,get}_file_name functions */
 #cmakedefine HAVE_GPGME_DATA_SET_FILE_NAME 1
 
 /* Define to 1 if your gpgme has the GPGME_INCLUDE_CERTS_DEFAULT macro */
 #cmakedefine HAVE_GPGME_INCLUDE_CERTS_DEFAULT 1
 
 /* Define to 1 if your gpgme has the GPGME_KEYLIST_MODE_SIG_NOTATIONS macro */
 #cmakedefine HAVE_GPGME_KEYLIST_MODE_SIG_NOTATIONS
 
 /* Define to 1 if your gpgme's gpgme_key_sig_t has the notations member */
 #cmakedefine HAVE_GPGME_KEY_SIG_NOTATIONS
 
 /* Define to 1 if your gpgme's gpgme_key_t has the is_qualified flag */
 #cmakedefine HAVE_GPGME_KEY_T_IS_QUALIFIED 1
 
 /* Define to 1 if your gpgme's gpgme_sig_notation_t has the critical flag */
 #cmakedefine HAVE_GPGME_SIG_NOTATION_CRITICAL
 
 /* Define to 1 if your gpgme's gpgme_sig_notation_t has the flags member */
 #cmakedefine HAVE_GPGME_SIG_NOTATION_FLAGS_T
 
 /* Define to 1 if your gpgme's gpgme_sig_notation_t has the human_readable flag */
 #cmakedefine HAVE_GPGME_SIG_NOTATION_HUMAN_READABLE
 
 /* Define to 1 if your gpgme's gpgme_subkey_t has the is_qualified flag */
 #cmakedefine HAVE_GPGME_SUBKEY_T_IS_QUALIFIED 1
 
 /* Define to 1 if your gpgme's gpgme_engine_info_t has the home_dir member */
 #cmakedefine HAVE_GPGME_ENGINE_INFO_T_HOME_DIR 1
 
 /* Define to 1 if your gpgme has the gpgme_ctx_{get,set}_engine_info() functions */
 #cmakedefine HAVE_GPGME_CTX_GETSET_ENGINE_INFO 1
 
 /* Define to 1 if your gpgme has the gpgme_sig_notation_{clear,add,get}() functions */
 #cmakedefine HAVE_GPGME_SIG_NOTATION_CLEARADDGET 1
 
 /* Define to 1 if your gpgme's gpgme_decrypt_result_t has the file_name member */
 #cmakedefine HAVE_GPGME_DECRYPT_RESULT_T_FILE_NAME 1
 
 /* Define to 1 if your gpgme's gpgme_decrypt_result_t has the recipients member */
 #cmakedefine HAVE_GPGME_DECRYPT_RESULT_T_RECIPIENTS 1
 
 /* Define to 1 if your gpgme's gpgme_verify_result_t has the file_name member */
 #cmakedefine HAVE_GPGME_VERIFY_RESULT_T_FILE_NAME 1
 
 /* Define to 1 if your gpgme's gpgme_signature_t has the pka_{trust,address} fields */
 #cmakedefine HAVE_GPGME_SIGNATURE_T_PKA_FIELDS 1
 
 /* Define to 1 if your gpgme's gpgme_signature_t has the {hash,pubkey}_algo fields */
 #cmakedefine HAVE_GPGME_SIGNATURE_T_ALGORITHM_FIELDS 1
 
 /* Define to 1 if your gpgme has gpgme_get_fdptr (it won't be in gpgme.h, though!) */
 #cmakedefine HAVE_GPGME_GET_FDPTR 1
 
 /* Define to 1 if your gpgme has the gpgme_op_getauditlog function */
 #cmakedefine HAVE_GPGME_OP_GETAUDITLOG 1
 
 /* Define to 1 if your gpgme has GPGME_PROTOCOL_GPGCONF */
 #cmakedefine HAVE_GPGME_PROTOCOL_GPGCONF 1
 
 /* Define to 1 if your gpgme has gpgme_cancel_async */
 #cmakedefine HAVE_GPGME_CANCEL_ASYNC 1
 
 /* Define to 1 if your gpg-error has GPG_ERR_NO_PASSPHRASE */
 #cmakedefine HAVE_GPG_ERR_NO_PASSPHRASE 1
 
 /* Define to 1 if your gpg-error has GPG_ERR_ALREADY_SIGNED */
 #cmakedefine HAVE_GPG_ERR_ALREADY_SIGNED 1
 
 #ifndef HAVE_GPG_ERR_NO_PASSPHRASE
 # define GPG_ERR_NO_PASSPHRASE GPG_ERR_INV_PASSPHRASE
 #endif
 
 #ifndef HAVE_GPG_ERR_ALREADY_SIGNED
 # define GPG_ERR_ALREADY_SIGNED GPG_ERR_USER_1
 #endif
 
 /* Define to 1 if your gpgme has GPGME_ENCRYPT_NO_ENCRYPT_TO */
 #cmakedefine HAVE_GPGME_ENCRYPT_NO_ENCRYPT_TO 1
 
 /* Define to 1 if your gpgme has gpgme_subkey_t->card_number and gpgme_subkey_t->is_cardkey */
 #cmakedefine HAVE_GPGME_SUBKEY_T_IS_CARDKEY
 
 /* Define to 1 if your gpgme has ASSUAN protocol support (in the interface, not only in the implementation */
 #cmakedefine HAVE_GPGME_ASSUAN_ENGINE
 
 /* Define to 1 if your gpgme has GPGME_KEYLIST_MODE_EPHEMERAL */
 #cmakedefine HAVE_GPGME_KEYLIST_MODE_EPHEMERAL
+
+/* Define to 1 if your gpgme has gpgme_op_import_keys */
+#cmakedefine HAVE_GPGME_OP_IMPORT_KEYS
diff --git a/gpgme++/context.cpp b/gpgme++/context.cpp
index a68b979fd..24241dbd1 100644
--- a/gpgme++/context.cpp
+++ b/gpgme++/context.cpp
@@ -1,1174 +1,1212 @@
 /*
   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++/interfaces/assuantransaction.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>
 
 namespace GpgME {
   void initializeLibrary() {
       gpgme_check_version( 0 );
   }
 
   static inline gpgme_error_t makeError( gpg_err_code_t code ) {
     return gpg_err_make( (gpg_err_source_t)22, code );
   }
 
   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;
   }
 
   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; d = 0;
   }
 
   Context * Context::createForProtocol( Protocol proto ) {
     gpgme_ctx_t ctx = 0;
     if ( gpgme_new ( &ctx ) != 0 )
       return 0;
 
     switch ( proto ) {
     case OpenPGP:
       if ( gpgme_set_protocol( ctx, GPGME_PROTOCOL_OpenPGP ) != 0 ) {
 	gpgme_release( ctx );
 	return 0;
       }
       break;
     case CMS:
       if ( gpgme_set_protocol( ctx, GPGME_PROTOCOL_CMS ) != 0 ) {
 	gpgme_release( ctx );
 	return 0;
       }
       break;
     default:
       return 0;
     }
 
     return new Context( ctx );
   }
 
   //
   //
   // 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;
 #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( makeError( 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( makeError( 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;
+#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() );
+    return ImportResult( d->ctx, Error(d->lasterr) );
+#else
+    (void)kk;
+    return ImportResult( Error( d->lasterr = gpg_error( GPG_ERR_NOT_IMPLEMENTED ) ) );
+#endif
+  }
+
   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 = gpg_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::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();
   }
 
   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();
   }
 
   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( 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 );
     return t->status( status, args ).encodedError();
   }
 #endif
 
   AssuanResult Context::assuanTransact( const char * command, std::auto_ptr<AssuanTransaction> transaction ) {
     d->lastop = Private::AssuanTransact;
     d->lastAssuanTransaction = transaction;
 #ifdef HAVE_GPGME_ASSUAN_ENGINE
     d->lasterr = gpgme_op_assuan_transact( d->ctx, command,
                                            d->lastAssuanTransaction.get() ? assuan_transaction_data_callback : 0,
                                            d->lastAssuanTransaction.get(),
                                            d->lastAssuanTransaction.get() ? assuan_transaction_inquire_callback : 0,
                                            d->lastAssuanTransaction.get() ? d : 0, // sic!
                                            d->lastAssuanTransaction.get() ? assuan_transaction_status_callback : 0,
                                            d->lastAssuanTransaction.get() );
 #else
     (void)command;
     d->lasterr = gpg_error( GPG_ERR_NOT_SUPPORTED );
 #endif
     return AssuanResult( d->ctx, d->lasterr );
   }
 
   Error Context::startAssuanTransaction( const char * command, std::auto_ptr<AssuanTransaction> transaction ) {
     d->lastop = Private::AssuanTransact;
     d->lastAssuanTransaction = transaction;
 #ifdef HAVE_GPGME_ASSUAN_ENGINE
     return Error( d->lasterr = gpgme_op_assuan_transact_start( d->ctx, command,
                                                                d->lastAssuanTransaction.get() ? assuan_transaction_data_callback : 0,
                                                                d->lastAssuanTransaction.get(),
                                                                d->lastAssuanTransaction.get() ? assuan_transaction_inquire_callback : 0,
                                                                d->lastAssuanTransaction.get() ? d : 0, // sic!
                                                                d->lastAssuanTransaction.get() ? assuan_transaction_status_callback : 0,
                                                                d->lastAssuanTransaction.get() ) );
 #else
     (void)command;
     return Error( d->lasterr = gpg_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();
  }
 
   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 = makeError( 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 = makeError( 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( makeError( 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( makeError( 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 = gpg_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++ = 0;
     d->lasterr = gpgme_op_encrypt( d->ctx, keys, encryptflags2encryptflags( flags ),
 				   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 = gpg_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++ = 0;
     d->lasterr = gpgme_op_encrypt_start( d->ctx, keys, encryptflags2encryptflags( flags ),
 					 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++ = 0;
     d->lasterr = gpgme_op_encrypt_sign( d->ctx, keys, encryptflags2encryptflags( flags ),
 					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++ = 0;
     d->lasterr = gpgme_op_encrypt_sign_start( d->ctx, keys, encryptflags2encryptflags( flags ),
 					      pdp ? pdp->data : 0, cdp ? cdp->data : 0 );
     delete[] keys;
     return Error( d->lasterr );
   }
 
 
   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";
       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::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
     ;
 
 bool GpgME::hasFeature( unsigned long features ) {
     return features == ( features & supported_features );
 }
diff --git a/gpgme++/context.h b/gpgme++/context.h
index d629aaa4d..0ec727c29 100644
--- a/gpgme++/context.h
+++ b/gpgme++/context.h
@@ -1,318 +1,320 @@
 /*
   context.h - wraps a gpgme key context
   Copyright (C) 2003, 2007 Klarälvdalens Datakonsult AB
 
   This file is part of GPGME++.
 
   GPGME++ is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License as published by the Free Software Foundation; either
   version 2 of the License, or (at your option) any later version.
 
   GPGME++ is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU Library General Public License for more details.
 
   You should have received a copy of the GNU Library General Public License
   along with GPGME++; see the file COPYING.LIB.  If not, write to the
   Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
   Boston, MA 02110-1301, USA.
 */
 
 // -*- c++ -*-
 #ifndef __GPGMEPP_CONTEXT_H__
 #define __GPGMEPP_CONTEXT_H__
 
 #include <gpgme++/global.h>
 
 #include <gpgme++/error.h>
 #include <gpgme++/verificationresult.h> // for Signature::Notation
 
 #include <memory>
 #include <vector>
 #include <utility>
 #include <iosfwd>
 
 namespace GpgME {
 
   class Key;
   class Data;
   class TrustItem;
   class ProgressProvider;
   class PassphraseProvider;
   class EventLoopInteractor;
   class EditInteractor;
   class AssuanTransaction;
 
   class AssuanResult;
   class KeyListResult;
   class KeyGenerationResult;
   class ImportResult;
   class DecryptionResult;
   class VerificationResult;
   class SigningResult;
   class EncryptionResult;
 
   class EngineInfo;
 
   class GPGMEPP_EXPORT Context {
     explicit Context( gpgme_ctx_t );
   public:
     //using GpgME::Protocol;
 
     //
     // Creation and destruction:
     //
 
     static Context * createForProtocol( Protocol proto );
     virtual ~Context();
 
     //
     // Context Attributes
     //
 
     Protocol protocol() const;
 
     void setArmor( bool useArmor );
     bool armor() const;
 
     void setTextMode( bool useTextMode );
     bool textMode() const;
 
     enum CertificateInclusion {
       DefaultCertificates = -256,
       AllCertificatesExceptRoot = -2,
       AllCertificates = -1,
       NoCertificates = 0,
       OnlySenderCertificate = 1
     };
     void setIncludeCertificates( int which );
     int includeCertificates() const;
 
     //using GpgME::KeyListMode;
     void setKeyListMode( unsigned int keyListMode );
     void addKeyListMode( unsigned int keyListMode );
     unsigned int keyListMode() const;
 
     void setPassphraseProvider( PassphraseProvider * provider );
     PassphraseProvider * passphraseProvider() const;
 
     void setProgressProvider( ProgressProvider * provider );
     ProgressProvider * progressProvider() const;
 
     void setManagedByEventLoopInteractor( bool managed );
     bool managedByEventLoopInteractor() const;
 
     GpgME::Error setLocale( int category, const char * value );
 
     EngineInfo engineInfo() const;
     GpgME::Error setEngineFileName( const char * filename );
     GpgME::Error setEngineHomeDirectory( const char * filename );
 
   private:
     friend class ::GpgME::EventLoopInteractor;
     void installIOCallbacks( gpgme_io_cbs * iocbs );
     void uninstallIOCallbacks();
 
   public:
     //
     //
     // Key Management
     //
     //
 
     //
     // Key Listing
     //
 
     GpgME::Error startKeyListing( const char * pattern=0, bool secretOnly=false );
     GpgME::Error startKeyListing( const char * patterns[], bool secretOnly=false );
 
     Key nextKey( GpgME::Error & e );
 
     KeyListResult endKeyListing();
     KeyListResult keyListResult() const;
 
     Key key( const char * fingerprint, GpgME::Error & e, bool secret=false );
 
     //
     // Key Generation
     //
 
     KeyGenerationResult generateKey( const char * parameters, Data & pubKey );
     GpgME::Error startKeyGeneration( const char * parameters, Data & pubkey );
     KeyGenerationResult keyGenerationResult() const;
 
     //
     // Key Export
     //
 
     GpgME::Error exportPublicKeys( const char * pattern, Data & keyData );
     GpgME::Error exportPublicKeys( const char * pattern[], Data & keyData );
     GpgME::Error startPublicKeyExport( const char * pattern, Data & keyData );
     GpgME::Error startPublicKeyExport( const char * pattern[], Data & keyData );
 
     //
     // Key Import
     //
 
     ImportResult importKeys( const Data & data );
+    ImportResult importKeys( const std::vector<Key> & keys );
     GpgME::Error startKeyImport( const Data & data );
+    GpgME::Error startKeyImport( const std::vector<Key> & keys );
     ImportResult importResult() const;
 
     //
     // Key Deletion
     //
 
     GpgME::Error deleteKey( const Key & key, bool allowSecretKeyDeletion=false );
     GpgME::Error startKeyDeletion( const Key & key, bool allowSecretKeyDeletion=false );
 
     //
     // Key Editing
     //
 
     GpgME::Error edit( const Key & key, std::auto_ptr<EditInteractor> function, Data & out );
     GpgME::Error startEditing( const Key & key, std::auto_ptr<EditInteractor> function, Data & out );
 
     EditInteractor * lastEditInteractor() const;
 
     //
     // SmartCard Editing
     //
 
     GpgME::Error cardEdit( const Key & key, std::auto_ptr<EditInteractor> function, Data & out );
     GpgME::Error startCardEditing( const Key & key, std::auto_ptr<EditInteractor> function, Data & out );
 
     EditInteractor * lastCardEditInteractor() const;
 
     //
     // Trust Item Management
     //
 
     GpgME::Error startTrustItemListing( const char * pattern, int maxLevel );
     TrustItem nextTrustItem( GpgME::Error & e );
     GpgME::Error endTrustItemListing();
 
     //
     // Assuan Transactions
     //
 
     AssuanResult assuanTransact( const char * command, std::auto_ptr<AssuanTransaction> transaction );
     GpgME::Error startAssuanTransaction( const char * command, std::auto_ptr<AssuanTransaction> transaction );
     AssuanResult assuanResult() const;
 
     AssuanTransaction * lastAssuanTransaction() const;
 
     //
     //
     // Crypto Operations
     //
     //
 
     //
     // Decryption
     //
 
     DecryptionResult decrypt( const Data & cipherText, Data & plainText );
     GpgME::Error startDecryption( const Data & cipherText, Data & plainText );
     DecryptionResult decryptionResult() const;
 
     //
     // Signature Verification
     //
 
     VerificationResult verifyDetachedSignature( const Data & signature, const Data & signedText );
     VerificationResult verifyOpaqueSignature( const Data & signedData, Data & plainText );
     GpgME::Error startDetachedSignatureVerification( const Data & signature, const Data & signedText );
     GpgME::Error startOpaqueSignatureVerification( const Data & signedData, Data & plainText );
     VerificationResult verificationResult() const;
 
     //
     // Combined Decryption and Signature Verification
     //
 
     std::pair<DecryptionResult,VerificationResult> decryptAndVerify( const Data & cipherText, Data & plainText );
     GpgME::Error startCombinedDecryptionAndVerification( const Data & cipherText, Data & plainText );
     // use verificationResult() and decryptionResult() to retrieve the result objects...
 
     //
     // Signing
     //
 
     void clearSigningKeys();
     GpgME::Error addSigningKey( const Key & signer );
     Key signingKey( unsigned int index ) const;
     std::vector<Key> signingKeys() const;
 
     void clearSignatureNotations();
     GpgME::Error addSignatureNotation( const char * name, const char * value, unsigned int flags=0 );
     GpgME::Error addSignaturePolicyURL( const char * url, bool critical=false );
     const char * signaturePolicyURL() const;
     Notation signatureNotation( unsigned int index ) const;
     std::vector<Notation> signatureNotations() const;
 
     //using GpgME::SignatureMode;
     SigningResult sign( const Data & plainText, Data & signature, SignatureMode mode );
     GpgME::Error startSigning( const Data & plainText, Data & signature, SignatureMode mode );
     SigningResult signingResult() const;
 
     //
     // Encryption
     //
 
     enum EncryptionFlags { None=0, AlwaysTrust=1, NoEncryptTo=2 };
     EncryptionResult encrypt( const std::vector<Key> & recipients, const Data & plainText, Data & cipherText, EncryptionFlags flags );
     GpgME::Error encryptSymmetrically( const Data & plainText, Data & cipherText );
     GpgME::Error startEncryption( const std::vector<Key> & recipients, const Data & plainText, Data & cipherText, EncryptionFlags flags );
     EncryptionResult encryptionResult() const;
 
     //
     // Combined Signing and Encryption
     //
 
     std::pair<SigningResult,EncryptionResult> signAndEncrypt( const std::vector<Key> & recipients, const Data & plainText, Data & cipherText, EncryptionFlags flags );
     GpgME::Error startCombinedSigningAndEncryption( const std::vector<Key> & recipients, const Data & plainText, Data & cipherText, EncryptionFlags flags );
     // use encryptionResult() and signingResult() to retrieve the result objects...
 
     //
     //
     // Audit Log
     //
     //
     enum AuditLogFlags {
         HtmlAuditLog = 1,
         AuditLogWithHelp = 128
     };
     GpgME::Error startGetAuditLog( Data & output, unsigned int flags=0 );
     GpgME::Error getAuditLog( Data & output, unsigned int flags=0 );
 
     //
     //
     // Run Control
     //
     //
 
     bool poll();
     GpgME::Error wait();
     GpgME::Error lastError() const;
     GpgME::Error cancelPendingOperation();
 
     class Private;
     const Private * impl() const { return d; }
     Private * impl() { return d; }
   private:
     Private * d;
 
   private: // disable...
     Context( const Context & );
     const Context & operator=( const Context & );
   };
 
   GPGMEPP_EXPORT std::ostream & operator<<( std::ostream & os, Context::CertificateInclusion incl );
   GPGMEPP_EXPORT std::ostream & operator<<( std::ostream & os, Context::EncryptionFlags flags );
   GPGMEPP_EXPORT std::ostream & operator<<( std::ostream & os, Context::AuditLogFlags flags );
 
 } // namespace GpgME
 
 #endif // __GPGMEPP_CONTEXT_H__
diff --git a/gpgme++/global.h b/gpgme++/global.h
index 7d8f39741..ffeb46ffb 100644
--- a/gpgme++/global.h
+++ b/gpgme++/global.h
@@ -1,130 +1,130 @@
 /*
   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>
 
 namespace GpgME {
     class Error;
     class EngineInfo;
     class Context;
 }
 
 struct _GIOChannel;
 typedef struct _GIOChannel      GIOChannel;
 class QIODevice;
 
 namespace GpgME {
 
     GPGMEPP_EXPORT void initializeLibrary();
 
     enum Protocol { OpenPGP, CMS, UnknownProtocol };
 
     enum Engine { GpgEngine, GpgSMEngine, GpgConfEngine, UnknownEngine, AssuanEngine };
 
     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,
-        // reserved
+        ImportFromKeyserverFeature                 = 0x00800000,
 
         KeyIsQualifiedFeature                      = 0x01000200,
         SubkeyIsQualifiedFeature                   = 0x02000000,
         SignaturePkaFieldsFeature                  = 0x04000000,
         SignatureAlgorithmFieldsFeature            = 0x08000000,
 
         FdPointerFeature                           = 0x10000000,
         // reserved
         // reserved
         // unusable (max value)
 
         FeatureMaxValue                            = 0x80000000
     };
     GPGMEPP_EXPORT bool hasFeature( unsigned long feature );
 
 } // namespace GpgME
 
 #endif // __GPGMEPP_GLOBAL_H__