LCOV - code coverage report
Current view: top level - lang/cpp/src - callbacks.cpp (source / functions) Hit Total Coverage
Test: coverage.info Lines: 42 55 76.4 %
Date: 2016-12-01 18:45:36 Functions: 8 9 88.9 %

          Line data    Source code
       1             : /*
       2             :   callbacks.cpp - callback targets for internal use:
       3             :   Copyright (C) 2003,2004 Klarälvdalens Datakonsult AB
       4             : 
       5             :   This file is part of GPGME++.
       6             : 
       7             :   GPGME++ is free software; you can redistribute it and/or
       8             :   modify it under the terms of the GNU Library General Public
       9             :   License as published by the Free Software Foundation; either
      10             :   version 2 of the License, or (at your option) any later version.
      11             : 
      12             :   GPGME++ is distributed in the hope that it will be useful,
      13             :   but WITHOUT ANY WARRANTY; without even the implied warranty of
      14             :   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      15             :   GNU Library General Public License for more details.
      16             : 
      17             :   You should have received a copy of the GNU Library General Public License
      18             :   along with GPGME++; see the file COPYING.LIB.  If not, write to the
      19             :   Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
      20             :   Boston, MA 02110-1301, USA.
      21             : */
      22             : 
      23             : #ifdef HAVE_CONFIG_H
      24             :  #include "config.h"
      25             : #endif
      26             : 
      27             : #include "callbacks.h"
      28             : #include "util.h"
      29             : 
      30             : #include <interfaces/progressprovider.h>
      31             : #include <interfaces/passphraseprovider.h>
      32             : #include <interfaces/dataprovider.h>
      33             : #include <error.h>
      34             : 
      35             : #include <gpgme.h>
      36             : #include <gpg-error.h>
      37             : 
      38             : #include <cassert>
      39             : #include <cerrno>
      40             : #include <cstring>
      41             : #include <unistd.h>
      42             : #include <stdlib.h>
      43             : 
      44           0 : static inline gpgme_error_t make_err_from_syserror()
      45             : {
      46           0 :     return gpgme_error_from_syserror();
      47             : }
      48             : 
      49             : using GpgME::ProgressProvider;
      50             : using GpgME::PassphraseProvider;
      51             : using GpgME::DataProvider;
      52             : 
      53          22 : void progress_callback(void *opaque, const char *what,
      54             :                        int type, int current, int total)
      55             : {
      56          22 :     ProgressProvider *provider = static_cast<ProgressProvider *>(opaque);
      57          22 :     if (provider) {
      58          22 :         provider->showProgress(what, type, current, total);
      59             :     }
      60          22 : }
      61             : 
      62             : /* To avoid that a compiler optimizes certain memset calls away, these
      63             :    macros may be used instead. */
      64             : #define wipememory2(_ptr,_set,_len) do { \
      65             :         volatile char *_vptr=(volatile char *)(_ptr); \
      66             :         size_t _vlen=(_len); \
      67             :         while(_vlen) { *_vptr=(_set); _vptr++; _vlen--; } \
      68             :     } while(0)
      69             : #define wipememory(_ptr,_len) wipememory2(_ptr,0,_len)
      70             : 
      71           4 : gpgme_error_t passphrase_callback(void *opaque, const char *uid_hint, const char *desc,
      72             :                                   int prev_was_bad, int fd)
      73             : {
      74           4 :     PassphraseProvider *provider = static_cast<PassphraseProvider *>(opaque);
      75           4 :     bool canceled = false;
      76           4 :     gpgme_error_t err = GPG_ERR_NO_ERROR;
      77           4 :     char *passphrase = provider ? provider->getPassphrase(uid_hint, desc, prev_was_bad, canceled) : 0 ;
      78           4 :     if (canceled) {
      79           0 :         err = make_error(GPG_ERR_CANCELED);
      80             :     } else {
      81           4 :         if (passphrase && *passphrase) {
      82           4 :             size_t passphrase_length = std::strlen(passphrase);
      83           4 :             size_t written = 0;
      84           4 :             do {
      85           4 :                 ssize_t now_written = gpgme_io_write(fd, passphrase + written, passphrase_length - written);
      86           4 :                 if (now_written < 0) {
      87           0 :                     err = make_err_from_syserror();
      88           0 :                     break;
      89             :                 }
      90           4 :                 written += now_written;
      91             :             } while (written < passphrase_length);
      92             :         }
      93             :     }
      94             : 
      95           4 :     if (passphrase && *passphrase) {
      96           4 :         wipememory(passphrase, std::strlen(passphrase));
      97             :     }
      98           4 :     free(passphrase);
      99           4 :     gpgme_io_write(fd, "\n", 1);
     100           4 :     return err;
     101             : }
     102             : 
     103             : static gpgme_ssize_t
     104         297 : data_read_callback(void *opaque, void *buf, size_t buflen)
     105             : {
     106         297 :     DataProvider *provider = static_cast<DataProvider *>(opaque);
     107         297 :     if (!provider) {
     108           0 :         gpgme_err_set_errno(gpgme_err_code_to_errno(GPG_ERR_EINVAL));
     109           0 :         return -1;
     110             :     }
     111         297 :     return (gpgme_ssize_t)provider->read(buf, buflen);
     112             : }
     113             : 
     114             : static gpgme_ssize_t
     115          29 : data_write_callback(void *opaque, const void *buf, size_t buflen)
     116             : {
     117          29 :     DataProvider *provider = static_cast<DataProvider *>(opaque);
     118          29 :     if (!provider) {
     119           0 :         gpgme_err_set_errno(gpgme_err_code_to_errno(GPG_ERR_EINVAL));
     120           0 :         return -1;
     121             :     }
     122          29 :     return (gpgme_ssize_t)provider->write(buf, buflen);
     123             : }
     124             : 
     125             : static gpgme_off_t
     126         134 : data_seek_callback(void *opaque, gpgme_off_t offset, int whence)
     127             : {
     128         134 :     DataProvider *provider = static_cast<DataProvider *>(opaque);
     129         134 :     if (!provider) {
     130           0 :         gpgme_err_set_errno(gpgme_err_code_to_errno(GPG_ERR_EINVAL));
     131           0 :         return -1;
     132             :     }
     133         134 :     if (whence != SEEK_SET && whence != SEEK_CUR && whence != SEEK_END) {
     134           0 :         gpgme_err_set_errno(gpgme_err_code_to_errno(GPG_ERR_EINVAL));
     135           0 :         return -1;
     136             :     }
     137         134 :     return provider->seek((off_t)offset, whence);
     138             : }
     139             : 
     140          67 : static void data_release_callback(void *opaque)
     141             : {
     142          67 :     DataProvider *provider = static_cast<DataProvider *>(opaque);
     143          67 :     if (provider) {
     144          67 :         provider->release();
     145             :     }
     146          67 : }
     147             : 
     148             : const gpgme_data_cbs GpgME::data_provider_callbacks = {
     149             :     &data_read_callback,
     150             :     &data_write_callback,
     151             :     &data_seek_callback,
     152             :     &data_release_callback
     153          18 : };

Generated by: LCOV version 1.11