diff options
180 files changed, 25637 insertions, 1958 deletions
diff --git a/acinclude.m4 b/acinclude.m4 index cdfe6e43..575e526f 100644 --- a/acinclude.m4 +++ b/acinclude.m4 @@ -58,3 +58,19 @@ AC_DEFUN([GNUPG_CHECK_VA_COPY], AC_MSG_RESULT($gnupg_cv_must_copy_va_byval) fi ]) + +dnl LIST_MEMBER() +dnl Check wether an element ist contained in a list. Set `found' to +dnl `1' if the element is found in the list, to `0' otherwise. +AC_DEFUN([LIST_MEMBER], +[ +name=$1 +list=$2 +found=0 + +for n in $list; do + if test "x$name" = "x$n"; then + found=1 + fi +done +]) diff --git a/configure.ac b/configure.ac index 55c388eb..87b9e976 100644 --- a/configure.ac +++ b/configure.ac @@ -61,6 +61,14 @@ LIBGPGME_LT_CURRENT=25 LIBGPGME_LT_AGE=14 LIBGPGME_LT_REVISION=0 +LIBGPGMEPP_LT_CURRENT=6 +LIBGPGMEPP_LT_AGE=0 +LIBGPGMEPP_LT_REVISION=0 + +LIBQGPGME_LT_CURRENT=6 +LIBQGPGME_LT_AGE=0 +LIBQGPGME_LT_REVISION=0 + # If the API is changed in an incompatible way: increment the next counter. GPGME_CONFIG_API_VERSION=1 ############################################## @@ -104,6 +112,12 @@ AC_CHECK_PROGS(GITLOG_TO_CHANGELOG, gitlog-to-changelog, [gitlog-to-changelog]) AC_SUBST(LIBGPGME_LT_CURRENT) AC_SUBST(LIBGPGME_LT_AGE) AC_SUBST(LIBGPGME_LT_REVISION) +AC_SUBST(LIBGPGMEPP_LT_CURRENT) +AC_SUBST(LIBGPGMEPP_LT_AGE) +AC_SUBST(LIBGPGMEPP_LT_REVISION) +AC_SUBST(LIBQGPGME_LT_CURRENT) +AC_SUBST(LIBQGPGME_LT_AGE) +AC_SUBST(LIBQGPGME_LT_REVISION) AC_SUBST(PACKAGE) AC_SUBST(VERSION) @@ -146,6 +160,8 @@ have_w32_system=no have_w64_system=no build_w32_glib=no build_w32_qt=no +available_languages="cpp cl qt" +default_languages="cpp cl qt" case "${host}" in x86_64-*mingw32*) have_w64_system=yes @@ -171,20 +187,9 @@ case "${host}" in AC_ARG_ENABLE(w32-glib, AC_HELP_STRING([--enable-w32-glib], [build GPGME Glib for W32]), build_w32_glib=$enableval) - - # Check disabled, because the qt-dev packages in gpg4win do - # not provide any support for cross compilation. - # PKG_CHECK_MODULES(QT4_CORE, QtCore) - - # Use it like this: - # ./configure --enable-w32-qt QT4_CORE_CFLAGS="..." QT4_CORE_LIBS="..." - AC_SUBST(QT4_CORE_CFLAGS) - AC_SUBST(QT4_CORE_LIBS) - AC_ARG_ENABLE(w32-qt, - AC_HELP_STRING([--enable-w32-qt], [build GPGME Qt for W32]), - build_w32_qt=$enableval) - ;; + ;; *) + AC_CHECK_LIB(pthread,pthread_create,have_pthread=yes) if test "$have_pthread" = yes; then AC_DEFINE(HAVE_PTHREAD, ,[Define if we have pthread.]) @@ -230,7 +235,6 @@ fi AM_CONDITIONAL(HAVE_ANDROID_SYSTEM, test "$have_android_system" = yes) AM_CONDITIONAL(BUILD_W32_GLIB, test "$build_w32_glib" = yes) -AM_CONDITIONAL(BUILD_W32_QT, test "$build_w32_qt" = yes) AM_CONDITIONAL(HAVE_PTHREAD, test "$have_pthread" = "yes") @@ -245,6 +249,97 @@ if test x$fixed_search_path != x ; then [Locate binaries only via this PATH]) fi +AC_ARG_ENABLE([languages], + AC_HELP_STRING([--enable-languages=languages], + [enable only specific language bindings]), + [enabled_languages=`echo $enableval | \ + tr ',:' ' ' | tr '[A-Z]' '[a-z]' | \ + sed 's/c++/cpp/'`], + [enabled_languages="maybe"]) +if test "x$enabled_languages" = "x" \ + -o "$enabled_languages" = "no"; then + enabled_languages= +fi + +# If languages are explicitly set missing requirements +# for the languages are treated as errors otherwise +# there will be a warning. +explicit_languages=1 +if test "x$enabled_languages" = "xmaybe"; then + explicit_languages=0 + enabled_languages="$default_languages" +fi + +for language in $enabled_languages; do + LIST_MEMBER($language, $available_languages) + if test "$found" = "0"; then + AC_MSG_ERROR([unsupported language binding specified]) + fi +done + + + +# Enable C++ 11 if cpp language is requested +LIST_MEMBER("cpp", $enabled_languages) +if test "$found" = "1"; then + AX_CXX_COMPILE_STDCXX(11, noext, optional) + if test "$HAVE_CXX11" != "1"; then + if test "$explicit_languages" = "1"; then + AC_MSG_ERROR([[ +*** +*** A compiler with c++11 support is required for the c++ binding. +***]]) + else + enabled_languages=$(echo $enabled_languages | sed 's/cpp//') + enabled_languages=$(echo $enabled_languages | sed 's/qt//') + AC_MSG_WARN([[ +*** +*** No c++11 support detected. C++ and Qt bindings will be disabled. +***]]) + fi + fi +fi + +# Check that if qt is enabled cpp also is enabled +LIST_MEMBER("qt", $enabled_languages) +if test "$found" = "1"; then + # We need to ensure that in the langauge order qt comes after cpp + # so we remove qt first and explicitly add it as last list member. + enabled_languages=$(echo $enabled_languages | sed 's/qt//') + LIST_MEMBER("cpp", $enabled_languages) + if test "$found" = "0"; then + AC_MSG_ERROR([[ +*** +*** Qt language binding depends on cpp binding. +***]]) + fi + FIND_QT + if test "$have_qt5_libs" != "yes"; then + if test "$explicit_languages" = "1"; then + AC_MSG_ERROR([[ +*** +*** Qt5 (Qt5Core) is required for Qt binding. +***]]) + else + AC_MSG_WARN([[ +*** +*** Qt5 (Qt5Core) not found Qt Binding will be disabled. +***]]) + fi + else + enabled_languages=`echo $enabled_languages qt` + + AC_CHECK_PROGS([DOXYGEN], [doxygen]) + if test -z "$DOXYGEN"; + # This is not highlighted becase it's not really important. + then AC_MSG_WARN([Doxygen not found - Qt binding doc will not be built.]) + fi + fi +fi +AM_CONDITIONAL([HAVE_DOXYGEN], + [test -n "$DOXYGEN"]) + +AC_SUBST(ENABLED_LANGUAGES, $enabled_languages) # # Provide information about the build. @@ -632,18 +727,29 @@ AC_CONFIG_FILES(Makefile src/Makefile src/versioninfo.rc src/gpgme.h) AC_CONFIG_FILES(src/gpgme-config, chmod +x src/gpgme-config) +AC_CONFIG_FILES(lang/cpp/Makefile lang/cpp/src/Makefile) +AC_CONFIG_FILES(lang/cpp/src/GpgmeppConfig.cmake.in) +AC_CONFIG_FILES(lang/cpp/src/GpgmeppConfigVersion.cmake) +AC_CONFIG_FILES(lang/qt/Makefile lang/qt/src/Makefile) +AC_CONFIG_FILES(lang/qt/src/QGpgmeConfig.cmake.in) +AC_CONFIG_FILES(lang/qt/src/QGpgmeConfigVersion.cmake) +AC_CONFIG_FILES(lang/qt/tests/Makefile) AC_CONFIG_FILES([lang/Makefile lang/cl/Makefile lang/cl/gpgme.asd]) +AM_COND_IF([HAVE_DOXYGEN], [AC_CONFIG_FILES([lang/qt/doc/Doxyfile])]) +AC_CONFIG_FILES(lang/qt/doc/Makefile) AC_OUTPUT echo " GPGME v${VERSION} has been configured as follows: - Revision: mym4_revision (mym4_revision_dec) - Platform: $host + Revision: mym4_revision (mym4_revision_dec) + Platform: $host + + UI Server: $uiserver + FD Passing: $use_descriptor_passing + GPGME Pthread: $have_pthread - UI Server: $uiserver - FD Passing: $use_descriptor_passing - GPGME Pthread: $have_pthread + Language bindings: $enabled_languages " if test "x${gpg_config_script_warn}" != x; then cat <<G10EOF diff --git a/lang/Makefile.am b/lang/Makefile.am index 854d9348..bb75cf00 100644 --- a/lang/Makefile.am +++ b/lang/Makefile.am @@ -17,6 +17,6 @@ # License along with this program; if not, write to the Free Software # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA -SUBDIRS = cl +SUBDIRS = $(ENABLED_LANGUAGES) EXTRA_DIST = README diff --git a/lang/README b/lang/README index da54c78b..e1c04f27 100644 --- a/lang/README +++ b/lang/README @@ -10,3 +10,5 @@ sub-directory. Directory Language cl Common Lisp +cpp C++ +qt Qt-Framework API diff --git a/lang/cpp/Makefile.am b/lang/cpp/Makefile.am new file mode 100644 index 00000000..7fbaca8e --- /dev/null +++ b/lang/cpp/Makefile.am @@ -0,0 +1,23 @@ +# Makefile.am for GPGMEPP. +# Copyright (C) 2016 Intevation GmbH +# +# This file is part of GPGMEPP. +# +# GPGME-CL 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-CL 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 Lesser General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program; if not, write to the Free Software +# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA +# 02111-1307, USA + +SUBDIRS = src + +EXTRA_DIST = README diff --git a/lang/cpp/README b/lang/cpp/README new file mode 100644 index 00000000..d5f4093b --- /dev/null +++ b/lang/cpp/README @@ -0,0 +1,60 @@ +GpgMEpp - C++ bindings/wrapper for gpgme +---------------------------------------- +Based on KF5gpgmepp + +GPGMEpp is free software; you can redistribute it and/or +modify it under the terms of the GNU Library General Public +License as published by the Free Software Foundation; either +version 2 of the License, or (at your option) any later version. + +GPGMEpp is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU Library General Public License for more details. + +You should have received a copy of the GNU Library General Public License +along with GPGME++; see the file COPYING.LIB. If not, write to the +Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, +Boston, MA 02110-1301, USA. + +Overview +-------- + +GpgMEpp 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). + +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. + +GpgMEpp was originally developed as part of the KDEPIM community +in KDE 4 it was part of kdepimlibs/gpgme++ for KF5 Gpgmepp was +renamed to KF5GpgMEpp and moved into it's own repository. + +Hacking +------- +GpgMEpp follows KDE Coding styles. See: +https://techbase.kde.org/Policies/Frameworks_Coding_Style +for more info. + +License +------- + +This library is licensed under the GNU Library General Public +License (LGPL), just as gpgme is. We feel that using a different +license than the one gpgme itself uses doesn't make sense. diff --git a/lang/cpp/src/GpgmeppConfig.cmake.in.in b/lang/cpp/src/GpgmeppConfig.cmake.in.in new file mode 100644 index 00000000..d54011e9 --- /dev/null +++ b/lang/cpp/src/GpgmeppConfig.cmake.in.in @@ -0,0 +1,108 @@ +# CMake Config file for GPGMEPP. +# Copyright (C) 2016 Intevation GmbH +# +# This file is part of GPGMEPP. +# +# GPGME-CL 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-CL 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 Lesser General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program; if not, write to the Free Software +# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA +# 02111-1307, USA + +# based on a generated file from cmake. +# Generated by CMake 3.0.2 + +if("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" LESS 2.5) + message(FATAL_ERROR "CMake >= 2.6.0 required") +endif() +cmake_policy(PUSH) +cmake_policy(VERSION 2.6) +#---------------------------------------------------------------- +# Generated CMake target import file. +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Protect against multiple inclusion, which would fail when already imported targets are added once more. +set(_targetsDefined) +set(_targetsNotDefined) +set(_expectedTargets) +foreach(_expectedTarget KF5::Gpgmepp Gpgmepp) + list(APPEND _expectedTargets ${_expectedTarget}) + if(NOT TARGET ${_expectedTarget}) + list(APPEND _targetsNotDefined ${_expectedTarget}) + endif() + if(TARGET ${_expectedTarget}) + list(APPEND _targetsDefined ${_expectedTarget}) + endif() +endforeach() +if("${_targetsDefined}" STREQUAL "${_expectedTargets}") + set(CMAKE_IMPORT_FILE_VERSION) + cmake_policy(POP) + return() +endif() +if(NOT "${_targetsDefined}" STREQUAL "") + message(FATAL_ERROR "Some (but not all) targets in this export set were already defined.\nTargets Defined: ${_targetsDefined}\nTargets not yet defined: ${_targetsNotDefined}\n") +endif() +unset(_targetsDefined) +unset(_targetsNotDefined) +unset(_expectedTargets) + +# Compute the installation prefix relative to this file. +get_filename_component(_IMPORT_PREFIX "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) + +# Create imported target Gpgmepp +add_library(Gpgmepp SHARED IMPORTED) + +set_target_properties(Gpgmepp PROPERTIES + INTERFACE_INCLUDE_DIRECTORIES "${_IMPORT_PREFIX}/include/gpgme++" + INTERFACE_LINK_LIBRARIES "pthread;@resolved_libdir@/libgpgme@libsuffix@;@LIBASSUAN_LIBS@" + IMPORTED_LOCATION "@resolved_libdir@/libgpgmepp@libsuffix@" +) + +if(CMAKE_VERSION VERSION_LESS 2.8.12) + message(FATAL_ERROR "This file relies on consumers using CMake 2.8.12 or greater.") +endif() + +# Cleanup temporary variables. +set(_IMPORT_PREFIX) + +# Loop over all imported files and verify that they actually exist +foreach(target ${_IMPORT_CHECK_TARGETS} ) + foreach(file ${_IMPORT_CHECK_FILES_FOR_${target}} ) + if(NOT EXISTS "${file}" ) + message(FATAL_ERROR "The imported target \"${target}\" references the file + \"${file}\" +but this file does not exist. Possible reasons include: +* The file was deleted, renamed, or moved to another location. +* An install or uninstall procedure did not complete successfully. +* The installation package was faulty and contained + \"${CMAKE_CURRENT_LIST_FILE}\" +but not all the files it references. +") + endif() + endforeach() + unset(_IMPORT_CHECK_FILES_FOR_${target}) +endforeach() +unset(_IMPORT_CHECK_TARGETS) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) +cmake_policy(POP) + +get_filename_component(QGpgme_DIR "${CMAKE_CURRENT_LIST_FILE}" PATH) +# Pull in QGpgme for compatibility with KF5 variant. +find_package(QGpgme CONFIG) diff --git a/lang/cpp/src/GpgmeppConfigVersion.cmake.in b/lang/cpp/src/GpgmeppConfigVersion.cmake.in new file mode 100644 index 00000000..43d65127 --- /dev/null +++ b/lang/cpp/src/GpgmeppConfigVersion.cmake.in @@ -0,0 +1,31 @@ +# CMake Version file for GPGMEPP. +# Copyright (C) 2016 Intevation GmbH +# +# This file is part of GPGMEPP. +# +# GPGME-CL 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-CL 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 Lesser General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program; if not, write to the Free Software +# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA +# 02111-1307, USA + +# based on a generated file from cmake. +set(PACKAGE_VERSION "@LIBGPGMEPP_LT_CURRENT@.@LIBGPGMEPP_LT_AGE@.@LIBGPGMEPP_LT_REVISION@.@BUILD_REVISION@") + +if("${PACKAGE_VERSION}" VERSION_LESS "${PACKAGE_FIND_VERSION}" ) + set(PACKAGE_VERSION_COMPATIBLE FALSE) +else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + if( "${PACKAGE_FIND_VERSION}" STREQUAL "${PACKAGE_VERSION}") + set(PACKAGE_VERSION_EXACT TRUE) + endif() +endif() diff --git a/lang/cpp/src/Makefile.am b/lang/cpp/src/Makefile.am new file mode 100644 index 00000000..24e0461c --- /dev/null +++ b/lang/cpp/src/Makefile.am @@ -0,0 +1,93 @@ +# Makefile.am for GPGMEPP. +# Copyright (C) 2016 Intevation GmbH +# +# This file is part of GPGMEPP. +# +# GPGME-CL 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-CL 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 Lesser General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program; if not, write to the Free Software +# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA +# 02111-1307, USA + +EXTRA_DIST = GpgmeppConfig.cmake.in.in GpgmeppConfigVersion.cmake.in + +lib_LTLIBRARIES = libgpgmepp.la + +main_sources = \ + exception.cpp context.cpp key.cpp trustitem.cpp data.cpp callbacks.cpp \ + eventloopinteractor.cpp editinteractor.cpp assuanresult.cpp \ + keylistresult.cpp keygenerationresult.cpp importresult.cpp \ + decryptionresult.cpp verificationresult.cpp \ + signingresult.cpp encryptionresult.cpp \ + engineinfo.cpp gpgsetexpirytimeeditinteractor.cpp \ + gpgsetownertrusteditinteractor.cpp gpgsignkeyeditinteractor.cpp \ + gpgadduserideditinteractor.cpp defaultassuantransaction.cpp \ + scdgetinfoassuantransaction.cpp gpgagentgetinfoassuantransaction.cpp \ + vfsmountresult.cpp configuration.cpp + +gpgmepp_headers = \ + assuanresult.h configuration.h context.h data.h decryptionresult.h \ + defaultassuantransaction.h editinteractor.h encryptionresult.h \ + engineinfo.h error.h eventloopinteractor.h exception.h global.h \ + gpgadduserideditinteractor.h gpgagentgetinfoassuantransaction.h \ + gpgmefw.h gpgsetexpirytimeeditinteractor.h \ + gpgsetownertrusteditinteractor.h gpgsignkeyeditinteractor.h \ + importresult.h keygenerationresult.h key.h keylistresult.h \ + notation.h result.h scdgetinfoassuantransaction.h signingresult.h \ + trustitem.h verificationresult.h vfsmountresult.h gpgmepp_export.h + +private_gpgmepp_headers = \ + result_p.h context_p.h util.h callbacks.h data_p.h + +interface_headers= \ + interfaces/assuantransaction.h interfaces/dataprovider.h \ + interfaces/passphraseprovider.h interfaces/progressprovider.h + +gpgmeppincludedir = $(includedir)/gpgme++ +gpgmeppinclude_HEADERS = $(gpgmepp_headers) +nobase_gpgmeppinclude_HEADERS = $(interface_headers) + +libgpgmepp_la_SOURCES = $(main_sources) $(gpgmepp_headers) context_vanilla.cpp \ + $(interface_headers) $(private_gpgmepp_headers) + +AM_CPPFLAGS = @GPG_ERROR_CFLAGS@ @LIBASSUAN_CFLAGS@ -DBUILDING_GPGMEPP + +libgpgmepp_la_LIBADD = ../../../src/libgpgme.la @LIBASSUAN_LIBS@ +libgpgmepp_la_LDFLAGS = -version-info \ + @LIBGPGMEPP_LT_CURRENT@:@LIBGPGMEPP_LT_REVISION@:@LIBGPGMEPP_LT_AGE@ + +if HAVE_W32_SYSTEM +libsuffix=.dll.a +else +libsuffix=.so +endif + +GpgmeppConfig.cmake: GpgmeppConfig.cmake.in + sed -e 's|[@]resolved_libdir@|$(libdir)|g' < "$<" > "$@" + sed -e 's|[@]libsuffix@|$(libsuffix)|g' < "$@" > "$@".2 + mv "$@".2 "$@" + +install-cmake-files: GpgmeppConfig.cmake GpgmeppConfigVersion.cmake + -$(INSTALL) -d $(DESTDIR)$(libdir)/cmake/Gpgmepp + $(INSTALL) GpgmeppConfig.cmake \ + $(DESTDIR)$(libdir)/cmake/Gpgmepp/GpgmeppConfig.cmake + $(INSTALL) GpgmeppConfigVersion.cmake \ + $(DESTDIR)$(libdir)/cmake/Gpgmepp/GpgmeppConfigVersion.cmake + +uninstall-cmake-files: + -rm $(DESTDIR)$(libdir)/cmake/Gpgmepp/GpgmeppConfigVersion.cmake + -rm $(DESTDIR)$(libdir)/cmake/Gpgmepp/GpgmeppConfig.cmake + -rmdir $(DESTDIR)$(libdir)/cmake/Gpgmepp/ + +install-data-local: install-cmake-files + +uninstall-local: uninstall-cmake-files diff --git a/lang/cpp/src/assuanresult.cpp b/lang/cpp/src/assuanresult.cpp new file mode 100644 index 00000000..3d6d0a3a --- /dev/null +++ b/lang/cpp/src/assuanresult.cpp @@ -0,0 +1,90 @@ +/* + assuanresult.cpp - wraps a gpgme assuan result + Copyright (C) 2009 Klarälvdalens Datakonsult AB + + This file is part of GPGME++. + + GPGME++ is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + GPGME++ is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Library General Public License for more details. + + You should have received a copy of the GNU Library General Public License + along with GPGME++; see the file COPYING.LIB. If not, write to the + Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. +*/ + +#include <assuanresult.h> +#include "result_p.h" + +#include <gpgme.h> + +#include <istream> + +using namespace GpgME; + +class AssuanResult::Private +{ +public: + explicit Private(const gpgme_assuan_result_t r) + { + if (!r) { + return; + } + error = r->err; + } + + gpgme_error_t error; +}; + +AssuanResult::AssuanResult(gpgme_ctx_t ctx, int error) + : Result(error), d() +{ + init(ctx); +} + +AssuanResult::AssuanResult(gpgme_ctx_t ctx, const Error &error) + : Result(error), d() +{ + init(ctx); +} + +void AssuanResult::init(gpgme_ctx_t ctx) +{ + (void)ctx; + if (!ctx) { + return; + } + gpgme_assuan_result_t res = gpgme_op_assuan_result(ctx); + if (!res) { + return; + } + d.reset(new Private(res)); +} + +make_standard_stuff(AssuanResult) + +Error AssuanResult::assuanError() const +{ + if (d) { + return Error(d->error); + } + return Error(); +} + +std::ostream &GpgME::operator<<(std::ostream &os, const AssuanResult &result) +{ + os << "GpgME::AssuanResult("; + if (!result.isNull()) { + os << "\n error: " << result.error() + << "\n assuanError: " << result.assuanError() + << "\n"; + } + return os << ')'; +} diff --git a/lang/cpp/src/assuanresult.h b/lang/cpp/src/assuanresult.h new file mode 100644 index 00000000..e59b5ac2 --- /dev/null +++ b/lang/cpp/src/assuanresult.h @@ -0,0 +1,79 @@ +/* + assuanresult.h - wraps a gpgme assuan result + Copyright (C) 2009 Klarälvdalens Datakonsult AB <[email protected]> + Author: Marc Mutz <[email protected]> + + This file is part of GPGME++. + + GPGME++ is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + GPGME++ is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Library General Public License for more details. + + You should have received a copy of the GNU Library General Public License + along with GPGME++; see the file COPYING.LIB. If not, write to the + Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. +*/ + +#ifndef __GPGMEPP_ASSUANRESULT_H__ +#define __GPGMEPP_ASSUANRESULT_H__ + +#include "gpgmefw.h" +#include "result.h" +#include "gpgmepp_export.h" + +#include <time.h> + +#include <vector> +#include <iosfwd> +#include <memory> + +namespace GpgME +{ + +class Error; + +class GPGMEPP_EXPORT AssuanResult : public Result +{ +public: + AssuanResult(); + AssuanResult(gpgme_ctx_t ctx, int error); + AssuanResult(gpgme_ctx_t ctx, const Error &error); + explicit AssuanResult(const Error &err); + + const AssuanResult &operator=(AssuanResult other) + { + swap(other); + return *this; + } + + void swap(AssuanResult &other) + { + Result::swap(other); + using std::swap; + swap(this->d, other.d); + } + + bool isNull() const; + + Error assuanError() const; + + class Private; +private: + void init(gpgme_ctx_t ctx); + std::shared_ptr<Private> d; +}; + +GPGMEPP_EXPORT std::ostream &operator<<(std::ostream &os, const AssuanResult &result); + +} + +GPGMEPP_MAKE_STD_SWAP_SPECIALIZATION(AssuanResult) + +#endif // __GPGMEPP_ASSUANRESULT_H__ diff --git a/lang/cpp/src/callbacks.cpp b/lang/cpp/src/callbacks.cpp new file mode 100644 index 00000000..4b4dd806 --- /dev/null +++ b/lang/cpp/src/callbacks.cpp @@ -0,0 +1,149 @@ +/* + callbacks.cpp - callback targets for internal use: + Copyright (C) 2003,2004 Klarälvdalens Datakonsult AB + + This file is part of GPGME++. + + GPGME++ is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + GPGME++ is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Library General Public License for more details. + + You should have received a copy of the GNU Library General Public License + along with GPGME++; see the file COPYING.LIB. If not, write to the + Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. +*/ + +#include "callbacks.h" +#include "util.h" + +#include <interfaces/progressprovider.h> +#include <interfaces/passphraseprovider.h> +#include <interfaces/dataprovider.h> +#include <error.h> + +#include <gpgme.h> +#include <gpg-error.h> + +#include <cassert> +#include <cerrno> +#include <cstring> +#include <unistd.h> +#include <stdlib.h> + +static inline gpgme_error_t make_err_from_syserror() +{ + return gpgme_error_from_syserror(); +} + +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); + } +} + +/* To avoid that a compiler optimizes certain memset calls away, these + macros may be used instead. */ +#define wipememory2(_ptr,_set,_len) do { \ + volatile char *_vptr=(volatile char *)(_ptr); \ + size_t _vlen=(_len); \ + while(_vlen) { *_vptr=(_set); _vptr++; _vlen--; } \ + } while(0) +#define wipememory(_ptr,_len) wipememory2(_ptr,0,_len) + +gpgme_error_t passphrase_callback(void *opaque, const char *uid_hint, const char *desc, + int prev_was_bad, int fd) +{ + PassphraseProvider *provider = static_cast<PassphraseProvider *>(opaque); + bool canceled = false; + gpgme_error_t err = GPG_ERR_NO_ERROR; + char *passphrase = provider ? provider->getPassphrase(uid_hint, desc, prev_was_bad, canceled) : 0 ; + if (canceled) { + err = make_error(GPG_ERR_CANCELED); + } else { + if (passphrase && *passphrase) { + size_t passphrase_length = std::strlen(passphrase); + size_t written = 0; + do { + ssize_t now_written = gpgme_io_write(fd, passphrase + written, passphrase_length - written); + if (now_written < 0) { + err = make_err_from_syserror(); + break; + } + written += now_written; + } while (written < passphrase_length); + } + } + + if (passphrase && *passphrase) { + wipememory(passphrase, std::strlen(passphrase)); + } + free(passphrase); + gpgme_io_write(fd, "\n", 1); + return err; +} + +static gpgme_ssize_t +data_read_callback(void *opaque, void *buf, size_t buflen) +{ + DataProvider *provider = static_cast<DataProvider *>(opaque); + if (!provider) { + gpgme_err_set_errno(gpgme_err_code_to_errno(GPG_ERR_EINVAL)); + return -1; + } + return (gpgme_ssize_t)provider->read(buf, buflen); +} + +static gpgme_ssize_t +data_write_callback(void *opaque, const void *buf, size_t buflen) +{ + DataProvider *provider = static_cast<DataProvider *>(opaque); + if (!provider) { + gpgme_err_set_errno(gpgme_err_code_to_errno(GPG_ERR_EINVAL)); + return -1; + } + return (gpgme_ssize_t)provider->write(buf, buflen); +} + +static gpgme_off_t +data_seek_callback(void *opaque, gpgme_off_t offset, int whence) +{ + DataProvider *provider = static_cast<DataProvider *>(opaque); + if (!provider) { + gpgme_err_set_errno(gpgme_err_code_to_errno(GPG_ERR_EINVAL)); + return -1; + } + if (whence != SEEK_SET && whence != SEEK_CUR && whence != SEEK_END) { + gpgme_err_set_errno(gpgme_err_code_to_errno(GPG_ERR_EINVAL)); + return -1; + } + return provider->seek((off_t)offset, whence); +} + +static void data_release_callback(void *opaque) +{ + DataProvider *provider = static_cast<DataProvider *>(opaque); + if (provider) { + provider->release(); + } +} + +const gpgme_data_cbs GpgME::data_provider_callbacks = { + &data_read_callback, + &data_write_callback, + &data_seek_callback, + &data_release_callback +}; diff --git a/lang/cpp/src/callbacks.h b/lang/cpp/src/callbacks.h new file mode 100644 index 00000000..42066379 --- /dev/null +++ b/lang/cpp/src/callbacks.h @@ -0,0 +1,45 @@ +/* + callbacks.h - callback targets for internal use: + Copyright (C) 2003 Klarälvdalens Datakonsult AB + + This file is part of GPGME++. + + This is an internal header file, subject to change without + notice. DO NOT USE. + + GPGME++ is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + GPGME++ is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Library General Public License for more details. + + You should have received a copy of the GNU Library General Public License + along with GPGME++; see the file COPYING.LIB. If not, write to the + Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. +*/ + +#ifndef __GPGMEPP_CALLBACKS_H__ +#define __GPGMEPP_CALLBACKS_H__ + +#include <gpgme.h> + +extern "C" { + + void progress_callback(void *opaque, const char *what, + int type, int current, int total); + gpgme_error_t passphrase_callback(void *opaque, const char *uid_hint, + const char *desc, int prev_was_bad, int fd); +} + +namespace GpgME +{ +extern const gpgme_data_cbs data_provider_callbacks; +extern const gpgme_edit_cb_t edit_interactor_callback; +} + +#endif // __GPGME_CALLBACKS_H__ diff --git a/lang/cpp/src/configuration.cpp b/lang/cpp/src/configuration.cpp new file mode 100644 index 00000000..7ef28836 --- /dev/null +++ b/lang/cpp/src/configuration.cpp @@ -0,0 +1,934 @@ +/* + configuration.cpp - wraps gpgme configuration components + Copyright (C) 2010 Klarälvdalens Datakonsult AB + + This file is part of GPGME++. + + GPGME++ is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + GPGME++ is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Library General Public License for more details. + + You should have received a copy of the GNU Library General Public License + along with GPGME++; see the file COPYING.LIB. If not, write to the + Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. +*/ + +#include "configuration.h" +#include "error.h" +#include "util.h" + +#include <gpgme.h> + +#include <iterator> +#include <algorithm> +#include <ostream> +#include <cstring> +#include <assert.h> + +using namespace GpgME; +using namespace GpgME::Configuration; + +typedef std::shared_ptr< std::remove_pointer<gpgme_conf_opt_t>::type > shared_gpgme_conf_opt_t; +typedef std::weak_ptr< std::remove_pointer<gpgme_conf_opt_t>::type > weak_gpgme_conf_opt_t; + +typedef std::shared_ptr< std::remove_pointer<gpgme_conf_arg_t>::type > shared_gpgme_conf_arg_t; +typedef std::weak_ptr< std::remove_pointer<gpgme_conf_arg_t>::type > weak_gpgme_conf_arg_t; + +typedef std::shared_ptr< std::remove_pointer<gpgme_ctx_t>::type > shared_gpgme_ctx_t; +typedef std::weak_ptr< std::remove_pointer<gpgme_ctx_t>::type > weak_gpgme_ctx_t; + +namespace +{ +struct nodelete { + template <typename T> void operator()(T *) {} +}; +} + +// static +std::vector<Component> Component::load(Error &returnedError) +{ + + // + // 1. get a context: + // + gpgme_ctx_t ctx_native = 0; + if (const gpgme_error_t err = gpgme_new(&ctx_native)) { + returnedError = Error(err); + return std::vector<Component>(); + } + const shared_gpgme_ctx_t ctx(ctx_native, &gpgme_release); + + // + // 2. load the config: + // + gpgme_conf_comp_t conf_list_native = 0; + if (const gpgme_error_t err = gpgme_op_conf_load(ctx_native, &conf_list_native)) { + returnedError = Error(err); + return std::vector<Component>(); + } + shared_gpgme_conf_comp_t head(conf_list_native, &gpgme_conf_release); + + // + // 3. convert to vector<Component>: + // + std::vector<Component> result; + + while (head) { + // secure 'head->next' (if any) against memleaks: + shared_gpgme_conf_comp_t next; + if (head->next) { + next.reset(head->next, &gpgme_conf_release); + } + + // now prevent double-free of next.get() and following: + head->next = 0; + + // now add a new Component to 'result' (may throw): + result.resize(result.size() + 1); + result.back().comp.swap(head); // .comp = std::move( head ); + head.swap(next); // head = std::move( next ); + } + + return result; +} + +Error Component::save() const +{ + + if (isNull()) { + return Error(make_error(GPG_ERR_INV_ARG)); + } + + // + // 1. get a context: + // + gpgme_ctx_t ctx_native = 0; + if (const gpgme_error_t err = gpgme_new(&ctx_native)) { + return Error(err); + } + const shared_gpgme_ctx_t ctx(ctx_native, &gpgme_release); + + // + // 2. save the config: + // + return Error(gpgme_op_conf_save(ctx.get(), comp.get())); +} + +const char *Component::name() const +{ + return comp ? comp->name : 0 ; +} + +const char *Component::description() const +{ + return comp ? comp->description : 0 ; +} + +const char *Component::programName() const +{ + return comp ? comp->program_name : 0 ; +} + +Option Component::option(unsigned int idx) const +{ + gpgme_conf_opt_t opt = 0; + if (comp) { + opt = comp->options; + } + while (opt && idx) { + opt = opt->next; + --idx; + } + if (opt) { + return Option(comp, opt); + } + return Option(); +} + +Option Component::option(const char *name) const +{ + gpgme_conf_opt_t opt = 0; + if (comp) { + opt = comp->options; + } + using namespace std; // for strcmp + while (opt && strcmp(name, opt->name) != 0) { + opt = opt->next; + } + if (opt) { + return Option(comp, opt); + } + return Option(); +} + +unsigned int Component::numOptions() const +{ + unsigned int result = 0; + for (gpgme_conf_opt_t opt = comp ? comp->options : 0 ; opt ; opt = opt->next) { + ++result; + } + return result; +} + +std::vector<Option> Component::options() const +{ + std::vector<Option> result; + for (gpgme_conf_opt_t opt = comp ? comp->options : 0 ; opt ; opt = opt->next) { + result.push_back(Option(comp, opt)); + } + return result; +} + +static gpgme_conf_arg_t mygpgme_conf_arg_copy(gpgme_conf_arg_t other, gpgme_conf_type_t type) +{ + gpgme_conf_arg_t result = 0, last = 0; + for (gpgme_conf_arg_t a = other ; a ; a = a->next) { + gpgme_conf_arg_t arg = 0; + const gpgme_error_t err + = gpgme_conf_arg_new(&arg, type, + a->no_arg ? 0 : + type == GPGME_CONF_STRING ? a->value.string : + /* else */ static_cast<void *>(&a->value)); + if (err) { + gpgme_conf_arg_release(result, type); + return 0; + } + assert(arg); + if (result) { + last->next = arg; + } else { + result = arg; + } + last = arg; + } + return result; +} + +Component Option::parent() const +{ + return Component(comp.lock()); +} + +unsigned int Option::flags() const +{ + return isNull() ? 0 : opt->flags; +} + +Level Option::level() const +{ + return isNull() ? Internal : static_cast<Level>(opt->level) ; +} + +const char *Option::name() const +{ + return isNull() ? 0 : opt->name ; +} + +const char *Option::description() const +{ + return isNull() ? 0 : opt->description ; +} + +const char *Option::argumentName() const +{ + return isNull() ? 0 : opt->argname ; +} + +Type Option::type() const +{ + return isNull() ? NoType : static_cast<Type>(opt->type) ; +} + +Type Option::alternateType() const +{ + return isNull() ? NoType : static_cast<Type>(opt->alt_type) ; +} + +#if 0 +static Option::Variant argument_to_variant(gpgme_conf_type_t type, bool list, gpgme_conf_arg_t arg) +{ + assert(arg); + switch (type) { + case GPGME_CONF_NONE: + if (list) { + // return the count (number of times set): + return arg->value.count; + } else { + return none; + } + case GPGME_CONF_INT32: + if (list) { + std::vector<int> result; + for (gpgme_conf_arg_t a = arg ; a ; a = a->next) { + result.push_back(a->value.int32); + } + return result; + } else { + return arg->value.int32; + } + case GPGME_CONF_UINT32: + if (list) { + std::vector<unsigned int> result; + for (gpgme_conf_arg_t a = arg ; a ; a = a->next) { + result.push_back(a->value.uint32); + } + return result; + } else { + return arg->value.uint32; + } + case GPGME_CONF_FILENAME: + case GPGME_CONF_LDAP_SERVER: + case GPGME_CONF_KEY_FPR: + case GPGME_CONF_PUB_KEY: + case GPGME_CONF_SEC_KEY: + case GPGME_CONF_ALIAS_LIST: + // these should not happen in alt_type, but fall through + case GPGME_CONF_STRING: + if (list) { + std::vector<const char *> result; + for (gpgme_conf_arg_t a = arg ; a ; a = a->next) { + result.push_back(a->value.string); + } + return result; + } else { + return arg->value.string; + } + } + assert(!"Option: unknown alt_type!"); + return Option::Variant(); +} + +namespace +{ +inline const void *to_void_star(const char *s) +{ + return s; +} +inline const void *to_void_star(const std::string &s) +{ + return s.c_str(); +} +inline const void *to_void_star(const int &i) +{ + return &i; // const-&: sic! +} +inline const void *to_void_star(const unsigned int &i) +{ + return &i; // const-&: sic! +} + +struct VariantToArgumentVisitor : boost::static_visitor<gpgme_conf_arg_t> { + static gpgme_conf_arg_t make_argument(gpgme_conf_type_t type, const void *value) + { + gpgme_conf_arg_t arg = 0; +#ifdef HAVE_GPGME_CONF_ARG_NEW_WITH_CONST_VALUE + if (const gpgme_error_t err = gpgme_conf_arg_new(&arg, type, value)) { + return 0; + } +#else + if (const gpgme_error_t err = gpgme_conf_arg_new(&arg, type, const_cast<void *>(value))) { + return 0; + } +#endif + else { + return arg; + } + } + + gpgme_conf_arg_t operator()(bool v) const + { + return v ? make_argument(0) : 0 ; + } + + gpgme_conf_arg_t operator()(const char *s) const + { + return make_argument(s ? s : ""); + } + + gpgme_conf_arg_t operator()(const std::string &s) const + { + return operator()(s.c_str()); + } + + gpgme_conf_arg_t operator()(int i) const + { + return make_argument(&i); + } + + gpgme_conf_arg_t operator()(unsigned int i) const + { + return make_argument(&i); + } + + template <typename T> + gpgme_conf_arg_t operator()(const std::vector<T> &value) const + { + gpgme_conf_arg_t result = 0; + gpgme_conf_arg_t last = 0; + for (typename std::vector<T>::const_iterator it = value.begin(), end = value.end() ; it != end ; ++it) { + if (gpgme_conf_arg_t arg = make_argument(to_void_star(*it))) { + if (last) { + last = last->next = arg; + } else { + result = last = arg; + } + } + } + return result; + } + +}; +} + +static gpgme_conf_arg_t variant_to_argument(const Option::Variant &value) +{ + VariantToArgumentVisitor v; + return apply_visitor(v, value); +} + +optional<Option::Variant> Option::defaultValue() const +{ + if (isNull()) { + return optional<Variant>(); + } else { + return argument_to_variant(opt->alt_type, opt->flags & GPGME_CONF_LIST, opt->default_value); + } +} +#endif + +Argument Option::defaultValue() const +{ + if (isNull()) { + return Argument(); + } else { + return Argument(comp.lock(), opt, opt->default_value, false); + } +} + +const char *Option::defaultDescription() const +{ + return isNull() ? 0 : opt->default_description ; +} + +Argument Option::noArgumentValue() const +{ + if (isNull()) { + return Argument(); + } else { + return Argument(comp.lock(), opt, opt->no_arg_value, false); + } +} + +const char *Option::noArgumentDescription() const +{ + return isNull() ? 0 : opt->no_arg_description ; +} + +Argument Option::activeValue() const +{ + if (isNull()) { + return Argument(); + } else { + return Argument(comp.lock(), opt, opt->value, false); + } +} + +Argument Option::currentValue() const +{ + if (isNull()) { + return Argument(); + } + const gpgme_conf_arg_t arg = + opt->change_value ? opt->new_value ? opt->new_value : opt->default_value : + opt->value ? opt->value : + /* else */ opt->default_value ; + return Argument(comp.lock(), opt, arg, false); +} + +Argument Option::newValue() const +{ + if (isNull()) { + return Argument(); + } else { + return Argument(comp.lock(), opt, opt->new_value, false); + } +} + +bool Option::set() const +{ + if (isNull()) { + return false; + } else if (opt->change_value) { + return opt->new_value; + } else { + return opt->value; + } +} + +bool Option::dirty() const +{ + return !isNull() && opt->change_value ; +} + +Error Option::setNewValue(const Argument &argument) +{ + if (isNull()) { + return Error(make_error(GPG_ERR_INV_ARG)); + } else if (argument.isNull()) { + return resetToDefaultValue(); + } else if (const gpgme_conf_arg_t arg = mygpgme_conf_arg_copy(argument.arg, opt->alt_type)) { + return Error(gpgme_conf_opt_change(opt, 0, arg)); + } else { + return Error(make_error(GPG_ERR_ENOMEM)); + } +} + +Error Option::resetToActiveValue() +{ + if (isNull()) { + return Error(make_error(GPG_ERR_INV_ARG)); + } else { + return Error(gpgme_conf_opt_change(opt, 1, 0)); + } +} + +Error Option::resetToDefaultValue() +{ + if (isNull()) { + return Error(make_error(GPG_ERR_INV_ARG)); + } else { + return Error(gpgme_conf_opt_change(opt, 0, 0)); + } +} + +static gpgme_conf_arg_t make_argument(gpgme_conf_type_t type, const void *value) +{ + gpgme_conf_arg_t arg = 0; + if (const gpgme_error_t err = gpgme_conf_arg_new(&arg, type, value)) { + return 0; + } else { + return arg; + } +} + +Argument Option::createNoneArgument(bool set) const +{ + if (isNull() || alternateType() != NoType) { + return Argument(); + } else { + if (set) { + return createNoneListArgument(1); + } + } + return Argument(); +} + +Argument Option::createStringArgument(const char *value) const +{ + if (isNull() || alternateType() != StringType) { + return Argument(); + } else { + return Argument(comp.lock(), opt, make_argument(GPGME_CONF_STRING, value), true); + } +} + +Argument Option::createStringArgument(const std::string &value) const +{ + if (isNull() || alternateType() != StringType) { + return Argument(); + } else { + return Argument(comp.lock(), opt, make_argument(GPGME_CONF_STRING, value.c_str()), true); + } +} + +Argument Option::createIntArgument(int value) const +{ + if (isNull() || alternateType() != IntegerType) { + return Argument(); + } else { + return Argument(comp.lock(), opt, make_argument(GPGME_CONF_INT32, &value), true); + } +} + +Argument Option::createUIntArgument(unsigned int value) const +{ + if (isNull() || alternateType() != UnsignedIntegerType) { + return Argument(); + } else { + return Argument(comp.lock(), opt, make_argument(GPGME_CONF_UINT32, &value), true); + } +} + +namespace +{ +const void *to_void_star(const char *s) +{ + return s; +} +const void *to_void_star(const std::string &s) +{ + return s.c_str(); +} +const void *to_void_star(const int &i) +{ + return &i; // const-&: sic! +} +const void *to_void_star(const unsigned int &i) +{ + return &i; // const-&: sic! +} + +template <typename T> +gpgme_conf_arg_t make_argument(gpgme_conf_type_t type, const std::vector<T> &value) +{ + gpgme_conf_arg_t result = 0; + gpgme_conf_arg_t last = 0; + for (typename std::vector<T>::const_iterator it = value.begin(), end = value.end() ; it != end ; ++it) { + if (gpgme_conf_arg_t arg = make_argument(type, to_void_star(*it))) { + if (last) { + last = last->next = arg; + } else { + result = last = arg; + } + } + } + return result; +} +} + +Argument Option::createNoneListArgument(unsigned int value) const +{ + if (value) { + return Argument(comp.lock(), opt, make_argument(GPGME_CONF_NONE, &value), true); + } + return Argument(); +} + +Argument Option::createStringListArgument(const std::vector<const char *> &value) const +{ + return Argument(comp.lock(), opt, make_argument(GPGME_CONF_STRING, value), true); +} + +Argument Option::createStringListArgument(const std::vector<std::string> &value) const +{ + return Argument(comp.lock(), opt, make_argument(GPGME_CONF_STRING, value), true); +} + +Argument Option::createIntListArgument(const std::vector<int> &value) const +{ + return Argument(comp.lock(), opt, make_argument(GPGME_CONF_INT32, value), true); +} + +Argument Option::createUIntListArgument(const std::vector<unsigned int> &value) const +{ + return Argument(comp.lock(), opt, make_argument(GPGME_CONF_UINT32, value), true); +} + +Argument::Argument(const shared_gpgme_conf_comp_t &comp, gpgme_conf_opt_t opt, gpgme_conf_arg_t arg, bool owns) + : comp(comp), + opt(opt), + arg(owns ? arg : mygpgme_conf_arg_copy(arg, opt ? opt->alt_type : GPGME_CONF_NONE)) +{ + +} + +#if 0 +Argument::Argument(const shared_gpgme_conf_comp_t &comp, gpgme_conf_opt_t opt, gpgme_conf_arg_t arg) + : comp(comp), + opt(opt), + arg(mygpgme_conf_arg_copy(arg, opt ? opt->alt_type : GPGME_CONF_NONE)) +{ + +} +#endif + +Argument::Argument(const Argument &other) + : comp(other.comp), + opt(other.opt), + arg(mygpgme_conf_arg_copy(other.arg, opt ? opt->alt_type : GPGME_CONF_NONE)) +{ + +} + +Argument::~Argument() +{ + gpgme_conf_arg_release(arg, opt ? opt->alt_type : GPGME_CONF_NONE); +} + +Option Argument::parent() const +{ + return Option(comp.lock(), opt); +} + +bool Argument::boolValue() const +{ + return numberOfTimesSet(); +} + +unsigned int Argument::numElements() const +{ + if (isNull()) { + return 0; + } + unsigned int result = 0; + for (gpgme_conf_arg_t a = arg ; a ; a = a->next) { + ++result; + } + return result; +} + +const char *Argument::stringValue(unsigned int idx) const +{ + if (isNull() || opt->alt_type != GPGME_CONF_STRING) { + return 0; + } + gpgme_conf_arg_t a = arg; + while (a && idx) { + a = a->next; + --idx; + } + return a ? a->value.string : 0 ; +} + +int Argument::intValue(unsigned int idx) const +{ + if (isNull() || opt->alt_type != GPGME_CONF_INT32) { + return 0; + } + gpgme_conf_arg_t a = arg; + while (a && idx) { + a = a->next; + --idx; + } + return a ? a->value.int32 : 0 ; +} + +unsigned int Argument::uintValue(unsigned int idx) const +{ + if (isNull() || opt->alt_type != GPGME_CONF_UINT32) { + return 0; + } + gpgme_conf_arg_t a = arg; + while (a && idx) { + a = a->next; + --idx; + } + return a ? a->value.uint32 : 0 ; +} + +unsigned int Argument::numberOfTimesSet() const +{ + if (isNull() || opt->alt_type != GPGME_CONF_NONE) { + return 0; + } + return arg->value.count; +} + +std::vector<const char *> Argument::stringValues() const +{ + if (isNull() || opt->alt_type != GPGME_CONF_STRING) { + return std::vector<const char *>(); + } + std::vector<const char *> result; + for (gpgme_conf_arg_t a = arg ; a ; a = a->next) { + result.push_back(a->value.string); + } + return result; +} + +std::vector<int> Argument::intValues() const +{ + if (isNull() || opt->alt_type != GPGME_CONF_INT32) { + return std::vector<int>(); + } + std::vector<int> result; + for (gpgme_conf_arg_t a = arg ; a ; a = a->next) { + result.push_back(a->value.int32); + } + return result; +} + +std::vector<unsigned int> Argument::uintValues() const +{ + if (isNull() || opt->alt_type != GPGME_CONF_UINT32) { + return std::vector<unsigned int>(); + } + std::vector<unsigned int> result; + for (gpgme_conf_arg_t a = arg ; a ; a = a->next) { + result.push_back(a->value.uint32); + } + return result; +} + +std::ostream &Configuration::operator<<(std::ostream &os, Level level) +{ + switch (level) { + case Basic: return os << "Basic"; + case Advanced: return os << "Advanced"; + case Expert: return os << "Expert"; + case Invisible: return os << "Invisible"; + case Internal: return os << "Internal"; + case NumLevels: ; + } + return os << "<unknown>"; +} + +std::ostream &Configuration::operator<<(std::ostream &os, Type type) +{ + switch (type) { + case NoType: return os << "None"; + case StringType: return os << "String"; + case IntegerType: return os << "Integer"; + case UnsignedIntegerType: return os << "UnsignedInteger"; + case FilenameType: return os << "Filename"; + case LdapServerType: return os << "LdapServer"; + case KeyFingerprintType: return os << "KeyFingerprint"; + case PublicKeyType: return os << "PublicKey"; + case SecretKeyType: return os << "SecretKey"; + case AliasListType: return os << "AliasList"; + case MaxType: ; + } + return os << "<unknown>"; +} + +std::ostream &Configuration::operator<<(std::ostream &os, Flag f) +{ + unsigned int flags = f; + std::vector<const char *> s; + if (flags & Group) { + s.push_back("Group"); + } + if (flags & Optional) { + s.push_back("Optional"); + } + if (flags & List) { + s.push_back("List"); + } + if (flags & Runtime) { + s.push_back("Runtime"); + } + if (flags & Default) { + s.push_back("Default"); + } + if (flags & DefaultDescription) { + s.push_back("DefaultDescription"); + } + if (flags & NoArgumentDescription) { + s.push_back("NoArgumentDescription"); + } + if (flags & NoChange) { + s.push_back("NoChange"); + } + flags &= ~(Group | Optional | List | Runtime | Default | DefaultDescription | NoArgumentDescription | NoChange); + if (flags) { + s.push_back("other flags("); + } + std::copy(s.begin(), s.end(), + std::ostream_iterator<const char *>(os, "|")); + if (flags) { + os << flags << ')'; + } + return os; +} + +std::ostream &Configuration::operator<<(std::ostream &os, const Component &c) +{ + os << "Component[" + << "\n name : " << protect(c.name()) + << "\n description: " << protect(c.description()) + << "\n programName: " << protect(c.programName()) + << "\n options : \n"; + const std::vector<Option> options = c.options(); + std::copy(options.begin(), options.end(), + std::ostream_iterator<Option>(os, "\n")); + os << "\n]"; + return os; +} + +std::ostream &Configuration::operator<<(std::ostream &os, const Option &o) +{ + return os << "Option[" + << "\n name: : " << protect(o.name()) + << "\n description : " << protect(o.description()) + << "\n argName : " << protect(o.argumentName()) + << "\n flags : " << static_cast<Flag>(o.flags()) + << "\n level : " << o.level() + << "\n type : " << o.type() + << "\n alt_type : " << o.alternateType() + << "\n default_val : " << o.defaultValue() + << "\n default_desc: " << protect(o.defaultDescription()) + << "\n no_arg_value: " << o.noArgumentValue() + << "\n no_arg_desc : " << protect(o.noArgumentDescription()) + << "\n active_value: " << o.activeValue() + << "\n new_value : " << o.newValue() + << "\n --> cur_val : " << o.currentValue() + << "\n set : " << o.set() + << "\n dirty : " << o.dirty() + << "\n]" + ; +} + +std::ostream &Configuration::operator<<(std::ostream &os, const Argument &a) +{ + const Option o = a.parent(); + const bool list = o.flags() & List; + os << "Argument["; + if (a) { + switch (o.alternateType()) { + case NoType: + if (list) { + os << a.numberOfTimesSet() << 'x'; + } else { + os << a.boolValue(); + } + break; + default: + case StringType: + if (list) { + const std::vector<const char *> v = a.stringValues(); + os << v.size() << ':'; + // can't use std::copy + ostream_iterator here, since we need the protect() call + bool first = true; + std::for_each(v.begin(), v.end(), [&first, &os](const char *s) { + if (first) { + first = false; + } else { + os << ','; + } + os << protect(s); + }); + } else { + os << protect(a.stringValue()); + } + break; + case IntegerType: + if (list) { + const std::vector<int> v = a.intValues(); + os << v.size() << ':'; + std::copy(v.begin(), v.end(), + std::ostream_iterator<int>(os, ",")); + } else { + os << a.intValue(); + } + break; + case UnsignedIntegerType: + if (list) { + const std::vector<unsigned int> v = a.uintValues(); + os << v.size() << ':'; + std::copy(v.begin(), v.end(), + std::ostream_iterator<unsigned int>(os, ",")); + } else { + os << a.intValue(); + } + break; + } + } + return os << ']'; +} diff --git a/lang/cpp/src/configuration.h b/lang/cpp/src/configuration.h new file mode 100644 index 00000000..288a410d --- /dev/null +++ b/lang/cpp/src/configuration.h @@ -0,0 +1,290 @@ +/* + configuration.h - wraps gpgme configuration components + Copyright (C) 2010 Klarälvdalens Datakonsult AB + + This file is part of GPGME++. + + GPGME++ is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + GPGME++ is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Library General Public License for more details. + + You should have received a copy of the GNU Library General Public License + along with GPGME++; see the file COPYING.LIB. If not, write to the + Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. +*/ + +// -*- c++ -*- +#ifndef __GPGMEPP_CONFIGURATION_H__ +#define __GPGMEPP_CONFIGURATION_H__ + +#include "global.h" + +#include "gpgmefw.h" + +#include <iosfwd> +#include <vector> +#include <string> +#include <algorithm> +#include <memory> + +namespace GpgME +{ +namespace Configuration +{ + +typedef std::shared_ptr< std::remove_pointer<gpgme_conf_comp_t>::type > shared_gpgme_conf_comp_t; +typedef std::weak_ptr< std::remove_pointer<gpgme_conf_comp_t>::type > weak_gpgme_conf_comp_t; + +class Argument; +class Option; +class Component; + +enum Level { + Basic, + Advanced, + Expert, + Invisible, + Internal, + + NumLevels +}; + +enum Type { + NoType, + StringType, + IntegerType, + UnsignedIntegerType, + + FilenameType = 32, + LdapServerType, + KeyFingerprintType, + PublicKeyType, + SecretKeyType, + AliasListType, + + MaxType +}; + +enum Flag { + Group = (1 << 0), + Optional = (1 << 1), + List = (1 << 2), + Runtime = (1 << 3), + Default = (1 << 4), + DefaultDescription = (1 << 5), + NoArgumentDescription = (1 << 6), + NoChange = (1 << 7), + + LastFlag = NoChange +}; + +// +// class Component +// + +class GPGMEPP_EXPORT Component +{ +public: + Component() : comp() {} + explicit Component(const shared_gpgme_conf_comp_t &comp) + : comp(comp) {} + + // copy ctor is ok + + const Component &operator=(const Component &other) + { + if (this != &other) { + Component(other).swap(*this); + } + return *this; + } + + void swap(Component &other) + { + using std::swap; + swap(this->comp, other.comp); + } + + bool isNull() const + { + return !comp; + } + + static std::vector<Component> load(Error &err); + Error save() const; + + const char *name() const; + const char *description() const; + const char *programName() const; + + Option option(unsigned int index) const; + Option option(const char *name) const; + + unsigned int numOptions() const; + + std::vector<Option> options() const; + + GPGMEPP_MAKE_SAFE_BOOL_OPERATOR(!isNull()) +private: + shared_gpgme_conf_comp_t comp; +}; + +// +// class Option +// + +class GPGMEPP_EXPORT Option +{ +public: + Option() : comp(), opt(0) {} + Option(const shared_gpgme_conf_comp_t &comp, gpgme_conf_opt_t opt) + : comp(comp), opt(opt) {} + + const Option &operator=(const Option &other) + { + if (this != &other) { + Option(other).swap(*this); + } + return *this; + } + + void swap(Option &other) + { + using std::swap; + swap(this->comp, other.comp); + swap(this->opt, other.opt); + } + + bool isNull() const + { + return comp.expired() || !opt; + } + + Component parent() const; + + unsigned int flags() const; + + Level level() const; + + const char *name() const; + const char *description() const; + const char *argumentName() const; + + Type type() const; + Type alternateType() const; + + Argument defaultValue() const; + const char *defaultDescription() const; + + Argument noArgumentValue() const; + const char *noArgumentDescription() const; + + /*! The value that is in the config file (or null, if it's not set). */ + Argument activeValue() const; + /*! The value that is in this object, ie. either activeValue(), newValue(), or defaultValue() */ + Argument currentValue() const; + + Argument newValue() const; + bool set() const; + bool dirty() const; + + Error setNewValue(const Argument &argument); + Error resetToDefaultValue(); + Error resetToActiveValue(); + + Argument createNoneArgument(bool set) const; + Argument createStringArgument(const char *value) const; + Argument createStringArgument(const std::string &value) const; + Argument createIntArgument(int value) const; + Argument createUIntArgument(unsigned int value) const; + + Argument createNoneListArgument(unsigned int count) const; + Argument createStringListArgument(const std::vector<const char *> &value) const; + Argument createStringListArgument(const std::vector<std::string> &value) const; + Argument createIntListArgument(const std::vector<int> &values) const; + Argument createUIntListArgument(const std::vector<unsigned int> &values) const; + + GPGMEPP_MAKE_SAFE_BOOL_OPERATOR(!isNull()) +private: + weak_gpgme_conf_comp_t comp; + gpgme_conf_opt_t opt; +}; + +// +// class Argument +// + +class GPGMEPP_EXPORT Argument +{ + friend class ::GpgME::Configuration::Option; + Argument(const shared_gpgme_conf_comp_t &comp, gpgme_conf_opt_t opt, gpgme_conf_arg_t arg, bool owns); +public: + Argument() : comp(), opt(0), arg(0) {} + //Argument( const shared_gpgme_conf_comp_t & comp, gpgme_conf_opt_t opt, gpgme_conf_arg_t arg ); + Argument(const Argument &other); + ~Argument(); + + const Argument &operator=(const Argument &other) + { + if (this != &other) { + Argument(other).swap(*this); + } + return *this; + } + + void swap(Argument &other) + { + using std::swap; + swap(this->comp, other.comp); + swap(this->opt, other.opt); + swap(this->arg, other.arg); + } + + bool isNull() const + { + return comp.expired() || !opt || !arg; + } + + Option parent() const; + + unsigned int numElements() const; + + bool boolValue() const; + const char *stringValue(unsigned int index = 0) const; + int intValue(unsigned int index = 0) const; + unsigned int uintValue(unsigned int index = 0) const; + + unsigned int numberOfTimesSet() const; + std::vector<const char *> stringValues() const; + std::vector<int> intValues() const; + std::vector<unsigned int> uintValues() const; + + GPGMEPP_MAKE_SAFE_BOOL_OPERATOR(!isNull()) +private: + weak_gpgme_conf_comp_t comp; + gpgme_conf_opt_t opt; + gpgme_conf_arg_t arg; +}; + +GPGMEPP_EXPORT std::ostream &operator<<(std::ostream &os, Level level); +GPGMEPP_EXPORT std::ostream &operator<<(std::ostream &os, Type type); +GPGMEPP_EXPORT std::ostream &operator<<(std::ostream &os, Flag flag); +GPGMEPP_EXPORT std::ostream &operator<<(std::ostream &os, const Component &component); +GPGMEPP_EXPORT std::ostream &operator<<(std::ostream &os, const Option &option); +GPGMEPP_EXPORT std::ostream &operator<<(std::ostream &os, const Argument &argument); + +} // namespace Configuration +} // namespace GpgME + +GPGMEPP_MAKE_STD_SWAP_SPECIALIZATION(Configuration::Component) +GPGMEPP_MAKE_STD_SWAP_SPECIALIZATION(Configuration::Option) +GPGMEPP_MAKE_STD_SWAP_SPECIALIZATION(Configuration::Argument) + +#endif // __GPGMEPP_CONFIGURATION_H__ diff --git a/lang/cpp/src/context.cpp b/lang/cpp/src/context.cpp new file mode 100644 index 00000000..93244b41 --- /dev/null +++ b/lang/cpp/src/context.cpp @@ -0,0 +1,1494 @@ +/* + context.cpp - wraps a gpgme key context + Copyright (C) 2003, 2007 Klarälvdalens Datakonsult AB + + This file is part of GPGME++. + + GPGME++ is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + GPGME++ is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Library General Public License for more details. + + You should have received a copy of the GNU Library General Public License + along with GPGME++; see the file COPYING.LIB. If not, write to the + Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. +*/ + +#include <context.h> +#include <eventloopinteractor.h> +#include <trustitem.h> +#include <assuanresult.h> +#include <keylistresult.h> +#include <keygenerationresult.h> +#include <importresult.h> +#include <decryptionresult.h> +#include <verificationresult.h> +#include <signingresult.h> +#include <encryptionresult.h> +#include <engineinfo.h> +#include <editinteractor.h> +#include <vfsmountresult.h> + +#include <interfaces/assuantransaction.h> +#include <defaultassuantransaction.h> + +#include "callbacks.h" +#include "data_p.h" +#include "context_p.h" +#include "util.h" + +#include <gpgme.h> + +#include <istream> +#ifndef NDEBUG +#include <iostream> +using std::cerr; +using std::endl; +#endif + +#include <cassert> + +namespace GpgME +{ + +static inline unsigned int xtoi_1(const char *str) +{ + const unsigned int ch = *str; + const unsigned int result = + ch <= '9' ? ch - '0' : + ch <= 'F' ? ch - 'A' + 10 : + /* else */ ch - 'a' + 10 ; + return result < 16 ? result : 0 ; +} +static inline int xtoi_2(const char *str) +{ + return xtoi_1(str) * 16U + xtoi_1(str + 1); +} + +static void percent_unescape(std::string &s, bool plus2space) +{ + std::string::iterator src = s.begin(), dest = s.begin(), end = s.end(); + while (src != end) { + if (*src == '%' && end - src > 2) { + *dest++ = xtoi_2(&*++src); + src += 2; + } else if (*src == '+' && plus2space) { + *dest++ = ' '; + ++src; + } else { + *dest++ = *src++; + } + } + s.erase(dest, end); +} + +void initializeLibrary() +{ + gpgme_check_version(0); +} + +Error initializeLibrary(int) +{ + if (gpgme_check_version(GPGME_VERSION)) { + return Error(); + } else { + return Error::fromCode(GPG_ERR_USER_1); + } +} + +static void format_error(gpgme_error_t err, std::string &str) +{ + char buffer[ 1024 ]; + gpgme_strerror_r(err, buffer, sizeof buffer); + buffer[ sizeof buffer - 1 ] = '\0'; + str = buffer; +} + +const char *Error::source() const +{ + return gpgme_strsource((gpgme_error_t)mErr); +} + +const char *Error::asString() const +{ + if (mMessage.empty()) { + format_error(static_cast<gpgme_error_t>(mErr), mMessage); + } + return mMessage.c_str(); +} + +int Error::code() const +{ + return gpgme_err_code(mErr); +} + +int Error::sourceID() const +{ + return gpgme_err_source(mErr); +} + +bool Error::isCanceled() const +{ + return code() == GPG_ERR_CANCELED; +} + +int Error::toErrno() const +{ +//#ifdef HAVE_GPGME_GPG_ERROR_WRAPPERS + return gpgme_err_code_to_errno(static_cast<gpgme_err_code_t>(code())); +//#else +// return gpg_err_code_to_errno( static_cast<gpg_err_code_t>( code() ) ); +//#endif +} + +// static +bool Error::hasSystemError() +{ + return gpgme_err_code_from_syserror() == GPG_ERR_MISSING_ERRNO ; +} + +// static +void Error::setSystemError(gpg_err_code_t err) +{ + setErrno(gpgme_err_code_to_errno(err)); +} + +// static +void Error::setErrno(int err) +{ + gpgme_err_set_errno(err); +} + +// static +Error Error::fromSystemError(unsigned int src) +{ + return Error(gpgme_err_make(static_cast<gpgme_err_source_t>(src), gpgme_err_code_from_syserror())); +} + +// static +Error Error::fromErrno(int err, unsigned int src) +{ + return Error(gpgme_err_make(static_cast<gpgme_err_source_t>(src), gpgme_err_code_from_errno(err))); +} + +// static +Error Error::fromCode(unsigned int err, unsigned int src) +{ + return Error(gpgme_err_make(static_cast<gpgme_err_source_t>(src), static_cast<gpgme_err_code_t>(err))); +} + +std::ostream &operator<<(std::ostream &os, const Error &err) +{ + return os << "GpgME::Error(" << err.encodedError() << " (" << err.asString() << "))"; +} + +Context::Context(gpgme_ctx_t ctx) : d(new Private(ctx)) +{ +} + +Context::~Context() +{ + delete d; +} + +Context *Context::createForProtocol(Protocol proto) +{ + gpgme_ctx_t ctx = 0; + if (gpgme_new(&ctx) != 0) { + return 0; + } + + switch (proto) { + case OpenPGP: + if (gpgme_set_protocol(ctx, GPGME_PROTOCOL_OpenPGP) != 0) { + gpgme_release(ctx); + return 0; + } + 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); +} + +std::auto_ptr<Context> Context::createForEngine(Engine eng, Error *error) +{ + gpgme_ctx_t ctx = 0; + if (const gpgme_error_t err = gpgme_new(&ctx)) { + if (error) { + *error = Error(err); + } + return std::auto_ptr<Context>(); + } + + switch (eng) { + case AssuanEngine: + if (const gpgme_error_t err = gpgme_set_protocol(ctx, GPGME_PROTOCOL_ASSUAN)) { + gpgme_release(ctx); + if (error) { + *error = Error(err); + } + return std::auto_ptr<Context>(); + } + break; + case G13Engine: + if (const gpgme_error_t err = gpgme_set_protocol(ctx, GPGME_PROTOCOL_G13)) { + gpgme_release(ctx); + if (error) { + *error = Error(err); + } + return std::auto_ptr<Context>(); + } + break; + default: + if (error) { + *error = Error::fromCode(GPG_ERR_INV_ARG); + } + return std::auto_ptr<Context>(); + } + + if (error) { + *error = Error(); + } + + return std::auto_ptr<Context>(new Context(ctx)); +} + +// +// +// Context::Private +// +// + +Context::Private::Private(gpgme_ctx_t c) + : ctx(c), + iocbs(0), + lastop(None), + lasterr(GPG_ERR_NO_ERROR), + lastAssuanInquireData(Data::null), + lastAssuanTransaction(), + lastEditInteractor(), + lastCardEditInteractor() +{ + +} + +Context::Private::~Private() +{ + if (ctx) { + gpgme_release(ctx); + } + ctx = 0; + delete iocbs; +} + +// +// +// Context attributes: +// +// + +Protocol Context::protocol() const +{ + gpgme_protocol_t p = gpgme_get_protocol(d->ctx); + switch (p) { + case GPGME_PROTOCOL_OpenPGP: return OpenPGP; + case GPGME_PROTOCOL_CMS: return CMS; + default: return UnknownProtocol; + } +} + +void Context::setArmor(bool useArmor) +{ + gpgme_set_armor(d->ctx, int(useArmor)); +} +bool Context::armor() const +{ + return gpgme_get_armor(d->ctx); +} + +void Context::setTextMode(bool useTextMode) +{ + gpgme_set_textmode(d->ctx, int(useTextMode)); +} +bool Context::textMode() const +{ + return gpgme_get_textmode(d->ctx); +} + +void Context::setOffline(bool useOfflineMode) +{ + gpgme_set_offline(d->ctx, int(useOfflineMode)); +} +bool Context::offline() const +{ + return gpgme_get_offline(d->ctx); +} + +void Context::setIncludeCertificates(int which) +{ + if (which == DefaultCertificates) { + which = GPGME_INCLUDE_CERTS_DEFAULT; + } + gpgme_set_include_certs(d->ctx, which); +} + +int Context::includeCertificates() const +{ + return gpgme_get_include_certs(d->ctx); +} + +void Context::setKeyListMode(unsigned int mode) +{ + gpgme_set_keylist_mode(d->ctx, add_to_gpgme_keylist_mode_t(0, mode)); +} + +void Context::addKeyListMode(unsigned int mode) +{ + const unsigned int cur = gpgme_get_keylist_mode(d->ctx); + gpgme_set_keylist_mode(d->ctx, add_to_gpgme_keylist_mode_t(cur, mode)); +} + +unsigned int Context::keyListMode() const +{ + return convert_from_gpgme_keylist_mode_t(gpgme_get_keylist_mode(d->ctx)); +} + +void Context::setProgressProvider(ProgressProvider *provider) +{ + gpgme_set_progress_cb(d->ctx, provider ? &progress_callback : 0, provider); +} +ProgressProvider *Context::progressProvider() const +{ + void *pp = 0; + gpgme_progress_cb_t pcb = &progress_callback; + gpgme_get_progress_cb(d->ctx, &pcb, &pp); + return static_cast<ProgressProvider *>(pp); +} + +void Context::setPassphraseProvider(PassphraseProvider *provider) +{ + gpgme_set_passphrase_cb(d->ctx, provider ? &passphrase_callback : 0, provider); +} + +PassphraseProvider *Context::passphraseProvider() const +{ + void *pp = 0; + gpgme_passphrase_cb_t pcb = &passphrase_callback; + gpgme_get_passphrase_cb(d->ctx, &pcb, &pp); + return static_cast<PassphraseProvider *>(pp); +} + +void Context::setManagedByEventLoopInteractor(bool manage) +{ + if (!EventLoopInteractor::instance()) { +#ifndef NDEBUG + cerr << "Context::setManagedByEventLoopInteractor(): " + "You must create an instance of EventLoopInteractor " + "before using anything that needs one." << endl; +#endif + return; + } + if (manage) { + EventLoopInteractor::instance()->manage(this); + } else { + EventLoopInteractor::instance()->unmanage(this); + } +} +bool Context::managedByEventLoopInteractor() const +{ + return d->iocbs != 0; +} + +void Context::installIOCallbacks(gpgme_io_cbs *iocbs) +{ + if (!iocbs) { + uninstallIOCallbacks(); + return; + } + gpgme_set_io_cbs(d->ctx, iocbs); + delete d->iocbs; d->iocbs = iocbs; +} + +void Context::uninstallIOCallbacks() +{ + static gpgme_io_cbs noiocbs = { 0, 0, 0, 0, 0 }; + // io.add == 0 means disable io callbacks: + gpgme_set_io_cbs(d->ctx, &noiocbs); + delete d->iocbs; d->iocbs = 0; +} + +Error Context::setLocale(int cat, const char *val) +{ + return Error(d->lasterr = gpgme_set_locale(d->ctx, cat, val)); +} + +EngineInfo Context::engineInfo() const +{ + return EngineInfo(gpgme_ctx_get_engine_info(d->ctx)); +} + +Error Context::setEngineFileName(const char *filename) +{ + const char *const home_dir = engineInfo().homeDirectory(); + return Error(gpgme_ctx_set_engine_info(d->ctx, gpgme_get_protocol(d->ctx), filename, home_dir)); +} + +Error Context::setEngineHomeDirectory(const char *home_dir) +{ + const char *const filename = engineInfo().fileName(); + return Error(gpgme_ctx_set_engine_info(d->ctx, gpgme_get_protocol(d->ctx), filename, home_dir)); +} + +// +// +// Key Management +// +// + +Error Context::startKeyListing(const char *pattern, bool secretOnly) +{ + d->lastop = Private::KeyList; + return Error(d->lasterr = gpgme_op_keylist_start(d->ctx, pattern, int(secretOnly))); +} + +Error Context::startKeyListing(const char *patterns[], bool secretOnly) +{ + d->lastop = Private::KeyList; +#ifndef HAVE_GPGME_EXT_KEYLIST_MODE_EXTERNAL_NONBROKEN + if (!patterns || !patterns[0] || !patterns[1]) { + // max. one pattern -> use the non-ext version + return startKeyListing(patterns ? patterns[0] : 0, secretOnly); + } +#endif + return Error(d->lasterr = gpgme_op_keylist_ext_start(d->ctx, patterns, int(secretOnly), 0)); +} + +Key Context::nextKey(GpgME::Error &e) +{ + d->lastop = Private::KeyList; + gpgme_key_t key; + e = Error(d->lasterr = gpgme_op_keylist_next(d->ctx, &key)); + return Key(key, false); +} + +KeyListResult Context::endKeyListing() +{ + d->lasterr = gpgme_op_keylist_end(d->ctx); + return keyListResult(); +} + +KeyListResult Context::keyListResult() const +{ + return KeyListResult(d->ctx, Error(d->lasterr)); +} + +Key Context::key(const char *fingerprint, GpgME::Error &e , bool secret /*, bool forceUpdate*/) +{ + d->lastop = Private::KeyList; + gpgme_key_t key; + e = Error(d->lasterr = gpgme_get_key(d->ctx, fingerprint, &key, int(secret)/*, int( forceUpdate )*/)); + return Key(key, false); +} + +KeyGenerationResult Context::generateKey(const char *parameters, Data &pubKey) +{ + d->lastop = Private::KeyGen; + Data::Private *const dp = pubKey.impl(); + d->lasterr = gpgme_op_genkey(d->ctx, parameters, dp ? dp->data : 0, 0); + return KeyGenerationResult(d->ctx, Error(d->lasterr)); +} + +Error Context::startKeyGeneration(const char *parameters, Data &pubKey) +{ + d->lastop = Private::KeyGen; + Data::Private *const dp = pubKey.impl(); + return Error(d->lasterr = gpgme_op_genkey_start(d->ctx, parameters, dp ? dp->data : 0, 0)); +} + +KeyGenerationResult Context::keyGenerationResult() const +{ + if (d->lastop & Private::KeyGen) { + return KeyGenerationResult(d->ctx, Error(d->lasterr)); + } else { + return KeyGenerationResult(); + } +} + +Error Context::exportPublicKeys(const char *pattern, Data &keyData) +{ + d->lastop = Private::Export; + Data::Private *const dp = keyData.impl(); + return Error(d->lasterr = gpgme_op_export(d->ctx, pattern, 0, dp ? dp->data : 0)); +} + +Error Context::exportPublicKeys(const char *patterns[], Data &keyData) +{ + d->lastop = Private::Export; +#ifndef HAVE_GPGME_EXT_KEYLIST_MODE_EXTERNAL_NONBROKEN + if (!patterns || !patterns[0] || !patterns[1]) { + // max. one pattern -> use the non-ext version + return exportPublicKeys(patterns ? patterns[0] : 0, keyData); + } +#endif + Data::Private *const dp = keyData.impl(); + return Error(d->lasterr = gpgme_op_export_ext(d->ctx, patterns, 0, dp ? dp->data : 0)); +} + +Error Context::startPublicKeyExport(const char *pattern, Data &keyData) +{ + d->lastop = Private::Export; + Data::Private *const dp = keyData.impl(); + return Error(d->lasterr = gpgme_op_export_start(d->ctx, pattern, 0, dp ? dp->data : 0)); +} + +Error Context::startPublicKeyExport(const char *patterns[], Data &keyData) +{ + d->lastop = Private::Export; +#ifndef HAVE_GPGME_EXT_KEYLIST_MODE_EXTERNAL_NONBROKEN + if (!patterns || !patterns[0] || !patterns[1]) { + // max. one pattern -> use the non-ext version + return startPublicKeyExport(patterns ? patterns[0] : 0, keyData); + } +#endif + Data::Private *const dp = keyData.impl(); + return Error(d->lasterr = gpgme_op_export_ext_start(d->ctx, patterns, 0, dp ? dp->data : 0)); +} + +ImportResult Context::importKeys(const Data &data) +{ + d->lastop = Private::Import; + const Data::Private *const dp = data.impl(); + d->lasterr = gpgme_op_import(d->ctx, dp ? dp->data : 0); + return ImportResult(d->ctx, Error(d->lasterr)); +} + +ImportResult Context::importKeys(const std::vector<Key> &kk) +{ + d->lastop = Private::Import; + d->lasterr = make_error(GPG_ERR_NOT_IMPLEMENTED); + + bool shouldHaveResult = false; + gpgme_key_t * const keys = new gpgme_key_t[ kk.size() + 1 ]; + gpgme_key_t *keys_it = &keys[0]; + for (std::vector<Key>::const_iterator it = kk.begin(), end = kk.end() ; it != end ; ++it) { + if (it->impl()) { + *keys_it++ = it->impl(); + } + } + *keys_it++ = 0; + d->lasterr = gpgme_op_import_keys(d->ctx, keys); + shouldHaveResult = true; + if ((gpgme_err_code(d->lasterr) == GPG_ERR_NOT_IMPLEMENTED || + gpgme_err_code(d->lasterr) == GPG_ERR_NOT_SUPPORTED) && + protocol() == CMS) { + // ok, try the workaround (export+import): + std::vector<const char *> fprs; + for (std::vector<Key>::const_iterator it = kk.begin(), end = kk.end() ; it != end ; ++it) { + if (const char *fpr = it->primaryFingerprint()) { + if (*fpr) { + fprs.push_back(fpr); + } + } else if (const char *keyid = it->keyID()) { + if (*keyid) { + fprs.push_back(keyid); + } + } + } + fprs.push_back(0); + Data data; + Data::Private *const dp = data.impl(); + const gpgme_keylist_mode_t oldMode = gpgme_get_keylist_mode(d->ctx); + gpgme_set_keylist_mode(d->ctx, GPGME_KEYLIST_MODE_EXTERN); + d->lasterr = gpgme_op_export_ext(d->ctx, &fprs[0], 0, dp ? dp->data : 0); + gpgme_set_keylist_mode(d->ctx, oldMode); + if (!d->lasterr) { + data.seek(0, SEEK_SET); + d->lasterr = gpgme_op_import(d->ctx, dp ? dp->data : 0); + shouldHaveResult = true; + } + } + delete[] keys; + if (shouldHaveResult) { + return ImportResult(d->ctx, Error(d->lasterr)); + } else { + return ImportResult(Error(d->lasterr)); + } +} + +Error Context::startKeyImport(const Data &data) +{ + d->lastop = Private::Import; + const Data::Private *const dp = data.impl(); + return Error(d->lasterr = gpgme_op_import_start(d->ctx, dp ? dp->data : 0)); +} + +Error Context::startKeyImport(const std::vector<Key> &kk) +{ + d->lastop = Private::Import; + gpgme_key_t * const keys = new gpgme_key_t[ kk.size() + 1 ]; + gpgme_key_t *keys_it = &keys[0]; + for (std::vector<Key>::const_iterator it = kk.begin(), end = kk.end() ; it != end ; ++it) { + if (it->impl()) { + *keys_it++ = it->impl(); + } + } + *keys_it++ = 0; + Error err = Error(d->lasterr = gpgme_op_import_keys_start(d->ctx, keys)); + delete[] keys; + return err; +} + +ImportResult Context::importResult() const +{ + if (d->lastop & Private::Import) { + return ImportResult(d->ctx, Error(d->lasterr)); + } else { + return ImportResult(); + } +} + +Error Context::deleteKey(const Key &key, bool allowSecretKeyDeletion) +{ + d->lastop = Private::Delete; + return Error(d->lasterr = gpgme_op_delete(d->ctx, key.impl(), int(allowSecretKeyDeletion))); +} + +Error Context::startKeyDeletion(const Key &key, bool allowSecretKeyDeletion) +{ + d->lastop = Private::Delete; + return Error(d->lasterr = gpgme_op_delete_start(d->ctx, key.impl(), int(allowSecretKeyDeletion))); +} + +Error Context::passwd(const Key &key) +{ + d->lastop = Private::Passwd; + return Error(d->lasterr = gpgme_op_passwd(d->ctx, key.impl(), 0U)); +} + +Error Context::startPasswd(const Key &key) +{ + d->lastop = Private::Passwd; + return Error(d->lasterr = gpgme_op_passwd_start(d->ctx, key.impl(), 0U)); +} + +Error Context::edit(const Key &key, std::auto_ptr<EditInteractor> func, Data &data) +{ + d->lastop = Private::Edit; + d->lastEditInteractor = func; + Data::Private *const dp = data.impl(); + return Error(d->lasterr = gpgme_op_edit(d->ctx, key.impl(), + d->lastEditInteractor.get() ? edit_interactor_callback : 0, + d->lastEditInteractor.get() ? d->lastEditInteractor->d : 0, + dp ? dp->data : 0)); +} + +Error Context::startEditing(const Key &key, std::auto_ptr<EditInteractor> func, Data &data) +{ + d->lastop = Private::Edit; + d->lastEditInteractor = func; + Data::Private *const dp = data.impl(); + return Error(d->lasterr = gpgme_op_edit_start(d->ctx, key.impl(), + d->lastEditInteractor.get() ? edit_interactor_callback : 0, + d->lastEditInteractor.get() ? d->lastEditInteractor->d : 0, + dp ? dp->data : 0)); +} + +EditInteractor *Context::lastEditInteractor() const +{ + return d->lastEditInteractor.get(); +} + +std::auto_ptr<EditInteractor> Context::takeLastEditInteractor() +{ + return d->lastEditInteractor; +} + +Error Context::cardEdit(const Key &key, std::auto_ptr<EditInteractor> func, Data &data) +{ + d->lastop = Private::CardEdit; + d->lastCardEditInteractor = func; + Data::Private *const dp = data.impl(); + return Error(d->lasterr = gpgme_op_card_edit(d->ctx, key.impl(), + d->lastCardEditInteractor.get() ? edit_interactor_callback : 0, + d->lastCardEditInteractor.get() ? d->lastCardEditInteractor->d : 0, + dp ? dp->data : 0)); +} + +Error Context::startCardEditing(const Key &key, std::auto_ptr<EditInteractor> func, Data &data) +{ + d->lastop = Private::CardEdit; + d->lastCardEditInteractor = func; + Data::Private *const dp = data.impl(); + return Error(d->lasterr = gpgme_op_card_edit_start(d->ctx, key.impl(), + d->lastCardEditInteractor.get() ? edit_interactor_callback : 0, + d->lastCardEditInteractor.get() ? d->lastCardEditInteractor->d : 0, + dp ? dp->data : 0)); +} + +EditInteractor *Context::lastCardEditInteractor() const +{ + return d->lastCardEditInteractor.get(); +} + +std::auto_ptr<EditInteractor> Context::takeLastCardEditInteractor() +{ + return d->lastCardEditInteractor; +} + +Error Context::startTrustItemListing(const char *pattern, int maxLevel) +{ + d->lastop = Private::TrustList; + return Error(d->lasterr = gpgme_op_trustlist_start(d->ctx, pattern, maxLevel)); +} + +TrustItem Context::nextTrustItem(Error &e) +{ + gpgme_trust_item_t ti = 0; + e = Error(d->lasterr = gpgme_op_trustlist_next(d->ctx, &ti)); + return TrustItem(ti); +} + +Error Context::endTrustItemListing() +{ + return Error(d->lasterr = gpgme_op_trustlist_end(d->ctx)); +} + +static gpgme_error_t assuan_transaction_data_callback(void *opaque, const void *data, size_t datalen) +{ + assert(opaque); + AssuanTransaction *t = static_cast<AssuanTransaction *>(opaque); + return t->data(static_cast<const char *>(data), datalen).encodedError(); +} + +static gpgme_error_t assuan_transaction_inquire_callback(void *opaque, const char *name, const char *args, gpgme_data_t *r_data) +{ + assert(opaque); + Context::Private *p = static_cast<Context::Private *>(opaque); + AssuanTransaction *t = p->lastAssuanTransaction.get(); + assert(t); + Error err; + if (name) { + p->lastAssuanInquireData = t->inquire(name, args, err); + } else { + p->lastAssuanInquireData = Data::null; + } + if (!p->lastAssuanInquireData.isNull()) { + *r_data = p->lastAssuanInquireData.impl()->data; + } + return err.encodedError(); +} + +static gpgme_error_t assuan_transaction_status_callback(void *opaque, const char *status, const char *args) +{ + assert(opaque); + AssuanTransaction *t = static_cast<AssuanTransaction *>(opaque); + std::string a = args; + percent_unescape(a, true); // ### why doesn't gpgme do this?? + return t->status(status, a.c_str()).encodedError(); +} + +AssuanResult Context::assuanTransact(const char *command) +{ + return assuanTransact(command, std::auto_ptr<AssuanTransaction>(new DefaultAssuanTransaction)); +} + +AssuanResult Context::assuanTransact(const char *command, std::auto_ptr<AssuanTransaction> transaction) +{ + d->lastop = Private::AssuanTransact; + d->lastAssuanTransaction = transaction; + if (!d->lastAssuanTransaction.get()) { + return AssuanResult(Error(d->lasterr = make_error(GPG_ERR_INV_ARG))); + } + d->lasterr = gpgme_op_assuan_transact(d->ctx, command, + assuan_transaction_data_callback, + d->lastAssuanTransaction.get(), + assuan_transaction_inquire_callback, + d, // sic! + assuan_transaction_status_callback, + d->lastAssuanTransaction.get()); + return AssuanResult(d->ctx, d->lasterr); +} + +Error Context::startAssuanTransaction(const char *command) +{ + return startAssuanTransaction(command, std::auto_ptr<AssuanTransaction>(new DefaultAssuanTransaction)); +} + +Error Context::startAssuanTransaction(const char *command, std::auto_ptr<AssuanTransaction> transaction) +{ + d->lastop = Private::AssuanTransact; + d->lastAssuanTransaction = transaction; + if (!d->lastAssuanTransaction.get()) { + return Error(d->lasterr = make_error(GPG_ERR_INV_ARG)); + } + return Error(d->lasterr = gpgme_op_assuan_transact_start(d->ctx, command, + assuan_transaction_data_callback, + d->lastAssuanTransaction.get(), + assuan_transaction_inquire_callback, + d, // sic! + assuan_transaction_status_callback, + d->lastAssuanTransaction.get())); +} + +AssuanResult Context::assuanResult() const +{ + if (d->lastop & Private::AssuanTransact) { + return AssuanResult(d->ctx, d->lasterr); + } else { + return AssuanResult(); + } +} + +AssuanTransaction *Context::lastAssuanTransaction() const +{ + return d->lastAssuanTransaction.get(); +} + +std::auto_ptr<AssuanTransaction> Context::takeLastAssuanTransaction() +{ + return d->lastAssuanTransaction; +} + +DecryptionResult Context::decrypt(const Data &cipherText, Data &plainText) +{ + d->lastop = Private::Decrypt; + const Data::Private *const cdp = cipherText.impl(); + Data::Private *const pdp = plainText.impl(); + d->lasterr = gpgme_op_decrypt(d->ctx, cdp ? cdp->data : 0, pdp ? pdp->data : 0); + return DecryptionResult(d->ctx, Error(d->lasterr)); +} + +Error Context::startDecryption(const Data &cipherText, Data &plainText) +{ + d->lastop = Private::Decrypt; + const Data::Private *const cdp = cipherText.impl(); + Data::Private *const pdp = plainText.impl(); + return Error(d->lasterr = gpgme_op_decrypt_start(d->ctx, cdp ? cdp->data : 0, pdp ? pdp->data : 0)); +} + +DecryptionResult Context::decryptionResult() const +{ + if (d->lastop & Private::Decrypt) { + return DecryptionResult(d->ctx, Error(d->lasterr)); + } else { + return DecryptionResult(); + } +} + +VerificationResult Context::verifyDetachedSignature(const Data &signature, const Data &signedText) +{ + d->lastop = Private::Verify; + const Data::Private *const sdp = signature.impl(); + const Data::Private *const tdp = signedText.impl(); + d->lasterr = gpgme_op_verify(d->ctx, sdp ? sdp->data : 0, tdp ? tdp->data : 0, 0); + return VerificationResult(d->ctx, Error(d->lasterr)); +} + +VerificationResult Context::verifyOpaqueSignature(const Data &signedData, Data &plainText) +{ + d->lastop = Private::Verify; + const Data::Private *const sdp = signedData.impl(); + Data::Private *const pdp = plainText.impl(); + d->lasterr = gpgme_op_verify(d->ctx, sdp ? sdp->data : 0, 0, pdp ? pdp->data : 0); + return VerificationResult(d->ctx, Error(d->lasterr)); +} + +Error Context::startDetachedSignatureVerification(const Data &signature, const Data &signedText) +{ + d->lastop = Private::Verify; + const Data::Private *const sdp = signature.impl(); + const Data::Private *const tdp = signedText.impl(); + return Error(d->lasterr = gpgme_op_verify_start(d->ctx, sdp ? sdp->data : 0, tdp ? tdp->data : 0, 0)); +} + +Error Context::startOpaqueSignatureVerification(const Data &signedData, Data &plainText) +{ + d->lastop = Private::Verify; + const Data::Private *const sdp = signedData.impl(); + Data::Private *const pdp = plainText.impl(); + return Error(d->lasterr = gpgme_op_verify_start(d->ctx, sdp ? sdp->data : 0, 0, pdp ? pdp->data : 0)); +} + +VerificationResult Context::verificationResult() const +{ + if (d->lastop & Private::Verify) { + return VerificationResult(d->ctx, Error(d->lasterr)); + } else { + return VerificationResult(); + } +} + +std::pair<DecryptionResult, VerificationResult> Context::decryptAndVerify(const Data &cipherText, Data &plainText) +{ + d->lastop = Private::DecryptAndVerify; + const Data::Private *const cdp = cipherText.impl(); + Data::Private *const pdp = plainText.impl(); + d->lasterr = gpgme_op_decrypt_verify(d->ctx, cdp ? cdp->data : 0, pdp ? pdp->data : 0); + return std::make_pair(DecryptionResult(d->ctx, Error(d->lasterr)), + VerificationResult(d->ctx, Error(d->lasterr))); +} + +Error Context::startCombinedDecryptionAndVerification(const Data &cipherText, Data &plainText) +{ + d->lastop = Private::DecryptAndVerify; + const Data::Private *const cdp = cipherText.impl(); + Data::Private *const pdp = plainText.impl(); + return Error(d->lasterr = gpgme_op_decrypt_verify_start(d->ctx, cdp ? cdp->data : 0, pdp ? pdp->data : 0)); +} + +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; +} + +Error Context::startGetAuditLog(Data &output, unsigned int flags) +{ + d->lastop = Private::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))); +} + +Error Context::getAuditLog(Data &output, unsigned int flags) +{ + d->lastop = Private::GetAuditLog; + Data::Private *const odp = output.impl(); + return Error(d->lasterr = gpgme_op_getauditlog(d->ctx, odp ? odp->data : 0, to_auditlog_flags(flags))); +} + +void Context::clearSigningKeys() +{ + gpgme_signers_clear(d->ctx); +} + +Error Context::addSigningKey(const Key &key) +{ + return Error(d->lasterr = gpgme_signers_add(d->ctx, key.impl())); +} + +Key Context::signingKey(unsigned int idx) const +{ + gpgme_key_t key = gpgme_signers_enum(d->ctx, idx); + return Key(key, false); +} + +std::vector<Key> Context::signingKeys() const +{ + std::vector<Key> result; + gpgme_key_t key; + for (unsigned int i = 0 ; (key = gpgme_signers_enum(d->ctx, i)) ; ++i) { + result.push_back(Key(key, false)); + } + return result; +} + +void Context::clearSignatureNotations() +{ + gpgme_sig_notation_clear(d->ctx); +} + +GpgME::Error Context::addSignatureNotation(const char *name, const char *value, unsigned int flags) +{ + return Error(gpgme_sig_notation_add(d->ctx, name, value, add_to_gpgme_sig_notation_flags_t(0, flags))); +} + +GpgME::Error Context::addSignaturePolicyURL(const char *url, bool critical) +{ + return Error(gpgme_sig_notation_add(d->ctx, 0, url, critical ? GPGME_SIG_NOTATION_CRITICAL : 0)); +} + +const char *Context::signaturePolicyURL() const +{ + for (gpgme_sig_notation_t n = gpgme_sig_notation_get(d->ctx) ; n ; n = n->next) { + if (!n->name) { + return n->value; + } + } +} + +Notation Context::signatureNotation(unsigned int idx) const +{ + for (gpgme_sig_notation_t n = gpgme_sig_notation_get(d->ctx) ; n ; n = n->next) { + if (n->name) { + if (idx-- == 0) { + return Notation(n); + } + } + } + return Notation(); +} + +std::vector<Notation> Context::signatureNotations() const +{ + std::vector<Notation> result; + for (gpgme_sig_notation_t n = gpgme_sig_notation_get(d->ctx) ; n ; n = n->next) { + if (n->name) { + result.push_back(Notation(n)); + } + } + return result; +} + +static gpgme_sig_mode_t sigmode2sigmode(SignatureMode mode) +{ + switch (mode) { + default: + case NormalSignatureMode: return GPGME_SIG_MODE_NORMAL; + case Detached: return GPGME_SIG_MODE_DETACH; + case Clearsigned: return GPGME_SIG_MODE_CLEAR; + } +} + +SigningResult Context::sign(const Data &plainText, Data &signature, SignatureMode mode) +{ + d->lastop = Private::Sign; + const Data::Private *const pdp = plainText.impl(); + Data::Private *const sdp = signature.impl(); + d->lasterr = gpgme_op_sign(d->ctx, pdp ? pdp->data : 0, sdp ? sdp->data : 0, sigmode2sigmode(mode)); + return SigningResult(d->ctx, Error(d->lasterr)); +} + +Error Context::startSigning(const Data &plainText, Data &signature, SignatureMode mode) +{ + d->lastop = Private::Sign; + const Data::Private *const pdp = plainText.impl(); + Data::Private *const sdp = signature.impl(); + return Error(d->lasterr = gpgme_op_sign_start(d->ctx, pdp ? pdp->data : 0, sdp ? sdp->data : 0, sigmode2sigmode(mode))); +} + +SigningResult Context::signingResult() const +{ + if (d->lastop & Private::Sign) { + return SigningResult(d->ctx, Error(d->lasterr)); + } else { + return SigningResult(); + } +} + +static gpgme_encrypt_flags_t encryptflags2encryptflags(Context::EncryptionFlags flags) +{ + unsigned int result = 0; + if (flags & Context::AlwaysTrust) { + result |= GPGME_ENCRYPT_ALWAYS_TRUST; + } + if (flags & Context::NoEncryptTo) { + result |= GPGME_ENCRYPT_NO_ENCRYPT_TO; + } + return static_cast<gpgme_encrypt_flags_t>(result); +} + +EncryptionResult Context::encrypt(const std::vector<Key> &recipients, const Data &plainText, Data &cipherText, EncryptionFlags flags) +{ + d->lastop = Private::Encrypt; + if (flags & NoEncryptTo) { + return EncryptionResult(Error(d->lasterr = make_error(GPG_ERR_NOT_IMPLEMENTED))); + } + const Data::Private *const pdp = plainText.impl(); + Data::Private *const cdp = cipherText.impl(); + gpgme_key_t *const keys = new gpgme_key_t[ recipients.size() + 1 ]; + gpgme_key_t *keys_it = keys; + for (std::vector<Key>::const_iterator it = recipients.begin() ; it != recipients.end() ; ++it) { + if (it->impl()) { + *keys_it++ = it->impl(); + } + } + *keys_it++ = 0; + d->lasterr = gpgme_op_encrypt(d->ctx, keys, encryptflags2encryptflags(flags), + pdp ? pdp->data : 0, cdp ? cdp->data : 0); + delete[] keys; + return EncryptionResult(d->ctx, Error(d->lasterr)); +} + +Error Context::encryptSymmetrically(const Data &plainText, Data &cipherText) +{ + d->lastop = Private::Encrypt; + const Data::Private *const pdp = plainText.impl(); + Data::Private *const cdp = cipherText.impl(); + return Error(d->lasterr = gpgme_op_encrypt(d->ctx, 0, (gpgme_encrypt_flags_t)0, + pdp ? pdp->data : 0, cdp ? cdp->data : 0)); +} + +Error Context::startEncryption(const std::vector<Key> &recipients, const Data &plainText, Data &cipherText, EncryptionFlags flags) +{ + d->lastop = Private::Encrypt; + if (flags & NoEncryptTo) { + return Error(d->lasterr = make_error(GPG_ERR_NOT_IMPLEMENTED)); + } + const Data::Private *const pdp = plainText.impl(); + Data::Private *const cdp = cipherText.impl(); + gpgme_key_t *const keys = new gpgme_key_t[ recipients.size() + 1 ]; + gpgme_key_t *keys_it = keys; + for (std::vector<Key>::const_iterator it = recipients.begin() ; it != recipients.end() ; ++it) { + if (it->impl()) { + *keys_it++ = it->impl(); + } + } + *keys_it++ = 0; + d->lasterr = gpgme_op_encrypt_start(d->ctx, keys, encryptflags2encryptflags(flags), + pdp ? pdp->data : 0, cdp ? cdp->data : 0); + delete[] keys; + return Error(d->lasterr); +} + +EncryptionResult Context::encryptionResult() const +{ + if (d->lastop & Private::Encrypt) { + return EncryptionResult(d->ctx, Error(d->lasterr)); + } else { + return EncryptionResult(); + } +} + +std::pair<SigningResult, EncryptionResult> Context::signAndEncrypt(const std::vector<Key> &recipients, const Data &plainText, Data &cipherText, EncryptionFlags flags) +{ + d->lastop = Private::SignAndEncrypt; + const Data::Private *const pdp = plainText.impl(); + Data::Private *const cdp = cipherText.impl(); + gpgme_key_t *const keys = new gpgme_key_t[ recipients.size() + 1 ]; + gpgme_key_t *keys_it = keys; + for (std::vector<Key>::const_iterator it = recipients.begin() ; it != recipients.end() ; ++it) { + if (it->impl()) { + *keys_it++ = it->impl(); + } + } + *keys_it++ = 0; + d->lasterr = gpgme_op_encrypt_sign(d->ctx, keys, encryptflags2encryptflags(flags), + pdp ? pdp->data : 0, cdp ? cdp->data : 0); + delete[] keys; + return std::make_pair(SigningResult(d->ctx, Error(d->lasterr)), + EncryptionResult(d->ctx, Error(d->lasterr))); +} + +Error Context::startCombinedSigningAndEncryption(const std::vector<Key> &recipients, const Data &plainText, Data &cipherText, EncryptionFlags flags) +{ + d->lastop = Private::SignAndEncrypt; + const Data::Private *const pdp = plainText.impl(); + Data::Private *const cdp = cipherText.impl(); + gpgme_key_t *const keys = new gpgme_key_t[ recipients.size() + 1 ]; + gpgme_key_t *keys_it = keys; + for (std::vector<Key>::const_iterator it = recipients.begin() ; it != recipients.end() ; ++it) { + if (it->impl()) { + *keys_it++ = it->impl(); + } + } + *keys_it++ = 0; + d->lasterr = gpgme_op_encrypt_sign_start(d->ctx, keys, encryptflags2encryptflags(flags), + pdp ? pdp->data : 0, cdp ? cdp->data : 0); + delete[] keys; + return Error(d->lasterr); +} + +Error Context::createVFS(const char *containerFile, const std::vector< Key > &recipients) +{ + d->lastop = Private::CreateVFS; + gpgme_key_t *const keys = new gpgme_key_t[ recipients.size() + 1 ]; + gpgme_key_t *keys_it = keys; + for (std::vector<Key>::const_iterator it = recipients.begin() ; it != recipients.end() ; ++it) { + if (it->impl()) { + *keys_it++ = it->impl(); + } + } + *keys_it++ = 0; + + gpgme_error_t op_err; + d->lasterr = gpgme_op_vfs_create(d->ctx, keys, containerFile, 0, &op_err); + delete[] keys; + Error error(d->lasterr); + if (error) { + return error; + } + return Error(d->lasterr = op_err); +} + +VfsMountResult Context::mountVFS(const char *containerFile, const char *mountDir) +{ + d->lastop = Private::MountVFS; + gpgme_error_t op_err; + d->lasterr = gpgme_op_vfs_mount(d->ctx, containerFile, mountDir, 0, &op_err); + return VfsMountResult(d->ctx, Error(d->lasterr), Error(op_err)); +} + +Error Context::cancelPendingOperation() +{ + return Error(gpgme_cancel_async(d->ctx)); +} + +bool Context::poll() +{ + gpgme_error_t e = GPG_ERR_NO_ERROR; + const bool finished = gpgme_wait(d->ctx, &e, 0); + if (finished) { + d->lasterr = e; + } + return finished; +} + +Error Context::wait() +{ + gpgme_error_t e = GPG_ERR_NO_ERROR; + gpgme_wait(d->ctx, &e, 1); + return Error(d->lasterr = e); +} + +Error Context::lastError() const +{ + return Error(d->lasterr); +} + +std::ostream &operator<<(std::ostream &os, Protocol proto) +{ + os << "GpgME::Protocol("; + switch (proto) { + case OpenPGP: + os << "OpenPGP"; + break; + case CMS: + os << "CMS"; + break; + default: + case UnknownProtocol: + os << "UnknownProtocol"; + break; + } + return os << ')'; +} + +std::ostream &operator<<(std::ostream &os, Engine eng) +{ + os << "GpgME::Engine("; + switch (eng) { + case GpgEngine: + os << "GpgEngine"; + break; + case GpgSMEngine: + os << "GpgSMEngine"; + break; + case GpgConfEngine: + os << "GpgConfEngine"; + break; + case AssuanEngine: + os << "AssuanEngine"; + break; + default: + case UnknownEngine: + os << "UnknownEngine"; + break; + } + return os << ')'; +} + +std::ostream &operator<<(std::ostream &os, Context::CertificateInclusion incl) +{ + os << "GpgME::Context::CertificateInclusion(" << static_cast<int>(incl); + switch (incl) { + case Context::DefaultCertificates: + os << "(DefaultCertificates)"; + break; + case Context::AllCertificatesExceptRoot: + os << "(AllCertificatesExceptRoot)"; + break; + case Context::AllCertificates: + os << "(AllCertificates)"; + break; + case Context::NoCertificates: + os << "(NoCertificates)"; + break; + case Context::OnlySenderCertificate: + os << "(OnlySenderCertificate)"; + break; + } + return os << ')'; +} + +std::ostream &operator<<(std::ostream &os, KeyListMode mode) +{ + os << "GpgME::KeyListMode("; +#define CHECK( x ) if ( !(mode & (x)) ) {} else do { os << #x " "; } while (0) + CHECK(Local); + CHECK(Extern); + CHECK(Signatures); + CHECK(Validate); + CHECK(Ephemeral); +#undef CHECK + return os << ')'; +} + +std::ostream &operator<<(std::ostream &os, SignatureMode mode) +{ + os << "GpgME::SignatureMode("; + switch (mode) { +#define CHECK( x ) case x: os << #x; break + CHECK(NormalSignatureMode); + CHECK(Detached); + CHECK(Clearsigned); +#undef CHECK + default: + os << "???" "(" << static_cast<int>(mode) << ')'; + break; + } + return os << ')'; +} + +std::ostream &operator<<(std::ostream &os, Context::EncryptionFlags flags) +{ + os << "GpgME::Context::EncryptionFlags("; +#define CHECK( x ) if ( !(flags & (Context::x)) ) {} else do { os << #x " "; } while (0) + CHECK(AlwaysTrust); +#undef CHECK + return os << ')'; +} + +std::ostream &operator<<(std::ostream &os, Context::AuditLogFlags flags) +{ + os << "GpgME::Context::AuditLogFlags("; +#define CHECK( x ) if ( !(flags & (Context::x)) ) {} else do { os << #x " "; } while (0) + CHECK(HtmlAuditLog); + CHECK(AuditLogWithHelp); +#undef CHECK + return os << ')'; +} + +} // namespace GpgME + +GpgME::Error GpgME::setDefaultLocale(int cat, const char *val) +{ + return Error(gpgme_set_locale(0, cat, val)); +} + +GpgME::EngineInfo GpgME::engineInfo(GpgME::Protocol proto) +{ + gpgme_engine_info_t ei = 0; + if (gpgme_get_engine_info(&ei)) { + return EngineInfo(); + } + + const gpgme_protocol_t p = proto == CMS ? GPGME_PROTOCOL_CMS : GPGME_PROTOCOL_OpenPGP ; + + for (gpgme_engine_info_t i = ei ; i ; i = i->next) { + if (i->protocol == p) { + return EngineInfo(i); + } + } + + return EngineInfo(); +} + +GpgME::Error GpgME::checkEngine(GpgME::Protocol proto) +{ + const gpgme_protocol_t p = proto == CMS ? GPGME_PROTOCOL_CMS : GPGME_PROTOCOL_OpenPGP ; + + return Error(gpgme_engine_check_version(p)); +} + +static const gpgme_protocol_t UNKNOWN_PROTOCOL = static_cast<gpgme_protocol_t>(255); + +static gpgme_protocol_t engine2protocol(const GpgME::Engine engine) +{ + switch (engine) { + case GpgME::GpgEngine: return GPGME_PROTOCOL_OpenPGP; + case GpgME::GpgSMEngine: return GPGME_PROTOCOL_CMS; + case GpgME::GpgConfEngine: + return GPGME_PROTOCOL_GPGCONF; + case GpgME::AssuanEngine: + return GPGME_PROTOCOL_ASSUAN; + case GpgME::G13Engine: + return GPGME_PROTOCOL_G13; + case GpgME::UnknownEngine: + ; + } + return UNKNOWN_PROTOCOL; +} + +GpgME::EngineInfo GpgME::engineInfo(GpgME::Engine engine) +{ + gpgme_engine_info_t ei = 0; + if (gpgme_get_engine_info(&ei)) { + return EngineInfo(); + } + + const gpgme_protocol_t p = engine2protocol(engine); + + for (gpgme_engine_info_t i = ei ; i ; i = i->next) { + if (i->protocol == p) { + return EngineInfo(i); + } + } + + return EngineInfo(); +} + +GpgME::Error GpgME::checkEngine(GpgME::Engine engine) +{ + const gpgme_protocol_t p = engine2protocol(engine); + + return Error(gpgme_engine_check_version(p)); +} + +static const unsigned long supported_features = 0 + | GpgME::ValidatingKeylistModeFeature + | GpgME::CancelOperationFeature + | GpgME::WrongKeyUsageFeature + | GpgME::DefaultCertificateInclusionFeature + | GpgME::GetSetEngineInfoFeature + | GpgME::ClearAddGetSignatureNotationsFeature + | GpgME::SetDataFileNameFeeature + | GpgME::SignatureNotationsKeylistModeFeature + | GpgME::KeySignatureNotationsFeature + | GpgME::KeyIsQualifiedFeature + | GpgME::SignatureNotationsCriticalFlagFeature + | GpgME::SignatureNotationsFlagsFeature + | GpgME::SignatureNotationsHumanReadableFlagFeature + | GpgME::SubkeyIsQualifiedFeature + | GpgME::EngineInfoHomeDirFeature + | GpgME::DecryptionResultFileNameFeature + | GpgME::DecryptionResultRecipientsFeature + | GpgME::VerificationResultFileNameFeature + | GpgME::SignaturePkaFieldsFeature + | GpgME::SignatureAlgorithmFieldsFeature + | GpgME::FdPointerFeature + | GpgME::AuditLogFeature + | GpgME::GpgConfEngineFeature + | GpgME::CancelOperationAsyncFeature + | GpgME::NoEncryptToEncryptionFlagFeature + | GpgME::CardKeyFeature + | GpgME::AssuanEngineFeature + | GpgME::EphemeralKeylistModeFeature + | GpgME::ImportFromKeyserverFeature + | GpgME::G13VFSFeature + | GpgME::PasswdFeature + ; + +static const unsigned long supported_features2 = 0 + ; + +bool GpgME::hasFeature(unsigned long features) +{ + return features == (features & supported_features); +} + +bool GpgME::hasFeature(unsigned long features, unsigned long features2) +{ + return features == (features & supported_features) + && features2 == (features2 & supported_features2) + ; +} diff --git a/lang/cpp/src/context.h b/lang/cpp/src/context.h new file mode 100644 index 00000000..ee4f847e --- /dev/null +++ b/lang/cpp/src/context.h @@ -0,0 +1,353 @@ +/* + context.h - wraps a gpgme key context + Copyright (C) 2003, 2007 Klarälvdalens Datakonsult AB + + This file is part of GPGME++. + + GPGME++ is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + GPGME++ is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Library General Public License for more details. + + You should have received a copy of the GNU Library General Public License + along with GPGME++; see the file COPYING.LIB. If not, write to the + Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. +*/ + +// -*- c++ -*- +#ifndef __GPGMEPP_CONTEXT_H__ +#define __GPGMEPP_CONTEXT_H__ + +#include "global.h" + +#include "error.h" +#include "verificationresult.h" // for Signature::Notation + +#include <memory> +#include <vector> +#include <utility> +#include <iosfwd> + +namespace GpgME +{ + +class Key; +class Data; +class TrustItem; +class ProgressProvider; +class PassphraseProvider; +class EventLoopInteractor; +class EditInteractor; +class AssuanTransaction; + +class AssuanResult; +class KeyListResult; +class KeyGenerationResult; +class ImportResult; +class DecryptionResult; +class VerificationResult; +class SigningResult; +class EncryptionResult; +class VfsMountResult; + +class EngineInfo; + +class GPGMEPP_EXPORT Context +{ + explicit Context(gpgme_ctx_t); +public: + //using GpgME::Protocol; + + // + // Creation and destruction: + // + + static Context *createForProtocol(Protocol proto); + static std::auto_ptr<Context> createForEngine(Engine engine, Error *err = 0); + virtual ~Context(); + + // + // Context Attributes + // + + Protocol protocol() const; + + void setArmor(bool useArmor); + bool armor() const; + + void setTextMode(bool useTextMode); + bool textMode() const; + + void setOffline(bool useOfflineMode); + bool offline() const; + + enum CertificateInclusion { + DefaultCertificates = -256, + AllCertificatesExceptRoot = -2, + AllCertificates = -1, + NoCertificates = 0, + OnlySenderCertificate = 1 + }; + void setIncludeCertificates(int which); + int includeCertificates() const; + + //using GpgME::KeyListMode; + void setKeyListMode(unsigned int keyListMode); + void addKeyListMode(unsigned int keyListMode); + unsigned int keyListMode() const; + + void setPassphraseProvider(PassphraseProvider *provider); + PassphraseProvider *passphraseProvider() const; + + void setProgressProvider(ProgressProvider *provider); + ProgressProvider *progressProvider() const; + + void setManagedByEventLoopInteractor(bool managed); + bool managedByEventLoopInteractor() const; + + GpgME::Error setLocale(int category, const char *value); + + EngineInfo engineInfo() const; + GpgME::Error setEngineFileName(const char *filename); + GpgME::Error setEngineHomeDirectory(const char *filename); + +private: + friend class ::GpgME::EventLoopInteractor; + void installIOCallbacks(gpgme_io_cbs *iocbs); + void uninstallIOCallbacks(); + +public: + // + // + // Key Management + // + // + + // + // Key Listing + // + + GpgME::Error startKeyListing(const char *pattern = 0, bool secretOnly = false); + GpgME::Error startKeyListing(const char *patterns[], bool secretOnly = false); + + Key nextKey(GpgME::Error &e); + + KeyListResult endKeyListing(); + KeyListResult keyListResult() const; + + Key key(const char *fingerprint, GpgME::Error &e, bool secret = false); + + // + // Key Generation + // + + KeyGenerationResult generateKey(const char *parameters, Data &pubKey); + GpgME::Error startKeyGeneration(const char *parameters, Data &pubkey); + KeyGenerationResult keyGenerationResult() const; + + // + // Key Export + // + + GpgME::Error exportPublicKeys(const char *pattern, Data &keyData); + GpgME::Error exportPublicKeys(const char *pattern[], Data &keyData); + GpgME::Error startPublicKeyExport(const char *pattern, Data &keyData); + GpgME::Error startPublicKeyExport(const char *pattern[], Data &keyData); + + // + // Key Import + // + + ImportResult importKeys(const Data &data); + ImportResult importKeys(const std::vector<Key> &keys); + GpgME::Error startKeyImport(const Data &data); + GpgME::Error startKeyImport(const std::vector<Key> &keys); + ImportResult importResult() const; + + // + // Key Deletion + // + + GpgME::Error deleteKey(const Key &key, bool allowSecretKeyDeletion = false); + GpgME::Error startKeyDeletion(const Key &key, bool allowSecretKeyDeletion = false); + + // + // Passphrase changing + // + + GpgME::Error passwd(const Key &key); + GpgME::Error startPasswd(const Key &key); + + // + // Key Editing + // + + GpgME::Error edit(const Key &key, std::auto_ptr<EditInteractor> function, Data &out); + GpgME::Error startEditing(const Key &key, std::auto_ptr<EditInteractor> function, Data &out); + + EditInteractor *lastEditInteractor() const; + std::auto_ptr<EditInteractor> takeLastEditInteractor(); + + // + // SmartCard Editing + // + + GpgME::Error cardEdit(const Key &key, std::auto_ptr<EditInteractor> function, Data &out); + GpgME::Error startCardEditing(const Key &key, std::auto_ptr<EditInteractor> function, Data &out); + + EditInteractor *lastCardEditInteractor() const; + std::auto_ptr<EditInteractor> takeLastCardEditInteractor(); + + // + // Trust Item Management + // + + GpgME::Error startTrustItemListing(const char *pattern, int maxLevel); + TrustItem nextTrustItem(GpgME::Error &e); + GpgME::Error endTrustItemListing(); + + // + // Assuan Transactions + // + + AssuanResult assuanTransact(const char *command, std::auto_ptr<AssuanTransaction> transaction); + AssuanResult assuanTransact(const char *command); + GpgME::Error startAssuanTransaction(const char *command, std::auto_ptr<AssuanTransaction> transaction); + GpgME::Error startAssuanTransaction(const char *command); + AssuanResult assuanResult() const; + + AssuanTransaction *lastAssuanTransaction() const; + std::auto_ptr<AssuanTransaction> takeLastAssuanTransaction(); + + // + // + // Crypto Operations + // + // + + // + // Decryption + // + + DecryptionResult decrypt(const Data &cipherText, Data &plainText); + GpgME::Error startDecryption(const Data &cipherText, Data &plainText); + DecryptionResult decryptionResult() const; + + // + // Signature Verification + // + + VerificationResult verifyDetachedSignature(const Data &signature, const Data &signedText); + VerificationResult verifyOpaqueSignature(const Data &signedData, Data &plainText); + GpgME::Error startDetachedSignatureVerification(const Data &signature, const Data &signedText); + GpgME::Error startOpaqueSignatureVerification(const Data &signedData, Data &plainText); + VerificationResult verificationResult() const; + + // + // Combined Decryption and Signature Verification + // + + std::pair<DecryptionResult, VerificationResult> decryptAndVerify(const Data &cipherText, Data &plainText); + GpgME::Error startCombinedDecryptionAndVerification(const Data &cipherText, Data &plainText); + // use verificationResult() and decryptionResult() to retrieve the result objects... + + // + // Signing + // + + void clearSigningKeys(); + GpgME::Error addSigningKey(const Key &signer); + Key signingKey(unsigned int index) const; + std::vector<Key> signingKeys() const; + + void clearSignatureNotations(); + GpgME::Error addSignatureNotation(const char *name, const char *value, unsigned int flags = 0); + GpgME::Error addSignaturePolicyURL(const char *url, bool critical = false); + const char *signaturePolicyURL() const; + Notation signatureNotation(unsigned int index) const; + std::vector<Notation> signatureNotations() const; + + //using GpgME::SignatureMode; + SigningResult sign(const Data &plainText, Data &signature, SignatureMode mode); + GpgME::Error startSigning(const Data &plainText, Data &signature, SignatureMode mode); + SigningResult signingResult() const; + + // + // Encryption + // + + enum EncryptionFlags { None = 0, AlwaysTrust = 1, NoEncryptTo = 2 }; + EncryptionResult encrypt(const std::vector<Key> &recipients, const Data &plainText, Data &cipherText, EncryptionFlags flags); + GpgME::Error encryptSymmetrically(const Data &plainText, Data &cipherText); + GpgME::Error startEncryption(const std::vector<Key> &recipients, const Data &plainText, Data &cipherText, EncryptionFlags flags); + EncryptionResult encryptionResult() const; + + // + // Combined Signing and Encryption + // + + std::pair<SigningResult, EncryptionResult> signAndEncrypt(const std::vector<Key> &recipients, const Data &plainText, Data &cipherText, EncryptionFlags flags); + GpgME::Error startCombinedSigningAndEncryption(const std::vector<Key> &recipients, const Data &plainText, Data &cipherText, EncryptionFlags flags); + // use encryptionResult() and signingResult() to retrieve the result objects... + + // + // + // Audit Log + // + // + enum AuditLogFlags { + HtmlAuditLog = 1, + AuditLogWithHelp = 128 + }; + GpgME::Error startGetAuditLog(Data &output, unsigned int flags = 0); + GpgME::Error getAuditLog(Data &output, unsigned int flags = 0); + + // + // + // G13 crypto container operations + // + // + GpgME::Error createVFS(const char *containerFile, const std::vector<Key> &recipients); + VfsMountResult mountVFS(const char *containerFile, const char *mountDir); + + // + // + // Run Control + // + // + + bool poll(); + GpgME::Error wait(); + GpgME::Error lastError() const; + GpgME::Error cancelPendingOperation(); + + class Private; + const Private *impl() const + { + return d; + } + Private *impl() + { + return d; + } +private: + Private *const d; + +private: // disable... + Context(const Context &); + const Context &operator=(const Context &); +}; + +GPGMEPP_EXPORT std::ostream &operator<<(std::ostream &os, Context::CertificateInclusion incl); +GPGMEPP_EXPORT std::ostream &operator<<(std::ostream &os, Context::EncryptionFlags flags); +GPGMEPP_EXPORT std::ostream &operator<<(std::ostream &os, Context::AuditLogFlags flags); + +} // namespace GpgME + +#endif // __GPGMEPP_CONTEXT_H__ diff --git a/lang/cpp/src/context_glib.cpp b/lang/cpp/src/context_glib.cpp new file mode 100644 index 00000000..d9889185 --- /dev/null +++ b/lang/cpp/src/context_glib.cpp @@ -0,0 +1,35 @@ +/* + context_glib.cpp - wraps a gpgme key context, gpgme-glib-specific functions + Copyright (C) 2007 Klarälvdalens Datakonsult AB + + This file is part of GPGME++. + + GPGME++ is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + GPGME++ is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Library General Public License for more details. + + You should have received a copy of the GNU Library General Public License + along with GPGME++; see the file COPYING.LIB. If not, write to the + Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. +*/ + +#include <global.h> + +extern "C" GIOChannel *gpgme_get_fdptr(int); + +GIOChannel *GpgME::getGIOChannel(int fd) +{ + return gpgme_get_fdptr(fd); +} + +QIODevice *GpgME::getQIODevice(int fd) +{ + return 0; +} diff --git a/lang/cpp/src/context_p.h b/lang/cpp/src/context_p.h new file mode 100644 index 00000000..2991123a --- /dev/null +++ b/lang/cpp/src/context_p.h @@ -0,0 +1,84 @@ +/* + context_p.h - wraps a gpgme context (private part) + Copyright (C) 2003, 2007 Klarälvdalens Datakonsult AB + + This file is part of GPGME++. + + GPGME++ is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + GPGME++ is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Library General Public License for more details. + + You should have received a copy of the GNU Library General Public License + along with GPGME++; see the file COPYING.LIB. If not, write to the + Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. +*/ + +// -*- c++ -*- +#ifndef __GPGMEPP_CONTEXT_P_H__ +#define __GPGMEPP_CONTEXT_P_H__ + +#include <context.h> +#include <data.h> + +#include <gpgme.h> + +namespace GpgME +{ + +class Context::Private +{ +public: + 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, // no gpgme_trustlist_result_t, but nevertheless... + + Edit = 0x400, // no gpgme_edit_result_t, but nevertheless... + CardEdit = 0x800, // no gpgme_card_edit_result_t, but nevertheless... + + GetAuditLog = 0x1000, // no gpgme_getauditlog_result_t, but nevertheless... + + AssuanTransact = 0x2000, + Passwd = 0x4000, // no gpgme_passwd_result_t, but nevertheless... + + CreateVFS = 0x4000, + MountVFS = 0x8000, + + EndMarker + }; + + Private(gpgme_ctx_t c = 0); + ~Private(); + + gpgme_ctx_t ctx; + gpgme_io_cbs *iocbs; + Operation lastop; + gpgme_error_t lasterr; + Data lastAssuanInquireData; + std::auto_ptr<AssuanTransaction> lastAssuanTransaction; + std::auto_ptr<EditInteractor> lastEditInteractor, lastCardEditInteractor; +}; + +} // namespace GpgME + +#endif // __GPGMEPP_CONTEXT_P_H__ diff --git a/lang/cpp/src/context_qt.cpp b/lang/cpp/src/context_qt.cpp new file mode 100644 index 00000000..2ce0005d --- /dev/null +++ b/lang/cpp/src/context_qt.cpp @@ -0,0 +1,35 @@ +/* + context_qt.cpp - wraps a gpgme key context, gpgme-qt-specific functions + Copyright (C) 2007 Klarälvdalens Datakonsult AB + + This file is part of GPGME++. + + GPGME++ is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + GPGME++ is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Library General Public License for more details. + + You should have received a copy of the GNU Library General Public License + along with GPGME++; see the file COPYING.LIB. If not, write to the + Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. +*/ + +#include <global.h> + +extern "C" QIODevice *gpgme_get_fdptr(int); + +GIOChannel *GpgME::getGIOChannel(int) +{ + return 0; +} + +QIODevice *GpgME::getQIODevice(int fd) +{ + return gpgme_get_fdptr(fd); +} diff --git a/lang/cpp/src/context_vanilla.cpp b/lang/cpp/src/context_vanilla.cpp new file mode 100644 index 00000000..984d41be --- /dev/null +++ b/lang/cpp/src/context_vanilla.cpp @@ -0,0 +1,33 @@ +/* + context_vanilla.cpp - wraps a gpgme key context, gpgme (vanilla)-specific functions + Copyright (C) 2007 Klarälvdalens Datakonsult AB + + This file is part of GPGME++. + + GPGME++ is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + GPGME++ is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Library General Public License for more details. + + You should have received a copy of the GNU Library General Public License + along with GPGME++; see the file COPYING.LIB. If not, write to the + Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. +*/ + +#include <global.h> + +GIOChannel *GpgME::getGIOChannel(int) +{ + return 0; +} + +QIODevice *GpgME::getQIODevice(int) +{ + return 0; +} diff --git a/lang/cpp/src/data.cpp b/lang/cpp/src/data.cpp new file mode 100644 index 00000000..bf9a629f --- /dev/null +++ b/lang/cpp/src/data.cpp @@ -0,0 +1,208 @@ +/* + data.cpp - wraps a gpgme data object + Copyright (C) 2003 Klarälvdalens Datakonsult AB + + This file is part of GPGME++. + + GPGME++ is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + GPGME++ is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Library General Public License for more details. + + You should have received a copy of the GNU Library General Public License + along with GPGME++; see the file COPYING.LIB. If not, write to the + Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. +*/ + +#include "data_p.h" +#include <error.h> +#include <interfaces/dataprovider.h> + +#include <gpgme.h> + +#ifndef NDEBUG +#include <iostream> +#endif + +GpgME::Data::Private::~Private() +{ + if (data) { + gpgme_data_release(data); + } +} + +const GpgME::Data::Null GpgME::Data::null; + +GpgME::Data::Data() +{ + gpgme_data_t data; + const gpgme_error_t e = gpgme_data_new(&data); + d.reset(new Private(e ? 0 : data)); +} + +GpgME::Data::Data(const Null &) + : d(new Private(0)) +{ + +} + +GpgME::Data::Data(gpgme_data_t data) + : d(new Private(data)) +{ + +} + +GpgME::Data::Data(const char *buffer, size_t size, bool copy) +{ + gpgme_data_t data; + const gpgme_error_t e = gpgme_data_new_from_mem(&data, buffer, size, int(copy)); + d.reset(new Private(e ? 0 : data)); +} + +GpgME::Data::Data(const char *filename) +{ + gpgme_data_t data; + const gpgme_error_t e = gpgme_data_new(&data); + d.reset(new Private(e ? 0 : data)); + if (!e) { + setFileName(filename); + } +} + +GpgME::Data::Data(const char *filename, off_t offset, size_t length) +{ + gpgme_data_t data; + const gpgme_error_t e = gpgme_data_new_from_filepart(&data, filename, 0, offset, length); + d.reset(new Private(e ? 0 : data)); +} + +GpgME::Data::Data(FILE *fp) +{ + gpgme_data_t data; + const gpgme_error_t e = gpgme_data_new_from_stream(&data, fp); + d.reset(new Private(e ? 0 : data)); +} + +GpgME::Data::Data(FILE *fp, off_t offset, size_t length) +{ + gpgme_data_t data; + const gpgme_error_t e = gpgme_data_new_from_filepart(&data, 0, fp, offset, length); + d.reset(new Private(e ? 0 : data)); +} + +GpgME::Data::Data(int fd) +{ + gpgme_data_t data; + const gpgme_error_t e = gpgme_data_new_from_fd(&data, fd); + d.reset(new Private(e ? 0 : data)); +} + +GpgME::Data::Data(DataProvider *dp) +{ + d.reset(new Private); + if (!dp) { + return; + } + if (!dp->isSupported(DataProvider::Read)) { + d->cbs.read = 0; + } + if (!dp->isSupported(DataProvider::Write)) { + d->cbs.write = 0; + } + if (!dp->isSupported(DataProvider::Seek)) { + d->cbs.seek = 0; + } + if (!dp->isSupported(DataProvider::Release)) { + d->cbs.release = 0; + } + const gpgme_error_t e = gpgme_data_new_from_cbs(&d->data, &d->cbs, dp); + if (e) { + d->data = 0; + } +#ifndef NDEBUG + //std::cerr << "GpgME::Data(): DataProvider supports: " + // << ( d->cbs.read ? "read" : "no read" ) << ", " + // << ( d->cbs.write ? "write" : "no write" ) << ", " + // << ( d->cbs.seek ? "seek" : "no seek" ) << ", " + // << ( d->cbs.release ? "release" : "no release" ) << std::endl; +#endif +} + +bool GpgME::Data::isNull() const +{ + return !d || !d->data; +} + +GpgME::Data::Encoding GpgME::Data::encoding() const +{ + switch (gpgme_data_get_encoding(d->data)) { + case GPGME_DATA_ENCODING_NONE: return AutoEncoding; + case GPGME_DATA_ENCODING_BINARY: return BinaryEncoding; + case GPGME_DATA_ENCODING_BASE64: return Base64Encoding; + case GPGME_DATA_ENCODING_ARMOR: return ArmorEncoding; + } + return AutoEncoding; +} + +GpgME::Error GpgME::Data::setEncoding(Encoding enc) +{ + gpgme_data_encoding_t ge = GPGME_DATA_ENCODING_NONE; + switch (enc) { + case AutoEncoding: ge = GPGME_DATA_ENCODING_NONE; break; + case BinaryEncoding: ge = GPGME_DATA_ENCODING_BINARY; break; + case Base64Encoding: ge = GPGME_DATA_ENCODING_BASE64; break; + case ArmorEncoding: ge = GPGME_DATA_ENCODING_ARMOR; break; + } + return Error(gpgme_data_set_encoding(d->data, ge)); +} + +GpgME::Data::Type GpgME::Data::type() const +{ + if (isNull()) { + return Invalid; + } + switch (gpgme_data_identify(d->data, 0)) { + case GPGME_DATA_TYPE_INVALID: return Invalid; + case GPGME_DATA_TYPE_UNKNOWN: return Unknown; + case GPGME_DATA_TYPE_PGP_SIGNED: return PGPSigned; + case GPGME_DATA_TYPE_PGP_OTHER: return PGPOther; + case GPGME_DATA_TYPE_PGP_KEY: return PGPKey; + case GPGME_DATA_TYPE_CMS_SIGNED: return CMSSigned; + case GPGME_DATA_TYPE_CMS_ENCRYPTED: return CMSEncrypted; + case GPGME_DATA_TYPE_CMS_OTHER: return CMSOther; + case GPGME_DATA_TYPE_X509_CERT: return X509Cert; + case GPGME_DATA_TYPE_PKCS12: return PKCS12; + } + return Invalid; +} + +char *GpgME::Data::fileName() const +{ + return gpgme_data_get_file_name(d->data); +} + +GpgME::Error GpgME::Data::setFileName(const char *name) +{ + return Error(gpgme_data_set_file_name(d->data, name)); +} + +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/lang/cpp/src/data.h b/lang/cpp/src/data.h new file mode 100644 index 00000000..efb1e790 --- /dev/null +++ b/lang/cpp/src/data.h @@ -0,0 +1,123 @@ +/* + data.h - wraps a gpgme data object + Copyright (C) 2003,2004 Klarälvdalens Datakonsult AB + + This file is part of GPGME++. + + GPGME++ is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + GPGME++ is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Library General Public License for more details. + + You should have received a copy of the GNU Library General Public License + along with GPGME++; see the file COPYING.LIB. If not, write to the + Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. +*/ + +#ifndef __GPGMEPP_DATA_H__ +#define __GPGMEPP_DATA_H__ + +#include "global.h" + +#include <sys/types.h> // for size_t, off_t +#include <cstdio> // FILE +#include <algorithm> +#include <memory> + +namespace GpgME +{ + +class DataProvider; +class Error; + +class GPGMEPP_EXPORT Data +{ + struct Null { + Null() {} + }; +public: + /* implicit */ Data(const Null &); + Data(); + explicit Data(gpgme_data_t data); + + // Memory-Based Data Buffers: + Data(const char *buffer, size_t size, bool copy = true); + explicit Data(const char *filename); + Data(const char *filename, off_t offset, size_t length); + Data(std::FILE *fp, off_t offset, size_t length); + // File-Based Data Buffers: + explicit Data(std::FILE *fp); + explicit Data(int fd); + // Callback-Based Data Buffers: + explicit Data(DataProvider *provider); + + static const Null null; + + const Data &operator=(Data other) + { + swap(other); + return *this; + } + + void swap(Data &other) + { + using std::swap; + swap(this->d, other.d); + } + + bool isNull() const; + + enum Encoding { + AutoEncoding, + BinaryEncoding, + Base64Encoding, + ArmorEncoding + }; + Encoding encoding() const; + Error setEncoding(Encoding encoding); + + enum Type { + Invalid, + Unknown, + PGPSigned, + PGPOther, + PGPKey, + CMSSigned, + CMSEncrypted, + CMSOther, + X509Cert, + PKCS12 + }; + Type type() const; + + char *fileName() const; + Error setFileName(const char *name); + + ssize_t read(void *buffer, size_t length); + ssize_t write(const void *buffer, size_t length); + off_t seek(off_t offset, int whence); + + class Private; + Private *impl() + { + return d.get(); + } + const Private *impl() const + { + return d.get(); + } +private: + std::shared_ptr<Private> d; +}; + +} + +GPGMEPP_MAKE_STD_SWAP_SPECIALIZATION(Data) + +#endif // __GPGMEPP_DATA_H__ diff --git a/lang/cpp/src/data_p.h b/lang/cpp/src/data_p.h new file mode 100644 index 00000000..38ba55af --- /dev/null +++ b/lang/cpp/src/data_p.h @@ -0,0 +1,40 @@ +/* + 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 Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + GPGME++ is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Library General Public License for more details. + + You should have received a copy of the GNU Library General Public License + along with GPGME++; see the file COPYING.LIB. If not, write to the + Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. +*/ + +#ifndef __GPGMEPP_DATA_P_H__ +#define __GPGMEPP_DATA_P_H__ + +#include <data.h> +#include "callbacks.h" + +class GpgME::Data::Private +{ +public: + explicit Private(gpgme_data_t d = 0) + : data(d), cbs(data_provider_callbacks) {} + ~Private(); + + gpgme_data_t data; + gpgme_data_cbs cbs; +}; + +#endif // __GPGMEPP_DATA_P_H__ diff --git a/lang/cpp/src/decryptionresult.cpp b/lang/cpp/src/decryptionresult.cpp new file mode 100644 index 00000000..78a2b1b6 --- /dev/null +++ b/lang/cpp/src/decryptionresult.cpp @@ -0,0 +1,240 @@ +/* + 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 Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + GPGME++ is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Library General Public License for more details. + + You should have received a copy of the GNU Library General Public License + along with GPGME++; see the file COPYING.LIB. If not, write to the + Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. +*/ + +#include <decryptionresult.h> +#include "result_p.h" +#include "util.h" + +#include <gpgme.h> + +#include <algorithm> +#include <iterator> +#include <cstring> +#include <cstdlib> +#include <istream> + +#include <string.h> + +class GpgME::DecryptionResult::Private +{ +public: + explicit Private(const _gpgme_op_decrypt_result &r) : res(r) + { + if (res.unsupported_algorithm) { + res.unsupported_algorithm = strdup(res.unsupported_algorithm); + } + if (res.file_name) { + res.file_name = strdup(res.file_name); + } + //FIXME: copying gpgme_recipient_t objects invalidates the keyid member, + //thus we use _keyid for now (internal API) + for (gpgme_recipient_t r = res.recipients ; r ; r = r->next) { + recipients.push_back(*r); + } + res.recipients = 0; + } + ~Private() + { + if (res.unsupported_algorithm) { + std::free(res.unsupported_algorithm); + } + res.unsupported_algorithm = 0; + if (res.file_name) { + std::free(res.file_name); + } + res.file_name = 0; + } + + _gpgme_op_decrypt_result res; + std::vector<_gpgme_recipient> recipients; +}; + +GpgME::DecryptionResult::DecryptionResult(gpgme_ctx_t ctx, int error) + : GpgME::Result(error), d() +{ + init(ctx); +} + +GpgME::DecryptionResult::DecryptionResult(gpgme_ctx_t ctx, const Error &error) + : GpgME::Result(error), d() +{ + init(ctx); +} + +void GpgME::DecryptionResult::init(gpgme_ctx_t ctx) +{ + if (!ctx) { + return; + } + gpgme_decrypt_result_t res = gpgme_op_decrypt_result(ctx); + if (!res) { + return; + } + d.reset(new Private(*res)); +} + +make_standard_stuff(DecryptionResult) + +const char *GpgME::DecryptionResult::unsupportedAlgorithm() const +{ + return d ? d->res.unsupported_algorithm : 0 ; +} + +bool GpgME::DecryptionResult::isWrongKeyUsage() const +{ + return d && d->res.wrong_key_usage; +} + +const char *GpgME::DecryptionResult::fileName() const +{ + return d ? d->res.file_name : 0 ; +} + +unsigned int GpgME::DecryptionResult::numRecipients() const +{ + return d ? d->recipients.size() : 0 ; +} + +GpgME::DecryptionResult::Recipient GpgME::DecryptionResult::recipient(unsigned int idx) const +{ + if (d && idx < d->recipients.size()) { + return Recipient(&d->recipients[idx]); + } + return Recipient(); +} + +namespace +{ +struct make_recipient { + GpgME::DecryptionResult::Recipient operator()(_gpgme_recipient &t) + { + return GpgME::DecryptionResult::Recipient(&t); + } +}; +} + +std::vector<GpgME::DecryptionResult::Recipient> GpgME::DecryptionResult::recipients() const +{ + std::vector<Recipient> result; + if (d) { + result.reserve(d->recipients.size()); + std::transform(d->recipients.begin(), d->recipients.end(), + std::back_inserter(result), + make_recipient()); + } + return result; +} + +class GpgME::DecryptionResult::Recipient::Private : public _gpgme_recipient +{ +public: + Private(gpgme_recipient_t reci) : _gpgme_recipient(*reci) {} +}; + +GpgME::DecryptionResult::Recipient::Recipient() + : d() +{ + +} + +GpgME::DecryptionResult::Recipient::Recipient(gpgme_recipient_t r) + : d() +{ + if (r) { + d.reset(new Private(r)); + } +} + +bool GpgME::DecryptionResult::Recipient::isNull() const +{ + return !d; +} + +const char *GpgME::DecryptionResult::Recipient::keyID() const +{ + //_keyid is internal API, but the public keyid is invalid after copying (see above) + if (d) { + return d->_keyid; + } + return 0; +} + +const char *GpgME::DecryptionResult::Recipient::shortKeyID() const +{ + //_keyid is internal API, but the public keyid is invalid after copying (see above) + if (d) { + return d->_keyid + 8; + } + return 0; +} + +unsigned int GpgME::DecryptionResult::Recipient::publicKeyAlgorithm() const +{ + if (d) { + return d->pubkey_algo; + } + return 0; +} + +const char *GpgME::DecryptionResult::Recipient::publicKeyAlgorithmAsString() const +{ + if (d) { + return gpgme_pubkey_algo_name(d->pubkey_algo); + } + return 0; +} + +GpgME::Error GpgME::DecryptionResult::Recipient::status() const +{ + if (d) { + return Error(d->status); + } + return Error(); +} + +std::ostream &GpgME::operator<<(std::ostream &os, const DecryptionResult &result) +{ + os << "GpgME::DecryptionResult("; + if (!result.isNull()) { + os << "\n error: " << result.error() + << "\n fileName: " << protect(result.fileName()) + << "\n unsupportedAlgorithm: " << protect(result.unsupportedAlgorithm()) + << "\n isWrongKeyUsage: " << result.isWrongKeyUsage() + << "\n recipients:\n"; + const std::vector<DecryptionResult::Recipient> recipients = result.recipients(); + std::copy(recipients.begin(), recipients.end(), + std::ostream_iterator<DecryptionResult::Recipient>(os, "\n")); + } + return os << ')'; +} + +std::ostream &GpgME::operator<<(std::ostream &os, const DecryptionResult::Recipient &reci) +{ + os << "GpgME::DecryptionResult::Recipient("; + if (!reci.isNull()) { + os << "\n keyID: " << protect(reci.keyID()) + << "\n shortKeyID: " << protect(reci.shortKeyID()) + << "\n publicKeyAlgorithm: " << protect(reci.publicKeyAlgorithmAsString()) + << "\n status: " << reci.status(); + } + return os << ')'; +} diff --git a/lang/cpp/src/decryptionresult.h b/lang/cpp/src/decryptionresult.h new file mode 100644 index 00000000..60b78d9c --- /dev/null +++ b/lang/cpp/src/decryptionresult.h @@ -0,0 +1,130 @@ +/* + decryptionresult.h - wraps a gpgme keygen result + Copyright (C) 2004 Klarälvdalens Datakonsult AB + + This file is part of GPGME++. + + GPGME++ is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + GPGME++ is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Library General Public License for more details. + + You should have received a copy of the GNU Library General Public License + along with GPGME++; see the file COPYING.LIB. If not, write to the + Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. +*/ + +#ifndef __GPGMEPP_DECRYPTIONRESULT_H__ +#define __GPGMEPP_DECRYPTIONRESULT_H__ + +#include "gpgmefw.h" +#include "result.h" +#include "gpgmepp_export.h" + +#include <vector> +#include <algorithm> +#include <iosfwd> +#include <memory> + +namespace GpgME +{ + +class Error; + +class GPGMEPP_EXPORT DecryptionResult : public Result +{ +public: + DecryptionResult(); + DecryptionResult(gpgme_ctx_t ctx, int error); + DecryptionResult(gpgme_ctx_t ctx, const Error &err); + explicit DecryptionResult(const Error &err); + + const DecryptionResult &operator=(DecryptionResult other) + { + swap(other); + return *this; + } + + void swap(DecryptionResult &other) + { + Result::swap(other); + using std::swap; + swap(this->d, other.d); + } + + bool isNull() const; + + GPGMEPP_DEPRECATED const char *unsupportedAlgortihm() const + { + return unsupportedAlgorithm(); + } + const char *unsupportedAlgorithm() const; + + GPGMEPP_DEPRECATED bool wrongKeyUsage() const + { + return isWrongKeyUsage(); + } + bool isWrongKeyUsage() const; + + const char *fileName() const; + + class Recipient; + + unsigned int numRecipients() const; + Recipient recipient(unsigned int idx) const; + std::vector<Recipient> recipients() const; + +private: + class Private; + void init(gpgme_ctx_t ctx); + std::shared_ptr<Private> d; +}; + +GPGMEPP_EXPORT std::ostream &operator<<(std::ostream &os, const DecryptionResult &result); + +class GPGMEPP_EXPORT DecryptionResult::Recipient +{ +public: + Recipient(); + explicit Recipient(gpgme_recipient_t reci); + + const Recipient &operator=(Recipient other) + { + swap(other); + return *this; + } + + void swap(Recipient &other) + { + using std::swap; + swap(this->d, other.d); + } + + bool isNull() const; + + const char *keyID() const; + const char *shortKeyID() const; + + unsigned int publicKeyAlgorithm() const; + const char *publicKeyAlgorithmAsString() const; + + Error status() const; + +private: + class Private; + std::shared_ptr<Private> d; +}; + +GPGMEPP_EXPORT std::ostream &operator<<(std::ostream &os, const DecryptionResult::Recipient &reci); + +} + +GPGMEPP_MAKE_STD_SWAP_SPECIALIZATION(DecryptionResult) + +#endif // __GPGMEPP_DECRYPTIONRESULT_H__ diff --git a/lang/cpp/src/defaultassuantransaction.cpp b/lang/cpp/src/defaultassuantransaction.cpp new file mode 100644 index 00000000..5bcf9705 --- /dev/null +++ b/lang/cpp/src/defaultassuantransaction.cpp @@ -0,0 +1,78 @@ +/* + defaultassuantransaction.cpp - default Assuan Transaction that just stores data and status lines + Copyright (C) 2009 Klarälvdalens Datakonsult AB + + This file is part of GPGME++. + + GPGME++ is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + GPGME++ is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Library General Public License for more details. + + You should have received a copy of the GNU Library General Public License + along with GPGME++; see the file COPYING.LIB. If not, write to the + Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. +*/ + +#include "defaultassuantransaction.h" +#include "error.h" +#include "data.h" + +#include <sstream> + +using namespace GpgME; + +DefaultAssuanTransaction::DefaultAssuanTransaction() + : AssuanTransaction(), + m_status(), + m_data() +{ + +} + +DefaultAssuanTransaction::~DefaultAssuanTransaction() {} + +Error DefaultAssuanTransaction::data(const char *data, size_t len) +{ + m_data.append(data, len); + return Error(); +} + +Data DefaultAssuanTransaction::inquire(const char *name, const char *args, Error &err) +{ + (void)name; (void)args; (void)err; + return Data::null; +} + +Error DefaultAssuanTransaction::status(const char *status, const char *args) +{ + m_status.push_back(std::pair<std::string, std::string>(status, args)); + return Error(); +} + +std::vector<std::string> DefaultAssuanTransaction::statusLine(const char *tag) const +{ + std::vector<std::string> result; + for (std::vector< std::pair<std::string, std::string> >::const_iterator it = m_status.begin(), end = m_status.end() ; it != end ; ++it) { + if (it->first == tag) { + result.push_back(it->second); + } + } + return result; +} + +std::string DefaultAssuanTransaction::firstStatusLine(const char *tag) const +{ + for (std::vector< std::pair<std::string, std::string> >::const_iterator it = m_status.begin(), end = m_status.end() ; it != end ; ++it) { + if (it->first == tag) { + return it->second; + } + } + return std::string(); +} diff --git a/lang/cpp/src/defaultassuantransaction.h b/lang/cpp/src/defaultassuantransaction.h new file mode 100644 index 00000000..bf4b8395 --- /dev/null +++ b/lang/cpp/src/defaultassuantransaction.h @@ -0,0 +1,65 @@ +/* + defaultassuantransaction.h - default Assuan Transaction that just stores data and status lines + Copyright (C) 2009 Klarälvdalens Datakonsult AB + + This file is part of GPGME++. + + GPGME++ is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + GPGME++ is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Library General Public License for more details. + + You should have received a copy of the GNU Library General Public License + along with GPGME++; see the file COPYING.LIB. If not, write to the + Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. +*/ + +#ifndef __GPGMEPP_DEFAULTASSUANTRANSACTION_H__ +#define __GPGMEPP_DEFAULTASSUANTRANSACTION_H__ + +#include <interfaces/assuantransaction.h> + +#include <string> +#include <vector> +#include <utility> + +namespace GpgME +{ + +class GPGMEPP_EXPORT DefaultAssuanTransaction : public AssuanTransaction +{ +public: + explicit DefaultAssuanTransaction(); + ~DefaultAssuanTransaction(); + + const std::vector< std::pair<std::string, std::string> > &statusLines() const + { + return m_status; + } + std::vector<std::string> statusLine(const char *tag) const; + std::string firstStatusLine(const char *tag) const; + + const std::string &data() const + { + return m_data; + } + +private: + /* reimp */ Error data(const char *data, size_t datalen); + /* reimp */ Data inquire(const char *name, const char *args, Error &err); + /* reimp */ Error status(const char *status, const char *args); + +private: + std::vector< std::pair<std::string, std::string> > m_status; + std::string m_data; +}; + +} // namespace GpgME + +#endif // __GPGMEPP_DEFAULTASSUANTRANSACTION_H__ diff --git a/lang/cpp/src/editinteractor.cpp b/lang/cpp/src/editinteractor.cpp new file mode 100644 index 00000000..c05ccd63 --- /dev/null +++ b/lang/cpp/src/editinteractor.cpp @@ -0,0 +1,344 @@ +/* + editinteractor.cpp - Interface for edit interactors + Copyright (C) 2007 Klarälvdalens Datakonsult AB + + This file is part of GPGME++. + + GPGME++ is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + GPGME++ is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Library General Public License for more details. + + You should have received a copy of the GNU Library General Public License + along with GPGME++; see the file COPYING.LIB. If not, write to the + Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. +*/ + +#include "editinteractor.h" +#include "callbacks.h" +#include "error.h" + +#include <gpgme.h> + +#ifdef _WIN32 +# include <io.h> +#include <windows.h> +#else +# include <unistd.h> +#endif + +#include <cerrno> +#include <cstring> + +#ifndef GPG_ERR_ALREADY_SIGNED +# define GPG_ERR_ALREADY_SIGNED GPG_ERR_USER_1 +#endif + +using namespace GpgME; + +static const char *status_to_string(unsigned int status); +static Error status_to_error(unsigned int status); + +class EditInteractor::Private +{ + friend class ::GpgME::EditInteractor; + friend class ::GpgME::CallbackHelper; + EditInteractor *const q; +public: + explicit Private(EditInteractor *qq); + ~Private(); + +private: + unsigned int state; + Error error; + std::FILE *debug; +}; + +class GpgME::CallbackHelper +{ +private: + static int writeAll(int fd, const void *buf, size_t count) + { + size_t toWrite = count; + while (toWrite > 0) { + const int n = gpgme_io_write(fd, buf, toWrite); + if (n < 0) { + return n; + } + toWrite -= n; + } + return count; + } + +public: + static int edit_interactor_callback_impl(void *opaque, gpgme_status_code_t status, const char *args, int fd) + { + EditInteractor::Private *ei = (EditInteractor::Private *)opaque; + + Error err = status_to_error(status); + + if (!err) { + + // advance to next state based on input: + const unsigned int oldState = ei->state; + ei->state = ei->q->nextState(status, args, err); + if (ei->debug) { + std::fprintf(ei->debug, "EditInteractor: %u -> nextState( %s, %s ) -> %u\n", + oldState, status_to_string(status), args ? args : "<null>", ei->state); + } + if (err) { + ei->state = oldState; + goto error; + } + + if (ei->state != oldState && + // if there was an error from before, we stop here (### this looks weird, can this happen at all?) + ei->error.code() == GPG_ERR_NO_ERROR) { + + // successful state change -> call action + if (const char *const result = ei->q->action(err)) { + if (err) { + goto error; + } + if (ei->debug) { + std::fprintf(ei->debug, "EditInteractor: action result \"%s\"\n", result); + } + // if there's a result, write it: + if (*result) { + gpgme_err_set_errno(0); + const ssize_t len = std::strlen(result); + if (writeAll(fd, result, len) != len) { + err = Error::fromSystemError(); + if (ei->debug) { + std::fprintf(ei->debug, "EditInteractor: Could not write to fd %d (%s)\n", fd, err.asString()); + } + goto error; + } + } + gpgme_err_set_errno(0); + if (writeAll(fd, "\n", 1) != 1) { + err = Error::fromSystemError(); + if (ei->debug) { + std::fprintf(ei->debug, "EditInteractor: Could not write to fd %d (%s)\n", fd, err.asString()); + } + goto error; + } + } else { + if (err) { + goto error; + } + if (ei->debug) { + std::fprintf(ei->debug, "EditInteractor: no action result\n"); + } + } + } else { + if (ei->debug) { + std::fprintf(ei->debug, "EditInteractor: no action executed\n"); + } + } + } + + error: + if (err) { + ei->error = err; + ei->state = EditInteractor::ErrorState; + } + + if (ei->debug) { + std::fprintf(ei->debug, "EditInteractor: error now %u (%s)\n", + ei->error.encodedError(), gpgme_strerror(ei->error.encodedError())); + } + + return ei->error.encodedError(); + } +}; + +static gpgme_error_t edit_interactor_callback(void *opaque, gpgme_status_code_t status, const char *args, int fd) +{ + return CallbackHelper::edit_interactor_callback_impl(opaque, status, args, fd); +} + +const gpgme_edit_cb_t GpgME::edit_interactor_callback = ::edit_interactor_callback; + +EditInteractor::Private::Private(EditInteractor *qq) + : q(qq), + state(StartState), + error(), + debug(0) +{ + +} + +EditInteractor::Private::~Private() {} + +EditInteractor::EditInteractor() + : d(new Private(this)) +{ + +} + +EditInteractor::~EditInteractor() +{ + delete d; +} + +unsigned int EditInteractor::state() const +{ + return d->state; +} + +Error EditInteractor::lastError() const +{ + return d->error; +} + +bool EditInteractor::needsNoResponse(unsigned int status) const +{ + switch (status) { + case GPGME_STATUS_EOF: + case GPGME_STATUS_GOT_IT: + case GPGME_STATUS_NEED_PASSPHRASE: + case GPGME_STATUS_NEED_PASSPHRASE_SYM: + case GPGME_STATUS_GOOD_PASSPHRASE: + case GPGME_STATUS_BAD_PASSPHRASE: + case GPGME_STATUS_USERID_HINT: + case GPGME_STATUS_SIGEXPIRED: + case GPGME_STATUS_KEYEXPIRED: + case GPGME_STATUS_PINENTRY_LAUNCHED: + return true; + default: + return false; + } +} + +// static +Error status_to_error(unsigned int status) +{ + switch (status) { + case GPGME_STATUS_MISSING_PASSPHRASE: + return Error::fromCode(GPG_ERR_NO_PASSPHRASE); + case GPGME_STATUS_ALREADY_SIGNED: + return Error::fromCode(GPG_ERR_ALREADY_SIGNED); + case GPGME_STATUS_KEYEXPIRED: + return Error::fromCode(GPG_ERR_CERT_EXPIRED); + case GPGME_STATUS_SIGEXPIRED: + return Error::fromCode(GPG_ERR_SIG_EXPIRED); + } + return Error(); +} + +void EditInteractor::setDebugChannel(std::FILE *debug) +{ + d->debug = debug; +} + +static const char *const status_strings[] = { + "EOF", + /* mkstatus processing starts here */ + "ENTER", + "LEAVE", + "ABORT", + + "GOODSIG", + "BADSIG", + "ERRSIG", + + "BADARMOR", + + "RSA_OR_IDEA", + "KEYEXPIRED", + "KEYREVOKED", + + "TRUST_UNDEFINED", + "TRUST_NEVER", + "TRUST_MARGINAL", + "TRUST_FULLY", + "TRUST_ULTIMATE", + + "SHM_INFO", + "SHM_GET", + "SHM_GET_BOOL", + "SHM_GET_HIDDEN", + + "NEED_PASSPHRASE", + "VALIDSIG", + "SIG_ID", + "ENC_TO", + "NODATA", + "BAD_PASSPHRASE", + "NO_PUBKEY", + "NO_SECKEY", + "NEED_PASSPHRASE_SYM", + "DECRYPTION_FAILED", + "DECRYPTION_OKAY", + "MISSING_PASSPHRASE", + "GOOD_PASSPHRASE", + "GOODMDC", + "BADMDC", + "ERRMDC", + "IMPORTED", + "IMPORT_OK", + "IMPORT_PROBLEM", + "IMPORT_RES", + "FILE_START", + "FILE_DONE", + "FILE_ERROR", + + "BEGIN_DECRYPTION", + "END_DECRYPTION", + "BEGIN_ENCRYPTION", + "END_ENCRYPTION", + + "DELETE_PROBLEM", + "GET_BOOL", + "GET_LINE", + "GET_HIDDEN", + "GOT_IT", + "PROGRESS", + "SIG_CREATED", + "SESSION_KEY", + "NOTATION_NAME", + "NOTATION_DATA", + "POLICY_URL", + "BEGIN_STREAM", + "END_STREAM", + "KEY_CREATED", + "USERID_HINT", + "UNEXPECTED", + "INV_RECP", + "NO_RECP", + "ALREADY_SIGNED", + "SIGEXPIRED", + "EXPSIG", + "EXPKEYSIG", + "TRUNCATED", + "ERROR", + "NEWSIG", + "REVKEYSIG", + "SIG_SUBPACKET", + "NEED_PASSPHRASE_PIN", + "SC_OP_FAILURE", + "SC_OP_SUCCESS", + "CARDCTRL", + "BACKUP_KEY_CREATED", + "PKA_TRUST_BAD", + "PKA_TRUST_GOOD", + + "PLAINTEXT", +}; +static const unsigned int num_status_strings = sizeof status_strings / sizeof * status_strings ; + +const char *status_to_string(unsigned int idx) +{ + if (idx < num_status_strings) { + return status_strings[idx]; + } else { + return "(unknown)"; + } +} diff --git a/lang/cpp/src/editinteractor.h b/lang/cpp/src/editinteractor.h new file mode 100644 index 00000000..21220528 --- /dev/null +++ b/lang/cpp/src/editinteractor.h @@ -0,0 +1,68 @@ +/* + editinteractor.h - Interface for edit interactors + Copyright (C) 2007 Klarälvdalens Datakonsult AB + + This file is part of GPGME++. + + GPGME++ is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + GPGME++ is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Library General Public License for more details. + + You should have received a copy of the GNU Library General Public License + along with GPGME++; see the file COPYING.LIB. If not, write to the + Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. +*/ + +#ifndef __GPGMEPP_EDITINTERACTOR_H__ +#define __GPGMEPP_EDITINTERACTOR_H__ + +#include "gpgmepp_export.h" + +#include <cstdio> + +namespace GpgME +{ + +class Error; +class Context; +class CallbackHelper; + +class GPGMEPP_EXPORT EditInteractor +{ + friend class ::GpgME::Context; + friend class ::GpgME::CallbackHelper; + EditInteractor(const EditInteractor &); + EditInteractor &operator=(const EditInteractor &); +public: + EditInteractor(); + virtual ~EditInteractor(); + + enum { + StartState = 0, + ErrorState = 0xFFFFFFFF + }; + + virtual const char *action(Error &err) const = 0; + virtual unsigned int nextState(unsigned int statusCode, const char *args, Error &err) const = 0; + + unsigned int state() const; + Error lastError() const; + bool needsNoResponse(unsigned int statusCode) const; + + void setDebugChannel(std::FILE *file); + +private: + class Private; + Private *const d; +}; + +} // namespace GpgME + +#endif // __GPGMEPP_EDITINTERACTOR_H__ diff --git a/lang/cpp/src/encryptionresult.cpp b/lang/cpp/src/encryptionresult.cpp new file mode 100644 index 00000000..c4e7df51 --- /dev/null +++ b/lang/cpp/src/encryptionresult.cpp @@ -0,0 +1,159 @@ +/* + encryptionresult.cpp - wraps a gpgme verify result + Copyright (C) 2004 Klarälvdalens Datakonsult AB + + This file is part of GPGME++. + + GPGME++ is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + GPGME++ is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Library General Public License for more details. + + You should have received a copy of the GNU Library General Public License + along with GPGME++; see the file COPYING.LIB. If not, write to the + Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. +*/ + +#include <encryptionresult.h> +#include "result_p.h" +#include "util.h" + +#include <gpgme.h> + +#include <cstring> +#include <cstdlib> +#include <istream> +#include <algorithm> +#include <iterator> + +#include <string.h> + +class GpgME::EncryptionResult::Private +{ +public: + explicit Private(const gpgme_encrypt_result_t r) + { + if (!r) { + return; + } + for (gpgme_invalid_key_t ik = r->invalid_recipients ; ik ; ik = ik->next) { + gpgme_invalid_key_t copy = new _gpgme_invalid_key(*ik); + if (ik->fpr) { + copy->fpr = strdup(ik->fpr); + } + copy->next = 0; + invalid.push_back(copy); + } + } + ~Private() + { + for (std::vector<gpgme_invalid_key_t>::iterator it = invalid.begin() ; it != invalid.end() ; ++it) { + std::free((*it)->fpr); + delete *it; *it = 0; + } + } + + std::vector<gpgme_invalid_key_t> invalid; +}; + +GpgME::EncryptionResult::EncryptionResult(gpgme_ctx_t ctx, int error) + : GpgME::Result(error), d() +{ + init(ctx); +} + +GpgME::EncryptionResult::EncryptionResult(gpgme_ctx_t ctx, const Error &error) + : GpgME::Result(error), d() +{ + init(ctx); +} + +void GpgME::EncryptionResult::init(gpgme_ctx_t ctx) +{ + if (!ctx) { + return; + } + gpgme_encrypt_result_t res = gpgme_op_encrypt_result(ctx); + if (!res) { + return; + } + d.reset(new Private(res)); +} + +make_standard_stuff(EncryptionResult) + +unsigned int GpgME::EncryptionResult::numInvalidRecipients() const +{ + return d ? d->invalid.size() : 0 ; +} + +GpgME::InvalidRecipient GpgME::EncryptionResult::invalidEncryptionKey(unsigned int idx) const +{ + return InvalidRecipient(d, idx); +} + +std::vector<GpgME::InvalidRecipient> GpgME::EncryptionResult::invalidEncryptionKeys() const +{ + if (!d) { + return std::vector<GpgME::InvalidRecipient>(); + } + std::vector<GpgME::InvalidRecipient> result; + result.reserve(d->invalid.size()); + for (unsigned int i = 0 ; i < d->invalid.size() ; ++i) { + result.push_back(InvalidRecipient(d, i)); + } + return result; +} + +GpgME::InvalidRecipient::InvalidRecipient(const std::shared_ptr<EncryptionResult::Private> &parent, unsigned int i) + : d(parent), idx(i) +{ + +} + +GpgME::InvalidRecipient::InvalidRecipient() : d(), idx(0) {} + +bool GpgME::InvalidRecipient::isNull() const +{ + return !d || idx >= d->invalid.size() ; +} + +const char *GpgME::InvalidRecipient::fingerprint() const +{ + return isNull() ? 0 : d->invalid[idx]->fpr ; +} + +GpgME::Error GpgME::InvalidRecipient::reason() const +{ + return Error(isNull() ? 0 : d->invalid[idx]->reason); +} + +std::ostream &GpgME::operator<<(std::ostream &os, const EncryptionResult &result) +{ + os << "GpgME::EncryptionResult("; + if (!result.isNull()) { + os << "\n error: " << result.error() + << "\n invalid recipients:\n"; + const std::vector<InvalidRecipient> ir = result.invalidEncryptionKeys(); + std::copy(ir.begin(), ir.end(), + std::ostream_iterator<InvalidRecipient>(os, "\n")); + } + return os << ')'; +} + +std::ostream &GpgME::operator<<(std::ostream &os, const InvalidRecipient &ir) +{ + os << "GpgME::InvalidRecipient("; + if (!ir.isNull()) { + os << "\n fingerprint: " << protect(ir.fingerprint()) + << "\n reason: " << ir.reason() + << '\n'; + } + return os << ')'; +} diff --git a/lang/cpp/src/encryptionresult.h b/lang/cpp/src/encryptionresult.h new file mode 100644 index 00000000..edc400fb --- /dev/null +++ b/lang/cpp/src/encryptionresult.h @@ -0,0 +1,113 @@ +/* + encryptionresult.h - wraps a gpgme sign result + Copyright (C) 2004 Klarälvdalens Datakonsult AB + + This file is part of GPGME++. + + GPGME++ is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + GPGME++ is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Library General Public License for more details. + + You should have received a copy of the GNU Library General Public License + along with GPGME++; see the file COPYING.LIB. If not, write to the + Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. +*/ + +#ifndef __GPGMEPP_ENCRYPTIONRESULT_H__ +#define __GPGMEPP_ENCRYPTIONRESULT_H__ + +#include "gpgmefw.h" +#include "result.h" +#include "gpgmepp_export.h" + +#include <memory> + +#include <vector> +#include <iosfwd> + +namespace GpgME +{ + +class Error; +class InvalidRecipient; + +class GPGMEPP_EXPORT EncryptionResult : public Result +{ +public: + EncryptionResult(); + EncryptionResult(gpgme_ctx_t ctx, int error); + EncryptionResult(gpgme_ctx_t ctx, const Error &error); + EncryptionResult(const Error &err); + + const EncryptionResult &operator=(EncryptionResult other) + { + swap(other); + return *this; + } + + void swap(EncryptionResult &other) + { + Result::swap(other); + using std::swap; + swap(this->d, other.d); + } + + bool isNull() const; + + unsigned int numInvalidRecipients() const; + + InvalidRecipient invalidEncryptionKey(unsigned int index) const; + std::vector<InvalidRecipient> invalidEncryptionKeys() const; + + class Private; +private: + void init(gpgme_ctx_t ctx); + std::shared_ptr<Private> d; +}; + +GPGMEPP_EXPORT std::ostream &operator<<(std::ostream &os, const EncryptionResult &result); + +class GPGMEPP_EXPORT InvalidRecipient +{ + friend class ::GpgME::EncryptionResult; + InvalidRecipient(const std::shared_ptr<EncryptionResult::Private> &parent, unsigned int index); +public: + InvalidRecipient(); + + const InvalidRecipient &operator=(InvalidRecipient other) + { + swap(other); + return *this; + } + + void swap(InvalidRecipient &other) + { + using std::swap; + swap(this->d, other.d); + } + + bool isNull() const; + + const char *fingerprint() const; + Error reason() const; + +private: + std::shared_ptr<EncryptionResult::Private> d; + unsigned int idx; +}; + +GPGMEPP_EXPORT std::ostream &operator<<(std::ostream &os, const InvalidRecipient &recipient); + +} + +GPGMEPP_MAKE_STD_SWAP_SPECIALIZATION(EncryptionResult) +GPGMEPP_MAKE_STD_SWAP_SPECIALIZATION(InvalidRecipient) + +#endif // __GPGMEPP_ENCRYPTIONRESULT_H__ diff --git a/lang/cpp/src/engineinfo.cpp b/lang/cpp/src/engineinfo.cpp new file mode 100644 index 00000000..d2600909 --- /dev/null +++ b/lang/cpp/src/engineinfo.cpp @@ -0,0 +1,83 @@ +/* + engineinfo.h + Copyright (C) 2004 Klarälvdalens Datakonsult AB + + This file is part of GPGME++. + + GPGME++ is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + GPGME++ is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Library General Public License for more details. + + You should have received a copy of the GNU Library General Public License + along with GPGME++; see the file COPYING.LIB. If not, write to the + Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. +*/ + +#include "engineinfo.h" + +#include <gpgme.h> + +class GpgME::EngineInfo::Private +{ +public: + Private(gpgme_engine_info_t engine = 0) : info(engine) {} + ~Private() + { + info = 0; + } + + gpgme_engine_info_t info; +}; + +GpgME::EngineInfo::EngineInfo() : d() {} + +GpgME::EngineInfo::EngineInfo(gpgme_engine_info_t engine) + : d(new Private(engine)) +{ + +} + +bool GpgME::EngineInfo::isNull() const +{ + return !d || !d->info; +} + +GpgME::Protocol GpgME::EngineInfo::protocol() const +{ + if (isNull()) { + return UnknownProtocol; + } + switch (d->info->protocol) { + case GPGME_PROTOCOL_OpenPGP: return OpenPGP; + case GPGME_PROTOCOL_CMS: return CMS; + default: + return UnknownProtocol; + } +} + +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; +} + +const char *GpgME::EngineInfo::homeDirectory() const +{ + return isNull() ? 0 : d->info->home_dir; +} diff --git a/lang/cpp/src/engineinfo.h b/lang/cpp/src/engineinfo.h new file mode 100644 index 00000000..4de9884f --- /dev/null +++ b/lang/cpp/src/engineinfo.h @@ -0,0 +1,70 @@ +/* + engineinfo.h + Copyright (C) 2004 Klarälvdalens Datakonsult AB + + This file is part of GPGME++. + + GPGME++ is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + GPGME++ is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Library General Public License for more details. + + You should have received a copy of the GNU Library General Public License + along with GPGME++; see the file COPYING.LIB. If not, write to the + Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. +*/ + +#ifndef __GPGMEPP_ENGINEINFO_H__ +#define __GPGMEPP_ENGINEINFO_H__ + +#include "global.h" + +#include <memory> + +#include <algorithm> + +namespace GpgME +{ + +class GPGMEPP_EXPORT EngineInfo +{ +public: + EngineInfo(); + explicit EngineInfo(gpgme_engine_info_t engine); + + const EngineInfo &operator=(EngineInfo other) + { + swap(other); + return *this; + } + + void swap(EngineInfo &other) + { + using std::swap; + swap(this->d, other.d); + } + + bool isNull() const; + + Protocol protocol() const; + const char *fileName() const; + const char *version() const; + const char *requiredVersion() const; + const char *homeDirectory() const; + +private: + class Private; + std::shared_ptr<Private> d; +}; + +} + +GPGMEPP_MAKE_STD_SWAP_SPECIALIZATION(EngineInfo) + +#endif // __GPGMEPP_ENGINEINFO_H__ diff --git a/lang/cpp/src/error.h b/lang/cpp/src/error.h new file mode 100644 index 00000000..009fe20f --- /dev/null +++ b/lang/cpp/src/error.h @@ -0,0 +1,78 @@ +/* + error.h - wraps a gpgme error + Copyright (C) 2003, 2007 Klarälvdalens Datakonsult AB + + This file is part of GPGME++. + + GPGME++ is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + GPGME++ is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Library General Public License for more details. + + You should have received a copy of the GNU Library General Public License + along with GPGME++; see the file COPYING.LIB. If not, write to the + Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. +*/ + +// -*- c++ -*- +#ifndef __GPGMEPP_ERROR_H__ +#define __GPGMEPP_ERROR_H__ + +#include "global.h" + +#include <string> +#include <iosfwd> + +#include <gpg-error.h> + +#ifndef GPGMEPP_ERR_SOURCE_DEFAULT +# define GPGMEPP_ERR_SOURCE_DEFAULT GPG_ERR_SOURCE_USER_1 +#endif + +namespace GpgME +{ + +class GPGMEPP_EXPORT Error +{ +public: + Error() : mErr(0), mMessage() {} + explicit Error(unsigned int e) : mErr(e), mMessage() {} + + const char *source() const; + const char *asString() const; + + int code() const; + int sourceID() const; + + bool isCanceled() const; + + unsigned int encodedError() const + { + return mErr; + } + int toErrno() const; + + static bool hasSystemError(); + static Error fromSystemError(unsigned int src = GPGMEPP_ERR_SOURCE_DEFAULT); + static void setSystemError(gpg_err_code_t err); + static void setErrno(int err); + static Error fromErrno(int err, unsigned int src = GPGMEPP_ERR_SOURCE_DEFAULT); + static Error fromCode(unsigned int err, unsigned int src = GPGMEPP_ERR_SOURCE_DEFAULT); + + GPGMEPP_MAKE_SAFE_BOOL_OPERATOR(mErr &&!isCanceled()) +private: + unsigned int mErr; + mutable std::string mMessage; +}; + +GPGMEPP_EXPORT std::ostream &operator<<(std::ostream &os, const Error &err); + +} // namespace GpgME + +#endif /* __GPGMEPP_ERROR_H__ */ diff --git a/lang/cpp/src/eventloopinteractor.cpp b/lang/cpp/src/eventloopinteractor.cpp new file mode 100644 index 00000000..7ec258c9 --- /dev/null +++ b/lang/cpp/src/eventloopinteractor.cpp @@ -0,0 +1,199 @@ +/* + eventloopinteractor.cpp + Copyright (C) 2003,2004 Klarälvdalens Datakonsult AB + + This file is part of GPGME++. + + GPGME++ is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + GPGME++ is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Library General Public License for more details. + + You should have received a copy of the GNU Library General Public License + along with GPGME++; see the file COPYING.LIB. If not, write to the + Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. +*/ + +#include <eventloopinteractor.h> + +#include <context.h> +#include "context_p.h" +#include <key.h> +#include <trustitem.h> + +#include <gpgme.h> + +#include <vector> +using std::vector; +#ifndef NDEBUG +# include <iostream> +#endif +#include <cassert> + +namespace GpgME +{ + +// +// EventLoopInteractor::Private Declaration +// + +class EventLoopInteractor::Private +{ +public: + struct OneFD { + OneFD(int aFd, int aDir, gpgme_io_cb_t aFnc, + void *aFncData, void *aExternalTag) + : fd(aFd), dir(aDir), fnc(aFnc), + fncData(aFncData), externalTag(aExternalTag) {} + 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 const gpgme_io_cbs iocbs; +}; + +const 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 gpgme_error(GPG_ERR_GENERAL); + } + instance()->d->mCallbacks.push_back(new OneFD(fd, dir, fnc, fnc_data, etag)); + if (r_tag) { + *r_tag = instance()->d->mCallbacks.back(); + } + return GPG_ERR_NO_ERROR; +} + +void EventLoopInteractor::Private::removeIOCb(void *tag) +{ + + if (!instance() || !instance()->d) { + return; + } + for (vector<OneFD *>::iterator it = instance()->d->mCallbacks.begin(); + it != instance()->d->mCallbacks.end() ; ++it) { + 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: { + instance()->operationStartEvent(ctx); + // TODO: what's in type_data? + } + break; + case GPGME_EVENT_DONE: { + gpgme_error_t e = *static_cast<gpgme_error_t *>(type_data); + if (ctx && ctx->impl()) { + ctx->impl()->lasterr = e; + } + instance()->operationDoneEvent(ctx, Error(e)); + } + break; + case GPGME_EVENT_NEXT_KEY: { + gpgme_key_t key = static_cast<gpgme_key_t>(type_data); + instance()->nextKeyEvent(ctx, Key(key, false)); + } + 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() : d(new Private) +{ + assert(!mSelf); + mSelf = this; +} + +EventLoopInteractor::~EventLoopInteractor() +{ + // warn if there are still callbacks registered + mSelf = 0; + delete d; +} + +void EventLoopInteractor::manage(Context *context) +{ + if (!context || context->managedByEventLoopInteractor()) { + return; + } + gpgme_io_cbs *iocbs = new gpgme_io_cbs(Private::iocbs); + iocbs->event_priv = context; + context->installIOCallbacks(iocbs); +} + +void EventLoopInteractor::unmanage(Context *context) +{ + if (context) { + context->uninstallIOCallbacks(); + } +} + +void EventLoopInteractor::actOn(int fd, Direction dir) +{ + for (vector<Private::OneFD *>::const_iterator it = d->mCallbacks.begin(); + it != d->mCallbacks.end() ; ++it) { + if ((*it)->fd == fd && ((*it)->dir ? Read : Write) == dir) { + (*((*it)->fnc))((*it)->fncData, fd); + break; + } + } +} + +} // namespace GpgME diff --git a/lang/cpp/src/eventloopinteractor.h b/lang/cpp/src/eventloopinteractor.h new file mode 100644 index 00000000..94821d6d --- /dev/null +++ b/lang/cpp/src/eventloopinteractor.h @@ -0,0 +1,156 @@ +/* + eventloopinteractor.h + Copyright (C) 2003,2004 Klarälvdalens Datakonsult AB + + This file is part of GPGME++. + + GPGME++ is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + GPGME++ is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Library General Public License for more details. + + You should have received a copy of the GNU Library General Public License + along with GPGME++; see the file COPYING.LIB. If not, write to the + Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. +*/ + +// -*- c++ -*- +#ifndef __GPGMEPP_EVENTLOOPINTERACTOR_H__ +#define __GPGMEPP_EVENTLOOPINTERACTOR_H__ + +#include "gpgmepp_export.h" + +namespace GpgME +{ + +class Context; +class Error; +class TrustItem; +class Key; + +/*! \file eventloopinteractor.h + \brief Abstract base class for gpgme's external event loop support + + This class does most of the work involved with hooking GpgME++ + up with external event loops, such as the GTK or Qt ones. + + It actually provides two interfaces: An interface to the gpgme + IO Callback handling and one for gpgme events. The IO Callback + interface consists of the three methods \c actOn(), \c + registerWatcher() and \c unregisterWatcher(). The event + interface consists of the three methods \c nextTrustItemEvent(), + \c nextKeyEvent() and \c operationDoneEvent(). + + \sect General Usage + + \c EventLoopInteractor is designed to be used as a + singleton. However, in order to make any use of it, you have to + subclass it and reimplement it's pure virtual methods (see + below). We suggest you keep the constructor protected and + provide a static \c instance() method that returns the single + instance. Alternatively, you can create an instance on the + stack, e.g. in \c main(). + + If you want \c EventLoopInteractor to manage a particular \c + Context, just call \c manage() on the \c Context. OTOH, if you + want to disable IO callbacks for a \c Context, use \c unmanage(). + + \sect IO Callback Interface + + One part of this interface is represented by \c + registerWatcher() and \c unregisterWatcher(), both of which are + pure virtual. \c registerWatcher() should do anything necessary + to hook up watching of file descriptor \c fd for reading (\c dir + = \c Read) or writing (\c dir = Write) to the event loop you use + and return a tag identifying that particular watching process + uniquely. This could be the index into an array of objects you + use for that purpose or the address of such an object. E.g. in + Qt, you'd essentially just create a new \c QSocketNotifier: + + \verbatim + void * registerWatcher( int fd, Direction dir ) { + return new QSocketNotifier( fd, dir == Read ? QSocketNotifier::Read : QSocketNotifier::Write ); + // misses connecting to the activated() signal... + } + \endverbatim + + which uses the address of the created object as unique tag. The + tag returned by \c registerWatcher is stored by \c + EventLoopInteractor and passed as argument to \c + unregisterWatcher(). So, in the picture above, you'd implement \c + unregisterWatcher() like this: + + \verbatim + void unregisterWatcher( void * tag ) { + delete static_cast<QSocketNotifier*>( tag ); + } + \endverbatim + + The other part of the IO callback interface is \c actOn(), which + you should call if you receive notification from your event loop + about activity on file descriptor \c fd in direction \c dir. In + the picture above, you'd call this from the slot connected to + the socket notifier's \c activated() signal. + + \note \c registerWatcher() as well as \c unregisterWatcher() may + be called from within \c actOn(), so be careful with + e.g. locking in threaded environments and keep in mind that the + object you used to find the \c fd and \c dir fo the \c actOn() + call might be deleted when \c actOn() returns! + + \sect Event Handler Interface + +*/ +class GPGMEPP_EXPORT EventLoopInteractor +{ +protected: + EventLoopInteractor(); +public: + virtual ~EventLoopInteractor(); + + static EventLoopInteractor *instance() + { + return mSelf; + } + + void manage(Context *context); + void unmanage(Context *context); + + enum Direction { Read, Write }; +protected: + // + // IO Notification Interface + // + + /** Call this if your event loop detected activity on file + descriptor fd, with direction dir */ + void actOn(int fd, Direction dir); + + virtual void *registerWatcher(int fd, Direction dir, bool &ok) = 0; + virtual void unregisterWatcher(void *tag) = 0; + + // + // Event Handler Interface + // + + virtual void operationStartEvent(Context *context) = 0; + virtual void nextTrustItemEvent(Context *context, const TrustItem &item) = 0; + virtual void nextKeyEvent(Context *context, const Key &key) = 0; + virtual void operationDoneEvent(Context *context, const Error &e) = 0; + +private: + class Private; + friend class Private; + Private *const d; + static EventLoopInteractor *mSelf; +}; + +} + +#endif // __GPGMEPP_EVENTLOOPINTERACTOR_H__ diff --git a/lang/cpp/src/exception.cpp b/lang/cpp/src/exception.cpp new file mode 100644 index 00000000..c687024b --- /dev/null +++ b/lang/cpp/src/exception.cpp @@ -0,0 +1,58 @@ +/* + exception.cpp - exception wrapping a gpgme error + Copyright (C) 2007 Klarälvdalens Datakonsult AB + + This file is part of GPGME++. + + GPGME++ is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + GPGME++ is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Library General Public License for more details. + + You should have received a copy of the GNU Library General Public License + along with GPGME++; see the file COPYING.LIB. If not, write to the + Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. +*/ + +// -*- c++ -*- +#include "exception.h" + +#include <gpgme.h> + +#include <sstream> + +using namespace GpgME; +using namespace std; // only safe b/c it's so small a file! + +Exception::~Exception() throw() {} + +// static +string Exception::make_message(const Error &err, const string &msg) +{ + return make_message(err, msg, NoOptions); +} + +// static +string Exception::make_message(const Error &err, const string &msg, Options opt) +{ + if (opt & MessageOnly) { + return msg; + } + char error_string[128]; + error_string[0] = '\0'; + gpgme_strerror_r(err.encodedError(), error_string, sizeof error_string); + error_string[sizeof error_string - 1] = '\0'; + stringstream ss; + ss << gpgme_strsource(err.encodedError()) << ": "; + if (!msg.empty()) { + ss << msg << ": "; + } + ss << error_string << " (" << static_cast<unsigned long>(err.encodedError()) << ')'; + return ss.str(); +} diff --git a/lang/cpp/src/exception.h b/lang/cpp/src/exception.h new file mode 100644 index 00000000..8f40b0e0 --- /dev/null +++ b/lang/cpp/src/exception.h @@ -0,0 +1,68 @@ +/* + exception.h - exception wrapping a gpgme error + Copyright (C) 2007 Klarälvdalens Datakonsult AB + + This file is part of GPGME++. + + GPGME++ is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + GPGME++ is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Library General Public License for more details. + + You should have received a copy of the GNU Library General Public License + along with GPGME++; see the file COPYING.LIB. If not, write to the + Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. +*/ + +// -*- c++ -*- +#ifndef __GPGMEPP_EXCEPTION_H__ +#define __GPGMEPP_EXCEPTION_H__ + +#include "error.h" + +#include <stdexcept> +#include <string> + +namespace GpgME +{ + +class GPGMEPP_EXPORT Exception : public std::runtime_error +{ +public: + enum Options { + NoOptions = 0x0, + MessageOnly = 0x1, + + AllOptions = MessageOnly + }; + + explicit Exception(const GpgME::Error &err, const std::string &msg = std::string(), Options opt = NoOptions) + : std::runtime_error(make_message(err, msg, opt)), m_error(err), m_message(msg) {} + + ~Exception() throw(); + + Error error() const + { + return m_error; + } + const std::string &message() const + { + return m_message; + } +private: + static std::string make_message(const GpgME::Error &err, const std::string &msg); + static std::string make_message(const GpgME::Error &err, const std::string &msg, Options opt); +private: + const GpgME::Error m_error; + const std::string m_message; +}; + +} // namespace GpgME + +#endif /* __GPGMEPP_EXCEPTION_H__ */ diff --git a/lang/cpp/src/global.h b/lang/cpp/src/global.h new file mode 100644 index 00000000..9be5202c --- /dev/null +++ b/lang/cpp/src/global.h @@ -0,0 +1,206 @@ +/* + global.h - global gpgme functions and enums + Copyright (C) 2003, 2007 Klarälvdalens Datakonsult AB + + This file is part of GPGME++. + + GPGME++ is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + GPGME++ is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Library General Public License for more details. + + You should have received a copy of the GNU Library General Public License + along with GPGME++; see the file COPYING.LIB. If not, write to the + Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. +*/ + +// -*- c++ -*- +#ifndef __GPGMEPP_GLOBAL_H__ +#define __GPGMEPP_GLOBAL_H__ + +#include "gpgmefw.h" +#include "gpgmepp_export.h" + +#include <iosfwd> +#include <cstring> + +namespace GpgME +{ +class Error; +class EngineInfo; +class Context; +} + +struct _GIOChannel; +typedef struct _GIOChannel GIOChannel; +class QIODevice; + +namespace GpgME +{ + +GPGMEPP_EXPORT void initializeLibrary(); +/*! + Initializes the library, returns Error::code() == + GPG_ERR_USER_1 if underlying gpgme is too old. +*/ +GPGMEPP_EXPORT Error initializeLibrary(int); + +enum Protocol { OpenPGP, CMS, UnknownProtocol }; + +enum Engine { GpgEngine, GpgSMEngine, GpgConfEngine, UnknownEngine, AssuanEngine, G13Engine }; + +enum KeyListMode { + Local = 0x1, + Extern = 0x2, + Signatures = 0x4, + SignatureNotations = 0x8, + Validate = 0x10, + Ephemeral = 0x20 +}; + +enum SignatureMode { NormalSignatureMode, Detached, Clearsigned }; + +GPGMEPP_EXPORT std::ostream &operator<<(std::ostream &os, Protocol proto); +GPGMEPP_EXPORT std::ostream &operator<<(std::ostream &os, Engine eng); +GPGMEPP_EXPORT std::ostream &operator<<(std::ostream &os, KeyListMode mode); +GPGMEPP_EXPORT std::ostream &operator<<(std::ostream &os, SignatureMode mode); + +GPGMEPP_EXPORT Error setDefaultLocale(int category, const char *value); + +GPGMEPP_EXPORT Context *wait(Error &e, bool hang = true); +typedef void (*IdleFunction)(void); +GPGMEPP_EXPORT IdleFunction registerIdleFunction(IdleFunction idleFunction); + +typedef void (*IOCallback)(void *data, int fd); + +GPGMEPP_EXPORT EngineInfo engineInfo(Protocol proto); +GPGMEPP_EXPORT EngineInfo engineInfo(Engine engine); + +GPGMEPP_EXPORT Error checkEngine(Protocol proto); +GPGMEPP_EXPORT Error checkEngine(Engine engine); + +GPGMEPP_EXPORT GIOChannel *getGIOChannel(int fd); +GPGMEPP_EXPORT QIODevice *getQIODevice(int fd); + +enum Feature { + ValidatingKeylistModeFeature = 0x00000001, + CancelOperationFeature = 0x00000002, + WrongKeyUsageFeature = 0x00000004, + DefaultCertificateInclusionFeature = 0x00000008, + + GetSetEngineInfoFeature = 0x00000010, + EngineInfoHomeDirFeature = 0x00000020, + NoEncryptToEncryptionFlagFeature = 0x00000040, + EphemeralKeylistModeFeature = 0x00000080, + + SetDataFileNameFeeature = 0x00000100, + VerificationResultFileNameFeature = 0x00000200, + DecryptionResultFileNameFeature = 0x00000400, + DecryptionResultRecipientsFeature = 0x00000800, + + AuditLogFeature = 0x00001000, + GpgConfEngineFeature = 0x00002000, + CancelOperationAsyncFeature = 0x00004000, + AssuanEngineFeature = 0x00008000, + + ClearAddGetSignatureNotationsFeature = 0x00010000, + SignatureNotationsKeylistModeFeature = 0x00020000, + KeySignatureNotationsFeature = 0x00040000, + SignatureNotationsFlagsFeature = 0x00080000, + SignatureNotationsCriticalFlagFeature = 0x00100000, + SignatureNotationsHumanReadableFlagFeature = 0x00200000, + CardKeyFeature = 0x00400000, + ImportFromKeyserverFeature = 0x00800000, + + KeyIsQualifiedFeature = 0x01000200, + SubkeyIsQualifiedFeature = 0x02000000, + SignaturePkaFieldsFeature = 0x04000000, + SignatureAlgorithmFieldsFeature = 0x08000000, + + FdPointerFeature = 0x10000000, + G13VFSFeature = 0x20000000, + PasswdFeature = 0x40000000, // gpgme >= 1.3.0 + // unusable (max value) + + FeatureMaxValue = 0x80000000 +}; +enum Feature2 { + Feature2MaxValue = 0x80000000 +}; +// use hasFeature( unsigned long, unsigned long ) instead +GPGMEPP_DEPRECATED_EXPORT bool hasFeature(unsigned long feature); +GPGMEPP_EXPORT bool hasFeature(unsigned long feature, unsigned long feature2); + +} // namespace GpgME + +# ifndef GPGMEPP_MAKE_STD_SWAP_SPECIALIZATION +# define GPGMEPP_MAKE_STD_SWAP_SPECIALIZATION( Class ) \ + namespace std { template <> inline void swap< GpgME::Class >( GpgME::Class & lhs, GpgME::Class & rhs ) { lhs.swap( rhs ); } } +# endif + +# ifndef GPGMEPP_MAKE_SAFE_BOOL_OPERATOR +# define GPGMEPP_MAKE_SAFE_BOOL_OPERATOR( Cond ) \ + private: \ + struct __safe_bool_dummy__ { void nonnull() {} }; \ + typedef void ( __safe_bool_dummy__::*unspecified_bool_type )(); \ + public: \ + operator unspecified_bool_type() const { return ( Cond ) ? &__safe_bool_dummy__::nonnull : 0 ; } +# endif + +inline int _gpgmepp_strcmp(const char *s1, const char *s2) +{ + return s1 ? s2 ? std::strcmp(s1, s2) : 1 : s2 ? -1 : 0; +} + +#define _GPGMEPP_MAKE_STRCMP( Name, expr, cmp ) \ + template <template <typename U> class Op> \ + struct Name { \ + typedef bool result_type; \ + \ + bool operator()( const char * lhs, const char * rhs ) const { \ + return Op<int>()( cmp, 0 ); \ + } \ + \ + bool operator()( const std::string & lhs, const std::string & rhs ) const { \ + return operator()( lhs.c_str(), rhs.c_str() ); \ + } \ + bool operator()( const char * lhs, const std::string & rhs ) const { \ + return operator()( lhs, rhs.c_str() ); \ + } \ + bool operator()( const std::string & lhs, const char * rhs ) const { \ + return operator()( lhs.c_str(), rhs ); \ + } \ + \ + template <typename T> \ + bool operator()( const T & lhs, const T & rhs ) const { \ + return operator()( (lhs expr), (rhs expr) ); \ + } \ + template <typename T> \ + bool operator()( const T & lhs, const char * rhs ) const { \ + return operator()( (lhs expr), rhs ); \ + } \ + template <typename T> \ + bool operator()( const char * lhs, const T & rhs ) const { \ + return operator()( lhs, (rhs expr) ); \ + } \ + template <typename T> \ + bool operator()( const T & lhs, const std::string & rhs ) const { \ + return operator()( (lhs expr), rhs ); \ + } \ + template <typename T> \ + bool operator()( const std::string & lhs, const T & rhs ) const { \ + return operator()( lhs, (rhs expr) ); \ + } \ + } + +#define GPGMEPP_MAKE_STRCMP( Name, expr ) \ + _GPGMEPP_MAKE_STRCMP( Name, expr, _gpgmepp_strcmp( lhs, rhs ) ) + + +#endif // __GPGMEPP_GLOBAL_H__ diff --git a/lang/cpp/src/gpgadduserideditinteractor.cpp b/lang/cpp/src/gpgadduserideditinteractor.cpp new file mode 100644 index 00000000..43c8592e --- /dev/null +++ b/lang/cpp/src/gpgadduserideditinteractor.cpp @@ -0,0 +1,189 @@ +/* + gpgadduserideditinteractor.cpp - Edit Interactor to add a new UID to an OpenPGP key + Copyright (C) 2008 Klarälvdalens Datakonsult AB + + This file is part of GPGME++. + + GPGME++ is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + GPGME++ is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Library General Public License for more details. + + You should have received a copy of the GNU Library General Public License + along with GPGME++; see the file COPYING.LIB. If not, write to the + Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. +*/ + +#include "gpgadduserideditinteractor.h" + +#include "error.h" + +#include <gpgme.h> + +#include <cstring> + +using std::strcmp; + +// avoid conflict (msvc) +#ifdef ERROR +# undef ERROR +#endif + +using namespace GpgME; + +GpgAddUserIDEditInteractor::GpgAddUserIDEditInteractor() + : EditInteractor(), + m_name(), + m_email(), + m_comment() +{ + +} + +GpgAddUserIDEditInteractor::~GpgAddUserIDEditInteractor() {} + +void GpgAddUserIDEditInteractor::setNameUtf8(const std::string &name) +{ + m_name = name; +} + +void GpgAddUserIDEditInteractor::setEmailUtf8(const std::string &email) +{ + m_email = email; +} + +void GpgAddUserIDEditInteractor::setCommentUtf8(const std::string &comment) +{ + m_comment = comment; +} + +// work around --enable-final +namespace GpgAddUserIDEditInteractor_Private +{ +enum { + START = EditInteractor::StartState, + COMMAND, + NAME, + EMAIL, + COMMENT, + QUIT, + SAVE, + + ERROR = EditInteractor::ErrorState +}; +} + +const char *GpgAddUserIDEditInteractor::action(Error &err) const +{ + + using namespace GpgAddUserIDEditInteractor_Private; + + switch (state()) { + case COMMAND: + return "adduid"; + case NAME: + return m_name.c_str(); + case EMAIL: + return m_email.c_str(); + case COMMENT: + return m_comment.c_str(); + case QUIT: + return "quit"; + case SAVE: + return "Y"; + case START: + case ERROR: + return 0; + default: + err = Error::fromCode(GPG_ERR_GENERAL); + return 0; + } +} + +unsigned int GpgAddUserIDEditInteractor::nextState(unsigned int status, const char *args, Error &err) const +{ + + static const Error GENERAL_ERROR = Error::fromCode(GPG_ERR_GENERAL); + static const Error INV_NAME_ERROR = Error::fromCode(GPG_ERR_INV_NAME); + static const Error INV_EMAIL_ERROR = Error::fromCode(GPG_ERR_INV_USER_ID); + static const Error INV_COMMENT_ERROR = Error::fromCode(GPG_ERR_INV_USER_ID); + + if (needsNoResponse(status)) { + return state(); + } + + using namespace GpgAddUserIDEditInteractor_Private; + + switch (state()) { + case START: + if (status == GPGME_STATUS_GET_LINE && + strcmp(args, "keyedit.prompt") == 0) { + return COMMAND; + } + err = GENERAL_ERROR; + return ERROR; + case COMMAND: + if (status == GPGME_STATUS_GET_LINE && + strcmp(args, "keygen.name") == 0) { + return NAME; + } + err = GENERAL_ERROR; + return ERROR; + case NAME: + if (status == GPGME_STATUS_GET_LINE && + strcmp(args, "keygen.email") == 0) { + return EMAIL; + } + err = GENERAL_ERROR; + if (status == GPGME_STATUS_GET_LINE && + strcmp(args, "keygen.name") == 0) { + err = INV_NAME_ERROR; + } + return ERROR; + case EMAIL: + if (status == GPGME_STATUS_GET_LINE && + strcmp(args, "keygen.comment") == 0) { + return COMMENT; + } + err = GENERAL_ERROR; + if (status == GPGME_STATUS_GET_LINE && + strcmp(args, "keygen.email") == 0) { + err = INV_EMAIL_ERROR; + } + return ERROR; + case COMMENT: + if (status == GPGME_STATUS_GET_LINE && + strcmp(args, "keyedit.prompt") == 0) { + return QUIT; + } + err = GENERAL_ERROR; + if (status == GPGME_STATUS_GET_LINE && + strcmp(args, "keygen.comment") == 0) { + err = INV_COMMENT_ERROR; + } + return ERROR; + case QUIT: + if (status == GPGME_STATUS_GET_BOOL && + strcmp(args, "keyedit.save.okay") == 0) { + return SAVE; + } + err = GENERAL_ERROR; + return ERROR; + case ERROR: + if (status == GPGME_STATUS_GET_LINE && + strcmp(args, "keyedit.prompt") == 0) { + return QUIT; + } + err = lastError(); + return ERROR; + default: + err = GENERAL_ERROR; + return ERROR; + } +} diff --git a/lang/cpp/src/gpgadduserideditinteractor.h b/lang/cpp/src/gpgadduserideditinteractor.h new file mode 100644 index 00000000..12b6e46a --- /dev/null +++ b/lang/cpp/src/gpgadduserideditinteractor.h @@ -0,0 +1,67 @@ +/* + gpgadduserideditinteractor.h - Edit Interactor to add a new UID to an OpenPGP key + Copyright (C) 2008 Klarälvdalens Datakonsult AB + + This file is part of GPGME++. + + GPGME++ is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + GPGME++ is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Library General Public License for more details. + + You should have received a copy of the GNU Library General Public License + along with GPGME++; see the file COPYING.LIB. If not, write to the + Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. +*/ + +#ifndef __GPGMEPP_GPGADDUSERIDEDITINTERACTOR_H__ +#define __GPGMEPP_GPGADDUSERIDEDITINTERACTOR_H__ + +#include <editinteractor.h> + +#include <string> + +namespace GpgME +{ + +class GPGMEPP_EXPORT GpgAddUserIDEditInteractor : public EditInteractor +{ +public: + explicit GpgAddUserIDEditInteractor(); + ~GpgAddUserIDEditInteractor(); + + void setNameUtf8(const std::string &name); + const std::string &nameUtf8() const + { + return m_name; + } + + void setEmailUtf8(const std::string &email); + const std::string &emailUtf8() const + { + return m_email; + } + + void setCommentUtf8(const std::string &comment); + const std::string &commentUtf8() const + { + return m_comment; + } + +private: + /* reimp */ const char *action(Error &err) const; + /* reimp */ unsigned int nextState(unsigned int statusCode, const char *args, Error &err) const; + +private: + std::string m_name, m_email, m_comment; +}; + +} // namespace GpgME + +#endif // __GPGMEPP_GPGADDUSERIDEDITINTERACTOR_H__ diff --git a/lang/cpp/src/gpgagentgetinfoassuantransaction.cpp b/lang/cpp/src/gpgagentgetinfoassuantransaction.cpp new file mode 100644 index 00000000..4739aa29 --- /dev/null +++ b/lang/cpp/src/gpgagentgetinfoassuantransaction.cpp @@ -0,0 +1,119 @@ +/* + gpgagentgetinfoassuantransaction.cpp - Assuan Transaction to get information from gpg-agent + Copyright (C) 2009 Klarälvdalens Datakonsult AB + + This file is part of GPGME++. + + GPGME++ is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + GPGME++ is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Library General Public License for more details. + + You should have received a copy of the GNU Library General Public License + along with GPGME++; see the file COPYING.LIB. If not, write to the + Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. +*/ + +#include "gpgagentgetinfoassuantransaction.h" +#include "error.h" +#include "data.h" +#include "util.h" + +#include <assert.h> + +#include <sstream> + +using namespace GpgME; + +GpgAgentGetInfoAssuanTransaction::GpgAgentGetInfoAssuanTransaction(InfoItem item) + : AssuanTransaction(), + m_item(item), + m_command(), + m_data() +{ + +} + +GpgAgentGetInfoAssuanTransaction::~GpgAgentGetInfoAssuanTransaction() {} + +std::string GpgAgentGetInfoAssuanTransaction::version() const +{ + if (m_item == Version) { + return m_data; + } else { + return std::string(); + } +} + +unsigned int GpgAgentGetInfoAssuanTransaction::pid() const +{ + if (m_item == Pid) { + return to_pid(m_data); + } else { + return 0U; + } +} + +std::string GpgAgentGetInfoAssuanTransaction::socketName() const +{ + if (m_item == SocketName) { + return m_data; + } else { + return std::string(); + } +} + +std::string GpgAgentGetInfoAssuanTransaction::sshSocketName() const +{ + if (m_item == SshSocketName) { + return m_data; + } else { + return std::string(); + } +} + +static const char *const gpgagent_getinfo_tokens[] = { + "version", + "pid", + "socket_name", + "ssh_socket_name", + "scd_running", +}; + +void GpgAgentGetInfoAssuanTransaction::makeCommand() const +{ + assert(m_item >= 0); + assert(m_item < LastInfoItem); + m_command = "GETINFO "; + m_command += gpgagent_getinfo_tokens[m_item]; +} + +const char *GpgAgentGetInfoAssuanTransaction::command() const +{ + makeCommand(); + return m_command.c_str(); +} + +Error GpgAgentGetInfoAssuanTransaction::data(const char *data, size_t len) +{ + m_data.append(data, len); + return Error(); +} + +Data GpgAgentGetInfoAssuanTransaction::inquire(const char *name, const char *args, Error &err) +{ + (void)name; (void)args; (void)err; + return Data::null; +} + +Error GpgAgentGetInfoAssuanTransaction::status(const char *status, const char *args) +{ + (void)status; (void)args; + return Error(); +} diff --git a/lang/cpp/src/gpgagentgetinfoassuantransaction.h b/lang/cpp/src/gpgagentgetinfoassuantransaction.h new file mode 100644 index 00000000..9e3e9581 --- /dev/null +++ b/lang/cpp/src/gpgagentgetinfoassuantransaction.h @@ -0,0 +1,73 @@ +/* + gpgagentgetinfoassuantransaction.h - Assuan Transaction to get information from gpg-agent + Copyright (C) 2009 Klarälvdalens Datakonsult AB + + This file is part of GPGME++. + + GPGME++ is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + GPGME++ is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Library General Public License for more details. + + You should have received a copy of the GNU Library General Public License + along with GPGME++; see the file COPYING.LIB. If not, write to the + Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. +*/ + +#ifndef __GPGMEPP_GPGAGENTGETINFOASSUANTRANSACTION_H__ +#define __GPGMEPP_GPGAGENTGETINFOASSUANTRANSACTION_H__ + +#include <interfaces/assuantransaction.h> + +#include <string> +#include <vector> + +namespace GpgME +{ + +class GPGMEPP_EXPORT GpgAgentGetInfoAssuanTransaction : public AssuanTransaction +{ +public: + enum InfoItem { + Version, // string + Pid, // unsigned long + SocketName, // string (path) + SshSocketName, // string (path) + ScdRunning, // (none, returns GPG_ERR_GENERAL when scdaemon isn't running) + //CommandHasOption, // not supported + + LastInfoItem + }; + + explicit GpgAgentGetInfoAssuanTransaction(InfoItem item); + ~GpgAgentGetInfoAssuanTransaction(); + + std::string version() const; + unsigned int pid() const; + std::string socketName() const; + std::string sshSocketName() const; + +private: + /* reimp */ const char *command() const; + /* reimp */ Error data(const char *data, size_t datalen); + /* reimp */ Data inquire(const char *name, const char *args, Error &err); + /* reimp */ Error status(const char *status, const char *args); + +private: + void makeCommand() const; + +private: + InfoItem m_item; + mutable std::string m_command; + std::string m_data; +}; + +} // namespace GpgME + +#endif // __GPGMEPP_GPGAGENTGETINFOASSUANTRANSACTION_H__ diff --git a/lang/cpp/src/gpgmefw.h b/lang/cpp/src/gpgmefw.h new file mode 100644 index 00000000..cbdd444f --- /dev/null +++ b/lang/cpp/src/gpgmefw.h @@ -0,0 +1,70 @@ +/* + 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 Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + GPGME++ is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Library General Public License for more details. + + You should have received a copy of the GNU Library General Public License + along with GPGME++; see the file COPYING.LIB. If not, write to the + Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. +*/ + +#ifndef __GPGMEPP_GPGMEFW_H__ +#define __GPGMEPP_GPGMEFW_H__ + +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; + +struct _gpgme_recipient; +typedef struct _gpgme_recipient *gpgme_recipient_t; + +struct gpgme_conf_opt; +typedef struct gpgme_conf_opt *gpgme_conf_opt_t; + +struct gpgme_conf_comp; +typedef struct gpgme_conf_comp *gpgme_conf_comp_t; + +struct gpgme_conf_arg; +typedef struct gpgme_conf_arg *gpgme_conf_arg_t; + +#endif // __GPGMEPP_GPGMEFW_H__ diff --git a/lang/cpp/src/gpgmepp_export.h b/lang/cpp/src/gpgmepp_export.h new file mode 100644 index 00000000..c24bda02 --- /dev/null +++ b/lang/cpp/src/gpgmepp_export.h @@ -0,0 +1,53 @@ + +#ifndef GPGMEPP_EXPORT_H +#define GPGMEPP_EXPORT_H + +#ifdef GPGMEPP_STATIC_DEFINE +# define GPGMEPP_EXPORT +# define GPGMEPP_NO_EXPORT +#else +# ifndef GPGMEPP_EXPORT +# ifdef BUILDING_GPGMEPP + /* We are building this library */ +# ifdef WIN32 +# define GPGMEPP_EXPORT __declspec(dllexport) +# else +# define GPGMEPP_EXPORT __attribute__((visibility("default"))) +# endif +# else + /* We are using this library */ +# ifdef WIN32 +# define GPGMEPP_EXPORT __declspec(dllimport) +# else +# define GPGMEPP_EXPORT __attribute__((visibility("default"))) +# endif +# endif +# endif + +# ifndef GPGMEPP_NO_EXPORT +# ifdef WIN32 +# define GPGMEPP_NO_EXPORT +# else +# define GPGMEPP_NO_EXPORT __attribute__((visibility("hidden"))) +# endif +# endif +#endif + +#ifndef GPGMEPP_DEPRECATED +# define GPGMEPP_DEPRECATED __attribute__ ((__deprecated__)) +#endif + +#ifndef GPGMEPP_DEPRECATED_EXPORT +# define GPGMEPP_DEPRECATED_EXPORT GPGMEPP_EXPORT GPGMEPP_DEPRECATED +#endif + +#ifndef GPGMEPP_DEPRECATED_NO_EXPORT +# define GPGMEPP_DEPRECATED_NO_EXPORT GPGMEPP_NO_EXPORT GPGMEPP_DEPRECATED +#endif + +#define DEFINE_NO_DEPRECATED 0 +#if DEFINE_NO_DEPRECATED +# define GPGMEPP_NO_DEPRECATED +#endif + +#endif diff --git a/lang/cpp/src/gpgsetexpirytimeeditinteractor.cpp b/lang/cpp/src/gpgsetexpirytimeeditinteractor.cpp new file mode 100644 index 00000000..8af897c3 --- /dev/null +++ b/lang/cpp/src/gpgsetexpirytimeeditinteractor.cpp @@ -0,0 +1,141 @@ +/* + gpgsetexpirytimeeditinteractor.cpp - Edit Interactor to change the expiry time of an OpenPGP key + Copyright (C) 2007 Klarälvdalens Datakonsult AB + + This file is part of GPGME++. + + GPGME++ is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + GPGME++ is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Library General Public License for more details. + + You should have received a copy of the GNU Library General Public License + along with GPGME++; see the file COPYING.LIB. If not, write to the + Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. +*/ + +#include "gpgsetexpirytimeeditinteractor.h" +#include "error.h" + +#include <gpgme.h> + +#include <cstring> + +using std::strcmp; + +// avoid conflict (msvc) +#ifdef ERROR +# undef ERROR +#endif + +using namespace GpgME; + +GpgSetExpiryTimeEditInteractor::GpgSetExpiryTimeEditInteractor(const std::string &t) + : EditInteractor(), + m_strtime(t) +{ + +} + +GpgSetExpiryTimeEditInteractor::~GpgSetExpiryTimeEditInteractor() {} + +// work around --enable-final +namespace GpgSetExpiryTimeEditInteractor_Private +{ +enum { + START = EditInteractor::StartState, + COMMAND, + DATE, + QUIT, + SAVE, + + ERROR = EditInteractor::ErrorState +}; +} + +const char *GpgSetExpiryTimeEditInteractor::action(Error &err) const +{ + + using namespace GpgSetExpiryTimeEditInteractor_Private; + + switch (state()) { + case COMMAND: + return "expire"; + case DATE: + return m_strtime.c_str(); + case QUIT: + return "quit"; + case SAVE: + return "Y"; + case START: + case ERROR: + return 0; + default: + err = Error::fromCode(GPG_ERR_GENERAL); + return 0; + } +} + +unsigned int GpgSetExpiryTimeEditInteractor::nextState(unsigned int status, const char *args, Error &err) const +{ + + static const Error GENERAL_ERROR = Error::fromCode(GPG_ERR_GENERAL); + static const Error INV_TIME_ERROR = Error::fromCode(GPG_ERR_INV_TIME); + + if (needsNoResponse(status)) { + return state(); + } + + using namespace GpgSetExpiryTimeEditInteractor_Private; + + switch (state()) { + case START: + if (status == GPGME_STATUS_GET_LINE && + strcmp(args, "keyedit.prompt") == 0) { + return COMMAND; + } + err = GENERAL_ERROR; + return ERROR; + case COMMAND: + if (status == GPGME_STATUS_GET_LINE && + strcmp(args, "keygen.valid") == 0) { + return DATE; + } + err = GENERAL_ERROR; + return ERROR; + case DATE: + if (status == GPGME_STATUS_GET_LINE && + strcmp(args, "keyedit.prompt") == 0) { + return QUIT; + } else if (status == GPGME_STATUS_GET_LINE && + strcmp(args, "keygen.valid")) { + err = INV_TIME_ERROR; + return ERROR; + } + err = GENERAL_ERROR; + return ERROR; + case QUIT: + if (status == GPGME_STATUS_GET_BOOL && + strcmp(args, "keyedit.save.okay") == 0) { + return SAVE; + } + err = GENERAL_ERROR; + return ERROR; + case ERROR: + if (status == GPGME_STATUS_GET_LINE && + strcmp(args, "keyedit.prompt") == 0) { + return QUIT; + } + err = lastError(); + return ERROR; + default: + err = GENERAL_ERROR; + return ERROR; + } +} diff --git a/lang/cpp/src/gpgsetexpirytimeeditinteractor.h b/lang/cpp/src/gpgsetexpirytimeeditinteractor.h new file mode 100644 index 00000000..670b4459 --- /dev/null +++ b/lang/cpp/src/gpgsetexpirytimeeditinteractor.h @@ -0,0 +1,49 @@ +/* + gpgsetexpirytimeeditinteractor.h - Edit Interactor to change the expiry time of an OpenPGP key + Copyright (C) 2007 Klarälvdalens Datakonsult AB + + This file is part of GPGME++. + + GPGME++ is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + GPGME++ is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Library General Public License for more details. + + You should have received a copy of the GNU Library General Public License + along with GPGME++; see the file COPYING.LIB. If not, write to the + Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. +*/ + +#ifndef __GPGMEPP_GPGSETEXPIRYTIMEEDITINTERACTOR_H__ +#define __GPGMEPP_GPGSETEXPIRYTIMEEDITINTERACTOR_H__ + +#include <editinteractor.h> + +#include <string> + +namespace GpgME +{ + +class GPGMEPP_EXPORT GpgSetExpiryTimeEditInteractor : public EditInteractor +{ +public: + explicit GpgSetExpiryTimeEditInteractor(const std::string &timeString = "0"); + ~GpgSetExpiryTimeEditInteractor(); + +private: + /* reimp */ const char *action(Error &err) const; + /* reimp */ unsigned int nextState(unsigned int statusCode, const char *args, Error &err) const; + +private: + const std::string m_strtime; +}; + +} // namespace GpgME + +#endif // __GPGMEPP_GPGSETEXPIRYTIMEEDITINTERACTOR_H___ diff --git a/lang/cpp/src/gpgsetownertrusteditinteractor.cpp b/lang/cpp/src/gpgsetownertrusteditinteractor.cpp new file mode 100644 index 00000000..15b12699 --- /dev/null +++ b/lang/cpp/src/gpgsetownertrusteditinteractor.cpp @@ -0,0 +1,151 @@ +/* + gpgsetownertrusteditinteractor.cpp - Edit Interactor to change the expiry time of an OpenPGP key + Copyright (C) 2007 Klarälvdalens Datakonsult AB + + This file is part of GPGME++. + + GPGME++ is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + GPGME++ is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Library General Public License for more details. + + You should have received a copy of the GNU Library General Public License + along with GPGME++; see the file COPYING.LIB. If not, write to the + Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. +*/ + +#include "gpgsetownertrusteditinteractor.h" +#include "error.h" + +#include <gpgme.h> + +#include <cstring> + +using std::strcmp; + +// avoid conflict (msvc) +#ifdef ERROR +# undef ERROR +#endif + +using namespace GpgME; + +GpgSetOwnerTrustEditInteractor::GpgSetOwnerTrustEditInteractor(Key::OwnerTrust ot) + : EditInteractor(), + m_ownertrust(ot) +{ + +} + +GpgSetOwnerTrustEditInteractor::~GpgSetOwnerTrustEditInteractor() {} + +// work around --enable-final +namespace GpgSetOwnerTrustEditInteractor_Private +{ +enum { + START = EditInteractor::StartState, + COMMAND, + VALUE, + REALLY_ULTIMATE, + QUIT, + SAVE, + + ERROR = EditInteractor::ErrorState +}; +} + +const char *GpgSetOwnerTrustEditInteractor::action(Error &err) const +{ + static const char truststrings[][2] = { "1", "1", "2", "3", "4", "5" }; + + using namespace GpgSetOwnerTrustEditInteractor_Private; + + switch (state()) { + case COMMAND: + return "trust"; + case VALUE: + return truststrings[m_ownertrust]; + case REALLY_ULTIMATE: + return "Y"; + case QUIT: + return "quit"; + case SAVE: + return "Y"; + case START: + case ERROR: + return 0; + default: + err = Error::fromCode(GPG_ERR_GENERAL); + return 0; + } +} + +unsigned int GpgSetOwnerTrustEditInteractor::nextState(unsigned int status, const char *args, Error &err) const +{ + + static const Error GENERAL_ERROR = Error::fromCode(GPG_ERR_GENERAL); + //static const Error INV_TIME_ERROR = Error::fromCode( GPG_ERR_INV_TIME ); + + if (needsNoResponse(status)) { + return state(); + } + + using namespace GpgSetOwnerTrustEditInteractor_Private; + + switch (state()) { + case START: + if (status == GPGME_STATUS_GET_LINE && + strcmp(args, "keyedit.prompt") == 0) { + return COMMAND; + } + err = GENERAL_ERROR; + return ERROR; + case COMMAND: + if (status == GPGME_STATUS_GET_LINE && + strcmp(args, "edit_ownertrust.value") == 0) { + return VALUE; + } + err = GENERAL_ERROR; + return ERROR; + case VALUE: + if (status == GPGME_STATUS_GET_LINE && + strcmp(args, "keyedit.prompt") == 0) { + return QUIT; + } else if (status == GPGME_STATUS_GET_BOOL && + strcmp(args, "edit_ownertrust.set_ultimate.okay") == 0) { + return REALLY_ULTIMATE; + } + err = GENERAL_ERROR; + return ERROR; + case REALLY_ULTIMATE: + if (status == GPGME_STATUS_GET_LINE && + strcmp(args, "keyedit.prompt") == 0) { + return QUIT; + } + err = GENERAL_ERROR; + return ERROR; + case QUIT: + if (status == GPGME_STATUS_GET_BOOL && + strcmp(args, "keyedit.save.okay") == 0) { + return SAVE; + } + err = GENERAL_ERROR; + return ERROR; + case ERROR: + if (status == GPGME_STATUS_GET_LINE && + strcmp(args, "keyedit.prompt") == 0) { + return QUIT; + } + err = lastError(); + return ERROR; + default: + err = GENERAL_ERROR; + return ERROR; + }; +} diff --git a/lang/cpp/src/gpgsetownertrusteditinteractor.h b/lang/cpp/src/gpgsetownertrusteditinteractor.h new file mode 100644 index 00000000..caf29eed --- /dev/null +++ b/lang/cpp/src/gpgsetownertrusteditinteractor.h @@ -0,0 +1,50 @@ +/* + gpgsetownertrusteditinteractor.h - Edit Interactor to change the owner trust of an OpenPGP key + Copyright (C) 2007 Klarälvdalens Datakonsult AB + + This file is part of GPGME++. + + GPGME++ is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + GPGME++ is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Library General Public License for more details. + + You should have received a copy of the GNU Library General Public License + along with GPGME++; see the file COPYING.LIB. If not, write to the + Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. +*/ + +#ifndef __GPGMEPP_GPGSETOWNERTRUSTEDITINTERACTOR_H__ +#define __GPGMEPP_GPGSETOWNERTRUSTEDITINTERACTOR_H__ + +#include <editinteractor.h> +#include <key.h> + +#include <string> + +namespace GpgME +{ + +class GPGMEPP_EXPORT GpgSetOwnerTrustEditInteractor : public EditInteractor +{ +public: + explicit GpgSetOwnerTrustEditInteractor(Key::OwnerTrust ownertrust); + ~GpgSetOwnerTrustEditInteractor(); + +private: + /* reimp */ const char *action(Error &err) const; + /* reimp */ unsigned int nextState(unsigned int statusCode, const char *args, Error &err) const; + +private: + const Key::OwnerTrust m_ownertrust; +}; + +} // namespace GpgME + +#endif // __GPGMEPP_GPGSETOWNERTRUSTEDITINTERACTOR_H__ diff --git a/lang/cpp/src/gpgsignkeyeditinteractor.cpp b/lang/cpp/src/gpgsignkeyeditinteractor.cpp new file mode 100644 index 00000000..fded90f8 --- /dev/null +++ b/lang/cpp/src/gpgsignkeyeditinteractor.cpp @@ -0,0 +1,318 @@ +/* + gpgsignkeyeditinteractor.cpp - Edit Interactor to change the expiry time of an OpenPGP key + Copyright (C) 2007 Klarälvdalens Datakonsult AB + + This file is part of GPGME++. + + GPGME++ is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + GPGME++ is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Library General Public License for more details. + + You should have received a copy of the GNU Library General Public License + along with GPGME++; see the file COPYING.LIB. If not, write to the + Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. +*/ + +#include "gpgsignkeyeditinteractor.h" +#include "error.h" +#include "key.h" + +#include <gpgme.h> + +#include <map> +#include <string> +#include <sstream> + +#include <cassert> +#include <cstring> + +using std::strcmp; + +// avoid conflict (msvc) +#ifdef ERROR +# undef ERROR +#endif + +#ifdef _MSC_VER +#undef snprintf +#define snprintf _snprintf +#endif + +using namespace GpgME; + +class GpgSignKeyEditInteractor::Private +{ +public: + Private(); + + std::string scratch; + bool started; + int options; + std::vector<unsigned int> userIDs; + std::vector<unsigned int>::const_iterator currentId, nextId; + unsigned int checkLevel; + + const char *command() const + { + const bool local = (options & Exportable) == 0; + const bool nonRevoc = options & NonRevocable; + const bool trust = options & Trust; + //TODO: check if all combinations are valid + if (local && nonRevoc && trust) { + return "ltnrsign"; + } + if (local && nonRevoc) { + return "lnrsign"; + } + if (local && trust) { + return "ltsign"; + } + if (local) { + return "lsign"; + } + if (nonRevoc && trust) { + return "tnrsign"; + } + if (nonRevoc) { + return "nrsign"; + } + if (trust) { + return "tsign"; + } + return "sign"; + } + + bool signAll() const + { + return userIDs.empty(); + } + unsigned int nextUserID() + { + assert(nextId != userIDs.end()); + currentId = nextId++; + return currentUserID(); + } + + bool allUserIDsListed() const + { + return nextId == userIDs.end(); + } + + unsigned int currentUserID() const + { + assert(currentId != userIDs.end()); + return *currentId + 1; + } + +}; + +GpgSignKeyEditInteractor::Private::Private() + : + started(false), + options(0), + userIDs(), + currentId(), + nextId(), + checkLevel(0) +{ +} + +GpgSignKeyEditInteractor::GpgSignKeyEditInteractor() + : EditInteractor(), d(new Private) +{ + +} + +GpgSignKeyEditInteractor::~GpgSignKeyEditInteractor() +{ + delete d; +} + +// work around --enable-final +namespace GpgSignKeyEditInteractor_Private +{ +enum SignKeyState { + START = EditInteractor::StartState, + COMMAND, + UIDS_ANSWER_SIGN_ALL, + UIDS_LIST_SEPARATELY, + // all these free slots belong to UIDS_LIST_SEPARATELY, too + // (we increase state() by one for each UID, so that action() is called) + UIDS_LIST_SEPARATELY_DONE = 1000000, + SET_EXPIRE, + SET_CHECK_LEVEL, + SET_TRUST_VALUE, + SET_TRUST_DEPTH, + SET_TRUST_REGEXP, + CONFIRM, + QUIT, + SAVE, + ERROR = EditInteractor::ErrorState +}; + +typedef std::map<std::tuple<SignKeyState, unsigned int, std::string>, SignKeyState> TransitionMap; + +} + +static const char *answer(bool b) +{ + return b ? "Y" : "N"; +} + +static GpgSignKeyEditInteractor_Private::TransitionMap makeTable() +{ + using namespace GpgSignKeyEditInteractor_Private; + TransitionMap tab; + const unsigned int GET_BOOL = GPGME_STATUS_GET_BOOL; + const unsigned int GET_LINE = GPGME_STATUS_GET_LINE; +#define addEntry( s1, status, str, s2 ) tab[std::make_tuple( s1, status, str)] = s2 + addEntry(START, GET_LINE, "keyedit.prompt", COMMAND); + addEntry(COMMAND, GET_BOOL, "keyedit.sign_all.okay", UIDS_ANSWER_SIGN_ALL); + addEntry(COMMAND, GET_BOOL, "sign_uid.okay", CONFIRM); + addEntry(UIDS_ANSWER_SIGN_ALL, GET_BOOL, "sign_uid.okay", CONFIRM); + addEntry(UIDS_ANSWER_SIGN_ALL, GET_LINE, "sign_uid.expire", SET_EXPIRE); + addEntry(UIDS_ANSWER_SIGN_ALL, GET_LINE, "sign_uid.class", SET_CHECK_LEVEL); + addEntry(SET_TRUST_VALUE, GET_LINE, "trustsign_prompt.trust_depth", SET_TRUST_DEPTH); + addEntry(SET_TRUST_DEPTH, GET_LINE, "trustsign_prompt.trust_regexp", SET_TRUST_REGEXP); + addEntry(SET_TRUST_REGEXP, GET_LINE, "sign_uid.okay", CONFIRM); + addEntry(SET_CHECK_LEVEL, GET_BOOL, "sign_uid.okay", CONFIRM); + addEntry(SET_EXPIRE, GET_BOOL, "sign_uid.class", SET_CHECK_LEVEL); + addEntry(CONFIRM, GET_BOOL, "sign_uid.local_promote_okay", CONFIRM); + addEntry(CONFIRM, GET_BOOL, "sign_uid.okay", CONFIRM); + addEntry(CONFIRM, GET_LINE, "keyedit.prompt", COMMAND); + addEntry(CONFIRM, GET_LINE, "trustsign_prompt.trust_value", SET_TRUST_VALUE); + addEntry(CONFIRM, GET_LINE, "sign_uid.expire", SET_EXPIRE); + addEntry(CONFIRM, GET_LINE, "sign_uid.class", SET_CHECK_LEVEL); + addEntry(UIDS_LIST_SEPARATELY_DONE, GET_BOOL, "sign_uid.local_promote_okay", CONFIRM); + addEntry(UIDS_LIST_SEPARATELY_DONE, GET_LINE, "keyedit.prompt", COMMAND); + addEntry(UIDS_LIST_SEPARATELY_DONE, GET_LINE, "trustsign_prompt.trust_value", SET_TRUST_VALUE); + addEntry(UIDS_LIST_SEPARATELY_DONE, GET_LINE, "sign_uid.expire", SET_EXPIRE); + addEntry(UIDS_LIST_SEPARATELY_DONE, GET_LINE, "sign_uid.class", SET_CHECK_LEVEL); + addEntry(UIDS_LIST_SEPARATELY_DONE, GET_BOOL, "sign_uid.okay", CONFIRM); + addEntry(CONFIRM, GET_LINE, "keyedit.prompt", QUIT); + addEntry(ERROR, GET_LINE, "keyedit.prompt", QUIT); + addEntry(QUIT, GET_BOOL, "keyedit.save.okay", SAVE); +#undef addEntry + return tab; +} + +const char *GpgSignKeyEditInteractor::action(Error &err) const +{ + static const char check_level_strings[][2] = { "0", "1", "2", "3" }; + using namespace GpgSignKeyEditInteractor_Private; + using namespace std; + + switch (const unsigned int st = state()) { + case COMMAND: + return d->command(); + case UIDS_ANSWER_SIGN_ALL: + return answer(d->signAll()); + case UIDS_LIST_SEPARATELY_DONE: + return d->command(); + case SET_EXPIRE: + return answer(true); + case SET_TRUST_VALUE: + // TODO + case SET_TRUST_DEPTH: + //TODO + case SET_TRUST_REGEXP: + //TODO + return 0; + case SET_CHECK_LEVEL: + return check_level_strings[d->checkLevel]; + case CONFIRM: + return answer(true); + case QUIT: + return "quit"; + case SAVE: + return answer(true); + default: + if (st >= UIDS_LIST_SEPARATELY && st < UIDS_LIST_SEPARATELY_DONE) { + std::stringstream ss; + ss << d->nextUserID(); + d->scratch = ss.str(); + return d->scratch.c_str(); + } + // fall through + case ERROR: + err = Error::fromCode(GPG_ERR_GENERAL); + return 0; + } +} + +unsigned int GpgSignKeyEditInteractor::nextState(unsigned int status, const char *args, Error &err) const +{ + d->started = true; + using namespace GpgSignKeyEditInteractor_Private; + static const Error GENERAL_ERROR = Error::fromCode(GPG_ERR_GENERAL); + //static const Error INV_TIME_ERROR = Error::fromCode( GPG_ERR_INV_TIME ); + static const TransitionMap table(makeTable()); + if (needsNoResponse(status)) { + return state(); + } + + using namespace GpgSignKeyEditInteractor_Private; + + //lookup transition in map + const TransitionMap::const_iterator it = table.find(std::make_tuple(static_cast<SignKeyState>(state()), status, std::string(args))); + if (it != table.end()) { + return it->second; + } + + //handle cases that cannot be handled via the map + switch (const unsigned int st = state()) { + case UIDS_ANSWER_SIGN_ALL: + if (status == GPGME_STATUS_GET_LINE && + strcmp(args, "keyedit.prompt") == 0) { + if (!d->signAll()) { + return UIDS_LIST_SEPARATELY; + } + err = Error::fromCode(GPG_ERR_UNUSABLE_PUBKEY); + return ERROR; + } + break; + default: + if (st >= UIDS_LIST_SEPARATELY && st < UIDS_LIST_SEPARATELY_DONE) { + if (status == GPGME_STATUS_GET_LINE && + strcmp(args, "keyedit.prompt") == 0) { + return d->allUserIDsListed() ? UIDS_LIST_SEPARATELY_DONE : st + 1 ; + } + } + break; + case CONFIRM: + case ERROR: + err = lastError(); + return ERROR; + } + + err = GENERAL_ERROR; + return ERROR; +} + +void GpgSignKeyEditInteractor::setCheckLevel(unsigned int checkLevel) +{ + assert(!d->started); + assert(checkLevel <= 3); + d->checkLevel = checkLevel; +} + +void GpgSignKeyEditInteractor::setUserIDsToSign(const std::vector<unsigned int> &userIDsToSign) +{ + assert(!d->started); + d->userIDs = userIDsToSign; + d->nextId = d->userIDs.begin(); + d->currentId = d->userIDs.end(); + +} +void GpgSignKeyEditInteractor::setSigningOptions(int options) +{ + assert(!d->started); + d->options = options; +} diff --git a/lang/cpp/src/gpgsignkeyeditinteractor.h b/lang/cpp/src/gpgsignkeyeditinteractor.h new file mode 100644 index 00000000..47ff8e55 --- /dev/null +++ b/lang/cpp/src/gpgsignkeyeditinteractor.h @@ -0,0 +1,64 @@ +/* + gpgsignkeyeditinteractor.h - Edit Interactor to change the owner trust of an OpenPGP key + Copyright (C) 2008 Klarälvdalens Datakonsult AB + + This file is part of GPGME++. + + GPGME++ is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + GPGME++ is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Library General Public License for more details. + + You should have received a copy of the GNU Library General Public License + along with GPGME++; see the file COPYING.LIB. If not, write to the + Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. +*/ + +#ifndef __GPGMEPP_GPGSIGNKEYEDITINTERACTOR_H__ +#define __GPGMEPP_GPGSIGNKEYEDITINTERACTOR_H__ + +#include <editinteractor.h> + +#include <string> +#include <vector> + +namespace GpgME +{ + +class Key; +class UserID; + +class GPGMEPP_EXPORT GpgSignKeyEditInteractor : public EditInteractor +{ +public: + enum SignOption { + Exportable = 0x1, + NonRevocable = 0x2, + Trust = 0x4 + }; + + GpgSignKeyEditInteractor(); + ~GpgSignKeyEditInteractor(); + + void setCheckLevel(unsigned int checkLevel); + void setUserIDsToSign(const std::vector<unsigned int> &userIDsToSign); + void setSigningOptions(int options); + +private: + /* reimp */ const char *action(Error &err) const; + /* reimp */ unsigned int nextState(unsigned int statusCode, const char *args, Error &err) const; + +private: + class Private; + Private *const d; +}; + +} // namespace GpgME + +#endif // __GPGMEPP_GPGSIGNKEYEDITINTERACTOR_H__ diff --git a/lang/cpp/src/importresult.cpp b/lang/cpp/src/importresult.cpp new file mode 100644 index 00000000..97e82399 --- /dev/null +++ b/lang/cpp/src/importresult.cpp @@ -0,0 +1,215 @@ +/* + 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 Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + GPGME++ is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Library General Public License for more details. + + You should have received a copy of the GNU Library General Public License + along with GPGME++; see the file COPYING.LIB. If not, write to the + Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. +*/ + + +#include <importresult.h> +#include "result_p.h" + +#include <gpgme.h> +#include <cstdlib> +#include <cstring> + +#include <string.h> + +class GpgME::ImportResult::Private +{ +public: + Private(const _gpgme_op_import_result &r) : 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() +{ + init(ctx); +} + +GpgME::ImportResult::ImportResult(gpgme_ctx_t ctx, const Error &error) + : GpgME::Result(error), d() +{ + init(ctx); +} + +void GpgME::ImportResult::init(gpgme_ctx_t ctx) +{ + if (!ctx) { + return; + } + gpgme_import_result_t res = gpgme_op_import_result(ctx); + if (!res) { + return; + } + d.reset(new Private(*res)); +} + +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(const std::shared_ptr<ImportResult::Private> &parent, unsigned int i) + : d(parent), idx(i) +{ + +} + +GpgME::Import::Import() : d(), idx(0) {} + +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 Error(isNull() ? 0 : d->imports[idx]->result); +} + +GpgME::Import::Status GpgME::Import::status() const +{ + if (isNull()) { + return Unknown; + } + const 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<Status>(result); +} diff --git a/lang/cpp/src/importresult.h b/lang/cpp/src/importresult.h new file mode 100644 index 00000000..adda80a4 --- /dev/null +++ b/lang/cpp/src/importresult.h @@ -0,0 +1,134 @@ +/* + importresult.h - wraps a gpgme import result + Copyright (C) 2004 Klarälvdalens Datakonsult AB + + This file is part of GPGME++. + + GPGME++ is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + GPGME++ is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Library General Public License for more details. + + You should have received a copy of the GNU Library General Public License + along with GPGME++; see the file COPYING.LIB. If not, write to the + Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. +*/ + +#ifndef __GPGMEPP_IMPORTRESULT_H__ +#define __GPGMEPP_IMPORTRESULT_H__ + +#include "gpgmefw.h" +#include "result.h" +#include "gpgmepp_export.h" + +#include <memory> + +#include <vector> + +namespace GpgME +{ + +class Error; +class Import; + +class GPGMEPP_EXPORT ImportResult : public Result +{ +public: + ImportResult(); + ImportResult(gpgme_ctx_t ctx, int error); + ImportResult(gpgme_ctx_t ctx, const Error &error); + explicit ImportResult(const Error &error); + + const ImportResult &operator=(ImportResult other) + { + swap(other); + return *this; + } + + void swap(ImportResult &other) + { + Result::swap(other); + using std::swap; + swap(this->d, other.d); + } + + bool isNull() const; + + int numConsidered() const; + int numKeysWithoutUserID() const; + int numImported() const; + int numRSAImported() const; + int numUnchanged() const; + + int newUserIDs() const; + int newSubkeys() const; + int newSignatures() const; + int newRevocations() const; + + int numSecretKeysConsidered() const; + int numSecretKeysImported() const; + int numSecretKeysUnchanged() const; + + int notImported() const; + + Import import(unsigned int idx) const; + std::vector<Import> imports() const; + + class Private; +private: + void init(gpgme_ctx_t ctx); + std::shared_ptr<Private> d; +}; + +class GPGMEPP_EXPORT Import +{ + friend class ::GpgME::ImportResult; + Import(const std::shared_ptr<ImportResult::Private> &parent, unsigned int idx); +public: + Import(); + + const Import &operator=(Import other) + { + swap(other); + return *this; + } + + void swap(Import &other) + { + using std::swap; + swap(this->d, other.d); + swap(this->idx, other.idx); + } + + bool isNull() const; + + const char *fingerprint() const; + Error error() const; + + enum Status { + Unknown = 0x0, + NewKey = 0x1, + NewUserIDs = 0x2, + NewSignatures = 0x4, + NewSubkeys = 0x8, + ContainedSecretKey = 0x10 + }; + Status status() const; + +private: + std::shared_ptr<ImportResult::Private> d; + unsigned int idx; +}; + +} + +GPGMEPP_MAKE_STD_SWAP_SPECIALIZATION(ImportResult) +GPGMEPP_MAKE_STD_SWAP_SPECIALIZATION(Import) + +#endif // __GPGMEPP_IMPORTRESULT_H__ diff --git a/lang/cpp/src/interfaces/assuantransaction.h b/lang/cpp/src/interfaces/assuantransaction.h new file mode 100644 index 00000000..a382b058 --- /dev/null +++ b/lang/cpp/src/interfaces/assuantransaction.h @@ -0,0 +1,49 @@ +/* + assuantransaction.h - Interface for ASSUAN transactions + Copyright (C) 2009 Klarälvdalens Datakonsult AB <[email protected]> + Author: Marc Mutz <[email protected]> + + This file is part of GPGME++. + + GPGME++ is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + GPGME++ is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Library General Public License for more details. + + You should have received a copy of the GNU Library General Public License + along with GPGME++; see the file COPYING.LIB. If not, write to the + Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. +*/ + +#ifndef __GPGMEPP_INTERFACES_ASSUANTRANSACTION_H__ +#define __GPGMEPP_INTERFACES_ASSUANTRANSACTION_H__ + +#include "gpgmepp_export.h" + +#include <stddef.h> + +namespace GpgME +{ + +class Error; +class Data; + +class GPGMEPP_EXPORT AssuanTransaction +{ +public: + virtual ~AssuanTransaction() {} + + virtual Error data(const char *data, size_t datalen) = 0; + virtual Data inquire(const char *name, const char *args, Error &err) = 0; + virtual Error status(const char *status, const char *args) = 0; +}; + +} // namespace GpgME + +#endif // __GPGMEPP_INTERFACES_ASSUANTRANSACTION_H__ diff --git a/lang/cpp/src/interfaces/dataprovider.h b/lang/cpp/src/interfaces/dataprovider.h new file mode 100644 index 00000000..166bb4ec --- /dev/null +++ b/lang/cpp/src/interfaces/dataprovider.h @@ -0,0 +1,53 @@ +/* + 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 Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + GPGME++ is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Library General Public License for more details. + + You should have received a copy of the GNU Library General Public License + along with GPGME++; see the file COPYING.LIB. If not, write to the + Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. +*/ + +#ifndef __GPGMEPP_INTERFACES_DATAPROVIDER_H__ +#define __GPGMEPP_INTERFACES_DATAPROVIDER_H__ + +#include <sys/types.h> + +#include "gpgmepp_export.h" + +#include <gpg-error.h> + +namespace GpgME +{ + +class GPGMEPP_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/lang/cpp/src/interfaces/passphraseprovider.h b/lang/cpp/src/interfaces/passphraseprovider.h new file mode 100644 index 00000000..5275e44b --- /dev/null +++ b/lang/cpp/src/interfaces/passphraseprovider.h @@ -0,0 +1,40 @@ +/* + interface/passphraseprovider.h - Interface for passphrase callbacks + Copyright (C) 2003,2004 Klarälvdalens Datakonsult AB + + This file is part of GPGME++. + + GPGME++ is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + GPGME++ is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Library General Public License for more details. + + You should have received a copy of the GNU Library General Public License + along with GPGME++; see the file COPYING.LIB. If not, write to the + Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. +*/ + +#ifndef __GPGMEPP_INTERFACES_PASSPHRASEPROVIDER_H__ +#define __GPGMEPP_INTERFACES_PASSPHRASEPROVIDER_H__ + +namespace GpgME +{ + +class PassphraseProvider +{ +public: + virtual ~PassphraseProvider() {} + + virtual char *getPassphrase(const char *useridHint, const char *description, + bool previousWasBad, bool &canceled) = 0; +}; + +} // namespace GpgME + +#endif // __GPGMEPP_INTERFACES_PASSPHRASEPROVIDER_H__ diff --git a/lang/cpp/src/interfaces/progressprovider.h b/lang/cpp/src/interfaces/progressprovider.h new file mode 100644 index 00000000..78bbdd78 --- /dev/null +++ b/lang/cpp/src/interfaces/progressprovider.h @@ -0,0 +1,40 @@ +/* + interface/progressprovider.h - Interface for progress reports + Copyright (C) 2003 Klarälvdalens Datakonsult AB + + This file is part of GPGME++. + + GPGME++ is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + GPGME++ is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Library General Public License for more details. + + You should have received a copy of the GNU Library General Public License + along with GPGME++; see the file COPYING.LIB. If not, write to the + Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. +*/ + +#ifndef __GPGMEPP_INTERFACES_PROGRESSPROVIDER_H__ +#define __GPGMEPP_INTERFACES_PROGRESSPROVIDER_H__ + +namespace GpgME +{ + +class ProgressProvider +{ +public: + virtual ~ProgressProvider() {} + + virtual void showProgress(const char *what, int type, + int current, int total) = 0; +}; + +} // namespace GpgME + +#endif // __GPGMEPP_INTERFACES_PROGRESSPROVIDER_H__ diff --git a/lang/cpp/src/key.cpp b/lang/cpp/src/key.cpp new file mode 100644 index 00000000..55eb0585 --- /dev/null +++ b/lang/cpp/src/key.cpp @@ -0,0 +1,828 @@ +/* + key.cpp - wraps a gpgme key + Copyright (C) 2003, 2005 Klarälvdalens Datakonsult AB + + This file is part of GPGME++. + + GPGME++ is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + GPGME++ is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Library General Public License for more details. + + You should have received a copy of the GNU Library General Public License + along with GPGME++; see the file COPYING.LIB. If not, write to the + Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. +*/ + +#include <key.h> + +#include "util.h" + +#include <gpgme.h> + +#include <string.h> + +const GpgME::Key::Null GpgME::Key::null; + +namespace GpgME +{ + +Key::Key() : key() {} + +Key::Key(const Null &) : key() {} + +Key::Key(const shared_gpgme_key_t &k) : key(k) {} + +Key::Key(gpgme_key_t k, bool ref) + : key(k + ? shared_gpgme_key_t(k, &gpgme_key_unref) + : shared_gpgme_key_t()) +{ + if (ref && impl()) { + gpgme_key_ref(impl()); + } +} + +UserID Key::userID(unsigned int index) const +{ + return UserID(key, index); +} + +Subkey Key::subkey(unsigned int index) const +{ + return Subkey(key, index); +} + +unsigned int Key::numUserIDs() const +{ + if (!key) { + return 0; + } + unsigned int count = 0; + for (gpgme_user_id_t uid = key->uids ; uid ; uid = uid->next) { + ++count; + } + return count; +} + +unsigned int Key::numSubkeys() const +{ + if (!key) { + return 0; + } + unsigned int count = 0; + for (gpgme_sub_key_t subkey = key->subkeys ; subkey ; subkey = subkey->next) { + ++count; + } + return count; +} + +std::vector<UserID> Key::userIDs() const +{ + if (!key) { + return std::vector<UserID>(); + } + + std::vector<UserID> v; + v.reserve(numUserIDs()); + for (gpgme_user_id_t uid = key->uids ; uid ; uid = uid->next) { + v.push_back(UserID(key, uid)); + } + return v; +} + +std::vector<Subkey> Key::subkeys() const +{ + if (!key) { + return std::vector<Subkey>(); + } + + std::vector<Subkey> v; + v.reserve(numSubkeys()); + for (gpgme_sub_key_t subkey = key->subkeys ; subkey ; subkey = subkey->next) { + v.push_back(Subkey(key, subkey)); + } + return v; +} + +Key::OwnerTrust Key::ownerTrust() const +{ + if (!key) { + return Unknown; + } + switch (key->owner_trust) { + default: + case GPGME_VALIDITY_UNKNOWN: return Unknown; + case GPGME_VALIDITY_UNDEFINED: return Undefined; + case GPGME_VALIDITY_NEVER: return Never; + case GPGME_VALIDITY_MARGINAL: return Marginal; + case GPGME_VALIDITY_FULL: return Full; + case GPGME_VALIDITY_ULTIMATE: return Ultimate; + } +} +char Key::ownerTrustAsString() const +{ + if (!key) { + return '?'; + } + switch (key->owner_trust) { + default: + case GPGME_VALIDITY_UNKNOWN: return '?'; + case GPGME_VALIDITY_UNDEFINED: return 'q'; + case GPGME_VALIDITY_NEVER: return 'n'; + case GPGME_VALIDITY_MARGINAL: return 'm'; + case GPGME_VALIDITY_FULL: return 'f'; + case GPGME_VALIDITY_ULTIMATE: return 'u'; + } +} + +Protocol Key::protocol() const +{ + if (!key) { + return UnknownProtocol; + } + switch (key->protocol) { + case GPGME_PROTOCOL_CMS: return CMS; + case GPGME_PROTOCOL_OpenPGP: return OpenPGP; + default: return UnknownProtocol; + } +} + +const char *Key::protocolAsString() const +{ + return key ? gpgme_get_protocol_name(key->protocol) : 0 ; +} + +bool Key::isRevoked() const +{ + return key && key->revoked; +} + +bool Key::isExpired() const +{ + return key && key->expired; +} + +bool Key::isDisabled() const +{ + return key && key->disabled; +} + +bool Key::isInvalid() const +{ + return key && key->invalid; +} + +bool Key::hasSecret() const +{ + return key && key->secret; +} + +bool Key::isRoot() const +{ + return key && key->subkeys && key->subkeys->fpr && key->chain_id && + strcasecmp(key->subkeys->fpr, key->chain_id) == 0; +} + +bool Key::canEncrypt() const +{ + return key && key->can_encrypt; +} + +bool Key::canSign() const +{ +#ifndef GPGME_CAN_SIGN_ON_SECRET_OPENPGP_KEYLISTING_NOT_BROKEN + if (key && key->protocol == GPGME_PROTOCOL_OpenPGP) { + return true; + } +#endif + return canReallySign(); +} + +bool Key::canReallySign() const +{ + return key && key->can_sign; +} + +bool Key::canCertify() const +{ + return key && key->can_certify; +} + +bool Key::canAuthenticate() const +{ + return key && key->can_authenticate; +} + +bool Key::isQualified() const +{ + return key && key->is_qualified; +} + +const char *Key::issuerSerial() const +{ + return key ? key->issuer_serial : 0 ; +} +const char *Key::issuerName() const +{ + return key ? key->issuer_name : 0 ; +} +const char *Key::chainID() const +{ + return key ? key->chain_id : 0 ; +} + +const char *Key::keyID() const +{ + return key && key->subkeys ? key->subkeys->keyid : 0 ; +} + +const char *Key::shortKeyID() const +{ + if (!key || !key->subkeys || !key->subkeys->keyid) { + return 0; + } + const int len = strlen(key->subkeys->keyid); + if (len > 8) { + return key->subkeys->keyid + len - 8; // return the last 8 bytes (in hex notation) + } else { + return key->subkeys->keyid; + } +} + +const char *Key::primaryFingerprint() const +{ + const char *fpr = key && key->subkeys ? key->subkeys->fpr : 0 ; + if (fpr) { + return fpr; + } else { + return keyID(); + } +} + +unsigned int Key::keyListMode() const +{ + return key ? convert_from_gpgme_keylist_mode_t(key->keylist_mode) : 0 ; +} + +const Key &Key::mergeWith(const Key &other) +{ + // ### incomplete. Just merges has* and can*, nothing else atm + // ### detach also missing + + if (!this->primaryFingerprint() || + !other.primaryFingerprint() || + strcasecmp(this->primaryFingerprint(), other.primaryFingerprint()) != 0) { + return *this; // only merge the Key object which describe the same key + } + + const gpgme_key_t me = impl(); + const gpgme_key_t him = other.impl(); + + if (!me || !him) { + return *this; + } + + me->revoked |= him->revoked; + me->expired |= him->expired; + me->disabled |= him->disabled; + me->invalid |= him->invalid; + me->can_encrypt |= him->can_encrypt; + me->can_sign |= him->can_sign; + me->can_certify |= him->can_certify; + me->secret |= him->secret; + me->can_authenticate |= him->can_authenticate; + me->is_qualified |= him->is_qualified; + me->keylist_mode |= him->keylist_mode; + + // make sure the gpgme_sub_key_t::is_cardkey flag isn't lost: + for (gpgme_sub_key_t mysk = me->subkeys ; mysk ; mysk = mysk->next) { + for (gpgme_sub_key_t hissk = him->subkeys ; hissk ; hissk = hissk->next) { + if (strcmp(mysk->fpr, hissk->fpr) == 0) { + mysk->is_cardkey |= hissk->is_cardkey; + break; + } + } + } + + return *this; +} + +// +// +// class Subkey +// +// + +gpgme_sub_key_t find_subkey(const shared_gpgme_key_t &key, unsigned int idx) +{ + if (key) { + for (gpgme_sub_key_t s = key->subkeys ; s ; s = s->next, --idx) { + if (idx == 0) { + return s; + } + } + } + return 0; +} + +gpgme_sub_key_t verify_subkey(const shared_gpgme_key_t &key, gpgme_sub_key_t subkey) +{ + if (key) { + for (gpgme_sub_key_t s = key->subkeys ; s ; s = s->next) { + if (s == subkey) { + return subkey; + } + } + } + return 0; +} + +Subkey::Subkey() : key(), subkey(0) {} + +Subkey::Subkey(const shared_gpgme_key_t &k, unsigned int idx) + : key(k), subkey(find_subkey(k, idx)) +{ + +} + +Subkey::Subkey(const shared_gpgme_key_t &k, gpgme_sub_key_t sk) + : key(k), subkey(verify_subkey(k, sk)) +{ + +} + +Key Subkey::parent() const +{ + return Key(key); +} + +const char *Subkey::keyID() const +{ + return subkey ? subkey->keyid : 0 ; +} + +const char *Subkey::fingerprint() const +{ + return subkey ? subkey->fpr : 0 ; +} + +unsigned int Subkey::publicKeyAlgorithm() const +{ + return subkey ? subkey->pubkey_algo : 0 ; +} + +const char *Subkey::publicKeyAlgorithmAsString() const +{ + return gpgme_pubkey_algo_name(subkey ? subkey->pubkey_algo : (gpgme_pubkey_algo_t)0); +} + +std::string Subkey::algoName() const +{ + char *gpgmeStr; + if (subkey && (gpgmeStr = gpgme_pubkey_algo_string(subkey))) { + std::string ret = std::string(gpgmeStr); + gpgme_free(gpgmeStr); + return ret; + } + return std::string(); +} + +bool Subkey::canEncrypt() const +{ + return subkey && subkey->can_encrypt; +} + +bool Subkey::canSign() const +{ + return subkey && subkey->can_sign; +} + +bool Subkey::canCertify() const +{ + return subkey && subkey->can_certify; +} + +bool Subkey::canAuthenticate() const +{ + return subkey && subkey->can_authenticate; +} + +bool Subkey::isQualified() const +{ + return subkey && subkey->is_qualified; +} + +bool Subkey::isCardKey() const +{ + return subkey && subkey->is_cardkey; +} + +const char *Subkey::cardSerialNumber() const +{ + return subkey ? subkey->card_number : 0 ; +} + +bool Subkey::isSecret() const +{ + return subkey && subkey->secret; +} + +unsigned int Subkey::length() const +{ + return subkey ? subkey->length : 0 ; +} + +time_t Subkey::creationTime() const +{ + return static_cast<time_t>(subkey ? subkey->timestamp : 0); +} + +time_t Subkey::expirationTime() const +{ + return static_cast<time_t>(subkey ? subkey->expires : 0); +} + +bool Subkey::neverExpires() const +{ + return expirationTime() == time_t(0); +} + +bool Subkey::isRevoked() const +{ + return subkey && subkey->revoked; +} + +bool Subkey::isInvalid() const +{ + return subkey && subkey->invalid; +} + +bool Subkey::isExpired() const +{ + return subkey && subkey->expired; +} + +bool Subkey::isDisabled() const +{ + return subkey && subkey->disabled; +} + +// +// +// class UserID +// +// + +gpgme_user_id_t find_uid(const shared_gpgme_key_t &key, unsigned int idx) +{ + if (key) { + for (gpgme_user_id_t u = key->uids ; u ; u = u->next, --idx) { + if (idx == 0) { + return u; + } + } + } + return 0; +} + +gpgme_user_id_t verify_uid(const shared_gpgme_key_t &key, gpgme_user_id_t uid) +{ + if (key) { + for (gpgme_user_id_t u = key->uids ; u ; u = u->next) { + if (u == uid) { + return uid; + } + } + } + return 0; +} + +UserID::UserID() : key(), uid(0) {} + +UserID::UserID(const shared_gpgme_key_t &k, gpgme_user_id_t u) + : key(k), uid(verify_uid(k, u)) +{ + +} + +UserID::UserID(const shared_gpgme_key_t &k, unsigned int idx) + : key(k), uid(find_uid(k, idx)) +{ + +} + +Key UserID::parent() const +{ + return Key(key); +} + +UserID::Signature UserID::signature(unsigned int index) const +{ + return Signature(key, uid, index); +} + +unsigned int UserID::numSignatures() const +{ + if (!uid) { + return 0; + } + unsigned int count = 0; + for (gpgme_key_sig_t sig = uid->signatures ; sig ; sig = sig->next) { + ++count; + } + return count; +} + +std::vector<UserID::Signature> UserID::signatures() const +{ + if (!uid) { + return std::vector<Signature>(); + } + + std::vector<Signature> v; + v.reserve(numSignatures()); + for (gpgme_key_sig_t sig = uid->signatures ; sig ; sig = sig->next) { + v.push_back(Signature(key, uid, sig)); + } + return v; +} + +const char *UserID::id() const +{ + return uid ? uid->uid : 0 ; +} + +const char *UserID::name() const +{ + return uid ? uid->name : 0 ; +} + +const char *UserID::email() const +{ + return uid ? uid->email : 0 ; +} + +const char *UserID::comment() const +{ + return uid ? uid->comment : 0 ; +} + +UserID::Validity UserID::validity() const +{ + if (!uid) { + return Unknown; + } + switch (uid->validity) { + default: + case GPGME_VALIDITY_UNKNOWN: return Unknown; + case GPGME_VALIDITY_UNDEFINED: return Undefined; + case GPGME_VALIDITY_NEVER: return Never; + case GPGME_VALIDITY_MARGINAL: return Marginal; + case GPGME_VALIDITY_FULL: return Full; + case GPGME_VALIDITY_ULTIMATE: return Ultimate; + } +} + +char UserID::validityAsString() const +{ + if (!uid) { + return '?'; + } + switch (uid->validity) { + default: + case GPGME_VALIDITY_UNKNOWN: return '?'; + case GPGME_VALIDITY_UNDEFINED: return 'q'; + case GPGME_VALIDITY_NEVER: return 'n'; + case GPGME_VALIDITY_MARGINAL: return 'm'; + case GPGME_VALIDITY_FULL: return 'f'; + case GPGME_VALIDITY_ULTIMATE: return 'u'; + } +} + +bool UserID::isRevoked() const +{ + return uid && uid->revoked; +} + +bool UserID::isInvalid() const +{ + return uid && uid->invalid; +} + +// +// +// class Signature +// +// + +gpgme_key_sig_t find_signature(gpgme_user_id_t uid, unsigned int idx) +{ + if (uid) { + for (gpgme_key_sig_t s = uid->signatures ; s ; s = s->next, --idx) { + if (idx == 0) { + return s; + } + } + } + return 0; +} + +gpgme_key_sig_t verify_signature(gpgme_user_id_t uid, gpgme_key_sig_t sig) +{ + if (uid) { + for (gpgme_key_sig_t s = uid->signatures ; s ; s = s->next) { + if (s == sig) { + return sig; + } + } + } + return 0; +} + +UserID::Signature::Signature() : key(), uid(0), sig(0) {} + +UserID::Signature::Signature(const shared_gpgme_key_t &k, gpgme_user_id_t u, unsigned int idx) + : key(k), uid(verify_uid(k, u)), sig(find_signature(uid, idx)) +{ + +} + +UserID::Signature::Signature(const shared_gpgme_key_t &k, gpgme_user_id_t u, gpgme_key_sig_t s) + : key(k), uid(verify_uid(k, u)), sig(verify_signature(uid, s)) +{ + +} + +UserID UserID::Signature::parent() const +{ + return UserID(key, uid); +} + +const char *UserID::Signature::signerKeyID() const +{ + return sig ? sig->keyid : 0 ; +} + +const char *UserID::Signature::algorithmAsString() const +{ + return gpgme_pubkey_algo_name(sig ? sig->pubkey_algo : (gpgme_pubkey_algo_t)0); +} + +unsigned int UserID::Signature::algorithm() const +{ + return sig ? sig->pubkey_algo : 0 ; +} + +time_t UserID::Signature::creationTime() const +{ + return static_cast<time_t>(sig ? sig->timestamp : 0); +} + +time_t UserID::Signature::expirationTime() const +{ + return static_cast<time_t>(sig ? sig->expires : 0); +} + +bool UserID::Signature::neverExpires() const +{ + return expirationTime() == time_t(0); +} + +bool UserID::Signature::isRevokation() const +{ + return sig && sig->revoked; +} + +bool UserID::Signature::isInvalid() const +{ + return sig && sig->invalid; +} + +bool UserID::Signature::isExpired() const +{ + return sig && sig->expired; +} + +bool UserID::Signature::isExportable() const +{ + return sig && sig->exportable; +} + +const char *UserID::Signature::signerUserID() const +{ + return sig ? sig->uid : 0 ; +} + +const char *UserID::Signature::signerName() const +{ + return sig ? sig->name : 0 ; +} + +const char *UserID::Signature::signerEmail() const +{ + return sig ? sig->email : 0 ; +} + +const char *UserID::Signature::signerComment() const +{ + return sig ? sig->comment : 0 ; +} + +unsigned int UserID::Signature::certClass() const +{ + return sig ? sig->sig_class : 0 ; +} + +UserID::Signature::Status UserID::Signature::status() const +{ + if (!sig) { + return GeneralError; + } + + switch (gpgme_err_code(sig->status)) { + case GPG_ERR_NO_ERROR: return NoError; + case GPG_ERR_SIG_EXPIRED: return SigExpired; + case GPG_ERR_KEY_EXPIRED: return KeyExpired; + case GPG_ERR_BAD_SIGNATURE: return BadSignature; + case GPG_ERR_NO_PUBKEY: return NoPublicKey; + default: + case GPG_ERR_GENERAL: return GeneralError; + } +} + +std::string UserID::Signature::statusAsString() const +{ + if (!sig) { + return std::string(); + } + char buf[ 1024 ]; + gpgme_strerror_r(sig->status, buf, sizeof buf); + buf[ sizeof buf - 1 ] = '\0'; + return std::string(buf); +} + +GpgME::Notation UserID::Signature::notation(unsigned int idx) const +{ + if (!sig) { + return GpgME::Notation(); + } + for (gpgme_sig_notation_t nota = sig->notations ; nota ; nota = nota->next) { + if (nota->name) { + if (idx-- == 0) { + return GpgME::Notation(nota); + } + } + } + return GpgME::Notation(); +} + +unsigned int UserID::Signature::numNotations() const +{ + if (!sig) { + return 0; + } + unsigned int count = 0; + for (gpgme_sig_notation_t nota = sig->notations ; nota ; nota = nota->next) { + if (nota->name) { + ++count; // others are policy URLs... + } + } + return count; +} + +std::vector<Notation> UserID::Signature::notations() const +{ + if (!sig) { + return std::vector<GpgME::Notation>(); + } + std::vector<GpgME::Notation> v; + v.reserve(numNotations()); + for (gpgme_sig_notation_t nota = sig->notations ; nota ; nota = nota->next) { + if (nota->name) { + v.push_back(GpgME::Notation(nota)); + } + } + return v; +} + +const char *UserID::Signature::policyURL() const +{ + if (!sig) { + return 0; + } + for (gpgme_sig_notation_t nota = sig->notations ; nota ; nota = nota->next) { + if (!nota->name) { + return nota->value; + } + } + return 0; +} + +} // namespace GpgME diff --git a/lang/cpp/src/key.h b/lang/cpp/src/key.h new file mode 100644 index 00000000..7322f650 --- /dev/null +++ b/lang/cpp/src/key.h @@ -0,0 +1,380 @@ +/* + key.h - wraps a gpgme key + Copyright (C) 2003, 2005 Klarälvdalens Datakonsult AB + + This file is part of GPGME++. + + GPGME++ is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + GPGME++ is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Library General Public License for more details. + + You should have received a copy of the GNU Library General Public License + along with GPGME++; see the file COPYING.LIB. If not, write to the + Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. +*/ + +// -*- c++ -*- +#ifndef __GPGMEPP_KEY_H__ +#define __GPGMEPP_KEY_H__ + +#include "global.h" +#include "notation.h" + +#include "gpgmefw.h" + +#include <memory> +#include <sys/time.h> + +#include <vector> +#include <algorithm> +#include <string> + +namespace GpgME +{ + +class Context; + +class Subkey; +class UserID; + +typedef std::shared_ptr< std::remove_pointer<gpgme_key_t>::type > shared_gpgme_key_t; + +// +// class Key +// + +class GPGMEPP_EXPORT Key +{ + friend class ::GpgME::Context; + struct Null { + Null() {} + }; +public: + Key(); + /* implicit */ Key(const Null &); + Key(const shared_gpgme_key_t &key); + Key(gpgme_key_t key, bool acquireRef); + + static const Null null; + + const Key &operator=(Key other) + { + swap(other); + return *this; + } + + const Key &mergeWith(const Key &other); + + void swap(Key &other) + { + using std::swap; + swap(this->key, other.key); + } + + bool isNull() const + { + return !key; + } + + 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; + /*! + This function contains a workaround for old gpgme's: all secret + OpenPGP keys canSign() == true, which canReallySign() doesn't + have. I don't have time to find what breaks when I remove this + workaround, but since Kleopatra merges secret into public keys, + the workaround is not necessary there (and actively harms), I've + added a new function instead. + */ + bool canSign() const; + bool canReallySign() const; + bool canCertify() const; + bool canAuthenticate() const; + bool isQualified() const; + + bool hasSecret() const; + GPGMEPP_DEPRECATED 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; + + 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; + + unsigned int keyListMode() const; + +private: + gpgme_key_t impl() const + { + return key.get(); + } + shared_gpgme_key_t key; +}; + +// +// class Subkey +// + +class GPGMEPP_EXPORT Subkey +{ +public: + Subkey(); + Subkey(const shared_gpgme_key_t &key, gpgme_sub_key_t subkey); + Subkey(const shared_gpgme_key_t &key, unsigned int idx); + + const Subkey &operator=(Subkey other) + { + swap(other); + return *this; + } + + void swap(Subkey &other) + { + using std::swap; + swap(this->key, other.key); + swap(this->subkey, other.subkey); + } + + bool isNull() const + { + return !key || !subkey; + } + + 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 isQualified() const; + bool isCardKey() const; + + bool isSecret() const; + + unsigned int publicKeyAlgorithm() const; + + /** + @brief Get the public key algorithm name. + + This only works for the pre 2.1 algorithms for ECC NULL is returned. + + @returns a statically allocated string with the name of the public + key algorithm, or NULL if that name is not known. + */ + const char *publicKeyAlgorithmAsString() const; + + /** + @brief Get the key algo string like GnuPG 2.1 prints it. + + This returns combinations of size and algorithm. Like + bp512 or rsa2048 + + @returns the key algorithm as string. Empty string on error. + */ + std::string algoName() const; + + unsigned int length() const; + + const char *cardSerialNumber() const; + +private: + shared_gpgme_key_t key; + gpgme_sub_key_t subkey; +}; + +// +// class UserID +// + +class GPGMEPP_EXPORT UserID +{ +public: + class Signature; + + UserID(); + UserID(const shared_gpgme_key_t &key, gpgme_user_id_t uid); + UserID(const shared_gpgme_key_t &key, unsigned int idx); + + const UserID &operator=(UserID other) + { + swap(other); + return *this; + } + + void swap(UserID &other) + { + using std::swap; + swap(this->key, other.key); + swap(this->uid, other.uid); + } + + bool isNull() const + { + return !key || !uid; + } + + 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: + shared_gpgme_key_t key; + gpgme_user_id_t uid; +}; + +// +// class UserID::Signature +// + +class GPGMEPP_EXPORT UserID::Signature +{ +public: + typedef GPGMEPP_DEPRECATED GpgME::Notation Notation; + + Signature(); + Signature(const shared_gpgme_key_t &key, gpgme_user_id_t uid, gpgme_key_sig_t sig); + Signature(const shared_gpgme_key_t &key, gpgme_user_id_t uid, unsigned int idx); + + const Signature &operator=(Signature other) + { + swap(other); + return *this; + } + + void swap(Signature &other) + { + using std::swap; + swap(this->key, other.key); + swap(this->uid, other.uid); + swap(this->sig, other.sig); + } + + bool isNull() const + { + return !sig || !uid || !key ; + } + + 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 Status { NoError = 0, SigExpired, KeyExpired, + BadSignature, NoPublicKey, GeneralError + }; + Status status() const; + std::string statusAsString() const; + + const char *policyURL() const; + + unsigned int numNotations() const; + GpgME::Notation notation(unsigned int idx) const; + std::vector<GpgME::Notation> notations() const; + +private: + shared_gpgme_key_t key; + gpgme_user_id_t uid; + gpgme_key_sig_t sig; +}; + +} // namespace GpgME + +GPGMEPP_MAKE_STD_SWAP_SPECIALIZATION(Key) +GPGMEPP_MAKE_STD_SWAP_SPECIALIZATION(Subkey) +GPGMEPP_MAKE_STD_SWAP_SPECIALIZATION(UserID) +GPGMEPP_MAKE_STD_SWAP_SPECIALIZATION(UserID::Signature) + +GPGMEPP_MAKE_STRCMP(ByFingerprint, .primaryFingerprint()); +GPGMEPP_MAKE_STRCMP(ByKeyID, .keyID()); +GPGMEPP_MAKE_STRCMP(ByShortKeyID, .shortKeyID()); +GPGMEPP_MAKE_STRCMP(ByChainID, .chainID()); + +#endif // __GPGMEPP_KEY_H__ diff --git a/lang/cpp/src/keygenerationresult.cpp b/lang/cpp/src/keygenerationresult.cpp new file mode 100644 index 00000000..7837e208 --- /dev/null +++ b/lang/cpp/src/keygenerationresult.cpp @@ -0,0 +1,92 @@ +/* + 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 Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + GPGME++ is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Library General Public License for more details. + + You should have received a copy of the GNU Library General Public License + along with GPGME++; see the file COPYING.LIB. If not, write to the + Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. +*/ + +#include <keygenerationresult.h> +#include "result_p.h" + +#include <gpgme.h> + +#include <cstring> +#include <cstdlib> + +#include <string.h> + +class GpgME::KeyGenerationResult::Private +{ +public: + Private(const _gpgme_op_genkey_result &r) : 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() +{ + init(ctx); +} + +GpgME::KeyGenerationResult::KeyGenerationResult(gpgme_ctx_t ctx, const Error &error) + : GpgME::Result(error), d() +{ + init(ctx); +} + +void GpgME::KeyGenerationResult::init(gpgme_ctx_t ctx) +{ + if (!ctx) { + return; + } + gpgme_genkey_result_t res = gpgme_op_genkey_result(ctx); + if (!res) { + return; + } + d.reset(new Private(*res)); +} + +make_standard_stuff(KeyGenerationResult) + +bool GpgME::KeyGenerationResult::isPrimaryKeyGenerated() const +{ + return d && d->res.primary; +} + +bool GpgME::KeyGenerationResult::isSubkeyGenerated() const +{ + return d && d->res.sub; +} + +const char *GpgME::KeyGenerationResult::fingerprint() const +{ + return d ? d->res.fpr : 0 ; +} diff --git a/lang/cpp/src/keygenerationresult.h b/lang/cpp/src/keygenerationresult.h new file mode 100644 index 00000000..c35c5044 --- /dev/null +++ b/lang/cpp/src/keygenerationresult.h @@ -0,0 +1,82 @@ +/* + keygenerationresult.h - wraps a gpgme keygen result + Copyright (C) 2004 Klarälvdalens Datakonsult AB + + This file is part of GPGME++. + + GPGME++ is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + GPGME++ is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Library General Public License for more details. + + You should have received a copy of the GNU Library General Public License + along with GPGME++; see the file COPYING.LIB. If not, write to the + Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. +*/ + +#ifndef __GPGMEPP_KEYGENERATIONRESULT_H__ +#define __GPGMEPP_KEYGENERATIONRESULT_H__ + +#include "gpgmefw.h" +#include "result.h" +#include "gpgmepp_export.h" + +#include <memory> + +namespace GpgME +{ + +class Error; + +class GPGMEPP_EXPORT KeyGenerationResult : public Result +{ +public: + KeyGenerationResult(); + KeyGenerationResult(gpgme_ctx_t ctx, int error); + KeyGenerationResult(gpgme_ctx_t ctx, const Error &error); + explicit KeyGenerationResult(const Error &err); + + const KeyGenerationResult &operator=(KeyGenerationResult other) + { + swap(other); + return *this; + } + + void swap(KeyGenerationResult &other) + { + Result::swap(other); + using std::swap; + swap(this->d, other.d); + } + + bool isNull() const; + + GPGMEPP_DEPRECATED bool primaryKeyGenerated() const + { + return isPrimaryKeyGenerated(); + } + GPGMEPP_DEPRECATED bool subkeyGenerated() const + { + return isSubkeyGenerated(); + } + bool isPrimaryKeyGenerated() const; + bool isSubkeyGenerated() const; + const char *fingerprint() const; + +private: + class Private; + void init(gpgme_ctx_t ctx); + std::shared_ptr<Private> d; +}; + +} + +GPGMEPP_MAKE_STD_SWAP_SPECIALIZATION(KeyGenerationResult) + +#endif // __GPGMEPP_KEYGENERATIONRESULT_H__ diff --git a/lang/cpp/src/keylistresult.cpp b/lang/cpp/src/keylistresult.cpp new file mode 100644 index 00000000..4512d3be --- /dev/null +++ b/lang/cpp/src/keylistresult.cpp @@ -0,0 +1,107 @@ +/* + 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 Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + GPGME++ is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Library General Public License for more details. + + You should have received a copy of the GNU Library General Public License + along with GPGME++; see the file COPYING.LIB. If not, write to the + Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. +*/ + +#include <keylistresult.h> +#include "result_p.h" + +#include <gpgme.h> + +#include <cstring> +#include <cassert> + +class GpgME::KeyListResult::Private +{ +public: + Private(const _gpgme_op_keylist_result &r) : res(r) {} + Private(const Private &other) : res(other.res) {} + + _gpgme_op_keylist_result res; +}; + +GpgME::KeyListResult::KeyListResult(gpgme_ctx_t ctx, int error) + : GpgME::Result(error), d() +{ + init(ctx); +} + +GpgME::KeyListResult::KeyListResult(gpgme_ctx_t ctx, const Error &error) + : GpgME::Result(error), d() +{ + init(ctx); +} + +void GpgME::KeyListResult::init(gpgme_ctx_t ctx) +{ + if (!ctx) { + return; + } + gpgme_keylist_result_t res = gpgme_op_keylist_result(ctx); + if (!res) { + return; + } + d.reset(new Private(*res)); +} + +GpgME::KeyListResult::KeyListResult(const Error &error, const _gpgme_op_keylist_result &res) + : GpgME::Result(error), d(new Private(res)) +{ + +} + +make_standard_stuff(KeyListResult) + +void GpgME::KeyListResult::detach() +{ + if (!d || d.unique()) { + return; + } + d.reset(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.reset(new Private(*other.d)); + } else { + d->res.truncated = true; + } + } + if (! bool(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/lang/cpp/src/keylistresult.h b/lang/cpp/src/keylistresult.h new file mode 100644 index 00000000..7dfe2d71 --- /dev/null +++ b/lang/cpp/src/keylistresult.h @@ -0,0 +1,81 @@ +/* + keylistresult.h - wraps a gpgme keylist result + Copyright (C) 2004 Klarälvdalens Datakonsult AB + + This file is part of GPGME++. + + GPGME++ is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + GPGME++ is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Library General Public License for more details. + + You should have received a copy of the GNU Library General Public License + along with GPGME++; see the file COPYING.LIB. If not, write to the + Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. +*/ + +#ifndef __GPGMEPP_KEYLISTRESULT_H__ +#define __GPGMEPP_KEYLISTRESULT_H__ + +#include "gpgmefw.h" +#include "result.h" +#include "gpgmepp_export.h" + +#include <memory> + +namespace GpgME +{ + +class Error; + +class GPGMEPP_EXPORT KeyListResult : public Result +{ +public: + KeyListResult(); + KeyListResult(gpgme_ctx_t ctx, int error); + KeyListResult(gpgme_ctx_t ctx, const Error &error); + explicit KeyListResult(const Error &err); + KeyListResult(const Error &err, const _gpgme_op_keylist_result &res); + + const KeyListResult &operator=(KeyListResult other) + { + swap(other); + return *this; + } + void swap(KeyListResult &other) + { + Result::swap(other); + using std::swap; + swap(this->d, other.d); + } + + const KeyListResult &operator+=(const KeyListResult &other) + { + mergeWith(other); + return *this; + } + + void mergeWith(const KeyListResult &other); + + bool isNull() const; + + bool isTruncated() const; + +private: + void detach(); + void init(gpgme_ctx_t ctx); + class Private; + std::shared_ptr<Private> d; +}; + +} + +GPGMEPP_MAKE_STD_SWAP_SPECIALIZATION(KeyListResult) + +#endif // __GPGMEPP_KEYLISTRESULT_H__ diff --git a/lang/cpp/src/notation.h b/lang/cpp/src/notation.h new file mode 100644 index 00000000..807bdaad --- /dev/null +++ b/lang/cpp/src/notation.h @@ -0,0 +1,84 @@ +/* + notation.h - wraps a gpgme verify result + Copyright (C) 2004, 2007 Klarälvdalens Datakonsult AB + + This file is part of GPGME++. + + GPGME++ is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + GPGME++ is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Library General Public License for more details. + + You should have received a copy of the GNU Library General Public License + along with GPGME++; see the file COPYING.LIB. If not, write to the + Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. +*/ + +#ifndef __GPGMEPP_NOTATION_H__ +#define __GPGMEPP_NOTATION_H__ + +#include "gpgmefw.h" +#include "verificationresult.h" +#include "gpgmepp_export.h" + +#include <memory> + +#include <iosfwd> + +namespace GpgME +{ + +class GPGMEPP_EXPORT Notation +{ + friend class ::GpgME::Signature; + Notation(const std::shared_ptr<VerificationResult::Private> &parent, unsigned int sindex, unsigned int nindex); +public: + Notation(); + explicit Notation(gpgme_sig_notation_t nota); + + const Notation &operator=(Notation other) + { + swap(other); + return *this; + } + + void swap(Notation &other) + { + using std::swap; + swap(this->d, other.d); + } + + bool isNull() const; + + const char *name() const; + const char *value() const; + + enum Flags { + NoFlags = 0, + HumanReadable = 1, + Critical = 2 + }; + Flags flags() const; + + bool isHumanReadable() const; + bool isCritical() const; + +private: + class Private; + std::shared_ptr<Private> d; +}; + +GPGMEPP_EXPORT std::ostream &operator<<(std::ostream &os, const Notation ¬a); +GPGMEPP_EXPORT std::ostream &operator<<(std::ostream &os, Notation::Flags flags); + +} + +GPGMEPP_MAKE_STD_SWAP_SPECIALIZATION(Notation) + +#endif // __GPGMEPP_NOTATION_H__ diff --git a/lang/cpp/src/result.h b/lang/cpp/src/result.h new file mode 100644 index 00000000..1eae5b1d --- /dev/null +++ b/lang/cpp/src/result.h @@ -0,0 +1,58 @@ +/* + 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 Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + GPGME++ is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Library General Public License for more details. + + You should have received a copy of the GNU Library General Public License + along with GPGME++; see the file COPYING.LIB. If not, write to the + Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. +*/ + +#ifndef __GPGMEPP_RESULT_H__ +#define __GPGMEPP_RESULT_H__ + +#include "gpgmefw.h" +#include "error.h" + +#include <algorithm> // std::swap + +namespace GpgME +{ + +class GPGMEPP_EXPORT Result +{ +protected: + explicit Result() : mError() {} + explicit Result(int error) : mError(error) {} + explicit Result(const Error &error) : mError(error) {} + + void swap(Result &other) + { + std::swap(other.mError, mError); + } + +public: + const Error &error() const + { + return mError; + } + +protected: + Error mError; +}; + +} + +#endif // __GPGMEPP_RESULT_H__ diff --git a/lang/cpp/src/result_p.h b/lang/cpp/src/result_p.h new file mode 100644 index 00000000..0cf73e42 --- /dev/null +++ b/lang/cpp/src/result_p.h @@ -0,0 +1,43 @@ +/* + 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 Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + GPGME++ is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Library General Public License for more details. + + You should have received a copy of the GNU Library General Public License + along with GPGME++; see the file COPYING.LIB. If not, write to the + Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. +*/ + +#ifndef __GPGMEPP_RESULT_P_H__ +#define __GPGMEPP_RESULT_P_H__ + +#define make_default_ctor(x) \ + GpgME::x::x() : GpgME::Result(), d() {} + +#define make_error_ctor(x) \ + GpgME::x::x( const Error & error ) \ + : GpgME::Result( error ), d() \ + { \ + \ + } + +#define make_isNull(x) bool GpgME::x::isNull() const { return !d && !bool(error()); } + +#define make_standard_stuff(x) \ + make_default_ctor(x) \ + make_error_ctor(x) \ + make_isNull(x) + +#endif // __GPGMEPP_RESULT_P_H__ diff --git a/lang/cpp/src/scdgetinfoassuantransaction.cpp b/lang/cpp/src/scdgetinfoassuantransaction.cpp new file mode 100644 index 00000000..073d7724 --- /dev/null +++ b/lang/cpp/src/scdgetinfoassuantransaction.cpp @@ -0,0 +1,156 @@ +/* + scdgetinfoassuantransaction.cpp - Assuan Transaction to get information from scdaemon + Copyright (C) 2009 Klarälvdalens Datakonsult AB + + This file is part of GPGME++. + + GPGME++ is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + GPGME++ is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Library General Public License for more details. + + You should have received a copy of the GNU Library General Public License + along with GPGME++; see the file COPYING.LIB. If not, write to the + Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. +*/ + +#include "scdgetinfoassuantransaction.h" +#include "error.h" +#include "data.h" +#include "util.h" + +#include <sstream> +#include <assert.h> + +using namespace GpgME; + +ScdGetInfoAssuanTransaction::ScdGetInfoAssuanTransaction(InfoItem item) + : AssuanTransaction(), + m_item(item), + m_command(), + m_data() +{ + +} + +ScdGetInfoAssuanTransaction::~ScdGetInfoAssuanTransaction() {} + +static std::vector<std::string> to_reader_list(const std::string &s) +{ + std::vector<std::string> result; + std::stringstream ss(s); + std::string tok; + while (std::getline(ss, tok, '\n')) { + result.push_back(tok); + } + return result; +} + +static std::vector<std::string> to_app_list(const std::string &s) +{ + return to_reader_list(s); +} + +std::string ScdGetInfoAssuanTransaction::version() const +{ + if (m_item == Version) { + return m_data; + } else { + return std::string(); + } +} + +unsigned int ScdGetInfoAssuanTransaction::pid() const +{ + if (m_item == Pid) { + return to_pid(m_data); + } else { + return 0U; + } +} + +std::string ScdGetInfoAssuanTransaction::socketName() const +{ + if (m_item == SocketName) { + return m_data; + } else { + return std::string(); + } +} + +char ScdGetInfoAssuanTransaction::status() const +{ + if (m_item == Status && !m_data.empty()) { + return m_data[0]; + } else { + return '\0'; + } +} + +std::vector<std::string> ScdGetInfoAssuanTransaction::readerList() const +{ + if (m_item == ReaderList) { + return to_reader_list(m_data); + } else { + return std::vector<std::string>(); + } +} + +std::vector<std::string> ScdGetInfoAssuanTransaction::applicationList() const +{ + if (m_item == ApplicationList) { + return to_app_list(m_data); + } else { + return std::vector<std::string>(); + } +} + +static const char *const scd_getinfo_tokens[] = { + "version", + "pid", + "socket_name", + "status", + "reader_list", + "deny_admin", + "app_list", +}; +static_assert((sizeof scd_getinfo_tokens / sizeof * scd_getinfo_tokens == ScdGetInfoAssuanTransaction::LastInfoItem), + "getinfo_tokens size mismatch"); + +void ScdGetInfoAssuanTransaction::makeCommand() const +{ + assert(m_item >= 0); + assert(m_item < LastInfoItem); + m_command = "SCD GETINFO "; + m_command += scd_getinfo_tokens[m_item]; +} + +const char *ScdGetInfoAssuanTransaction::command() const +{ + makeCommand(); + return m_command.c_str(); +} + +Error ScdGetInfoAssuanTransaction::data(const char *data, size_t len) +{ + m_data.append(data, len); + return Error(); +} + +Data ScdGetInfoAssuanTransaction::inquire(const char *name, const char *args, Error &err) +{ + (void)name; (void)args; (void)err; + return Data::null; +} + +Error ScdGetInfoAssuanTransaction::status(const char *status, const char *args) +{ + (void)status; (void)args; + return Error(); +} diff --git a/lang/cpp/src/scdgetinfoassuantransaction.h b/lang/cpp/src/scdgetinfoassuantransaction.h new file mode 100644 index 00000000..a22a0ffd --- /dev/null +++ b/lang/cpp/src/scdgetinfoassuantransaction.h @@ -0,0 +1,76 @@ +/* + scdgetinfoassuantransaction.h - Assuan Transaction to get information from scdaemon + Copyright (C) 2009 Klarälvdalens Datakonsult AB + + This file is part of GPGME++. + + GPGME++ is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + GPGME++ is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Library General Public License for more details. + + You should have received a copy of the GNU Library General Public License + along with GPGME++; see the file COPYING.LIB. If not, write to the + Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. +*/ + +#ifndef __GPGMEPP_SCDGETINFOASSUANTRANSACTION_H__ +#define __GPGMEPP_SCDGETINFOASSUANTRANSACTION_H__ + +#include <interfaces/assuantransaction.h> + +#include <string> +#include <vector> + +namespace GpgME +{ + +class GPGMEPP_EXPORT ScdGetInfoAssuanTransaction : public AssuanTransaction +{ +public: + enum InfoItem { + Version, // string + Pid, // unsigned long + SocketName, // string (path) + Status, // char (status) + ReaderList, // string list + DenyAdmin, // (none, returns GPG_ERR_GENERAL when admin commands are allowed) + ApplicationList, // string list + + LastInfoItem + }; + + explicit ScdGetInfoAssuanTransaction(InfoItem item); + ~ScdGetInfoAssuanTransaction(); + + std::string version() const; + unsigned int pid() const; + std::string socketName() const; + char status() const; + std::vector<std::string> readerList() const; + std::vector<std::string> applicationList() const; + +private: + /* reimp */ const char *command() const; + /* reimp */ Error data(const char *data, size_t datalen); + /* reimp */ Data inquire(const char *name, const char *args, Error &err); + /* reimp */ Error status(const char *status, const char *args); + +private: + void makeCommand() const; + +private: + InfoItem m_item; + mutable std::string m_command; + std::string m_data; +}; + +} // namespace GpgME + +#endif // __GPGMEPP_SCDGETINFOASSUANTRANSACTION_H__ diff --git a/lang/cpp/src/signingresult.cpp b/lang/cpp/src/signingresult.cpp new file mode 100644 index 00000000..4f2ef72e --- /dev/null +++ b/lang/cpp/src/signingresult.cpp @@ -0,0 +1,265 @@ +/* + signingresult.cpp - wraps a gpgme verify result + Copyright (C) 2004 Klarälvdalens Datakonsult AB + + This file is part of GPGME++. + + GPGME++ is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + GPGME++ is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Library General Public License for more details. + + You should have received a copy of the GNU Library General Public License + along with GPGME++; see the file COPYING.LIB. If not, write to the + Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. +*/ + +#include <signingresult.h> +#include "result_p.h" +#include "util.h" + +#include <gpgme.h> + +#include <cstring> +#include <cstdlib> +#include <algorithm> +#include <istream> +#include <iterator> + +#include <string.h> + +class GpgME::SigningResult::Private +{ +public: + Private(const gpgme_sign_result_t r) + { + if (!r) { + return; + } + for (gpgme_new_signature_t is = r->signatures ; is ; is = is->next) { + gpgme_new_signature_t copy = new _gpgme_new_signature(*is); + if (is->fpr) { + copy->fpr = strdup(is->fpr); + } + copy->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() +{ + init(ctx); +} + +GpgME::SigningResult::SigningResult(gpgme_ctx_t ctx, const Error &error) + : GpgME::Result(error), d() +{ + init(ctx); +} + +void GpgME::SigningResult::init(gpgme_ctx_t ctx) +{ + if (!ctx) { + return; + } + gpgme_sign_result_t res = gpgme_op_sign_result(ctx); + if (!res) { + return; + } + d.reset(new Private(res)); +} + +make_standard_stuff(SigningResult) + +GpgME::CreatedSignature GpgME::SigningResult::createdSignature(unsigned int idx) const +{ + return CreatedSignature(d, idx); +} + +std::vector<GpgME::CreatedSignature> GpgME::SigningResult::createdSignatures() const +{ + if (!d) { + return std::vector<CreatedSignature>(); + } + std::vector<CreatedSignature> result; + result.reserve(d->created.size()); + for (unsigned int i = 0 ; i < d->created.size() ; ++i) { + result.push_back(CreatedSignature(d, i)); + } + return result; +} + +GpgME::InvalidSigningKey GpgME::SigningResult::invalidSigningKey(unsigned int idx) const +{ + return InvalidSigningKey(d, idx); +} + +std::vector<GpgME::InvalidSigningKey> GpgME::SigningResult::invalidSigningKeys() const +{ + if (!d) { + return std::vector<GpgME::InvalidSigningKey>(); + } + std::vector<GpgME::InvalidSigningKey> result; + result.reserve(d->invalid.size()); + for (unsigned int i = 0 ; i < d->invalid.size() ; ++i) { + result.push_back(InvalidSigningKey(d, i)); + } + return result; +} + +GpgME::InvalidSigningKey::InvalidSigningKey(const std::shared_ptr<SigningResult::Private> &parent, unsigned int i) + : d(parent), idx(i) +{ + +} + +GpgME::InvalidSigningKey::InvalidSigningKey() : d(), idx(0) {} + +bool GpgME::InvalidSigningKey::isNull() const +{ + return !d || idx >= d->invalid.size() ; +} + +const char *GpgME::InvalidSigningKey::fingerprint() const +{ + return isNull() ? 0 : d->invalid[idx]->fpr ; +} + +GpgME::Error GpgME::InvalidSigningKey::reason() const +{ + return Error(isNull() ? 0 : d->invalid[idx]->reason); +} + +GpgME::CreatedSignature::CreatedSignature(const std::shared_ptr<SigningResult::Private> &parent, unsigned int i) + : d(parent), idx(i) +{ + +} + +GpgME::CreatedSignature::CreatedSignature() : d(), idx(0) {} + +bool GpgME::CreatedSignature::isNull() const +{ + return !d || idx >= d->created.size() ; +} + +const char *GpgME::CreatedSignature::fingerprint() const +{ + return isNull() ? 0 : d->created[idx]->fpr ; +} + +time_t GpgME::CreatedSignature::creationTime() const +{ + return static_cast<time_t>(isNull() ? 0 : d->created[idx]->timestamp); +} + +GpgME::SignatureMode GpgME::CreatedSignature::mode() const +{ + if (isNull()) { + return NormalSignatureMode; + } + switch (d->created[idx]->type) { + default: + case GPGME_SIG_MODE_NORMAL: return NormalSignatureMode; + case GPGME_SIG_MODE_DETACH: return Detached; + case GPGME_SIG_MODE_CLEAR: return Clearsigned; + } +} + +unsigned int GpgME::CreatedSignature::publicKeyAlgorithm() const +{ + return isNull() ? 0 : d->created[idx]->pubkey_algo ; +} + +const char *GpgME::CreatedSignature::publicKeyAlgorithmAsString() const +{ + return gpgme_pubkey_algo_name(isNull() ? (gpgme_pubkey_algo_t)0 : d->created[idx]->pubkey_algo); +} + +unsigned int GpgME::CreatedSignature::hashAlgorithm() const +{ + return isNull() ? 0 : d->created[idx]->hash_algo ; +} + +const char *GpgME::CreatedSignature::hashAlgorithmAsString() const +{ + return gpgme_hash_algo_name(isNull() ? (gpgme_hash_algo_t)0 : d->created[idx]->hash_algo); +} + +unsigned int GpgME::CreatedSignature::signatureClass() const +{ + return isNull() ? 0 : d->created[idx]->sig_class ; +} + +std::ostream &GpgME::operator<<(std::ostream &os, const SigningResult &result) +{ + os << "GpgME::SigningResult("; + if (!result.isNull()) { + os << "\n error: " << result.error() + << "\n createdSignatures:\n"; + const std::vector<CreatedSignature> cs = result.createdSignatures(); + std::copy(cs.begin(), cs.end(), + std::ostream_iterator<CreatedSignature>(os, "\n")); + os << " invalidSigningKeys:\n"; + const std::vector<InvalidSigningKey> isk = result.invalidSigningKeys(); + std::copy(isk.begin(), isk.end(), + std::ostream_iterator<InvalidSigningKey>(os, "\n")); + } + return os << ')'; +} + +std::ostream &GpgME::operator<<(std::ostream &os, const CreatedSignature &sig) +{ + os << "GpgME::CreatedSignature("; + if (!sig.isNull()) { + os << "\n fingerprint: " << protect(sig.fingerprint()) + << "\n creationTime: " << sig.creationTime() + << "\n mode: " << sig.mode() + << "\n publicKeyAlgorithm: " << protect(sig.publicKeyAlgorithmAsString()) + << "\n hashAlgorithm: " << protect(sig.hashAlgorithmAsString()) + << "\n signatureClass: " << sig.signatureClass() + << '\n'; + } + return os << ')'; +} + +std::ostream &GpgME::operator<<(std::ostream &os, const InvalidSigningKey &key) +{ + os << "GpgME::InvalidSigningKey("; + if (!key.isNull()) { + os << "\n fingerprint: " << protect(key.fingerprint()) + << "\n reason: " << key.reason() + << '\n'; + } + return os << ')'; +} diff --git a/lang/cpp/src/signingresult.h b/lang/cpp/src/signingresult.h new file mode 100644 index 00000000..2c274549 --- /dev/null +++ b/lang/cpp/src/signingresult.h @@ -0,0 +1,162 @@ +/* + signingresult.h - wraps a gpgme sign result + Copyright (C) 2004 Klarälvdalens Datakonsult AB + + This file is part of GPGME++. + + GPGME++ is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + GPGME++ is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Library General Public License for more details. + + You should have received a copy of the GNU Library General Public License + along with GPGME++; see the file COPYING.LIB. If not, write to the + Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. +*/ + +#ifndef __GPGMEPP_SIGNINGRESULT_H__ +#define __GPGMEPP_SIGNINGRESULT_H__ + +#include "global.h" +#include "result.h" + +#include <time.h> + +#include <memory> + +#include <vector> +#include <iosfwd> + +namespace GpgME +{ + +class Error; +class CreatedSignature; +class InvalidSigningKey; + +class GPGMEPP_EXPORT SigningResult : public Result +{ +public: + SigningResult(); + SigningResult(gpgme_ctx_t ctx, int error); + SigningResult(gpgme_ctx_t ctx, const Error &error); + explicit SigningResult(const Error &err); + + const SigningResult &operator=(SigningResult other) + { + swap(other); + return *this; + } + + void swap(SigningResult &other) + { + Result::swap(other); + using std::swap; + swap(this->d, other.d); + } + + bool isNull() const; + + CreatedSignature createdSignature(unsigned int index) const; + std::vector<CreatedSignature> createdSignatures() const; + + InvalidSigningKey invalidSigningKey(unsigned int index) const; + std::vector<InvalidSigningKey> invalidSigningKeys() const; + + class Private; +private: + void init(gpgme_ctx_t ctx); + std::shared_ptr<Private> d; +}; + +GPGMEPP_EXPORT std::ostream &operator<<(std::ostream &os, const SigningResult &result); + +class GPGMEPP_EXPORT InvalidSigningKey +{ + friend class ::GpgME::SigningResult; + InvalidSigningKey(const std::shared_ptr<SigningResult::Private> &parent, unsigned int index); +public: + InvalidSigningKey(); + + const InvalidSigningKey &operator=(InvalidSigningKey other) + { + swap(other); + return *this; + } + + void swap(InvalidSigningKey &other) + { + using std::swap; + swap(this->d, other.d); + swap(this->idx, other.idx); + } + + bool isNull() const; + + const char *fingerprint() const; + Error reason() const; + +private: + std::shared_ptr<SigningResult::Private> d; + unsigned int idx; +}; + +GPGMEPP_EXPORT std::ostream &operator<<(std::ostream &os, const InvalidSigningKey &key); + +class GPGMEPP_EXPORT CreatedSignature +{ + friend class ::GpgME::SigningResult; + CreatedSignature(const std::shared_ptr<SigningResult::Private> &parent, unsigned int index); +public: + + CreatedSignature(); + + const CreatedSignature &operator=(CreatedSignature other) + { + swap(other); + return *this; + } + + void swap(CreatedSignature &other) + { + using std::swap; + swap(this->d, other.d); + swap(this->idx, other.idx); + } + + bool isNull() const; + + const char *fingerprint() const; + + time_t creationTime() const; + + SignatureMode mode() const; + + unsigned int publicKeyAlgorithm() const; + const char *publicKeyAlgorithmAsString() const; + + unsigned int hashAlgorithm() const; + const char *hashAlgorithmAsString() const; + + unsigned int signatureClass() const; + +private: + std::shared_ptr<SigningResult::Private> d; + unsigned int idx; +}; + +GPGMEPP_EXPORT std::ostream &operator<<(std::ostream &os, const CreatedSignature &sig); + +} + +GPGMEPP_MAKE_STD_SWAP_SPECIALIZATION(SigningResult) +GPGMEPP_MAKE_STD_SWAP_SPECIALIZATION(InvalidSigningKey) +GPGMEPP_MAKE_STD_SWAP_SPECIALIZATION(CreatedSignature) + +#endif // __GPGMEPP_SIGNINGRESULT_H__ diff --git a/lang/cpp/src/trustitem.cpp b/lang/cpp/src/trustitem.cpp new file mode 100644 index 00000000..fc7e4a61 --- /dev/null +++ b/lang/cpp/src/trustitem.cpp @@ -0,0 +1,114 @@ +/* + trustitem.cpp - wraps a gpgme trust item + Copyright (C) 2003 Klarälvdalens Datakonsult AB + + This file is part of GPGME. + + GPGME++ is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + GPGME++ is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Library General Public License for more details. + + You should have received a copy of the GNU Library General Public License + along with GPGME++; see the file COPYING.LIB. If not, write to the + Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. +*/ + +#include <trustitem.h> + +#include <gpgme.h> + +#include <cassert> + +namespace GpgME +{ + +class TrustItem::Private +{ +public: + Private(gpgme_trust_item_t aItem) + : item(aItem) + { + } + + gpgme_trust_item_t item; +}; + +TrustItem::TrustItem(gpgme_trust_item_t item) +{ + d = new Private(item); + if (d->item) { + gpgme_trust_item_ref(d->item); + } +} + +TrustItem::TrustItem(const TrustItem &other) +{ + d = new Private(other.d->item); + if (d->item) { + gpgme_trust_item_ref(d->item); + } +} + +TrustItem::~TrustItem() +{ + if (d->item) { + gpgme_trust_item_unref(d->item); + } + delete d; d = 0; +} + +bool TrustItem::isNull() const +{ + return !d || !d->item; +} + +gpgme_trust_item_t TrustItem::impl() const +{ + return d->item; +} + +const char *TrustItem::keyID() const +{ + return d->item ? d->item->keyid : 0 ; +} + +const char *TrustItem::userID() const +{ + return d->item ? d->item->name : 0 ; +} + +const char *TrustItem::ownerTrustAsString() const +{ + return d->item ? d->item->owner_trust : 0 ; +} + +const char *TrustItem::validityAsString() const +{ + return d->item ? d->item->validity : 0 ; +} + +int TrustItem::trustLevel() const +{ + return d->item ? d->item->level : 0 ; +} + +TrustItem::Type TrustItem::type() const +{ + if (!d->item) { + return Unknown; + } else { + return + d->item->type == 1 ? Key : + d->item->type == 2 ? UserID : + Unknown ; + } +} + +} // namespace GpgME diff --git a/lang/cpp/src/trustitem.h b/lang/cpp/src/trustitem.h new file mode 100644 index 00000000..65f109c8 --- /dev/null +++ b/lang/cpp/src/trustitem.h @@ -0,0 +1,81 @@ +/* + trustitem.h - wraps a gpgme trust item + Copyright (C) 2003 Klarälvdalens Datakonsult AB + + This file is part of GPGME. + + GPGME++ is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + GPGME++ is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Library General Public License for more details. + + You should have received a copy of the GNU Library General Public License + along with GPGME++; see the file COPYING.LIB. If not, write to the + Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. +*/ + +// -*- c++ -*- +#ifndef __GPGMEPP_TRUSTITEM_H__ +#define __GPGMEPP_TRUSTITEM_H__ + +#include "gpgmefw.h" +#include <key.h> +#include "gpgmepp_export.h" + +#include <algorithm> + +namespace GpgME +{ + +class Context; + +class GPGMEPP_EXPORT TrustItem +{ + friend class ::GpgME::Context; +public: + explicit TrustItem(gpgme_trust_item_t item = 0); + TrustItem(const TrustItem &other); + virtual ~TrustItem(); + + const TrustItem &operator=(TrustItem other) + { + swap(other); + return *this; + } + + void swap(TrustItem &other) + { + using std::swap; + swap(this->d, other.d); + } + + bool isNull() const; + + const char *keyID() const; + const char *userID() const; + + const char *ownerTrustAsString() const; + const char *validityAsString() const; + + int trustLevel() const; + + enum Type { Unknown = 0, Key = 1, UserID = 2 }; + Type type() const; + +private: + gpgme_trust_item_t impl() const; + class Private; + Private *d; +}; + +} // namepace GpgME + +GPGMEPP_MAKE_STD_SWAP_SPECIALIZATION(TrustItem) + +#endif // __GPGMEPP_TRUSTITEM_H__ diff --git a/lang/cpp/src/util.h b/lang/cpp/src/util.h new file mode 100644 index 00000000..8ccb0bf5 --- /dev/null +++ b/lang/cpp/src/util.h @@ -0,0 +1,146 @@ +/* + util.h - some inline helper functions + Copyright (C) 2004 Klarälvdalens Datakonsult AB + + This file is part of GPGME++. + + GPGME++ is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + GPGME++ is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Library General Public License for more details. + + You should have received a copy of the GNU Library General Public License + along with GPGME++; see the file COPYING.LIB. If not, write to the + Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. +*/ + +// -*- c++ -*- +#ifndef __GPGMEPP_UTIL_H__ +#define __GPGMEPP_UTIL_H__ + +#include "global.h" +#include "notation.h" + +#include <gpgme.h> + +#ifndef NDEBUG +#include <iostream> +#endif +#include <sstream> +#include <string> + +static inline const char *protect(const char *s) +{ + return s ? s : "<null>" ; +} + +static inline gpgme_error_t make_error(gpgme_err_code_t code) +{ + return gpgme_err_make((gpgme_err_source_t)22, code); +} + +static inline unsigned long to_pid(const std::string &s) +{ + std::stringstream ss(s); + unsigned int result; + if (ss >> result) { + return result; + } else { + return 0U; + } +} + +static inline gpgme_keylist_mode_t add_to_gpgme_keylist_mode_t(unsigned int oldmode, unsigned int newmodes) +{ + if (newmodes & GpgME::Local) { + oldmode |= GPGME_KEYLIST_MODE_LOCAL; + } + if (newmodes & GpgME::Extern) { + oldmode |= GPGME_KEYLIST_MODE_EXTERN; + } + if (newmodes & GpgME::Signatures) { + oldmode |= GPGME_KEYLIST_MODE_SIGS; + } + if (newmodes & GpgME::SignatureNotations) { + oldmode |= GPGME_KEYLIST_MODE_SIG_NOTATIONS; + } + if (newmodes & GpgME::Ephemeral) { + oldmode |= GPGME_KEYLIST_MODE_EPHEMERAL; + } + if (newmodes & GpgME::Validate) { + oldmode |= GPGME_KEYLIST_MODE_VALIDATE; + } +#ifndef NDEBUG + if (newmodes & ~(GpgME::Local | GpgME::Extern | GpgME::Signatures | GpgME::SignatureNotations | GpgME::Ephemeral | GpgME::Validate)) { + //std::cerr << "GpgME::Context: keylist mode must be one of Local, " + //"Extern, Signatures, SignatureNotations, or Validate, or a combination thereof!" << std::endl; + } +#endif + return static_cast<gpgme_keylist_mode_t>(oldmode); +} + +static inline unsigned int convert_from_gpgme_keylist_mode_t(unsigned int mode) +{ + unsigned int result = 0; + if (mode & GPGME_KEYLIST_MODE_LOCAL) { + result |= GpgME::Local; + } + if (mode & GPGME_KEYLIST_MODE_EXTERN) { + result |= GpgME::Extern; + } + if (mode & GPGME_KEYLIST_MODE_SIGS) { + result |= GpgME::Signatures; + } + if (mode & GPGME_KEYLIST_MODE_SIG_NOTATIONS) { + result |= GpgME::SignatureNotations; + } + if (mode & GPGME_KEYLIST_MODE_EPHEMERAL) { + result |= GpgME::Ephemeral; + } + if (mode & GPGME_KEYLIST_MODE_VALIDATE) { + result |= GpgME::Validate; + } +#ifndef NDEBUG + if (mode & ~(GPGME_KEYLIST_MODE_LOCAL | + GPGME_KEYLIST_MODE_EXTERN | + GPGME_KEYLIST_MODE_SIG_NOTATIONS | + GPGME_KEYLIST_MODE_EPHEMERAL | + GPGME_KEYLIST_MODE_VALIDATE | + GPGME_KEYLIST_MODE_SIGS)) { + //std::cerr << "GpgME: WARNING: gpgme_get_keylist_mode() returned an unknown flag!" << std::endl; + } +#endif // NDEBUG + return result; +} + +static inline GpgME::Notation::Flags convert_from_gpgme_sig_notation_flags_t(unsigned int flags) +{ + unsigned int result = 0; + if (flags & GPGME_SIG_NOTATION_HUMAN_READABLE) { + result |= GpgME::Notation::HumanReadable ; + } + if (flags & GPGME_SIG_NOTATION_CRITICAL) { + result |= GpgME::Notation::Critical ; + } + return static_cast<GpgME::Notation::Flags>(result); +} + +static inline gpgme_sig_notation_flags_t add_to_gpgme_sig_notation_flags_t(unsigned int oldflags, unsigned int newflags) +{ + unsigned int result = oldflags; + if (newflags & GpgME::Notation::HumanReadable) { + result |= GPGME_SIG_NOTATION_HUMAN_READABLE; + } + if (newflags & GpgME::Notation::Critical) { + result |= GPGME_SIG_NOTATION_CRITICAL; + } + return static_cast<gpgme_sig_notation_flags_t>(result); +} + +#endif // __GPGMEPP_UTIL_H__ diff --git a/lang/cpp/src/verificationresult.cpp b/lang/cpp/src/verificationresult.cpp new file mode 100644 index 00000000..b6fde7da --- /dev/null +++ b/lang/cpp/src/verificationresult.cpp @@ -0,0 +1,557 @@ +/* + verificationresult.cpp - wraps a gpgme verify result + Copyright (C) 2004 Klarälvdalens Datakonsult AB + + This file is part of GPGME++. + + GPGME++ is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + GPGME++ is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Library General Public License for more details. + + You should have received a copy of the GNU Library General Public License + along with GPGME++; see the file COPYING.LIB. If not, write to the + Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. +*/ + +#include <verificationresult.h> +#include <notation.h> +#include "result_p.h" +#include "util.h" + +#include <gpgme.h> + +#include <istream> +#include <algorithm> +#include <iterator> +#include <string> +#include <cstring> +#include <cstdlib> + +#include <string.h> + +class GpgME::VerificationResult::Private +{ +public: + explicit Private(const gpgme_verify_result_t r) + { + if (!r) { + return; + } + if (r->file_name) { + file_name = r->file_name; + } + // 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); + } +// PENDING(marc) why does this crash on Windows in strdup()? +# ifndef _WIN32 + if (is->pka_address) { + scopy->pka_address = strdup(is->pka_address); + } +# else + scopy->pka_address = 0; +# endif + scopy->next = 0; + sigs.push_back(scopy); + // copy notations: + nota.push_back(std::vector<Nota>()); + purls.push_back(0); + for (gpgme_sig_notation_t in = is->notations ; in ; in = in->next) { + if (!in->name) { + if (in->value) { + purls.back() = strdup(in->value); // policy url + } + continue; + } + Nota n = { 0, 0, in->flags }; + 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); + std::free((*it)->pka_address); + 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; + gpgme_sig_notation_flags_t flags; + }; + + std::vector<gpgme_signature_t> sigs; + std::vector< std::vector<Nota> > nota; + std::vector<char *> purls; + std::string file_name; +}; + +GpgME::VerificationResult::VerificationResult(gpgme_ctx_t ctx, int error) + : GpgME::Result(error), d() +{ + init(ctx); +} + +GpgME::VerificationResult::VerificationResult(gpgme_ctx_t ctx, const Error &error) + : GpgME::Result(error), d() +{ + init(ctx); +} + +void GpgME::VerificationResult::init(gpgme_ctx_t ctx) +{ + if (!ctx) { + return; + } + gpgme_verify_result_t res = gpgme_op_verify_result(ctx); + if (!res) { + return; + } + d.reset(new Private(res)); +} + +make_standard_stuff(VerificationResult) + +const char *GpgME::VerificationResult::fileName() const +{ + return d ? d->file_name.c_str() : 0 ; +} + +unsigned int GpgME::VerificationResult::numSignatures() const +{ + return d ? d->sigs.size() : 0 ; +} + +GpgME::Signature GpgME::VerificationResult::signature(unsigned int idx) const +{ + return Signature(d, idx); +} + +std::vector<GpgME::Signature> GpgME::VerificationResult::signatures() const +{ + if (!d) { + return std::vector<Signature>(); + } + std::vector<Signature> result; + result.reserve(d->sigs.size()); + for (unsigned int i = 0 ; i < d->sigs.size() ; ++i) { + result.push_back(Signature(d, i)); + } + return result; +} + +GpgME::Signature::Signature(const std::shared_ptr<VerificationResult::Private> &parent, unsigned int i) + : d(parent), idx(i) +{ +} + +GpgME::Signature::Signature() : d(), idx(0) {} + +bool GpgME::Signature::isNull() const +{ + return !d || idx >= d->sigs.size() ; +} + +GpgME::Signature::Summary GpgME::Signature::summary() const +{ + if (isNull()) { + return None; + } + gpgme_sigsum_t sigsum = d->sigs[idx]->summary; + unsigned int result = 0; + if (sigsum & GPGME_SIGSUM_VALID) { + result |= Valid; + } + if (sigsum & GPGME_SIGSUM_GREEN) { + result |= Green; + } + if (sigsum & GPGME_SIGSUM_RED) { + result |= Red; + } + if (sigsum & GPGME_SIGSUM_KEY_REVOKED) { + result |= KeyRevoked; + } + if (sigsum & GPGME_SIGSUM_KEY_EXPIRED) { + result |= KeyExpired; + } + if (sigsum & GPGME_SIGSUM_SIG_EXPIRED) { + result |= SigExpired; + } + if (sigsum & GPGME_SIGSUM_KEY_MISSING) { + result |= KeyMissing; + } + if (sigsum & GPGME_SIGSUM_CRL_MISSING) { + result |= CrlMissing; + } + if (sigsum & GPGME_SIGSUM_CRL_TOO_OLD) { + result |= CrlTooOld; + } + if (sigsum & GPGME_SIGSUM_BAD_POLICY) { + result |= BadPolicy; + } + if (sigsum & GPGME_SIGSUM_SYS_ERROR) { + result |= SysError; + } + return static_cast<Summary>(result); +} + +const char *GpgME::Signature::fingerprint() const +{ + return isNull() ? 0 : d->sigs[idx]->fpr ; +} + +GpgME::Error GpgME::Signature::status() const +{ + return Error(isNull() ? 0 : d->sigs[idx]->status); +} + +time_t GpgME::Signature::creationTime() const +{ + return static_cast<time_t>(isNull() ? 0 : d->sigs[idx]->timestamp); +} + +time_t GpgME::Signature::expirationTime() const +{ + return static_cast<time_t>(isNull() ? 0 : d->sigs[idx]->exp_timestamp); +} + +bool GpgME::Signature::neverExpires() const +{ + return expirationTime() == (time_t)0; +} + +bool GpgME::Signature::isWrongKeyUsage() const +{ + return !isNull() && d->sigs[idx]->wrong_key_usage; +} + +bool GpgME::Signature::isVerifiedUsingChainModel() const +{ + return !isNull() && d->sigs[idx]->chain_model; +} + +GpgME::Signature::PKAStatus GpgME::Signature::pkaStatus() const +{ + if (!isNull()) { + return static_cast<PKAStatus>(d->sigs[idx]->pka_trust); + } + return UnknownPKAStatus; +} + +const char *GpgME::Signature::pkaAddress() const +{ + if (!isNull()) { + return d->sigs[idx]->pka_address; + } + return 0; +} + +GpgME::Signature::Validity GpgME::Signature::validity() const +{ + if (isNull()) { + return Unknown; + } + switch (d->sigs[idx]->validity) { + default: + case GPGME_VALIDITY_UNKNOWN: return Unknown; + case GPGME_VALIDITY_UNDEFINED: return Undefined; + case GPGME_VALIDITY_NEVER: return Never; + case GPGME_VALIDITY_MARGINAL: return Marginal; + case GPGME_VALIDITY_FULL: return Full; + case GPGME_VALIDITY_ULTIMATE: return Ultimate; + } +} + +char GpgME::Signature::validityAsString() const +{ + if (isNull()) { + return '?'; + } + switch (d->sigs[idx]->validity) { + default: + case GPGME_VALIDITY_UNKNOWN: return '?'; + case GPGME_VALIDITY_UNDEFINED: return 'q'; + case GPGME_VALIDITY_NEVER: return 'n'; + case GPGME_VALIDITY_MARGINAL: return 'm'; + case GPGME_VALIDITY_FULL: return 'f'; + case GPGME_VALIDITY_ULTIMATE: return 'u'; + } +} + +GpgME::Error GpgME::Signature::nonValidityReason() const +{ + return Error(isNull() ? 0 : d->sigs[idx]->validity_reason); +} + +unsigned int GpgME::Signature::publicKeyAlgorithm() const +{ + if (!isNull()) { + return d->sigs[idx]->pubkey_algo; + } + return 0; +} + +const char *GpgME::Signature::publicKeyAlgorithmAsString() const +{ + if (!isNull()) { + return gpgme_pubkey_algo_name(d->sigs[idx]->pubkey_algo); + } + return 0; +} + +unsigned int GpgME::Signature::hashAlgorithm() const +{ + if (!isNull()) { + return d->sigs[idx]->hash_algo; + } + return 0; +} + +const char *GpgME::Signature::hashAlgorithmAsString() const +{ + if (!isNull()) { + return gpgme_hash_algo_name(d->sigs[idx]->hash_algo); + } + return 0; +} + +const char *GpgME::Signature::policyURL() const +{ + return isNull() ? 0 : d->purls[idx] ; +} + +GpgME::Notation GpgME::Signature::notation(unsigned int nidx) const +{ + return GpgME::Notation(d, idx, nidx); +} + +std::vector<GpgME::Notation> GpgME::Signature::notations() const +{ + if (isNull()) { + return std::vector<GpgME::Notation>(); + } + std::vector<GpgME::Notation> result; + result.reserve(d->nota[idx].size()); + for (unsigned int i = 0 ; i < d->nota[idx].size() ; ++i) { + result.push_back(GpgME::Notation(d, idx, i)); + } + return result; +} + +class GpgME::Notation::Private +{ +public: + Private() : d(), sidx(0), nidx(0), nota(0) {} + Private(const std::shared_ptr<VerificationResult::Private> &priv, unsigned int sindex, unsigned int nindex) + : d(priv), sidx(sindex), nidx(nindex), nota(0) + { + + } + Private(gpgme_sig_notation_t n) + : d(), sidx(0), nidx(0), nota(n ? new _gpgme_sig_notation(*n) : 0) + { + if (nota && nota->name) { + nota->name = strdup(nota->name); + } + if (nota && nota->value) { + nota->value = strdup(nota->value); + } + } + Private(const Private &other) + : d(other.d), sidx(other.sidx), nidx(other.nidx), nota(other.nota) + { + if (nota) { + nota->name = strdup(nota->name); + nota->value = strdup(nota->value); + } + } + ~Private() + { + if (nota) { + std::free(nota->name); nota->name = 0; + std::free(nota->value); nota->value = 0; + delete nota; + } + } + + std::shared_ptr<VerificationResult::Private> d; + unsigned int sidx, nidx; + gpgme_sig_notation_t nota; +}; + +GpgME::Notation::Notation(const std::shared_ptr<VerificationResult::Private> &parent, unsigned int sindex, unsigned int nindex) + : d(new Private(parent, sindex, nindex)) +{ + +} + +GpgME::Notation::Notation(gpgme_sig_notation_t nota) + : d(new Private(nota)) +{ + +} + +GpgME::Notation::Notation() : d() {} + +bool GpgME::Notation::isNull() const +{ + if (!d) { + return true; + } + if (d->d) { + return d->sidx >= d->d->nota.size() || d->nidx >= d->d->nota[d->sidx].size() ; + } + return !d->nota; +} + +const char *GpgME::Notation::name() const +{ + return + isNull() ? 0 : + d->d ? d->d->nota[d->sidx][d->nidx].name : + d->nota ? d->nota->name : 0 ; +} + +const char *GpgME::Notation::value() const +{ + return + isNull() ? 0 : + d->d ? d->d->nota[d->sidx][d->nidx].value : + d->nota ? d->nota->value : 0 ; +} + +GpgME::Notation::Flags GpgME::Notation::flags() const +{ + return + convert_from_gpgme_sig_notation_flags_t( + isNull() ? 0 : + d->d ? d->d->nota[d->sidx][d->nidx].flags : + d->nota ? d->nota->flags : 0); +} + +bool GpgME::Notation::isHumanReadable() const +{ + return flags() & HumanReadable; +} + +bool GpgME::Notation::isCritical() const +{ + return flags() & Critical; +} + +std::ostream &GpgME::operator<<(std::ostream &os, const VerificationResult &result) +{ + os << "GpgME::VerificationResult("; + if (!result.isNull()) { + os << "\n error: " << result.error() + << "\n fileName: " << protect(result.fileName()) + << "\n signatures:\n"; + const std::vector<Signature> sigs = result.signatures(); + std::copy(sigs.begin(), sigs.end(), + std::ostream_iterator<Signature>(os, "\n")); + } + return os << ')'; +} + +std::ostream &GpgME::operator<<(std::ostream &os, Signature::PKAStatus pkaStatus) +{ +#define OUTPUT( x ) if ( !(pkaStatus & (GpgME::Signature:: x)) ) {} else do { os << #x " "; } while(0) + os << "GpgME::Signature::PKAStatus("; + OUTPUT(UnknownPKAStatus); + OUTPUT(PKAVerificationFailed); + OUTPUT(PKAVerificationSucceeded); +#undef OUTPUT + return os << ')'; +} + +std::ostream &GpgME::operator<<(std::ostream &os, Signature::Summary summary) +{ +#define OUTPUT( x ) if ( !(summary & (GpgME::Signature:: x)) ) {} else do { os << #x " "; } while(0) + os << "GpgME::Signature::Summary("; + OUTPUT(Valid); + OUTPUT(Green); + OUTPUT(Red); + OUTPUT(KeyRevoked); + OUTPUT(KeyExpired); + OUTPUT(SigExpired); + OUTPUT(KeyMissing); + OUTPUT(CrlMissing); + OUTPUT(CrlTooOld); + OUTPUT(BadPolicy); + OUTPUT(SysError); +#undef OUTPUT + return os << ')'; +} + +std::ostream &GpgME::operator<<(std::ostream &os, const Signature &sig) +{ + os << "GpgME::Signature("; + if (!sig.isNull()) { + os << "\n Summary: " << sig.summary() + << "\n Fingerprint: " << protect(sig.fingerprint()) + << "\n Status: " << sig.status() + << "\n creationTime: " << sig.creationTime() + << "\n expirationTime: " << sig.expirationTime() + << "\n isWrongKeyUsage: " << sig.isWrongKeyUsage() + << "\n isVerifiedUsingChainModel: " << sig.isVerifiedUsingChainModel() + << "\n pkaStatus: " << sig.pkaStatus() + << "\n pkaAddress: " << protect(sig.pkaAddress()) + << "\n validity: " << sig.validityAsString() + << "\n nonValidityReason: " << sig.nonValidityReason() + << "\n publicKeyAlgorithm: " << protect(sig.publicKeyAlgorithmAsString()) + << "\n hashAlgorithm: " << protect(sig.hashAlgorithmAsString()) + << "\n policyURL: " << protect(sig.policyURL()) + << "\n notations:\n"; + const std::vector<Notation> nota = sig.notations(); + std::copy(nota.begin(), nota.end(), + std::ostream_iterator<Notation>(os, "\n")); + } + return os << ')'; +} + +std::ostream &GpgME::operator<<(std::ostream &os, Notation::Flags flags) +{ + os << "GpgME::Notation::Flags("; +#define OUTPUT( x ) if ( !(flags & (GpgME::Notation:: x)) ) {} else do { os << #x " "; } while(0) + OUTPUT(HumanReadable); + OUTPUT(Critical); +#undef OUTPUT + return os << ')'; +} + +std::ostream &GpgME::operator<<(std::ostream &os, const Notation ¬a) +{ + os << "GpgME::Signature::Notation("; + if (!nota.isNull()) { + os << "\n name: " << protect(nota.name()) + << "\n value: " << protect(nota.value()) + << "\n flags: " << nota.flags() + << '\n'; + } + return os << ")"; +} diff --git a/lang/cpp/src/verificationresult.h b/lang/cpp/src/verificationresult.h new file mode 100644 index 00000000..17f0568b --- /dev/null +++ b/lang/cpp/src/verificationresult.h @@ -0,0 +1,173 @@ +/* + verificationresult.h - wraps a gpgme verify result + Copyright (C) 2004 Klarälvdalens Datakonsult AB + + This file is part of GPGME++. + + GPGME++ is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + GPGME++ is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Library General Public License for more details. + + You should have received a copy of the GNU Library General Public License + along with GPGME++; see the file COPYING.LIB. If not, write to the + Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. +*/ + +#ifndef __GPGMEPP_VERIFICATIONRESULT_H__ +#define __GPGMEPP_VERIFICATIONRESULT_H__ + +#include "gpgmefw.h" +#include "result.h" +#include "gpgmepp_export.h" + +#include <time.h> + +#include <memory> + +#include <vector> +#include <iosfwd> + +namespace GpgME +{ + +class Error; +class Signature; +class Notation; + +class GPGMEPP_EXPORT VerificationResult : public Result +{ +public: + VerificationResult(); + VerificationResult(gpgme_ctx_t ctx, int error); + VerificationResult(gpgme_ctx_t ctx, const Error &error); + explicit VerificationResult(const Error &err); + + const VerificationResult &operator=(VerificationResult other) + { + swap(other); + return *this; + } + + void swap(VerificationResult &other) + { + Result::swap(other); + using std::swap; + swap(this->d, other.d); + } + + bool isNull() const; + + const char *fileName() const; + + unsigned int numSignatures() const; + Signature signature(unsigned int index) const; + std::vector<Signature> signatures() const; + + class Private; +private: + void init(gpgme_ctx_t ctx); + std::shared_ptr<Private> d; +}; + +GPGMEPP_EXPORT std::ostream &operator<<(std::ostream &os, const VerificationResult &result); + +class GPGMEPP_EXPORT Signature +{ + friend class ::GpgME::VerificationResult; + Signature(const std::shared_ptr<VerificationResult::Private> &parent, unsigned int index); +public: + typedef GPGMEPP_DEPRECATED GpgME::Notation Notation; + + Signature(); + + const Signature &operator=(Signature other) + { + swap(other); + return *this; + } + + void swap(Signature &other) + { + using std::swap; + swap(this->d, other.d); + swap(this->idx, other.idx); + } + + bool isNull() const; + + enum Summary { + None = 0x000, + Valid = 0x001, + Green = 0x002, + Red = 0x004, + KeyRevoked = 0x008, + KeyExpired = 0x010, + SigExpired = 0x020, + KeyMissing = 0x040, + CrlMissing = 0x080, + CrlTooOld = 0x100, + BadPolicy = 0x200, + SysError = 0x400 + }; + Summary summary() const; + + const char *fingerprint() const; + + Error status() const; + + time_t creationTime() const; + time_t expirationTime() const; + bool neverExpires() const; + + GPGMEPP_DEPRECATED bool wrongKeyUsage() const + { + return isWrongKeyUsage(); + } + bool isWrongKeyUsage() const; + bool isVerifiedUsingChainModel() const; + + enum PKAStatus { + UnknownPKAStatus, PKAVerificationFailed, PKAVerificationSucceeded + }; + PKAStatus pkaStatus() const; + const char *pkaAddress() const; + + enum Validity { + Unknown, Undefined, Never, Marginal, Full, Ultimate + }; + Validity validity() const; + char validityAsString() const; + Error nonValidityReason() const; + + unsigned int publicKeyAlgorithm() const; + const char *publicKeyAlgorithmAsString() const; + + unsigned int hashAlgorithm() const; + const char *hashAlgorithmAsString() const; + + const char *policyURL() const; + GpgME::Notation notation(unsigned int index) const; + std::vector<GpgME::Notation> notations() const; + +private: + std::shared_ptr<VerificationResult::Private> d; + unsigned int idx; +}; + +GPGMEPP_EXPORT std::ostream &operator<<(std::ostream &os, const Signature &sig); +GPGMEPP_EXPORT std::ostream &operator<<(std::ostream &os, Signature::PKAStatus pkaStatus); +GPGMEPP_EXPORT std::ostream &operator<<(std::ostream &os, Signature::Summary summary); + +} + +GPGMEPP_MAKE_STD_SWAP_SPECIALIZATION(VerificationResult) +GPGMEPP_MAKE_STD_SWAP_SPECIALIZATION(Signature) + +#endif // __GPGMEPP_VERIFICATIONRESULT_H__ diff --git a/lang/cpp/src/vfsmountresult.cpp b/lang/cpp/src/vfsmountresult.cpp new file mode 100644 index 00000000..c9fdd5e2 --- /dev/null +++ b/lang/cpp/src/vfsmountresult.cpp @@ -0,0 +1,90 @@ +/* + vfsmountresult.cpp - wraps a gpgme vfs mount result + Copyright (C) 2009 Klarälvdalens Datakonsult AB <[email protected]> + Author: Marc Mutz <[email protected]>, Volker Krause <[email protected]> + + This file is part of GPGME++. + + GPGME++ is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + GPGME++ is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Library General Public License for more details. + + You should have received a copy of the GNU Library General Public License + along with GPGME++; see the file COPYING.LIB. If not, write to the + Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. +*/ + +#include <vfsmountresult.h> +#include "result_p.h" + +#include <gpgme.h> + +#include <istream> +#include <string.h> + +using namespace GpgME; + +class VfsMountResult::Private +{ +public: + explicit Private(const gpgme_vfs_mount_result_t r) : mountDir(0) + { + if (r && r->mount_dir) { + mountDir = strdup(r->mount_dir); + } + } + + ~Private() + { + std::free(mountDir); + } + + char *mountDir; +}; + +VfsMountResult::VfsMountResult(gpgme_ctx_t ctx, const Error &error, const Error &opError) + : Result(error ? error : opError), d() +{ + init(ctx); +} + +void VfsMountResult::init(gpgme_ctx_t ctx) +{ + (void)ctx; + if (!ctx) { + return; + } + gpgme_vfs_mount_result_t res = gpgme_op_vfs_mount_result(ctx); + if (!res) { + return; + } + d.reset(new Private(res)); +} + +make_standard_stuff(VfsMountResult) + +const char *VfsMountResult::mountDir() const +{ + if (d) { + return d->mountDir; + } + return 0; +} + +std::ostream &GpgME::operator<<(std::ostream &os, const VfsMountResult &result) +{ + os << "GpgME::VfsMountResult("; + if (!result.isNull()) { + os << "\n error: " << result.error() + << "\n mount dir: " << result.mountDir() + << "\n"; + } + return os << ')'; +} diff --git a/lang/cpp/src/vfsmountresult.h b/lang/cpp/src/vfsmountresult.h new file mode 100644 index 00000000..abdd655d --- /dev/null +++ b/lang/cpp/src/vfsmountresult.h @@ -0,0 +1,76 @@ +/* + vfsmountresult.h - wraps a gpgme vfs mount result + Copyright (C) 2009 Klarälvdalens Datakonsult AB <[email protected]> + Author: Marc Mutz <[email protected]>, Volker Krause <[email protected]> + + This file is part of GPGME++. + + GPGME++ is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + GPGME++ is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Library General Public License for more details. + + You should have received a copy of the GNU Library General Public License + along with GPGME++; see the file COPYING.LIB. If not, write to the + Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. +*/ + +#ifndef __GPGMEPP_VFSMOUNTRESULT_H__ +#define __GPGMEPP_VFSMOUNTRESULT_H__ + +#include "gpgmefw.h" +#include "result.h" +#include "gpgmepp_export.h" + +#include <memory> + +#include <vector> +#include <iosfwd> + +namespace GpgME +{ + +class Error; + +class GPGMEPP_EXPORT VfsMountResult : public Result +{ +public: + VfsMountResult(); + VfsMountResult(gpgme_ctx_t ctx, const Error &error, const Error &opError); + explicit VfsMountResult(const Error &err); + + const VfsMountResult &operator=(VfsMountResult other) + { + swap(other); + return *this; + } + + void swap(VfsMountResult &other) + { + Result::swap(other); + using std::swap; + swap(this->d, other.d); + } + + bool isNull() const; + const char *mountDir() const; + + class Private; +private: + void init(gpgme_ctx_t ctx); + std::shared_ptr<Private> d; +}; + +GPGMEPP_EXPORT std::ostream &operator<<(std::ostream &os, const VfsMountResult &result); + +} + +GPGMEPP_MAKE_STD_SWAP_SPECIALIZATION(VfsMountResult) + +#endif // __GPGMEPP_ASSUANRESULT_H__ diff --git a/lang/qt/Makefile.am b/lang/qt/Makefile.am new file mode 100644 index 00000000..39eb55ee --- /dev/null +++ b/lang/qt/Makefile.am @@ -0,0 +1,23 @@ +# Makefile.am for GPGMEPP. +# Copyright (C) 2016 Intevation GmbH +# +# This file is part of GPGMEPP. +# +# GPGME-CL 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-CL 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 Lesser General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program; if not, write to the Free Software +# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA +# 02111-1307, USA + +SUBDIRS = src tests doc + +EXTRA_DIST = README diff --git a/lang/qt/README b/lang/qt/README new file mode 100644 index 00000000..f624f601 --- /dev/null +++ b/lang/qt/README @@ -0,0 +1,40 @@ +Qt API bindings/wrapper for gpgme +---------------------------------------- +Based on KF5gpgmepp QGpgme and libkleo/backends/qgpgme + +QGpgME 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. + +QGpgME 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 this program; if not, write to the Free Software +Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + +In addition, as a special exception, the copyright holders give +permission to link the code of this program with any edition of +the Qt library by Trolltech AS, Norway (or with modified versions +of Qt that use the same license as Qt), and distribute linked +combinations including the two. You must obey the GNU General +Public License in all respects for all of the code used other than +Qt. If you modify this file, you may extend this exception to +your version of the file, but you are not obligated to do so. If +you do not wish to do so, delete this exception statement from +your version. + +Overview +-------- +QGpgme provides Qt API bindings around Gpgmepp. It depends on Gpgmepp. + +See the generated documentation for more info. + +Hacking +------- +QGpgME comes from a KDE background. As such it does not use +GNU Coding styles but KDE Coding styles. See: +https://techbase.kde.org/Policies/Frameworks_Coding_Style diff --git a/lang/qt/doc/Doxyfile.in b/lang/qt/doc/Doxyfile.in new file mode 100644 index 00000000..ef0a5c09 --- /dev/null +++ b/lang/qt/doc/Doxyfile.in @@ -0,0 +1,2352 @@ +# Doxyfile 1.8.8 + +# This file describes the settings to be used by the documentation system +# doxygen (www.doxygen.org) for a project. +# +# All text after a double hash (##) is considered a comment and is placed in +# front of the TAG it is preceding. +# +# All text after a single hash (#) is considered a comment and will be ignored. +# The format is: +# TAG = value [value, ...] +# For lists, items can also be appended using: +# TAG += value [value, ...] +# Values that contain spaces should be placed between quotes (\" \"). + +#--------------------------------------------------------------------------- +# Project related configuration options +#--------------------------------------------------------------------------- + +# This tag specifies the encoding used for all characters in the config file +# that follow. The default is UTF-8 which is also the encoding used for all text +# before the first occurrence of this tag. Doxygen uses libiconv (or the iconv +# built into libc) for the transcoding. See http://www.gnu.org/software/libiconv +# for the list of possible encodings. +# The default value is: UTF-8. + +DOXYFILE_ENCODING = UTF-8 + +# The PROJECT_NAME tag is a single word (or a sequence of words surrounded by +# double-quotes, unless you are using Doxywizard) that should identify the +# project for which the documentation is generated. This name is used in the +# title of most generated pages and in a few other places. +# The default value is: My Project. + +PROJECT_NAME = "QGpgME" + +# The PROJECT_NUMBER tag can be used to enter a project or revision number. This +# could be handy for archiving the generated documentation or if some version +# control system is used. + +PROJECT_NUMBER = "@LIBQGPGME_LT_CURRENT@.@LIBQGPGME_LT_AGE@.@LIBQGPGME_LT_REVISION@.@BUILD_REVISION@" + +# Using the PROJECT_BRIEF tag one can provide an optional one line description +# for a project that appears at the top of each page and should give viewer a +# quick idea about the purpose of the project. Keep the description short. + +PROJECT_BRIEF = "Qt API for GpgME" + +# With the PROJECT_LOGO tag one can specify an logo or icon that is included in +# the documentation. The maximum height of the logo should not exceed 55 pixels +# and the maximum width should not exceed 200 pixels. Doxygen will copy the logo +# to the output directory. + +PROJECT_LOGO = + +# The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute) path +# into which the generated documentation will be written. If a relative path is +# entered, it will be relative to the location where doxygen was started. If +# left blank the current directory will be used. + +OUTPUT_DIRECTORY = "@abs_builddir@/generated" + +# If the CREATE_SUBDIRS tag is set to YES, then doxygen will create 4096 sub- +# directories (in 2 levels) under the output directory of each output format and +# will distribute the generated files over these directories. Enabling this +# option can be useful when feeding doxygen a huge amount of source files, where +# putting all generated files in the same directory would otherwise causes +# performance problems for the file system. +# The default value is: NO. + +CREATE_SUBDIRS = NO + +# If the ALLOW_UNICODE_NAMES tag is set to YES, doxygen will allow non-ASCII +# characters to appear in the names of generated files. If set to NO, non-ASCII +# characters will be escaped, for example _xE3_x81_x84 will be used for Unicode +# U+3044. +# The default value is: NO. + +ALLOW_UNICODE_NAMES = NO + +# The OUTPUT_LANGUAGE tag is used to specify the language in which all +# documentation generated by doxygen is written. Doxygen will use this +# information to generate all constant output in the proper language. +# Possible values are: Afrikaans, Arabic, Armenian, Brazilian, Catalan, Chinese, +# Chinese-Traditional, Croatian, Czech, Danish, Dutch, English (United States), +# Esperanto, Farsi (Persian), Finnish, French, German, Greek, Hungarian, +# Indonesian, Italian, Japanese, Japanese-en (Japanese with English messages), +# Korean, Korean-en (Korean with English messages), Latvian, Lithuanian, +# Macedonian, Norwegian, Persian (Farsi), Polish, Portuguese, Romanian, Russian, +# Serbian, Serbian-Cyrillic, Slovak, Slovene, Spanish, Swedish, Turkish, +# Ukrainian and Vietnamese. +# The default value is: English. + +OUTPUT_LANGUAGE = English + +# If the BRIEF_MEMBER_DESC tag is set to YES doxygen will include brief member +# descriptions after the members that are listed in the file and class +# documentation (similar to Javadoc). Set to NO to disable this. +# The default value is: YES. + +BRIEF_MEMBER_DESC = YES + +# If the REPEAT_BRIEF tag is set to YES doxygen will prepend the brief +# description of a member or function before the detailed description +# +# Note: If both HIDE_UNDOC_MEMBERS and BRIEF_MEMBER_DESC are set to NO, the +# brief descriptions will be completely suppressed. +# The default value is: YES. + +REPEAT_BRIEF = YES + +# This tag implements a quasi-intelligent brief description abbreviator that is +# used to form the text in various listings. Each string in this list, if found +# as the leading text of the brief description, will be stripped from the text +# and the result, after processing the whole list, is used as the annotated +# text. Otherwise, the brief description is used as-is. If left blank, the +# following values are used ($name is automatically replaced with the name of +# the entity):The $name class, The $name widget, The $name file, is, provides, +# specifies, contains, represents, a, an and the. + +ABBREVIATE_BRIEF = + +# If the ALWAYS_DETAILED_SEC and REPEAT_BRIEF tags are both set to YES then +# doxygen will generate a detailed section even if there is only a brief +# description. +# The default value is: NO. + +ALWAYS_DETAILED_SEC = NO + +# If the INLINE_INHERITED_MEMB tag is set to YES, doxygen will show all +# inherited members of a class in the documentation of that class as if those +# members were ordinary class members. Constructors, destructors and assignment +# operators of the base classes will not be shown. +# The default value is: NO. + +INLINE_INHERITED_MEMB = NO + +# If the FULL_PATH_NAMES tag is set to YES doxygen will prepend the full path +# before files name in the file list and in the header files. If set to NO the +# shortest path that makes the file name unique will be used +# The default value is: YES. + +FULL_PATH_NAMES = YES + +# The STRIP_FROM_PATH tag can be used to strip a user-defined part of the path. +# Stripping is only done if one of the specified strings matches the left-hand +# part of the path. The tag can be used to show relative paths in the file list. +# If left blank the directory from which doxygen is run is used as the path to +# strip. +# +# Note that you can specify absolute paths here, but also relative paths, which +# will be relative from the directory where doxygen is started. +# This tag requires that the tag FULL_PATH_NAMES is set to YES. + +STRIP_FROM_PATH = + +# The STRIP_FROM_INC_PATH tag can be used to strip a user-defined part of the +# path mentioned in the documentation of a class, which tells the reader which +# header file to include in order to use a class. If left blank only the name of +# the header file containing the class definition is used. Otherwise one should +# specify the list of include paths that are normally passed to the compiler +# using the -I flag. + +STRIP_FROM_INC_PATH = + +# If the SHORT_NAMES tag is set to YES, doxygen will generate much shorter (but +# less readable) file names. This can be useful is your file systems doesn't +# support long names like on DOS, Mac, or CD-ROM. +# The default value is: NO. + +SHORT_NAMES = NO + +# If the JAVADOC_AUTOBRIEF tag is set to YES then doxygen will interpret the +# first line (until the first dot) of a Javadoc-style comment as the brief +# description. If set to NO, the Javadoc-style will behave just like regular Qt- +# style comments (thus requiring an explicit @brief command for a brief +# description.) +# The default value is: NO. + +JAVADOC_AUTOBRIEF = NO + +# If the QT_AUTOBRIEF tag is set to YES then doxygen will interpret the first +# line (until the first dot) of a Qt-style comment as the brief description. If +# set to NO, the Qt-style will behave just like regular Qt-style comments (thus +# requiring an explicit \brief command for a brief description.) +# The default value is: NO. + +QT_AUTOBRIEF = NO + +# The MULTILINE_CPP_IS_BRIEF tag can be set to YES to make doxygen treat a +# multi-line C++ special comment block (i.e. a block of //! or /// comments) as +# a brief description. This used to be the default behavior. The new default is +# to treat a multi-line C++ comment block as a detailed description. Set this +# tag to YES if you prefer the old behavior instead. +# +# Note that setting this tag to YES also means that rational rose comments are +# not recognized any more. +# The default value is: NO. + +MULTILINE_CPP_IS_BRIEF = NO + +# If the INHERIT_DOCS tag is set to YES then an undocumented member inherits the +# documentation from any documented member that it re-implements. +# The default value is: YES. + +INHERIT_DOCS = YES + +# If the SEPARATE_MEMBER_PAGES tag is set to YES, then doxygen will produce a +# new page for each member. If set to NO, the documentation of a member will be +# part of the file/class/namespace that contains it. +# The default value is: NO. + +SEPARATE_MEMBER_PAGES = NO + +# The TAB_SIZE tag can be used to set the number of spaces in a tab. Doxygen +# uses this value to replace tabs by spaces in code fragments. +# Minimum value: 1, maximum value: 16, default value: 4. + +TAB_SIZE = 4 + +# This tag can be used to specify a number of aliases that act as commands in +# the documentation. An alias has the form: +# name=value +# For example adding +# "sideeffect=@par Side Effects:\n" +# will allow you to put the command \sideeffect (or @sideeffect) in the +# documentation, which will result in a user-defined paragraph with heading +# "Side Effects:". You can put \n's in the value part of an alias to insert +# newlines. + +ALIASES = + +# This tag can be used to specify a number of word-keyword mappings (TCL only). +# A mapping has the form "name=value". For example adding "class=itcl::class" +# will allow you to use the command class in the itcl::class meaning. + +TCL_SUBST = + +# Set the OPTIMIZE_OUTPUT_FOR_C tag to YES if your project consists of C sources +# only. Doxygen will then generate output that is more tailored for C. For +# instance, some of the names that are used will be different. The list of all +# members will be omitted, etc. +# The default value is: NO. + +OPTIMIZE_OUTPUT_FOR_C = NO + +# Set the OPTIMIZE_OUTPUT_JAVA tag to YES if your project consists of Java or +# Python sources only. Doxygen will then generate output that is more tailored +# for that language. For instance, namespaces will be presented as packages, +# qualified scopes will look different, etc. +# The default value is: NO. + +OPTIMIZE_OUTPUT_JAVA = NO + +# Set the OPTIMIZE_FOR_FORTRAN tag to YES if your project consists of Fortran +# sources. Doxygen will then generate output that is tailored for Fortran. +# The default value is: NO. + +OPTIMIZE_FOR_FORTRAN = NO + +# Set the OPTIMIZE_OUTPUT_VHDL tag to YES if your project consists of VHDL +# sources. Doxygen will then generate output that is tailored for VHDL. +# The default value is: NO. + +OPTIMIZE_OUTPUT_VHDL = NO + +# Doxygen selects the parser to use depending on the extension of the files it +# parses. With this tag you can assign which parser to use for a given +# extension. Doxygen has a built-in mapping, but you can override or extend it +# using this tag. The format is ext=language, where ext is a file extension, and +# language is one of the parsers supported by doxygen: IDL, Java, Javascript, +# C#, C, C++, D, PHP, Objective-C, Python, Fortran (fixed format Fortran: +# FortranFixed, free formatted Fortran: FortranFree, unknown formatted Fortran: +# Fortran. In the later case the parser tries to guess whether the code is fixed +# or free formatted code, this is the default for Fortran type files), VHDL. For +# instance to make doxygen treat .inc files as Fortran files (default is PHP), +# and .f files as C (default is Fortran), use: inc=Fortran f=C. +# +# Note For files without extension you can use no_extension as a placeholder. +# +# Note that for custom extensions you also need to set FILE_PATTERNS otherwise +# the files are not read by doxygen. + +EXTENSION_MAPPING = + +# If the MARKDOWN_SUPPORT tag is enabled then doxygen pre-processes all comments +# according to the Markdown format, which allows for more readable +# documentation. See http://daringfireball.net/projects/markdown/ for details. +# The output of markdown processing is further processed by doxygen, so you can +# mix doxygen, HTML, and XML commands with Markdown formatting. Disable only in +# case of backward compatibilities issues. +# The default value is: YES. + +MARKDOWN_SUPPORT = YES + +# When enabled doxygen tries to link words that correspond to documented +# classes, or namespaces to their corresponding documentation. Such a link can +# be prevented in individual cases by by putting a % sign in front of the word +# or globally by setting AUTOLINK_SUPPORT to NO. +# The default value is: YES. + +AUTOLINK_SUPPORT = YES + +# If you use STL classes (i.e. std::string, std::vector, etc.) but do not want +# to include (a tag file for) the STL sources as input, then you should set this +# tag to YES in order to let doxygen match functions declarations and +# definitions whose arguments contain STL classes (e.g. func(std::string); +# versus func(std::string) {}). This also make the inheritance and collaboration +# diagrams that involve STL classes more complete and accurate. +# The default value is: NO. + +BUILTIN_STL_SUPPORT = NO + +# If you use Microsoft's C++/CLI language, you should set this option to YES to +# enable parsing support. +# The default value is: NO. + +CPP_CLI_SUPPORT = NO + +# Set the SIP_SUPPORT tag to YES if your project consists of sip (see: +# http://www.riverbankcomputing.co.uk/software/sip/intro) sources only. Doxygen +# will parse them like normal C++ but will assume all classes use public instead +# of private inheritance when no explicit protection keyword is present. +# The default value is: NO. + +SIP_SUPPORT = NO + +# For Microsoft's IDL there are propget and propput attributes to indicate +# getter and setter methods for a property. Setting this option to YES will make +# doxygen to replace the get and set methods by a property in the documentation. +# This will only work if the methods are indeed getting or setting a simple +# type. If this is not the case, or you want to show the methods anyway, you +# should set this option to NO. +# The default value is: YES. + +IDL_PROPERTY_SUPPORT = YES + +# If member grouping is used in the documentation and the DISTRIBUTE_GROUP_DOC +# tag is set to YES, then doxygen will reuse the documentation of the first +# member in the group (if any) for the other members of the group. By default +# all members of a group must be documented explicitly. +# The default value is: NO. + +DISTRIBUTE_GROUP_DOC = NO + +# Set the SUBGROUPING tag to YES to allow class member groups of the same type +# (for instance a group of public functions) to be put as a subgroup of that +# type (e.g. under the Public Functions section). Set it to NO to prevent +# subgrouping. Alternatively, this can be done per class using the +# \nosubgrouping command. +# The default value is: YES. + +SUBGROUPING = YES + +# When the INLINE_GROUPED_CLASSES tag is set to YES, classes, structs and unions +# are shown inside the group in which they are included (e.g. using \ingroup) +# instead of on a separate page (for HTML and Man pages) or section (for LaTeX +# and RTF). +# +# Note that this feature does not work in combination with +# SEPARATE_MEMBER_PAGES. +# The default value is: NO. + +INLINE_GROUPED_CLASSES = NO + +# When the INLINE_SIMPLE_STRUCTS tag is set to YES, structs, classes, and unions +# with only public data fields or simple typedef fields will be shown inline in +# the documentation of the scope in which they are defined (i.e. file, +# namespace, or group documentation), provided this scope is documented. If set +# to NO, structs, classes, and unions are shown on a separate page (for HTML and +# Man pages) or section (for LaTeX and RTF). +# The default value is: NO. + +INLINE_SIMPLE_STRUCTS = NO + +# When TYPEDEF_HIDES_STRUCT tag is enabled, a typedef of a struct, union, or +# enum is documented as struct, union, or enum with the name of the typedef. So +# typedef struct TypeS {} TypeT, will appear in the documentation as a struct +# with name TypeT. When disabled the typedef will appear as a member of a file, +# namespace, or class. And the struct will be named TypeS. This can typically be +# useful for C code in case the coding convention dictates that all compound +# types are typedef'ed and only the typedef is referenced, never the tag name. +# The default value is: NO. + +TYPEDEF_HIDES_STRUCT = NO + +# The size of the symbol lookup cache can be set using LOOKUP_CACHE_SIZE. This +# cache is used to resolve symbols given their name and scope. Since this can be +# an expensive process and often the same symbol appears multiple times in the +# code, doxygen keeps a cache of pre-resolved symbols. If the cache is too small +# doxygen will become slower. If the cache is too large, memory is wasted. The +# cache size is given by this formula: 2^(16+LOOKUP_CACHE_SIZE). The valid range +# is 0..9, the default is 0, corresponding to a cache size of 2^16=65536 +# symbols. At the end of a run doxygen will report the cache usage and suggest +# the optimal cache size from a speed point of view. +# Minimum value: 0, maximum value: 9, default value: 0. + +LOOKUP_CACHE_SIZE = 0 + +#--------------------------------------------------------------------------- +# Build related configuration options +#--------------------------------------------------------------------------- + +# If the EXTRACT_ALL tag is set to YES doxygen will assume all entities in +# documentation are documented, even if no documentation was available. Private +# class members and static file members will be hidden unless the +# EXTRACT_PRIVATE respectively EXTRACT_STATIC tags are set to YES. +# Note: This will also disable the warnings about undocumented members that are +# normally produced when WARNINGS is set to YES. +# The default value is: NO. + +EXTRACT_ALL = NO + +# If the EXTRACT_PRIVATE tag is set to YES all private members of a class will +# be included in the documentation. +# The default value is: NO. + +EXTRACT_PRIVATE = NO + +# If the EXTRACT_PACKAGE tag is set to YES all members with package or internal +# scope will be included in the documentation. +# The default value is: NO. + +EXTRACT_PACKAGE = NO + +# If the EXTRACT_STATIC tag is set to YES all static members of a file will be +# included in the documentation. +# The default value is: NO. + +EXTRACT_STATIC = NO + +# If the EXTRACT_LOCAL_CLASSES tag is set to YES classes (and structs) defined +# locally in source files will be included in the documentation. If set to NO +# only classes defined in header files are included. Does not have any effect +# for Java sources. +# The default value is: YES. + +EXTRACT_LOCAL_CLASSES = YES + +# This flag is only useful for Objective-C code. When set to YES local methods, +# which are defined in the implementation section but not in the interface are +# included in the documentation. If set to NO only methods in the interface are +# included. +# The default value is: NO. + +EXTRACT_LOCAL_METHODS = NO + +# If this flag is set to YES, the members of anonymous namespaces will be +# extracted and appear in the documentation as a namespace called +# 'anonymous_namespace{file}', where file will be replaced with the base name of +# the file that contains the anonymous namespace. By default anonymous namespace +# are hidden. +# The default value is: NO. + +EXTRACT_ANON_NSPACES = NO + +# If the HIDE_UNDOC_MEMBERS tag is set to YES, doxygen will hide all +# undocumented members inside documented classes or files. If set to NO these +# members will be included in the various overviews, but no documentation +# section is generated. This option has no effect if EXTRACT_ALL is enabled. +# The default value is: NO. + +HIDE_UNDOC_MEMBERS = NO + +# If the HIDE_UNDOC_CLASSES tag is set to YES, doxygen will hide all +# undocumented classes that are normally visible in the class hierarchy. If set +# to NO these classes will be included in the various overviews. This option has +# no effect if EXTRACT_ALL is enabled. +# The default value is: NO. + +HIDE_UNDOC_CLASSES = NO + +# If the HIDE_FRIEND_COMPOUNDS tag is set to YES, doxygen will hide all friend +# (class|struct|union) declarations. If set to NO these declarations will be +# included in the documentation. +# The default value is: NO. + +HIDE_FRIEND_COMPOUNDS = NO + +# If the HIDE_IN_BODY_DOCS tag is set to YES, doxygen will hide any +# documentation blocks found inside the body of a function. If set to NO these +# blocks will be appended to the function's detailed documentation block. +# The default value is: NO. + +HIDE_IN_BODY_DOCS = NO + +# The INTERNAL_DOCS tag determines if documentation that is typed after a +# \internal command is included. If the tag is set to NO then the documentation +# will be excluded. Set it to YES to include the internal documentation. +# The default value is: NO. + +INTERNAL_DOCS = NO + +# If the CASE_SENSE_NAMES tag is set to NO then doxygen will only generate file +# names in lower-case letters. If set to YES upper-case letters are also +# allowed. This is useful if you have classes or files whose names only differ +# in case and if your file system supports case sensitive file names. Windows +# and Mac users are advised to set this option to NO. +# The default value is: system dependent. + +CASE_SENSE_NAMES = YES + +# If the HIDE_SCOPE_NAMES tag is set to NO then doxygen will show members with +# their full class and namespace scopes in the documentation. If set to YES the +# scope will be hidden. +# The default value is: NO. + +HIDE_SCOPE_NAMES = NO + +# If the SHOW_INCLUDE_FILES tag is set to YES then doxygen will put a list of +# the files that are included by a file in the documentation of that file. +# The default value is: YES. + +SHOW_INCLUDE_FILES = YES + +# If the SHOW_GROUPED_MEMB_INC tag is set to YES then Doxygen will add for each +# grouped member an include statement to the documentation, telling the reader +# which file to include in order to use the member. +# The default value is: NO. + +SHOW_GROUPED_MEMB_INC = NO + +# If the FORCE_LOCAL_INCLUDES tag is set to YES then doxygen will list include +# files with double quotes in the documentation rather than with sharp brackets. +# The default value is: NO. + +FORCE_LOCAL_INCLUDES = NO + +# If the INLINE_INFO tag is set to YES then a tag [inline] is inserted in the +# documentation for inline members. +# The default value is: YES. + +INLINE_INFO = YES + +# If the SORT_MEMBER_DOCS tag is set to YES then doxygen will sort the +# (detailed) documentation of file and class members alphabetically by member +# name. If set to NO the members will appear in declaration order. +# The default value is: YES. + +SORT_MEMBER_DOCS = YES + +# If the SORT_BRIEF_DOCS tag is set to YES then doxygen will sort the brief +# descriptions of file, namespace and class members alphabetically by member +# name. If set to NO the members will appear in declaration order. Note that +# this will also influence the order of the classes in the class list. +# The default value is: NO. + +SORT_BRIEF_DOCS = NO + +# If the SORT_MEMBERS_CTORS_1ST tag is set to YES then doxygen will sort the +# (brief and detailed) documentation of class members so that constructors and +# destructors are listed first. If set to NO the constructors will appear in the +# respective orders defined by SORT_BRIEF_DOCS and SORT_MEMBER_DOCS. +# Note: If SORT_BRIEF_DOCS is set to NO this option is ignored for sorting brief +# member documentation. +# Note: If SORT_MEMBER_DOCS is set to NO this option is ignored for sorting +# detailed member documentation. +# The default value is: NO. + +SORT_MEMBERS_CTORS_1ST = NO + +# If the SORT_GROUP_NAMES tag is set to YES then doxygen will sort the hierarchy +# of group names into alphabetical order. If set to NO the group names will +# appear in their defined order. +# The default value is: NO. + +SORT_GROUP_NAMES = NO + +# If the SORT_BY_SCOPE_NAME tag is set to YES, the class list will be sorted by +# fully-qualified names, including namespaces. If set to NO, the class list will +# be sorted only by class name, not including the namespace part. +# Note: This option is not very useful if HIDE_SCOPE_NAMES is set to YES. +# Note: This option applies only to the class list, not to the alphabetical +# list. +# The default value is: NO. + +SORT_BY_SCOPE_NAME = NO + +# If the STRICT_PROTO_MATCHING option is enabled and doxygen fails to do proper +# type resolution of all parameters of a function it will reject a match between +# the prototype and the implementation of a member function even if there is +# only one candidate or it is obvious which candidate to choose by doing a +# simple string match. By disabling STRICT_PROTO_MATCHING doxygen will still +# accept a match between prototype and implementation in such cases. +# The default value is: NO. + +STRICT_PROTO_MATCHING = NO + +# The GENERATE_TODOLIST tag can be used to enable ( YES) or disable ( NO) the +# todo list. This list is created by putting \todo commands in the +# documentation. +# The default value is: YES. + +GENERATE_TODOLIST = YES + +# The GENERATE_TESTLIST tag can be used to enable ( YES) or disable ( NO) the +# test list. This list is created by putting \test commands in the +# documentation. +# The default value is: YES. + +GENERATE_TESTLIST = YES + +# The GENERATE_BUGLIST tag can be used to enable ( YES) or disable ( NO) the bug +# list. This list is created by putting \bug commands in the documentation. +# The default value is: YES. + +GENERATE_BUGLIST = YES + +# The GENERATE_DEPRECATEDLIST tag can be used to enable ( YES) or disable ( NO) +# the deprecated list. This list is created by putting \deprecated commands in +# the documentation. +# The default value is: YES. + +GENERATE_DEPRECATEDLIST= YES + +# The ENABLED_SECTIONS tag can be used to enable conditional documentation +# sections, marked by \if <section_label> ... \endif and \cond <section_label> +# ... \endcond blocks. + +ENABLED_SECTIONS = + +# The MAX_INITIALIZER_LINES tag determines the maximum number of lines that the +# initial value of a variable or macro / define can have for it to appear in the +# documentation. If the initializer consists of more lines than specified here +# it will be hidden. Use a value of 0 to hide initializers completely. The +# appearance of the value of individual variables and macros / defines can be +# controlled using \showinitializer or \hideinitializer command in the +# documentation regardless of this setting. +# Minimum value: 0, maximum value: 10000, default value: 30. + +MAX_INITIALIZER_LINES = 30 + +# Set the SHOW_USED_FILES tag to NO to disable the list of files generated at +# the bottom of the documentation of classes and structs. If set to YES the list +# will mention the files that were used to generate the documentation. +# The default value is: YES. + +SHOW_USED_FILES = YES + +# Set the SHOW_FILES tag to NO to disable the generation of the Files page. This +# will remove the Files entry from the Quick Index and from the Folder Tree View +# (if specified). +# The default value is: YES. + +SHOW_FILES = YES + +# Set the SHOW_NAMESPACES tag to NO to disable the generation of the Namespaces +# page. This will remove the Namespaces entry from the Quick Index and from the +# Folder Tree View (if specified). +# The default value is: YES. + +SHOW_NAMESPACES = YES + +# The FILE_VERSION_FILTER tag can be used to specify a program or script that +# doxygen should invoke to get the current version for each file (typically from +# the version control system). Doxygen will invoke the program by executing (via +# popen()) the command command input-file, where command is the value of the +# FILE_VERSION_FILTER tag, and input-file is the name of an input file provided +# by doxygen. Whatever the program writes to standard output is used as the file +# version. For an example see the documentation. + +FILE_VERSION_FILTER = + +# The LAYOUT_FILE tag can be used to specify a layout file which will be parsed +# by doxygen. The layout file controls the global structure of the generated +# output files in an output format independent way. To create the layout file +# that represents doxygen's defaults, run doxygen with the -l option. You can +# optionally specify a file name after the option, if omitted DoxygenLayout.xml +# will be used as the name of the layout file. +# +# Note that if you run doxygen from a directory containing a file called +# DoxygenLayout.xml, doxygen will parse it automatically even if the LAYOUT_FILE +# tag is left empty. + +LAYOUT_FILE = + +# The CITE_BIB_FILES tag can be used to specify one or more bib files containing +# the reference definitions. This must be a list of .bib files. The .bib +# extension is automatically appended if omitted. This requires the bibtex tool +# to be installed. See also http://en.wikipedia.org/wiki/BibTeX for more info. +# For LaTeX the style of the bibliography can be controlled using +# LATEX_BIB_STYLE. To use this feature you need bibtex and perl available in the +# search path. See also \cite for info how to create references. + +CITE_BIB_FILES = + +#--------------------------------------------------------------------------- +# Configuration options related to warning and progress messages +#--------------------------------------------------------------------------- + +# The QUIET tag can be used to turn on/off the messages that are generated to +# standard output by doxygen. If QUIET is set to YES this implies that the +# messages are off. +# The default value is: NO. + +QUIET = YES + +# The WARNINGS tag can be used to turn on/off the warning messages that are +# generated to standard error ( stderr) by doxygen. If WARNINGS is set to YES +# this implies that the warnings are on. +# +# Tip: Turn warnings on while writing the documentation. +# The default value is: YES. + +WARNINGS = YES + +# If the WARN_IF_UNDOCUMENTED tag is set to YES, then doxygen will generate +# warnings for undocumented members. If EXTRACT_ALL is set to YES then this flag +# will automatically be disabled. +# The default value is: YES. + +WARN_IF_UNDOCUMENTED = NO + +# If the WARN_IF_DOC_ERROR tag is set to YES, doxygen will generate warnings for +# potential errors in the documentation, such as not documenting some parameters +# in a documented function, or documenting parameters that don't exist or using +# markup commands wrongly. +# The default value is: YES. + +WARN_IF_DOC_ERROR = YES + +# This WARN_NO_PARAMDOC option can be enabled to get warnings for functions that +# are documented, but have no documentation for their parameters or return +# value. If set to NO doxygen will only warn about wrong or incomplete parameter +# documentation, but not about the absence of documentation. +# The default value is: NO. + +WARN_NO_PARAMDOC = NO + +# The WARN_FORMAT tag determines the format of the warning messages that doxygen +# can produce. The string should contain the $file, $line, and $text tags, which +# will be replaced by the file and line number from which the warning originated +# and the warning text. Optionally the format may contain $version, which will +# be replaced by the version of the file (if it could be obtained via +# FILE_VERSION_FILTER) +# The default value is: $file:$line: $text. + +WARN_FORMAT = "$file:$line: $text" + +# The WARN_LOGFILE tag can be used to specify a file to which warning and error +# messages should be written. If left blank the output is written to standard +# error (stderr). + +WARN_LOGFILE = + +#--------------------------------------------------------------------------- +# Configuration options related to the input files +#--------------------------------------------------------------------------- + +# The INPUT tag is used to specify the files and/or directories that contain +# documented source files. You may enter file names like myfile.cpp or +# directories like /usr/src/myproject. Separate the files or directories with +# spaces. +# Note: If this tag is empty the current directory is searched. + +INPUT = "@top_srcdir@/lang/qt/src" + +# This tag can be used to specify the character encoding of the source files +# that doxygen parses. Internally doxygen uses the UTF-8 encoding. Doxygen uses +# libiconv (or the iconv built into libc) for the transcoding. See the libiconv +# documentation (see: http://www.gnu.org/software/libiconv) for the list of +# possible encodings. +# The default value is: UTF-8. + +INPUT_ENCODING = UTF-8 + +# If the value of the INPUT tag contains directories, you can use the +# FILE_PATTERNS tag to specify one or more wildcard patterns (like *.cpp and +# *.h) to filter out the source-files in the directories. If left blank the +# following patterns are tested:*.c, *.cc, *.cxx, *.cpp, *.c++, *.java, *.ii, +# *.ixx, *.ipp, *.i++, *.inl, *.idl, *.ddl, *.odl, *.h, *.hh, *.hxx, *.hpp, +# *.h++, *.cs, *.d, *.php, *.php4, *.php5, *.phtml, *.inc, *.m, *.markdown, +# *.md, *.mm, *.dox, *.py, *.f90, *.f, *.for, *.tcl, *.vhd, *.vhdl, *.ucf, +# *.qsf, *.as and *.js. + +FILE_PATTERNS = + +# The RECURSIVE tag can be used to specify whether or not subdirectories should +# be searched for input files as well. +# The default value is: NO. + +RECURSIVE = NO + +# The EXCLUDE tag can be used to specify files and/or directories that should be +# excluded from the INPUT source files. This way you can easily exclude a +# subdirectory from a directory tree whose root is specified with the INPUT tag. +# +# Note that relative paths are relative to the directory from which doxygen is +# run. + +EXCLUDE = + +# The EXCLUDE_SYMLINKS tag can be used to select whether or not files or +# directories that are symbolic links (a Unix file system feature) are excluded +# from the input. +# The default value is: NO. + +EXCLUDE_SYMLINKS = NO + +# If the value of the INPUT tag contains directories, you can use the +# EXCLUDE_PATTERNS tag to specify one or more wildcard patterns to exclude +# certain files from those directories. +# +# Note that the wildcards are matched against the file with absolute path, so to +# exclude all test directories for example use the pattern */test/* + +EXCLUDE_PATTERNS = + +# The EXCLUDE_SYMBOLS tag can be used to specify one or more symbol names +# (namespaces, classes, functions, etc.) that should be excluded from the +# output. The symbol name can be a fully qualified name, a word, or if the +# wildcard * is used, a substring. Examples: ANamespace, AClass, +# AClass::ANamespace, ANamespace::*Test +# +# Note that the wildcards are matched against the file with absolute path, so to +# exclude all test directories use the pattern */test/* + +EXCLUDE_SYMBOLS = + +# The EXAMPLE_PATH tag can be used to specify one or more files or directories +# that contain example code fragments that are included (see the \include +# command). + +EXAMPLE_PATH = + +# If the value of the EXAMPLE_PATH tag contains directories, you can use the +# EXAMPLE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp and +# *.h) to filter out the source-files in the directories. If left blank all +# files are included. + +EXAMPLE_PATTERNS = + +# If the EXAMPLE_RECURSIVE tag is set to YES then subdirectories will be +# searched for input files to be used with the \include or \dontinclude commands +# irrespective of the value of the RECURSIVE tag. +# The default value is: NO. + +EXAMPLE_RECURSIVE = NO + +# The IMAGE_PATH tag can be used to specify one or more files or directories +# that contain images that are to be included in the documentation (see the +# \image command). + +IMAGE_PATH = + +# The INPUT_FILTER tag can be used to specify a program that doxygen should +# invoke to filter for each input file. Doxygen will invoke the filter program +# by executing (via popen()) the command: +# +# <filter> <input-file> +# +# where <filter> is the value of the INPUT_FILTER tag, and <input-file> is the +# name of an input file. Doxygen will then use the output that the filter +# program writes to standard output. If FILTER_PATTERNS is specified, this tag +# will be ignored. +# +# Note that the filter must not add or remove lines; it is applied before the +# code is scanned, but not when the output code is generated. If lines are added +# or removed, the anchors will not be placed correctly. + +INPUT_FILTER = + +# The FILTER_PATTERNS tag can be used to specify filters on a per file pattern +# basis. Doxygen will compare the file name with each pattern and apply the +# filter if there is a match. The filters are a list of the form: pattern=filter +# (like *.cpp=my_cpp_filter). See INPUT_FILTER for further information on how +# filters are used. If the FILTER_PATTERNS tag is empty or if none of the +# patterns match the file name, INPUT_FILTER is applied. + +FILTER_PATTERNS = + +# If the FILTER_SOURCE_FILES tag is set to YES, the input filter (if set using +# INPUT_FILTER ) will also be used to filter the input files that are used for +# producing the source files to browse (i.e. when SOURCE_BROWSER is set to YES). +# The default value is: NO. + +FILTER_SOURCE_FILES = NO + +# The FILTER_SOURCE_PATTERNS tag can be used to specify source filters per file +# pattern. A pattern will override the setting for FILTER_PATTERN (if any) and +# it is also possible to disable source filtering for a specific pattern using +# *.ext= (so without naming a filter). +# This tag requires that the tag FILTER_SOURCE_FILES is set to YES. + +FILTER_SOURCE_PATTERNS = + +# If the USE_MDFILE_AS_MAINPAGE tag refers to the name of a markdown file that +# is part of the input, its contents will be placed on the main page +# (index.html). This can be useful if you have a project on for instance GitHub +# and want to reuse the introduction page also for the doxygen output. + +USE_MDFILE_AS_MAINPAGE = + +#--------------------------------------------------------------------------- +# Configuration options related to source browsing +#--------------------------------------------------------------------------- + +# If the SOURCE_BROWSER tag is set to YES then a list of source files will be +# generated. Documented entities will be cross-referenced with these sources. +# +# Note: To get rid of all source code in the generated output, make sure that +# also VERBATIM_HEADERS is set to NO. +# The default value is: NO. + +SOURCE_BROWSER = NO + +# Setting the INLINE_SOURCES tag to YES will include the body of functions, +# classes and enums directly into the documentation. +# The default value is: NO. + +INLINE_SOURCES = NO + +# Setting the STRIP_CODE_COMMENTS tag to YES will instruct doxygen to hide any +# special comment blocks from generated source code fragments. Normal C, C++ and +# Fortran comments will always remain visible. +# The default value is: YES. + +STRIP_CODE_COMMENTS = YES + +# If the REFERENCED_BY_RELATION tag is set to YES then for each documented +# function all documented functions referencing it will be listed. +# The default value is: NO. + +REFERENCED_BY_RELATION = NO + +# If the REFERENCES_RELATION tag is set to YES then for each documented function +# all documented entities called/used by that function will be listed. +# The default value is: NO. + +REFERENCES_RELATION = NO + +# If the REFERENCES_LINK_SOURCE tag is set to YES and SOURCE_BROWSER tag is set +# to YES, then the hyperlinks from functions in REFERENCES_RELATION and +# REFERENCED_BY_RELATION lists will link to the source code. Otherwise they will +# link to the documentation. +# The default value is: YES. + +REFERENCES_LINK_SOURCE = YES + +# If SOURCE_TOOLTIPS is enabled (the default) then hovering a hyperlink in the +# source code will show a tooltip with additional information such as prototype, +# brief description and links to the definition and documentation. Since this +# will make the HTML file larger and loading of large files a bit slower, you +# can opt to disable this feature. +# The default value is: YES. +# This tag requires that the tag SOURCE_BROWSER is set to YES. + +SOURCE_TOOLTIPS = YES + +# If the USE_HTAGS tag is set to YES then the references to source code will +# point to the HTML generated by the htags(1) tool instead of doxygen built-in +# source browser. The htags tool is part of GNU's global source tagging system +# (see http://www.gnu.org/software/global/global.html). You will need version +# 4.8.6 or higher. +# +# To use it do the following: +# - Install the latest version of global +# - Enable SOURCE_BROWSER and USE_HTAGS in the config file +# - Make sure the INPUT points to the root of the source tree +# - Run doxygen as normal +# +# Doxygen will invoke htags (and that will in turn invoke gtags), so these +# tools must be available from the command line (i.e. in the search path). +# +# The result: instead of the source browser generated by doxygen, the links to +# source code will now point to the output of htags. +# The default value is: NO. +# This tag requires that the tag SOURCE_BROWSER is set to YES. + +USE_HTAGS = NO + +# If the VERBATIM_HEADERS tag is set the YES then doxygen will generate a +# verbatim copy of the header file for each class for which an include is +# specified. Set to NO to disable this. +# See also: Section \class. +# The default value is: YES. + +VERBATIM_HEADERS = YES + +# If the CLANG_ASSISTED_PARSING tag is set to YES, then doxygen will use the +# clang parser (see: http://clang.llvm.org/) for more accurate parsing at the +# cost of reduced performance. This can be particularly helpful with template +# rich C++ code for which doxygen's built-in parser lacks the necessary type +# information. +# Note: The availability of this option depends on whether or not doxygen was +# compiled with the --with-libclang option. +# The default value is: NO. + +CLANG_ASSISTED_PARSING = NO + +# If clang assisted parsing is enabled you can provide the compiler with command +# line options that you would normally use when invoking the compiler. Note that +# the include paths will already be set by doxygen for the files and directories +# specified with INPUT and INCLUDE_PATH. +# This tag requires that the tag CLANG_ASSISTED_PARSING is set to YES. + +CLANG_OPTIONS = + +#--------------------------------------------------------------------------- +# Configuration options related to the alphabetical class index +#--------------------------------------------------------------------------- + +# If the ALPHABETICAL_INDEX tag is set to YES, an alphabetical index of all +# compounds will be generated. Enable this if the project contains a lot of +# classes, structs, unions or interfaces. +# The default value is: YES. + +ALPHABETICAL_INDEX = YES + +# The COLS_IN_ALPHA_INDEX tag can be used to specify the number of columns in +# which the alphabetical index list will be split. +# Minimum value: 1, maximum value: 20, default value: 5. +# This tag requires that the tag ALPHABETICAL_INDEX is set to YES. + +COLS_IN_ALPHA_INDEX = 5 + +# In case all classes in a project start with a common prefix, all classes will +# be put under the same header in the alphabetical index. The IGNORE_PREFIX tag +# can be used to specify a prefix (or a list of prefixes) that should be ignored +# while generating the index headers. +# This tag requires that the tag ALPHABETICAL_INDEX is set to YES. + +IGNORE_PREFIX = + +#--------------------------------------------------------------------------- +# Configuration options related to the HTML output +#--------------------------------------------------------------------------- + +# If the GENERATE_HTML tag is set to YES doxygen will generate HTML output +# The default value is: YES. + +GENERATE_HTML = YES + +# The HTML_OUTPUT tag is used to specify where the HTML docs will be put. If a +# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of +# it. +# The default directory is: html. +# This tag requires that the tag GENERATE_HTML is set to YES. + +HTML_OUTPUT = html + +# The HTML_FILE_EXTENSION tag can be used to specify the file extension for each +# generated HTML page (for example: .htm, .php, .asp). +# The default value is: .html. +# This tag requires that the tag GENERATE_HTML is set to YES. + +HTML_FILE_EXTENSION = .html + +# The HTML_HEADER tag can be used to specify a user-defined HTML header file for +# each generated HTML page. If the tag is left blank doxygen will generate a +# standard header. +# +# To get valid HTML the header file that includes any scripts and style sheets +# that doxygen needs, which is dependent on the configuration options used (e.g. +# the setting GENERATE_TREEVIEW). It is highly recommended to start with a +# default header using +# doxygen -w html new_header.html new_footer.html new_stylesheet.css +# YourConfigFile +# and then modify the file new_header.html. See also section "Doxygen usage" +# for information on how to generate the default header that doxygen normally +# uses. +# Note: The header is subject to change so you typically have to regenerate the +# default header when upgrading to a newer version of doxygen. For a description +# of the possible markers and block names see the documentation. +# This tag requires that the tag GENERATE_HTML is set to YES. + +HTML_HEADER = + +# The HTML_FOOTER tag can be used to specify a user-defined HTML footer for each +# generated HTML page. If the tag is left blank doxygen will generate a standard +# footer. See HTML_HEADER for more information on how to generate a default +# footer and what special commands can be used inside the footer. See also +# section "Doxygen usage" for information on how to generate the default footer +# that doxygen normally uses. +# This tag requires that the tag GENERATE_HTML is set to YES. + +HTML_FOOTER = + +# The HTML_STYLESHEET tag can be used to specify a user-defined cascading style +# sheet that is used by each HTML page. It can be used to fine-tune the look of +# the HTML output. If left blank doxygen will generate a default style sheet. +# See also section "Doxygen usage" for information on how to generate the style +# sheet that doxygen normally uses. +# Note: It is recommended to use HTML_EXTRA_STYLESHEET instead of this tag, as +# it is more robust and this tag (HTML_STYLESHEET) will in the future become +# obsolete. +# This tag requires that the tag GENERATE_HTML is set to YES. + +HTML_STYLESHEET = + +# The HTML_EXTRA_STYLESHEET tag can be used to specify additional user-defined +# cascading style sheets that are included after the standard style sheets +# created by doxygen. Using this option one can overrule certain style aspects. +# This is preferred over using HTML_STYLESHEET since it does not replace the +# standard style sheet and is therefor more robust against future updates. +# Doxygen will copy the style sheet files to the output directory. +# Note: The order of the extra stylesheet files is of importance (e.g. the last +# stylesheet in the list overrules the setting of the previous ones in the +# list). For an example see the documentation. +# This tag requires that the tag GENERATE_HTML is set to YES. + +HTML_EXTRA_STYLESHEET = + +# The HTML_EXTRA_FILES tag can be used to specify one or more extra images or +# other source files which should be copied to the HTML output directory. Note +# that these files will be copied to the base HTML output directory. Use the +# $relpath^ marker in the HTML_HEADER and/or HTML_FOOTER files to load these +# files. In the HTML_STYLESHEET file, use the file name only. Also note that the +# files will be copied as-is; there are no commands or markers available. +# This tag requires that the tag GENERATE_HTML is set to YES. + +HTML_EXTRA_FILES = + +# The HTML_COLORSTYLE_HUE tag controls the color of the HTML output. Doxygen +# will adjust the colors in the stylesheet and background images according to +# this color. Hue is specified as an angle on a colorwheel, see +# http://en.wikipedia.org/wiki/Hue for more information. For instance the value +# 0 represents red, 60 is yellow, 120 is green, 180 is cyan, 240 is blue, 300 +# purple, and 360 is red again. +# Minimum value: 0, maximum value: 359, default value: 220. +# This tag requires that the tag GENERATE_HTML is set to YES. + +HTML_COLORSTYLE_HUE = 220 + +# The HTML_COLORSTYLE_SAT tag controls the purity (or saturation) of the colors +# in the HTML output. For a value of 0 the output will use grayscales only. A +# value of 255 will produce the most vivid colors. +# Minimum value: 0, maximum value: 255, default value: 100. +# This tag requires that the tag GENERATE_HTML is set to YES. + +HTML_COLORSTYLE_SAT = 100 + +# The HTML_COLORSTYLE_GAMMA tag controls the gamma correction applied to the +# luminance component of the colors in the HTML output. Values below 100 +# gradually make the output lighter, whereas values above 100 make the output +# darker. The value divided by 100 is the actual gamma applied, so 80 represents +# a gamma of 0.8, The value 220 represents a gamma of 2.2, and 100 does not +# change the gamma. +# Minimum value: 40, maximum value: 240, default value: 80. +# This tag requires that the tag GENERATE_HTML is set to YES. + +HTML_COLORSTYLE_GAMMA = 80 + +# If the HTML_TIMESTAMP tag is set to YES then the footer of each generated HTML +# page will contain the date and time when the page was generated. Setting this +# to NO can help when comparing the output of multiple runs. +# The default value is: YES. +# This tag requires that the tag GENERATE_HTML is set to YES. + +HTML_TIMESTAMP = YES + +# If the HTML_DYNAMIC_SECTIONS tag is set to YES then the generated HTML +# documentation will contain sections that can be hidden and shown after the +# page has loaded. +# The default value is: NO. +# This tag requires that the tag GENERATE_HTML is set to YES. + +HTML_DYNAMIC_SECTIONS = NO + +# With HTML_INDEX_NUM_ENTRIES one can control the preferred number of entries +# shown in the various tree structured indices initially; the user can expand +# and collapse entries dynamically later on. Doxygen will expand the tree to +# such a level that at most the specified number of entries are visible (unless +# a fully collapsed tree already exceeds this amount). So setting the number of +# entries 1 will produce a full collapsed tree by default. 0 is a special value +# representing an infinite number of entries and will result in a full expanded +# tree by default. +# Minimum value: 0, maximum value: 9999, default value: 100. +# This tag requires that the tag GENERATE_HTML is set to YES. + +HTML_INDEX_NUM_ENTRIES = 100 + +# If the GENERATE_DOCSET tag is set to YES, additional index files will be +# generated that can be used as input for Apple's Xcode 3 integrated development +# environment (see: http://developer.apple.com/tools/xcode/), introduced with +# OSX 10.5 (Leopard). To create a documentation set, doxygen will generate a +# Makefile in the HTML output directory. Running make will produce the docset in +# that directory and running make install will install the docset in +# ~/Library/Developer/Shared/Documentation/DocSets so that Xcode will find it at +# startup. See http://developer.apple.com/tools/creatingdocsetswithdoxygen.html +# for more information. +# The default value is: NO. +# This tag requires that the tag GENERATE_HTML is set to YES. + +GENERATE_DOCSET = NO + +# This tag determines the name of the docset feed. A documentation feed provides +# an umbrella under which multiple documentation sets from a single provider +# (such as a company or product suite) can be grouped. +# The default value is: Doxygen generated docs. +# This tag requires that the tag GENERATE_DOCSET is set to YES. + +DOCSET_FEEDNAME = "Doxygen generated docs" + +# This tag specifies a string that should uniquely identify the documentation +# set bundle. This should be a reverse domain-name style string, e.g. +# com.mycompany.MyDocSet. Doxygen will append .docset to the name. +# The default value is: org.doxygen.Project. +# This tag requires that the tag GENERATE_DOCSET is set to YES. + +DOCSET_BUNDLE_ID = org.doxygen.Project + +# The DOCSET_PUBLISHER_ID tag specifies a string that should uniquely identify +# the documentation publisher. This should be a reverse domain-name style +# string, e.g. com.mycompany.MyDocSet.documentation. +# The default value is: org.doxygen.Publisher. +# This tag requires that the tag GENERATE_DOCSET is set to YES. + +DOCSET_PUBLISHER_ID = org.doxygen.Publisher + +# The DOCSET_PUBLISHER_NAME tag identifies the documentation publisher. +# The default value is: Publisher. +# This tag requires that the tag GENERATE_DOCSET is set to YES. + +DOCSET_PUBLISHER_NAME = Publisher + +# If the GENERATE_HTMLHELP tag is set to YES then doxygen generates three +# additional HTML index files: index.hhp, index.hhc, and index.hhk. The +# index.hhp is a project file that can be read by Microsoft's HTML Help Workshop +# (see: http://www.microsoft.com/en-us/download/details.aspx?id=21138) on +# Windows. +# +# The HTML Help Workshop contains a compiler that can convert all HTML output +# generated by doxygen into a single compiled HTML file (.chm). Compiled HTML +# files are now used as the Windows 98 help format, and will replace the old +# Windows help format (.hlp) on all Windows platforms in the future. Compressed +# HTML files also contain an index, a table of contents, and you can search for +# words in the documentation. The HTML workshop also contains a viewer for +# compressed HTML files. +# The default value is: NO. +# This tag requires that the tag GENERATE_HTML is set to YES. + +GENERATE_HTMLHELP = NO + +# The CHM_FILE tag can be used to specify the file name of the resulting .chm +# file. You can add a path in front of the file if the result should not be +# written to the html output directory. +# This tag requires that the tag GENERATE_HTMLHELP is set to YES. + +CHM_FILE = + +# The HHC_LOCATION tag can be used to specify the location (absolute path +# including file name) of the HTML help compiler ( hhc.exe). If non-empty +# doxygen will try to run the HTML help compiler on the generated index.hhp. +# The file has to be specified with full path. +# This tag requires that the tag GENERATE_HTMLHELP is set to YES. + +HHC_LOCATION = + +# The GENERATE_CHI flag controls if a separate .chi index file is generated ( +# YES) or that it should be included in the master .chm file ( NO). +# The default value is: NO. +# This tag requires that the tag GENERATE_HTMLHELP is set to YES. + +GENERATE_CHI = NO + +# The CHM_INDEX_ENCODING is used to encode HtmlHelp index ( hhk), content ( hhc) +# and project file content. +# This tag requires that the tag GENERATE_HTMLHELP is set to YES. + +CHM_INDEX_ENCODING = + +# The BINARY_TOC flag controls whether a binary table of contents is generated ( +# YES) or a normal table of contents ( NO) in the .chm file. Furthermore it +# enables the Previous and Next buttons. +# The default value is: NO. +# This tag requires that the tag GENERATE_HTMLHELP is set to YES. + +BINARY_TOC = NO + +# The TOC_EXPAND flag can be set to YES to add extra items for group members to +# the table of contents of the HTML help documentation and to the tree view. +# The default value is: NO. +# This tag requires that the tag GENERATE_HTMLHELP is set to YES. + +TOC_EXPAND = NO + +# If the GENERATE_QHP tag is set to YES and both QHP_NAMESPACE and +# QHP_VIRTUAL_FOLDER are set, an additional index file will be generated that +# can be used as input for Qt's qhelpgenerator to generate a Qt Compressed Help +# (.qch) of the generated HTML documentation. +# The default value is: NO. +# This tag requires that the tag GENERATE_HTML is set to YES. + +GENERATE_QHP = NO + +# If the QHG_LOCATION tag is specified, the QCH_FILE tag can be used to specify +# the file name of the resulting .qch file. The path specified is relative to +# the HTML output folder. +# This tag requires that the tag GENERATE_QHP is set to YES. + +QCH_FILE = + +# The QHP_NAMESPACE tag specifies the namespace to use when generating Qt Help +# Project output. For more information please see Qt Help Project / Namespace +# (see: http://qt-project.org/doc/qt-4.8/qthelpproject.html#namespace). +# The default value is: org.doxygen.Project. +# This tag requires that the tag GENERATE_QHP is set to YES. + +QHP_NAMESPACE = org.doxygen.Project + +# The QHP_VIRTUAL_FOLDER tag specifies the namespace to use when generating Qt +# Help Project output. For more information please see Qt Help Project / Virtual +# Folders (see: http://qt-project.org/doc/qt-4.8/qthelpproject.html#virtual- +# folders). +# The default value is: doc. +# This tag requires that the tag GENERATE_QHP is set to YES. + +QHP_VIRTUAL_FOLDER = doc + +# If the QHP_CUST_FILTER_NAME tag is set, it specifies the name of a custom +# filter to add. For more information please see Qt Help Project / Custom +# Filters (see: http://qt-project.org/doc/qt-4.8/qthelpproject.html#custom- +# filters). +# This tag requires that the tag GENERATE_QHP is set to YES. + +QHP_CUST_FILTER_NAME = + +# The QHP_CUST_FILTER_ATTRS tag specifies the list of the attributes of the +# custom filter to add. For more information please see Qt Help Project / Custom +# Filters (see: http://qt-project.org/doc/qt-4.8/qthelpproject.html#custom- +# filters). +# This tag requires that the tag GENERATE_QHP is set to YES. + +QHP_CUST_FILTER_ATTRS = + +# The QHP_SECT_FILTER_ATTRS tag specifies the list of the attributes this +# project's filter section matches. Qt Help Project / Filter Attributes (see: +# http://qt-project.org/doc/qt-4.8/qthelpproject.html#filter-attributes). +# This tag requires that the tag GENERATE_QHP is set to YES. + +QHP_SECT_FILTER_ATTRS = + +# The QHG_LOCATION tag can be used to specify the location of Qt's +# qhelpgenerator. If non-empty doxygen will try to run qhelpgenerator on the +# generated .qhp file. +# This tag requires that the tag GENERATE_QHP is set to YES. + +QHG_LOCATION = + +# If the GENERATE_ECLIPSEHELP tag is set to YES, additional index files will be +# generated, together with the HTML files, they form an Eclipse help plugin. To +# install this plugin and make it available under the help contents menu in +# Eclipse, the contents of the directory containing the HTML and XML files needs +# to be copied into the plugins directory of eclipse. The name of the directory +# within the plugins directory should be the same as the ECLIPSE_DOC_ID value. +# After copying Eclipse needs to be restarted before the help appears. +# The default value is: NO. +# This tag requires that the tag GENERATE_HTML is set to YES. + +GENERATE_ECLIPSEHELP = NO + +# A unique identifier for the Eclipse help plugin. When installing the plugin +# the directory name containing the HTML and XML files should also have this +# name. Each documentation set should have its own identifier. +# The default value is: org.doxygen.Project. +# This tag requires that the tag GENERATE_ECLIPSEHELP is set to YES. + +ECLIPSE_DOC_ID = org.doxygen.Project + +# If you want full control over the layout of the generated HTML pages it might +# be necessary to disable the index and replace it with your own. The +# DISABLE_INDEX tag can be used to turn on/off the condensed index (tabs) at top +# of each HTML page. A value of NO enables the index and the value YES disables +# it. Since the tabs in the index contain the same information as the navigation +# tree, you can set this option to YES if you also set GENERATE_TREEVIEW to YES. +# The default value is: NO. +# This tag requires that the tag GENERATE_HTML is set to YES. + +DISABLE_INDEX = NO + +# The GENERATE_TREEVIEW tag is used to specify whether a tree-like index +# structure should be generated to display hierarchical information. If the tag +# value is set to YES, a side panel will be generated containing a tree-like +# index structure (just like the one that is generated for HTML Help). For this +# to work a browser that supports JavaScript, DHTML, CSS and frames is required +# (i.e. any modern browser). Windows users are probably better off using the +# HTML help feature. Via custom stylesheets (see HTML_EXTRA_STYLESHEET) one can +# further fine-tune the look of the index. As an example, the default style +# sheet generated by doxygen has an example that shows how to put an image at +# the root of the tree instead of the PROJECT_NAME. Since the tree basically has +# the same information as the tab index, you could consider setting +# DISABLE_INDEX to YES when enabling this option. +# The default value is: NO. +# This tag requires that the tag GENERATE_HTML is set to YES. + +GENERATE_TREEVIEW = NO + +# The ENUM_VALUES_PER_LINE tag can be used to set the number of enum values that +# doxygen will group on one line in the generated HTML documentation. +# +# Note that a value of 0 will completely suppress the enum values from appearing +# in the overview section. +# Minimum value: 0, maximum value: 20, default value: 4. +# This tag requires that the tag GENERATE_HTML is set to YES. + +ENUM_VALUES_PER_LINE = 4 + +# If the treeview is enabled (see GENERATE_TREEVIEW) then this tag can be used +# to set the initial width (in pixels) of the frame in which the tree is shown. +# Minimum value: 0, maximum value: 1500, default value: 250. +# This tag requires that the tag GENERATE_HTML is set to YES. + +TREEVIEW_WIDTH = 250 + +# When the EXT_LINKS_IN_WINDOW option is set to YES doxygen will open links to +# external symbols imported via tag files in a separate window. +# The default value is: NO. +# This tag requires that the tag GENERATE_HTML is set to YES. + +EXT_LINKS_IN_WINDOW = NO + +# Use this tag to change the font size of LaTeX formulas included as images in +# the HTML documentation. When you change the font size after a successful +# doxygen run you need to manually remove any form_*.png images from the HTML +# output directory to force them to be regenerated. +# Minimum value: 8, maximum value: 50, default value: 10. +# This tag requires that the tag GENERATE_HTML is set to YES. + +FORMULA_FONTSIZE = 10 + +# Use the FORMULA_TRANPARENT tag to determine whether or not the images +# generated for formulas are transparent PNGs. Transparent PNGs are not +# supported properly for IE 6.0, but are supported on all modern browsers. +# +# Note that when changing this option you need to delete any form_*.png files in +# the HTML output directory before the changes have effect. +# The default value is: YES. +# This tag requires that the tag GENERATE_HTML is set to YES. + +FORMULA_TRANSPARENT = YES + +# Enable the USE_MATHJAX option to render LaTeX formulas using MathJax (see +# http://www.mathjax.org) which uses client side Javascript for the rendering +# instead of using prerendered bitmaps. Use this if you do not have LaTeX +# installed or if you want to formulas look prettier in the HTML output. When +# enabled you may also need to install MathJax separately and configure the path +# to it using the MATHJAX_RELPATH option. +# The default value is: NO. +# This tag requires that the tag GENERATE_HTML is set to YES. + +USE_MATHJAX = NO + +# When MathJax is enabled you can set the default output format to be used for +# the MathJax output. See the MathJax site (see: +# http://docs.mathjax.org/en/latest/output.html) for more details. +# Possible values are: HTML-CSS (which is slower, but has the best +# compatibility), NativeMML (i.e. MathML) and SVG. +# The default value is: HTML-CSS. +# This tag requires that the tag USE_MATHJAX is set to YES. + +MATHJAX_FORMAT = HTML-CSS + +# When MathJax is enabled you need to specify the location relative to the HTML +# output directory using the MATHJAX_RELPATH option. The destination directory +# should contain the MathJax.js script. For instance, if the mathjax directory +# is located at the same level as the HTML output directory, then +# MATHJAX_RELPATH should be ../mathjax. The default value points to the MathJax +# Content Delivery Network so you can quickly see the result without installing +# MathJax. However, it is strongly recommended to install a local copy of +# MathJax from http://www.mathjax.org before deployment. +# The default value is: http://cdn.mathjax.org/mathjax/latest. +# This tag requires that the tag USE_MATHJAX is set to YES. + +MATHJAX_RELPATH = http://cdn.mathjax.org/mathjax/latest + +# The MATHJAX_EXTENSIONS tag can be used to specify one or more MathJax +# extension names that should be enabled during MathJax rendering. For example +# MATHJAX_EXTENSIONS = TeX/AMSmath TeX/AMSsymbols +# This tag requires that the tag USE_MATHJAX is set to YES. + +MATHJAX_EXTENSIONS = + +# The MATHJAX_CODEFILE tag can be used to specify a file with javascript pieces +# of code that will be used on startup of the MathJax code. See the MathJax site +# (see: http://docs.mathjax.org/en/latest/output.html) for more details. For an +# example see the documentation. +# This tag requires that the tag USE_MATHJAX is set to YES. + +MATHJAX_CODEFILE = + +# When the SEARCHENGINE tag is enabled doxygen will generate a search box for +# the HTML output. The underlying search engine uses javascript and DHTML and +# should work on any modern browser. Note that when using HTML help +# (GENERATE_HTMLHELP), Qt help (GENERATE_QHP), or docsets (GENERATE_DOCSET) +# there is already a search function so this one should typically be disabled. +# For large projects the javascript based search engine can be slow, then +# enabling SERVER_BASED_SEARCH may provide a better solution. It is possible to +# search using the keyboard; to jump to the search box use <access key> + S +# (what the <access key> is depends on the OS and browser, but it is typically +# <CTRL>, <ALT>/<option>, or both). Inside the search box use the <cursor down +# key> to jump into the search results window, the results can be navigated +# using the <cursor keys>. Press <Enter> to select an item or <escape> to cancel +# the search. The filter options can be selected when the cursor is inside the +# search box by pressing <Shift>+<cursor down>. Also here use the <cursor keys> +# to select a filter and <Enter> or <escape> to activate or cancel the filter +# option. +# The default value is: YES. +# This tag requires that the tag GENERATE_HTML is set to YES. + +SEARCHENGINE = YES + +# When the SERVER_BASED_SEARCH tag is enabled the search engine will be +# implemented using a web server instead of a web client using Javascript. There +# are two flavors of web server based searching depending on the EXTERNAL_SEARCH +# setting. When disabled, doxygen will generate a PHP script for searching and +# an index file used by the script. When EXTERNAL_SEARCH is enabled the indexing +# and searching needs to be provided by external tools. See the section +# "External Indexing and Searching" for details. +# The default value is: NO. +# This tag requires that the tag SEARCHENGINE is set to YES. + +SERVER_BASED_SEARCH = NO + +# When EXTERNAL_SEARCH tag is enabled doxygen will no longer generate the PHP +# script for searching. Instead the search results are written to an XML file +# which needs to be processed by an external indexer. Doxygen will invoke an +# external search engine pointed to by the SEARCHENGINE_URL option to obtain the +# search results. +# +# Doxygen ships with an example indexer ( doxyindexer) and search engine +# (doxysearch.cgi) which are based on the open source search engine library +# Xapian (see: http://xapian.org/). +# +# See the section "External Indexing and Searching" for details. +# The default value is: NO. +# This tag requires that the tag SEARCHENGINE is set to YES. + +EXTERNAL_SEARCH = NO + +# The SEARCHENGINE_URL should point to a search engine hosted by a web server +# which will return the search results when EXTERNAL_SEARCH is enabled. +# +# Doxygen ships with an example indexer ( doxyindexer) and search engine +# (doxysearch.cgi) which are based on the open source search engine library +# Xapian (see: http://xapian.org/). See the section "External Indexing and +# Searching" for details. +# This tag requires that the tag SEARCHENGINE is set to YES. + +SEARCHENGINE_URL = + +# When SERVER_BASED_SEARCH and EXTERNAL_SEARCH are both enabled the unindexed +# search data is written to a file for indexing by an external tool. With the +# SEARCHDATA_FILE tag the name of this file can be specified. +# The default file is: searchdata.xml. +# This tag requires that the tag SEARCHENGINE is set to YES. + +SEARCHDATA_FILE = searchdata.xml + +# When SERVER_BASED_SEARCH and EXTERNAL_SEARCH are both enabled the +# EXTERNAL_SEARCH_ID tag can be used as an identifier for the project. This is +# useful in combination with EXTRA_SEARCH_MAPPINGS to search through multiple +# projects and redirect the results back to the right project. +# This tag requires that the tag SEARCHENGINE is set to YES. + +EXTERNAL_SEARCH_ID = + +# The EXTRA_SEARCH_MAPPINGS tag can be used to enable searching through doxygen +# projects other than the one defined by this configuration file, but that are +# all added to the same external search index. Each project needs to have a +# unique id set via EXTERNAL_SEARCH_ID. The search mapping then maps the id of +# to a relative location where the documentation can be found. The format is: +# EXTRA_SEARCH_MAPPINGS = tagname1=loc1 tagname2=loc2 ... +# This tag requires that the tag SEARCHENGINE is set to YES. + +EXTRA_SEARCH_MAPPINGS = + +#--------------------------------------------------------------------------- +# Configuration options related to the LaTeX output +#--------------------------------------------------------------------------- + +# If the GENERATE_LATEX tag is set to YES doxygen will generate LaTeX output. +# The default value is: YES. + +GENERATE_LATEX = YES + +# The LATEX_OUTPUT tag is used to specify where the LaTeX docs will be put. If a +# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of +# it. +# The default directory is: latex. +# This tag requires that the tag GENERATE_LATEX is set to YES. + +LATEX_OUTPUT = latex + +# The LATEX_CMD_NAME tag can be used to specify the LaTeX command name to be +# invoked. +# +# Note that when enabling USE_PDFLATEX this option is only used for generating +# bitmaps for formulas in the HTML output, but not in the Makefile that is +# written to the output directory. +# The default file is: latex. +# This tag requires that the tag GENERATE_LATEX is set to YES. + +LATEX_CMD_NAME = latex + +# The MAKEINDEX_CMD_NAME tag can be used to specify the command name to generate +# index for LaTeX. +# The default file is: makeindex. +# This tag requires that the tag GENERATE_LATEX is set to YES. + +MAKEINDEX_CMD_NAME = makeindex + +# If the COMPACT_LATEX tag is set to YES doxygen generates more compact LaTeX +# documents. This may be useful for small projects and may help to save some +# trees in general. +# The default value is: NO. +# This tag requires that the tag GENERATE_LATEX is set to YES. + +COMPACT_LATEX = NO + +# The PAPER_TYPE tag can be used to set the paper type that is used by the +# printer. +# Possible values are: a4 (210 x 297 mm), letter (8.5 x 11 inches), legal (8.5 x +# 14 inches) and executive (7.25 x 10.5 inches). +# The default value is: a4. +# This tag requires that the tag GENERATE_LATEX is set to YES. + +PAPER_TYPE = a4 + +# The EXTRA_PACKAGES tag can be used to specify one or more LaTeX package names +# that should be included in the LaTeX output. To get the times font for +# instance you can specify +# EXTRA_PACKAGES=times +# If left blank no extra packages will be included. +# This tag requires that the tag GENERATE_LATEX is set to YES. + +EXTRA_PACKAGES = + +# The LATEX_HEADER tag can be used to specify a personal LaTeX header for the +# generated LaTeX document. The header should contain everything until the first +# chapter. If it is left blank doxygen will generate a standard header. See +# section "Doxygen usage" for information on how to let doxygen write the +# default header to a separate file. +# +# Note: Only use a user-defined header if you know what you are doing! The +# following commands have a special meaning inside the header: $title, +# $datetime, $date, $doxygenversion, $projectname, $projectnumber, +# $projectbrief, $projectlogo. Doxygen will replace $title with the empy string, +# for the replacement values of the other commands the user is refered to +# HTML_HEADER. +# This tag requires that the tag GENERATE_LATEX is set to YES. + +LATEX_HEADER = + +# The LATEX_FOOTER tag can be used to specify a personal LaTeX footer for the +# generated LaTeX document. The footer should contain everything after the last +# chapter. If it is left blank doxygen will generate a standard footer. See +# LATEX_HEADER for more information on how to generate a default footer and what +# special commands can be used inside the footer. +# +# Note: Only use a user-defined footer if you know what you are doing! +# This tag requires that the tag GENERATE_LATEX is set to YES. + +LATEX_FOOTER = + +# The LATEX_EXTRA_FILES tag can be used to specify one or more extra images or +# other source files which should be copied to the LATEX_OUTPUT output +# directory. Note that the files will be copied as-is; there are no commands or +# markers available. +# This tag requires that the tag GENERATE_LATEX is set to YES. + +LATEX_EXTRA_FILES = + +# If the PDF_HYPERLINKS tag is set to YES, the LaTeX that is generated is +# prepared for conversion to PDF (using ps2pdf or pdflatex). The PDF file will +# contain links (just like the HTML output) instead of page references. This +# makes the output suitable for online browsing using a PDF viewer. +# The default value is: YES. +# This tag requires that the tag GENERATE_LATEX is set to YES. + +PDF_HYPERLINKS = YES + +# If the USE_PDFLATEX tag is set to YES, doxygen will use pdflatex to generate +# the PDF file directly from the LaTeX files. Set this option to YES to get a +# higher quality PDF documentation. +# The default value is: YES. +# This tag requires that the tag GENERATE_LATEX is set to YES. + +USE_PDFLATEX = YES + +# If the LATEX_BATCHMODE tag is set to YES, doxygen will add the \batchmode +# command to the generated LaTeX files. This will instruct LaTeX to keep running +# if errors occur, instead of asking the user for help. This option is also used +# when generating formulas in HTML. +# The default value is: NO. +# This tag requires that the tag GENERATE_LATEX is set to YES. + +LATEX_BATCHMODE = NO + +# If the LATEX_HIDE_INDICES tag is set to YES then doxygen will not include the +# index chapters (such as File Index, Compound Index, etc.) in the output. +# The default value is: NO. +# This tag requires that the tag GENERATE_LATEX is set to YES. + +LATEX_HIDE_INDICES = NO + +# If the LATEX_SOURCE_CODE tag is set to YES then doxygen will include source +# code with syntax highlighting in the LaTeX output. +# +# Note that which sources are shown also depends on other settings such as +# SOURCE_BROWSER. +# The default value is: NO. +# This tag requires that the tag GENERATE_LATEX is set to YES. + +LATEX_SOURCE_CODE = NO + +# The LATEX_BIB_STYLE tag can be used to specify the style to use for the +# bibliography, e.g. plainnat, or ieeetr. See +# http://en.wikipedia.org/wiki/BibTeX and \cite for more info. +# The default value is: plain. +# This tag requires that the tag GENERATE_LATEX is set to YES. + +LATEX_BIB_STYLE = plain + +#--------------------------------------------------------------------------- +# Configuration options related to the RTF output +#--------------------------------------------------------------------------- + +# If the GENERATE_RTF tag is set to YES doxygen will generate RTF output. The +# RTF output is optimized for Word 97 and may not look too pretty with other RTF +# readers/editors. +# The default value is: NO. + +GENERATE_RTF = NO + +# The RTF_OUTPUT tag is used to specify where the RTF docs will be put. If a +# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of +# it. +# The default directory is: rtf. +# This tag requires that the tag GENERATE_RTF is set to YES. + +RTF_OUTPUT = rtf + +# If the COMPACT_RTF tag is set to YES doxygen generates more compact RTF +# documents. This may be useful for small projects and may help to save some +# trees in general. +# The default value is: NO. +# This tag requires that the tag GENERATE_RTF is set to YES. + +COMPACT_RTF = NO + +# If the RTF_HYPERLINKS tag is set to YES, the RTF that is generated will +# contain hyperlink fields. The RTF file will contain links (just like the HTML +# output) instead of page references. This makes the output suitable for online +# browsing using Word or some other Word compatible readers that support those +# fields. +# +# Note: WordPad (write) and others do not support links. +# The default value is: NO. +# This tag requires that the tag GENERATE_RTF is set to YES. + +RTF_HYPERLINKS = NO + +# Load stylesheet definitions from file. Syntax is similar to doxygen's config +# file, i.e. a series of assignments. You only have to provide replacements, +# missing definitions are set to their default value. +# +# See also section "Doxygen usage" for information on how to generate the +# default style sheet that doxygen normally uses. +# This tag requires that the tag GENERATE_RTF is set to YES. + +RTF_STYLESHEET_FILE = + +# Set optional variables used in the generation of an RTF document. Syntax is +# similar to doxygen's config file. A template extensions file can be generated +# using doxygen -e rtf extensionFile. +# This tag requires that the tag GENERATE_RTF is set to YES. + +RTF_EXTENSIONS_FILE = + +#--------------------------------------------------------------------------- +# Configuration options related to the man page output +#--------------------------------------------------------------------------- + +# If the GENERATE_MAN tag is set to YES doxygen will generate man pages for +# classes and files. +# The default value is: NO. + +GENERATE_MAN = NO + +# The MAN_OUTPUT tag is used to specify where the man pages will be put. If a +# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of +# it. A directory man3 will be created inside the directory specified by +# MAN_OUTPUT. +# The default directory is: man. +# This tag requires that the tag GENERATE_MAN is set to YES. + +MAN_OUTPUT = man + +# The MAN_EXTENSION tag determines the extension that is added to the generated +# man pages. In case the manual section does not start with a number, the number +# 3 is prepended. The dot (.) at the beginning of the MAN_EXTENSION tag is +# optional. +# The default value is: .3. +# This tag requires that the tag GENERATE_MAN is set to YES. + +MAN_EXTENSION = .3 + +# The MAN_SUBDIR tag determines the name of the directory created within +# MAN_OUTPUT in which the man pages are placed. If defaults to man followed by +# MAN_EXTENSION with the initial . removed. +# This tag requires that the tag GENERATE_MAN is set to YES. + +MAN_SUBDIR = + +# If the MAN_LINKS tag is set to YES and doxygen generates man output, then it +# will generate one additional man file for each entity documented in the real +# man page(s). These additional files only source the real man page, but without +# them the man command would be unable to find the correct page. +# The default value is: NO. +# This tag requires that the tag GENERATE_MAN is set to YES. + +MAN_LINKS = NO + +#--------------------------------------------------------------------------- +# Configuration options related to the XML output +#--------------------------------------------------------------------------- + +# If the GENERATE_XML tag is set to YES doxygen will generate an XML file that +# captures the structure of the code including all documentation. +# The default value is: NO. + +GENERATE_XML = NO + +# The XML_OUTPUT tag is used to specify where the XML pages will be put. If a +# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of +# it. +# The default directory is: xml. +# This tag requires that the tag GENERATE_XML is set to YES. + +XML_OUTPUT = xml + +# If the XML_PROGRAMLISTING tag is set to YES doxygen will dump the program +# listings (including syntax highlighting and cross-referencing information) to +# the XML output. Note that enabling this will significantly increase the size +# of the XML output. +# The default value is: YES. +# This tag requires that the tag GENERATE_XML is set to YES. + +XML_PROGRAMLISTING = YES + +#--------------------------------------------------------------------------- +# Configuration options related to the DOCBOOK output +#--------------------------------------------------------------------------- + +# If the GENERATE_DOCBOOK tag is set to YES doxygen will generate Docbook files +# that can be used to generate PDF. +# The default value is: NO. + +GENERATE_DOCBOOK = NO + +# The DOCBOOK_OUTPUT tag is used to specify where the Docbook pages will be put. +# If a relative path is entered the value of OUTPUT_DIRECTORY will be put in +# front of it. +# The default directory is: docbook. +# This tag requires that the tag GENERATE_DOCBOOK is set to YES. + +DOCBOOK_OUTPUT = docbook + +# If the DOCBOOK_PROGRAMLISTING tag is set to YES doxygen will include the +# program listings (including syntax highlighting and cross-referencing +# information) to the DOCBOOK output. Note that enabling this will significantly +# increase the size of the DOCBOOK output. +# The default value is: NO. +# This tag requires that the tag GENERATE_DOCBOOK is set to YES. + +DOCBOOK_PROGRAMLISTING = NO + +#--------------------------------------------------------------------------- +# Configuration options for the AutoGen Definitions output +#--------------------------------------------------------------------------- + +# If the GENERATE_AUTOGEN_DEF tag is set to YES doxygen will generate an AutoGen +# Definitions (see http://autogen.sf.net) file that captures the structure of +# the code including all documentation. Note that this feature is still +# experimental and incomplete at the moment. +# The default value is: NO. + +GENERATE_AUTOGEN_DEF = NO + +#--------------------------------------------------------------------------- +# Configuration options related to the Perl module output +#--------------------------------------------------------------------------- + +# If the GENERATE_PERLMOD tag is set to YES doxygen will generate a Perl module +# file that captures the structure of the code including all documentation. +# +# Note that this feature is still experimental and incomplete at the moment. +# The default value is: NO. + +GENERATE_PERLMOD = NO + +# If the PERLMOD_LATEX tag is set to YES doxygen will generate the necessary +# Makefile rules, Perl scripts and LaTeX code to be able to generate PDF and DVI +# output from the Perl module output. +# The default value is: NO. +# This tag requires that the tag GENERATE_PERLMOD is set to YES. + +PERLMOD_LATEX = NO + +# If the PERLMOD_PRETTY tag is set to YES the Perl module output will be nicely +# formatted so it can be parsed by a human reader. This is useful if you want to +# understand what is going on. On the other hand, if this tag is set to NO the +# size of the Perl module output will be much smaller and Perl will parse it +# just the same. +# The default value is: YES. +# This tag requires that the tag GENERATE_PERLMOD is set to YES. + +PERLMOD_PRETTY = YES + +# The names of the make variables in the generated doxyrules.make file are +# prefixed with the string contained in PERLMOD_MAKEVAR_PREFIX. This is useful +# so different doxyrules.make files included by the same Makefile don't +# overwrite each other's variables. +# This tag requires that the tag GENERATE_PERLMOD is set to YES. + +PERLMOD_MAKEVAR_PREFIX = + +#--------------------------------------------------------------------------- +# Configuration options related to the preprocessor +#--------------------------------------------------------------------------- + +# If the ENABLE_PREPROCESSING tag is set to YES doxygen will evaluate all +# C-preprocessor directives found in the sources and include files. +# The default value is: YES. + +ENABLE_PREPROCESSING = YES + +# If the MACRO_EXPANSION tag is set to YES doxygen will expand all macro names +# in the source code. If set to NO only conditional compilation will be +# performed. Macro expansion can be done in a controlled way by setting +# EXPAND_ONLY_PREDEF to YES. +# The default value is: NO. +# This tag requires that the tag ENABLE_PREPROCESSING is set to YES. + +MACRO_EXPANSION = NO + +# If the EXPAND_ONLY_PREDEF and MACRO_EXPANSION tags are both set to YES then +# the macro expansion is limited to the macros specified with the PREDEFINED and +# EXPAND_AS_DEFINED tags. +# The default value is: NO. +# This tag requires that the tag ENABLE_PREPROCESSING is set to YES. + +EXPAND_ONLY_PREDEF = NO + +# If the SEARCH_INCLUDES tag is set to YES the includes files in the +# INCLUDE_PATH will be searched if a #include is found. +# The default value is: YES. +# This tag requires that the tag ENABLE_PREPROCESSING is set to YES. + +SEARCH_INCLUDES = YES + +# The INCLUDE_PATH tag can be used to specify one or more directories that +# contain include files that are not input files but should be processed by the +# preprocessor. +# This tag requires that the tag SEARCH_INCLUDES is set to YES. + +INCLUDE_PATH = + +# You can use the INCLUDE_FILE_PATTERNS tag to specify one or more wildcard +# patterns (like *.h and *.hpp) to filter out the header-files in the +# directories. If left blank, the patterns specified with FILE_PATTERNS will be +# used. +# This tag requires that the tag ENABLE_PREPROCESSING is set to YES. + +INCLUDE_FILE_PATTERNS = + +# The PREDEFINED tag can be used to specify one or more macro names that are +# defined before the preprocessor is started (similar to the -D option of e.g. +# gcc). The argument of the tag is a list of macros of the form: name or +# name=definition (no spaces). If the definition and the "=" are omitted, "=1" +# is assumed. To prevent a macro definition from being undefined via #undef or +# recursively expanded use the := operator instead of the = operator. +# This tag requires that the tag ENABLE_PREPROCESSING is set to YES. + +PREDEFINED = + +# If the MACRO_EXPANSION and EXPAND_ONLY_PREDEF tags are set to YES then this +# tag can be used to specify a list of macro names that should be expanded. The +# macro definition that is found in the sources will be used. Use the PREDEFINED +# tag if you want to use a different macro definition that overrules the +# definition found in the source code. +# This tag requires that the tag ENABLE_PREPROCESSING is set to YES. + +EXPAND_AS_DEFINED = + +# If the SKIP_FUNCTION_MACROS tag is set to YES then doxygen's preprocessor will +# remove all references to function-like macros that are alone on a line, have +# an all uppercase name, and do not end with a semicolon. Such function macros +# are typically used for boiler-plate code, and will confuse the parser if not +# removed. +# The default value is: YES. +# This tag requires that the tag ENABLE_PREPROCESSING is set to YES. + +SKIP_FUNCTION_MACROS = YES + +#--------------------------------------------------------------------------- +# Configuration options related to external references +#--------------------------------------------------------------------------- + +# The TAGFILES tag can be used to specify one or more tag files. For each tag +# file the location of the external documentation should be added. The format of +# a tag file without this location is as follows: +# TAGFILES = file1 file2 ... +# Adding location for the tag files is done as follows: +# TAGFILES = file1=loc1 "file2 = loc2" ... +# where loc1 and loc2 can be relative or absolute paths or URLs. See the +# section "Linking to external documentation" for more information about the use +# of tag files. +# Note: Each tag file must have a unique name (where the name does NOT include +# the path). If a tag file is not located in the directory in which doxygen is +# run, you must also specify the path to the tagfile here. + +TAGFILES = + +# When a file name is specified after GENERATE_TAGFILE, doxygen will create a +# tag file that is based on the input files it reads. See section "Linking to +# external documentation" for more information about the usage of tag files. + +GENERATE_TAGFILE = + +# If the ALLEXTERNALS tag is set to YES all external class will be listed in the +# class index. If set to NO only the inherited external classes will be listed. +# The default value is: NO. + +ALLEXTERNALS = NO + +# If the EXTERNAL_GROUPS tag is set to YES all external groups will be listed in +# the modules index. If set to NO, only the current project's groups will be +# listed. +# The default value is: YES. + +EXTERNAL_GROUPS = YES + +# If the EXTERNAL_PAGES tag is set to YES all external pages will be listed in +# the related pages index. If set to NO, only the current project's pages will +# be listed. +# The default value is: YES. + +EXTERNAL_PAGES = YES + +# The PERL_PATH should be the absolute path and name of the perl script +# interpreter (i.e. the result of 'which perl'). +# The default file (with absolute path) is: /usr/bin/perl. + +PERL_PATH = /usr/bin/perl + +#--------------------------------------------------------------------------- +# Configuration options related to the dot tool +#--------------------------------------------------------------------------- + +# If the CLASS_DIAGRAMS tag is set to YES doxygen will generate a class diagram +# (in HTML and LaTeX) for classes with base or super classes. Setting the tag to +# NO turns the diagrams off. Note that this option also works with HAVE_DOT +# disabled, but it is recommended to install and use dot, since it yields more +# powerful graphs. +# The default value is: YES. + +CLASS_DIAGRAMS = YES + +# You can define message sequence charts within doxygen comments using the \msc +# command. Doxygen will then run the mscgen tool (see: +# http://www.mcternan.me.uk/mscgen/)) to produce the chart and insert it in the +# documentation. The MSCGEN_PATH tag allows you to specify the directory where +# the mscgen tool resides. If left empty the tool is assumed to be found in the +# default search path. + +MSCGEN_PATH = + +# You can include diagrams made with dia in doxygen documentation. Doxygen will +# then run dia to produce the diagram and insert it in the documentation. The +# DIA_PATH tag allows you to specify the directory where the dia binary resides. +# If left empty dia is assumed to be found in the default search path. + +DIA_PATH = + +# If set to YES, the inheritance and collaboration graphs will hide inheritance +# and usage relations if the target is undocumented or is not a class. +# The default value is: YES. + +HIDE_UNDOC_RELATIONS = YES + +# If you set the HAVE_DOT tag to YES then doxygen will assume the dot tool is +# available from the path. This tool is part of Graphviz (see: +# http://www.graphviz.org/), a graph visualization toolkit from AT&T and Lucent +# Bell Labs. The other options in this section have no effect if this option is +# set to NO +# The default value is: YES. + +HAVE_DOT = YES + +# The DOT_NUM_THREADS specifies the number of dot invocations doxygen is allowed +# to run in parallel. When set to 0 doxygen will base this on the number of +# processors available in the system. You can set it explicitly to a value +# larger than 0 to get control over the balance between CPU load and processing +# speed. +# Minimum value: 0, maximum value: 32, default value: 0. +# This tag requires that the tag HAVE_DOT is set to YES. + +DOT_NUM_THREADS = 0 + +# When you want a differently looking font in the dot files that doxygen +# generates you can specify the font name using DOT_FONTNAME. You need to make +# sure dot is able to find the font, which can be done by putting it in a +# standard location or by setting the DOTFONTPATH environment variable or by +# setting DOT_FONTPATH to the directory containing the font. +# The default value is: Helvetica. +# This tag requires that the tag HAVE_DOT is set to YES. + +DOT_FONTNAME = Helvetica + +# The DOT_FONTSIZE tag can be used to set the size (in points) of the font of +# dot graphs. +# Minimum value: 4, maximum value: 24, default value: 10. +# This tag requires that the tag HAVE_DOT is set to YES. + +DOT_FONTSIZE = 10 + +# By default doxygen will tell dot to use the default font as specified with +# DOT_FONTNAME. If you specify a different font using DOT_FONTNAME you can set +# the path where dot can find it using this tag. +# This tag requires that the tag HAVE_DOT is set to YES. + +DOT_FONTPATH = + +# If the CLASS_GRAPH tag is set to YES then doxygen will generate a graph for +# each documented class showing the direct and indirect inheritance relations. +# Setting this tag to YES will force the CLASS_DIAGRAMS tag to NO. +# The default value is: YES. +# This tag requires that the tag HAVE_DOT is set to YES. + +CLASS_GRAPH = YES + +# If the COLLABORATION_GRAPH tag is set to YES then doxygen will generate a +# graph for each documented class showing the direct and indirect implementation +# dependencies (inheritance, containment, and class references variables) of the +# class with other documented classes. +# The default value is: YES. +# This tag requires that the tag HAVE_DOT is set to YES. + +COLLABORATION_GRAPH = YES + +# If the GROUP_GRAPHS tag is set to YES then doxygen will generate a graph for +# groups, showing the direct groups dependencies. +# The default value is: YES. +# This tag requires that the tag HAVE_DOT is set to YES. + +GROUP_GRAPHS = YES + +# If the UML_LOOK tag is set to YES doxygen will generate inheritance and +# collaboration diagrams in a style similar to the OMG's Unified Modeling +# Language. +# The default value is: NO. +# This tag requires that the tag HAVE_DOT is set to YES. + +UML_LOOK = NO + +# If the UML_LOOK tag is enabled, the fields and methods are shown inside the +# class node. If there are many fields or methods and many nodes the graph may +# become too big to be useful. The UML_LIMIT_NUM_FIELDS threshold limits the +# number of items for each type to make the size more manageable. Set this to 0 +# for no limit. Note that the threshold may be exceeded by 50% before the limit +# is enforced. So when you set the threshold to 10, up to 15 fields may appear, +# but if the number exceeds 15, the total amount of fields shown is limited to +# 10. +# Minimum value: 0, maximum value: 100, default value: 10. +# This tag requires that the tag HAVE_DOT is set to YES. + +UML_LIMIT_NUM_FIELDS = 10 + +# If the TEMPLATE_RELATIONS tag is set to YES then the inheritance and +# collaboration graphs will show the relations between templates and their +# instances. +# The default value is: NO. +# This tag requires that the tag HAVE_DOT is set to YES. + +TEMPLATE_RELATIONS = NO + +# If the INCLUDE_GRAPH, ENABLE_PREPROCESSING and SEARCH_INCLUDES tags are set to +# YES then doxygen will generate a graph for each documented file showing the +# direct and indirect include dependencies of the file with other documented +# files. +# The default value is: YES. +# This tag requires that the tag HAVE_DOT is set to YES. + +INCLUDE_GRAPH = YES + +# If the INCLUDED_BY_GRAPH, ENABLE_PREPROCESSING and SEARCH_INCLUDES tags are +# set to YES then doxygen will generate a graph for each documented file showing +# the direct and indirect include dependencies of the file with other documented +# files. +# The default value is: YES. +# This tag requires that the tag HAVE_DOT is set to YES. + +INCLUDED_BY_GRAPH = YES + +# If the CALL_GRAPH tag is set to YES then doxygen will generate a call +# dependency graph for every global function or class method. +# +# Note that enabling this option will significantly increase the time of a run. +# So in most cases it will be better to enable call graphs for selected +# functions only using the \callgraph command. +# The default value is: NO. +# This tag requires that the tag HAVE_DOT is set to YES. + +CALL_GRAPH = NO + +# If the CALLER_GRAPH tag is set to YES then doxygen will generate a caller +# dependency graph for every global function or class method. +# +# Note that enabling this option will significantly increase the time of a run. +# So in most cases it will be better to enable caller graphs for selected +# functions only using the \callergraph command. +# The default value is: NO. +# This tag requires that the tag HAVE_DOT is set to YES. + +CALLER_GRAPH = NO + +# If the GRAPHICAL_HIERARCHY tag is set to YES then doxygen will graphical +# hierarchy of all classes instead of a textual one. +# The default value is: YES. +# This tag requires that the tag HAVE_DOT is set to YES. + +GRAPHICAL_HIERARCHY = YES + +# If the DIRECTORY_GRAPH tag is set to YES then doxygen will show the +# dependencies a directory has on other directories in a graphical way. The +# dependency relations are determined by the #include relations between the +# files in the directories. +# The default value is: YES. +# This tag requires that the tag HAVE_DOT is set to YES. + +DIRECTORY_GRAPH = YES + +# The DOT_IMAGE_FORMAT tag can be used to set the image format of the images +# generated by dot. +# Note: If you choose svg you need to set HTML_FILE_EXTENSION to xhtml in order +# to make the SVG files visible in IE 9+ (other browsers do not have this +# requirement). +# Possible values are: png, png:cairo, png:cairo:cairo, png:cairo:gd, png:gd, +# png:gd:gd, jpg, jpg:cairo, jpg:cairo:gd, jpg:gd, jpg:gd:gd, gif, gif:cairo, +# gif:cairo:gd, gif:gd, gif:gd:gd and svg. +# The default value is: png. +# This tag requires that the tag HAVE_DOT is set to YES. + +DOT_IMAGE_FORMAT = png + +# If DOT_IMAGE_FORMAT is set to svg, then this option can be set to YES to +# enable generation of interactive SVG images that allow zooming and panning. +# +# Note that this requires a modern browser other than Internet Explorer. Tested +# and working are Firefox, Chrome, Safari, and Opera. +# Note: For IE 9+ you need to set HTML_FILE_EXTENSION to xhtml in order to make +# the SVG files visible. Older versions of IE do not have SVG support. +# The default value is: NO. +# This tag requires that the tag HAVE_DOT is set to YES. + +INTERACTIVE_SVG = NO + +# The DOT_PATH tag can be used to specify the path where the dot tool can be +# found. If left blank, it is assumed the dot tool can be found in the path. +# This tag requires that the tag HAVE_DOT is set to YES. + +DOT_PATH = + +# The DOTFILE_DIRS tag can be used to specify one or more directories that +# contain dot files that are included in the documentation (see the \dotfile +# command). +# This tag requires that the tag HAVE_DOT is set to YES. + +DOTFILE_DIRS = + +# The MSCFILE_DIRS tag can be used to specify one or more directories that +# contain msc files that are included in the documentation (see the \mscfile +# command). + +MSCFILE_DIRS = + +# The DIAFILE_DIRS tag can be used to specify one or more directories that +# contain dia files that are included in the documentation (see the \diafile +# command). + +DIAFILE_DIRS = + +# When using plantuml, the PLANTUML_JAR_PATH tag should be used to specify the +# path where java can find the plantuml.jar file. If left blank, it is assumed +# PlantUML is not used or called during a preprocessing step. Doxygen will +# generate a warning when it encounters a \startuml command in this case and +# will not generate output for the diagram. +# This tag requires that the tag HAVE_DOT is set to YES. + +PLANTUML_JAR_PATH = + +# The DOT_GRAPH_MAX_NODES tag can be used to set the maximum number of nodes +# that will be shown in the graph. If the number of nodes in a graph becomes +# larger than this value, doxygen will truncate the graph, which is visualized +# by representing a node as a red box. Note that doxygen if the number of direct +# children of the root node in a graph is already larger than +# DOT_GRAPH_MAX_NODES then the graph will not be shown at all. Also note that +# the size of a graph can be further restricted by MAX_DOT_GRAPH_DEPTH. +# Minimum value: 0, maximum value: 10000, default value: 50. +# This tag requires that the tag HAVE_DOT is set to YES. + +DOT_GRAPH_MAX_NODES = 50 + +# The MAX_DOT_GRAPH_DEPTH tag can be used to set the maximum depth of the graphs +# generated by dot. A depth value of 3 means that only nodes reachable from the +# root by following a path via at most 3 edges will be shown. Nodes that lay +# further from the root node will be omitted. Note that setting this option to 1 +# or 2 may greatly reduce the computation time needed for large code bases. Also +# note that the size of a graph can be further restricted by +# DOT_GRAPH_MAX_NODES. Using a depth of 0 means no depth restriction. +# Minimum value: 0, maximum value: 1000, default value: 0. +# This tag requires that the tag HAVE_DOT is set to YES. + +MAX_DOT_GRAPH_DEPTH = 0 + +# Set the DOT_TRANSPARENT tag to YES to generate images with a transparent +# background. This is disabled by default, because dot on Windows does not seem +# to support this out of the box. +# +# Warning: Depending on the platform used, enabling this option may lead to +# badly anti-aliased labels on the edges of a graph (i.e. they become hard to +# read). +# The default value is: NO. +# This tag requires that the tag HAVE_DOT is set to YES. + +DOT_TRANSPARENT = NO + +# Set the DOT_MULTI_TARGETS tag to YES allow dot to generate multiple output +# files in one run (i.e. multiple -o and -T options on the command line). This +# makes dot run faster, but since only newer versions of dot (>1.8.10) support +# this, this feature is disabled by default. +# The default value is: NO. +# This tag requires that the tag HAVE_DOT is set to YES. + +DOT_MULTI_TARGETS = NO + +# If the GENERATE_LEGEND tag is set to YES doxygen will generate a legend page +# explaining the meaning of the various boxes and arrows in the dot generated +# graphs. +# The default value is: YES. +# This tag requires that the tag HAVE_DOT is set to YES. + +GENERATE_LEGEND = YES + +# If the DOT_CLEANUP tag is set to YES doxygen will remove the intermediate dot +# files that are used to generate the various graphs. +# The default value is: YES. +# This tag requires that the tag HAVE_DOT is set to YES. + +DOT_CLEANUP = YES diff --git a/lang/qt/doc/Makefile.am b/lang/qt/doc/Makefile.am new file mode 100644 index 00000000..ddf49351 --- /dev/null +++ b/lang/qt/doc/Makefile.am @@ -0,0 +1,31 @@ +# Makefile.am - Makefile for GPGME Qt docs. +# Copyright (C) 2016 Intevation GmbH +# +# This file is part of GPGME. +# +# GPGME is free software; you can redistribute it and/or modify it +# under the terms of the GNU Lesser General Public License as +# published by the Free Software Foundation; either version 2.1 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 Lesser General +# Public License for more details. +# +# You should have received a copy of the GNU Lesser General Public +# License along with this program; if not, see <http://www.gnu.org/licenses/>. + +## Process this file with automake to produce Makefile.in + +if HAVE_DOXYGEN +doxyfile.stamp: + $(DOXYGEN) Doxyfile + touch doxyfile.stamp + +CLEANFILES = doxyfile.stamp + +all-local: doxyfile.stamp +clean-local: + rm -rf $(abs_builddir)/generated +endif diff --git a/lang/qt/src/Makefile.am b/lang/qt/src/Makefile.am new file mode 100644 index 00000000..7de3ef63 --- /dev/null +++ b/lang/qt/src/Makefile.am @@ -0,0 +1,195 @@ +# Makefile.am for GPGMEPP. +# Copyright (C) 2016 Intevation GmbH +# +# This file is part of GPGMEPP. +# +# GPGME-CL 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-CL 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 Lesser General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program; if not, write to the Free Software +# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA +# 02111-1307, USA +lib_LTLIBRARIES = libqgpgme.la +EXTRA_DIST = QGpgmeConfig.cmake.in.in QGpgmeConfigVersion.cmake.in \ + gpgme_backend_debug.h + +qgpgme_sources = \ + dataprovider.cpp job.cpp qgpgmeadduseridjob.cpp \ + qgpgmebackend.cpp qgpgmechangeexpiryjob.cpp qgpgmechangeownertrustjob.cpp \ + qgpgmechangepasswdjob.cpp qgpgmedecryptjob.cpp \ + qgpgmedecryptverifyjob.cpp qgpgmedeletejob.cpp qgpgmedownloadjob.cpp \ + qgpgmeencryptjob.cpp qgpgmeexportjob.cpp qgpgmeimportfromkeyserverjob.cpp \ + qgpgmeimportjob.cpp qgpgmekeygenerationjob.cpp qgpgmekeylistjob.cpp \ + qgpgmelistallkeysjob.cpp qgpgmenewcryptoconfig.cpp \ + qgpgmerefreshkeysjob.cpp \ + qgpgmesecretkeyexportjob.cpp qgpgmesignencryptjob.cpp \ + qgpgmesignjob.cpp qgpgmesignkeyjob.cpp qgpgmeverifydetachedjob.cpp \ + qgpgmeverifyopaquejob.cpp threadedjobmixin.cpp \ + gpgme_backend_debug.cpp + +qgpgme_headers= \ + adduseridjob.h \ + changeexpiryjob.h \ + changeownertrustjob.h \ + changepasswdjob.h \ + dataprovider.h \ + decryptjob.h \ + decryptverifyjob.h \ + downloadjob.h \ + encryptjob.h \ + exportjob.h \ + hierarchicalkeylistjob.h \ + job.h \ + multideletejob.h \ + protocol.h \ + qgpgme_export.h \ + qgpgmenewcryptoconfig.h \ + signjob.h \ + signkeyjob.h \ + signencryptjob.h \ + verifyopaquejob.h \ + refreshkeysjob.h \ + cryptoconfig.h \ + deletejob.h \ + importfromkeyserverjob.h \ + importjob.h \ + keygenerationjob.h \ + keylistjob.h \ + listallkeysjob.h + +private_qgpgme_headers = \ + qgpgme_export.h \ + abstractimportjob.h \ + protocol_p.h \ + qgpgmeadduseridjob.h \ + qgpgmebackend.h \ + qgpgmechangeexpiryjob.h \ + qgpgmechangeownertrustjob.h \ + qgpgmechangepasswdjob.h \ + qgpgmedecryptjob.h \ + qgpgmedecryptverifyjob.h \ + qgpgmedeletejob.h \ + qgpgmedownloadjob.h \ + qgpgmeencryptjob.h \ + qgpgmeexportjob.h \ + qgpgmeimportfromkeyserverjob.h \ + qgpgmeimportjob.h \ + qgpgmekeygenerationjob.h \ + qgpgmekeylistjob.h \ + qgpgmelistallkeysjob.h \ + qgpgmerefreshkeysjob.h \ + qgpgmesecretkeyexportjob.h \ + qgpgmesignencryptjob.h \ + qgpgmesignjob.h \ + qgpgmesignkeyjob.h \ + qgpgmeverifydetachedjob.h \ + qgpgmeverifyopaquejob.h \ + specialjob.h \ + threadedjobmixin.h + +qgpgme_moc_sources = \ + abstractimportjob.moc \ + adduseridjob.moc \ + changeexpiryjob.moc \ + changeownertrustjob.moc \ + changepasswdjob.moc \ + decryptjob.moc \ + decryptverifyjob.moc \ + deletejob.moc \ + downloadjob.moc \ + encryptjob.moc \ + exportjob.moc \ + hierarchicalkeylistjob.moc \ + importfromkeyserverjob.moc \ + importjob.moc \ + job.moc \ + keygenerationjob.moc \ + keylistjob.moc \ + listallkeysjob.moc \ + multideletejob.moc \ + qgpgmeadduseridjob.moc \ + qgpgmechangeexpiryjob.moc \ + qgpgmechangeownertrustjob.moc \ + qgpgmechangepasswdjob.moc \ + qgpgmedecryptjob.moc \ + qgpgmedecryptverifyjob.moc \ + qgpgmedeletejob.moc \ + qgpgmedownloadjob.moc \ + qgpgmeencryptjob.moc \ + qgpgmeexportjob.moc \ + qgpgmeimportfromkeyserverjob.moc \ + qgpgmeimportjob.moc \ + qgpgmekeygenerationjob.moc \ + qgpgmekeylistjob.moc \ + qgpgmelistallkeysjob.moc \ + qgpgmerefreshkeysjob.moc \ + qgpgmesecretkeyexportjob.moc \ + qgpgmesignencryptjob.moc \ + qgpgmesignjob.moc \ + qgpgmesignkeyjob.moc \ + qgpgmeverifydetachedjob.moc \ + qgpgmeverifyopaquejob.moc \ + refreshkeysjob.moc \ + signencryptjob.moc \ + signjob.moc \ + signkeyjob.moc \ + specialjob.moc \ + verifydetachedjob.moc \ + verifyopaquejob.moc + +qgpgmeincludedir = $(includedir)/qgpgme +qgpgmeinclude_HEADERS = $(qgpgme_headers) + +libqgpgme_la_SOURCES = $(qgpgme_sources) $(qgpgme_headers) $(private_qgpgme_headers) + +AM_CPPFLAGS = @GPGME_QT_CFLAGS@ @GPG_ERROR_CFLAGS@ @LIBASSUAN_CFLAGS@ \ + -DBUILDING_QGPGME -I$(top_srcdir)/lang/cpp/src + +libqgpgme_la_LIBADD = ../../cpp/src/libgpgmepp.la ../../../src/libgpgme.la \ + @LIBASSUAN_LIBS@ @GPGME_QT_LIBS@ +libqgpgme_la_LDFLAGS = -version-info \ + @LIBQGPGME_LT_CURRENT@:@LIBQGPGME_LT_REVISION@:@LIBQGPGME_LT_AGE@ + +if HAVE_W32_SYSTEM +libsuffix=.dll.a +else +libsuffix=.so +endif + +QGpgmeConfig.cmake: QGpgmeConfig.cmake.in + sed -e 's|[@]resolved_libdir@|$(libdir)|g' < "$<" > "$@" + sed -e 's|[@]libsuffix@|$(libsuffix)|g' < "$@" > "$@".2 + mv "$@".2 "$@" + +install-cmake-files: QGpgmeConfig.cmake QGpgmeConfigVersion.cmake + -$(INSTALL) -d $(DESTDIR)$(libdir)/cmake/Gpgmepp + $(INSTALL) QGpgmeConfig.cmake \ + $(DESTDIR)$(libdir)/cmake/Gpgmepp/QGpgmeConfig.cmake + $(INSTALL) QGpgmeConfigVersion.cmake \ + $(DESTDIR)$(libdir)/cmake/Gpgmepp/QGpgmeConfigVersion.cmake + +uninstall-cmake-files: + -rm $(DESTDIR)$(libdir)/cmake/Gpgmepp/QGpgmeConfigVersion.cmake + -rm $(DESTDIR)$(libdir)/cmake/Gpgmepp/QGpgmeConfig.cmake + -rmdir $(DESTDIR)$(libdir)/cmake/Gpgmepp/ + +install-data-local: install-cmake-files + +uninstall-local: uninstall-cmake-files + +BUILT_SOURCES = $(qgpgme_moc_sources) + +CLEANFILES = $(qgpgme_moc_sources) + +nodist_libqgpgme_la_SOURCES = $(qgpgme_moc_sources) + +.h.moc: + $(MOC) `test -f '$<' || echo '$(srcdir)/'`$< -o $@ diff --git a/lang/qt/src/QGpgmeConfig.cmake.in.in b/lang/qt/src/QGpgmeConfig.cmake.in.in new file mode 100644 index 00000000..3d196965 --- /dev/null +++ b/lang/qt/src/QGpgmeConfig.cmake.in.in @@ -0,0 +1,107 @@ +# CMake Config file for QGPGME. +# Copyright (C) 2016 Intevation GmbH +# +# This file is part of GPGME. +# +# GPGME-CL 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-CL 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 Lesser General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program; if not, write to the Free Software +# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA +# 02111-1307, USA + +# based on a generated file from cmake. +# Generated by CMake 3.0.2 + +if("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" LESS 2.5) + message(FATAL_ERROR "CMake >= 2.6.0 required") +endif() +cmake_policy(PUSH) +cmake_policy(VERSION 2.6) +#---------------------------------------------------------------- +# Generated CMake target import file. +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Protect against multiple inclusion, which would fail when already imported targets are added once more. +set(_targetsDefined) +set(_targetsNotDefined) +set(_expectedTargets) +foreach(_expectedTarget QGpgme KF5::QGpgme) + list(APPEND _expectedTargets ${_expectedTarget}) + if(NOT TARGET ${_expectedTarget}) + list(APPEND _targetsNotDefined ${_expectedTarget}) + endif() + if(TARGET ${_expectedTarget}) + list(APPEND _targetsDefined ${_expectedTarget}) + endif() +endforeach() +if("${_targetsDefined}" STREQUAL "${_expectedTargets}") + set(CMAKE_IMPORT_FILE_VERSION) + cmake_policy(POP) + return() +endif() +if(NOT "${_targetsDefined}" STREQUAL "") + message(FATAL_ERROR "Some (but not all) targets in this export set were already defined.\nTargets Defined: ${_targetsDefined}\nTargets not yet defined: ${_targetsNotDefined}\n") +endif() +unset(_targetsDefined) +unset(_targetsNotDefined) +unset(_expectedTargets) + +# Compute the installation prefix relative to this file. +get_filename_component(_IMPORT_PREFIX "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) + +# Create imported target QGpgme +add_library(QGpgme SHARED IMPORTED) + +set_target_properties(QGpgme PROPERTIES + INTERFACE_INCLUDE_DIRECTORIES "${_IMPORT_PREFIX}/include;${_IMPORT_PREFIX}/include/qgpgme" + INTERFACE_LINK_LIBRARIES "Gpgmepp;Qt5::Core" + IMPORTED_LOCATION "@resolved_libdir@/libqgpgme@libsuffix@" +) + +if(CMAKE_VERSION VERSION_LESS 2.8.12) + message(FATAL_ERROR "This file relies on consumers using CMake 2.8.12 or greater.") +endif() + +# Cleanup temporary variables. +set(_IMPORT_PREFIX) + +# Loop over all imported files and verify that they actually exist +foreach(target ${_IMPORT_CHECK_TARGETS} ) + foreach(file ${_IMPORT_CHECK_FILES_FOR_${target}} ) + if(NOT EXISTS "${file}" ) + message(FATAL_ERROR "The imported target \"${target}\" references the file + \"${file}\" +but this file does not exist. Possible reasons include: +* The file was deleted, renamed, or moved to another location. +* An install or uninstall procedure did not complete successfully. +* The installation package was faulty and contained + \"${CMAKE_CURRENT_LIST_FILE}\" +but not all the files it references. +") + endif() + endforeach() + unset(_IMPORT_CHECK_FILES_FOR_${target}) +endforeach() +unset(_IMPORT_CHECK_TARGETS) + +# This file does not depend on other imported targets which have +# been exported from the same project but in a separate export set. + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) +cmake_policy(POP) diff --git a/lang/qt/src/QGpgmeConfigVersion.cmake.in b/lang/qt/src/QGpgmeConfigVersion.cmake.in new file mode 100644 index 00000000..04a12cbb --- /dev/null +++ b/lang/qt/src/QGpgmeConfigVersion.cmake.in @@ -0,0 +1,31 @@ +# CMake Version file for QGPGME. +# Copyright (C) 2016 Intevation GmbH +# +# This file is part of GPGME. +# +# GPGME-CL 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-CL 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 Lesser General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program; if not, write to the Free Software +# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA +# 02111-1307, USA + +# based on a generated file from cmake. +set(PACKAGE_VERSION "@LIBQGPGME_LT_CURRENT@.@LIBQGPGME_LT_AGE@.@LIBQGPGME_LT_REVISION@.@BUILD_REVISION@") + +if("${PACKAGE_VERSION}" VERSION_LESS "${PACKAGE_FIND_VERSION}" ) + set(PACKAGE_VERSION_COMPATIBLE FALSE) +else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + if( "${PACKAGE_FIND_VERSION}" STREQUAL "${PACKAGE_VERSION}") + set(PACKAGE_VERSION_EXACT TRUE) + endif() +endif() diff --git a/lang/qt/src/abstractimportjob.h b/lang/qt/src/abstractimportjob.h new file mode 100644 index 00000000..33f6a2ac --- /dev/null +++ b/lang/qt/src/abstractimportjob.h @@ -0,0 +1,62 @@ +/* + abstractimportjob.h + + This file is part of qgpgme, the Qt API binding for gpgme + Copyright (c) 2009 Klarälvdalens Datakonsult AB + Copyright (c) 2016 Intevation GmbH + + QGpgME 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. + + QGpgME 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 this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + + In addition, as a special exception, the copyright holders give + permission to link the code of this program with any edition of + the Qt library by Trolltech AS, Norway (or with modified versions + of Qt that use the same license as Qt), and distribute linked + combinations including the two. You must obey the GNU General + Public License in all respects for all of the code used other than + Qt. If you modify this file, you may extend this exception to + your version of the file, but you are not obligated to do so. If + you do not wish to do so, delete this exception statement from + your version. +*/ + +#ifndef __KLEO_ABSTRACTIMPORTJOB_H__ +#define __KLEO_ABSTRACTIMPORTJOB_H__ + +#include "job.h" + +namespace GpgME +{ +class Error; +class ImportResult; +} + +namespace QGpgME +{ + +class AbstractImportJob : public Job +{ + Q_OBJECT +protected: + explicit AbstractImportJob(QObject *parent); +public: + ~AbstractImportJob(); + +Q_SIGNALS: + void result(const GpgME::ImportResult &result, const QString &auditLogAsHtml = QString(), const GpgME::Error &auditLogError = GpgME::Error()); +}; + +} + +#endif // __KLEO_IMPORTJOB_H__ diff --git a/lang/qt/src/adduseridjob.h b/lang/qt/src/adduseridjob.h new file mode 100644 index 00000000..1b5676f6 --- /dev/null +++ b/lang/qt/src/adduseridjob.h @@ -0,0 +1,84 @@ +/* + adduseridjob.h + + This file is part of qgpgme, the Qt API binding for gpgme + Copyright (c) 2008 Klarälvdalens Datakonsult AB + Copyright (c) 2016 Intevation GmbH + + QGpgME 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. + + QGpgME 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 this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + + In addition, as a special exception, the copyright holders give + permission to link the code of this program with any edition of + the Qt library by Trolltech AS, Norway (or with modified versions + of Qt that use the same license as Qt), and distribute linked + combinations including the two. You must obey the GNU General + Public License in all respects for all of the code used other than + Qt. If you modify this file, you may extend this exception to + your version of the file, but you are not obligated to do so. If + you do not wish to do so, delete this exception statement from + your version. +*/ + +#ifndef __KLEO_ADDUSERIDJOB_H__ +#define __KLEO_ADDUSERIDJOB_H__ + +#include "job.h" + +#include <QtCore/QString> + +namespace GpgME +{ +class Error; +class Key; +} + +namespace QGpgME +{ + +/** + @short An abstract base class to asynchronously add UIDs to OpenPGP keys + + To use a AddUserIDJob, first obtain an instance from the + CryptoBackend implementation, connect the progress() and result() + signals to suitable slots and then start the job with a call + to start(). This call might fail, in which case the AddUserIDJob + instance will have scheduled it's own destruction with a call to + QObject::deleteLater(). + + After result() is emitted, the AddUserIDJob will schedule it's own + destruction by calling QObject::deleteLater(). +*/ +class QGPGME_EXPORT AddUserIDJob : public Job +{ + Q_OBJECT +protected: + explicit AddUserIDJob(QObject *parent); +public: + ~AddUserIDJob(); + + /** + Starts the operation. \a key is the key to add the UID to. \a + name, \a email and \a comment are the components of the user id. + */ + virtual GpgME::Error start(const GpgME::Key &key, const QString &name, + const QString &email, const QString &comment = QString()) = 0; + +Q_SIGNALS: + void result(const GpgME::Error &result, const QString &auditLogAsHtml = QString(), const GpgME::Error &auditLogError = GpgME::Error()); +}; + +} + +#endif // __KLEO_ADDUSERIDJOB_H__ diff --git a/lang/qt/src/changeexpiryjob.h b/lang/qt/src/changeexpiryjob.h new file mode 100644 index 00000000..7902cb8e --- /dev/null +++ b/lang/qt/src/changeexpiryjob.h @@ -0,0 +1,84 @@ +/* + changeexpiryjob.h + + This file is part of qgpgme, the Qt API binding for gpgme + Copyright (c) 2008 Klarälvdalens Datakonsult AB + Copyright (c) 2016 Intevation GmbH + + QGpgME 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. + + QGpgME 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 this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + + In addition, as a special exception, the copyright holders give + permission to link the code of this program with any edition of + the Qt library by Trolltech AS, Norway (or with modified versions + of Qt that use the same license as Qt), and distribute linked + combinations including the two. You must obey the GNU General + Public License in all respects for all of the code used other than + Qt. If you modify this file, you may extend this exception to + your version of the file, but you are not obligated to do so. If + you do not wish to do so, delete this exception statement from + your version. +*/ + +#ifndef __KLEO_CHANGEEXPIRYJOB_H__ +#define __KLEO_CHANGEEXPIRYJOB_H__ + +#include "job.h" + +namespace GpgME +{ +class Error; +class Key; +} + +class QDateTime; + +namespace QGpgME +{ + +/** + @short An abstract base class to change expiry asynchronously + + To use a ChangeExpiryJob, first obtain an instance from the + CryptoBackend implementation, connect the progress() and result() + signals to suitable slots and then start the job with a call + to start(). This call might fail, in which case the ChangeExpiryJob + instance will have scheduled it's own destruction with a call to + QObject::deleteLater(). + + After result() is emitted, the ChangeExpiryJob will schedule it's own + destruction by calling QObject::deleteLater(). +*/ +class QGPGME_EXPORT ChangeExpiryJob : public Job +{ + Q_OBJECT +protected: + explicit ChangeExpiryJob(QObject *parent); +public: + ~ChangeExpiryJob(); + + /** + Starts the change-expiry operation. \a key is the key to change + the expiry of. \a expiry is the new expiry time. If \a expiry + is not valid, \a key is set to never expire. + */ + virtual GpgME::Error start(const GpgME::Key &key, const QDateTime &expiry) = 0; + +Q_SIGNALS: + void result(const GpgME::Error &result, const QString &auditLogAsHtml = QString(), const GpgME::Error &auditLogError = GpgME::Error()); +}; + +} + +#endif // __KLEO_CHANGEEXPIRYJOB_H__ diff --git a/lang/qt/src/changeownertrustjob.h b/lang/qt/src/changeownertrustjob.h new file mode 100644 index 00000000..75c11633 --- /dev/null +++ b/lang/qt/src/changeownertrustjob.h @@ -0,0 +1,81 @@ +/* + changeownertrustjob.h + + This file is part of qgpgme, the Qt API binding for gpgme + Copyright (c) 2008 Klarälvdalens Datakonsult AB + Copyright (c) 2016 Intevation GmbH + + QGpgME 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. + + QGpgME 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 this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + + In addition, as a special exception, the copyright holders give + permission to link the code of this program with any edition of + the Qt library by Trolltech AS, Norway (or with modified versions + of Qt that use the same license as Qt), and distribute linked + combinations including the two. You must obey the GNU General + Public License in all respects for all of the code used other than + Qt. If you modify this file, you may extend this exception to + your version of the file, but you are not obligated to do so. If + you do not wish to do so, delete this exception statement from + your version. +*/ + +#ifndef __KLEO_CHANGEOWNERTRUST_H__ +#define __KLEO_CHANGEOWNERTRUST_H__ + +#include "job.h" + +#ifdef BUILDING_QGPGME +# include "key.h" +#else +# include <gpgme++/key.h> +#endif + +namespace QGpgME +{ + +/** + @short An abstract base class to change owner trust asynchronously + + To use a ChangeOwnerTrustJob, first obtain an instance from the + CryptoBackend implementation, connect the progress() and result() + signals to suitable slots and then start the job with a call + to start(). This call might fail, in which case the ChangeOwnerTrustJob + instance will have scheduled it's own destruction with a call to + QObject::deleteLater(). + + After result() is emitted, the ChangeOwnerTrustJob will schedule it's own + destruction by calling QObject::deleteLater(). +*/ +class QGPGME_EXPORT ChangeOwnerTrustJob : public Job +{ + Q_OBJECT +protected: + explicit ChangeOwnerTrustJob(QObject *parent); +public: + ~ChangeOwnerTrustJob(); + + /** + Starts the change-owner trust operation. \a key is the key to change + the owner trust of . \a trust is the new trust level. + */ + virtual GpgME::Error start(const GpgME::Key &key, GpgME::Key::OwnerTrust trust) = 0; + +Q_SIGNALS: + void result(const GpgME::Error &result, const QString &auditLogAsHtml = QString(), const GpgME::Error &auditLogError = GpgME::Error()); +}; + +} + +#endif // __KLEO_CHANGEOWNERTRUSTJOB_H__ diff --git a/lang/qt/src/changepasswdjob.h b/lang/qt/src/changepasswdjob.h new file mode 100644 index 00000000..72908982 --- /dev/null +++ b/lang/qt/src/changepasswdjob.h @@ -0,0 +1,82 @@ +/* + changepasswdjob.h + + This file is part of qgpgme, the Qt API binding for gpgme + Copyright (c) 2010 Klarälvdalens Datakonsult AB + Copyright (c) 2016 Intevation GmbH + + QGpgME 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. + + QGpgME 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 this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + + In addition, as a special exception, the copyright holders give + permission to link the code of this program with any edition of + the Qt library by Trolltech AS, Norway (or with modified versions + of Qt that use the same license as Qt), and distribute linked + combinations including the two. You must obey the GNU General + Public License in all respects for all of the code used other than + Qt. If you modify this file, you may extend this exception to + your version of the file, but you are not obligated to do so. If + you do not wish to do so, delete this exception statement from + your version. +*/ + +#ifndef __KLEO_CHANGEPASSWDJOB_H__ +#define __KLEO_CHANGEPASSWDJOB_H__ + +#include "job.h" + +namespace GpgME +{ +class Error; +class Key; +} + +namespace QGpgME +{ + +/** + @short An abstract base class to change a key's passphrase asynchronously + + To use a ChangePasswdJob, first obtain an instance from the + CryptoBackend implementation, connect the progress() and result() + signals to suitable slots and then start the job with a call + to start(). This call might fail, in which case the ChangePasswdJob + instance will have scheduled it's own destruction with a call to + QObject::deleteLater(). + + After result() is emitted, the ChangePasswdJob will schedule it's own + destruction by calling QObject::deleteLater(). +*/ +class QGPGME_EXPORT ChangePasswdJob : public Job +{ + Q_OBJECT +protected: + explicit ChangePasswdJob(QObject *parent); +public: + ~ChangePasswdJob(); + + /** + Starts the passphrase-change operation. \a key is the key to + change the passphrase of. The passphrase is queried by the + backend directly, you cannot give it to the job beforehand. + */ + virtual GpgME::Error start(const GpgME::Key &key) = 0; + +Q_SIGNALS: + void result(const GpgME::Error &result, const QString &auditLogAsHtml = QString(), const GpgME::Error &auditLogError = GpgME::Error()); +}; + +} + +#endif // __KLEO_CHANGEPASSWDJOB_H__ diff --git a/lang/qt/src/cryptoconfig.h b/lang/qt/src/cryptoconfig.h new file mode 100644 index 00000000..858dbb72 --- /dev/null +++ b/lang/qt/src/cryptoconfig.h @@ -0,0 +1,399 @@ +/* + cryptoconfig.h + + This file is part of qgpgme, the Qt API binding for gpgme + Copyright (c) 2004 Klarälvdalens Datakonsult AB + Copyright (c) 2016 Intevation GmbH + + QGpgME 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. + + QGpgME 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 this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + + In addition, as a special exception, the copyright holders give + permission to link the code of this program with any edition of + the Qt library by Trolltech AS, Norway (or with modified versions + of Qt that use the same license as Qt), and distribute linked + combinations including the two. You must obey the GNU General + Public License in all respects for all of the code used other than + Qt. If you modify this file, you may extend this exception to + your version of the file, but you are not obligated to do so. If + you do not wish to do so, delete this exception statement from + your version. +*/ + +#ifndef CRYPTOCONFIG_H +#define CRYPTOCONFIG_H + +#ifdef __cplusplus +/* we read this file from a C compiler, and are only interested in the + * enums... */ + +#include <QUrl> + +#include <vector> + +/* Start reading this file from the bottom up :) */ + +namespace QGpgME +{ + +/** + * Description of a single option + */ +class CryptoConfigEntry +{ + +public: +#endif /* __cplusplus */ + /** + @li basic This option should always be offered to the user. + @li advanced This option may be offered to advanced users. + @li expert This option should only be offered to expert users. + */ + enum Level { Level_Basic = 0, + Level_Advanced = 1, + Level_Expert = 2 + }; + + /** + Type of the argument + @li ArgType_None The option is set or not set, but no argument. + @li ArgType_String An unformatted string. + @li ArgType_Int A signed integer number. + @li ArgType_UInt An unsigned integer number. + @li ArgType_Path A string that describes the pathname of a file. + The file does not necessarily need to exist. + Separated from string so that e.g. a FileDialog can be used. + @li ArgType_DirPath A string that describes the pathname of a directory. + The directory does not necessarily need to exist. + Separated from path so that e.g. a FileDialog can be used which only + allows directories to be selected. + @li ArgType_LDAPURL A LDAP URL + Separated from URL so that a more specific widget can be shown, hiding the url syntax + */ + enum ArgType { ArgType_None = 0, + ArgType_String = 1, + ArgType_Int = 2, + ArgType_UInt = 3, + ArgType_Path = 4, + /* Nr. 5 was URL historically. */ + ArgType_LDAPURL = 6, + ArgType_DirPath = 7, + + NumArgType + }; + +#ifdef __cplusplus + virtual ~CryptoConfigEntry() {} + + /** + * Return the internal name of this entry + */ + virtual QString name() const = 0; + + /** + * @return user-visible description of this entry + */ + virtual QString description() const = 0; + + /** + * @return "component/group/name" + */ + virtual QString path() const = 0; + + /** + * @return true if the argument is optional + */ + virtual bool isOptional() const = 0; + + /** + * @return true if the entry is readonly + */ + virtual bool isReadOnly() const = 0; + + /** + * @return true if the argument can be given multiple times + */ + virtual bool isList() const = 0; + + /** + * @return true if the argument can be changed at runtime + */ + virtual bool isRuntime() const = 0; + + /** + * User level + */ + virtual Level level() const = 0; + + /** + * Argument type + */ + virtual ArgType argType() const = 0; + + /** + * Return true if the option is set, i.e. different from default + */ + virtual bool isSet() const = 0; + + /** + * Return value as a bool (only allowed for ArgType_None) + */ + virtual bool boolValue() const = 0; + + /** + * Return value as a string (available for all argtypes) + * The returned string can be empty (explicitly set to empty) or null (not set). + */ + virtual QString stringValue() const = 0; + + /** + * Return value as a signed int + */ + virtual int intValue() const = 0; + + /** + * Return value as an unsigned int + */ + virtual unsigned int uintValue() const = 0; + + /** + * Return value as a URL (only meaningful for Path and URL argtypes) + */ + virtual QUrl urlValue() const = 0; + + /** + * Return number of times the option is set (only valid for ArgType_None, if isList()) + */ + virtual unsigned int numberOfTimesSet() const = 0; + + /** + * Return value as a list of signed ints + */ + virtual std::vector<int> intValueList() const = 0; + + /** + * Return value as a list of unsigned ints + */ + virtual std::vector<unsigned int> uintValueList() const = 0; + + /** + * Return value as a list of URLs (only meaningful for Path and URL argtypes, if isList()) + */ + virtual QList<QUrl> urlValueList() const = 0; + + /** + * Reset an option to its default value + */ + virtual void resetToDefault() = 0; + + /** + * Define whether the option is set or not (only allowed for ArgType_None) + * #### TODO: and for options with optional args + */ + virtual void setBoolValue(bool) = 0; + + /** + * Set string value (allowed for all argtypes) + */ + virtual void setStringValue(const QString &) = 0; + + /** + * Set a new signed int value + */ + virtual void setIntValue(int) = 0; + + /** + * Set a new unsigned int value + */ + virtual void setUIntValue(unsigned int) = 0; + + /** + * Set value as a URL (only meaningful for Path (if local) and URL argtypes) + */ + virtual void setURLValue(const QUrl &) = 0; + + /** + * Set the number of times the option is set (only valid for ArgType_None, if isList()) + */ + virtual void setNumberOfTimesSet(unsigned int) = 0; + + /** + * Set a new list of signed int values + */ + virtual void setIntValueList(const std::vector<int> &) = 0; + + /** + * Set a new list of unsigned int values + */ + virtual void setUIntValueList(const std::vector<unsigned int> &) = 0; + + /** + * Set value as a URL list (only meaningful for Path (if all URLs are local) and URL argtypes, if isList()) + */ + virtual void setURLValueList(const QList<QUrl> &) = 0; + + /** + * @return true if the value was changed + */ + virtual bool isDirty() const = 0; +}; + +/** + * Group containing a set of config options + */ +class CryptoConfigGroup +{ + +public: + virtual ~CryptoConfigGroup() {} + + /** + * Return the internal name of this group + */ + virtual QString name() const = 0; + + /** + * Return the name of the icon for this group + */ + virtual QString iconName() const = 0; + + /** + * @return user-visible description of this group + */ + virtual QString description() const = 0; + + /** + * @return "component/group" + */ + virtual QString path() const = 0; + + /** + * User level + */ + virtual CryptoConfigEntry::Level level() const = 0; + + /** + * Returns the list of entries that are known by this group. + * + * @return list of group entry names. + **/ + virtual QStringList entryList() const = 0; + + /** + * @return the configuration object for a given entry in this group + * The object is owned by CryptoConfigGroup, don't delete it. + * Groups cannot be nested, so all entries returned here are pure entries, no groups. + */ + virtual CryptoConfigEntry *entry(const QString &name) const = 0; +}; + +/** + * Crypto config for one component (e.g. gpg-agent, dirmngr etc.) + */ +class CryptoConfigComponent +{ + +public: + virtual ~CryptoConfigComponent() {} + + /** + * Return the internal name of this component + */ + virtual QString name() const = 0; + + /** + * Return the name of the icon for this component + */ + virtual QString iconName() const = 0; + + /** + * Return user-visible description of this component + */ + virtual QString description() const = 0; + + /** + * Returns the list of groups that are known about. + * + * @return list of group names. One of them can be "<nogroup>", which is the group where all + * "toplevel" options (belonging to no group) are. + */ + virtual QStringList groupList() const = 0; + + /** + * @return the configuration object for a given group + * The object is owned by CryptoConfigComponent, don't delete it. + */ + virtual CryptoConfigGroup *group(const QString &name) const = 0; + +}; + +/** + * Main interface to crypto configuration. + */ +class CryptoConfig +{ + +public: + virtual ~CryptoConfig() {} + + /** + * Returns the list of known components (e.g. "gpg-agent", "dirmngr" etc.). + * Use @ref component() to retrieve more information about each one. + * @return list of component names. + **/ + virtual QStringList componentList() const = 0; + + /** + * @return the configuration object for a given component + * The object is owned by CryptoConfig, don't delete it. + */ + virtual CryptoConfigComponent *component(const QString &name) const = 0; + + /** + * Convenience method to get hold of a single configuration entry when + * its component, group and name are known. This can be used to read + * the value and/or to set a value to it. + * + * @return the configuration object for a single configuration entry, 0 if not found. + * The object is owned by CryptoConfig, don't delete it. + */ + CryptoConfigEntry *entry(const QString &componentName, const QString &groupName, const QString &entryName) const + { + const QGpgME::CryptoConfigComponent *comp = component(componentName); + const QGpgME::CryptoConfigGroup *group = comp ? comp->group(groupName) : 0; + return group ? group->entry(entryName) : 0; + } + + /** + * Write back changes + * + * @param runtime If this option is set, the changes will take effect at run-time, as + * far as this is possible. Otherwise, they will take effect at the next + * start of the respective backend programs. + */ + virtual void sync(bool runtime) = 0; + + /** + * Tells the CryptoConfig to discard any cached information, including + * all components, groups and entries. + * Call this to free some memory when you won't be using the object + * for some time. + * DON'T call this if you're holding pointers to components, groups or entries. + */ + virtual void clear() = 0; +}; + +} +#endif /* __cplusplus */ +#endif /* CRYPTOCONFIG_H */ diff --git a/lang/qt/src/dataprovider.cpp b/lang/qt/src/dataprovider.cpp new file mode 100644 index 00000000..533b67dc --- /dev/null +++ b/lang/qt/src/dataprovider.cpp @@ -0,0 +1,282 @@ +/* dataprovider.cpp + Copyright (C) 2004 Klar�vdalens Datakonsult AB + Copyright (c) 2016 Intevation GmbH + + This file is part of QGPGME. + + QGPGME is free software; you can redistribute it and/or modify it + under the terms of the GNU Library General Public License as published + by the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + QGPGME is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Library General Public License for more details. + + You should have received a copy of the GNU Library General Public License + along with QGPGME; see the file COPYING.LIB. If not, write to the + Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. */ + +// -*- c++ -*- + +#include <dataprovider.h> + +#include <error.h> + +#include <QIODevice> +#include <QProcess> + +#include <cstdio> +#include <cstring> +#include <cassert> + +using namespace QGpgME; +using namespace GpgME; + +// +// +// QByteArrayDataProvider +// +// + +static bool resizeAndInit(QByteArray &ba, size_t newSize) +{ + const size_t oldSize = ba.size(); + ba.resize(newSize); + const bool ok = (newSize == static_cast<size_t>(ba.size())); + if (ok) { + memset(ba.data() + oldSize, 0, newSize - oldSize); + } + return ok; +} + +QByteArrayDataProvider::QByteArrayDataProvider() + : GpgME::DataProvider(), mOff(0) {} + +QByteArrayDataProvider::QByteArrayDataProvider(const QByteArray &initialData) + : GpgME::DataProvider(), mArray(initialData), mOff(0) {} + +QByteArrayDataProvider::~QByteArrayDataProvider() {} + +ssize_t QByteArrayDataProvider::read(void *buffer, size_t bufSize) +{ +#ifndef NDEBUG + //qDebug( "QByteArrayDataProvider::read( %p, %d )", buffer, bufSize ); +#endif + if (bufSize == 0) { + return 0; + } + if (!buffer) { + Error::setSystemError(GPG_ERR_EINVAL); + return -1; + } + if (mOff >= mArray.size()) { + return 0; // EOF + } + size_t amount = qMin(bufSize, static_cast<size_t>(mArray.size() - mOff)); + assert(amount > 0); + memcpy(buffer, mArray.data() + mOff, amount); + mOff += amount; + return amount; +} + +ssize_t QByteArrayDataProvider::write(const void *buffer, size_t bufSize) +{ +#ifndef NDEBUG + //qDebug( "QByteArrayDataProvider::write( %p, %lu )", buffer, static_cast<unsigned long>( bufSize ) ); +#endif + if (bufSize == 0) { + return 0; + } + if (!buffer) { + Error::setSystemError(GPG_ERR_EINVAL); + return -1; + } + if (mOff >= mArray.size()) { + resizeAndInit(mArray, mOff + bufSize); + } + if (mOff >= mArray.size()) { + Error::setSystemError(GPG_ERR_EIO); + return -1; + } + assert(bufSize <= static_cast<size_t>(mArray.size()) - mOff); + memcpy(mArray.data() + mOff, buffer, bufSize); + mOff += bufSize; + return bufSize; +} + +off_t QByteArrayDataProvider::seek(off_t offset, int whence) +{ +#ifndef NDEBUG + //qDebug( "QByteArrayDataProvider::seek( %d, %d )", int(offset), whence ); +#endif + int newOffset = mOff; + switch (whence) { + case SEEK_SET: + newOffset = offset; + break; + case SEEK_CUR: + newOffset += offset; + break; + case SEEK_END: + newOffset = mArray.size() + offset; + break; + default: + Error::setSystemError(GPG_ERR_EINVAL); + return (off_t) - 1; + } + return mOff = newOffset; +} + +void QByteArrayDataProvider::release() +{ +#ifndef NDEBUG + //qDebug( "QByteArrayDataProvider::release()" ); +#endif + mArray = QByteArray(); +} + +// +// +// QIODeviceDataProvider +// +// + +QIODeviceDataProvider::QIODeviceDataProvider(const std::shared_ptr<QIODevice> &io) + : GpgME::DataProvider(), + mIO(io), + mErrorOccurred(false), + mHaveQProcess(qobject_cast<QProcess *>(io.get())) +{ + assert(mIO); +} + +QIODeviceDataProvider::~QIODeviceDataProvider() {} + +bool QIODeviceDataProvider::isSupported(Operation op) const +{ + const QProcess *const proc = qobject_cast<QProcess *>(mIO.get()); + bool canRead = true; + if (proc) { + canRead = proc->readChannel() == QProcess::StandardOutput; + } + + switch (op) { + case Read: return mIO->isReadable() && canRead; + case Write: return mIO->isWritable(); + case Seek: return !mIO->isSequential(); + case Release: return true; + default: return false; + } +} + +static qint64 blocking_read(const std::shared_ptr<QIODevice> &io, char *buffer, qint64 maxSize) +{ + while (!io->bytesAvailable()) { + if (!io->waitForReadyRead(-1)) { + if (const QProcess *const p = qobject_cast<QProcess *>(io.get())) { + if (p->error() == QProcess::UnknownError && + p->exitStatus() == QProcess::NormalExit && + p->exitCode() == 0) { + return 0; + } else { + Error::setSystemError(GPG_ERR_EIO); + return -1; + } + } else { + return 0; // assume EOF (loses error cases :/ ) + } + } + } + return io->read(buffer, maxSize); +} + +ssize_t QIODeviceDataProvider::read(void *buffer, size_t bufSize) +{ +#ifndef NDEBUG + //qDebug( "QIODeviceDataProvider::read( %p, %lu )", buffer, bufSize ); +#endif + if (bufSize == 0) { + return 0; + } + if (!buffer) { + Error::setSystemError(GPG_ERR_EINVAL); + return -1; + } + const qint64 numRead = mHaveQProcess + ? blocking_read(mIO, static_cast<char *>(buffer), bufSize) + : mIO->read(static_cast<char *>(buffer), bufSize); + + //workaround: some QIODevices (known example: QProcess) might not return 0 (EOF), but immediately -1 when finished. If no + //errno is set, gpgme doesn't detect the error and loops forever. So return 0 on the very first -1 in case errno is 0 + + ssize_t rc = numRead; + if (numRead < 0 && !Error::hasSystemError()) { + if (mErrorOccurred) { + Error::setSystemError(GPG_ERR_EIO); + } else { + rc = 0; + } + } + if (numRead < 0) { + mErrorOccurred = true; + } + return rc; +} + +ssize_t QIODeviceDataProvider::write(const void *buffer, size_t bufSize) +{ +#ifndef NDEBUG + //qDebug( "QIODeviceDataProvider::write( %p, %lu )", buffer, static_cast<unsigned long>( bufSize ) ); +#endif + if (bufSize == 0) { + return 0; + } + if (!buffer) { + Error::setSystemError(GPG_ERR_EINVAL); + return -1; + } + + return mIO->write(static_cast<const char *>(buffer), bufSize); +} + +off_t QIODeviceDataProvider::seek(off_t offset, int whence) +{ +#ifndef NDEBUG + //qDebug( "QIODeviceDataProvider::seek( %d, %d )", int(offset), whence ); +#endif + if (mIO->isSequential()) { + Error::setSystemError(GPG_ERR_ESPIPE); + return (off_t) - 1; + } + qint64 newOffset = mIO->pos(); + switch (whence) { + case SEEK_SET: + newOffset = offset; + break; + case SEEK_CUR: + newOffset += offset; + break; + case SEEK_END: + newOffset = mIO->size() + offset; + break; + default: + Error::setSystemError(GPG_ERR_EINVAL); + return (off_t) - 1; + } + if (!mIO->seek(newOffset)) { + Error::setSystemError(GPG_ERR_EINVAL); + return (off_t) - 1; + } + return newOffset; +} + +void QIODeviceDataProvider::release() +{ +#ifndef NDEBUG + //qDebug( "QIODeviceDataProvider::release()" ); +#endif + mIO->close(); +} diff --git a/lang/qt/src/dataprovider.h b/lang/qt/src/dataprovider.h new file mode 100644 index 00000000..337f2646 --- /dev/null +++ b/lang/qt/src/dataprovider.h @@ -0,0 +1,95 @@ +/* dataprovider.h + Copyright (C) 2004 Klarälvdalens Datakonsult AB + Copyright (c) 2016 Intevation GmbH + + This file is part of QGPGME. + + QGPGME is free software; you can redistribute it and/or modify it + under the terms of the GNU Library General Public License as published + by the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + QGPGME is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Library General Public License for more details. + + You should have received a copy of the GNU Library General Public License + along with QGPGME; see the file COPYING.LIB. If not, write to the + Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. */ + +// -*- c++ -*- +#ifndef __QGPGME_DATAPROVIDER_H__ +#define __QGPGME_DATAPROVIDER_H__ + +#include "qgpgme_export.h" +#include <interfaces/dataprovider.h> +#include <memory> + +#include <QtCore/QByteArray> + + +class QIODevice; + +namespace QGpgME +{ + +class QGPGME_EXPORT QByteArrayDataProvider : public GpgME::DataProvider +{ +public: + QByteArrayDataProvider(); + explicit QByteArrayDataProvider(const QByteArray &initialData); + ~QByteArrayDataProvider(); + + const QByteArray &data() const + { + return mArray; + } + +private: + // these shall only be accessed through the dataprovider + // interface, where they're public: + bool isSupported(Operation) const + { + return true; + } + ssize_t read(void *buffer, size_t bufSize); + ssize_t write(const void *buffer, size_t bufSize); + off_t seek(off_t offset, int whence); + void release(); + +private: + QByteArray mArray; + off_t mOff; +}; + +class QGPGME_EXPORT QIODeviceDataProvider : public GpgME::DataProvider +{ +public: + explicit QIODeviceDataProvider(const std::shared_ptr<QIODevice> &initialData); + ~QIODeviceDataProvider(); + + const std::shared_ptr<QIODevice> &ioDevice() const + { + return mIO; + } + +private: + // these shall only be accessed through the dataprovider + // interface, where they're public: + bool isSupported(Operation) const; + ssize_t read(void *buffer, size_t bufSize); + ssize_t write(const void *buffer, size_t bufSize); + off_t seek(off_t offset, int whence); + void release(); + +private: + const std::shared_ptr<QIODevice> mIO; + bool mErrorOccurred : 1; + bool mHaveQProcess : 1; +}; + +} // namespace QGpgME + +#endif diff --git a/lang/qt/src/decryptjob.h b/lang/qt/src/decryptjob.h new file mode 100644 index 00000000..c4fc86fd --- /dev/null +++ b/lang/qt/src/decryptjob.h @@ -0,0 +1,100 @@ +/* + decryptjob.h + + This file is part of qgpgme, the Qt API binding for gpgme + Copyright (c) 2004, 2007 Klarälvdalens Datakonsult AB + Copyright (c) 2016 Intevation GmbH + + QGpgME 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. + + QGpgME 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 this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + + In addition, as a special exception, the copyright holders give + permission to link the code of this program with any edition of + the Qt library by Trolltech AS, Norway (or with modified versions + of Qt that use the same license as Qt), and distribute linked + combinations including the two. You must obey the GNU General + Public License in all respects for all of the code used other than + Qt. If you modify this file, you may extend this exception to + your version of the file, but you are not obligated to do so. If + you do not wish to do so, delete this exception statement from + your version. +*/ + +#ifndef __KLEO_DECRYPTJOB_H__ +#define __KLEO_DECRYPTJOB_H__ + +#include "job.h" + +#include <memory> + +class QByteArray; +class QIODevice; + +namespace GpgME +{ +class Error; +class DecryptionResult; +} + +namespace QGpgME +{ + +/** + @short An abstract base class for asynchronous decrypters + + To use a DecryptJob, first obtain an instance from the + CryptoBackend implementation, connect the progress() and result() + signals to suitable slots and then start the decryption with a + call to start(). This call might fail, in which case the + DecryptJob instance will have scheduled it's own destruction with + a call to QObject::deleteLater(). + + After result() is emitted, the DecryptJob will schedule it's own + destruction by calling QObject::deleteLater(). +*/ +class QGPGME_EXPORT DecryptJob : public Job +{ + Q_OBJECT +protected: + explicit DecryptJob(QObject *parent); +public: + ~DecryptJob(); + + /** + Starts the decryption operation. \a cipherText is the data to + decrypt. + */ + virtual QGPGME_DEPRECATED_EXPORT GpgME::Error start(const QByteArray &cipherText) = 0; + + /*! + \overload + + If \a plainText is non-null, the plaintext is written + there. Otherwise, it will be delivered in the second argument + of result(). + + \throws GpgME::Exception if starting fails + */ + virtual void start(const std::shared_ptr<QIODevice> &cipherText, const std::shared_ptr<QIODevice> &plainText = std::shared_ptr<QIODevice>()) = 0; + + virtual GpgME::DecryptionResult exec(const QByteArray &cipherText, + QByteArray &plainText) = 0; + +Q_SIGNALS: + void result(const GpgME::DecryptionResult &result, const QByteArray &plainText, const QString &auditLogAsHtml = QString(), const GpgME::Error &auditLogError = GpgME::Error()); +}; + +} + +#endif // __KLEO_DECRYPTJOB_H__ diff --git a/lang/qt/src/decryptverifyjob.h b/lang/qt/src/decryptverifyjob.h new file mode 100644 index 00000000..97af0086 --- /dev/null +++ b/lang/qt/src/decryptverifyjob.h @@ -0,0 +1,105 @@ +/* + decryptverifyjob.h + + This file is part of qgpgme, the Qt API binding for gpgme + Copyright (c) 2004, 2007 Klarälvdalens Datakonsult AB + Copyright (c) 2016 Intevation GmbH + + QGpgME 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. + + QGpgME 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 this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + + In addition, as a special exception, the copyright holders give + permission to link the code of this program with any edition of + the Qt library by Trolltech AS, Norway (or with modified versions + of Qt that use the same license as Qt), and distribute linked + combinations including the two. You must obey the GNU General + Public License in all respects for all of the code used other than + Qt. If you modify this file, you may extend this exception to + your version of the file, but you are not obligated to do so. If + you do not wish to do so, delete this exception statement from + your version. +*/ + +#ifndef __KLEO_DECRYPTVERIFYJOB_H__ +#define __KLEO_DECRYPTVERIFYJOB_H__ + +#include "job.h" + +#include <memory> + +class QByteArray; +class QIODevice; + +namespace GpgME +{ +class Error; +class DecryptionResult; +class VerificationResult; +} + +namespace QGpgME +{ + +/** + @short An abstract base class for asynchronous combined decrypters and verifiers + + To use a DecryptVerifyJob, first obtain an instance from the + CryptoBackend implementation, connect the progress() and result() + signals to suitable slots and then start the operation with a + call to start(). This call might fail, in which case the + DecryptVerifyJob instance will have scheduled it's own destruction with + a call to QObject::deleteLater(). + + After result() is emitted, the DecryptVerifyJob will schedule it's own + destruction by calling QObject::deleteLater(). +*/ +class QGPGME_EXPORT DecryptVerifyJob : public Job +{ + Q_OBJECT +protected: + explicit DecryptVerifyJob(QObject *parent); +public: + ~DecryptVerifyJob(); + + /** + Starts the combined decryption and verification operation. + \a cipherText is the data to decrypt and later verify. + */ + virtual QGPGME_DEPRECATED_EXPORT GpgME::Error start(const QByteArray &cipherText) = 0; + + /*! + \overload + + If \a plainText is non-null, the plaintext is written + there. Otherwise, it will be delivered in the third argument + of result(). + + \throws GpgME::Exception if starting fails + */ + virtual void start(const std::shared_ptr<QIODevice> &cipherText, const std::shared_ptr<QIODevice> &plainText = std::shared_ptr<QIODevice>()) = 0; + + /** Synchronous equivalent of start() */ + virtual std::pair<GpgME::DecryptionResult, GpgME::VerificationResult> + exec(const QByteArray &cipherText, QByteArray &plainText) = 0; + +Q_SIGNALS: + void result(const GpgME::DecryptionResult &decryptionresult, + const GpgME::VerificationResult &verificationresult, + const QByteArray &plainText, const QString &auditLogAsHtml = QString(), + const GpgME::Error &auditLogError = GpgME::Error()); +}; + +} + +#endif // __KLEO_DECRYPTVERIFYJOB_H__ diff --git a/lang/qt/src/deletejob.h b/lang/qt/src/deletejob.h new file mode 100644 index 00000000..1f4e8cfd --- /dev/null +++ b/lang/qt/src/deletejob.h @@ -0,0 +1,82 @@ +/* + deletejob.h + + This file is part of qgpgme, the Qt API binding for gpgme + Copyright (c) 2004 Klarälvdalens Datakonsult AB + Copyright (c) 2016 Intevation GmbH + + QGpgME 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. + + QGpgME 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 this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + + In addition, as a special exception, the copyright holders give + permission to link the code of this program with any edition of + the Qt library by Trolltech AS, Norway (or with modified versions + of Qt that use the same license as Qt), and distribute linked + combinations including the two. You must obey the GNU General + Public License in all respects for all of the code used other than + Qt. If you modify this file, you may extend this exception to + your version of the file, but you are not obligated to do so. If + you do not wish to do so, delete this exception statement from + your version. +*/ + +#ifndef __KLEO_DELETEJOB_H__ +#define __KLEO_DELETEJOB_H__ + +#include "job.h" + +namespace GpgME +{ +class Error; +class Key; +} + +namespace QGpgME +{ + +/** + @short An abstract base class for asynchronous deleters + + To use a DeleteJob, first obtain an instance from the + CryptoBackend implementation, connect the progress() and result() + signals to suitable slots and then start the delete with a call + to start(). This call might fail, in which case the DeleteJob + instance will have scheduled it's own destruction with a call to + QObject::deleteLater(). + + After result() is emitted, the DeleteJob will schedule it's own + destruction by calling QObject::deleteLater(). +*/ +class DeleteJob : public Job +{ + Q_OBJECT +protected: + explicit DeleteJob(QObject *parent); +public: + ~DeleteJob(); + + /** + Starts the delete operation. \a key represents the key to + delete, \a allowSecretKeyDeletion specifies if a key may also + be deleted if the secret key part is available, too. + */ + virtual GpgME::Error start(const GpgME::Key &key, bool allowSecretKeyDeletion = false) = 0; + +Q_SIGNALS: + void result(const GpgME::Error &result, const QString &auditLogAsHtml = QString(), const GpgME::Error &auditLogError = GpgME::Error()); +}; + +} + +#endif // __KLEO_DELETEJOB_H__ diff --git a/lang/qt/src/downloadjob.h b/lang/qt/src/downloadjob.h new file mode 100644 index 00000000..09eecf63 --- /dev/null +++ b/lang/qt/src/downloadjob.h @@ -0,0 +1,103 @@ +/* + downloadjob.h + + This file is part of qgpgme, the Qt API binding for gpgme + Copyright (c) 2004 Klarälvdalens Datakonsult AB + Copyright (c) 2016 Intevation GmbH + + QGpgME 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. + + QGpgME 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 this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + + In addition, as a special exception, the copyright holders give + permission to link the code of this program with any edition of + the Qt library by Trolltech AS, Norway (or with modified versions + of Qt that use the same license as Qt), and distribute linked + combinations including the two. You must obey the GNU General + Public License in all respects for all of the code used other than + Qt. If you modify this file, you may extend this exception to + your version of the file, but you are not obligated to do so. If + you do not wish to do so, delete this exception statement from + your version. +*/ + +#ifndef __KLEO_DOWNLOADJOB_H__ +#define __KLEO_DOWNLOADJOB_H__ + +#include "job.h" + +#include <QtCore/QByteArray> + +#include <memory> + +namespace GpgME +{ +class Error; +} + +class QStringList; +class QIODevice; +class QByteArray; + +namespace QGpgME +{ + +/** + @short An abstract base class for asynchronous downloaders + + To use a DownloadJob, first obtain an instance from the + CryptoBackend implementation, connect the progress() and result() + signals to suitable slots and then start the download with a call + to start(). This call might fail, in which case the DownloadJob + instance will have scheduled it's own destruction with a call to + QObject::deleteLater(). + + After result() is emitted, the DownloadJob will schedule it's own + destruction by calling QObject::deleteLater(). +*/ +class QGPGME_EXPORT DownloadJob : public Job +{ + Q_OBJECT +protected: + explicit DownloadJob(QObject *parent); +public: + ~DownloadJob(); + + /** + Starts the download operation. \a fingerprint is the + fingerprint of the key to download. If \a fingerprint is empty, + contains only whitespace or anything other than a fingerprint, + the result is undefined. + + Output is written to \a keyData, if given. Otherwise, it is + passed as the second argument of result(). + */ + virtual GpgME::Error start(const QByteArray &fingerprint, + const std::shared_ptr<QIODevice> &keyData) = 0; + + /** + Starts the download operation. \a fingerprints is a list of + fingerprints used to specify the list of keys downloaded. Empty + patterns are ignored. If \a fingerprints is empty, contains + only empty strings or anything other than fingerprints, the + result is undefined. + */ + virtual QGPGME_DEPRECATED_EXPORT GpgME::Error start(const QStringList &fingerprints) = 0; + +Q_SIGNALS: + void result(const GpgME::Error &result, const QByteArray &keyData, const QString &auditLogAsHtml = QString(), const GpgME::Error &auditLogError = GpgME::Error()); +}; + +} + +#endif // __KLEO_DOWNLOADJOB_H__ diff --git a/lang/qt/src/encryptjob.h b/lang/qt/src/encryptjob.h new file mode 100644 index 00000000..060ff8df --- /dev/null +++ b/lang/qt/src/encryptjob.h @@ -0,0 +1,119 @@ +/* + encryptjob.h + + This file is part of qgpgme, the Qt API binding for gpgme + Copyright (c) 2004, 2007 Klarälvdalens Datakonsult AB + Copyright (c) 2016 Intevation GmbH + + QGpgME 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. + + QGpgME 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 this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + + In addition, as a special exception, the copyright holders give + permission to link the code of this program with any edition of + the Qt library by Trolltech AS, Norway (or with modified versions + of Qt that use the same license as Qt), and distribute linked + combinations including the two. You must obey the GNU General + Public License in all respects for all of the code used other than + Qt. If you modify this file, you may extend this exception to + your version of the file, but you are not obligated to do so. If + you do not wish to do so, delete this exception statement from + your version. +*/ + +#ifndef __KLEO_ENCRYPTJOB_H__ +#define __KLEO_ENCRYPTJOB_H__ + +#include "job.h" + +#include <memory> +#include <vector> + +class QByteArray; +class QIODevice; + +namespace GpgME +{ +class Error; +class Key; +class EncryptionResult; +} + +namespace QGpgME +{ + +/** + @short An abstract base class for asynchronous encrypters + + To use a EncryptJob, first obtain an instance from the + CryptoBackend implementation, connect the progress() and result() + signals to suitable slots and then start the encryption with a + call to start(). This call might fail, in which case the + EncryptJob instance will have scheduled it's own destruction with + a call to QObject::deleteLater(). + + After result() is emitted, the EncryptJob will schedule it's own + destruction by calling QObject::deleteLater(). +*/ +class QGPGME_EXPORT EncryptJob : public Job +{ + Q_OBJECT +protected: + explicit EncryptJob(QObject *parent); +public: + ~EncryptJob(); + + /** + Starts the encryption operation. \a recipients is the a list of + keys to encrypt \a plainText to. Empty (null) keys are + ignored. If \a recipients is empty, performs symmetric + (passphrase) encryption. + + If \a alwaysTrust is true, validity checking for the keys will + not be performed, but full validity assumed for all keys + without further checks. + */ + virtual QGPGME_DEPRECATED_EXPORT GpgME::Error start(const std::vector<GpgME::Key> &recipients, + const QByteArray &plainText, bool alwaysTrust = false) = 0; + + /*! + \overload + + If \a cipherText is non-null, the ciphertext is written + there. Otherwise, it will be delivered in the second argument of + result(). + + \throws GpgME::Exception if starting fails + */ + virtual void start(const std::vector<GpgME::Key> &recipients, + const std::shared_ptr<QIODevice> &plainText, + const std::shared_ptr<QIODevice> &cipherText = std::shared_ptr<QIODevice>(), + bool alwaysTrust = false) = 0; + + virtual GpgME::EncryptionResult exec(const std::vector<GpgME::Key> &recipients, + const QByteArray &plainText, + bool alwaysTrust, QByteArray &cipherText) = 0; + + /*! + This is a hack to request BASE64 output (instead of whatever + comes out normally). + */ + virtual void setOutputIsBase64Encoded(bool) = 0; + +Q_SIGNALS: + void result(const GpgME::EncryptionResult &result, const QByteArray &cipherText, const QString &auditLogAsHtml = QString(), const GpgME::Error &auditLogError = GpgME::Error()); +}; + +} + +#endif // __KLEO_ENCRYPTJOB_H__ diff --git a/lang/qt/src/exportjob.h b/lang/qt/src/exportjob.h new file mode 100644 index 00000000..df21f032 --- /dev/null +++ b/lang/qt/src/exportjob.h @@ -0,0 +1,86 @@ +/* + exportjob.h + + This file is part of qgpgme, the Qt API binding for gpgme + Copyright (c) 2004 Klarälvdalens Datakonsult AB + Copyright (c) 2016 Intevation GmbH + + QGpgME 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. + + QGpgME 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 this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + + In addition, as a special exception, the copyright holders give + permission to link the code of this program with any edition of + the Qt library by Trolltech AS, Norway (or with modified versions + of Qt that use the same license as Qt), and distribute linked + combinations including the two. You must obey the GNU General + Public License in all respects for all of the code used other than + Qt. If you modify this file, you may extend this exception to + your version of the file, but you are not obligated to do so. If + you do not wish to do so, delete this exception statement from + your version. +*/ + +#ifndef __QGPGME_EXPORTJOB_H__ +#define __QGPGME_EXPORTJOB_H__ + +#include "job.h" + +#include <QtCore/QByteArray> + +namespace GpgME +{ +class Error; +} + +class QStringList; + +namespace QGpgME +{ + +/** + @short An abstract base class for asynchronous exporters + + To use a ExportJob, first obtain an instance from the + CryptoBackend implementation, connect the progress() and result() + signals to suitable slots and then start the export with a call + to start(). This call might fail, in which case the ExportJob + instance will have scheduled it's own destruction with a call to + QObject::deleteLater(). + + After result() is emitted, the ExportJob will schedule it's own + destruction by calling QObject::deleteLater(). +*/ +class ExportJob : public Job +{ + Q_OBJECT +protected: + explicit ExportJob(QObject *parent); +public: + ~ExportJob(); + + /** + Starts the export operation. \a patterns is a list of patterns + used to restrict the list of keys exported. Empty patterns are + ignored. If \a patterns is empty or contains only empty + strings, all available keys are exported. + */ + virtual GpgME::Error start(const QStringList &patterns) = 0; + +Q_SIGNALS: + void result(const GpgME::Error &result, const QByteArray &keyData, const QString &auditLogAsHtml = QString(), const GpgME::Error &auditLogError = GpgME::Error()); +}; + +} + +#endif // __QGPGME_EXPORTJOB_H__ diff --git a/lang/qt/src/gpgme_backend_debug.cpp b/lang/qt/src/gpgme_backend_debug.cpp new file mode 100644 index 00000000..6dfb3135 --- /dev/null +++ b/lang/qt/src/gpgme_backend_debug.cpp @@ -0,0 +1,10 @@ +// This file is autogenerated by CMake: DO NOT EDIT + +#include "gpgme_backend_debug.h" + + +#if QT_VERSION >= QT_VERSION_CHECK(5, 4, 0) +Q_LOGGING_CATEGORY(GPGPME_BACKEND_LOG, "log_gpgme_backend", QtWarningMsg) +#else +Q_LOGGING_CATEGORY(GPGPME_BACKEND_LOG, "log_gpgme_backend") +#endif diff --git a/lang/qt/src/gpgme_backend_debug.h b/lang/qt/src/gpgme_backend_debug.h new file mode 100644 index 00000000..5ac93db2 --- /dev/null +++ b/lang/qt/src/gpgme_backend_debug.h @@ -0,0 +1,11 @@ +// This file is autogenerated by CMake: DO NOT EDIT + +#ifndef GPGPME_BACKEND_LOG_H +#define GPGPME_BACKEND_LOG_H + +#include <QLoggingCategory> + +Q_DECLARE_LOGGING_CATEGORY(GPGPME_BACKEND_LOG) + + +#endif diff --git a/lang/qt/src/hierarchicalkeylistjob.h b/lang/qt/src/hierarchicalkeylistjob.h new file mode 100644 index 00000000..2ec187d2 --- /dev/null +++ b/lang/qt/src/hierarchicalkeylistjob.h @@ -0,0 +1,125 @@ +/* + hierarchicalkeylistjob.h + + This file is part of qgpgme, the Qt API binding for gpgme + Copyright (c) 2004 Klarälvdalens Datakonsult AB + Copyright (c) 2016 Intevation GmbH + + QGpgME 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. + + QGpgME 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 this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + + In addition, as a special exception, the copyright holders give + permission to link the code of this program with any edition of + the Qt library by Trolltech AS, Norway (or with modified versions + of Qt that use the same license as Qt), and distribute linked + combinations including the two. You must obey the GNU General + Public License in all respects for all of the code used other than + Qt. If you modify this file, you may extend this exception to + your version of the file, but you are not obligated to do so. If + you do not wish to do so, delete this exception statement from + your version. +*/ + +#ifndef __KLEO_HIERARCHICALKEYLISTJOB_H__ +#define __KLEO_HIERARCHICALKEYLISTJOB_H__ + +#include "qgpgme_export.h" +#include "keylistjob.h" +#include "cryptobackend.h" + +#ifdef BUILDING_QGPGME +# include "keylistresult.h" +#else +#include <gpgme++/keylistresult.h> +#endif + +#include <QPointer> + +#include <set> + +namespace GpgME +{ +class Error; +class Key; +} + +namespace QGpgME +{ +class KeyListJob; +} + +namespace QGpgME +{ + +/** + @short A convenience job that additionally fetches all available issuers. + + To use a HierarchicalKeyListJob, pass it a CryptoBackend + implementation, connect the progress() and result() signals to + suitable slots and then start the keylisting with a call to + start(). This call might fail, in which case the + HierarchicalKeyListJob instance will have scheduled it's own + destruction with a call to QObject::deleteLater(). + + After result() is emitted, the HierarchicalKeyListJob will + schedule its own destruction by calling QObject::deleteLater(). +*/ +class QGPGME_EXPORT HierarchicalKeyListJob : public KeyListJob +{ + Q_OBJECT +public: + explicit HierarchicalKeyListJob(const Protocol *protocol, + bool remote = false, bool includeSigs = false, + bool validating = false); + ~HierarchicalKeyListJob(); + + /** + Starts the keylist operation. \a patterns is a list of patterns + used to restrict the list of keys returned. Empty patterns are + ignored. \a patterns must not be empty or contain only empty + patterns; use the normal KeyListJob for a full listing. + + The \a secretOnly parameter is ignored by + HierarchicalKeyListJob and must be set to false. + */ + GpgME::Error start(const QStringList &patterns, bool secretOnly = false) Q_DECL_OVERRIDE; + + GpgME::KeyListResult exec(const QStringList &patterns, bool secretOnly, + std::vector<GpgME::Key> &keys) Q_DECL_OVERRIDE; + +private Q_SLOTS: + void slotResult(const GpgME::KeyListResult &); + void slotNextKey(const GpgME::Key &key); + /* from Job */ + void slotCancel() Q_DECL_OVERRIDE; + +private: + GpgME::Error startAJob(); + +private: + const Protocol *const mProtocol; + const bool mRemote; + const bool mIncludeSigs; + const bool mValidating; + bool mTruncated; + std::set<QString> mSentSet; // keys already sent (prevent duplicates even if the backend should return them) + std::set<QString> mScheduledSet; // keys already scheduled (by starting a job for them) + std::set<QString> mNextSet; // keys to schedule for the next iteraton + GpgME::KeyListResult mIntermediateResult; + QPointer<KeyListJob> mJob; +}; + +} + +#endif // __KLEO_HIERARCHICALKEYLISTJOB_H__ diff --git a/lang/qt/src/importfromkeyserverjob.h b/lang/qt/src/importfromkeyserverjob.h new file mode 100644 index 00000000..7ab13cb2 --- /dev/null +++ b/lang/qt/src/importfromkeyserverjob.h @@ -0,0 +1,83 @@ +/* + importfromkeyserverjob.h + + This file is part of qgpgme, the Qt API binding for gpgme + Copyright (c) 2004 Klarälvdalens Datakonsult AB + Copyright (c) 2016 Intevation GmbH + + QGpgME 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. + + QGpgME 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 this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + + In addition, as a special exception, the copyright holders give + permission to link the code of this program with any edition of + the Qt library by Trolltech AS, Norway (or with modified versions + of Qt that use the same license as Qt), and distribute linked + combinations including the two. You must obey the GNU General + Public License in all respects for all of the code used other than + Qt. If you modify this file, you may extend this exception to + your version of the file, but you are not obligated to do so. If + you do not wish to do so, delete this exception statement from + your version. +*/ + +#ifndef __KLEO_IMPORTFROMKEYSERVERJOB_H__ +#define __KLEO_IMPORTFROMKEYSERVERJOB_H__ + +#include "abstractimportjob.h" + +namespace GpgME +{ +class Key; +class Error; +class ImportResult; +} + +#include <vector> + +namespace QGpgME +{ + +/** + @short An abstract base class for asynchronous keyserver-importers + + To use a ImportJob, first obtain an instance from the + CryptoBackend implementation, connect the progress() and result() + signals to suitable slots and then start the import with a call + to start(). This call might fail, in which case the ImportJob + instance will have scheduled it's own destruction with a call to + QObject::deleteLater(). + + After result() is emitted, the ImportJob will schedule it's own + destruction by calling QObject::deleteLater(). +*/ +class ImportFromKeyserverJob : public AbstractImportJob +{ + Q_OBJECT +protected: + explicit ImportFromKeyserverJob(QObject *parent); +public: + ~ImportFromKeyserverJob(); + + /** + Starts the importing operation. \a keyData contains the data to + import from. + */ + virtual GpgME::Error start(const std::vector<GpgME::Key> &keys) = 0; + + virtual GpgME::ImportResult exec(const std::vector<GpgME::Key> &keys) = 0; +}; + +} + +#endif // __KLEO_IMPORTFROMKEYSERVERJOB_H__ diff --git a/lang/qt/src/importjob.h b/lang/qt/src/importjob.h new file mode 100644 index 00000000..d9f60d1a --- /dev/null +++ b/lang/qt/src/importjob.h @@ -0,0 +1,82 @@ +/* + importjob.h + + This file is part of qgpgme, the Qt API binding for gpgme + Copyright (c) 2004 Klarälvdalens Datakonsult AB + Copyright (c) 2016 Intevation GmbH + + QGpgME 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. + + QGpgME 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 this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + + In addition, as a special exception, the copyright holders give + permission to link the code of this program with any edition of + the Qt library by Trolltech AS, Norway (or with modified versions + of Qt that use the same license as Qt), and distribute linked + combinations including the two. You must obey the GNU General + Public License in all respects for all of the code used other than + Qt. If you modify this file, you may extend this exception to + your version of the file, but you are not obligated to do so. If + you do not wish to do so, delete this exception statement from + your version. +*/ + +#ifndef __KLEO_IMPORTJOB_H__ +#define __KLEO_IMPORTJOB_H__ + +#include "abstractimportjob.h" + +#include <QtCore/QByteArray> + +namespace GpgME +{ +class Error; +class ImportResult; +} + +namespace QGpgME +{ + +/** + @short An abstract base class for asynchronous importers + + To use a ImportJob, first obtain an instance from the + CryptoBackend implementation, connect the progress() and result() + signals to suitable slots and then start the import with a call + to start(). This call might fail, in which case the ImportJob + instance will have scheduled it's own destruction with a call to + QObject::deleteLater(). + + After result() is emitted, the ImportJob will schedule it's own + destruction by calling QObject::deleteLater(). +*/ +class ImportJob : public AbstractImportJob +{ + Q_OBJECT +protected: + explicit ImportJob(QObject *parent); +public: + ~ImportJob(); + + /** + Starts the importing operation. \a keyData contains the data to + import from. + */ + virtual GpgME::Error start(const QByteArray &keyData) = 0; + + virtual GpgME::ImportResult exec(const QByteArray &keyData) = 0; +}; + +} + +#endif // __KLEO_IMPORTJOB_H__ diff --git a/lang/qt/src/job.cpp b/lang/qt/src/job.cpp new file mode 100644 index 00000000..7ca1df9b --- /dev/null +++ b/lang/qt/src/job.cpp @@ -0,0 +1,150 @@ +/* + job.cpp + + This file is part of qgpgme, the Qt API binding for gpgme + Copyright (c) 2004,2005 Klarälvdalens Datakonsult AB + Copyright (c) 2016 Intevation GmbH + + QGpgME 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. + + QGpgME 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 this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + + In addition, as a special exception, the copyright holders give + permission to link the code of this program with any edition of + the Qt library by Trolltech AS, Norway (or with modified versions + of Qt that use the same license as Qt), and distribute linked + combinations including the two. You must obey the GNU General + Public License in all respects for all of the code used other than + Qt. If you modify this file, you may extend this exception to + your version of the file, but you are not obligated to do so. If + you do not wish to do so, delete this exception statement from + your version. +*/ + +#include "job.h" + +#include "keylistjob.h" +#include "listallkeysjob.h" +#include "encryptjob.h" +#include "decryptjob.h" +#include "decryptverifyjob.h" +#include "signjob.h" +#include "signkeyjob.h" +#include "signencryptjob.h" +#include "verifydetachedjob.h" +#include "verifyopaquejob.h" +#include "keygenerationjob.h" +#include "importjob.h" +#include "importfromkeyserverjob.h" +#include "exportjob.h" +#include "changeexpiryjob.h" +#include "changeownertrustjob.h" +#include "changepasswdjob.h" +#include "downloadjob.h" +#include "deletejob.h" +#include "refreshkeysjob.h" +#include "adduseridjob.h" +#include "specialjob.h" + +#include <QCoreApplication> +#include <QDebug> + +#include <gpg-error.h> + +QGpgME::Job::Job(QObject *parent) + : QObject(parent) +{ + if (QCoreApplication *app = QCoreApplication::instance()) { + connect(app, &QCoreApplication::aboutToQuit, this, &Job::slotCancel); + } +} + +QGpgME::Job::~Job() +{ + +} + +QString QGpgME::Job::auditLogAsHtml() const +{ + qDebug() << "QGpgME::Job::auditLogAsHtml() should be reimplemented in Kleo::Job subclasses!"; + return QString(); +} + +GpgME::Error QGpgME::Job::auditLogError() const +{ + qDebug() << "QGpgME::Job::auditLogError() should be reimplemented in Kleo::Job subclasses!"; + return GpgME::Error::fromCode(GPG_ERR_NOT_IMPLEMENTED); +} + +bool QGpgME::Job::isAuditLogSupported() const +{ + return auditLogError().code() != GPG_ERR_NOT_IMPLEMENTED; +} + +#define make_job_subclass_ext(x,y) \ + QGpgME::x::x( QObject * parent ) : y( parent ) {} \ + QGpgME::x::~x() {} + +#define make_job_subclass(x) make_job_subclass_ext(x,Job) + +make_job_subclass(KeyListJob) +make_job_subclass(ListAllKeysJob) +make_job_subclass(EncryptJob) +make_job_subclass(DecryptJob) +make_job_subclass(DecryptVerifyJob) +make_job_subclass(SignJob) +make_job_subclass(SignEncryptJob) +make_job_subclass(SignKeyJob) +make_job_subclass(VerifyDetachedJob) +make_job_subclass(VerifyOpaqueJob) +make_job_subclass(KeyGenerationJob) +make_job_subclass(AbstractImportJob) +make_job_subclass_ext(ImportJob, AbstractImportJob) +make_job_subclass_ext(ImportFromKeyserverJob, AbstractImportJob) +make_job_subclass(ExportJob) +make_job_subclass(ChangeExpiryJob) +make_job_subclass(ChangeOwnerTrustJob) +make_job_subclass(ChangePasswdJob) +make_job_subclass(DownloadJob) +make_job_subclass(DeleteJob) +make_job_subclass(RefreshKeysJob) +make_job_subclass(AddUserIDJob) +make_job_subclass(SpecialJob) + +#undef make_job_subclass + +#include "job.moc" + +#include "keylistjob.moc" +#include "listallkeysjob.moc" +#include "encryptjob.moc" +#include "decryptjob.moc" +#include "decryptverifyjob.moc" +#include "signjob.moc" +#include "signencryptjob.moc" +#include "signkeyjob.moc" +#include "verifydetachedjob.moc" +#include "verifyopaquejob.moc" +#include "keygenerationjob.moc" +#include "abstractimportjob.moc" +#include "importjob.moc" +#include "importfromkeyserverjob.moc" +#include "exportjob.moc" +#include "changeexpiryjob.moc" +#include "changeownertrustjob.moc" +#include "changepasswdjob.moc" +#include "downloadjob.moc" +#include "deletejob.moc" +#include "refreshkeysjob.moc" +#include "adduseridjob.moc" +#include "specialjob.moc" diff --git a/lang/qt/src/job.h b/lang/qt/src/job.h new file mode 100644 index 00000000..57677296 --- /dev/null +++ b/lang/qt/src/job.h @@ -0,0 +1,92 @@ +/* + job.h + + This file is part of qgpgme, the Qt API binding for gpgme + Copyright (c) 2004 Klarälvdalens Datakonsult AB + Copyright (c) 2016 Intevation GmbH + + QGpgME 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. + + QGpgME 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 this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + + In addition, as a special exception, the copyright holders give + permission to link the code of this program with any edition of + the Qt library by Trolltech AS, Norway (or with modified versions + of Qt that use the same license as Qt), and distribute linked + combinations including the two. You must obey the GNU General + Public License in all respects for all of the code used other than + Qt. If you modify this file, you may extend this exception to + your version of the file, but you are not obligated to do so. If + you do not wish to do so, delete this exception statement from + your version. +*/ + +#ifndef __KLEO_JOB_H__ +#define __KLEO_JOB_H__ + +#include "qgpgme_export.h" + +#include <QObject> +#include <QString> + +#ifdef BUILDING_QGPGME +# include "error.h" +#else +# include <gpgme++/error.h> +#endif + +class QWidget; + +namespace QGpgME +{ + +/** + @short An abstract base class for asynchronous crypto operations + + During the operation, you might receive progress updates through + the progress() signal as they arrive, but an implementation is + free to not send progress information. You should show a busy + progressbar until the first progress() signal is received. + + The done() signal is emitted _before_ the result() signals of + subclasses and should be used to hide and/or reset progress bars, + not to learn of the end of the operation. Use the result() + signals for that. + + To cancel the operation, simply call slotCancel(). The result() + signal of subclasses will still be emitted, though, and will + carry the information that the operation was canceled. +*/ +class QGPGME_EXPORT Job : public QObject +{ + Q_OBJECT +protected: + explicit Job(QObject *parent); +public: + ~Job(); + + virtual QString auditLogAsHtml() const; + virtual GpgME::Error auditLogError() const; + bool isAuditLogSupported() const; + +public Q_SLOTS: + virtual void slotCancel() = 0; + +Q_SIGNALS: + void progress(const QString &what, int current, int total); + void done(); +}; + +} + +#endif // __KLEO_JOB_H__ diff --git a/lang/qt/src/keygenerationjob.h b/lang/qt/src/keygenerationjob.h new file mode 100644 index 00000000..90f29bfb --- /dev/null +++ b/lang/qt/src/keygenerationjob.h @@ -0,0 +1,84 @@ +/* + keygenerationjob.h + + This file is part of qgpgme, the Qt API binding for gpgme + Copyright (c) 2004 Klarälvdalens Datakonsult AB + Copyright (c) 2016 Intevation GmbH + + QGpgME 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. + + QGpgME 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 this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + + In addition, as a special exception, the copyright holders give + permission to link the code of this program with any edition of + the Qt library by Trolltech AS, Norway (or with modified versions + of Qt that use the same license as Qt), and distribute linked + combinations including the two. You must obey the GNU General + Public License in all respects for all of the code used other than + Qt. If you modify this file, you may extend this exception to + your version of the file, but you are not obligated to do so. If + you do not wish to do so, delete this exception statement from + your version. +*/ + +#ifndef __KLEO_KEYGENERATIONJOB_H__ +#define __KLEO_KEYGENERATIONJOB_H__ + +#include "job.h" + +#include <QtCore/QByteArray> + +namespace GpgME +{ +class Error; +class KeyGenerationResult; +} + +namespace QGpgME +{ + +/** + @short An abstract base class for asynchronous key generation + + To use a KeyGenerationJob, first obtain an instance from the + CryptoBackend implementation, connect the progress() and result() + signals to suitable slots and then start the key generation with + a call to start(). This call might fail, in which case the + KeyGenerationJob instance will have scheduled it's own + destruction with a call to QObject::deleteLater(). + + After result() is emitted, the KeyGenerationJob will schedule it's own + destruction by calling QObject::deleteLater(). +*/ +class KeyGenerationJob : public Job +{ + Q_OBJECT +protected: + explicit KeyGenerationJob(QObject *parent); +public: + ~KeyGenerationJob(); + + /** + Starts the key generation operation. \a parameters is a + backend-specific string containing the parameters of the key to + create (length, capabilities, etc). + */ + virtual GpgME::Error start(const QString ¶meters) = 0; + +Q_SIGNALS: + void result(const GpgME::KeyGenerationResult &result, const QByteArray &pubKeyData, const QString &auditLogAsHtml = QString(), const GpgME::Error &auditLogError = GpgME::Error()); +}; + +} + +#endif // __KLEO_KEYGENERATIONJOB_H__ diff --git a/lang/qt/src/keylistjob.h b/lang/qt/src/keylistjob.h new file mode 100644 index 00000000..6e62c4fb --- /dev/null +++ b/lang/qt/src/keylistjob.h @@ -0,0 +1,105 @@ +/* + keylistjob.h + + This file is part of qgpgme, the Qt API binding for gpgme + Copyright (c) 2004 Klarälvdalens Datakonsult AB + Copyright (c) 2016 Intevation GmbH + + QGpgME 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. + + QGpgME 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 this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + + In addition, as a special exception, the copyright holders give + permission to link the code of this program with any edition of + the Qt library by Trolltech AS, Norway (or with modified versions + of Qt that use the same license as Qt), and distribute linked + combinations including the two. You must obey the GNU General + Public License in all respects for all of the code used other than + Qt. If you modify this file, you may extend this exception to + your version of the file, but you are not obligated to do so. If + you do not wish to do so, delete this exception statement from + your version. +*/ + +#ifndef __KLEO_KEYLISTJOB_H__ +#define __KLEO_KEYLISTJOB_H__ + +#include "job.h" + +#ifdef BUILDING_QGPGME +# include "key.h" +#else +# include <gpgme++/key.h> +#endif + +#include <vector> + +namespace GpgME +{ +class Error; +class KeyListResult; +} + +class QStringList; + +namespace QGpgME +{ + +/** + @short An abstract base class for asynchronous key listers + + To use a KeyListJob, first obtain an instance from the + CryptoBackend implementation, connect the nextKey(), progress() + and result() signals to suitable slots and then start the key + listing with a call to start(). This call might fail, in which + case the KeylistJob instance will have schedules it's own + destruction with a call to QObject::deleteLater(). + + During keylisting, you will receive new key objects through the + nextKey() signal as they arrive. After result() is emitted, the + KeyListJob will schedule it's own destruction by calling + QObject::deleteLater(). +*/ +class KeyListJob : public Job +{ + Q_OBJECT +protected: + explicit KeyListJob(QObject *parent); + +public: + ~KeyListJob(); + + /** + Starts the keylist operation. \a pattern is a list of patterns + used to restrict the list of keys returned. Empty patterns are + ignored. If \a pattern is empty or contains only empty strings, + all keys are returned (however, the backend is free to truncate + the result and should do so; when this happens, it will be + reported by the reult object). + + If \a secretOnly is true, only keys for which the secret key is + also available are returned. Use this if you need to select a + key for signing. + */ + virtual GpgME::Error start(const QStringList &patterns, bool secretOnly = false) = 0; + + virtual GpgME::KeyListResult exec(const QStringList &patterns, bool secretOnly, std::vector<GpgME::Key> &keys) = 0; + +Q_SIGNALS: + void nextKey(const GpgME::Key &key); + void result(const GpgME::KeyListResult &result, const std::vector<GpgME::Key> &keys = std::vector<GpgME::Key>(), const QString &auditLogAsHtml = QString(), const GpgME::Error &auditLogError = GpgME::Error()); +}; + +} + +#endif // __KLEO_KEYLISTJOB_H__ diff --git a/lang/qt/src/listallkeysjob.h b/lang/qt/src/listallkeysjob.h new file mode 100644 index 00000000..9d4711d2 --- /dev/null +++ b/lang/qt/src/listallkeysjob.h @@ -0,0 +1,103 @@ +/* + listallkeysjob.h + + This file is part of qgpgme, the Qt API binding for gpgme + Copyright (c) 2004 Klarälvdalens Datakonsult AB + Copyright (c) 2016 Intevation GmbH + + QGpgME 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. + + QGpgME 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 this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + + In addition, as a special exception, the copyright holders give + permission to link the code of this program with any edition of + the Qt library by Trolltech AS, Norway (or with modified versions + of Qt that use the same license as Qt), and distribute linked + combinations including the two. You must obey the GNU General + Public License in all respects for all of the code used other than + Qt. If you modify this file, you may extend this exception to + your version of the file, but you are not obligated to do so. If + you do not wish to do so, delete this exception statement from + your version. +*/ + +#ifndef __KLEO_LISTALLKEYSJOB_H__ +#define __KLEO_LISTALLKEYSJOB_H__ + +#include "job.h" + +#ifdef BUILDING_QGPGME +# include "key.h" +#else +# include <gpgme++/key.h> +#endif + +#include <vector> + +namespace GpgME +{ +class Error; +class KeyListResult; +} + +namespace QGpgME +{ + +/** + @short An abstract base class for asynchronously listing all keys + + To use a ListAllKeysJob, first obtain an instance from the + CryptoBackend implementation, connect the progress() + and result() signals to suitable slots and then start the key + listing with a call to start(). This call might fail, in which + case the ListAllKeysJob instance will have schedules it's own + destruction with a call to QObject::deleteLater(). + + After result() is emitted, the ListAllKeysJob will schedule it's + own destruction by calling QObject::deleteLater(). + + This is potentially much faster than a KeyListJob with empty + pattern. +*/ +class ListAllKeysJob : public Job +{ + Q_OBJECT +protected: + explicit ListAllKeysJob(QObject *parent); + +public: + ~ListAllKeysJob(); + + /** + Starts the listallkeys operation. In general, all keys are + returned (however, the backend is free to truncate the result + and should do so; when this happens, it will be reported by the + result object). + + If \a mergeKeys is true, secret keys are merged into public + keys. + */ + virtual GpgME::Error start(bool mergeKeys = false) = 0; + + /** + Synchronous version of start(). + */ + virtual GpgME::KeyListResult exec(std::vector<GpgME::Key> &pub, std::vector<GpgME::Key> &sec, bool mergeKeys = false) = 0; + +Q_SIGNALS: + void result(const GpgME::KeyListResult &result, const std::vector<GpgME::Key> &pub = std::vector<GpgME::Key>(), const std::vector<GpgME::Key> &sec = std::vector<GpgME::Key>(), const QString &auditLogAsHtml = QString(), const GpgME::Error &auditLogError = GpgME::Error()); +}; + +} + +#endif // __KLEO_LISTALLKEYSJOB_H__ diff --git a/lang/qt/src/multideletejob.h b/lang/qt/src/multideletejob.h new file mode 100644 index 00000000..8915cd1a --- /dev/null +++ b/lang/qt/src/multideletejob.h @@ -0,0 +1,107 @@ +/* + multideletejob.h + + This file is part of qgpgme, the Qt API binding for gpgme + Copyright (c) 2004 Klarälvdalens Datakonsult AB + Copyright (c) 2016 Intevation GmbH + + QGpgME 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. + + QGpgME 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 this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + + In addition, as a special exception, the copyright holders give + permission to link the code of this program with any edition of + the Qt library by Trolltech AS, Norway (or with modified versions + of Qt that use the same license as Qt), and distribute linked + combinations including the two. You must obey the GNU General + Public License in all respects for all of the code used other than + Qt. If you modify this file, you may extend this exception to + your version of the file, but you are not obligated to do so. If + you do not wish to do so, delete this exception statement from + your version. +*/ + +#ifndef __KLEO_MULTIDELETEJOB_H__ +#define __KLEO_MULTIDELETEJOB_H__ + +#include "qgpgme_export.h" +#include "job.h" +#include "cryptobackend.h" + +#include <QPointer> + +#include <vector> + +namespace GpgME +{ +class Error; +class Key; +} + +namespace QGpgME +{ +class DeleteJob; +} + +namespace QGpgME +{ + +/** + @short A convenience class bundling together multiple DeleteJobs. + + To use a MultiDeleteJob, pass it a CryptoBackend implementation, + connect the progress() and result() signals to suitable slots and + then start the delete with a call to start(). This call might + fail, in which case the MultiDeleteJob instance will have scheduled + it's own destruction with a call to QObject::deleteLater(). + + After result() is emitted, the MultiDeleteJob will schedule it's own + destruction by calling QObject::deleteLater(). +*/ +class QGPGME_EXPORT MultiDeleteJob : public Job +{ + Q_OBJECT +public: + explicit MultiDeleteJob(const Protocol *protocol); + ~MultiDeleteJob(); + + /** + Starts the delete operation. \a keys is the list of keys to + delete, \a allowSecretKeyDeletion specifies if a key may also + be deleted if the secret key part is available, too. + */ + GpgME::Error start(const std::vector<GpgME::Key> &keys, bool allowSecretKeyDeletion = false); + + /* from Job */ + void slotCancel() Q_DECL_OVERRIDE; + +Q_SIGNALS: + void result(const GpgME::Error &result, const GpgME::Key &errorKey); + +private Q_SLOTS: + void slotResult(const GpgME::Error &); + +private: + GpgME::Error startAJob(); + +private: + const Protocol *mProtocol; + QPointer<DeleteJob> mJob; + std::vector<GpgME::Key> mKeys; + std::vector<GpgME::Key>::const_iterator mIt; + bool mAllowSecretKeyDeletion; +}; + +} + +#endif // __KLEO_MULTIDELETEJOB_H__ diff --git a/lang/qt/src/protocol.h b/lang/qt/src/protocol.h new file mode 100644 index 00000000..5162fe6a --- /dev/null +++ b/lang/qt/src/protocol.h @@ -0,0 +1,123 @@ +/* + protocol.h + + This file is part of qgpgme, the Qt API binding for gpgme + Copyright (c) 2004,2005 Klarälvdalens Datakonsult AB + Copyright (c) 2016 Intevation GmbH + + QGpgME 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. + + QGpgME 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 this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + + In addition, as a special exception, the copyright holders give + permission to link the code of this program with any edition of + the Qt library by Trolltech AS, Norway (or with modified versions + of Qt that use the same license as Qt), and distribute linked + combinations including the two. You must obey the GNU General + Public License in all respects for all of the code used other than + Qt. If you modify this file, you may extend this exception to + your version of the file, but you are not obligated to do so. If + you do not wish to do so, delete this exception statement from + your version. +*/ +#ifndef __QGPGME_PROTOCOL_H__ +#define __QGPGME_PROTOCOL_H__ + +#include <QString> +#include <QVariant> + +#include "qgpgme_export.h" + +namespace QGpgME { +class CryptoConfig; +class KeyListJob; +class ListAllKeysJob; +class KeyGenerationJob; +class ImportJob; +class ImportFromKeyserverJob; +class ExportJob; +class DownloadJob; +class DeleteJob; +class EncryptJob; +class DecryptJob; +class SignJob; +class SignKeyJob; +class VerifyDetachedJob; +class VerifyOpaqueJob; +class SignEncryptJob; +class DecryptVerifyJob; +class RefreshKeysJob; +class ChangeExpiryJob; +class ChangeOwnerTrustJob; +class ChangePasswdJob; +class AddUserIDJob; +class SpecialJob; + +class QGPGME_EXPORT Protocol +{ +public: + virtual ~Protocol() {} + + virtual QString name() const = 0; + + virtual QString displayName() const = 0; + + virtual KeyListJob *keyListJob(bool remote = false, bool includeSigs = false, bool validate = false) const = 0; + virtual ListAllKeysJob *listAllKeysJob(bool includeSigs = false, bool validate = false) const = 0; + virtual EncryptJob *encryptJob(bool armor = false, bool textmode = false) const = 0; + virtual DecryptJob *decryptJob() const = 0; + virtual SignJob *signJob(bool armor = false, bool textMode = false) const = 0; + virtual VerifyDetachedJob *verifyDetachedJob(bool textmode = false) const = 0; + virtual VerifyOpaqueJob *verifyOpaqueJob(bool textmode = false) const = 0; + virtual KeyGenerationJob *keyGenerationJob() const = 0; + virtual ImportJob *importJob() const = 0; + virtual ImportFromKeyserverJob *importFromKeyserverJob() const = 0; + virtual ExportJob *publicKeyExportJob(bool armor = false) const = 0; + // @param charset the encoding of the passphrase in the exported file + virtual ExportJob *secretKeyExportJob(bool armor = false, const QString &charset = QString()) const = 0; + virtual DownloadJob *downloadJob(bool armor = false) const = 0; + virtual DeleteJob *deleteJob() const = 0; + virtual SignEncryptJob *signEncryptJob(bool armor = false, bool textMode = false) const = 0; + virtual DecryptVerifyJob *decryptVerifyJob(bool textmode = false) const = 0; + virtual RefreshKeysJob *refreshKeysJob() const = 0; + virtual ChangeExpiryJob *changeExpiryJob() const = 0; + virtual SignKeyJob *signKeyJob() const = 0; + virtual ChangePasswdJob *changePasswdJob() const = 0; + virtual ChangeOwnerTrustJob *changeOwnerTrustJob() const = 0; + virtual AddUserIDJob *addUserIDJob() const = 0; + virtual SpecialJob *specialJob(const char *type, const QMap<QString, QVariant> &args) const = 0; +}; + +/** Obtain a reference to the OpenPGP Protocol. + * + * The reference is to a static object. + * @returns Refrence to the OpenPGP Protocol. + */ +QGPGME_EXPORT Protocol *openpgp(); + +/** Obtain a reference to the smime Protocol. + * + * The reference is to a static object. + * @returns Refrence to the smime Protocol. + */ +QGPGME_EXPORT Protocol *smime(); + +/** Obtain a reference to a cryptoConfig object. + * + * The reference is to a static object. + * @returns reference to cryptoConfig object. + */ +QGPGME_EXPORT CryptoConfig *cryptoConfig(); + +} +#endif diff --git a/lang/qt/src/protocol_p.h b/lang/qt/src/protocol_p.h new file mode 100644 index 00000000..d6c5625a --- /dev/null +++ b/lang/qt/src/protocol_p.h @@ -0,0 +1,371 @@ +/* + protocol_p.h + + This file is part of qgpgme, the Qt API binding for gpgme + Copyright (c) 2004,2005 Klarälvdalens Datakonsult AB + Copyright (c) 2016 Intevation GmbH + + QGpgME 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. + + QGpgME 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 this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + + In addition, as a special exception, the copyright holders give + permission to link the code of this program with any edition of + the Qt library by Trolltech AS, Norway (or with modified versions + of Qt that use the same license as Qt), and distribute linked + combinations including the two. You must obey the GNU General + Public License in all respects for all of the code used other than + Qt. If you modify this file, you may extend this exception to + your version of the file, but you are not obligated to do so. If + you do not wish to do so, delete this exception statement from + your version. +*/ +#ifndef __QGPGME_PROTOCOL_P_H__ +#define __QGPGME_PROTOCOL_P_H__ +#include "qgpgmenewcryptoconfig.h" + +#include "qgpgmekeygenerationjob.h" +#include "qgpgmekeylistjob.h" +#include "qgpgmelistallkeysjob.h" +#include "qgpgmedecryptjob.h" +#include "qgpgmedecryptverifyjob.h" +#include "qgpgmerefreshkeysjob.h" +#include "qgpgmedeletejob.h" +#include "qgpgmesecretkeyexportjob.h" +#include "qgpgmedownloadjob.h" +#include "qgpgmesignencryptjob.h" +#include "qgpgmeencryptjob.h" +#include "qgpgmesignjob.h" +#include "qgpgmesignkeyjob.h" +#include "qgpgmeexportjob.h" +#include "qgpgmeverifydetachedjob.h" +#include "qgpgmeimportjob.h" +#include "qgpgmeimportfromkeyserverjob.h" +#include "qgpgmeverifyopaquejob.h" +#include "qgpgmechangeexpiryjob.h" +#include "qgpgmechangeownertrustjob.h" +#include "qgpgmechangepasswdjob.h" +#include "qgpgmeadduseridjob.h" + +namespace +{ + +class Protocol : public QGpgME::Protocol +{ + GpgME::Protocol mProtocol; +public: + explicit Protocol(GpgME::Protocol proto) : mProtocol(proto) {} + + QString name() const Q_DECL_OVERRIDE + { + switch (mProtocol) { + case GpgME::OpenPGP: return QStringLiteral("OpenPGP"); + case GpgME::CMS: return QStringLiteral("SMIME"); + default: return QString(); + } + } + + QString displayName() const Q_DECL_OVERRIDE + { + // ah (2.4.16): Where is this used and isn't this inverted + // with name + switch (mProtocol) { + case GpgME::OpenPGP: return QStringLiteral("gpg"); + case GpgME::CMS: return QStringLiteral("gpgsm"); + default: return QStringLiteral("unknown"); + } + } + + QGpgME::SpecialJob *specialJob(const char *, const QMap<QString, QVariant> &) const Q_DECL_OVERRIDE + { + return 0; + } + + QGpgME::KeyListJob *keyListJob(bool remote, bool includeSigs, bool validate) const Q_DECL_OVERRIDE + { + GpgME::Context *context = GpgME::Context::createForProtocol(mProtocol); + if (!context) { + return 0; + } + + unsigned int mode = context->keyListMode(); + if (remote) { + mode |= GpgME::Extern; + mode &= ~GpgME::Local; + } else { + mode |= GpgME::Local; + mode &= ~GpgME::Extern; + } + if (includeSigs) { + mode |= GpgME::Signatures; + } + if (validate) { + mode |= GpgME::Validate; + } + context->setKeyListMode(mode); + return new QGpgME::QGpgMEKeyListJob(context); + } + + QGpgME::ListAllKeysJob *listAllKeysJob(bool includeSigs, bool validate) const Q_DECL_OVERRIDE + { + GpgME::Context *context = GpgME::Context::createForProtocol(mProtocol); + if (!context) { + return 0; + } + + unsigned int mode = context->keyListMode(); + mode |= GpgME::Local; + mode &= ~GpgME::Extern; + if (includeSigs) { + mode |= GpgME::Signatures; + } + if (validate) { + mode |= GpgME::Validate; + /* Setting the context to offline mode disables CRL / OCSP checks in + this Job. Otherwise we would try to fetch the CRL's for all CMS + keys in the users keyring because GpgME::Validate includes remote + resources by default in the validity check. + This setting only has any effect if gpgsm >= 2.1.6 is used. + */ + context->setOffline(true); + } + context->setKeyListMode(mode); + return new QGpgME::QGpgMEListAllKeysJob(context); + } + + QGpgME::EncryptJob *encryptJob(bool armor, bool textmode) const Q_DECL_OVERRIDE + { + GpgME::Context *context = GpgME::Context::createForProtocol(mProtocol); + if (!context) { + return 0; + } + + context->setArmor(armor); + context->setTextMode(textmode); + return new QGpgME::QGpgMEEncryptJob(context); + } + + QGpgME::DecryptJob *decryptJob() const Q_DECL_OVERRIDE + { + GpgME::Context *context = GpgME::Context::createForProtocol(mProtocol); + if (!context) { + return 0; + } + return new QGpgME::QGpgMEDecryptJob(context); + } + + QGpgME::SignJob *signJob(bool armor, bool textMode) const Q_DECL_OVERRIDE + { + GpgME::Context *context = GpgME::Context::createForProtocol(mProtocol); + if (!context) { + return 0; + } + + context->setArmor(armor); + context->setTextMode(textMode); + return new QGpgME::QGpgMESignJob(context); + } + + QGpgME::VerifyDetachedJob *verifyDetachedJob(bool textMode) const Q_DECL_OVERRIDE + { + GpgME::Context *context = GpgME::Context::createForProtocol(mProtocol); + if (!context) { + return 0; + } + + context->setTextMode(textMode); + return new QGpgME::QGpgMEVerifyDetachedJob(context); + } + + QGpgME::VerifyOpaqueJob *verifyOpaqueJob(bool textMode) const Q_DECL_OVERRIDE + { + GpgME::Context *context = GpgME::Context::createForProtocol(mProtocol); + if (!context) { + return 0; + } + + context->setTextMode(textMode); + return new QGpgME::QGpgMEVerifyOpaqueJob(context); + } + + QGpgME::KeyGenerationJob *keyGenerationJob() const Q_DECL_OVERRIDE + { + GpgME::Context *context = GpgME::Context::createForProtocol(mProtocol); + if (!context) { + return 0; + } + return new QGpgME::QGpgMEKeyGenerationJob(context); + } + + QGpgME::ImportJob *importJob() const Q_DECL_OVERRIDE + { + GpgME::Context *context = GpgME::Context::createForProtocol(mProtocol); + if (!context) { + return 0; + } + return new QGpgME::QGpgMEImportJob(context); + } + + QGpgME::ImportFromKeyserverJob *importFromKeyserverJob() const Q_DECL_OVERRIDE + { + GpgME::Context *context = GpgME::Context::createForProtocol(mProtocol); + if (!context) { + return 0; + } + return new QGpgME::QGpgMEImportFromKeyserverJob(context); + } + + QGpgME::ExportJob *publicKeyExportJob(bool armor) const Q_DECL_OVERRIDE + { + GpgME::Context *context = GpgME::Context::createForProtocol(mProtocol); + if (!context) { + return 0; + } + + context->setArmor(armor); + return new QGpgME::QGpgMEExportJob(context); + } + + QGpgME::ExportJob *secretKeyExportJob(bool armor, const QString &charset) const Q_DECL_OVERRIDE + { + if (mProtocol != GpgME::CMS) { // fixme: add support for gpg, too + return 0; + } + + // this operation is not supported by gpgme, so we have to call gpgsm ourselves: + return new QGpgME::QGpgMESecretKeyExportJob(armor, charset); + } + + QGpgME::RefreshKeysJob *refreshKeysJob() const Q_DECL_OVERRIDE + { + if (mProtocol != GpgME::CMS) { // fixme: add support for gpg, too + return 0; + } + + // this operation is not supported by gpgme, so we have to call gpgsm ourselves: + return new QGpgME::QGpgMERefreshKeysJob(); + } + + QGpgME::DownloadJob *downloadJob(bool armor) const Q_DECL_OVERRIDE + { + GpgME::Context *context = GpgME::Context::createForProtocol(mProtocol); + if (!context) { + return 0; + } + + context->setArmor(armor); + // this is the hackish interface for downloading from keyserers currently: + context->setKeyListMode(GpgME::Extern); + return new QGpgME::QGpgMEDownloadJob(context); + } + + QGpgME::DeleteJob *deleteJob() const Q_DECL_OVERRIDE + { + GpgME::Context *context = GpgME::Context::createForProtocol(mProtocol); + if (!context) { + return 0; + } + return new QGpgME::QGpgMEDeleteJob(context); + } + + QGpgME::SignEncryptJob *signEncryptJob(bool armor, bool textMode) const Q_DECL_OVERRIDE + { + GpgME::Context *context = GpgME::Context::createForProtocol(mProtocol); + if (!context) { + return 0; + } + + context->setArmor(armor); + context->setTextMode(textMode); + return new QGpgME::QGpgMESignEncryptJob(context); + } + + QGpgME::DecryptVerifyJob *decryptVerifyJob(bool textMode) const Q_DECL_OVERRIDE + { + GpgME::Context *context = GpgME::Context::createForProtocol(mProtocol); + if (!context) { + return 0; + } + + context->setTextMode(textMode); + return new QGpgME::QGpgMEDecryptVerifyJob(context); + } + + QGpgME::ChangeExpiryJob *changeExpiryJob() const Q_DECL_OVERRIDE + { + if (mProtocol != GpgME::OpenPGP) { + return 0; // only supported by gpg + } + + GpgME::Context *context = GpgME::Context::createForProtocol(mProtocol); + if (!context) { + return 0; + } + return new QGpgME::QGpgMEChangeExpiryJob(context); + } + + QGpgME::ChangePasswdJob *changePasswdJob() const Q_DECL_OVERRIDE + { + if (!GpgME::hasFeature(GpgME::PasswdFeature, 0)) { + return 0; + } + GpgME::Context *context = GpgME::Context::createForProtocol(mProtocol); + if (!context) { + return 0; + } + return new QGpgME::QGpgMEChangePasswdJob(context); + } + + QGpgME::SignKeyJob *signKeyJob() const Q_DECL_OVERRIDE + { + if (mProtocol != GpgME::OpenPGP) { + return 0; // only supported by gpg + } + + GpgME::Context *context = GpgME::Context::createForProtocol(mProtocol); + if (!context) { + return 0; + } + return new QGpgME::QGpgMESignKeyJob(context); + } + + QGpgME::ChangeOwnerTrustJob *changeOwnerTrustJob() const Q_DECL_OVERRIDE + { + if (mProtocol != GpgME::OpenPGP) { + return 0; // only supported by gpg + } + + GpgME::Context *context = GpgME::Context::createForProtocol(mProtocol); + if (!context) { + return 0; + } + return new QGpgME::QGpgMEChangeOwnerTrustJob(context); + } + + QGpgME::AddUserIDJob *addUserIDJob() const Q_DECL_OVERRIDE + { + if (mProtocol != GpgME::OpenPGP) { + return 0; // only supported by gpg + } + + GpgME::Context *context = GpgME::Context::createForProtocol(mProtocol); + if (!context) { + return 0; + } + return new QGpgME::QGpgMEAddUserIDJob(context); + } + +}; + +} +#endif diff --git a/lang/qt/src/qgpgme_export.h b/lang/qt/src/qgpgme_export.h new file mode 100644 index 00000000..40630d55 --- /dev/null +++ b/lang/qt/src/qgpgme_export.h @@ -0,0 +1,53 @@ + +#ifndef QGPGME_EXPORT_H +#define QGPGME_EXPORT_H + +#ifdef QGPGME_STATIC_DEFINE +# define QGPGME_EXPORT +# define QGPGME_NO_EXPORT +#else +# ifndef QGPGME_EXPORT +# ifdef BUILDING_QGPGME + /* We are building this library */ +# ifdef WIN32 +# define QGPGME_EXPORT __declspec(dllexport) +# else +# define QGPGME_EXPORT __attribute__((visibility("default"))) +# endif +# else + /* We are using this library */ +# ifdef WIN32 +# define QGPGME_EXPORT __declspec(dllimport) +# else +# define QGPGME_EXPORT __attribute__((visibility("default"))) +# endif +# endif +# endif + +# ifndef QGPGME_NO_EXPORT +# ifdef WIN32 +# define QGPGME_NO_EXPORT +# else +# define QGPGME_NO_EXPORT __attribute__((visibility("hidden"))) +# endif +# endif +#endif + +#ifndef QGPGME_DEPRECATED +# define QGPGME_DEPRECATED __attribute__ ((__deprecated__)) +#endif + +#ifndef QGPGME_DEPRECATED_EXPORT +# define QGPGME_DEPRECATED_EXPORT QGPGME_EXPORT QGPGME_DEPRECATED +#endif + +#ifndef QGPGME_DEPRECATED_NO_EXPORT +# define QGPGME_DEPRECATED_NO_EXPORT QGPGME_NO_EXPORT QGPGME_DEPRECATED +#endif + +#define DEFINE_NO_DEPRECATED 0 +#if DEFINE_NO_DEPRECATED +# define QGPGME_NO_DEPRECATED +#endif + +#endif diff --git a/lang/qt/src/qgpgmeadduseridjob.cpp b/lang/qt/src/qgpgmeadduseridjob.cpp new file mode 100644 index 00000000..aa873f43 --- /dev/null +++ b/lang/qt/src/qgpgmeadduseridjob.cpp @@ -0,0 +1,82 @@ +/* + qgpgmeadduseridjob.cpp + + This file is part of qgpgme, the Qt API binding for gpgme + Copyright (c) 2008 Klarälvdalens Datakonsult AB + Copyright (c) 2016 Intevation GmbH + + QGpgME 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. + + QGpgME 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 this program; if not, write to the Free Software Foundation, Inc., + 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + + In addition, as a special exception, the copyright holders give + permission to link the code of this program with any edition of + the Qt library by Trolltech AS, Norway (or with modified versions + of Qt that use the same license as Qt), and distribute linked + combinations including the two. You must obey the GNU General + Public License in all respects for all of the code used other than + Qt. If you modify this file, you may extend this exception to + your version of the file, but you are not obligated to do so. If + you do not wish to do so, delete this exception statement from + your version. +*/ + +#include "qgpgmeadduseridjob.h" + +#include "dataprovider.h" + +#include "context.h" +#include "data.h" +#include "gpgadduserideditinteractor.h" +#include "key.h" + +#include <cassert> +#include <memory> + +using namespace QGpgME; +using namespace GpgME; + +QGpgMEAddUserIDJob::QGpgMEAddUserIDJob(Context *context) + : mixin_type(context) +{ + lateInitialization(); +} + +QGpgMEAddUserIDJob::~QGpgMEAddUserIDJob() {} + +static QGpgMEAddUserIDJob::result_type add_user_id(Context *ctx, const Key &key, const QString &name, const QString &email, const QString &comment) +{ + + std::auto_ptr<GpgAddUserIDEditInteractor> gau(new GpgAddUserIDEditInteractor); + + gau->setNameUtf8(name.toUtf8().constData()); + gau->setEmailUtf8(email.toUtf8().constData()); + gau->setCommentUtf8(comment.toUtf8().constData()); + + std::auto_ptr<EditInteractor> ei(gau); + + QGpgME::QByteArrayDataProvider dp; + Data data(&dp); + assert(!data.isNull()); + const Error err = ctx->edit(key, ei, data); + Error ae; + const QString log = _detail::audit_log_as_html(ctx, ae); + return std::make_tuple(err, log, ae); +} + +Error QGpgMEAddUserIDJob::start(const Key &key, const QString &name, const QString &email, const QString &comment) +{ + run(std::bind(&add_user_id, std::placeholders::_1, key, name, email, comment)); + return Error(); +} +#include "qgpgmeadduseridjob.moc" diff --git a/lang/qt/src/qgpgmeadduseridjob.h b/lang/qt/src/qgpgmeadduseridjob.h new file mode 100644 index 00000000..294eb6c4 --- /dev/null +++ b/lang/qt/src/qgpgmeadduseridjob.h @@ -0,0 +1,65 @@ +/* + qgpgmeadduseridjob.h + + This file is part of qgpgme, the Qt API binding for gpgme + Copyright (c) 2008 Klarälvdalens Datakonsult AB + Copyright (c) 2016 Intevation GmbH + + QGpgME 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. + + QGpgME 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 this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + + In addition, as a special exception, the copyright holders give + permission to link the code of this program with any edition of + the Qt library by Trolltech AS, Norway (or with modified versions + of Qt that use the same license as Qt), and distribute linked + combinations including the two. You must obey the GNU General + Public License in all respects for all of the code used other than + Qt. If you modify this file, you may extend this exception to + your version of the file, but you are not obligated to do so. If + you do not wish to do so, delete this exception statement from + your version. +*/ + +#ifndef __QGPGME_QGPGMEADDUSERIDJOB_H__ +#define __QGPGME_QGPGMEADDUSERIDJOB_H__ + +#include "adduseridjob.h" + +#include "threadedjobmixin.h" + +namespace QGpgME +{ + +class QGpgMEAddUserIDJob +#ifdef Q_MOC_RUN + : public AddUserIDJob +#else + : public _detail::ThreadedJobMixin<AddUserIDJob> +#endif +{ + Q_OBJECT +#ifdef Q_MOC_RUN +private Q_SLOTS: + void slotFinished(); +#endif +public: + explicit QGpgMEAddUserIDJob(GpgME::Context *context); + ~QGpgMEAddUserIDJob(); + + /* from AddUserIDJob */ + GpgME::Error start(const GpgME::Key &key, const QString &name, const QString &email, const QString &comment) Q_DECL_OVERRIDE; +}; +} + +#endif // __QGPGME_QGPGMEADDUSERIDJOB_H__ diff --git a/lang/qt/src/qgpgmebackend.cpp b/lang/qt/src/qgpgmebackend.cpp new file mode 100644 index 00000000..797e58a6 --- /dev/null +++ b/lang/qt/src/qgpgmebackend.cpp @@ -0,0 +1,203 @@ +/* + qgpgmebackend.cpp + + This file is part of qgpgme, the Qt API binding for gpgme + Copyright (c) 2004,2005 Klarälvdalens Datakonsult AB + Copyright (c) 2016 Intevation GmbH + + QGpgME 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. + + QGpgME 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 this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + + In addition, as a special exception, the copyright holders give + permission to link the code of this program with any edition of + the Qt library by Trolltech AS, Norway (or with modified versions + of Qt that use the same license as Qt), and distribute linked + combinations including the two. You must obey the GNU General + Public License in all respects for all of the code used other than + Qt. If you modify this file, you may extend this exception to + your version of the file, but you are not obligated to do so. If + you do not wish to do so, delete this exception statement from + your version. +*/ + +#include "qgpgmebackend.h" + + +#include "error.h" +#include "engineinfo.h" + +#include "protocol_p.h" + +#include <QFile> +#include <QString> + +const char QGpgME::QGpgMEBackend::OpenPGP[] = "OpenPGP"; +const char QGpgME::QGpgMEBackend::SMIME[] = "SMIME"; + + +QGpgME::QGpgMEBackend::QGpgMEBackend() + : mCryptoConfig(0), + mOpenPGPProtocol(0), + mSMIMEProtocol(0) +{ + GpgME::initializeLibrary(); +} + +QGpgME::QGpgMEBackend::~QGpgMEBackend() +{ + delete mCryptoConfig; mCryptoConfig = 0; + delete mOpenPGPProtocol; mOpenPGPProtocol = 0; + delete mSMIMEProtocol; mSMIMEProtocol = 0; +} + +QString QGpgME::QGpgMEBackend::name() const +{ + return QStringLiteral("gpgme"); +} + +QString QGpgME::QGpgMEBackend::displayName() const +{ + return QStringLiteral("GpgME"); +} + +QGpgME::CryptoConfig *QGpgME::QGpgMEBackend::config() const +{ + if (!mCryptoConfig) { + if (GpgME::hasFeature(GpgME::GpgConfEngineFeature, 0)) { + mCryptoConfig = new QGpgMENewCryptoConfig; + } + } + return mCryptoConfig; +} + +static bool check(GpgME::Protocol proto, QString *reason) +{ + if (!GpgME::checkEngine(proto)) { + return true; + } + if (!reason) { + return false; + } + // error, check why: +#if 0 +Port away from localised string or delete. + const GpgME::EngineInfo ei = GpgME::engineInfo(proto); + if (ei.isNull()) { + *reason = i18n("GPGME was compiled without support for %1.", proto == GpgME::CMS ? QLatin1String("S/MIME") : QLatin1String("OpenPGP")); + } else if (ei.fileName() && !ei.version()) { + *reason = i18n("Engine %1 is not installed properly.", QFile::decodeName(ei.fileName())); + } else if (ei.fileName() && ei.version() && ei.requiredVersion()) + *reason = i18n("Engine %1 version %2 installed, " + "but at least version %3 is required.", + QFile::decodeName(ei.fileName()), QLatin1String(ei.version()), QLatin1String(ei.requiredVersion())); + else { + *reason = i18n("Unknown problem with engine for protocol %1.", proto == GpgME::CMS ? QLatin1String("S/MIME") : QLatin1String("OpenPGP")); + } +#endif + return false; +} + +bool QGpgME::QGpgMEBackend::checkForOpenPGP(QString *reason) const +{ + return check(GpgME::OpenPGP, reason); +} + +bool QGpgME::QGpgMEBackend::checkForSMIME(QString *reason) const +{ + return check(GpgME::CMS, reason); +} + +bool QGpgME::QGpgMEBackend::checkForProtocol(const char *name, QString *reason) const +{ + if (qstricmp(name, OpenPGP) == 0) { + return check(GpgME::OpenPGP, reason); + } + if (qstricmp(name, SMIME) == 0) { + return check(GpgME::CMS, reason); + } + if (reason) { + *reason = QStringLiteral("Unsupported protocol \"%1\"").arg(QLatin1String(name)); + } + return false; +} + +QGpgME::Protocol *QGpgME::QGpgMEBackend::openpgp() const +{ + if (!mOpenPGPProtocol) + if (checkForOpenPGP()) { + mOpenPGPProtocol = new ::Protocol(GpgME::OpenPGP); + } + return mOpenPGPProtocol; +} + +QGpgME::Protocol *QGpgME::QGpgMEBackend::smime() const +{ + if (!mSMIMEProtocol) + if (checkForSMIME()) { + mSMIMEProtocol = new ::Protocol(GpgME::CMS); + } + return mSMIMEProtocol; +} + +QGpgME::Protocol *QGpgME::QGpgMEBackend::protocol(const char *name) const +{ + if (qstricmp(name, OpenPGP) == 0) { + return openpgp(); + } + if (qstricmp(name, SMIME) == 0) { + return smime(); + } + return 0; +} + +bool QGpgME::QGpgMEBackend::supportsProtocol(const char *name) const +{ + return qstricmp(name, OpenPGP) == 0 || qstricmp(name, SMIME) == 0; +} + +const char *QGpgME::QGpgMEBackend::enumerateProtocols(int i) const +{ + switch (i) { + case 0: return OpenPGP; + case 1: return SMIME; + default: return 0; + } +} + +static QGpgME::QGpgMEBackend *gpgmeBackend; + +QGpgME::CryptoConfig *QGpgME::cryptoConfig() +{ + if (!gpgmeBackend) { + gpgmeBackend = new QGpgME::QGpgMEBackend(); + } + return gpgmeBackend->config(); + +} + +QGpgME::Protocol *QGpgME::openpgp() +{ + if (!gpgmeBackend) { + gpgmeBackend = new QGpgME::QGpgMEBackend(); + } + return gpgmeBackend->openpgp(); +} + +QGpgME::Protocol *QGpgME::smime() +{ + if (!gpgmeBackend) { + gpgmeBackend = new QGpgME::QGpgMEBackend(); + } + return gpgmeBackend->smime(); +} diff --git a/lang/qt/src/qgpgmebackend.h b/lang/qt/src/qgpgmebackend.h new file mode 100644 index 00000000..cca8b711 --- /dev/null +++ b/lang/qt/src/qgpgmebackend.h @@ -0,0 +1,92 @@ +/* + qgpgmebackend.h + + This file is part of qgpgme, the Qt API binding for gpgme + Copyright (c) 2004,2005 Klarälvdalens Datakonsult AB + Copyright (c) 2016 Intevation GmbH + + QGpgME 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. + + QGpgME 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 this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + + In addition, as a special exception, the copyright holders give + permission to link the code of this program with any edition of + the Qt library by Trolltech AS, Norway (or with modified versions + of Qt that use the same license as Qt), and distribute linked + combinations including the two. You must obey the GNU General + Public License in all respects for all of the code used other than + Qt. If you modify this file, you may extend this exception to + your version of the file, but you are not obligated to do so. If + you do not wish to do so, delete this exception statement from + your version. +*/ + +#ifndef __QGPGME_QGPGMEBACKEND_H__ +#define __QGPGME_QGPGMEBACKEND_H__ + +#include <QString> + +#include "protocol.h" + +class QString; +template <typename T_Key, typename T_Value> class QMap; + +namespace QGpgME +{ +class CryptoConfig; +class Protocol; + + +class QGpgMEBackend +{ +public: + QGpgMEBackend(); + ~QGpgMEBackend(); + + QString name() const; + QString displayName() const; + + CryptoConfig *config() const; + + Protocol *openpgp() const; + Protocol *smime() const; + Protocol *protocol(const char *name) const; + + static const char OpenPGP[]; + static const char SMIME[]; + + bool checkForOpenPGP(QString *reason = Q_NULLPTR) const; + bool checkForSMIME(QString *reason = Q_NULLPTR) const; + bool checkForProtocol(const char *name, QString *reason) const; + + bool supportsOpenPGP() const + { + return true; + } + bool supportsSMIME() const + { + return true; + } + bool supportsProtocol(const char *name) const; + + const char *enumerateProtocols(int i) const; + +private: + mutable QGpgME::CryptoConfig *mCryptoConfig; + mutable Protocol *mOpenPGPProtocol; + mutable Protocol *mSMIMEProtocol; +}; + +} + +#endif // __QGPGME_QGPGMEBACKEND_H__ diff --git a/lang/qt/src/qgpgmechangeexpiryjob.cpp b/lang/qt/src/qgpgmechangeexpiryjob.cpp new file mode 100644 index 00000000..e0c6c4d1 --- /dev/null +++ b/lang/qt/src/qgpgmechangeexpiryjob.cpp @@ -0,0 +1,81 @@ +/* + qgpgmechangeexpiryjob.cpp + + This file is part of qgpgme, the Qt API binding for gpgme + Copyright (c) 2008 Klarälvdalens Datakonsult AB + Copyright (c) 2016 Intevation GmbH + + QGpgME 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. + + QGpgME 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 this program; if not, write to the Free Software Foundation, Inc., + 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + + In addition, as a special exception, the copyright holders give + permission to link the code of this program with any edition of + the Qt library by Trolltech AS, Norway (or with modified versions + of Qt that use the same license as Qt), and distribute linked + combinations including the two. You must obey the GNU General + Public License in all respects for all of the code used other than + Qt. If you modify this file, you may extend this exception to + your version of the file, but you are not obligated to do so. If + you do not wish to do so, delete this exception statement from + your version. +*/ + +#include "qgpgmechangeexpiryjob.h" + +#include "dataprovider.h" + +#include "context.h" +#include "data.h" +#include "gpgsetexpirytimeeditinteractor.h" +#include "key.h" + +#include <QDateTime> + +#include <cassert> +#include <memory> +#include <string> + +using namespace QGpgME; +using namespace GpgME; + +QGpgMEChangeExpiryJob::QGpgMEChangeExpiryJob(Context *context) + : mixin_type(context) +{ + lateInitialization(); +} + +QGpgMEChangeExpiryJob::~QGpgMEChangeExpiryJob() {} + +static QGpgMEChangeExpiryJob::result_type change_expiry(Context *ctx, const Key &key, const QDateTime &expiry) +{ + std::auto_ptr<EditInteractor> + ei(expiry.isValid() + ? new GpgSetExpiryTimeEditInteractor(expiry.date().toString(Qt::ISODate).toStdString()) + : new GpgSetExpiryTimeEditInteractor()); + + QGpgME::QByteArrayDataProvider dp; + Data data(&dp); + assert(!data.isNull()); + const Error err = ctx->edit(key, ei, data); + Error ae; + const QString log = _detail::audit_log_as_html(ctx, ae); + return std::make_tuple(err, log, ae); +} + +Error QGpgMEChangeExpiryJob::start(const Key &key, const QDateTime &expiry) +{ + run(std::bind(&change_expiry, std::placeholders::_1, key, expiry)); + return Error(); +} +#include "qgpgmechangeexpiryjob.moc" diff --git a/lang/qt/src/qgpgmechangeexpiryjob.h b/lang/qt/src/qgpgmechangeexpiryjob.h new file mode 100644 index 00000000..4abdf78f --- /dev/null +++ b/lang/qt/src/qgpgmechangeexpiryjob.h @@ -0,0 +1,66 @@ +/* + qgpgmechangeexpiryjob.h + + This file is part of qgpgme, the Qt API binding for gpgme + Copyright (c) 2008 Klarälvdalens Datakonsult AB + Copyright (c) 2016 Intevation GmbH + + QGpgME 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. + + QGpgME 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 this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + + In addition, as a special exception, the copyright holders give + permission to link the code of this program with any edition of + the Qt library by Trolltech AS, Norway (or with modified versions + of Qt that use the same license as Qt), and distribute linked + combinations including the two. You must obey the GNU General + Public License in all respects for all of the code used other than + Qt. If you modify this file, you may extend this exception to + your version of the file, but you are not obligated to do so. If + you do not wish to do so, delete this exception statement from + your version. +*/ + +#ifndef __QGPGME_QGPGMECHANGEEXPIRYJOB_H__ +#define __QGPGME_QGPGMECHANGEEXPIRYJOB_H__ + +#include "changeexpiryjob.h" + +#include "threadedjobmixin.h" + +namespace QGpgME +{ + +class QGpgMEChangeExpiryJob +#ifdef Q_MOC_RUN + : public ChangeExpiryJob +#else + : public _detail::ThreadedJobMixin<ChangeExpiryJob> +#endif +{ + Q_OBJECT +#ifdef Q_MOC_RUN +private Q_SLOTS: + void slotFinished(); +#endif +public: + explicit QGpgMEChangeExpiryJob(GpgME::Context *context); + ~QGpgMEChangeExpiryJob(); + + /* from ChangeExpiryJob */ + GpgME::Error start(const GpgME::Key &key, const QDateTime &expiry) Q_DECL_OVERRIDE; +}; + +} + +#endif // __QGPGME_QGPGMECHANGEEXPIRYJOB_H__ diff --git a/lang/qt/src/qgpgmechangeownertrustjob.cpp b/lang/qt/src/qgpgmechangeownertrustjob.cpp new file mode 100644 index 00000000..2f055f11 --- /dev/null +++ b/lang/qt/src/qgpgmechangeownertrustjob.cpp @@ -0,0 +1,77 @@ +/* + qgpgmechangeownertrustjob.cpp + + This file is part of qgpgme, the Qt API binding for gpgme + Copyright (c) 2008 Klarälvdalens Datakonsult AB + Copyright (c) 2016 Intevation GmbH + + QGpgME 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. + + QGpgME 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 this program; if not, write to the Free Software Foundation, Inc., + 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + + In addition, as a special exception, the copyright holders give + permission to link the code of this program with any edition of + the Qt library by Trolltech AS, Norway (or with modified versions + of Qt that use the same license as Qt), and distribute linked + combinations including the two. You must obey the GNU General + Public License in all respects for all of the code used other than + Qt. If you modify this file, you may extend this exception to + your version of the file, but you are not obligated to do so. If + you do not wish to do so, delete this exception statement from + your version. +*/ + +#include "qgpgmechangeownertrustjob.h" + +#include "dataprovider.h" + +#include "context.h" +#include "data.h" +#include "gpgsetownertrusteditinteractor.h" +#include "key.h" + +#include <cassert> +#include <memory> + +using namespace QGpgME; +using namespace GpgME; + +QGpgMEChangeOwnerTrustJob::QGpgMEChangeOwnerTrustJob(Context *context) + : mixin_type(context) +{ + lateInitialization(); +} + +QGpgMEChangeOwnerTrustJob::~QGpgMEChangeOwnerTrustJob() {} + +static QGpgMEChangeOwnerTrustJob::result_type change_ownertrust(Context *ctx, const Key &key, Key::OwnerTrust trust) +{ + std::auto_ptr<EditInteractor> + ei(new GpgSetOwnerTrustEditInteractor(trust)); + + QGpgME::QByteArrayDataProvider dp; + Data data(&dp); + assert(!data.isNull()); + + const Error err = ctx->edit(key, ei, data); + Error ae; + const QString log = _detail::audit_log_as_html(ctx, ae); + return std::make_tuple(err, log, ae); +} + +Error QGpgMEChangeOwnerTrustJob::start(const Key &key, Key::OwnerTrust trust) +{ + run(std::bind(&change_ownertrust, std::placeholders::_1, key, trust)); + return Error(); +} +#include "qgpgmechangeownertrustjob.moc" diff --git a/lang/qt/src/qgpgmechangeownertrustjob.h b/lang/qt/src/qgpgmechangeownertrustjob.h new file mode 100644 index 00000000..77406165 --- /dev/null +++ b/lang/qt/src/qgpgmechangeownertrustjob.h @@ -0,0 +1,65 @@ +/* + qgpgmechangeexpiryjob.h + + This file is part of qgpgme, the Qt API binding for gpgme + Copyright (c) 2008 Klarälvdalens Datakonsult AB + Copyright (c) 2016 Intevation GmbH + + QGpgME 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. + + QGpgME 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 this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + + In addition, as a special exception, the copyright holders give + permission to link the code of this program with any edition of + the Qt library by Trolltech AS, Norway (or with modified versions + of Qt that use the same license as Qt), and distribute linked + combinations including the two. You must obey the GNU General + Public License in all respects for all of the code used other than + Qt. If you modify this file, you may extend this exception to + your version of the file, but you are not obligated to do so. If + you do not wish to do so, delete this exception statement from + your version. +*/ + +#ifndef __QGPGME_QGPGMECHANGEOWNERTRUSTJOB_H__ +#define __QGPGME_QGPGMECHANGEOWNERTRUSTJOB_H__ + +#include "changeownertrustjob.h" + +#include "threadedjobmixin.h" + +namespace QGpgME +{ + +class QGpgMEChangeOwnerTrustJob +#ifdef Q_MOC_RUN + : public ChangeOwnerTrustJob +#else + : public _detail::ThreadedJobMixin<ChangeOwnerTrustJob> +#endif +{ + Q_OBJECT +#ifdef Q_MOC_RUN +private Q_SLOTS: + void slotFinished(); +#endif +public: + explicit QGpgMEChangeOwnerTrustJob(GpgME::Context *context); + ~QGpgMEChangeOwnerTrustJob(); + + /* from ChangeOwnerTrustJob */ + GpgME::Error start(const GpgME::Key &key, GpgME::Key::OwnerTrust trust) Q_DECL_OVERRIDE; +}; +} + +#endif // __QGPGME_QGPGMECHANGEOWNERTRUSTJOB_H__ diff --git a/lang/qt/src/qgpgmechangepasswdjob.cpp b/lang/qt/src/qgpgmechangepasswdjob.cpp new file mode 100644 index 00000000..675eee67 --- /dev/null +++ b/lang/qt/src/qgpgmechangepasswdjob.cpp @@ -0,0 +1,79 @@ +/* + qgpgmechangepasswdjob.cpp + + This file is part of qgpgme, the Qt API binding for gpgme + Copyright (c) 2010 Klarälvdalens Datakonsult AB + Copyright (c) 2016 Intevation GmbH + + QGpgME 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. + + QGpgME 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 this program; if not, write to the Free Software Foundation, Inc., + 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + + In addition, as a special exception, the copyright holders give + permission to link the code of this program with any edition of + the Qt library by Trolltech AS, Norway (or with modified versions + of Qt that use the same license as Qt), and distribute linked + combinations including the two. You must obey the GNU General + Public License in all respects for all of the code used other than + Qt. If you modify this file, you may extend this exception to + your version of the file, but you are not obligated to do so. If + you do not wish to do so, delete this exception statement from + your version. +*/ + +#include "qgpgmechangepasswdjob.h" + +#include "dataprovider.h" + +#include "context.h" +#include "data.h" +#include "key.h" + +#include <cassert> +#include <memory> + +using namespace QGpgME; +using namespace GpgME; + +QGpgMEChangePasswdJob::QGpgMEChangePasswdJob(Context *context) + : mixin_type(context) +{ + lateInitialization(); +} + +QGpgMEChangePasswdJob::~QGpgMEChangePasswdJob() {} + +static QGpgMEChangePasswdJob::result_type change_passwd(Context *ctx, const Key &key) +{ +#if 0 // in case we want to fall back to edit interactor for gpg... + std::auto_ptr<EditInteractor> ei(new GpgChangePasswdEditInteractor); + + QGpgME::QByteArrayDataProvider dp; + Data data(&dp); + assert(!data.isNull()); + const Error err = ctx->edit(key, ei, data); +#else + const Error err = ctx->passwd(key); +#endif + Error ae; + const QString log = _detail::audit_log_as_html(ctx, ae); + return std::make_tuple(err, log, ae); +} + +Error QGpgMEChangePasswdJob::start(const Key &key) +{ + run(std::bind(&change_passwd, std::placeholders::_1, key)); + return Error(); +} + +#include "qgpgmechangepasswdjob.moc" diff --git a/lang/qt/src/qgpgmechangepasswdjob.h b/lang/qt/src/qgpgmechangepasswdjob.h new file mode 100644 index 00000000..e37789e1 --- /dev/null +++ b/lang/qt/src/qgpgmechangepasswdjob.h @@ -0,0 +1,66 @@ +/* + qgpgmechangepasswdjob.h + + This file is part of qgpgme, the Qt API binding for gpgme + Copyright (c) 2010 Klarälvdalens Datakonsult AB + Copyright (c) 2016 Intevation GmbH + + QGpgME 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. + + QGpgME 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 this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + + In addition, as a special exception, the copyright holders give + permission to link the code of this program with any edition of + the Qt library by Trolltech AS, Norway (or with modified versions + of Qt that use the same license as Qt), and distribute linked + combinations including the two. You must obey the GNU General + Public License in all respects for all of the code used other than + Qt. If you modify this file, you may extend this exception to + your version of the file, but you are not obligated to do so. If + you do not wish to do so, delete this exception statement from + your version. +*/ + +#ifndef __QGPGME_QGPGMECHANGEPASSWDJOB_H__ +#define __QGPGME_QGPGMECHANGEPASSWDJOB_H__ + +#include "changepasswdjob.h" + +#include "threadedjobmixin.h" + +namespace QGpgME +{ + +class QGpgMEChangePasswdJob +#ifdef Q_MOC_RUN + : public ChangePasswdJob +#else + : public _detail::ThreadedJobMixin<ChangePasswdJob> +#endif +{ + Q_OBJECT +#ifdef Q_MOC_RUN +private Q_SLOTS: + void slotFinished(); +#endif +public: + explicit QGpgMEChangePasswdJob(GpgME::Context *context); + ~QGpgMEChangePasswdJob(); + + /* from ChangePasswdJob */ + GpgME::Error start(const GpgME::Key &key) Q_DECL_OVERRIDE; +}; + +} + +#endif // __QGPGME_QGPGMECHANGEPASSWDJOB_H__ diff --git a/lang/qt/src/qgpgmedecryptjob.cpp b/lang/qt/src/qgpgmedecryptjob.cpp new file mode 100644 index 00000000..7116449b --- /dev/null +++ b/lang/qt/src/qgpgmedecryptjob.cpp @@ -0,0 +1,128 @@ +/* + qgpgmedecryptjob.cpp + + This file is part of qgpgme, the Qt API binding for gpgme + Copyright (c) 2004,2008 Klarälvdalens Datakonsult AB + Copyright (c) 2016 Intevation GmbH + + QGpgME 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. + + QGpgME 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 this program; if not, write to the Free Software Foundation, Inc., + 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + + In addition, as a special exception, the copyright holders give + permission to link the code of this program with any edition of + the Qt library by Trolltech AS, Norway (or with modified versions + of Qt that use the same license as Qt), and distribute linked + combinations including the two. You must obey the GNU General + Public License in all respects for all of the code used other than + Qt. If you modify this file, you may extend this exception to + your version of the file, but you are not obligated to do so. If + you do not wish to do so, delete this exception statement from + your version. +*/ + +#include "qgpgmedecryptjob.h" + +#include "dataprovider.h" + +#include "context.h" +#include "decryptionresult.h" +#include "data.h" + +#include <QBuffer> + +#include <cassert> + +using namespace QGpgME; +using namespace GpgME; + +QGpgMEDecryptJob::QGpgMEDecryptJob(Context *context) + : mixin_type(context) +{ + lateInitialization(); +} + +QGpgMEDecryptJob::~QGpgMEDecryptJob() {} + +static QGpgMEDecryptJob::result_type decrypt(Context *ctx, QThread *thread, + const std::weak_ptr<QIODevice> &cipherText_, + const std::weak_ptr<QIODevice> &plainText_) +{ + + const std::shared_ptr<QIODevice> cipherText = cipherText_.lock(); + const std::shared_ptr<QIODevice> plainText = plainText_.lock(); + + const _detail::ToThreadMover ctMover(cipherText, thread); + const _detail::ToThreadMover ptMover(plainText, thread); + + QGpgME::QIODeviceDataProvider in(cipherText); + const Data indata(&in); + + if (!plainText) { + QGpgME::QByteArrayDataProvider out; + Data outdata(&out); + + const DecryptionResult res = ctx->decrypt(indata, outdata); + Error ae; + const QString log = _detail::audit_log_as_html(ctx, ae); + return std::make_tuple(res, out.data(), log, ae); + } else { + QGpgME::QIODeviceDataProvider out(plainText); + Data outdata(&out); + + const DecryptionResult res = ctx->decrypt(indata, outdata); + Error ae; + const QString log = _detail::audit_log_as_html(ctx, ae); + return std::make_tuple(res, QByteArray(), log, ae); + } + +} + +static QGpgMEDecryptJob::result_type decrypt_qba(Context *ctx, const QByteArray &cipherText) +{ + const std::shared_ptr<QBuffer> buffer(new QBuffer); + buffer->setData(cipherText); + if (!buffer->open(QIODevice::ReadOnly)) { + assert(!"This should never happen: QBuffer::open() failed"); + } + return decrypt(ctx, 0, buffer, std::shared_ptr<QIODevice>()); +} + +Error QGpgMEDecryptJob::start(const QByteArray &cipherText) +{ + run(std::bind(&decrypt_qba, std::placeholders::_1, cipherText)); + return Error(); +} + +void QGpgMEDecryptJob::start(const std::shared_ptr<QIODevice> &cipherText, const std::shared_ptr<QIODevice> &plainText) +{ + run(std::bind(&decrypt, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3, std::placeholders::_4), cipherText, plainText); +} + +GpgME::DecryptionResult QGpgME::QGpgMEDecryptJob::exec(const QByteArray &cipherText, + QByteArray &plainText) +{ + const result_type r = decrypt_qba(context(), cipherText); + plainText = std::get<1>(r); + resultHook(r); + return mResult; +} + +//PENDING(marc) implement showErrorDialog() + +void QGpgMEDecryptJob::resultHook(const result_type &tuple) +{ + mResult = std::get<0>(tuple); +} + +#include "qgpgmedecryptjob.moc" diff --git a/lang/qt/src/qgpgmedecryptjob.h b/lang/qt/src/qgpgmedecryptjob.h new file mode 100644 index 00000000..5335e849 --- /dev/null +++ b/lang/qt/src/qgpgmedecryptjob.h @@ -0,0 +1,84 @@ +/* + qgpgmedecryptjob.h + + This file is part of qgpgme, the Qt API binding for gpgme + Copyright (c) 2004,2008 Klarälvdalens Datakonsult AB + Copyright (c) 2016 Intevation GmbH + + QGpgME 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. + + QGpgME 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 this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + + In addition, as a special exception, the copyright holders give + permission to link the code of this program with any edition of + the Qt library by Trolltech AS, Norway (or with modified versions + of Qt that use the same license as Qt), and distribute linked + combinations including the two. You must obey the GNU General + Public License in all respects for all of the code used other than + Qt. If you modify this file, you may extend this exception to + your version of the file, but you are not obligated to do so. If + you do not wish to do so, delete this exception statement from + your version. +*/ + +#ifndef __QGPGME_QGPGMEDECRYPTJOB_H__ +#define __QGPGME_QGPGMEDECRYPTJOB_H__ + +#include "decryptjob.h" + +#include "threadedjobmixin.h" + +#ifdef BUILDING_QGPGME +# include "decryptionresult.h" +#else +#include <gpgme++/decryptionresult.h> +#endif + +namespace QGpgME +{ + +class QGpgMEDecryptJob +#ifdef Q_MOC_RUN + : public DecryptJob +#else + : public _detail::ThreadedJobMixin<DecryptJob, std::tuple<GpgME::DecryptionResult, QByteArray, QString, GpgME::Error> > +#endif +{ + Q_OBJECT +#ifdef Q_MOC_RUN +private Q_SLOTS: + void slotFinished(); +#endif +public: + explicit QGpgMEDecryptJob(GpgME::Context *context); + ~QGpgMEDecryptJob(); + + /* from DecryptJob */ + GpgME::Error start(const QByteArray &cipherText) Q_DECL_OVERRIDE; + + /* from DecryptJob */ + void start(const std::shared_ptr<QIODevice> &cipherText, const std::shared_ptr<QIODevice> &plainText) Q_DECL_OVERRIDE; + + /* from DecryptJob */ + GpgME::DecryptionResult exec(const QByteArray &cipherText, + QByteArray &plainText) Q_DECL_OVERRIDE; + + /* from ThreadedJobMixin */ + void resultHook(const result_type &r) Q_DECL_OVERRIDE; + +private: + GpgME::DecryptionResult mResult; +}; + +} +#endif // __QGPGME_QGPGMEDECRYPTJOB_H__ diff --git a/lang/qt/src/qgpgmedecryptverifyjob.cpp b/lang/qt/src/qgpgmedecryptverifyjob.cpp new file mode 100644 index 00000000..d46a9b59 --- /dev/null +++ b/lang/qt/src/qgpgmedecryptverifyjob.cpp @@ -0,0 +1,135 @@ +/* + qgpgmedecryptverifyjob.cpp + + This file is part of qgpgme, the Qt API binding for gpgme + Copyright (c) 2004,2008 Klarälvdalens Datakonsult AB + Copyright (c) 2016 Intevation GmbH + + QGpgME 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. + + QGpgME 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 this program; if not, write to the Free Software Foundation, Inc., + 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + + In addition, as a special exception, the copyright holders give + permission to link the code of this program with any edition of + the Qt library by Trolltech AS, Norway (or with modified versions + of Qt that use the same license as Qt), and distribute linked + combinations including the two. You must obey the GNU General + Public License in all respects for all of the code used other than + Qt. If you modify this file, you may extend this exception to + your version of the file, but you are not obligated to do so. If + you do not wish to do so, delete this exception statement from + your version. +*/ + +#include "qgpgmedecryptverifyjob.h" + +#include "dataprovider.h" + +#include "context.h" +#include "decryptionresult.h" +#include "verificationresult.h" +#include "data.h" + +#include <QDebug> +#include "gpgme_backend_debug.h" + +#include <QBuffer> + +#include <cassert> + +using namespace QGpgME; +using namespace GpgME; + +QGpgMEDecryptVerifyJob::QGpgMEDecryptVerifyJob(Context *context) + : mixin_type(context) +{ + lateInitialization(); +} + +QGpgMEDecryptVerifyJob::~QGpgMEDecryptVerifyJob() {} + +static QGpgMEDecryptVerifyJob::result_type decrypt_verify(Context *ctx, QThread *thread, + const std::weak_ptr<QIODevice> &cipherText_, + const std::weak_ptr<QIODevice> &plainText_) +{ + + qCDebug(GPGPME_BACKEND_LOG); + + const std::shared_ptr<QIODevice> cipherText = cipherText_.lock(); + const std::shared_ptr<QIODevice> plainText = plainText_.lock(); + + const _detail::ToThreadMover ctMover(cipherText, thread); + const _detail::ToThreadMover ptMover(plainText, thread); + + QGpgME::QIODeviceDataProvider in(cipherText); + const Data indata(&in); + + if (!plainText) { + QGpgME::QByteArrayDataProvider out; + Data outdata(&out); + + const std::pair<DecryptionResult, VerificationResult> res = ctx->decryptAndVerify(indata, outdata); + Error ae; + const QString log = _detail::audit_log_as_html(ctx, ae); + qCDebug(GPGPME_BACKEND_LOG) << "End no plainText. Error: " << ae; + return std::make_tuple(res.first, res.second, out.data(), log, ae); + } else { + QGpgME::QIODeviceDataProvider out(plainText); + Data outdata(&out); + + const std::pair<DecryptionResult, VerificationResult> res = ctx->decryptAndVerify(indata, outdata); + Error ae; + const QString log = _detail::audit_log_as_html(ctx, ae); + qCDebug(GPGPME_BACKEND_LOG) << "End plainText. Error: " << ae; + return std::make_tuple(res.first, res.second, QByteArray(), log, ae); + } + +} + +static QGpgMEDecryptVerifyJob::result_type decrypt_verify_qba(Context *ctx, const QByteArray &cipherText) +{ + const std::shared_ptr<QBuffer> buffer(new QBuffer); + buffer->setData(cipherText); + if (!buffer->open(QIODevice::ReadOnly)) { + assert(!"This should never happen: QBuffer::open() failed"); + } + return decrypt_verify(ctx, 0, buffer, std::shared_ptr<QIODevice>()); +} + +Error QGpgMEDecryptVerifyJob::start(const QByteArray &cipherText) +{ + run(std::bind(&decrypt_verify_qba, std::placeholders::_1, cipherText)); + return Error(); +} + +void QGpgMEDecryptVerifyJob::start(const std::shared_ptr<QIODevice> &cipherText, const std::shared_ptr<QIODevice> &plainText) +{ + run(std::bind(&decrypt_verify, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3, std::placeholders::_4), cipherText, plainText); +} + +std::pair<GpgME::DecryptionResult, GpgME::VerificationResult> +QGpgME::QGpgMEDecryptVerifyJob::exec(const QByteArray &cipherText, QByteArray &plainText) +{ + const result_type r = decrypt_verify_qba(context(), cipherText); + plainText = std::get<2>(r); + resultHook(r); + return mResult; +} + +//PENDING(marc) implement showErrorDialog() + +void QGpgMEDecryptVerifyJob::resultHook(const result_type &tuple) +{ + mResult = std::make_pair(std::get<0>(tuple), std::get<1>(tuple)); +} +#include "qgpgmedecryptverifyjob.moc" diff --git a/lang/qt/src/qgpgmedecryptverifyjob.h b/lang/qt/src/qgpgmedecryptverifyjob.h new file mode 100644 index 00000000..de2bce79 --- /dev/null +++ b/lang/qt/src/qgpgmedecryptverifyjob.h @@ -0,0 +1,89 @@ +/* + qgpgmedecryptverifyjob.h + + This file is part of qgpgme, the Qt API binding for gpgme + Copyright (c) 2004,2008 Klarälvdalens Datakonsult AB + Copyright (c) 2016 Intevation GmbH + + QGpgME 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. + + QGpgME 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 this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + + In addition, as a special exception, the copyright holders give + permission to link the code of this program with any edition of + the Qt library by Trolltech AS, Norway (or with modified versions + of Qt that use the same license as Qt), and distribute linked + combinations including the two. You must obey the GNU General + Public License in all respects for all of the code used other than + Qt. If you modify this file, you may extend this exception to + your version of the file, but you are not obligated to do so. If + you do not wish to do so, delete this exception statement from + your version. +*/ + +#ifndef __QGPGME_QGPGMEDECRYPTVERIFYJOB_H__ +#define __QGPGME_QGPGMEDECRYPTVERIFYJOB_H__ + +#include "decryptverifyjob.h" + +#include "threadedjobmixin.h" + +#ifdef BUILDING_QGPGME +# include "decryptionresult.h" +#else +#include <gpgme++/decryptionresult.h> +#endif +#ifdef BUILDING_QGPGME +# include "verificationresult.h" +#else +#include <gpgme++/verificationresult.h> +#endif + +namespace QGpgME +{ + +class QGpgMEDecryptVerifyJob +#ifdef Q_MOC_RUN + : public DecryptVerifyJob +#else + : public _detail::ThreadedJobMixin<DecryptVerifyJob, std::tuple<GpgME::DecryptionResult, GpgME::VerificationResult, QByteArray, QString, GpgME::Error> > +#endif +{ + Q_OBJECT +#ifdef Q_MOC_RUN +private Q_SLOTS: + void slotFinished(); +#endif +public: + explicit QGpgMEDecryptVerifyJob(GpgME::Context *context); + ~QGpgMEDecryptVerifyJob(); + + /* from DecryptVerifyJob */ + GpgME::Error start(const QByteArray &cipherText) Q_DECL_OVERRIDE; + + /* from DecryptVerifyJob */ + void start(const std::shared_ptr<QIODevice> &cipherText, const std::shared_ptr<QIODevice> &plainText) Q_DECL_OVERRIDE; + + /* from DecryptVerifyJob */ + std::pair<GpgME::DecryptionResult, GpgME::VerificationResult> + exec(const QByteArray &cipherText, QByteArray &plainText) Q_DECL_OVERRIDE; + + /* from ThreadedJobMixin */ + void resultHook(const result_type &r) Q_DECL_OVERRIDE; + +private: + std::pair<GpgME::DecryptionResult, GpgME::VerificationResult> mResult; +}; + +} +#endif // __QGPGME_QGPGMEDECRYPTVERIFYJOB_H__ diff --git a/lang/qt/src/qgpgmedeletejob.cpp b/lang/qt/src/qgpgmedeletejob.cpp new file mode 100644 index 00000000..323aec4e --- /dev/null +++ b/lang/qt/src/qgpgmedeletejob.cpp @@ -0,0 +1,65 @@ +/* + qgpgmedeletejob.cpp + + This file is part of qgpgme, the Qt API binding for gpgme + Copyright (c) 2004,2008 Klarälvdalens Datakonsult AB + Copyright (c) 2016 Intevation GmbH + + QGpgME 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. + + QGpgME 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 this program; if not, write to the Free Software Foundation, Inc., + 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + + In addition, as a special exception, the copyright holders give + permission to link the code of this program with any edition of + the Qt library by Trolltech AS, Norway (or with modified versions + of Qt that use the same license as Qt), and distribute linked + combinations including the two. You must obey the GNU General + Public License in all respects for all of the code used other than + Qt. If you modify this file, you may extend this exception to + your version of the file, but you are not obligated to do so. If + you do not wish to do so, delete this exception statement from + your version. +*/ + +#include "qgpgmedeletejob.h" + +#include "context.h" +#include "key.h" + +#include <cassert> + +using namespace QGpgME; +using namespace GpgME; + +QGpgMEDeleteJob::QGpgMEDeleteJob(Context *context) + : mixin_type(context) +{ + lateInitialization(); +} + +QGpgMEDeleteJob::~QGpgMEDeleteJob() {} + +static QGpgMEDeleteJob::result_type delete_key(Context *ctx, const Key &key, bool allowSecretKeyDeletion) +{ + const Error err = ctx->deleteKey(key, allowSecretKeyDeletion); + Error ae; + const QString log = _detail::audit_log_as_html(ctx, ae); + return std::make_tuple(err, log, ae); +} + +Error QGpgMEDeleteJob::start(const Key &key, bool allowSecretKeyDeletion) +{ + run(std::bind(&delete_key, std::placeholders::_1, key, allowSecretKeyDeletion)); + return Error(); +} +#include "qgpgmedeletejob.moc" diff --git a/lang/qt/src/qgpgmedeletejob.h b/lang/qt/src/qgpgmedeletejob.h new file mode 100644 index 00000000..992442fa --- /dev/null +++ b/lang/qt/src/qgpgmedeletejob.h @@ -0,0 +1,71 @@ +/* + qgpgmedeletejob.h + + This file is part of qgpgme, the Qt API binding for gpgme + Copyright (c) 2004,2008 Klarälvdalens Datakonsult AB + Copyright (c) 2016 Intevation GmbH + + QGpgME 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. + + QGpgME 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 this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + + In addition, as a special exception, the copyright holders give + permission to link the code of this program with any edition of + the Qt library by Trolltech AS, Norway (or with modified versions + of Qt that use the same license as Qt), and distribute linked + combinations including the two. You must obey the GNU General + Public License in all respects for all of the code used other than + Qt. If you modify this file, you may extend this exception to + your version of the file, but you are not obligated to do so. If + you do not wish to do so, delete this exception statement from + your version. +*/ + +#ifndef __QGPGME_QGPGMEDELETEJOB_H__ +#define __QGPGME_QGPGMEDELETEJOB_H__ + +#include "deletejob.h" + +#include "threadedjobmixin.h" + +namespace GpgME +{ +class Key; +} + +namespace QGpgME +{ + +class QGpgMEDeleteJob +#ifdef Q_MOC_RUN + : public DeleteJob +#else + : public _detail::ThreadedJobMixin<DeleteJob> +#endif +{ + Q_OBJECT +#ifdef Q_MOC_RUN +public Q_SLOTS: + void slotFinished(); +#endif +public: + explicit QGpgMEDeleteJob(GpgME::Context *context); + ~QGpgMEDeleteJob(); + + /* from DeleteJob */ + GpgME::Error start(const GpgME::Key &key, bool allowSecretKeyDeletion) Q_DECL_OVERRIDE; +}; + +} + +#endif // __QGPGME_QGPGMEDELETEJOB_H__ diff --git a/lang/qt/src/qgpgmedownloadjob.cpp b/lang/qt/src/qgpgmedownloadjob.cpp new file mode 100644 index 00000000..48cc9071 --- /dev/null +++ b/lang/qt/src/qgpgmedownloadjob.cpp @@ -0,0 +1,100 @@ +/* + qgpgmedownloadjob.cpp + + This file is part of qgpgme, the Qt API binding for gpgme + Copyright (c) 2004,2008 Klarälvdalens Datakonsult AB + Copyright (c) 2016 Intevation GmbH + + QGpgME 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. + + QGpgME 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 this program; if not, write to the Free Software Foundation, Inc., + 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + + In addition, as a special exception, the copyright holders give + permission to link the code of this program with any edition of + the Qt library by Trolltech AS, Norway (or with modified versions + of Qt that use the same license as Qt), and distribute linked + combinations including the two. You must obey the GNU General + Public License in all respects for all of the code used other than + Qt. If you modify this file, you may extend this exception to + your version of the file, but you are not obligated to do so. If + you do not wish to do so, delete this exception statement from + your version. +*/ + +#include "qgpgmedownloadjob.h" + +#include "dataprovider.h" + +#include "context.h" +#include "data.h" + +#include <QStringList> + +#include <cassert> + +using namespace QGpgME; +using namespace GpgME; + +QGpgMEDownloadJob::QGpgMEDownloadJob(Context *context) + : mixin_type(context) +{ + lateInitialization(); +} + +QGpgMEDownloadJob::~QGpgMEDownloadJob() {} + +static QGpgMEDownloadJob::result_type download_qsl(Context *ctx, const QStringList &pats) +{ + QGpgME::QByteArrayDataProvider dp; + Data data(&dp); + + const _detail::PatternConverter pc(pats); + + const Error err = ctx->exportPublicKeys(pc.patterns(), data); + Error ae; + const QString log = _detail::audit_log_as_html(ctx, ae); + return std::make_tuple(err, dp.data(), log, ae); +} + +static QGpgMEDownloadJob::result_type download(Context *ctx, QThread *thread, const QByteArray &fpr, const std::weak_ptr<QIODevice> &keyData_) +{ + const std::shared_ptr<QIODevice> keyData = keyData_.lock(); + if (!keyData) { + return download_qsl(ctx, QStringList(QString::fromUtf8(fpr))); + } + + const _detail::ToThreadMover kdMover(keyData, thread); + + QGpgME::QIODeviceDataProvider dp(keyData); + Data data(&dp); + + const _detail::PatternConverter pc(fpr); + + const Error err = ctx->exportPublicKeys(pc.patterns(), data); + Error ae; + const QString log = _detail::audit_log_as_html(ctx, ae); + return std::make_tuple(err, QByteArray(), log, ae); +} + +Error QGpgMEDownloadJob::start(const QStringList &pats) +{ + run(std::bind(&download_qsl, std::placeholders::_1, pats)); + return Error(); +} + +Error QGpgMEDownloadJob::start(const QByteArray &fpr, const std::shared_ptr<QIODevice> &keyData) +{ + run(std::bind(&download, std::placeholders::_1, std::placeholders::_2, fpr, std::placeholders::_3), keyData); + return Error(); +} +#include "qgpgmedownloadjob.moc" diff --git a/lang/qt/src/qgpgmedownloadjob.h b/lang/qt/src/qgpgmedownloadjob.h new file mode 100644 index 00000000..40911909 --- /dev/null +++ b/lang/qt/src/qgpgmedownloadjob.h @@ -0,0 +1,69 @@ +/* + qgpgmedownloadjob.h + + This file is part of qgpgme, the Qt API binding for gpgme + Copyright (c) 2004,2008 Klarälvdalens Datakonsult AB + Copyright (c) 2016 Intevation GmbH + + QGpgME 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. + + QGpgME 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 this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + + In addition, as a special exception, the copyright holders give + permission to link the code of this program with any edition of + the Qt library by Trolltech AS, Norway (or with modified versions + of Qt that use the same license as Qt), and distribute linked + combinations including the two. You must obey the GNU General + Public License in all respects for all of the code used other than + Qt. If you modify this file, you may extend this exception to + your version of the file, but you are not obligated to do so. If + you do not wish to do so, delete this exception statement from + your version. +*/ + +#ifndef __QGPGME_QGPGMEDOWNLOADJOB_H__ +#define __QGPGME_QGPGMEDOWNLOADJOB_H__ + +#include "downloadjob.h" + +#include "threadedjobmixin.h" + +namespace QGpgME +{ + +class QGpgMEDownloadJob +#ifdef Q_MOC_RUN + : public DownloadJob +#else + : public _detail::ThreadedJobMixin<DownloadJob, std::tuple<GpgME::Error, QByteArray, QString, GpgME::Error> > +#endif +{ + Q_OBJECT +#ifdef Q_MOC_RUN +public Q_SLOTS: + void slotFinished(); +#endif +public: + explicit QGpgMEDownloadJob(GpgME::Context *context); + ~QGpgMEDownloadJob(); + + /* from DownloadJob */ + GpgME::Error start(const QStringList &fingerprints) Q_DECL_OVERRIDE; + + /* from DownloadJob */ + GpgME::Error start(const QByteArray &fingerprint, const std::shared_ptr<QIODevice> &keyData) Q_DECL_OVERRIDE; +}; + +} + +#endif // __QGPGME_QGPGMEDOWNLOADJOB_H__ diff --git a/lang/qt/src/qgpgmeencryptjob.cpp b/lang/qt/src/qgpgmeencryptjob.cpp new file mode 100644 index 00000000..8d0bfd43 --- /dev/null +++ b/lang/qt/src/qgpgmeencryptjob.cpp @@ -0,0 +1,160 @@ +/* + qgpgmeencryptjob.cpp + + This file is part of qgpgme, the Qt API binding for gpgme + Copyright (c) 2004,2007,2008 Klarälvdalens Datakonsult AB + Copyright (c) 2016 Intevation GmbH + + QGpgME 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. + + QGpgME 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 this program; if not, write to the Free Software Foundation, Inc., + 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + + In addition, as a special exception, the copyright holders give + permission to link the code of this program with any edition of + the Qt library by Trolltech AS, Norway (or with modified versions + of Qt that use the same license as Qt), and distribute linked + combinations including the two. You must obey the GNU General + Public License in all respects for all of the code used other than + Qt. If you modify this file, you may extend this exception to + your version of the file, but you are not obligated to do so. If + you do not wish to do so, delete this exception statement from + your version. +*/ + +#include "qgpgmeencryptjob.h" + +#include "dataprovider.h" + +#include "context.h" +#include "encryptionresult.h" +#include "data.h" + +#include <QBuffer> + + +#include <cassert> + +using namespace QGpgME; +using namespace GpgME; + +QGpgMEEncryptJob::QGpgMEEncryptJob(Context *context) + : mixin_type(context), + mOutputIsBase64Encoded(false) +{ + lateInitialization(); +} + +QGpgMEEncryptJob::~QGpgMEEncryptJob() {} + +void QGpgMEEncryptJob::setOutputIsBase64Encoded(bool on) +{ + mOutputIsBase64Encoded = on; +} + +static QGpgMEEncryptJob::result_type encrypt(Context *ctx, QThread *thread, + const std::vector<Key> &recipients, + const std::weak_ptr<QIODevice> &plainText_, + const std::weak_ptr<QIODevice> &cipherText_, + bool alwaysTrust, + bool outputIsBsse64Encoded) +{ + + const std::shared_ptr<QIODevice> plainText = plainText_.lock(); + const std::shared_ptr<QIODevice> cipherText = cipherText_.lock(); + + const _detail::ToThreadMover ctMover(cipherText, thread); + const _detail::ToThreadMover ptMover(plainText, thread); + + QGpgME::QIODeviceDataProvider in(plainText); + const Data indata(&in); + + const Context::EncryptionFlags eflags = + alwaysTrust ? Context::AlwaysTrust : Context::None; + + if (!cipherText) { + QGpgME::QByteArrayDataProvider out; + Data outdata(&out); + + if (outputIsBsse64Encoded) { + outdata.setEncoding(Data::Base64Encoding); + } + + const EncryptionResult res = ctx->encrypt(recipients, indata, outdata, eflags); + Error ae; + const QString log = _detail::audit_log_as_html(ctx, ae); + return std::make_tuple(res, out.data(), log, ae); + } else { + QGpgME::QIODeviceDataProvider out(cipherText); + Data outdata(&out); + + if (outputIsBsse64Encoded) { + outdata.setEncoding(Data::Base64Encoding); + } + + const EncryptionResult res = ctx->encrypt(recipients, indata, outdata, eflags); + Error ae; + const QString log = _detail::audit_log_as_html(ctx, ae); + return std::make_tuple(res, QByteArray(), log, ae); + } + +} + +static QGpgMEEncryptJob::result_type encrypt_qba(Context *ctx, const std::vector<Key> &recipients, const QByteArray &plainText, bool alwaysTrust, bool outputIsBsse64Encoded) +{ + const std::shared_ptr<QBuffer> buffer(new QBuffer); + buffer->setData(plainText); + if (!buffer->open(QIODevice::ReadOnly)) { + assert(!"This should never happen: QBuffer::open() failed"); + } + return encrypt(ctx, 0, recipients, buffer, std::shared_ptr<QIODevice>(), alwaysTrust, outputIsBsse64Encoded); +} + +Error QGpgMEEncryptJob::start(const std::vector<Key> &recipients, const QByteArray &plainText, bool alwaysTrust) +{ + run(std::bind(&encrypt_qba, std::placeholders::_1, recipients, plainText, alwaysTrust, mOutputIsBase64Encoded)); + return Error(); +} + +void QGpgMEEncryptJob::start(const std::vector<Key> &recipients, const std::shared_ptr<QIODevice> &plainText, const std::shared_ptr<QIODevice> &cipherText, bool alwaysTrust) +{ + run(std::bind(&encrypt, + std::placeholders::_1, std::placeholders::_2, + recipients, + std::placeholders::_3, std::placeholders::_4, + alwaysTrust, + mOutputIsBase64Encoded), + plainText, cipherText); +} + +EncryptionResult QGpgMEEncryptJob::exec(const std::vector<Key> &recipients, const QByteArray &plainText, bool alwaysTrust, QByteArray &cipherText) +{ + const result_type r = encrypt_qba(context(), recipients, plainText, alwaysTrust, mOutputIsBase64Encoded); + cipherText = std::get<1>(r); + resultHook(r); + return mResult; +} + +void QGpgMEEncryptJob::resultHook(const result_type &tuple) +{ + mResult = std::get<0>(tuple); +} + +#if 0 +void QGpgMEEncryptJob::showErrorDialog(QWidget *parent, const QString &caption) const +{ + if (mResult.error() && !mResult.error().isCanceled()) { + MessageBox::error(parent, mResult, this, caption); + } +} +#endif +#include "qgpgmeencryptjob.moc" diff --git a/lang/qt/src/qgpgmeencryptjob.h b/lang/qt/src/qgpgmeencryptjob.h new file mode 100644 index 00000000..d35a41ba --- /dev/null +++ b/lang/qt/src/qgpgmeencryptjob.h @@ -0,0 +1,99 @@ +/* + qgpgmeencryptjob.h + + This file is part of qgpgme, the Qt API binding for gpgme + Copyright (c) 2004,2007,2008 Klarälvdalens Datakonsult AB + Copyright (c) 2016 Intevation GmbH + + QGpgME 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. + + QGpgME 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 this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + + In addition, as a special exception, the copyright holders give + permission to link the code of this program with any edition of + the Qt library by Trolltech AS, Norway (or with modified versions + of Qt that use the same license as Qt), and distribute linked + combinations including the two. You must obey the GNU General + Public License in all respects for all of the code used other than + Qt. If you modify this file, you may extend this exception to + your version of the file, but you are not obligated to do so. If + you do not wish to do so, delete this exception statement from + your version. +*/ + +#ifndef __QGPGME_QGPGMEENCRYPTJOB_H__ +#define __QGPGME_QGPGMEENCRYPTJOB_H__ + +#include "encryptjob.h" + +#include "threadedjobmixin.h" + +#ifdef BUILDING_QGPGME +# include "encryptionresult.h" +#else +#include <gpgme++/encryptionresult.h> +#endif +#ifdef BUILDING_QGPGME +# include "key.h" +#else +#include <gpgme++/key.h> +#endif + +namespace QGpgME +{ + +class QGpgMEEncryptJob +#ifdef Q_MOC_RUN + : public EncryptJob +#else + : public _detail::ThreadedJobMixin<EncryptJob, std::tuple<GpgME::EncryptionResult, QByteArray, QString, GpgME::Error> > +#endif +{ + Q_OBJECT +#ifdef Q_MOC_RUN +public Q_SLOTS: + void slotFinished(); +#endif +public: + explicit QGpgMEEncryptJob(GpgME::Context *context); + ~QGpgMEEncryptJob(); + + /* from EncryptJob */ + GpgME::Error start(const std::vector<GpgME::Key> &recipients, + const QByteArray &plainText, bool alwaysTrust) Q_DECL_OVERRIDE; + + /* from EncryptJob */ + void start(const std::vector<GpgME::Key> &recipients, + const std::shared_ptr<QIODevice> &plainText, + const std::shared_ptr<QIODevice> &cipherText, + bool alwaysTrust) Q_DECL_OVERRIDE; + + /* from EncryptJob */ + GpgME::EncryptionResult exec(const std::vector<GpgME::Key> &recipients, + const QByteArray &plainText, bool alwaysTrust, + QByteArray &cipherText) Q_DECL_OVERRIDE; + + /* from EncryptJob */ + void setOutputIsBase64Encoded(bool on) Q_DECL_OVERRIDE; + + /* from ThreadedJobMixin */ + void resultHook(const result_type &r) Q_DECL_OVERRIDE; + +private: + bool mOutputIsBase64Encoded; + GpgME::EncryptionResult mResult; +}; + +} + +#endif // __QGPGME_QGPGMEENCRYPTJOB_H__ diff --git a/lang/qt/src/qgpgmeexportjob.cpp b/lang/qt/src/qgpgmeexportjob.cpp new file mode 100644 index 00000000..dfc5fc97 --- /dev/null +++ b/lang/qt/src/qgpgmeexportjob.cpp @@ -0,0 +1,76 @@ +/* + qgpgmeexportjob.cpp + + This file is part of qgpgme, the Qt API binding for gpgme + Copyright (c) 2004,2008 Klarälvdalens Datakonsult AB + Copyright (c) 2016 Intevation GmbH + + QGpgME 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. + + QGpgME 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 this program; if not, write to the Free Software Foundation, Inc., + 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + + In addition, as a special exception, the copyright holders give + permission to link the code of this program with any edition of + the Qt library by Trolltech AS, Norway (or with modified versions + of Qt that use the same license as Qt), and distribute linked + combinations including the two. You must obey the GNU General + Public License in all respects for all of the code used other than + Qt. If you modify this file, you may extend this exception to + your version of the file, but you are not obligated to do so. If + you do not wish to do so, delete this exception statement from + your version. +*/ + +#include "qgpgmeexportjob.h" + +#include "dataprovider.h" + +#include "context.h" +#include "data.h" +#include "key.h" + +#include <QStringList> + +#include <cassert> + +using namespace QGpgME; +using namespace GpgME; + +QGpgMEExportJob::QGpgMEExportJob(Context *context) + : mixin_type(context) +{ + lateInitialization(); +} + +QGpgMEExportJob::~QGpgMEExportJob() {} + +static QGpgMEExportJob::result_type export_qba(Context *ctx, const QStringList &patterns) +{ + + const _detail::PatternConverter pc(patterns); + + QGpgME::QByteArrayDataProvider dp; + Data data(&dp); + + const Error err = ctx->exportPublicKeys(pc.patterns(), data); + Error ae; + const QString log = _detail::audit_log_as_html(ctx, ae); + return std::make_tuple(err, dp.data(), log, ae); +} + +Error QGpgMEExportJob::start(const QStringList &patterns) +{ + run(std::bind(&export_qba, std::placeholders::_1, patterns)); + return Error(); +} +#include "qgpgmeexportjob.moc" diff --git a/lang/qt/src/qgpgmeexportjob.h b/lang/qt/src/qgpgmeexportjob.h new file mode 100644 index 00000000..7561054d --- /dev/null +++ b/lang/qt/src/qgpgmeexportjob.h @@ -0,0 +1,66 @@ +/* + qgpgmeexportjob.h + + This file is part of qgpgme, the Qt API binding for gpgme + Copyright (c) 2004,2008 Klarälvdalens Datakonsult AB + Copyright (c) 2016 Intevation GmbH + + QGpgME 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. + + QGpgME 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 this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + + In addition, as a special exception, the copyright holders give + permission to link the code of this program with any edition of + the Qt library by Trolltech AS, Norway (or with modified versions + of Qt that use the same license as Qt), and distribute linked + combinations including the two. You must obey the GNU General + Public License in all respects for all of the code used other than + Qt. If you modify this file, you may extend this exception to + your version of the file, but you are not obligated to do so. If + you do not wish to do so, delete this exception statement from + your version. +*/ + +#ifndef __QGPGME_QGPGMEEXPORTJOB_H__ +#define __QGPGME_QGPGMEEXPORTJOB_H__ + +#include "exportjob.h" + +#include "threadedjobmixin.h" + +namespace QGpgME +{ + +class QGpgMEExportJob +#ifdef Q_MOC_RUN + : public ExportJob +#else + : public _detail::ThreadedJobMixin<ExportJob, std::tuple<GpgME::Error, QByteArray, QString, GpgME::Error> > +#endif +{ + Q_OBJECT +#ifdef Q_MOC_RUN +public Q_SLOTS: + void slotFinished(); +#endif +public: + explicit QGpgMEExportJob(GpgME::Context *context); + ~QGpgMEExportJob(); + + /* from ExportJob */ + GpgME::Error start(const QStringList &patterns) Q_DECL_OVERRIDE; +}; + +} + +#endif // __QGPGME_QGPGMEEXPORTJOB_H__ diff --git a/lang/qt/src/qgpgmeimportfromkeyserverjob.cpp b/lang/qt/src/qgpgmeimportfromkeyserverjob.cpp new file mode 100644 index 00000000..0f196796 --- /dev/null +++ b/lang/qt/src/qgpgmeimportfromkeyserverjob.cpp @@ -0,0 +1,82 @@ +/* + qgpgmeimportfromkeyserverjob.cpp + + This file is part of qgpgme, the Qt API binding for gpgme + Copyright (c) 2004,2008 Klarälvdalens Datakonsult AB + Copyright (c) 2016 Intevation GmbH + + QGpgME 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. + + QGpgME 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 this program; if not, write to the Free Software Foundation, Inc., + 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + + In addition, as a special exception, the copyright holders give + permission to link the code of this program with any edition of + the Qt library by Trolltech AS, Norway (or with modified versions + of Qt that use the same license as Qt), and distribute linked + combinations including the two. You must obey the GNU General + Public License in all respects for all of the code used other than + Qt. If you modify this file, you may extend this exception to + your version of the file, but you are not obligated to do so. If + you do not wish to do so, delete this exception statement from + your version. +*/ + +#include "qgpgmeimportfromkeyserverjob.h" + +#include "dataprovider.h" + +#include "context.h" +#include "data.h" +#include "key.h" + +#include <cassert> + +using namespace QGpgME; +using namespace GpgME; + +QGpgMEImportFromKeyserverJob::QGpgMEImportFromKeyserverJob(Context *context) + : mixin_type(context) +{ + lateInitialization(); +} + +QGpgMEImportFromKeyserverJob::~QGpgMEImportFromKeyserverJob() {} + +static QGpgMEImportFromKeyserverJob::result_type importfromkeyserver(Context *ctx, const std::vector<Key> &keys) +{ + const ImportResult res = ctx->importKeys(keys); + Error ae; + const QString log = _detail::audit_log_as_html(ctx, ae); + return std::make_tuple(res, log, ae); +} + +Error QGpgMEImportFromKeyserverJob::start(const std::vector<Key> &keys) +{ + run(std::bind(&importfromkeyserver, std::placeholders::_1, keys)); + return Error(); +} + +GpgME::ImportResult QGpgME::QGpgMEImportFromKeyserverJob::exec(const std::vector<Key> &keys) +{ + const result_type r = importfromkeyserver(context(), keys); + resultHook(r); + return mResult; +} + +// PENDING(marc) implement showErrorDialog() + +void QGpgME::QGpgMEImportFromKeyserverJob::resultHook(const result_type &tuple) +{ + mResult = std::get<0>(tuple); +} +#include "qgpgmeimportfromkeyserverjob.moc" diff --git a/lang/qt/src/qgpgmeimportfromkeyserverjob.h b/lang/qt/src/qgpgmeimportfromkeyserverjob.h new file mode 100644 index 00000000..8c9f944d --- /dev/null +++ b/lang/qt/src/qgpgmeimportfromkeyserverjob.h @@ -0,0 +1,81 @@ +/* + qgpgmeimportfromkeyserverjob.h + + This file is part of qgpgme, the Qt API binding for gpgme + Copyright (c) 2004,2008 Klarälvdalens Datakonsult AB + Copyright (c) 2016 Intevation GmbH + + QGpgME 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. + + QGpgME 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 this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + + In addition, as a special exception, the copyright holders give + permission to link the code of this program with any edition of + the Qt library by Trolltech AS, Norway (or with modified versions + of Qt that use the same license as Qt), and distribute linked + combinations including the two. You must obey the GNU General + Public License in all respects for all of the code used other than + Qt. If you modify this file, you may extend this exception to + your version of the file, but you are not obligated to do so. If + you do not wish to do so, delete this exception statement from + your version. +*/ + +#ifndef __QGPGME_QGPGMEIMPORTFROMKEYSERVERJOB_H__ +#define __QGPGME_QGPGMEIMPORTFROMKEYSERVERJOB_H__ + +#include "importfromkeyserverjob.h" + +#include "threadedjobmixin.h" + +#ifdef BUILDING_QGPGME +# include "importresult.h" +#else +#include <gpgme++/importresult.h> +#endif + +namespace QGpgME +{ + +class QGpgMEImportFromKeyserverJob +#ifdef Q_MOC_RUN + : public ImportFromKeyserverJob +#else + : public _detail::ThreadedJobMixin<ImportFromKeyserverJob, std::tuple<GpgME::ImportResult, QString, GpgME::Error> > +#endif +{ + Q_OBJECT +#ifdef Q_MOC_RUN +public Q_SLOTS: + void slotFinished(); +#endif +public: + explicit QGpgMEImportFromKeyserverJob(GpgME::Context *context); + ~QGpgMEImportFromKeyserverJob(); + + /* from ImportFromKeyserverJob */ + GpgME::Error start(const std::vector<GpgME::Key> &keys) Q_DECL_OVERRIDE; + + /* from ImportFromKeyserverJob */ + GpgME::ImportResult exec(const std::vector<GpgME::Key> &keys) Q_DECL_OVERRIDE; + + /* from ThreadedJobMixin */ + void resultHook(const result_type &r) Q_DECL_OVERRIDE; + +private: + GpgME::ImportResult mResult; +}; + +} + +#endif // __QGPGME_QGPGMEIMPORTFROMKEYSERVERJOB_H__ diff --git a/lang/qt/src/qgpgmeimportjob.cpp b/lang/qt/src/qgpgmeimportjob.cpp new file mode 100644 index 00000000..f125b12d --- /dev/null +++ b/lang/qt/src/qgpgmeimportjob.cpp @@ -0,0 +1,85 @@ +/* + qgpgmeimportjob.cpp + + This file is part of qgpgme, the Qt API binding for gpgme + Copyright (c) 2004,2008 Klarälvdalens Datakonsult AB + Copyright (c) 2016 Intevation GmbH + + QGpgME 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. + + QGpgME 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 this program; if not, write to the Free Software Foundation, Inc., + 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + + In addition, as a special exception, the copyright holders give + permission to link the code of this program with any edition of + the Qt library by Trolltech AS, Norway (or with modified versions + of Qt that use the same license as Qt), and distribute linked + combinations including the two. You must obey the GNU General + Public License in all respects for all of the code used other than + Qt. If you modify this file, you may extend this exception to + your version of the file, but you are not obligated to do so. If + you do not wish to do so, delete this exception statement from + your version. +*/ + +#include "qgpgmeimportjob.h" + +#include "dataprovider.h" + +#include "context.h" +#include "data.h" +#include "key.h" + +#include <cassert> + +using namespace QGpgME; +using namespace GpgME; + +QGpgMEImportJob::QGpgMEImportJob(Context *context) + : mixin_type(context) +{ + lateInitialization(); +} + +QGpgMEImportJob::~QGpgMEImportJob() {} + +static QGpgMEImportJob::result_type import_qba(Context *ctx, const QByteArray &certData) +{ + QGpgME::QByteArrayDataProvider dp(certData); + Data data(&dp); + + const ImportResult res = ctx->importKeys(data); + Error ae; + const QString log = _detail::audit_log_as_html(ctx, ae); + return std::make_tuple(res, log, ae); +} + +Error QGpgMEImportJob::start(const QByteArray &certData) +{ + run(std::bind(&import_qba, std::placeholders::_1, certData)); + return Error(); +} + +GpgME::ImportResult QGpgME::QGpgMEImportJob::exec(const QByteArray &keyData) +{ + const result_type r = import_qba(context(), keyData); + resultHook(r); + return mResult; +} + +// PENDING(marc) implement showErrorDialog() + +void QGpgME::QGpgMEImportJob::resultHook(const result_type &tuple) +{ + mResult = std::get<0>(tuple); +} +#include "qgpgmeimportjob.moc" diff --git a/lang/qt/src/qgpgmeimportjob.h b/lang/qt/src/qgpgmeimportjob.h new file mode 100644 index 00000000..424cb507 --- /dev/null +++ b/lang/qt/src/qgpgmeimportjob.h @@ -0,0 +1,81 @@ +/* + qgpgmeimportjob.h + + This file is part of qgpgme, the Qt API binding for gpgme + Copyright (c) 2004,2008 Klarälvdalens Datakonsult AB + Copyright (c) 2016 Intevation GmbH + + QGpgME 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. + + QGpgME 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 this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + + In addition, as a special exception, the copyright holders give + permission to link the code of this program with any edition of + the Qt library by Trolltech AS, Norway (or with modified versions + of Qt that use the same license as Qt), and distribute linked + combinations including the two. You must obey the GNU General + Public License in all respects for all of the code used other than + Qt. If you modify this file, you may extend this exception to + your version of the file, but you are not obligated to do so. If + you do not wish to do so, delete this exception statement from + your version. +*/ + +#ifndef __QGPGME_QGPGMEIMPORTJOB_H__ +#define __QGPGME_QGPGMEIMPORTJOB_H__ + +#include "importjob.h" + +#include "threadedjobmixin.h" + +#ifdef BUILDING_QGPGME +# include "importresult.h" +#else +#include <gpgme++/importresult.h> +#endif + +namespace QGpgME +{ + +class QGpgMEImportJob +#ifdef Q_MOC_RUN + : public ImportJob +#else + : public _detail::ThreadedJobMixin<ImportJob, std::tuple<GpgME::ImportResult, QString, GpgME::Error> > +#endif +{ + Q_OBJECT +#ifdef Q_MOC_RUN +public Q_SLOTS: + void slotFinished(); +#endif +public: + explicit QGpgMEImportJob(GpgME::Context *context); + ~QGpgMEImportJob(); + + /* from ImportJob */ + GpgME::Error start(const QByteArray &keyData) Q_DECL_OVERRIDE; + + /* from ImportJob */ + GpgME::ImportResult exec(const QByteArray &keyData) Q_DECL_OVERRIDE; + + /* from ThreadedJobMixin */ + void resultHook(const result_type &r) Q_DECL_OVERRIDE; + +private: + GpgME::ImportResult mResult; +}; + +} + +#endif // __QGPGME_QGPGMEIMPORTJOB_H__ diff --git a/lang/qt/src/qgpgmekeygenerationjob.cpp b/lang/qt/src/qgpgmekeygenerationjob.cpp new file mode 100644 index 00000000..cba6b761 --- /dev/null +++ b/lang/qt/src/qgpgmekeygenerationjob.cpp @@ -0,0 +1,71 @@ +/* + qgpgmekeygenerationjob.cpp + + This file is part of qgpgme, the Qt API binding for gpgme + Copyright (c) 2004 Klarälvdalens Datakonsult AB + Copyright (c) 2016 Intevation GmbH + + QGpgME 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. + + QGpgME 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 this program; if not, write to the Free Software Foundation, Inc., + 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + + In addition, as a special exception, the copyright holders give + permission to link the code of this program with any edition of + the Qt library by Trolltech AS, Norway (or with modified versions + of Qt that use the same license as Qt), and distribute linked + combinations including the two. You must obey the GNU General + Public License in all respects for all of the code used other than + Qt. If you modify this file, you may extend this exception to + your version of the file, but you are not obligated to do so. If + you do not wish to do so, delete this exception statement from + your version. +*/ + +#include "qgpgmekeygenerationjob.h" + +#include "dataprovider.h" + +#include "context.h" +#include "data.h" + +#include <cassert> + +using namespace QGpgME; +using namespace GpgME; + +QGpgMEKeyGenerationJob::QGpgMEKeyGenerationJob(Context *context) + : mixin_type(context) +{ + lateInitialization(); +} + +QGpgMEKeyGenerationJob::~QGpgMEKeyGenerationJob() {} + +static QGpgMEKeyGenerationJob::result_type generate_key(Context *ctx, const QString ¶meters) +{ + QGpgME::QByteArrayDataProvider dp; + Data data = ctx->protocol() == CMS ? Data(&dp) : Data(Data::null); + assert(data.isNull() == (ctx->protocol() != CMS)); + + const KeyGenerationResult res = ctx->generateKey(parameters.toUtf8().constData(), data); + Error ae; + const QString log = _detail::audit_log_as_html(ctx, ae); + return std::make_tuple(res, dp.data(), log, ae); +} + +Error QGpgMEKeyGenerationJob::start(const QString ¶meters) +{ + run(std::bind(&generate_key, std::placeholders::_1, parameters)); + return Error(); +} +#include "qgpgmekeygenerationjob.moc" diff --git a/lang/qt/src/qgpgmekeygenerationjob.h b/lang/qt/src/qgpgmekeygenerationjob.h new file mode 100644 index 00000000..808b7144 --- /dev/null +++ b/lang/qt/src/qgpgmekeygenerationjob.h @@ -0,0 +1,72 @@ +/* + qgpgmekeygenerationjob.h + + This file is part of qgpgme, the Qt API binding for gpgme + Copyright (c) 2004,2008 Klarälvdalens Datakonsult AB + Copyright (c) 2016 Intevation GmbH + + QGpgME 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. + + QGpgME 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 this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + + In addition, as a special exception, the copyright holders give + permission to link the code of this program with any edition of + the Qt library by Trolltech AS, Norway (or with modified versions + of Qt that use the same license as Qt), and distribute linked + combinations including the two. You must obey the GNU General + Public License in all respects for all of the code used other than + Qt. If you modify this file, you may extend this exception to + your version of the file, but you are not obligated to do so. If + you do not wish to do so, delete this exception statement from + your version. +*/ + +#ifndef __QGPGME_QGPGMEKEYGENERATIONJOB_H__ +#define __QGPGME_QGPGMEKEYGENERATIONJOB_H__ + +#include "keygenerationjob.h" + +#include "threadedjobmixin.h" + +#ifdef BUILDING_QGPGME +# include "keygenerationresult.h" +#else +#include <gpgme++/keygenerationresult.h> +#endif + +namespace QGpgME +{ + +class QGpgMEKeyGenerationJob +#ifdef Q_MOC_RUN + : public KeyGenerationJob +#else + : public _detail::ThreadedJobMixin<KeyGenerationJob, std::tuple<GpgME::KeyGenerationResult, QByteArray, QString, GpgME::Error> > +#endif +{ + Q_OBJECT +#ifdef Q_MOC_RUN +private Q_SLOTS: + void slotFinished(); +#endif +public: + explicit QGpgMEKeyGenerationJob(GpgME::Context *context); + ~QGpgMEKeyGenerationJob(); + + /* from KeygenerationJob */ + GpgME::Error start(const QString ¶meters) Q_DECL_OVERRIDE; +}; + +} + +#endif // __QGPGME_QGPGMEKEYGENERATIONJOB_H__ diff --git a/lang/qt/src/qgpgmekeylistjob.cpp b/lang/qt/src/qgpgmekeylistjob.cpp new file mode 100644 index 00000000..49a3c037 --- /dev/null +++ b/lang/qt/src/qgpgmekeylistjob.cpp @@ -0,0 +1,167 @@ +/* + qgpgmekeylistjob.cpp + + This file is part of qgpgme, the Qt API binding for gpgme + Copyright (c) 2004,2008 Klarälvdalens Datakonsult AB + Copyright (c) 2016 Intevation GmbH + + QGpgME 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. + + QGpgME 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 this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + + In addition, as a special exception, the copyright holders give + permission to link the code of this program with any edition of + the Qt library by Trolltech AS, Norway (or with modified versions + of Qt that use the same license as Qt), and distribute linked + combinations including the two. You must obey the GNU General + Public License in all respects for all of the code used other than + Qt. If you modify this file, you may extend this exception to + your version of the file, but you are not obligated to do so. If + you do not wish to do so, delete this exception statement from + your version. +*/ + +#include "qgpgmekeylistjob.h" + +#include "key.h" +#include "context.h" +#include "keylistresult.h" +#include <gpg-error.h> + +#include <QStringList> + +#include <algorithm> + +#include <cstdlib> +#include <cstring> +#include <cassert> + +using namespace QGpgME; +using namespace GpgME; + +QGpgMEKeyListJob::QGpgMEKeyListJob(Context *context) + : mixin_type(context), + mResult(), mSecretOnly(false) +{ + lateInitialization(); +} + +QGpgMEKeyListJob::~QGpgMEKeyListJob() {} + +static KeyListResult do_list_keys(Context *ctx, const QStringList &pats, std::vector<Key> &keys, bool secretOnly) +{ + + const _detail::PatternConverter pc(pats); + + if (const Error err = ctx->startKeyListing(pc.patterns(), secretOnly)) { + return KeyListResult(0, err); + } + + Error err; + do { + keys.push_back(ctx->nextKey(err)); + } while (!err); + + keys.pop_back(); + + const KeyListResult result = ctx->endKeyListing(); + ctx->cancelPendingOperation(); + return result; +} + +static QGpgMEKeyListJob::result_type list_keys(Context *ctx, QStringList pats, bool secretOnly) +{ + if (pats.size() < 2) { + std::vector<Key> keys; + const KeyListResult r = do_list_keys(ctx, pats, keys, secretOnly); + return std::make_tuple(r, keys, QString(), Error()); + } + + // The communication channel between gpgme and gpgsm is limited in + // the number of patterns that can be transported, but they won't + // say to how much, so we need to find out ourselves if we get a + // LINE_TOO_LONG error back... + + // We could of course just feed them single patterns, and that would + // probably be easier, but the performance penalty would currently + // be noticeable. + + unsigned int chunkSize = pats.size(); +retry: + std::vector<Key> keys; + keys.reserve(pats.size()); + KeyListResult result; + do { + const KeyListResult this_result = do_list_keys(ctx, pats.mid(0, chunkSize), keys, secretOnly); + if (this_result.error().code() == GPG_ERR_LINE_TOO_LONG) { + // got LINE_TOO_LONG, try a smaller chunksize: + chunkSize /= 2; + if (chunkSize < 1) + // chunks smaller than one can't be -> return the error. + { + return std::make_tuple(this_result, keys, QString(), Error()); + } else { + goto retry; + } + } else if (this_result.error().code() == GPG_ERR_EOF) { + // early end of keylisting (can happen when ~/.gnupg doesn't + // exist). Fakeing an empty result: + return std::make_tuple(KeyListResult(), std::vector<Key>(), QString(), Error()); + } + // ok, that seemed to work... + result.mergeWith(this_result); + if (result.error().code()) { + break; + } + pats = pats.mid(chunkSize); + } while (!pats.empty()); + return std::make_tuple(result, keys, QString(), Error()); +} + +Error QGpgMEKeyListJob::start(const QStringList &patterns, bool secretOnly) +{ + mSecretOnly = secretOnly; + run(std::bind(&list_keys, std::placeholders::_1, patterns, secretOnly)); + return Error(); +} + +KeyListResult QGpgMEKeyListJob::exec(const QStringList &patterns, bool secretOnly, std::vector<Key> &keys) +{ + mSecretOnly = secretOnly; + const result_type r = list_keys(context(), patterns, secretOnly); + resultHook(r); + keys = std::get<1>(r); + return std::get<0>(r); +} + +void QGpgMEKeyListJob::resultHook(const result_type &tuple) +{ + mResult = std::get<0>(tuple); + Q_FOREACH (const Key &key, std::get<1>(tuple)) { + Q_EMIT nextKey(key); + } +} +#if 0 +void QGpgMEKeyListJob::showErrorDialog(QWidget *parent, const QString &caption) const +{ + if (!mResult.error() || mResult.error().isCanceled()) { + return; + } + const QString msg = i18n("<qt><p>An error occurred while fetching " + "the keys from the backend:</p>" + "<p><b>%1</b></p></qt>", + QString::fromLocal8Bit(mResult.error().asString())); + KMessageBox::error(parent, msg, caption); +} +#endif +#include "qgpgmekeylistjob.moc" diff --git a/lang/qt/src/qgpgmekeylistjob.h b/lang/qt/src/qgpgmekeylistjob.h new file mode 100644 index 00000000..cbe1e94d --- /dev/null +++ b/lang/qt/src/qgpgmekeylistjob.h @@ -0,0 +1,87 @@ +/* + qgpgmekeylistjob.h + + This file is part of qgpgme, the Qt API binding for gpgme + Copyright (c) 2004,2008 Klarälvdalens Datakonsult AB + Copyright (c) 2016 Intevation GmbH + + QGpgME 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. + + QGpgME 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 this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + + In addition, as a special exception, the copyright holders give + permission to link the code of this program with any edition of + the Qt library by Trolltech AS, Norway (or with modified versions + of Qt that use the same license as Qt), and distribute linked + combinations including the two. You must obey the GNU General + Public License in all respects for all of the code used other than + Qt. If you modify this file, you may extend this exception to + your version of the file, but you are not obligated to do so. If + you do not wish to do so, delete this exception statement from + your version. +*/ + +#ifndef __QGPGME_QGPGMEKEYLISTJOB_H__ +#define __QGPGME_QGPGMEKEYLISTJOB_H__ + +#include "keylistjob.h" + +#include "threadedjobmixin.h" + +#ifdef BUILDING_QGPGME +# include "keylistresult.h" +#else +#include <gpgme++/keylistresult.h> +#endif +#ifdef BUILDING_QGPGME +# include "key.h" +#else +#include <gpgme++/key.h> +#endif + +namespace QGpgME +{ + +class QGpgMEKeyListJob +#ifdef Q_MOC_RUN + : public KeyListJob +#else + : public _detail::ThreadedJobMixin<KeyListJob, std::tuple<GpgME::KeyListResult, std::vector<GpgME::Key>, QString, GpgME::Error> > +#endif +{ + Q_OBJECT +#ifdef Q_MOC_RUN +public Q_SLOTS: + void slotFinished(); +#endif +public: + explicit QGpgMEKeyListJob(GpgME::Context *context); + ~QGpgMEKeyListJob(); + + /* from KeyListJob */ + GpgME::Error start(const QStringList &patterns, bool secretOnly) Q_DECL_OVERRIDE; + + /* from KeyListJob */ + GpgME::KeyListResult exec(const QStringList &patterns, bool secretOnly, std::vector<GpgME::Key> &keys) Q_DECL_OVERRIDE; + + /* from ThreadedJobMixin */ + void resultHook(const result_type &result) Q_DECL_OVERRIDE; + +private: + GpgME::KeyListResult mResult; + bool mSecretOnly; +}; + +} + +#endif // __QGPGME_QGPGMEKEYLISTJOB_H__ diff --git a/lang/qt/src/qgpgmelistallkeysjob.cpp b/lang/qt/src/qgpgmelistallkeysjob.cpp new file mode 100644 index 00000000..fd8bfc38 --- /dev/null +++ b/lang/qt/src/qgpgmelistallkeysjob.cpp @@ -0,0 +1,168 @@ +/* + qgpgmelistallkeysjob.cpp + + This file is part of qgpgme, the Qt API binding for gpgme + Copyright (c) 2004,2008 Klarälvdalens Datakonsult AB + Copyright (c) 2016 Intevation GmbH + + QGpgME 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. + + QGpgME 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 this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + + In addition, as a special exception, the copyright holders give + permission to link the code of this program with any edition of + the Qt library by Trolltech AS, Norway (or with modified versions + of Qt that use the same license as Qt), and distribute linked + combinations including the two. You must obey the GNU General + Public License in all respects for all of the code used other than + Qt. If you modify this file, you may extend this exception to + your version of the file, but you are not obligated to do so. If + you do not wish to do so, delete this exception statement from + your version. +*/ + +#include "qgpgmelistallkeysjob.h" + +#include "key.h" +#include "context.h" +#include "keylistresult.h" +#include <gpg-error.h> + +#include <algorithm> + +#include <cstdlib> +#include <cstring> +#include <cassert> + +using namespace QGpgME; +using namespace GpgME; + +QGpgMEListAllKeysJob::QGpgMEListAllKeysJob(Context *context) + : mixin_type(context), + mResult() +{ + lateInitialization(); +} + +QGpgMEListAllKeysJob::~QGpgMEListAllKeysJob() {} + +static KeyListResult do_list_keys(Context *ctx, std::vector<Key> &keys, bool secretOnly) +{ + + const char **pat = 0; + if (const Error err = ctx->startKeyListing(pat, secretOnly)) { + return KeyListResult(0, err); + } + + Error err; + do { + keys.push_back(ctx->nextKey(err)); + } while (!err); + + keys.pop_back(); + + const KeyListResult result = ctx->endKeyListing(); + ctx->cancelPendingOperation(); + return result; +} + +namespace +{ + +template <typename ForwardIterator, typename BinaryPredicate> +ForwardIterator unique_by_merge(ForwardIterator first, ForwardIterator last, BinaryPredicate pred) +{ + first = std::adjacent_find(first, last, pred); + if (first == last) { + return last; + } + + ForwardIterator dest = first; + dest->mergeWith(*++first); + while (++first != last) + if (pred(*dest, *first)) { + dest->mergeWith(*first); + } else { + *++dest = *first; + } + return ++dest; +} + +} + +static void merge_keys(std::vector<Key> &merged, std::vector<Key> &pub, std::vector<Key> &sec) +{ + merged.reserve(pub.size() + sec.size()); + + std::merge(pub.begin(), pub.end(), + sec.begin(), sec.end(), + std::back_inserter(merged), + ByFingerprint<std::less>()); + + merged.erase(unique_by_merge(merged.begin(), merged.end(), ByFingerprint<std::equal_to>()), + merged.end()); +} + +static QGpgMEListAllKeysJob::result_type list_keys(Context *ctx, bool mergeKeys) +{ + std::vector<Key> pub, sec, merged; + KeyListResult r; + + r.mergeWith(do_list_keys(ctx, pub, false)); + std::sort(pub.begin(), pub.end(), ByFingerprint<std::less>()); + + r.mergeWith(do_list_keys(ctx, sec, true)); + std::sort(sec.begin(), sec.end(), ByFingerprint<std::less>()); + + if (mergeKeys) { + merge_keys(merged, pub, sec); + } else { + merged.swap(pub); + } + return std::make_tuple(r, merged, sec, QString(), Error()); +} + +Error QGpgMEListAllKeysJob::start(bool mergeKeys) +{ + run(std::bind(&list_keys, std::placeholders::_1, mergeKeys)); + return Error(); +} + +KeyListResult QGpgMEListAllKeysJob::exec(std::vector<Key> &pub, std::vector<Key> &sec, bool mergeKeys) +{ + const result_type r = list_keys(context(), mergeKeys); + resultHook(r); + pub = std::get<1>(r); + sec = std::get<2>(r); + return std::get<0>(r); +} + +void QGpgMEListAllKeysJob::resultHook(const result_type &tuple) +{ + mResult = std::get<0>(tuple); +} + +#if 0 +void QGpgMEListAllKeysJob::showErrorDialog(QWidget *parent, const QString &caption) const +{ + if (!mResult.error() || mResult.error().isCanceled()) { + return; + } + const QString msg = i18n("<qt><p>An error occurred while fetching " + "the keys from the backend:</p>" + "<p><b>%1</b></p></qt>", + QString::fromLocal8Bit(mResult.error().asString())); + KMessageBox::error(parent, msg, caption); +} +#endif +#include "qgpgmelistallkeysjob.moc" diff --git a/lang/qt/src/qgpgmelistallkeysjob.h b/lang/qt/src/qgpgmelistallkeysjob.h new file mode 100644 index 00000000..1fc69d41 --- /dev/null +++ b/lang/qt/src/qgpgmelistallkeysjob.h @@ -0,0 +1,86 @@ +/* + qgpgmelistallkeysjob.h + + This file is part of qgpgme, the Qt API binding for gpgme + Copyright (c) 2004,2008 Klarälvdalens Datakonsult AB + Copyright (c) 2016 Intevation GmbH + + QGpgME 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. + + QGpgME 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 this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + + In addition, as a special exception, the copyright holders give + permission to link the code of this program with any edition of + the Qt library by Trolltech AS, Norway (or with modified versions + of Qt that use the same license as Qt), and distribute linked + combinations including the two. You must obey the GNU General + Public License in all respects for all of the code used other than + Qt. If you modify this file, you may extend this exception to + your version of the file, but you are not obligated to do so. If + you do not wish to do so, delete this exception statement from + your version. +*/ + +#ifndef __QGPGME_QGPGMELISTALLKEYSJOB_H__ +#define __QGPGME_QGPGMELISTALLKEYSJOB_H__ + +#include "listallkeysjob.h" + +#include "threadedjobmixin.h" + +#ifdef BUILDING_QGPGME +# include "keylistresult.h" +#else +#include <gpgme++/keylistresult.h> +#endif +#ifdef BUILDING_QGPGME +# include "key.h" +#else +#include <gpgme++/key.h> +#endif + +namespace QGpgME +{ + +class QGpgMEListAllKeysJob +#ifdef Q_MOC_RUN + : public ListAllKeysJob +#else + : public _detail::ThreadedJobMixin<ListAllKeysJob, std::tuple<GpgME::KeyListResult, std::vector<GpgME::Key>, std::vector<GpgME::Key>, QString, GpgME::Error> > +#endif +{ + Q_OBJECT +#ifdef Q_MOC_RUN +public Q_SLOTS: + void slotFinished(); +#endif +public: + explicit QGpgMEListAllKeysJob(GpgME::Context *context); + ~QGpgMEListAllKeysJob(); + + /* from ListAllKeysJob */ + GpgME::Error start(bool mergeKeys) Q_DECL_OVERRIDE; + + /* from ListAllKeysJob */ + GpgME::KeyListResult exec(std::vector<GpgME::Key> &pub, std::vector<GpgME::Key> &sec, bool mergeKeys) Q_DECL_OVERRIDE; + + /* from ThreadedJobMixin */ + void resultHook(const result_type &result) Q_DECL_OVERRIDE; + +private: + GpgME::KeyListResult mResult; +}; + +} + +#endif // __QGPGME_QGPGMELISTALLKEYSJOB_H__ diff --git a/lang/qt/src/qgpgmenewcryptoconfig.cpp b/lang/qt/src/qgpgmenewcryptoconfig.cpp new file mode 100644 index 00000000..7303f10b --- /dev/null +++ b/lang/qt/src/qgpgmenewcryptoconfig.cpp @@ -0,0 +1,738 @@ +/* + qgpgmenewcryptoconfig.cpp + + This file is part of qgpgme, the Qt API binding for gpgme + Copyright (c) 2010 Klarälvdalens Datakonsult AB + Copyright (c) 2016 Intevation GmbH + + QGpgME 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. + + QGpgME 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 this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + + In addition, as a special exception, the copyright holders give + permission to link the code of this program with any edition of + the Qt library by Trolltech AS, Norway (or with modified versions + of Qt that use the same license as Qt), and distribute linked + combinations including the two. You must obey the GNU General + Public License in all respects for all of the code used other than + Qt. If you modify this file, you may extend this exception to + your version of the file, but you are not obligated to do so. If + you do not wish to do so, delete this exception statement from + your version. +*/ + +#include "qgpgmenewcryptoconfig.h" + +#include <QDebug> +#include "gpgme_backend_debug.h" + +#include <QFile> + +#include "global.h" +#include "error.h" + + +#include <sstream> +#include <string> +#include <cassert> + +using namespace QGpgME; +using namespace GpgME; +using namespace GpgME::Configuration; + +namespace +{ +struct Select1St { + template <typename U, typename V> + const U &operator()(const std::pair<U, V> &p) const + { + return p.first; + } + template <typename U, typename V> + const U &operator()(const QPair<U, V> &p) const + { + return p.first; + } +}; +} + +// Just for the Q_ASSERT in the dtor. Not thread-safe, but who would +// have 2 threads talking to gpgconf anyway? :) +static bool s_duringClear = false; + +QGpgMENewCryptoConfig::QGpgMENewCryptoConfig() + : m_parsed(false) +{ +} + +QGpgMENewCryptoConfig::~QGpgMENewCryptoConfig() +{ + clear(); +} + +void QGpgMENewCryptoConfig::reloadConfiguration(bool showErrors) +{ + clear(); + + Error error; + const std::vector<Component> components = Component::load(error); +#ifndef NDEBUG + { + std::stringstream ss; + ss << "error: " << error + << "components:\n"; + std::copy(components.begin(), components.end(), + std::ostream_iterator<Component>(ss, "\n")); + qCDebug(GPGPME_BACKEND_LOG) << ss.str().c_str(); + } +#endif +#if 0 + TODO port? + if (error && showErrors) { + const QString wmsg = i18n("<qt>Failed to execute gpgconf:<p>%1</p></qt>", QString::fromLocal8Bit(error.asString())); + qCWarning(GPGPME_BACKEND_LOG) << wmsg; // to see it from test_cryptoconfig.cpp + KMessageBox::error(0, wmsg); + } +#endif + Q_FOREACH(const Component & c, components) { + const std::shared_ptr<QGpgMENewCryptoConfigComponent> comp(new QGpgMENewCryptoConfigComponent); + comp->setComponent(c); + m_componentsByName[ comp->name() ] = comp; + } + m_parsed = true; +} + +QStringList QGpgMENewCryptoConfig::componentList() const +{ + if (!m_parsed) { + const_cast<QGpgMENewCryptoConfig *>(this)->reloadConfiguration(true); + } + QStringList result; + std::transform(m_componentsByName.begin(), m_componentsByName.end(), + std::back_inserter(result), + mem_fn(&QGpgMENewCryptoConfigComponent::name)); + return result; +} + +QGpgMENewCryptoConfigComponent *QGpgMENewCryptoConfig::component(const QString &name) const +{ + if (!m_parsed) { + const_cast<QGpgMENewCryptoConfig *>(this)->reloadConfiguration(false); + } + return m_componentsByName.value(name).get(); +} + +void QGpgMENewCryptoConfig::sync(bool runtime) +{ + Q_FOREACH(const std::shared_ptr<QGpgMENewCryptoConfigComponent> &c, m_componentsByName) + c->sync(runtime); +} + +void QGpgMENewCryptoConfig::clear() +{ + s_duringClear = true; + m_componentsByName.clear(); + s_duringClear = false; + m_parsed = false; // next call to componentList/component will need to run gpgconf again +} + +//// + +QGpgMENewCryptoConfigComponent::QGpgMENewCryptoConfigComponent() + : CryptoConfigComponent(), + m_component() +{ + +} + +void QGpgMENewCryptoConfigComponent::setComponent(const Component &component) +{ + m_component = component; + m_groupsByName.clear(); + + std::shared_ptr<QGpgMENewCryptoConfigGroup> group; + + const std::vector<Option> options = m_component.options(); + Q_FOREACH(const Option & o, options) + if (o.flags() & Group) { + if (group) { + m_groupsByName[group->name()] = group; + } + group.reset(new QGpgMENewCryptoConfigGroup(shared_from_this(), o)); + } else if (group) { + const std::shared_ptr<QGpgMENewCryptoConfigEntry> entry(new QGpgMENewCryptoConfigEntry(group, o)); + const QString name = entry->name(); + group->m_entryNames.push_back(name); + group->m_entriesByName[name] = entry; + } else { + qCWarning(GPGPME_BACKEND_LOG) << "found no group for entry" << o.name() << "of component" << name(); + } + if (group) { + m_groupsByName[group->name()] = group; + } + +} + +QGpgMENewCryptoConfigComponent::~QGpgMENewCryptoConfigComponent() {} + +QString QGpgMENewCryptoConfigComponent::name() const +{ + return QString::fromUtf8(m_component.name()); +} + +QString QGpgMENewCryptoConfigComponent::description() const +{ + return QString::fromUtf8(m_component.description()); +} + +QStringList QGpgMENewCryptoConfigComponent::groupList() const +{ + QStringList result; + result.reserve(m_groupsByName.size()); + std::transform(m_groupsByName.begin(), m_groupsByName.end(), + std::back_inserter(result), + std::mem_fn(&QGpgMENewCryptoConfigGroup::name)); + return result; +} + +QGpgMENewCryptoConfigGroup *QGpgMENewCryptoConfigComponent::group(const QString &name) const +{ + return m_groupsByName.value(name).get(); +} + +void QGpgMENewCryptoConfigComponent::sync(bool runtime) +{ + Q_UNUSED(runtime) + // ### how to pass --runtime to gpgconf? -> marcus: not yet supported (2010-11-20) + if (const Error err = m_component.save()) { +#if 0 + TODO port + const QString wmsg = i18n("Error from gpgconf while saving configuration: %1", QString::fromLocal8Bit(err.asString())); + qCWarning(GPGPME_BACKEND_LOG) << ":" << wmsg; + KMessageBox::error(0, wmsg); +#endif + } + // ### unset dirty state again +} + +//// + +QGpgMENewCryptoConfigGroup::QGpgMENewCryptoConfigGroup(const std::shared_ptr<QGpgMENewCryptoConfigComponent> &comp, const Option &option) + : CryptoConfigGroup(), + m_component(comp), + m_option(option) +{ +} + +QGpgMENewCryptoConfigGroup::~QGpgMENewCryptoConfigGroup() {} + +QString QGpgMENewCryptoConfigGroup::name() const +{ + return QString::fromUtf8(m_option.name()); +} + +QString QGpgMENewCryptoConfigGroup::description() const +{ + return QString::fromUtf8(m_option.description()); +} + +QString QGpgMENewCryptoConfigGroup::path() const +{ + if (const std::shared_ptr<QGpgMENewCryptoConfigComponent> c = m_component.lock()) { + return c->name() + QLatin1Char('/') + name(); + } else { + return QString(); + } +} + +CryptoConfigEntry::Level QGpgMENewCryptoConfigGroup::level() const +{ + // two casts to make SunCC happy: + return static_cast<CryptoConfigEntry::Level>(static_cast<unsigned int>(m_option.level())); +} + +QStringList QGpgMENewCryptoConfigGroup::entryList() const +{ + return m_entryNames; +} + +QGpgMENewCryptoConfigEntry *QGpgMENewCryptoConfigGroup::entry(const QString &name) const +{ + return m_entriesByName.value(name).get(); +} + +static QString urlpart_encode(const QString &str) +{ + QString enc(str); + enc.replace(QLatin1Char('%'), QStringLiteral("%25")); // first! + enc.replace(QLatin1Char(':'), QStringLiteral("%3a")); + //qCDebug(GPGPME_BACKEND_LOG) <<" urlpart_encode:" << str <<" ->" << enc; + return enc; +} + +static QString urlpart_decode(const QString &str) +{ + return QUrl::fromPercentEncoding(str.toLatin1()); +} + +// gpgconf arg type number -> NewCryptoConfigEntry arg type enum mapping +static QGpgME::CryptoConfigEntry::ArgType knownArgType(int argType, bool &ok) +{ + ok = true; + switch (argType) { + case 0: // none + return QGpgME::CryptoConfigEntry::ArgType_None; + case 1: // string + return QGpgME::CryptoConfigEntry::ArgType_String; + case 2: // int32 + return QGpgME::CryptoConfigEntry::ArgType_Int; + case 3: // uint32 + return QGpgME::CryptoConfigEntry::ArgType_UInt; + case 32: // pathname + return QGpgME::CryptoConfigEntry::ArgType_Path; + case 33: // ldap server + return QGpgME::CryptoConfigEntry::ArgType_LDAPURL; + default: + ok = false; + return QGpgME::CryptoConfigEntry::ArgType_None; + } +} + +QGpgMENewCryptoConfigEntry::QGpgMENewCryptoConfigEntry(const std::shared_ptr<QGpgMENewCryptoConfigGroup> &group, const Option &option) + : m_group(group), m_option(option) +{ +} + +#if 0 +QVariant QGpgMENewCryptoConfigEntry::stringToValue(const QString &str, bool unescape) const +{ + const bool isString = isStringType(); + + if (isList()) { + if (argType() == ArgType_None) { + bool ok = true; + const QVariant v = str.isEmpty() ? 0U : str.toUInt(&ok); + if (!ok) { + qCWarning(GPGPME_BACKEND_LOG) << "list-of-none should have an unsigned int as value:" << str; + } + return v; + } + QList<QVariant> lst; + QStringList items = str.split(',', QString::SkipEmptyParts); + for (QStringList::const_iterator valit = items.constBegin(); valit != items.constEnd(); ++valit) { + QString val = *valit; + if (isString) { + if (val.isEmpty()) { + lst << QVariant(QString()); + continue; + } else if (unescape) { + if (val[0] != '"') { // see README.gpgconf + qCWarning(GPGPME_BACKEND_LOG) << "String value should start with '\"' :" << val; + } + val = val.mid(1); + } + } + lst << QVariant(unescape ? gpgconf_unescape(val) : val); + } + return lst; + } else { // not a list + QString val(str); + if (isString) { + if (val.isEmpty()) { + return QVariant(QString()); // not set [ok with lists too?] + } else if (unescape) { + if (val[0] != '"') { // see README.gpgconf + qCWarning(GPGPME_BACKEND_LOG) << "String value should start with '\"' :" << val; + } + val = val.mid(1); + } + } + return QVariant(unescape ? gpgconf_unescape(val) : val); + } +} +#endif + +QGpgMENewCryptoConfigEntry::~QGpgMENewCryptoConfigEntry() +{ +#ifndef NDEBUG + if (!s_duringClear && m_option.dirty()) + qCWarning(GPGPME_BACKEND_LOG) << "Deleting a QGpgMENewCryptoConfigEntry that was modified (" << m_option.description() << ")" + << "You forgot to call sync() (to commit) or clear() (to discard)"; +#endif +} + +QString QGpgMENewCryptoConfigEntry::name() const +{ + return QString::fromUtf8(m_option.name()); +} + +QString QGpgMENewCryptoConfigEntry::description() const +{ + return QString::fromUtf8(m_option.description()); +} + +QString QGpgMENewCryptoConfigEntry::path() const +{ + if (const std::shared_ptr<QGpgMENewCryptoConfigGroup> g = m_group.lock()) { + return g->path() + QLatin1Char('/') + name(); + } else { + return QString(); + } +} + +bool QGpgMENewCryptoConfigEntry::isOptional() const +{ + return m_option.flags() & Optional; +} + +bool QGpgMENewCryptoConfigEntry::isReadOnly() const +{ + return m_option.flags() & NoChange; +} + +bool QGpgMENewCryptoConfigEntry::isList() const +{ + return m_option.flags() & List; +} + +bool QGpgMENewCryptoConfigEntry::isRuntime() const +{ + return m_option.flags() & Runtime; +} + +CryptoConfigEntry::Level QGpgMENewCryptoConfigEntry::level() const +{ + // two casts to make SunCC happy: + return static_cast<Level>(static_cast<unsigned int>(m_option.level())); +} + +CryptoConfigEntry::ArgType QGpgMENewCryptoConfigEntry::argType() const +{ + bool ok = false; + const ArgType type = knownArgType(m_option.type(), ok); + if (ok) { + return type; + } else { + return knownArgType(m_option.alternateType(), ok); + } +} + +bool QGpgMENewCryptoConfigEntry::isSet() const +{ + return m_option.set(); +} + +bool QGpgMENewCryptoConfigEntry::boolValue() const +{ + Q_ASSERT(m_option.alternateType() == NoType); + Q_ASSERT(!isList()); + return m_option.currentValue().boolValue(); +} + +QString QGpgMENewCryptoConfigEntry::stringValue() const +{ + //return toString( false ); + Q_ASSERT(m_option.alternateType() == StringType); + Q_ASSERT(!isList()); + return QString::fromUtf8(m_option.currentValue().stringValue()); +} + +int QGpgMENewCryptoConfigEntry::intValue() const +{ + Q_ASSERT(m_option.alternateType() == IntegerType); + Q_ASSERT(!isList()); + return m_option.currentValue().intValue(); +} + +unsigned int QGpgMENewCryptoConfigEntry::uintValue() const +{ + Q_ASSERT(m_option.alternateType() == UnsignedIntegerType); + Q_ASSERT(!isList()); + return m_option.currentValue().uintValue(); +} + +static QUrl parseURL(int mRealArgType, const QString &str) +{ + if (mRealArgType == 33) { // LDAP server + // The format is HOSTNAME:PORT:USERNAME:PASSWORD:BASE_DN + QStringList items = str.split(QLatin1Char(':')); + if (items.count() == 5) { + QStringList::const_iterator it = items.constBegin(); + QUrl url; + url.setScheme(QStringLiteral("ldap")); + url.setHost(urlpart_decode(*it++)); + + bool ok; + const int port = (*it++).toInt(&ok); + if (ok) { + url.setPort(port); + } else if (!it->isEmpty()) { + qCWarning(GPGPME_BACKEND_LOG) << "parseURL: malformed LDAP server port, ignoring: \"" << *it << "\""; + } + + const QString userName = urlpart_decode(*it++); + if (!userName.isEmpty()) { + url.setUserName(userName); + } + const QString passWord = urlpart_decode(*it++); + if (!passWord.isEmpty()) { + url.setPassword(passWord); + } + url.setQuery(urlpart_decode(*it)); + return url; + } else { + qCWarning(GPGPME_BACKEND_LOG) << "parseURL: malformed LDAP server:" << str; + } + } + // other URLs : assume wellformed URL syntax. + return QUrl(str); +} + +// The opposite of parseURL +static QString splitURL(int mRealArgType, const QUrl &url) +{ + if (mRealArgType == 33) { // LDAP server + // The format is HOSTNAME:PORT:USERNAME:PASSWORD:BASE_DN + Q_ASSERT(url.scheme() == QLatin1String("ldap")); + return urlpart_encode(url.host()) + QLatin1Char(':') + + (url.port() != -1 ? QString::number(url.port()) : QString()) + QLatin1Char(':') + // -1 is used for default ports, omit + urlpart_encode(url.userName()) + QLatin1Char(':') + + urlpart_encode(url.password()) + QLatin1Char(':') + + urlpart_encode(url.query()); + } + return url.path(); +} + +QUrl QGpgMENewCryptoConfigEntry::urlValue() const +{ + const Type type = m_option.type(); + Q_ASSERT(type == FilenameType || type == LdapServerType); + Q_ASSERT(!isList()); + if (type == FilenameType) { + QUrl url; + url.setPath(QFile::decodeName(m_option.currentValue().stringValue())); + return url; + } + return parseURL(type, stringValue()); +} + +unsigned int QGpgMENewCryptoConfigEntry::numberOfTimesSet() const +{ + Q_ASSERT(m_option.alternateType() == NoType); + Q_ASSERT(isList()); + return m_option.currentValue().uintValue(); +} + +std::vector<int> QGpgMENewCryptoConfigEntry::intValueList() const +{ + Q_ASSERT(m_option.alternateType() == IntegerType); + Q_ASSERT(isList()); + return m_option.currentValue().intValues(); +} + +std::vector<unsigned int> QGpgMENewCryptoConfigEntry::uintValueList() const +{ + Q_ASSERT(m_option.alternateType() == UnsignedIntegerType); + Q_ASSERT(isList()); + return m_option.currentValue().uintValues(); +} + +QList<QUrl> QGpgMENewCryptoConfigEntry::urlValueList() const +{ + const Type type = m_option.type(); + Q_ASSERT(type == FilenameType || type == LdapServerType); + Q_ASSERT(isList()); + const Argument arg = m_option.currentValue(); + const std::vector<const char *> values = arg.stringValues(); + QList<QUrl> ret; + Q_FOREACH(const char *value, values) + if (type == FilenameType) { + QUrl url; + url.setPath(QFile::decodeName(value)); + ret << url; + } else { + ret << parseURL(type, QString::fromUtf8(value)); + } + return ret; +} + +void QGpgMENewCryptoConfigEntry::resetToDefault() +{ + m_option.resetToDefaultValue(); +} + +void QGpgMENewCryptoConfigEntry::setBoolValue(bool b) +{ + Q_ASSERT(m_option.alternateType() == NoType); + Q_ASSERT(!isList()); + // A "no arg" option is either set or not set. + // Being set means createNoneArgument(), being unset means resetToDefault() + m_option.setNewValue(m_option.createNoneArgument(b)); +} + +void QGpgMENewCryptoConfigEntry::setStringValue(const QString &str) +{ + Q_ASSERT(m_option.alternateType() == StringType); + Q_ASSERT(!isList()); + const Type type = m_option.type(); + // When setting a string to empty (and there's no default), we need to act like resetToDefault + // Otherwise we try e.g. "ocsp-responder:0:" and gpgconf answers: + // "gpgconf: argument required for option ocsp-responder" + if (str.isEmpty() && !isOptional()) { + m_option.resetToDefaultValue(); + } else if (type == FilenameType) { + m_option.setNewValue(m_option.createStringArgument(QFile::encodeName(str).constData())); + } else { + m_option.setNewValue(m_option.createStringArgument(str.toUtf8().constData())); + } +} + +void QGpgMENewCryptoConfigEntry::setIntValue(int i) +{ + Q_ASSERT(m_option.alternateType() == IntegerType); + Q_ASSERT(!isList()); + m_option.setNewValue(m_option.createIntArgument(i)); +} + +void QGpgMENewCryptoConfigEntry::setUIntValue(unsigned int i) +{ + Q_ASSERT(m_option.alternateType() == UnsignedIntegerType); + Q_ASSERT(!isList()); + m_option.setNewValue(m_option.createUIntArgument(i)); +} + +void QGpgMENewCryptoConfigEntry::setURLValue(const QUrl &url) +{ + const Type type = m_option.type(); + Q_ASSERT(type == FilenameType || type == LdapServerType); + Q_ASSERT(!isList()); + const QString str = splitURL(type, url); + // cf. setStringValue() + if (str.isEmpty() && !isOptional()) { + m_option.resetToDefaultValue(); + } else if (type == FilenameType) { + m_option.setNewValue(m_option.createStringArgument(QFile::encodeName(str).constData())); + } else { + m_option.setNewValue(m_option.createStringArgument(str.toUtf8().constData())); + } +} + +void QGpgMENewCryptoConfigEntry::setNumberOfTimesSet(unsigned int i) +{ + Q_ASSERT(m_option.alternateType() == NoType); + Q_ASSERT(isList()); + m_option.setNewValue(m_option.createNoneListArgument(i)); +} + +void QGpgMENewCryptoConfigEntry::setIntValueList(const std::vector<int> &lst) +{ + Q_ASSERT(m_option.alternateType() == IntegerType); + Q_ASSERT(isList()); + m_option.setNewValue(m_option.createIntListArgument(lst)); +} + +void QGpgMENewCryptoConfigEntry::setUIntValueList(const std::vector<unsigned int> &lst) +{ + Q_ASSERT(m_option.alternateType() == UnsignedIntegerType); + Q_ASSERT(isList()); + m_option.setNewValue(m_option.createUIntListArgument(lst)); +} + +void QGpgMENewCryptoConfigEntry::setURLValueList(const QList<QUrl> &urls) +{ + const Type type = m_option.type(); + Q_ASSERT(m_option.alternateType() == StringType); + Q_ASSERT(isList()); + std::vector<std::string> values; + values.reserve(urls.size()); + Q_FOREACH (const QUrl &url, urls) + if (type == FilenameType) { + values.push_back(QFile::encodeName(url.path()).constData()); + } else { + values.push_back(splitURL(type, url).toUtf8().constData()); + } + m_option.setNewValue(m_option.createStringListArgument(values)); +} + +bool QGpgMENewCryptoConfigEntry::isDirty() const +{ + return m_option.dirty(); +} + +#if 0 +QString QGpgMENewCryptoConfigEntry::toString(bool escape) const +{ + // Basically the opposite of stringToValue + if (isStringType()) { + if (mValue.isNull()) { + return QString(); + } else if (isList()) { // string list + QStringList lst = mValue.toStringList(); + if (escape) { + for (QStringList::iterator it = lst.begin(); it != lst.end(); ++it) { + if (!(*it).isNull()) { + *it = gpgconf_escape(*it).prepend("\""); + } + } + } + QString res = lst.join(","); + //qCDebug(GPGPME_BACKEND_LOG) <<"toString:" << res; + return res; + } else { // normal string + QString res = mValue.toString(); + if (escape) { + res = gpgconf_escape(res).prepend("\""); + } + return res; + } + } + if (!isList()) { // non-list non-string + if (mArgType == ArgType_None) { + return mValue.toBool() ? QString::fromLatin1("1") : QString(); + } else { // some int + Q_ASSERT(mArgType == ArgType_Int || mArgType == ArgType_UInt); + return mValue.toString(); // int to string conversion + } + } + + // Lists (of other types than strings) + if (mArgType == ArgType_None) { + return QString::number(numberOfTimesSet()); + } + QStringList ret; + QList<QVariant> lst = mValue.toList(); + for (QList<QVariant>::const_iterator it = lst.constBegin(); it != lst.constEnd(); ++it) { + ret << (*it).toString(); // QVariant does the conversion + } + return ret.join(","); +} + +QString QGpgMENewCryptoConfigEntry::outputString() const +{ + Q_ASSERT(mSet); + return toString(true); +} + +bool QGpgMENewCryptoConfigEntry::isStringType() const +{ + return (mArgType == QGpgME::NewCryptoConfigEntry::ArgType_String + || mArgType == QGpgME::NewCryptoConfigEntry::ArgType_Path + || mArgType == QGpgME::NewCryptoConfigEntry::ArgType_URL + || mArgType == QGpgME::NewCryptoConfigEntry::ArgType_LDAPURL); +} + +void QGpgMENewCryptoConfigEntry::setDirty(bool b) +{ + mDirty = b; +} +#endif diff --git a/lang/qt/src/qgpgmenewcryptoconfig.h b/lang/qt/src/qgpgmenewcryptoconfig.h new file mode 100644 index 00000000..81b4cb44 --- /dev/null +++ b/lang/qt/src/qgpgmenewcryptoconfig.h @@ -0,0 +1,189 @@ +/* + qgpgmenewcryptoconfig.h + + This file is part of qgpgme, the Qt API binding for gpgme + Copyright (c) 2010 Klarälvdalens Datakonsult AB + Copyright (c) 2016 Intevation GmbH + + QGpgME 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. + + QGpgME 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 this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + + In addition, as a special exception, the copyright holders give + permission to link the code of this program with any edition of + the Qt library by Trolltech AS, Norway (or with modified versions + of Qt that use the same license as Qt), and distribute linked + combinations including the two. You must obey the GNU General + Public License in all respects for all of the code used other than + Qt. If you modify this file, you may extend this exception to + your version of the file, but you are not obligated to do so. If + you do not wish to do so, delete this exception statement from + your version. +*/ + +#ifndef QGPGME_QGPGMENEWCRYPTOCONFIG_H +#define QGPGME_QGPGMENEWCRYPTOCONFIG_H + +#include "qgpgme_export.h" +#include "cryptoconfig.h" + +#include <QHash> +#include <QStringList> +#include <QVariant> + +#ifdef BUILDING_QGPGME +# include "configuration.h" +#else +# include <gpgme++/configuration.h> +#endif + + +#include <vector> +#include <utility> + +class QGpgMENewCryptoConfig; +class QGpgMENewCryptoConfigComponent; +class QGpgMENewCryptoConfigGroup; +class QGpgMENewCryptoConfigEntry; + +class QGpgMENewCryptoConfigEntry : public QGpgME::CryptoConfigEntry +{ +public: + QGpgMENewCryptoConfigEntry(const std::shared_ptr<QGpgMENewCryptoConfigGroup> &group, const GpgME::Configuration::Option &option); + ~QGpgMENewCryptoConfigEntry(); + + QString name() const Q_DECL_OVERRIDE; + QString description() const Q_DECL_OVERRIDE; + QString path() const Q_DECL_OVERRIDE; + bool isOptional() const Q_DECL_OVERRIDE; + bool isReadOnly() const Q_DECL_OVERRIDE; + bool isList() const Q_DECL_OVERRIDE; + bool isRuntime() const Q_DECL_OVERRIDE; + Level level() const Q_DECL_OVERRIDE; + ArgType argType() const Q_DECL_OVERRIDE; + bool isSet() const Q_DECL_OVERRIDE; + bool boolValue() const Q_DECL_OVERRIDE; + QString stringValue() const Q_DECL_OVERRIDE; + int intValue() const Q_DECL_OVERRIDE; + unsigned int uintValue() const Q_DECL_OVERRIDE; + QUrl urlValue() const Q_DECL_OVERRIDE; + unsigned int numberOfTimesSet() const Q_DECL_OVERRIDE; + std::vector<int> intValueList() const Q_DECL_OVERRIDE; + std::vector<unsigned int> uintValueList() const Q_DECL_OVERRIDE; + QList<QUrl> urlValueList() const Q_DECL_OVERRIDE; + void resetToDefault() Q_DECL_OVERRIDE; + void setBoolValue(bool) Q_DECL_OVERRIDE; + void setStringValue(const QString &) Q_DECL_OVERRIDE; + void setIntValue(int) Q_DECL_OVERRIDE; + void setUIntValue(unsigned int) Q_DECL_OVERRIDE; + void setURLValue(const QUrl &) Q_DECL_OVERRIDE; + void setNumberOfTimesSet(unsigned int) Q_DECL_OVERRIDE; + void setIntValueList(const std::vector<int> &) Q_DECL_OVERRIDE; + void setUIntValueList(const std::vector<unsigned int> &) Q_DECL_OVERRIDE; + void setURLValueList(const QList<QUrl> &) Q_DECL_OVERRIDE; + bool isDirty() const Q_DECL_OVERRIDE; + +#if 0 + void setDirty(bool b); + QString outputString() const; + +protected: + bool isStringType() const; + QVariant stringToValue(const QString &value, bool unescape) const; + QString toString(bool escape) const; +#endif +private: + std::weak_ptr<QGpgMENewCryptoConfigGroup> m_group; + GpgME::Configuration::Option m_option; +}; + +class QGpgMENewCryptoConfigGroup : public QGpgME::CryptoConfigGroup +{ +public: + QGpgMENewCryptoConfigGroup(const std::shared_ptr<QGpgMENewCryptoConfigComponent> &parent, const GpgME::Configuration::Option &option); + ~QGpgMENewCryptoConfigGroup(); + + QString name() const Q_DECL_OVERRIDE; + QString iconName() const Q_DECL_OVERRIDE + { + return QString(); + } + QString description() const Q_DECL_OVERRIDE; + QString path() const Q_DECL_OVERRIDE; + QGpgME::CryptoConfigEntry::Level level() const Q_DECL_OVERRIDE; + QStringList entryList() const Q_DECL_OVERRIDE; + QGpgMENewCryptoConfigEntry *entry(const QString &name) const Q_DECL_OVERRIDE; + +private: + friend class QGpgMENewCryptoConfigComponent; // it adds the entries + std::weak_ptr<QGpgMENewCryptoConfigComponent> m_component; + GpgME::Configuration::Option m_option; + QStringList m_entryNames; + QHash< QString, std::shared_ptr<QGpgMENewCryptoConfigEntry> > m_entriesByName; +}; + +/// For docu, see kleo/cryptoconfig.h +class QGpgMENewCryptoConfigComponent : public QGpgME::CryptoConfigComponent, public std::enable_shared_from_this<QGpgMENewCryptoConfigComponent> +{ +public: + QGpgMENewCryptoConfigComponent(); + ~QGpgMENewCryptoConfigComponent(); + + void setComponent(const GpgME::Configuration::Component &component); + + QString name() const Q_DECL_OVERRIDE; + QString iconName() const Q_DECL_OVERRIDE + { + return name(); + } + QString description() const Q_DECL_OVERRIDE; + QStringList groupList() const Q_DECL_OVERRIDE; + QGpgMENewCryptoConfigGroup *group(const QString &name) const Q_DECL_OVERRIDE; + + void sync(bool runtime); + +private: + GpgME::Configuration::Component m_component; + QHash< QString, std::shared_ptr<QGpgMENewCryptoConfigGroup> > m_groupsByName; +}; + +/** + * CryptoConfig implementation around the gpgconf command-line tool + * For method docu, see kleo/cryptoconfig.h + */ +class QGPGME_EXPORT QGpgMENewCryptoConfig : public QGpgME::CryptoConfig +{ +public: + /** + * Constructor + */ + QGpgMENewCryptoConfig(); + ~QGpgMENewCryptoConfig(); + + QStringList componentList() const Q_DECL_OVERRIDE; + + QGpgMENewCryptoConfigComponent *component(const QString &name) const Q_DECL_OVERRIDE; + + void clear() Q_DECL_OVERRIDE; + void sync(bool runtime) Q_DECL_OVERRIDE; + +private: + /// @param showErrors if true, a messagebox will be shown if e.g. gpgconf wasn't found + void reloadConfiguration(bool showErrors); + +private: + QHash< QString, std::shared_ptr<QGpgMENewCryptoConfigComponent> > m_componentsByName; + bool m_parsed; +}; + +#endif /* QGPGME_QGPGMENEWCRYPTOCONFIG_H */ diff --git a/lang/qt/src/qgpgmerefreshkeysjob.cpp b/lang/qt/src/qgpgmerefreshkeysjob.cpp new file mode 100644 index 00000000..53a9d2c0 --- /dev/null +++ b/lang/qt/src/qgpgmerefreshkeysjob.cpp @@ -0,0 +1,225 @@ +/* + qgpgmerefreshkeysjob.cpp + + This file is part of qgpgme, the Qt API binding for gpgme + Copyright (c) 2004 Klar�vdalens Datakonsult AB + Copyright (c) 2016 Intevation GmbH + + QGpgME 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. + + QGpgME 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 this program; if not, write to the Free Software Foundation, Inc., + 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + + In addition, as a special exception, the copyright holders give + permission to link the code of this program with any edition of + the Qt library by Trolltech AS, Norway (or with modified versions + of Qt that use the same license as Qt), and distribute linked + combinations including the two. You must obey the GNU General + Public License in all respects for all of the code used other than + Qt. If you modify this file, you may extend this exception to + your version of the file, but you are not obligated to do so. If + you do not wish to do so, delete this exception statement from + your version. +*/ + +#define MAX_CMD_LENGTH 32768 + +#include "qgpgmerefreshkeysjob.h" + +#include <QDebug> +#include "gpgme_backend_debug.h" + +#include "context.h" + +#include <QByteArray> +#include <QStringList> + +#include <gpg-error.h> + +#include <assert.h> + +QGpgME::QGpgMERefreshKeysJob::QGpgMERefreshKeysJob() + : RefreshKeysJob(0), + mProcess(0), + mError(0) +{ + +} + +QGpgME::QGpgMERefreshKeysJob::~QGpgMERefreshKeysJob() +{ + +} + +GpgME::Error QGpgME::QGpgMERefreshKeysJob::start(const QStringList &patterns) +{ + assert(mPatternsToDo.empty()); + + mPatternsToDo = patterns; + if (mPatternsToDo.empty()) { + mPatternsToDo.push_back(QStringLiteral(" ")); // empty list means all -> mae + } + // sure to fail the first + // startAProcess() guard clause + + return startAProcess(); +} + +#if MAX_CMD_LENGTH < 65 + 128 +#error MAX_CMD_LENGTH is too low +#endif + +GpgME::Error QGpgME::QGpgMERefreshKeysJob::startAProcess() +{ + if (mPatternsToDo.empty()) { + return GpgME::Error(); + } + // create and start gpgsm process: + mProcess = new QProcess(this); + mProcess->setObjectName(QStringLiteral("gpgsm -k --with-validation --force-crl-refresh --enable-crl-checks")); + + // FIXME: obbtain the path to gpgsm from gpgme, so we use the same instance. + mProcess->setProgram(QStringLiteral("gpgsm")); + QStringList arguments; + arguments << QStringLiteral("-k") + << QStringLiteral("--with-validation") + << QStringLiteral("--force-crl-refresh") + << QStringLiteral("--enable-crl-checks"); + unsigned int commandLineLength = MAX_CMD_LENGTH; + commandLineLength -= + strlen("gpgsm") + 1 + strlen("-k") + 1 + + strlen("--with-validation") + 1 + strlen("--force-crl-refresh") + 1 + + strlen("--enable-crl-checks") + 1; + while (!mPatternsToDo.empty()) { + const QByteArray pat = mPatternsToDo.front().toUtf8().trimmed(); + const unsigned int patLength = pat.length(); + if (patLength >= commandLineLength) { + break; + } + mPatternsToDo.pop_front(); + if (pat.isEmpty()) { + continue; + } + arguments << QLatin1String(pat); + commandLineLength -= patLength + 1; + } + + mProcess->setArguments(arguments); + + connect(mProcess, SIGNAL(finished(int,QProcess::ExitStatus)), + SLOT(slotProcessExited(int,QProcess::ExitStatus))); + connect(mProcess, SIGNAL(readyReadStandardOutput()), + SLOT(slotStdout())); + connect(mProcess, &QProcess::readyReadStandardError, + this, &QGpgMERefreshKeysJob::slotStderr); + + mProcess->start(); + if (!mProcess->waitForStarted()) { + mError = GpgME::Error::fromCode(GPG_ERR_ENOENT, GPG_ERR_SOURCE_GPGSM); // what else? + deleteLater(); + return mError; + } else { + return GpgME::Error(); + } +} + +void QGpgME::QGpgMERefreshKeysJob::slotCancel() +{ + if (mProcess) { + mProcess->kill(); + } + mProcess = 0; + mError = GpgME::Error::fromCode(GPG_ERR_CANCELED, GPG_ERR_SOURCE_GPGSM); +} + +void QGpgME::QGpgMERefreshKeysJob::slotStatus(QProcess *proc, const QString &type, const QStringList &args) +{ + if (proc != mProcess) { + return; + } + QStringList::const_iterator it = args.begin(); + bool ok = false; + + if (type == QLatin1String("ERROR")) { + + if (args.size() < 2) { + qCDebug(GPGPME_BACKEND_LOG) << "not recognising ERROR with < 2 args!"; + return; + } + const int source = (*++it).toInt(&ok); + if (!ok) { + qCDebug(GPGPME_BACKEND_LOG) << "expected number for first ERROR arg, got something else"; + return; + } + ok = false; + const int code = (*++it).toInt(&ok); + if (!ok) { + qCDebug(GPGPME_BACKEND_LOG) << "expected number for second ERROR arg, got something else"; + return; + } + mError = GpgME::Error::fromCode(code, source); + + } else if (type == QLatin1String("PROGRESS")) { + + if (args.size() < 4) { + qCDebug(GPGPME_BACKEND_LOG) << "not recognising PROGRESS with < 4 args!"; + return; + } + const QString what = *++it; + ok = false; + const int typ = (*++it).toInt(&ok); + if (!ok) { + qCDebug(GPGPME_BACKEND_LOG) << "expected number for \"type\", got something else"; + return; + } + ok = false; + const int cur = (*++it).toInt(&ok); + if (!ok) { + qCDebug(GPGPME_BACKEND_LOG) << "expected number for \"cur\", got something else"; + return; + } + ok = false; + const int total = (*++it).toInt(&ok); + if (!ok) { + qCDebug(GPGPME_BACKEND_LOG) << "expected number for \"total\", got something else"; + return; + } + // TODO port + Q_EMIT progress(QString(), cur, total); + + } +} + +void QGpgME::QGpgMERefreshKeysJob::slotStderr() +{ + // implement? or not? +} + +void QGpgME::QGpgMERefreshKeysJob::slotProcessExited(int exitCode, QProcess::ExitStatus exitStatus) +{ + if (!mError && !mPatternsToDo.empty()) { + if (const GpgME::Error err = startAProcess()) { + mError = err; + } else { + return; + } + } + + Q_EMIT done(); + if (!mError && + (exitStatus != QProcess::NormalExit || exitCode != 0)) { + mError = GpgME::Error::fromCode(GPG_ERR_GENERAL, GPG_ERR_SOURCE_GPGSM); + } + Q_EMIT result(mError); + deleteLater(); +} +#include "qgpgmerefreshkeysjob.moc" diff --git a/lang/qt/src/qgpgmerefreshkeysjob.h b/lang/qt/src/qgpgmerefreshkeysjob.h new file mode 100644 index 00000000..2a54e38e --- /dev/null +++ b/lang/qt/src/qgpgmerefreshkeysjob.h @@ -0,0 +1,79 @@ +/* + qgpgmerefreshkeysjob.h + + This file is part of qgpgme, the Qt API binding for gpgme + Copyright (c) 2004 Klarälvdalens Datakonsult AB + Copyright (c) 2016 Intevation GmbH + + QGpgME 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. + + QGpgME 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 this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + + In addition, as a special exception, the copyright holders give + permission to link the code of this program with any edition of + the Qt library by Trolltech AS, Norway (or with modified versions + of Qt that use the same license as Qt), and distribute linked + combinations including the two. You must obey the GNU General + Public License in all respects for all of the code used other than + Qt. If you modify this file, you may extend this exception to + your version of the file, but you are not obligated to do so. If + you do not wish to do so, delete this exception statement from + your version. +*/ + +#ifndef __QGPGME_QGPGMEREFRESHKEYSJOB_H__ +#define __QGPGME_QGPGMEREFRESHKEYSJOB_H__ + +#include "refreshkeysjob.h" +#ifdef BUILDING_QGPGME +# include "context.h" +#else +#include "gpgme++/context.h" +#endif + +#include <QStringList> +#include <QProcess> + +namespace QGpgME +{ + +class QGpgMERefreshKeysJob : public RefreshKeysJob +{ + Q_OBJECT +public: + QGpgMERefreshKeysJob(); + ~QGpgMERefreshKeysJob(); + + /* from RefreshKeysJob */ + GpgME::Error start(const QStringList &patterns) Q_DECL_OVERRIDE; + +private Q_SLOTS: + /* from Job */ + void slotCancel() Q_DECL_OVERRIDE; + + void slotStatus(QProcess *, const QString &, const QStringList &); + void slotStderr(); + void slotProcessExited(int exitCode, QProcess::ExitStatus exitStatus); + +private: + GpgME::Error startAProcess(); + +private: + QProcess *mProcess; + GpgME::Error mError; + QStringList mPatternsToDo; +}; + +} + +#endif // __QGPGME_QGPGMEREFRESHKEYSJOB_H__ diff --git a/lang/qt/src/qgpgmesecretkeyexportjob.cpp b/lang/qt/src/qgpgmesecretkeyexportjob.cpp new file mode 100644 index 00000000..f4ec698f --- /dev/null +++ b/lang/qt/src/qgpgmesecretkeyexportjob.cpp @@ -0,0 +1,142 @@ +/* + qgpgmesecretexportjob.cpp + + This file is part of qgpgme, the Qt API binding for gpgme + Copyright (c) 2004 Klar�vdalens Datakonsult AB + Copyright (c) 2016 Intevation GmbH + + QGpgME 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. + + QGpgME 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 this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + + In addition, as a special exception, the copyright holders give + permission to link the code of this program with any edition of + the Qt library by Trolltech AS, Norway (or with modified versions + of Qt that use the same license as Qt), and distribute linked + combinations including the two. You must obey the GNU General + Public License in all respects for all of the code used other than + Qt. If you modify this file, you may extend this exception to + your version of the file, but you are not obligated to do so. If + you do not wish to do so, delete this exception statement from + your version. +*/ + +#include "qgpgmesecretkeyexportjob.h" + +#include <QDebug> +#include "gpgme_backend_debug.h" + +#include "context.h" +#include "data.h" + +#include <QStringList> + +#include <gpg-error.h> + +#include <string.h> +#include <assert.h> + +QGpgME::QGpgMESecretKeyExportJob::QGpgMESecretKeyExportJob(bool armour, const QString &charset) + : ExportJob(0), + mProcess(0), + mError(0), + mArmour(armour), + mCharset(charset) +{ + +} + +QGpgME::QGpgMESecretKeyExportJob::~QGpgMESecretKeyExportJob() +{ + +} + +GpgME::Error QGpgME::QGpgMESecretKeyExportJob::start(const QStringList &patterns) +{ + assert(mKeyData.isEmpty()); + + if (patterns.size() != 1 || patterns.front().isEmpty()) { + deleteLater(); + return mError = GpgME::Error::fromCode(GPG_ERR_INV_VALUE, GPG_ERR_SOURCE_GPGSM); + } + + // create and start gpgsm process: + mProcess = new QProcess(this); + mProcess->setObjectName(QStringLiteral("gpgsm --export-secret-key-p12")); + + // FIXME: obtain the path to gpgsm from gpgme, so we use the same instance. + mProcess->setProgram("gpgsm"); + QStringList arguments; + arguments << QStringLiteral("--export-secret-key-p12"); + if (mArmour) { + arguments << QStringLiteral("--armor"); + } + if (!mCharset.isEmpty()) { + arguments << QStringLiteral("--p12-charset") << mCharset; + } + arguments << QLatin1String(patterns.front().toUtf8()); + + mProcess->setArguments(arguments); + connect(mProcess, SIGNAL(finished(int,QProcess::ExitStatus)), + SLOT(slotProcessExited(int,QProcess::ExitStatus))); + connect(mProcess, &QProcess::readyReadStandardOutput, + this, &QGpgMESecretKeyExportJob::slotStdout); + connect(mProcess, &QProcess::readyReadStandardError, + this, &QGpgMESecretKeyExportJob::slotStderr); + + mProcess->start(); + if (!mProcess->waitForStarted()) { + mError = GpgME::Error::fromCode(GPG_ERR_ENOENT, GPG_ERR_SOURCE_GPGSM); // what else? + deleteLater(); + return mError; + } else { + return GpgME::Error(); + } +} + +void QGpgME::QGpgMESecretKeyExportJob::slotCancel() +{ + if (mProcess) { + mProcess->kill(); + } + mProcess = 0; + mError = GpgME::Error::fromCode(GPG_ERR_CANCELED, GPG_ERR_SOURCE_GPGSM); +} + +void QGpgME::QGpgMESecretKeyExportJob::slotStdout() +{ + QString line = QString::fromLocal8Bit(mProcess->readLine()); + if (!line.isEmpty()) { + return; + } + const unsigned int oldlen = mKeyData.size(); + mKeyData.resize(oldlen + line.length()); + memcpy(mKeyData.data() + oldlen, line.toLatin1(), line.length()); +} + +void QGpgME::QGpgMESecretKeyExportJob::slotStderr() +{ + // implement? or not? +} + +void QGpgME::QGpgMESecretKeyExportJob::slotProcessExited(int exitCode, QProcess::ExitStatus exitStatus) +{ + Q_EMIT done(); + if (!mError && + (exitStatus != QProcess::NormalExit || exitCode != 0)) { + mError = GpgME::Error::fromCode(GPG_ERR_GENERAL, GPG_ERR_SOURCE_GPGSM); + } + Q_EMIT result(mError, mKeyData); + deleteLater(); +} +#include "qgpgmesecretkeyexportjob.moc" diff --git a/lang/qt/src/qgpgmesecretkeyexportjob.h b/lang/qt/src/qgpgmesecretkeyexportjob.h new file mode 100644 index 00000000..ad53f99d --- /dev/null +++ b/lang/qt/src/qgpgmesecretkeyexportjob.h @@ -0,0 +1,81 @@ +/* + qgpgmesecretkeyexportjob.h + + This file is part of qgpgme, the Qt API binding for gpgme + Copyright (c) 2004 Klarälvdalens Datakonsult AB + Copyright (c) 2016 Intevation GmbH + + QGpgME 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. + + QGpgME 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 this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + + In addition, as a special exception, the copyright holders give + permission to link the code of this program with any edition of + the Qt library by Trolltech AS, Norway (or with modified versions + of Qt that use the same license as Qt), and distribute linked + combinations including the two. You must obey the GNU General + Public License in all respects for all of the code used other than + Qt. If you modify this file, you may extend this exception to + your version of the file, but you are not obligated to do so. If + you do not wish to do so, delete this exception statement from + your version. +*/ + +#ifndef __QGPGME_QGPGMESECRETKEYEXPORTJOB_H__ +#define __QGPGME_QGPGMESECRETKEYEXPORTJOB_H__ + +#include "exportjob.h" +#ifdef BUILDING_QGPGME +# include "context.h" +#else +#include "gpgme++/context.h" +#endif +#include <QProcess> + +namespace GpgME +{ +class Data; +} + +namespace QGpgME +{ + +class QGpgMESecretKeyExportJob : public ExportJob +{ + Q_OBJECT +public: + QGpgMESecretKeyExportJob(bool armour, const QString &charset); + ~QGpgMESecretKeyExportJob(); + + /* from ExportJob */ + GpgME::Error start(const QStringList &patterns) Q_DECL_OVERRIDE; + +private Q_SLOTS: + /* from Job */ + void slotCancel() Q_DECL_OVERRIDE; + + void slotStdout(); + void slotStderr(); + void slotProcessExited(int exitCode, QProcess::ExitStatus exitStatus); + +private: + QProcess *mProcess; + QByteArray mKeyData; + GpgME::Error mError; + bool mArmour; + QString mCharset; +}; + +} + +#endif // __QGPGME_QGPGMESECRETKEYEXPORTJOB_H__ diff --git a/lang/qt/src/qgpgmesignencryptjob.cpp b/lang/qt/src/qgpgmesignencryptjob.cpp new file mode 100644 index 00000000..d19ab0fc --- /dev/null +++ b/lang/qt/src/qgpgmesignencryptjob.cpp @@ -0,0 +1,159 @@ +/* + qgpgmesignencryptjob.cpp + + This file is part of qgpgme, the Qt API binding for gpgme + Copyright (c) 2004, 2007 Klarälvdalens Datakonsult AB + Copyright (c) 2016 Intevation GmbH + + QGpgME 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. + + QGpgME 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 this program; if not, write to the Free Software Foundation, Inc., + 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + + In addition, as a special exception, the copyright holders give + permission to link the code of this program with any edition of + the Qt library by Trolltech AS, Norway (or with modified versions + of Qt that use the same license as Qt), and distribute linked + combinations including the two. You must obey the GNU General + Public License in all respects for all of the code used other than + Qt. If you modify this file, you may extend this exception to + your version of the file, but you are not obligated to do so. If + you do not wish to do so, delete this exception statement from + your version. +*/ + +#include "qgpgmesignencryptjob.h" + +#include "dataprovider.h" + +#include "context.h" +#include "data.h" +#include "key.h" +#include "exception.h" + +#include <QBuffer> + + +#include <cassert> + +using namespace QGpgME; +using namespace GpgME; + +QGpgMESignEncryptJob::QGpgMESignEncryptJob(Context *context) + : mixin_type(context), + mOutputIsBase64Encoded(false) +{ + lateInitialization(); +} + +QGpgMESignEncryptJob::~QGpgMESignEncryptJob() {} + +void QGpgMESignEncryptJob::setOutputIsBase64Encoded(bool on) +{ + mOutputIsBase64Encoded = on; +} + +static QGpgMESignEncryptJob::result_type sign_encrypt(Context *ctx, QThread *thread, const std::vector<Key> &signers, const std::vector<Key> &recipients, const std::weak_ptr<QIODevice> &plainText_, const std::weak_ptr<QIODevice> &cipherText_, bool alwaysTrust, bool outputIsBsse64Encoded) +{ + const std::shared_ptr<QIODevice> &plainText = plainText_.lock(); + const std::shared_ptr<QIODevice> &cipherText = cipherText_.lock(); + + const _detail::ToThreadMover ctMover(cipherText, thread); + const _detail::ToThreadMover ptMover(plainText, thread); + + QGpgME::QIODeviceDataProvider in(plainText); + const Data indata(&in); + + const Context::EncryptionFlags eflags = + alwaysTrust ? Context::AlwaysTrust : Context::None; + + ctx->clearSigningKeys(); + Q_FOREACH (const Key &signer, signers) + if (!signer.isNull()) + if (const Error err = ctx->addSigningKey(signer)) { + return std::make_tuple(SigningResult(err), EncryptionResult(), QByteArray(), QString(), Error()); + } + + if (!cipherText) { + QGpgME::QByteArrayDataProvider out; + Data outdata(&out); + + if (outputIsBsse64Encoded) { + outdata.setEncoding(Data::Base64Encoding); + } + + const std::pair<SigningResult, EncryptionResult> res = ctx->signAndEncrypt(recipients, indata, outdata, eflags); + Error ae; + const QString log = _detail::audit_log_as_html(ctx, ae); + return std::make_tuple(res.first, res.second, out.data(), log, ae); + } else { + QGpgME::QIODeviceDataProvider out(cipherText); + Data outdata(&out); + + if (outputIsBsse64Encoded) { + outdata.setEncoding(Data::Base64Encoding); + } + + const std::pair<SigningResult, EncryptionResult> res = ctx->signAndEncrypt(recipients, indata, outdata, eflags); + Error ae; + const QString log = _detail::audit_log_as_html(ctx, ae); + return std::make_tuple(res.first, res.second, QByteArray(), log, ae); + } + +} + +static QGpgMESignEncryptJob::result_type sign_encrypt_qba(Context *ctx, const std::vector<Key> &signers, const std::vector<Key> &recipients, const QByteArray &plainText, bool alwaysTrust, bool outputIsBsse64Encoded) +{ + const std::shared_ptr<QBuffer> buffer(new QBuffer); + buffer->setData(plainText); + if (!buffer->open(QIODevice::ReadOnly)) { + assert(!"This should never happen: QBuffer::open() failed"); + } + return sign_encrypt(ctx, 0, signers, recipients, buffer, std::shared_ptr<QIODevice>(), alwaysTrust, outputIsBsse64Encoded); +} + +Error QGpgMESignEncryptJob::start(const std::vector<Key> &signers, const std::vector<Key> &recipients, const QByteArray &plainText, bool alwaysTrust) +{ + run(std::bind(&sign_encrypt_qba, std::placeholders::_1, signers, recipients, plainText, alwaysTrust, mOutputIsBase64Encoded)); + return Error(); +} + +void QGpgMESignEncryptJob::start(const std::vector<Key> &signers, const std::vector<Key> &recipients, const std::shared_ptr<QIODevice> &plainText, const std::shared_ptr<QIODevice> &cipherText, bool alwaysTrust) +{ + run(std::bind(&sign_encrypt, std::placeholders::_1, std::placeholders::_2, signers, recipients, std::placeholders::_3, std::placeholders::_4, alwaysTrust, mOutputIsBase64Encoded), plainText, cipherText); +} + +std::pair<SigningResult, EncryptionResult> QGpgMESignEncryptJob::exec(const std::vector<Key> &signers, const std::vector<Key> &recipients, const QByteArray &plainText, bool alwaysTrust, QByteArray &cipherText) +{ + const result_type r = sign_encrypt_qba(context(), signers, recipients, plainText, alwaysTrust, mOutputIsBase64Encoded); + cipherText = std::get<2>(r); + resultHook(r); + return mResult; +} + +#if 0 + +TODO port? +void QGpgMESignEncryptJob::showErrorDialog(QWidget *parent, const QString &caption) const +{ + if ((mResult.first.error() && !mResult.first.error().isCanceled()) || + (mResult.second.error() && !mResult.second.error().isCanceled())) { + MessageBox::error(parent, mResult.first, mResult.second, this, caption); + } +} +#endif + +void QGpgMESignEncryptJob::resultHook(const result_type &tuple) +{ + mResult = std::make_pair(std::get<0>(tuple), std::get<1>(tuple)); +} +#include "qgpgmesignencryptjob.moc" diff --git a/lang/qt/src/qgpgmesignencryptjob.h b/lang/qt/src/qgpgmesignencryptjob.h new file mode 100644 index 00000000..49177d37 --- /dev/null +++ b/lang/qt/src/qgpgmesignencryptjob.h @@ -0,0 +1,109 @@ +/* + qgpgmesignencryptjob.h + + This file is part of qgpgme, the Qt API binding for gpgme + Copyright (c) 2004,2007,2008 Klarälvdalens Datakonsult AB + Copyright (c) 2016 Intevation GmbH + + QGpgME 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. + + QGpgME 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 this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + + In addition, as a special exception, the copyright holders give + permission to link the code of this program with any edition of + the Qt library by Trolltech AS, Norway (or with modified versions + of Qt that use the same license as Qt), and distribute linked + combinations including the two. You must obey the GNU General + Public License in all respects for all of the code used other than + Qt. If you modify this file, you may extend this exception to + your version of the file, but you are not obligated to do so. If + you do not wish to do so, delete this exception statement from + your version. +*/ + +#ifndef __QGPGME_QGPGMESIGNENCRYPTJOB_H__ +#define __QGPGME_QGPGMESIGNENCRYPTJOB_H__ + +#include "signencryptjob.h" + +#include "threadedjobmixin.h" + +#ifdef BUILDING_QGPGME +# include "signingresult.h" +#else +#include <gpgme++/signingresult.h> +#endif +#ifdef BUILDING_QGPGME +# include "encryptionresult.h" +#else +#include <gpgme++/encryptionresult.h> +#endif +#ifdef BUILDING_QGPGME +# include "key.h" +#else +#include <gpgme++/key.h> +#endif + +#include <utility> + +namespace QGpgME +{ + +class QGpgMESignEncryptJob +#ifdef Q_MOC_RUN + : public SignEncryptJob +#else + : public _detail::ThreadedJobMixin<SignEncryptJob, std::tuple<GpgME::SigningResult, GpgME::EncryptionResult, QByteArray, QString, GpgME::Error> > +#endif +{ + Q_OBJECT +#ifdef Q_MOC_RUN +public Q_SLOTS: + void slotFinished(); +#endif +public: + explicit QGpgMESignEncryptJob(GpgME::Context *context); + ~QGpgMESignEncryptJob(); + + /* from SignEncryptJob */ + GpgME::Error start(const std::vector<GpgME::Key> &signers, + const std::vector<GpgME::Key> &recipients, + const QByteArray &plainText, bool alwaysTrust) Q_DECL_OVERRIDE; + + /* from SignEncryptJob */ + void start(const std::vector<GpgME::Key> &signers, + const std::vector<GpgME::Key> &recipients, + const std::shared_ptr<QIODevice> &plainText, + const std::shared_ptr<QIODevice> &cipherText, + bool alwaysTrust) Q_DECL_OVERRIDE; + + std::pair<GpgME::SigningResult, GpgME::EncryptionResult> + exec(const std::vector<GpgME::Key> &signers, + const std::vector<GpgME::Key> &recipients, + const QByteArray &plainText, bool alwaysTrust, + QByteArray &cipherText) Q_DECL_OVERRIDE; + + /* from SignEncryptJob */ + void setOutputIsBase64Encoded(bool on) Q_DECL_OVERRIDE; + + /* from ThreadedJobMixin */ + void resultHook(const result_type &r) Q_DECL_OVERRIDE; + +private: + bool mOutputIsBase64Encoded; + std::pair<GpgME::SigningResult, GpgME::EncryptionResult> mResult; +}; + +} + +#endif // __QGPGME_QGPGMESIGNENCRYPTJOB_H__ diff --git a/lang/qt/src/qgpgmesignjob.cpp b/lang/qt/src/qgpgmesignjob.cpp new file mode 100644 index 00000000..4e2312b3 --- /dev/null +++ b/lang/qt/src/qgpgmesignjob.cpp @@ -0,0 +1,163 @@ +/* + qgpgmesignjob.cpp + + This file is part of qgpgme, the Qt API binding for gpgme + Copyright (c) 2004,2007,2008 Klarälvdalens Datakonsult AB + Copyright (c) 2016 Intevation GmbH + + QGpgME 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. + + QGpgME 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 this program; if not, write to the Free Software Foundation, Inc., + 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + + In addition, as a special exception, the copyright holders give + permission to link the code of this program with any edition of + the Qt library by Trolltech AS, Norway (or with modified versions + of Qt that use the same license as Qt), and distribute linked + combinations including the two. You must obey the GNU General + Public License in all respects for all of the code used other than + Qt. If you modify this file, you may extend this exception to + your version of the file, but you are not obligated to do so. If + you do not wish to do so, delete this exception statement from + your version. +*/ + +#include "qgpgmesignjob.h" + +#include "dataprovider.h" + +#include "context.h" +#include "signingresult.h" +#include "data.h" + +#include <QBuffer> + + +#include <cassert> + +using namespace QGpgME; +using namespace GpgME; + +QGpgMESignJob::QGpgMESignJob(Context *context) + : mixin_type(context), + mOutputIsBase64Encoded(false) +{ + lateInitialization(); +} + +QGpgMESignJob::~QGpgMESignJob() {} + +void QGpgMESignJob::setOutputIsBase64Encoded(bool on) +{ + mOutputIsBase64Encoded = on; +} + +static QGpgMESignJob::result_type sign(Context *ctx, QThread *thread, + const std::vector<Key> &signers, + const std::weak_ptr<QIODevice> &plainText_, + const std::weak_ptr<QIODevice> &signature_, + SignatureMode mode, + bool outputIsBsse64Encoded) +{ + + const std::shared_ptr<QIODevice> plainText = plainText_.lock(); + const std::shared_ptr<QIODevice> signature = signature_.lock(); + + const _detail::ToThreadMover ptMover(plainText, thread); + const _detail::ToThreadMover sgMover(signature, thread); + + QGpgME::QIODeviceDataProvider in(plainText); + const Data indata(&in); + + ctx->clearSigningKeys(); + Q_FOREACH (const Key &signer, signers) + if (!signer.isNull()) + if (const Error err = ctx->addSigningKey(signer)) { + return std::make_tuple(SigningResult(err), QByteArray(), QString(), Error()); + } + + if (!signature) { + QGpgME::QByteArrayDataProvider out; + Data outdata(&out); + + if (outputIsBsse64Encoded) { + outdata.setEncoding(Data::Base64Encoding); + } + + const SigningResult res = ctx->sign(indata, outdata, mode); + Error ae; + const QString log = _detail::audit_log_as_html(ctx, ae); + return std::make_tuple(res, out.data(), log, ae); + } else { + QGpgME::QIODeviceDataProvider out(signature); + Data outdata(&out); + + if (outputIsBsse64Encoded) { + outdata.setEncoding(Data::Base64Encoding); + } + + const SigningResult res = ctx->sign(indata, outdata, mode); + Error ae; + const QString log = _detail::audit_log_as_html(ctx, ae); + return std::make_tuple(res, QByteArray(), log, ae); + } + +} + +static QGpgMESignJob::result_type sign_qba(Context *ctx, + const std::vector<Key> &signers, + const QByteArray &plainText, + SignatureMode mode, + bool outputIsBsse64Encoded) +{ + const std::shared_ptr<QBuffer> buffer(new QBuffer); + buffer->setData(plainText); + if (!buffer->open(QIODevice::ReadOnly)) { + assert(!"This should never happen: QBuffer::open() failed"); + } + return sign(ctx, 0, signers, buffer, std::shared_ptr<QIODevice>(), mode, outputIsBsse64Encoded); +} + +Error QGpgMESignJob::start(const std::vector<Key> &signers, const QByteArray &plainText, SignatureMode mode) +{ + run(std::bind(&sign_qba, std::placeholders::_1, signers, plainText, mode, mOutputIsBase64Encoded)); + return Error(); +} + +void QGpgMESignJob::start(const std::vector<Key> &signers, const std::shared_ptr<QIODevice> &plainText, const std::shared_ptr<QIODevice> &signature, SignatureMode mode) +{ + run(std::bind(&sign, std::placeholders::_1, std::placeholders::_2, signers, std::placeholders::_3, std::placeholders::_4, mode, mOutputIsBase64Encoded), plainText, signature); +} + +SigningResult QGpgMESignJob::exec(const std::vector<Key> &signers, const QByteArray &plainText, SignatureMode mode, QByteArray &signature) +{ + const result_type r = sign_qba(context(), signers, plainText, mode, mOutputIsBase64Encoded); + signature = std::get<1>(r); + resultHook(r); + return mResult; +} + +void QGpgMESignJob::resultHook(const result_type &tuple) +{ + mResult = std::get<0>(tuple); +} + +#if 0 +TODO port +void QGpgMESignJob::showErrorDialog(QWidget *parent, const QString &caption) const +{ + if (mResult.error() && !mResult.error().isCanceled()) { + MessageBox::error(parent, mResult, this, caption); + } +} +#endif +#include "qgpgmesignjob.moc" diff --git a/lang/qt/src/qgpgmesignjob.h b/lang/qt/src/qgpgmesignjob.h new file mode 100644 index 00000000..1d4a1747 --- /dev/null +++ b/lang/qt/src/qgpgmesignjob.h @@ -0,0 +1,101 @@ +/* + qgpgmesignjob.h + + This file is part of qgpgme, the Qt API binding for gpgme + Copyright (c) 2004,2007,2008 Klarälvdalens Datakonsult AB + Copyright (c) 2016 Intevation GmbH + + QGpgME 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. + + QGpgME 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 this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + + In addition, as a special exception, the copyright holders give + permission to link the code of this program with any edition of + the Qt library by Trolltech AS, Norway (or with modified versions + of Qt that use the same license as Qt), and distribute linked + combinations including the two. You must obey the GNU General + Public License in all respects for all of the code used other than + Qt. If you modify this file, you may extend this exception to + your version of the file, but you are not obligated to do so. If + you do not wish to do so, delete this exception statement from + your version. +*/ + +#ifndef __QGPGME_QGPGMESIGNJOB_H__ +#define __QGPGME_QGPGMESIGNJOB_H__ + +#include "signjob.h" + +#include "threadedjobmixin.h" + +#ifdef BUILDING_QGPGME +# include "signingresult.h" +#else +#include <gpgme++/signingresult.h> +#endif +#ifdef BUILDING_QGPGME +# include "key.h" +#else +#include <gpgme++/key.h> +#endif + +namespace QGpgME +{ + +class QGpgMESignJob +#ifdef Q_MOC_RUN + : public SignJob +#else + : public _detail::ThreadedJobMixin<SignJob, std::tuple<GpgME::SigningResult, QByteArray, QString, GpgME::Error> > +#endif +{ + Q_OBJECT +#ifdef Q_MOC_RUN +public Q_SLOTS: + void slotFinished(); +#endif +public: + explicit QGpgMESignJob(GpgME::Context *context); + ~QGpgMESignJob(); + + /* from SignJob */ + GpgME::Error start(const std::vector<GpgME::Key> &signers, + const QByteArray &plainText, + GpgME::SignatureMode mode) Q_DECL_OVERRIDE; + + /* from SignJob */ + void start(const std::vector<GpgME::Key> &signers, + const std::shared_ptr<QIODevice> &plainText, + const std::shared_ptr<QIODevice> &signature, + GpgME::SignatureMode mode) Q_DECL_OVERRIDE; + + /* from SignJob */ + GpgME::SigningResult exec(const std::vector<GpgME::Key> &signers, + const QByteArray &plainText, + GpgME::SignatureMode mode, + QByteArray &signature) Q_DECL_OVERRIDE; + + /* from SignJob */ + void setOutputIsBase64Encoded(bool on) Q_DECL_OVERRIDE; + + /* from ThreadedJobMixin */ + void resultHook(const result_type &r) Q_DECL_OVERRIDE; + +private: + GpgME::SigningResult mResult; + bool mOutputIsBase64Encoded; +}; + +} + +#endif // __QGPGME_QGPGMESIGNJOB_H__ diff --git a/lang/qt/src/qgpgmesignkeyjob.cpp b/lang/qt/src/qgpgmesignkeyjob.cpp new file mode 100644 index 00000000..9a12f613 --- /dev/null +++ b/lang/qt/src/qgpgmesignkeyjob.cpp @@ -0,0 +1,127 @@ +/* + qgpgmesignkeyjob.cpp + + This file is part of qgpgme, the Qt API binding for gpgme + Copyright (c) 2008 Klarälvdalens Datakonsult AB + Copyright (c) 2016 Intevation GmbH + + QGpgME 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. + + QGpgME 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 this program; if not, write to the Free Software Foundation, Inc., + 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + + In addition, as a special exception, the copyright holders give + permission to link the code of this program with any edition of + the Qt library by Trolltech AS, Norway (or with modified versions + of Qt that use the same license as Qt), and distribute linked + combinations including the two. You must obey the GNU General + Public License in all respects for all of the code used other than + Qt. If you modify this file, you may extend this exception to + your version of the file, but you are not obligated to do so. If + you do not wish to do so, delete this exception statement from + your version. +*/ + +#include "qgpgmesignkeyjob.h" + +#include "dataprovider.h" + +#include "context.h" +#include "data.h" +#include "gpgsignkeyeditinteractor.h" + +#include <cassert> +#include <memory> + +using namespace QGpgME; +using namespace GpgME; + +QGpgMESignKeyJob::QGpgMESignKeyJob(Context *context) + : mixin_type(context), + m_userIDsToSign(), + m_signingKey(), + m_checkLevel(0), + m_exportable(false), + m_nonRevocable(false), + m_started(false) +{ + lateInitialization(); +} + +QGpgMESignKeyJob::~QGpgMESignKeyJob() {} + +static QGpgMESignKeyJob::result_type sign_key(Context *ctx, const Key &key, const std::vector<unsigned int> &uids, unsigned int checkLevel, const Key &signer, unsigned int opts) +{ + QGpgME::QByteArrayDataProvider dp; + Data data(&dp); + + std::auto_ptr<GpgSignKeyEditInteractor> skei(new GpgSignKeyEditInteractor); + skei->setUserIDsToSign(uids); + skei->setCheckLevel(checkLevel); + skei->setSigningOptions(opts); + + std::auto_ptr<EditInteractor> ei(skei); + + if (!signer.isNull()) + if (const Error err = ctx->addSigningKey(signer)) { + return std::make_tuple(err, QString(), Error()); + } + const Error err = ctx->edit(key, ei, data); + Error ae; + const QString log = _detail::audit_log_as_html(ctx, ae); + return std::make_tuple(err, log, ae); +} + +Error QGpgMESignKeyJob::start(const Key &key) +{ + unsigned int opts = 0; + if (m_nonRevocable) { + opts |= GpgSignKeyEditInteractor::NonRevocable; + } + if (m_exportable) { + opts |= GpgSignKeyEditInteractor::Exportable; + } + run(std::bind(&sign_key, std::placeholders::_1, key, m_userIDsToSign, m_checkLevel, m_signingKey, opts)); + m_started = true; + return Error(); +} + +void QGpgMESignKeyJob::setUserIDsToSign(const std::vector<unsigned int> &idsToSign) +{ + assert(!m_started); + m_userIDsToSign = idsToSign; +} + +void QGpgMESignKeyJob::setCheckLevel(unsigned int checkLevel) +{ + assert(!m_started); + m_checkLevel = checkLevel; +} + +void QGpgMESignKeyJob::setExportable(bool exportable) +{ + assert(!m_started); + m_exportable = exportable; +} + +void QGpgMESignKeyJob::setSigningKey(const Key &key) +{ + assert(!m_started); + m_signingKey = key; +} + +void QGpgMESignKeyJob::setNonRevocable(bool nonRevocable) +{ + assert(!m_started); + m_nonRevocable = nonRevocable; +} +#include "qgpgmesignkeyjob.moc" diff --git a/lang/qt/src/qgpgmesignkeyjob.h b/lang/qt/src/qgpgmesignkeyjob.h new file mode 100644 index 00000000..6cdb7db8 --- /dev/null +++ b/lang/qt/src/qgpgmesignkeyjob.h @@ -0,0 +1,94 @@ +/* + qgpgmesignkeyjob.h + + This file is part of qgpgme, the Qt API binding for gpgme + Copyright (c) 2008 Klarälvdalens Datakonsult AB + Copyright (c) 2016 Intevation GmbH + + QGpgME 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. + + QGpgME 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 this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + + In addition, as a special exception, the copyright holders give + permission to link the code of this program with any edition of + the Qt library by Trolltech AS, Norway (or with modified versions + of Qt that use the same license as Qt), and distribute linked + combinations including the two. You must obey the GNU General + Public License in all respects for all of the code used other than + Qt. If you modify this file, you may extend this exception to + your version of the file, but you are not obligated to do so. If + you do not wish to do so, delete this exception statement from + your version. +*/ + +#ifndef __QGPGME_QGPGMESIGNKEYJOB_H__ +#define __QGPGME_QGPGMESIGNKEYJOB_H__ + +#include "signkeyjob.h" + +#include "threadedjobmixin.h" + +#ifdef BUILDING_QGPGME +# include "key.h" +#else +#include <gpgme++/key.h> +#endif + +namespace QGpgME +{ + +class QGpgMESignKeyJob +#ifdef Q_MOC_RUN + : public SignKeyJob +#else + : public _detail::ThreadedJobMixin<SignKeyJob> +#endif +{ + Q_OBJECT +#ifdef Q_MOC_RUN +public Q_SLOTS: + void slotFinished(); +#endif +public: + explicit QGpgMESignKeyJob(GpgME::Context *context); + ~QGpgMESignKeyJob(); + + /* from SignKeyJob */ + GpgME::Error start(const GpgME::Key &key) Q_DECL_OVERRIDE; + + /* from SignKeyJob */ + void setUserIDsToSign(const std::vector<unsigned int> &idsToSign) Q_DECL_OVERRIDE; + + /* from SignKeyJob */ + void setCheckLevel(unsigned int checkLevel) Q_DECL_OVERRIDE; + + /* from SignKeyJob */ + void setExportable(bool exportable) Q_DECL_OVERRIDE; + + /* from SignKeyJob */ + void setSigningKey(const GpgME::Key &key) Q_DECL_OVERRIDE; + + /* from SignKeyJob */ + void setNonRevocable(bool nonRevocable) Q_DECL_OVERRIDE; + +private: + std::vector<unsigned int> m_userIDsToSign; + GpgME::Key m_signingKey; + unsigned int m_checkLevel; + bool m_exportable; + bool m_nonRevocable; + bool m_started; +}; +} + +#endif // __QGPGME_QGPGMESIGNKEYJOB_H__ diff --git a/lang/qt/src/qgpgmeverifydetachedjob.cpp b/lang/qt/src/qgpgmeverifydetachedjob.cpp new file mode 100644 index 00000000..8efef051 --- /dev/null +++ b/lang/qt/src/qgpgmeverifydetachedjob.cpp @@ -0,0 +1,118 @@ +/* + qgpgmeverifydetachedjob.cpp + + This file is part of qgpgme, the Qt API binding for gpgme + Copyright (c) 2004,2007,2008 Klarälvdalens Datakonsult AB + Copyright (c) 2016 Intevation GmbH + + QGpgME 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. + + QGpgME 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 this program; if not, write to the Free Software Foundation, Inc., + 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + + In addition, as a special exception, the copyright holders give + permission to link the code of this program with any edition of + the Qt library by Trolltech AS, Norway (or with modified versions + of Qt that use the same license as Qt), and distribute linked + combinations including the two. You must obey the GNU General + Public License in all respects for all of the code used other than + Qt. If you modify this file, you may extend this exception to + your version of the file, but you are not obligated to do so. If + you do not wish to do so, delete this exception statement from + your version. +*/ + +#include "qgpgmeverifydetachedjob.h" + +#include "dataprovider.h" + +#include "context.h" +#include "verificationresult.h" +#include "data.h" + +#include <cassert> + + +using namespace QGpgME; +using namespace GpgME; + +QGpgMEVerifyDetachedJob::QGpgMEVerifyDetachedJob(Context *context) + : mixin_type(context) +{ + lateInitialization(); +} + +QGpgMEVerifyDetachedJob::~QGpgMEVerifyDetachedJob() {} + +static QGpgMEVerifyDetachedJob::result_type verify_detached(Context *ctx, QThread *thread, const std::weak_ptr<QIODevice> &signature_, const std::weak_ptr<QIODevice> &signedData_) +{ + const std::shared_ptr<QIODevice> signature = signature_.lock(); + const std::shared_ptr<QIODevice> signedData = signedData_.lock(); + + const _detail::ToThreadMover sgMover(signature, thread); + const _detail::ToThreadMover sdMover(signedData, thread); + + QGpgME::QIODeviceDataProvider sigDP(signature); + Data sig(&sigDP); + + QGpgME::QIODeviceDataProvider dataDP(signedData); + Data data(&dataDP); + + const VerificationResult res = ctx->verifyDetachedSignature(sig, data); + Error ae; + const QString log = _detail::audit_log_as_html(ctx, ae); + + return std::make_tuple(res, log, ae); +} + +static QGpgMEVerifyDetachedJob::result_type verify_detached_qba(Context *ctx, const QByteArray &signature, const QByteArray &signedData) +{ + QGpgME::QByteArrayDataProvider sigDP(signature); + Data sig(&sigDP); + + QGpgME::QByteArrayDataProvider dataDP(signedData); + Data data(&dataDP); + + const VerificationResult res = ctx->verifyDetachedSignature(sig, data); + Error ae; + const QString log = _detail::audit_log_as_html(ctx, ae); + + return std::make_tuple(res, log, ae); + +} + +Error QGpgMEVerifyDetachedJob::start(const QByteArray &signature, const QByteArray &signedData) +{ + run(std::bind(&verify_detached_qba, std::placeholders::_1, signature, signedData)); + return Error(); +} + +void QGpgMEVerifyDetachedJob::start(const std::shared_ptr<QIODevice> &signature, const std::shared_ptr<QIODevice> &signedData) +{ + run(std::bind(&verify_detached, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3, std::placeholders::_4), signature, signedData); +} + +GpgME::VerificationResult QGpgME::QGpgMEVerifyDetachedJob::exec(const QByteArray &signature, + const QByteArray &signedData) +{ + const result_type r = verify_detached_qba(context(), signature, signedData); + resultHook(r); + return mResult; +} + +//PENDING(marc) implement showErrorDialog() + +void QGpgME::QGpgMEVerifyDetachedJob::resultHook(const result_type &tuple) +{ + mResult = std::get<0>(tuple); +} +#include "qgpgmeverifydetachedjob.moc" diff --git a/lang/qt/src/qgpgmeverifydetachedjob.h b/lang/qt/src/qgpgmeverifydetachedjob.h new file mode 100644 index 00000000..051caf07 --- /dev/null +++ b/lang/qt/src/qgpgmeverifydetachedjob.h @@ -0,0 +1,85 @@ +/* + qgpgmeverifydetachedjob.h + + This file is part of qgpgme, the Qt API binding for gpgme + Copyright (c) 2004,2007,2008 Klarälvdalens Datakonsult AB + Copyright (c) 2016 Intevation GmbH + + QGpgME 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. + + QGpgME 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 this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + + In addition, as a special exception, the copyright holders give + permission to link the code of this program with any edition of + the Qt library by Trolltech AS, Norway (or with modified versions + of Qt that use the same license as Qt), and distribute linked + combinations including the two. You must obey the GNU General + Public License in all respects for all of the code used other than + Qt. If you modify this file, you may extend this exception to + your version of the file, but you are not obligated to do so. If + you do not wish to do so, delete this exception statement from + your version. +*/ + +#ifndef __QGPGME_QGPGMEVERIFYDETACHEDJOB_H__ +#define __QGPGME_QGPGMEVERIFYDETACHEDJOB_H__ + +#include "verifydetachedjob.h" + +#include "threadedjobmixin.h" + +#ifdef BUILDING_QGPGME +# include "verificationresult.h" +#else +#include <gpgme++/verificationresult.h> +#endif + +namespace QGpgME +{ + +class QGpgMEVerifyDetachedJob +#ifdef Q_MOC_RUN + : public VerifyDetachedJob +#else + : public _detail::ThreadedJobMixin<VerifyDetachedJob, std::tuple<GpgME::VerificationResult, QString, GpgME::Error> > +#endif +{ + Q_OBJECT +#ifdef Q_MOC_RUN +public Q_SLOTS: + void slotFinished(); +#endif +public: + explicit QGpgMEVerifyDetachedJob(GpgME::Context *context); + ~QGpgMEVerifyDetachedJob(); + + /* from VerifyDetachedJob */ + GpgME::Error start(const QByteArray &signature, const QByteArray &signedData) Q_DECL_OVERRIDE; + + /* from VerifyDetachedJob */ + void start(const std::shared_ptr<QIODevice> &signature, const std::shared_ptr<QIODevice> &signedData) Q_DECL_OVERRIDE; + + /* from VerifyDetachedJob */ + GpgME::VerificationResult exec(const QByteArray &signature, + const QByteArray &signedData) Q_DECL_OVERRIDE; + + /* from ThreadedJobMixin */ + void resultHook(const result_type &r) Q_DECL_OVERRIDE; + +private: + GpgME::VerificationResult mResult; +}; + +} + +#endif // __QGPGME_QGPGMEVERIFYDETACHEDJOB_H__ diff --git a/lang/qt/src/qgpgmeverifyopaquejob.cpp b/lang/qt/src/qgpgmeverifyopaquejob.cpp new file mode 100644 index 00000000..b513f82a --- /dev/null +++ b/lang/qt/src/qgpgmeverifyopaquejob.cpp @@ -0,0 +1,125 @@ +/* + qgpgmeverifyopaquejob.cpp + + This file is part of qgpgme, the Qt API binding for gpgme + Copyright (c) 2004,2007,2008 Klarälvdalens Datakonsult AB + Copyright (c) 2016 Intevation GmbH + + QGpgME 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. + + QGpgME 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 this program; if not, write to the Free Software Foundation, Inc., + 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + + In addition, as a special exception, the copyright holders give + permission to link the code of this program with any edition of + the Qt library by Trolltech AS, Norway (or with modified versions + of Qt that use the same license as Qt), and distribute linked + combinations including the two. You must obey the GNU General + Public License in all respects for all of the code used other than + Qt. If you modify this file, you may extend this exception to + your version of the file, but you are not obligated to do so. If + you do not wish to do so, delete this exception statement from + your version. +*/ + +#include "qgpgmeverifyopaquejob.h" + +#include "dataprovider.h" + +#include "context.h" +#include "verificationresult.h" +#include "data.h" + +#include <QBuffer> + + +#include <cassert> + +using namespace QGpgME; +using namespace GpgME; + +QGpgMEVerifyOpaqueJob::QGpgMEVerifyOpaqueJob(Context *context) + : mixin_type(context) +{ + lateInitialization(); +} + +QGpgMEVerifyOpaqueJob::~QGpgMEVerifyOpaqueJob() {} + +static QGpgMEVerifyOpaqueJob::result_type verify_opaque(Context *ctx, QThread *thread, const std::weak_ptr<QIODevice> &signedData_, const std::weak_ptr<QIODevice> &plainText_) +{ + + const std::shared_ptr<QIODevice> plainText = plainText_.lock(); + const std::shared_ptr<QIODevice> signedData = signedData_.lock(); + + const _detail::ToThreadMover ptMover(plainText, thread); + const _detail::ToThreadMover sdMover(signedData, thread); + + QGpgME::QIODeviceDataProvider in(signedData); + const Data indata(&in); + + if (!plainText) { + QGpgME::QByteArrayDataProvider out; + Data outdata(&out); + + const VerificationResult res = ctx->verifyOpaqueSignature(indata, outdata); + Error ae; + const QString log = _detail::audit_log_as_html(ctx, ae); + return std::make_tuple(res, out.data(), log, ae); + } else { + QGpgME::QIODeviceDataProvider out(plainText); + Data outdata(&out); + + const VerificationResult res = ctx->verifyOpaqueSignature(indata, outdata); + Error ae; + const QString log = _detail::audit_log_as_html(ctx, ae); + return std::make_tuple(res, QByteArray(), log, ae); + } + +} + +static QGpgMEVerifyOpaqueJob::result_type verify_opaque_qba(Context *ctx, const QByteArray &signedData) +{ + const std::shared_ptr<QBuffer> buffer(new QBuffer); + buffer->setData(signedData); + if (!buffer->open(QIODevice::ReadOnly)) { + assert(!"This should never happen: QBuffer::open() failed"); + } + return verify_opaque(ctx, 0, buffer, std::shared_ptr<QIODevice>()); +} + +Error QGpgMEVerifyOpaqueJob::start(const QByteArray &signedData) +{ + run(std::bind(&verify_opaque_qba, std::placeholders::_1, signedData)); + return Error(); +} + +void QGpgMEVerifyOpaqueJob::start(const std::shared_ptr<QIODevice> &signedData, const std::shared_ptr<QIODevice> &plainText) +{ + run(std::bind(&verify_opaque, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3, std::placeholders::_4), signedData, plainText); +} + +GpgME::VerificationResult QGpgME::QGpgMEVerifyOpaqueJob::exec(const QByteArray &signedData, QByteArray &plainText) +{ + const result_type r = verify_opaque_qba(context(), signedData); + plainText = std::get<1>(r); + resultHook(r); + return mResult; +} + +//PENDING(marc) implement showErrorDialog() + +void QGpgME::QGpgMEVerifyOpaqueJob::resultHook(const result_type &tuple) +{ + mResult = std::get<0>(tuple); +} +#include "qgpgmeverifyopaquejob.moc" diff --git a/lang/qt/src/qgpgmeverifyopaquejob.h b/lang/qt/src/qgpgmeverifyopaquejob.h new file mode 100644 index 00000000..87c94a33 --- /dev/null +++ b/lang/qt/src/qgpgmeverifyopaquejob.h @@ -0,0 +1,84 @@ +/* + qgpgmeverifyopaquejob.h + + This file is part of qgpgme, the Qt API binding for gpgme + Copyright (c) 2004,2007,2008 Klarälvdalens Datakonsult AB + Copyright (c) 2016 Intevation GmbH + + QGpgME 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. + + QGpgME 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 this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + + In addition, as a special exception, the copyright holders give + permission to link the code of this program with any edition of + the Qt library by Trolltech AS, Norway (or with modified versions + of Qt that use the same license as Qt), and distribute linked + combinations including the two. You must obey the GNU General + Public License in all respects for all of the code used other than + Qt. If you modify this file, you may extend this exception to + your version of the file, but you are not obligated to do so. If + you do not wish to do so, delete this exception statement from + your version. +*/ + +#ifndef __QGPGME_QGPGMEVERIFYOPAQUEJOB_H__ +#define __QGPGME_QGPGMEVERIFYOPAQUEJOB_H__ + +#include "verifyopaquejob.h" + +#include "threadedjobmixin.h" + +#ifdef BUILDING_QGPGME +# include "verificationresult.h" +#else +#include <gpgme++/verificationresult.h> +#endif + +namespace QGpgME +{ + +class QGpgMEVerifyOpaqueJob +#ifdef Q_MOC_RUN + : public VerifyOpaqueJob +#else + : public _detail::ThreadedJobMixin<VerifyOpaqueJob, std::tuple<GpgME::VerificationResult, QByteArray, QString, GpgME::Error> > +#endif +{ + Q_OBJECT +#ifdef Q_MOC_RUN +public Q_SLOTS: + void slotFinished(); +#endif +public: + explicit QGpgMEVerifyOpaqueJob(GpgME::Context *context); + ~QGpgMEVerifyOpaqueJob(); + + /* from VerifyOpaqueJob */ + GpgME::Error start(const QByteArray &signedData) Q_DECL_OVERRIDE; + + /* from VerifyOpaqueJob */ + void start(const std::shared_ptr<QIODevice> &signedData, const std::shared_ptr<QIODevice> &plainText) Q_DECL_OVERRIDE; + + /* form VerifyOpaqueJob */ + GpgME::VerificationResult exec(const QByteArray &signedData, QByteArray &plainData) Q_DECL_OVERRIDE; + + /* from ThreadedJobMixin */ + void resultHook(const result_type &r) Q_DECL_OVERRIDE; + +private: + GpgME::VerificationResult mResult; +}; + +} + +#endif // __QGPGME_QGPGMEVERIFYOPAQUEJOB_H__ diff --git a/lang/qt/src/refreshkeysjob.h b/lang/qt/src/refreshkeysjob.h new file mode 100644 index 00000000..d0bc51f4 --- /dev/null +++ b/lang/qt/src/refreshkeysjob.h @@ -0,0 +1,93 @@ +/* + refreshkeysjob.h + + This file is part of qgpgme, the Qt API binding for gpgme + Copyright (c) 2004 Klarälvdalens Datakonsult AB + Copyright (c) 2016 Intevation GmbH + + QGpgME 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. + + QGpgME 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 this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + + In addition, as a special exception, the copyright holders give + permission to link the code of this program with any edition of + the Qt library by Trolltech AS, Norway (or with modified versions + of Qt that use the same license as Qt), and distribute linked + combinations including the two. You must obey the GNU General + Public License in all respects for all of the code used other than + Qt. If you modify this file, you may extend this exception to + your version of the file, but you are not obligated to do so. If + you do not wish to do so, delete this exception statement from + your version. +*/ + +#ifndef __KLEO_REFRESHKEYSJOB_H__ +#define __KLEO_REFRESHKEYSJOB_H__ + +#include "job.h" + +#include <vector> + +namespace GpgME +{ +class Error; +class Key; +} + +class QStringList; + +namespace QGpgME +{ + +/** + @short An abstract base class for asynchronous key refreshers. + + To use a RefreshKeysJob, first obtain an instance from the + CryptoBackend implementation, connect the progress() and result() + signals to suitable slots and then start the key refresh with a + call to start(). This call might fail, in which case the + RefreshKeysJob instance will have scheduled its own destruction + with a call to QObject::deleteLater(). + + After result() is emitted, the KeyListJob will schedule it's own + destruction by calling QObject::deleteLater(). +*/ +class RefreshKeysJob : public Job +{ + Q_OBJECT +protected: + explicit RefreshKeysJob(QObject *parent); +public: + ~RefreshKeysJob(); + + /** + Starts the keylist operation. \a pattern is a list of patterns + used to restrict the list of keys returned. Empty patterns are + ignored. If \a pattern is empty or contains only empty strings, + all keys are returned (however, the backend is free to truncate + the result and should do so; when this happens, it will be + reported by the reult object). + + If \a secretOnly is true, only keys for which the secret key is + also available are returned. Use this if you need to select a + key for signing. + */ + virtual GpgME::Error start(const QStringList &patterns) = 0; + +Q_SIGNALS: + void result(const GpgME::Error &error); +}; + +} + +#endif // __KLEO_REFRESHKEYSJOB_H__ diff --git a/lang/qt/src/signencryptjob.h b/lang/qt/src/signencryptjob.h new file mode 100644 index 00000000..4818d2af --- /dev/null +++ b/lang/qt/src/signencryptjob.h @@ -0,0 +1,135 @@ +/* + signencryptjob.h + + This file is part of qgpgme, the Qt API binding for gpgme + Copyright (c) 2004, 2007 Klarälvdalens Datakonsult AB + Copyright (c) 2016 Intevation GmbH + + QGpgME 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. + + QGpgME 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 this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + + In addition, as a special exception, the copyright holders give + permission to link the code of this program with any edition of + the Qt library by Trolltech AS, Norway (or with modified versions + of Qt that use the same license as Qt), and distribute linked + combinations including the two. You must obey the GNU General + Public License in all respects for all of the code used other than + Qt. If you modify this file, you may extend this exception to + your version of the file, but you are not obligated to do so. If + you do not wish to do so, delete this exception statement from + your version. +*/ + +#ifndef __KLEO_SIGNENCRYPTJOB_H__ +#define __KLEO_SIGNENCRYPTJOB_H__ + +#include "job.h" + +#ifdef BUILDING_QGPGME +# include "global.h" +#else +# include <gpgme++/global.h> +#endif + +#include <memory> +#include <vector> +#include <utility> + +class QByteArray; +class QIODevice; + +namespace GpgME +{ +class Error; +class Key; +class SigningResult; +class EncryptionResult; +} + +namespace QGpgME +{ + +/** + @short An abstract base class for asynchronous combined signing and encrypting + + To use a SignEncryptJob, first obtain an instance from the + CryptoBackend implementation, connect the progress() and result() + signals to suitable slots and then start the operation with a + call to start(). This call might fail, in which case the + SignEncryptJob instance will have scheduled it's own destruction + with a call to QObject::deleteLater(). + + After result() is emitted, the SignEncryptJob will schedule it's + own destruction by calling QObject::deleteLater(). +*/ +class SignEncryptJob : public Job +{ + Q_OBJECT +protected: + explicit SignEncryptJob(QObject *parent); +public: + ~SignEncryptJob(); + + /** + Starts the combined signing and encrypting operation. \a signers + is the list of keys to sign \a plainText with. \a recipients is + a list of keys to encrypt the signed \a plainText to. In both + lists, empty (null) keys are ignored. + + If \a alwaysTrust is true, validity checking for the + \em recipient keys will not be performed, but full validity + assumed for all \em recipient keys without further checks. + */ + virtual QGPGME_DEPRECATED_EXPORT GpgME::Error start(const std::vector<GpgME::Key> &signers, + const std::vector<GpgME::Key> &recipients, + const QByteArray &plainText, + bool alwaysTrust = false) = 0; + + /*! + \overload + + If \a cipherText is non-null, the ciphertext is written + there. Otherwise, it will be delivered in the third argument of + result(). + + \throws GpgME::Exception if starting fails + */ + virtual void start(const std::vector<GpgME::Key> &signers, + const std::vector<GpgME::Key> &recipients, + const std::shared_ptr<QIODevice> &plainText, + const std::shared_ptr<QIODevice> &cipherText = std::shared_ptr<QIODevice>(), + bool alwaysTrust = false) = 0; + + virtual std::pair<GpgME::SigningResult, GpgME::EncryptionResult> + exec(const std::vector<GpgME::Key> &signers, + const std::vector<GpgME::Key> &recipients, + const QByteArray &plainText, + bool alwaysTrust, QByteArray &cipherText) = 0; + + /*! + This is a hack to request BASE64 output (instead of whatever + comes out normally). + */ + virtual void setOutputIsBase64Encoded(bool) = 0; + +Q_SIGNALS: + void result(const GpgME::SigningResult &signingresult, + const GpgME::EncryptionResult &encryptionresult, + const QByteArray &cipherText, const QString &auditLogAsHtml = QString(), + const GpgME::Error &auditLogError = GpgME::Error()); +}; + +} + +#endif // __KLEO_SIGNENCRYPTJOB_H__ diff --git a/lang/qt/src/signjob.h b/lang/qt/src/signjob.h new file mode 100644 index 00000000..cf5c6282 --- /dev/null +++ b/lang/qt/src/signjob.h @@ -0,0 +1,122 @@ +/* + signjob.h + + This file is part of qgpgme, the Qt API binding for gpgme + Copyright (c) 2004, 2007 Klarälvdalens Datakonsult AB + Copyright (c) 2016 Intevation GmbH + + QGpgME 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. + + QGpgME 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 this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + + In addition, as a special exception, the copyright holders give + permission to link the code of this program with any edition of + the Qt library by Trolltech AS, Norway (or with modified versions + of Qt that use the same license as Qt), and distribute linked + combinations including the two. You must obey the GNU General + Public License in all respects for all of the code used other than + Qt. If you modify this file, you may extend this exception to + your version of the file, but you are not obligated to do so. If + you do not wish to do so, delete this exception statement from + your version. +*/ + +#ifndef __KLEO_SIGNJOB_H__ +#define __KLEO_SIGNJOB_H__ + +#include "job.h" + +#ifdef BUILDING_QGPGME +# include "global.h" +#else +# include <gpgme++/global.h> +#endif + + +#include <vector> +#include <memory> + +class QByteArray; +class QIODevice; + +namespace GpgME +{ +class Error; +class Key; +class SigningResult; +} + +namespace QGpgME +{ + +/** + @short An abstract base class for asynchronous signing + + To use a SignJob, first obtain an instance from the CryptoBackend + implementation, connect the progress() and result() signals to + suitable slots and then start the signing with a call to + start(). This call might fail, in which case the SignJob instance + will have scheduled it's own destruction with a call to + QObject::deleteLater(). + + After result() is emitted, the SignJob will schedule it's own + destruction by calling QObject::deleteLater(). +*/ +class QGPGME_EXPORT SignJob : public Job +{ + Q_OBJECT +protected: + explicit SignJob(QObject *parent); +public: + ~SignJob(); + + /** + Starts the signing operation. \a signers is the list of keys to + sign \a plainText with. Empty (null) keys are ignored. + */ + virtual QGPGME_DEPRECATED_EXPORT GpgME::Error start(const std::vector<GpgME::Key> &signers, + const QByteArray &plainText, + GpgME::SignatureMode mode) = 0; + + /*! + \overload + + If \a signature is non-null the signature is written + there. Otherwise, it will be delivered in the second argument of + result(). + + \throws GpgME::Exception if starting fails + */ + virtual void start(const std::vector<GpgME::Key> &signers, + const std::shared_ptr<QIODevice> &plainText, + const std::shared_ptr<QIODevice> &signature, + GpgME::SignatureMode mode) = 0; + + virtual GpgME::SigningResult exec(const std::vector<GpgME::Key> &signers, + const QByteArray &plainText, + GpgME::SignatureMode mode, + QByteArray &signature) = 0; + + /*! + This is a hack to request BASE64 output (instead of whatever + comes out normally). + */ + virtual void setOutputIsBase64Encoded(bool) = 0; + +Q_SIGNALS: + void result(const GpgME::SigningResult &result, const QByteArray &signature, const QString &auditLogAsHtml = QString(), const GpgME::Error &auditLogError = GpgME::Error()); +}; + +} + +#endif // __KLEO_SIGNJOB_H__ diff --git a/lang/qt/src/signkeyjob.h b/lang/qt/src/signkeyjob.h new file mode 100644 index 00000000..b5efc013 --- /dev/null +++ b/lang/qt/src/signkeyjob.h @@ -0,0 +1,117 @@ +/* + signkeyjob.h + + This file is part of qgpgme, the Qt API binding for gpgme + Copyright (c) 2008 Klarälvdalens Datakonsult AB + Copyright (c) 2016 Intevation GmbH + + QGpgME 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. + + QGpgME 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 this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + + In addition, as a special exception, the copyright holders give + permission to link the code of this program with any edition of + the Qt library by Trolltech AS, Norway (or with modified versions + of Qt that use the same license as Qt), and distribute linked + combinations including the two. You must obey the GNU General + Public License in all respects for all of the code used other than + Qt. If you modify this file, you may extend this exception to + your version of the file, but you are not obligated to do so. If + you do not wish to do so, delete this exception statement from + your version. +*/ + +#ifndef __KLEO_SIGNKEYJOB_H__ +#define __KLEO_SIGNKEYJOB_H__ + +#include "job.h" + +#include <vector> + +namespace GpgME +{ +class Error; +class Key; +} + +namespace QGpgME +{ + +/** + @short An abstract base class to sign keys asynchronously + + To use a SignKeyJob, first obtain an instance from the + CryptoBackend implementation, connect the progress() and result() + signals to suitable slots and then start the job with a call + to start(). This call might fail, in which case the ChangeExpiryJob + instance will have scheduled it's own destruction with a call to + QObject::deleteLater(). + + After result() is emitted, the SignKeyJob will schedule it's own + destruction by calling QObject::deleteLater(). +*/ +class QGPGME_EXPORT SignKeyJob : public Job +{ + Q_OBJECT +protected: + explicit SignKeyJob(QObject *parent); +public: + ~SignKeyJob(); + + /** + Starts the key signing operation. \a key is the key to sign. + @param keyToSign the key to be signed + @param idsToSign the user IDs to sign + @param signingKey the secret key to use for signing + @param option the signing mode, either local or exportable + */ + virtual GpgME::Error start(const GpgME::Key &keyToSign) = 0; + + /** + * If explicitly specified, only the listed user IDs will be signed. Otherwise all user IDs + * are signed. + * @param list of user ID indexes (of the key to be signed). + */ + virtual void setUserIDsToSign(const std::vector<unsigned int> &idsToSign) = 0; + + /** + * sets the check level + * @param the check level, ranges from 0 (no claim) and 3 (extensively checked), + * default is 0 + */ + virtual void setCheckLevel(unsigned int checkLevel) = 0; + + /** + * sets whether the signature should be exportable, or local only. + * default is local. + */ + virtual void setExportable(bool exportable) = 0; + + /** + * sets an alternate signing key + */ + virtual void setSigningKey(const GpgME::Key &key) = 0; + + /** + * if set, the created signature won't be revocable. By default signatures + * can be revoked. + */ + virtual void setNonRevocable(bool nonRevocable) = 0; + +Q_SIGNALS: + void result(const GpgME::Error &result, const QString &auditLogAsHtml = QString(), const GpgME::Error &auditLogError = GpgME::Error()); +}; + +} + +#endif // __KLEO_SIGNKEYJOB_H__ diff --git a/lang/qt/src/specialjob.h b/lang/qt/src/specialjob.h new file mode 100644 index 00000000..788371e7 --- /dev/null +++ b/lang/qt/src/specialjob.h @@ -0,0 +1,90 @@ +/* + specialjob.h + + This file is part of qgpgme, the Qt API binding for gpgme + Copyright (c) 2004 Klarälvdalens Datakonsult AB + Copyright (c) 2016 Intevation GmbH + + QGpgME 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. + + QGpgME 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 this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + + In addition, as a special exception, the copyright holders give + permission to link the code of this program with any edition of + the Qt library by Trolltech AS, Norway (or with modified versions + of Qt that use the same license as Qt), and distribute linked + combinations including the two. You must obey the GNU General + Public License in all respects for all of the code used other than + Qt. If you modify this file, you may extend this exception to + your version of the file, but you are not obligated to do so. If + you do not wish to do so, delete this exception statement from + your version. +*/ + +#ifndef __KLEO_SPECIALJOB_H__ +#define __KLEO_SPECIALJOB_H__ + +#include "job.h" + +namespace GpgME +{ +class Error; +} + +namespace QGpgME +{ + +/** + @short An abstract base class for protocol-specific jobs + + To use a SpecialJob, first obtain an instance from the + CryptoBackend implementation, connect progress() and result() + signals to suitable slots and then start the job with a call to + start(). This call might fail, in which case the SpecialJob + instance will have schedules its own destruction with a call to + QObject::deleteLater(). + + After result() is emitted, the SpecialJob will schedule its own + destruction by calling QObject::deleteLater(). + + Parameters are set using the Qt property system. More general, or + constructor parameters are given in the call to + QGpgME::Protocol::specialJob(). + + The result is made available through the result signal, and + through the read-only result property, the latter of which needs + to be defined in each SpecialJob subclass. +*/ +class SpecialJob : public Job +{ + Q_OBJECT +protected: + explicit SpecialJob(QObject *parent); + +public: + ~SpecialJob(); + + /** + Starts the special operation. + */ + virtual GpgME::Error start() = 0; + + virtual GpgME::Error exec() = 0; + +Q_SIGNALS: + void result(const GpgME::Error &result, const QVariant &data); +}; + +} + +#endif // __KLEO_SPECIALJOB_H__ diff --git a/lang/qt/src/threadedjobmixin.cpp b/lang/qt/src/threadedjobmixin.cpp new file mode 100644 index 00000000..cd6ab5fc --- /dev/null +++ b/lang/qt/src/threadedjobmixin.cpp @@ -0,0 +1,110 @@ +/* + threadedjobmixin.cpp + + This file is part of qgpgme, the Qt API binding for gpgme + Copyright (c) 2008 Klarälvdalens Datakonsult AB + Copyright (c) 2016 Intevation GmbH + + QGpgME 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. + + QGpgME 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 this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + + In addition, as a special exception, the copyright holders give + permission to link the code of this program with any edition of + the Qt library by Trolltech AS, Norway (or with modified versions + of Qt that use the same license as Qt), and distribute linked + combinations including the two. You must obey the GNU General + Public License in all respects for all of the code used other than + Qt. If you modify this file, you may extend this exception to + your version of the file, but you are not obligated to do so. If + you do not wish to do so, delete this exception statement from + your version. +*/ + +#include "threadedjobmixin.h" + +#include "dataprovider.h" + +#include "data.h" + +#include <QString> +#include <QStringList> +#include <QByteArray> + + +#include <algorithm> +#include <iterator> + +using namespace QGpgME; +using namespace GpgME; + +static const unsigned int GetAuditLogFlags = Context::AuditLogWithHelp | Context::HtmlAuditLog; + +QString _detail::audit_log_as_html(Context *ctx, GpgME::Error &err) +{ + assert(ctx); + QGpgME::QByteArrayDataProvider dp; + Data data(&dp); + assert(!data.isNull()); + if ((err = ctx->lastError()) || (err = ctx->getAuditLog(data, GetAuditLogFlags))) { + return QString::fromLocal8Bit(err.asString()); + } + const QByteArray ba = dp.data(); + return QString::fromUtf8(ba.data(), ba.size()); +} + +static QList<QByteArray> from_sl(const QStringList &sl) +{ + QList<QByteArray> result; + Q_FOREACH (const QString &str, sl) { + result.append(str.toUtf8()); + } + +#if 0 + std::transform(sl.begin(), sl.end(), std::back_inserter(result), + mem_fn(static_cast<QByteArray()const>(&QString::toUtf8))); +#endif + return result; +} + +static QList<QByteArray> single(const QByteArray &ba) +{ + QList<QByteArray> result; + result.push_back(ba); + return result; +} + +_detail::PatternConverter::PatternConverter(const QByteArray &ba) + : m_list(single(ba)), m_patterns(0) {} +_detail::PatternConverter::PatternConverter(const QString &s) + : m_list(single(s.toUtf8())), m_patterns(0) {} +_detail::PatternConverter::PatternConverter(const QList<QByteArray> &lba) + : m_list(lba), m_patterns(0) {} +_detail::PatternConverter::PatternConverter(const QStringList &sl) + : m_list(from_sl(sl)), m_patterns(0) {} + +const char **_detail::PatternConverter::patterns() const +{ + if (!m_patterns) { + m_patterns = new const char *[ m_list.size() + 1 ]; + const char **end = std::transform(m_list.begin(), m_list.end(), m_patterns, + std::mem_fn(&QByteArray::constData)); + *end = 0; + } + return m_patterns; +} + +_detail::PatternConverter::~PatternConverter() +{ + delete [] m_patterns; +} diff --git a/lang/qt/src/threadedjobmixin.h b/lang/qt/src/threadedjobmixin.h new file mode 100644 index 00000000..62d7f1c1 --- /dev/null +++ b/lang/qt/src/threadedjobmixin.h @@ -0,0 +1,272 @@ +/* + threadedjobmixin.h + + This file is part of qgpgme, the Qt API binding for gpgme + Copyright (c) 2008 Klarälvdalens Datakonsult AB + Copyright (c) 2016 Intevation GmbH + + QGpgME 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. + + QGpgME 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 this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + + In addition, as a special exception, the copyright holders give + permission to link the code of this program with any edition of + the Qt library by Trolltech AS, Norway (or with modified versions + of Qt that use the same license as Qt), and distribute linked + combinations including the two. You must obey the GNU General + Public License in all respects for all of the code used other than + Qt. If you modify this file, you may extend this exception to + your version of the file, but you are not obligated to do so. If + you do not wish to do so, delete this exception statement from + your version. +*/ + +#ifndef __QGPGME_THREADEDJOBMIXING_H__ +#define __QGPGME_THREADEDJOBMIXING_H__ + +#include <QMutex> +#include <QMutexLocker> +#include <QThread> +#include <QString> +#include <QIODevice> + +#ifdef BUILDING_QGPGME +# include "context.h" +# include "interfaces/progressprovider.h" +#else +# include <gpgme++/context.h> +# include <gpgme++/interfaces/progressprovider.h> +#endif + + +#include <cassert> + +namespace QGpgME +{ +namespace _detail +{ + +QString audit_log_as_html(GpgME::Context *ctx, GpgME::Error &err); + +class PatternConverter +{ + const QList<QByteArray> m_list; + mutable const char **m_patterns; +public: + explicit PatternConverter(const QByteArray &ba); + explicit PatternConverter(const QString &s); + explicit PatternConverter(const QList<QByteArray> &lba); + explicit PatternConverter(const QStringList &sl); + ~PatternConverter(); + + const char **patterns() const; +}; + +class ToThreadMover +{ + QObject *const m_object; + QThread *const m_thread; +public: + ToThreadMover(QObject *o, QThread *t) : m_object(o), m_thread(t) {} + ToThreadMover(QObject &o, QThread *t) : m_object(&o), m_thread(t) {} + ToThreadMover(const std::shared_ptr<QObject> &o, QThread *t) : m_object(o.get()), m_thread(t) {} + ~ToThreadMover() + { + if (m_object && m_thread) { + m_object->moveToThread(m_thread); + } + } +}; + +template <typename T_result> +class Thread : public QThread +{ +public: + explicit Thread(QObject *parent = Q_NULLPTR) : QThread(parent) {} + + void setFunction(const std::function<T_result()> &function) + { + const QMutexLocker locker(&m_mutex); + m_function = function; + } + + T_result result() const + { + const QMutexLocker locker(&m_mutex); + return m_result; + } + +private: + void run() Q_DECL_OVERRIDE { + const QMutexLocker locker(&m_mutex); + m_result = m_function(); + } +private: + mutable QMutex m_mutex; + std::function<T_result()> m_function; + T_result m_result; +}; + +template <typename T_base, typename T_result = std::tuple<GpgME::Error, QString, GpgME::Error> > +class ThreadedJobMixin : public T_base, public GpgME::ProgressProvider +{ +public: + typedef ThreadedJobMixin<T_base, T_result> mixin_type; + typedef T_result result_type; + +protected: + static_assert(std::tuple_size<T_result>::value > 2, + "Result tuple too small"); + static_assert(std::is_same < + typename std::tuple_element < + std::tuple_size<T_result>::value - 2, + T_result + >::type, + QString + >::value, + "Second to last result type not a QString"); + static_assert(std::is_same < + typename std::tuple_element < + std::tuple_size<T_result>::value - 1, + T_result + >::type, + GpgME::Error + >::value, + "Last result type not a GpgME::Error"); + + explicit ThreadedJobMixin(GpgME::Context *ctx) + : T_base(0), m_ctx(ctx), m_thread(), m_auditLog(), m_auditLogError() + { + + } + + void lateInitialization() + { + assert(m_ctx); + QObject::connect(&m_thread, SIGNAL(finished()), this, SLOT(slotFinished())); + m_ctx->setProgressProvider(this); + } + + template <typename T_binder> + void run(const T_binder &func) + { + m_thread.setFunction(std::bind(func, this->context())); + m_thread.start(); + } + template <typename T_binder> + void run(const T_binder &func, const std::shared_ptr<QIODevice> &io) + { + if (io) { + io->moveToThread(&m_thread); + } + // the arguments passed here to the functor are stored in a QThread, and are not + // necessarily destroyed (living outside the UI thread) at the time the result signal + // is emitted and the signal receiver wants to clean up IO devices. + // To avoid such races, we pass std::weak_ptr's to the functor. + m_thread.setFunction(std::bind(func, this->context(), this->thread(), std::weak_ptr<QIODevice>(io))); + m_thread.start(); + } + template <typename T_binder> + void run(const T_binder &func, const std::shared_ptr<QIODevice> &io1, const std::shared_ptr<QIODevice> &io2) + { + if (io1) { + io1->moveToThread(&m_thread); + } + if (io2) { + io2->moveToThread(&m_thread); + } + // the arguments passed here to the functor are stored in a QThread, and are not + // necessarily destroyed (living outside the UI thread) at the time the result signal + // is emitted and the signal receiver wants to clean up IO devices. + // To avoid such races, we pass std::weak_ptr's to the functor. + m_thread.setFunction(std::bind(func, this->context(), this->thread(), std::weak_ptr<QIODevice>(io1), std::weak_ptr<QIODevice>(io2))); + m_thread.start(); + } + GpgME::Context *context() const + { + return m_ctx.get(); + } + + virtual void resultHook(const result_type &) {} + + void slotFinished() + { + const T_result r = m_thread.result(); + m_auditLog = std::get < std::tuple_size<T_result>::value - 2 > (r); + m_auditLogError = std::get < std::tuple_size<T_result>::value - 1 > (r); + resultHook(r); + Q_EMIT this->done(); + doEmitResult(r); + this->deleteLater(); + } + void slotCancel() Q_DECL_OVERRIDE { + if (m_ctx) + { + m_ctx->cancelPendingOperation(); + } + } + QString auditLogAsHtml() const Q_DECL_OVERRIDE + { + return m_auditLog; + } + GpgME::Error auditLogError() const Q_DECL_OVERRIDE + { + return m_auditLogError; + } + void showProgress(const char *what, int type, int current, int total) Q_DECL_OVERRIDE { + // will be called from the thread exec'ing the operation, so + // just bounce everything to the owning thread: + // ### hope this is thread-safe (meta obj is const, and + // ### portEvent is thread-safe, so should be ok) + QMetaObject::invokeMethod(this, "progress", Qt::QueuedConnection, + // TODO port + Q_ARG(QString, QString()), + Q_ARG(int, current), + Q_ARG(int, total)); + } +private: + template <typename T1, typename T2> + void doEmitResult(const std::tuple<T1, T2> &tuple) + { + Q_EMIT this->result(std::get<0>(tuple), std::get<1>(tuple)); + } + + template <typename T1, typename T2, typename T3> + void doEmitResult(const std::tuple<T1, T2, T3> &tuple) + { + Q_EMIT this->result(std::get<0>(tuple), std::get<1>(tuple), std::get<2>(tuple)); + } + + template <typename T1, typename T2, typename T3, typename T4> + void doEmitResult(const std::tuple<T1, T2, T3, T4> &tuple) + { + Q_EMIT this->result(std::get<0>(tuple), std::get<1>(tuple), std::get<2>(tuple), std::get<3>(tuple)); + } + + template <typename T1, typename T2, typename T3, typename T4, typename T5> + void doEmitResult(const std::tuple<T1, T2, T3, T4, T5> &tuple) + { + Q_EMIT this->result(std::get<0>(tuple), std::get<1>(tuple), std::get<2>(tuple), std::get<3>(tuple), std::get<4>(tuple)); + } + +private: + std::shared_ptr<GpgME::Context> m_ctx; + Thread<T_result> m_thread; + QString m_auditLog; + GpgME::Error m_auditLogError; +}; + +} +} + +#endif /* __QGPGME_THREADEDJOBMIXING_H__ */ diff --git a/lang/qt/src/verifydetachedjob.h b/lang/qt/src/verifydetachedjob.h new file mode 100644 index 00000000..fc5bc697 --- /dev/null +++ b/lang/qt/src/verifydetachedjob.h @@ -0,0 +1,98 @@ +/* + verifydetachedjob.h + + This file is part of qgpgme, the Qt API binding for gpgme + Copyright (c) 2004, 2007 Klarälvdalens Datakonsult AB + Copyright (c) 2016 Intevation GmbH + + QGpgME 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. + + QGpgME 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 this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + + In addition, as a special exception, the copyright holders give + permission to link the code of this program with any edition of + the Qt library by Trolltech AS, Norway (or with modified versions + of Qt that use the same license as Qt), and distribute linked + combinations including the two. You must obey the GNU General + Public License in all respects for all of the code used other than + Qt. If you modify this file, you may extend this exception to + your version of the file, but you are not obligated to do so. If + you do not wish to do so, delete this exception statement from + your version. +*/ + +#ifndef __KLEO_VERIFYDETACHEDJOB_H__ +#define __KLEO_VERIFYDETACHEDJOB_H__ + +#include "job.h" + +#include <memory> + +class QByteArray; +class QIODevice; + +namespace GpgME +{ +class Error; +class VerificationResult; +} + +namespace QGpgME +{ + +/** + @short An abstract base class for asynchronous verification of detached signatures + + To use a VerifyDetachedJob, first obtain an instance from the + CryptoBackend implementation, connect the progress() and result() + signals to suitable slots and then start the verification with a + call to start(). This call might fail, in which case the + VerifyDetachedJob instance will have scheduled it's own + destruction with a call to QObject::deleteLater(). + + After result() is emitted, the VerifyDetachedJob will schedule + it's own destruction by calling QObject::deleteLater(). +*/ +class VerifyDetachedJob : public Job +{ + Q_OBJECT +protected: + explicit VerifyDetachedJob(QObject *parent); +public: + ~VerifyDetachedJob(); + + /** + Starts the verification operation. \a signature contains the + signature data, while \a signedData contains the data over + which the signature was made. + */ + virtual QGPGME_DEPRECATED_EXPORT GpgME::Error start(const QByteArray &signature, + const QByteArray &signedData) = 0; + + /*! + \overload + + \throws GpgME::Exception if starting fails. + */ + virtual void start(const std::shared_ptr<QIODevice> &signature, const std::shared_ptr<QIODevice> &signedData) = 0; + + virtual GpgME::VerificationResult exec(const QByteArray &signature, + const QByteArray &signedData) = 0; + +Q_SIGNALS: + void result(const GpgME::VerificationResult &result, const QString &auditLogAsHtml = QString(), const GpgME::Error &auditLogError = GpgME::Error()); +}; + +} + +#endif // __KLEO_VERIFYDETACHEDJOB_H__ diff --git a/lang/qt/src/verifyopaquejob.h b/lang/qt/src/verifyopaquejob.h new file mode 100644 index 00000000..f0640492 --- /dev/null +++ b/lang/qt/src/verifyopaquejob.h @@ -0,0 +1,101 @@ +/* + verifyopaquejob.h + + This file is part of qgpgme, the Qt API binding for gpgme + Copyright (c) 2004, 2007 Klarälvdalens Datakonsult AB + Copyright (c) 2016 Intevation GmbH + + QGpgME 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. + + QGpgME 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 this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + + In addition, as a special exception, the copyright holders give + permission to link the code of this program with any edition of + the Qt library by Trolltech AS, Norway (or with modified versions + of Qt that use the same license as Qt), and distribute linked + combinations including the two. You must obey the GNU General + Public License in all respects for all of the code used other than + Qt. If you modify this file, you may extend this exception to + your version of the file, but you are not obligated to do so. If + you do not wish to do so, delete this exception statement from + your version. +*/ + +#ifndef __KLEO_VERIFYOPAQUEJOB_H__ +#define __KLEO_VERIFYOPAQUEJOB_H__ + +#include "job.h" + +#include <memory> + +class QByteArray; +class QIODevice; + +namespace GpgME +{ +class Error; +class VerificationResult; +} + +namespace QGpgME +{ + +/** + @short An abstract base class for asynchronous verification of opaque signatures + + To use a VerifyOpaqueJob, first obtain an instance from the + CryptoBackend implementation, connect the progress() and result() + signals to suitable slots and then start the verification with a + call to start(). This call might fail, in which case the + VerifyOpaqueJob instance will have scheduled it's own + destruction with a call to QObject::deleteLater(). + + After result() is emitted, the VerifyOpaqueJob will schedule + it's own destruction by calling QObject::deleteLater(). +*/ +class QGPGME_EXPORT VerifyOpaqueJob : public Job +{ + Q_OBJECT +protected: + explicit VerifyOpaqueJob(QObject *parent); +public: + ~VerifyOpaqueJob(); + + /** + Starts the verification operation. \a signature contains the + signature data, while \a signedData contains the data over + which the signature was made. + */ + virtual QGPGME_DEPRECATED_EXPORT GpgME::Error start(const QByteArray &signedData) = 0; + + /*! + \overload + + If \a plainText is non-null, the plaintext is written + there. Otherwise, it will be delivered in the second argument + of result(). + + \throws GpgME::Exception if starting fails + */ + virtual void start(const std::shared_ptr<QIODevice> &signedData, const std::shared_ptr<QIODevice> &plainText = std::shared_ptr<QIODevice>()) = 0; + + /** Synchronous version of @ref start */ + virtual GpgME::VerificationResult exec(const QByteArray &signedData, QByteArray &plainText) = 0; + +Q_SIGNALS: + void result(const GpgME::VerificationResult &result, const QByteArray &plainText, const QString &auditLogAsHtml = QString(), const GpgME::Error &auditLogError = GpgME::Error()); +}; + +} + +#endif // __KLEO_VERIFYOPAQUEJOB_H__ diff --git a/lang/qt/tests/Makefile.am b/lang/qt/tests/Makefile.am new file mode 100644 index 00000000..6da9d29c --- /dev/null +++ b/lang/qt/tests/Makefile.am @@ -0,0 +1,72 @@ +# Makefile.am - Makefile for GPGME Qt tests. +# Copyright (C) 2016 Intevation GmbH +# +# This file is part of GPGME. +# +# GPGME is free software; you can redistribute it and/or modify it +# under the terms of the GNU Lesser General Public License as +# published by the Free Software Foundation; either version 2.1 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 Lesser General +# Public License for more details. +# +# You should have received a copy of the GNU Lesser General Public +# License along with this program; if not, see <http://www.gnu.org/licenses/>. + +## Process this file with automake to produce Makefile.in + +GPG = gpg + +TESTS_ENVIRONMENT = GNUPGHOME=$(abs_builddir) + +EXTRA_DIST = initial.test + +TESTS = initial.test t-keylist + +moc_files = t-keylist.moc + +AM_LDFLAGS = -no-install + +LDADD = ../../cpp/src/libgpgmepp.la ../src/libqgpgme.la \ + ../../../src/libgpgme.la @GPGME_QT_LIBS@ @GPG_ERROR_LIBS@ \ + @GPGME_QTTEST_LIBS@ + +AM_CPPFLAGS = -I$(top_builddir)/src @GPG_ERROR_CFLAGS@ \ + @GPGME_QT_CFLAGS@ @GPG_ERROR_CFLAGS@ @LIBASSUAN_CFLAGS@ \ + @GPGME_QTTEST_CFLAGS@ \ + -I$(top_srcdir)/lang/cpp/src -I$(top_srcdir)/lang/qt/src \ + -DTOP_SRCDIR="$(top_srcdir)" + +check-local: ./pubring-stamp + +# To guarantee that check-local is run before any tests we +# add this dependency: +initial.test : check-local + +t_keylist_SOURCES = t-keylist.cpp + +nodist_t_keylist_SOURCES = $(moc_files) + +BUILT_SOURCES = $(moc_files) + +noinst_PROGRAMS = t-keylist + +CLEANFILES = secring.gpg pubring.gpg pubring.kbx trustdb.gpg dirmngr.conf \ + gpg-agent.conf pubring.kbx~ S.gpg-agent gpg.conf pubring.gpg~ \ + random_seed S.gpg-agent .gpg-v21-migrated pubring-stamp $(moc_files) + +export GNUPGHOME := $(abs_builddir) + +./pubring-stamp: $(top_srcdir)/tests/gpg/pubdemo.asc \ + $(top_srcdir)/tests/gpg/secdemo.asc + $(GPG) --no-permission-warning \ + --import $(top_srcdir)/tests/gpg/pubdemo.asc + $(GPG) --no-permission-warning \ + --import $(top_srcdir)/tests/gpg/secdemo.asc + touch ./pubring-stamp + +.cpp.moc: + $(MOC) `test -f '$<' || echo '$(srcdir)/'`$< -o $@ diff --git a/lang/qt/tests/initial.test b/lang/qt/tests/initial.test new file mode 100755 index 00000000..039e4d00 --- /dev/null +++ b/lang/qt/tests/initial.test @@ -0,0 +1,2 @@ +#!/bin/sh +exit 0 diff --git a/lang/qt/tests/t-keylist.cpp b/lang/qt/tests/t-keylist.cpp new file mode 100644 index 00000000..f5c7f131 --- /dev/null +++ b/lang/qt/tests/t-keylist.cpp @@ -0,0 +1,54 @@ +#include <QDebug> +#include <QTest> +#include <QSignalSpy> +#include "keylistjob.h" +#include "qgpgmebackend.h" +#include "keylistresult.h" + +using namespace QGpgME; +using namespace GpgME; + +class KeyListTest : public QObject +{ + Q_OBJECT + +Q_SIGNALS: + void asyncDone(); + +private Q_SLOTS: + + void testSingleKeyListSync() + { + KeyListJob *job = openpgp()->keyListJob(false, false, false); + std::vector<GpgME::Key> keys; + GpgME::KeyListResult result = job->exec(QStringList() << QStringLiteral("[email protected]"), + false, keys); + Q_ASSERT (!result.error()); + Q_ASSERT (keys.size() == 1); + const QString kId = QLatin1String(keys.front().keyID()); + Q_ASSERT (kId == QStringLiteral("2D727CC768697734")); + } + + void testKeyListAsync() + { + KeyListJob *job = openpgp()->keyListJob(); + connect(job, &KeyListJob::result, job, [this, job](KeyListResult, std::vector<Key> keys, QString, Error) + { + Q_ASSERT(keys.size() == 1); + Q_EMIT asyncDone(); + }); + job->start(QStringList() << "[email protected]"); + QSignalSpy spy (this, &KeyListTest::asyncDone); + Q_ASSERT(spy.wait()); + } + + void initTestCase() + { + const QString gpgHome = qgetenv("GNUPGHOME"); + QVERIFY2(!gpgHome.isEmpty(), "GNUPGHOME environment variable is not set."); + } +}; + +QTEST_MAIN(KeyListTest) + +#include "t-keylist.moc" diff --git a/m4/ax_cxx_compile_stdcxx.m4 b/m4/ax_cxx_compile_stdcxx.m4 new file mode 100644 index 00000000..2c18e49c --- /dev/null +++ b/m4/ax_cxx_compile_stdcxx.m4 @@ -0,0 +1,562 @@ +# =========================================================================== +# http://www.gnu.org/software/autoconf-archive/ax_cxx_compile_stdcxx.html +# =========================================================================== +# +# SYNOPSIS +# +# AX_CXX_COMPILE_STDCXX(VERSION, [ext|noext], [mandatory|optional]) +# +# DESCRIPTION +# +# Check for baseline language coverage in the compiler for the specified +# version of the C++ standard. If necessary, add switches to CXX and +# CXXCPP to enable support. VERSION may be '11' (for the C++11 standard) +# or '14' (for the C++14 standard). +# +# The second argument, if specified, indicates whether you insist on an +# extended mode (e.g. -std=gnu++11) or a strict conformance mode (e.g. +# -std=c++11). If neither is specified, you get whatever works, with +# preference for an extended mode. +# +# The third argument, if specified 'mandatory' or if left unspecified, +# indicates that baseline support for the specified C++ standard is +# required and that the macro should error out if no mode with that +# support is found. If specified 'optional', then configuration proceeds +# regardless, after defining HAVE_CXX${VERSION} if and only if a +# supporting mode is found. +# +# LICENSE +# +# Copyright (c) 2008 Benjamin Kosnik <[email protected]> +# Copyright (c) 2012 Zack Weinberg <[email protected]> +# Copyright (c) 2013 Roy Stogner <[email protected]> +# Copyright (c) 2014, 2015 Google Inc.; contributed by Alexey Sokolov <[email protected]> +# Copyright (c) 2015 Paul Norman <[email protected]> +# Copyright (c) 2015 Moritz Klammler <[email protected]> +# +# Copying and distribution of this file, with or without modification, are +# permitted in any medium without royalty provided the copyright notice +# and this notice are preserved. This file is offered as-is, without any +# warranty. + +#serial 4 + +dnl This macro is based on the code from the AX_CXX_COMPILE_STDCXX_11 macro +dnl (serial version number 13). + +AC_DEFUN([AX_CXX_COMPILE_STDCXX], [dnl + m4_if([$1], [11], [], + [$1], [14], [], + [$1], [17], [m4_fatal([support for C++17 not yet implemented in AX_CXX_COMPILE_STDCXX])], + [m4_fatal([invalid first argument `$1' to AX_CXX_COMPILE_STDCXX])])dnl + m4_if([$2], [], [], + [$2], [ext], [], + [$2], [noext], [], + [m4_fatal([invalid second argument `$2' to AX_CXX_COMPILE_STDCXX])])dnl + m4_if([$3], [], [ax_cxx_compile_cxx$1_required=true], + [$3], [mandatory], [ax_cxx_compile_cxx$1_required=true], + [$3], [optional], [ax_cxx_compile_cxx$1_required=false], + [m4_fatal([invalid third argument `$3' to AX_CXX_COMPILE_STDCXX])]) + AC_LANG_PUSH([C++])dnl + ac_success=no + AC_CACHE_CHECK(whether $CXX supports C++$1 features by default, + ax_cv_cxx_compile_cxx$1, + [AC_COMPILE_IFELSE([AC_LANG_SOURCE([_AX_CXX_COMPILE_STDCXX_testbody_$1])], + [ax_cv_cxx_compile_cxx$1=yes], + [ax_cv_cxx_compile_cxx$1=no])]) + if test x$ax_cv_cxx_compile_cxx$1 = xyes; then + ac_success=yes + fi + + m4_if([$2], [noext], [], [dnl + if test x$ac_success = xno; then + for switch in -std=gnu++$1 -std=gnu++0x; do + cachevar=AS_TR_SH([ax_cv_cxx_compile_cxx$1_$switch]) + AC_CACHE_CHECK(whether $CXX supports C++$1 features with $switch, + $cachevar, + [ac_save_CXX="$CXX" + CXX="$CXX $switch" + AC_COMPILE_IFELSE([AC_LANG_SOURCE([_AX_CXX_COMPILE_STDCXX_testbody_$1])], + [eval $cachevar=yes], + [eval $cachevar=no]) + CXX="$ac_save_CXX"]) + if eval test x\$$cachevar = xyes; then + CXX="$CXX $switch" + if test -n "$CXXCPP" ; then + CXXCPP="$CXXCPP $switch" + fi + ac_success=yes + break + fi + done + fi]) + + m4_if([$2], [ext], [], [dnl + if test x$ac_success = xno; then + dnl HP's aCC needs +std=c++11 according to: + dnl http://h21007.www2.hp.com/portal/download/files/unprot/aCxx/PDF_Release_Notes/769149-001.pdf + dnl Cray's crayCC needs "-h std=c++11" + for switch in -std=c++$1 -std=c++0x +std=c++$1 "-h std=c++$1"; do + cachevar=AS_TR_SH([ax_cv_cxx_compile_cxx$1_$switch]) + AC_CACHE_CHECK(whether $CXX supports C++$1 features with $switch, + $cachevar, + [ac_save_CXX="$CXX" + CXX="$CXX $switch" + AC_COMPILE_IFELSE([AC_LANG_SOURCE([_AX_CXX_COMPILE_STDCXX_testbody_$1])], + [eval $cachevar=yes], + [eval $cachevar=no]) + CXX="$ac_save_CXX"]) + if eval test x\$$cachevar = xyes; then + CXX="$CXX $switch" + if test -n "$CXXCPP" ; then + CXXCPP="$CXXCPP $switch" + fi + ac_success=yes + break + fi + done + fi]) + AC_LANG_POP([C++]) + if test x$ax_cxx_compile_cxx$1_required = xtrue; then + if test x$ac_success = xno; then + AC_MSG_ERROR([*** A compiler with support for C++$1 language features is required.]) + fi + fi + if test x$ac_success = xno; then + HAVE_CXX$1=0 + AC_MSG_NOTICE([No compiler with C++$1 support was found]) + else + HAVE_CXX$1=1 + AC_DEFINE(HAVE_CXX$1,1, + [define if the compiler supports basic C++$1 syntax]) + fi + AC_SUBST(HAVE_CXX$1) +]) + + +dnl Test body for checking C++11 support + +m4_define([_AX_CXX_COMPILE_STDCXX_testbody_11], + _AX_CXX_COMPILE_STDCXX_testbody_new_in_11 +) + + +dnl Test body for checking C++14 support + +m4_define([_AX_CXX_COMPILE_STDCXX_testbody_14], + _AX_CXX_COMPILE_STDCXX_testbody_new_in_11 + _AX_CXX_COMPILE_STDCXX_testbody_new_in_14 +) + + +dnl Tests for new features in C++11 + +m4_define([_AX_CXX_COMPILE_STDCXX_testbody_new_in_11], [[ + +// If the compiler admits that it is not ready for C++11, why torture it? +// Hopefully, this will speed up the test. + +#ifndef __cplusplus + +#error "This is not a C++ compiler" + +#elif __cplusplus < 201103L + +#error "This is not a C++11 compiler" + +#else + +namespace cxx11 +{ + + namespace test_static_assert + { + + template <typename T> + struct check + { + static_assert(sizeof(int) <= sizeof(T), "not big enough"); + }; + + } + + namespace test_final_override + { + + struct Base + { + virtual void f() {} + }; + + struct Derived : public Base + { + virtual void f() override {} + }; + + } + + namespace test_double_right_angle_brackets + { + + template < typename T > + struct check {}; + + typedef check<void> single_type; + typedef check<check<void>> double_type; + typedef check<check<check<void>>> triple_type; + typedef check<check<check<check<void>>>> quadruple_type; + + } + + namespace test_decltype + { + + int + f() + { + int a = 1; + decltype(a) b = 2; + return a + b; + } + + } + + namespace test_type_deduction + { + + template < typename T1, typename T2 > + struct is_same + { + static const bool value = false; + }; + + template < typename T > + struct is_same<T, T> + { + static const bool value = true; + }; + + template < typename T1, typename T2 > + auto + add(T1 a1, T2 a2) -> decltype(a1 + a2) + { + return a1 + a2; + } + + int + test(const int c, volatile int v) + { + static_assert(is_same<int, decltype(0)>::value == true, ""); + static_assert(is_same<int, decltype(c)>::value == false, ""); + static_assert(is_same<int, decltype(v)>::value == false, ""); + auto ac = c; + auto av = v; + auto sumi = ac + av + 'x'; + auto sumf = ac + av + 1.0; + static_assert(is_same<int, decltype(ac)>::value == true, ""); + static_assert(is_same<int, decltype(av)>::value == true, ""); + static_assert(is_same<int, decltype(sumi)>::value == true, ""); + static_assert(is_same<int, decltype(sumf)>::value == false, ""); + static_assert(is_same<int, decltype(add(c, v))>::value == true, ""); + return (sumf > 0.0) ? sumi : add(c, v); + } + + } + + namespace test_noexcept + { + + int f() { return 0; } + int g() noexcept { return 0; } + + static_assert(noexcept(f()) == false, ""); + static_assert(noexcept(g()) == true, ""); + + } + + namespace test_constexpr + { + + template < typename CharT > + unsigned long constexpr + strlen_c_r(const CharT *const s, const unsigned long acc) noexcept + { + return *s ? strlen_c_r(s + 1, acc + 1) : acc; + } + + template < typename CharT > + unsigned long constexpr + strlen_c(const CharT *const s) noexcept + { + return strlen_c_r(s, 0UL); + } + + static_assert(strlen_c("") == 0UL, ""); + static_assert(strlen_c("1") == 1UL, ""); + static_assert(strlen_c("example") == 7UL, ""); + static_assert(strlen_c("another\0example") == 7UL, ""); + + } + + namespace test_rvalue_references + { + + template < int N > + struct answer + { + static constexpr int value = N; + }; + + answer<1> f(int&) { return answer<1>(); } + answer<2> f(const int&) { return answer<2>(); } + answer<3> f(int&&) { return answer<3>(); } + + void + test() + { + int i = 0; + const int c = 0; + static_assert(decltype(f(i))::value == 1, ""); + static_assert(decltype(f(c))::value == 2, ""); + static_assert(decltype(f(0))::value == 3, ""); + } + + } + + namespace test_uniform_initialization + { + + struct test + { + static const int zero {}; + static const int one {1}; + }; + + static_assert(test::zero == 0, ""); + static_assert(test::one == 1, ""); + + } + + namespace test_lambdas + { + + void + test1() + { + auto lambda1 = [](){}; + auto lambda2 = lambda1; + lambda1(); + lambda2(); + } + + int + test2() + { + auto a = [](int i, int j){ return i + j; }(1, 2); + auto b = []() -> int { return '0'; }(); + auto c = [=](){ return a + b; }(); + auto d = [&](){ return c; }(); + auto e = [a, &b](int x) mutable { + const auto identity = [](int y){ return y; }; + for (auto i = 0; i < a; ++i) + a += b--; + return x + identity(a + b); + }(0); + return a + b + c + d + e; + } + + int + test3() + { + const auto nullary = [](){ return 0; }; + const auto unary = [](int x){ return x; }; + using nullary_t = decltype(nullary); + using unary_t = decltype(unary); + const auto higher1st = [](nullary_t f){ return f(); }; + const auto higher2nd = [unary](nullary_t f1){ + return [unary, f1](unary_t f2){ return f2(unary(f1())); }; + }; + return higher1st(nullary) + higher2nd(nullary)(unary); + } + + } + + namespace test_variadic_templates + { + + template <int...> + struct sum; + + template <int N0, int... N1toN> + struct sum<N0, N1toN...> + { + static constexpr auto value = N0 + sum<N1toN...>::value; + }; + + template <> + struct sum<> + { + static constexpr auto value = 0; + }; + + static_assert(sum<>::value == 0, ""); + static_assert(sum<1>::value == 1, ""); + static_assert(sum<23>::value == 23, ""); + static_assert(sum<1, 2>::value == 3, ""); + static_assert(sum<5, 5, 11>::value == 21, ""); + static_assert(sum<2, 3, 5, 7, 11, 13>::value == 41, ""); + + } + + // http://stackoverflow.com/questions/13728184/template-aliases-and-sfinae + // Clang 3.1 fails with headers of libstd++ 4.8.3 when using std::function + // because of this. + namespace test_template_alias_sfinae + { + + struct foo {}; + + template<typename T> + using member = typename T::member_type; + + template<typename T> + void func(...) {} + + template<typename T> + void func(member<T>*) {} + + void test(); + + void test() { func<foo>(0); } + + } + +} // namespace cxx11 + +#endif // __cplusplus >= 201103L + +]]) + + +dnl Tests for new features in C++14 + +m4_define([_AX_CXX_COMPILE_STDCXX_testbody_new_in_14], [[ + +// If the compiler admits that it is not ready for C++14, why torture it? +// Hopefully, this will speed up the test. + +#ifndef __cplusplus + +#error "This is not a C++ compiler" + +#elif __cplusplus < 201402L + +#error "This is not a C++14 compiler" + +#else + +namespace cxx14 +{ + + namespace test_polymorphic_lambdas + { + + int + test() + { + const auto lambda = [](auto&&... args){ + const auto istiny = [](auto x){ + return (sizeof(x) == 1UL) ? 1 : 0; + }; + const int aretiny[] = { istiny(args)... }; + return aretiny[0]; + }; + return lambda(1, 1L, 1.0f, '1'); + } + + } + + namespace test_binary_literals + { + + constexpr auto ivii = 0b0000000000101010; + static_assert(ivii == 42, "wrong value"); + + } + + namespace test_generalized_constexpr + { + + template < typename CharT > + constexpr unsigned long + strlen_c(const CharT *const s) noexcept + { + auto length = 0UL; + for (auto p = s; *p; ++p) + ++length; + return length; + } + + static_assert(strlen_c("") == 0UL, ""); + static_assert(strlen_c("x") == 1UL, ""); + static_assert(strlen_c("test") == 4UL, ""); + static_assert(strlen_c("another\0test") == 7UL, ""); + + } + + namespace test_lambda_init_capture + { + + int + test() + { + auto x = 0; + const auto lambda1 = [a = x](int b){ return a + b; }; + const auto lambda2 = [a = lambda1(x)](){ return a; }; + return lambda2(); + } + + } + + namespace test_digit_seperators + { + + constexpr auto ten_million = 100'000'000; + static_assert(ten_million == 100000000, ""); + + } + + namespace test_return_type_deduction + { + + auto f(int& x) { return x; } + decltype(auto) g(int& x) { return x; } + + template < typename T1, typename T2 > + struct is_same + { + static constexpr auto value = false; + }; + + template < typename T > + struct is_same<T, T> + { + static constexpr auto value = true; + }; + + int + test() + { + auto x = 0; + static_assert(is_same<int, decltype(f(x))>::value, ""); + static_assert(is_same<int&, decltype(g(x))>::value, ""); + return x; + } + + } + +} // namespace cxx14 + +#endif // __cplusplus >= 201402L + +]]) diff --git a/m4/qt.m4 b/m4/qt.m4 new file mode 100644 index 00000000..d3be7f88 --- /dev/null +++ b/m4/qt.m4 @@ -0,0 +1,56 @@ +dnl qt.m4 +dnl Copyright (C) 2016 Intevation GmbH +dnl +dnl This file is part of gpgme and is provided under the same license as gpgme + +dnl Autoconf macro to find either Qt4 or Qt5 +dnl +dnl sets GPGME_QT_LIBS and GPGME_QT_CFLAGS +dnl +dnl if QT5 was found have_qt5_libs is set to yes + +AC_DEFUN([FIND_QT], +[ + have_qt5_libs="no"; + + PKG_CHECK_MODULES(GPGME_QT, + Qt5Core >= 5.0.0, + [have_qt5_libs="yes"], + [have_qt5_libs="no"]) + + PKG_CHECK_MODULES(GPGME_QTTEST, + Qt5Test >= 5.0.0, + [have_qt5test_libs="yes"], + [have_qt5test_libs="no"]) + + if "$PKG_CONFIG" --variable qt_config Qt5Core | grep -q "reduce_relocations"; then + GPGME_QT_CFLAGS="$GPGME_QT_CFLAGS -fpic" + fi + if test "$have_qt5_libs" = "yes"; then + AC_CHECK_TOOL(MOC, moc) + AC_MSG_CHECKING([moc version]) + mocversion=`$MOC -v 2>&1` + mocversiongrep=`echo $mocversion | grep "Qt 5\|moc 5"` + if test x"$mocversiongrep" != x"$mocversion"; then + AC_MSG_RESULT([no]) + # moc was not the qt5 one, try with moc-qt5 + AC_CHECK_TOOL(MOC2, moc-qt5) + mocversion=`$MOC2 -v 2>&1` + mocversiongrep=`echo $mocversion | grep "Qt 5\|moc-qt5 5\|moc 5"` + if test x"$mocversiongrep" != x"$mocversion"; then + AC_CHECK_TOOL(QTCHOOSER, qtchooser) + qt5tooldir=`QT_SELECT=qt5 qtchooser -print-env | grep QTTOOLDIR | cut -d '=' -f 2 | cut -d \" -f 2` + mocversion=`$qt5tooldir/moc -v 2>&1` + mocversiongrep=`echo $mocversion | grep "Qt 5\|moc 5"` + if test x"$mocversiongrep" != x"$mocversion"; then + # no valid moc found + have_qt5_libs="no"; + else + MOC=$qt5tooldir/moc + fi + else + MOC=$MOC2 + fi + fi + fi +]) diff --git a/src/Makefile.am b/src/Makefile.am index 698c6322..951fc00b 100644 --- a/src/Makefile.am +++ b/src/Makefile.am @@ -41,12 +41,6 @@ else ltlib_gpgme_glib = endif -if BUILD_W32_QT -ltlib_gpgme_qt = libgpgme-qt.la -else -ltlib_gpgme_qt = -endif - lib_LTLIBRARIES = libgpgme.la $(ltlib_gpgme_glib) $(ltlib_gpgme_qt) \ $(ltlib_gpgme_pthread) @@ -110,23 +104,9 @@ if BUILD_W32_GLIB libgpgme_glib_la_SOURCES = $(main_sources) ath.h ath.c w32-glib-io.c endif -if BUILD_W32_QT -libgpgme_qt_la_SOURCES = $(main_sources) ath.h ath.c w32-qt-io.cpp \ - kdpipeiodevice.h kdpipeiodevice.cpp kdpipeiodevice.moc -# FIXME: Add extra depedency: moc_kdpipeiodevice.cpp - -# These are built sources (normally). -# moc_kdpipeiodevice.cpp: kdpipeiodevice.h -# $(MOC4) -o $@ $< -# -# kdpipeiodevice.moc: kdpipeiodevice.cpp -# $(MOC4) -o $@ $< -endif - -# We use a global CFLAGS and CPPFLAGS setting for all library +# We use a global CFLAGS setting for all library # versions, because then every object file is only compiled once. -AM_CPPFLAGS = @GPG_ERROR_CFLAGS@ @QT4_CORE_CFLAGS@ -AM_CFLAGS = @LIBASSUAN_CFLAGS@ @GLIB_CFLAGS@ @QT4_CORE_CFLAGS@ +AM_CFLAGS = @LIBASSUAN_CFLAGS@ @GLIB_CFLAGS@ gpgme_tool_SOURCES = gpgme-tool.c argparse.c argparse.h gpgme_tool_LDADD = libgpgme.la @LIBASSUAN_LIBS@ @@ -202,15 +182,6 @@ libgpgme_glib_la_LIBADD = $(gpgme_res) @LIBASSUAN_LIBS@ @LTLIBOBJS@ \ @GPG_ERROR_LIBS@ @GLIB_LIBS@ endif -if BUILD_W32_QT -libgpgme_qt_la_LDFLAGS = $(no_undefined) \ - $(export_symbols) $(libgpgme_version_script_cmd) -version-info \ - @LIBGPGME_LT_CURRENT@:@LIBGPGME_LT_REVISION@:@LIBGPGME_LT_AGE@ -libgpgme_qt_la_DEPENDENCIES = @LTLIBOBJS@ $(srcdir)/libgpgme.vers $(gpgme_deps) -libgpgme_qt_la_LIBADD = $(gpgme_res) @LIBASSUAN_LIBS@ @LTLIBOBJS@ \ - @GPG_ERROR_LIBS@ @QT4_CORE_LIBS@ -endif - install-data-local: install-def-file uninstall-local: uninstall-def-file diff --git a/src/kdpipeiodevice.cpp b/src/kdpipeiodevice.cpp deleted file mode 100644 index 5661790a..00000000 --- a/src/kdpipeiodevice.cpp +++ /dev/null @@ -1,951 +0,0 @@ -/* - Copyright (C) 2007 Klar�lvdalens Datakonsult AB - - KDPipeIODevice is free software; you can redistribute it and/or - modify it under the terms of the GNU Library General Public - License as published by the Free Software Foundation; either - version 2 of the License, or (at your option) any later version. - - KDPipeIODevice is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU Library General Public License for more details. - - You should have received a copy of the GNU Library General Public License - along with KDPipeIODevice; see the file COPYING.LIB. If not, write to the - Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, - Boston, MA 02110-1301, USA. -*/ - -#include "kdpipeiodevice.h" - -#include <QtCore> - -#include <cassert> -#include <memory> -#include <algorithm> - -#ifdef Q_OS_WIN32 -# ifndef NOMINMAX -# define NOMINMAX -# endif -# include <windows.h> -# include <io.h> -#else -# include <unistd.h> -# include <errno.h> -#endif - -using namespace _gpgme_; - -#ifndef KDAB_CHECK_THIS -# define KDAB_CHECK_CTOR (void)1 -# define KDAB_CHECK_DTOR KDAB_CHECK_CTOR -# define KDAB_CHECK_THIS KDAB_CHECK_CTOR -#endif - -#define LOCKED( d ) const QMutexLocker locker( &d->mutex ) -#define synchronized( d ) if ( int i = 0 ) {} else for ( const QMutexLocker locker( &d->mutex ) ; !i ; ++i ) - -const unsigned int BUFFER_SIZE = 4096; -const bool ALLOW_QIODEVICE_BUFFERING = true; - -// comment to get trace output: -//#define qDebug if(1){}else qDebug - -namespace { -class Reader : public QThread { - Q_OBJECT -public: - Reader( int fd, Qt::HANDLE handle ); - ~Reader(); - - qint64 readData( char * data, qint64 maxSize ); - - unsigned int bytesInBuffer() const { - return ( wptr + sizeof buffer - rptr ) % sizeof buffer ; - } - - bool bufferFull() const { - return bytesInBuffer() == sizeof buffer - 1; - } - - bool bufferEmpty() const { - return bytesInBuffer() == 0; - } - - bool bufferContains( char ch ) { - const unsigned int bib = bytesInBuffer(); - for ( unsigned int i = rptr ; i < rptr + bib ; ++i ) - if ( buffer[i%sizeof buffer] == ch ) - return true; - return false; - } - - void notifyReadyRead(); - -Q_SIGNALS: - void readyRead(); - -protected: - /* reimp */ void run(); - -private: - int fd; - Qt::HANDLE handle; -public: - QMutex mutex; - QWaitCondition waitForCancelCondition; - QWaitCondition bufferNotFullCondition; - QWaitCondition bufferNotEmptyCondition; - QWaitCondition hasStarted; - QWaitCondition readyReadSentCondition; - QWaitCondition blockedConsumerIsDoneCondition; - bool cancel; - bool eof; - bool error; - bool eofShortCut; - int errorCode; - bool isReading; - bool consumerBlocksOnUs; - -private: - unsigned int rptr, wptr; - char buffer[BUFFER_SIZE+1]; // need to keep one byte free to detect empty state -}; - - -Reader::Reader( int fd_, Qt::HANDLE handle_ ) - : QThread(), - fd( fd_ ), - handle( handle_ ), - mutex(), - bufferNotFullCondition(), - bufferNotEmptyCondition(), - hasStarted(), - cancel( false ), - eof( false ), - error( false ), - eofShortCut( false ), - errorCode( 0 ), - isReading( false ), - consumerBlocksOnUs( false ), - rptr( 0 ), wptr( 0 ) -{ - -} - -Reader::~Reader() {} - - -class Writer : public QThread { - Q_OBJECT -public: - Writer( int fd, Qt::HANDLE handle ); - ~Writer(); - - qint64 writeData( const char * data, qint64 size ); - - unsigned int bytesInBuffer() const { return numBytesInBuffer; } - - bool bufferFull() const { - return numBytesInBuffer == sizeof buffer; - } - - bool bufferEmpty() const { - return numBytesInBuffer == 0; - } - -Q_SIGNALS: - void bytesWritten( qint64 ); - -protected: - /* reimp */ void run(); - -private: - int fd; - Qt::HANDLE handle; -public: - QMutex mutex; - QWaitCondition bufferEmptyCondition; - QWaitCondition bufferNotEmptyCondition; - QWaitCondition hasStarted; - bool cancel; - bool error; - int errorCode; -private: - unsigned int numBytesInBuffer; - char buffer[BUFFER_SIZE]; -}; -} - -Writer::Writer( int fd_, Qt::HANDLE handle_ ) - : QThread(), - fd( fd_ ), - handle( handle_ ), - mutex(), - bufferEmptyCondition(), - bufferNotEmptyCondition(), - hasStarted(), - cancel( false ), - error( false ), - errorCode( 0 ), - numBytesInBuffer( 0 ) -{ - -} - -Writer::~Writer() {} - - -class KDPipeIODevice::Private : public QObject { -Q_OBJECT - friend class ::KDPipeIODevice; - KDPipeIODevice * const q; -public: - explicit Private( KDPipeIODevice * qq ); - ~Private(); - - bool doOpen( int, Qt::HANDLE, OpenMode ); - bool startReaderThread(); - bool startWriterThread(); - void stopThreads(); - -public Q_SLOTS: - void emitReadyRead(); - -private: - int fd; - Qt::HANDLE handle; - Reader * reader; - Writer * writer; - bool triedToStartReader; - bool triedToStartWriter; -}; - -KDPipeIODevice::Private::Private( KDPipeIODevice * qq ) - : QObject( qq ), q( qq ), - fd( -1 ), - handle( 0 ), - reader( 0 ), - writer( 0 ), - triedToStartReader( false ), triedToStartWriter( false ) -{ - -} - -KDPipeIODevice::Private::~Private() { - qDebug( "KDPipeIODevice::~Private(): Destroying %p", q ); -} - -KDPipeIODevice::KDPipeIODevice( QObject * p ) - : QIODevice( p ), d( new Private( this ) ) -{ - KDAB_CHECK_CTOR; -} - -KDPipeIODevice::KDPipeIODevice( int fd, OpenMode mode, QObject * p ) - : QIODevice( p ), d( new Private( this ) ) -{ - KDAB_CHECK_CTOR; - open( fd, mode ); -} - -KDPipeIODevice::KDPipeIODevice( Qt::HANDLE handle, OpenMode mode, QObject * p ) - : QIODevice( p ), d( new Private( this ) ) -{ - KDAB_CHECK_CTOR; - open( handle, mode ); -} - -KDPipeIODevice::~KDPipeIODevice() { KDAB_CHECK_DTOR; - if ( isOpen() ) - close(); - delete d; d = 0; -} - - -bool KDPipeIODevice::open( int fd, OpenMode mode ) { KDAB_CHECK_THIS; - -#ifdef Q_OS_WIN32 - return d->doOpen( fd, (HANDLE)_get_osfhandle( fd ), mode ); -#else - return d->doOpen( fd, 0, mode ); -#endif - -} - -bool KDPipeIODevice::open( Qt::HANDLE h, OpenMode mode ) { KDAB_CHECK_THIS; - -#ifdef Q_OS_WIN32 - return d->doOpen( -1, h, mode ); -#else - Q_UNUSED( h ); - Q_UNUSED( mode ); - assert( !"KDPipeIODevice::open( Qt::HANDLE, OpenMode ) should never be called except on Windows." ); -#endif - -} - -bool KDPipeIODevice::Private::startReaderThread() -{ - if ( triedToStartReader ) - return true; - triedToStartReader = true; - if ( reader && !reader->isRunning() && !reader->isFinished() ) { - qDebug("KDPipeIODevice::Private::startReaderThread(): locking reader (CONSUMER THREAD)" ); - LOCKED( reader ); - qDebug("KDPipeIODevice::Private::startReaderThread(): locked reader (CONSUMER THREAD)" ); - reader->start( QThread::HighestPriority ); - qDebug("KDPipeIODevice::Private::startReaderThread(): waiting for hasStarted (CONSUMER THREAD)" ); - const bool hasStarted = reader->hasStarted.wait( &reader->mutex, 1000 ); - qDebug("KDPipeIODevice::Private::startReaderThread(): returned from hasStarted (CONSUMER THREAD)" ); - - return hasStarted; - } - return true; -} - -bool KDPipeIODevice::Private::startWriterThread() -{ - if ( triedToStartWriter ) - return true; - triedToStartWriter = true; - if ( writer && !writer->isRunning() && !writer->isFinished() ) { - LOCKED( writer ); - - writer->start( QThread::HighestPriority ); - if ( !writer->hasStarted.wait( &writer->mutex, 1000 ) ) - return false; - } - return true; -} - -void KDPipeIODevice::Private::emitReadyRead() -{ - QPointer<Private> thisPointer( this ); - qDebug( "KDPipeIODevice::Private::emitReadyRead %p", this ); - - emit q->readyRead(); - - if ( !thisPointer ) - return; - - bool mustNotify = false; - - if ( reader ) { - qDebug( "KDPipeIODevice::Private::emitReadyRead %p: locking reader (CONSUMER THREAD)", this ); - synchronized( reader ) { - qDebug( "KDPipeIODevice::Private::emitReadyRead %p: locked reader (CONSUMER THREAD)", this ); - reader->readyReadSentCondition.wakeAll(); - mustNotify = !reader->bufferEmpty() && reader->isReading; - qDebug( "KDPipeIODevice::emitReadyRead %p: bufferEmpty: %d reader in ReadFile: %d", this, reader->bufferEmpty(), reader->isReading ); - } - } - if ( mustNotify ) - QTimer::singleShot( 100, this, SLOT( emitReadyRead() ) ); - qDebug( "KDPipeIODevice::Private::emitReadyRead %p leaving", this ); - -} - -bool KDPipeIODevice::Private::doOpen( int fd_, Qt::HANDLE handle_, OpenMode mode_ ) { - - if ( q->isOpen() ) - return false; - -#ifdef Q_OS_WIN32 - if ( !handle_ ) - return false; -#else - if ( fd_ < 0 ) - return false; -#endif - - if ( !(mode_ & ReadWrite) ) - return false; // need to have at least read -or- write - - - std::auto_ptr<Reader> reader_; - std::auto_ptr<Writer> writer_; - - if ( mode_ & ReadOnly ) { - reader_.reset( new Reader( fd_, handle_ ) ); - qDebug( "KDPipeIODevice::doOpen (%p): created reader (%p) for fd %d", this, reader_.get(), fd_ ); - connect( reader_.get(), SIGNAL(readyRead()), this, SLOT(emitReadyRead()), -Qt::QueuedConnection ); - } - if ( mode_ & WriteOnly ) { - writer_.reset( new Writer( fd_, handle_ ) ); - qDebug( "KDPipeIODevice::doOpen (%p): created writer (%p) for fd %d", this, writer_.get(), fd_ ); - connect( writer_.get(), SIGNAL(bytesWritten(qint64)), q, SIGNAL(bytesWritten(qint64)), -Qt::QueuedConnection ); - } - - // commit to *this: - fd = fd_; - handle = handle_; - reader = reader_.release(); - writer = writer_.release(); - - q->setOpenMode( mode_|Unbuffered ); - return true; -} - -int KDPipeIODevice::descriptor() const { KDAB_CHECK_THIS; - return d->fd; -} - - -Qt::HANDLE KDPipeIODevice::handle() const { KDAB_CHECK_THIS; - return d->handle; -} - -qint64 KDPipeIODevice::bytesAvailable() const { KDAB_CHECK_THIS; - const qint64 base = QIODevice::bytesAvailable(); - if ( !d->triedToStartReader ) { - d->startReaderThread(); - return base; - } - if ( d->reader ) - synchronized( d->reader ) { - const qint64 inBuffer = d->reader->bytesInBuffer(); - return base + inBuffer; - } - return base; -} - -qint64 KDPipeIODevice::bytesToWrite() const { KDAB_CHECK_THIS; - d->startWriterThread(); - const qint64 base = QIODevice::bytesToWrite(); - if ( d->writer ) - synchronized( d->writer ) return base + d->writer->bytesInBuffer(); - return base; -} - -bool KDPipeIODevice::canReadLine() const { KDAB_CHECK_THIS; - d->startReaderThread(); - if ( QIODevice::canReadLine() ) - return true; - if ( d->reader ) - synchronized( d->reader ) return d->reader->bufferContains( '\n' ); - return true; -} - -bool KDPipeIODevice::isSequential() const { - return true; -} - -bool KDPipeIODevice::atEnd() const { KDAB_CHECK_THIS; - d->startReaderThread(); - if ( !QIODevice::atEnd() ) { - qDebug( "%p: KDPipeIODevice::atEnd returns false since QIODevice::atEnd does (with bytesAvailable=%ld)", this, static_cast<long>(bytesAvailable()) ); - return false; - } - if ( !isOpen() ) - return true; - if ( d->reader->eofShortCut ) - return true; - LOCKED( d->reader ); - const bool eof = ( d->reader->error || d->reader->eof ) && d->reader->bufferEmpty(); - if ( !eof ) { - if ( !d->reader->error && !d->reader->eof ) - qDebug( "%p: KDPipeIODevice::atEnd returns false since !reader->error && !reader->eof", this ); - if ( !d->reader->bufferEmpty() ) - qDebug( "%p: KDPipeIODevice::atEnd returns false since !reader->bufferEmpty()", this ); - } - return eof; -} - -bool KDPipeIODevice::waitForBytesWritten( int msecs ) { KDAB_CHECK_THIS; - d->startWriterThread(); - Writer * const w = d->writer; - if ( !w ) - return true; - LOCKED( w ); - qDebug( "KDPipeIODevice::waitForBytesWritten (%p,w=%p): entered locked area", this, w -); - return w->bufferEmpty() || w->error || w->bufferEmptyCondition.wait( &w->mutex, msecs ) ; -} - -bool KDPipeIODevice::waitForReadyRead( int msecs ) { KDAB_CHECK_THIS; - qDebug( "KDPipeIODEvice::waitForReadyRead()(%p)", this); - d->startReaderThread(); - if ( ALLOW_QIODEVICE_BUFFERING ) { - if ( bytesAvailable() > 0 ) - return true; - } - Reader * const r = d->reader; - if ( !r || r->eofShortCut ) - return true; - LOCKED( r ); - if ( r->bytesInBuffer() != 0 || r->eof || r->error ) - return true; - - return msecs >= 0 ? r->bufferNotEmptyCondition.wait( &r->mutex, msecs ) : r->bufferNotEmptyCondition.wait( &r->mutex ); -} - -template <typename T> -class TemporaryValue { -public: - TemporaryValue( T& var_, const T& tv ) : var( var_ ), oldValue( var_ ) { var = tv; } - ~TemporaryValue() { var = oldValue; } -private: - T& var; - const T oldValue; -}; - - -bool KDPipeIODevice::readWouldBlock() const -{ - d->startReaderThread(); - LOCKED( d->reader ); - return d->reader->bufferEmpty() && !d->reader->eof && !d->reader->error; -} - -bool KDPipeIODevice::writeWouldBlock() const -{ - d->startWriterThread(); - LOCKED( d->writer ); - return !d->writer->bufferEmpty() && !d->writer->error; -} - - -qint64 KDPipeIODevice::readData( char * data, qint64 maxSize ) { KDAB_CHECK_THIS; - qDebug( "%p: KDPipeIODevice::readData: data=%p, maxSize=%lld", this, data, maxSize ); - d->startReaderThread(); - Reader * const r = d->reader; - - assert( r ); - - - //assert( r->isRunning() ); // wrong (might be eof, error) - assert( data || maxSize == 0 ); - assert( maxSize >= 0 ); - - if ( r->eofShortCut ) { - qDebug( "%p: KDPipeIODevice::readData: hit eofShortCut, returning 0", this ); - return 0; - } - - if ( maxSize < 0 ) - maxSize = 0; - - if ( ALLOW_QIODEVICE_BUFFERING ) { - if ( bytesAvailable() > 0 ) - maxSize = std::min( maxSize, bytesAvailable() ); // don't block - } - qDebug( "%p: KDPipeIODevice::readData: try to lock reader (CONSUMER THREAD)", this ); - LOCKED( r ); - qDebug( "%p: KDPipeIODevice::readData: locked reader (CONSUMER THREAD)", this ); - - r->readyReadSentCondition.wakeAll(); - if ( /* maxSize > 0 && */ r->bufferEmpty() && !r->error && !r->eof ) { // ### block on maxSize == 0? - qDebug( "%p: KDPipeIODevice::readData: waiting for bufferNotEmptyCondition (CONSUMER THREAD)", this ); - const TemporaryValue<bool> tmp( d->reader->consumerBlocksOnUs, true ); - r->bufferNotEmptyCondition.wait( &r->mutex ); - r->blockedConsumerIsDoneCondition.wakeAll(); - qDebug( "%p: KDPipeIODevice::readData: woke up from bufferNotEmptyCondition (CONSUMER THREAD)", this ); - } - - if ( r->bufferEmpty() ) { - qDebug( "%p: KDPipeIODevice::readData: got empty buffer, signal eof", this ); - // woken with an empty buffer must mean either EOF or error: - assert( r->eof || r->error ); - r->eofShortCut = true; - return r->eof ? 0 : -1 ; - } - - qDebug( "%p: KDPipeIODevice::readData: got bufferNotEmptyCondition, trying to read %lld bytes", this, maxSize ); - const qint64 bytesRead = r->readData( data, maxSize ); - qDebug( "%p: KDPipeIODevice::readData: read %lld bytes", this, bytesRead ); - qDebug( "%p (fd=%d): KDPipeIODevice::readData: %s", this, d->fd, data ); - - return bytesRead; -} - -qint64 Reader::readData( char * data, qint64 maxSize ) { - qint64 numRead = rptr < wptr ? wptr - rptr : sizeof buffer - rptr ; - if ( numRead > maxSize ) - numRead = maxSize; - - qDebug( "%p: KDPipeIODevice::readData: data=%p, maxSize=%lld; rptr=%u, wptr=%u (bytesInBuffer=%u); -> numRead=%lld", this, - data, maxSize, rptr, wptr, bytesInBuffer(), numRead ); - - std::memcpy( data, buffer + rptr, numRead ); - - rptr = ( rptr + numRead ) % sizeof buffer ; - - if ( !bufferFull() ) { - qDebug( "%p: KDPipeIODevice::readData: signal bufferNotFullCondition", this ); - bufferNotFullCondition.wakeAll(); - } - - return numRead; -} - -qint64 KDPipeIODevice::writeData( const char * data, qint64 size ) { KDAB_CHECK_THIS; - d->startWriterThread(); - Writer * const w = d->writer; - - assert( w ); - assert( w->error || w->isRunning() ); - assert( data || size == 0 ); - assert( size >= 0 ); - - LOCKED( w ); - - while ( !w->error && !w->bufferEmpty() ) { - qDebug( "%p: KDPipeIODevice::writeData: wait for empty buffer", this ); - w->bufferEmptyCondition.wait( &w->mutex ); - qDebug( "%p: KDPipeIODevice::writeData: empty buffer signaled", this ); - - } - if ( w->error ) - return -1; - - assert( w->bufferEmpty() ); - - return w->writeData( data, size ); -} - -qint64 Writer::writeData( const char * data, qint64 size ) { - assert( bufferEmpty() ); - - if ( size > static_cast<qint64>( sizeof buffer ) ) - size = sizeof buffer; - - std::memcpy( buffer, data, size ); - - numBytesInBuffer = size; - - if ( !bufferEmpty() ) { - bufferNotEmptyCondition.wakeAll(); - } - return size; -} - -void KDPipeIODevice::Private::stopThreads() -{ - if ( triedToStartWriter ) - { - if ( writer && q->bytesToWrite() > 0 ) - q->waitForBytesWritten( -1 ); - - assert( q->bytesToWrite() == 0 ); - } - if ( Reader * & r = reader ) { - disconnect( r, SIGNAL( readyRead() ), this, SLOT( emitReadyRead() ) ); - synchronized( r ) { - // tell thread to cancel: - r->cancel = true; - // and wake it, so it can terminate: - r->waitForCancelCondition.wakeAll(); - r->bufferNotFullCondition.wakeAll(); - r->readyReadSentCondition.wakeAll(); - } - } - if ( Writer * & w = writer ) { - synchronized( w ) { - // tell thread to cancel: - w->cancel = true; - // and wake it, so it can terminate: - w->bufferNotEmptyCondition.wakeAll(); - } - } -} - -void KDPipeIODevice::close() { KDAB_CHECK_THIS; - qDebug( "KDPipeIODevice::close(%p)", this ); - if ( !isOpen() ) - return; - - // tell clients we're about to close: - emit aboutToClose(); - d->stopThreads(); - -#define waitAndDelete( t ) if ( t ) { t->wait(); QThread* const t2 = t; t = 0; delete t2; } - qDebug( "KPipeIODevice::close(%p): wait and closing writer %p", this, d->writer ); - waitAndDelete( d->writer ); - qDebug( "KPipeIODevice::close(%p): wait and closing reader %p", this, d->reader ); - if ( d->reader ) { - LOCKED( d->reader ); - d->reader->readyReadSentCondition.wakeAll(); - } - waitAndDelete( d->reader ); -#undef waitAndDelete -#ifdef Q_OS_WIN32 - if ( d->fd != -1 ) - _close( d->fd ); - else - CloseHandle( d->handle ); -#else - ::close( d->fd ); -#endif - - setOpenMode( NotOpen ); - d->fd = -1; - d->handle = 0; -} - -void Reader::run() { - - LOCKED( this ); - - // too bad QThread doesn't have that itself; a signal isn't enough - hasStarted.wakeAll(); - - qDebug( "%p: Reader::run: started", this ); - - while ( true ) { - if ( !cancel && ( eof || error ) ) { - //notify the client until the buffer is empty and then once - //again so he receives eof/error. After that, wait for him - //to cancel - const bool wasEmpty = bufferEmpty(); - qDebug( "%p: Reader::run: received eof(%d) or error(%d), waking everyone", this, eof, error ); - notifyReadyRead(); - if ( !cancel && wasEmpty ) - waitForCancelCondition.wait( &mutex ); - } else if ( !cancel && !bufferFull() && !bufferEmpty() ) { - qDebug( "%p: Reader::run: buffer no longer empty, waking everyone", this ); - notifyReadyRead(); - } - - while ( !cancel && !error && bufferFull() ) { - notifyReadyRead(); - if ( !cancel && bufferFull() ) { - qDebug( "%p: Reader::run: buffer is full, going to sleep", this ); - bufferNotFullCondition.wait( &mutex ); - } - } - - if ( cancel ) { - qDebug( "%p: Reader::run: detected cancel", this ); - goto leave; - } - - if ( !eof && !error ) { - if ( rptr == wptr ) // optimize for larger chunks in case the buffer is empty - rptr = wptr = 0; - - unsigned int numBytes = ( rptr + sizeof buffer - wptr - 1 ) % sizeof buffer; - if ( numBytes > sizeof buffer - wptr ) - numBytes = sizeof buffer - wptr; - - qDebug( "%p: Reader::run: rptr=%d, wptr=%d -> numBytes=%d", this, rptr, wptr, numBytes ); - - assert( numBytes > 0 ); - - qDebug( "%p: Reader::run: trying to read %d bytes", this, numBytes ); -#ifdef Q_OS_WIN32 - isReading = true; - mutex.unlock(); - DWORD numRead; - const bool ok = ReadFile( handle, buffer + wptr, numBytes, &numRead, 0 ); - mutex.lock(); - isReading = false; - if ( ok ) { - if ( numRead == 0 ) { - qDebug( "%p: Reader::run: got eof (numRead==0)", this ); - eof = true; - } - } else { // !ok - errorCode = static_cast<int>( GetLastError() ); - if ( errorCode == ERROR_BROKEN_PIPE ) { - assert( numRead == 0 ); - qDebug( "%p: Reader::run: got eof (broken pipe)", this ); - eof = true; - } else { - assert( numRead == 0 ); - qDebug( "%p: Reader::run: got error: %s (%d)", this, strerror( errorCode ), errorCode ); - error = true; - } - } -#else - qint64 numRead; - mutex.unlock(); - do { - numRead = ::read( fd, buffer + wptr, numBytes ); - } while ( numRead == -1 && errno == EINTR ); - mutex.lock(); - - if ( numRead < 0 ) { - errorCode = errno; - error = true; - qDebug( "%p: Reader::run: got error: %d", this, errorCode ); - } else if ( numRead == 0 ) { - qDebug( "%p: Reader::run: eof detected", this ); - eof = true; - } -#endif - qDebug( "%p: Reader::run: read %ld bytes", this, static_cast<long>(numRead) ); - qDebug( "%p: Reader::run(fd=%d): %s", this, fd, buffer ); - - if ( numRead > 0 ) { - qDebug( "%p: Reader::run: buffer before: rptr=%4d, wptr=%4d", this, rptr, wptr ); - wptr = ( wptr + numRead ) % sizeof buffer; - qDebug( "%p: Reader::run: buffer after: rptr=%4d, wptr=%4d", this, rptr, wptr ); - } - } - } - leave: - qDebug( "%p: Reader::run: terminated", this ); -} - -void Reader::notifyReadyRead() -{ - qDebug( "notifyReadyRead: %d bytes available", bytesInBuffer() ); - assert( !cancel ); - - if ( consumerBlocksOnUs ) { - bufferNotEmptyCondition.wakeAll(); - blockedConsumerIsDoneCondition.wait( &mutex ); - return; - } - qDebug( "notifyReadyRead: emit signal" ); - emit readyRead(); - readyReadSentCondition.wait( &mutex ); - qDebug( "notifyReadyRead: returning from waiting, leave" ); -} - -void Writer::run() { - - LOCKED( this ); - - // too bad QThread doesn't have that itself; a signal isn't enough - hasStarted.wakeAll(); - - qDebug( "%p: Writer::run: started", this ); - - while ( true ) { - - while ( !cancel && bufferEmpty() ) { - qDebug( "%p: Writer::run: buffer is empty, wake bufferEmptyCond listeners", this ); - bufferEmptyCondition.wakeAll(); - emit bytesWritten( 0 ); - qDebug( "%p: Writer::run: buffer is empty, going to sleep", this ); - bufferNotEmptyCondition.wait( &mutex ); - qDebug( "%p: Writer::run: woke up", this ); - } - - if ( cancel ) { - qDebug( "%p: Writer::run: detected cancel", this ); - goto leave; - } - - assert( numBytesInBuffer > 0 ); - - qDebug( "%p: Writer::run: Trying to write %u bytes", this, numBytesInBuffer ); - qint64 totalWritten = 0; - do { - mutex.unlock(); -#ifdef Q_OS_WIN32 - DWORD numWritten; - qDebug( "%p (fd=%d): Writer::run: buffer before WriteFile (numBytes=%lld): %s:", this, fd, numBytesInBuffer, buffer ); - qDebug( "%p (fd=%d): Writer::run: Going into WriteFile", this, fd ); - if ( !WriteFile( handle, buffer + totalWritten, numBytesInBuffer - totalWritten, &numWritten, 0 ) ) { - mutex.lock(); - errorCode = static_cast<int>( GetLastError() ); - qDebug( "%p: Writer::run: got error code: %d", this, errorCode ); - error = true; - goto leave; - } -#else - qint64 numWritten; - do { - numWritten = ::write( fd, buffer + totalWritten, numBytesInBuffer - totalWritten ); - } while ( numWritten == -1 && errno == EINTR ); - - if ( numWritten < 0 ) { - mutex.lock(); - errorCode = errno; - qDebug( "%p: Writer::run: got error code: %d", this, errorCode ); - error = true; - goto leave; - } -#endif - qDebug( "%p (fd=%d): Writer::run: buffer after WriteFile (numBytes=%u): %s:", this, fd, numBytesInBuffer, buffer ); - totalWritten += numWritten; - mutex.lock(); - } while ( totalWritten < numBytesInBuffer ); - - qDebug( "%p: Writer::run: wrote %lld bytes", this, totalWritten ); - - numBytesInBuffer = 0; - - qDebug( "%p: Writer::run: buffer is empty, wake bufferEmptyCond listeners", this ); - bufferEmptyCondition.wakeAll(); - emit bytesWritten( totalWritten ); - } - leave: - qDebug( "%p: Writer::run: terminating", this ); - numBytesInBuffer = 0; - qDebug( "%p: Writer::run: buffer is empty, wake bufferEmptyCond listeners", this ); - bufferEmptyCondition.wakeAll(); - emit bytesWritten( 0 ); -} - -// static -std::pair<KDPipeIODevice*,KDPipeIODevice*> KDPipeIODevice::makePairOfConnectedPipes() { - KDPipeIODevice * read = 0; - KDPipeIODevice * write = 0; -#ifdef Q_OS_WIN32 - HANDLE rh; - HANDLE wh; - SECURITY_ATTRIBUTES sa; - memset( &sa, 0, sizeof(sa) ); - sa.nLength = sizeof(sa); - sa.bInheritHandle = TRUE; - if ( CreatePipe( &rh, &wh, &sa, BUFFER_SIZE ) ) { - read = new KDPipeIODevice; - read->open( rh, ReadOnly ); - write = new KDPipeIODevice; - write->open( wh, WriteOnly ); - } -#else - int fds[2]; - if ( pipe( fds ) == 0 ) { - read = new KDPipeIODevice; - read->open( fds[0], ReadOnly ); - write = new KDPipeIODevice; - write->open( fds[1], WriteOnly ); - } -#endif - return std::make_pair( read, write ); -} - -#ifdef KDAB_DEFINE_CHECKS -KDAB_DEFINE_CHECKS( KDPipeIODevice ) { - if ( !isOpen() ) { - assert( openMode() == NotOpen ); - assert( !d->reader ); - assert( !d->writer ); -#ifdef Q_OS_WIN32 - assert( !d->handle ); -#else - assert( d->fd < 0 ); -#endif - } else { - assert( openMode() != NotOpen ); - assert( openMode() & ReadWrite ); - if ( openMode() & ReadOnly ) { - assert( d->reader ); - synchronized( d->reader ) - assert( d->reader->eof || d->reader->error || d->reader->isRunning() ); - } - if ( openMode() & WriteOnly ) { - assert( d->writer ); - synchronized( d->writer ) - assert( d->writer->error || d->writer->isRunning() ); - } -#ifdef Q_OS_WIN32 - assert( d->handle ); -#else - assert( d->fd >= 0 ); -#endif - } -} -#endif // KDAB_DEFINE_CHECKS - -#include "moc_kdpipeiodevice.cpp" -#include "kdpipeiodevice.moc" diff --git a/src/kdpipeiodevice.h b/src/kdpipeiodevice.h deleted file mode 100644 index 8da6af68..00000000 --- a/src/kdpipeiodevice.h +++ /dev/null @@ -1,73 +0,0 @@ -/* - Copyright (C) 2007 Klar�lvdalens Datakonsult AB - - KDPipeIODevice is free software; you can redistribute it and/or - modify it under the terms of the GNU Library General Public - License as published by the Free Software Foundation; either - version 2 of the License, or (at your option) any later version. - - KDPipeIODevice is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU Library General Public License for more details. - - You should have received a copy of the GNU Library General Public License - along with KDPipeIODevice; see the file COPYING.LIB. If not, write to the - Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, - Boston, MA 02110-1301, USA. -*/ - -#ifndef __KDTOOLSCORE_KDPIPEIODEVICE_H__ -#define __KDTOOLSCORE_KDPIPEIODEVICE_H__ - -#include <QIODevice> - -#include <utility> - -//#include "checker.h" - -namespace _gpgme_ { - -class KDPipeIODevice : public QIODevice { - Q_OBJECT - //KDAB_MAKE_CHECKABLE( KDPipeIODevice ) -public: - explicit KDPipeIODevice( QObject * parent=0 ); - explicit KDPipeIODevice( int fd, OpenMode=ReadOnly, QObject * parent=0 ); - explicit KDPipeIODevice( Qt::HANDLE handle, OpenMode=ReadOnly, QObject * parent=0 ); - ~KDPipeIODevice(); - - static std::pair<KDPipeIODevice*, KDPipeIODevice*> makePairOfConnectedPipes(); - - bool open( int fd, OpenMode mode=ReadOnly ); - bool open( Qt::HANDLE handle, OpenMode mode=ReadOnly ); - - Qt::HANDLE handle() const; - int descriptor() const; - - bool readWouldBlock() const; - bool writeWouldBlock() const; - - /* reimp */ qint64 bytesAvailable() const; - /* reimp */ qint64 bytesToWrite() const; - /* reimp */ bool canReadLine() const; - /* reimp */ void close(); - /* reimp */ bool isSequential() const; - /* reimp */ bool atEnd() const; - - /* reimp */ bool waitForBytesWritten( int msecs ); - /* reimp */ bool waitForReadyRead( int msecs ); - -protected: - /* reimp */ qint64 readData( char * data, qint64 maxSize ); - /* reimp */ qint64 writeData( const char * data, qint64 maxSize ); - -private: - class Private; - Private * d; -}; - -} /* namespace _gpgme_ */ - -#endif /* __KDTOOLSCORE_KDPIPEIODEVICE_H__ */ - diff --git a/src/kdpipeiodevice.moc b/src/kdpipeiodevice.moc deleted file mode 100644 index 457f371a..00000000 --- a/src/kdpipeiodevice.moc +++ /dev/null @@ -1,183 +0,0 @@ -/**************************************************************************** -** Meta object code from reading C++ file 'kdpipeiodevice.cpp' -** -** Created: Tue Oct 2 19:30:13 2007 -** by: The Qt Meta Object Compiler version 59 (Qt 4.3.1) -** -** WARNING! All changes made in this file will be lost! -*****************************************************************************/ - -#if !defined(Q_MOC_OUTPUT_REVISION) -#error "The header file 'kdpipeiodevice.cpp' doesn't include <QObject>." -#elif Q_MOC_OUTPUT_REVISION != 59 -#error "This file was generated using the moc from 4.3.1. It" -#error "cannot be used with the include files from this version of Qt." -#error "(The moc has changed too much.)" -#endif - -static const uint qt_meta_data_Reader[] = { - - // content: - 1, // revision - 0, // classname - 0, 0, // classinfo - 1, 10, // methods - 0, 0, // properties - 0, 0, // enums/sets - - // signals: signature, parameters, type, tag, flags - 8, 7, 7, 7, 0x05, - - 0 // eod -}; - -static const char qt_meta_stringdata_Reader[] = { - "Reader\0\0readyRead()\0" -}; - -const QMetaObject Reader::staticMetaObject = { - { &QThread::staticMetaObject, qt_meta_stringdata_Reader, - qt_meta_data_Reader, 0 } -}; - -const QMetaObject *Reader::metaObject() const -{ - return &staticMetaObject; -} - -void *Reader::qt_metacast(const char *_clname) -{ - if (!_clname) return 0; - if (!strcmp(_clname, qt_meta_stringdata_Reader)) - return static_cast<void*>(const_cast< Reader*>(this)); - return QThread::qt_metacast(_clname); -} - -int Reader::qt_metacall(QMetaObject::Call _c, int _id, void **_a) -{ - _id = QThread::qt_metacall(_c, _id, _a); - if (_id < 0) - return _id; - if (_c == QMetaObject::InvokeMetaMethod) { - switch (_id) { - case 0: readyRead(); break; - } - _id -= 1; - } - return _id; -} - -// SIGNAL 0 -void Reader::readyRead() -{ - QMetaObject::activate(this, &staticMetaObject, 0, 0); -} -static const uint qt_meta_data_Writer[] = { - - // content: - 1, // revision - 0, // classname - 0, 0, // classinfo - 1, 10, // methods - 0, 0, // properties - 0, 0, // enums/sets - - // signals: signature, parameters, type, tag, flags - 8, 7, 7, 7, 0x05, - - 0 // eod -}; - -static const char qt_meta_stringdata_Writer[] = { - "Writer\0\0bytesWritten(qint64)\0" -}; - -const QMetaObject Writer::staticMetaObject = { - { &QThread::staticMetaObject, qt_meta_stringdata_Writer, - qt_meta_data_Writer, 0 } -}; - -const QMetaObject *Writer::metaObject() const -{ - return &staticMetaObject; -} - -void *Writer::qt_metacast(const char *_clname) -{ - if (!_clname) return 0; - if (!strcmp(_clname, qt_meta_stringdata_Writer)) - return static_cast<void*>(const_cast< Writer*>(this)); - return QThread::qt_metacast(_clname); -} - -int Writer::qt_metacall(QMetaObject::Call _c, int _id, void **_a) -{ - _id = QThread::qt_metacall(_c, _id, _a); - if (_id < 0) - return _id; - if (_c == QMetaObject::InvokeMetaMethod) { - switch (_id) { - case 0: bytesWritten((*reinterpret_cast< qint64(*)>(_a[1]))); break; - } - _id -= 1; - } - return _id; -} - -// SIGNAL 0 -void Writer::bytesWritten(qint64 _t1) -{ - void *_a[] = { 0, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) }; - QMetaObject::activate(this, &staticMetaObject, 0, _a); -} -static const uint qt_meta_data_KDPipeIODevice__Private[] = { - - // content: - 1, // revision - 0, // classname - 0, 0, // classinfo - 1, 10, // methods - 0, 0, // properties - 0, 0, // enums/sets - - // slots: signature, parameters, type, tag, flags - 25, 24, 24, 24, 0x0a, - - 0 // eod -}; - -static const char qt_meta_stringdata_KDPipeIODevice__Private[] = { - "KDPipeIODevice::Private\0\0emitReadyRead()\0" -}; - -const QMetaObject KDPipeIODevice::Private::staticMetaObject = { - { &QObject::staticMetaObject, qt_meta_stringdata_KDPipeIODevice__Private, - qt_meta_data_KDPipeIODevice__Private, 0 } -}; - -const QMetaObject *KDPipeIODevice::Private::metaObject() const -{ - return &staticMetaObject; -} - -void *KDPipeIODevice::Private::qt_metacast(const char *_clname) -{ - if (!_clname) return 0; - if (!strcmp(_clname, qt_meta_stringdata_KDPipeIODevice__Private)) - return static_cast<void*>(const_cast< Private*>(this)); - return QObject::qt_metacast(_clname); -} - -int KDPipeIODevice::Private::qt_metacall(QMetaObject::Call _c, int _id, void **_a) -{ - _id = QObject::qt_metacall(_c, _id, _a); - if (_id < 0) - return _id; - if (_c == QMetaObject::InvokeMetaMethod) { - switch (_id) { - case 0: emitReadyRead(); break; - } - _id -= 1; - } - return _id; -} diff --git a/src/w32-qt-io.cpp b/src/w32-qt-io.cpp deleted file mode 100644 index 44655ecb..00000000 --- a/src/w32-qt-io.cpp +++ /dev/null @@ -1,700 +0,0 @@ -/* w32-qt-io.c - W32 Glib I/O functions - Copyright (C) 2000 Werner Koch (dd9jn) - Copyright (C) 2001, 2002, 2004, 2005, 2007 g10 Code GmbH - - This file is part of GPGME. - - GPGME is free software; you can redistribute it and/or modify it - under the terms of the GNU Lesser General Public License as - published by the Free Software Foundation; either version 2.1 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 - Lesser General Public License for more details. - - You should have received a copy of the GNU Lesser General Public - License along with this program; if not, write to the Free Software - Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA - 02111-1307, USA. */ - -#ifdef HAVE_CONFIG_H -#include <config.h> -#endif -#include <stdio.h> -#include <stdlib.h> -#include <string.h> -#include <assert.h> -#include <errno.h> -#include <fcntl.h> -#include <unistd.h> -#include <sys/time.h> -#include <sys/types.h> -#include <windows.h> -#include <io.h> - -#include "kdpipeiodevice.h" - -extern "C" -{ -#include "util.h" -#include "priv-io.h" -#include "sema.h" -#include "debug.h" -} - -#ifndef O_BINARY -#ifdef _O_BINARY -#define O_BINARY _O_BINARY -#else -#define O_BINARY 0 -#endif -#endif - -using _gpgme_::KDPipeIODevice; - - -/* This file is an ugly hack to get GPGME working with Qt on Windows - targets. On Windows, you can not select() on file descriptors. - - The only way to check if there is something to read is to read - something. This means that GPGME can not let Qt check for data - without letting Qt also handle the data on Windows targets. - - The ugly consequence is that we need to work on QIODevices in - GPGME, creating a Qt dependency. Also, we need to export an - interface for the application to get at GPGME's QIODevices. There - is no good way to abstract all this with callbacks, because the - whole thing is also interconnected with the creation of pipes and - child processes. - - The following rule applies only to this I/O backend: - - * ALL operations must use the user defined event loop. GPGME can - not anymore provide its own event loop. This is mostly a sanity - requirement: Although we have in theory all information we need to - make the GPGME W32 code for select still work, it would be a big - complication and require changes throughout GPGME. - - Eventually, we probably have to bite the bullet and make some - really nice callback interfaces to let the user control all this at - a per-context level. */ - -#define MAX_SLAFD 1024 - -struct DeviceEntry { - DeviceEntry() : iodev( 0 ), refCount( 1 ), blocking( true ) {} - KDPipeIODevice* iodev; - bool blocking; - mutable int refCount; - void ref() const { ++refCount; } - int unref() const { assert( refCount > 0 ); return --refCount; } -}; - -DeviceEntry* iodevice_table[MAX_SLAFD]; - - -static KDPipeIODevice * -find_channel (int fd, int create) -{ - assert( fd < MAX_SLAFD ); - if (fd < 0 || fd >= MAX_SLAFD) - return NULL; - - if (create && !iodevice_table[fd]) - { - DeviceEntry* entry = new DeviceEntry; - entry->iodev = new KDPipeIODevice - (fd, QIODevice::ReadWrite|QIODevice::Unbuffered); - iodevice_table[fd] = entry; - } - return iodevice_table[fd] ? iodevice_table[fd]->iodev : 0; -} - -/* Write the printable version of FD to the buffer BUF of length - BUFLEN. The printable version is the representation on the command - line that the child process expects. */ -int -_gpgme_io_fd2str (char *buf, int buflen, int fd) -{ - return snprintf (buf, buflen, "%d", (long)_get_osfhandle( fd ) ); -} - - -void -_gpgme_io_subsystem_init (void) -{ -} - - -static struct -{ - _gpgme_close_notify_handler_t handler; - void *value; -} notify_table[MAX_SLAFD]; - - -int -_gpgme_io_read (int fd, void *buffer, size_t count) -{ - int saved_errno = 0; - qint64 nread; - KDPipeIODevice *chan; - TRACE_BEG2 (DEBUG_SYSIO, "_gpgme_io_read", fd, - "buffer=%p, count=%u", buffer, count); - - chan = find_channel (fd, 0); - if (!chan) - { - TRACE_LOG ("no channel registered"); - errno = EINVAL; - return TRACE_SYSRES (-1); - } - TRACE_LOG1 ("channel %p", chan); - if ( iodevice_table[fd] && !iodevice_table[fd]->blocking && chan->readWouldBlock() ) { - errno = EAGAIN; - return TRACE_SYSRES( -1 ); - } - - nread = chan->read ((char *) buffer, count); - if (nread < 0) - { - TRACE_LOG1 ("err %s", qPrintable (chan->errorString ())); - saved_errno = EIO; - nread = -1; - } - - TRACE_LOGBUF ((char *) buffer, nread); - - errno = saved_errno; - return TRACE_SYSRES (nread); -} - - -int -_gpgme_io_write (int fd, const void *buffer, size_t count) -{ - qint64 nwritten; - KDPipeIODevice *chan; - TRACE_BEG2 (DEBUG_SYSIO, "_gpgme_io_write", fd, - "buffer=%p, count=%u", buffer, count); - TRACE_LOGBUF ((char *) buffer, count); - - chan = find_channel (fd, 0); - if (!chan) - { - TRACE_LOG ("fd %d: no channel registered"); - errno = EINVAL; - return -1; - } - - if ( iodevice_table[fd] && !iodevice_table[fd]->blocking && chan->writeWouldBlock() ) - { - errno = EAGAIN; - return TRACE_SYSRES( -1 ); - } - nwritten = chan->write ((char *) buffer, count); - - if (nwritten < 0) - { - nwritten = -1; - errno = EIO; - return TRACE_SYSRES(-1); - } - errno = 0; - return TRACE_SYSRES (nwritten); -} - - -int -_gpgme_io_pipe (int filedes[2], int inherit_idx) -{ - KDPipeIODevice *chan; - TRACE_BEG2 (DEBUG_SYSIO, "_gpgme_io_pipe", filedes, - "inherit_idx=%i (GPGME uses it for %s)", - inherit_idx, inherit_idx ? "reading" : "writing"); - -#define PIPEBUF_SIZE 4096 - if (_pipe (filedes, PIPEBUF_SIZE, O_NOINHERIT | O_BINARY) == -1) - return TRACE_SYSRES (-1); - - /* Make one end inheritable. */ - if (inherit_idx == 0) - { - int new_read; - - new_read = _dup (filedes[0]); - _close (filedes[0]); - filedes[0] = new_read; - - if (new_read < 0) - { - _close (filedes[1]); - return TRACE_SYSRES (-1); - } - } - else if (inherit_idx == 1) - { - int new_write; - - new_write = _dup (filedes[1]); - _close (filedes[1]); - filedes[1] = new_write; - - if (new_write < 0) - { - _close (filedes[0]); - return TRACE_SYSRES (-1); - } - } - - /* Now we have a pipe with the right end inheritable. The other end - should have a giochannel. */ - - chan = find_channel (filedes[1 - inherit_idx], 1); - - if (!chan) - { - int saved_errno = errno; - _close (filedes[0]); - _close (filedes[1]); - errno = saved_errno; - return TRACE_SYSRES (-1); - } - - return TRACE_SUC5 ("read=0x%x/%p, write=0x%x/%p, channel=%p", - filedes[0], (HANDLE) _get_osfhandle (filedes[0]), - filedes[1], (HANDLE) _get_osfhandle (filedes[1]), - chan); -} - -int -_gpgme_io_close (int fd) -{ - KDPipeIODevice *chan; - TRACE_BEG (DEBUG_SYSIO, "_gpgme_io_close", fd); - - if (fd < 0 || fd >= MAX_SLAFD) - { - errno = EBADF; - return TRACE_SYSRES (-1); - } - - /* First call the notify handler. */ - if (notify_table[fd].handler) - { - notify_table[fd].handler (fd, notify_table[fd].value); - notify_table[fd].handler = NULL; - notify_table[fd].value = NULL; - } - - /* Then do the close. */ - - DeviceEntry* const entry = iodevice_table[fd]; - if ( entry ) { - if ( entry->unref() == 0 ) { - entry->iodev->close(); - delete entry->iodev; - delete entry; - iodevice_table[fd] = 0; - } - } else { - _close( fd ); - } - - - - return 0; -} - - -int -_gpgme_io_set_close_notify (int fd, _gpgme_close_notify_handler_t handler, - void *value) -{ - TRACE_BEG2 (DEBUG_SYSIO, "_gpgme_io_set_close_notify", fd, - "close_handler=%p/%p", handler, value); - - assert (fd != -1); - - if (fd < 0 || fd >= (int) DIM (notify_table)) - { - errno = EINVAL; - return TRACE_SYSRES (-1); - } - notify_table[fd].handler = handler; - notify_table[fd].value = value; - return TRACE_SYSRES (0); -} - - -int -_gpgme_io_set_nonblocking (int fd) -{ - DeviceEntry* const entry = iodevice_table[fd]; - assert( entry ); - entry->blocking = false; - TRACE_BEG (DEBUG_SYSIO, "_gpgme_io_set_nonblocking", fd); - return TRACE_SYSRES (0); -} - - -static char * -build_commandline (char **argv) -{ - int i; - int n = 0; - char *buf; - char *p; - - /* We have to quote some things because under Windows the program - parses the commandline and does some unquoting. We enclose the - whole argument in double-quotes, and escape literal double-quotes - as well as backslashes with a backslash. We end up with a - trailing space at the end of the line, but that is harmless. */ - for (i = 0; argv[i]; i++) - { - p = argv[i]; - /* The leading double-quote. */ - n++; - while (*p) - { - /* An extra one for each literal that must be escaped. */ - if (*p == '\\' || *p == '"') - n++; - n++; - p++; - } - /* The trailing double-quote and the delimiter. */ - n += 2; - } - /* And a trailing zero. */ - n++; - - buf = p = (char *) malloc (n); - if (!buf) - return NULL; - for (i = 0; argv[i]; i++) - { - char *argvp = argv[i]; - - *(p++) = '"'; - while (*argvp) - { - if (*argvp == '\\' || *argvp == '"') - *(p++) = '\\'; - *(p++) = *(argvp++); - } - *(p++) = '"'; - *(p++) = ' '; - } - *(p++) = 0; - - return buf; -} - - -int -_gpgme_io_spawn (const char *path, char * const argv[], unsigned int flags, - struct spawn_fd_item_s *fd_list, - void (*atfork) (void *opaque, int reserved), - void *atforkvalue, pid_t *r_pid) -{ - SECURITY_ATTRIBUTES sec_attr; - PROCESS_INFORMATION pi = - { - NULL, /* returns process handle */ - 0, /* returns primary thread handle */ - 0, /* returns pid */ - 0 /* returns tid */ - }; - STARTUPINFO si; - int cr_flags = CREATE_DEFAULT_ERROR_MODE - | GetPriorityClass (GetCurrentProcess ()); - int i; - char **args; - char *arg_string; - /* FIXME. */ - int debug_me = 0; - int tmp_fd; - char *tmp_name; - - TRACE_BEG1 (DEBUG_SYSIO, "_gpgme_io_spawn", path, - "path=%s", path); - i = 0; - while (argv[i]) - { - TRACE_LOG2 ("argv[%2i] = %s", i, argv[i]); - i++; - } - - /* We do not inherit any handles by default, and just insert those - handles we want the child to have afterwards. But some handle - values occur on the command line, and we need to move - stdin/out/err to the right location. So we use a wrapper program - which gets the information from a temporary file. */ - if (_gpgme_mkstemp (&tmp_fd, &tmp_name) < 0) - { - TRACE_LOG1 ("_gpgme_mkstemp failed: %s", strerror (errno)); - return TRACE_SYSRES (-1); - } - TRACE_LOG1 ("tmp_name = %s", tmp_name); - - args = (char **) calloc (2 + i + 1, sizeof (*args)); - args[0] = (char *) _gpgme_get_w32spawn_path (); - args[1] = tmp_name; - args[2] = const_cast<char *>(path); - memcpy (&args[3], &argv[1], i * sizeof (*args)); - - memset (&sec_attr, 0, sizeof sec_attr); - sec_attr.nLength = sizeof sec_attr; - sec_attr.bInheritHandle = FALSE; - - arg_string = build_commandline (args); - free (args); - if (!arg_string) - { - close (tmp_fd); - DeleteFile (tmp_name); - return TRACE_SYSRES (-1); - } - - memset (&si, 0, sizeof si); - si.cb = sizeof (si); - si.dwFlags = STARTF_USESTDHANDLES | STARTF_USESHOWWINDOW; - si.wShowWindow = debug_me ? SW_SHOW : SW_HIDE; - si.hStdInput = INVALID_HANDLE_VALUE; - si.hStdOutput = INVALID_HANDLE_VALUE; - si.hStdError = INVALID_HANDLE_VALUE; - - cr_flags |= CREATE_SUSPENDED; - if ((flags & IOSPAWN_FLAG_DETACHED)) - cr_flags |= DETACHED_PROCESS; - if (!CreateProcessA (_gpgme_get_w32spawn_path (), - arg_string, - &sec_attr, /* process security attributes */ - &sec_attr, /* thread security attributes */ - FALSE, /* inherit handles */ - cr_flags, /* creation flags */ - NULL, /* environment */ - NULL, /* use current drive/directory */ - &si, /* startup information */ - &pi)) /* returns process information */ - { - TRACE_LOG1 ("CreateProcess failed: ec=%d", (int) GetLastError ()); - free (arg_string); - close (tmp_fd); - DeleteFile (tmp_name); - - /* FIXME: Should translate the error code. */ - errno = EIO; - return TRACE_SYSRES (-1); - } - - free (arg_string); - - if (flags & IOSPAWN_FLAG_ALLOW_SET_FG) - _gpgme_allow_set_foreground_window ((pid_t)pi.dwProcessId); - - /* Insert the inherited handles. */ - for (i = 0; fd_list[i].fd != -1; i++) - { - HANDLE hd; - - if (!DuplicateHandle (GetCurrentProcess(), - (HANDLE) _get_osfhandle (fd_list[i].fd), - pi.hProcess, &hd, 0, TRUE, DUPLICATE_SAME_ACCESS)) - { - TRACE_LOG1 ("DuplicateHandle failed: ec=%d", (int) GetLastError ()); - TerminateProcess (pi.hProcess, 0); - /* Just in case TerminateProcess didn't work, let the - process fail on its own. */ - ResumeThread (pi.hThread); - CloseHandle (pi.hThread); - CloseHandle (pi.hProcess); - - close (tmp_fd); - DeleteFile (tmp_name); - - /* FIXME: Should translate the error code. */ - errno = EIO; - return TRACE_SYSRES (-1); - } - /* Return the child name of this handle. */ - fd_list[i].peer_name = (int) hd; - } - - /* Write the handle translation information to the temporary - file. */ - { - /* Hold roughly MAX_TRANS quadruplets of 64 bit numbers in hex - notation: "0xFEDCBA9876543210" with an extra white space after - every quadruplet. 10*(19*4 + 1) - 1 = 769. This plans ahead - for a time when a HANDLE is 64 bit. */ -#define BUFFER_MAX 800 - char line[BUFFER_MAX + 1]; - int res; - int written; - size_t len; - - if ((flags & IOSPAWN_FLAG_ALLOW_SET_FG)) - strcpy (line, "~1 \n"); - else - strcpy (line, "\n"); - for (i = 0; fd_list[i].fd != -1; i++) - { - /* Strip the newline. */ - len = strlen (line) - 1; - - /* Format is: Local name, stdin/stdout/stderr, peer name, argv idx. */ - snprintf (&line[len], BUFFER_MAX - len, "0x%x %d 0x%x %d \n", - fd_list[i].fd, fd_list[i].dup_to, - fd_list[i].peer_name, fd_list[i].arg_loc); - /* Rather safe than sorry. */ - line[BUFFER_MAX - 1] = '\n'; - line[BUFFER_MAX] = '\0'; - } - len = strlen (line); - written = 0; - do - { - res = write (tmp_fd, &line[written], len - written); - if (res > 0) - written += res; - } - while (res > 0 || (res < 0 && errno == EAGAIN)); - } - close (tmp_fd); - /* The temporary file is deleted by the gpgme-w32spawn process - (hopefully). */ - - TRACE_LOG4 ("CreateProcess ready: hProcess=%p, hThread=%p, " - "dwProcessID=%d, dwThreadId=%d", - pi.hProcess, pi.hThread, - (int) pi.dwProcessId, (int) pi.dwThreadId); - - if (r_pid) - *r_pid = (pid_t)pi.dwProcessId; - - if (ResumeThread (pi.hThread) < 0) - TRACE_LOG1 ("ResumeThread failed: ec=%d", (int) GetLastError ()); - - if (!CloseHandle (pi.hThread)) - TRACE_LOG1 ("CloseHandle of thread failed: ec=%d", - (int) GetLastError ()); - - TRACE_LOG1 ("process=%p", pi.hProcess); - - /* We don't need to wait for the process. */ - if (!CloseHandle (pi.hProcess)) - TRACE_LOG1 ("CloseHandle of process failed: ec=%d", - (int) GetLastError ()); - - for (i = 0; fd_list[i].fd != -1; i++) - _gpgme_io_close (fd_list[i].fd); - - for (i = 0; fd_list[i].fd != -1; i++) - if (fd_list[i].dup_to == -1) - TRACE_LOG3 ("fd[%i] = 0x%x -> 0x%x", i, fd_list[i].fd, - fd_list[i].peer_name); - else - TRACE_LOG4 ("fd[%i] = 0x%x -> 0x%x (std%s)", i, fd_list[i].fd, - fd_list[i].peer_name, (fd_list[i].dup_to == 0) ? "in" : - ((fd_list[i].dup_to == 1) ? "out" : "err")); - - return TRACE_SYSRES (0); -} - - -/* Select on the list of fds. Returns: -1 = error, 0 = timeout or - nothing to select, > 0 = number of signaled fds. */ -int -_gpgme_io_select (struct io_select_fd_s *fds, size_t nfds, int nonblock) -{ - /* Use a 1s timeout. */ - - void *dbg_help = NULL; - TRACE_BEG2 (DEBUG_SYSIO, "_gpgme_io_select", fds, - "nfds=%u, nonblock=%u", nfds, nonblock); - - int count = 0; - - TRACE_SEQ (dbg_help, "select on [ "); - for (int i = 0; i < nfds; i++) - { - if (fds[i].fd == -1) - { - fds[i].signaled = 0; - } - else if (fds[i].for_read ) - { - KDPipeIODevice * const chan = find_channel (fds[i].fd, 0); - assert (chan); - if ( nonblock ) - fds[i].signaled = chan->readWouldBlock() ? 0 : 1; - else - fds[i].signaled = chan->waitForReadyRead( 1000 ) ? 1 : 0; - TRACE_ADD1 (dbg_help, "w0x%x ", fds[i].fd); - if ( fds[i].signaled ) - count++; - } - else if (fds[i].for_write) - { - const KDPipeIODevice * const chan = find_channel (fds[i].fd, 0); - assert (chan); - fds[i].signaled = nonblock ? ( chan->writeWouldBlock() ? 0 : 1 ) : 1; - TRACE_ADD1 (dbg_help, "w0x%x ", fds[i].fd); - if ( fds[i].signaled ) - count++; - } - } - TRACE_END (dbg_help, "]"); - - return TRACE_SYSRES (count); -} - - -/* Look up the qiodevice for file descriptor FD. */ -extern "C" -void * -gpgme_get_fdptr (int fd) -{ - return find_channel (fd, 0); -} - - -/* Obsolete compatibility interface. */ -extern "C" -void * -gpgme_get_giochannel (int fd) -{ - return NULL; -} - - -int -_gpgme_io_dup (int fd) -{ - assert( iodevice_table[fd] ); - iodevice_table[fd]->ref(); - return fd; -} - - -extern "C" -int -_gpgme_io_socket (int domain, int type, int proto) -{ - errno = EIO; - return -1; -} - - -extern "C" -int -_gpgme_io_connect (int fd, struct sockaddr *addr, int addrlen) -{ - errno = EIO; - return -1; -} |