LCOV - code coverage report
Current view: top level - lang/cpp/src - context.cpp (source / functions) Hit Total Coverage
Test: coverage.info Lines: 185 817 22.6 %
Date: 2016-12-01 18:45:36 Functions: 48 160 30.0 %

          Line data    Source code
       1             : /*
       2             :   context.cpp - wraps a gpgme key context
       3             :   Copyright (C) 2003, 2007 Klarälvdalens Datakonsult AB
       4             : 
       5             :   This file is part of GPGME++.
       6             : 
       7             :   GPGME++ is free software; you can redistribute it and/or
       8             :   modify it under the terms of the GNU Library General Public
       9             :   License as published by the Free Software Foundation; either
      10             :   version 2 of the License, or (at your option) any later version.
      11             : 
      12             :   GPGME++ is distributed in the hope that it will be useful,
      13             :   but WITHOUT ANY WARRANTY; without even the implied warranty of
      14             :   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      15             :   GNU Library General Public License for more details.
      16             : 
      17             :   You should have received a copy of the GNU Library General Public License
      18             :   along with GPGME++; see the file COPYING.LIB.  If not, write to the
      19             :   Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
      20             :   Boston, MA 02110-1301, USA.
      21             : */
      22             : 
      23             : #ifdef HAVE_CONFIG_H
      24             :  #include "config.h"
      25             : #endif
      26             : 
      27             : #include <context.h>
      28             : #include <eventloopinteractor.h>
      29             : #include <trustitem.h>
      30             : #include <keylistresult.h>
      31             : #include <keygenerationresult.h>
      32             : #include <importresult.h>
      33             : #include <decryptionresult.h>
      34             : #include <verificationresult.h>
      35             : #include <signingresult.h>
      36             : #include <encryptionresult.h>
      37             : #include <engineinfo.h>
      38             : #include <editinteractor.h>
      39             : #include <vfsmountresult.h>
      40             : 
      41             : #include <interfaces/assuantransaction.h>
      42             : #include <defaultassuantransaction.h>
      43             : 
      44             : #include "callbacks.h"
      45             : #include "data_p.h"
      46             : #include "context_p.h"
      47             : #include "util.h"
      48             : #include "tofuinfo.h"
      49             : 
      50             : #include <gpgme.h>
      51             : 
      52             : #include <istream>
      53             : #ifndef NDEBUG
      54             : #include <iostream>
      55             : using std::cerr;
      56             : using std::endl;
      57             : #endif
      58             : 
      59             : #include <cassert>
      60             : 
      61             : namespace GpgME
      62             : {
      63             : 
      64           0 : static inline unsigned int xtoi_1(const char *str)
      65             : {
      66           0 :     const unsigned int ch = *str;
      67             :     const unsigned int result =
      68             :         ch <= '9' ? ch - '0' :
      69             :         ch <= 'F' ? ch - 'A' + 10 :
      70           0 :         /* else */  ch - 'a' + 10 ;
      71           0 :     return result < 16 ? result : 0 ;
      72             : }
      73           0 : static inline int xtoi_2(const char *str)
      74             : {
      75           0 :     return xtoi_1(str) * 16U + xtoi_1(str + 1);
      76             : }
      77             : 
      78           0 : static void percent_unescape(std::string &s, bool plus2space)
      79             : {
      80           0 :     std::string::iterator src = s.begin(), dest = s.begin(), end = s.end();
      81           0 :     while (src != end) {
      82           0 :         if (*src == '%' && end - src > 2) {
      83           0 :             *dest++ = xtoi_2(&*++src);
      84           0 :             src += 2;
      85           0 :         } else if (*src == '+' && plus2space) {
      86           0 :             *dest++ = ' ';
      87           0 :             ++src;
      88             :         } else {
      89           0 :             *dest++ = *src++;
      90             :         }
      91             :     }
      92           0 :     s.erase(dest, end);
      93           0 : }
      94             : 
      95           6 : void initializeLibrary()
      96             : {
      97           6 :     gpgme_check_version(0);
      98           6 : }
      99             : 
     100           0 : Error initializeLibrary(int)
     101             : {
     102           0 :     if (gpgme_check_version(GPGME_VERSION)) {
     103           0 :         return Error();
     104             :     } else {
     105           0 :         return Error::fromCode(GPG_ERR_USER_1);
     106             :     }
     107             : }
     108             : 
     109          23 : static void format_error(gpgme_error_t err, std::string &str)
     110             : {
     111             :     char buffer[ 1024 ];
     112          23 :     gpgme_strerror_r(err, buffer, sizeof buffer);
     113          23 :     buffer[ sizeof buffer - 1 ] = '\0';
     114          23 :     str = buffer;
     115          23 : }
     116             : 
     117           0 : const char *Error::source() const
     118             : {
     119           0 :     return gpgme_strsource((gpgme_error_t)mErr);
     120             : }
     121             : 
     122          23 : const char *Error::asString() const
     123             : {
     124          23 :     if (mMessage.empty()) {
     125          23 :         format_error(static_cast<gpgme_error_t>(mErr), mMessage);
     126             :     }
     127          23 :     return mMessage.c_str();
     128             : }
     129             : 
     130          44 : int Error::code() const
     131             : {
     132          44 :     return gpgme_err_code(mErr);
     133             : }
     134             : 
     135           0 : int Error::sourceID() const
     136             : {
     137           0 :     return gpgme_err_source(mErr);
     138             : }
     139             : 
     140          37 : bool Error::isCanceled() const
     141             : {
     142          37 :     return code() == GPG_ERR_CANCELED;
     143             : }
     144             : 
     145           0 : int Error::toErrno() const
     146             : {
     147             : //#ifdef HAVE_GPGME_GPG_ERROR_WRAPPERS
     148           0 :     return gpgme_err_code_to_errno(static_cast<gpgme_err_code_t>(code()));
     149             : //#else
     150             : //    return gpg_err_code_to_errno( static_cast<gpg_err_code_t>( code() ) );
     151             : //#endif
     152             : }
     153             : 
     154             : // static
     155           0 : bool Error::hasSystemError()
     156             : {
     157           0 :     return gpgme_err_code_from_syserror() == GPG_ERR_MISSING_ERRNO ;
     158             : }
     159             : 
     160             : // static
     161           0 : void Error::setSystemError(gpg_err_code_t err)
     162             : {
     163           0 :     setErrno(gpgme_err_code_to_errno(err));
     164           0 : }
     165             : 
     166             : // static
     167           0 : void Error::setErrno(int err)
     168             : {
     169           0 :     gpgme_err_set_errno(err);
     170           0 : }
     171             : 
     172             : // static
     173           0 : Error Error::fromSystemError(unsigned int src)
     174             : {
     175           0 :     return Error(gpgme_err_make(static_cast<gpgme_err_source_t>(src), gpgme_err_code_from_syserror()));
     176             : }
     177             : 
     178             : // static
     179           0 : Error Error::fromErrno(int err, unsigned int src)
     180             : {
     181           0 :     return Error(gpgme_err_make(static_cast<gpgme_err_source_t>(src), gpgme_err_code_from_errno(err)));
     182             : }
     183             : 
     184             : // static
     185           1 : Error Error::fromCode(unsigned int err, unsigned int src)
     186             : {
     187           1 :     return Error(gpgme_err_make(static_cast<gpgme_err_source_t>(src), static_cast<gpgme_err_code_t>(err)));
     188             : }
     189             : 
     190           0 : std::ostream &operator<<(std::ostream &os, const Error &err)
     191             : {
     192           0 :     return os << "GpgME::Error(" << err.encodedError() << " (" << err.asString() << "))";
     193             : }
     194             : 
     195          42 : Context::Context(gpgme_ctx_t ctx) : d(new Private(ctx))
     196             : {
     197          42 : }
     198             : 
     199          84 : Context::~Context()
     200             : {
     201          42 :     delete d;
     202          84 : }
     203             : 
     204          42 : Context *Context::createForProtocol(Protocol proto)
     205             : {
     206          42 :     gpgme_ctx_t ctx = 0;
     207          42 :     if (gpgme_new(&ctx) != 0) {
     208           0 :         return 0;
     209             :     }
     210             : 
     211          42 :     switch (proto) {
     212             :     case OpenPGP:
     213          42 :         if (gpgme_set_protocol(ctx, GPGME_PROTOCOL_OpenPGP) != 0) {
     214           0 :             gpgme_release(ctx);
     215           0 :             return 0;
     216             :         }
     217          42 :         break;
     218             :     case CMS:
     219           0 :         if (gpgme_set_protocol(ctx, GPGME_PROTOCOL_CMS) != 0) {
     220           0 :             gpgme_release(ctx);
     221           0 :             return 0;
     222             :         }
     223           0 :         break;
     224             :     default:
     225           0 :         return 0;
     226             :     }
     227             : 
     228          42 :     return new Context(ctx);
     229             : }
     230             : 
     231           0 : std::unique_ptr<Context> Context::createForEngine(Engine eng, Error *error)
     232             : {
     233           0 :     gpgme_ctx_t ctx = 0;
     234           0 :     if (const gpgme_error_t err = gpgme_new(&ctx)) {
     235           0 :         if (error) {
     236           0 :             *error = Error(err);
     237             :         }
     238           0 :         return std::unique_ptr<Context>();
     239             :     }
     240             : 
     241           0 :     switch (eng) {
     242             :     case AssuanEngine:
     243           0 :         if (const gpgme_error_t err = gpgme_set_protocol(ctx, GPGME_PROTOCOL_ASSUAN)) {
     244           0 :             gpgme_release(ctx);
     245           0 :             if (error) {
     246           0 :                 *error = Error(err);
     247             :             }
     248           0 :             return std::unique_ptr<Context>();
     249             :         }
     250           0 :         break;
     251             :     case G13Engine:
     252           0 :         if (const gpgme_error_t err = gpgme_set_protocol(ctx, GPGME_PROTOCOL_G13)) {
     253           0 :             gpgme_release(ctx);
     254           0 :             if (error) {
     255           0 :                 *error = Error(err);
     256             :             }
     257           0 :             return std::unique_ptr<Context>();
     258             :         }
     259           0 :         break;
     260             :     case SpawnEngine:
     261           0 :         if (const gpgme_error_t err = gpgme_set_protocol(ctx, GPGME_PROTOCOL_SPAWN)) {
     262           0 :             gpgme_release(ctx);
     263           0 :             if (error) {
     264           0 :                 *error = Error(err);
     265             :             }
     266           0 :             return std::unique_ptr<Context>();
     267             :         }
     268           0 :         break;
     269             :     default:
     270           0 :         if (error) {
     271           0 :             *error = Error::fromCode(GPG_ERR_INV_ARG);
     272             :         }
     273           0 :         return std::unique_ptr<Context>();
     274             :     }
     275             : 
     276           0 :     if (error) {
     277           0 :         *error = Error();
     278             :     }
     279             : 
     280           0 :     return std::unique_ptr<Context>(new Context(ctx));
     281             : }
     282             : 
     283             : //
     284             : //
     285             : // Context::Private
     286             : //
     287             : //
     288             : 
     289          42 : Context::Private::Private(gpgme_ctx_t c)
     290             :     : ctx(c),
     291             :       iocbs(0),
     292             :       lastop(None),
     293             :       lasterr(GPG_ERR_NO_ERROR),
     294             :       lastAssuanInquireData(Data::null),
     295             :       lastAssuanTransaction(),
     296             :       lastEditInteractor(),
     297          42 :       lastCardEditInteractor()
     298             : {
     299             : 
     300          42 : }
     301             : 
     302          84 : Context::Private::~Private()
     303             : {
     304          42 :     if (ctx) {
     305          42 :         gpgme_release(ctx);
     306             :     }
     307          42 :     ctx = 0;
     308          42 :     delete iocbs;
     309          42 : }
     310             : 
     311             : //
     312             : //
     313             : // Context attributes:
     314             : //
     315             : //
     316             : 
     317           0 : Protocol Context::protocol() const
     318             : {
     319           0 :     gpgme_protocol_t p = gpgme_get_protocol(d->ctx);
     320           0 :     switch (p) {
     321           0 :     case GPGME_PROTOCOL_OpenPGP: return OpenPGP;
     322           0 :     case GPGME_PROTOCOL_CMS:     return CMS;
     323           0 :     default:                     return UnknownProtocol;
     324             :     }
     325             : }
     326             : 
     327           3 : void Context::setArmor(bool useArmor)
     328             : {
     329           3 :     gpgme_set_armor(d->ctx, int(useArmor));
     330           3 : }
     331           0 : bool Context::armor() const
     332             : {
     333           0 :     return gpgme_get_armor(d->ctx);
     334             : }
     335             : 
     336          13 : void Context::setTextMode(bool useTextMode)
     337             : {
     338          13 :     gpgme_set_textmode(d->ctx, int(useTextMode));
     339          13 : }
     340           0 : bool Context::textMode() const
     341             : {
     342           0 :     return gpgme_get_textmode(d->ctx);
     343             : }
     344             : 
     345           0 : void Context::setOffline(bool useOfflineMode)
     346             : {
     347           0 :     gpgme_set_offline(d->ctx, int(useOfflineMode));
     348           0 : }
     349           0 : bool Context::offline() const
     350             : {
     351           0 :     return gpgme_get_offline(d->ctx);
     352             : }
     353             : 
     354           0 : void Context::setIncludeCertificates(int which)
     355             : {
     356           0 :     if (which == DefaultCertificates) {
     357           0 :         which = GPGME_INCLUDE_CERTS_DEFAULT;
     358             :     }
     359           0 :     gpgme_set_include_certs(d->ctx, which);
     360           0 : }
     361             : 
     362           0 : int Context::includeCertificates() const
     363             : {
     364           0 :     return gpgme_get_include_certs(d->ctx);
     365             : }
     366             : 
     367          18 : void Context::setKeyListMode(unsigned int mode)
     368             : {
     369          18 :     gpgme_set_keylist_mode(d->ctx, add_to_gpgme_keylist_mode_t(0, mode));
     370          18 : }
     371             : 
     372           3 : void Context::addKeyListMode(unsigned int mode)
     373             : {
     374           3 :     const unsigned int cur = gpgme_get_keylist_mode(d->ctx);
     375           3 :     gpgme_set_keylist_mode(d->ctx, add_to_gpgme_keylist_mode_t(cur, mode));
     376           3 : }
     377             : 
     378          11 : unsigned int Context::keyListMode() const
     379             : {
     380          11 :     return convert_from_gpgme_keylist_mode_t(gpgme_get_keylist_mode(d->ctx));
     381             : }
     382             : 
     383          36 : void Context::setProgressProvider(ProgressProvider *provider)
     384             : {
     385          36 :     gpgme_set_progress_cb(d->ctx, provider ? &progress_callback : 0, provider);
     386          36 : }
     387           0 : ProgressProvider *Context::progressProvider() const
     388             : {
     389           0 :     void *pp = 0;
     390           0 :     gpgme_progress_cb_t pcb = &progress_callback;
     391           0 :     gpgme_get_progress_cb(d->ctx, &pcb, &pp);
     392           0 :     return static_cast<ProgressProvider *>(pp);
     393             : }
     394             : 
     395           9 : void Context::setPassphraseProvider(PassphraseProvider *provider)
     396             : {
     397           9 :     gpgme_set_passphrase_cb(d->ctx, provider ? &passphrase_callback : 0, provider);
     398           9 : }
     399             : 
     400           0 : PassphraseProvider *Context::passphraseProvider() const
     401             : {
     402           0 :     void *pp = 0;
     403           0 :     gpgme_passphrase_cb_t pcb = &passphrase_callback;
     404           0 :     gpgme_get_passphrase_cb(d->ctx, &pcb, &pp);
     405           0 :     return static_cast<PassphraseProvider *>(pp);
     406             : }
     407             : 
     408           0 : void Context::setManagedByEventLoopInteractor(bool manage)
     409             : {
     410           0 :     if (!EventLoopInteractor::instance()) {
     411             : #ifndef NDEBUG
     412             :         cerr << "Context::setManagedByEventLoopInteractor(): "
     413             :              "You must create an instance of EventLoopInteractor "
     414           0 :              "before using anything that needs one." << endl;
     415             : #endif
     416           0 :         return;
     417             :     }
     418           0 :     if (manage) {
     419           0 :         EventLoopInteractor::instance()->manage(this);
     420             :     } else {
     421           0 :         EventLoopInteractor::instance()->unmanage(this);
     422             :     }
     423             : }
     424           0 : bool Context::managedByEventLoopInteractor() const
     425             : {
     426           0 :     return d->iocbs != 0;
     427             : }
     428             : 
     429           0 : void Context::installIOCallbacks(gpgme_io_cbs *iocbs)
     430             : {
     431           0 :     if (!iocbs) {
     432           0 :         uninstallIOCallbacks();
     433           0 :         return;
     434             :     }
     435           0 :     gpgme_set_io_cbs(d->ctx, iocbs);
     436           0 :     delete d->iocbs; d->iocbs = iocbs;
     437             : }
     438             : 
     439           0 : void Context::uninstallIOCallbacks()
     440             : {
     441             :     static gpgme_io_cbs noiocbs = { 0, 0, 0, 0, 0 };
     442             :     // io.add == 0 means disable io callbacks:
     443           0 :     gpgme_set_io_cbs(d->ctx, &noiocbs);
     444           0 :     delete d->iocbs; d->iocbs = 0;
     445           0 : }
     446             : 
     447           0 : Error Context::setLocale(int cat, const char *val)
     448             : {
     449           0 :     return Error(d->lasterr = gpgme_set_locale(d->ctx, cat, val));
     450             : }
     451             : 
     452           0 : EngineInfo Context::engineInfo() const
     453             : {
     454           0 :     return EngineInfo(gpgme_ctx_get_engine_info(d->ctx));
     455             : }
     456             : 
     457           0 : Error Context::setEngineFileName(const char *filename)
     458             : {
     459           0 :     const char *const home_dir = engineInfo().homeDirectory();
     460           0 :     return Error(gpgme_ctx_set_engine_info(d->ctx, gpgme_get_protocol(d->ctx), filename, home_dir));
     461             : }
     462             : 
     463           0 : Error Context::setEngineHomeDirectory(const char *home_dir)
     464             : {
     465           0 :     const char *const filename = engineInfo().fileName();
     466           0 :     return Error(gpgme_ctx_set_engine_info(d->ctx, gpgme_get_protocol(d->ctx), filename, home_dir));
     467             : }
     468             : 
     469           1 : Error Context::setSender (const char *sender)
     470             : {
     471           1 :     return Error(gpgme_set_sender(d->ctx, sender));
     472             : }
     473             : 
     474           0 : const char *Context::getSender ()
     475             : {
     476           0 :     return gpgme_get_sender(d->ctx);
     477             : }
     478             : 
     479             : //
     480             : //
     481             : // Key Management
     482             : //
     483             : //
     484             : 
     485          14 : Error Context::startKeyListing(const char *pattern, bool secretOnly)
     486             : {
     487          14 :     d->lastop = Private::KeyList;
     488          14 :     return Error(d->lasterr = gpgme_op_keylist_start(d->ctx, pattern, int(secretOnly)));
     489             : }
     490             : 
     491          14 : Error Context::startKeyListing(const char *patterns[], bool secretOnly)
     492             : {
     493          14 :     d->lastop = Private::KeyList;
     494             : #ifndef HAVE_GPGME_EXT_KEYLIST_MODE_EXTERNAL_NONBROKEN
     495          14 :     if (!patterns || !patterns[0] || !patterns[1]) {
     496             :         // max. one pattern -> use the non-ext version
     497          14 :         return startKeyListing(patterns ? patterns[0] : 0, secretOnly);
     498             :     }
     499             : #endif
     500           0 :     return Error(d->lasterr = gpgme_op_keylist_ext_start(d->ctx, patterns, int(secretOnly), 0));
     501             : }
     502             : 
     503          28 : Key Context::nextKey(GpgME::Error &e)
     504             : {
     505          28 :     d->lastop = Private::KeyList;
     506             :     gpgme_key_t key;
     507          28 :     e = Error(d->lasterr = gpgme_op_keylist_next(d->ctx, &key));
     508          28 :     return Key(key, false);
     509             : }
     510             : 
     511          14 : KeyListResult Context::endKeyListing()
     512             : {
     513          14 :     d->lasterr = gpgme_op_keylist_end(d->ctx);
     514          14 :     return keyListResult();
     515             : }
     516             : 
     517          14 : KeyListResult Context::keyListResult() const
     518             : {
     519          14 :     return KeyListResult(d->ctx, Error(d->lasterr));
     520             : }
     521             : 
     522           6 : Key Context::key(const char *fingerprint, GpgME::Error &e , bool secret /*, bool forceUpdate*/)
     523             : {
     524           6 :     d->lastop = Private::KeyList;
     525             :     gpgme_key_t key;
     526           6 :     e = Error(d->lasterr = gpgme_get_key(d->ctx, fingerprint, &key, int(secret)/*, int( forceUpdate )*/));
     527           6 :     return Key(key, false);
     528             : }
     529             : 
     530           0 : KeyGenerationResult Context::generateKey(const char *parameters, Data &pubKey)
     531             : {
     532           0 :     d->lastop = Private::KeyGen;
     533           0 :     Data::Private *const dp = pubKey.impl();
     534           0 :     d->lasterr = gpgme_op_genkey(d->ctx, parameters, dp ? dp->data : 0, 0);
     535           0 :     return KeyGenerationResult(d->ctx, Error(d->lasterr));
     536             : }
     537             : 
     538           0 : Error Context::startKeyGeneration(const char *parameters, Data &pubKey)
     539             : {
     540           0 :     d->lastop = Private::KeyGen;
     541           0 :     Data::Private *const dp = pubKey.impl();
     542           0 :     return Error(d->lasterr = gpgme_op_genkey_start(d->ctx, parameters, dp ? dp->data : 0, 0));
     543             : }
     544             : 
     545           0 : KeyGenerationResult Context::keyGenerationResult() const
     546             : {
     547           0 :     if (d->lastop & Private::KeyGen) {
     548           0 :         return KeyGenerationResult(d->ctx, Error(d->lasterr));
     549             :     } else {
     550           0 :         return KeyGenerationResult();
     551             :     }
     552             : }
     553             : 
     554           0 : Error Context::exportPublicKeys(const char *pattern, Data &keyData)
     555             : {
     556           0 :     d->lastop = Private::Export;
     557           0 :     Data::Private *const dp = keyData.impl();
     558           0 :     return Error(d->lasterr = gpgme_op_export(d->ctx, pattern, 0, dp ? dp->data : 0));
     559             : }
     560             : 
     561           0 : Error Context::exportPublicKeys(const char *patterns[], Data &keyData)
     562             : {
     563           0 :     d->lastop = Private::Export;
     564             : #ifndef HAVE_GPGME_EXT_KEYLIST_MODE_EXTERNAL_NONBROKEN
     565           0 :     if (!patterns || !patterns[0] || !patterns[1]) {
     566             :         // max. one pattern -> use the non-ext version
     567           0 :         return exportPublicKeys(patterns ? patterns[0] : 0, keyData);
     568             :     }
     569             : #endif
     570           0 :     Data::Private *const dp = keyData.impl();
     571           0 :     return Error(d->lasterr = gpgme_op_export_ext(d->ctx, patterns, 0, dp ? dp->data : 0));
     572             : }
     573             : 
     574           0 : Error Context::startPublicKeyExport(const char *pattern, Data &keyData)
     575             : {
     576           0 :     d->lastop = Private::Export;
     577           0 :     Data::Private *const dp = keyData.impl();
     578           0 :     return Error(d->lasterr = gpgme_op_export_start(d->ctx, pattern, 0, dp ? dp->data : 0));
     579             : }
     580             : 
     581           0 : Error Context::startPublicKeyExport(const char *patterns[], Data &keyData)
     582             : {
     583           0 :     d->lastop = Private::Export;
     584             : #ifndef HAVE_GPGME_EXT_KEYLIST_MODE_EXTERNAL_NONBROKEN
     585           0 :     if (!patterns || !patterns[0] || !patterns[1]) {
     586             :         // max. one pattern -> use the non-ext version
     587           0 :         return startPublicKeyExport(patterns ? patterns[0] : 0, keyData);
     588             :     }
     589             : #endif
     590           0 :     Data::Private *const dp = keyData.impl();
     591           0 :     return Error(d->lasterr = gpgme_op_export_ext_start(d->ctx, patterns, 0, dp ? dp->data : 0));
     592             : }
     593             : 
     594           0 : ImportResult Context::importKeys(const Data &data)
     595             : {
     596           0 :     d->lastop = Private::Import;
     597           0 :     const Data::Private *const dp = data.impl();
     598           0 :     d->lasterr = gpgme_op_import(d->ctx, dp ? dp->data : 0);
     599           0 :     return ImportResult(d->ctx, Error(d->lasterr));
     600             : }
     601             : 
     602           0 : ImportResult Context::importKeys(const std::vector<Key> &kk)
     603             : {
     604           0 :     d->lastop = Private::Import;
     605           0 :     d->lasterr = make_error(GPG_ERR_NOT_IMPLEMENTED);
     606             : 
     607           0 :     bool shouldHaveResult = false;
     608           0 :     gpgme_key_t * const keys = new gpgme_key_t[ kk.size() + 1 ];
     609           0 :     gpgme_key_t *keys_it = &keys[0];
     610           0 :     for (std::vector<Key>::const_iterator it = kk.begin(), end = kk.end() ; it != end ; ++it) {
     611           0 :         if (it->impl()) {
     612           0 :             *keys_it++ = it->impl();
     613             :         }
     614             :     }
     615           0 :     *keys_it++ = 0;
     616           0 :     d->lasterr = gpgme_op_import_keys(d->ctx, keys);
     617           0 :     shouldHaveResult = true;
     618           0 :     if ((gpgme_err_code(d->lasterr) == GPG_ERR_NOT_IMPLEMENTED ||
     619           0 :             gpgme_err_code(d->lasterr) == GPG_ERR_NOT_SUPPORTED) &&
     620           0 :             protocol() == CMS) {
     621             :         // ok, try the workaround (export+import):
     622           0 :         std::vector<const char *> fprs;
     623           0 :         for (std::vector<Key>::const_iterator it = kk.begin(), end = kk.end() ; it != end ; ++it) {
     624           0 :             if (const char *fpr = it->primaryFingerprint()) {
     625           0 :                 if (*fpr) {
     626           0 :                     fprs.push_back(fpr);
     627             :                 }
     628           0 :             } else if (const char *keyid = it->keyID()) {
     629           0 :                 if (*keyid) {
     630           0 :                     fprs.push_back(keyid);
     631             :                 }
     632             :             }
     633             :         }
     634           0 :         fprs.push_back(0);
     635           0 :         Data data;
     636           0 :         Data::Private *const dp = data.impl();
     637           0 :         const gpgme_keylist_mode_t oldMode = gpgme_get_keylist_mode(d->ctx);
     638           0 :         gpgme_set_keylist_mode(d->ctx, GPGME_KEYLIST_MODE_EXTERN);
     639           0 :         d->lasterr = gpgme_op_export_ext(d->ctx, &fprs[0], 0, dp ? dp->data : 0);
     640           0 :         gpgme_set_keylist_mode(d->ctx, oldMode);
     641           0 :         if (!d->lasterr) {
     642           0 :             data.seek(0, SEEK_SET);
     643           0 :             d->lasterr = gpgme_op_import(d->ctx, dp ? dp->data : 0);
     644           0 :             shouldHaveResult = true;
     645           0 :         }
     646             :     }
     647           0 :     delete[] keys;
     648           0 :     if (shouldHaveResult) {
     649           0 :         return ImportResult(d->ctx, Error(d->lasterr));
     650             :     } else {
     651           0 :         return ImportResult(Error(d->lasterr));
     652             :     }
     653             : }
     654             : 
     655           0 : Error Context::startKeyImport(const Data &data)
     656             : {
     657           0 :     d->lastop = Private::Import;
     658           0 :     const Data::Private *const dp = data.impl();
     659           0 :     return Error(d->lasterr = gpgme_op_import_start(d->ctx, dp ? dp->data : 0));
     660             : }
     661             : 
     662           0 : Error Context::startKeyImport(const std::vector<Key> &kk)
     663             : {
     664           0 :     d->lastop = Private::Import;
     665           0 :     gpgme_key_t * const keys = new gpgme_key_t[ kk.size() + 1 ];
     666           0 :     gpgme_key_t *keys_it = &keys[0];
     667           0 :     for (std::vector<Key>::const_iterator it = kk.begin(), end = kk.end() ; it != end ; ++it) {
     668           0 :         if (it->impl()) {
     669           0 :             *keys_it++ = it->impl();
     670             :         }
     671             :     }
     672           0 :     *keys_it++ = 0;
     673           0 :     Error err = Error(d->lasterr = gpgme_op_import_keys_start(d->ctx, keys));
     674           0 :     delete[] keys;
     675           0 :     return err;
     676             : }
     677             : 
     678           0 : ImportResult Context::importResult() const
     679             : {
     680           0 :     if (d->lastop & Private::Import) {
     681           0 :         return ImportResult(d->ctx, Error(d->lasterr));
     682             :     } else {
     683           0 :         return ImportResult();
     684             :     }
     685             : }
     686             : 
     687           0 : Error Context::deleteKey(const Key &key, bool allowSecretKeyDeletion)
     688             : {
     689           0 :     d->lastop = Private::Delete;
     690           0 :     return Error(d->lasterr = gpgme_op_delete(d->ctx, key.impl(), int(allowSecretKeyDeletion)));
     691             : }
     692             : 
     693           0 : Error Context::startKeyDeletion(const Key &key, bool allowSecretKeyDeletion)
     694             : {
     695           0 :     d->lastop = Private::Delete;
     696           0 :     return Error(d->lasterr = gpgme_op_delete_start(d->ctx, key.impl(), int(allowSecretKeyDeletion)));
     697             : }
     698             : 
     699           0 : Error Context::passwd(const Key &key)
     700             : {
     701           0 :     d->lastop = Private::Passwd;
     702           0 :     return Error(d->lasterr = gpgme_op_passwd(d->ctx, key.impl(), 0U));
     703             : }
     704             : 
     705           0 : Error Context::startPasswd(const Key &key)
     706             : {
     707           0 :     d->lastop = Private::Passwd;
     708           0 :     return Error(d->lasterr = gpgme_op_passwd_start(d->ctx, key.impl(), 0U));
     709             : }
     710             : 
     711             : 
     712             : #pragma GCC diagnostic push
     713             : #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
     714             : 
     715           2 : Error Context::edit(const Key &key, std::unique_ptr<EditInteractor> func, Data &data)
     716             : {
     717           2 :     d->lastop = Private::Edit;
     718           2 :     d->lastEditInteractor = std::move(func);
     719           2 :     Data::Private *const dp = data.impl();
     720             :     return Error(d->lasterr = gpgme_op_edit(d->ctx, key.impl(),
     721           2 :                                             d->lastEditInteractor.get() ? edit_interactor_callback : 0,
     722           4 :                                             d->lastEditInteractor.get() ? d->lastEditInteractor->d : 0,
     723           8 :                                             dp ? dp->data : 0));
     724             : }
     725             : 
     726             : 
     727           0 : Error Context::startEditing(const Key &key, std::unique_ptr<EditInteractor> func, Data &data)
     728             : {
     729           0 :     d->lastop = Private::Edit;
     730           0 :     d->lastEditInteractor = std::move(func);
     731           0 :     Data::Private *const dp = data.impl();
     732             :     return Error(d->lasterr = gpgme_op_edit_start(d->ctx, key.impl(),
     733           0 :                               d->lastEditInteractor.get() ? edit_interactor_callback : 0,
     734           0 :                               d->lastEditInteractor.get() ? d->lastEditInteractor->d : 0,
     735           0 :                               dp ? dp->data : 0));
     736             : }
     737             : 
     738             : 
     739           0 : EditInteractor *Context::lastEditInteractor() const
     740             : {
     741           0 :     return d->lastEditInteractor.get();
     742             : }
     743             : 
     744           0 : std::unique_ptr<EditInteractor> Context::takeLastEditInteractor()
     745             : {
     746           0 :     return std::move(d->lastEditInteractor);
     747             : }
     748             : 
     749             : 
     750           0 : Error Context::cardEdit(const Key &key, std::unique_ptr<EditInteractor> func, Data &data)
     751             : {
     752           0 :     d->lastop = Private::CardEdit;
     753           0 :     d->lastCardEditInteractor = std::move(func);
     754           0 :     Data::Private *const dp = data.impl();
     755             :     return Error(d->lasterr = gpgme_op_card_edit(d->ctx, key.impl(),
     756           0 :                               d->lastCardEditInteractor.get() ? edit_interactor_callback : 0,
     757           0 :                               d->lastCardEditInteractor.get() ? d->lastCardEditInteractor->d : 0,
     758           0 :                               dp ? dp->data : 0));
     759             : }
     760             : 
     761           0 : Error Context::startCardEditing(const Key &key, std::unique_ptr<EditInteractor> func, Data &data)
     762             : {
     763           0 :     d->lastop = Private::CardEdit;
     764           0 :     d->lastCardEditInteractor = std::move(func);
     765           0 :     Data::Private *const dp = data.impl();
     766             :     return Error(d->lasterr = gpgme_op_card_edit_start(d->ctx, key.impl(),
     767           0 :                               d->lastCardEditInteractor.get() ? edit_interactor_callback : 0,
     768           0 :                               d->lastCardEditInteractor.get() ? d->lastCardEditInteractor->d : 0,
     769           0 :                               dp ? dp->data : 0));
     770             : }
     771             : 
     772             : #pragma GCC diagnostic pop
     773             : 
     774           0 : EditInteractor *Context::lastCardEditInteractor() const
     775             : {
     776           0 :     return d->lastCardEditInteractor.get();
     777             : }
     778             : 
     779           0 : std::unique_ptr<EditInteractor> Context::takeLastCardEditInteractor()
     780             : {
     781           0 :     return std::move(d->lastCardEditInteractor);
     782             : }
     783             : 
     784           0 : Error Context::startTrustItemListing(const char *pattern, int maxLevel)
     785             : {
     786           0 :     d->lastop = Private::TrustList;
     787           0 :     return Error(d->lasterr = gpgme_op_trustlist_start(d->ctx, pattern, maxLevel));
     788             : }
     789             : 
     790           0 : TrustItem Context::nextTrustItem(Error &e)
     791             : {
     792           0 :     gpgme_trust_item_t ti = 0;
     793           0 :     e = Error(d->lasterr = gpgme_op_trustlist_next(d->ctx, &ti));
     794           0 :     return TrustItem(ti);
     795             : }
     796             : 
     797           0 : Error Context::endTrustItemListing()
     798             : {
     799           0 :     return Error(d->lasterr = gpgme_op_trustlist_end(d->ctx));
     800             : }
     801             : 
     802           0 : static gpgme_error_t assuan_transaction_data_callback(void *opaque, const void *data, size_t datalen)
     803             : {
     804           0 :     assert(opaque);
     805           0 :     AssuanTransaction *t = static_cast<AssuanTransaction *>(opaque);
     806           0 :     return t->data(static_cast<const char *>(data), datalen).encodedError();
     807             : }
     808             : 
     809           0 : static gpgme_error_t assuan_transaction_inquire_callback(void *opaque, const char *name, const char *args, gpgme_data_t *r_data)
     810             : {
     811           0 :     assert(opaque);
     812           0 :     Context::Private *p = static_cast<Context::Private *>(opaque);
     813           0 :     AssuanTransaction *t = p->lastAssuanTransaction.get();
     814           0 :     assert(t);
     815           0 :     Error err;
     816           0 :     if (name) {
     817           0 :         p->lastAssuanInquireData = t->inquire(name, args, err);
     818             :     } else {
     819           0 :         p->lastAssuanInquireData = Data::null;
     820             :     }
     821           0 :     if (!p->lastAssuanInquireData.isNull()) {
     822           0 :         *r_data = p->lastAssuanInquireData.impl()->data;
     823             :     }
     824           0 :     return err.encodedError();
     825             : }
     826             : 
     827           0 : static gpgme_error_t assuan_transaction_status_callback(void *opaque, const char *status, const char *args)
     828             : {
     829           0 :     assert(opaque);
     830           0 :     AssuanTransaction *t = static_cast<AssuanTransaction *>(opaque);
     831           0 :     std::string a = args;
     832           0 :     percent_unescape(a, true);   // ### why doesn't gpgme do this??
     833           0 :     return t->status(status, a.c_str()).encodedError();
     834             : }
     835             : 
     836           0 : Error Context::assuanTransact(const char *command)
     837             : {
     838           0 :     return assuanTransact(command, std::unique_ptr<AssuanTransaction>(new DefaultAssuanTransaction));
     839             : }
     840             : 
     841           0 : Error Context::assuanTransact(const char *command, std::unique_ptr<AssuanTransaction> transaction)
     842             : {
     843             :     gpgme_error_t err, operr;
     844             : 
     845           0 :     d->lastop = Private::AssuanTransact;
     846           0 :     d->lastAssuanTransaction = std::move(transaction);
     847           0 :     if (!d->lastAssuanTransaction.get()) {
     848           0 :         return Error(d->lasterr = make_error(GPG_ERR_INV_ARG));
     849             :     }
     850             :     err = gpgme_op_assuan_transact_ext
     851             :       (d->ctx,
     852             :        command,
     853             :        assuan_transaction_data_callback,
     854           0 :        d->lastAssuanTransaction.get(),
     855             :        assuan_transaction_inquire_callback,
     856             :        d,
     857             :        assuan_transaction_status_callback,
     858           0 :        d->lastAssuanTransaction.get(),
     859           0 :        &operr);
     860             : 
     861           0 :     if (!err)
     862           0 :       err = operr;
     863           0 :     d->lasterr = err;
     864             : 
     865           0 :     return Error(d->lasterr);
     866             : }
     867             : 
     868           0 : Error Context::startAssuanTransaction(const char *command)
     869             : {
     870           0 :     return startAssuanTransaction(command, std::unique_ptr<AssuanTransaction>(new DefaultAssuanTransaction));
     871             : }
     872             : 
     873           0 : Error Context::startAssuanTransaction(const char *command, std::unique_ptr<AssuanTransaction> transaction)
     874             : {
     875             :     gpgme_error_t err;
     876             : 
     877           0 :     d->lastop = Private::AssuanTransact;
     878           0 :     d->lastAssuanTransaction = std::move(transaction);
     879           0 :     if (!d->lastAssuanTransaction.get()) {
     880           0 :         return Error(d->lasterr = make_error(GPG_ERR_INV_ARG));
     881             :     }
     882             :     err = gpgme_op_assuan_transact_start
     883             :       (d->ctx,
     884             :        command,
     885             :        assuan_transaction_data_callback,
     886           0 :        d->lastAssuanTransaction.get(),
     887             :        assuan_transaction_inquire_callback,
     888             :        d,
     889             :        assuan_transaction_status_callback,
     890           0 :        d->lastAssuanTransaction.get());
     891             : 
     892           0 :     d->lasterr = err;
     893             : 
     894           0 :     return Error(d->lasterr);
     895             : }
     896             : 
     897           0 : AssuanTransaction *Context::lastAssuanTransaction() const
     898             : {
     899           0 :     return d->lastAssuanTransaction.get();
     900             : }
     901             : 
     902           0 : std::unique_ptr<AssuanTransaction> Context::takeLastAssuanTransaction()
     903             : {
     904           0 :     return std::move(d->lastAssuanTransaction);
     905             : }
     906             : 
     907           2 : DecryptionResult Context::decrypt(const Data &cipherText, Data &plainText)
     908             : {
     909           2 :     d->lastop = Private::Decrypt;
     910           2 :     const Data::Private *const cdp = cipherText.impl();
     911           2 :     Data::Private *const pdp = plainText.impl();
     912           2 :     d->lasterr = gpgme_op_decrypt(d->ctx, cdp ? cdp->data : 0, pdp ? pdp->data : 0);
     913           2 :     return DecryptionResult(d->ctx, Error(d->lasterr));
     914             : }
     915             : 
     916           0 : Error Context::startDecryption(const Data &cipherText, Data &plainText)
     917             : {
     918           0 :     d->lastop = Private::Decrypt;
     919           0 :     const Data::Private *const cdp = cipherText.impl();
     920           0 :     Data::Private *const pdp = plainText.impl();
     921           0 :     return Error(d->lasterr = gpgme_op_decrypt_start(d->ctx, cdp ? cdp->data : 0, pdp ? pdp->data : 0));
     922             : }
     923             : 
     924           0 : DecryptionResult Context::decryptionResult() const
     925             : {
     926           0 :     if (d->lastop & Private::Decrypt) {
     927           0 :         return DecryptionResult(d->ctx, Error(d->lasterr));
     928             :     } else {
     929           0 :         return DecryptionResult();
     930             :     }
     931             : }
     932             : 
     933           0 : VerificationResult Context::verifyDetachedSignature(const Data &signature, const Data &signedText)
     934             : {
     935           0 :     d->lastop = Private::Verify;
     936           0 :     const Data::Private *const sdp = signature.impl();
     937           0 :     const Data::Private *const tdp = signedText.impl();
     938           0 :     d->lasterr = gpgme_op_verify(d->ctx, sdp ? sdp->data : 0, tdp ? tdp->data : 0, 0);
     939           0 :     return VerificationResult(d->ctx, Error(d->lasterr));
     940             : }
     941             : 
     942          10 : VerificationResult Context::verifyOpaqueSignature(const Data &signedData, Data &plainText)
     943             : {
     944          10 :     d->lastop = Private::Verify;
     945          10 :     const Data::Private *const sdp = signedData.impl();
     946          10 :     Data::Private *const pdp = plainText.impl();
     947          10 :     d->lasterr = gpgme_op_verify(d->ctx, sdp ? sdp->data : 0, 0, pdp ? pdp->data : 0);
     948          10 :     return VerificationResult(d->ctx, Error(d->lasterr));
     949             : }
     950             : 
     951           0 : Error Context::startDetachedSignatureVerification(const Data &signature, const Data &signedText)
     952             : {
     953           0 :     d->lastop = Private::Verify;
     954           0 :     const Data::Private *const sdp = signature.impl();
     955           0 :     const Data::Private *const tdp = signedText.impl();
     956           0 :     return Error(d->lasterr = gpgme_op_verify_start(d->ctx, sdp ? sdp->data : 0, tdp ? tdp->data : 0, 0));
     957             : }
     958             : 
     959           0 : Error Context::startOpaqueSignatureVerification(const Data &signedData, Data &plainText)
     960             : {
     961           0 :     d->lastop = Private::Verify;
     962           0 :     const Data::Private *const sdp = signedData.impl();
     963           0 :     Data::Private *const pdp = plainText.impl();
     964           0 :     return Error(d->lasterr = gpgme_op_verify_start(d->ctx, sdp ? sdp->data : 0, 0, pdp ? pdp->data : 0));
     965             : }
     966             : 
     967           0 : VerificationResult Context::verificationResult() const
     968             : {
     969           0 :     if (d->lastop & Private::Verify) {
     970           0 :         return VerificationResult(d->ctx, Error(d->lasterr));
     971             :     } else {
     972           0 :         return VerificationResult();
     973             :     }
     974             : }
     975             : 
     976           0 : std::pair<DecryptionResult, VerificationResult> Context::decryptAndVerify(const Data &cipherText, Data &plainText)
     977             : {
     978           0 :     d->lastop = Private::DecryptAndVerify;
     979           0 :     const Data::Private *const cdp = cipherText.impl();
     980           0 :     Data::Private *const pdp = plainText.impl();
     981           0 :     d->lasterr = gpgme_op_decrypt_verify(d->ctx, cdp ? cdp->data : 0, pdp ? pdp->data : 0);
     982             :     return std::make_pair(DecryptionResult(d->ctx, Error(d->lasterr)),
     983           0 :                           VerificationResult(d->ctx, Error(d->lasterr)));
     984             : }
     985             : 
     986           0 : Error Context::startCombinedDecryptionAndVerification(const Data &cipherText, Data &plainText)
     987             : {
     988           0 :     d->lastop = Private::DecryptAndVerify;
     989           0 :     const Data::Private *const cdp = cipherText.impl();
     990           0 :     Data::Private *const pdp = plainText.impl();
     991           0 :     return Error(d->lasterr = gpgme_op_decrypt_verify_start(d->ctx, cdp ? cdp->data : 0, pdp ? pdp->data : 0));
     992             : }
     993             : 
     994          23 : unsigned int to_auditlog_flags(unsigned int flags)
     995             : {
     996          23 :     unsigned int result = 0;
     997          23 :     if (flags & Context::HtmlAuditLog) {
     998          23 :         result |= GPGME_AUDITLOG_HTML;
     999             :     }
    1000          23 :     if (flags & Context::AuditLogWithHelp) {
    1001          23 :         result |= GPGME_AUDITLOG_WITH_HELP;
    1002             :     }
    1003          23 :     return result;
    1004             : }
    1005             : 
    1006           0 : Error Context::startGetAuditLog(Data &output, unsigned int flags)
    1007             : {
    1008           0 :     d->lastop = Private::GetAuditLog;
    1009           0 :     Data::Private *const odp = output.impl();
    1010           0 :     return Error(d->lasterr = gpgme_op_getauditlog_start(d->ctx, odp ? odp->data : 0, to_auditlog_flags(flags)));
    1011             : }
    1012             : 
    1013          23 : Error Context::getAuditLog(Data &output, unsigned int flags)
    1014             : {
    1015          23 :     d->lastop = Private::GetAuditLog;
    1016          23 :     Data::Private *const odp = output.impl();
    1017          23 :     return Error(d->lasterr = gpgme_op_getauditlog(d->ctx, odp ? odp->data : 0, to_auditlog_flags(flags)));
    1018             : }
    1019             : 
    1020           6 : void Context::clearSigningKeys()
    1021             : {
    1022           6 :     gpgme_signers_clear(d->ctx);
    1023           6 : }
    1024             : 
    1025           6 : Error Context::addSigningKey(const Key &key)
    1026             : {
    1027           6 :     return Error(d->lasterr = gpgme_signers_add(d->ctx, key.impl()));
    1028             : }
    1029             : 
    1030           0 : Key Context::signingKey(unsigned int idx) const
    1031             : {
    1032           0 :     gpgme_key_t key = gpgme_signers_enum(d->ctx, idx);
    1033           0 :     return Key(key, false);
    1034             : }
    1035             : 
    1036           0 : std::vector<Key> Context::signingKeys() const
    1037             : {
    1038           0 :     std::vector<Key> result;
    1039             :     gpgme_key_t key;
    1040           0 :     for (unsigned int i = 0 ; (key = gpgme_signers_enum(d->ctx, i)) ; ++i) {
    1041           0 :         result.push_back(Key(key, false));
    1042             :     }
    1043           0 :     return result;
    1044             : }
    1045             : 
    1046           0 : void Context::clearSignatureNotations()
    1047             : {
    1048           0 :     gpgme_sig_notation_clear(d->ctx);
    1049           0 : }
    1050             : 
    1051           0 : GpgME::Error Context::addSignatureNotation(const char *name, const char *value, unsigned int flags)
    1052             : {
    1053           0 :     return Error(gpgme_sig_notation_add(d->ctx, name, value, add_to_gpgme_sig_notation_flags_t(0, flags)));
    1054             : }
    1055             : 
    1056           0 : GpgME::Error Context::addSignaturePolicyURL(const char *url, bool critical)
    1057             : {
    1058           0 :     return Error(gpgme_sig_notation_add(d->ctx, 0, url, critical ? GPGME_SIG_NOTATION_CRITICAL : 0));
    1059             : }
    1060             : 
    1061           0 : const char *Context::signaturePolicyURL() const
    1062             : {
    1063           0 :     for (gpgme_sig_notation_t n = gpgme_sig_notation_get(d->ctx) ; n ; n = n->next) {
    1064           0 :         if (!n->name) {
    1065           0 :             return n->value;
    1066             :         }
    1067             :     }
    1068           0 :     return nullptr;
    1069             : }
    1070             : 
    1071           0 : Notation Context::signatureNotation(unsigned int idx) const
    1072             : {
    1073           0 :     for (gpgme_sig_notation_t n = gpgme_sig_notation_get(d->ctx) ; n ; n = n->next) {
    1074           0 :         if (n->name) {
    1075           0 :             if (idx-- == 0) {
    1076           0 :                 return Notation(n);
    1077             :             }
    1078             :         }
    1079             :     }
    1080           0 :     return Notation();
    1081             : }
    1082             : 
    1083           0 : std::vector<Notation> Context::signatureNotations() const
    1084             : {
    1085           0 :     std::vector<Notation> result;
    1086           0 :     for (gpgme_sig_notation_t n = gpgme_sig_notation_get(d->ctx) ; n ; n = n->next) {
    1087           0 :         if (n->name) {
    1088           0 :             result.push_back(Notation(n));
    1089             :         }
    1090             :     }
    1091           0 :     return result;
    1092             : }
    1093             : 
    1094           6 : static gpgme_sig_mode_t sigmode2sigmode(SignatureMode mode)
    1095             : {
    1096           6 :     switch (mode) {
    1097             :     default:
    1098           6 :     case NormalSignatureMode: return GPGME_SIG_MODE_NORMAL;
    1099           0 :     case Detached:            return GPGME_SIG_MODE_DETACH;
    1100           0 :     case Clearsigned:         return GPGME_SIG_MODE_CLEAR;
    1101             :     }
    1102             : }
    1103             : 
    1104           6 : SigningResult Context::sign(const Data &plainText, Data &signature, SignatureMode mode)
    1105             : {
    1106           6 :     d->lastop = Private::Sign;
    1107           6 :     const Data::Private *const pdp = plainText.impl();
    1108           6 :     Data::Private *const sdp = signature.impl();
    1109           6 :     d->lasterr = gpgme_op_sign(d->ctx, pdp ? pdp->data : 0, sdp ? sdp->data : 0, sigmode2sigmode(mode));
    1110           6 :     return SigningResult(d->ctx, Error(d->lasterr));
    1111             : }
    1112             : 
    1113           0 : Error Context::startSigning(const Data &plainText, Data &signature, SignatureMode mode)
    1114             : {
    1115           0 :     d->lastop = Private::Sign;
    1116           0 :     const Data::Private *const pdp = plainText.impl();
    1117           0 :     Data::Private *const sdp = signature.impl();
    1118           0 :     return Error(d->lasterr = gpgme_op_sign_start(d->ctx, pdp ? pdp->data : 0, sdp ? sdp->data : 0, sigmode2sigmode(mode)));
    1119             : }
    1120             : 
    1121           0 : SigningResult Context::signingResult() const
    1122             : {
    1123           0 :     if (d->lastop & Private::Sign) {
    1124           0 :         return SigningResult(d->ctx, Error(d->lasterr));
    1125             :     } else {
    1126           0 :         return SigningResult();
    1127             :     }
    1128             : }
    1129             : 
    1130           3 : static gpgme_encrypt_flags_t encryptflags2encryptflags(Context::EncryptionFlags flags)
    1131             : {
    1132           3 :     unsigned int result = 0;
    1133           3 :     if (flags & Context::AlwaysTrust) {
    1134           3 :         result |= GPGME_ENCRYPT_ALWAYS_TRUST;
    1135             :     }
    1136           3 :     if (flags & Context::NoEncryptTo) {
    1137           0 :         result |= GPGME_ENCRYPT_NO_ENCRYPT_TO;
    1138             :     }
    1139           3 :     if (flags & Context::Prepare) {
    1140           0 :         result |= GPGME_ENCRYPT_PREPARE;
    1141             :     }
    1142           3 :     if (flags & Context::ExpectSign) {
    1143           0 :         result |= GPGME_ENCRYPT_EXPECT_SIGN;
    1144             :     }
    1145           3 :     if (flags & Context::NoCompress) {
    1146           0 :         result |= GPGME_ENCRYPT_NO_COMPRESS;
    1147             :     }
    1148           3 :     if (flags & Context::Symmetric) {
    1149           0 :         result |= GPGME_ENCRYPT_SYMMETRIC;
    1150             :     }
    1151           3 :     return static_cast<gpgme_encrypt_flags_t>(result);
    1152             : }
    1153             : 
    1154           3 : gpgme_key_t *Context::getKeysFromRecipients(const std::vector<Key> &recipients)
    1155             : {
    1156           3 :     if (recipients.empty()) {
    1157           1 :         return nullptr;
    1158             :     }
    1159           2 :     gpgme_key_t *ret = new gpgme_key_t[ recipients.size() + 1 ];
    1160           2 :     gpgme_key_t *keys_it = ret;
    1161           4 :     for (std::vector<Key>::const_iterator it = recipients.begin() ; it != recipients.end() ; ++it) {
    1162           2 :         if (it->impl()) {
    1163           2 :             *keys_it++ = it->impl();
    1164             :         }
    1165             :     }
    1166           2 :     *keys_it++ = 0;
    1167           2 :     return ret;
    1168             : }
    1169             : 
    1170           3 : EncryptionResult Context::encrypt(const std::vector<Key> &recipients, const Data &plainText, Data &cipherText, EncryptionFlags flags)
    1171             : {
    1172           3 :     d->lastop = Private::Encrypt;
    1173           3 :     if (flags & NoEncryptTo) {
    1174           0 :         return EncryptionResult(Error(d->lasterr = make_error(GPG_ERR_NOT_IMPLEMENTED)));
    1175             :     }
    1176           3 :     const Data::Private *const pdp = plainText.impl();
    1177           3 :     Data::Private *const cdp = cipherText.impl();
    1178           3 :     gpgme_key_t *const keys = getKeysFromRecipients(recipients);
    1179             :     d->lasterr = gpgme_op_encrypt(d->ctx, keys, encryptflags2encryptflags(flags),
    1180           3 :                                   pdp ? pdp->data : 0, cdp ? cdp->data : 0);
    1181           3 :     if (keys) {
    1182           2 :         delete[] keys;
    1183             :     }
    1184           3 :     return EncryptionResult(d->ctx, Error(d->lasterr));
    1185             : }
    1186             : 
    1187           0 : Error Context::encryptSymmetrically(const Data &plainText, Data &cipherText)
    1188             : {
    1189           0 :     d->lastop = Private::Encrypt;
    1190           0 :     const Data::Private *const pdp = plainText.impl();
    1191           0 :     Data::Private *const cdp = cipherText.impl();
    1192             :     return Error(d->lasterr = gpgme_op_encrypt(d->ctx, 0, (gpgme_encrypt_flags_t)0,
    1193           0 :                               pdp ? pdp->data : 0, cdp ? cdp->data : 0));
    1194             : }
    1195             : 
    1196           0 : Error Context::startEncryption(const std::vector<Key> &recipients, const Data &plainText, Data &cipherText, EncryptionFlags flags)
    1197             : {
    1198           0 :     d->lastop = Private::Encrypt;
    1199           0 :     if (flags & NoEncryptTo) {
    1200           0 :         return Error(d->lasterr = make_error(GPG_ERR_NOT_IMPLEMENTED));
    1201             :     }
    1202           0 :     const Data::Private *const pdp = plainText.impl();
    1203           0 :     Data::Private *const cdp = cipherText.impl();
    1204           0 :     gpgme_key_t *const keys = getKeysFromRecipients(recipients);
    1205             :     d->lasterr = gpgme_op_encrypt_start(d->ctx, keys, encryptflags2encryptflags(flags),
    1206           0 :                                         pdp ? pdp->data : 0, cdp ? cdp->data : 0);
    1207           0 :     if (keys) {
    1208           0 :         delete[] keys;
    1209             :     }
    1210           0 :     return Error(d->lasterr);
    1211             : }
    1212             : 
    1213           0 : EncryptionResult Context::encryptionResult() const
    1214             : {
    1215           0 :     if (d->lastop & Private::Encrypt) {
    1216           0 :         return EncryptionResult(d->ctx, Error(d->lasterr));
    1217             :     } else {
    1218           0 :         return EncryptionResult();
    1219             :     }
    1220             : }
    1221             : 
    1222           0 : std::pair<SigningResult, EncryptionResult> Context::signAndEncrypt(const std::vector<Key> &recipients, const Data &plainText, Data &cipherText, EncryptionFlags flags)
    1223             : {
    1224           0 :     d->lastop = Private::SignAndEncrypt;
    1225           0 :     const Data::Private *const pdp = plainText.impl();
    1226           0 :     Data::Private *const cdp = cipherText.impl();
    1227           0 :     gpgme_key_t *const keys = getKeysFromRecipients(recipients);
    1228             :     d->lasterr = gpgme_op_encrypt_sign(d->ctx, keys, encryptflags2encryptflags(flags),
    1229           0 :                                        pdp ? pdp->data : 0, cdp ? cdp->data : 0);
    1230           0 :     if (keys) {
    1231           0 :         delete[] keys;
    1232             :     }
    1233             :     return std::make_pair(SigningResult(d->ctx, Error(d->lasterr)),
    1234           0 :                           EncryptionResult(d->ctx, Error(d->lasterr)));
    1235             : }
    1236             : 
    1237           0 : Error Context::startCombinedSigningAndEncryption(const std::vector<Key> &recipients, const Data &plainText, Data &cipherText, EncryptionFlags flags)
    1238             : {
    1239           0 :     d->lastop = Private::SignAndEncrypt;
    1240           0 :     const Data::Private *const pdp = plainText.impl();
    1241           0 :     Data::Private *const cdp = cipherText.impl();
    1242           0 :     gpgme_key_t *const keys = getKeysFromRecipients(recipients);
    1243             :     d->lasterr = gpgme_op_encrypt_sign_start(d->ctx, keys, encryptflags2encryptflags(flags),
    1244           0 :                  pdp ? pdp->data : 0, cdp ? cdp->data : 0);
    1245           0 :     if (keys) {
    1246           0 :         delete[] keys;
    1247             :     }
    1248           0 :     return Error(d->lasterr);
    1249             : }
    1250             : 
    1251           0 : Error Context::createVFS(const char *containerFile, const std::vector< Key > &recipients)
    1252             : {
    1253           0 :     d->lastop = Private::CreateVFS;
    1254           0 :     gpgme_key_t *const keys = new gpgme_key_t[ recipients.size() + 1 ];
    1255           0 :     gpgme_key_t *keys_it = keys;
    1256           0 :     for (std::vector<Key>::const_iterator it = recipients.begin() ; it != recipients.end() ; ++it) {
    1257           0 :         if (it->impl()) {
    1258           0 :             *keys_it++ = it->impl();
    1259             :         }
    1260             :     }
    1261           0 :     *keys_it++ = 0;
    1262             : 
    1263             :     gpgme_error_t op_err;
    1264           0 :     d->lasterr = gpgme_op_vfs_create(d->ctx, keys, containerFile, 0, &op_err);
    1265           0 :     delete[] keys;
    1266           0 :     Error error(d->lasterr);
    1267           0 :     if (error) {
    1268           0 :         return error;
    1269             :     }
    1270           0 :     return Error(d->lasterr = op_err);
    1271             : }
    1272             : 
    1273           0 : VfsMountResult Context::mountVFS(const char *containerFile, const char *mountDir)
    1274             : {
    1275           0 :     d->lastop = Private::MountVFS;
    1276             :     gpgme_error_t op_err;
    1277           0 :     d->lasterr = gpgme_op_vfs_mount(d->ctx, containerFile, mountDir, 0, &op_err);
    1278           0 :     return VfsMountResult(d->ctx, Error(d->lasterr), Error(op_err));
    1279             : }
    1280             : 
    1281          14 : Error Context::cancelPendingOperation()
    1282             : {
    1283          14 :     return Error(gpgme_cancel_async(d->ctx));
    1284             : }
    1285             : 
    1286           0 : bool Context::poll()
    1287             : {
    1288           0 :     gpgme_error_t e = GPG_ERR_NO_ERROR;
    1289           0 :     const bool finished = gpgme_wait(d->ctx, &e, 0);
    1290           0 :     if (finished) {
    1291           0 :         d->lasterr = e;
    1292             :     }
    1293           0 :     return finished;
    1294             : }
    1295             : 
    1296           0 : Error Context::wait()
    1297             : {
    1298           0 :     gpgme_error_t e = GPG_ERR_NO_ERROR;
    1299           0 :     gpgme_wait(d->ctx, &e, 1);
    1300           0 :     return Error(d->lasterr = e);
    1301             : }
    1302             : 
    1303          23 : Error Context::lastError() const
    1304             : {
    1305          23 :     return Error(d->lasterr);
    1306             : }
    1307             : 
    1308           0 : Context::PinentryMode Context::pinentryMode() const
    1309             : {
    1310           0 :     switch (gpgme_get_pinentry_mode (d->ctx)) {
    1311             :         case GPGME_PINENTRY_MODE_ASK:
    1312           0 :             return PinentryAsk;
    1313             :         case GPGME_PINENTRY_MODE_CANCEL:
    1314           0 :             return PinentryCancel;
    1315             :         case GPGME_PINENTRY_MODE_ERROR:
    1316           0 :             return PinentryError;
    1317             :         case GPGME_PINENTRY_MODE_LOOPBACK:
    1318           0 :             return PinentryLoopback;
    1319             :         case GPGME_PINENTRY_MODE_DEFAULT:
    1320             :         default:
    1321           0 :             return PinentryDefault;
    1322             :     }
    1323             : }
    1324             : 
    1325           9 : Error Context::setPinentryMode(PinentryMode which)
    1326             : {
    1327             :     gpgme_pinentry_mode_t mode;
    1328           9 :     switch (which) {
    1329             :         case PinentryAsk:
    1330           0 :             mode = GPGME_PINENTRY_MODE_ASK;
    1331           0 :             break;
    1332             :         case PinentryCancel:
    1333           0 :             mode = GPGME_PINENTRY_MODE_CANCEL;
    1334           0 :             break;
    1335             :         case PinentryError:
    1336           0 :             mode = GPGME_PINENTRY_MODE_ERROR;
    1337           0 :             break;
    1338             :         case PinentryLoopback:
    1339           9 :             mode = GPGME_PINENTRY_MODE_LOOPBACK;
    1340           9 :             break;
    1341             :         case PinentryDefault:
    1342             :         default:
    1343           0 :             mode = GPGME_PINENTRY_MODE_DEFAULT;
    1344             :     }
    1345           9 :     return Error(d->lasterr = gpgme_set_pinentry_mode(d->ctx, mode));
    1346             : }
    1347             : 
    1348           2 : static gpgme_tofu_policy_t to_tofu_policy_t(unsigned int policy)
    1349             : {
    1350           2 :     switch (policy) {
    1351             :         case TofuInfo::PolicyNone:
    1352           0 :             return GPGME_TOFU_POLICY_NONE;
    1353             :         case TofuInfo::PolicyAuto:
    1354           0 :             return GPGME_TOFU_POLICY_AUTO;
    1355             :         case TofuInfo::PolicyGood:
    1356           1 :             return GPGME_TOFU_POLICY_GOOD;
    1357             :         case TofuInfo::PolicyBad:
    1358           1 :             return GPGME_TOFU_POLICY_BAD;
    1359             :         case TofuInfo::PolicyAsk:
    1360           0 :             return GPGME_TOFU_POLICY_ASK;
    1361             :         case TofuInfo::PolicyUnknown:
    1362             :         default:
    1363           0 :             return GPGME_TOFU_POLICY_UNKNOWN;
    1364             :     }
    1365             : }
    1366             : 
    1367           2 : Error Context::setTofuPolicy(const Key &k, unsigned int policy)
    1368             : {
    1369             :     return Error(d->lasterr = gpgme_op_tofu_policy(d->ctx,
    1370           2 :                  k.impl(), to_tofu_policy_t(policy)));
    1371             : }
    1372             : 
    1373           0 : Error Context::setTofuPolicyStart(const Key &k, unsigned int policy)
    1374             : {
    1375             :     return Error(d->lasterr = gpgme_op_tofu_policy_start(d->ctx,
    1376           0 :                  k.impl(), to_tofu_policy_t(policy)));
    1377             : }
    1378             : 
    1379             : // Engine Spawn stuff
    1380           0 : Error Context::spawn(const char *file, const char *argv[],
    1381             :                      Data &input, Data &output, Data &err,
    1382             :                      SpawnFlags flags)
    1383             : {
    1384             :     return Error(d->lasterr = gpgme_op_spawn (d->ctx, file, argv,
    1385           0 :         input.impl() ? input.impl()->data : nullptr,
    1386           0 :         output.impl() ? output.impl()->data : nullptr,
    1387           0 :         err.impl() ? err.impl()->data : nullptr,
    1388           0 :         static_cast<int>(flags)));
    1389             : }
    1390             : 
    1391           0 : Error Context::spawnAsync(const char *file, const char *argv[],
    1392             :                           Data &input, Data &output, Data &err,
    1393             :                           SpawnFlags flags)
    1394             : {
    1395             :     return Error(d->lasterr = gpgme_op_spawn_start (d->ctx, file, argv,
    1396           0 :         input.impl() ? input.impl()->data : nullptr,
    1397           0 :         output.impl() ? output.impl()->data : nullptr,
    1398           0 :         err.impl() ? err.impl()->data : nullptr,
    1399           0 :         static_cast<int>(flags)));
    1400             : }
    1401             : 
    1402           0 : std::ostream &operator<<(std::ostream &os, Protocol proto)
    1403             : {
    1404           0 :     os << "GpgME::Protocol(";
    1405           0 :     switch (proto) {
    1406             :     case OpenPGP:
    1407           0 :         os << "OpenPGP";
    1408           0 :         break;
    1409             :     case CMS:
    1410           0 :         os << "CMS";
    1411           0 :         break;
    1412             :     default:
    1413             :     case UnknownProtocol:
    1414           0 :         os << "UnknownProtocol";
    1415           0 :         break;
    1416             :     }
    1417           0 :     return os << ')';
    1418             : }
    1419             : 
    1420           0 : std::ostream &operator<<(std::ostream &os, Engine eng)
    1421             : {
    1422           0 :     os << "GpgME::Engine(";
    1423           0 :     switch (eng) {
    1424             :     case GpgEngine:
    1425           0 :         os << "GpgEngine";
    1426           0 :         break;
    1427             :     case GpgSMEngine:
    1428           0 :         os << "GpgSMEngine";
    1429           0 :         break;
    1430             :     case GpgConfEngine:
    1431           0 :         os << "GpgConfEngine";
    1432           0 :         break;
    1433             :     case AssuanEngine:
    1434           0 :         os << "AssuanEngine";
    1435           0 :         break;
    1436             :     case SpawnEngine:
    1437           0 :         os << "SpawnEngine";
    1438           0 :         break;
    1439             :     default:
    1440             :     case UnknownEngine:
    1441           0 :         os << "UnknownEngine";
    1442           0 :         break;
    1443             :     }
    1444           0 :     return os << ')';
    1445             : }
    1446             : 
    1447           0 : std::ostream &operator<<(std::ostream &os, Context::CertificateInclusion incl)
    1448             : {
    1449           0 :     os << "GpgME::Context::CertificateInclusion(" << static_cast<int>(incl);
    1450           0 :     switch (incl) {
    1451             :     case Context::DefaultCertificates:
    1452           0 :         os << "(DefaultCertificates)";
    1453           0 :         break;
    1454             :     case Context::AllCertificatesExceptRoot:
    1455           0 :         os << "(AllCertificatesExceptRoot)";
    1456           0 :         break;
    1457             :     case Context::AllCertificates:
    1458           0 :         os << "(AllCertificates)";
    1459           0 :         break;
    1460             :     case Context::NoCertificates:
    1461           0 :         os << "(NoCertificates)";
    1462           0 :         break;
    1463             :     case Context::OnlySenderCertificate:
    1464           0 :         os << "(OnlySenderCertificate)";
    1465           0 :         break;
    1466             :     }
    1467           0 :     return os << ')';
    1468             : }
    1469             : 
    1470           0 : std::ostream &operator<<(std::ostream &os, KeyListMode mode)
    1471             : {
    1472           0 :     os << "GpgME::KeyListMode(";
    1473             : #define CHECK( x ) if ( !(mode & (x)) ) {} else do { os << #x " "; } while (0)
    1474           0 :     CHECK(Local);
    1475           0 :     CHECK(Extern);
    1476           0 :     CHECK(Signatures);
    1477           0 :     CHECK(Validate);
    1478           0 :     CHECK(Ephemeral);
    1479           0 :     CHECK(WithTofu);
    1480             : #undef CHECK
    1481           0 :     return os << ')';
    1482             : }
    1483             : 
    1484           0 : std::ostream &operator<<(std::ostream &os, SignatureMode mode)
    1485             : {
    1486           0 :     os << "GpgME::SignatureMode(";
    1487           0 :     switch (mode) {
    1488             : #define CHECK( x ) case x: os << #x; break
    1489           0 :         CHECK(NormalSignatureMode);
    1490           0 :         CHECK(Detached);
    1491           0 :         CHECK(Clearsigned);
    1492             : #undef CHECK
    1493             :     default:
    1494           0 :         os << "???" "(" << static_cast<int>(mode) << ')';
    1495           0 :         break;
    1496             :     }
    1497           0 :     return os << ')';
    1498             : }
    1499             : 
    1500           0 : std::ostream &operator<<(std::ostream &os, Context::EncryptionFlags flags)
    1501             : {
    1502           0 :     os << "GpgME::Context::EncryptionFlags(";
    1503             : #define CHECK( x ) if ( !(flags & (Context::x)) ) {} else do { os << #x " "; } while (0)
    1504           0 :     CHECK(AlwaysTrust);
    1505           0 :     CHECK(NoEncryptTo);
    1506           0 :     CHECK(Prepare);
    1507           0 :     CHECK(ExpectSign);
    1508           0 :     CHECK(NoCompress);
    1509           0 :     CHECK(Symmetric);
    1510             : #undef CHECK
    1511           0 :     return os << ')';
    1512             : }
    1513             : 
    1514           0 : std::ostream &operator<<(std::ostream &os, Context::AuditLogFlags flags)
    1515             : {
    1516           0 :     os << "GpgME::Context::AuditLogFlags(";
    1517             : #define CHECK( x ) if ( !(flags & (Context::x)) ) {} else do { os << #x " "; } while (0)
    1518           0 :     CHECK(HtmlAuditLog);
    1519           0 :     CHECK(AuditLogWithHelp);
    1520             : #undef CHECK
    1521           0 :     return os << ')';
    1522             : }
    1523             : 
    1524             : } // namespace GpgME
    1525             : 
    1526           0 : GpgME::Error GpgME::setDefaultLocale(int cat, const char *val)
    1527             : {
    1528           0 :     return Error(gpgme_set_locale(0, cat, val));
    1529             : }
    1530             : 
    1531           0 : GpgME::EngineInfo GpgME::engineInfo(GpgME::Protocol proto)
    1532             : {
    1533           0 :     gpgme_engine_info_t ei = 0;
    1534           0 :     if (gpgme_get_engine_info(&ei)) {
    1535           0 :         return EngineInfo();
    1536             :     }
    1537             : 
    1538           0 :     const gpgme_protocol_t p = proto == CMS ? GPGME_PROTOCOL_CMS : GPGME_PROTOCOL_OpenPGP ;
    1539             : 
    1540           0 :     for (gpgme_engine_info_t i = ei ; i ; i = i->next) {
    1541           0 :         if (i->protocol == p) {
    1542           0 :             return EngineInfo(i);
    1543             :         }
    1544             :     }
    1545             : 
    1546           0 :     return EngineInfo();
    1547             : }
    1548             : 
    1549           0 : const char *GpgME::dirInfo(const char *what)
    1550             : {
    1551           0 :     return gpgme_get_dirinfo(what);
    1552             : }
    1553             : 
    1554           6 : GpgME::Error GpgME::checkEngine(GpgME::Protocol proto)
    1555             : {
    1556           6 :     const gpgme_protocol_t p = proto == CMS ? GPGME_PROTOCOL_CMS : GPGME_PROTOCOL_OpenPGP ;
    1557             : 
    1558           6 :     return Error(gpgme_engine_check_version(p));
    1559             : }
    1560             : 
    1561             : static const gpgme_protocol_t UNKNOWN_PROTOCOL = static_cast<gpgme_protocol_t>(255);
    1562             : 
    1563           8 : static gpgme_protocol_t engine2protocol(const GpgME::Engine engine)
    1564             : {
    1565           8 :     switch (engine) {
    1566           8 :     case GpgME::GpgEngine:   return GPGME_PROTOCOL_OpenPGP;
    1567           0 :     case GpgME::GpgSMEngine: return GPGME_PROTOCOL_CMS;
    1568             :     case GpgME::GpgConfEngine:
    1569           0 :         return GPGME_PROTOCOL_GPGCONF;
    1570             :     case GpgME::AssuanEngine:
    1571           0 :         return GPGME_PROTOCOL_ASSUAN;
    1572             :     case GpgME::G13Engine:
    1573           0 :         return GPGME_PROTOCOL_G13;
    1574             :     case GpgME::SpawnEngine:
    1575           0 :         return GPGME_PROTOCOL_SPAWN;
    1576             :     case GpgME::UnknownEngine:
    1577             :         ;
    1578             :     }
    1579           0 :     return UNKNOWN_PROTOCOL;
    1580             : }
    1581             : 
    1582           8 : GpgME::EngineInfo GpgME::engineInfo(GpgME::Engine engine)
    1583             : {
    1584           8 :     gpgme_engine_info_t ei = 0;
    1585           8 :     if (gpgme_get_engine_info(&ei)) {
    1586           0 :         return EngineInfo();
    1587             :     }
    1588             : 
    1589           8 :     const gpgme_protocol_t p = engine2protocol(engine);
    1590             : 
    1591           8 :     for (gpgme_engine_info_t i = ei ; i ; i = i->next) {
    1592           8 :         if (i->protocol == p) {
    1593           8 :             return EngineInfo(i);
    1594             :         }
    1595             :     }
    1596             : 
    1597           0 :     return EngineInfo();
    1598             : }
    1599             : 
    1600           0 : GpgME::Error GpgME::checkEngine(GpgME::Engine engine)
    1601             : {
    1602           0 :     const gpgme_protocol_t p = engine2protocol(engine);
    1603             : 
    1604           0 :     return Error(gpgme_engine_check_version(p));
    1605             : }
    1606             : 
    1607             : static const unsigned long supported_features = 0
    1608             :         | GpgME::ValidatingKeylistModeFeature
    1609             :         | GpgME::CancelOperationFeature
    1610             :         | GpgME::WrongKeyUsageFeature
    1611             :         | GpgME::DefaultCertificateInclusionFeature
    1612             :         | GpgME::GetSetEngineInfoFeature
    1613             :         | GpgME::ClearAddGetSignatureNotationsFeature
    1614             :         | GpgME::SetDataFileNameFeeature
    1615             :         | GpgME::SignatureNotationsKeylistModeFeature
    1616             :         | GpgME::KeySignatureNotationsFeature
    1617             :         | GpgME::KeyIsQualifiedFeature
    1618             :         | GpgME::SignatureNotationsCriticalFlagFeature
    1619             :         | GpgME::SignatureNotationsFlagsFeature
    1620             :         | GpgME::SignatureNotationsHumanReadableFlagFeature
    1621             :         | GpgME::SubkeyIsQualifiedFeature
    1622             :         | GpgME::EngineInfoHomeDirFeature
    1623             :         | GpgME::DecryptionResultFileNameFeature
    1624             :         | GpgME::DecryptionResultRecipientsFeature
    1625             :         | GpgME::VerificationResultFileNameFeature
    1626             :         | GpgME::SignaturePkaFieldsFeature
    1627             :         | GpgME::SignatureAlgorithmFieldsFeature
    1628             :         | GpgME::FdPointerFeature
    1629             :         | GpgME::AuditLogFeature
    1630             :         | GpgME::GpgConfEngineFeature
    1631             :         | GpgME::CancelOperationAsyncFeature
    1632             :         | GpgME::NoEncryptToEncryptionFlagFeature
    1633             :         | GpgME::CardKeyFeature
    1634             :         | GpgME::AssuanEngineFeature
    1635             :         | GpgME::EphemeralKeylistModeFeature
    1636             :         | GpgME::ImportFromKeyserverFeature
    1637             :         | GpgME::G13VFSFeature
    1638             :         | GpgME::PasswdFeature
    1639             :         ;
    1640             : 
    1641             : static const unsigned long supported_features2 = 0
    1642             :         | GpgME::BinaryAndFineGrainedIdentify
    1643             :         ;
    1644             : 
    1645           0 : bool GpgME::hasFeature(unsigned long features)
    1646             : {
    1647           0 :     return features == (features & supported_features);
    1648             : }
    1649             : 
    1650           0 : bool GpgME::hasFeature(unsigned long features, unsigned long features2)
    1651             : {
    1652           0 :     return features  == (features  & supported_features)
    1653           0 :            && features2 == (features2 & supported_features2)
    1654             :            ;
    1655          18 : }

Generated by: LCOV version 1.11