lang/cpp/src/context.cpp

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