LCOV - code coverage report
Current view: top level - g10 - gpgv.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 44 194 22.7 %
Date: 2016-09-12 12:29:17 Functions: 3 54 5.6 %

          Line data    Source code
       1             : /* gpgv.c - The GnuPG signature verify utility
       2             :  * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2005, 2006,
       3             :  *               2008, 2009, 2012 Free Software Foundation, Inc.
       4             :  *
       5             :  * This file is part of GnuPG.
       6             :  *
       7             :  * GnuPG is free software; you can redistribute it and/or modify
       8             :  * it under the terms of the GNU General Public License as published by
       9             :  * the Free Software Foundation; either version 3 of the License, or
      10             :  * (at your option) any later version.
      11             :  *
      12             :  * GnuPG 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 General Public License for more details.
      16             :  *
      17             :  * You should have received a copy of the GNU General Public License
      18             :  * along with this program; if not, see <http://www.gnu.org/licenses/>.
      19             :  */
      20             : 
      21             : #include <config.h>
      22             : #include <errno.h>
      23             : #include <stdio.h>
      24             : #include <stdlib.h>
      25             : #include <string.h>
      26             : #include <ctype.h>
      27             : #include <unistd.h>
      28             : #ifdef HAVE_DOSISH_SYSTEM
      29             : #include <fcntl.h> /* for setmode() */
      30             : #endif
      31             : #ifdef HAVE_LIBREADLINE
      32             : #define GNUPG_LIBREADLINE_H_INCLUDED
      33             : #include <readline/readline.h>
      34             : #endif
      35             : 
      36             : #define INCLUDED_BY_MAIN_MODULE 1
      37             : #include "gpg.h"
      38             : #include "util.h"
      39             : #include "packet.h"
      40             : #include "iobuf.h"
      41             : #include "main.h"
      42             : #include "options.h"
      43             : #include "keydb.h"
      44             : #include "trustdb.h"
      45             : #include "filter.h"
      46             : #include "ttyio.h"
      47             : #include "i18n.h"
      48             : #include "sysutils.h"
      49             : #include "status.h"
      50             : #include "call-agent.h"
      51             : #include "../common/init.h"
      52             : 
      53             : 
      54             : enum cmd_and_opt_values {
      55             :   aNull = 0,
      56             :   oQuiet          = 'q',
      57             :   oVerbose        = 'v',
      58             :   oOutput         = 'o',
      59             :   oBatch          = 500,
      60             :   oKeyring,
      61             :   oIgnoreTimeConflict,
      62             :   oStatusFD,
      63             :   oLoggerFD,
      64             :   oHomedir,
      65             :   oWeakDigest,
      66             :   aTest
      67             : };
      68             : 
      69             : 
      70             : static ARGPARSE_OPTS opts[] = {
      71             :   ARGPARSE_group (300, N_("@\nOptions:\n ")),
      72             : 
      73             :   ARGPARSE_s_n (oVerbose, "verbose", N_("verbose")),
      74             :   ARGPARSE_s_n (oQuiet,   "quiet",   N_("be somewhat more quiet")),
      75             :   ARGPARSE_s_s (oKeyring, "keyring",
      76             :                 N_("|FILE|take the keys from the keyring FILE")),
      77             :   ARGPARSE_s_s (oOutput, "output", N_("|FILE|write output to FILE")),
      78             :   ARGPARSE_s_n (oIgnoreTimeConflict, "ignore-time-conflict",
      79             :                 N_("make timestamp conflicts only a warning")),
      80             :   ARGPARSE_s_i (oStatusFD, "status-fd",
      81             :                 N_("|FD|write status info to this FD")),
      82             :   ARGPARSE_s_i (oLoggerFD, "logger-fd", "@"),
      83             :   ARGPARSE_s_s (oHomedir, "homedir", "@"),
      84             :   ARGPARSE_s_s (oWeakDigest, "weak-digest",
      85             :                 N_("|ALGO|reject signatures made with ALGO")),
      86             : 
      87             :   ARGPARSE_end ()
      88             : };
      89             : 
      90             : 
      91             : 
      92             : int g10_errors_seen = 0;
      93             : 
      94             : 
      95             : static char *
      96           0 : make_libversion (const char *libname, const char *(*getfnc)(const char*))
      97             : {
      98             :   const char *s;
      99             :   char *result;
     100             : 
     101           0 :   s = getfnc (NULL);
     102           0 :   result = xmalloc (strlen (libname) + 1 + strlen (s) + 1);
     103           0 :   strcpy (stpcpy (stpcpy (result, libname), " "), s);
     104           0 :   return result;
     105             : }
     106             : 
     107             : static const char *
     108           0 : my_strusage( int level )
     109             : {
     110             :   static char *ver_gcry;
     111             :   const char *p;
     112             : 
     113           0 :   switch (level)
     114             :     {
     115           0 :     case 11: p = "@GPG@v (GnuPG)";
     116           0 :       break;
     117           0 :     case 13: p = VERSION; break;
     118           0 :     case 17: p = PRINTABLE_OS_NAME; break;
     119           0 :     case 19: p = _("Please report bugs to <@EMAIL@>.\n"); break;
     120             : 
     121             :     case 1:
     122           0 :     case 40: p = _("Usage: gpgv [options] [files] (-h for help)");
     123           0 :       break;
     124           0 :     case 41: p = _("Syntax: gpgv [options] [files]\n"
     125             :                    "Check signatures against known trusted keys\n");
     126           0 :         break;
     127             : 
     128             :     case 20:
     129           0 :       if (!ver_gcry)
     130           0 :         ver_gcry = make_libversion ("libgcrypt", gcry_check_version);
     131           0 :       p = ver_gcry;
     132           0 :       break;
     133             : 
     134             : 
     135           0 :     default: p = NULL;
     136             :     }
     137           0 :   return p;
     138             : }
     139             : 
     140             : 
     141             : 
     142             : int
     143           1 : main( int argc, char **argv )
     144             : {
     145             :   ARGPARSE_ARGS pargs;
     146           1 :   int rc=0;
     147             :   strlist_t sl;
     148           1 :   strlist_t nrings = NULL;
     149             :   unsigned configlineno;
     150             :   ctrl_t ctrl;
     151             : 
     152           1 :   early_system_init ();
     153           1 :   set_strusage (my_strusage);
     154           1 :   log_set_prefix ("gpgv", GPGRT_LOG_WITH_PREFIX);
     155             : 
     156             :   /* Make sure that our subsystems are ready.  */
     157           1 :   i18n_init();
     158           1 :   init_common_subsystems (&argc, &argv);
     159             : 
     160           1 :   gcry_control (GCRYCTL_DISABLE_SECMEM, 0);
     161             : 
     162           1 :   gnupg_init_signals (0, NULL);
     163             : 
     164           1 :   opt.command_fd = -1; /* no command fd */
     165           1 :   opt.keyserver_options.options |= KEYSERVER_AUTO_KEY_RETRIEVE;
     166           1 :   opt.trust_model = TM_ALWAYS;
     167           1 :   opt.no_sig_cache = 1;
     168           1 :   opt.flags.require_cross_cert = 1;
     169           1 :   opt.batch = 1;
     170           1 :   opt.answer_yes = 1;
     171             : 
     172           1 :   opt.weak_digests = NULL;
     173             : 
     174           1 :   tty_no_terminal(1);
     175           1 :   tty_batchmode(1);
     176           1 :   dotlock_disable ();
     177           1 :   gcry_control (GCRYCTL_INITIALIZATION_FINISHED, 0);
     178           1 :   additional_weak_digest("MD5");
     179             : 
     180           1 :   pargs.argc = &argc;
     181           1 :   pargs.argv = &argv;
     182           1 :   pargs.flags=  1;  /* do not remove the args */
     183           3 :   while (optfile_parse( NULL, NULL, &configlineno, &pargs, opts))
     184             :     {
     185           1 :       switch (pargs.r_opt)
     186             :         {
     187           0 :         case oQuiet: opt.quiet = 1; break;
     188             :         case oVerbose:
     189           0 :           opt.verbose++;
     190           0 :           opt.list_sigs=1;
     191           0 :           gcry_control (GCRYCTL_SET_VERBOSITY, (int)opt.verbose);
     192           0 :           break;
     193           1 :         case oKeyring: append_to_strlist( &nrings, pargs.r.ret_str); break;
     194           0 :         case oOutput: opt.outfile = pargs.r.ret_str; break;
     195           0 :         case oStatusFD: set_status_fd( pargs.r.ret_int ); break;
     196             :         case oLoggerFD:
     197           0 :           log_set_fd (translate_sys2libc_fd_int (pargs.r.ret_int, 1));
     198           0 :           break;
     199           0 :         case oHomedir: gnupg_set_homedir (pargs.r.ret_str); break;
     200             :         case oWeakDigest:
     201           0 :           additional_weak_digest(pargs.r.ret_str);
     202           0 :           break;
     203           0 :         case oIgnoreTimeConflict: opt.ignore_time_conflict = 1; break;
     204           0 :         default : pargs.err = ARGPARSE_PRINT_ERROR; break;
     205             :         }
     206             :     }
     207             : 
     208           1 :   if (log_get_errorcount (0))
     209           0 :     g10_exit(2);
     210             : 
     211           1 :   if (opt.verbose > 1)
     212           0 :     set_packet_list_mode(1);
     213             : 
     214             :   /* Note: We open all keyrings in read-only mode.  */
     215           1 :   if (!nrings)  /* No keyring given: use default one. */
     216           0 :     keydb_add_resource ("trustedkeys" EXTSEP_S "kbx",
     217             :                         (KEYDB_RESOURCE_FLAG_READONLY
     218             :                          |KEYDB_RESOURCE_FLAG_GPGVDEF));
     219           2 :   for (sl = nrings; sl; sl = sl->next)
     220           1 :     keydb_add_resource (sl->d, KEYDB_RESOURCE_FLAG_READONLY);
     221             : 
     222           1 :   FREE_STRLIST (nrings);
     223             : 
     224           1 :   ctrl = xcalloc (1, sizeof *ctrl);
     225             : 
     226           1 :   if ((rc = verify_signatures (ctrl, argc, argv)))
     227           0 :     log_error("verify signatures failed: %s\n", gpg_strerror (rc) );
     228             : 
     229           1 :   xfree (ctrl);
     230             : 
     231             :   /* cleanup */
     232           1 :   g10_exit (0);
     233             :   return 8; /*NOTREACHED*/
     234             : }
     235             : 
     236             : 
     237             : void
     238           1 : g10_exit( int rc )
     239             : {
     240           1 :   rc = rc? rc : log_get_errorcount(0)? 2 : g10_errors_seen? 1 : 0;
     241           1 :   exit(rc );
     242             : }
     243             : 
     244             : 
     245             : /* Stub:
     246             :  * We have to override the trustcheck from pkclist.c because
     247             :  * this utility assumes that all keys in the keyring are trustworthy
     248             :  */
     249             : int
     250           0 : check_signatures_trust (ctrl_t ctrl, PKT_signature *sig)
     251             : {
     252             :   (void)ctrl;
     253             :   (void)sig;
     254           0 :   return 0;
     255             : }
     256             : 
     257             : void
     258           0 : read_trust_options(byte *trust_model, ulong *created, ulong *nextcheck,
     259             :                    byte *marginals, byte *completes, byte *cert_depth,
     260             :                    byte *min_cert_level)
     261             : {
     262             :   (void)trust_model;
     263             :   (void)created;
     264             :   (void)nextcheck;
     265             :   (void)marginals;
     266             :   (void)completes;
     267             :   (void)cert_depth;
     268             :   (void)min_cert_level;
     269           0 : }
     270             : 
     271             : /* Stub:
     272             :  * We don't have the trustdb , so we have to provide some stub functions
     273             :  * instead
     274             :  */
     275             : 
     276             : int
     277           0 : cache_disabled_value(PKT_public_key *pk)
     278             : {
     279             :   (void)pk;
     280           0 :   return 0;
     281             : }
     282             : 
     283             : void
     284           0 : check_trustdb_stale (ctrl_t ctrl)
     285             : {
     286             :   (void)ctrl;
     287           0 : }
     288             : 
     289             : int
     290           0 : get_validity_info (ctrl_t ctrl, PKT_public_key *pk, PKT_user_id *uid)
     291             : {
     292             :   (void)ctrl;
     293             :   (void)pk;
     294             :   (void)uid;
     295           0 :   return '?';
     296             : }
     297             : 
     298             : unsigned int
     299           0 : get_validity (ctrl_t ctrl, PKT_public_key *pk, PKT_user_id *uid,
     300             :               PKT_signature *sig, int may_ask)
     301             : {
     302             :   (void)ctrl;
     303             :   (void)pk;
     304             :   (void)uid;
     305             :   (void)sig;
     306             :   (void)may_ask;
     307           0 :   return 0;
     308             : }
     309             : 
     310             : const char *
     311           0 : trust_value_to_string (unsigned int value)
     312             : {
     313             :   (void)value;
     314           0 :   return "err";
     315             : }
     316             : 
     317             : const char *
     318           0 : uid_trust_string_fixed (ctrl_t ctrl, PKT_public_key *key, PKT_user_id *uid)
     319             : {
     320             :   (void)ctrl;
     321             :   (void)key;
     322             :   (void)uid;
     323           0 :   return "err";
     324             : }
     325             : 
     326             : int
     327           0 : get_ownertrust_info (PKT_public_key *pk)
     328             : {
     329             :   (void)pk;
     330           0 :   return '?';
     331             : }
     332             : 
     333             : unsigned int
     334           0 : get_ownertrust (PKT_public_key *pk)
     335             : {
     336             :   (void)pk;
     337           0 :   return TRUST_UNKNOWN;
     338             : }
     339             : 
     340             : 
     341             : /* Stubs:
     342             :  * Because we only work with trusted keys, it does not make sense to
     343             :  * get them from a keyserver
     344             :  */
     345             : 
     346             : struct keyserver_spec *
     347           0 : keyserver_match (struct keyserver_spec *spec)
     348             : {
     349             :   (void)spec;
     350           0 :   return NULL;
     351             : }
     352             : 
     353             : int
     354           0 : keyserver_any_configured (ctrl_t ctrl)
     355             : {
     356             :   (void)ctrl;
     357           0 :   return 0;
     358             : }
     359             : 
     360             : int
     361           0 : keyserver_import_keyid (u32 *keyid, void *dummy)
     362             : {
     363             :   (void)keyid;
     364             :   (void)dummy;
     365           0 :   return -1;
     366             : }
     367             : 
     368             : int
     369           0 : keyserver_import_fprint (ctrl_t ctrl, const byte *fprint,size_t fprint_len,
     370             :                          struct keyserver_spec *keyserver)
     371             : {
     372             :   (void)ctrl;
     373             :   (void)fprint;
     374             :   (void)fprint_len;
     375             :   (void)keyserver;
     376           0 :   return -1;
     377             : }
     378             : 
     379             : int
     380           0 : keyserver_import_cert (const char *name)
     381             : {
     382             :   (void)name;
     383           0 :   return -1;
     384             : }
     385             : 
     386             : int
     387           0 : keyserver_import_pka (const char *name,unsigned char *fpr)
     388             : {
     389             :   (void)name;
     390             :   (void)fpr;
     391           0 :   return -1;
     392             : }
     393             : 
     394             : gpg_error_t
     395           0 : keyserver_import_wkd (ctrl_t ctrl, const char *name,
     396             :                       unsigned char **fpr, size_t *fpr_len)
     397             : {
     398             :   (void)ctrl;
     399             :   (void)name;
     400             :   (void)fpr;
     401             :   (void)fpr_len;
     402           0 :   return GPG_ERR_BUG;
     403             : }
     404             : 
     405             : int
     406           0 : keyserver_import_name (const char *name,struct keyserver_spec *spec)
     407             : {
     408             :   (void)name;
     409             :   (void)spec;
     410           0 :   return -1;
     411             : }
     412             : 
     413             : int
     414           0 : keyserver_import_ldap (const char *name)
     415             : {
     416             :   (void)name;
     417           0 :   return -1;
     418             : }
     419             : 
     420             : 
     421             : gpg_error_t
     422           0 : read_key_from_file (ctrl_t ctrl, const char *fname, kbnode_t *r_keyblock)
     423             : {
     424             :   (void)ctrl;
     425             :   (void)fname;
     426             :   (void)r_keyblock;
     427           0 :   return -1;
     428             : }
     429             : 
     430             : 
     431             : /* Stub:
     432             :  * No encryption here but mainproc links to these functions.
     433             :  */
     434             : gpg_error_t
     435           0 : get_session_key (ctrl_t ctrl, PKT_pubkey_enc *k, DEK *dek)
     436             : {
     437             :   (void)ctrl;
     438             :   (void)k;
     439             :   (void)dek;
     440           0 :   return GPG_ERR_GENERAL;
     441             : }
     442             : 
     443             : /* Stub: */
     444             : gpg_error_t
     445           0 : get_override_session_key (DEK *dek, const char *string)
     446             : {
     447             :   (void)dek;
     448             :   (void)string;
     449           0 :   return GPG_ERR_GENERAL;
     450             : }
     451             : 
     452             : /* Stub: */
     453             : int
     454           0 : decrypt_data (ctrl_t ctrl, void *procctx, PKT_encrypted *ed, DEK *dek)
     455             : {
     456             :   (void)ctrl;
     457             :   (void)procctx;
     458             :   (void)ed;
     459             :   (void)dek;
     460           0 :   return GPG_ERR_GENERAL;
     461             : }
     462             : 
     463             : 
     464             : /* Stub:
     465             :  * No interactive commands, so we don't need the helptexts
     466             :  */
     467             : void
     468           0 : display_online_help (const char *keyword)
     469             : {
     470             :   (void)keyword;
     471           0 : }
     472             : 
     473             : /* Stub:
     474             :  * We don't use secret keys, but getkey.c links to this
     475             :  */
     476             : int
     477           0 : check_secret_key (PKT_public_key *pk, int n)
     478             : {
     479             :   (void)pk;
     480             :   (void)n;
     481           0 :   return GPG_ERR_GENERAL;
     482             : }
     483             : 
     484             : /* Stub:
     485             :  * No secret key, so no passphrase needed
     486             :  */
     487             : DEK *
     488           0 : passphrase_to_dek (int cipher_algo, STRING2KEY *s2k, int create, int nocache,
     489             :                    const char *tmp, int *canceled)
     490             : {
     491             :   (void)cipher_algo;
     492             :   (void)s2k;
     493             :   (void)create;
     494             :   (void)nocache;
     495             :   (void)tmp;
     496             : 
     497           0 :   if (canceled)
     498           0 :     *canceled = 0;
     499           0 :   return NULL;
     500             : }
     501             : 
     502             : void
     503           0 : passphrase_clear_cache (const char *cacheid)
     504             : {
     505             :   (void)cacheid;
     506           0 : }
     507             : 
     508             : struct keyserver_spec *
     509           0 : parse_preferred_keyserver(PKT_signature *sig)
     510             : {
     511             :   (void)sig;
     512           0 :   return NULL;
     513             : }
     514             : 
     515             : struct keyserver_spec *
     516           0 : parse_keyserver_uri (const char *uri, int require_scheme,
     517             :                      const char *configname, unsigned int configlineno)
     518             : {
     519             :   (void)uri;
     520             :   (void)require_scheme;
     521             :   (void)configname;
     522             :   (void)configlineno;
     523           0 :   return NULL;
     524             : }
     525             : 
     526             : void
     527           0 : free_keyserver_spec (struct keyserver_spec *keyserver)
     528             : {
     529             :   (void)keyserver;
     530           0 : }
     531             : 
     532             : /* Stubs to avoid linking to photoid.c */
     533             : void
     534           0 : show_photos (const struct user_attribute *attrs, int count, PKT_public_key *pk)
     535             : {
     536             :   (void)attrs;
     537             :   (void)count;
     538             :   (void)pk;
     539           0 : }
     540             : 
     541             : int
     542           0 : parse_image_header (const struct user_attribute *attr, byte *type, u32 *len)
     543             : {
     544             :   (void)attr;
     545             :   (void)type;
     546             :   (void)len;
     547           0 :   return 0;
     548             : }
     549             : 
     550             : char *
     551           0 : image_type_to_string (byte type, int string)
     552             : {
     553             :   (void)type;
     554             :   (void)string;
     555           0 :   return NULL;
     556             : }
     557             : 
     558             : #ifdef ENABLE_CARD_SUPPORT
     559             : int
     560           0 : agent_scd_getattr (const char *name, struct agent_card_info_s *info)
     561             : {
     562             :   (void)name;
     563             :   (void)info;
     564           0 :   return 0;
     565             : }
     566             : #endif /* ENABLE_CARD_SUPPORT */
     567             : 
     568             : /* We do not do any locking, so use these stubs here */
     569             : void
     570           1 : dotlock_disable (void)
     571             : {
     572           1 : }
     573             : 
     574             : dotlock_t
     575           0 : dotlock_create (const char *file_to_lock, unsigned int flags)
     576             : {
     577             :   (void)file_to_lock;
     578             :   (void)flags;
     579           0 :   return NULL;
     580             : }
     581             : 
     582             : void
     583           0 : dotlock_destroy (dotlock_t h)
     584             : {
     585             :   (void)h;
     586           0 : }
     587             : 
     588             : int
     589           0 : dotlock_take (dotlock_t h, long timeout)
     590             : {
     591             :   (void)h;
     592             :   (void)timeout;
     593           0 :   return 0;
     594             : }
     595             : 
     596             : int
     597           0 : dotlock_release (dotlock_t h)
     598             : {
     599             :   (void)h;
     600           0 :   return 0;
     601             : }
     602             : 
     603             : void
     604           0 : dotlock_remove_lockfiles (void)
     605             : {
     606           0 : }
     607             : 
     608             : gpg_error_t
     609           0 : agent_probe_secret_key (ctrl_t ctrl, PKT_public_key *pk)
     610             : {
     611             :   (void)ctrl;
     612             :   (void)pk;
     613           0 :   return gpg_error (GPG_ERR_NO_SECKEY);
     614             : }
     615             : 
     616             : gpg_error_t
     617           0 : agent_probe_any_secret_key (ctrl_t ctrl, kbnode_t keyblock)
     618             : {
     619             :   (void)ctrl;
     620             :   (void)keyblock;
     621           0 :   return gpg_error (GPG_ERR_NO_SECKEY);
     622             : }
     623             : 
     624             : gpg_error_t
     625           0 : agent_get_keyinfo (ctrl_t ctrl, const char *hexkeygrip,
     626             :                    char **r_serialno, int *r_cleartext)
     627             : {
     628             :   (void)ctrl;
     629             :   (void)hexkeygrip;
     630             :   (void)r_cleartext;
     631           0 :   *r_serialno = NULL;
     632           0 :   return gpg_error (GPG_ERR_NO_SECKEY);
     633             : }
     634             : 
     635             : gpg_error_t
     636           0 : gpg_dirmngr_get_pka (ctrl_t ctrl, const char *userid,
     637             :                      unsigned char **r_fpr, size_t *r_fprlen,
     638             :                      char **r_url)
     639             : {
     640             :   (void)ctrl;
     641             :   (void)userid;
     642           0 :   if (r_fpr)
     643           0 :     *r_fpr = NULL;
     644           0 :   if (r_fprlen)
     645           0 :     *r_fprlen = 0;
     646           0 :   if (r_url)
     647           0 :     *r_url = NULL;
     648           0 :   return gpg_error (GPG_ERR_NOT_FOUND);
     649             : }
     650             : 
     651             : gpg_error_t
     652           0 : export_pubkey_buffer (ctrl_t ctrl, const char *keyspec, unsigned int options,
     653             :                       export_stats_t stats,
     654             :                       kbnode_t *r_keyblock, void **r_data, size_t *r_datalen)
     655             : {
     656             :   (void)ctrl;
     657             :   (void)keyspec;
     658             :   (void)options;
     659             :   (void)stats;
     660             : 
     661           0 :   *r_keyblock = NULL;
     662           0 :   *r_data = NULL;
     663           0 :   *r_datalen = 0;
     664           0 :   return gpg_error (GPG_ERR_NOT_IMPLEMENTED);
     665             : }
     666             : 
     667             : gpg_error_t
     668           0 : tofu_write_tfs_record (ctrl_t ctrl, estream_t fp,
     669             :                        PKT_public_key *pk, const char *user_id)
     670             : {
     671             :   (void)ctrl;
     672             :   (void)fp;
     673             :   (void)pk;
     674             :   (void)user_id;
     675           0 :   return gpg_error (GPG_ERR_GENERAL);
     676             : }
     677             : 
     678             : gpg_error_t
     679           0 : tofu_get_policy (ctrl_t ctrl, PKT_public_key *pk, PKT_user_id *user_id,
     680             :                  enum tofu_policy *policy)
     681             : {
     682             :   (void)ctrl;
     683             :   (void)pk;
     684             :   (void)user_id;
     685             :   (void)policy;
     686           0 :   return gpg_error (GPG_ERR_GENERAL);
     687             : }
     688             : 
     689             : const char *
     690           0 : tofu_policy_str (enum tofu_policy policy)
     691             : {
     692             :   (void)policy;
     693             : 
     694           0 :   return "unknown";
     695             : }
     696             : 
     697             : void
     698           0 : tofu_begin_batch_update (ctrl_t ctrl)
     699             : {
     700             :   (void)ctrl;
     701           0 : }
     702             : 
     703             : void
     704           0 : tofu_end_batch_update (ctrl_t ctrl)
     705             : {
     706             :   (void)ctrl;
     707           0 : }

Generated by: LCOV version 1.11