g10: On a TOFU conflict, show whether the uids are expired or revoked
[gnupg.git] / g10 / tofu.c
1 /* tofu.c - TOFU trust model.
2  * Copyright (C) 2015, 2016 g10 Code GmbH
3  *
4  * This file is part of GnuPG.
5  *
6  * GnuPG is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 3 of the License, or
9  * (at your option) any later version.
10  *
11  * GnuPG is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, see <http://www.gnu.org/licenses/>.
18  */
19
20 /* TODO:
21
22    - Format the fingerprints nicely when printing (similar to gpg
23      --list-keys)
24  */
25
26 #include <config.h>
27 #include <stdio.h>
28 #include <sys/stat.h>
29 #include <stdarg.h>
30 #include <sqlite3.h>
31
32 #include "gpg.h"
33 #include "types.h"
34 #include "logging.h"
35 #include "stringhelp.h"
36 #include "options.h"
37 #include "mbox-util.h"
38 #include "i18n.h"
39 #include "ttyio.h"
40 #include "trustdb.h"
41 #include "mkdir_p.h"
42 #include "gpgsql.h"
43 #include "status.h"
44
45 #include "tofu.h"
46
47
48 #define CONTROL_L ('L' - 'A' + 1)
49
50 /* Number of signed messages required to indicate that enough history
51  * is available for basic trust.  */
52 #define BASIC_TRUST_THRESHOLD  10
53 /* Number of signed messages required to indicate that a lot of
54  * history is available.  */
55 #define FULL_TRUST_THRESHOLD  100
56
57
58 /* An struct with data pertaining to the tofu DB.
59
60    To initialize this data structure, call opendbs().  Cleanup is done
61    when the CTRL object is released.  To get a handle to a database,
62    use the getdb() function.  This will either return an existing
63    handle or open a new DB connection, as appropriate.  */
64 struct tofu_dbs_s
65 {
66   sqlite3 *db;
67
68   struct
69   {
70     sqlite3_stmt *savepoint_batch;
71     sqlite3_stmt *savepoint_batch_commit;
72
73     sqlite3_stmt *record_binding_get_old_policy;
74     sqlite3_stmt *record_binding_update;
75     sqlite3_stmt *record_binding_update2;
76     sqlite3_stmt *get_policy_select_policy_and_conflict;
77     sqlite3_stmt *get_trust_bindings_with_this_email;
78     sqlite3_stmt *get_trust_gather_other_user_ids;
79     sqlite3_stmt *get_trust_gather_other_keys;
80     sqlite3_stmt *register_already_seen;
81     sqlite3_stmt *register_insert;
82   } s;
83
84   int in_batch_transaction;
85   int in_transaction;
86   time_t batch_update_started;
87 };
88
89
90 #define STRINGIFY(s) STRINGIFY2(s)
91 #define STRINGIFY2(s) #s
92
93 /* The grouping parameters when collecting signature statistics.  */
94
95 /* If a message is signed a couple of hours in the future, just assume
96    some clock skew.  */
97 #define TIME_AGO_FUTURE_IGNORE (2 * 60 * 60)
98 #if 0
99 #  define TIME_AGO_UNIT_SMALL 60
100 #  define TIME_AGO_MEDIUM_THRESHOLD (60 * TIME_AGO_UNIT_SMALL)
101 #  define TIME_AGO_UNIT_MEDIUM (60 * 60)
102 #  define TIME_AGO_LARGE_THRESHOLD (24 * 60 * TIME_AGO_UNIT_SMALL)
103 #  define TIME_AGO_UNIT_LARGE (24 * 60 * 60)
104 #else
105 #  define TIME_AGO_UNIT_SMALL (24 * 60 * 60)
106 #  define TIME_AGO_MEDIUM_THRESHOLD (4 * TIME_AGO_UNIT_SMALL)
107 #  define TIME_AGO_UNIT_MEDIUM (7 * 24 * 60 * 60)
108 #  define TIME_AGO_LARGE_THRESHOLD (28 * TIME_AGO_UNIT_SMALL)
109 #  define TIME_AGO_UNIT_LARGE (30 * 24 * 60 * 60)
110 #endif
111
112 /* Local prototypes.  */
113 static gpg_error_t end_transaction (ctrl_t ctrl, int only_batch);
114 static char *email_from_user_id (const char *user_id);
115
116
117 \f
118 const char *
119 tofu_policy_str (enum tofu_policy policy)
120 {
121   switch (policy)
122     {
123     case TOFU_POLICY_NONE: return "none";
124     case TOFU_POLICY_AUTO: return "auto";
125     case TOFU_POLICY_GOOD: return "good";
126     case TOFU_POLICY_UNKNOWN: return "unknown";
127     case TOFU_POLICY_BAD: return "bad";
128     case TOFU_POLICY_ASK: return "ask";
129     default: return "???";
130     }
131 }
132
133 /* Convert a binding policy (e.g., TOFU_POLICY_BAD) to a trust level
134    (e.g., TRUST_BAD) in light of the current configuration.  */
135 int
136 tofu_policy_to_trust_level (enum tofu_policy policy)
137 {
138   if (policy == TOFU_POLICY_AUTO)
139     /* If POLICY is AUTO, fallback to OPT.TOFU_DEFAULT_POLICY.  */
140     policy = opt.tofu_default_policy;
141
142   switch (policy)
143     {
144     case TOFU_POLICY_AUTO:
145       /* If POLICY and OPT.TOFU_DEFAULT_POLICY are both AUTO, default
146          to marginal trust.  */
147       return TRUST_MARGINAL;
148     case TOFU_POLICY_GOOD:
149       return TRUST_FULLY;
150     case TOFU_POLICY_UNKNOWN:
151       return TRUST_UNKNOWN;
152     case TOFU_POLICY_BAD:
153       return TRUST_NEVER;
154     case TOFU_POLICY_ASK:
155       return TRUST_UNKNOWN;
156     default:
157       log_bug ("Bad value for trust policy: %d\n",
158                opt.tofu_default_policy);
159       return 0;
160     }
161 }
162
163
164 \f
165 /* Start a transaction on DB.  */
166 static gpg_error_t
167 begin_transaction (ctrl_t ctrl)
168 {
169   tofu_dbs_t dbs = ctrl->tofu.dbs;
170   int rc;
171   char *err = NULL;
172
173   log_assert (dbs);
174
175   /* If we've been in batch update mode for a while (on average, more
176    * than 500 ms), to prevent starving other gpg processes, we drop
177    * and retake the batch lock.
178    *
179    * Note: if we wanted higher resolution, we could use
180    * npth_clock_gettime.  */
181   if (/* No real transactions.  */
182       dbs->in_transaction == 0
183       /* There is an open batch transaction.  */
184       && dbs->in_batch_transaction
185       /* And some time has gone by since it was started.  */
186       && dbs->batch_update_started != gnupg_get_time ())
187     {
188       /* If we are in a batch update, then batch updates better have
189          been enabled.  */
190       log_assert (ctrl->tofu.batch_updated_wanted);
191
192       end_transaction (ctrl, 2);
193
194       /* Yield to allow another process a chance to run.  */
195       gpgrt_yield ();
196     }
197
198   if (/* Batch mode is enabled.  */
199       ctrl->tofu.batch_updated_wanted
200       /* But we don't have an open batch transaction.  */
201       && !dbs->in_batch_transaction)
202     {
203       /* We are in batch mode, but we don't have an open batch
204        * transaction.  Since the batch save point must be the outer
205        * save point, it must be taken before the inner save point.  */
206       log_assert (dbs->in_transaction == 0);
207
208       rc = gpgsql_stepx (dbs->db, &dbs->s.savepoint_batch,
209                           NULL, NULL, &err,
210                           "savepoint batch;", GPGSQL_ARG_END);
211       if (rc)
212         {
213           log_error (_("error beginning transaction on TOFU database: %s\n"),
214                      err);
215           sqlite3_free (err);
216           return gpg_error (GPG_ERR_GENERAL);
217         }
218
219       dbs->in_batch_transaction = 1;
220       dbs->batch_update_started = gnupg_get_time ();
221     }
222
223   log_assert(dbs->in_transaction >= 0);
224   dbs->in_transaction ++;
225
226   rc = gpgsql_exec_printf (dbs->db, NULL, NULL, &err,
227                            "savepoint inner%d;",
228                            dbs->in_transaction);
229   if (rc)
230     {
231       log_error (_("error beginning transaction on TOFU database: %s\n"),
232                  err);
233       sqlite3_free (err);
234       return gpg_error (GPG_ERR_GENERAL);
235     }
236
237   return 0;
238 }
239
240
241 /* Commit a transaction.  If ONLY_BATCH is 1, then this only ends the
242  * batch transaction if we have left batch mode.  If ONLY_BATCH is 2,
243  * this ends any open batch transaction even if we are still in batch
244  * mode.  */
245 static gpg_error_t
246 end_transaction (ctrl_t ctrl, int only_batch)
247 {
248   tofu_dbs_t dbs = ctrl->tofu.dbs;
249   int rc;
250   char *err = NULL;
251
252   if (only_batch)
253     {
254       if (!dbs)
255         return 0;  /* Shortcut to allow for easier cleanup code.  */
256
257       /* If we are releasing the batch transaction, then we better not
258          be in a normal transaction.  */
259       log_assert (dbs->in_transaction == 0);
260
261       if (/* Batch mode disabled?  */
262           (!ctrl->tofu.batch_updated_wanted || only_batch == 2)
263           /* But, we still have an open batch transaction?  */
264           && dbs->in_batch_transaction)
265         {
266           /* The batch transaction is still in open, but we've left
267            * batch mode.  */
268           dbs->in_batch_transaction = 0;
269
270           rc = gpgsql_stepx (dbs->db, &dbs->s.savepoint_batch_commit,
271                              NULL, NULL, &err,
272                              "release batch;", GPGSQL_ARG_END);
273           if (rc)
274             {
275               log_error (_("error committing transaction on TOFU database: %s\n"),
276                          err);
277               sqlite3_free (err);
278               return gpg_error (GPG_ERR_GENERAL);
279             }
280
281           return 0;
282         }
283
284       return 0;
285     }
286
287   log_assert (dbs);
288   log_assert (dbs->in_transaction > 0);
289
290   rc = gpgsql_exec_printf (dbs->db, NULL, NULL, &err,
291                            "release inner%d;", dbs->in_transaction);
292   if (rc)
293     {
294       log_error (_("error committing transaction on TOFU database: %s\n"),
295                  err);
296       sqlite3_free (err);
297       return gpg_error (GPG_ERR_GENERAL);
298     }
299
300   dbs->in_transaction --;
301
302   return 0;
303 }
304
305
306 static gpg_error_t
307 rollback_transaction (ctrl_t ctrl)
308 {
309   tofu_dbs_t dbs = ctrl->tofu.dbs;
310   int rc;
311   char *err = NULL;
312
313   log_assert (dbs);
314   log_assert (dbs->in_transaction > 0);
315
316   /* Be careful to not any progress made by closed transactions in
317      batch mode.  */
318   rc = gpgsql_exec_printf (dbs->db, NULL, NULL, &err,
319                            "rollback to inner%d;",
320                            dbs->in_transaction);
321
322   dbs->in_transaction --;
323
324   if (rc)
325     {
326       log_error (_("error rolling back transaction on TOFU database: %s\n"),
327                  err);
328       sqlite3_free (err);
329       return gpg_error (GPG_ERR_GENERAL);
330     }
331
332   return 0;
333 }
334
335 void
336 tofu_begin_batch_update (ctrl_t ctrl)
337 {
338   ctrl->tofu.batch_updated_wanted ++;
339 }
340
341 void
342 tofu_end_batch_update (ctrl_t ctrl)
343 {
344   log_assert (ctrl->tofu.batch_updated_wanted > 0);
345   ctrl->tofu.batch_updated_wanted --;
346
347   if (!ctrl->tofu.batch_updated_wanted)
348     end_transaction (ctrl, 1);
349 }
350
351
352
353 \f
354 /* Wrapper around strtol which prints a warning in case of a
355  * conversion error.  On success the converted value is stored at
356  * R_VALUE and 0 is returned; on error FALLBACK is stored at R_VALUE
357  * and an error code is returned.  */
358 static gpg_error_t
359 string_to_long (long *r_value, const char *string, long fallback, int line)
360 {
361   gpg_error_t err;
362   char *tail = NULL;
363
364   gpg_err_set_errno (0);
365   *r_value = strtol (string, &tail, 0);
366   if (errno || !(!strcmp (tail, ".0") || !*tail))
367     {
368       err = errno? gpg_error_from_errno (errno) : gpg_error (GPG_ERR_BAD_DATA);
369       log_debug ("%s:%d: "
370                  "strtol failed for DB returned string (tail=%.10s): %s\n",
371                  __FILE__, line, tail, gpg_strerror (err));
372       *r_value = fallback;
373     }
374   else
375     err = 0;
376
377   return err;
378 }
379
380
381 /* Wrapper around strtoul which prints a warning in case of a
382  * conversion error.  On success the converted value is stored at
383  * R_VALUE and 0 is returned; on error FALLBACK is stored at R_VALUE
384  * and an error code is returned.  */
385 static gpg_error_t
386 string_to_ulong (unsigned long *r_value, const char *string,
387                  unsigned long fallback, int line)
388 {
389   gpg_error_t err;
390   char *tail = NULL;
391
392   gpg_err_set_errno (0);
393   *r_value = strtoul (string, &tail, 0);
394   if (errno || !(!strcmp (tail, ".0") || !*tail))
395     {
396       err = errno? gpg_error_from_errno (errno) : gpg_error (GPG_ERR_BAD_DATA);
397       log_debug ("%s:%d: "
398                  "strtoul failed for DB returned string (tail=%.10s): %s\n",
399                  __FILE__, line, tail, gpg_strerror (err));
400       *r_value = fallback;
401     }
402   else
403     err = 0;
404
405   return err;
406 }
407
408
409
410 /* Collect results of a select count (*) ...; style query.  Aborts if
411    the argument is not a valid integer (or real of the form X.0).  */
412 static int
413 get_single_unsigned_long_cb (void *cookie, int argc, char **argv,
414                              char **azColName)
415 {
416   unsigned long int *count = cookie;
417
418   (void) azColName;
419
420   log_assert (argc == 1);
421
422   if (string_to_ulong (count, argv[0], 0, __LINE__))
423     return 1; /* Abort.  */
424   return 0;
425 }
426
427 static int
428 get_single_unsigned_long_cb2 (void *cookie, int argc, char **argv,
429                              char **azColName, sqlite3_stmt *stmt)
430 {
431   (void) stmt;
432   return get_single_unsigned_long_cb (cookie, argc, argv, azColName);
433 }
434
435 /* We expect a single integer column whose name is "version".  COOKIE
436    must point to an int.  This function always aborts.  On error or a
437    if the version is bad, sets *VERSION to -1.  */
438 static int
439 version_check_cb (void *cookie, int argc, char **argv, char **azColName)
440 {
441   int *version = cookie;
442
443   if (argc != 1 || strcmp (azColName[0], "version") != 0)
444     {
445       *version = -1;
446       return 1;
447     }
448
449   if (strcmp (argv[0], "1") == 0)
450     *version = 1;
451   else
452     {
453       log_error (_("unsupported TOFU database version: %s\n"), argv[0]);
454       *version = -1;
455     }
456
457   /* Don't run again.  */
458   return 1;
459 }
460
461
462 /* If the DB is new, initialize it.  Otherwise, check the DB's
463    version.
464
465    Return 0 if the database is okay and 1 otherwise.  */
466 static int
467 initdb (sqlite3 *db)
468 {
469   char *err = NULL;
470   int rc;
471   unsigned long int count;
472   int version = -1;
473
474   rc = sqlite3_exec (db, "begin transaction;", NULL, NULL, &err);
475   if (rc)
476     {
477       log_error (_("error beginning transaction on TOFU database: %s\n"),
478                  err);
479       sqlite3_free (err);
480       return 1;
481     }
482
483   /* If the DB has no tables, then assume this is a new DB that needs
484      to be initialized.  */
485   rc = sqlite3_exec (db,
486                      "select count(*) from sqlite_master where type='table';",
487                      get_single_unsigned_long_cb, &count, &err);
488   if (rc)
489     {
490       log_error (_("error reading TOFU database: %s\n"), err);
491       print_further_info ("query available tables");
492       sqlite3_free (err);
493       goto out;
494     }
495   else if (count != 0)
496     /* Assume that the DB is already initialized.  Make sure the
497        version is okay.  */
498     {
499       rc = sqlite3_exec (db, "select version from version;", version_check_cb,
500                          &version, &err);
501       if (rc == SQLITE_ABORT && version == 1)
502         /* Happy, happy, joy, joy.  */
503         {
504           sqlite3_free (err);
505           rc = 0;
506           goto out;
507         }
508       else if (rc == SQLITE_ABORT && version == -1)
509         /* Unsupported version.  */
510         {
511           /* An error message was already displayed.  */
512           sqlite3_free (err);
513           goto out;
514         }
515       else if (rc)
516         /* Some error.  */
517         {
518           log_error (_("error determining TOFU database's version: %s\n"), err);
519           sqlite3_free (err);
520           goto out;
521         }
522       else
523         {
524           /* Unexpected success.  This can only happen if there are no
525              rows.  (select returned 0, but expected ABORT.)  */
526           log_error (_("error determining TOFU database's version: %s\n"),
527                      gpg_strerror (GPG_ERR_NO_DATA));
528           rc = 1;
529           goto out;
530         }
531     }
532
533   /* Create the version table.  */
534   rc = sqlite3_exec (db,
535                      "create table version (version INTEGER);",
536                      NULL, NULL, &err);
537   if (rc)
538     {
539       log_error (_("error initializing TOFU database: %s\n"), err);
540       print_further_info ("create version");
541       sqlite3_free (err);
542       goto out;
543     }
544
545   /* Initialize the version table, which contains a single integer
546      value.  */
547   rc = sqlite3_exec (db,
548                      "insert into version values (1);",
549                      NULL, NULL, &err);
550   if (rc)
551     {
552       log_error (_("error initializing TOFU database: %s\n"), err);
553       print_further_info ("insert version");
554       sqlite3_free (err);
555       goto out;
556     }
557
558   /* The list of <fingerprint, email> bindings and auxiliary data.
559    *
560    *  OID is a unique ID identifying this binding (and used by the
561    *    signatures table, see below).  Note: OIDs will never be
562    *    reused.
563    *
564    *  FINGERPRINT: The key's fingerprint.
565    *
566    *  EMAIL: The normalized email address.
567    *
568    *  USER_ID: The unmodified user id from which EMAIL was extracted.
569    *
570    *  TIME: The time this binding was first observed.
571    *
572    *  POLICY: The trust policy (TOFU_POLICY_BAD, etc. as an integer).
573    *
574    *  CONFLICT is either NULL or a fingerprint.  Assume that we have
575    *    a binding <0xdeadbeef, foo@example.com> and then we observe
576    *    <0xbaddecaf, foo@example.com>.  There two bindings conflict
577    *    (they have the same email address).  When we observe the
578    *    latter binding, we warn the user about the conflict and ask
579    *    for a policy decision about the new binding.  We also change
580    *    the old binding's policy to ask if it was auto.  So that we
581    *     know why this occurred, we also set conflict to 0xbaddecaf.
582    */
583   rc = gpgsql_exec_printf
584       (db, NULL, NULL, &err,
585        "create table bindings\n"
586        " (oid INTEGER PRIMARY KEY AUTOINCREMENT,\n"
587        "  fingerprint TEXT, email TEXT, user_id TEXT, time INTEGER,\n"
588        "  policy BOOLEAN CHECK (policy in (%d, %d, %d, %d, %d)),\n"
589        "  conflict STRING,\n"
590        "  unique (fingerprint, email));\n"
591        "create index bindings_fingerprint_email\n"
592        " on bindings (fingerprint, email);\n"
593        "create index bindings_email on bindings (email);\n",
594        TOFU_POLICY_AUTO, TOFU_POLICY_GOOD, TOFU_POLICY_UNKNOWN,
595        TOFU_POLICY_BAD, TOFU_POLICY_ASK);
596   if (rc)
597     {
598       log_error (_("error initializing TOFU database: %s\n"), err);
599       print_further_info ("create bindings");
600       sqlite3_free (err);
601       goto out;
602     }
603
604   /* The signatures that we have observed.
605    *
606    * BINDING refers to a record in the bindings table, which
607    * describes the binding (i.e., this is a foreign key that
608    * references bindings.oid).
609    *
610    * SIG_DIGEST is the digest stored in the signature.
611    *
612    * SIG_TIME is the timestamp stored in the signature.
613    *
614    * ORIGIN is a free-form string that describes who fed this
615    * signature to GnuPG (e.g., email:claws).
616    *
617    * TIME is the time this signature was registered.  */
618   rc = sqlite3_exec (db,
619                          "create table signatures "
620                          " (binding INTEGER NOT NULL, sig_digest TEXT,"
621                          "  origin TEXT, sig_time INTEGER, time INTEGER,"
622                          "  primary key (binding, sig_digest, origin));",
623                          NULL, NULL, &err);
624   if (rc)
625     {
626       log_error (_("error initializing TOFU database: %s\n"), err);
627       print_further_info ("create signatures");
628       sqlite3_free (err);
629       goto out;
630     }
631
632  out:
633   if (rc)
634     {
635       rc = sqlite3_exec (db, "rollback;", NULL, NULL, &err);
636       if (rc)
637         {
638           log_error (_("error rolling back transaction on TOFU database: %s\n"),
639                      err);
640           sqlite3_free (err);
641         }
642       return 1;
643     }
644   else
645     {
646       rc = sqlite3_exec (db, "end transaction;", NULL, NULL, &err);
647       if (rc)
648         {
649           log_error (_("error committing transaction on TOFU database: %s\n"),
650                      err);
651           sqlite3_free (err);
652           return 1;
653         }
654       return 0;
655     }
656 }
657
658
659 /* Create a new DB handle.  Returns NULL on error.  */
660 /* FIXME: Change to return an error code for better reporting by the
661    caller.  */
662 static tofu_dbs_t
663 opendbs (ctrl_t ctrl)
664 {
665   char *filename;
666   sqlite3 *db;
667   int rc;
668
669   if (!ctrl->tofu.dbs)
670     {
671       filename = make_filename (gnupg_homedir (), "tofu.db", NULL);
672
673       rc = sqlite3_open (filename, &db);
674       if (rc)
675         {
676           log_error (_("error opening TOFU database '%s': %s\n"),
677                      filename, sqlite3_errmsg (db));
678           /* Even if an error occurs, DB is guaranteed to be valid.  */
679           sqlite3_close (db);
680           db = NULL;
681         }
682       xfree (filename);
683
684       /* If a DB is locked wait up to 5 seconds for the lock to be cleared
685          before failing.  */
686       if (db)
687         sqlite3_busy_timeout (db, 5 * 1000);
688
689       if (db && initdb (db))
690         {
691           sqlite3_close (db);
692           db = NULL;
693         }
694
695       if (db)
696         {
697           ctrl->tofu.dbs = xmalloc_clear (sizeof *ctrl->tofu.dbs);
698           ctrl->tofu.dbs->db = db;
699         }
700     }
701   else
702     log_assert (ctrl->tofu.dbs->db);
703
704   return ctrl->tofu.dbs;
705 }
706
707
708 /* Release all of the resources associated with the DB handle.  */
709 void
710 tofu_closedbs (ctrl_t ctrl)
711 {
712   tofu_dbs_t dbs;
713   sqlite3_stmt **statements;
714
715   dbs = ctrl->tofu.dbs;
716   if (!dbs)
717     return;  /* Not initialized.  */
718
719   log_assert (dbs->in_transaction == 0);
720
721   end_transaction (ctrl, 2);
722
723   /* Arghh, that is a surprising use of the struct.  */
724   for (statements = (void *) &dbs->s;
725        (void *) statements < (void *) &(&dbs->s)[1];
726        statements ++)
727     sqlite3_finalize (*statements);
728
729   sqlite3_close (dbs->db);
730   xfree (dbs);
731   ctrl->tofu.dbs = NULL;
732 }
733
734
735 /* Collect results of a select min (foo) ...; style query.  Aborts if
736    the argument is not a valid integer (or real of the form X.0).  */
737 static int
738 get_single_long_cb (void *cookie, int argc, char **argv, char **azColName)
739 {
740   long *count = cookie;
741
742   (void) azColName;
743
744   log_assert (argc == 1);
745
746   if (string_to_long (count, argv[0], 0, __LINE__))
747     return 1; /* Abort.  */
748
749   return 0;
750 }
751
752 static int
753 get_single_long_cb2 (void *cookie, int argc, char **argv, char **azColName,
754                      sqlite3_stmt *stmt)
755 {
756   (void) stmt;
757   return get_single_long_cb (cookie, argc, argv, azColName);
758 }
759
760 /* Record (or update) a trust policy about a (possibly new)
761    binding.
762
763    If SHOW_OLD is set, the binding's old policy is displayed.  */
764 static gpg_error_t
765 record_binding (tofu_dbs_t dbs, const char *fingerprint, const char *email,
766                 const char *user_id, enum tofu_policy policy, int show_old)
767 {
768   char *fingerprint_pp = format_hexfingerprint (fingerprint, NULL, 0);
769   gpg_error_t rc;
770   char *err = NULL;
771
772   if (! (policy == TOFU_POLICY_AUTO
773          || policy == TOFU_POLICY_GOOD
774          || policy == TOFU_POLICY_UNKNOWN
775          || policy == TOFU_POLICY_BAD
776          || policy == TOFU_POLICY_ASK))
777     log_bug ("%s: Bad value for policy (%d)!\n", __func__, policy);
778
779
780   if (DBG_TRUST || show_old)
781     {
782       /* Get the old policy.  Since this is just for informational
783        * purposes, there is no need to start a transaction or to die
784        * if there is a failure.  */
785
786       /* policy_old needs to be a long and not an enum tofu_policy,
787          because we pass it by reference to get_single_long_cb2, which
788          expects a long.  */
789       long policy_old = TOFU_POLICY_NONE;
790
791       rc = gpgsql_stepx
792         (dbs->db, &dbs->s.record_binding_get_old_policy,
793          get_single_long_cb2, &policy_old, &err,
794          "select policy from bindings where fingerprint = ? and email = ?",
795          GPGSQL_ARG_STRING, fingerprint, GPGSQL_ARG_STRING, email,
796          GPGSQL_ARG_END);
797       if (rc)
798         {
799           log_debug ("TOFU: Error reading from binding database"
800                      " (reading policy for <key: %s, user id: %s>): %s\n",
801                      fingerprint, email, err);
802           sqlite3_free (err);
803         }
804
805       if (policy_old != TOFU_POLICY_NONE)
806         (show_old ? log_info : log_debug)
807           ("Changing TOFU trust policy for binding"
808            " <key: %s, user id: %s> from %s to %s.\n",
809            fingerprint, show_old ? user_id : email,
810            tofu_policy_str (policy_old),
811            tofu_policy_str (policy));
812       else
813         (show_old ? log_info : log_debug)
814           ("Setting TOFU trust policy for new binding"
815            " <key: %s, user id: %s> to %s.\n",
816            fingerprint, show_old ? user_id : email,
817            tofu_policy_str (policy));
818
819       if (policy_old == policy)
820         {
821           rc = 0;
822           goto leave; /* Nothing to do.  */
823         }
824     }
825
826   if (opt.dry_run)
827     {
828       log_info ("TOFU database update skipped due to --dry-run\n");
829       rc = 0;
830       goto leave;
831     }
832
833   rc = gpgsql_stepx
834     (dbs->db, &dbs->s.record_binding_update, NULL, NULL, &err,
835      "insert or replace into bindings\n"
836      " (oid, fingerprint, email, user_id, time, policy)\n"
837      " values (\n"
838      /* If we don't explicitly reuse the OID, then SQLite will
839         reallocate a new one.  We just need to search for the OID
840         based on the fingerprint and email since they are unique.  */
841      "  (select oid from bindings where fingerprint = ? and email = ?),\n"
842      "  ?, ?, ?, strftime('%s','now'), ?);",
843      GPGSQL_ARG_STRING, fingerprint, GPGSQL_ARG_STRING, email,
844      GPGSQL_ARG_STRING, fingerprint, GPGSQL_ARG_STRING, email,
845      GPGSQL_ARG_STRING, user_id, GPGSQL_ARG_INT, (int) policy,
846      GPGSQL_ARG_END);
847   if (rc)
848     {
849       log_error (_("error updating TOFU database: %s\n"), err);
850       print_further_info (" insert bindings <key: %s, user id: %s> = %s",
851                           fingerprint, email, tofu_policy_str (policy));
852       sqlite3_free (err);
853       goto leave;
854     }
855
856  leave:
857   xfree (fingerprint_pp);
858   return rc;
859 }
860
861
862 /* Collect the strings returned by a query in a simply string list.
863    Any NULL values are converted to the empty string.
864
865    If a result has 3 rows and each row contains two columns, then the
866    results are added to the list as follows (the value is parentheses
867    is the 1-based index in the final list):
868
869      row 1, col 2 (6)
870      row 1, col 1 (5)
871      row 2, col 2 (4)
872      row 2, col 1 (3)
873      row 3, col 2 (2)
874      row 3, col 1 (1)
875
876    This is because add_to_strlist pushes the results onto the front of
877    the list.  The end result is that the rows are backwards, but the
878    columns are in the expected order.  */
879 static int
880 strings_collect_cb (void *cookie, int argc, char **argv, char **azColName)
881 {
882   int i;
883   strlist_t *strlist = cookie;
884
885   (void) azColName;
886
887   for (i = argc - 1; i >= 0; i --)
888     add_to_strlist (strlist, argv[i] ? argv[i] : "");
889
890   return 0;
891 }
892
893 static int
894 strings_collect_cb2 (void *cookie, int argc, char **argv, char **azColName,
895                      sqlite3_stmt *stmt)
896 {
897   (void) stmt;
898   return strings_collect_cb (cookie, argc, argv, azColName);
899
900 }
901
902 /* Auxiliary data structure to collect statistics about
903    signatures.  */
904 struct signature_stats
905 {
906   struct signature_stats *next;
907
908   /* The user-assigned policy for this binding.  */
909   enum tofu_policy policy;
910
911   /* How long ago the signature was created (rounded to a multiple of
912      TIME_AGO_UNIT_SMALL, etc.).  */
913   long time_ago;
914   /* Number of signatures during this time.  */
915   unsigned long count;
916
917   /* If the corresponding key/user id has been expired / revoked.  */
918   int is_expired;
919   int is_revoked;
920
921   /* The key that generated this signature.  */
922   char fingerprint[1];
923 };
924
925 static void
926 signature_stats_free (struct signature_stats *stats)
927 {
928   while (stats)
929     {
930       struct signature_stats *next = stats->next;
931       xfree (stats);
932       stats = next;
933     }
934 }
935
936 static void
937 signature_stats_prepend (struct signature_stats **statsp,
938                          const char *fingerprint,
939                          enum tofu_policy policy,
940                          long time_ago,
941                          unsigned long count)
942 {
943   struct signature_stats *stats =
944     xmalloc_clear (sizeof (*stats) + strlen (fingerprint));
945
946   stats->next = *statsp;
947   *statsp = stats;
948
949   strcpy (stats->fingerprint, fingerprint);
950   stats->policy = policy;
951   stats->time_ago = time_ago;
952   stats->count = count;
953 }
954
955
956 /* Process rows that contain the four columns:
957
958      <fingerprint, policy, time ago, count>.  */
959 static int
960 signature_stats_collect_cb (void *cookie, int argc, char **argv,
961                             char **azColName, sqlite3_stmt *stmt)
962 {
963   struct signature_stats **statsp = cookie;
964   int i = 0;
965   enum tofu_policy policy;
966   long time_ago;
967   unsigned long count;
968   long along;
969
970   (void) azColName;
971   (void) stmt;
972
973   i ++;
974
975   if (string_to_long (&along, argv[i], 0, __LINE__))
976     return 1;  /* Abort */
977   policy = along;
978   i ++;
979
980   if (! argv[i])
981     time_ago = 0;
982   else
983     {
984       if (string_to_long (&time_ago, argv[i], 0, __LINE__))
985         return 1; /* Abort.  */
986     }
987   i ++;
988
989   /* If time_ago is NULL, then we had no messages, but we still have a
990      single row, which count(*) turns into 1.  */
991   if (! argv[i - 1])
992     count = 0;
993   else
994     {
995       if (string_to_ulong (&count, argv[i], 0, __LINE__))
996         return 1; /* Abort */
997     }
998   i ++;
999
1000   log_assert (argc == i);
1001
1002   signature_stats_prepend (statsp, argv[0], policy, time_ago, count);
1003
1004   return 0;
1005 }
1006
1007 /* Convert from seconds to time units.
1008
1009    Note: T should already be a multiple of TIME_AGO_UNIT_SMALL or
1010    TIME_AGO_UNIT_MEDIUM or TIME_AGO_UNIT_LARGE.  */
1011 signed long
1012 time_ago_scale (signed long t)
1013 {
1014   if (t < TIME_AGO_UNIT_MEDIUM)
1015     return t / TIME_AGO_UNIT_SMALL;
1016   if (t < TIME_AGO_UNIT_LARGE)
1017     return t / TIME_AGO_UNIT_MEDIUM;
1018   return t / TIME_AGO_UNIT_LARGE;
1019 }
1020
1021
1022 /* Return the policy for the binding <FINGERPRINT, EMAIL> (email has
1023    already been normalized) and any conflict information in *CONFLICT
1024    if CONFLICT is not NULL.  Returns _tofu_GET_POLICY_ERROR if an error
1025    occurs.  */
1026 static enum tofu_policy
1027 get_policy (tofu_dbs_t dbs, const char *fingerprint, const char *email,
1028             char **conflict)
1029 {
1030   int rc;
1031   char *err = NULL;
1032   strlist_t strlist = NULL;
1033   enum tofu_policy policy = _tofu_GET_POLICY_ERROR;
1034   long along;
1035
1036   /* Check if the <FINGERPRINT, EMAIL> binding is known
1037      (TOFU_POLICY_NONE cannot appear in the DB.  Thus, if POLICY is
1038      still TOFU_POLICY_NONE after executing the query, then the
1039      result set was empty.)  */
1040   rc = gpgsql_stepx (dbs->db, &dbs->s.get_policy_select_policy_and_conflict,
1041                       strings_collect_cb2, &strlist, &err,
1042                       "select policy, conflict from bindings\n"
1043                       " where fingerprint = ? and email = ?",
1044                       GPGSQL_ARG_STRING, fingerprint,
1045                       GPGSQL_ARG_STRING, email,
1046                       GPGSQL_ARG_END);
1047   if (rc)
1048     {
1049       log_error (_("error reading TOFU database: %s\n"), err);
1050       print_further_info ("checking for existing bad bindings");
1051       sqlite3_free (err);
1052       goto out;
1053     }
1054
1055   if (strlist_length (strlist) == 0)
1056     /* No results.  */
1057     {
1058       policy = TOFU_POLICY_NONE;
1059       goto out;
1060     }
1061   else if (strlist_length (strlist) != 2)
1062     /* The result has the wrong form.  */
1063     {
1064       log_error (_("error reading TOFU database: %s\n"),
1065                  gpg_strerror (GPG_ERR_BAD_DATA));
1066       print_further_info ("checking for existing bad bindings:"
1067                           " expected 2 results, got %d\n",
1068                           strlist_length (strlist));
1069       goto out;
1070     }
1071
1072   /* The result has the right form.  */
1073
1074   if (string_to_long (&along, strlist->d, 0, __LINE__))
1075     {
1076       log_error (_("error reading TOFU database: %s\n"),
1077                  gpg_strerror (GPG_ERR_BAD_DATA));
1078       print_further_info ("bad value for policy: %s", strlist->d);
1079       goto out;
1080     }
1081   policy = along;
1082
1083   if (! (policy == TOFU_POLICY_AUTO
1084          || policy == TOFU_POLICY_GOOD
1085          || policy == TOFU_POLICY_UNKNOWN
1086          || policy == TOFU_POLICY_BAD
1087          || policy == TOFU_POLICY_ASK))
1088     {
1089       log_error (_("error reading TOFU database: %s\n"),
1090                  gpg_strerror (GPG_ERR_DB_CORRUPTED));
1091       print_further_info ("invalid value for policy (%d)", policy);
1092       policy = _tofu_GET_POLICY_ERROR;
1093       goto out;
1094     }
1095
1096
1097   /* If CONFLICT is set, then policy should be TOFU_POLICY_ASK.  But,
1098      just in case, we do the check again here and ignore the conflict
1099      if POLICY is not TOFU_POLICY_ASK.  */
1100   if (conflict)
1101     {
1102       if (policy == TOFU_POLICY_ASK && *strlist->next->d)
1103         *conflict = xstrdup (strlist->next->d);
1104       else
1105         *conflict = NULL;
1106     }
1107
1108  out:
1109   log_assert (policy == _tofu_GET_POLICY_ERROR
1110               || policy == TOFU_POLICY_NONE
1111               || policy == TOFU_POLICY_AUTO
1112               || policy == TOFU_POLICY_GOOD
1113               || policy == TOFU_POLICY_UNKNOWN
1114               || policy == TOFU_POLICY_BAD
1115               || policy == TOFU_POLICY_ASK);
1116
1117   free_strlist (strlist);
1118
1119   return policy;
1120 }
1121
1122
1123 /* Format the first part of a conflict message and return that as a
1124  * malloced string.  */
1125 static char *
1126 format_conflict_msg_part1 (int policy, const char *conflict,
1127                            const char *fingerprint, const char *email)
1128 {
1129   estream_t fp;
1130   char *binding;
1131   int binding_shown = 0;
1132   char *tmpstr, *text;
1133
1134   binding = xasprintf ("<%s, %s>", fingerprint, email);
1135
1136   fp = es_fopenmem (0, "rw,samethread");
1137   if (!fp)
1138     log_fatal ("error creating memory stream: %s\n",
1139                gpg_strerror (gpg_error_from_syserror()));
1140
1141   if (policy == TOFU_POLICY_NONE)
1142     {
1143       es_fprintf (fp, _("The binding %s is NOT known."), binding);
1144       es_fputs ("  ", fp);
1145       binding_shown = 1;
1146     }
1147   else if (policy == TOFU_POLICY_ASK
1148            /* If there the conflict is with itself, then don't
1149             * display this message.  */
1150            && conflict && strcmp (conflict, fingerprint))
1151     {
1152       es_fprintf (fp,
1153                   _("The key with fingerprint %s raised a conflict "
1154                     "with the binding %s."
1155                     "  Since this binding's policy was 'auto', it was "
1156                     "changed to 'ask'."),
1157                   conflict, binding);
1158       es_fputs ("  ", fp);
1159       binding_shown = 1;
1160     }
1161
1162   /* TRANSLATORS: The %s%s is replaced by either a fingerprint and a
1163      blank or by two empty strings.  */
1164   es_fprintf (fp,
1165               _("Please indicate whether you believe the binding %s%s"
1166                 "is legitimate (the key belongs to the stated owner) "
1167                 "or a forgery (bad)."),
1168               binding_shown ? "" : binding,
1169               binding_shown ? "" : " ");
1170   es_fputc ('\n', fp);
1171
1172   xfree (binding);
1173
1174   es_fputc (0, fp);
1175   if (es_fclose_snatch (fp, (void **)&tmpstr, NULL))
1176     log_fatal ("error snatching memory stream\n");
1177   text = format_text (tmpstr, 0, 72, 80);
1178   es_free (tmpstr);
1179
1180   return text;
1181 }
1182
1183
1184 /* Ask the user about the binding.  There are three ways we could end
1185  * up here:
1186  *
1187  *   - This is a new binding and there is a conflict
1188  *     (policy == TOFU_POLICY_NONE && bindings_with_this_email_count > 0),
1189  *
1190  *   - This is a new binding and opt.tofu_default_policy is set to
1191  *     ask.  (policy == TOFU_POLICY_NONE && opt.tofu_default_policy ==
1192  *     TOFU_POLICY_ASK), or,
1193  *
1194  *   - The policy is ask (the user deferred last time) (policy ==
1195  *     TOFU_POLICY_ASK).
1196  */
1197 static void
1198 ask_about_binding (tofu_dbs_t dbs,
1199                    enum tofu_policy *policy,
1200                    int *trust_level,
1201                    int bindings_with_this_email_count,
1202                    strlist_t bindings_with_this_email,
1203                    char *conflict,
1204                    const char *fingerprint,
1205                    const char *email,
1206                    const char *user_id)
1207 {
1208   char *sqerr = NULL;
1209   int rc;
1210   estream_t fp;
1211   strlist_t other_user_ids = NULL;
1212   struct signature_stats *stats = NULL;
1213   struct signature_stats *stats_iter = NULL;
1214   char *prompt;
1215   char *choices;
1216
1217   fp = es_fopenmem (0, "rw,samethread");
1218   if (!fp)
1219     log_fatal ("error creating memory stream: %s\n",
1220                gpg_strerror (gpg_error_from_syserror()));
1221
1222   {
1223     char *text = format_conflict_msg_part1 (*policy, conflict,
1224                                             fingerprint, email);
1225     es_fputs (text, fp);
1226     es_fputc ('\n', fp);
1227     xfree (text);
1228   }
1229
1230   /* Find other user ids associated with this key and whether the
1231    * bindings are marked as good or bad.  */
1232   rc = gpgsql_stepx
1233     (dbs->db, &dbs->s.get_trust_gather_other_user_ids,
1234      strings_collect_cb2, &other_user_ids, &sqerr,
1235      "select user_id, policy from bindings where fingerprint = ?;",
1236      GPGSQL_ARG_STRING, fingerprint, GPGSQL_ARG_END);
1237   if (rc)
1238     {
1239       log_error (_("error gathering other user IDs: %s\n"), sqerr);
1240       sqlite3_free (sqerr);
1241       sqerr = NULL;
1242     }
1243
1244   if (other_user_ids)
1245     {
1246       strlist_t strlist_iter;
1247
1248       es_fprintf (fp, _("Known user IDs associated with this key:\n"));
1249       for (strlist_iter = other_user_ids;
1250            strlist_iter;
1251            strlist_iter = strlist_iter->next)
1252         {
1253           char *other_user_id = strlist_iter->d;
1254           char *other_thing;
1255           enum tofu_policy other_policy;
1256
1257           log_assert (strlist_iter->next);
1258           strlist_iter = strlist_iter->next;
1259           other_thing = strlist_iter->d;
1260
1261           other_policy = atoi (other_thing);
1262
1263           es_fprintf (fp, "  %s (", other_user_id);
1264           es_fprintf (fp, _("policy: %s"), tofu_policy_str (other_policy));
1265           es_fprintf (fp, ")\n");
1266         }
1267       es_fprintf (fp, "\n");
1268
1269       free_strlist (other_user_ids);
1270     }
1271
1272   /* Find other keys associated with this email address.  */
1273   /* FIXME: When generating the statistics, do we want the time
1274      embedded in the signature (column 'sig_time') or the time that
1275      we first verified the signature (column 'time').  */
1276   rc = gpgsql_stepx
1277     (dbs->db, &dbs->s.get_trust_gather_other_keys,
1278      signature_stats_collect_cb, &stats, &sqerr,
1279      "select fingerprint, policy, time_ago, count(*)\n"
1280      " from (select bindings.*,\n"
1281      "        case\n"
1282      /* From the future (but if its just a couple of hours in the
1283       * future don't turn it into a warning)?  Or should we use
1284       * small, medium or large units?  (Note: whatever we do, we
1285       * keep the value in seconds.  Then when we group, everything
1286       * that rounds to the same number of seconds is grouped.)  */
1287      "         when delta < -("STRINGIFY (TIME_AGO_FUTURE_IGNORE)") then -1\n"
1288      "         when delta < ("STRINGIFY (TIME_AGO_MEDIUM_THRESHOLD)")\n"
1289      "          then max(0,\n"
1290      "                   round(delta / ("STRINGIFY (TIME_AGO_UNIT_SMALL)"))\n"
1291      "               * ("STRINGIFY (TIME_AGO_UNIT_SMALL)"))\n"
1292      "         when delta < ("STRINGIFY (TIME_AGO_LARGE_THRESHOLD)")\n"
1293      "          then round(delta / ("STRINGIFY (TIME_AGO_UNIT_MEDIUM)"))\n"
1294      "               * ("STRINGIFY (TIME_AGO_UNIT_MEDIUM)")\n"
1295      "         else round(delta / ("STRINGIFY (TIME_AGO_UNIT_LARGE)"))\n"
1296      "              * ("STRINGIFY (TIME_AGO_UNIT_LARGE)")\n"
1297      "        end time_ago,\n"
1298      "        delta time_ago_raw\n"
1299      "       from bindings\n"
1300      "       left join\n"
1301      "         (select *,\n"
1302      "            cast(strftime('%s','now') - sig_time as real) delta\n"
1303      "           from signatures) ss\n"
1304      "        on ss.binding = bindings.oid)\n"
1305      " where email = ?\n"
1306      " group by fingerprint, time_ago\n"
1307      /* Make sure the current key is first.  */
1308      " order by fingerprint = ? asc, fingerprint desc, time_ago desc;\n",
1309      GPGSQL_ARG_STRING, email, GPGSQL_ARG_STRING, fingerprint,
1310      GPGSQL_ARG_END);
1311   if (rc)
1312     {
1313       strlist_t strlist_iter;
1314
1315       log_error (_("error gathering signature stats: %s\n"), sqerr);
1316       sqlite3_free (sqerr);
1317       sqerr = NULL;
1318
1319       es_fprintf (fp, ngettext("The email address \"%s\" is"
1320                                " associated with %d key:\n",
1321                                "The email address \"%s\" is"
1322                                " associated with %d keys:\n",
1323                                bindings_with_this_email_count),
1324                   email, bindings_with_this_email_count);
1325       for (strlist_iter = bindings_with_this_email;
1326            strlist_iter;
1327            strlist_iter = strlist_iter->next)
1328         es_fprintf (fp, "  %s\n", strlist_iter->d);
1329     }
1330   else
1331     {
1332       KEYDB_HANDLE hd;
1333       char *key = NULL;
1334
1335       if (! stats || strcmp (stats->fingerprint, fingerprint))
1336         {
1337           /* If we have already added this key to the DB, then it will
1338            * be first (see the above select).  Since the first key on
1339            * the list is not this key, we must not yet have verified any
1340            * messages signed by this key.  Add a dummy entry.  */
1341           signature_stats_prepend (&stats, fingerprint, TOFU_POLICY_AUTO, 0, 0);
1342         }
1343
1344       /* Figure out which user ids are revoked or expired.  */
1345       hd = keydb_new ();
1346       for (stats_iter = stats; stats_iter; stats_iter = stats_iter->next)
1347         {
1348           KEYDB_SEARCH_DESC desc;
1349           kbnode_t kb;
1350           PKT_public_key *pk;
1351           kbnode_t n;
1352           int found_user_id;
1353
1354           rc = keydb_search_reset (hd);
1355           if (rc)
1356             {
1357               log_error (_("resetting keydb: %s\n"),
1358                          gpg_strerror (rc));
1359               continue;
1360             }
1361
1362           rc = classify_user_id (stats_iter->fingerprint, &desc, 0);
1363           if (rc)
1364             {
1365               log_error (_("error parsing key specification '%s': %s\n"),
1366                          stats_iter->fingerprint, gpg_strerror (rc));
1367               continue;
1368             }
1369
1370           rc = keydb_search (hd, &desc, 1, NULL);
1371           if (rc)
1372             {
1373               log_error (_("key \"%s\" not found: %s\n"),
1374                          stats_iter->fingerprint,
1375                          gpg_strerror (rc));
1376               continue;
1377             }
1378
1379           rc = keydb_get_keyblock (hd, &kb);
1380           if (rc)
1381             {
1382               log_error (_("error reading keyblock: %s\n"),
1383                          gpg_strerror (rc));
1384               print_further_info ("fingerprint: %s", stats_iter->fingerprint);
1385               continue;
1386             }
1387
1388           merge_keys_and_selfsig (kb);
1389
1390           log_assert (kb->pkt->pkttype == PKT_PUBLIC_KEY);
1391           pk = kb->pkt->pkt.public_key;
1392
1393           if (pk->has_expired)
1394             stats_iter->is_expired = 1;
1395           if (pk->flags.revoked)
1396             stats_iter->is_revoked = 1;
1397
1398           n = kb;
1399           found_user_id = 0;
1400           while ((n = find_next_kbnode (n, PKT_USER_ID)) && ! found_user_id)
1401             {
1402               PKT_user_id *user_id2 = n->pkt->pkt.user_id;
1403               char *email2;
1404
1405               if (user_id2->attrib_data)
1406                 continue;
1407
1408               email2 = email_from_user_id (user_id2->name);
1409
1410               if (strcmp (email, email2) == 0)
1411                 {
1412                   found_user_id = 1;
1413
1414                   if (user_id2->is_revoked)
1415                     stats_iter->is_revoked = 1;
1416                   if (user_id2->is_expired)
1417                     stats_iter->is_expired = 1;
1418                 }
1419
1420               xfree (email2);
1421             }
1422           release_kbnode (kb);
1423
1424           if (! found_user_id)
1425             log_info (_("TOFU db may be corrupted: user id (%s)"
1426                         " not on key block (%s)\n"),
1427                       email, fingerprint);
1428         }
1429       keydb_release (hd);
1430
1431       es_fprintf (fp, _("Statistics for keys with the email address \"%s\":\n"),
1432                   email);
1433       for (stats_iter = stats; stats_iter; stats_iter = stats_iter->next)
1434         {
1435           if (! key || strcmp (key, stats_iter->fingerprint))
1436             {
1437               int this_key;
1438               char *key_pp;
1439
1440               key = stats_iter->fingerprint;
1441               this_key = strcmp (key, fingerprint) == 0;
1442               key_pp = format_hexfingerprint (key, NULL, 0);
1443               es_fprintf (fp, "  %s (", key_pp);
1444
1445               if (stats_iter->is_revoked)
1446                 {
1447                   es_fprintf (fp, _("revoked"));
1448                   es_fprintf (fp, _(", "));
1449                 }
1450               else if (stats_iter->is_expired)
1451                 {
1452                   es_fprintf (fp, _("expired"));
1453                   es_fprintf (fp, _(", "));
1454                 }
1455
1456               if (this_key)
1457                 es_fprintf (fp, _("this key"));
1458               else
1459                 es_fprintf (fp, _("policy: %s"),
1460                             tofu_policy_str (stats_iter->policy));
1461               es_fputs ("):\n", fp);
1462               xfree (key_pp);
1463             }
1464
1465           es_fputs ("    ", fp);
1466           if (stats_iter->time_ago == -1)
1467             es_fprintf (fp, ngettext("%ld message signed in the future.",
1468                                      "%ld messages signed in the future.",
1469                                      stats_iter->count), stats_iter->count);
1470           else
1471             {
1472               long t_scaled = time_ago_scale (stats_iter->time_ago);
1473
1474               /* TANSLATORS: This string is concatenated with one of
1475                * the day/week/month strings to form one sentence.  */
1476               es_fprintf (fp, ngettext("%ld message signed",
1477                                        "%ld messages signed",
1478                                        stats_iter->count), stats_iter->count);
1479               if (!stats_iter->count)
1480                 es_fputs (".", fp);
1481               else if (stats_iter->time_ago < TIME_AGO_UNIT_MEDIUM)
1482                 es_fprintf (fp, ngettext(" over the past %ld day.",
1483                                          " over the past %ld days.",
1484                                          t_scaled), t_scaled);
1485               else if (stats_iter->time_ago < TIME_AGO_UNIT_LARGE)
1486                 es_fprintf (fp, ngettext(" over the past %ld week.",
1487                                          " over the past %ld weeks.",
1488                                          t_scaled), t_scaled);
1489               else
1490                 es_fprintf (fp, ngettext(" over the past %ld month.",
1491                                          " over the past %ld months.",
1492                                          t_scaled), t_scaled);
1493             }
1494           es_fputs ("\n", fp);
1495         }
1496     }
1497
1498
1499   if ((*policy == TOFU_POLICY_NONE && bindings_with_this_email_count > 0)
1500       || (*policy == TOFU_POLICY_ASK
1501           && (conflict || bindings_with_this_email_count > 0)))
1502     {
1503       /* This is a conflict.  */
1504
1505       /* TRANSLATORS: Please translate the text found in the source
1506        * file below.  We don't directly internationalize that text so
1507        * that we can tweak it without breaking translations.  */
1508       char *text = _("TOFU detected a binding conflict");
1509       char *textbuf;
1510       if (!strcmp (text, "TOFU detected a binding conflict"))
1511         {
1512           /* No translation.  Use the English text.  */
1513           text =
1514             "Normally, there is only a single key associated with an email "
1515             "address.  However, people sometimes generate a new key if "
1516             "their key is too old or they think it might be compromised.  "
1517             "Alternatively, a new key may indicate a man-in-the-middle "
1518             "attack!  Before accepting this key, you should talk to or "
1519             "call the person to make sure this new key is legitimate.";
1520         }
1521       textbuf = format_text (text, 0, 72, 80);
1522       es_fprintf (fp, "\n%s\n", textbuf);
1523       xfree (textbuf);
1524     }
1525
1526   es_fputc ('\n', fp);
1527
1528   /* Add a NUL terminator.  */
1529   es_fputc (0, fp);
1530   if (es_fclose_snatch (fp, (void **) &prompt, NULL))
1531     log_fatal ("error snatching memory stream\n");
1532
1533   /* I think showing the large message once is sufficient.  If we
1534    * would move it right before the cpr_get many lines will scroll
1535    * away and the user might not realize that he merely entered a
1536    * wrong choise (because he does not see that either).  As a small
1537    * benefit we allow C-L to redisplay everything.  */
1538   tty_printf ("%s", prompt);
1539   while (1)
1540     {
1541       char *response;
1542
1543       /* TRANSLATORS: Two letters (normally the lower and upper case
1544        * version of the hotkey) for each of the five choices.  If
1545        * there is only one choice in your language, repeat it.  */
1546       choices = _("gG" "aA" "uU" "rR" "bB");
1547       if (strlen (choices) != 10)
1548         log_bug ("Bad TOFU conflict translation!  Please report.");
1549
1550       response = cpr_get
1551         ("tofu.conflict",
1552          _("(G)ood, (A)ccept once, (U)nknown, (R)eject once, (B)ad? "));
1553       trim_spaces (response);
1554       cpr_kill_prompt ();
1555       if (*response == CONTROL_L)
1556         tty_printf ("%s", prompt);
1557       else if (strlen (response) == 1)
1558         {
1559           char *choice = strchr (choices, *response);
1560           if (choice)
1561             {
1562               int c = ((size_t) choice - (size_t) choices) / 2;
1563
1564               switch (c)
1565                 {
1566                 case 0: /* Good.  */
1567                   *policy = TOFU_POLICY_GOOD;
1568                   *trust_level = tofu_policy_to_trust_level (*policy);
1569                   break;
1570                 case 1: /* Accept once.  */
1571                   *policy = TOFU_POLICY_ASK;
1572                   *trust_level = tofu_policy_to_trust_level (TOFU_POLICY_GOOD);
1573                   break;
1574                 case 2: /* Unknown.  */
1575                   *policy = TOFU_POLICY_UNKNOWN;
1576                   *trust_level = tofu_policy_to_trust_level (*policy);
1577                   break;
1578                 case 3: /* Reject once.  */
1579                   *policy = TOFU_POLICY_ASK;
1580                   *trust_level = tofu_policy_to_trust_level (TOFU_POLICY_BAD);
1581                   break;
1582                 case 4: /* Bad.  */
1583                   *policy = TOFU_POLICY_BAD;
1584                   *trust_level = tofu_policy_to_trust_level (*policy);
1585                   break;
1586                 default:
1587                   log_bug ("c should be between 0 and 4 but it is %d!", c);
1588                 }
1589
1590               if (record_binding (dbs, fingerprint, email, user_id,
1591                                   *policy, 0))
1592                 {
1593                   /* If there's an error registering the
1594                    * binding, don't save the signature.  */
1595                   *trust_level = _tofu_GET_TRUST_ERROR;
1596                 }
1597               break;
1598             }
1599         }
1600       xfree (response);
1601     }
1602
1603   xfree (prompt);
1604
1605   signature_stats_free (stats);
1606 }
1607
1608
1609 /* Return the trust level (TRUST_NEVER, etc.) for the binding
1610  * <FINGERPRINT, EMAIL> (email is already normalized).  If no policy
1611  * is registered, returns TOFU_POLICY_NONE.  If an error occurs,
1612  * returns _tofu_GET_TRUST_ERROR.
1613  *
1614  * PK is the public key object for FINGERPRINT.
1615  *
1616  * USER_ID is the unadulterated user id.
1617  *
1618  * If MAY_ASK is set, then we may interact with the user.  This is
1619  * necessary if there is a conflict or the binding's policy is
1620  * TOFU_POLICY_ASK.  In the case of a conflict, we set the new
1621  * conflicting binding's policy to TOFU_POLICY_ASK.  In either case,
1622  * we return TRUST_UNDEFINED.  */
1623 static enum tofu_policy
1624 get_trust (tofu_dbs_t dbs, PKT_public_key *pk,
1625            const char *fingerprint, const char *email,
1626            const char *user_id, int may_ask)
1627 {
1628   enum tofu_policy policy;
1629   char *conflict = NULL;
1630   int rc;
1631   char *sqerr = NULL;
1632   strlist_t bindings_with_this_email = NULL;
1633   int bindings_with_this_email_count;
1634   int change_conflicting_to_ask = 0;
1635   int trust_level = TRUST_UNKNOWN;
1636
1637   if (opt.batch)
1638     may_ask = 0;
1639
1640   /* Make sure _tofu_GET_TRUST_ERROR isn't equal to any of the trust
1641      levels.  */
1642   log_assert (_tofu_GET_TRUST_ERROR != TRUST_UNKNOWN
1643               && _tofu_GET_TRUST_ERROR != TRUST_EXPIRED
1644               && _tofu_GET_TRUST_ERROR != TRUST_UNDEFINED
1645               && _tofu_GET_TRUST_ERROR != TRUST_NEVER
1646               && _tofu_GET_TRUST_ERROR != TRUST_MARGINAL
1647               && _tofu_GET_TRUST_ERROR != TRUST_FULLY
1648               && _tofu_GET_TRUST_ERROR != TRUST_ULTIMATE);
1649
1650   policy = get_policy (dbs, fingerprint, email, &conflict);
1651   {
1652     /* See if the key is ultimately trusted.  If so, we're done.  */
1653     u32 kid[2];
1654
1655     keyid_from_pk (pk, kid);
1656
1657     if (tdb_keyid_is_utk (kid))
1658       {
1659         if (policy == TOFU_POLICY_NONE)
1660           {
1661             if (record_binding (dbs, fingerprint, email, user_id,
1662                                 TOFU_POLICY_AUTO, 0) != 0)
1663               {
1664                 log_error (_("error setting TOFU binding's trust level"
1665                              " to %s\n"), "auto");
1666                 trust_level = _tofu_GET_TRUST_ERROR;
1667                 goto out;
1668               }
1669           }
1670
1671         trust_level = TRUST_ULTIMATE;
1672         goto out;
1673       }
1674   }
1675
1676   if (policy == TOFU_POLICY_AUTO)
1677     {
1678       policy = opt.tofu_default_policy;
1679       if (DBG_TRUST)
1680         log_debug ("TOFU: binding <key: %s, user id: %s>'s policy is "
1681                    " auto (default: %s).\n",
1682                    fingerprint, email,
1683                    tofu_policy_str (opt.tofu_default_policy));
1684     }
1685   switch (policy)
1686     {
1687     case TOFU_POLICY_AUTO:
1688     case TOFU_POLICY_GOOD:
1689     case TOFU_POLICY_UNKNOWN:
1690     case TOFU_POLICY_BAD:
1691       /* The saved judgement is auto -> auto, good, unknown or bad.
1692        * We don't need to ask the user anything.  */
1693       if (DBG_TRUST)
1694         log_debug ("TOFU: Known binding <key: %s, user id: %s>'s policy: %s\n",
1695                    fingerprint, email, tofu_policy_str (policy));
1696       trust_level = tofu_policy_to_trust_level (policy);
1697       goto out;
1698
1699     case TOFU_POLICY_ASK:
1700       /* We need to ask the user what to do.  Case #1 or #2 below.  */
1701       if (! may_ask)
1702         {
1703           trust_level = TRUST_UNDEFINED;
1704           goto out;
1705         }
1706
1707       break;
1708
1709     case TOFU_POLICY_NONE:
1710       /* The binding is new, we need to check for conflicts.  Case #3
1711        * below.  */
1712       break;
1713
1714     case _tofu_GET_POLICY_ERROR:
1715       trust_level = _tofu_GET_TRUST_ERROR;
1716       goto out;
1717
1718     default:
1719       log_bug ("%s: Impossible value for policy (%d)\n", __func__, policy);
1720     }
1721
1722
1723   /* We get here if:
1724    *
1725    *   1. The saved policy is auto and the default policy is ask
1726    *      (get_policy() == TOFU_POLICY_AUTO
1727    *       && opt.tofu_default_policy == TOFU_POLICY_ASK)
1728    *
1729    *   2. The saved policy is ask (either last time the user selected
1730    *      accept once or reject once or there was a conflict and this
1731    *      binding's policy was changed from auto to ask)
1732    *      (policy == TOFU_POLICY_ASK), or,
1733    *
1734    *   3. We don't have a saved policy (policy == TOFU_POLICY_NONE)
1735    *      (need to check for a conflict).
1736    */
1737
1738   /* Look for conflicts.  This is needed in all 3 cases.
1739    *
1740    * Get the fingerprints of any bindings that share the email
1741    * address.  Note: if the binding in question is in the DB, it will
1742    * also be returned.  Thus, if the result set is empty, then this is
1743    * a new binding.  */
1744   rc = gpgsql_stepx
1745     (dbs->db, &dbs->s.get_trust_bindings_with_this_email,
1746      strings_collect_cb2, &bindings_with_this_email, &sqerr,
1747      "select distinct fingerprint from bindings where email = ?;",
1748      GPGSQL_ARG_STRING, email, GPGSQL_ARG_END);
1749   if (rc)
1750     {
1751       log_error (_("error reading TOFU database: %s\n"), sqerr);
1752       print_further_info ("listing fingerprints");
1753       sqlite3_free (sqerr);
1754       goto out;
1755     }
1756
1757   bindings_with_this_email_count = strlist_length (bindings_with_this_email);
1758   if (bindings_with_this_email_count == 0
1759       && opt.tofu_default_policy != TOFU_POLICY_ASK)
1760     {
1761       /* New binding with no conflict and a concrete default policy.
1762        *
1763        * We've never observed a binding with this email address
1764        * BINDINGS_WITH_THIS_EMAIL_COUNT is 0 and the above query would
1765        * return the current binding if it were in the DB) and we have
1766        * a default policy, which is not to ask the user.
1767        */
1768
1769       /* If we've seen this binding, then we've seen this email and
1770          policy couldn't possibly be TOFU_POLICY_NONE.  */
1771       log_assert (policy == TOFU_POLICY_NONE);
1772
1773       if (DBG_TRUST)
1774         log_debug ("TOFU: New binding <key: %s, user id: %s>, no conflict.\n",
1775                    fingerprint, email);
1776
1777       if (record_binding (dbs, fingerprint, email, user_id,
1778                           TOFU_POLICY_AUTO, 0) != 0)
1779         {
1780           log_error (_("error setting TOFU binding's trust level to %s\n"),
1781                        "auto");
1782           trust_level = _tofu_GET_TRUST_ERROR;
1783           goto out;
1784         }
1785
1786       trust_level = tofu_policy_to_trust_level (TOFU_POLICY_AUTO);
1787       goto out;
1788     }
1789
1790   if (policy == TOFU_POLICY_NONE)
1791     {
1792       /* This is a new binding and we have a conflict.  Mark any
1793        * conflicting bindings that have an automatic policy as now
1794        * requiring confirmation.  Note: we delay this until after we
1795        * ask for confirmation so that when the current policy is
1796        * printed, it is correct.  */
1797       change_conflicting_to_ask = 1;
1798     }
1799
1800   if (! may_ask)
1801     {
1802       /* We can only get here in the third case (no saved policy) and
1803        * if there is a conflict.  (If the policy was ask (cases #1 and
1804        * #2) and we weren't allowed to ask, we'd have already exited).  */
1805       log_assert (policy == TOFU_POLICY_NONE);
1806
1807       if (record_binding (dbs, fingerprint, email, user_id,
1808                           TOFU_POLICY_ASK, 0) != 0)
1809         log_error (_("error setting TOFU binding's trust level to %s\n"),
1810                    "ask");
1811
1812       trust_level = TRUST_UNDEFINED;
1813       goto out;
1814     }
1815
1816   /* If we get here, we need to ask the user about the binding.  */
1817   ask_about_binding (dbs,
1818                      &policy,
1819                      &trust_level,
1820                      bindings_with_this_email_count,
1821                      bindings_with_this_email,
1822                      conflict,
1823                      fingerprint,
1824                      email,
1825                      user_id);
1826
1827  out:
1828   if (change_conflicting_to_ask)
1829     {
1830       if (! may_ask)
1831         {
1832           /* If we weren't allowed to ask, also update this key as
1833              conflicting with itself.  */
1834           rc = gpgsql_exec_printf
1835             (dbs->db, NULL, NULL, &sqerr,
1836              "update bindings set policy = %d, conflict = %Q"
1837              " where email = %Q"
1838              "  and (policy = %d or (policy = %d and fingerprint = %Q));",
1839              TOFU_POLICY_ASK, fingerprint, email, TOFU_POLICY_AUTO,
1840              TOFU_POLICY_ASK, fingerprint);
1841         }
1842       else
1843         {
1844           rc = gpgsql_exec_printf
1845             (dbs->db, NULL, NULL, &sqerr,
1846              "update bindings set policy = %d, conflict = %Q"
1847              " where email = %Q and fingerprint != %Q and policy = %d;",
1848              TOFU_POLICY_ASK, fingerprint, email, fingerprint,
1849              TOFU_POLICY_AUTO);
1850         }
1851
1852       if (rc)
1853         {
1854           log_error (_("error changing TOFU policy: %s\n"), sqerr);
1855           sqlite3_free (sqerr);
1856           sqerr = NULL;
1857         }
1858     }
1859
1860   xfree (conflict);
1861   free_strlist (bindings_with_this_email);
1862
1863   return trust_level;
1864 }
1865
1866
1867 /* Return a malloced string of the form
1868  *    "7 months, 1 day, 5 minutes, 0 seconds"
1869  * The caller should replace all '~' in the returned string by a space
1870  * and also free the returned string.
1871  *
1872  * This is actually a bad hack which may not work correctly with all
1873  * languages.
1874  */
1875 static char *
1876 time_ago_str (long long int t)
1877 {
1878   estream_t fp;
1879   int years = 0;
1880   int months = 0;
1881   int days = 0;
1882   int hours = 0;
1883   int minutes = 0;
1884   int seconds = 0;
1885
1886   /* The number of units that we've printed so far.  */
1887   int count = 0;
1888   /* The first unit that we printed (year = 0, month = 1,
1889      etc.).  */
1890   int first = -1;
1891   /* The current unit.  */
1892   int i = 0;
1893
1894   char *str;
1895
1896   /* It would be nice to use a macro to do this, but gettext
1897      works on the unpreprocessed code.  */
1898 #define MIN_SECS (60)
1899 #define HOUR_SECS (60 * MIN_SECS)
1900 #define DAY_SECS (24 * HOUR_SECS)
1901 #define MONTH_SECS (30 * DAY_SECS)
1902 #define YEAR_SECS (365 * DAY_SECS)
1903
1904   if (t > YEAR_SECS)
1905     {
1906       years = t / YEAR_SECS;
1907       t -= years * YEAR_SECS;
1908     }
1909   if (t > MONTH_SECS)
1910     {
1911       months = t / MONTH_SECS;
1912       t -= months * MONTH_SECS;
1913     }
1914   if (t > DAY_SECS)
1915     {
1916       days = t / DAY_SECS;
1917       t -= days * DAY_SECS;
1918     }
1919   if (t > HOUR_SECS)
1920     {
1921       hours = t / HOUR_SECS;
1922       t -= hours * HOUR_SECS;
1923     }
1924   if (t > MIN_SECS)
1925     {
1926       minutes = t / MIN_SECS;
1927       t -= minutes * MIN_SECS;
1928     }
1929   seconds = t;
1930
1931 #undef MIN_SECS
1932 #undef HOUR_SECS
1933 #undef DAY_SECS
1934 #undef MONTH_SECS
1935 #undef YEAR_SECS
1936
1937   fp = es_fopenmem (0, "rw,samethread");
1938   if (! fp)
1939     log_fatal ("error creating memory stream: %s\n",
1940                gpg_strerror (gpg_error_from_syserror()));
1941
1942   if (years)
1943     {
1944       /* TRANSLATORS: The tilde ('~') is used here to indicate a
1945        * non-breakable space  */
1946       es_fprintf (fp, ngettext("%d~year", "%d~years", years), years);
1947       count ++;
1948       first = i;
1949     }
1950   i ++;
1951   if ((first == -1 || i - first <= 3) && months)
1952     {
1953       if (count)
1954         es_fprintf (fp, ", ");
1955       es_fprintf (fp, ngettext("%d~month", "%d~months", months), months);
1956       count ++;
1957       first = i;
1958     }
1959   i ++;
1960   if ((first == -1 || i - first <= 3) && count < 2 && days)
1961     {
1962       if (count)
1963         es_fprintf (fp, ", ");
1964       es_fprintf (fp, ngettext("%d~day", "%d~days", days), days);
1965       count ++;
1966       first = i;
1967     }
1968   i ++;
1969   if ((first == -1 || i - first <= 3) && count < 2 && hours)
1970     {
1971       if (count)
1972         es_fprintf (fp, ", ");
1973       es_fprintf (fp, ngettext("%d~hour", "%d~hours", hours), hours);
1974       count ++;
1975       first = i;
1976     }
1977   i ++;
1978   if ((first == -1 || i - first <= 3) && count < 2 && minutes)
1979     {
1980       if (count)
1981         es_fprintf (fp, ", ");
1982       es_fprintf (fp, ngettext("%d~minute", "%d~minutes", minutes), minutes);
1983       count ++;
1984       first = i;
1985     }
1986   i ++;
1987   if ((first == -1 || i - first <= 3) && count < 2)
1988     {
1989       if (count)
1990         es_fprintf (fp, ", ");
1991       es_fprintf (fp, ngettext("%d~second", "%d~seconds", seconds), seconds);
1992     }
1993
1994   es_fputc (0, fp);
1995   if (es_fclose_snatch (fp, (void **) &str, NULL))
1996     log_fatal ("error snatching memory stream\n");
1997
1998   return str;
1999 }
2000
2001
2002 /* If FP is NULL, write TOFU_STATS status line.  If FP is not NULL
2003  * write a "tfs" record to that stream. */
2004 static void
2005 write_stats_status (estream_t fp, long messages, enum tofu_policy policy,
2006                     unsigned long first_seen,
2007                     unsigned long most_recent_seen)
2008 {
2009   const char *validity;
2010
2011   if (messages < 1)
2012     validity = "1"; /* Key without history.  */
2013   else if (messages < BASIC_TRUST_THRESHOLD)
2014     validity = "2"; /* Key with too little history.  */
2015   else if (messages < FULL_TRUST_THRESHOLD)
2016     validity = "3"; /* Key with enough history for basic trust.  */
2017   else
2018     validity = "4"; /* Key with a lot of history.  */
2019
2020   if (fp)
2021     {
2022       es_fprintf (fp, "tfs:1:%s:%ld:0:%s:%lu:%lu:\n",
2023                   validity, messages,
2024                   tofu_policy_str (policy),
2025                   first_seen, most_recent_seen);
2026     }
2027   else
2028     {
2029       char numbuf1[35];
2030       char numbuf2[35];
2031       char numbuf3[35];
2032
2033       snprintf (numbuf1, sizeof numbuf1, " %ld", messages);
2034       *numbuf2 = *numbuf3 = 0;
2035       if (first_seen && most_recent_seen)
2036         {
2037           snprintf (numbuf2, sizeof numbuf2, " %lu", first_seen);
2038           snprintf (numbuf3, sizeof numbuf3, " %lu", most_recent_seen);
2039         }
2040
2041       write_status_strings (STATUS_TOFU_STATS,
2042                             validity, numbuf1, " 0",
2043                             " ", tofu_policy_str (policy),
2044                             numbuf2, numbuf3,
2045                             NULL);
2046     }
2047 }
2048
2049
2050 /* Note: If OUTFP is not NULL, this function merely prints a "tfs" record
2051  * to OUTFP.  In this case USER_ID is not required.  */
2052 static void
2053 show_statistics (tofu_dbs_t dbs, const char *fingerprint,
2054                  const char *email, const char *user_id,
2055                  const char *sig_exclude, estream_t outfp)
2056 {
2057   char *fingerprint_pp;
2058   int rc;
2059   strlist_t strlist = NULL;
2060   char *err = NULL;
2061
2062   fingerprint_pp = format_hexfingerprint (fingerprint, NULL, 0);
2063
2064   rc = gpgsql_exec_printf
2065     (dbs->db, strings_collect_cb, &strlist, &err,
2066      "select count (*), min (signatures.time), max (signatures.time)\n"
2067      " from signatures\n"
2068      " left join bindings on signatures.binding = bindings.oid\n"
2069      " where fingerprint = %Q and email = %Q and sig_digest %s%s%s;",
2070      fingerprint, email,
2071      /* We want either: sig_digest != 'SIG_EXCLUDE' or sig_digest is
2072         not NULL.  */
2073      sig_exclude ? "!= '" : "is not NULL",
2074      sig_exclude ? sig_exclude : "",
2075      sig_exclude ? "'" : "");
2076   if (rc)
2077     {
2078       log_error (_("error reading TOFU database: %s\n"), err);
2079       print_further_info ("getting statistics");
2080       sqlite3_free (err);
2081       goto out;
2082     }
2083
2084   if (!outfp)
2085     write_status_text_and_buffer (STATUS_TOFU_USER, fingerprint,
2086                                   email, strlen (email), 0);
2087
2088   if (! strlist)
2089     {
2090       if (!outfp)
2091         log_info (_("Have never verified a message signed by key %s!\n"),
2092                   fingerprint_pp);
2093       write_stats_status (outfp, 0, TOFU_POLICY_NONE, 0, 0);
2094     }
2095   else
2096     {
2097       unsigned long now = gnupg_get_time ();
2098       signed long messages;
2099       unsigned long first_seen;
2100       unsigned long most_recent_seen;
2101
2102       log_assert (strlist_length (strlist) == 3);
2103
2104       string_to_long (&messages, strlist->d, -1, __LINE__);
2105
2106       if (messages == 0 && *strlist->next->d == '\0')
2107         { /* min(NULL) => NULL => "".  */
2108           first_seen = 0;
2109           most_recent_seen = 0;
2110         }
2111       else
2112         {
2113           string_to_ulong (&first_seen, strlist->next->d, -1, __LINE__);
2114           if (first_seen > now)
2115             {
2116               log_debug ("time-warp - tofu DB has a future value (%lu, %lu)\n",
2117                          first_seen, now);
2118               first_seen = now;
2119             }
2120           string_to_ulong (&most_recent_seen, strlist->next->next->d, -1,
2121                            __LINE__);
2122           if (most_recent_seen > now)
2123             {
2124               log_debug ("time-warp - tofu DB has a future value (%lu, %lu)\n",
2125                          most_recent_seen, now);
2126               most_recent_seen = now;
2127             }
2128
2129         }
2130
2131       if (messages == -1 || first_seen == -1)
2132         {
2133           write_stats_status (outfp, 0, TOFU_POLICY_NONE, 0, 0);
2134           if (!outfp)
2135             log_info (_("Failed to collect signature statistics for \"%s\"\n"
2136                         "(key %s)\n"),
2137                       user_id, fingerprint_pp);
2138         }
2139       else if (outfp)
2140         {
2141           write_stats_status (outfp, messages,
2142                               get_policy (dbs, fingerprint, email, NULL),
2143                               first_seen, most_recent_seen);
2144         }
2145       else
2146         {
2147           enum tofu_policy policy = get_policy (dbs, fingerprint, email, NULL);
2148           estream_t fp;
2149           char *msg;
2150
2151           write_stats_status (NULL, messages,
2152                               policy,
2153                               first_seen, most_recent_seen);
2154
2155           fp = es_fopenmem (0, "rw,samethread");
2156           if (! fp)
2157             log_fatal ("error creating memory stream: %s\n",
2158                        gpg_strerror (gpg_error_from_syserror()));
2159
2160           if (messages == 0)
2161             {
2162               es_fprintf (fp, _("Verified %ld messages signed by \"%s\"."),
2163                           0L, user_id);
2164               es_fputc ('\n', fp);
2165             }
2166           else
2167             {
2168               char *first_seen_ago_str = time_ago_str (now - first_seen);
2169
2170               /* TRANSLATORS: The final %s is replaced by a string like
2171                  "7 months, 1 day, 5 minutes, 0 seconds". */
2172               es_fprintf (fp,
2173                           ngettext("Verified %ld message signed by \"%s\"\n"
2174                                    "in the past %s.",
2175                                    "Verified %ld messages signed by \"%s\"\n"
2176                                    "in the past %s.",
2177                                    messages),
2178                           messages, user_id, first_seen_ago_str);
2179
2180               if (messages > 1)
2181                 {
2182                   char *tmpstr = time_ago_str (now - most_recent_seen);
2183                   es_fputs ("  ", fp);
2184                   es_fprintf (fp, _("The most recent message was"
2185                                     " verified %s ago."), tmpstr);
2186                   xfree (tmpstr);
2187                 }
2188               xfree (first_seen_ago_str);
2189
2190               if (opt.verbose)
2191                 {
2192                   es_fputs ("  ", fp);
2193                   es_fputc ('(', fp);
2194                   es_fprintf (fp, _("policy: %s"), tofu_policy_str (policy));
2195                   es_fputs (")\n", fp);
2196                 }
2197               else
2198                 es_fputs ("\n", fp);
2199             }
2200
2201           {
2202             char *tmpmsg, *p;
2203             es_fputc (0, fp);
2204             if (es_fclose_snatch (fp, (void **) &tmpmsg, NULL))
2205               log_fatal ("error snatching memory stream\n");
2206             msg = format_text (tmpmsg, 0, 72, 80);
2207             es_free (tmpmsg);
2208
2209             /* Print a status line but suppress the trailing LF.
2210              * Spaces are not percent escaped. */
2211             if (*msg)
2212               write_status_buffer (STATUS_TOFU_STATS_LONG,
2213                                    msg, strlen (msg)-1, -1);
2214
2215             /* Remove the non-breaking space markers.  */
2216             for (p=msg; *p; p++)
2217               if (*p == '~')
2218                 *p = ' ';
2219
2220           }
2221
2222           log_string (GPGRT_LOG_INFO, msg);
2223           xfree (msg);
2224
2225           if (policy == TOFU_POLICY_AUTO && messages < BASIC_TRUST_THRESHOLD)
2226             {
2227               char *set_policy_command;
2228               char *text;
2229               char *tmpmsg;
2230
2231               if (messages == 0)
2232                 log_info (_("Warning: we've have yet to see"
2233                             " a message signed by this key!\n"));
2234               else if (messages == 1)
2235                 log_info (_("Warning: we've only seen a"
2236                             " single message signed by this key!\n"));
2237
2238               set_policy_command =
2239                 xasprintf ("gpg --tofu-policy bad %s", fingerprint);
2240
2241               tmpmsg = xasprintf
2242                 (ngettext
2243                  ("Warning: if you think you've seen more than %ld message "
2244                   "signed by this key, then this key might be a forgery!  "
2245                   "Carefully examine the email address for small "
2246                   "variations.  If the key is suspect, then use\n"
2247                   "  %s\n"
2248                   "to mark it as being bad.\n",
2249                   "Warning: if you think you've seen more than %ld messages "
2250                   "signed by this key, then this key might be a forgery!  "
2251                       "Carefully examine the email address for small "
2252                   "variations.  If the key is suspect, then use\n"
2253                   "  %s\n"
2254                   "to mark it as being bad.\n",
2255                   messages),
2256                   messages, set_policy_command);
2257               text = format_text (tmpmsg, 0, 72, 80);
2258               xfree (tmpmsg);
2259               log_string (GPGRT_LOG_INFO, text);
2260               xfree (text);
2261
2262               es_free (set_policy_command);
2263             }
2264         }
2265     }
2266
2267  out:
2268   free_strlist (strlist);
2269   xfree (fingerprint_pp);
2270
2271   return;
2272 }
2273
2274 /* Extract the email address from a user id and normalize it.  If the
2275    user id doesn't contain an email address, then we use the whole
2276    user_id and normalize that.  The returned string must be freed.  */
2277 static char *
2278 email_from_user_id (const char *user_id)
2279 {
2280   char *email = mailbox_from_userid (user_id);
2281   if (! email)
2282     {
2283       /* Hmm, no email address was provided or we are out of core.  Just
2284          take the lower-case version of the whole user id.  It could be
2285          a hostname, for instance.  */
2286       email = ascii_strlwr (xstrdup (user_id));
2287     }
2288
2289   return email;
2290 }
2291
2292 /* Register the signature with the bindings <fingerprint, USER_ID>,
2293    for each USER_ID in USER_ID_LIST.  The fingerprint is taken from
2294    the primary key packet PK.
2295
2296    SIG_DIGEST_BIN is the binary representation of the message's
2297    digest.  SIG_DIGEST_BIN_LEN is its length.
2298
2299    SIG_TIME is the time that the signature was generated.
2300
2301    ORIGIN is a free-formed string describing the origin of the
2302    signature.  If this was from an email and the Claws MUA was used,
2303    then this should be something like: "email:claws".  If this is
2304    NULL, the default is simply "unknown".
2305
2306    If MAY_ASK is 1, then this function may interact with the user.
2307    This is necessary if there is a conflict or the binding's policy is
2308    TOFU_POLICY_ASK.
2309
2310    This function returns 0 on success and an error code if an error
2311    occured.  */
2312 gpg_error_t
2313 tofu_register (ctrl_t ctrl, PKT_public_key *pk, strlist_t user_id_list,
2314                const byte *sig_digest_bin, int sig_digest_bin_len,
2315                time_t sig_time, const char *origin)
2316 {
2317   gpg_error_t rc;
2318   tofu_dbs_t dbs;
2319   char *fingerprint = NULL;
2320   strlist_t user_id;
2321   char *email = NULL;
2322   char *err = NULL;
2323   char *sig_digest;
2324   unsigned long c;
2325
2326   dbs = opendbs (ctrl);
2327   if (! dbs)
2328     {
2329       rc = gpg_error (GPG_ERR_GENERAL);
2330       log_error (_("error opening TOFU database: %s\n"),
2331                  gpg_strerror (rc));
2332       return rc;
2333     }
2334
2335   /* We do a query and then an insert.  Make sure they are atomic
2336      by wrapping them in a transaction.  */
2337   rc = begin_transaction (ctrl);
2338   if (rc)
2339     return rc;
2340
2341   sig_digest = make_radix64_string (sig_digest_bin, sig_digest_bin_len);
2342   fingerprint = hexfingerprint (pk, NULL, 0);
2343
2344   if (! origin)
2345     /* The default origin is simply "unknown".  */
2346     origin = "unknown";
2347
2348   for (user_id = user_id_list; user_id; user_id = user_id->next)
2349     {
2350       email = email_from_user_id (user_id->d);
2351
2352       if (DBG_TRUST)
2353         log_debug ("TOFU: Registering signature %s with binding"
2354                    " <key: %s, user id: %s>\n",
2355                    sig_digest, fingerprint, email);
2356
2357       /* Make sure the binding exists and record any TOFU
2358          conflicts.  */
2359       if (get_trust (dbs, pk, fingerprint, email, user_id->d, 0)
2360           == _tofu_GET_TRUST_ERROR)
2361         {
2362           rc = gpg_error (GPG_ERR_GENERAL);
2363           xfree (email);
2364           break;
2365         }
2366
2367       /* If we've already seen this signature before, then don't add
2368          it again.  */
2369       rc = gpgsql_stepx
2370         (dbs->db, &dbs->s.register_already_seen,
2371          get_single_unsigned_long_cb2, &c, &err,
2372          "select count (*)\n"
2373          " from signatures left join bindings\n"
2374          "  on signatures.binding = bindings.oid\n"
2375          " where fingerprint = ? and email = ? and sig_time = ?\n"
2376          "  and sig_digest = ?",
2377          GPGSQL_ARG_STRING, fingerprint, GPGSQL_ARG_STRING, email,
2378          GPGSQL_ARG_LONG_LONG, (long long) sig_time,
2379          GPGSQL_ARG_STRING, sig_digest,
2380          GPGSQL_ARG_END);
2381       if (rc)
2382         {
2383           log_error (_("error reading TOFU database: %s\n"), err);
2384           print_further_info ("checking existence");
2385           sqlite3_free (err);
2386         }
2387       else if (c > 1)
2388         /* Duplicates!  This should not happen.  In particular,
2389            because <fingerprint, email, sig_time, sig_digest> is the
2390            primary key!  */
2391         log_debug ("SIGNATURES DB contains duplicate records"
2392                    " <key: %s, fingerprint: %s, time: 0x%lx, sig: %s,"
2393                    " origin: %s>."
2394                    "  Please report.\n",
2395                    fingerprint, email, (unsigned long) sig_time,
2396                    sig_digest, origin);
2397       else if (c == 1)
2398         {
2399           if (DBG_TRUST)
2400             log_debug ("Already observed the signature and binding"
2401                        " <key: %s, user id: %s, time: 0x%lx, sig: %s,"
2402                        " origin: %s>\n",
2403                        fingerprint, email, (unsigned long) sig_time,
2404                        sig_digest, origin);
2405         }
2406       else if (opt.dry_run)
2407         {
2408           log_info ("TOFU database update skipped due to --dry-run\n");
2409         }
2410       else
2411         /* This is the first time that we've seen this signature and
2412            binding.  Record it.  */
2413         {
2414           if (DBG_TRUST)
2415             log_debug ("TOFU: Saving signature"
2416                        " <key: %s, user id: %s, sig: %s>\n",
2417                        fingerprint, email, sig_digest);
2418
2419           log_assert (c == 0);
2420
2421           rc = gpgsql_stepx
2422             (dbs->db, &dbs->s.register_insert, NULL, NULL, &err,
2423              "insert into signatures\n"
2424              " (binding, sig_digest, origin, sig_time, time)\n"
2425              " values\n"
2426              " ((select oid from bindings\n"
2427              "    where fingerprint = ? and email = ?),\n"
2428              "  ?, ?, ?, strftime('%s', 'now'));",
2429              GPGSQL_ARG_STRING, fingerprint, GPGSQL_ARG_STRING, email,
2430              GPGSQL_ARG_STRING, sig_digest, GPGSQL_ARG_STRING, origin,
2431              GPGSQL_ARG_LONG_LONG, (long long) sig_time,
2432              GPGSQL_ARG_END);
2433           if (rc)
2434             {
2435               log_error (_("error updating TOFU database: %s\n"), err);
2436               print_further_info ("insert signatures");
2437               sqlite3_free (err);
2438             }
2439         }
2440
2441       xfree (email);
2442
2443       if (rc)
2444         break;
2445     }
2446
2447   if (rc)
2448     rollback_transaction (ctrl);
2449   else
2450     rc = end_transaction (ctrl, 0);
2451
2452   xfree (fingerprint);
2453   xfree (sig_digest);
2454
2455   return rc;
2456 }
2457
2458 /* Combine a trust level returned from the TOFU trust model with a
2459    trust level returned by the PGP trust model.  This is primarily of
2460    interest when the trust model is tofu+pgp (TM_TOFU_PGP).
2461
2462    This function ors together the upper bits (the values not covered
2463    by TRUST_MASK, i.e., TRUST_FLAG_REVOKED, etc.).  */
2464 int
2465 tofu_wot_trust_combine (int tofu_base, int wot_base)
2466 {
2467   int tofu = tofu_base & TRUST_MASK;
2468   int wot = wot_base & TRUST_MASK;
2469   int upper = (tofu_base & ~TRUST_MASK) | (wot_base & ~TRUST_MASK);
2470
2471   log_assert (tofu == TRUST_UNKNOWN
2472               || tofu == TRUST_EXPIRED
2473               || tofu == TRUST_UNDEFINED
2474               || tofu == TRUST_NEVER
2475               || tofu == TRUST_MARGINAL
2476               || tofu == TRUST_FULLY
2477               || tofu == TRUST_ULTIMATE);
2478   log_assert (wot == TRUST_UNKNOWN
2479               || wot == TRUST_EXPIRED
2480               || wot == TRUST_UNDEFINED
2481               || wot == TRUST_NEVER
2482               || wot == TRUST_MARGINAL
2483               || wot == TRUST_FULLY
2484               || wot == TRUST_ULTIMATE);
2485
2486   /* We first consider negative trust policys.  These trump positive
2487      trust policies.  */
2488   if (tofu == TRUST_NEVER || wot == TRUST_NEVER)
2489     /* TRUST_NEVER trumps everything else.  */
2490     return upper | TRUST_NEVER;
2491   if (tofu == TRUST_EXPIRED || wot == TRUST_EXPIRED)
2492     /* TRUST_EXPIRED trumps everything but TRUST_NEVER.  */
2493     return upper | TRUST_EXPIRED;
2494
2495   /* Now we only have positive or neutral trust policies.  We take
2496      the max.  */
2497   if (tofu == TRUST_ULTIMATE)
2498     return upper | TRUST_ULTIMATE | TRUST_FLAG_TOFU_BASED;
2499   if (wot == TRUST_ULTIMATE)
2500     return upper | TRUST_ULTIMATE;
2501
2502   if (tofu == TRUST_FULLY)
2503     return upper | TRUST_FULLY | TRUST_FLAG_TOFU_BASED;
2504   if (wot == TRUST_FULLY)
2505     return upper | TRUST_FULLY;
2506
2507   if (tofu == TRUST_MARGINAL)
2508     return upper | TRUST_MARGINAL | TRUST_FLAG_TOFU_BASED;
2509   if (wot == TRUST_MARGINAL)
2510     return upper | TRUST_MARGINAL;
2511
2512   if (tofu == TRUST_UNDEFINED)
2513     return upper | TRUST_UNDEFINED | TRUST_FLAG_TOFU_BASED;
2514   if (wot == TRUST_UNDEFINED)
2515     return upper | TRUST_UNDEFINED;
2516
2517   return upper | TRUST_UNKNOWN;
2518 }
2519
2520
2521 /* Write a "tfs" record for a --with-colons listing.  */
2522 gpg_error_t
2523 tofu_write_tfs_record (ctrl_t ctrl, estream_t fp,
2524                        PKT_public_key *pk, const char *user_id)
2525 {
2526   gpg_error_t err;
2527   tofu_dbs_t dbs;
2528   char *fingerprint;
2529   char *email;
2530
2531   if (!*user_id)
2532     return 0;  /* No TOFU stats possible for an empty ID.  */
2533
2534   dbs = opendbs (ctrl);
2535   if (!dbs)
2536     {
2537       err = gpg_error (GPG_ERR_GENERAL);
2538       log_error (_("error opening TOFU database: %s\n"), gpg_strerror (err));
2539       return err;
2540     }
2541
2542   fingerprint = hexfingerprint (pk, NULL, 0);
2543   email = email_from_user_id (user_id);
2544
2545   show_statistics (dbs, fingerprint, email, user_id, NULL, fp);
2546
2547   xfree (email);
2548   xfree (fingerprint);
2549   return 0;
2550 }
2551
2552
2553 /* Return the validity (TRUST_NEVER, etc.) of the bindings
2554    <FINGERPRINT, USER_ID>, for each USER_ID in USER_ID_LIST.  If
2555    USER_ID_LIST->FLAG is set, then the id is considered to be expired.
2556
2557    PK is the primary key packet.
2558
2559    If MAY_ASK is 1 and the policy is TOFU_POLICY_ASK, then the user
2560    will be prompted to choose a different policy.  If MAY_ASK is 0 and
2561    the policy is TOFU_POLICY_ASK, then TRUST_UNKNOWN is returned.
2562
2563    Returns TRUST_UNDEFINED if an error occurs.  */
2564 int
2565 tofu_get_validity (ctrl_t ctrl, PKT_public_key *pk, strlist_t user_id_list,
2566                    int may_ask)
2567 {
2568   tofu_dbs_t dbs;
2569   char *fingerprint = NULL;
2570   strlist_t user_id;
2571   int trust_level = TRUST_UNKNOWN;
2572   int bindings = 0;
2573   int bindings_valid = 0;
2574
2575   dbs = opendbs (ctrl);
2576   if (! dbs)
2577     {
2578       log_error (_("error opening TOFU database: %s\n"),
2579                  gpg_strerror (GPG_ERR_GENERAL));
2580       return TRUST_UNDEFINED;
2581     }
2582
2583   fingerprint = hexfingerprint (pk, NULL, 0);
2584
2585   begin_transaction (ctrl);
2586
2587   for (user_id = user_id_list; user_id; user_id = user_id->next, bindings ++)
2588     {
2589       char *email = email_from_user_id (user_id->d);
2590
2591       /* Always call get_trust to make sure the binding is
2592          registered.  */
2593       int tl = get_trust (dbs, pk, fingerprint, email, user_id->d, may_ask);
2594       if (tl == _tofu_GET_TRUST_ERROR)
2595         {
2596           /* An error.  */
2597           trust_level = TRUST_UNDEFINED;
2598           xfree (email);
2599           goto die;
2600         }
2601
2602       if (DBG_TRUST)
2603         log_debug ("TOFU: validity for <key: %s, user id: %s>: %s%s.\n",
2604                    fingerprint, email,
2605                    trust_value_to_string (tl),
2606                    user_id->flags ? " (but expired)" : "");
2607
2608       if (user_id->flags)
2609         tl = TRUST_EXPIRED;
2610
2611       if (tl != TRUST_EXPIRED)
2612         bindings_valid ++;
2613
2614       if (may_ask && tl != TRUST_ULTIMATE && tl != TRUST_EXPIRED)
2615         show_statistics (dbs, fingerprint, email, user_id->d, NULL, NULL);
2616
2617       if (tl == TRUST_NEVER)
2618         trust_level = TRUST_NEVER;
2619       else if (tl == TRUST_EXPIRED)
2620         /* Ignore expired bindings in the trust calculation.  */
2621         ;
2622       else if (tl > trust_level)
2623         {
2624           /* The expected values: */
2625           log_assert (tl == TRUST_UNKNOWN || tl == TRUST_UNDEFINED
2626                       || tl == TRUST_MARGINAL || tl == TRUST_FULLY
2627                       || tl == TRUST_ULTIMATE);
2628
2629           /* We assume the following ordering:  */
2630           log_assert (TRUST_UNKNOWN < TRUST_UNDEFINED);
2631           log_assert (TRUST_UNDEFINED < TRUST_MARGINAL);
2632           log_assert (TRUST_MARGINAL < TRUST_FULLY);
2633           log_assert (TRUST_FULLY < TRUST_ULTIMATE);
2634
2635           trust_level = tl;
2636         }
2637
2638       xfree (email);
2639     }
2640
2641  die:
2642   end_transaction (ctrl, 0);
2643
2644   xfree (fingerprint);
2645
2646   if (bindings_valid == 0)
2647     {
2648       if (DBG_TRUST)
2649         log_debug ("no (of %d) valid bindings."
2650                    "  Can't get TOFU validity for this set of user ids.\n",
2651                    bindings);
2652       return TRUST_NEVER;
2653     }
2654
2655   return trust_level;
2656 }
2657
2658 /* Set the policy for all non-revoked user ids in the keyblock KB to
2659    POLICY.
2660
2661    If no key is available with the specified key id, then this
2662    function returns GPG_ERR_NO_PUBKEY.
2663
2664    Returns 0 on success and an error code otherwise.  */
2665 gpg_error_t
2666 tofu_set_policy (ctrl_t ctrl, kbnode_t kb, enum tofu_policy policy)
2667 {
2668   tofu_dbs_t dbs;
2669   PKT_public_key *pk;
2670   char *fingerprint = NULL;
2671
2672   log_assert (kb->pkt->pkttype == PKT_PUBLIC_KEY);
2673   pk = kb->pkt->pkt.public_key;
2674
2675   dbs = opendbs (ctrl);
2676   if (! dbs)
2677     {
2678       log_error (_("error opening TOFU database: %s\n"),
2679                  gpg_strerror (GPG_ERR_GENERAL));
2680       return gpg_error (GPG_ERR_GENERAL);
2681     }
2682
2683   if (DBG_TRUST)
2684     log_debug ("Setting TOFU policy for %s to %s\n",
2685                keystr (pk->keyid), tofu_policy_str (policy));
2686   if (! (pk->main_keyid[0] == pk->keyid[0]
2687          && pk->main_keyid[1] == pk->keyid[1]))
2688     log_bug ("%s: Passed a subkey, but expecting a primary key.\n", __func__);
2689
2690   fingerprint = hexfingerprint (pk, NULL, 0);
2691
2692   begin_transaction (ctrl);
2693
2694   for (; kb; kb = kb->next)
2695     {
2696       PKT_user_id *user_id;
2697       char *email;
2698
2699       if (kb->pkt->pkttype != PKT_USER_ID)
2700         continue;
2701
2702       user_id = kb->pkt->pkt.user_id;
2703       if (user_id->is_revoked)
2704         /* Skip revoked user ids.  (Don't skip expired user ids, the
2705            expiry can be changed.)  */
2706         continue;
2707
2708       email = email_from_user_id (user_id->name);
2709
2710       record_binding (dbs, fingerprint, email, user_id->name, policy, 1);
2711
2712       xfree (email);
2713     }
2714
2715   end_transaction (ctrl, 0);
2716
2717   xfree (fingerprint);
2718   return 0;
2719 }
2720
2721 /* Set the TOFU policy for all non-revoked user ids in the KEY with
2722    the key id KEYID to POLICY.
2723
2724    If no key is available with the specified key id, then this
2725    function returns GPG_ERR_NO_PUBKEY.
2726
2727    Returns 0 on success and an error code otherwise.  */
2728 gpg_error_t
2729 tofu_set_policy_by_keyid (ctrl_t ctrl, u32 *keyid, enum tofu_policy policy)
2730 {
2731   kbnode_t keyblock = get_pubkeyblock (keyid);
2732   if (! keyblock)
2733     return gpg_error (GPG_ERR_NO_PUBKEY);
2734
2735   return tofu_set_policy (ctrl, keyblock, policy);
2736 }
2737
2738 /* Return the TOFU policy for the specified binding in *POLICY.  If no
2739    policy has been set for the binding, sets *POLICY to
2740    TOFU_POLICY_NONE.
2741
2742    PK is a primary public key and USER_ID is a user id.
2743
2744    Returns 0 on success and an error code otherwise.  */
2745 gpg_error_t
2746 tofu_get_policy (ctrl_t ctrl, PKT_public_key *pk, PKT_user_id *user_id,
2747                  enum tofu_policy *policy)
2748 {
2749   tofu_dbs_t dbs;
2750   char *fingerprint;
2751   char *email;
2752
2753   /* Make sure PK is a primary key.  */
2754   log_assert (pk->main_keyid[0] == pk->keyid[0]
2755               && pk->main_keyid[1] == pk->keyid[1]);
2756
2757   dbs = opendbs (ctrl);
2758   if (! dbs)
2759     {
2760       log_error (_("error opening TOFU database: %s\n"),
2761                  gpg_strerror (GPG_ERR_GENERAL));
2762       return gpg_error (GPG_ERR_GENERAL);
2763     }
2764
2765   fingerprint = hexfingerprint (pk, NULL, 0);
2766
2767   email = email_from_user_id (user_id->name);
2768
2769   *policy = get_policy (dbs, fingerprint, email, NULL);
2770
2771   xfree (email);
2772   xfree (fingerprint);
2773   if (*policy == _tofu_GET_POLICY_ERROR)
2774     return gpg_error (GPG_ERR_GENERAL);
2775   return 0;
2776 }