LCOV - code coverage report
Current view: top level - lang/cpp/src - importresult.cpp (source / functions) Hit Total Coverage
Test: coverage.info Lines: 36 94 38.3 %
Date: 2018-11-14 16:53:58 Functions: 8 30 26.7 %

          Line data    Source code
       1             : /*
       2             :   importresult.cpp - wraps a gpgme import result
       3             :   Copyright (C) 2004 Klarälvdalens Datakonsult AB
       4             :   2016 Bundesamt für Sicherheit in der Informationstechnik
       5             :   Software engineering by Intevation GmbH
       6             : 
       7             :   This file is part of GPGME++.
       8             : 
       9             :   GPGME++ is free software; you can redistribute it and/or
      10             :   modify it under the terms of the GNU Library General Public
      11             :   License as published by the Free Software Foundation; either
      12             :   version 2 of the License, or (at your option) any later version.
      13             : 
      14             :   GPGME++ is distributed in the hope that it will be useful,
      15             :   but WITHOUT ANY WARRANTY; without even the implied warranty of
      16             :   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      17             :   GNU Library General Public License for more details.
      18             : 
      19             :   You should have received a copy of the GNU Library General Public License
      20             :   along with GPGME++; see the file COPYING.LIB.  If not, write to the
      21             :   Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
      22             :   Boston, MA 02110-1301, USA.
      23             : */
      24             : 
      25             : 
      26             : #ifdef HAVE_CONFIG_H
      27             :  #include "config.h"
      28             : #endif
      29             : 
      30             : #include <importresult.h>
      31             : #include "result_p.h"
      32             : 
      33             : #include <gpgme.h>
      34             : #include <cstdlib>
      35             : #include <cstring>
      36             : 
      37             : #include <string.h>
      38             : 
      39             : class GpgME::ImportResult::Private
      40             : {
      41             : public:
      42           2 :     Private(const _gpgme_op_import_result &r) : res(r)
      43             :     {
      44             :         // copy recursively, using compiler-generated copy ctor.
      45             :         // We just need to handle the pointers in the structs:
      46           4 :         for (gpgme_import_status_t is = r.imports ; is ; is = is->next) {
      47           2 :             gpgme_import_status_t copy = new _gpgme_import_status(*is);
      48           2 :             copy->fpr = strdup(is->fpr);
      49           2 :             copy->next = 0;
      50           2 :             imports.push_back(copy);
      51             :         }
      52           2 :         res.imports = 0;
      53           2 :     }
      54           2 :     ~Private()
      55           2 :     {
      56           4 :         for (std::vector<gpgme_import_status_t>::iterator it = imports.begin() ; it != imports.end() ; ++it) {
      57           2 :             std::free((*it)->fpr);
      58           2 :             delete *it; *it = 0;
      59             :         }
      60           2 :     }
      61             : 
      62             :     _gpgme_op_import_result res;
      63             :     std::vector<gpgme_import_status_t> imports;
      64             : };
      65             : 
      66           0 : GpgME::ImportResult::ImportResult(gpgme_ctx_t ctx, int error)
      67           0 :     : GpgME::Result(error), d()
      68             : {
      69           0 :     init(ctx);
      70           0 : }
      71             : 
      72           2 : GpgME::ImportResult::ImportResult(gpgme_ctx_t ctx, const Error &error)
      73           2 :     : GpgME::Result(error), d()
      74             : {
      75           2 :     init(ctx);
      76           2 : }
      77             : 
      78           2 : void GpgME::ImportResult::init(gpgme_ctx_t ctx)
      79             : {
      80           2 :     if (!ctx) {
      81           0 :         return;
      82             :     }
      83           2 :     gpgme_import_result_t res = gpgme_op_import_result(ctx);
      84           2 :     if (!res) {
      85           0 :         return;
      86             :     }
      87           2 :     d.reset(new Private(*res));
      88             : }
      89             : 
      90           4 : make_standard_stuff(ImportResult)
      91             : 
      92           0 : int GpgME::ImportResult::numConsidered() const
      93             : {
      94           0 :     return d ? d->res.considered : 0 ;
      95             : }
      96             : 
      97           0 : int GpgME::ImportResult::numKeysWithoutUserID() const
      98             : {
      99           0 :     return d ? d->res.no_user_id : 0 ;
     100             : }
     101             : 
     102           2 : int GpgME::ImportResult::numImported() const
     103             : {
     104           2 :     return d ? d->res.imported : 0 ;
     105             : }
     106             : 
     107           0 : int GpgME::ImportResult::numRSAImported() const
     108             : {
     109           0 :     return d ? d->res.imported_rsa : 0 ;
     110             : }
     111             : 
     112           0 : int GpgME::ImportResult::numUnchanged() const
     113             : {
     114           0 :     return d ? d->res.unchanged : 0 ;
     115             : }
     116             : 
     117           0 : int GpgME::ImportResult::newUserIDs() const
     118             : {
     119           0 :     return d ? d->res.new_user_ids : 0 ;
     120             : }
     121             : 
     122           0 : int GpgME::ImportResult::newSubkeys() const
     123             : {
     124           0 :     return d ? d->res.new_sub_keys : 0 ;
     125             : }
     126             : 
     127           0 : int GpgME::ImportResult::newSignatures() const
     128             : {
     129           0 :     return d ? d->res.new_signatures : 0 ;
     130             : }
     131             : 
     132           0 : int GpgME::ImportResult::newRevocations() const
     133             : {
     134           0 :     return d ? d->res.new_revocations : 0 ;
     135             : }
     136             : 
     137           0 : int GpgME::ImportResult::numSecretKeysConsidered() const
     138             : {
     139           0 :     return d ? d->res.secret_read : 0 ;
     140             : }
     141             : 
     142           0 : int GpgME::ImportResult::numSecretKeysImported() const
     143             : {
     144           0 :     return d ? d->res.secret_imported : 0 ;
     145             : }
     146             : 
     147           0 : int GpgME::ImportResult::numSecretKeysUnchanged() const
     148             : {
     149           0 :     return d ? d->res.secret_unchanged : 0 ;
     150             : }
     151             : 
     152           0 : int GpgME::ImportResult::notImported() const
     153             : {
     154           0 :     return d ? d->res.not_imported : 0 ;
     155             : }
     156             : 
     157           0 : int GpgME::ImportResult::numV3KeysSkipped() const
     158             : {
     159           0 :     return d ? d->res.skipped_v3_keys : 0 ;
     160             : }
     161             : 
     162           0 : GpgME::Import GpgME::ImportResult::import(unsigned int idx) const
     163             : {
     164           0 :     return Import(d, idx);
     165             : }
     166             : 
     167           2 : std::vector<GpgME::Import> GpgME::ImportResult::imports() const
     168             : {
     169           2 :     if (!d) {
     170           0 :         return std::vector<Import>();
     171             :     }
     172           4 :     std::vector<Import> result;
     173           2 :     result.reserve(d->imports.size());
     174           4 :     for (unsigned int i = 0 ; i < d->imports.size() ; ++i) {
     175           2 :         result.push_back(Import(d, i));
     176             :     }
     177           2 :     return result;
     178             : }
     179             : 
     180           2 : GpgME::Import::Import(const std::shared_ptr<ImportResult::Private> &parent, unsigned int i)
     181           2 :     : d(parent), idx(i)
     182             : {
     183             : 
     184           2 : }
     185             : 
     186           0 : GpgME::Import::Import() : d(), idx(0) {}
     187             : 
     188           0 : bool GpgME::Import::isNull() const
     189             : {
     190           0 :     return !d || idx >= d->imports.size() ;
     191             : }
     192             : 
     193           0 : const char *GpgME::Import::fingerprint() const
     194             : {
     195           0 :     return isNull() ? 0 : d->imports[idx]->fpr ;
     196             : }
     197             : 
     198           0 : GpgME::Error GpgME::Import::error() const
     199             : {
     200           0 :     return Error(isNull() ? 0 : d->imports[idx]->result);
     201             : }
     202             : 
     203           0 : GpgME::Import::Status GpgME::Import::status() const
     204             : {
     205           0 :     if (isNull()) {
     206           0 :         return Unknown;
     207             :     }
     208           0 :     const unsigned int s = d->imports[idx]->status;
     209           0 :     unsigned int result = Unknown;
     210           0 :     if (s & GPGME_IMPORT_NEW) {
     211           0 :         result |= NewKey;
     212             :     }
     213           0 :     if (s & GPGME_IMPORT_UID) {
     214           0 :         result |= NewUserIDs;
     215             :     }
     216           0 :     if (s & GPGME_IMPORT_SIG) {
     217           0 :         result |= NewSignatures;
     218             :     }
     219           0 :     if (s & GPGME_IMPORT_SUBKEY) {
     220           0 :         result |= NewSubkeys;
     221             :     }
     222           0 :     if (s & GPGME_IMPORT_SECRET) {
     223           0 :         result |= ContainedSecretKey;
     224             :     }
     225           0 :     return static_cast<Status>(result);
     226             : }

Generated by: LCOV version 1.13