diff options
Diffstat (limited to 'libtdenetwork/gpgmepp')
47 files changed, 6288 insertions, 0 deletions
diff --git a/libtdenetwork/gpgmepp/CMakeLists.txt b/libtdenetwork/gpgmepp/CMakeLists.txt new file mode 100644 index 00000000..cf4efc7f --- /dev/null +++ b/libtdenetwork/gpgmepp/CMakeLists.txt @@ -0,0 +1,54 @@ +################################################# +# +# (C) 2010-2011 Serghei Amelian +# serghei (DOT) amelian (AT) gmail.com +# +# Improvements and feedback are welcome +# +# This file is released under GPL >= 2 +# +################################################# + +add_subdirectory( interfaces ) + +include_directories( + ${CMAKE_CURRENT_BINARY_DIR} + ${CMAKE_CURRENT_SOURCE_DIR} + ${CMAKE_BINARY_DIR} + ${CMAKE_SOURCE_DIR}/libtdenetwork + ${CMAKE_SOURCE_DIR}/libtdepim + ${TDE_INCLUDE_DIR} + ${TQT_INCLUDE_DIRS} + ${GPGME_INCLUDE_DIRS} +) + +link_directories( + ${TQT_LIBRARY_DIRS} +) + + +##### headers ################################### + +install( FILES + context.h key.h trustitem.h eventloopinteractor.h + data.h gpgmefw.h result.h keylistresult.h + keygenerationresult.h importresult.h decryptionresult.h + verificationresult.h signingresult.h encryptionresult.h + engineinfo.h + DESTINATION ${INCLUDE_INSTALL_DIR}/kde/gpgme++ ) + + +##### gpgme++ (shared) ########################## + +tde_add_library( gpgme++ SHARED + SOURCES + context.cpp key.cpp trustitem.cpp data.cpp + callbacks.cpp eventloopinteractor.cpp + keylistresult.cpp keygenerationresult.cpp + importresult.cpp decryptionresult.cpp + verificationresult.cpp signingresult.cpp + encryptionresult.cpp engineinfo.cpp + VERSION 0.4.0 + LINK ${TQT_LIBRARIES} ${GPGME_LIBRARIES} + DESTINATION ${LIB_INSTALL_DIR} +) diff --git a/libtdenetwork/gpgmepp/Makefile.am b/libtdenetwork/gpgmepp/Makefile.am new file mode 100644 index 00000000..d4ebfde9 --- /dev/null +++ b/libtdenetwork/gpgmepp/Makefile.am @@ -0,0 +1,52 @@ +KDE_OPTIONS = foreign +#AM_CXXFLAGS = -Wno-deprecated-declarations + +SUBDIRS = interfaces . + +INCLUDES = -I$(top_srcdir)/libtdenetwork -I$(top_srcdir)/libtdenetwork/gpgmepp \ + $(GPGME_CFLAGS) $(all_includes) + +gpgmeppdir = $(includedir)/gpgme++ +gpgmepp_HEADERS = context.h \ + key.h \ + trustitem.h \ + eventloopinteractor.h \ + data.h \ + gpgmefw.h \ + result.h \ + keylistresult.h \ + keygenerationresult.h \ + importresult.h \ + decryptionresult.h \ + verificationresult.h \ + signingresult.h \ + encryptionresult.h \ + engineinfo.h + +noinst_HEADERS = context_p.h data_p.h shared.h callbacks.h gpgme-0-3-compat.h result_p.h util.h + +lib_LTLIBRARIES = libgpgme++.la +libgpgme___la_SOURCES = context.cpp \ + key.cpp \ + trustitem.cpp \ + data.cpp \ + callbacks.cpp \ + eventloopinteractor.cpp \ + keylistresult.cpp \ + keygenerationresult.cpp \ + importresult.cpp \ + decryptionresult.cpp \ + verificationresult.cpp \ + signingresult.cpp \ + encryptionresult.cpp \ + engineinfo.cpp + +# --version-info CURRENT:REVISION:AGE +# (Code changed: REVISION++) +# (Interfaces added/removed/changed: CURRENT++, REVISION=0) +# (Interfaces added: AGE++) +# (Interfaces removed/changed: AGE=0) +libgpgme___la_LDFLAGS = -no-undefined -version-info 4:0:4 +libgpgme___la_LIBADD = $(GPGME_LIBS) +libgpgme___la_DEPENDENCIES = $(GPGME_LIBS_DEP) + diff --git a/libtdenetwork/gpgmepp/README.gpgme++ b/libtdenetwork/gpgmepp/README.gpgme++ new file mode 100644 index 00000000..ecda2c9a --- /dev/null +++ b/libtdenetwork/gpgmepp/README.gpgme++ @@ -0,0 +1,82 @@ + GpgME++ - C++ bindings/wrapper for gpgme + ------------------------------------ + Version 0.0.1 + + Copyright (c) 2003, 2004 Klarälvdalens Datakonsult AB + + This file is free software; as a special exception the author gives + unlimited permission to copy and/or distribute it, with or without + modifications, as long as this notice is preserved. + + This file is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY, to the extent permitted by law; without even the + implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + + + + Overview + -------- + + GpgME++ is a C++ wrapper (or C++ bindings) for the GnuPG project's + gpgme (GnuPG Made Easy) library, version 0.4.4 and later. + + It is fairly complete, with some minor things still missing (in + particular, the key edit interface). It is mostly tested using + external event loops, for which its design is optimised. + + The design principles of this library are as follows: + + 1. A value-based interface (most clases are implicitly shared) + 2. Callbacks are replaced by C++ interfaces (classes with only + abstract methods). + 3. No exceptions are thrown + 4. There is (as yet) no explicit support for multi-threaded use + (other than what gpgme itself provides; most notably the + refcounting for implicit sharing is not thread-safe) + 5. To avoid binary incompatible interface changes, we make + extensive use of the d-pointer pattern and avoid virtual + methods; any polymorphism present is already provided by gpgme + itself, anyway (see e.g. Data). A notable exception of the + no-virtuals rule is the use of abstract classes to cover + C-callbacks. + + The authors hope that once there are more users of this library, + the GnuPG project will include it as the official C++ binding for + gpgme. Currently, this is not the case, since it was felt that C++ + bindings can be provided with different design decisions, and that + it is not clear that the decisions made for GpgME++ are broad + enough to be universally applicable (e.g. a pivotal design + decision was to not use exceptions to wrap gpgme_error_t). + + GpgME++ depends on gpgme, which in turn depends on libgpg-error, both + of which must be installed correctly before GpgME++ is to be + built. Furthermore, GpgME++ should be recompiled if the underlying + gpgme is changed. This is to allow closer integration and to + abstract away possible interface changes. Therefore, once this + libray becomes stable, we intend to follow gpgme's versioning. + + Currently, we use the KDE CVS repository to develop our code, + basically because GpgME++ is used in KMail and Kleopatra. However, + the library is in no way dependant on KDE or Qt libraries, and you + are free to use it in your own projects, provided you follow the + license. If you _do_ want to use GpgME++ in Qt/KDE applications, + have a look at QGpgME, which provides integration with QEventLoop + and some Qt datatypes (e.g. QByteArray). + + + Mailing List + ------------ + + Discussion of this library and questions regarding it's use and + design should happen on gpa-dev@gnupg.org or gnupg-devel@gnupg.org. + + + License + ------- + + This library is licensed under the GNU General Public License + (GPL), just as gpgme is. We feel that using a different license + than the one gpgme itself uses doesn't make sense. OTOH, we shall + relicense this library to the GNU Lesser General Public License + (LGPL) should gpgme itself be made available under this license at + any time in the future. diff --git a/libtdenetwork/gpgmepp/callbacks.cpp b/libtdenetwork/gpgmepp/callbacks.cpp new file mode 100644 index 00000000..b352515d --- /dev/null +++ b/libtdenetwork/gpgmepp/callbacks.cpp @@ -0,0 +1,138 @@ +/* callbacks.cpp - callback targets for internal use: + Copyright (C) 2003,2004 Klarälvdalens Datakonsult AB + + This file is part of GPGME++. + + GPGME++ is free software; you can redistribute it and/or modify it + under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + GPGME++ is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + General Public License for more details. + + You should have received a copy of the GNU General Public License + along with GPGME; if not, write to the Free Software Foundation, + Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. +*/ +#ifdef HAVE_CONFIG_H +#include <config.h> +#endif + +#include "callbacks.h" + +#include <gpgmepp/interfaces/progressprovider.h> +#include <gpgmepp/interfaces/passphraseprovider.h> +#include <gpgmepp/interfaces/dataprovider.h> +#include <gpgmepp/context.h> // for Error + +#include <cassert> +#include <cerrno> +#include <unistd.h> +#include <cstdlib> +#include <string.h> +#include <cstdlib> + +static inline gpg_error_t makeErrorFromErrno() { + return gpg_err_make_from_errno( (gpg_err_source_t)22, errno ); +} +static inline gpg_error_t makeError( gpg_err_code_t code ) { + return gpg_err_make( (gpg_err_source_t)22, code ); +} + +using GpgME::ProgressProvider; +using GpgME::PassphraseProvider; +using GpgME::DataProvider; + +void progress_callback( void * opaque, const char * what, + int type, int current, int total ) { + ProgressProvider * provider = static_cast<ProgressProvider*>( opaque ); + if ( provider ) + provider->showProgress( what, type, current, total ); +} + +static void wipe( char * buf, size_t len ) { + for ( size_t i = 0 ; i < len ; ++i ) + buf[i] = '\0'; +} + +gpgme_error_t passphrase_callback( void * opaque, const char * uid_hint, const char * desc, + int prev_was_bad, int fd ) { + PassphraseProvider * provider = static_cast<PassphraseProvider*>( opaque ); + bool canceled = false; + gpgme_error_t err = GPG_ERR_NO_ERROR; + char * passphrase = provider ? provider->getPassphrase( uid_hint, desc, prev_was_bad, canceled ) : 0 ; + if ( canceled ) + err = makeError( GPG_ERR_CANCELED ); + else + if ( passphrase && *passphrase ) { + size_t passphrase_length = strlen( passphrase ); + size_t written = 0; + do { + ssize_t now_written = write( fd, passphrase + written, passphrase_length - written ); + if ( now_written < 0 ) { + err = makeErrorFromErrno(); + break; + } + written += now_written; + } while ( written < passphrase_length ); + } + + if ( passphrase && *passphrase ) + wipe( passphrase, strlen( passphrase ) ); + free( passphrase ); + write( fd, "\n", 1 ); + return err; +} + + + +static ssize_t +data_read_callback( void * opaque, void * buf, size_t buflen ) { + DataProvider * provider = static_cast<DataProvider*>( opaque ); + if ( !provider ) { + errno = EINVAL; + return -1; + } + return provider->read( buf, buflen ); +} + +static ssize_t +data_write_callback( void * opaque, const void * buf, size_t buflen ) { + DataProvider * provider = static_cast<DataProvider*>( opaque ); + if ( !provider ) { + errno = EINVAL; + return -1; + } + return provider->write( buf, buflen ); +} + +static off_t +data_seek_callback( void * opaque, off_t offset, int whence ) { + DataProvider * provider = static_cast<DataProvider*>( opaque ); + if ( !provider ) { + errno = EINVAL; + return -1; + } + if ( whence != SEEK_SET && whence != SEEK_CUR && whence != SEEK_END ) { + errno = EINVAL; + return -1; + } + return provider->seek( offset, whence ); +} + +static void data_release_callback( void * opaque ) { + DataProvider * provider = static_cast<DataProvider*>( opaque ); + if ( provider ) + provider->release(); +} + +gpgme_data_cbs data_provider_callbacks = { + &data_read_callback, + &data_write_callback, + &data_seek_callback, + &data_release_callback +}; + diff --git a/libtdenetwork/gpgmepp/callbacks.h b/libtdenetwork/gpgmepp/callbacks.h new file mode 100644 index 00000000..cc5b9355 --- /dev/null +++ b/libtdenetwork/gpgmepp/callbacks.h @@ -0,0 +1,39 @@ +/* callbacks.h - callback targets for internal use: + Copyright (C) 2003 Klarälvdalens Datakonsult AB + + This file is part of GPGME++. + + This is an internal header file, subject to change without + notice. DO NOT USE. + + GPGME++ is free software; you can redistribute it and/or modify it + under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + GPGME++ is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + General Public License for more details. + + You should have received a copy of the GNU General Public License + along with GPGME++; if not, write to the Free Software Foundation, + Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. +*/ + +#ifndef __GPGMEPP_CALLBACKS_H__ +#define __GPGMEPP_CALLBACKS_H__ + +#include <gpgme.h> + +extern "C" { + + void progress_callback( void * opaque, const char * what, + int type, int current, int total ); + gpgme_error_t passphrase_callback( void * opaque, const char * uid_hint, + const char * desc, int prev_was_bad, int fd ); +} + +extern gpgme_data_cbs data_provider_callbacks; + +#endif // __GPGME_CALLBACKS_H__ diff --git a/libtdenetwork/gpgmepp/configure.in.bot b/libtdenetwork/gpgmepp/configure.in.bot new file mode 100644 index 00000000..e4b1a884 --- /dev/null +++ b/libtdenetwork/gpgmepp/configure.in.bot @@ -0,0 +1,10 @@ +if test -z "$GPGME_LIBS" || test -n "$tdepim_needs_gpgme_copy" ; then + echo + echo "You are missing gpgme 0.4.5 or higher." + echo "Gpgme will be built statically from libtdenetwork/libgpgme-copy." + echo "If you are a packager, we most strongly recommend to build against" + echo "the system's shared gpgme." + echo "Consider downloading gpgme >= 0.4.5 from ftp://ftp.gnupg.org/gcrypt/alpha/gpgme" + echo "or use the --with-gpgme-prefix=/path/where/gpgme/is/installed option." + echo +fi diff --git a/libtdenetwork/gpgmepp/configure.in.in b/libtdenetwork/gpgmepp/configure.in.in new file mode 100644 index 00000000..6361be45 --- /dev/null +++ b/libtdenetwork/gpgmepp/configure.in.in @@ -0,0 +1,193 @@ +dnl BEGIN inline of gpgme.m4 from gpgme 0.4.4 +dnl remaned from AM_PATH_GPGME to TDEPIM_PATH_GPGME and inlined here +dnl to not require aclocal fiddling... + +dnl Autoconf macros for libgpgme +dnl Id: gpgme.m4,v 1.6 2003/09/03 01:15:56 marcus Exp + +AC_DEFUN([_TDEPIM_PATH_GPGME_CONFIG], +[ AC_ARG_WITH(gpgme-prefix, + AC_HELP_STRING([--with-gpgme-prefix=PFX], + [prefix where GPGME is installed (optional)]), + gpgme_config_prefix="$withval", gpgme_config_prefix="") + if test "x$gpgme_config_prefix" != x ; then + gpgme_config_path="$gpgme_config_prefix/bin" + else + gpgme_config_path="$PATH:/usr/local/bin" + fi + AC_PATH_PROG(GPGME_CONFIG, gpgme-config, no, $gpgme_config_path) + + if test "x$GPGME_CONFIG" != "xno" ; then + gpgme_version=`$GPGME_CONFIG --version` + gpgme_version_major=`echo $gpgme_version | \ + sed 's/\([[0-9]]*\)\.\([[0-9]]*\)\.\([[0-9]]*\).*/\1/'` + gpgme_version_minor=`echo $gpgme_version | \ + sed 's/\([[0-9]]*\)\.\([[0-9]]*\)\.\([[0-9]]*\).*/\2/'` + gpgme_version_micro=`echo $gpgme_version | \ + sed 's/\([[0-9]]*\)\.\([[0-9]]*\)\.\([[0-9]]*\).*/\3/'` + fi +]) + +dnl AM_PATH_GPGME([MINIMUM-VERSION, +dnl [ACTION-IF-FOUND [, ACTION-IF-NOT-FOUND ]]]) +dnl Test for libgpgme and define GPGME_CFLAGS and GPGME_LIBS. +dnl +AC_DEFUN([TDEPIM_PATH_GPGME], +[ AC_REQUIRE([_TDEPIM_PATH_GPGME_CONFIG])dnl + min_gpgme_version=ifelse([$1], ,0.4.2,$1) + AC_MSG_CHECKING(for GPGME - version >= $min_gpgme_version) + ok=no + if test "$GPGME_CONFIG" != "no" ; then + req_major=`echo $min_gpgme_version | \ + sed 's/\([[0-9]]*\)\.\([[0-9]]*\)\.\([[0-9]]*\)/\1/'` + req_minor=`echo $min_gpgme_version | \ + sed 's/\([[0-9]]*\)\.\([[0-9]]*\)\.\([[0-9]]*\)/\2/'` + req_micro=`echo $min_gpgme_version | \ + sed 's/\([[0-9]]*\)\.\([[0-9]]*\)\.\([[0-9]]*\)/\3/'` + if test "$gpgme_version_major" -gt "$req_major"; then + ok=yes + else + if test "$gpgme_version_major" -eq "$req_major"; then + if test "$gpgme_version_minor" -gt "$req_minor"; then + ok=yes + else + if test "$gpgme_version_minor" -eq "$req_minor"; then + if test "$gpgme_version_micro" -ge "$req_micro"; then + ok=yes + fi + fi + fi + fi + fi + fi + if test $ok = yes; then + GPGME_CFLAGS=`$GPGME_CONFIG --cflags` + GPGME_LIBS=`$GPGME_CONFIG --libs` + if test "x$GPGME_LIBS" != x ; then + if test "x`echo $GPGME_LIBS | grep lgpg-error`" = x ; then + GPGME_LIBS="$GPGME_LIBS -lgpg-error" + fi + fi + AC_MSG_RESULT([yes]) + ifelse([$2], , :, [$2]) + else + GPGME_CFLAGS="" + GPGME_LIBS="" + AC_MSG_RESULT([no, will use local libgpgme-copy]) + ifelse([$3], , :, [$3]) + fi + AC_SUBST(GPGME_CFLAGS) + AC_SUBST(GPGME_LIBS) +]) + +dnl +dnl snip AM_PATH_GPGME_{PTH,PTHREAD} +dnl + +dnl END inline of gpgme.m4 + +# The minimum required gpgme version is 0.4.5. +# It was the first useable one for C++ (class keyword) and KDE (largefile support). +# If you change this minimum version here, update also configure.in.bot + +tdepim_needs_gpgme_copy="" +TDEPIM_PATH_GPGME(0.4.5,[ + AC_LANG_SAVE + AC_LANG_C + tdepim_gpgmepp_save_cflags="$CFLAGS" + tdepim_gpgmepp_save_libs="$LIBS" + CFLAGS="$GPGME_CFLAGS" + LIBS="$GPGME_LIBS" + + AC_MSG_CHECKING([if gpgme has GPGME_KEYLIST_MODE_VALIDATE]) + AC_TRY_COMPILE([#include <gpgme.h>], [ + gpgme_keylist_mode_t mode = GPGME_KEYLIST_MODE_VALIDATE; + ], [ + AC_DEFINE(HAVE_GPGME_KEYLIST_MODE_VALIDATE, 1, [Define to 1 if your gpgme supports GPGME_KEYLIST_MODE_VALIDATE]) + AC_MSG_RESULT([yes]) + ], [ + AC_MSG_RESULT([no]) + ]) + + AC_MSG_CHECKING([if gpgme has gpgme_cancel]) + AC_TRY_LINK([#include <gpgme.h>], [ + gpgme_ctx_t ctx = 0; + gpgme_error_t e = gpgme_cancel( ctx ); + ], [ + AC_DEFINE(HAVE_GPGME_CANCEL, 1, [Define to 1 if your gpgme supports gpgme_cancel()]) + AC_MSG_RESULT([yes]) + ], [ + AC_MSG_RESULT([no]) + ]) + + AC_MSG_CHECKING([if gpgme has gpgme_key_t->keylist_mode]) + AC_TRY_COMPILE([#include <gpgme.h>], [ + gpgme_key_t key = 0; + key->keylist_mode = 0; + ], [ + AC_DEFINE(HAVE_GPGME_KEY_T_KEYLIST_MODE, 1, [Define to 1 if your gpgme's gpgme_key_t has the keylist_mode member]) + AC_MSG_RESULT([yes]) + ], [ + AC_MSG_RESULT([no]) + ]) + + AC_MSG_CHECKING([if gpgme has gpgme_decrypt_result_t->wrong_key_usage]) + AC_TRY_COMPILE([#include <gpgme.h>], [ + gpgme_decrypt_result_t res; + unsigned int wku = res->wrong_key_usage; + ], [ + AC_DEFINE(HAVE_GPGME_WRONG_KEY_USAGE, 1, [Define to 1 if your gpgme's gpgme_decrypt_result_t has the wrong_key_usage member]) + AC_MSG_RESULT([yes]) + ], [ + AC_MSG_RESULT([no]) + ]) + + AC_MSG_CHECKING([if gpgme has GPGME_INCLUDE_CERTS_DEFAULT]) + AC_TRY_COMPILE([#include <gpgme.h>], [ + int i = GPGME_INCLUDE_CERTS_DEFAULT; + ], [ + AC_DEFINE(HAVE_GPGME_INCLUDE_CERTS_DEFAULT, 1, [Define to 1 if your gpgme has the GPGME_INCLUDE_CERTS_DEFAULT macro]) + AC_MSG_RESULT([yes]) + ], [ + AC_MSG_RESULT([no]) + ]) + + AC_MSG_CHECKING([if gpgme has gpgme_op_getauditlog]) + AC_TRY_LINK([#include <gpgme.h>], [ + gpgme_ctx_t ctx = 0; + gpgme_data_t data = 0; + unsigned int flags = 0; + gpgme_error_t e = gpgme_op_getauditlog( ctx, data, flags ); + ], [ + AC_DEFINE(HAVE_GPGME_OP_GETAUDITLOG, 1, [Define to 1 if your gpgme supports gpgme_op_getauditlog]) + AC_MSG_RESULT([yes]) + ], [ + AC_MSG_RESULT([no]) + ]) + + CFLAGS="$tdepim_gpgmepp_save_cflags" + LIBS="$tdepim_gpgmepp_save_libs" + AC_LANG_RESTORE + +],[ + tdepim_needs_gpgme_copy="true" + GPGME_CFLAGS='-I$(top_srcdir)/libtdenetwork/libgpgme-copy/gpgme -I$(top_srcdir)/libtdenetwork/libgpg-error-copy -I$(top_builddir)/libtdenetwork/libgpg-error-copy' + GPGME_LIBS='$(top_builddir)/libtdenetwork/libgpgme-copy/gpgme/libgpgme.la' + GPGME_LIBS_DEP='$(GPGME_LIBS)' + # All of this is in gpgme-copy + AC_DEFINE(HAVE_GPGME_KEYLIST_MODE_VALIDATE, 1, [Define to 1 if your gpgme supports GPGME_KEYLIST_MODE_VALIDATE]) + AC_DEFINE(HAVE_GPGME_KEY_T_KEYLIST_MODE, 1, [Define to 1 if your gpgme's gpgme_key_t has the keylist_mode member]) + AC_DEFINE(HAVE_GPGME_CANCEL, 1, [Define to 1 if your gpgme supports gpgme_cancel()]) +]) + +AC_SUBST(GPGME_LIBS_DEP) + +AM_CONDITIONAL(needs_gpgme_copy, test -n "$tdepim_needs_gpgme_copy") + +dnl Always true - either from the local copy or from the system lib. +dnl Still used in gpgmepp/gpgmefw.h for some reason. +AC_DEFINE(HAVE_GPGME_0_4_BRANCH, 1, [Always set since we use gpgme-copy if gpgme isn't available]) + +dnl Used by Makefile.am +AC_PROG_AWK + diff --git a/libtdenetwork/gpgmepp/context.cpp b/libtdenetwork/gpgmepp/context.cpp new file mode 100644 index 00000000..547adde9 --- /dev/null +++ b/libtdenetwork/gpgmepp/context.cpp @@ -0,0 +1,763 @@ +/* context.cpp - wraps a gpgme key context + Copyright (C) 2003 Klarälvdalens Datakonsult AB + + This file is part of GPGME++. + + GPGME++ is free software; you can redistribute it and/or modify it + under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + GPGME++ is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + General Public License for more details. + + You should have received a copy of the GNU General Public License + along with GPGME++; if not, write to the Free Software Foundation, + Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */ + +#ifdef HAVE_CONFIG_H +#include <config.h> +#endif + +#include <gpgmepp/context.h> +#include <gpgmepp/eventloopinteractor.h> +#include <gpgmepp/trustitem.h> +#include <gpgmepp/keylistresult.h> +#include <gpgmepp/keygenerationresult.h> +#include <gpgmepp/importresult.h> +#include <gpgmepp/decryptionresult.h> +#include <gpgmepp/verificationresult.h> +#include <gpgmepp/signingresult.h> +#include <gpgmepp/encryptionresult.h> +#include <gpgmepp/engineinfo.h> + +#include "callbacks.h" +#include "data_p.h" +#include "context_p.h" +#include "util.h" + +#include <gpgme.h> +#include <gpg-error.h> + +//#include <string> +//using std::string; +#include <istream> +#ifndef NDEBUG +#include <iostream> +using std::cerr; +using std::endl; +#endif + +#include <cassert> + +namespace GpgME { + + void initializeLibrary() { + gpgme_check_version( 0 ); + } + + const char * Error::source() const { + return gpgme_strsource( (gpgme_error_t)mErr ); + } + + const char * Error::asString() const { + return gpgme_strerror( (gpgme_error_t)mErr ); + } + + int Error::code() const { + return gpgme_err_code( mErr ); + } + + int Error::sourceID() const { + return gpgme_err_source( mErr ); + } + + bool Error::isCanceled() const { + return code() == GPG_ERR_CANCELED; + } + + std::ostream & operator<<( std::ostream & os, Error err ) { + return os << "GpgME::Error(" << err.operator int() << " (" << err.asString() << "))"; + } + + Context::Context( gpgme_ctx_t ctx ) { + d = new Private( ctx ); + } + + Context::~Context() { + delete d; d = 0; + } + + Context * Context::createForProtocol( Protocol proto ) { + gpgme_ctx_t ctx = 0; + if ( gpgme_new ( &ctx ) != 0 ) + return 0; + + switch ( proto ) { + case OpenPGP: + if ( gpgme_set_protocol( ctx, GPGME_PROTOCOL_OpenPGP ) != 0 ) { + gpgme_release( ctx ); + return 0; + } + break; + case CMS: + if ( gpgme_set_protocol( ctx, GPGME_PROTOCOL_CMS ) != 0 ) { + gpgme_release( ctx ); + return 0; + } + break; + default: + return 0; + } + + return new Context( ctx ); + } + + // + // + // Context attributes: + // + // + + Context::Protocol Context::protocol() const { + gpgme_protocol_t p = gpgme_get_protocol( d->ctx ); + switch ( p ) { + case GPGME_PROTOCOL_OpenPGP: return OpenPGP; + case GPGME_PROTOCOL_CMS: return CMS; + default: return Unknown; + } + } + + + void Context::setArmor( bool useArmor ) { + gpgme_set_armor( d->ctx, int( useArmor ) ); + } + bool Context::armor() const { + return gpgme_get_armor( d->ctx ); + } + + void Context::setTextMode( bool useTextMode ) { + gpgme_set_textmode( d->ctx, int( useTextMode ) ); + } + bool Context::textMode() const { + return gpgme_get_textmode( d->ctx ); + } + + void Context::setIncludeCertificates( int which ) { + if ( which == DefaultCertificates ) { +#ifdef HAVE_GPGME_INCLUDE_CERTS_DEFAULT + which = GPGME_INCLUDE_CERTS_DEFAULT; +#else + which = 1; +#endif + } + gpgme_set_include_certs( d->ctx, which ); + } + + int Context::includeCertificates() const { + return gpgme_get_include_certs( d->ctx ); + } + + void Context::setKeyListMode( unsigned int mode ) { + gpgme_set_keylist_mode( d->ctx, add_to_gpgme_keylist_mode_t( 0, mode ) ); + } + + void Context::addKeyListMode( unsigned int mode ) { + const unsigned int cur = gpgme_get_keylist_mode( d->ctx ); + gpgme_set_keylist_mode( d->ctx, add_to_gpgme_keylist_mode_t( cur, mode ) ); + } + + + unsigned int Context::keyListMode() const { + return convert_from_gpgme_keylist_mode_t( gpgme_get_keylist_mode( d->ctx ) ); + } + + void Context::setProgressProvider( ProgressProvider * provider ) { + gpgme_set_progress_cb( d->ctx, provider ? &progress_callback : 0, provider ); + } + ProgressProvider * Context::progressProvider() const { + void * pp = 0; + gpgme_progress_cb_t pcb = &progress_callback; + gpgme_get_progress_cb( d->ctx, &pcb, &pp ); + return static_cast<ProgressProvider*>( pp ); + } + + void Context::setPassphraseProvider( PassphraseProvider * provider ) { + gpgme_set_passphrase_cb( d->ctx, provider ? &passphrase_callback : 0, provider ); + } + + PassphraseProvider * Context::passphraseProvider() const { + void * pp = 0; + gpgme_passphrase_cb_t pcb = &passphrase_callback; + gpgme_get_passphrase_cb( d->ctx, &pcb, &pp ); + return static_cast<PassphraseProvider*>( pp ); + } + + void Context::setManagedByEventLoopInteractor( bool manage ) { + if ( !EventLoopInteractor::instance() ) { +#ifndef NDEBUG + cerr << "Context::setManagedByEventLoopInteractor(): " + "You must create an instance of EventLoopInteractor " + "before using anything that needs one." << endl; +#endif + return; + } + if ( manage ) + EventLoopInteractor::instance()->manage( this ); + else + EventLoopInteractor::instance()->unmanage( this ); + } + bool Context::managedByEventLoopInteractor() const { + return d->iocbs != 0; + } + + + void Context::installIOCallbacks( gpgme_io_cbs * iocbs ) { + if ( !iocbs ) { + uninstallIOCallbacks(); + return; + } + gpgme_set_io_cbs( d->ctx, iocbs ); + delete d->iocbs; d->iocbs = iocbs; + } + + void Context::uninstallIOCallbacks() { + static gpgme_io_cbs noiocbs = { 0, 0, 0, 0, 0 }; + // io.add == 0 means disable io callbacks: + gpgme_set_io_cbs( d->ctx, &noiocbs ); + delete d->iocbs; d->iocbs = 0; + } + + Error Context::setLocale( int cat, const char * val ) { + return d->lasterr = gpgme_set_locale( d->ctx, cat, val ); + } + + // + // + // Key Management + // + // + + Error Context::startKeyListing( const char * pattern, bool secretOnly ) { + d->lastop = Private::KeyList; + return d->lasterr = gpgme_op_keylist_start( d->ctx, pattern, int( secretOnly ) ); + } + + Error Context::startKeyListing( const char * patterns[], bool secretOnly ) { + d->lastop = Private::KeyList; + return d->lasterr = gpgme_op_keylist_ext_start( d->ctx, patterns, int( secretOnly ), 0 ); + } + + Key Context::nextKey( GpgME::Error & e ) { + d->lastop = Private::KeyList; + gpgme_key_t key; + e = d->lasterr = gpgme_op_keylist_next( d->ctx, &key ); + return Key( key, false, keyListMode() ); + } + + KeyListResult Context::endKeyListing() { + d->lasterr = gpgme_op_keylist_end( d->ctx ); + return keyListResult(); + } + + KeyListResult Context::keyListResult() const { + return KeyListResult( d->ctx, d->lasterr ); + } + + Key Context::key( const char * fingerprint, GpgME::Error & e , bool secret /*, bool forceUpdate*/ ) { + d->lastop = Private::KeyList; + gpgme_key_t key; + e = d->lasterr = gpgme_get_key( d->ctx, fingerprint, &key, int( secret )/*, int( forceUpdate )*/ ); + return Key( key, false, keyListMode() ); + } + + KeyGenerationResult Context::generateKey( const char * parameters, Data & pubKey ) { + d->lastop = Private::KeyGen; + Data::Private * dp = pubKey.impl(); + d->lasterr = gpgme_op_genkey( d->ctx, parameters, dp ? dp->data : 0, 0 ); + return KeyGenerationResult( d->ctx, d->lasterr ); + } + + Error Context::startKeyGeneration( const char * parameters, Data & pubKey ) { + d->lastop = Private::KeyGen; + Data::Private * dp = pubKey.impl(); + return d->lasterr = gpgme_op_genkey_start( d->ctx, parameters, dp ? dp->data : 0, 0 ); + } + + KeyGenerationResult Context::keyGenerationResult() const { + if ( d->lastop & Private::KeyGen ) + return KeyGenerationResult( d->ctx, d->lasterr ); + else + return KeyGenerationResult(); + } + + Error Context::exportPublicKeys( const char * pattern, Data & keyData ) { + d->lastop = Private::Export; + Data::Private * dp = keyData.impl(); + return d->lasterr = gpgme_op_export( d->ctx, pattern, 0, dp ? dp->data : 0 ); + } + + Error Context::exportPublicKeys( const char * patterns[], Data & keyData ) { + d->lastop = Private::Export; + Data::Private * dp = keyData.impl(); + return d->lasterr = gpgme_op_export_ext( d->ctx, patterns, 0, dp ? dp->data : 0 ); + } + + Error Context::startPublicKeyExport( const char * pattern, Data & keyData ) { + d->lastop = Private::Export; + Data::Private * dp = keyData.impl(); + return d->lasterr = gpgme_op_export_start( d->ctx, pattern, 0, dp ? dp->data : 0 ); + } + + Error Context::startPublicKeyExport( const char * patterns[], Data & keyData ) { + d->lastop = Private::Export; + Data::Private * dp = keyData.impl(); + return d->lasterr = gpgme_op_export_ext_start( d->ctx, patterns, 0, dp ? dp->data : 0 ); + } + + + ImportResult Context::importKeys( const Data & data ) { + d->lastop = Private::Import; + Data::Private * dp = data.impl(); + d->lasterr = gpgme_op_import( d->ctx, dp ? dp->data : 0 ); + return ImportResult( d->ctx, d->lasterr ); + } + + Error Context::startKeyImport( const Data & data ) { + d->lastop = Private::Import; + Data::Private * dp = data.impl(); + return d->lasterr = gpgme_op_import_start( d->ctx, dp ? dp->data : 0 ); + } + + ImportResult Context::importResult() const { + if ( d->lastop & Private::Import ) + return ImportResult( d->ctx, d->lasterr ); + else + return ImportResult(); + } + + Error Context::deleteKey( const Key & key, bool allowSecretKeyDeletion ) { + d->lastop = Private::Delete; + return d->lasterr = gpgme_op_delete( d->ctx, key.impl(), int( allowSecretKeyDeletion ) ); + } + + Error Context::startKeyDeletion( const Key & key, bool allowSecretKeyDeletion ) { + d->lastop = Private::Delete; + return d->lasterr = gpgme_op_delete_start( d->ctx, key.impl(), int( allowSecretKeyDeletion ) ); + } + + Error Context::startTrustItemListing( const char * pattern, int maxLevel ) { + d->lastop = Private::TrustList; + return d->lasterr = gpgme_op_trustlist_start( d->ctx, pattern, maxLevel ); + } + + TrustItem Context::nextTrustItem( Error & e ) { + gpgme_trust_item_t ti = 0; + e = d->lasterr = gpgme_op_trustlist_next( d->ctx, &ti ); + return ti; + } + + Error Context::endTrustItemListing() { + return d->lasterr = gpgme_op_trustlist_end( d->ctx ); + } + + DecryptionResult Context::decrypt( const Data & cipherText, Data & plainText ) { + d->lastop = Private::Decrypt; + Data::Private * cdp = cipherText.impl(); + Data::Private * pdp = plainText.impl(); + d->lasterr = gpgme_op_decrypt( d->ctx, cdp ? cdp->data : 0, pdp ? pdp->data : 0 ); + return DecryptionResult( d->ctx, d->lasterr ); + } + + Error Context::startDecryption( const Data & cipherText, Data & plainText ) { + d->lastop = Private::Decrypt; + Data::Private * cdp = cipherText.impl(); + Data::Private * pdp = plainText.impl(); + return d->lasterr = gpgme_op_decrypt_start( d->ctx, cdp ? cdp->data : 0, pdp ? pdp->data : 0 ); + } + + DecryptionResult Context::decryptionResult() const { + if ( d->lastop & Private::Decrypt ) + return DecryptionResult( d->ctx, d->lasterr ); + else + return DecryptionResult(); + } + + + + VerificationResult Context::verifyDetachedSignature( const Data & signature, const Data & signedText ) { + d->lastop = Private::Verify; + Data::Private * sdp = signature.impl(); + Data::Private * tdp = signedText.impl(); + d->lasterr = gpgme_op_verify( d->ctx, sdp ? sdp->data : 0, tdp ? tdp->data : 0, 0 ); + return VerificationResult( d->ctx, d->lasterr ); + } + + VerificationResult Context::verifyOpaqueSignature( const Data & signedData, Data & plainText ) { + d->lastop = Private::Verify; + Data::Private * sdp = signedData.impl(); + Data::Private * pdp = plainText.impl(); + d->lasterr = gpgme_op_verify( d->ctx, sdp ? sdp->data : 0, 0, pdp ? pdp->data : 0 ); + return VerificationResult( d->ctx, d->lasterr ); + } + + Error Context::startDetachedSignatureVerification( const Data & signature, const Data & signedText ) { + d->lastop = Private::Verify; + Data::Private * sdp = signature.impl(); + Data::Private * tdp = signedText.impl(); + return d->lasterr = gpgme_op_verify_start( d->ctx, sdp ? sdp->data : 0, tdp ? tdp->data : 0, 0 ); + } + + Error Context::startOpaqueSignatureVerification( const Data & signedData, Data & plainText ) { + d->lastop = Private::Verify; + Data::Private * sdp = signedData.impl(); + Data::Private * pdp = plainText.impl(); + return d->lasterr = gpgme_op_verify_start( d->ctx, sdp ? sdp->data : 0, 0, pdp ? pdp->data : 0 ); + } + + VerificationResult Context::verificationResult() const { + if ( d->lastop & Private::Verify ) + return VerificationResult( d->ctx, d->lasterr ); + else + return VerificationResult(); + } + + + std::pair<DecryptionResult,VerificationResult> Context::decryptAndVerify( const Data & cipherText, Data & plainText ) { + d->lastop = Private::DecryptAndVerify; + Data::Private * cdp = cipherText.impl(); + Data::Private * pdp = plainText.impl(); + d->lasterr = gpgme_op_decrypt_verify( d->ctx, cdp ? cdp->data : 0, pdp ? pdp->data : 0 ); + return std::make_pair( DecryptionResult( d->ctx, d->lasterr ), + VerificationResult( d->ctx, d->lasterr ) ); + } + + Error Context::startCombinedDecryptionAndVerification( const Data & cipherText, Data & plainText ) { + d->lastop = Private::DecryptAndVerify; + Data::Private * cdp = cipherText.impl(); + Data::Private * pdp = plainText.impl(); + return d->lasterr = gpgme_op_decrypt_verify_start( d->ctx, cdp ? cdp->data : 0, pdp ? pdp->data : 0 ); + } + +#ifdef HAVE_GPGME_OP_GETAUDITLOG + unsigned int to_auditlog_flags( unsigned int flags ) { + unsigned int result = 0; + if ( flags & Context::HtmlAuditLog ) + result |= GPGME_AUDITLOG_HTML; + if ( flags & Context::AuditLogWithHelp ) + result |= GPGME_AUDITLOG_WITH_HELP; + return result; + } +#endif // HAVE_GPGME_OP_GETAUDITLOG + + + Error Context::startGetAuditLog( Data & output, unsigned int flags ) { + d->lastop = Private::GetAuditLog; +#ifdef HAVE_GPGME_OP_GETAUDITLOG + Data::Private * const odp = output.impl(); + return Error( d->lasterr = gpgme_op_getauditlog_start( d->ctx, odp ? odp->data : 0, to_auditlog_flags( flags ) ) ); +#else + (void)output; (void)flags; + return Error( d->lasterr = gpg_error( GPG_ERR_NOT_IMPLEMENTED ) ); +#endif + } + + Error Context::getAuditLog( Data & output, unsigned int flags ) { + d->lastop = Private::GetAuditLog; +#ifdef HAVE_GPGME_OP_GETAUDITLOG + Data::Private * const odp = output.impl(); + return Error( d->lasterr = gpgme_op_getauditlog( d->ctx, odp ? odp->data : 0, to_auditlog_flags( flags ) ) ); +#else + (void)output; (void)flags; + return Error( d->lasterr = gpg_error( GPG_ERR_NOT_IMPLEMENTED ) ); +#endif + } + + void Context::clearSigningKeys() { + gpgme_signers_clear( d->ctx ); + } + + Error Context::addSigningKey( const Key & key ) { + return d->lasterr = gpgme_signers_add( d->ctx, key.impl() ); + } + + Key Context::signingKey( unsigned int idx ) const { + gpgme_key_t key = gpgme_signers_enum( d->ctx, idx ); + return Key( key, false, keyListMode() ); + } + + + static gpgme_sig_mode_t sigmode2sigmode( Context::SignatureMode mode ) { + switch ( mode ) { + default: + case Context::Normal: return GPGME_SIG_MODE_NORMAL; + case Context::Detached: return GPGME_SIG_MODE_DETACH; + case Context::Clearsigned: return GPGME_SIG_MODE_CLEAR; + } + } + + SigningResult Context::sign( const Data & plainText, Data & signature, SignatureMode mode ) { + d->lastop = Private::Sign; + Data::Private * pdp = plainText.impl(); + Data::Private * sdp = signature.impl(); + d->lasterr = gpgme_op_sign( d->ctx, pdp ? pdp->data : 0, sdp ? sdp->data : 0, sigmode2sigmode( mode ) ); + return SigningResult( d->ctx, d->lasterr ); + } + + + Error Context::startSigning( const Data & plainText, Data & signature, SignatureMode mode ) { + d->lastop = Private::Sign; + Data::Private * pdp = plainText.impl(); + Data::Private * sdp = signature.impl(); + return d->lasterr = gpgme_op_sign_start( d->ctx, pdp ? pdp->data : 0, sdp ? sdp->data : 0, sigmode2sigmode( mode ) ); + } + + SigningResult Context::signingResult() const { + if ( d->lastop & Private::Sign ) + return SigningResult( d->ctx, d->lasterr ); + else + return SigningResult(); + } + + + EncryptionResult Context::encrypt( const std::vector<Key> & recipients, const Data & plainText, Data & cipherText, EncryptionFlags flags ) { + d->lastop = Private::Encrypt; + Data::Private * pdp = plainText.impl(); + Data::Private * cdp = cipherText.impl(); + gpgme_key_t * keys = new gpgme_key_t[ recipients.size() + 1 ]; + gpgme_key_t * keys_it = keys; + for ( std::vector<Key>::const_iterator it = recipients.begin() ; it != recipients.end() ; ++it ) + if ( it->impl() ) + *keys_it++ = it->impl(); + *keys_it++ = 0; + d->lasterr = gpgme_op_encrypt( d->ctx, keys, + flags & AlwaysTrust ? GPGME_ENCRYPT_ALWAYS_TRUST : (gpgme_encrypt_flags_t)0, + pdp ? pdp->data : 0, cdp ? cdp->data : 0 ); + delete[] keys; + return EncryptionResult( d->ctx, d->lasterr ); + } + + Error Context::encryptSymmetrically( const Data & plainText, Data & cipherText ) { + d->lastop = Private::Encrypt; + Data::Private * pdp = plainText.impl(); + Data::Private * cdp = cipherText.impl(); + return d->lasterr = gpgme_op_encrypt( d->ctx, 0, (gpgme_encrypt_flags_t)0, + pdp ? pdp->data : 0, cdp ? cdp->data : 0 ); + } + + Error Context::startEncryption( const std::vector<Key> & recipients, const Data & plainText, Data & cipherText, EncryptionFlags flags ) { + d->lastop = Private::Encrypt; + Data::Private * pdp = plainText.impl(); + Data::Private * cdp = cipherText.impl(); + gpgme_key_t * keys = new gpgme_key_t[ recipients.size() + 1 ]; + gpgme_key_t * keys_it = keys; + for ( std::vector<Key>::const_iterator it = recipients.begin() ; it != recipients.end() ; ++it ) + if ( it->impl() ) + *keys_it++ = it->impl(); + *keys_it++ = 0; + d->lasterr = gpgme_op_encrypt_start( d->ctx, keys, + flags & AlwaysTrust ? GPGME_ENCRYPT_ALWAYS_TRUST : (gpgme_encrypt_flags_t)0, + pdp ? pdp->data : 0, cdp ? cdp->data : 0 ); + delete[] keys; + return d->lasterr; + } + + EncryptionResult Context::encryptionResult() const { + if ( d->lastop & Private::Encrypt ) + return EncryptionResult( d->ctx, d->lasterr ); + else + return EncryptionResult(); + } + + std::pair<SigningResult,EncryptionResult> Context::signAndEncrypt( const std::vector<Key> & recipients, const Data & plainText, Data & cipherText, EncryptionFlags flags ) { + d->lastop = Private::SignAndEncrypt; + Data::Private * pdp = plainText.impl(); + Data::Private * cdp = cipherText.impl(); + gpgme_key_t * keys = new gpgme_key_t[ recipients.size() + 1 ]; + gpgme_key_t * keys_it = keys; + for ( std::vector<Key>::const_iterator it = recipients.begin() ; it != recipients.end() ; ++it ) + if ( it->impl() ) + *keys_it++ = it->impl(); + *keys_it++ = 0; + d->lasterr = gpgme_op_encrypt_sign( d->ctx, keys, + flags & AlwaysTrust ? GPGME_ENCRYPT_ALWAYS_TRUST : (gpgme_encrypt_flags_t)0, + pdp ? pdp->data : 0, cdp ? cdp->data : 0 ); + delete[] keys; + return std::make_pair( SigningResult( d->ctx, d->lasterr ), + EncryptionResult( d->ctx, d->lasterr ) ); + } + + Error Context::startCombinedSigningAndEncryption( const std::vector<Key> & recipients, const Data & plainText, Data & cipherText, EncryptionFlags flags ) { + d->lastop = Private::SignAndEncrypt; + Data::Private * pdp = plainText.impl(); + Data::Private * cdp = cipherText.impl(); + gpgme_key_t * keys = new gpgme_key_t[ recipients.size() + 1 ]; + gpgme_key_t * keys_it = keys; + for ( std::vector<Key>::const_iterator it = recipients.begin() ; it != recipients.end() ; ++it ) + if ( it->impl() ) + *keys_it++ = it->impl(); + *keys_it++ = 0; + d->lasterr = gpgme_op_encrypt_sign_start( d->ctx, keys, + flags & AlwaysTrust ? GPGME_ENCRYPT_ALWAYS_TRUST : (gpgme_encrypt_flags_t)0, + pdp ? pdp->data : 0, cdp ? cdp->data : 0 ); + delete[] keys; + return d->lasterr; + } + + + Error Context::cancelPendingOperation() { +#ifdef HAVE_GPGME_CANCEL + return gpgme_cancel( d->ctx ); +#else + return 0; +#endif + } + + bool Context::poll() { + gpgme_error_t e = GPG_ERR_NO_ERROR; + const bool finished = gpgme_wait( d->ctx, &e, 0 ); + if ( finished ) + d->lasterr = e; + return finished; + } + + Error Context::wait() { + gpgme_error_t e = GPG_ERR_NO_ERROR; + gpgme_wait( d->ctx, &e, 1 ); + return d->lasterr = e; + } + + Error Context::lastError() const { + return d->lasterr; + } + + std::ostream & operator<<( std::ostream & os, Context::Protocol proto ) { + os << "GpgME::Context::Protocol("; + switch ( proto ) { + case Context::OpenPGP: + os << "OpenPGP"; + break; + case Context::CMS: + os << "CMS"; + break; + default: + case Context::Unknown: + os << "Unknown"; + break; + } + return os << ')'; + } + + std::ostream & operator<<( std::ostream & os, Context::CertificateInclusion incl ) { + os << "GpgME::Context::CertificateInclusion(" << static_cast<int>( incl ); + switch ( incl ) { + case Context::DefaultCertificates: + os << "(DefaultCertificates)"; + break; + case Context::AllCertificatesExceptRoot: + os << "(AllCertificatesExceptRoot)"; + break; + case Context::AllCertificates: + os << "(AllCertificates)"; + break; + case Context::NoCertificates: + os << "(NoCertificates)"; + break; + case Context::OnlySenderCertificate: + os << "(OnlySenderCertificate)"; + break; + } + return os << ')'; + } + + std::ostream & operator<<( std::ostream & os, Context::KeyListMode mode ) { + os << "GpgME::Context::KeyListMode("; +#define CHECK( x ) if ( !(mode & (Context::x)) ) {} else do { os << #x " "; } while (0) + CHECK( Local ); + CHECK( Extern ); + CHECK( Signatures ); + CHECK( Validate ); +#undef CHECK + return os << ')'; + } + + std::ostream & operator<<( std::ostream & os, Context::SignatureMode mode ) { + os << "GpgME::Context::SignatureMode("; + switch ( mode ) { +#define CHECK( x ) case Context::x: os << #x; break + CHECK( Normal ); + CHECK( Detached ); + CHECK( Clearsigned ); +#undef CHECK + default: + os << "???" "(" << static_cast<int>( mode ) << ')'; + break; + } + return os << ')'; + } + + std::ostream & operator<<( std::ostream & os, Context::EncryptionFlags flags ) { + os << "GpgME::Context::EncryptionFlags("; +#define CHECK( x ) if ( !(flags & (Context::x)) ) {} else do { os << #x " "; } while (0) + CHECK( AlwaysTrust ); +#undef CHECK + return os << ')'; + } + + std::ostream & operator<<( std::ostream & os, Context::AuditLogFlags flags ) { + os << "GpgME::Context::AuditLogFlags("; +#define CHECK( x ) if ( !(flags & (Context::x)) ) {} else do { os << #x " "; } while (0) + CHECK( HtmlAuditLog ); + CHECK( AuditLogWithHelp ); +#undef CHECK + return os << ')'; + } + + + +} // namespace GpgME + +GpgME::Error GpgME::setDefaultLocale( int cat, const char * val ) { + return gpgme_set_locale( 0, cat, val ); +} + +GpgME::EngineInfo GpgME::engineInfo( Context::Protocol proto ) { + gpgme_engine_info_t ei = 0; + if ( gpgme_get_engine_info( &ei ) ) + return EngineInfo(); + + gpgme_protocol_t p = proto == Context::CMS ? GPGME_PROTOCOL_CMS : GPGME_PROTOCOL_OpenPGP ; + + for ( gpgme_engine_info_t i = ei ; i ; i = i->next ) + if ( i->protocol == p ) + return EngineInfo( i ); + + return EngineInfo(); +} + +GpgME::Error GpgME::checkEngine( Context::Protocol proto ) { + gpgme_protocol_t p = proto == Context::CMS ? GPGME_PROTOCOL_CMS : GPGME_PROTOCOL_OpenPGP ; + + return gpgme_engine_check_version( p ); +} + +static const unsigned long supported_features = 0 +#ifdef HAVE_GPGME_KEYLIST_MODE_VALIDATE + | GpgME::ValidatingKeylistModeFeature +#endif +#ifdef HAVE_GPGME_CANCEL + | GpgME::CancelOperationFeature +#endif +#ifdef HAVE_GPGME_WRONG_KEY_USAGE + | GpgME::WrongKeyUsageFeature +#endif +#ifdef HAVE_GPGME_OP_GETAUDITLOG + | GpgME::AuditLogFeature +#endif + ; + +bool GpgME::hasFeature( unsigned long features ) { + return features == ( features & supported_features ); +} diff --git a/libtdenetwork/gpgmepp/context.h b/libtdenetwork/gpgmepp/context.h new file mode 100644 index 00000000..054f8bee --- /dev/null +++ b/libtdenetwork/gpgmepp/context.h @@ -0,0 +1,328 @@ +/* context.h - wraps a gpgme key context + Copyright (C) 2003 Klarälvdalens Datakonsult AB + + This file is part of GPGME++. + + GPGME++ is free software; you can redistribute it and/or modify it + under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + GPGME++ is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + General Public License for more details. + + You should have received a copy of the GNU General Public License + along with GPGME++; if not, write to the Free Software Foundation, + Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */ + +// -*- c++ -*- +#ifndef __GPGMEPP_CONTEXT_H__ +#define __GPGMEPP_CONTEXT_H__ + +#include <gpgmepp/gpgmefw.h> + +#include <vector> +#include <utility> +#include <iosfwd> + +#include <tdepimmacros.h> + +namespace GpgME { + + class Key; + class Data; + class TrustItem; + class ProgressProvider; + class PassphraseProvider; + class EventLoopInteractor; + + class KeyListResult; + class KeyGenerationResult; + class ImportResult; + class DecryptionResult; + class VerificationResult; + class SigningResult; + class EncryptionResult; + + class EngineInfo; + + class KDE_EXPORT Error { + public: + Error( int e=0 ) : mErr( e ) {} + + const char * source() const; + const char * asString() const; + + int code() const; + int sourceID() const; + + bool isCanceled() const; + + operator int() const { return mErr; } + operator bool() const { return mErr && !isCanceled(); } + private: + int mErr; + }; + + KDE_EXPORT std::ostream & operator<<( std::ostream & os, Error err ); + + class KDE_EXPORT Context { + Context( gpgme_ctx_t ); + public: + enum Protocol { OpenPGP, CMS, Unknown }; + + // + // Creation and destruction: + // + + static Context * createForProtocol( Protocol proto ); + virtual ~Context(); + + // + // Context Attributes + // + + Protocol protocol() const; + + void setArmor( bool useArmor ); + bool armor() const; + + void setTextMode( bool useTextMode ); + bool textMode() const; + + enum CertificateInclusion { + DefaultCertificates = -256, + AllCertificatesExceptRoot = -2, + AllCertificates = -1, + NoCertificates = 0, + OnlySenderCertificate = 1 + }; + void setIncludeCertificates( int which ); + int includeCertificates() const; + + enum KeyListMode { + Local = 0x1, + Extern = 0x2, + Signatures = 0x4, + Validate = 0x10 + }; + void setKeyListMode( unsigned int keyListMode ); + void addKeyListMode( unsigned int keyListMode ); + unsigned int keyListMode() const; + + void setPassphraseProvider( PassphraseProvider * provider ); + PassphraseProvider * passphraseProvider() const; + + void setProgressProvider( ProgressProvider * provider ); + ProgressProvider * progressProvider() const; + + void setManagedByEventLoopInteractor( bool managed ); + bool managedByEventLoopInteractor() const; + + GpgME::Error setLocale( int category, const char * value ); + + private: + friend class EventLoopInteractor; + void installIOCallbacks( gpgme_io_cbs * iocbs ); + void uninstallIOCallbacks(); + + public: + // + // + // Key Management + // + // + + // + // Key Listing + // + + GpgME::Error startKeyListing( const char * pattern=0, bool secretOnly=false ); + GpgME::Error startKeyListing( const char * patterns[], bool secretOnly=false ); + + Key nextKey( GpgME::Error & e ); + + KeyListResult endKeyListing(); + KeyListResult keyListResult() const; + + Key key( const char * fingerprint, GpgME::Error & e, bool secret=false ); + + // + // Key Generation + // + + KeyGenerationResult generateKey( const char * parameters, Data & pubKey ); + GpgME::Error startKeyGeneration( const char * parameters, Data & pubkey ); + KeyGenerationResult keyGenerationResult() const; + + // + // Key Export + // + + GpgME::Error exportPublicKeys( const char * pattern, Data & keyData ); + GpgME::Error exportPublicKeys( const char * pattern[], Data & keyData ); + GpgME::Error startPublicKeyExport( const char * pattern, Data & keyData ); + GpgME::Error startPublicKeyExport( const char * pattern[], Data & keyData ); + + // + // Key Import + // + + ImportResult importKeys( const Data & data ); + GpgME::Error startKeyImport( const Data & data ); + ImportResult importResult() const; + + // + // Key Deletion + // + + GpgME::Error deleteKey( const Key & key, bool allowSecretKeyDeletion=false ); + GpgME::Error startKeyDeletion( const Key & key, bool allowSecretKeyDeletion=false ); + + // + // Trust Item Management + // + + GpgME::Error startTrustItemListing( const char * pattern, int maxLevel ); + TrustItem nextTrustItem( GpgME::Error & e ); + GpgME::Error endTrustItemListing(); + + // + // + // Crypto Operations + // + // + + // + // Decryption + // + + DecryptionResult decrypt( const Data & cipherText, Data & plainText ); + GpgME::Error startDecryption( const Data & cipherText, Data & plainText ); + DecryptionResult decryptionResult() const; + + // + // Signature Verification + // + + VerificationResult verifyDetachedSignature( const Data & signature, const Data & signedText ); + VerificationResult verifyOpaqueSignature( const Data & signedData, Data & plainText ); + GpgME::Error startDetachedSignatureVerification( const Data & signature, const Data & signedText ); + GpgME::Error startOpaqueSignatureVerification( const Data & signedData, Data & plainText ); + VerificationResult verificationResult() const; + + // + // Combined Decryption and Signature Verification + // + + std::pair<DecryptionResult,VerificationResult> decryptAndVerify( const Data & cipherText, Data & plainText ); + GpgME::Error startCombinedDecryptionAndVerification( const Data & cipherText, Data & plainText ); + // use verificationResult() and decryptionResult() to retrieve the result objects... + + // + // Signing + // + + void clearSigningKeys(); + GpgME::Error addSigningKey( const Key & signer ); + Key signingKey( unsigned int index ) const; + + enum SignatureMode { Normal, Detached, Clearsigned }; + SigningResult sign( const Data & plainText, Data & signature, SignatureMode mode ); + GpgME::Error startSigning( const Data & plainText, Data & signature, SignatureMode mode ); + SigningResult signingResult() const; + + // + // Encryption + // + + enum EncryptionFlags { None=0, AlwaysTrust=1 }; + EncryptionResult encrypt( const std::vector<Key> & recipients, const Data & plainText, Data & cipherText, EncryptionFlags flags ); + GpgME::Error encryptSymmetrically( const Data & plainText, Data & cipherText ); + GpgME::Error startEncryption( const std::vector<Key> & recipients, const Data & plainText, Data & cipherText, EncryptionFlags flags ); + EncryptionResult encryptionResult() const; + + // + // Combined Signing and Encryption + // + + std::pair<SigningResult,EncryptionResult> signAndEncrypt( const std::vector<Key> & recipients, const Data & plainText, Data & cipherText, EncryptionFlags flags ); + GpgME::Error startCombinedSigningAndEncryption( const std::vector<Key> & recipients, const Data & plainText, Data & cipherText, EncryptionFlags flags ); + // use encryptionResult() and signingResult() to retrieve the result objects... + + // + // + // Audit Log + // + // + enum AuditLogFlags { + HtmlAuditLog = 1, + AuditLogWithHelp = 128 + }; + GpgME::Error startGetAuditLog( Data & output, unsigned int flags=0 ); + GpgME::Error getAuditLog( Data & output, unsigned int flags=0 ); + + // + // + // Run Control + // + // + + bool poll(); + GpgME::Error wait(); + GpgME::Error lastError() const; + GpgME::Error cancelPendingOperation(); + + class Private; + Private * impl() const { return d; } + private: + Private * d; + + private: // disable... + Context( const Context & ); + const Context & operator=( const Context & ); + }; + + KDE_EXPORT std::ostream & operator<<( std::ostream & os, Context::Protocol proto ); + KDE_EXPORT std::ostream & operator<<( std::ostream & os, Context::CertificateInclusion incl ); + KDE_EXPORT std::ostream & operator<<( std::ostream & os, Context::KeyListMode mode ); + KDE_EXPORT std::ostream & operator<<( std::ostream & os, Context::SignatureMode mode ); + KDE_EXPORT std::ostream & operator<<( std::ostream & os, Context::EncryptionFlags flags ); + KDE_EXPORT std::ostream & operator<<( std::ostream & os, Context::AuditLogFlags flags ); + + // + // + // Globals + // + // + + KDE_EXPORT void initializeLibrary(); + + KDE_EXPORT GpgME::Error setDefaultLocale( int category, const char * value ); + + KDE_EXPORT Context * wait( GpgME::Error & e, bool hang=true ); + typedef void (*IdleFunction)(void); + KDE_EXPORT IdleFunction registerIdleFunction( IdleFunction idleFunction ); + + typedef void (*IOCallback)( void * data, int fd ); + + KDE_EXPORT EngineInfo engineInfo( Context::Protocol proto ); + + KDE_EXPORT GpgME::Error checkEngine( Context::Protocol proto ); + + enum Feature { + ValidatingKeylistModeFeature = 0x00000001, + CancelOperationFeature = 0x00000002, + WrongKeyUsageFeature = 0x00000004, + + AuditLogFeature = 0x00001000, + + FeatureMaxValue = 0x80000000 + }; + KDE_EXPORT bool hasFeature( unsigned long feature ); + +} // namespace GpgME + +#endif // __GPGMEPP_CONTEXT_H__ diff --git a/libtdenetwork/gpgmepp/context_p.h b/libtdenetwork/gpgmepp/context_p.h new file mode 100644 index 00000000..dfff5863 --- /dev/null +++ b/libtdenetwork/gpgmepp/context_p.h @@ -0,0 +1,76 @@ +/* context_p.h - wraps a gpgme key context (private part) + Copyright (C) 2003 Klarälvdalens Datakonsult AB + + This file is part of GPGME++. + + GPGME++ is free software; you can redistribute it and/or modify it + under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + GPGME++ is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + General Public License for more details. + + You should have received a copy of the GNU General Public License + along with GPGME; if not, write to the Free Software Foundation, + Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */ + + +// -*- c++ -*- +#ifndef __GPGMEPP_CONTEXT_P_H__ +#define __GPGMEPP_CONTEXT_P_H__ + +#include <gpgmepp/context.h> + +#include <gpgme.h> + +namespace GpgME { + + + struct Context::Private { + enum Operation { + None = 0, + + Encrypt = 0x001, + Decrypt = 0x002, + Sign = 0x004, + Verify = 0x008, + DecryptAndVerify = Decrypt|Verify, + SignAndEncrypt = Sign|Encrypt, + + Import = 0x010, + Export = 0x020, // no gpgme_export_result_t, but nevertheless... + Delete = 0x040, // no gpgme_delete_result_t, but nevertheless... + + KeyGen = 0x080, + KeyList = 0x100, + TrustList = 0x200, // gpgme_trustlist_result_t, but nevertheless... + + GetAuditLog = 0x1000 // no gpgme_getauditlog_result_t, but nevertheless... + }; + + Private( gpgme_ctx_t c=0 ) + : ctx( c ), + iocbs( 0 ), + lastop( None ), + lasterr( GPG_ERR_NO_ERROR ) {} + ~Private() { + if ( ctx ) { + gpgme_release( ctx ); + ctx = 0; + } + delete iocbs; + } + + gpgme_ctx_t ctx; + gpgme_io_cbs * iocbs; + //EditInteractor * edit; + Operation lastop; + gpgme_error_t lasterr; + }; + +} // namespace GpgME + +#endif // __GPGMEPP_CONTEXT_P_H__ diff --git a/libtdenetwork/gpgmepp/data.cpp b/libtdenetwork/gpgmepp/data.cpp new file mode 100644 index 00000000..52471be9 --- /dev/null +++ b/libtdenetwork/gpgmepp/data.cpp @@ -0,0 +1,160 @@ +/* data.cpp - wraps a gpgme data object + Copyright (C) 2003 Klarälvdalens Datakonsult AB + + This file is part of GPGME++. + + GPGME++ is free software; you can redistribute it and/or modify it + under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + GPGME++ is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + General Public License for more details. + + You should have received a copy of the GNU General Public License + along with GPGME++; if not, write to the Free Software Foundation, + Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. +*/ + +#ifdef HAVE_CONFIG_H +#include <config.h> +#endif + +#include <gpgmepp/context.h> // Error +#include <gpgmepp/interfaces/dataprovider.h> +#include "data_p.h" + +#include <gpgme.h> + +#ifndef NDEBUG +#include <iostream> +#endif + +GpgME::Data::Private::~Private() { + if ( data ) + gpgme_data_release( data ); +} + +GpgME::Data GpgME::Data::null( (gpgme_data_t)0 ); + +GpgME::Data::Data() { + gpgme_data_t data; + const gpgme_error_t e = gpgme_data_new( &data ); + d = new Private( e ? 0 : data ); + d->ref(); +} + +GpgME::Data::Data( gpgme_data_t data ) { + d = new Private( data ); + d->ref(); +} + +GpgME::Data::Data( const Data & other ) + : d( other.d ) +{ + d->ref(); +} + +GpgME::Data::~Data() { + d->unref(); d = 0; +} + + +const GpgME::Data & GpgME::Data::operator=( const Data & other ) { + if ( this->d == other.d ) return *this; + + if ( other.d ) + other.d->ref(); + if ( this->d ) + this->d->unref(); + this->d = other.d; + + return *this; +} + +GpgME::Data::Data( const char * buffer, size_t size, bool copy ) { + gpgme_data_t data; + const gpgme_error_t e = gpgme_data_new_from_mem( &data, buffer, size, int( copy ) ); + d = new Private( e ? 0 : data ); + d->ref(); +} + +GpgME::Data::Data( const char * filename ) { + gpgme_data_t data; + const gpgme_error_t e = gpgme_data_new_from_file( &data, filename, 1 ); + d = new Private( e ? 0 : data ); + d->ref(); +} + +GpgME::Data::Data( const char * filename, off_t offset, size_t length ) { + gpgme_data_t data; + const gpgme_error_t e = gpgme_data_new_from_filepart( &data, filename, 0, offset, length ); + d = new Private( e ? 0 : data ); + d->ref(); +} + +GpgME::Data::Data( FILE * fp ) { + gpgme_data_t data; + const gpgme_error_t e = gpgme_data_new_from_stream( &data, fp ); + d = new Private( e ? 0 : data ); + d->ref(); +} + +GpgME::Data::Data( FILE * fp, off_t offset, size_t length ) { + gpgme_data_t data; + const gpgme_error_t e = gpgme_data_new_from_filepart( &data, 0, fp, offset, length ); + d = new Private( e ? 0 : data ); + d->ref(); +} + +GpgME::Data::Data( int fd ) { + gpgme_data_t data; + const gpgme_error_t e = gpgme_data_new_from_fd( &data, fd ); + d = new Private( e ? 0 : data ); + d->ref(); +} + +GpgME::Data::Data( DataProvider * dp ) { + d = new Private(); + d->ref(); + if ( !dp ) + return; + if ( !dp->isSupported( DataProvider::Read ) ) + d->cbs.read = 0; + if ( !dp->isSupported( DataProvider::Write ) ) + d->cbs.write = 0; + if ( !dp->isSupported( DataProvider::Seek ) ) + d->cbs.seek = 0; + if ( !dp->isSupported( DataProvider::Release ) ) + d->cbs.release = 0; + const gpgme_error_t e = gpgme_data_new_from_cbs( &d->data, &d->cbs, dp ); + if ( e ) + d->data = 0; +#ifndef NDEBUG +// std::cerr << "GpgME::Data(): DataProvider supports: " +// << ( d->cbs.read ? "read" : "no read" ) << ", " +// << ( d->cbs.write ? "write" : "no write" ) << ", " +// << ( d->cbs.seek ? "seek" : "no seek" ) << ", " +// << ( d->cbs.release ? "release" : "no release" ) << std::endl; +#endif +} + + + +bool GpgME::Data::isNull() const { + return !d || !d->data; +} + +ssize_t GpgME::Data::read( void * buffer, size_t length ) { + return gpgme_data_read( d->data, buffer, length ); +} + +ssize_t GpgME::Data::write( const void * buffer, size_t length ) { + return gpgme_data_write( d->data, buffer, length ); +} + +off_t GpgME::Data::seek( off_t offset, int whence ) { + return gpgme_data_seek( d->data, offset, whence ); +} diff --git a/libtdenetwork/gpgmepp/data.h b/libtdenetwork/gpgmepp/data.h new file mode 100644 index 00000000..e1206472 --- /dev/null +++ b/libtdenetwork/gpgmepp/data.h @@ -0,0 +1,72 @@ +/* data.h - wraps a gpgme data object + Copyright (C) 2003,2004 Klarälvdalens Datakonsult AB + + This file is part of GPGME++. + + GPGME++ is free software; you can redistribute it and/or modify it + under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + GPGME++ is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + General Public License for more details. + + You should have received a copy of the GNU General Public License + along with GPGME++; if not, write to the Free Software Foundation, + Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. +*/ + +#ifndef __GPGMEPP_DATA_H__ +#define __GPGMEPP_DATA_H__ + +#include <gpgmepp/gpgmefw.h> + +#include <sys/types.h> // for size_t, off_t +#include <cstdio> // FILE +#include <tdepimmacros.h> + +namespace GpgME { + + class DataProvider; + class Error; + + class KDE_EXPORT Data { + public: + Data(); + Data( gpgme_data_t data ); + Data( const Data & other ); + + // Memory-Based Data Buffers: + Data( const char * buffer, size_t size, bool copy=true ); + Data( const char * filename ); + Data( const char * filename, off_t offset, size_t length ); + Data( FILE * fp, off_t offset, size_t length ); + // File-Based Data Buffers: + Data( FILE * fp ); + Data( int fd ); + // Callback-Based Data Buffers: + Data( DataProvider * provider ); + + virtual ~Data(); + + static Data null; + + const Data & operator=( const Data & other ); + + bool isNull() const; + + ssize_t read( void * buffer, size_t length ); + ssize_t write( const void * buffer, size_t length ); + off_t seek( off_t offset, int whence ); + + class Private; + Private * impl() const { return d; } + private: + Private * d; + }; + +} + +#endif // __GPGMEPP_DATA_H__ diff --git a/libtdenetwork/gpgmepp/data_p.h b/libtdenetwork/gpgmepp/data_p.h new file mode 100644 index 00000000..38981cce --- /dev/null +++ b/libtdenetwork/gpgmepp/data_p.h @@ -0,0 +1,39 @@ +/* data_p.h - wraps a gpgme data object, private part -*- c++ -*- + Copyright (C) 2003,2004 Klarälvdalens Datakonsult AB + + This file is part of GPGME++. + + GPGME++ is free software; you can redistribute it and/or modify it + under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + GPGME++ is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + General Public License for more details. + + You should have received a copy of the GNU General Public License + along with GPGME++; if not, write to the Free Software Foundation, + Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. +*/ + +#ifndef __GPGMEPP_DATA_P_H__ +#define __GPGMEPP_DATA_P_H__ + +#include <gpgmepp/data.h> +#include "shared.h" +#include "callbacks.h" + +class GpgME::Data::Private : public GpgME::Shared { +public: + Private( gpgme_data_t d=0 ) + : Shared(), data( d ), cbs( data_provider_callbacks ) {} + ~Private(); + + gpgme_data_t data; + gpgme_data_cbs cbs; +}; + + +#endif // __GPGMEPP_DATA_P_H__ diff --git a/libtdenetwork/gpgmepp/decryptionresult.cpp b/libtdenetwork/gpgmepp/decryptionresult.cpp new file mode 100644 index 00000000..2efcc67d --- /dev/null +++ b/libtdenetwork/gpgmepp/decryptionresult.cpp @@ -0,0 +1,85 @@ +/* decryptionresult.cpp - wraps a gpgme keygen result + Copyright (C) 2004 Klarälvdalens Datakonsult AB + + This file is part of GPGME++. + + GPGME++ is free software; you can redistribute it and/or modify it + under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + GPGME++ is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + General Public License for more details. + + You should have received a copy of the GNU General Public License + along with GPGME++; if not, write to the Free Software Foundation, + Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. +*/ + +#ifdef HAVE_CONFIG_H +#include <config.h> +#endif + +#include <gpgmepp/decryptionresult.h> +#include "shared.h" +#include "result_p.h" +#include "util.h" + +#include <gpgme.h> + +#include <cstring> +#include <cstdlib> +#include <istream> + +class GpgME::DecryptionResult::Private : public GpgME::Shared { +public: + Private( const _gpgme_op_decrypt_result & r ) : Shared(), res( r ) { + if ( res.unsupported_algorithm ) + res.unsupported_algorithm = strdup( res.unsupported_algorithm ); + } + ~Private() { + if ( res.unsupported_algorithm ) + std::free( res.unsupported_algorithm ); + res.unsupported_algorithm = 0; + } + + _gpgme_op_decrypt_result res; +}; + +GpgME::DecryptionResult::DecryptionResult( gpgme_ctx_t ctx, int error ) + : GpgME::Result( error ), d( 0 ) +{ + if ( error || !ctx ) + return; + gpgme_decrypt_result_t res = gpgme_op_decrypt_result( ctx ); + if ( !res ) + return; + d = new Private( *res ); + d->ref(); +} + +make_standard_stuff(DecryptionResult) + +const char * GpgME::DecryptionResult::unsupportedAlgortihm() const { + return d ? d->res.unsupported_algorithm : 0 ; +} + +bool GpgME::DecryptionResult::wrongKeyUsage() const { +#ifdef HAVE_GPGME_WRONG_KEY_USAGE + if ( d ) + return d->res.wrong_key_usage; +#endif + return false; +} + +std::ostream & GpgME::operator<<( std::ostream & os, const DecryptionResult & result ) { + os << "GpgME::DecryptionResult("; + if ( !result.isNull() ) + os << "\n error: " << result.error() + << "\n unsupportedAlgortihm: " << protect( result.unsupportedAlgortihm() ) + << "\n wrongKeyUsage: " << result.wrongKeyUsage() + << '\n'; + return os << ')'; +} diff --git a/libtdenetwork/gpgmepp/decryptionresult.h b/libtdenetwork/gpgmepp/decryptionresult.h new file mode 100644 index 00000000..da4833bb --- /dev/null +++ b/libtdenetwork/gpgmepp/decryptionresult.h @@ -0,0 +1,59 @@ +/* decryptionresult.h - wraps a gpgme keygen result + Copyright (C) 2004 Klarälvdalens Datakonsult AB + + This file is part of GPGME++. + + GPGME++ is free software; you can redistribute it and/or modify it + under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + GPGME++ is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + General Public License for more details. + + You should have received a copy of the GNU General Public License + along with GPGME++; if not, write to the Free Software Foundation, + Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. +*/ + +#ifndef __GPGMEPP_DECRYPTIONRESULT_H__ +#define __GPGMEPP_DECRYPTIONRESULT_H__ + +#include <gpgmepp/gpgmefw.h> +#include <gpgmepp/result.h> + +#include <iosfwd> + +#include <tdepimmacros.h> + +namespace GpgME { + + class Error; + + class KDE_EXPORT DecryptionResult : public Result { + public: + DecryptionResult( gpgme_ctx_t ctx=0, int error=0 ); + explicit DecryptionResult( const Error & err ); + DecryptionResult( const DecryptionResult & other ); + ~DecryptionResult(); + + const DecryptionResult & operator=( const DecryptionResult & other ); + + bool isNull() const; + + const char * unsupportedAlgortihm() const; + + bool wrongKeyUsage() const; + + private: + class Private; + Private * d; + }; + + KDE_EXPORT std::ostream & operator<<( std::ostream & os, const DecryptionResult & result ); + +} + +#endif // __GPGMEPP_DECRYPTIONRESULT_H__ diff --git a/libtdenetwork/gpgmepp/encryptionresult.cpp b/libtdenetwork/gpgmepp/encryptionresult.cpp new file mode 100644 index 00000000..f827ca83 --- /dev/null +++ b/libtdenetwork/gpgmepp/encryptionresult.cpp @@ -0,0 +1,165 @@ +/* encryptionresult.cpp - wraps a gpgme verify result + Copyright (C) 2004 Klarälvdalens Datakonsult AB + + This file is part of GPGME++. + + GPGME++ is free software; you can redistribute it and/or modify it + under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + GPGME++ is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + General Public License for more details. + + You should have received a copy of the GNU General Public License + along with GPGME++; if not, write to the Free Software Foundation, + Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. +*/ + +#ifdef HAVE_CONFIG_H +#include <config.h> +#endif + +#include <gpgmepp/encryptionresult.h> +#include "shared.h" +#include "result_p.h" +#include "util.h" + +#include <gpgme.h> + +#include <cstring> +#include <cstdlib> +#include <istream> +#include <algorithm> +#include <iterator> + +class GpgME::EncryptionResult::Private : public GpgME::Shared { +public: + Private( const gpgme_encrypt_result_t r ) : Shared() { + if ( !r ) + return; + for ( gpgme_invalid_key_t ik = r->invalid_recipients ; ik ; ik = ik->next ) { + gpgme_invalid_key_t copy = new _gpgme_invalid_key( *ik ); + if ( ik->fpr ) + copy->fpr = strdup( ik->fpr ); + copy->next = 0; + invalid.push_back( copy ); + } + } + ~Private() { + for ( std::vector<gpgme_invalid_key_t>::iterator it = invalid.begin() ; it != invalid.end() ; ++it ) { + std::free( (*it)->fpr ); + delete *it; *it = 0; + } + } + + std::vector<gpgme_invalid_key_t> invalid; +}; + +GpgME::EncryptionResult::EncryptionResult( gpgme_ctx_t ctx, int error ) + : GpgME::Result( error ), d( 0 ) +{ + if ( error || !ctx ) + return; + gpgme_encrypt_result_t res = gpgme_op_encrypt_result( ctx ); + if ( !res ) + return; + d = new Private( res ); + d->ref(); +} + +make_standard_stuff(EncryptionResult) + + +unsigned int GpgME::EncryptionResult::numInvalidRecipients() const { + return d ? d->invalid.size() : 0 ; +} + +GpgME::InvalidRecipient GpgME::EncryptionResult::invalidEncryptionKey( unsigned int idx ) const { + return InvalidRecipient( d, idx ); +} + +std::vector<GpgME::InvalidRecipient> GpgME::EncryptionResult::invalidEncryptionKeys() const { + if ( !d ) + return std::vector<GpgME::InvalidRecipient>(); + std::vector<GpgME::InvalidRecipient> result; + result.reserve( d->invalid.size() ); + for ( unsigned int i = 0 ; i < d->invalid.size() ; ++i ) + result.push_back( InvalidRecipient( d, i ) ); + return result; +} + + + + +GpgME::InvalidRecipient::InvalidRecipient( EncryptionResult::Private * parent, unsigned int i ) + : d( parent ), idx( i ) +{ + if ( d ) + d->ref(); +} + +GpgME::InvalidRecipient::InvalidRecipient() : d( 0 ), idx( 0 ) {} + +GpgME::InvalidRecipient::InvalidRecipient( const InvalidRecipient & other ) + : d( other.d ), idx( other.idx ) +{ + if ( d ) + d->ref(); +} + +GpgME::InvalidRecipient::~InvalidRecipient() { + if ( d ) + d->unref(); +} + +const GpgME::InvalidRecipient & GpgME::InvalidRecipient::operator=( const InvalidRecipient & other ) { + if ( this->d != other.d ) { + if ( other.d ) + other.d->ref(); + if ( this->d ) + this->d->unref(); + this->d = other.d; + } + + this->idx = other.idx; + return *this; +} + + +bool GpgME::InvalidRecipient::isNull() const { + return !d || idx >= d->invalid.size() ; +} + +const char * GpgME::InvalidRecipient::fingerprint() const { + return isNull() ? 0 : d->invalid[idx]->fpr ; +} + +GpgME::Error GpgME::InvalidRecipient::reason() const { + return isNull() ? 0 : d->invalid[idx]->reason ; +} + + + +std::ostream & GpgME::operator<<( std::ostream & os, const EncryptionResult & result ) { + os << "GpgME::EncryptionResult("; + if ( !result.isNull() ) { + os << "\n error: " << result.error() + << "\n invalid recipients:\n"; + const std::vector<InvalidRecipient> ir = result.invalidEncryptionKeys(); + std::copy( ir.begin(), ir.end(), + std::ostream_iterator<InvalidRecipient>( os, "\n" ) ); + } + return os << ')'; +} + +std::ostream & GpgME::operator<<( std::ostream & os, const InvalidRecipient & ir ) { + os << "GpgME::InvalidRecipient("; + if ( !ir.isNull() ) + os << "\n fingerprint: " << protect( ir.fingerprint() ) + << "\n reason: " << ir.reason() + << '\n'; + return os << ')'; +} diff --git a/libtdenetwork/gpgmepp/encryptionresult.h b/libtdenetwork/gpgmepp/encryptionresult.h new file mode 100644 index 00000000..4339bef5 --- /dev/null +++ b/libtdenetwork/gpgmepp/encryptionresult.h @@ -0,0 +1,84 @@ +/* encryptionresult.h - wraps a gpgme sign result + Copyright (C) 2004 Klarälvdalens Datakonsult AB + + This file is part of GPGME++. + + GPGME++ is free software; you can redistribute it and/or modify it + under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + GPGME++ is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + General Public License for more details. + + You should have received a copy of the GNU General Public License + along with GPGME++; if not, write to the Free Software Foundation, + Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. +*/ + +#ifndef __GPGMEPP_ENCRYPTIONRESULT_H__ +#define __GPGMEPP_ENCRYPTIONRESULT_H__ + +#include <gpgmepp/gpgmefw.h> +#include <gpgmepp/result.h> + +#include <vector> +#include <iosfwd> + +#include <tdepimmacros.h> + +namespace GpgME { + + class Error; + class InvalidRecipient; + + class KDE_EXPORT EncryptionResult : public Result { + public: + EncryptionResult( gpgme_ctx_t ctx=0, int error=0 ); + explicit EncryptionResult( const Error & err ); + EncryptionResult( const EncryptionResult & other ); + ~EncryptionResult(); + + const EncryptionResult & operator=( const EncryptionResult & other ); + + bool isNull() const; + + unsigned int numInvalidRecipients() const; + + InvalidRecipient invalidEncryptionKey( unsigned int index ) const; + std::vector<InvalidRecipient> invalidEncryptionKeys() const; + + class Private; + private: + Private * d; + }; + + KDE_EXPORT std::ostream & operator<<( std::ostream & os, const EncryptionResult & result ); + + class KDE_EXPORT InvalidRecipient { + friend class EncryptionResult; + InvalidRecipient( EncryptionResult::Private * parent, unsigned int index ); + public: + InvalidRecipient(); + InvalidRecipient( const InvalidRecipient & other ); + ~InvalidRecipient(); + + const InvalidRecipient & operator=( const InvalidRecipient & other ); + + bool isNull() const; + + const char * fingerprint() const; + Error reason() const; + + private: + EncryptionResult::Private * d; + unsigned int idx; + }; + + KDE_EXPORT std::ostream & operator<<( std::ostream & os, const InvalidRecipient & recipient ); + +} + +#endif // __GPGMEPP_ENCRYPTIONRESULT_H__ diff --git a/libtdenetwork/gpgmepp/engineinfo.cpp b/libtdenetwork/gpgmepp/engineinfo.cpp new file mode 100644 index 00000000..461a61db --- /dev/null +++ b/libtdenetwork/gpgmepp/engineinfo.cpp @@ -0,0 +1,99 @@ +/* engineinfo.h + Copyright (C) 2004 Klarälvdalens Datakonsult AB + + This file is part of GPGME++. + + GPGME++ is free software; you can redistribute it and/or modify it + under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + GPGME++ is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + General Public License for more details. + + You should have received a copy of the GNU General Public License + along with GPGME++; if not, write to the Free Software Foundation, + Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. +*/ + +#ifdef HAVE_CONFIG_H +#include <config.h> +#endif + +#include "engineinfo.h" +#include "shared.h" + +#include <gpgme.h> + +struct GpgME::EngineInfo::Private : public GpgME::Shared { + Private( gpgme_engine_info_t engine=0 ) : Shared(), info( engine ) {} + ~Private() { info = 0; } + + gpgme_engine_info_t info; +}; + + +GpgME::EngineInfo::EngineInfo() : d(0) {} + +GpgME::EngineInfo::EngineInfo( gpgme_engine_info_t engine ) + : d(0) +{ + d = new Private( engine ); + d->ref(); +} + +GpgME::EngineInfo::EngineInfo( const EngineInfo & other ) + : d( other.d ) +{ + if ( d ) + d->ref(); +} + + +GpgME::EngineInfo::~EngineInfo() { + if ( d ) + d->deref(); +} + +const GpgME::EngineInfo & GpgME::EngineInfo::operator=( const GpgME::EngineInfo & other ) { + if ( this->d == other.d ) + return *this; + + if ( other.d ) + other.d->ref(); + if ( this->d ) + this->d->unref(); + + this->d = other.d; + return *this; +} + +bool GpgME::EngineInfo::isNull() const { + return !d || !d->info; +} + +GpgME::Context::Protocol GpgME::EngineInfo::protocol() const { + if ( isNull() ) + return Context::Unknown; + switch( d->info->protocol ) { + case GPGME_PROTOCOL_OpenPGP: return Context::OpenPGP; + case GPGME_PROTOCOL_CMS: return Context::CMS; + default: + return Context::Unknown; + } +} + +const char * GpgME::EngineInfo::fileName() const { + return isNull() ? 0 : d->info->file_name; +} + +const char * GpgME::EngineInfo::version() const { + return isNull() ? 0 : d->info->version; +} + +const char * GpgME::EngineInfo::requiredVersion() const { + return isNull() ? 0 : d->info->req_version; +} + diff --git a/libtdenetwork/gpgmepp/engineinfo.h b/libtdenetwork/gpgmepp/engineinfo.h new file mode 100644 index 00000000..c07d2817 --- /dev/null +++ b/libtdenetwork/gpgmepp/engineinfo.h @@ -0,0 +1,53 @@ +/* engineinfo.h + Copyright (C) 2004 Klarälvdalens Datakonsult AB + + This file is part of GPGME++. + + GPGME++ is free software; you can redistribute it and/or modify it + under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + GPGME++ is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + General Public License for more details. + + You should have received a copy of the GNU General Public License + along with GPGME++; if not, write to the Free Software Foundation, + Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. +*/ + +#ifndef __GPGMEPP_ENGINEINFO_H__ +#define __GPGMEPP_ENGINEINFO_H__ + +#include <gpgmepp/gpgmefw.h> +#include <gpgmepp/context.h> + +#include <tdepimmacros.h> + +namespace GpgME { + + class KDE_EXPORT EngineInfo { + public: + EngineInfo(); + EngineInfo( gpgme_engine_info_t engine ); + EngineInfo( const EngineInfo & other ); + ~EngineInfo(); + + const EngineInfo & operator=( const EngineInfo & other ); + + bool isNull() const; + + Context::Protocol protocol() const; + const char * fileName() const; + const char * version() const; + const char * requiredVersion() const; + private: + class Private; + Private * d; + }; + +} + +#endif // __GPGMEPP_ENGINEINFO_H__ diff --git a/libtdenetwork/gpgmepp/eventloopinteractor.cpp b/libtdenetwork/gpgmepp/eventloopinteractor.cpp new file mode 100644 index 00000000..cdac7d56 --- /dev/null +++ b/libtdenetwork/gpgmepp/eventloopinteractor.cpp @@ -0,0 +1,185 @@ +/* eventloopinteractor.cpp + Copyright (C) 2003,2004 Klarälvdalens Datakonsult AB + + This file is part of GPGME++. + + GPGME++ is free software; you can redistribute it and/or modify it + under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + GPGME++ is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + General Public License for more details. + + You should have received a copy of the GNU General Public License + along with GPGME; if not, write to the Free Software Foundation, + Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */ + +#ifdef HAVE_CONFIG_H +#include <config.h> +#endif + +#include <gpgmepp/eventloopinteractor.h> + +#include <gpgmepp/context.h> +#include "context_p.h" +#include <gpgmepp/key.h> +#include <gpgmepp/trustitem.h> + +#include <gpgme.h> + +#include <vector> +using std::vector; +#ifndef NDEBUG +# include <iostream> +#endif +#include <cassert> + +namespace GpgME { + + // + // EventLoopInteractor::Private Declaration + // + + struct EventLoopInteractor::Private { + struct OneFD { + OneFD( int aFd, int aDir, gpgme_io_cb_t aFnc, + void * aFncData, void * aExternalTag ) + : fd( aFd ), dir( aDir ), fnc( aFnc ), + fncData( aFncData ), externalTag( aExternalTag ) {} + int fd; + int dir; + gpgme_io_cb_t fnc; + void * fncData; + void * externalTag; + }; + + vector<OneFD*> mCallbacks; + + static void removeIOCb( void * tag ); + static gpgme_error_t registerIOCb( void * data, int fd, int dir, + gpgme_io_cb_t fnc, void * fnc_data, + void ** r_tag ); + static void eventIOCb( void *, gpgme_event_io_t type, void * type_data ); + + static gpgme_io_cbs iocbs; + }; + + gpgme_io_cbs EventLoopInteractor::Private::iocbs = { + &EventLoopInteractor::Private::registerIOCb, + 0, + &EventLoopInteractor::Private::removeIOCb, + &EventLoopInteractor::Private::eventIOCb, + 0 + }; + + + // + // EventLoopInteractor::Private IO Callback Implementations + // + + gpgme_error_t EventLoopInteractor::Private::registerIOCb( void *, int fd, int dir, + gpgme_io_cb_t fnc, void * fnc_data, + void ** r_tag ) + { + assert( instance() ); assert( instance()->d ); + bool ok = false; + void * etag = instance()->registerWatcher( fd, dir ? Read : Write, ok ); + if ( !ok ) return GPG_ERR_GENERAL; + instance()->d->mCallbacks.push_back( new OneFD( fd, dir, fnc, fnc_data, etag ) ); + if ( r_tag ) + *r_tag = instance()->d->mCallbacks.back(); + return GPG_ERR_NO_ERROR; + } + + void EventLoopInteractor::Private::removeIOCb( void * tag ) { + assert( instance() ); assert( instance()->d ); + + for ( vector<OneFD*>::iterator it = instance()->d->mCallbacks.begin() ; + it != instance()->d->mCallbacks.end() ; ++it ) { + if ( *it == tag ) { + instance()->unregisterWatcher( (*it)->externalTag ); + delete *it; *it = 0; + instance()->d->mCallbacks.erase( it ); + return; + } + } + } + + void EventLoopInteractor::Private::eventIOCb( void * data, gpgme_event_io_t type, void * type_data ) { + assert( instance() ); + Context * ctx = static_cast<Context*>( data ); + switch( type ) { + case GPGME_EVENT_START: + { + // hmmm, what to do here? + } + break; + case GPGME_EVENT_DONE: + { + gpgme_error_t e = *static_cast<gpgme_error_t*>( type_data ); + if ( ctx && ctx->impl() ) + ctx->impl()->lasterr = e; + instance()->operationDoneEvent( ctx, e ); + } + break; + case GPGME_EVENT_NEXT_KEY: + { + gpgme_key_t key = static_cast<gpgme_key_t>( type_data ); + instance()->nextKeyEvent( ctx, Key( key, false, ctx ? ctx->keyListMode() : 0 ) ); + } + break; + case GPGME_EVENT_NEXT_TRUSTITEM: + { + gpgme_trust_item_t item = static_cast<gpgme_trust_item_t>( type_data ); + instance()->nextTrustItemEvent( ctx, TrustItem( item ) ); + gpgme_trust_item_unref( item ); + } + break; + default: // warn + ; + } + } + + // + // EventLoopInteractor Implementation + // + + EventLoopInteractor * EventLoopInteractor::mSelf = 0; + + EventLoopInteractor::EventLoopInteractor() { + assert( !mSelf ); + d = new Private(); + mSelf = this; + } + + EventLoopInteractor::~EventLoopInteractor() { + // warn if there are still callbacks registered + mSelf = 0; + delete d; d = 0; + } + + void EventLoopInteractor::manage( Context * context ) { + if ( !context || context->managedByEventLoopInteractor() ) return; + gpgme_io_cbs * iocbs = new gpgme_io_cbs( Private::iocbs ); + iocbs->event_priv = context; + context->installIOCallbacks( iocbs ); + } + + void EventLoopInteractor::unmanage( Context * context ) { + if ( context ) + context->uninstallIOCallbacks(); + } + + void EventLoopInteractor::actOn( int fd, Direction dir ) { + for ( vector<Private::OneFD*>::const_iterator it = d->mCallbacks.begin() ; + it != d->mCallbacks.end() ; ++it ) + if ( (*it)->fd == fd && ( (*it)->dir ? Read : Write ) == dir ) { + (*((*it)->fnc))( (*it)->fncData, fd ); + break; + } + } + +} // namespace GpgME diff --git a/libtdenetwork/gpgmepp/eventloopinteractor.h b/libtdenetwork/gpgmepp/eventloopinteractor.h new file mode 100644 index 00000000..c3688833 --- /dev/null +++ b/libtdenetwork/gpgmepp/eventloopinteractor.h @@ -0,0 +1,148 @@ +/* eventloopinteractor.h + Copyright (C) 2003,2004 Klarälvdalens Datakonsult AB + + This file is part of GPGME++. + + GPGME++ is free software; you can redistribute it and/or modify it + under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + GPGME++ is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + General Public License for more details. + + You should have received a copy of the GNU General Public License + along with GPGME; if not, write to the Free Software Foundation, + Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */ + +// -*- c++ -*- +#ifndef __GPGMEPP_EVENTLOOPINTERACTOR_H__ +#define __GPGMEPP_EVENTLOOPINTERACTOR_H__ + +#include <tdepimmacros.h> + +namespace GpgME { + + class Context; + class Error; + class TrustItem; + class Key; + + /*! \file eventloopinteractor.h + \brief Abstract base class for gpgme's external event loop support + + This class does most of the work involved with hooking GpgME++ + up with external event loops, such as the GTK or TQt ones. + + It actually provides two interfaces: An interface to the gpgme + IO Callback handling and one for gpgme events. The IO Callback + interface consists of the three methods \c actOn(), \c + registerWatcher() and \c unregisterWatcher(). The event + interface consists of the three methods \c nextTrustItemEvent(), + \c nextKeyEvent() and \c operationDoneEvent(). + + \sect General Usage + + \c EventLoopInteractor is designed to be used as a + singleton. However, in order to make any use of it, you have to + subclass it and reimplement it's pure virtual methods (see + below). We suggest you keep the constructor protected and + provide a static \c instance() method that returns the single + instance. Alternatively, you can create an instance on the + stack, e.g. in \c main(). + + If you want \c EventLoopInteractor to manage a particular \c + Context, just call \c manage() on the \c Context. OTOH, if you + want to disable IO callbacks for a \c Context, use \c unmanage(). + + \sect IO Callback Interface + + One part of this interface is represented by \c + registerWatcher() and \c unregisterWatcher(), both of which are + pure virtual. \c registerWatcher() should do anything necessary + to hook up watching of file descriptor \c fd for reading (\c dir + = \c Read) or writing (\c dir = Write) to the event loop you use + and return a tag identifying that particular watching process + uniquely. This could be the index into an array of objects you + use for that purpose or the address of such an object. E.g. in + TQt, you'd essentially just create a new \c TQSocketNotifier: + + \verbatim + void * registerWatcher( int fd, Direction dir ) { + return new TQSocketNotifier( fd, dir == Read ? TQSocketNotifier::Read : TQSocketNotifier::Write ); + // misses connecting to the activated() signal... + } + \endverbatim + + which uses the address of the created object as unique tag. The + tag returned by \c registerWatcher is stored by \c + EventLoopInteractor and passed as argument to \c + unregisterWatcher(). So, in the picture above, you'd implement \c + unregisterWatcher() like this: + + \verbatim + void unregisterWatcher( void * tag ) { + delete static_cast<TQSocketNotifier*>( tag ); + } + \endverbatim + + The other part of the IO callback interface is \c actOn(), which + you should call if you receive notification from your event loop + about activity on file descriptor \c fd in direction \c dir. In + the picture above, you'd call this from the slot connected to + the socket notifier's \c activated() signal. + + \note \c registerWatcher() as well as \c unregisterWatcher() may + be called from within \c actOn(), so be careful with + e.g. locking in threaded environments and keep in mind that the + object you used to find the \c fd and \c dir fo the \c actOn() + call might be deleted when \c actOn() returns! + + \sect Event Handler Interface + + + */ + class KDE_EXPORT EventLoopInteractor { + protected: + EventLoopInteractor(); + public: + virtual ~EventLoopInteractor(); + + static EventLoopInteractor * instance() { return mSelf; } + + void manage( Context * context ); + void unmanage( Context * context ); + + enum Direction { Read, Write }; + protected: + // + // IO Notification Interface + // + + /** Call this if your event loop detected activity on file + descriptor fd, with direction dir */ + void actOn( int fd, Direction dir ); + + virtual void * registerWatcher( int fd, Direction dir, bool & ok ) = 0; + virtual void unregisterWatcher( void * tag ) = 0; + + // + // Event Handler Interface + // + + virtual void nextTrustItemEvent( Context * context, const TrustItem & item ) = 0; + virtual void nextKeyEvent( Context * context, const Key & key ) = 0; + virtual void operationDoneEvent( Context * context, const Error & e ) = 0; + + private: + class Private; + friend class Private; + Private * d; + static EventLoopInteractor * mSelf; + }; + +} + +#endif // __GPGMEPP_EVENTLOOPINTERACTOR_H__ diff --git a/libtdenetwork/gpgmepp/gpgme-0-3-compat.h b/libtdenetwork/gpgmepp/gpgme-0-3-compat.h new file mode 100644 index 00000000..5f8c5b61 --- /dev/null +++ b/libtdenetwork/gpgmepp/gpgme-0-3-compat.h @@ -0,0 +1,49 @@ +/* gpgmefw.h - Forwards declarations for gpgme (0.3 and 0.4) + Copyright (C) 2004 Klarälvdalens Datakonsult AB + + This file is part of GPGME++. + + GPGME++ is free software; you can redistribute it and/or modify it + under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + GPGME++ is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + General Public License for more details. + + You should have received a copy of the GNU General Public License + along with GPGME++; if not, write to the Free Software Foundation, + Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. +*/ + +#ifndef __GPGMEPP_GPGME_0_3_COMPAT_H__ +#define __GPGMEPP_GPGME_0_3_COMPAT_H__ + +#include <gpgme.h> + +#ifndef HAVE_GPGME_0_4_BRANCH +// make gpgme-0.4 names available even if we have only 0.3: +typedef GpgmeError gpgme_error_t; +typedef GpgmeIOCb gpgme_io_cb_t; +typedef GpgmeIOCbs gpgme_io_cbs; +typedef GpgmeEventIO gpgme_event_io_t; +typedef GpgmeEventIOCb gpgme_event_io_cb_t; +typedef GpgmeRegisterIOCb gpgme_register_io_cb_t; +typedef GpgmeRemoveIOCb gpgme_remove_io_cb_t; +typedef GpgmeSigStat gpgme_sig_stat_t; +typedef GpgmeAttr gpgme_attr_t; +typedef GpgmeTrustItem gpgme_trust_item_t; +typedef GpgmeCtx gpgme_ctx_t; +typedef GpgmeProtocol gpgme_protocol_t; +typedef GpgmeData gpgme_data_t; +typedef GpgmeKey gpgme_key_t; + +#define GPG_ERR_GENERAL GPGME_General_Error +#define GPG_ERR_NO_ERROR GPGME_No_Error +#define GPG_ERR_EOF GPGME_EOF +#define gpg_err_code(x) (x) +#endif + +#endif // __GPGMEPP_GPGME_0_3_COMPAT_H__ diff --git a/libtdenetwork/gpgmepp/gpgmefw.h b/libtdenetwork/gpgmepp/gpgmefw.h new file mode 100644 index 00000000..8fe43746 --- /dev/null +++ b/libtdenetwork/gpgmepp/gpgmefw.h @@ -0,0 +1,60 @@ +/* gpgmefw.h - Forwards declarations for gpgme (0.3 and 0.4) + Copyright (C) 2004 Klarälvdalens Datakonsult AB + + This file is part of GPGME++. + + GPGME++ is free software; you can redistribute it and/or modify it + under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + GPGME++ is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + General Public License for more details. + + You should have received a copy of the GNU General Public License + along with GPGME++; if not, write to the Free Software Foundation, + Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. +*/ + +#ifndef __GPGMEPP_GPGMEFW_H__ +#define __GPGMEPP_GPGMEFW_H__ + +#ifndef HAVE_GPGME_0_4_BRANCH +#error You need gpgme 0.4.x, x >= 4, to compile gpgme++ +#endif + +struct gpgme_context; +typedef gpgme_context * gpgme_ctx_t; + +struct gpgme_data; +typedef gpgme_data * gpgme_data_t; + +struct gpgme_io_cbs; + +struct _gpgme_key; +typedef struct _gpgme_key * gpgme_key_t; + +struct _gpgme_trust_item; +typedef struct _gpgme_trust_item * gpgme_trust_item_t; + +struct _gpgme_subkey; +typedef struct _gpgme_subkey * gpgme_sub_key_t; + +struct _gpgme_user_id; +typedef struct _gpgme_user_id * gpgme_user_id_t; + +struct _gpgme_key_sig; +typedef struct _gpgme_key_sig * gpgme_key_sig_t; + +struct _gpgme_sig_notation; +typedef struct _gpgme_sig_notation * gpgme_sig_notation_t; + +struct _gpgme_engine_info; +typedef struct _gpgme_engine_info * gpgme_engine_info_t; + +struct _gpgme_op_keylist_result; +typedef struct _gpgme_op_keylist_result * gpgme_keylist_result_t; + +#endif // __GPGMEPP_GPGMEFW_H__ diff --git a/libtdenetwork/gpgmepp/importresult.cpp b/libtdenetwork/gpgmepp/importresult.cpp new file mode 100644 index 00000000..3b4b713c --- /dev/null +++ b/libtdenetwork/gpgmepp/importresult.cpp @@ -0,0 +1,204 @@ +/* importresult.cpp - wraps a gpgme import result + Copyright (C) 2004 Klarälvdalens Datakonsult AB + + This file is part of GPGME++. + + GPGME++ is free software; you can redistribute it and/or modify it + under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + GPGME++ is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + General Public License for more details. + + You should have received a copy of the GNU General Public License + along with GPGME++; if not, write to the Free Software Foundation, + Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. +*/ + +#ifdef HAVE_CONFIG_H +#include <config.h> +#endif + +#include <gpgmepp/importresult.h> +#include "shared.h" +#include "result_p.h" + +#include <gpgme.h> +#include <cstring> +#include <cstdlib> +#include <cstdlib> + +class GpgME::ImportResult::Private : public GpgME::Shared { +public: + Private( const _gpgme_op_import_result & r ) : Shared(), res( r ) { + // copy recursively, using compiler-generated copy ctor. + // We just need to handle the pointers in the structs: + for ( gpgme_import_status_t is = r.imports ; is ; is = is->next ) { + gpgme_import_status_t copy = new _gpgme_import_status( *is ); + copy->fpr = strdup( is->fpr ); + copy->next = 0; + imports.push_back( copy ); + } + res.imports = 0; + } + ~Private() { + for ( std::vector<gpgme_import_status_t>::iterator it = imports.begin() ; it != imports.end() ; ++it ) { + std::free( (*it)->fpr ); + delete *it; *it = 0; + } + } + + _gpgme_op_import_result res; + std::vector<gpgme_import_status_t> imports; +}; + +GpgME::ImportResult::ImportResult( gpgme_ctx_t ctx, int error ) + : GpgME::Result( error ), d( 0 ) +{ + if ( error || !ctx ) + return; + gpgme_import_result_t res = gpgme_op_import_result( ctx ); + if ( !res ) + return; + d = new Private( *res ); + d->ref(); +} + +make_standard_stuff(ImportResult) + +int GpgME::ImportResult::numConsidered() const { + return d ? d->res.considered : 0 ; +} + +int GpgME::ImportResult::numKeysWithoutUserID() const { + return d ? d->res.no_user_id : 0 ; +} + +int GpgME::ImportResult::numImported() const { + return d ? d->res.imported : 0 ; +} + +int GpgME::ImportResult::numRSAImported() const { + return d ? d->res.imported_rsa : 0 ; +} + +int GpgME::ImportResult::numUnchanged() const { + return d ? d->res.unchanged : 0 ; +} + +int GpgME::ImportResult::newUserIDs() const { + return d ? d->res.new_user_ids : 0 ; +} + +int GpgME::ImportResult::newSubkeys() const { + return d ? d->res.new_sub_keys : 0 ; +} + +int GpgME::ImportResult::newSignatures() const { + return d ? d->res.new_signatures : 0 ; +} + +int GpgME::ImportResult::newRevocations() const { + return d ? d->res.new_revocations : 0 ; +} + +int GpgME::ImportResult::numSecretKeysConsidered() const { + return d ? d->res.secret_read : 0 ; +} + +int GpgME::ImportResult::numSecretKeysImported() const { + return d ? d->res.secret_imported : 0 ; +} + +int GpgME::ImportResult::numSecretKeysUnchanged() const { + return d ? d->res.secret_unchanged : 0 ; +} + +int GpgME::ImportResult::notImported() const { + return d ? d->res.not_imported : 0 ; +} + +GpgME::Import GpgME::ImportResult::import( unsigned int idx ) const { + return Import( d, idx ); +} + +std::vector<GpgME::Import> GpgME::ImportResult::imports() const { + if ( !d ) + return std::vector<Import>(); + std::vector<Import> result; + result.reserve( d->imports.size() ); + for ( unsigned int i = 0 ; i < d->imports.size() ; ++i ) + result.push_back( Import( d, i ) ); + return result; +} + + + + + + +GpgME::Import::Import( ImportResult::Private * parent, unsigned int i ) + : d( parent ), idx( i ) +{ + if ( d ) + d->ref(); +} + +GpgME::Import::Import() : d( 0 ), idx( 0 ) {} + +GpgME::Import::Import( const Import & other ) + : d( other.d ), idx( other.idx ) +{ + if ( d ) + d->ref(); +} + +GpgME::Import::~Import() { + if ( d ) + d->unref(); +} + +const GpgME::Import & GpgME::Import::operator=( const Import & other ) { + if ( this->d != other.d ) { + if ( other.d ) + other.d->ref(); + if ( this->d ) + this->d->unref(); + this->d = other.d; + } + + this->idx = other.idx; + return *this; +} + + +bool GpgME::Import::isNull() const { + return !d || idx >= d->imports.size() ; +} + + + + +const char * GpgME::Import::fingerprint() const { + return isNull() ? 0 : d->imports[idx]->fpr ; +} + +GpgME::Error GpgME::Import::error() const { + return isNull() ? 0 : d->imports[idx]->result ; +} + +GpgME::Import::tqStatus GpgME::Import::status() const { + if ( isNull() ) + return Unknown; + unsigned int s = d->imports[idx]->status; + unsigned int result = Unknown; + if ( s & GPGME_IMPORT_NEW ) result |= NewKey; + if ( s & GPGME_IMPORT_UID ) result |= NewUserIDs; + if ( s & GPGME_IMPORT_SIG ) result |= NewSignatures; + if ( s & GPGME_IMPORT_SUBKEY ) result |= NewSubkeys; + if ( s & GPGME_IMPORT_SECRET ) result |= ContainedSecretKey; + return static_cast<tqStatus>( result ); +} diff --git a/libtdenetwork/gpgmepp/importresult.h b/libtdenetwork/gpgmepp/importresult.h new file mode 100644 index 00000000..61675a29 --- /dev/null +++ b/libtdenetwork/gpgmepp/importresult.h @@ -0,0 +1,103 @@ +/* importresult.h - wraps a gpgme import result + Copyright (C) 2004 Klarälvdalens Datakonsult AB + + This file is part of GPGME++. + + GPGME++ is free software; you can redistribute it and/or modify it + under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + GPGME++ is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + General Public License for more details. + + You should have received a copy of the GNU General Public License + along with GPGME++; if not, write to the Free Software Foundation, + Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. +*/ + +#ifndef __GPGMEPP_IMPORTRESULT_H__ +#define __GPGMEPP_IMPORTRESULT_H__ + +#include <gpgmepp/gpgmefw.h> +#include <gpgmepp/result.h> + +#include <vector> +#include <tdepimmacros.h> + +namespace GpgME { + + class Error; + class Import; + + class KDE_EXPORT ImportResult : public Result { + public: + ImportResult( gpgme_ctx_t ctx=0, int error=0 ); + explicit ImportResult( const Error & error ); + ImportResult( const ImportResult & other ); + ~ImportResult(); + + const ImportResult & operator=( const ImportResult & other ); + + bool isNull() const; + + int numConsidered() const; + int numKeysWithoutUserID() const; + int numImported() const; + int numRSAImported() const; + int numUnchanged() const; + + int newUserIDs() const; + int newSubkeys() const; + int newSignatures() const; + int newRevocations() const; + + int numSecretKeysConsidered() const; + int numSecretKeysImported() const; + int numSecretKeysUnchanged() const; + + int notImported() const; + + Import import( unsigned int idx ) const; + std::vector<Import> imports() const; + + class Private; + private: + Private * d; + }; + + class KDE_EXPORT Import { + friend class ImportResult; + Import( ImportResult::Private * parent, unsigned int idx ); + public: + Import(); + Import( const Import & other ); + ~Import(); + + const Import & operator=( const Import & other ); + + bool isNull() const; + + const char * fingerprint() const; + Error error() const; + + enum tqStatus { + Unknown = 0x0, + NewKey = 0x1, + NewUserIDs = 0x2, + NewSignatures = 0x4, + NewSubkeys = 0x8, + ContainedSecretKey = 0x10 + }; + tqStatus status() const; + + private: + ImportResult::Private * d; + unsigned int idx; + }; + +} + +#endif // __GPGMEPP_IMPORTRESULT_H__ diff --git a/libtdenetwork/gpgmepp/interfaces/CMakeLists.txt b/libtdenetwork/gpgmepp/interfaces/CMakeLists.txt new file mode 100644 index 00000000..db5b88ee --- /dev/null +++ b/libtdenetwork/gpgmepp/interfaces/CMakeLists.txt @@ -0,0 +1,14 @@ +################################################# +# +# (C) 2010-2011 Serghei Amelian +# serghei (DOT) amelian (AT) gmail.com +# +# Improvements and feedback are welcome +# +# This file is released under GPL >= 2 +# +################################################# + +install( FILES + editinteractor.h passphraseprovider.h progressprovider.h + DESTINATION ${INCLUDE_INSTALL_DIR}/gpgme++/interfaces ) diff --git a/libtdenetwork/gpgmepp/interfaces/Makefile.am b/libtdenetwork/gpgmepp/interfaces/Makefile.am new file mode 100644 index 00000000..ad2f79e4 --- /dev/null +++ b/libtdenetwork/gpgmepp/interfaces/Makefile.am @@ -0,0 +1,3 @@ +gpgmeppinterfacesdir = $(includedir)/gpgme++/interfaces +gpgmeppinterfaces_HEADERS = editinteractor.h \ + passphraseprovider.h progressprovider.h diff --git a/libtdenetwork/gpgmepp/interfaces/dataprovider.h b/libtdenetwork/gpgmepp/interfaces/dataprovider.h new file mode 100644 index 00000000..34dd4a7e --- /dev/null +++ b/libtdenetwork/gpgmepp/interfaces/dataprovider.h @@ -0,0 +1,48 @@ +/* interface/dataprovider.h - Interface for data sources + Copyright (C) 2003 Klarälvdalens Datakonsult AB + + This file is part of GPGME++. + + GPGME++ is free software; you can redistribute it and/or modify it + under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + GPGME++ is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + General Public License for more details. + + You should have received a copy of the GNU General Public License + along with GPGME; if not, write to the Free Software Foundation, + Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. +*/ + +#ifndef __GPGMEPP_INTERFACES_DATAPROVIDER_H__ +#define __GPGMEPP_INTERFACES_DATAPROVIDER_H__ + +#include <sys/types.h> + +#include <tdepimmacros.h> + +namespace GpgME { + + class KDE_EXPORT DataProvider { + public: + virtual ~DataProvider() {} + + enum Operation { + Read, Write, Seek, Release + }; + virtual bool isSupported( Operation op ) const = 0; + + + virtual ssize_t read( void * buffer, size_t bufSize ) = 0; + virtual ssize_t write( const void * buffer, size_t bufSize ) = 0; + virtual off_t seek( off_t offset, int whence ) = 0; + virtual void release() = 0; + }; + +} // namespace GpgME + +#endif // __GPGMEPP_INTERFACES_DATAPROVIDER_H__ diff --git a/libtdenetwork/gpgmepp/interfaces/editinteractor.h b/libtdenetwork/gpgmepp/interfaces/editinteractor.h new file mode 100644 index 00000000..e1f31eed --- /dev/null +++ b/libtdenetwork/gpgmepp/interfaces/editinteractor.h @@ -0,0 +1,35 @@ +/* interface/editinteractor.h - Interface for key edit functions + Copyright (C) 2003 Klarälvdalens Datakonsult AB + + This file is part of GPGME++. + + GPGME++ is free software; you can redistribute it and/or modify it + under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + GPGME++ is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + General Public License for more details. + + You should have received a copy of the GNU General Public License + along with GPGME; if not, write to the Free Software Foundation, + Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. +*/ + +#ifndef __GPGMEPP_INTERFACES_EDITINTERACTOR_H__ +#define __GPGMEPP_INTERFACES_EDITINTERACTOR_H__ + +namespace GpgME { + + class EditInteractor { + public: + virtual ~EditInteractor() {} + + virtual bool interactiveEdit( int status, const char * args, const char ** reply ) = 0; + }; + +} // namespace GpgME + +#endif // __GPGMEPP_INTERFACES_EDITINTERACTOR_H__ diff --git a/libtdenetwork/gpgmepp/interfaces/passphraseprovider.h b/libtdenetwork/gpgmepp/interfaces/passphraseprovider.h new file mode 100644 index 00000000..37ff6a8b --- /dev/null +++ b/libtdenetwork/gpgmepp/interfaces/passphraseprovider.h @@ -0,0 +1,38 @@ +/* interface/passphraseprovider.h - Interface for passphrase callbacks + Copyright (C) 2003,2004 Klarälvdalens Datakonsult AB + + This file is part of GPGME++. + + GPGME++ is free software; you can redistribute it and/or modify it + under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + GPGME++ is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + General Public License for more details. + + You should have received a copy of the GNU General Public License + along with GPGME; if not, write to the Free Software Foundation, + Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. +*/ + +#ifndef __GPGMEPP_INTERFACES_PASSPHRASEPROVIDER_H__ +#define __GPGMEPP_INTERFACES_PASSPHRASEPROVIDER_H__ + +#include <string> + +namespace GpgME { + + class PassphraseProvider { + public: + virtual ~PassphraseProvider() {} + + virtual char * getPassphrase( const char * useridHint, const char * description, + bool previousWasbad, bool & canceled ) = 0; + }; + +} // namespace GpgME + +#endif // __GPGMEPP_INTERFACES_PASSPHRASEPROVIDER_H__ diff --git a/libtdenetwork/gpgmepp/interfaces/progressprovider.h b/libtdenetwork/gpgmepp/interfaces/progressprovider.h new file mode 100644 index 00000000..b51765b7 --- /dev/null +++ b/libtdenetwork/gpgmepp/interfaces/progressprovider.h @@ -0,0 +1,36 @@ +/* interface/progressprovider.h - Interface for progress reports + Copyright (C) 2003 Klarälvdalens Datakonsult AB + + This file is part of GPGME++. + + GPGME++ is free software; you can redistribute it and/or modify it + under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + GPGME++ is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + General Public License for more details. + + You should have received a copy of the GNU General Public License + along with GPGME; if not, write to the Free Software Foundation, + Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. +*/ + +#ifndef __GPGMEPP_INTERFACES_PROGRESSPROVIDER_H__ +#define __GPGMEPP_INTERFACES_PROGRESSPROVIDER_H__ + +namespace GpgME { + + class ProgressProvider { + public: + virtual ~ProgressProvider() {} + + virtual void showProgress( const char * what, int type, + int current, int total ) = 0; + }; + +} // namespace GpgME + +#endif // __GPGMEPP_INTERFACES_PROGRESSPROVIDER_H__ diff --git a/libtdenetwork/gpgmepp/key.cpp b/libtdenetwork/gpgmepp/key.cpp new file mode 100644 index 00000000..13cd0a7e --- /dev/null +++ b/libtdenetwork/gpgmepp/key.cpp @@ -0,0 +1,926 @@ +/* key.cpp - wraps a gpgme key + Copyright (C) 2003 Klarälvdalens Datakonsult AB + + This file is part of GPGME++. + + GPGME++ is free software; you can redistribute it and/or modify it + under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + GPGME++ is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + General Public License for more details. + + You should have received a copy of the GNU General Public License + along with GPGME; if not, write to the Free Software Foundation, + Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */ + +#ifdef HAVE_CONFIG_H +#include <config.h> +#endif + +#include <gpgmepp/key.h> + +#include "util.h" + +#include <gpgme.h> + +#include <string.h> + +GpgME::Key GpgME::Key::null; + +namespace GpgME { + + using std::vector; + + struct Key::Private { + Private( gpgme_key_t aKey, unsigned int aMode ) + : key( aKey ), +#ifdef HAVE_GPGME_KEY_T_KEYLIST_MODE + mode( 0 ) +#else + mode( aMode ) +#endif + {} + gpgme_key_t key; + unsigned int mode; + }; + + Key::Key() { + d = new Private( 0, 0 ); + } + + Key::Key( gpgme_key_t key, bool ref, unsigned int mode ) { + d = new Private( key, mode ); + if ( ref && d->key ) + gpgme_key_ref( d->key ); + } + + Key::Key( const Key & other ) { + d = new Private( other.d->key, other.d->mode ); + if ( d->key ) + gpgme_key_ref( d->key ); + } + + Key::~Key() { + if ( d->key ) + gpgme_key_unref( d->key ); + delete d; d = 0; + } + + const Key & Key::operator=( const Key & other ) { + if ( d == other.d ) return *this; + + if ( other.d->key ) + gpgme_key_ref( other.d->key ); + if ( d->key ) + gpgme_key_unref( d->key ); + *d = *other.d; + return *this; + } + + bool Key::isNull() const { + return d->key == 0; + } + + gpgme_key_t Key::impl() const { + return d->key; + } + + + + UserID Key::userID( unsigned int index ) const { + return UserID( d->key, index ); + } + + Subkey Key::subkey( unsigned int index ) const { + return Subkey( d->key, index ); + } + + + unsigned int Key::numUserIDs() const { + if ( !d->key ) + return 0; + unsigned int count = 0; + for ( gpgme_user_id_t uid = d->key->uids ; uid ; uid = uid->next ) + ++count; + return count; + } + + unsigned int Key::numSubkeys() const { + if ( !d->key ) + return 0; + unsigned int count = 0; + for ( gpgme_sub_key_t subkey = d->key->subkeys ; subkey ; subkey = subkey->next ) + ++count; + return count; + } + + vector<UserID> Key::userIDs() const { + if ( !d->key ) + return vector<UserID>(); + + vector<UserID> v; + v.reserve( numUserIDs() ); + for ( gpgme_user_id_t uid = d->key->uids ; uid ; uid = uid->next ) + v.push_back( UserID( d->key, uid ) ); + return v; + } + + vector<Subkey> Key::subkeys() const { + if ( !d->key ) + return vector<Subkey>(); + + vector<Subkey> v; + v.reserve( numSubkeys() ); + for ( gpgme_sub_key_t subkey = d->key->subkeys ; subkey ; subkey = subkey->next ) + v.push_back( Subkey( d->key, subkey ) ); + return v; + } + + Key::OwnerTrust Key::ownerTrust() const { + if ( !d->key ) + return Unknown; + switch ( d->key->owner_trust ) { + default: + case GPGME_VALIDITY_UNKNOWN: return Unknown; + case GPGME_VALIDITY_UNDEFINED: return Undefined; + case GPGME_VALIDITY_NEVER: return Never; + case GPGME_VALIDITY_MARGINAL: return Marginal; + case GPGME_VALIDITY_FULL: return Full; + case GPGME_VALIDITY_ULTIMATE: return Ultimate; + } + } + char Key::ownerTrustAsString() const { + if ( !d->key ) + return '?'; + switch ( d->key->owner_trust ) { + default: + case GPGME_VALIDITY_UNKNOWN: return '?'; + case GPGME_VALIDITY_UNDEFINED: return 'q'; + case GPGME_VALIDITY_NEVER: return 'n'; + case GPGME_VALIDITY_MARGINAL: return 'm'; + case GPGME_VALIDITY_FULL: return 'f'; + case GPGME_VALIDITY_ULTIMATE: return 'u'; + } + } + + Context::Protocol Key::protocol() const { + if ( !d->key ) + return Context::Unknown; + switch ( d->key->protocol ) { + case GPGME_PROTOCOL_CMS: return Context::CMS; + case GPGME_PROTOCOL_OpenPGP: return Context::OpenPGP; + default: return Context::Unknown; + } + } + + const char * Key::protocolAsString() const { + return d->key ? gpgme_get_protocol_name( d->key->protocol ) : 0 ; + } + + bool Key::isRevoked() const { + return d->key && d->key->revoked; + } + + bool Key::isExpired() const { + return d->key && d->key->expired; + } + + bool Key::isDisabled() const { + return d->key && d->key->disabled; + } + + bool Key::isInvalid() const { + return d->key && d->key->invalid; + } + + bool Key::hasSecret() const { + return d->key && d->key->secret; + } + + bool Key::isRoot() const { + return d->key && d->key->subkeys && d->key->subkeys->fpr && d->key->chain_id && + strcasecmp( d->key->subkeys->fpr, d->key->chain_id ) == 0; + } + + bool Key::canEncrypt() const { + return d->key && d->key->can_encrypt; + } + + bool Key::canSign() const { +#ifndef GPGME_CAN_SIGN_ON_SECRET_OPENPGP_KEYLISTING_NOT_BROKEN + if ( d->key && d->key->protocol == GPGME_PROTOCOL_OpenPGP ) + return true; +#endif + return d->key && d->key->can_sign; + } + + bool Key::canCertify() const { + return d->key && d->key->can_certify; + } + + bool Key::canAuthenticate() const { + return d->key && d->key->can_authenticate; + } + + const char * Key::issuerSerial() const { + return d->key ? d->key->issuer_serial : 0 ; + } + const char * Key::issuerName() const { + return d->key ? d->key->issuer_name : 0 ; + } + const char * Key::chainID() const { + return d->key ? d->key->chain_id : 0 ; + } + + const char * Key::keyID() const { +#ifdef HAVE_GPGME_KEY_T_KEYID + return d->key ? d->key->keyid : 0 ; +#else + if ( !d->key || !d->key->subkeys || !d->key->subkeys->fpr ) + return 0; + const int len = strlen( d->key->subkeys->fpr ); + if ( len < 16 ) + return 0; + return d->key->subkeys->fpr + len - 16; // return the last 8 bytes (in hex notation) +#endif + } + + const char * Key::shortKeyID() const { + if ( const char * keyid = keyID() ) + return keyid + 8 ; + else + return 0; + } + + const char * Key::primaryFingerprint() const { +#ifdef HAVE_GPGME_KEY_T_FPR + return d->key ? d->key->fpr : 0 ; +#else + return d->key && d->key->subkeys ? d->key->subkeys->fpr : 0 ; +#endif + } + + unsigned int Key::keyListMode() const { +#ifdef HAVE_GPGME_KEY_T_KEYLIST_MODE + return d->key ? convert_from_gpgme_keylist_mode_t( d->key->keylist_mode ) : 0 ; +#else + return d ? d->mode : 0 ; +#endif + } + + // + // + // class Subkey + // + // + + struct Subkey::Private { + Private( gpgme_key_t aKey, unsigned int idx ) + : key( aKey ), subkey( 0 ) + { + if ( key ) + for ( gpgme_sub_key_t s = key->subkeys ; s ; s = s->next, --idx ) + if ( idx == 0 ) { + subkey = s; + break; + } + if ( !subkey ) + key = 0; + } + + Private( gpgme_key_t aKey, gpgme_sub_key_t aSubkey ) + : key( aKey ), subkey( 0 ) + { + if ( key ) + for ( gpgme_sub_key_t s = key->subkeys ; s ; s = s->next ) + if ( s == aSubkey ) { // verify this subkey really belongs to this key + subkey = aSubkey; + break; + } + if ( !subkey ) + key = 0; + } + + gpgme_key_t key; + gpgme_sub_key_t subkey; + }; + + Subkey::Subkey( gpgme_key_t key, unsigned int idx ) { + d = new Private( key, idx ); + if ( d->key ) + gpgme_key_ref( d->key ); + } + + Subkey::Subkey( gpgme_key_t key, gpgme_sub_key_t subkey ) { + d = new Private( key, subkey ); + if ( d->key ) + gpgme_key_ref( d->key ); + } + + Subkey::Subkey( const Subkey & other ) { + d = new Private( other.d->key, other.d->subkey ); + if ( d->key ) + gpgme_key_ref( d->key ); + } + + Subkey::~Subkey() { + if ( d->key ) + gpgme_key_unref( d->key ); + delete d; d = 0; + } + + const Subkey & Subkey::operator=( const Subkey & other ) { + if ( &other == this ) return *this; + + if ( other.d->key ) + gpgme_key_ref( other.d->key ); + if ( d->key ) + gpgme_key_unref( d->key ); + *d = *other.d; + return *this; + } + + bool Subkey::isNull() const { + return !d || !d->key || !d->subkey; + } + + Key Subkey::parent() const { + return Key( d->key, true ); + } + + const char * Subkey::keyID() const { + return d->subkey ? d->subkey->keyid : 0 ; + } + + const char * Subkey::fingerprint() const { + return d->subkey ? d->subkey->fpr : 0 ; + } + + unsigned int Subkey::publicKeyAlgorithm() const { + return d->subkey ? d->subkey->pubkey_algo : 0 ; + } + + const char * Subkey::publicKeyAlgorithmAsString() const { + return gpgme_pubkey_algo_name( d->subkey ? d->subkey->pubkey_algo : (gpgme_pubkey_algo_t)0 ); + } + + bool Subkey::canEncrypt() const { + return d->subkey && d->subkey->can_encrypt; + } + + bool Subkey::canSign() const { + return d->subkey && d->subkey->can_sign; + } + + bool Subkey::canCertify() const { + return d->subkey && d->subkey->can_certify; + } + + bool Subkey::canAuthenticate() const { + return d->subkey && d->subkey->can_authenticate; + } + + bool Subkey::isSecret() const { + return d->subkey && d->subkey->secret; + } + + unsigned int Subkey::length() const { + return d->subkey ? d->subkey->length : 0 ; + } + + time_t Subkey::creationTime() const { + return static_cast<time_t>( d->subkey ? d->subkey->timestamp : 0 ); + } + + time_t Subkey::expirationTime() const { + return static_cast<time_t>( d->subkey ? d->subkey->expires : 0 ); + } + + bool Subkey::neverExpires() const { + return expirationTime() == time_t(0); + } + + bool Subkey::isRevoked() const { + return d->subkey && d->subkey->revoked; + } + + bool Subkey::isInvalid() const { + return d->subkey && d->subkey->invalid; + } + + bool Subkey::isExpired() const { + return d->subkey && d->subkey->expired; + } + + bool Subkey::isDisabled() const { + return d->subkey && d->subkey->disabled; + } + + // + // + // class UserID + // + // + + struct UserID::Private { + Private( gpgme_key_t aKey, unsigned int idx ) + : key( aKey ), uid( 0 ) + { + if ( key ) + for ( gpgme_user_id_t u = key->uids ; u ; u = u->next, --idx ) + if ( idx == 0 ) { + uid = u; + break; + } + if ( !uid ) + key = 0; + } + + Private( gpgme_key_t aKey, gpgme_user_id_t aUid ) + : key( aKey ), uid( 0 ) + { + if ( key ) + for ( gpgme_user_id_t u = key->uids ; u ; u = u->next ) + if ( u == aUid ) { + uid = u; + break; + } + if ( !uid ) + key = 0; + } + + gpgme_key_t key; + gpgme_user_id_t uid; + }; + + UserID::UserID( gpgme_key_t key, gpgme_user_id_t uid ) { + d = new Private( key, uid ); + if ( d->key ) + gpgme_key_ref( d->key ); + } + + UserID::UserID( gpgme_key_t key, unsigned int idx ) { + d = new Private( key, idx ); + if ( d->key ) + gpgme_key_ref( d->key ); + } + + UserID::UserID( const UserID & other ) { + d = new Private( other.d->key, other.d->uid ); + if ( d->key ) + gpgme_key_ref( d->key ); + } + + UserID::~UserID() { + if ( d->key ) + gpgme_key_unref( d->key ); + delete d; d = 0; + } + + const UserID & UserID::operator=( const UserID & other ) { + if ( &other == this ) return *this; + + if ( other.d->key ) + gpgme_key_ref( other.d->key ); + if ( d->key ) + gpgme_key_unref( d->key ); + *d = *other.d; + return *this; + } + + bool UserID::isNull() const { + return !d || !d->key || !d->uid; + } + + Key UserID::parent() const { + return Key( d->key, true ); + } + + UserID::Signature UserID::signature( unsigned int index ) const { + return Signature( d->key, d->uid, index ); + } + + unsigned int UserID::numSignatures() const { + if ( !d->uid ) + return 0; + unsigned int count = 0; + for ( gpgme_key_sig_t sig = d->uid->signatures ; sig ; sig = sig->next ) + ++count; + return count; + } + + vector<UserID::Signature> UserID::signatures() const { + if ( !d->uid ) + return vector<Signature>(); + + vector<Signature> v; + v.reserve( numSignatures() ); + for ( gpgme_key_sig_t sig = d->uid->signatures ; sig ; sig = sig->next ) + v.push_back( Signature( d->key, d->uid, sig ) ); + return v; + } + + const char * UserID::id() const { + return d->uid ? d->uid->uid : 0 ; + } + + const char * UserID::name() const { + return d->uid ? d->uid->name : 0 ; + } + + const char * UserID::email() const { + return d->uid ? d->uid->email : 0 ; + } + + const char * UserID::comment() const { + return d->uid ? d->uid->comment : 0 ; + } + + UserID::Validity UserID::validity() const { + if ( !d->uid ) + return Unknown; + switch ( d->uid->validity ) { + default: + case GPGME_VALIDITY_UNKNOWN: return Unknown; + case GPGME_VALIDITY_UNDEFINED: return Undefined; + case GPGME_VALIDITY_NEVER: return Never; + case GPGME_VALIDITY_MARGINAL: return Marginal; + case GPGME_VALIDITY_FULL: return Full; + case GPGME_VALIDITY_ULTIMATE: return Ultimate; + } + } + + char UserID::validityAsString() const { + if ( !d->uid ) + return '?'; + switch ( d->uid->validity ) { + default: + case GPGME_VALIDITY_UNKNOWN: return '?'; + case GPGME_VALIDITY_UNDEFINED: return 'q'; + case GPGME_VALIDITY_NEVER: return 'n'; + case GPGME_VALIDITY_MARGINAL: return 'm'; + case GPGME_VALIDITY_FULL: return 'f'; + case GPGME_VALIDITY_ULTIMATE: return 'u'; + } + } + + bool UserID::isRevoked() const { + return d->uid && d->uid->revoked; + } + + bool UserID::isInvalid() const { + return d->uid && d->uid->invalid; + } + + // + // + // class Signature + // + // + + struct UserID::Signature::Private { + Private( gpgme_key_t aKey, gpgme_user_id_t aUid, unsigned int idx ) + : key( aKey ), uid( 0 ), sig( 0 ) + { + if ( key ) + for ( gpgme_user_id_t u = key->uids ; u ; u = u->next ) + if ( u == aUid ) { + uid = u; + for ( gpgme_key_sig_t s = uid->signatures ; s ; s = s->next, --idx ) + if ( idx == 0 ) { + sig = s; + break; + } + break; + } + if ( !uid || !sig ) { + uid = 0; + sig = 0; + key = 0; + } + } + + Private( gpgme_key_t aKey, gpgme_user_id_t aUid, gpgme_key_sig_t aSig ) + : key( aKey ), uid( 0 ), sig( 0 ) + { + if ( key ) + for ( gpgme_user_id_t u = key->uids ; u ; u = u->next ) + if ( u == aUid ) { + uid = u; + for ( gpgme_key_sig_t s = uid->signatures ; s ; s = s->next ) + if ( s == aSig ) { + sig = s; + break; + } + break; + } + if ( !uid || !sig ) { + uid = 0; + sig = 0; + key = 0; + } + } + + gpgme_key_t key; + gpgme_user_id_t uid; + gpgme_key_sig_t sig; + }; + + UserID::Signature::Signature( gpgme_key_t key, gpgme_user_id_t uid, unsigned int idx ) { + d = new Private( key, uid, idx ); + if ( d->key ) + gpgme_key_ref( d->key ); + } + + UserID::Signature::Signature( gpgme_key_t key, gpgme_user_id_t uid, gpgme_key_sig_t sig ) { + d = new Private( key, uid, sig ); + if ( d->key ) + gpgme_key_ref( d->key ); + } + + UserID::Signature::Signature( const Signature & other ) { + d = new Private( other.d->key, other.d->uid, other.d->sig ); + if ( d->key ) + gpgme_key_ref( d->key ); + } + + UserID::Signature::~Signature() { + if ( d->key ) + gpgme_key_unref( d->key ); + delete d; d = 0; + } + + const UserID::Signature & UserID::Signature::operator=( const Signature & other ) { + if ( &other == this ) return *this; + + if ( other.d->key ) + gpgme_key_ref( other.d->key ); + if ( d->key ) + gpgme_key_unref( d->key ); + *d = *other.d; + return *this; + } + + bool UserID::Signature::isNull() const { + return !d || !d->key || !d->uid || !d->sig; + } + + UserID UserID::Signature::parent() const { + return UserID( d->key, d->uid ); + } + + const char * UserID::Signature::signerKeyID() const { + return d->sig ? d->sig->keyid : 0 ; + } + + const char * UserID::Signature::algorithmAsString() const { + return gpgme_pubkey_algo_name( d->sig ? d->sig->pubkey_algo : (gpgme_pubkey_algo_t)0 ); + } + + unsigned int UserID::Signature::algorithm() const { + return d->sig ? d->sig->pubkey_algo : 0 ; + } + + time_t UserID::Signature::creationTime() const { + return static_cast<time_t>( d->sig ? d->sig->timestamp : 0 ); + } + + time_t UserID::Signature::expirationTime() const { + return static_cast<time_t>( d->sig ? d->sig->expires : 0 ); + } + + bool UserID::Signature::neverExpires() const { + return expirationTime() == time_t(0); + } + + bool UserID::Signature::isRevokation() const { + return d->sig && d->sig->revoked; + } + + bool UserID::Signature::isInvalid() const { + return d->sig && d->sig->invalid; + } + + bool UserID::Signature::isExpired() const { + return d->sig && d->sig->expired; + } + + bool UserID::Signature::isExportable() const { + return d->sig && d->sig->exportable; + } + + const char * UserID::Signature::signerUserID() const { + return d->sig ? d->sig->uid : 0 ; + } + + const char * UserID::Signature::signerName() const { + return d->sig ? d->sig->name : 0 ; + } + + const char * UserID::Signature::signerEmail() const { + return d->sig ? d->sig->email : 0 ; + } + + const char * UserID::Signature::signerComment() const { + return d->sig ? d->sig->comment : 0 ; + } + + unsigned int UserID::Signature::certClass() const { + return d->sig ? d->sig->sig_class : 0 ; + } + + UserID::Signature::tqStatus UserID::Signature::status() const { + if ( !d->sig ) + return GeneralError; + + switch ( gpgme_err_code(d->sig->status) ) { + case GPG_ERR_NO_ERROR: return NoError; + case GPG_ERR_SIG_EXPIRED: return SigExpired; + case GPG_ERR_KEY_EXPIRED: return KeyExpired; + case GPG_ERR_BAD_SIGNATURE: return BadSignature; + case GPG_ERR_NO_PUBKEY: return NoPublicKey; + default: + case GPG_ERR_GENERAL: return GeneralError; + } + } + + const char * UserID::Signature::statusAsString() const { + return d->sig ? gpgme_strerror( d->sig->status ) : 0 ; + } + + UserID::Signature::Notation UserID::Signature::notation( unsigned int idx ) const { + return Notation( d->key, d->uid, d->sig, idx ); + } + + unsigned int UserID::Signature::numNotations() const { + if ( !d->sig ) + return 0; + unsigned int count = 0; +#ifdef HAVE_GPGME_KEY_SIG_NOTATIONS + for ( gpgme_sig_notation_t nota = d->sig->notations ; nota ; nota = nota->next ) + if ( nota->name ) ++count; // others are policy URLs... +#endif + return count; + } + + vector<UserID::Signature::Notation> UserID::Signature::notations() const { + if ( !d->sig ) + return vector<Notation>(); + vector<Notation> v; +#ifdef HAVE_GPGME_KEY_SIG_NOTATIONS + v.reserve( numNotations() ); + for ( gpgme_sig_notation_t nota = d->sig->notations ; nota ; nota = nota->next ) + if ( nota->name ) + v.push_back( Notation( d->key, d->uid, d->sig, nota ) ); +#endif + return v; + } + + const char * UserID::Signature::policyURL() const { +#ifdef HAVE_GPGME_KEY_SIG_NOTATIONS + if ( !d->sig ) + return 0; + for ( gpgme_sig_notation_t nota = d->sig->notations ; nota ; nota = nota->next ) + if ( !nota->name ) + return nota->value; +#endif + return 0; + } + + + + // + // + // class Notation + // + // + + struct UserID::Signature::Notation::Private { + Private( gpgme_key_t aKey, gpgme_user_id_t aUid, + gpgme_key_sig_t aSig, unsigned int idx ) + : key( aKey ), uid( 0 ), sig( 0 ), nota( 0 ) + { + if ( key ) + for ( gpgme_user_id_t u = key->uids ; u ; u = u->next ) + if ( u == aUid ) { + uid = u; + for ( gpgme_key_sig_t s = uid->signatures ; s ; s = s->next ) + if ( s == aSig ) { + sig = s; +#ifdef HAVE_GPGME_KEY_SIG_NOTATIONS + for ( gpgme_sig_notation_t n = sig->notations ; n ; n = n->next, --idx ) + if ( n == aNota ) { + nota = n; + break; + } +#else + (void)idx; +#endif + break; + } + break; + } + if ( !uid || !sig || !nota ) { + uid = 0; + sig = 0; + key = 0; + nota = 0; + } + } + + Private( gpgme_key_t aKey, gpgme_user_id_t aUid, + gpgme_key_sig_t aSig, gpgme_sig_notation_t aNota ) + : key( aKey ), uid( 0 ), sig( 0 ), nota( 0 ) + { + if ( key ) + for ( gpgme_user_id_t u = key->uids ; u ; u = u->next ) + if ( u == aUid ) { + uid = u; + for ( gpgme_key_sig_t s = uid->signatures ; s ; s = s->next ) + if ( s == aSig ) { + sig = s; +#ifdef HAVE_GPGME_KEY_SIG_NOTATIONS + for ( gpgme_sig_notation_t n = sig->notations ; n ; n = n->next ) + if ( n == aNota ) { + nota = n; + break; + } +#else + (void)aNota; +#endif + break; + } + break; + } + if ( !uid || !sig || !nota ) { + uid = 0; + sig = 0; + key = 0; + nota = 0; + } + } + + gpgme_key_t key; + gpgme_user_id_t uid; + gpgme_key_sig_t sig; + gpgme_sig_notation_t nota; + }; + + UserID::Signature::Notation::Notation( gpgme_key_t key, gpgme_user_id_t uid, + gpgme_key_sig_t sig, unsigned int idx ) { + d = new Private( key, uid, sig, idx ); + if ( d->key ) + gpgme_key_ref( d->key ); + } + + UserID::Signature::Notation::Notation( gpgme_key_t key, gpgme_user_id_t uid, + gpgme_key_sig_t sig, gpgme_sig_notation_t nota ) { + d = new Private( key, uid, sig, nota ); + if ( d->key ) + gpgme_key_ref( d->key ); + } + + UserID::Signature::Notation::Notation( const Notation & other ) { + d = new Private( other.d->key, other.d->uid, other.d->sig, other.d->nota ); + if ( d->key ) + gpgme_key_ref( d->key ); + } + + UserID::Signature::Notation::~Notation() { + if ( d->key ) + gpgme_key_unref( d->key ); + delete d; d = 0; + } + + const UserID::Signature::Notation & UserID::Signature::Notation::operator=( const Notation & other ) { + if ( &other == this ) return *this; + + if ( other.d->key ) + gpgme_key_ref( other.d->key ); + if ( d->key ) + gpgme_key_unref( d->key ); + *d = *other.d; + return *this; + } + + bool UserID::Signature::Notation::isNull() const { + return !d || !d->key || !d->uid || !d->sig || !d->nota; + } + + UserID::Signature UserID::Signature::Notation::parent() const { + return Signature( d->key, d->uid, d->sig ); + } + + const char * UserID::Signature::Notation::name() const { + return d->nota ? d->nota->name : 0 ; + } + + const char * UserID::Signature::Notation::value() const { + return d->nota ? d->nota->value : 0 ; + } + +} // namespace GpgME diff --git a/libtdenetwork/gpgmepp/key.h b/libtdenetwork/gpgmepp/key.h new file mode 100644 index 00000000..15d09371 --- /dev/null +++ b/libtdenetwork/gpgmepp/key.h @@ -0,0 +1,285 @@ +/* key.h - wraps a gpgme key + Copyright (C) 2003 Klarälvdalens Datakonsult AB + + This file is part of GPGME++. + + GPGME++ is free software; you can redistribute it and/or modify it + under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + GPGME++ is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + General Public License for more details. + + You should have received a copy of the GNU General Public License + along with GPGME; if not, write to the Free Software Foundation, + Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */ + +// -*- c++ -*- +#ifndef __GPGMEPP_KEY_H__ +#define __GPGMEPP_KEY_H__ + +#include <gpgmepp/gpgmefw.h> +#include <gpgmepp/context.h> + +#include <sys/time.h> + +#include <vector> +#include <tdepimmacros.h> + +namespace GpgME { + + class Subkey; + class UserID; + + // + // class Key + // + + class KDE_EXPORT Key { + friend class Context; + public: + Key(); + Key( gpgme_key_t key, bool acquireRef, unsigned int keyListMode=0 ); + Key( const Key & key ); + ~Key(); + + static Key null; + + const Key & operator=( const Key & other ); + + bool isNull() const; + + UserID userID( unsigned int index ) const; + Subkey subkey( unsigned int index ) const; + + unsigned int numUserIDs() const; + unsigned int numSubkeys() const; + + std::vector<UserID> userIDs() const; + std::vector<Subkey> subkeys() const; + + bool isRevoked() const; + bool isExpired() const; + bool isDisabled() const; + bool isInvalid() const; + + bool canEncrypt() const; + bool canSign() const; + bool canCertify() const; + bool canAuthenticate() const; + + bool hasSecret() const; + bool isSecret() const { return hasSecret(); } + + /*! + @return true if this is a X.509 root certificate (currently + equivalent to something like + strcmp( chainID(), subkey(0).fingerprint() ) == 0 ) + */ + bool isRoot() const; + + enum OwnerTrust { Unknown=0, Undefined=1, Never=2, + Marginal=3, Full=4, Ultimate=5 }; + + OwnerTrust ownerTrust() const; + char ownerTrustAsString() const; + + typedef Context::Protocol Protocol; + Protocol protocol() const; + const char * protocolAsString() const; + + const char * issuerSerial() const; + const char * issuerName() const; + const char * chainID() const; + + const char * keyID() const; + const char * shortKeyID() const; + const char * primaryFingerprint() const; + + typedef Context::KeyListMode KeyListMode; + unsigned int keyListMode() const; + + private: + gpgme_key_t impl() const; + class Private; + Private * d; + }; + + // + // class Subkey + // + + class KDE_EXPORT Subkey { + public: + Subkey( gpgme_key_t key=0, gpgme_sub_key_t subkey=0 ); + Subkey( gpgme_key_t key, unsigned int idx ); + Subkey( const Subkey & other ); + ~Subkey(); + + const Subkey & operator=( const Subkey & other ); + + bool isNull() const; + + Key parent() const; + + const char * keyID() const; + const char * fingerprint() const; + + time_t creationTime() const; + time_t expirationTime() const; + bool neverExpires() const; + + bool isRevoked() const; + bool isExpired() const; + bool isInvalid() const; + bool isDisabled() const; + + bool canEncrypt() const; + bool canSign() const; + bool canCertify() const; + bool canAuthenticate() const; + + bool isSecret() const; + + unsigned int publicKeyAlgorithm() const; + const char * publicKeyAlgorithmAsString() const; + + unsigned int length() const; + + private: + class Private; + Private * d; + }; + + // + // class UserID + // + + class KDE_EXPORT UserID { + public: + class Signature; + + UserID( gpgme_key_t key=0, gpgme_user_id_t uid=0 ); + UserID( gpgme_key_t key, unsigned int idx ); + UserID( const UserID & other ); + ~UserID(); + + const UserID & operator=( const UserID & other ); + + bool isNull() const; + + Key parent() const; + + unsigned int numSignatures() const; + Signature signature( unsigned int index ) const; + std::vector<Signature> signatures() const; + + const char * id() const; + const char * name() const; + const char * email() const; + const char * comment() const; + + enum Validity { Unknown=0, Undefined=1, Never=2, + Marginal=3, Full=4, Ultimate=5 }; + + Validity validity() const; + char validityAsString() const; + + bool isRevoked() const; + bool isInvalid() const; + + private: + class Private; + Private * d; + }; + + // + // class UserID::Signature + // + + class KDE_EXPORT UserID::Signature { + public: + class Notation; + + Signature( gpgme_key_t key=0, gpgme_user_id_t uid=0, gpgme_key_sig_t sig=0 ); + Signature( gpgme_key_t key, gpgme_user_id_t uid, unsigned int idx ); + Signature( const Signature & other ); + ~Signature(); + + const Signature & operator=( const Signature & other ); + + bool isNull() const; + + UserID parent() const; + + const char * signerKeyID() const; + + const char * algorithmAsString() const; + unsigned int algorithm() const; + time_t creationTime() const; + time_t expirationTime() const; + bool neverExpires() const; + + bool isRevokation() const; + bool isInvalid() const; + bool isExpired() const; + bool isExportable() const; + + const char * signerUserID() const; + const char * signerName() const; + const char * signerEmail() const; + const char * signerComment() const; + + unsigned int certClass() const; + + enum tqStatus { NoError = 0, SigExpired, KeyExpired, + BadSignature, NoPublicKey, GeneralError }; + tqStatus status() const; + const char * statusAsString() const; + + const char * policyURL() const; + + unsigned int numNotations() const; + Notation notation( unsigned int idx ) const; + std::vector<Notation> notations() const; + + private: + class Private; + Private * d; + }; + + // + // + // class UserID::Signature::Notation + // + // + + class KDE_EXPORT UserID::Signature::Notation { + public: + Notation( gpgme_key_t key=0, gpgme_user_id_t uid=0, + gpgme_key_sig_t sig=0, gpgme_sig_notation_t nota=0 ); + Notation( gpgme_key_t key, gpgme_user_id_t uid, + gpgme_key_sig_t sig, unsigned int idx ); + Notation( const Notation & other ); + ~Notation(); + + const Notation & operator=( const Notation & other ); + + bool isNull() const; + + Signature parent() const; + + const char * name() const; + const char * value() const; + + private: + class Private; + Private * d; + }; + +} // namespace GpgME + +#endif // __GPGMEPP_KEY_H__ diff --git a/libtdenetwork/gpgmepp/keygenerationresult.cpp b/libtdenetwork/gpgmepp/keygenerationresult.cpp new file mode 100644 index 00000000..76045ee2 --- /dev/null +++ b/libtdenetwork/gpgmepp/keygenerationresult.cpp @@ -0,0 +1,73 @@ +/* keygenerationresult.cpp - wraps a gpgme keygen result + Copyright (C) 2004 Klarälvdalens Datakonsult AB + + This file is part of GPGME++. + + GPGME++ is free software; you can redistribute it and/or modify it + under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + GPGME++ is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + General Public License for more details. + + You should have received a copy of the GNU General Public License + along with GPGME++; if not, write to the Free Software Foundation, + Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. +*/ + +#ifdef HAVE_CONFIG_H +#include <config.h> +#endif + +#include <gpgmepp/keygenerationresult.h> +#include "shared.h" +#include "result_p.h" + +#include <gpgme.h> + +#include <cstring> +#include <cstdlib> + +class GpgME::KeyGenerationResult::Private : public GpgME::Shared { +public: + Private( const _gpgme_op_genkey_result & r ) : Shared(), res( r ) { + if ( res.fpr ) + res.fpr = strdup( res.fpr ); + } + ~Private() { + if ( res.fpr ) + std::free( res.fpr ); + res.fpr = 0; + } + + _gpgme_op_genkey_result res; +}; + +GpgME::KeyGenerationResult::KeyGenerationResult( gpgme_ctx_t ctx, int error ) + : GpgME::Result( error ), d( 0 ) +{ + if ( error || !ctx ) + return; + gpgme_genkey_result_t res = gpgme_op_genkey_result( ctx ); + if ( !res ) + return; + d = new Private( *res ); + d->ref(); +} + +make_standard_stuff(KeyGenerationResult) + +bool GpgME::KeyGenerationResult::primaryKeyGenerated() const { + return d && d->res.primary; +} + +bool GpgME::KeyGenerationResult::subkeyGenerated() const { + return d && d->res.sub; +} + +const char * GpgME::KeyGenerationResult::fingerprint() const { + return d ? d->res.fpr : 0 ; +} diff --git a/libtdenetwork/gpgmepp/keygenerationresult.h b/libtdenetwork/gpgmepp/keygenerationresult.h new file mode 100644 index 00000000..7b2d98e8 --- /dev/null +++ b/libtdenetwork/gpgmepp/keygenerationresult.h @@ -0,0 +1,53 @@ +/* keygenerationresult.h - wraps a gpgme keygen result + Copyright (C) 2004 Klarälvdalens Datakonsult AB + + This file is part of GPGME++. + + GPGME++ is free software; you can redistribute it and/or modify it + under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + GPGME++ is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + General Public License for more details. + + You should have received a copy of the GNU General Public License + along with GPGME++; if not, write to the Free Software Foundation, + Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. +*/ + +#ifndef __GPGMEPP_KEYGENERATIONRESULT_H__ +#define __GPGMEPP_KEYGENERATIONRESULT_H__ + +#include <gpgmepp/gpgmefw.h> +#include <gpgmepp/result.h> +#include <tdepimmacros.h> +namespace GpgME { + + class Error; + + class KDE_EXPORT KeyGenerationResult : public Result { + public: + KeyGenerationResult( gpgme_ctx_t ctx=0, int error=0 ); + explicit KeyGenerationResult( const Error & err ); + KeyGenerationResult( const KeyGenerationResult & other ); + ~KeyGenerationResult(); + + const KeyGenerationResult & operator=( const KeyGenerationResult & other ); + + bool isNull() const; + + bool primaryKeyGenerated() const; + bool subkeyGenerated() const; + const char * fingerprint() const; + + private: + class Private; + Private * d; + }; + +} + +#endif // __GPGMEPP_KEYGENERATIONRESULT_H__ diff --git a/libtdenetwork/gpgmepp/keylistresult.cpp b/libtdenetwork/gpgmepp/keylistresult.cpp new file mode 100644 index 00000000..17dc3a46 --- /dev/null +++ b/libtdenetwork/gpgmepp/keylistresult.cpp @@ -0,0 +1,92 @@ +/* keylistresult.cpp - wraps a gpgme keylist result + Copyright (C) 2004 Klarälvdalens Datakonsult AB + + This file is part of GPGME++. + + GPGME++ is free software; you can redistribute it and/or modify it + under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + GPGME++ is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + General Public License for more details. + + You should have received a copy of the GNU General Public License + along with GPGME++; if not, write to the Free Software Foundation, + Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. +*/ + +#ifdef HAVE_CONFIG_H +#include <config.h> +#endif + +#include <gpgmepp/keylistresult.h> +#include "shared.h" +#include "result_p.h" + +#include <gpgme.h> + +#include <cstring> +#include <cassert> + +class GpgME::KeyListResult::Private : public GpgME::Shared { +public: + Private( const _gpgme_op_keylist_result & r ) : Shared(), res( r ) {} + Private( const Private & other ) : Shared(), res( other.res ) {} + + _gpgme_op_keylist_result res; +}; + +GpgME::KeyListResult::KeyListResult( gpgme_ctx_t ctx, int error ) + : GpgME::Result( error ), d( 0 ) +{ + if ( error || !ctx ) + return; + gpgme_keylist_result_t res = gpgme_op_keylist_result( ctx ); + if ( !res ) + return; + d = new Private( *res ); + d->ref(); +} + +GpgME::KeyListResult::KeyListResult( const Error & error, const _gpgme_op_keylist_result & res ) + : GpgME::Result( error ), d( 0 ) +{ + d = new Private( res ); + d->ref(); +} + +make_standard_stuff(KeyListResult) + +void GpgME::KeyListResult::detach() { + if ( !d || d->refCount() <= 1 ) + return; + d->unref(); + d = new Private( *d ); +} + +void GpgME::KeyListResult::mergeWith( const KeyListResult & other ) { + if ( other.isNull() ) + return; + if ( isNull() ) { // just assign + operator=( other ); + return; + } + // merge the truncated flag (try to keep detaching to a minimum): + if ( other.isTruncated() && !this->isTruncated() ) { + assert( other.d ); + detach(); + if ( !d ) + d = new Private( *other.d ); + else + d->res.truncated = true; + } + if ( !error() ) // only merge the error when there was none yet. + Result::operator=( other ); +} + +bool GpgME::KeyListResult::isTruncated() const { + return d && d->res.truncated; +} diff --git a/libtdenetwork/gpgmepp/keylistresult.h b/libtdenetwork/gpgmepp/keylistresult.h new file mode 100644 index 00000000..068210c0 --- /dev/null +++ b/libtdenetwork/gpgmepp/keylistresult.h @@ -0,0 +1,62 @@ +/* keylistresult.h - wraps a gpgme keylist result + Copyright (C) 2004 Klarälvdalens Datakonsult AB + + This file is part of GPGME++. + + GPGME++ is free software; you can redistribute it and/or modify it + under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + GPGME++ is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + General Public License for more details. + + You should have received a copy of the GNU General Public License + along with GPGME++; if not, write to the Free Software Foundation, + Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. +*/ + +#ifndef __GPGMEPP_KEYLISTRESULT_H__ +#define __GPGMEPP_KEYLISTRESULT_H__ + +#include <gpgmepp/gpgmefw.h> +#include <gpgmepp/result.h> +#include <tdepimmacros.h> + +namespace GpgME { + + class Context; + class Error; + + class KDE_EXPORT KeyListResult : public Result { + public: + KeyListResult( gpgme_ctx_t ctx=0, int error=0 ); + explicit KeyListResult( const Error & err ); + KeyListResult( const Error & err, const _gpgme_op_keylist_result & res ); + KeyListResult( const KeyListResult & other ); + ~KeyListResult(); + + const KeyListResult & operator=( const KeyListResult & other ); + + const KeyListResult & operator+=( const KeyListResult & other ) { + mergeWith( other ); + return *this; + } + + void mergeWith( const KeyListResult & other ); + + bool isNull() const; + + bool isTruncated() const; + + private: + void detach(); + class Private; + Private * d; + }; + +} + +#endif // __GPGMEPP_KEYLISTRESULT_H__ diff --git a/libtdenetwork/gpgmepp/result.h b/libtdenetwork/gpgmepp/result.h new file mode 100644 index 00000000..aa91cf98 --- /dev/null +++ b/libtdenetwork/gpgmepp/result.h @@ -0,0 +1,47 @@ +/* result.h - base class for results + Copyright (C) 2004 Klarälvdalens Datakonsult AB + + This file is part of GPGME++. + + GPGME++ is free software; you can redistribute it and/or modify it + under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + GPGME++ is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + General Public License for more details. + + You should have received a copy of the GNU General Public License + along with GPGME++; if not, write to the Free Software Foundation, + Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. +*/ + +#ifndef __GPGMEPP_RESULT_H__ +#define __GPGMEPP_RESULT_H__ + +#include <gpgmepp/gpgmefw.h> +#include <gpgmepp/context.h> + +namespace GpgME { + + class Result { + public: + Result( int error=0 ) : mError( error ) {} + Result( const Result & other ) : mError( other.error() ) {} + + const Result & operator=( const Result & other ) { + mError = other.mError; + return *this; + } + + const Error & error() const { return mError; } + + private: + Error mError; + }; + +} + +#endif // __GPGMEPP_RESULT_H__ diff --git a/libtdenetwork/gpgmepp/result_p.h b/libtdenetwork/gpgmepp/result_p.h new file mode 100644 index 00000000..cc1d2793 --- /dev/null +++ b/libtdenetwork/gpgmepp/result_p.h @@ -0,0 +1,69 @@ +/* result.h - base class for results + Copyright (C) 2004 Klarälvdalens Datakonsult AB + + This file is part of GPGME++. + + GPGME++ is free software; you can redistribute it and/or modify it + under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + GPGME++ is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + General Public License for more details. + + You should have received a copy of the GNU General Public License + along with GPGME++; if not, write to the Free Software Foundation, + Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. +*/ + +#ifndef __GPGMEPP_RESULT_P_H__ +#define __GPGMEPP_RESULT_P_H__ + +#define make_copy_ctor(x) \ +GpgME::x::x( const x & other ) \ + : GpgME::Result( other ), d( other.d ) \ +{ \ + if ( d ) \ + d->ref(); \ +} + +#define make_error_ctor(x) \ +GpgME::x::x( const Error & error ) \ + : GpgME::Result( error ), d( 0 ) \ +{ \ + \ +} + +#define make_assignment_operator(x) \ +const GpgME::x & GpgME::x::operator=( const x & other ) { \ + if ( other.d ) \ + other.d->ref(); \ + if ( this->d ) \ + this->d->unref(); \ + this->d = other.d; \ + \ + Result::operator=( other ); \ + \ + return *this; \ +} + +#define make_dtor(x) \ +GpgME::x::~x() { \ + if ( d ) \ + d->unref(); \ + d = 0; \ +} + +#define make_isNull(x) bool GpgME::x::isNull() const { return !d && !error(); } + +#define make_standard_stuff(x) \ +make_copy_ctor(x) \ +make_error_ctor(x) \ +make_assignment_operator(x) \ +make_isNull(x) \ +make_dtor(x) + + +#endif // __GPGMEPP_RESULT_P_H__ diff --git a/libtdenetwork/gpgmepp/shared.h b/libtdenetwork/gpgmepp/shared.h new file mode 100644 index 00000000..f9c79e0c --- /dev/null +++ b/libtdenetwork/gpgmepp/shared.h @@ -0,0 +1,54 @@ +/* shared.h - internal tool for refcounting -*- c++ -*- + Copyright (C) 2003 Klarälvdalens Datakonsult AB + + This file is part of GPGME++. + + GPGME++ is free software; you can redistribute it and/or modify it + under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + GPGME++ is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + General Public License for more details. + + You should have received a copy of the GNU General Public License + along with GPGME; if not, write to the Free Software Foundation, + Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. +*/ + +#ifndef __GPGMEPP_SHARED_H__ +#define __GPGMEPP_SHARED_H__ + +#include <cassert> + +namespace GpgME { + + class Shared { + protected: + Shared() : mRefCount( 0 ) {} + virtual ~Shared() { + assert( mRefCount <= 0 ); + } + + public: + int ref() { return ++mRefCount; } + int deref() { return unref(); } + int unref() { + if ( --mRefCount <= 0 ) { + delete this; + return 0; + } + return mRefCount; + } + int refCount() { return mRefCount; } + + private: + int mRefCount; + }; + +} + + +#endif // __GPGMEPP_SHARED_H__ diff --git a/libtdenetwork/gpgmepp/signingresult.cpp b/libtdenetwork/gpgmepp/signingresult.cpp new file mode 100644 index 00000000..6996eef7 --- /dev/null +++ b/libtdenetwork/gpgmepp/signingresult.cpp @@ -0,0 +1,283 @@ +/* signingresult.cpp - wraps a gpgme verify result + Copyright (C) 2004 Klarälvdalens Datakonsult AB + + This file is part of GPGME++. + + GPGME++ is free software; you can redistribute it and/or modify it + under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + GPGME++ is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + General Public License for more details. + + You should have received a copy of the GNU General Public License + along with GPGME++; if not, write to the Free Software Foundation, + Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. +*/ + +#ifdef HAVE_CONFIG_H +#include <config.h> +#endif + +#include <gpgmepp/signingresult.h> +#include "shared.h" +#include "result_p.h" +#include "util.h" + +#include <gpgme.h> + +#include <cstring> +#include <cstdlib> +#include <algorithm> +#include <istream> +#include <iterator> + +class GpgME::SigningResult::Private : public GpgME::Shared { +public: + Private( const gpgme_sign_result_t r ) : Shared() { + if ( !r ) + return; + for ( gpgme_new_signature_t is = r->signatures ; is ; is = is->next ) { + gpgme_new_signature_t copy = new _gpgme_new_signature( *is ); + if ( is->fpr ) + copy->fpr = strdup( is->fpr ); + copy->next = 0; + created.push_back( copy ); + } + for ( gpgme_invalid_key_t ik = r->invalid_signers ; ik ; ik = ik->next ) { + gpgme_invalid_key_t copy = new _gpgme_invalid_key( *ik ); + if ( ik->fpr ) + copy->fpr = strdup( ik->fpr ); + copy->next = 0; + invalid.push_back( copy ); + } + } + ~Private() { + for ( std::vector<gpgme_new_signature_t>::iterator it = created.begin() ; it != created.end() ; ++it ) { + std::free( (*it)->fpr ); + delete *it; *it = 0; + } + for ( std::vector<gpgme_invalid_key_t>::iterator it = invalid.begin() ; it != invalid.end() ; ++it ) { + std::free( (*it)->fpr ); + delete *it; *it = 0; + } + } + + std::vector<gpgme_new_signature_t> created; + std::vector<gpgme_invalid_key_t> invalid; +}; + +GpgME::SigningResult::SigningResult( gpgme_ctx_t ctx, int error ) + : GpgME::Result( error ), d( 0 ) +{ + if ( error || !ctx ) + return; + gpgme_sign_result_t res = gpgme_op_sign_result( ctx ); + if ( !res ) + return; + d = new Private( res ); + d->ref(); +} + +make_standard_stuff(SigningResult) + +GpgME::CreatedSignature GpgME::SigningResult::createdSignature( unsigned int idx ) const { + return CreatedSignature( d, idx ); +} + +std::vector<GpgME::CreatedSignature> GpgME::SigningResult::createdSignatures() const { + if ( !d ) + return std::vector<CreatedSignature>(); + std::vector<CreatedSignature> result; + result.reserve( d->created.size() ); + for ( unsigned int i = 0 ; i < d->created.size() ; ++i ) + result.push_back( CreatedSignature( d, i ) ); + return result; +} + + +GpgME::InvalidSigningKey GpgME::SigningResult::invalidSigningKey( unsigned int idx ) const { + return InvalidSigningKey( d, idx ); +} + +std::vector<GpgME::InvalidSigningKey> GpgME::SigningResult::invalidSigningKeys() const { + if ( !d ) + return std::vector<GpgME::InvalidSigningKey>(); + std::vector<GpgME::InvalidSigningKey> result; + result.reserve( d->invalid.size() ); + for ( unsigned int i = 0 ; i < d->invalid.size() ; ++i ) + result.push_back( InvalidSigningKey( d, i ) ); + return result; +} + + + + +GpgME::InvalidSigningKey::InvalidSigningKey( SigningResult::Private * parent, unsigned int i ) + : d( parent ), idx( i ) +{ + if ( d ) + d->ref(); +} + +GpgME::InvalidSigningKey::InvalidSigningKey() : d( 0 ), idx( 0 ) {} + +GpgME::InvalidSigningKey::InvalidSigningKey( const InvalidSigningKey & other ) + : d( other.d ), idx( other.idx ) +{ + if ( d ) + d->ref(); +} + +GpgME::InvalidSigningKey::~InvalidSigningKey() { + if ( d ) + d->unref(); +} + +const GpgME::InvalidSigningKey & GpgME::InvalidSigningKey::operator=( const InvalidSigningKey & other ) { + if ( this->d != other.d ) { + if ( other.d ) + other.d->ref(); + if ( this->d ) + this->d->unref(); + this->d = other.d; + } + + this->idx = other.idx; + return *this; +} + + +bool GpgME::InvalidSigningKey::isNull() const { + return !d || idx >= d->invalid.size() ; +} + +const char * GpgME::InvalidSigningKey::fingerprint() const { + return isNull() ? 0 : d->invalid[idx]->fpr ; +} + +GpgME::Error GpgME::InvalidSigningKey::reason() const { + return isNull() ? 0 : d->invalid[idx]->reason ; +} + + + +GpgME::CreatedSignature::CreatedSignature( SigningResult::Private * parent, unsigned int i ) + : d( parent ), idx( i ) +{ + if ( d ) + d->ref(); +} + +GpgME::CreatedSignature::CreatedSignature() : d( 0 ), idx( 0 ) {} + +GpgME::CreatedSignature::CreatedSignature( const CreatedSignature & other ) + : d( other.d ), idx( other.idx ) +{ + if ( d ) + d->ref(); +} + +GpgME::CreatedSignature::~CreatedSignature() { + if ( d ) + d->unref(); +} + +const GpgME::CreatedSignature & GpgME::CreatedSignature::operator=( const CreatedSignature & other ) { + if ( this->d != other.d ) { + if ( other.d ) + other.d->ref(); + if ( this->d ) + this->d->unref(); + this->d = other.d; + } + + this->idx = other.idx; + return *this; +} + + +bool GpgME::CreatedSignature::isNull() const { + return !d || idx >= d->created.size() ; +} + +const char * GpgME::CreatedSignature::fingerprint() const { + return isNull() ? 0 : d->created[idx]->fpr ; +} + +time_t GpgME::CreatedSignature::creationTime() const { + return static_cast<time_t>( isNull() ? 0 : d->created[idx]->timestamp ); +} + +GpgME::Context::SignatureMode GpgME::CreatedSignature::mode() const { + if ( isNull() ) + return Context::Normal; + switch ( d->created[idx]->type ) { + default: + case GPGME_SIG_MODE_NORMAL: return Context::Normal; + case GPGME_SIG_MODE_DETACH: return Context::Detached; + case GPGME_SIG_MODE_CLEAR: return Context::Clearsigned; + } +} + +unsigned int GpgME::CreatedSignature::publicKeyAlgorithm() const { + return isNull() ? 0 : d->created[idx]->pubkey_algo ; +} + +const char * GpgME::CreatedSignature::publicKeyAlgorithmAsString() const { + return gpgme_pubkey_algo_name( isNull() ? (gpgme_pubkey_algo_t)0 : d->created[idx]->pubkey_algo ); +} + +unsigned int GpgME::CreatedSignature::hashAlgorithm() const { + return isNull() ? 0 : d->created[idx]->hash_algo ; +} + +const char * GpgME::CreatedSignature::hashAlgorithmAsString() const { + return gpgme_hash_algo_name( isNull() ? (gpgme_hash_algo_t)0 : d->created[idx]->hash_algo ); +} + +unsigned int GpgME::CreatedSignature::signatureClass() const { + return isNull() ? 0 : d->created[idx]->sig_class ; +} + + +std::ostream & GpgME::operator<<( std::ostream & os, const SigningResult & result ) { + os << "GpgME::SigningResult("; + if ( !result.isNull() ) { + os << "\n error: " << result.error() + << "\n createdSignatures:\n"; + const std::vector<CreatedSignature> cs = result.createdSignatures(); + std::copy( cs.begin(), cs.end(), + std::ostream_iterator<CreatedSignature>( os, "\n" ) ); + os << " invalidSigningKeys:\n"; + const std::vector<InvalidSigningKey> isk = result.invalidSigningKeys(); + std::copy( isk.begin(), isk.end(), + std::ostream_iterator<InvalidSigningKey>( os, "\n" ) ); + } + return os << ')'; +} + +std::ostream & GpgME::operator<<( std::ostream & os, const CreatedSignature & sig ) { + os << "GpgME::CreatedSignature("; + if ( !sig.isNull() ) + os << "\n fingerprint: " << protect( sig.fingerprint() ) + << "\n creationTime: " << sig.creationTime() + << "\n mode: " << sig.mode() + << "\n publicKeyAlgorithm: " << protect( sig.publicKeyAlgorithmAsString() ) + << "\n hashAlgorithm: " << protect( sig.hashAlgorithmAsString() ) + << "\n signatureClass: " << sig.signatureClass() + << '\n'; + return os << ')'; +} + +std::ostream & GpgME::operator<<( std::ostream & os, const InvalidSigningKey & key ) { + os << "GpgME::InvalidSigningKey("; + if ( !key.isNull() ) + os << "\n fingerprint: " << protect( key.fingerprint() ) + << "\n reason: " << key.reason() + << '\n'; + return os << ')'; +} diff --git a/libtdenetwork/gpgmepp/signingresult.h b/libtdenetwork/gpgmepp/signingresult.h new file mode 100644 index 00000000..1ee7a8de --- /dev/null +++ b/libtdenetwork/gpgmepp/signingresult.h @@ -0,0 +1,124 @@ +/* signingresult.h - wraps a gpgme sign result + Copyright (C) 2004 Klarälvdalens Datakonsult AB + + This file is part of GPGME++. + + GPGME++ is free software; you can redistribute it and/or modify it + under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + GPGME++ is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + General Public License for more details. + + You should have received a copy of the GNU General Public License + along with GPGME++; if not, write to the Free Software Foundation, + Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. +*/ + +#ifndef __GPGMEPP_SIGNINGRESULT_H__ +#define __GPGMEPP_SIGNINGRESULT_H__ + +#include <gpgmepp/gpgmefw.h> +#include <gpgmepp/result.h> +#include <gpgmepp/context.h> + +#include <time.h> + +#include <vector> +#include <iosfwd> + +#include <tdepimmacros.h> + +namespace GpgME { + + class Error; + class CreatedSignature; + class InvalidSigningKey; + + class KDE_EXPORT SigningResult : public Result { + public: + SigningResult( gpgme_ctx_t ctx=0, int error=0 ); + explicit SigningResult( const Error & err ); + SigningResult( const SigningResult & other ); + ~SigningResult(); + + const SigningResult & operator=( const SigningResult & other ); + + bool isNull() const; + + CreatedSignature createdSignature( unsigned int index ) const; + std::vector<CreatedSignature> createdSignatures() const; + + InvalidSigningKey invalidSigningKey( unsigned int index ) const; + std::vector<InvalidSigningKey> invalidSigningKeys() const; + + class Private; + private: + Private * d; + }; + + KDE_EXPORT std::ostream & operator<<( std::ostream & os, const SigningResult & result ); + + class KDE_EXPORT InvalidSigningKey { + friend class SigningResult; + InvalidSigningKey( SigningResult::Private * parent, unsigned int index ); + public: + InvalidSigningKey(); + InvalidSigningKey( const InvalidSigningKey & other ); + ~InvalidSigningKey(); + + const InvalidSigningKey & operator=( const InvalidSigningKey & other ); + + bool isNull() const; + + const char * fingerprint() const; + Error reason() const; + + private: + SigningResult::Private * d; + unsigned int idx; + }; + + KDE_EXPORT std::ostream & operator<<( std::ostream & os, const InvalidSigningKey & key ); + + class KDE_EXPORT CreatedSignature { + friend class SigningResult; + CreatedSignature( SigningResult::Private * parent, unsigned int index ); + public: + class Notation; + + CreatedSignature(); + CreatedSignature( const CreatedSignature & other ); + ~CreatedSignature(); + + const CreatedSignature & operator=( const CreatedSignature & other ); + + bool isNull() const; + + const char * fingerprint() const; + + time_t creationTime() const; + + Context::SignatureMode mode() const; + + unsigned int publicKeyAlgorithm() const; + const char * publicKeyAlgorithmAsString() const; + + unsigned int hashAlgorithm() const; + const char * hashAlgorithmAsString() const; + + unsigned int signatureClass() const; + + private: + SigningResult::Private * d; + unsigned int idx; + }; + + KDE_EXPORT std::ostream & operator<<( std::ostream & os, const CreatedSignature & sig ); + +} + +#endif // __GPGMEPP_SIGNINGRESULT_H__ diff --git a/libtdenetwork/gpgmepp/trustitem.cpp b/libtdenetwork/gpgmepp/trustitem.cpp new file mode 100644 index 00000000..59840ebb --- /dev/null +++ b/libtdenetwork/gpgmepp/trustitem.cpp @@ -0,0 +1,109 @@ +/* trustitem.cpp - wraps a gpgme trust item + Copyright (C) 2003 Klarälvdalens Datakonsult AB + + This file is part of GPGME. + + GPGME is free software; you can redistribute it and/or modify it + under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + GPGME is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + General Public License for more details. + + You should have received a copy of the GNU General Public License + along with GPGME; if not, write to the Free Software Foundation, + Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */ + +#ifdef HAVE_CONFIG_H +#include <config.h> +#endif + +#include <gpgmepp/trustitem.h> + +#include <gpgme.h> + +#include <cassert> + +namespace GpgME { + + struct TrustItem::Private { + Private( gpgme_trust_item_t aItem ) + : item( aItem ) + { + } + + gpgme_trust_item_t item; + }; + + TrustItem::TrustItem( gpgme_trust_item_t item ) { + d = new Private( item ); + if ( d->item ) + gpgme_trust_item_ref( d->item ); + } + + TrustItem::TrustItem( const TrustItem & other ) { + d = new Private( other.d->item ); + if ( d->item ) + gpgme_trust_item_ref( d->item ); + } + + const TrustItem & TrustItem::operator=( const TrustItem & other ) { + if ( &other == this ) return *this; + + if ( other.d->item ) + gpgme_trust_item_ref( other.d->item ); + if ( d->item ) + gpgme_trust_item_unref( d->item ); + *d = *other.d; + return *this; + } + + TrustItem::~TrustItem() { + if ( d->item ) + gpgme_trust_item_unref( d->item ); + delete d; d = 0; + } + + bool TrustItem::isNull() const { + return !d || !d->item; + } + + gpgme_trust_item_t TrustItem::impl() const { + return d->item; + } + + + const char * TrustItem::keyID() const { + return d->item ? d->item->keyid : 0 ; + } + + const char * TrustItem::userID() const { + return d->item ? d->item->name : 0 ; + } + + const char * TrustItem::ownerTrustAsString() const { + return d->item ? d->item->owner_trust : 0 ; + } + + const char * TrustItem::validityAsString() const { + return d->item ? d->item->validity : 0 ; + } + + int TrustItem::trustLevel() const { + return d->item ? d->item->level : 0 ; + } + + TrustItem::Type TrustItem::type() const { + if ( !d->item ) + return Unknown; + else + return + d->item->type == 1 ? Key : + d->item->type == 2 ? UserID : + Unknown ; + } + +} // namespace GpgME diff --git a/libtdenetwork/gpgmepp/trustitem.h b/libtdenetwork/gpgmepp/trustitem.h new file mode 100644 index 00000000..61c74617 --- /dev/null +++ b/libtdenetwork/gpgmepp/trustitem.h @@ -0,0 +1,61 @@ +/* trustitem.h - wraps a gpgme trust item + Copyright (C) 2003 Klarälvdalens Datakonsult AB + + This file is part of GPGME. + + GPGME is free software; you can redistribute it and/or modify it + under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + GPGME is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + General Public License for more details. + + You should have received a copy of the GNU General Public License + along with GPGME; if not, write to the Free Software Foundation, + Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */ + +// -*- c++ -*- +#ifndef __GPGMEPP_TRUSTITEM_H__ +#define __GPGMEPP_TRUSTITEM_H__ + +#include <gpgmepp/gpgmefw.h> +#include <gpgmepp/key.h> + +namespace GpgME { + + class Context; + + class TrustItem { + friend class Context; + public: + TrustItem( gpgme_trust_item_t item=0 ); + TrustItem( const TrustItem & other ); + virtual ~TrustItem(); + + const TrustItem & operator=( const TrustItem & other ); + + bool isNull() const; + + const char * keyID() const; + const char * userID() const; + + const char * ownerTrustAsString() const; + const char * validityAsString() const; + + int trustLevel() const; + + enum Type { Unknown=0, Key=1, UserID=2 }; + Type type() const; + + private: + gpgme_trust_item_t impl() const; + class Private; + Private * d; + }; + +} // namepace GpgME + +#endif // __GPGMEPP_TRUSTITEM_H__ diff --git a/libtdenetwork/gpgmepp/util.h b/libtdenetwork/gpgmepp/util.h new file mode 100644 index 00000000..8246cfc3 --- /dev/null +++ b/libtdenetwork/gpgmepp/util.h @@ -0,0 +1,75 @@ +/* util.h - some inline helper functions + Copyright (C) 2004 Klarälvdalens Datakonsult AB + + This file is part of GPGME++. + + GPGME++ is free software; you can redistribute it and/or modify it + under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + GPGME++ is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + General Public License for more details. + + You should have received a copy of the GNU General Public License + along with GPGME; if not, write to the Free Software Foundation, + Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */ + +// -*- c++ -*- +#ifndef __GPGMEPP_UTIL_H__ +#define __GPGMEPP_UTIL_H__ + +#include <gpgme.h> +#include <context.h> + +#ifndef NDEBUG +#include <iostream> +#endif + +static inline const char * protect( const char * s ) { + return s ? s : "<null>" ; +} + +static inline gpgme_keylist_mode_t add_to_gpgme_keylist_mode_t( unsigned int oldmode, unsigned int newmodes ) { + if ( newmodes & GpgME::Context::Local ) oldmode |= GPGME_KEYLIST_MODE_LOCAL; + if ( newmodes & GpgME::Context::Extern ) oldmode |= GPGME_KEYLIST_MODE_EXTERN; + if ( newmodes & GpgME::Context::Signatures ) oldmode |= GPGME_KEYLIST_MODE_SIGS; + if ( newmodes & GpgME::Context::Validate ) { +#ifdef HAVE_GPGME_KEYLIST_MODE_VALIDATE + oldmode |= GPGME_KEYLIST_MODE_VALIDATE; +#elif !defined(NDEBUG) + std::cerr << "GpgME::Context: ignoring Valdidate keylist flag (gpgme too old)." << std::endl; +#endif + } +#ifndef NDEBUG + if ( newmodes & ~(GpgME::Context::Local|GpgME::Context::Extern|GpgME::Context::Signatures|GpgME::Context::Validate) ) + std::cerr << "GpgME::Context: keylist mode must be one of Local, " + "Extern, Signatures, or Validate, or a combination thereof!" << std::endl; +#endif + return static_cast<gpgme_keylist_mode_t>( oldmode ); +} + +static inline unsigned int convert_from_gpgme_keylist_mode_t( unsigned int mode ) { + unsigned int result = 0; + if ( mode & GPGME_KEYLIST_MODE_LOCAL ) result |= GpgME::Context::Local; + if ( mode & GPGME_KEYLIST_MODE_EXTERN ) result |= GpgME::Context::Extern; + if ( mode & GPGME_KEYLIST_MODE_SIGS ) result |= GpgME::Context::Signatures; +#ifdef HAVE_GPGME_KEYLIST_MODE_VALIDATE + if ( mode & GPGME_KEYLIST_MODE_VALIDATE ) result |= GpgME::Context::Validate; +#endif +#ifndef NDEBUG + if ( mode & ~(GPGME_KEYLIST_MODE_LOCAL| + GPGME_KEYLIST_MODE_EXTERN| +#ifdef HAVE_GPGME_KEYLIST_MODE_VALIDATE + GPGME_KEYLIST_MODE_VALIDATE| +#endif + GPGME_KEYLIST_MODE_SIGS) ) + std::cerr << "GpgME::Context: WARNING: gpgme_get_keylist_mode() returned an unknown flag!" << std::endl; +#endif // NDEBUG + return result; +} + + +#endif // __GPGMEPP_UTIL_H__ diff --git a/libtdenetwork/gpgmepp/verificationresult.cpp b/libtdenetwork/gpgmepp/verificationresult.cpp new file mode 100644 index 00000000..abf30d96 --- /dev/null +++ b/libtdenetwork/gpgmepp/verificationresult.cpp @@ -0,0 +1,357 @@ +/* verificationresult.cpp - wraps a gpgme verify result + Copyright (C) 2004 Klarälvdalens Datakonsult AB + + This file is part of GPGME++. + + GPGME++ is free software; you can redistribute it and/or modify it + under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + GPGME++ is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + General Public License for more details. + + You should have received a copy of the GNU General Public License + along with GPGME++; if not, write to the Free Software Foundation, + Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. +*/ + +#ifdef HAVE_CONFIG_H +#include <config.h> +#endif + +#include <gpgmepp/verificationresult.h> +#include "shared.h" +#include "result_p.h" +#include "util.h" + +#include <gpgme.h> + +#include <istream> +#include <algorithm> +#include <iterator> +#include <cstring> +#include <cstdlib> + +class GpgME::VerificationResult::Private : public GpgME::Shared { +public: + Private( const gpgme_verify_result_t r ) : Shared() { + if ( !r ) + return; + // copy recursively, using compiler-generated copy ctor. + // We just need to handle the pointers in the structs: + for ( gpgme_signature_t is = r->signatures ; is ; is = is->next ) { + gpgme_signature_t scopy = new _gpgme_signature( *is ); + if ( is->fpr ) + scopy->fpr = strdup( is->fpr ); + scopy->next = 0; + sigs.push_back( scopy ); + // copy notations: + nota.push_back( std::vector<Nota>() ); + purls.push_back( 0 ); + for ( gpgme_sig_notation_t in = is->notations ; in ; in = in->next ) { + if ( !in->name ) { + if ( in->value ) + purls.back() = strdup( in->value ); // policy url + continue; + } + Nota n = { 0, 0 }; + n.name = strdup( in->name ); + if ( in->value ) + n.value = strdup( in->value ); + nota.back().push_back( n ); + } + } + } + ~Private() { + for ( std::vector<gpgme_signature_t>::iterator it = sigs.begin() ; it != sigs.end() ; ++it ) { + std::free( (*it)->fpr ); + delete *it; *it = 0; + } + for ( std::vector< std::vector<Nota> >::iterator it = nota.begin() ; it != nota.end() ; ++it ) + for ( std::vector<Nota>::iterator jt = it->begin() ; jt != it->end() ; ++jt ) { + std::free( jt->name ); jt->name = 0; + std::free( jt->value ); jt->value = 0; + } + std::for_each( purls.begin(), purls.end(), &std::free ); + } + + struct Nota { + char * name; + char * value; + }; + + std::vector<gpgme_signature_t> sigs; + std::vector< std::vector<Nota> > nota; + std::vector<char*> purls; +}; + +GpgME::VerificationResult::VerificationResult( gpgme_ctx_t ctx, int error ) + : GpgME::Result( error ), d( 0 ) +{ + if ( error || !ctx ) + return; + gpgme_verify_result_t res = gpgme_op_verify_result( ctx ); + if ( !res ) + return; + d = new Private( res ); + d->ref(); +} + +make_standard_stuff(VerificationResult) + +GpgME::Signature GpgME::VerificationResult::signature( unsigned int idx ) const { + return Signature( d, idx ); +} + +std::vector<GpgME::Signature> GpgME::VerificationResult::signatures() const { + if ( !d ) + return std::vector<Signature>(); + std::vector<Signature> result; + result.reserve( d->sigs.size() ); + for ( unsigned int i = 0 ; i < d->sigs.size() ; ++i ) + result.push_back( Signature( d, i ) ); + return result; +} + + + + + + +GpgME::Signature::Signature( VerificationResult::Private * parent, unsigned int i ) + : d( parent ), idx( i ) +{ + if ( d ) + d->ref(); +} + +GpgME::Signature::Signature() : d( 0 ), idx( 0 ) {} + +GpgME::Signature::Signature( const Signature & other ) + : d( other.d ), idx( other.idx ) +{ + if ( d ) + d->ref(); +} + +GpgME::Signature::~Signature() { + if ( d ) + d->unref(); +} + +const GpgME::Signature & GpgME::Signature::operator=( const Signature & other ) { + if ( this->d != other.d ) { + if ( other.d ) + other.d->ref(); + if ( this->d ) + this->d->unref(); + this->d = other.d; + } + + this->idx = other.idx; + return *this; +} + + +bool GpgME::Signature::isNull() const { + return !d || idx >= d->sigs.size() ; +} + + +GpgME::Signature::Summary GpgME::Signature::summary() const { + if ( isNull() ) + return None; + gpgme_sigsum_t sigsum = d->sigs[idx]->summary; + unsigned int result = 0; + if ( sigsum & GPGME_SIGSUM_VALID ) result |= Valid; + if ( sigsum & GPGME_SIGSUM_GREEN ) result |= Green; + if ( sigsum & GPGME_SIGSUM_RED ) result |= Red; + if ( sigsum & GPGME_SIGSUM_KEY_REVOKED ) result |= KeyRevoked; + if ( sigsum & GPGME_SIGSUM_KEY_EXPIRED ) result |= KeyExpired; + if ( sigsum & GPGME_SIGSUM_SIG_EXPIRED ) result |= SigExpired; + if ( sigsum & GPGME_SIGSUM_KEY_MISSING ) result |= KeyMissing; + if ( sigsum & GPGME_SIGSUM_CRL_MISSING ) result |= CrlMissing; + if ( sigsum & GPGME_SIGSUM_CRL_TOO_OLD ) result |= CrlTooOld; + if ( sigsum & GPGME_SIGSUM_BAD_POLICY ) result |= BadPolicy; + if ( sigsum & GPGME_SIGSUM_SYS_ERROR ) result |= SysError; + return static_cast<Summary>( result ); +} + +const char * GpgME::Signature::fingerprint() const { + return isNull() ? 0 : d->sigs[idx]->fpr ; +} + +GpgME::Error GpgME::Signature::status() const { + return isNull() ? 0 : d->sigs[idx]->status ; +} + +time_t GpgME::Signature::creationTime() const { + return static_cast<time_t>( isNull() ? 0 : d->sigs[idx]->timestamp ); +} + +time_t GpgME::Signature::expirationTime() const { + return static_cast<time_t>( isNull() ? 0 : d->sigs[idx]->exp_timestamp ); +} + +bool GpgME::Signature::neverExpires() const { + return expirationTime() == (time_t)0; +} + +bool GpgME::Signature::wrongKeyUsage() const { + return !isNull() && d->sigs[idx]->wrong_key_usage; +} + +GpgME::Signature::Validity GpgME::Signature::validity() const { + if ( isNull() ) + return Unknown; + switch ( d->sigs[idx]->validity ) { + default: + case GPGME_VALIDITY_UNKNOWN: return Unknown; + case GPGME_VALIDITY_UNDEFINED: return Undefined; + case GPGME_VALIDITY_NEVER: return Never; + case GPGME_VALIDITY_MARGINAL: return Marginal; + case GPGME_VALIDITY_FULL: return Full; + case GPGME_VALIDITY_ULTIMATE: return Ultimate; + } +} + + +char GpgME::Signature::validityAsString() const { + if ( isNull() ) + return '?'; + switch ( d->sigs[idx]->validity ) { + default: + case GPGME_VALIDITY_UNKNOWN: return '?'; + case GPGME_VALIDITY_UNDEFINED: return 'q'; + case GPGME_VALIDITY_NEVER: return 'n'; + case GPGME_VALIDITY_MARGINAL: return 'm'; + case GPGME_VALIDITY_FULL: return 'f'; + case GPGME_VALIDITY_ULTIMATE: return 'u'; + } +} + +GpgME::Error GpgME::Signature::nonValidityReason() const { + return isNull() ? 0 : d->sigs[idx]->validity_reason ; +} + + +GpgME::Signature::Notation GpgME::Signature::notation( unsigned int nidx ) const { + return Notation( d, idx, nidx ); +} + +std::vector<GpgME::Signature::Notation> GpgME::Signature::notations() const { + if ( isNull() ) + return std::vector<Notation>(); + std::vector<Notation> result; + result.reserve( d->nota[idx].size() ); + for ( unsigned int i = 0 ; i < d->nota[idx].size() ; ++i ) + result.push_back( Notation( d, idx, i ) ); + return result; +} + + +GpgME::Signature::Notation::Notation( VerificationResult::Private * parent, unsigned int sindex, unsigned int nindex ) + : d( parent ), sidx( sindex ), nidx( nindex ) +{ + if ( d ) + d->ref(); +} + +GpgME::Signature::Notation::Notation() + : d( 0 ), sidx( 0 ), nidx( 0 ) {} + +GpgME::Signature::Notation::Notation( const Notation & other ) + : d( other.d ), sidx( other.sidx ), nidx( other.nidx ) +{ + if ( d ) + d->ref(); +} + +GpgME::Signature::Notation::~Notation() { + if ( d ) + d->unref(); +} + +const GpgME::Signature::Notation & GpgME::Signature::Notation::operator=( const Notation & other ) { + if ( this->d != other.d ) { + if ( other.d ) + other.d->ref(); + if ( this->d ) + this->d->ref(); + this->d = other.d; + } + + sidx = other.sidx; + nidx = other.nidx; + return *this; +} + +bool GpgME::Signature::Notation::isNull() const { + return !d || sidx >= d->nota.size() || nidx >= d->nota[sidx].size() ; +} + + +const char * GpgME::Signature::Notation::name() const { + return isNull() ? 0 : d->nota[sidx][nidx].name ; +} + +const char * GpgME::Signature::Notation::value() const { + return isNull() ? 0 : d->nota[sidx][nidx].value ; +} + + +std::ostream & GpgME::operator<<( std::ostream & os, const VerificationResult & result ) { + os << "GpgME::VerificationResult("; + if ( !result.isNull() ) { + os << "\n error: " << result.error() + << "\n signatures:\n"; + const std::vector<Signature> sigs = result.signatures(); + std::copy( sigs.begin(), sigs.end(), + std::ostream_iterator<Signature>( os, "\n" ) ); + } + return os << ')'; +} + +std::ostream & GpgME::operator<<( std::ostream & os, Signature::Summary summary ) { +#define OUTPUT( x ) if ( !(summary & (GpgME::Signature:: x)) ) {} else do { os << #x " "; } while(0) + os << "GpgME::Signature::Summary("; + OUTPUT( Valid ); + OUTPUT( Green ); + OUTPUT( Red ); + OUTPUT( KeyRevoked ); + OUTPUT( KeyExpired ); + OUTPUT( SigExpired ); + OUTPUT( KeyMissing ); + OUTPUT( CrlMissing ); + OUTPUT( CrlTooOld ); + OUTPUT( BadPolicy ); + OUTPUT( SysError ); +#undef OUTPUT + return os << ')'; +} + +std::ostream & GpgME::operator<<( std::ostream & os, const Signature & sig ) { + os << "GpgME::Signature("; + if ( !sig.isNull() ) { + os << "\n Summary: " << sig.summary() + << "\n Fingerprint: " << protect( sig.fingerprint() ) + << "\n Status: " << sig.status() + << "\n creationTime: " << sig.creationTime() + << "\n expirationTime: " << sig.expirationTime() + << "\n wrongKeyUsage: " << sig.wrongKeyUsage() + << "\n validity: " << sig.validityAsString() + << "\n nonValidityReason: " << sig.nonValidityReason() + << "\n notations:\n"; + const std::vector<Signature::Notation> nota = sig.notations(); + std::copy( nota.begin(), nota.end(), + std::ostream_iterator<Signature::Notation>( os, "\n" ) ); + } + return os << ')'; +} + +std::ostream & GpgME::operator<<( std::ostream & os, const Signature::Notation & nota ) { + return os << "GpgME::Signature::Notation( \"" << protect( nota.name() ) << "\", \"" << protect( nota.value() ) << "\")"; +} diff --git a/libtdenetwork/gpgmepp/verificationresult.h b/libtdenetwork/gpgmepp/verificationresult.h new file mode 100644 index 00000000..e572ecfe --- /dev/null +++ b/libtdenetwork/gpgmepp/verificationresult.h @@ -0,0 +1,144 @@ +/* verificationresult.h - wraps a gpgme verify result + Copyright (C) 2004 Klarälvdalens Datakonsult AB + + This file is part of GPGME++. + + GPGME++ is free software; you can redistribute it and/or modify it + under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + GPGME++ is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + General Public License for more details. + + You should have received a copy of the GNU General Public License + along with GPGME++; if not, write to the Free Software Foundation, + Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. +*/ + +#ifndef __GPGMEPP_VERIFICATIONRESULT_H__ +#define __GPGMEPP_VERIFICATIONRESULT_H__ + +#include <gpgmepp/gpgmefw.h> +#include <gpgmepp/result.h> + +#include <time.h> + +#include <vector> +#include <iosfwd> + +#include <tdepimmacros.h> + +namespace GpgME { + + class Error; + class Signature; + + class KDE_EXPORT VerificationResult : public Result { + public: + VerificationResult( gpgme_ctx_t ctx=0, int error=0 ); + explicit VerificationResult( const Error & err ); + VerificationResult( const VerificationResult & other ); + ~VerificationResult(); + + const VerificationResult & operator=( const VerificationResult & other ); + + bool isNull() const; + + Signature signature( unsigned int index ) const; + std::vector<Signature> signatures() const; + + class Private; + private: + Private * d; + }; + + KDE_EXPORT std::ostream & operator<<( std::ostream & os, const VerificationResult & result ); + + class KDE_EXPORT Signature { + friend class VerificationResult; + Signature( VerificationResult::Private * parent, unsigned int index ); + public: + class Notation; + + Signature(); + Signature( const Signature & other ); + ~Signature(); + + const Signature & operator=( const Signature & other ); + + bool isNull() const; + + + enum Summary { + None = 0x000, + Valid = 0x001, + Green = 0x002, + Red = 0x004, + KeyRevoked = 0x008, + KeyExpired = 0x010, + SigExpired = 0x020, + KeyMissing = 0x040, + CrlMissing = 0x080, + CrlTooOld = 0x100, + BadPolicy = 0x200, + SysError = 0x400 + }; + Summary summary() const; + + const char * fingerprint() const; + + Error status() const; + + time_t creationTime() const; + time_t expirationTime() const; + bool neverExpires() const; + + bool wrongKeyUsage() const; + + enum Validity { + Unknown, Undefined, Never, Marginal, Full, Ultimate + }; + Validity validity() const; + char validityAsString() const; + Error nonValidityReason() const; + + Notation notation( unsigned int index ) const; + std::vector<Notation> notations() const; + + private: + VerificationResult::Private * d; + unsigned int idx; + }; + + KDE_EXPORT std::ostream & operator<<( std::ostream & os, const Signature & sig ); + KDE_EXPORT std::ostream & operator<<( std::ostream & os, Signature::Summary summary ); + + class KDE_EXPORT Signature::Notation { + friend class Signature; + Notation( VerificationResult::Private * parent, unsigned int sindex, unsigned int nindex ); + public: + Notation(); + Notation( const Notation & other ); + ~Notation(); + + const Notation & operator=( const Notation & other ); + + bool isNull() const; + + const char * name() const; + const char * value() const; + + private: + VerificationResult::Private * d; + unsigned int sidx; + unsigned int nidx; + }; + + KDE_EXPORT std::ostream & operator<<( std::ostream & os, const Signature::Notation & nota ); + +} + +#endif // __GPGMEPP_VERIFICATIONRESULT_H__ |