LCOV - code coverage report
Current view: top level - src - engine.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 231 402 57.5 %
Date: 2015-11-05 17:14:26 Functions: 32 44 72.7 %

          Line data    Source code
       1             : /* engine.c - GPGME engine support.
       2             :    Copyright (C) 2000 Werner Koch (dd9jn)
       3             :    Copyright (C) 2001, 2002, 2003, 2004, 2006, 2009, 2010 g10 Code GmbH
       4             : 
       5             :    This file is part of GPGME.
       6             : 
       7             :    GPGME is free software; you can redistribute it and/or modify it
       8             :    under the terms of the GNU Lesser General Public License as
       9             :    published by the Free Software Foundation; either version 2.1 of
      10             :    the License, or (at your option) any later version.
      11             : 
      12             :    GPGME is distributed in the hope that it will be useful, but
      13             :    WITHOUT ANY WARRANTY; without even the implied warranty of
      14             :    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      15             :    Lesser General Public License for more details.
      16             : 
      17             :    You should have received a copy of the GNU Lesser General Public
      18             :    License along with this program; if not, see <http://www.gnu.org/licenses/>.
      19             : */
      20             : 
      21             : #ifdef HAVE_CONFIG_H
      22             : #include <config.h>
      23             : #endif
      24             : #include <stdlib.h>
      25             : #include <string.h>
      26             : #include <errno.h>
      27             : #include <assert.h>
      28             : 
      29             : #include "gpgme.h"
      30             : #include "util.h"
      31             : #include "sema.h"
      32             : #include "ops.h"
      33             : #include "debug.h"
      34             : 
      35             : #include "engine.h"
      36             : #include "engine-backend.h"
      37             : 
      38             : 
      39             : struct engine
      40             : {
      41             :   struct engine_ops *ops;
      42             :   void *engine;
      43             : };
      44             : 
      45             : 
      46             : static struct engine_ops *engine_ops[] =
      47             :   {
      48             :     &_gpgme_engine_ops_gpg,         /* OpenPGP.  */
      49             :     &_gpgme_engine_ops_gpgsm,               /* CMS.  */
      50             :     &_gpgme_engine_ops_gpgconf,             /* gpg-conf.  */
      51             :     &_gpgme_engine_ops_assuan,              /* Low-Level Assuan.  */
      52             :     &_gpgme_engine_ops_g13,         /* Crypto VFS.  */
      53             : #ifdef ENABLE_UISERVER
      54             :     &_gpgme_engine_ops_uiserver,    /* UI-Server.  */
      55             : #else
      56             :     NULL,
      57             : #endif
      58             :     &_gpgme_engine_ops_spawn
      59             :   };
      60             : 
      61             : 
      62             : /* The engine info.  */
      63             : static gpgme_engine_info_t engine_info;
      64             : DEFINE_STATIC_LOCK (engine_info_lock);
      65             : 
      66             : 
      67             : /* Get the file name of the engine for PROTOCOL.  */
      68             : static const char *
      69         196 : engine_get_file_name (gpgme_protocol_t proto)
      70             : {
      71         196 :   if (proto > DIM (engine_ops))
      72           0 :     return NULL;
      73             : 
      74         196 :   if (engine_ops[proto] && engine_ops[proto]->get_file_name)
      75         196 :     return (*engine_ops[proto]->get_file_name) ();
      76             :   else
      77           0 :     return NULL;
      78             : }
      79             : 
      80             : 
      81             : /* Get the standard home dir of the engine for PROTOCOL.  */
      82             : static const char *
      83         248 : engine_get_home_dir (gpgme_protocol_t proto)
      84             : {
      85         248 :   if (proto > DIM (engine_ops))
      86           0 :     return NULL;
      87             : 
      88         248 :   if (engine_ops[proto] && engine_ops[proto]->get_home_dir)
      89          28 :     return (*engine_ops[proto]->get_home_dir) ();
      90             :   else
      91         220 :     return NULL;
      92             : }
      93             : 
      94             : 
      95             : /* Get a malloced string containing the version number of the engine
      96             :    for PROTOCOL.  */
      97             : static char *
      98         220 : engine_get_version (gpgme_protocol_t proto, const char *file_name)
      99             : {
     100         220 :   if (proto > DIM (engine_ops))
     101           0 :     return NULL;
     102             : 
     103         220 :   if (engine_ops[proto] && engine_ops[proto]->get_version)
     104         220 :     return (*engine_ops[proto]->get_version) (file_name);
     105             :   else
     106           0 :     return NULL;
     107             : }
     108             : 
     109             : 
     110             : /* Get the required version number of the engine for PROTOCOL.  */
     111             : static const char *
     112         168 : engine_get_req_version (gpgme_protocol_t proto)
     113             : {
     114         168 :   if (proto > DIM (engine_ops))
     115           0 :     return NULL;
     116             : 
     117         168 :   if (engine_ops[proto] && engine_ops[proto]->get_req_version)
     118         168 :     return (*engine_ops[proto]->get_req_version) ();
     119             :   else
     120           0 :     return NULL;
     121             : }
     122             : 
     123             : 
     124             : /* Verify the version requirement for the engine for PROTOCOL.  */
     125             : gpgme_error_t
     126          48 : gpgme_engine_check_version (gpgme_protocol_t proto)
     127             : {
     128             :   gpgme_error_t err;
     129             :   gpgme_engine_info_t info;
     130             :   int result;
     131             : 
     132          48 :   LOCK (engine_info_lock);
     133          48 :   info = engine_info;
     134          48 :   if (!info)
     135             :     {
     136             :       /* Make sure it is initialized.  */
     137          27 :       UNLOCK (engine_info_lock);
     138          27 :       err = gpgme_get_engine_info (&info);
     139          27 :       if (err)
     140           0 :         return err;
     141             : 
     142          27 :       LOCK (engine_info_lock);
     143             :     }
     144             : 
     145         103 :   while (info && info->protocol != proto)
     146           7 :     info = info->next;
     147             : 
     148          48 :   if (!info)
     149           0 :     result = 0;
     150             :   else
     151          48 :     result = _gpgme_compare_versions (info->version,
     152          48 :                                       info->req_version);
     153             : 
     154          48 :   UNLOCK (engine_info_lock);
     155          48 :   return result ? 0 : trace_gpg_error (GPG_ERR_INV_ENGINE);
     156             : }
     157             : 
     158             : 
     159             : /* Release the engine info INFO.  */
     160             : void
     161         118 : _gpgme_engine_info_release (gpgme_engine_info_t info)
     162             : {
     163         944 :   while (info)
     164             :     {
     165         708 :       gpgme_engine_info_t next_info = info->next;
     166             : 
     167         708 :       assert (info->file_name);
     168         708 :       free (info->file_name);
     169         708 :       if (info->home_dir)
     170         118 :         free (info->home_dir);
     171         708 :       if (info->version)
     172         708 :         free (info->version);
     173         708 :       free (info);
     174         708 :       info = next_info;
     175             :     }
     176         118 : }
     177             : 
     178             : 
     179             : /* Get the information about the configured and installed engines.  A
     180             :    pointer to the first engine in the statically allocated linked list
     181             :    is returned in *INFO.  If an error occurs, it is returned.  The
     182             :    returned data is valid until the next gpgme_set_engine_info.  */
     183             : gpgme_error_t
     184          28 : gpgme_get_engine_info (gpgme_engine_info_t *info)
     185             : {
     186             :   gpgme_error_t err;
     187             : 
     188          28 :   LOCK (engine_info_lock);
     189          28 :   if (!engine_info)
     190             :     {
     191          28 :       gpgme_engine_info_t *lastp = &engine_info;
     192          28 :       gpgme_protocol_t proto_list[] = { GPGME_PROTOCOL_OpenPGP,
     193             :                                         GPGME_PROTOCOL_CMS,
     194             :                                         GPGME_PROTOCOL_GPGCONF,
     195             :                                         GPGME_PROTOCOL_ASSUAN,
     196             :                                         GPGME_PROTOCOL_G13,
     197             :                                         GPGME_PROTOCOL_UISERVER,
     198             :                                         GPGME_PROTOCOL_SPAWN    };
     199             :       unsigned int proto;
     200             : 
     201          28 :       err = 0;
     202         224 :       for (proto = 0; proto < DIM (proto_list); proto++)
     203             :         {
     204         196 :           const char *ofile_name = engine_get_file_name (proto_list[proto]);
     205         196 :           const char *ohome_dir  = engine_get_home_dir (proto_list[proto]);
     206             :           char *file_name;
     207             :           char *home_dir;
     208             : 
     209         196 :           if (!ofile_name)
     210          28 :             continue;
     211             : 
     212         168 :           file_name = strdup (ofile_name);
     213         168 :           if (!file_name)
     214           0 :             err = gpg_error_from_syserror ();
     215             : 
     216         168 :           if (ohome_dir)
     217             :             {
     218          28 :               home_dir = strdup (ohome_dir);
     219          28 :               if (!home_dir && !err)
     220           0 :                 err = gpg_error_from_syserror ();
     221             :             }
     222             :           else
     223         140 :             home_dir = NULL;
     224             : 
     225         168 :           *lastp = malloc (sizeof (*engine_info));
     226         168 :           if (!*lastp && !err)
     227           0 :             err = gpg_error_from_syserror ();
     228             : 
     229         168 :           if (err)
     230             :             {
     231           0 :               _gpgme_engine_info_release (engine_info);
     232           0 :               engine_info = NULL;
     233             : 
     234           0 :               if (file_name)
     235           0 :                 free (file_name);
     236           0 :               if (home_dir)
     237           0 :                 free (home_dir);
     238             : 
     239           0 :               UNLOCK (engine_info_lock);
     240           0 :               return err;
     241             :             }
     242             : 
     243         168 :           (*lastp)->protocol = proto_list[proto];
     244         168 :           (*lastp)->file_name = file_name;
     245         168 :           (*lastp)->home_dir = home_dir;
     246         168 :           (*lastp)->version = engine_get_version (proto_list[proto], NULL);
     247         168 :           (*lastp)->req_version = engine_get_req_version (proto_list[proto]);
     248         168 :           (*lastp)->next = NULL;
     249         168 :           lastp = &(*lastp)->next;
     250             :         }
     251             :     }
     252             : 
     253          28 :   *info = engine_info;
     254          28 :   UNLOCK (engine_info_lock);
     255          28 :   return 0;
     256             : }
     257             : 
     258             : 
     259             : /* Get a deep copy of the engine info and return it in INFO.  */
     260             : gpgme_error_t
     261         118 : _gpgme_engine_info_copy (gpgme_engine_info_t *r_info)
     262             : {
     263         118 :   gpgme_error_t err = 0;
     264             :   gpgme_engine_info_t info;
     265             :   gpgme_engine_info_t new_info;
     266             :   gpgme_engine_info_t *lastp;
     267             : 
     268         118 :   LOCK (engine_info_lock);
     269         118 :   info = engine_info;
     270         118 :   if (!info)
     271             :     {
     272             :       /* Make sure it is initialized.  */
     273           0 :       UNLOCK (engine_info_lock);
     274           0 :       err = gpgme_get_engine_info (&info);
     275           0 :       if (err)
     276           0 :         return err;
     277             : 
     278           0 :       LOCK (engine_info_lock);
     279             :     }
     280             : 
     281         118 :   new_info = NULL;
     282         118 :   lastp = &new_info;
     283             : 
     284         944 :   while (info)
     285             :     {
     286             :       char *file_name;
     287             :       char *home_dir;
     288             :       char *version;
     289             : 
     290         708 :       assert (info->file_name);
     291         708 :       file_name = strdup (info->file_name);
     292         708 :       if (!file_name)
     293           0 :         err = gpg_error_from_syserror ();
     294             : 
     295         708 :       if (info->home_dir)
     296             :         {
     297         118 :           home_dir = strdup (info->home_dir);
     298         118 :           if (!home_dir && !err)
     299           0 :             err = gpg_error_from_syserror ();
     300             :         }
     301             :       else
     302         590 :         home_dir = NULL;
     303             : 
     304         708 :       if (info->version)
     305             :         {
     306         708 :           version = strdup (info->version);
     307         708 :           if (!version && !err)
     308           0 :             err = gpg_error_from_syserror ();
     309             :         }
     310             :       else
     311           0 :         version = NULL;
     312             : 
     313         708 :       *lastp = malloc (sizeof (*engine_info));
     314         708 :       if (!*lastp && !err)
     315           0 :         err = gpg_error_from_syserror ();
     316             : 
     317         708 :       if (err)
     318             :         {
     319           0 :           _gpgme_engine_info_release (new_info);
     320           0 :           if (file_name)
     321           0 :             free (file_name);
     322           0 :           if (home_dir)
     323           0 :             free (home_dir);
     324           0 :           if (version)
     325           0 :             free (version);
     326             : 
     327           0 :           UNLOCK (engine_info_lock);
     328           0 :           return err;
     329             :         }
     330             : 
     331         708 :       (*lastp)->protocol = info->protocol;
     332         708 :       (*lastp)->file_name = file_name;
     333         708 :       (*lastp)->home_dir = home_dir;
     334         708 :       (*lastp)->version = version;
     335         708 :       (*lastp)->req_version = info->req_version;
     336         708 :       (*lastp)->next = NULL;
     337         708 :       lastp = &(*lastp)->next;
     338             : 
     339         708 :       info = info->next;
     340             :     }
     341             : 
     342         118 :   *r_info = new_info;
     343         118 :   UNLOCK (engine_info_lock);
     344         118 :   return 0;
     345             : }
     346             : 
     347             : 
     348             : /* Set the engine info for the info list INFO, protocol PROTO, to the
     349             :    file name FILE_NAME and the home directory HOME_DIR.  */
     350             : gpgme_error_t
     351          52 : _gpgme_set_engine_info (gpgme_engine_info_t info, gpgme_protocol_t proto,
     352             :                         const char *file_name, const char *home_dir)
     353             : {
     354             :   char *new_file_name;
     355             :   char *new_home_dir;
     356             : 
     357             :   /* FIXME: Use some PROTO_MAX definition.  */
     358          52 :   if (proto > DIM (engine_ops))
     359           0 :     return gpg_error (GPG_ERR_INV_VALUE);
     360             : 
     361         105 :   while (info && info->protocol != proto)
     362           1 :     info = info->next;
     363             : 
     364          52 :   if (!info)
     365           0 :     return trace_gpg_error (GPG_ERR_INV_ENGINE);
     366             : 
     367             :   /* Prepare new members.  */
     368          52 :   if (file_name)
     369          52 :     new_file_name = strdup (file_name);
     370             :   else
     371             :     {
     372           0 :       const char *ofile_name = engine_get_file_name (proto);
     373           0 :       assert (ofile_name);
     374           0 :       new_file_name = strdup (ofile_name);
     375             :     }
     376          52 :   if (!new_file_name)
     377           0 :     return gpg_error_from_syserror ();
     378             : 
     379          52 :   if (home_dir)
     380             :     {
     381           0 :       new_home_dir = strdup (home_dir);
     382           0 :       if (!new_home_dir)
     383             :         {
     384           0 :           free (new_file_name);
     385           0 :           return gpg_error_from_syserror ();
     386             :         }
     387             :     }
     388             :   else
     389             :     {
     390          52 :       const char *ohome_dir = engine_get_home_dir (proto);
     391          52 :       if (ohome_dir)
     392             :         {
     393           0 :           new_home_dir = strdup (ohome_dir);
     394           0 :           if (!new_home_dir)
     395             :             {
     396           0 :               free (new_file_name);
     397           0 :               return gpg_error_from_syserror ();
     398             :             }
     399             :         }
     400             :       else
     401          52 :         new_home_dir = NULL;
     402             :     }
     403             : 
     404             :   /* Remove the old members.  */
     405          52 :   assert (info->file_name);
     406          52 :   free (info->file_name);
     407          52 :   if (info->home_dir)
     408           0 :     free (info->home_dir);
     409          52 :   if (info->version)
     410          52 :     free (info->version);
     411             : 
     412             :   /* Install the new members.  */
     413          52 :   info->file_name = new_file_name;
     414          52 :   info->home_dir = new_home_dir;
     415          52 :   info->version = engine_get_version (proto, new_file_name);
     416             : 
     417          52 :   return 0;
     418             : }
     419             : 
     420             : 
     421             : /* Set the default engine info for the protocol PROTO to the file name
     422             :    FILE_NAME and the home directory HOME_DIR.  */
     423             : gpgme_error_t
     424           0 : gpgme_set_engine_info (gpgme_protocol_t proto,
     425             :                        const char *file_name, const char *home_dir)
     426             : {
     427             :   gpgme_error_t err;
     428             :   gpgme_engine_info_t info;
     429             : 
     430           0 :   LOCK (engine_info_lock);
     431           0 :   info = engine_info;
     432           0 :   if (!info)
     433             :     {
     434             :       /* Make sure it is initialized.  */
     435           0 :       UNLOCK (engine_info_lock);
     436           0 :       err = gpgme_get_engine_info (&info);
     437           0 :       if (err)
     438           0 :         return err;
     439             : 
     440           0 :       LOCK (engine_info_lock);
     441             :     }
     442             : 
     443           0 :   err = _gpgme_set_engine_info (info, proto, file_name, home_dir);
     444           0 :   UNLOCK (engine_info_lock);
     445           0 :   return err;
     446             : }
     447             : 
     448             : 
     449             : gpgme_error_t
     450         133 : _gpgme_engine_new (gpgme_engine_info_t info, engine_t *r_engine)
     451             : {
     452             :   engine_t engine;
     453             : 
     454         133 :   if (!info->file_name || !info->version)
     455           0 :     return trace_gpg_error (GPG_ERR_INV_ENGINE);
     456             : 
     457         133 :   engine = calloc (1, sizeof *engine);
     458         133 :   if (!engine)
     459           0 :     return gpg_error_from_syserror ();
     460             : 
     461         133 :   engine->ops = engine_ops[info->protocol];
     462         133 :   if (engine->ops->new)
     463             :     {
     464             :       gpgme_error_t err;
     465         266 :       err = (*engine->ops->new) (&engine->engine,
     466         133 :                                  info->file_name, info->home_dir);
     467         133 :       if (err)
     468             :         {
     469           0 :           free (engine);
     470           0 :           return err;
     471             :         }
     472             :     }
     473             :   else
     474           0 :     engine->engine = NULL;
     475             : 
     476         133 :   *r_engine = engine;
     477         133 :   return 0;
     478             : }
     479             : 
     480             : 
     481             : gpgme_error_t
     482          19 : _gpgme_engine_reset (engine_t engine)
     483             : {
     484          19 :   if (!engine)
     485           0 :     return gpg_error (GPG_ERR_INV_VALUE);
     486             : 
     487          19 :   if (!engine->ops->reset)
     488          15 :     return gpg_error (GPG_ERR_NOT_IMPLEMENTED);
     489             : 
     490           4 :   return (*engine->ops->reset) (engine->engine);
     491             : }
     492             : 
     493             : 
     494             : void
     495         133 : _gpgme_engine_release (engine_t engine)
     496             : {
     497         133 :   if (!engine)
     498         133 :     return;
     499             : 
     500         133 :   if (engine->ops->release)
     501         133 :     (*engine->ops->release) (engine->engine);
     502         133 :   free (engine);
     503             : }
     504             : 
     505             : 
     506             : void
     507         139 : _gpgme_engine_set_status_handler (engine_t engine,
     508             :                                   engine_status_handler_t fnc, void *fnc_value)
     509             : {
     510         139 :   if (!engine)
     511         139 :     return;
     512             : 
     513         139 :   if (engine->ops->set_status_handler)
     514         139 :     (*engine->ops->set_status_handler) (engine->engine, fnc, fnc_value);
     515             : }
     516             : 
     517             : 
     518             : gpgme_error_t
     519          35 : _gpgme_engine_set_command_handler (engine_t engine,
     520             :                                    engine_command_handler_t fnc,
     521             :                                    void *fnc_value,
     522             :                                    gpgme_data_t linked_data)
     523             : {
     524          35 :   if (!engine)
     525           0 :     return gpg_error (GPG_ERR_INV_VALUE);
     526             : 
     527          35 :   if (!engine->ops->set_command_handler)
     528           0 :     return gpg_error (GPG_ERR_NOT_IMPLEMENTED);
     529             : 
     530          35 :   return (*engine->ops->set_command_handler) (engine->engine,
     531             :                                               fnc, fnc_value, linked_data);
     532             : }
     533             : 
     534             : gpgme_error_t
     535          58 : _gpgme_engine_set_colon_line_handler (engine_t engine,
     536             :                                       engine_colon_line_handler_t fnc,
     537             :                                       void *fnc_value)
     538             : {
     539          58 :   if (!engine)
     540           0 :     return gpg_error (GPG_ERR_INV_VALUE);
     541             : 
     542          58 :   if (!engine->ops->set_colon_line_handler)
     543           0 :     return gpg_error (GPG_ERR_NOT_IMPLEMENTED);
     544             : 
     545          58 :   return (*engine->ops->set_colon_line_handler) (engine->engine,
     546             :                                                  fnc, fnc_value);
     547             : }
     548             : 
     549             : gpgme_error_t
     550         274 : _gpgme_engine_set_locale (engine_t engine, int category,
     551             :                           const char *value)
     552             : {
     553         274 :   if (!engine)
     554           0 :     return gpg_error (GPG_ERR_INV_VALUE);
     555             : 
     556         274 :   if (!engine->ops->set_locale)
     557           0 :     return gpg_error (GPG_ERR_NOT_IMPLEMENTED);
     558             : 
     559         274 :   return (*engine->ops->set_locale) (engine->engine, category, value);
     560             : }
     561             : 
     562             : 
     563             : gpgme_error_t
     564           0 : _gpgme_engine_set_protocol (engine_t engine, gpgme_protocol_t protocol)
     565             : {
     566           0 :   if (!engine)
     567           0 :     return gpg_error (GPG_ERR_INV_VALUE);
     568             : 
     569           0 :   if (!engine->ops->set_protocol)
     570           0 :     return gpg_error (GPG_ERR_NOT_IMPLEMENTED);
     571             : 
     572           0 :   return (*engine->ops->set_protocol) (engine->engine, protocol);
     573             : }
     574             : 
     575             : 
     576             : gpgme_error_t
     577          24 : _gpgme_engine_op_decrypt (engine_t engine, gpgme_data_t ciph,
     578             :                           gpgme_data_t plain)
     579             : {
     580          24 :   if (!engine)
     581           0 :     return gpg_error (GPG_ERR_INV_VALUE);
     582             : 
     583          24 :   if (!engine->ops->decrypt)
     584           0 :     return gpg_error (GPG_ERR_NOT_IMPLEMENTED);
     585             : 
     586          24 :   return (*engine->ops->decrypt) (engine->engine, ciph, plain);
     587             : }
     588             : 
     589             : 
     590             : gpgme_error_t
     591           1 : _gpgme_engine_op_decrypt_verify (engine_t engine, gpgme_data_t ciph,
     592             :                                  gpgme_data_t plain)
     593             : {
     594           1 :   if (!engine)
     595           0 :     return gpg_error (GPG_ERR_INV_VALUE);
     596             : 
     597           1 :   if (!engine->ops->decrypt_verify)
     598           0 :     return gpg_error (GPG_ERR_NOT_IMPLEMENTED);
     599             : 
     600           1 :   return (*engine->ops->decrypt_verify) (engine->engine, ciph, plain);
     601             : }
     602             : 
     603             : 
     604             : gpgme_error_t
     605           0 : _gpgme_engine_op_delete (engine_t engine, gpgme_key_t key,
     606             :                          int allow_secret)
     607             : {
     608           0 :   if (!engine)
     609           0 :     return gpg_error (GPG_ERR_INV_VALUE);
     610             : 
     611           0 :   if (!engine->ops->delete)
     612           0 :     return gpg_error (GPG_ERR_NOT_IMPLEMENTED);
     613             : 
     614           0 :   return (*engine->ops->delete) (engine->engine, key, allow_secret);
     615             : }
     616             : 
     617             : 
     618             : gpgme_error_t
     619           1 : _gpgme_engine_op_edit (engine_t engine, int type, gpgme_key_t key,
     620             :                        gpgme_data_t out, gpgme_ctx_t ctx /* FIXME */)
     621             : {
     622           1 :   if (!engine)
     623           0 :     return gpg_error (GPG_ERR_INV_VALUE);
     624             : 
     625           1 :   if (!engine->ops->edit)
     626           0 :     return gpg_error (GPG_ERR_NOT_IMPLEMENTED);
     627             : 
     628           1 :   return (*engine->ops->edit) (engine->engine, type, key, out, ctx);
     629             : }
     630             : 
     631             : 
     632             : gpgme_error_t
     633          26 : _gpgme_engine_op_encrypt (engine_t engine, gpgme_key_t recp[],
     634             :                           gpgme_encrypt_flags_t flags,
     635             :                           gpgme_data_t plain, gpgme_data_t ciph, int use_armor)
     636             : {
     637          26 :   if (!engine)
     638           0 :     return gpg_error (GPG_ERR_INV_VALUE);
     639             : 
     640          26 :   if (!engine->ops->encrypt)
     641           0 :     return gpg_error (GPG_ERR_NOT_IMPLEMENTED);
     642             : 
     643          26 :   return (*engine->ops->encrypt) (engine->engine, recp, flags, plain, ciph,
     644             :                                   use_armor);
     645             : }
     646             : 
     647             : 
     648             : gpgme_error_t
     649           2 : _gpgme_engine_op_encrypt_sign (engine_t engine, gpgme_key_t recp[],
     650             :                                gpgme_encrypt_flags_t flags,
     651             :                                gpgme_data_t plain, gpgme_data_t ciph,
     652             :                                int use_armor, gpgme_ctx_t ctx /* FIXME */)
     653             : {
     654           2 :   if (!engine)
     655           0 :     return gpg_error (GPG_ERR_INV_VALUE);
     656             : 
     657           2 :   if (!engine->ops->encrypt_sign)
     658           0 :     return gpg_error (GPG_ERR_NOT_IMPLEMENTED);
     659             : 
     660           2 :   return (*engine->ops->encrypt_sign) (engine->engine, recp, flags,
     661             :                                        plain, ciph, use_armor, ctx);
     662             : }
     663             : 
     664             : 
     665             : gpgme_error_t
     666           0 : _gpgme_engine_op_export (engine_t engine, const char *pattern,
     667             :                          gpgme_export_mode_t mode, gpgme_data_t keydata,
     668             :                          int use_armor)
     669             : {
     670           0 :   if (!engine)
     671           0 :     return gpg_error (GPG_ERR_INV_VALUE);
     672             : 
     673           0 :   if (!engine->ops->export)
     674           0 :     return gpg_error (GPG_ERR_NOT_IMPLEMENTED);
     675             : 
     676           0 :   return (*engine->ops->export) (engine->engine, pattern, mode,
     677             :                                  keydata, use_armor);
     678             : }
     679             : 
     680             : 
     681             : gpgme_error_t
     682           4 : _gpgme_engine_op_export_ext (engine_t engine, const char *pattern[],
     683             :                              unsigned int reserved, gpgme_data_t keydata,
     684             :                              int use_armor)
     685             : {
     686           4 :   if (!engine)
     687           0 :     return gpg_error (GPG_ERR_INV_VALUE);
     688             : 
     689           4 :   if (!engine->ops->export_ext)
     690           0 :     return gpg_error (GPG_ERR_NOT_IMPLEMENTED);
     691             : 
     692           4 :   return (*engine->ops->export_ext) (engine->engine, pattern, reserved,
     693             :                                      keydata, use_armor);
     694             : }
     695             : 
     696             : 
     697             : gpgme_error_t
     698           0 : _gpgme_engine_op_genkey (engine_t engine, gpgme_data_t help_data,
     699             :                          int use_armor, gpgme_data_t pubkey,
     700             :                          gpgme_data_t seckey)
     701             : {
     702           0 :   if (!engine)
     703           0 :     return gpg_error (GPG_ERR_INV_VALUE);
     704             : 
     705           0 :   if (!engine->ops->genkey)
     706           0 :     return gpg_error (GPG_ERR_NOT_IMPLEMENTED);
     707             : 
     708           0 :   return (*engine->ops->genkey) (engine->engine, help_data, use_armor,
     709             :                                  pubkey, seckey);
     710             : }
     711             : 
     712             : 
     713             : gpgme_error_t
     714           4 : _gpgme_engine_op_import (engine_t engine, gpgme_data_t keydata,
     715             :                          gpgme_key_t *keyarray)
     716             : {
     717           4 :   if (!engine)
     718           0 :     return gpg_error (GPG_ERR_INV_VALUE);
     719             : 
     720           4 :   if (!engine->ops->import)
     721           0 :     return gpg_error (GPG_ERR_NOT_IMPLEMENTED);
     722             : 
     723           4 :   return (*engine->ops->import) (engine->engine, keydata, keyarray);
     724             : }
     725             : 
     726             : 
     727             : gpgme_error_t
     728          57 : _gpgme_engine_op_keylist (engine_t engine, const char *pattern,
     729             :                           int secret_only, gpgme_keylist_mode_t mode,
     730             :                           int engine_flags)
     731             : {
     732          57 :   if (!engine)
     733           0 :     return gpg_error (GPG_ERR_INV_VALUE);
     734             : 
     735          57 :   if (!engine->ops->keylist)
     736           0 :     return gpg_error (GPG_ERR_NOT_IMPLEMENTED);
     737             : 
     738          57 :   return (*engine->ops->keylist) (engine->engine, pattern, secret_only, mode,
     739             :                                   engine_flags);
     740             : }
     741             : 
     742             : 
     743             : gpgme_error_t
     744           0 : _gpgme_engine_op_keylist_ext (engine_t engine, const char *pattern[],
     745             :                               int secret_only, int reserved,
     746             :                               gpgme_keylist_mode_t mode, int engine_flags)
     747             : {
     748           0 :   if (!engine)
     749           0 :     return gpg_error (GPG_ERR_INV_VALUE);
     750             : 
     751           0 :   if (!engine->ops->keylist_ext)
     752           0 :     return gpg_error (GPG_ERR_NOT_IMPLEMENTED);
     753             : 
     754           0 :   return (*engine->ops->keylist_ext) (engine->engine, pattern, secret_only,
     755             :                                       reserved, mode, engine_flags);
     756             : }
     757             : 
     758             : 
     759             : gpgme_error_t
     760           9 : _gpgme_engine_op_sign (engine_t engine, gpgme_data_t in, gpgme_data_t out,
     761             :                        gpgme_sig_mode_t mode, int use_armor,
     762             :                        int use_textmode, int include_certs,
     763             :                        gpgme_ctx_t ctx /* FIXME */)
     764             : {
     765           9 :   if (!engine)
     766           0 :     return gpg_error (GPG_ERR_INV_VALUE);
     767             : 
     768           9 :   if (!engine->ops->sign)
     769           0 :     return gpg_error (GPG_ERR_NOT_IMPLEMENTED);
     770             : 
     771           9 :   return (*engine->ops->sign) (engine->engine, in, out, mode, use_armor,
     772             :                                use_textmode, include_certs, ctx);
     773             : }
     774             : 
     775             : 
     776             : gpgme_error_t
     777           1 : _gpgme_engine_op_trustlist (engine_t engine, const char *pattern)
     778             : {
     779           1 :   if (!engine)
     780           0 :     return gpg_error (GPG_ERR_INV_VALUE);
     781             : 
     782           1 :   if (!engine->ops->trustlist)
     783           0 :     return gpg_error (GPG_ERR_NOT_IMPLEMENTED);
     784             : 
     785           1 :   return (*engine->ops->trustlist) (engine->engine, pattern);
     786             : }
     787             : 
     788             : 
     789             : gpgme_error_t
     790           8 : _gpgme_engine_op_verify (engine_t engine, gpgme_data_t sig,
     791             :                          gpgme_data_t signed_text, gpgme_data_t plaintext)
     792             : {
     793           8 :   if (!engine)
     794           0 :     return gpg_error (GPG_ERR_INV_VALUE);
     795             : 
     796           8 :   if (!engine->ops->verify)
     797           0 :     return gpg_error (GPG_ERR_NOT_IMPLEMENTED);
     798             : 
     799           8 :   return (*engine->ops->verify) (engine->engine, sig, signed_text, plaintext);
     800             : }
     801             : 
     802             : 
     803             : gpgme_error_t
     804           2 : _gpgme_engine_op_getauditlog (engine_t engine, gpgme_data_t output,
     805             :                               unsigned int flags)
     806             : {
     807           2 :   if (!engine)
     808           0 :     return gpg_error (GPG_ERR_INV_VALUE);
     809             : 
     810           2 :   if (!engine->ops->getauditlog)
     811           0 :     return gpg_error (GPG_ERR_NOT_IMPLEMENTED);
     812             : 
     813           2 :   return (*engine->ops->getauditlog) (engine->engine, output, flags);
     814             : }
     815             : 
     816             : 
     817             : gpgme_error_t
     818           0 : _gpgme_engine_op_assuan_transact (engine_t engine,
     819             :                                   const char *command,
     820             :                                   gpgme_assuan_data_cb_t data_cb,
     821             :                                   void *data_cb_value,
     822             :                                   gpgme_assuan_inquire_cb_t inq_cb,
     823             :                                   void *inq_cb_value,
     824             :                                   gpgme_assuan_status_cb_t status_cb,
     825             :                                   void *status_cb_value)
     826             : {
     827           0 :   if (!engine)
     828           0 :     return gpg_error (GPG_ERR_INV_VALUE);
     829             : 
     830           0 :   if (!engine->ops->opassuan_transact)
     831           0 :     return gpg_error (GPG_ERR_NOT_IMPLEMENTED);
     832             : 
     833           0 :   return (*engine->ops->opassuan_transact) (engine->engine,
     834             :                                             command,
     835             :                                             data_cb, data_cb_value,
     836             :                                             inq_cb, inq_cb_value,
     837             :                                             status_cb, status_cb_value);
     838             : }
     839             : 
     840             : 
     841             : gpgme_error_t
     842           0 : _gpgme_engine_op_conf_load (engine_t engine, gpgme_conf_comp_t *conf_p)
     843             : {
     844           0 :   if (!engine)
     845           0 :     return gpg_error (GPG_ERR_INV_VALUE);
     846             : 
     847           0 :   if (!engine->ops->conf_load)
     848           0 :     return gpg_error (GPG_ERR_NOT_IMPLEMENTED);
     849             : 
     850           0 :   return (*engine->ops->conf_load) (engine->engine, conf_p);
     851             : }
     852             : 
     853             : 
     854             : gpgme_error_t
     855           0 : _gpgme_engine_op_conf_save (engine_t engine, gpgme_conf_comp_t conf)
     856             : {
     857           0 :   if (!engine)
     858           0 :     return gpg_error (GPG_ERR_INV_VALUE);
     859             : 
     860           0 :   if (!engine->ops->conf_save)
     861           0 :     return gpg_error (GPG_ERR_NOT_IMPLEMENTED);
     862             : 
     863           0 :   return (*engine->ops->conf_save) (engine->engine, conf);
     864             : }
     865             : 
     866             : 
     867             : void
     868         139 : _gpgme_engine_set_io_cbs (engine_t engine, gpgme_io_cbs_t io_cbs)
     869             : {
     870         139 :   if (!engine)
     871         139 :     return;
     872             : 
     873         139 :   (*engine->ops->set_io_cbs) (engine->engine, io_cbs);
     874             : }
     875             : 
     876             : 
     877             : void
     878         279 : _gpgme_engine_io_event (engine_t engine,
     879             :                         gpgme_event_io_t type, void *type_data)
     880             : {
     881         279 :   if (!engine)
     882         279 :     return;
     883             : 
     884         279 :   (*engine->ops->io_event) (engine->engine, type, type_data);
     885             : }
     886             : 
     887             : 
     888             : /* Cancel the session and the pending operation if any.  */
     889             : gpgme_error_t
     890           2 : _gpgme_engine_cancel (engine_t engine)
     891             : {
     892           2 :   if (!engine)
     893           0 :     return gpg_error (GPG_ERR_INV_VALUE);
     894             : 
     895           2 :   if (!engine->ops->cancel)
     896           0 :     return gpg_error (GPG_ERR_NOT_IMPLEMENTED);
     897             : 
     898           2 :   return (*engine->ops->cancel) (engine->engine);
     899             : }
     900             : 
     901             : 
     902             : /* Cancel the pending operation, but not the complete session.  */
     903             : gpgme_error_t
     904           0 : _gpgme_engine_cancel_op (engine_t engine)
     905             : {
     906           0 :   if (!engine)
     907           0 :     return gpg_error (GPG_ERR_INV_VALUE);
     908             : 
     909           0 :   if (!engine->ops->cancel_op)
     910           0 :     return 0;
     911             : 
     912           0 :   return (*engine->ops->cancel_op) (engine->engine);
     913             : }
     914             : 
     915             : 
     916             : /* Change the passphrase for KEY.  */
     917             : gpgme_error_t
     918           0 : _gpgme_engine_op_passwd (engine_t engine, gpgme_key_t key,
     919             :                          unsigned int flags)
     920             : {
     921           0 :   if (!engine)
     922           0 :     return gpg_error (GPG_ERR_INV_VALUE);
     923             : 
     924           0 :   if (!engine->ops->passwd)
     925           0 :     return gpg_error (GPG_ERR_NOT_IMPLEMENTED);
     926             : 
     927           0 :   return (*engine->ops->passwd) (engine->engine, key, flags);
     928             : }
     929             : 
     930             : 
     931             : /* Set the pinentry mode for ENGINE to MODE.  */
     932             : gpgme_error_t
     933         137 : _gpgme_engine_set_pinentry_mode (engine_t engine, gpgme_pinentry_mode_t mode)
     934             : {
     935         137 :   if (!engine)
     936           0 :     return gpg_error (GPG_ERR_INV_VALUE);
     937             : 
     938         137 :   if (!engine->ops->set_pinentry_mode)
     939          12 :     return gpg_error (GPG_ERR_NOT_IMPLEMENTED);
     940             : 
     941         125 :   return (*engine->ops->set_pinentry_mode) (engine->engine, mode);
     942             : }
     943             : 
     944             : 
     945             : gpgme_error_t
     946           0 : _gpgme_engine_op_spawn (engine_t engine,
     947             :                         const char *file, const char *argv[],
     948             :                         gpgme_data_t datain,
     949             :                         gpgme_data_t dataout, gpgme_data_t dataerr,
     950             :                         unsigned int flags)
     951             : {
     952           0 :   if (!engine)
     953           0 :     return gpg_error (GPG_ERR_INV_VALUE);
     954             : 
     955           0 :   if (!engine->ops->opspawn)
     956           0 :     return gpg_error (GPG_ERR_NOT_IMPLEMENTED);
     957             : 
     958           0 :   return (*engine->ops->opspawn) (engine->engine, file, argv,
     959             :                                   datain, dataout, dataerr, flags);
     960             : }

Generated by: LCOV version 1.11